Bei zwei Ganzzahlen größer als eins, A und B, werden vier mathematische Ausdrücke in dieser Reihenfolge ausgegeben:

1. Der einfache Ausdruck A ^ B (A hoch B). zB wenn A = 2 und B = 3 2^3,.

2. Die Expansion von A ^ B in Bezug auf wiederholte Multiplikationen von A. z 2*2*2.

3. Die Expansion von A ^ B in Bezug auf wiederholte Zugaben von A. z 2+2+2+2.

4. Die Erweiterung von A ^ B in Bezug auf wiederholte Hinzufügungen von 1. z 1+1+1+1+1+1+1+1.

Die vier Ausdrücke können auf jede vernünftige Weise ausgegeben werden, solange sie geordnet und klar voneinander getrennt sind. Sie können sie beispielsweise in eine Liste aufnehmen oder in separaten Zeilen drucken

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

oder vielleicht in einer durch Gleichheitszeichen getrennten Zeile:

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

Leerzeichen können so neben mathematischen Operatoren eingefügt werden

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

wäre gleichermaßen gültig, wenn A = 2 und B = 3.

Sie können Symbole alternativ zu ^, *und verwenden +, aber nur, wenn die neuen Symbole für Ihre Sprache idiomatischer sind (z. B. **statt ^in Python).

Sie können davon ausgehen, dass A und B ausreichend klein sind, damit A ^ B den Standard-Integer-Typ Ihrer Sprache nicht überläuft (vorausgesetzt, dieser Typ hat ein angemessenes Maximum, mindestens 255).

Der kürzeste Code in Bytes gewinnt.

Testfälle

Ein Ausgang pro Zeile. Die Eingabe kann abgeleitet werden, da der erste Ausdruck immer A ^ B ist.

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 Bytes

-2 Bytes dank Dada (Verwendung ~)
-5 Bytes dank Erwan (Verwendung von F-Strings aus Python 3.6)

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

Online für jemanden?

Wie?

Dies ist eine unbenannte Funktion, die die beiden Ganzzahleingaben aund bjeweils größer als 0(obwohl die Spezifikation nur für diejenigen größer als gilt 1) verwendet.

In Python 3.6 ist eine neue Funktion verfügbar, nämlich formatierte String-Literale oder "f-Strings". Diese ermöglichen einen zur Laufzeit bewerteten Stringaufbau. Ein führendes f(oder F) erzeugt solches Konstrukt, beispielsweise f"blah"oder f'blah'. Innerhalb einer f-Zeichenfolge ist alles zwischen zwei geschweiften Klammern {...}ein auszuwertender Ausdruck.

Als solche f"{a}^{b}={a}{f'*{a}'*~-b}={a}{f'+{a}'*~-a**~-b}=1"auswertet jeder a, b, a, f'*{a}'*~-b, a, und f'+{a}'*~-a**~-b}als Ausdruck, halten die ^, =, =und =1als Zeichenfolgen, von denen alle miteinander verkettet wird.

Die aund bAusdrücke auswerten zu den Darstellungen aund bjeweils.

Die f'*{a}'und sind f'+{a}'wiederum auch F-Strings in diesen Ausdrücken, die amit einem führenden '*'bzw. einem führenden '+'Ergebnis bewertet werden

Um die erforderliche Anzahl von as und Operationen für die Teile *und zu erstellen, ist zu +beachten, dass b as multipliziert und a**(b-1) as addiert werden. In jedem Fall ist dann ein Vorzeichen weniger als die Anzahl von as erforderlich . So können wir die f-Zeichenfolgen wiederholen f'*{a}und so oft f'+{a}'(mit *), wie es Operatoren gibt, und jeder eine einzelne voranstellen a. (b-1)ist ~-bund (a**(b-1))-1ist ~-a**~-b.

Dasselbe gilt für das 1s using (a**b)-1being ~-**b, aber wir brauchen den Overhead von f-Strings nicht, da 1es konstant ist, sodass ein wiederholter Standard-String mit verkettet wird +.

