Étant donné deux entiers supérieurs à un, A et B, affichez quatre expressions mathématiques dans cet ordre:

1. L'expression simple A ^ B (A à la puissance B). par exemple si A = 2 et B = 3 2^3,.

2. L'expansion de A ^ B en termes de multiplications répétées de A. par exemple 2*2*2.

3. L'expansion de A ^ B en termes d'additions répétées de A. par exemple 2+2+2+2.

4. L'expansion de A ^ B en termes d'additions répétées de 1. par exemple 1+1+1+1+1+1+1+1.

Les quatre expressions peuvent être sorties de n'importe quelle manière raisonnable tant qu'elles sont en ordre et clairement distinctes. Par exemple, vous pouvez les mettre dans une liste ou les imprimer sur des lignes distinctes

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

ou peut-être sur une ligne séparée par des signes égaux:

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

Des espaces peuvent être insérés à côté des opérateurs mathématiques afin

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

serait une sortie également valide lorsque A = 2 et B = 3.

Vous pouvez utiliser d' autres symboles pour ^, *et +, mais seulement si les nouveaux symboles sont plus idiomatiques pour votre langue (par exemple , au **lieu de ^en Python).

Vous pouvez supposer que A et B sont suffisamment petits pour que A ^ B ne déborde pas du type entier par défaut de votre langue (étant donné que ce type a un maximum raisonnable, 255 au moins).

Le code le plus court en octets gagne.

Cas de test

Une sortie par ligne. L'entrée peut être déduite car la première expression est toujours 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 octets

-2 octets grâce à Dada (utiliser ~)
-5 octets grâce à Erwan (utiliser les chaînes f de Python 3.6)

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

en ligne n'importe qui?

Comment?

Il s'agit d'une fonction sans nom prenant les deux entrées entières aet bchacune supérieure à 0(même si la spécification ne concerne que celles supérieures à 1).

Dans Python 3.6, une nouvelle fonctionnalité est disponible, à savoir les chaînes de caractères formatées ou "f-strings". Ceux-ci permettent la construction de chaînes évaluées au moment de l'exécution. Un leader f(ou F) crée une telle construction, par exemple f"blah"ou f'blah'. À l'intérieur d'une chaîne f quelque chose entre une paire d'accolades,, {...}est une expression à évaluer.

En tant que tel f"{a}^{b}={a}{f'*{a}'*~-b}={a}{f'+{a}'*~-a**~-b}=1"évalue chacun a, b, a, f'*{a}'*~-b, a, et f'+{a}'*~-a**~-b}que les expressions, en gardant le ^, =, =et =1sous forme de chaînes, tous qui obtient concaténés.

Les expressions aet bévaluent respectivement les représentations de aet b.

Le f'*{a}'et f'+{a}'à son tour sont également des chaînes f à l'intérieur de ces expressions, qui évaluent respectivement aavec un interligne '*'et un '+'interligne

Pour créer le nombre requis d' aopérations et de s pour les portions *et +notez qu'il y aura des b amultiplications et des a**(b-1) aadditions. Chaque cas nécessite alors un signe opérateur de moins que le nombre de as. Nous pouvons donc répéter les chaînes f f'*{a}et f'+{a}'(en utilisant *) autant de fois qu'il y a d'opérateurs et ajouter chacun un seul a. (b-1)est ~-bet (a**(b-1))-1est ~-a**~-b.

La même chose est faite pour les 1s utilisant l' (a**b)-1être ~-**b, mais nous n'avons pas besoin de la surcharge des chaînes f car 1est constante, donc une chaîne standard répétée est concaténée avec +.

Versions Python antérieures, 81:

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

Essayez-le en ligne!

Cubix, 238 234 217 151 110 100 octets

14 octets enregistrés grâce à ETHProductions

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

Étendu:

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

Essayez-le en ligne!

Essayez-le ici

Explication

Le code se compose de 8 étapes, avec deux boucles. Je vais passer en revue le code partie par partie.

Étape 1 (A ^ B)

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

Il s'agit du cube dont les parties non pertinentes pour la première étape ont été supprimées. Le point d'interrogation indique les non-opérations que l'IP visitera, pour rendre son chemin plus clair.

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)

