Dados dois números inteiros maiores que um, A e B, produzem quatro expressões matemáticas nesta ordem:

1. A expressão simples A ^ B (A à potência B). por exemplo, se A = 2 e B = 3 2^3,.

2. A expansão de A ^ B em termos de multiplicações repetidas de A. eg 2*2*2.

3. A expansão de A ^ B em termos de adições repetidas de A. eg 2+2+2+2.

4. A expansão de A ^ B em termos de adições repetidas de 1. eg 1+1+1+1+1+1+1+1.

As quatro expressões podem ser produzidas de qualquer maneira razoável, desde que estejam em ordem e claramente distintas. Por exemplo, você pode colocá-los em uma lista ou imprimi-los em linhas separadas

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

ou talvez em uma linha separada por sinais de igual:

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

Os espaços podem ser inseridos ao lado dos operadores matemáticos para que

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

seria uma saída igualmente válida quando A = 2 e B = 3.

Você pode usar símbolos alternativos para ^, *e +, mas somente se os novos símbolos são mais idiomática para o seu idioma (por exemplo, **em vez de ^em Python).

Você pode supor que A e B são suficientemente pequenos para que A ^ B não ultrapasse o tipo inteiro padrão do seu idioma (dado que esse tipo tem um máximo razoável, 255 pelo menos).

O código mais curto em bytes vence.

Casos de teste

Uma saída por linha. A entrada pode ser inferida, pois a primeira expressão é sempre 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 graças ao Dada (uso ~)
-5 bytes graças ao Erwan (use strings f do Python 3.6)

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

ide online alguém?

Quão?

Esta é uma função sem nome que recebe as duas entradas inteiras ae bcada uma é maior que 0(mesmo que a especificação seja apenas para aquelas maiores que 1).

No Python 3.6, um novo recurso está disponível, a saber, literais de string formatados ou "f-strings". Isso permite a construção de cadeias avaliadas em tempo de execução. Um líder f(ou F) cria essa construção, por exemplo, f"blah"ou f'blah'. Dentro de uma string F, qualquer coisa entre um par de chaves,, {...}é uma expressão a ser avaliada.

Como tal, f"{a}^{b}={a}{f'*{a}'*~-b}={a}{f'+{a}'*~-a**~-b}=1"avalia cada um a, b, a, f'*{a}'*~-b, a, e f'+{a}'*~-a**~-b}como expressões, mantendo o ^, =, =, e =1como cordas, todos os quais se concatenadas.

As expressões ae bavaliam as representações de ae brespectivamente.

O f'*{a}'ef'+{a}' por sua vez também são strings f dentro dessas expressões, que avaliam acom um líder '*'e um líder '+'respectivamente

Para criar o número necessário de se aoperações para as partes *e, +observe que serão b amultiplicados e a**(b-1) aadicionados. Cada caso requer um sinal de operador a menos que o número de as. Assim, podemos repetir as f-cordas f'*{a}e f'+{a}'(usando *) tantas vezes quantas existem operadores e preceder cada um com um único a.(b-1)é ~-be (a**(b-1))-1é ~-a**~-b.

O mesmo é feito para os que estão 1usando(a**b)-1~-**b , mas nós não precisamos a sobrecarga de f-cordas desde 1é constante, por isso, uma cadeia de caracteres padrão repetido é concatenado com +.

Versões anteriores do Python, 81:

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

Experimente online!

Cubix, 238 234 217 151 110 100 bytes

Economizou 14 bytes graças ao 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 \ . . . . .
. . . . . . . . . . . . . . . . . . . .
          . . . . .
          . . . . .
          . . . . .
          . . . . .
          . . . . .

Experimente online!

Experimente aqui

Explicação

O código consiste em 8 etapas, com dois loops. Vou revisar o código parte por parte.

Etapa 1 (A ^ B)

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

Este é o cubo com as partes que são irrelevantes para a primeira etapa removida. O ponto de interrogação mostra as no-ops que o IP visitará, para tornar seu caminho mais 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)

Agora, a pilha fica assim: A, B, A, B

Etapa 2 (preparar para o loop de impressão)

O ciclo de impressão leva 3 argumentos (os 3 principais elementos na pilha): P, Qe R. Pé a quantidade de repetições, Qé o separador (código de caractere) e Ré o número a repetir. Felizmente, o loop também cuida da exigência de que a sequência resultante termine R, não Q.

Queremos repetir A*exatamente os Btempos, então o separador é *. Observe que a pilha começa como A, B, A, B. Mais uma vez, removi todas as instruções irrelevantes. O IP começa no sentido Snorte.

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

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

A pilha está agora A, B, B, *, A .

Etapa 3/6/8 (o loop de impressão)

Conceito

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

O IP entra no loop S, apontando para o norte, e sai do loop em E, apontando para o norte novamente. Para esta explicação, a pilha está definida como [..., A, B, C]. As seguintes instruções são executadas. Observe que o IP não pode deixar o loop antes do ponto de interrogação; portanto, as quatro primeiras instruções sempre serão executadas.

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

