Dati due numeri interi maggiori di uno, A e B, emettono quattro espressioni matematiche in questo ordine:

1. La semplice espressione A ^ B (A alla potenza B). ad esempio se A = B = 2 e 3, 2^3.

2. L'espansione di A ^ B in termini di ripetute moltiplicazioni di A. es 2*2*2.

3. L'espansione di A ^ B in termini di aggiunte ripetute di A. es 2+2+2+2.

4. L'espansione di A ^ B in termini di aggiunte ripetute di 1. ad es 1+1+1+1+1+1+1+1.

Le quattro espressioni possono essere emesse in modo ragionevole purché siano in ordine e chiaramente distinte. Ad esempio, è possibile inserirli in un elenco o stamparli su righe separate

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

o forse su una riga separata da segni di uguale:

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

Gli spazi possono essere inseriti accanto agli operatori matematici

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

sarebbe ugualmente valido se A = 2 e B = 3.

È possibile utilizzare simboli alternativi a ^, *e +, ma solo se i nuovi simboli sono più idiomatico per la lingua (ad esempio, **invece che ^in Python).

Puoi presumere che A e B siano sufficientemente piccoli in modo che A ^ B non trabocchi del tipo intero predefinito della tua lingua (dato che quel tipo ha un massimo ragionevole, almeno 255).

Vince il codice più breve in byte.

Casi test

Un output per riga. L'input può essere dedotto poiché la prima espressione è 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 byte

-2 byte grazie a Dada (usa ~)
-5 byte grazie a Erwan (usa le stringhe f di Python 3.6)

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

online qualcuno?

Come?

Questa è una funzione senza nome che accetta i due input interi ae bciascuno maggiore di 0(anche se la specifica è solo per quelli maggiori di 1).

In Python 3.6 è disponibile una nuova funzionalità, vale a dire letterali di stringa formattati o "f-string". Ciò consente la costruzione di stringhe valutate in fase di esecuzione. Un leader f(o F) crea un tale costrutto, ad esempio, f"blah"o f'blah'. All'interno di una stringa F qualsiasi cosa tra una coppia di parentesi graffe {...}, è un'espressione da valutare.

Come tale f"{a}^{b}={a}{f'*{a}'*~-b}={a}{f'+{a}'*~-a**~-b}=1"valuta ogni di a, b, a, f'*{a}'*~-b, a, e f'+{a}'*~-a**~-b}come espressioni, mantenendo il ^, =, =, e =1come stringhe, ognuno dei quali viene concatenati tra loro.

Le espressioni ae bvalutano rispettivamente le rappresentazioni di ae b.

La f'*{a}'e f'+{a}', a sua volta sono anche f-stringhe all'interno queste espressioni che restituiscono acon un primario '*'e leader '+'rispettivamente

Per creare il numero richiesto di se aoperazioni per le porzioni *e, +tenere presente che verranno b amoltiplicati insieme e a**(b-1) aaggiunti insieme. Ogni caso richiede quindi un segno di operatore in meno rispetto al numero di as. Quindi possiamo ripetere le f-string f'*{a}e f'+{a}'(usare *) tutte le volte che ci sono operatori e anteporre ciascuno con un singolo a. (b-1)è ~-bed (a**(b-1))-1è ~-a**~-b.

Lo stesso viene fatto per l' essere 1usando s , ma non abbiamo bisogno dell'overhead delle stringhe f poiché è costante, quindi viene concatenata una stringa standard ripetuta .(a**b)-1~-**b1+

Versioni precedenti di Python, 81:

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

Provalo online!

Cubix, 238 234 217 151 110 100 byte

Risparmiato 14 byte grazie a ETHProductions

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

Allargato:

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

Provalo online!

Provalo qui

Spiegazione

Il codice è composto da 8 passaggi, con due loop. Esaminerò il codice parte per parte.

Passaggio 1 (A ^ B)

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

Questo è il cubo con le parti che sono irrilevanti per il primo passo rimosso. Il punto interrogativo mostra le no-op che l'IP visiterà, per rendere più chiaro il suo percorso.

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)