Frühere Python-Versionen, 81:

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

Probieren Sie es online!

Cubix, 238 234 217 151 110 100 Bytes

14 Bytes gespart dank ETHProductions

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

Erweitert:

          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 \ . . . . .
. . . . . . . . . . . . . . . . . . . .
          . . . . .
          . . . . .
          . . . . .
          . . . . .
          . . . . .

Probieren Sie es online!

Probieren Sie es hier aus

Erläuterung

Der Code besteht aus 8 Schritten mit zwei Schleifen. Ich werde den Code Teil für Teil durchgehen.

Schritt 1 (A ^ B)

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

Dies ist der Würfel, bei dem die Teile, die für den ersten Schritt irrelevant sind, entfernt wurden. Das Fragezeichen zeigt die No-Ops, die die IP besuchen wird, um ihren Weg klarer zu machen.

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)

Der Stack sieht nun so aus: A, B, A, B

Schritt 2 (Druckschleife vorbereiten)

Die Druckschleife dauert 3 Argumente (die Top - 3 - Elemente auf dem Stapel) P, Qund R. Pist die Anzahl der Wiederholungen, Qist das Trennzeichen (Zeichencode) und Rist die zu wiederholende Zahl. Glücklicherweise erfüllt die Schleife auch die Anforderung, dass die resultierende Zeichenfolge auf enden soll R, nicht Q.

Wir wollen A*genau Bmal wiederholen , also ist das Trennzeichen *. Beachten Sie, dass der Stapel als beginnt A, B, A, B. Wieder entfernte ich alle irrelevanten Anweisungen. Die IP beginnt im SNorden.

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

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

Der Stapel ist jetzt A, B, B, *, A.

Schritt 3/6/8 (die Druckschleife)

Konzept

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

Die IP tritt in die Schleife ein Sund zeigt nach Norden. Sie verlässt die Schleife unter Eund zeigt wieder nach Norden. Für diese Erklärung wird der Stack auf gesetzt [..., A, B, C]. Die folgenden Anweisungen werden ausgeführt. Beachten Sie, dass die IP die Schleife nicht vor dem Fragezeichen verlassen kann, sodass die ersten vier Anweisungen immer ausgeführt werden.

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 ...

Implementierung

Hier ist wieder der Würfel, wobei die irrelevanten Teile entfernt sind. Die IP beginnt bei Sund zeigt nach Osten.

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

Wie Sie sehen können, trifft die IP auf vier Anweisungen, bevor sie in die Schleife eintritt. Da der Zeichencode wieder entfernt wird, erreichen wir die Schleife mit genau demselben Stapel, mit dem wir diesen Teil betreten haben.

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

Innerhalb der Schleife gilt die obige Erklärung.

Schritt 4 (Unterscheidung der IPs)

Da wir die obige Schleife mehrmals verwenden und sie alle dazu führen, dass die IP an derselben Stelle endet, müssen wir zwischen mehreren Läufen unterscheiden. Erstens können wir zwischen dem Trennzeichen unterscheiden (der erste Lauf hat ein *, während der zweite und der dritte Lauf ein +Trennzeichen haben). Wir können zwischen den Läufen 2 und 3 unterscheiden, indem wir den Wert der Zahl überprüfen, die wiederholt wird. Wenn dies der Fall ist, sollte das Programm beendet werden.

Erster Vergleich

So sieht es auf dem Würfel aus. Die IP beginnt bei S und zeigt nach Norden. Der Stapel enthält [..., * or +, A or 1, 0]. Die Nummer 1 gibt an, wo die IP enden wird, wenn dies die erste Schleife ist (nach Norden zeigend), und die Nummer 2 gibt an, wo die IP enden wird, wenn dies die zweite (oder dritte) Schleife ist (nach Osten zeigend).

          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.