Maintenant, la pile ressemble à ceci: A, B, A, B

Étape 2 (préparer la boucle d'impression)

La boucle d'impression prend 3 arguments (les 3 premiers éléments de la pile): P, Qet R. Pest le nombre de répétitions, Qle séparateur (code de caractère) et Rle nombre à répéter. Heureusement, la boucle prend également en charge l'exigence que la chaîne résultante se termine R, non Q.

Nous voulons répéter A*exactement les Btemps, donc le séparateur est *. Notez que la pile commence en tant que A, B, A, B. Encore une fois, j'ai supprimé toutes les instructions non pertinentes. L'IP commence au Snord pointé.

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

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

La pile est maintenant A, B, B, *, A.

Étape 3/6/8 (la boucle d'impression)

Concept

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

L'IP entre dans la boucle S, pointant vers le nord, et quitte la boucle vers E, pointant à nouveau vers le nord. Pour cette explication, la pile est définie sur [..., A, B, C]. Les instructions suivantes sont exécutées. Notez que l'IP ne peut pas quitter la boucle avant le point d'interrogation, donc les quatre premières instructions seront toujours exécutées.

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

la mise en oeuvre

Voici à nouveau le cube, avec les parties non pertinentes supprimées. L'IP commence à S, pointant vers l'est.

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

Comme vous pouvez le voir, l'IP passe par quatre instructions avant d'entrer dans la boucle. Puisque le code de caractère est à nouveau supprimé, nous atteignons la boucle avec la même pile exacte que celle que nous avons entrée dans cette partie.

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

À l'intérieur de la boucle, l'explication ci-dessus est valable.

Étape 4 (différenciation des IP)

Étant donné que nous utilisons la boucle ci-dessus plusieurs fois et qu'elles provoquent toutes la fin de l'IP au même endroit, nous devons différencier plusieurs exécutions. Tout d'abord, nous pouvons distinguer le séparateur (la première exécution a un *, tandis que les exécutions deux et trois ont un +séparateur). Nous pouvons différencier les cycles 2 et 3 en vérifiant la valeur du nombre répété. Si tel est le cas, le programme doit se terminer.

Première comparaison

Voici à quoi cela ressemble sur le cube. L'IP commence à S et pointe vers le nord. La pile contient [..., * or +, A or 1, 0]. Le numéro 1 indique où l'IP se terminera s'il s'agit de la première boucle (pointant vers le nord) et le numéro 2 indique où l'IP se terminera s'il s'agit de la deuxième (ou troisième) boucle (pointant vers l'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.

Si l'IP est maintenant à 1, la pile l'est [A, *, +, -1]. Sinon, la pile l'est [A or 1, +, +, 0]. Comme vous pouvez le voir, il y a toujours un inconnu dans la pile du deuxième cas, nous devons donc faire une autre comparaison.

Deuxième comparaison

Parce que la propriété intellectuelle est passée à l' étape 5, les regards de la pile comme ceci: [A^(B-1) or nothing, A or 1, +, +, 0]. Si le premier élément l'est nothing, le deuxième l'est 1, et l'inverse aussi. Le cube ressemble à ceci, avec l'IP commençant à S et pointant vers l'est. S'il s'agit de la deuxième boucle, l'IP finit par Epointer vers l'ouest. Sinon, le programme frappe le @et se termine.

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

Les instructions exécutées qui ne font rien au flux de contrôle sont répertoriées ci-dessous.

;;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 pile est maintenant [A^B, +, A^(B-1), A-1], à condition que le programme ne se soit pas terminé.

Étape 5 (préparation de "A +" (répétez A ^ (B-1)))

Malheureusement, Cubix n'a pas d'opérateur électrique, nous avons donc besoin d'une autre boucle. Cependant, nous devons d'abord nettoyer la pile, qui contient maintenant [B, A, *, +, -1].

Nettoyer

Voici à nouveau le cube. Comme d'habitude, l'IP commence à S (pointant vers le nord) et se termine à E, pointant vers l'ouest.

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

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

Calcul de A ^ (B-1)

Une autre boucle qui fonctionne à peu près comme la boucle d'impression, mais elle est un peu plus compacte. L'IP commence à S, pointant vers l'ouest, avec la pile [B, A, *]. L'IP sort en Epointant vers le nord.

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

Le corps de la boucle est le suivant.

;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 pile résultante est [A, A^(B-1), 0].

Nettoyage de la pile (à nouveau)

Maintenant, nous devons revenir à la boucle d'impression, avec le haut de la pile contenant [..., A^(B-1), +, A]. Pour ce faire, nous exécutons ce qui suit. Voici à nouveau le cube,

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

Étape 7 (préparation de la dernière boucle)

La pile est maintenant [A^B, +, A^(B-1), A-1], l'IP commence à S, va vers l'ouest et se termine à E, va à droite.

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

Les instructions exécutées:

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

La pile ressemble maintenant [A^B, +, 1], et l'IP est sur le point d'entrer dans la boucle d'impression, nous avons donc terminé.

MATL , 46 octets

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

Essayez-le en ligne!

Allonger les limites de la "voie raisonnable" ici, mais les expressions sont séparées.

Explication

Première expression:

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

Deuxième expression:

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

Troisième expression:

&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

Quatrième expression:

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

Prend des entrées dans la syntaxe de currying (a)(b). Génère une chaîne.

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

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

Rubis, 52 octets

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

05AB1E , 30 octets

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

Explication:

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

Essayez-le en ligne!

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 octets si nous pouvons ignorer 0 puissances; y=!!ipourrait deveniry=1

Essayez-le en ligne!

Java 7, 170 octets

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

Code de test:

Essayez ici.

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

Sortie:

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 octets

33 octets de code, +1 pour l' -nindicateur.

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

Prend A et B comme arguments de ligne de commande; imprime une expression par ligne. Essayez-le en ligne!

Explication

Ya**best le code de configuration: yank a**bdans la yvariable. Après cela, nous avons une liste (en []) contenant nos quatre expressions:

• gJ'^: prendre la gliste complète des ar (ici, une liste contenant aet b) et Jcontinuer sur^
• aRLbJ'*: Utilisation REPEAT List pour créer une liste avec des bcopies de a, puis JOIN sur*
• aRLy/aJ'+: Utiliser RLpour créer une liste y/a( par exemple a**(b-1)) des copies de a, puis JOIN sur+
• 1XyJ'+: 1, chaîne multipliée par y, Jhuilée sur+

La liste est imprimée avec une nouvelle ligne comme séparateur grâce au -ndrapeau.

Javascript 115 113 104 octets

Merci à @Neil et @TuukkaX pour avoir joué un octet chacun et @ETHproductions et Luke pour avoir joué au golf 9 octets

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

Essayez-le en ligne

Gelée , 29 octets

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

Essayez-le en ligne!

Comment?

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

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

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

tinylisp repl , 178 186 octets

(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'utilisation de la repl enregistre 8 octets entre parenthèses de fermeture implicites à la fin des lignes. Définit une fonction Xqui prend deux nombres et renvoie une liste d'expressions. Chaque expression est entre parenthèses, avec des espaces autour des opérateurs (en fait, c'est une liste de nombres et de symboles d'opérateurs):

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

Espérons que ce format de sortie soit acceptable. Essayez-le en ligne! (avec plusieurs cas de test).

Explication

(load library)

Nous avons besoin de deux fonctions de la bibliothèque standard: listet *.

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

Définissez une fonction W(abréviation de "tissage") qui prend un accumulateur _, un nombre N, un symbole Set un comptage #. Nous utiliserons cette fonction pour générer la plupart de nos expressions: par exemple, (W () 2 (q +) 3)entraînera (2 + 2 + 2).

Si le décompte est de 1 (e # 1), alors contre le nombre à l'avant de l'accumulateur (c N _)et retournez-le. Sinon, récusez:

• Le nouvel accumulateur est (c S(c N _)): le symbole et le numéro cons au devant de l'accumulateur précédent;
• Net Ssont les mêmes;
• Le nouveau décompte est (s # 1): décompte - 1.

L'idiome de l'accumulateur est nécessaire pour obtenir une récursion de queue appropriée , empêchant une erreur de profondeur de récursivité. (Ce changement est responsable du +8 au nombre d'octets. Le 13^2cas ne fonctionnait pas dans la version précédente.)

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

Malheureusement, la bibliothèque n'a pas de fonction d'exponentiation pour le moment, nous devons donc en définir une. ^prend xet y. Si yest véridique (non nul), nous récursions avec y-1( (s y 1)) et multiplions le résultat par x. Sinon, yc'est zéro et on revient 1.

(Remarque: Cette fonction n'utilise pas la récursion de queue appropriée. Je suppose que les exposants seront suffisamment petits pour que cela n'ait pas d' importance. Certaines expériences sur TIO ont indiqué un exposant maximum de 325, ce qui, à mon avis, devrait être suffisant pour cette question. Si le PO n'est pas d'accord, je le changerai.)

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

Enfin, la fonction qui nous intéresse, X, prend Aet Bet retourne une liste de quatre éléments:

• (list A(q ^)B): une liste contenant A, un littéral ^, et B;
• (W()A(q *)B): appelez Wpour obtenir une liste d' Bexemplaires de A, entrelacés avec littéral *;
• (W()A(q +)(^ A(s B 1))): appelez Wpour obtenir une liste d' A^(B-1)exemplaires de A, entrelacés avec littéral +;
• (W()1(q +)(^ A B)): appelez Wpour obtenir une liste d' A^Bexemplaires de 1, entrelacés avec littéral +.

Brainfuck , 372 octets

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

Essayez-le en ligne!

Remarques

1. Les deux entrées doivent être choisies de manière à A**Bne pas dépasser 255. En effet, brainfuck ne peut stocker que des valeurs d'un octet.
2. Si une entrée est supérieure à 9, utilisez le caractère ASCII suivant. 10devient :, 11devient ;etc. C'est parce que Brainfuck ne peut accepter que des entrées d'un octet.

Explication

Voici mon code quelque peu commenté. Je développerai cela plus tard.

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

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

Prend l'entrée comme [2,10], les sorties comme["2^10", "2*2*2*2*2*2*2*2*2*2", "2+2+...

Explication:

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

Essayez ici.

Perl , 81 octets

78 octets de code + -nindicateur (compté comme 3 octets puisque le code contient $').

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

Essayez-le en ligne!

R, 147 octets

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

Fonction anonyme qui produit les sorties requises, eh bien, ligne par ligne. Cette solution utilise largement la switchfonction.

La switchfonction prend une expression (ici s) qui correspond à un nombre ou à une chaîne de caractères (voir ?switch), suivie des alternatives correspondant à s. Si une alternative est manquante (par exemple switch(s, a=, b= "PPCG"), la prochaine alternative non manquante est évaluée (dans l'exemple, les s="a"sorties "PPCG").

La repfonction répète (réplique, en fait) son premier argument le nombre de fois indiqué dans le second argument.

cat, pour terminer, concaténer et imprimer les objets, avec un séparateur qui peut être choisi avec l' sep =argument. La deuxième catfonction est ici pour le saut de ligne.

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 octets

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

Essayez-le en ligne!

k, 44 octets

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

Cas de test.

Cardinal 202 octets

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

Ne fonctionnera que pour les nombres dont la valeur calculée <256 en raison des limitations des valeurs pouvant être détenues par des pointeurs dans Cardinal

Essayez-le en ligne

Explication:

Étape 1

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

Reçoit deux nombres a et b en entrée et sort comme "a ^ b ="
Passe un pointeur avec la valeur active a et la valeur inactive b

Étape 2

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

Reçoit un pointeur avec une valeur active a et une valeur inactive b imprimant "a" + ("* a") (b-1) fois
Passe un pointeur avec une valeur active a ^ (b-1) à la partie suivante

Étape 3

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

Reçoit un pointeur avec une valeur de ^ (b-1) et sort "= a" + ("+ a") répété (a ^ (b-1) -1) fois + "="
Passe un pointeur de valeur a ^ b à la partie suivante

Étape 4

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

Reçoit un pointeur avec la valeur a ^ b et imprime "1" + ("+ 1") répété a ^ b-1 fois

Rétine, 89 88 octets

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

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

:`a

+`11
1+1

L'entrée est un nombre unaire séparé par des virgules.

Essayez-le en ligne!