Ora, lo stack è simile al seguente: A, B, A, B

Passaggio 2 (preparare il ciclo di stampa)

Il ciclo di stampa prende 3 argomenti (i primi 3 elementi nello stack): P, Qe R. Pè la quantità di ripetizioni, Qè il separatore (codice carattere) ed Rè il numero da ripetere. Fortunatamente, il loop si occupa anche del requisito in cui la stringa risultante dovrebbe finire R, no Q.

Vogliamo ripetere A*esattamente i Btempi, quindi è il separatore *. Si noti che lo stack inizia come A, B, A, B. Ancora una volta, ho rimosso tutte le istruzioni irrilevanti. L'IP inizia Spuntando verso nord.

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

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

Lo stack è ora A, B, B, *, A.

Passaggio 3/6/8 (il ciclo di stampa)

Concetto

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

L'IP entra nel loop attraverso S, puntando verso nord, ed esce dal loop verso E, puntando di nuovo verso nord. Per questa spiegazione, lo stack è impostato su [..., A, B, C]. Vengono eseguite le seguenti istruzioni. Nota che l'IP non può lasciare il ciclo prima del punto interrogativo, quindi le prime quattro istruzioni verranno sempre eseguite.

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

Implementazione

Ecco di nuovo il cubo, con le parti irrilevanti rimosse. L'IP inizia da S, puntando verso est.

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

Come puoi vedere, l'IP arriva attraverso quattro istruzioni prima di entrare nel ciclo. Poiché il codice carattere viene nuovamente rimosso, raggiungiamo il loop con lo stesso stack esatto in cui abbiamo inserito questa parte.

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

All'interno del ciclo, la spiegazione sopra vale.

Passaggio 4 (differenziazione degli IP)

Dato che utilizziamo il loop sopra più volte e tutti fanno sì che l'IP finisca nello stesso punto, dobbiamo differenziare tra più esecuzioni. Innanzitutto, possiamo distinguere tra il separatore (la prima esecuzione ha a *, mentre le corse due e tre hanno un +separatore). Possiamo distinguere tra le esecuzioni 2 e 3 controllando il valore del numero che si ripete. Se quello è uno, il programma dovrebbe terminare.

Primo confronto

Ecco come appare sul cubo. L'IP inizia da S e punta a nord. La pila contiene [..., * or +, A or 1, 0]. Il numero 1 mostra dove finirà l'IP se questo è il primo loop (che punta a nord) e il numero 2 mostra dove finirà l'IP se questo è il secondo (o terzo) loop (che punta ad est).

          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 l'IP è ora 1, lo stack è [A, *, +, -1]. Altrimenti, lo stack è [A or 1, +, +, 0]. Come puoi vedere, c'è ancora uno sconosciuto nello stack del secondo caso, quindi dobbiamo fare un altro confronto.

Secondo confronto

Poiché l'IP ha attraversato il passaggio 5, gli sguardi di stack come questo: [A^(B-1) or nothing, A or 1, +, +, 0]. Se il primo elemento è nothing, il secondo è 1e anche il contrario. Il cubo si presenta così, con l'IP che inizia da S e punta verso est. Se questo è il secondo loop, l'IP finisce in E, puntando verso ovest. Altrimenti, il programma colpisce @e termina.

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

Le istruzioni eseguite che non fanno nulla al flusso di controllo sono elencate di seguito.

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

Lo stack è ora [A^B, +, A^(B-1), A-1], a condizione che il programma non sia terminato.

Passaggio 5 (preparazione per "A +" (ripetere A ^ (B-1)))

Purtroppo, Cubix non ha un operatore di potenza, quindi abbiamo bisogno di un altro loop. Tuttavia, dobbiamo prima pulire lo stack, che ora contiene [B, A, *, +, -1].

Pulire

Ecco di nuovo il cubo. Come al solito, l'IP inizia da S (che punta a nord) e termina a E, che punta a ovest.

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

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

Calcolo di A ^ (B-1)

Un altro loop che funziona più o meno come il loop di stampa, ma è un po 'più compatto. L'IP inizia da S, puntando verso ovest, con stack [B, A, *]. L'IP esce Eindicando il nord.

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

