Dados dos enteros mayores que uno, A y B, generan cuatro expresiones matemáticas en este orden:

1. La expresión simple A ^ B (A a la potencia B). por ejemplo, si A = 2 y B = 3, 2^3.

2. La expansión de A ^ B en términos de multiplicaciones repetidas de A. ej 2*2*2.

3. La expansión de A ^ B en términos de adiciones repetidas de A. ej 2+2+2+2.

4. La expansión de A ^ B en términos de adiciones repetidas de 1. ej 1+1+1+1+1+1+1+1.

Las cuatro expresiones pueden salir de cualquier manera razonable siempre que estén en orden y claramente distintas. Por ejemplo, puede ponerlos en una lista o imprimirlos en líneas separadas

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

o tal vez en una línea separada por signos iguales:

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

Se pueden insertar espacios al lado de los operadores matemáticos para

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

sería una salida igualmente válida cuando A = 2 y B = 3.

Puede usar símbolos alternativos a ^, *y +, pero solo si los nuevos símbolos son más idiomáticos para su idioma (por ejemplo, en **lugar de ^en Python).

Puede suponer que A y B son lo suficientemente pequeños como para que A ^ B no desborde el tipo entero predeterminado de su idioma (dado que ese tipo tiene un máximo razonable, 255 al menos).

El código más corto en bytes gana.

Casos de prueba

Una salida por línea. La entrada se puede inferir ya que la primera expresión es siempre 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 bytes

-2 bytes gracias a Dada (use ~)
-5 bytes gracias a Erwan (use f-strings de Python 3.6)

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

en línea ide alguien?

¿Cómo?

Esta es una función sin nombre que toma las dos entradas enteras ay bcada una mayor que 0(aunque la especificación es solo para aquellas mayores que 1).

En Python 3.6 hay disponible una nueva característica, a saber, literales de cadena formateados o "cadenas f". Permiten la construcción de cadenas evaluadas en tiempo de ejecución. Un líder f(o F) crea tal construcción, por ejemplo, f"blah"o f'blah'. Dentro de una cadena f, cualquier cosa entre un par de llaves {...}, es una expresión a evaluar.

Como tales f"{a}^{b}={a}{f'*{a}'*~-b}={a}{f'+{a}'*~-a**~-b}=1"evalúa cada uno de a, b, a, f'*{a}'*~-b, a, y f'+{a}'*~-a**~-b}como expresiones, manteniendo el ^, =, =y =1como cadenas, todos los cuales obtiene concatenan juntos.

Las expresiones ay bevalúan las representaciones de ay brespectivamente.

El f'*{a}'y f'+{a}'a su vez también son cadenas f dentro de estas expresiones, que se evalúan acon un líder '*'y un líder '+'respectivamente

Para crear el número requerido de asy operaciones para las porciones *y +tenga en cuenta que se b amultiplicarán y se a**(b-1) asumarán. Cada caso requiere un signo de operador menos que el número de as. Entonces podemos repetir las cadenas f f'*{a}y f'+{a}'(usar *) tantas veces como haya operadores y anteponer cada una con un solo a. (b-1)es ~-by (a**(b-1))-1es ~-a**~-b.

Lo mismo se hace para los 1s que usan (a**b)-1being ~-**b, pero no necesitamos la sobrecarga de las cadenas f ya que 1es constante, por lo que una cadena estándar repetida se concatena con +.

Versiones anteriores de Python, 81:

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

Pruébalo en línea!

Cubix, 238 234 217 151 110 100 bytes

Ahorró 14 bytes gracias a ETHProductions

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

Expandido:

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

Pruébalo en línea!

Pruébalo aquí

Explicación

El código consta de 8 pasos, con dos bucles. Revisaré el código parte por parte.

Paso 1 (A ^ B)

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

Este es el cubo con las partes que son irrelevantes para el primer paso eliminado. El signo de interrogación muestra los no-ops que visitará el IP, para dejar su camino más claro.

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)

