Biorąc pod uwagę dwie liczby całkowite większe niż jeden, A i B, wypisz cztery wyrażenia matematyczne w następującej kolejności:

1. Proste wyrażenie A ^ B (A do potęgi B). np. jeśli A = 2 i B = 3 2^3,.

2. Ekspansja A ^ B pod względem powtarzających się wielokrotności A. np 2*2*2.

3. Ekspansja A ^ B pod względem powtarzających się dodatków A. np 2+2+2+2.

4. Rozszerzenie A ^ B pod względem powtarzających się dodatków 1. np 1+1+1+1+1+1+1+1.

Cztery wyrażenia mogą być generowane w dowolny rozsądny sposób, o ile są one uporządkowane i wyraźnie odrębne. Na przykład możesz umieścić je na liście lub wydrukować w osobnych wierszach

2^3
2*2*2
2+2+2+2
1+1+1+1+1+1+1+1

a może na jednej linii oddzielonej znakami równości:

2^3=2*2*2=2+2+2+2=1+1+1+1+1+1+1+1

Spacje mogą być wstawiane obok operatorów matematycznych tzw

2^3 = 2 * 2 * 2 = 2 + 2 + 2 + 2 = 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1

byłby równie prawidłowy, gdy A = 2 i B = 3.

Możesz używać symboli alternatywnych do ^, *i +, ale tylko wtedy, gdy nowe symbole są bardziej idiomatyczne dla twojego języka (np. **Zamiast ^w Pythonie).

Możesz założyć, że A i B są wystarczająco małe, aby A ^ B nie przepełnia domyślnego typu liczb całkowitych twojego języka (biorąc pod uwagę, że ten typ ma rozsądne maksimum, co najmniej 255).

Najkrótszy kod w bajtach wygrywa.

Przypadki testowe

Jedno wyjście na linię. Dane wejściowe można wywnioskować, ponieważ pierwszym wyrażeniem jest zawsze A ^ B.

2^2 = 2*2 = 2+2 = 1+1+1+1
2^3 = 2*2*2 = 2+2+2+2 = 1+1+1+1+1+1+1+1
2^4 = 2*2*2*2 = 2+2+2+2+2+2+2+2 = 1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1
2^5 = 2*2*2*2*2 = 2+2+2+2+2+2+2+2+2+2+2+2+2+2+2+2 = 1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1
3^2 = 3*3 = 3+3+3 = 1+1+1+1+1+1+1+1+1
3^3 = 3*3*3 = 3+3+3+3+3+3+3+3+3 = 1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1
3^4 = 3*3*3*3 = 3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3 = 1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1
3^5 = 3*3*3*3*3 = 3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3 = 1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1
4^2 = 4*4 = 4+4+4+4 = 1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1
4^3 = 4*4*4 = 4+4+4+4+4+4+4+4+4+4+4+4+4+4+4+4 = 1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1
10^2 = 10*10 = 10+10+10+10+10+10+10+10+10+10 = 1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1
13^2 = 13*13 = 13+13+13+13+13+13+13+13+13+13+13+13+13 = 1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1

Python 3.6 , 88 74 bajtów

-2 bajty dzięki Dadzie (użycie ~)
-5 bajtów dzięki Erwanowi (użyj f-stringów z Python 3.6)

lambda a,b:f"{a}^{b}={a}{f'*{a}'*~-b}={a}{f'+{a}'*~-a**~-b}=1"+"+1"*~-a**b

ktoś online?

W jaki sposób?

Jest to nienazwana funkcja przyjmująca dwa wejścia całkowite ai bkażde większe niż 0(nawet jeśli specyfikacja dotyczy tylko tych większych niż 1).

W Pythonie 3.6 dostępna jest nowa funkcja, mianowicie sformatowane literały łańcuchowe lub „f-string”. Umożliwiają one budowę ciągów ocenianych w czasie wykonywania. Prowadzący f(lub F) tworzy taki konstrukt, np . f"blah"Lub f'blah'. Wewnątrz ciągu f cokolwiek między parą nawiasów klamrowych {...}, jest wyrażeniem do oceny.

Jako takie f"{a}^{b}={a}{f'*{a}'*~-b}={a}{f'+{a}'*~-a**~-b}=1"ocenia każdą z a, b, a, f'*{a}'*~-b, a, i f'+{a}'*~-a**~-b}jako wyrażenia, utrzymując ^, =, =, i =1jako ciągi znaków, z których każdy dostaje sklejone.

aI bwyrażenia ocenić przedstawicielstw ai bodpowiednio.

f'*{a}'A f'+{a}'także z kolei f-strings wewnątrz tych wyrażeń, które oceniają się az czołowym '*'i czołowym '+'odpowiednio

Aby utworzyć wymaganą liczbę aoperacji i operacji dla części *i, +zwróć uwagę, że zostaną b apomnożone razem i a**(b-1) adodane. Każdy przypadek wymaga wtedy o jeden znak operatora mniej niż liczba as. Możemy więc powtarzać ciągi f f'*{a}i f'+{a}'(używając *) tyle razy, ile jest operatorów, i dodawać je po jednym a. (b-1)jest ~-bi (a**(b-1))-1jest ~-a**~-b.