Implementação

Aqui está o cubo novamente, com as partes irrelevantes removidas. O IP começa em S, apontando para o leste.

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

Como você pode ver, o IP encontra quatro instruções antes de entrar no loop. Como o código do caractere é removido novamente, alcançamos o loop exatamente com a mesma pilha em que entramos nesta parte.

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

Dentro do loop, a explicação acima é válida.

Etapa 4 (diferenciando os IPs)

Como usamos o loop acima várias vezes e todos eles fazem com que o IP termine no mesmo local, precisamos diferenciar entre várias execuções. Primeiro, podemos distinguir entre o separador (a primeira execução tem a *, enquanto as duas e três têm uma+ como separador). Podemos diferenciar entre as execuções 2 e 3 verificando o valor do número que é repetido. Se for esse o caso, o programa deve terminar.

Primeira comparação

Aqui está o que parece no cubo. O IP começa em S e aponta para o norte. A pilha contém [..., * or +, A or 1, 0]. O número 1 mostra onde o IP terminará se este for o primeiro loop (apontando para o norte) e o número 2 mostra onde o IP terminará se esse for o segundo (ou terceiro) loop (apontando para o leste).

          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.

Se o IP agora estiver em 1, a pilha estará [A, *, +, -1]. Caso contrário, a pilha é[A or 1, +, +, 0] . Como você pode ver, ainda há um desconhecido na pilha do segundo caso, então temos que fazer outra comparação.

Segunda comparação

Porque o IP passou por etapa 5, os olhares pilha como este: [A^(B-1) or nothing, A or 1, +, +, 0]. Se o primeiro elemento for nothing, o segundo elemento será 1e o inverso também será válido. O cubo fica assim, com o IP começando em S e apontando para leste. Se esse for o segundo loop, o IP terminará emE , apontando para oeste. Caso contrário, o programa acessa @e termina.

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

As instruções executadas que não fazem nada no fluxo de controle estão listadas abaixo.

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

A pilha está agora [A^B, +, A^(B-1), A-1], desde que o programa não tenha terminado.

Etapa 5 (preparando para "A +" (repita A ^ (B-1)))

Infelizmente, o Cubix não tem um operador de energia, então precisamos de outro loop. No entanto, precisamos limpar a pilha primeiro, que agora contém[B, A, *, +, -1] .

Limpando

Aqui está o cubo novamente. Como de costume, o IP começa em S (apontando para o norte) e termina em E, apontando para o oeste.

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

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

Cálculo de A ^ (B-1)

Outro loop que funciona aproximadamente o mesmo que o loop de impressão, mas é um pouco mais compacto. O IP começa em S, apontando para o oeste, com a pilha [B, A, *]. O IP sai Eapontando para o norte.

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

O corpo do loop é o seguinte.

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

A pilha resultante é [A, A^(B-1), 0].

Limpando a pilha (novamente)

Agora precisamos voltar ao loop de impressão novamente, com a parte superior da pilha [..., A^(B-1), +, A]. Para fazer isso, executamos o seguinte. Aqui está o cubo novamente,

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

Etapa 7 (preparando para o último loop)

A pilha está agora [A^B, +, A^(B-1), A-1], o IP começa em S, indo para o oeste, e termina em E, indo para a direita.

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

As instruções executadas:

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

A pilha agora parece [A^B, +, 1]e o IP está prestes a entrar no loop de impressão, então terminamos.

MATL , 46 bytes

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

Experimente online!

Esticando os limites da "maneira razoável" aqui, mas as expressões são separadas.

Explicação

Primeira expressão:

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 expressão:

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

Terceira expressão:

&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

Quarta expressão:

&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

Recebe entrada na sintaxe de currying (a)(b). Produz uma string.

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

Casos de teste

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

Explicação:

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

Experimente 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 se pudermos ignorar 0 potências; y=!!ipode se tornary=1

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

Código do teste:

Experimente aqui.

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

Saída:

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

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

Leva A e B como argumentos de linha de comando; imprime uma expressão por linha. Experimente online!

Explicação

Ya**bé o código de instalação: puxe a**ba yvariável. Depois disso, temos uma lista (in []) contendo nossas quatro expressões:

• gJ'^: pegue uma glista completa (aqui, uma lista contendo ae b) e Jcoloque-a no^
• aRLbJ'*: use Repeat List para criar uma lista com bcópias e a, em seguida J,*
• aRLy/aJ'+: use RLpara criar uma lista com y/a(ou seja a**(b-1)) cópias de e a, em seguida J,+
• 1XyJ'+: 1, sequência de caracteres multiplicada por y, Jrepetida em+

A lista é impressa com nova linha como separador, graças à -nbandeira.

Javascript 115 113 104 bytes

Obrigado a @Neil e @TuukkaX por jogarem um byte cada e @ETHproductions e Luke por jogarem 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)]

Experimente Online

Gelatina , 29 bytes

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

Experimente online!

Quão?

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

repl do 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