Ahora, la pila se ve así: A, B, A, B

Paso 2 (prepárese para el ciclo de impresión)

El bucle de impresión toma 3 argumentos (los 3 primeros elementos en la pila): P, Qy R. Pes la cantidad de repeticiones, Qes el separador (código de caracteres) y Res el número a repetir. Por suerte, el bucle también se encarga de la exigencia de que la cadena resultante debe terminar en R, no Q.

Queremos repetir tiempos A*exactos B, entonces el separador es *. Tenga en cuenta que la pila comienza como A, B, A, B. Una vez más, eliminé todas las instrucciones irrelevantes. La IP comienza en el Snorte.

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

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

La pila es ahora A, B, B, *, A.

Paso 3/6/8 (el bucle de impresión)

Concepto

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

La IP ingresa al bucle S, apunta hacia el norte, y sale del bucle hacia E, apuntando hacia el norte nuevamente. Para esta explicación, la pila se establece en [..., A, B, C]. Se ejecutan las siguientes instrucciones. Tenga en cuenta que la IP no puede abandonar el bucle antes del signo de interrogación, por lo que las primeras cuatro instrucciones siempre se ejecutarán.

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

Implementación

Aquí está el cubo nuevamente, con las partes irrelevantes eliminadas. La IP comienza en S, apuntando hacia el este.

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

Como puede ver, la IP se encuentra con cuatro instrucciones antes de ingresar al bucle. Dado que el código de caracteres se elimina nuevamente, llegamos al bucle con exactamente la misma pila que ingresamos en esta parte.

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

Dentro del bucle, la explicación anterior es válida.

Paso 4 (diferenciando las IP)

Dado que usamos el bucle anterior varias veces, y todos hacen que la IP termine en el mismo lugar, tenemos que diferenciar entre múltiples ejecuciones. Primero, podemos distinguir entre el separador (la primera ejecución tiene un *, mientras que las ejecuciones dos y tres tienen un +separador). Podemos diferenciar entre las ejecuciones 2 y 3 comprobando el valor del número que se repite. Si ese es uno, el programa debería finalizar.

Primera comparación

Así es como se ve en el cubo. La IP comienza en S y apunta al norte. La pila contiene [..., * or +, A or 1, 0]. El número 1 muestra dónde terminará la IP si este es el primer bucle (apuntando hacia el norte) y el número 2 muestra dónde terminará la IP si este es el segundo (o tercer) bucle (apuntando hacia el este).

          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.

Si la IP ahora está en 1, la pila está [A, *, +, -1]. De lo contrario, la pila es [A or 1, +, +, 0]. Como puede ver, todavía hay una incógnita en la pila del segundo caso, por lo que tenemos que hacer otra comparación.

Segunda comparación

Debido a que la IP ha pasado por el paso 5, las miradas de pila de este tipo: [A^(B-1) or nothing, A or 1, +, +, 0]. Si el primer elemento es nothing, el segundo elemento es 1, y lo contrario también se cumple. El cubo se ve así, con la IP comenzando en S y apuntando hacia el este. Si este es el segundo bucle, la IP termina en E, apuntando hacia el oeste. De lo contrario, el programa golpea @y finaliza.

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

Las instrucciones ejecutadas que no hacen nada al flujo de control se enumeran a continuación.

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

La pila está ahora [A^B, +, A^(B-1), A-1], siempre que el programa no haya terminado.

Paso 5 (preparación para "A +" (repita A ^ (B-1)))

Lamentablemente, Cubix no tiene un operador de potencia, por lo que necesitamos otro bucle. Sin embargo, primero debemos limpiar la pila, que ahora contiene [B, A, *, +, -1].

Limpiar

Aquí está el cubo otra vez. Como de costumbre, la IP comienza en S (apuntando hacia el norte) y termina en E, apuntando hacia el oeste.

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

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

Calculando A ^ (B-1)