Il corpo del loop è il seguente.

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

Lo stack risultante è [A, A^(B-1), 0].

Pulire la pila (di nuovo)

Ora dobbiamo tornare al ciclo di stampa, con la parte superiore della pila contenente [..., A^(B-1), +, A]. Per fare ciò, eseguiamo quanto segue. Ecco di nuovo il cubo,

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

Passaggio 7 (preparazione per l'ultimo loop)

Lo stack è ora [A^B, +, A^(B-1), A-1], l'IP inizia a S, andando verso ovest, e finisce a E, andando a destra.

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

Le istruzioni eseguite:

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

Lo stack ora appare [A^B, +, 1]e l'IP sta per entrare nel ciclo di stampa, quindi abbiamo finito.

MATL , 46 byte

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

Provalo online!

Allungando qui i limiti del "modo ragionevole", ma le espressioni sono separate.

Spiegazione

Prima espressione:

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

Seconda espressione:

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

Terza espressione:

&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 espressione:

&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

Accetta input nella sintassi del curry (a)(b). Emette una stringa.

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

Casi test

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

Rubino, 52 byte

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

05AB1E , 30 byte

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

Spiegazione:

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

Provalo online!

C (gcc) , 156 149 byte

#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 byte se possiamo ignorare 0 poteri; y=!!ipuò diventarey=1

Provalo online!

Java 7, 170 byte

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

Codice di prova:

Provalo qui.

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

Produzione:

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 byte

33 byte di codice, +1 per la -nbandiera.

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

Prende A e B come argomenti della riga di comando; stampa un'espressione per riga. Provalo online!

Spiegazione

Ya**bè il codice di installazione: yank a**bnella yvariabile. Successivamente, abbiamo un elenco (in []) contenente le nostre quattro espressioni:

• gJ'^: prendi la glista completa ar (qui, una lista contenente ae b) e Join su di essa^
• aRLbJ'*: usa Repeat List per creare un elenco con bcopie di a, quindi Jattivalo*
• aRLy/aJ'+: usare RLper creare un elenco con y/a(es. a**(b-1)) copie di a, quindi Jaccenderlo+
• 1XyJ'+: 1, moltiplicato per stringa y, Joined su+

L'elenco viene stampato con newline come separatore grazie alla -nbandiera.

Javascript 115 113 104 byte

Grazie a @Neil e @TuukkaX per giocare a golf a un byte ciascuno e @ETHproductions e Luke per giocare a golf a 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)]

Provalo online

Gelatina , 29 byte

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

Provalo online!

Come?

*⁹’,¤;@ - 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 sostitu , 178 186 byte