To samo dzieje się w przypadku 1używania (a**b)-1bytu ~-**b, ale nie potrzebujemy narzutu strun f, ponieważ 1jest stały, więc powtarzany standardowy ciąg jest łączony +.

Poprzednie wersje Pythona, 81:

lambda a,b:'%s^%s=%s=%s=1'%(a,b,('*%s'%a*b)[1:],('+%s'%a*a**~-b)[1:])+'+1'*~-a**b

Wypróbuj online!

Cubix, 238 234 217 151 110 100 bajtów

Zaoszczędzono 14 bajtów dzięki ETHProductions

u'^.:s+.;;;\-?W?rsos\(rrOIO:ur>'=o;^u.;;.>$.vUo^'rsu1;;@!\q?s*su;;IOu*+qU../;(*\(s.;<..r:''uq....qu\

Rozszerzony:

          u ' ^ . :
          s + . ; ;
          ; \ - ? W
          ? r s o s
          \ ( r r O
I O : u r > ' = o ; ^ u . ; ; . > $ . v
U o ^ ' r s u 1 ; ; @ ! \ q ? s * s u ;
; I O u * + q U . . / ; ( * \ ( s . ; <
. . r : ' ' u q . . . . q u \ . . . . .
. . . . . . . . . . . . . . . . . . . .
          . . . . .
          . . . . .
          . . . . .
          . . . . .
          . . . . .

Wypróbuj online!

Wypróbuj tutaj

Wyjaśnienie

Kod składa się z 8 kroków z dwiema pętlami. Przejrzę kod po części.

Krok 1 (A ^ B)

          . . . . .
          . . . . .
          . . . . .
          . . . . .
          . . . . .
I O : u . . . . . . . . . . . . . . . .
U o ^ ' . . . . . . . . . . . . . . . .
; I O u . . . . . . / ; ( * \ . . . . .
? ? r : . . . . . . ? . . . \ ? ? ? ? ?
. . . . ? . . . . . ? . . . . . . . . .
          ? ? ? ? ?
          . . . . .
          . . . . .
          . . . . .
          . . . . .

To jest sześcian z usuniętymi częściami, które nie mają znaczenia dla pierwszego kroku. Znak zapytania pokazuje brak operacji, które odwiedzi adres IP, aby jego ścieżka była bardziej przejrzysta.

IO:'^o;IO:r*(; # Explanation
I              # Push the first input (A)
 O             #   output that
  :            #   duplicate it
   '^          # Push the character "^"
     o         #   output that
      ;        #   pop it from the stack
       I       # Push the second input (B)
        O      #   output that 
         :     #   duplicate
          r    #   rotate top 3 elements
           *   # Push the product of the top two elements
            (  #   decrease it by one
             ; #   pop it from the stack (making the last
               #   two operations useless, but doing it
               #   this way saves 10B)

Teraz stos wygląda następująco: A, B, A, B

Krok 2 (przygotuj się do wydruku w pętli)

Pętla drukowania trwa 3 argumenty (3 najlepsze elementy na stosie): P, Qi R. Poznacza liczbę powtórzeń, Qjest separatorem (kodem znaków) i Rjest liczbą do powtórzenia. Na szczęście, pętla dba również wymogu, że otrzymany ciąg powinien zakończyć się w Rnie Q.

Chcemy powtarzać A*dokładnie Btyle razy, więc separatorem jest *. Zauważ, że stos zaczyna się jako A, B, A, B. Po raz kolejny usunąłem wszystkie nieistotne instrukcje. Adres IP zaczyna się od Swskazującej północy.

          . . . . .
          . . . . .
          . . . . .
          . . . . .
          . . . . .
. . . . r . . . . . . . . . . . . . . .
. . . . r . . . . . . . . . . . . . . .
. . . . * . . . . . . . . . . . . . . .
. . . . ' . . . . . . . . . . . . . . .
. . . . S . . . . . . . . . . . . . . .
          . . . . .
          . . . . .
          . . . . .
          . . . . .
          . . . . .

'*rr # Explanation
'*   # Push * (Stack: A, B, A, B, *)
  rr # Rotate top three elements twice

Stos jest teraz A, B, B, *, A.

Krok 3/6/8 (pętla drukująca)

Pojęcie

E . . . . .
? r s o s u 
\ ( r r O <
. . . . . S

IP wchodzi do pętli przez S, wskazując na północ i wychodzi z pętli w E, ponownie wskazując na północ. Dla tego wyjaśnienia stos jest ustawiony na [..., A, B, C]. Wykonane są następujące instrukcje. Zauważ, że adres IP nie może opuścić pętli przed znakiem zapytania, więc pierwsze cztery instrukcje będą zawsze wykonywane.

Orr(?rsos # Explanation
O         # Output `C`
 rr       # Rotate top three elements twice (Stack: [..., B, C, A])
   (      # Decrease A by one (Stack: [..., B, C, A-1])
    ?     # If top of stack (A) > 0:
     r    #    Rotate top of stack (Stack: [..., A-1, B, C])
      s   #    Swap top elements (Stack: [..., A-1, C, B])
       o  #    Output top of stack (B) as character code
        s #    Swap top elements (Stack: [..., A-1, B, C]
          #
          # ... and repeat ...

Realizacja

Oto znowu sześcian, z usuniętymi nieistotnymi częściami. Adres IP zaczyna się od S, wskazując na wschód.

          . . . . .
          . . . . .
          . . . . .
          ? r s o s
          \ ( r r O
. . . . . S ' = o ; ^ u . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
          . . . . .
          . . . . .
          . . . . .
          . . . . .
          . . . . .

Jak widać, IP napotyka cztery instrukcje, zanim trafi do pętli. Ponieważ kod znakowy jest ponownie usuwany, dochodzimy do pętli z dokładnie takim samym stosem, jak weszliśmy do tej części.

'=o; # Explanation
'=   # Push =
  o  #     Output
   ; #     Pop from stack

Wewnątrz pętli obowiązuje powyższe wyjaśnienie.

Krok 4 (różnicowanie adresów IP)

Ponieważ używamy powyższej pętli wiele razy, a wszystkie powodują, że adres IP kończy się w tym samym miejscu, musimy rozróżnić wiele przebiegów. Po pierwsze możemy rozróżnić separator (pierwszy przebieg ma a *, podczas gdy drugi i trzeci mają +separator jako). Możemy rozróżnić przebiegi 2 i 3, sprawdzając wartość liczby, która się powtarza. Jeśli tak jest, program powinien zakończyć się.

Pierwsze porównanie

Oto jak to wygląda na kostce. Adres IP zaczyna się w punkcie S i wskazuje na północ. Stos zawiera [..., * or +, A or 1, 0]. Liczba 1 pokazuje, gdzie kończy się IP, jeśli jest to pierwsza pętla (skierowana na północ), a liczba 2 pokazuje, gdzie kończy się IP, jeśli jest to druga (lub trzecia) pętla (skierowana na wschód).

          u ' . . .
          s + . 1 .
          ; \ - ? 2
          S . . . .
          . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
          . . . . .
          . . . . .
          . . . . .
          . . . . .
          . . . . .

;s'+-? # Explanation
;      # Delete top element (0)
 s     # Swap the top two elements (Stack: 1/A, */+)
  '+   # Push the character code of + 
    -  # Subtract the top two elements and push
       #  that to the stack (Stack: 1/A, */+, +, (*/+)-+)
     ? # Changes the direction based on the top
       # item on the stack. If it's 0 (if (*/+) == +)
       # the IP continues going right, otherwise, it
       # turns and continues going north.

Jeśli adres IP jest teraz 1ustawiony, stos jest [A, *, +, -1]. W przeciwnym razie stos jest [A or 1, +, +, 0]. Jak widać, na stosie drugiego przypadku wciąż jest nieznany, więc musimy zrobić kolejne porównanie.

Drugie porównanie

Ponieważ IP przeszedł kroku 5, stos wygląda jak ten: [A^(B-1) or nothing, A or 1, +, +, 0]. Jeśli pierwszym elementem jest nothing, drugim jest 1, i odwrotnie. Sześcian wygląda tak, z IP zaczynającym się na S i skierowanym na wschód. Jeśli jest to druga pętla, adres IP kończy się na E, wskazując na zachód. W przeciwnym razie program uderza @i kończy.

          . . . . .
          . . . . ;
          . . . S W
          . . . . .
          . . . . .
. . . . . . . . . . . . . ; . . . . . .
. . . . . . . . . E @ ! \ q . . . . . .
. . . . . . . . . . . . ( * . . . . . .
. . . . . . . . . . . . q u . . . . . .
. . . . . . . . . . . . . . . . . . . .
          . . . . .
          . . . . .
          . . . . .
          . . . . .
          . . . . .

Wykonane instrukcje, które nic nie wpływają na przepływ sterowania, są wymienione poniżej.

;;q*q(!@
;;       # Delete top two elements (Stack [A^(B-1)/null, A/1, +])
  q      # Send top element to the bottom (Stack [+, A^(B-1)/0, A/1])
   *     # Push product of top two elements 
         #    (Stack [+, A^(B-1)/0, A/1, A^B/0])
    q    # Send top element to the bottom 
         #    (Stack [A^B/0, +, A^(B-1)/0, A/1])
     (   # Decrease the top element by 1 
         #    (Stack [A^B/0, +, A^(B-1)/0, (A-1)/0])
      !  # If (top element == 0):
       @ #  Stop program

Stos jest teraz [A^B, +, A^(B-1), A-1], pod warunkiem, że program się nie zakończy.

Krok 5 (przygotowanie do „A +” (powtórz A ^ (B-1)))

Niestety Cubix nie ma operatora mocy, więc potrzebujemy kolejnej pętli. Jednak najpierw musimy wyczyścić stos, który teraz zawiera [B, A, *, +, -1].

Sprzątanie

Oto znowu kostka. Jak zwykle IP zaczyna się w S (wskazując na północ), a kończy w E, wskazując na zachód.

          . . . ? .
          . . . ; .
          . . . S .
          . . . . .
          . . . . .
. . . . . . . . . . . . . . . . > $ . v
. . . . . . . . . . . . . . . . . . . ;
. . . . . . . . . . . . . . . . . . E <
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
          . . . . .
          . . . . .
          . . . . .
          . . . . .
          . . . . .

;; # Explanation
;; # Remove top 2 elements (Stack: [B, A, *])

Obliczanie A ^ (B-1)

Kolejna pętla, która działa mniej więcej tak samo jak pętla drukująca, ale jest nieco bardziej kompaktowa. Adres IP zaczyna się od S, wskazując na zachód, ze stosem [B, A, *]. IP kończy się, Ewskazując na północ.

          . . . . .
          . . . . .
          . . . . .
          . . . . .
          . . . . .
. . . . . . . . . . . . . . E . . . . .
. . . . . . . . . . . . . . ? s * s u .
. . . . . . . . . . . . . . \ ( s . ; S
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
          . . . . .
          . . . . .
          . . . . .
          . . . . .
          . . . . .

Ciało pętli jest następujące.

;s(?s*s # Explanation
;       # Pop top element.
 s      # Shift top elements.
  (     # Decrease top element by one
   ?    # If not 0:
    s   #    Shift top elements again
     *  #    Multiply
      s #    Shift back
        #
        # ... and repeat ...

Wynikowy stos to [A, A^(B-1), 0].

Czyszczenie stosu (ponownie)

Teraz musimy ponownie przejść do pętli drukowania, zawierając górę stosu [..., A^(B-1), +, A]. Aby to zrobić, wykonujemy następujące czynności. Oto znowu kostka

          . . ^ ? :
          . . . . .
          . . . . .
          . . . . .
          E . . . .
. . . . . s . . . . . . . . ; . . $ . .
. . . . . + q U . . . . . . S . . s . .
. . . . . ' u q . . . . . . . . . ? . .
. . . . . . . ? . . . . . . . . . ? . .
. . . . . . . ? . . . . . . . . . ? . .
          . . ? . .
          . . ? . .
          . . ? . .
          . . ? . .
          . . ? . .

;:$sqq'+s # Explanation
;         # Delete top element (Stack: [A, A^(B-1)])
 :        # Copy top element
  $s      # No-op
    qq    # Send top two elements to the bottom
          #   (Stack: [A^(B-1), A^(B-1), A])
      '+  # Push +
          #   (Stack: [A^(B-1), A^(B-1), A, +])
        s # Swap top two elements
          #   (Stack: [A^(B-1), A^(B-1), +, A])

Krok 7 (przygotowanie do ostatniej pętli)

Stos jest teraz [A^B, +, A^(B-1), A-1], IP zaczyna się od S, idzie na zachód, a kończy o E, idzie w prawo.

          . . . . .
          . . . . .
          . . . . .
          . . . . .
          . . . . .
. . . . . E . . . . . . . . . . . . . .
. . . . . . u 1 ; ; S . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
          . . . . .
          . . . . .
          . . . . .
          . . . . .
          . . . . .

Wykonane instrukcje:

;;1 # Explanation
;;  # Delete top two elements
  1 # Push 1

Wygląda teraz stos [A^B, +, 1], a adres IP ma zamiar wejść do pętli drukowania, więc skończyliśmy.

MATL , 46 bajtów

XH'^'i'='XJ2G:"H'*']xJ&Gq^:"H'+']xJ&G^:"1'+']x

Wypróbuj online!

Rozciągając tutaj granice „rozsądnego sposobu”, ale wyrażenia są rozdzielone.

Wyjaśnienie

Pierwsze wyrażenie:

XH'^'i'='XJ

XH         % implicitly take input A, save it to clipboard H
'^'        % push literal '^'
i          % take input B
'='        % push literal '='
XJ         % copy '=' to clipboard J, we'll use this twice more so it's worth it

Drugie wyrażenie:

2G:"H'*']xJ

2G         % paste the second input (B) again
:"         % do the following B times
  H        % paste A from clipboard H
  '*'      % push literal '*'
]          % end loop
x          % delete the final element (at the moment we have a trailing *)
J          % paste '=' from clipboard J

Trzecie wyrażenie:

&Gq^:"H'+']xJ

&G         % paste all of the input, ie push A and B
q          % decrement B
^          % power, giving A^(B-1)
:"         % do the following A^(B-1) times 
  H        % paste A from clipboard H
  '+'      % push literal '+'
]          % end loop
x          % delete the final element (at the moment we have a trailing +)
J          % paste '=' from clipboard J

Czwarte wyrażenie:

&G^:"1'+']x

&G         % paste all of the input, ie push A and B
^          % power, giving A^B
:"         % do the following A^B times 
  1        % push 1
  '+'      % push '+'
]          % end loop
x          % delete the final element (at the moment we have a trailing +)
           % (implicit) convert all to string and display

JavaScript (ES7), 78 bajtów

Pobiera dane wejściowe w składni curry (a)(b). Wyprowadza ciąg.

a=>b=>a+'^'+b+(g=o=>'='+a+('+*'[+!o]+a).repeat(b-1))()+g(b=a**~-b)+g(b*=a,a=1)

Przypadki testowe

let f =

a=>b=>a+'^'+b+(g=o=>'='+a+('+*'[+!o]+a).repeat(b-1))()+g(b=a**~-b)+g(b*=a,a=1)

console.log(f(2)(2));
console.log(f(2)(3));
console.log(f(2)(4));
console.log(f(2)(5));
console.log(f(3)(2));
console.log(f(3)(3));
console.log(f(3)(4));
console.log(f(3)(5));
console.log(f(4)(2));
console.log(f(4)(3));
console.log(f(10)(2));
console.log(f(13)(2));

Ruby, 52 bajty

->a,b{[[a,b]*?^,[a]*b*?*,[a]*a**~-b*?+,[1]*a**b*?+]}

05AB1E , 30 bajtów

mUð¹'^²J'*¹«²×'+¹«X¹÷ׄ+1X×)€¦

Wyjaśnienie:

mU                               # Store a^b in variable X
  ð                              # Push a space character to the stack (will be deleted at the end, but this is needed to keep the character count low)
   ¹'^²J                         # Push the string "a^b" to the stack
        '*¹«                     # Push the string "*a" to the stack
            ²×                   # Repeat b times
              '+¹«               # Push the string "+a" to the stack
                  «X¹÷×          # Repeat a^b / a times
                       „+1       # Push the string "+1" to the stack
                          X×     # Repeat a^b times
                            )    # Wrap stack to array
                             €¦  # Remove the first character from each element in the array

Wypróbuj online!

C (gcc) , 156 149 bajtów

#define q for(x=0;x
x,y;p(a,b,c){printf("%c%d",x?b:61,c),x+=a;}e(n,i){x=1;p(0,0,n);p(0,94,i);y=!!i;q<i;y*=n)p(1,42,n);q<y;)p(n,43,n);q<y;)p(1,43,1);}

-2 bajty, jeśli możemy zignorować 0 mocy; y=!!imoże zostaćy=1

Wypróbuj online!

Java 7, 170 bajtów

String c(int a,int b){String s="=",r=a+"^"+b+s+a;double i=0,x=Math.pow(a,b);for(;++i<b;r+="*"+a);r+=s+a;for(i=0;++i<x/a;r+="+"+a);r+=s+1;for(i=0;++i<x;r+="+1");return r;}

Nie golfowany:

String c(int a, int b){
  String s = "=",
         r = a+"^"+b+s+a;
  double i = 0,
         x = Math.pow(a,b);
  for(; ++i < b; r += "*"+a);
  r += s+a;
  for(i = 0; ++i < x/a; r += "+"+a);
  r += s+1;
  for(i = 0; ++i < x; r += "+1");
  return r;
}

Kod testowy:

Wypróbuj tutaj.

class M{
  static String c(int a,int b){String s="=",r=a+"^"+b+s+a;double i=0,x=Math.pow(a,b);for(;++i<b;r+="*"+a);r+=s+a;for(i=0;++i<x/a;r+="+"+a);r+=s+1;for(i=0;++i<x;r+="+1");return r;}

  public static void main(String[] a){
    System.out.println(c(2,2));
    System.out.println(c(2,3));
    System.out.println(c(2,4));
    System.out.println(c(2,5));
    System.out.println(c(3,2));
    System.out.println(c(3,3));
    System.out.println(c(3,4));
    System.out.println(c(3,5));
    System.out.println(c(4,2));
    System.out.println(c(4,3));
    System.out.println(c(10,2));
    System.out.println(c(13,2));
  }
}

Wydajność:

2^2=2*2=2+2=1+1+1+1
2^3=2*2*2=2+2+2+2=1+1+1+1+1+1+1+1
2^4=2*2*2*2=2+2+2+2+2+2+2+2=1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1
2^5=2*2*2*2*2=2+2+2+2+2+2+2+2+2+2+2+2+2+2+2+2=1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1
3^2=3*3=3+3+3=1+1+1+1+1+1+1+1+1
3^3=3*3*3=3+3+3+3+3+3+3+3+3=1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1
3^4=3*3*3*3=3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3=1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1
3^5=3*3*3*3*3=3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3=1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1
4^2=4*4=4+4+4+4=1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1
4^3=4*4*4=4+4+4+4+4+4+4+4+4+4+4+4+4+4+4+4=1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1
10^2=10*10=10+10+10+10+10+10+10+10+10+10=1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1
13^2=13*13=13+13+13+13+13+13+13+13+13+13+13+13+13=1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1

Pip , 38 35 34 bajtów

33 bajty kodu, +1 dla -nflagi.

Ya**b[gJ'^aRLbJ'*aRLy/aJ'+1XyJ'+]

Bierze A i B jako argumenty wiersza poleceń; wypisuje jedno wyrażenie w linii. Wypróbuj online!

Wyjaśnienie

Ya**bjest kod instalacyjny: szarpnij a**bdo yzmiennej. Następnie mamy listę ( []wewnątrz) zawierającą nasze cztery wyrażenia:

• gJ'^: weź pełną glistę ar (tutaj listę zawierającą ai b) i Jwłącz ją^
• aRLbJ'*: użyj Repeat List, aby utworzyć listę z bkopiami a, a następnie Jwłącz ją*
• aRLy/aJ'+: użyj, RLaby utworzyć listę z y/a(tj. a**(b-1)) kopiami a, a następnieJ włącz ją+
• 1XyJ'+: 1, ciąg pomnożony przez y, Joined on+

Lista jest drukowana z nową linią jako separatorem dzięki -nfladze.

JavaScript 115 113 104 bajtów

Dzięki @Neil i @TukukX za grę w golfa po jednym bajcie i @ETHproductions oraz Luke za grę w golfa po 9 bajtów

a=>b=>[a+'^'+b,(a+'*').repeat(b-1)+a,(a+'+').repeat(Math.pow(a,b-1)-1)+a,1+'+1'.repeat(Math.pow(a,b)-1)]

Wypróbuj online

Galaretka , 29 bajtów

*⁹’,¤;@
,`;1ẋ"ç
,W;çj"“^*++”Y

Wypróbuj online!

W jaki sposób?

*⁹’,¤;@ - Link 1, get list lengths: a, b
    ¤   - nilad followed by link(s) as a nilad
 ⁹      - right: b
  ’     - decrement: b-1
   ,    - pair with right: [b-1, b]
*       - exponentiate: [a^(b-1), a^b]
     ;@ - concatenate with reversed arguments: [b, a^(b-1), a^b]

,`;1ẋ"ç - Link 2, create lists: a, b
 `      - monad from dyad by repeating argument
,       - pair: [a, a]
  ;1    - concatenate 1: [a, a, 1]
      ç - last link (1) as a dyad: [b, a^(b-1), a^b]
     "  - zip with the dyad...
    ẋ   -     repeat list:  [[a, a, ..., a], [a, a, ..., a], [1, 1, ..., 1]]
                                <- b ->       <- a^(b-1) ->     <- a^b ->

,W;çj"“^*++”Y - Main link: a, b
,             - pair: [a, b]
 W            - wrap: [[a, b]]
   ç          - last link (2) as a dyad: [[a, a, ..., a], [a, a, ..., a], [1, 1, ..., 1]]
  ;           - concatenate [[a, b], [a, a, ..., a], [a, a, ..., a], [1, 1, ..., 1]]
      “^*++”  - list of characters: ['^', '*', '+', '+']
     "        - zip with the dyad...
    j         -     join: ["a^b", "a*a*...*a", "a+a+...+a", "1+1+...+1"]
            Y - join with line feeds
              - implicit print

tinylisp repl, 178 186 bajtów

(load library
(d W(q((_ N S #)(i(e # 1)(c N _)(W(c S(c N _))N S(s # 1
(d ^(q((x y)(i y(*(^ x(s y 1))x)1
(d X(q((A B)(list(list A(q ^)B)(W()A(q *)B)(W()A(q +)(^ A(s B 1)))(W()1(q +)(^ A B

Użycie repl pozwala zaoszczędzić 8 bajtów w domyślnych nawiasach zamykających na końcach linii. Definiuje funkcję, Xktóra pobiera dwie liczby i zwraca listę wyrażeń. Każde wyrażenie jest w nawiasach, ze spacjami wokół operatorów (w rzeczywistości jest to lista liczb i symboli operatora):

((2 ^ 3) (2 * 2 * 2) (2 + 2 + 2 + 2) (1 + 1 + 1 + 1 + 1 + 1 + 1 + 1))

Mam nadzieję, że ten format wyjściowy jest akceptowalny. Wypróbuj online! (z kilkoma przypadkami testowymi).

Wyjaśnienie

(load library)

Potrzebujemy dwóch funkcji ze standardowej biblioteki: listi *.

(d W(q((_ N S #)(i(e # 1)(c N _)(W(c S(c N _))N S(s # 1))))))

Zdefiniuj funkcję W(skrót od „splot”), która pobiera akumulator _, liczbę N, symbol Si liczbę #. Będziemy używać tej funkcji do generowania większości naszych wyrażeń: na przykład(W () 2 (q +) 3) spowoduje (2 + 2 + 2).

Jeśli liczba wynosi 1 (e # 1), a następnie przenieś liczbę z przodu akumulatora (c N _)i zwróć ją. W przeciwnym razie powtórz:

• Nowy akumulator jest (c S(c N _)) : symbol i liczba z przodu poprzedniego akumulatora;
• N i S są takie same;
• Nowa liczba to (s # 1) : liczba - 1.

Idiom akumulatora jest potrzebny do osiągnięcia prawidłowej rekurencji ogona , zapobiegając błędowi głębokości rekurencji. (Ta zmiana odpowiada za zwiększenie liczby bajtów o +8. 13^2Sprawa nie działała w poprzedniej wersji).

(d ^(q((x y)(i y(*(^ x(s y 1))x)1))))

Niestety, biblioteka nie ma w tej chwili funkcji potęgowania, więc musimy ją zdefiniować. ^bierze xi y. Jeśli yjest to prawda (niezerowa), rekurencja następuje za pomocą y-1( (s y 1)) i mnożymy wynik przez x. W przeciwnym razie ywynosi zero i wracamy1 .

(Uwaga: ta funkcja nie wykorzystuje właściwej rekurencji ogona. Zakładam, że wykładniki będą na tyle małe, że nie będą miały znaczenia. Niektóre eksperymenty na TIO wykazały maksymalny wykładnik 325, co, moim zdaniem, powinno wystarczyć do tego pytania. Jeśli PO się nie zgadza, zmienię to.)

(d X(q((A B)(list(list A(q ^)B)(W()A(q *)B)(W()A(q +)(^ A(s B 1)))(W()1(q +)(^ A B))))))

Wreszcie, funkcja nas interesuje, Xbierze Ai Bi zwraca listę czterech elementów:

• (list A(q ^)B): lista zawierająca Aliterał ^i B;
• (W()A(q *)B): zadzwoń, Waby uzyskać listę Bkopii A, splecionych z literałem *;
• (W()A(q +)(^ A(s B 1))): zadzwoń, Waby uzyskać listę A^(B-1)kopii A, splecionych z literałem +;
• (W()1(q +)(^ A B)): zadzwoń, Waby uzyskać listę A^Bkopii 1, splecionych z literałem +.

Brainfuck , 372 bajtów

,.>++++++++[>++++++++++++>++++++++>+++++<<<-]>--.<,.>>---.>++>++++++++[<<<<------>>>>-]<<<<-[<.>>>>.>>+<<<<<-]<.>>>.<<++++++++[<------>-]<[>+>>>>+<<<<<-]>>>>>>>+<[->[-<<[->>>+>+<<<<]>>>>[-<<<<+>>>>]<<]>[-<+>]<<]>[<+>>+<-]>[<+>-]<<<<<<<<++++++++[>++++++<-]>>>>+>>-[<<<<<.>>>.>>-]<<<<<.>>.>>>>[<+>-]<<[->[->+>+<<]>>[-<<+>>]<<<]>>>++++++++[<<<++++++>>>-]<<<+>>-[<<.<.>>>-]<<.

Wypróbuj online!

Notatki

1. Dwa wejścia muszą być wybrane w taki sposób, aby A**Bnie przekraczały255 . Wynika to z faktu, że pieprzenie mózgu może przechowywać tylko wartości jednego bajtu.
2. Jeśli jedno wejście jest większe niż 9, użyj następnego znaku ASCII. 10staje się :, 11staje się ;itp. Jest tak, ponieważ Brainfuck może przyjmować dane wejściowe tylko jednego bajtu.

Wyjaśnienie

Oto mój nieco skomentowany kod. Rozwiążę to później.

,.                      print A
> +++++ +++
[
    > +++++ +++++ ++    set up 96 (for ^ sign)
    > +++++ +++         set up 64 (for = sign)
    > +++++             set up 40 (for plus and * sign)
    <<< -
]
> --.                   print ^
< ,.                    print B
>
> ---.                  print =
> ++                    prepare *

> +++++ +++             convert B from char code
[
    <<<< ----- -
    >>>> -
]

<<<< -                  print loop "A*"
[
    < .
    >>>> .
    >> +
    <<<<< -
]
< .                     print final A
>>> .                   print =


<< +++++ +++            convert A from char code
[
    < ----- -
    > -
]

<
[                       duplicate A
    > +
    >>>> +
    <<<<< -
]

>>>>>                   exponentiation (A**(B minus 1))
>>+<[->[-<<[->>>+>+<<<<]>>>>[-<<<<+>>>>]<<]>[-<+>]<<]<

>>
[                       duplicate
    < +
    >> +
    < -
]

>[<+>-]                 move

<<<<< <<< +++++ +++     convert A to char code
[
    > +++++ +
    < -
]

>>>> +                  convert * to plus sign
>> -                    print loop "A plus"
[
    <<<< < .
    >>> .
    >> -
]
<<<<< .                 print final A
>> .                    print =

>>>>                    move
[
    < +
    > -
]

                        multiply A**(B minus 1) by A
<<[->[->+>+<<]>>[-<<+>>]<<<]        

>>> +++++ +++           generate the char code for 1 (49)
[                           generate 8*6 = 48
    <<< +++++ +
    >>> -
]
<<< +                       add one

>> -                    print loop "1 plus"
[
    << .
    < .
    >>> -
]
<< .                    print final 1

Pyth, 32 31 bajtów

AQjMC,"^*++"[Q*]GH*^GtH]G*]1^GH

Przyjmuje dane wejściowe jako [2,10], dane wyjściowe jako["2^10", "2*2*2*2*2*2*2*2*2*2", "2+2+...

Wyjaśnienie:

Q = eval(input())                     #  
G, H = Q                              #  AQ
operators = "^*++"                    #        "^*++"
operands = [Q,                        #              [Q
  [G]*H,                              #                *]GH
  G**(H-1)*[G]                        #                    *^GtH]G
  [1]*G**H                            #                           *]1^GH
]                                     #
map( lambda d: join(*d),              #    jM
     zip(operators, operands)         #      C,...
)                                     #

Wypróbuj tutaj.

Perl , 81 bajtów

78 bajtów kodu + -nflaga (liczona jako 3 bajty, ponieważ kod zawiera $').

$,=$/;print s/ /^/r,map{/\D/;join$&,($`)x$'}"$`*$'","$`+".$`**~-$',"1+".$`**$'

Wypróbuj online!

R, 147 bajtów

w=switch;function(A,B)for(s in letters[1:4]){cat(rep(w(s,d=1,a=c(A,B),b=,c=A),w(s,a=1,b=B,c=A^B/A,d=A^B)),sep=w(s,a="^",b="*",d=,c="+"));cat("\n")}

Anonimowa funkcja, która generuje wymagane, dobrze, wyniki, linia po linii. To rozwiązanie w szerokim zakresie wykorzystujeswitch funkcję.

switchFunkcja przyjmuje wyrażenie (tutaj s), którego wynikiem jest liczba lub ciąg znaków (patrz ?switch), a następnie przez alernatives odpowiadających s. Jeśli brakuje alternatywy (np switch(s, a=, b= "PPCG"). Następna nieobecna alternatywa jest oceniana (w przykładzies="a" wyniki"PPCG" ).

The rep funkcje powtórzeń (powtórzeń), faktycznie pierwszy argument liczba powtórzeń wskazanych w drugim argumencie.

cat, aby zakończyć, połączyć i wydrukować obiekty za pomocą separatora, który można wybrać za pomocą sep =argumentu. Drugicat funkcja służy tutaj do łamania linii.

Nie golfowany:

f=function(A,B)
    for(s in letters[1:4]){
        cat(
            rep(switch(s, d = 1, a = c(A,B), b =, c = A),
            switch(s, a = 1, b = B, c = A^B/A, d = A^B)),
        sep=switch(s,a = "^", b = "*", d =, c = "+"))
    cat("\n")
}

CJam , 42 bajty

q_'#/)i*_'**\__:i:*_@0=i/@0=*'+*\'1*'+*]N*

Wypróbuj online!

k, 44 bajtów

{"^*++"{x/$y}'(x,y;y#x;(x*y-1)#x;(*/y#x)#1)}

Przypadki testowe.

Kardynał 202 bajtów

%:.~:#"^"."=">v
x            "~
             *.
     >~=088v "~
     v88+88< ?
     8       -
     8      x#<
     v     < 0
     >   t / <
v~.~ <#"="?<
-
#?"+"^t
0
V
#?"="  >"1"-v
/ {   <^"+"?<
>     ^

Działa tylko dla liczb, dla których obliczona wartość <256 z powodu ograniczeń wartości, które mogą być utrzymywane przez wskaźniki w Kardynale

Wypróbuj online

Wyjaśnienie:

Krok 1

%:.~:#"^"."="

Otrzymuje dwie liczby aib jako dane wejściowe i wyjściowe jako „a ^ b =”
Przekazuje wskaźnik z aktywną wartością a i nieaktywną wartością b

Krok 2

        >v
        "~
        *.
>~=088v "~
v88+88< ?
8       -
8      x#<
v     < 0
>   t / <

Otrzymuje wskaźnik z aktywną wartością a i nieaktywną wartością b wypisujący „a” + („* a”) (b-1) razy
Przekazuje wskaźnik z aktywną wartością a ^ (b-1) do następnej części

Krok 3

v~.~ <#"="?<
-
#?"+"^t
0
V
#?"="  
/ {   <
>     ^ 

Pobiera wskaźnik o wartości ^ (b-1) i wysyła „= a” + („+ a”) powtarzane (a ^ (b-1) -1) razy + „=”
Przekazuje wskaźnik o wartości a ^ b do następnej części

Krok 4

>"1"-v
^"+"?<

Otrzymuje wskaźnik o wartości a ^ b i wypisuje „1” + („+ 1”) powtarzane a ^ b-1 razy

Retina, 89 88 bajtów

*`,
^
+`(1+),1
$1*$1,
:`.1+.$

{`^[1+]+
a$&z
+`a(.+)z.1
$1+a$1z*
)`.a.+z.

:`a

+`11
1+1

Dane wejściowe to oddzielone przecinkami liczby jednoargumentowe.

Wypróbuj online!