Otro bucle que funciona más o menos igual que el bucle de impresión, pero es un poco más compacto. La IP comienza en S, apuntando al oeste, con pila [B, A, *]. La IP sale Eapuntando hacia el norte.

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

El cuerpo del bucle es el siguiente.

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

La pila resultante es [A, A^(B-1), 0].

Limpiar la pila (de nuevo)

Ahora necesitamos volver al ciclo de impresión, con la parte superior de la pila conteniendo [..., A^(B-1), +, A]. Para hacer esto, ejecutamos lo siguiente. Aquí está el cubo otra vez,

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

Paso 7 (preparación para el último bucle)

La pila es ahora [A^B, +, A^(B-1), A-1], la IP comienza en S, yendo hacia el oeste, y termina en E, yendo hacia la derecha.

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

Las instrucciones ejecutadas:

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

La pila ahora se ve [A^B, +, 1]y la IP está a punto de entrar en el ciclo de impresión, así que hemos terminado.

MATL , 46 bytes

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

Pruébalo en línea!

Estirando los límites de "forma razonable" aquí, pero las expresiones están separadas.

Explicación

Primera expresion:

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

Segunda expresión:

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

Tercera expresión:

&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

Cuarta expresión:

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

Toma entrada en la sintaxis de curry (a)(b). Emite una cadena.

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

Casos de prueba

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×)€¦

Explicación:

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

Pruébalo en línea!

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 si podemos ignorar 0 potencias; y=!!ipodría convertirsey=1

Pruébalo en línea!

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

Sin golf:

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

Código de prueba:

Pruébalo aquí.

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

Salida:

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 bytes de código, +1 para -nbandera.

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

Toma A y B como argumentos de línea de comandos; imprime una expresión por línea. Pruébalo en línea!

Explicación

Ya**bes el código de configuración: tire de a**bla yvariable. Después de eso, tenemos una lista (in []) que contiene nuestras cuatro expresiones:

• gJ'^: tome la glista ar completa (aquí, una lista que contiene ay b) y Jcompártala en^
• aRLbJ'*: use Repeat List para crear una lista con bcopias de a, y luego Jen*
• aRLy/aJ'+: se usa RLpara crear una lista con y/a(es decir a**(b-1)) copias de a, y luego Jen+
• 1XyJ'+: 1, cadena multiplicada por y, Jalineada en+

La lista se imprime con nueva línea como separador gracias a la -nbandera.

Javascript 115 113 104 bytes

Gracias a @Neil y @TuukkaX por jugar golf en un byte cada uno y @ETHproductions y Luke por jugar golf en 9 bytes

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

Pruébalo en línea

Jalea , 29 bytes

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

Pruébalo en línea!

¿Cómo?

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

El uso de la respuesta ahorra 8 bytes entre paréntesis de cierre implícitos al final de las líneas. Define una función Xque toma dos números y devuelve una lista de expresiones. Cada expresión está entre paréntesis, con espacios alrededor de los operadores (en realidad, es una lista de números y símbolos de operador):

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

Esperemos que este formato de salida sea aceptable. Pruébalo en línea! (con varios casos de prueba).

Explicación

(load library)

Necesitamos dos funciones de la biblioteca estándar: listy* .

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

Definir una función W(abreviatura de "tejido") que toma un acumulador _, un número N, un símbolo Sy un conteo# . Utilizaremos esta función para generar la mayoría de nuestras expresiones: por ejemplo, (W () 2 (q +) 3)resultará en (2 + 2 + 2).