(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

L'uso di repl consente di salvare 8 byte tra parentesi chiuse implicite alle estremità delle righe. Definisce una funzione Xche accetta due numeri e restituisce un elenco di espressioni. Ogni espressione è tra parentesi, con spazi attorno agli operatori (in realtà, è un elenco di numeri e simboli operatore):

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

Speriamo che questo formato di output sia accettabile. Provalo online! (con diversi casi di test).

Spiegazione

(load library)

Abbiamo bisogno di due funzioni dalla libreria standard: liste *.

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

Definire una funzione W(abbreviazione di "trama") che accetta un accumulatore _, un numero N, un simbolo Se un conteggio #. Useremo questa funzione per generare la maggior parte delle nostre espressioni: ad esempio, (W () 2 (q +) 3)si tradurrà in (2 + 2 + 2).

Se il conteggio è 1 (e # 1), cons contro il numero nella parte anteriore dell'accumulatore (c N _)e restituirlo. Altrimenti, ricorrere:

• Il nuovo accumulatore è (c S(c N _)): il simbolo e il numero consegnato alla parte anteriore dell'accumulatore precedente;
• Ne Ssono uguali;
• Il nuovo conteggio è (s # 1): conteggio - 1.

Il linguaggio dell'accumulatore è necessario per ottenere una corretta ricorsione della coda , prevenendo un errore di profondità della ricorsione. (Questa modifica è responsabile del +8 al conteggio dei byte. Il 13^2caso non ha funzionato nella versione precedente.)

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

Sfortunatamente, la libreria non ha attualmente alcuna funzione di esponenziazione, quindi dobbiamo definirne una. ^prende xe y. Se yè verità (diverso da zero), ricerchiamo con y-1( (s y 1)) e moltiplichiamo il risultato per x. Altrimenti, yè zero e torniamo 1.

(Nota: questa funzione non utilizza la ricorsione della coda corretta. Presumo che gli esponenti saranno abbastanza piccoli da non importare. Alcuni esperimenti su TIO hanno indicato un esponente massimo di 325, che direi dovrebbe essere sufficiente per questa domanda. Se l'OP non è d'accordo, lo cambierò.)

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

Infine, la funzione che ci interessa, X, prende Ae Be restituisce una lista di quattro elementi:

• (list A(q ^)B): un elenco contenente A, un letterale ^e B;
• (W()A(q *)B): chiama Wper ottenere un elenco di Bcopie A, intrecciate con letterale *;
• (W()A(q +)(^ A(s B 1))): chiama Wper ottenere un elenco di A^(B-1)copie A, intrecciate con letterale +;
• (W()1(q +)(^ A B)): chiama Wper ottenere un elenco di A^Bcopie 1, intrecciate con letterale +.

Brainfuck , 372 byte

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

Provalo online!

Gli appunti

1. I due ingressi devono essere scelti in modo tale da A**Bnon superare 255. Questo perché brainfuck può memorizzare solo valori di un byte.
2. Se un input è maggiore di 9, utilizzare il carattere ASCII successivo. 10diventa :, 11diventa ;ecc. Questo perché Brainfuck può accettare solo input di un byte.

Spiegazione

Ecco il mio codice in qualche modo commentato. Espanderò su questo più tardi.

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

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

Accetta input as [2,10], output as["2^10", "2*2*2*2*2*2*2*2*2*2", "2+2+...

Spiegazione:

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

Provalo qui.

Perl , 81 byte

78 byte di codice + -nflag (contati come 3 byte poiché il codice contiene $').

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

Provalo online!

R, 147 byte

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

Funzione anonima che genera output richiesti, bene, riga per riga. Questa soluzione fa ampio uso della switchfunzione.

La switchfunzione accetta un'espressione (qui, s) che restituisce un numero o una stringa di caratteri (vedi ?switch), seguita dagli alernativi corrispondenti a s. Se manca un'alternativa (ad esempio switch(s, a=, b= "PPCG"), viene valutata la successiva alternativa non mancante (nell'esempio, s="a"output "PPCG").

Le repfunzioni ripete (replica, in realtà) il suo primo argomento il numero di volte indicato nel secondo argomento.

cat, per finire, concatenare e stampare gli oggetti, con un separatore che può essere scelto con il sep = argomento. La seconda catfunzione è qui per l'interruzione di linea.

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 byte

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

Provalo online!

k, 44 byte

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

Casi test.

Cardinale 202 byte

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

Funzionerà solo per numeri in cui il valore calcolato <256 a causa di limitazioni nei valori che possono essere mantenuti dai puntatori in Cardinal

Provalo online

Spiegazione:

Passo 1

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

Riceve due numeri a e b come input e genera come "a ^ b ="
Passa un puntatore con valore attivo a e valore inattivo b

Passo 2

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

Riceve un puntatore con valore attivo a e valore inattivo b stampando "a" + ("* a") (b-1) volte
Passa un puntatore con valore attivo a ^ (b-1) alla parte successiva

Passaggio 3

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

Riceve un puntatore con valore di a ^ (b-1) e genera "= a" + ("+ a") ripetuto (a ^ (b-1) -1) volte + "="
Passa un puntatore con valore a ^ b alla parte successiva

Passaggio 4

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

Riceve un puntatore con valore a ^ b e stampa "1" + ("+ 1") ripetuto a ^ b-1 volte

Retina, 89 88 byte

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

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

:`a

+`11
1+1

L'input è composto da numeri unari separati da virgola.

Provalo online!