O uso da repl salva 8 bytes entre parênteses de fechamento implícitos no final das linhas. Define uma função Xque recebe dois números e retorna uma lista de expressões. Cada expressão está entre parênteses, com espaços ao redor dos operadores (na verdade, é uma lista de números e símbolos do operador):

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

Espero que este formato de saída seja aceitável. Experimente online! (com vários casos de teste).

Explicação

(load library)

Precisamos de duas funções da biblioteca padrão: liste *.

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

Defina uma função W(abreviação de "tecer") que recebe um acumulador _, um número N, um símbolo Se uma contagem #. Usaremos essa função para gerar a maioria de nossas expressões: por exemplo, (W () 2 (q +) 3)resultará em(2 + 2 + 2) .

Se a contagem for 1 (e # 1), considere o número na frente do acumulador (c N _)e devolva-o. Caso contrário, recorra:

• O novo acumulador é (c S(c N _)): o símbolo e o número consitados na frente do acumulador anterior;
• N e S são iguais;
• Nova contagem é (s # 1): contagem - 1.

O idioma do acumulador é necessário para obter uma recursão adequada da cauda , evitando um erro de profundidade da recursão. (Essa alteração é responsável pela contagem de +8 para bytes. O 13^2caso não funcionou na versão anterior.)

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

Infelizmente, a biblioteca não possui função de exponenciação no momento, portanto, precisamos definir uma. ^leva xe y. Se yfor verdade (diferente de zero), repetimos com y-1( (s y 1)) e multiplicamos o resultado por x. Caso contrário, yé zero e retornamos 1.

(Nota: Essa função não usa recursão de cauda adequada. Suponho que os expoentes serão pequenos o suficiente para que não importem. Algumas experiências com o TIO indicaram um expoente máximo de 325, o que eu argumentaria que deveria ser suficiente para esta pergunta. Se o OP discordar, eu o mudarei.)

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

Finalmente, a função que nos interessa, X, leva Ae Be retorna uma lista de quatro itens:

• (list A(q ^)B): uma lista contendo A, um literal ^e B;
• (W()A(q *)B): ligue Wpara obter uma lista de Bcópias Aentrelaçadas com literal *;
• (W()A(q +)(^ A(s B 1))): ligue Wpara obter uma lista de A^(B-1)cópias Aentrelaçadas com literal +;
• (W()1(q +)(^ A B)): ligue Wpara obter uma lista de A^Bcópias 1entrelaçadas com literal +.

Brainfuck , 372 bytes

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

Experimente online!

Notas

1. As duas entradas devem ser escolhidas de forma a A**Bnão exceder 255. Isso ocorre porque o brainfuck só pode armazenar valores de um byte.
2. Se uma entrada for maior que 9, use o próximo caractere ASCII. 10torna-se :, 11torna-se ;etc. Isso ocorre porque o Brainfuck pode receber apenas entradas de um byte.

Explicação

Aqui está o meu código comentado. Vou expandir isso mais 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

Pitão, 32 31 bytes

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

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

Explicação:

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

Experimente aqui.

Perl , 81 bytes

78 bytes de código + -nsinalizador (contados como 3 bytes desde que o código contenha $').

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

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

Função anônima que gera as saídas necessárias, bem, linha por linha. Esta solução faz uso extensivo da switchfunção.

A switchfunção pega uma expressão (aqui s) que é avaliada como um número ou sequência de caracteres (consulte ?switch), seguida pelas alernativas correspondentes a s. Se uma alternativa estiver ausente (por exemplo switch(s, a=, b= "PPCG"), a próxima alternativa não ausente será avaliada (no exemplo, as s="a"saídas"PPCG" ).

As repfunções repetem (na verdade replicam) seu primeiro argumento o número de vezes indicado no segundo argumento.

cat, para finalizar, concatenar e imprimir os objetos, com um separador que pode ser escolhido com o sep =argumento A segunda catfunção está aqui para a quebra de linha.

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*

Experimente online!

k, 44 bytes

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

Casos de teste.

Cardinal 202 bytes

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

Funcionará apenas para números em que o valor calculado <256 devido a limitações nos valores que podem ser mantidos por ponteiros no Cardinal

Experimente Online

Explicação:

Passo 1

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

Recebe dois números aeb como entrada e saída como "a ^ b ="
Passa um ponteiro com o valor ativo a e o valor inativo b

Passo 2

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

Recebe um ponteiro com valor ativo ae valor inativo b imprimindo "a" + ("* a") (b-1) vezes
Passa um ponteiro com valor ativo a ^ (b-1) para a próxima parte

etapa 3

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

Recebe um ponteiro com o valor de a ^ (b-1) e gera "= a" + ("+ a") repetido (a ^ (b-1) -1) vezes + "="
Passa um ponteiro com o valor a ^ b para a próxima parte

Passo 4

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

Recebe um ponteiro com o valor a ^ b e imprime "1" + ("+ 1") repetido a ^ b-1 vezes

Retina, 89 88 bytes

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

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

:`a

+`11
1+1

A entrada é números unários separados por vírgula.

Experimente online!