Si el recuento es 1 (e # 1), entonces cons el número al frente del acumulador(c N _) y devuélvalo. De lo contrario, recurse:

• Nuevo acumulador es (c S(c N _)) : el símbolo y el número cons'd al frente del acumulador anterior;
• N y S son lo mismo;
• Nuevo recuento es (s # 1) : cuenta - 1.

El idioma del acumulador es necesario para lograr una recursión de cola adecuada , evitando un error de profundidad de recursión. (Este cambio es responsable del +8 al recuento de bytes. El 13^2caso no funcionó en la versión anterior).

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

Desafortunadamente, la biblioteca no tiene una función de exponenciación en este momento, por lo que tenemos que definir una. ^toma xy y. Si yes verdadero (distinto de cero), recurrimos con y-1( (s y 1)) y multiplicamos el resultado por x. De lo contrario, yes cero y volvemos 1.

(Nota: esta función no utiliza la recursión de la cola adecuada. Supongo que los exponentes serán lo suficientemente pequeños como para que no importe. Algunos experimentos en TIO indicaron un exponente máximo de 325, lo que diría que debería ser suficiente para esta pregunta. Si el OP no está de acuerdo, lo cambiaré).

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

Por último, la función que nos interesa, X, toma Ay By devuelve una lista de cuatro elementos:

• (list A(q ^)B): una lista que contiene Aun literal ^y B;
• (W()A(q *)B): llame Wpara obtener una lista de Bcopias Aentrelazadas con literal *;
• (W()A(q +)(^ A(s B 1))): llame Wpara obtener una lista de A^(B-1)copias Aentrelazadas con literal +;
• (W()1(q +)(^ A B)): llame Wpara obtener una lista de A^Bcopias 1entrelazadas con literal +.

Brainfuck , 372 bytes

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

Pruébalo en línea!

Notas

1. Las dos entradas deben elegirse de tal manera que A**Bno exceda 255. Esto se debe a que Brainfuck solo puede almacenar valores de un byte.
2. Si una entrada es mayor que 9, use el siguiente carácter ASCII. 10se convierte :, se 11convierte en ;etc. Esto se debe a que Brainfuck solo puede tomar entradas de un byte.

Explicación

Aquí está mi código algo comentado. Ampliaré esto más tarde.

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

Toma entrada como [2,10], salidas como["2^10", "2*2*2*2*2*2*2*2*2*2", "2+2+...

Explicación:

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

Pruébalo aquí.

Perl , 81 bytes

78 bytes de código + -nbandera (contados como 3 bytes ya que el código contiene $').

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

Pruébalo en línea!

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

Función anónima que genera las salidas requeridas, bien, línea por línea. Esta solución hace un amplio uso de laswitch función.

La switchfunción toma una expresión (aquí s) que se evalúa como un número o una cadena de caracteres (ver ?switch), seguida de las alernativas correspondientes a s. Si falta una alternativa (por ejemplo switch(s, a=, b= "PPCG"), se evalúa la siguiente alternativa que no falta) (en el ejemplo, s="a"salidas "PPCG").

Las repfunciones repiten (replican, en realidad) su primer argumento el número de veces indicado en el segundo argumento.

cat, para finalizar, concatenar e imprimir los objetos, con un separador que se puede elegir con el sep =argumento. La segunda catfunción está aquí para el salto de línea.

Sin golf:

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*

Pruébalo en línea!

k, 44 bytes

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

Casos de prueba.

Cardenal 202 bytes

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

Solo funcionará para números donde el valor calculado <256 debido a limitaciones en los valores que pueden mantener los punteros en Cardinal

Pruébalo en línea

Explicación:

Paso 1

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

Recibe dos números a y b como entrada y salidas como "a ^ b ="
Pasa un puntero con valor activo ay valor inactivo b

Paso 2

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

Recibe un puntero con valor activo ay valor inactivo b imprimiendo "a" + ("* a") (b-1) veces
Pasa un puntero con valor activo a ^ (b-1) a la siguiente parte

Paso 3

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

Recibe un puntero con valor de a ^ (b-1) y genera "= a" + ("+ a") repetido (a ^ (b-1) -1) veces + "="
Pasa un puntero con valor a ^ b a la siguiente parte

Etapa 4

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

Recibe un puntero con valor a ^ b e imprime "1" + ("+ 1") repetido a ^ b-1 veces

Retina, 89 88 bytes

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

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

:`a

+`11
1+1

La entrada es números unarios separados por comas.

Pruébalo en línea!