Wenn die IP jetzt auf ist 1, ist der Stack [A, *, +, -1]. Ansonsten ist der Stack [A or 1, +, +, 0]. Wie Sie sehen, befindet sich im Stapel des zweiten Falls noch ein Unbekannter, sodass wir einen weiteren Vergleich durchführen müssen.

Zweiter Vergleich

Da die IP hat durch Schritt 5, der Stapel sieht wie folgt fort: [A^(B-1) or nothing, A or 1, +, +, 0]. Wenn das erste Element ist nothing, ist das zweite Element 1und das Gegenteil gilt auch. Der Würfel sieht so aus, wobei die IP bei S beginnt und nach Osten zeigt. Wenn dies die zweite Schleife ist, endet die IP bei Eund zeigt nach Westen. Ansonsten schlägt das Programm zu @und bricht ab.

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

Die ausgeführten Anweisungen, die nichts mit dem Steuerungsfluss zu tun haben, sind unten aufgeführt.

;;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

Der Stack ist jetzt [A^B, +, A^(B-1), A-1], sofern das Programm nicht beendet wurde.

Schritt 5 (Vorbereitung für "A +" (Wiederholung von A ^ (B-1))

Leider hat Cubix keinen Netzbetreiber, also brauchen wir eine weitere Schleife. Wir müssen jedoch zuerst den Stapel bereinigen, der jetzt enthält [B, A, *, +, -1].

Aufräumen

Hier ist wieder der Würfel. Wie üblich beginnt die IP bei S (nach Norden zeigend) und endet bei E (nach Westen zeigend).

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

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

Berechnung von A ^ (B-1)

Eine weitere Schleife, die ungefähr so ​​funktioniert wie die Druckschleife, aber etwas kompakter ist. Die IP beginnt mit Snach Westen zeigendem Stack [B, A, *]. Die IP-Adresse Ezeigt nach Norden.

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

Der Schleifenkörper ist der folgende.

;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 ...

Der resultierende Stapel ist [A, A^(B-1), 0].

Stapel (wieder) aufräumen

Jetzt müssen wir wieder zur Druckschleife gelangen, wobei die Oberseite des Stapels enthält [..., A^(B-1), +, A]. Dazu führen wir Folgendes aus. Hier ist wieder der Würfel,

          . . ^ ? :
          . . . . .
          . . . . .
          . . . . .
          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])

Schritt 7 (Vorbereitung für die letzte Schleife)

Der Stack ist jetzt [A^B, +, A^(B-1), A-1], die IP beginnt bei S, geht nach Westen und endet bei E, geht nach rechts.

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

Die ausgeführten Anweisungen:

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

Der Stapel sieht nun so aus [A^B, +, 1]und die IP wird in die Druckerschleife eingegeben, also sind wir fertig.

MATL , 46 Bytes

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

Probieren Sie es online!

Die Grenzen des "vernünftigen Weges" hier ausdehnen, aber die Ausdrücke sind getrennt.

Erläuterung

Erster Ausdruck:

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

Zweiter Ausdruck:

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

Dritter Ausdruck:

&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

Vierter Ausdruck:

&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 Byte

Übernimmt Eingaben in der Currying-Syntax (a)(b). Gibt einen String aus.

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

Testfälle

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 Bytes

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

05AB1E , 30 Bytes

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

Erläuterung:

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

Probieren Sie es online!

C (GCC) , 156 149 Bytes

#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 Bytes, wenn wir 0 Potenzen ignorieren können; y=!!ikann werdeny=1

Probieren Sie es online!

Java 7, 170 Bytes

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;}

Ungolfed:

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;
}

Testcode:

Probieren Sie es hier aus.

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));
  }
}

Ausgabe:

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 Bytes

33 Byte Code, +1 für -nFlag.

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

Nimmt A und B als Befehlszeilenargumente; druckt einen Ausdruck pro Zeile. Probieren Sie es online!

Erläuterung

Ya**bist der Setup-Code: Ziehe a**bin die yVariable. Danach haben wir eine Liste (in []), die unsere vier Ausdrücke enthält:

• gJ'^: nimm eine vollständige AR- gListe (hier eine Liste mit aund b) und Join es auf^
• aRLbJ'*: benutze Repeat List um eine Liste mit bKopien von zu erstellen a, dann Join es auf*
• aRLy/aJ'+: Verwenden Sie diese Option RL, um eine Liste mit y/a(dh a**(b-1)) Kopien von zu erstellen a, und Jschließen Sie sie dann an+
• 1XyJ'+: 1, Zeichenfolge multipliziert mit y, Jeingezeichnet auf+

Die Liste wird dank des -nFlags mit Zeilenvorschub als Trennzeichen gedruckt .

Javascript 115 113 104 Bytes

Vielen Dank an @Neil und @TuukkaX für das Golfen mit jeweils einem Byte und an @ETHproductions und an Luke für das Golfen mit 9 Byte

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)]

Probieren Sie es online

Gelee , 29 Bytes

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

Probieren Sie es online!

Wie?

*⁹’,¤;@ - 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 bytes

(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

Durch die Verwendung von repl werden 8 Bytes in impliziten schließenden Klammern am Zeilenende gespeichert. Definiert eine Funktion, Xdie zwei Zahlen annimmt und eine Liste von Ausdrücken zurückgibt. Jeder Ausdruck steht in Klammern mit Leerzeichen um die Operatoren (tatsächlich handelt es sich um eine Liste von Zahlen und Operatorsymbolen):

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

Hoffentlich ist dieses Ausgabeformat akzeptabel. Probieren Sie es online! (mit mehreren Testfällen).

Erläuterung

(load library)

Wir benötigen zwei Funktionen aus der Standardbibliothek: listund *.

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

Definieren Sie eine Funktion W(kurz für "Weben"), die einen Akkumulator _, eine Zahl N, ein Symbol Sund eine Zählung enthält #. Wir werden diese Funktion verwenden die meisten unserer Ausdrücke generieren: zum Beispiel (W () 2 (q +) 3)führt zu (2 + 2 + 2).

Wenn der Zähler 1 ist (e # 1), tragen Sie die Nummer auf die Vorderseite des Akkus (c N _)und geben Sie diese zurück. Ansonsten rekursiv:

• Neuer Akku ist (c S(c N _)): das Symbol und die Nummer vor dem vorherigen Akku;
• Nund Ssind gleich;
• Neue Zählung ist (s # 1): Zählung - 1.

Das Akkumulator-Idiom wird benötigt, um eine ordnungsgemäße Schwanzrekursion zu erreichen und einen Rekursionstiefenfehler zu vermeiden. (Diese Änderung ist für die Erhöhung der Bytezahl um 8 verantwortlich. In 13^2der vorherigen Version funktionierte die Groß- / Kleinschreibung nicht.)

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

Leider hat die Bibliothek zu diesem Zeitpunkt keine Potenzierungsfunktion, daher müssen wir eine definieren. ^nimmt xund y. Wenn ywahr ist (ungleich Null), verwenden wir y-1( (s y 1)) und multiplizieren das Ergebnis mit x. Ansonsten yist Null und wir kehren zurück 1.

(Hinweis: Diese Funktion verwendet keine ordnungsgemäße Schwanzrekursion. Ich gehe davon aus, dass die Exponenten so klein sind, dass es keine Rolle spielt. Einige Experimente mit TIO ergaben einen maximalen Exponenten von 325, der meiner Meinung nach für diese Frage ausreichen sollte. Wenn das OP nicht einverstanden ist, werde ich es ändern.)

(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))))))

Schließlich wird in der Funktion , die wir interessiert sind, Xnimmt, Aund Bund gibt eine Liste der vier Elemente:

• (list A(q ^)B): eine Liste mit A, einem Literal ^und B;
• (W()A(q *)B): Rufen Sie Wan, um eine Liste der BKopien von A, mit wörtlichen verwoben zu bekommen *;
• (W()A(q +)(^ A(s B 1))): Rufen Sie Wan, um eine Liste der A^(B-1)Kopien von A, mit wörtlichen verwoben zu bekommen +;
• (W()1(q +)(^ A B)): rufen Sie Wan, um eine Liste von A^BKopien zu erhalten 1, die mit dem Wortlaut verwoben sind +.

Brainfuck , 372 Bytes

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

Probieren Sie es online!

Anmerkungen

1. Die beiden Eingänge müssen so gewählt werden, dass A**Bsie nicht überschreiten 255. Dies liegt daran, dass Brainfuck nur Werte von einem Byte speichern kann.
2. Wenn eine Eingabe größer als 9 ist, verwenden Sie das nächste ASCII-Zeichen. 10wird :, 11wird ;usw. Dies liegt daran, dass Brainfuck nur Eingaben von einem Byte annehmen kann.

Erläuterung

Hier ist mein etwas kommentierter Code. Ich werde später darauf eingehen.

,.                      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 Bytes

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

Nimmt Eingaben als [2,10], Ausgaben als["2^10", "2*2*2*2*2*2*2*2*2*2", "2+2+...

Erläuterung:

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,...
)                                     #

Probieren Sie es hier aus.

Perl , 81 Bytes

78 Byte Code + -nFlag (gezählt als 3 Byte, da der Code enthält $').

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

Probieren Sie es online!

R, 147 Bytes

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")}

Anonyme Funktion, die die erforderlichen Informationen Zeile für Zeile ausgibt. Diese Lösung nutzt die switchFunktion in großem Umfang .

Die switchFunktion verwendet einen Ausdruck (hier s), der zu einer Zahl oder einer Zeichenfolge (siehe ?switch) ausgewertet wird , gefolgt von den entsprechenden Alernativen s. Fehlt eine Alternative (z. B. switch(s, a=, b= "PPCG")wird die nächste nicht fehlende Alternative ausgewertet (im Beispiel s="a"Ausgänge "PPCG").

Die repFunktionen wiederholen ihr erstes Argument so oft, wie es im zweiten Argument angegeben ist.

cat, um die Objekte fertigzustellen, zu verketten und auszudrucken, mit einem Trennzeichen, das mit dem sep =Argument ausgewählt werden kann. Die zweite catFunktion ist hier für den Zeilenumbruch.

Ungolfed:

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 Bytes

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

Probieren Sie es online!

k, 44 Bytes

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

Testfälle.

Kardinal 202 Bytes

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

Funktioniert nur für Zahlen, bei denen der berechnete Wert <256 ist, da die Werte, die Zeiger in Cardinal enthalten können, begrenzt sind

Probieren Sie es online

Erläuterung:

Schritt 1

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

Erhält zwei Zahlen a und b als Eingabe und gibt sie als "a ^ b =" aus.
Übergibt einen Zeiger mit aktivem Wert a und inaktivem Wert b

Schritt 2

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

Erhält einen Zeiger mit aktivem Wert a und inaktivem Wert b, der "a" + ("* a") (b-1) mal
druckt. Übergibt einen Zeiger mit aktivem Wert a ^ (b-1) an den nächsten Teil

Schritt 3

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

Erhält einen Zeiger mit dem Wert a ^ (b-1) und gibt "= a" + ("+ a") aus, und zwar wiederholt (a ^ (b-1) -1) mal + "="
Übergibt einen Zeiger mit dem Wert a ^ b zum nächsten Teil

Schritt 4

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

Erhält einen Zeiger mit dem Wert a ^ b und gibt "1" + ("+ 1") aus, der a ^ b-1-mal wiederholt wird

Retina, 89 88 Bytes

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

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

:`a

+`11
1+1

Die Eingabe erfolgt durch Kommas getrennte unäre Zahlen.

Probieren Sie es online!