Ce défi est basé sur cette question Stackoverflow .

Avec un nombre positif en entrée, sortez-le comme la somme de chaque chiffre multiplié par sa représentation de puissance de 10.

Contribution

Un nombre, sous forme d'entier, une chaîne ou une liste de chiffres / caractères.

• Le nombre sera strictement positif.
• Si vous acceptez le nombre sous forme de chaîne ou de liste, il ne commencera pas par un 0.

Sortie

Une chaîne représentant une somme de chacun des chiffres de base 10 pertinents, chacun multiplié par sa puissance de base 10 respective. Une somme est représentée par a + b. Vous pouvez utiliser jusqu'à un espace autour de chaque côté du +panneau si vous le souhaitez. Les opérandes sont répertoriés par ordre décroissant.

• 0 ne peut jamais être un opérande valide.
• Le +signe (entouré ou non d'espaces) peut ne pas être la partie avant ou arrière.

Exemples

Input       Output
12          10 + 2
         or 10+2
         or 10 +2
         or 10+ 2
9           9
123         100 + 20 + 3
10          10
101         100 + 1

Sorties invalides

2           1 + 1
10          10 + 0
1           0 + 1
12          + 10 + 2
12          10 + 2 +
12          2 + 10

C'est du code-golf donc le code le plus court en octets gagne!

Python 3: 83 80 79 octets

Essayez-le en ligne!

Ma première soumission Code Golf.

t=input();x=len(t);print(*[t[i]+'0'*(x+~i)for i in range(x)if'0'<t[i]],sep='+')

-3 octets par ovs. Merci pour cette astuce utile :) -4 octets par mypetlion. Merci pour cette astuce de raccourcissement :)

Gelée , 9 octets

ḊƬḌQIAj”+

Essayez-le en ligne!

Comment ça marche

ḊƬḌQIAj”+  Main link. Argument: A (digit array)

 Ƭ         Til; apply the link to the left until the results are no longer unique.
           Return all unique results.
Ḋ              Dequeue; discard the first element.
           For input [1,2,0,4], this yields [[1,2,0,4], [2,0,4], [0,4], [4], []].
  Ḍ        Undecimal; convert the digit arrays into integers.
           For input [1,2,0,4], this yields [1204, 204, 4, 4, 0].
   Q       Unique; deduplicate the resulting integers.
           For input [1,2,0,4], this yields [1204, 204, 4, 0].
    I      Increments; yield the forward differences.
           For input [1,2,0,4], this yields [-1000, -200, -4].
     A     Absolute value.
      j”+  Join with separator '+'.

JavaScript (ES6), 47 octets

Prend l'entrée comme un entier.

f=(n,m=1,k=n%m)=>n-k?f(n-k,m*10)+(k?'+'+k:''):n

Essayez-le en ligne!

Commenté

f = (                     // f is a recursive function taking:
  n,                      //   n = number to process
  m = 1,                  //   m = modulo (a power of 10, starting at 1)
  k = n % m               //   k = n mod m
) =>                      //
  n - k ?                 // if n is not equal to k:
    f(n - k, m * 10)      //   do a recursive call with n - k and m * 10
    + (k ? '+' + k : '')  //   if k is not zero: append '+' and k
  :                       // else:
    n                     //   append n and stop recursion

R , 55 octets

En supposant que les entiers sont tous inférieurs à 1e10, ce qui est de toute façon supérieur à l'entier 32 bits maximum ...

function(n,p=10^(9:0),x=p*n%/%p%%10)cat(x[!!x],sep='+')

Essayez-le en ligne!

Langage de programmation Shakespeare , 807 806 805 804 octets

,.Ajax,.Ford,.Page,.Act I:.Scene I:.[Enter Ajax and Ford]Ford:Listen tothy!Scene V:.Ajax:Remember the remainder of the quotient between I twice the sum of a cat a big big cat.You be the sum of you a cat.Ford:You be the quotient between you twice the sum of a cat a big big cat.Be you nicer zero?If solet usScene V.You be I.Scene X:.Ajax:Recall.Be you worse a cat?If solet usScene D.[Exit Ford][Enter Page]Ajax:Be you nicer zero?If sospeak thy.You be the sum of a big big big big cat the cube of the sum of a cat a big cat.[Exit Page][Enter Ford]Ajax:Open heart.Remember I.You zero.Scene L:.Ajax:Am I nicer a cat?If notlet usScene C.Open heart.Ford:You be the sum of you a pig.Let usScene L.Scene C:.Ajax:Recall.Ford:You be I.Scene D:.Ford:You be the sum of you a pig.Be you nicer zero?If solet usScene X.

Essayez-le en ligne!

-23 octets si un caractère nul peut être sorti en premier

,.Ajax,.Ford,.Page,.Act I:.Scene I:.[Enter Ajax and Ford]Ford:Listen tothy!Scene V:.Ajax:Remember the remainder of the quotient between I twice the sum of a cat a big big cat.You be the sum of you a cat.Ford:You be the quotient between you twice the sum of a cat a big big cat.Be you nicer zero?If solet usScene V.You be I.Scene X:.Ajax:Recall.Be you worse a cat?If solet usScene D.[Exit Ford][Enter Page]Ajax:Speak thy.You be the sum of a big big big big cat the cube of the sum of a cat a big cat.[Exit Page][Enter Ford]Ajax:Open heart.Remember me.You zero.Scene L:.Ajax:Am I nicer a cat?If notlet usScene C.Open heart.Ford:You be the sum of you a pig.Let usScene L.Scene C:.Ajax:Recall.Ford:You be I.Scene D:.Ford:You be the sum of you a pig.Be you nicer zero?If solet usScene X.

Explication

,.Ajax,.Ford,.Page,.Act I:.Scene I:.[Enter Ajax and Ford]

    Boilerplate, introducing the characters.

Ford:Listen tothy!

    Input a value to Ajax.

Scene V:.Ajax:Remember the remainder of the quotient between I twice the sum of a cat a big big cat.You be the sum of you a cat.Ford:You be the quotient between you twice the sum of a cat a big big cat.Be you nicer zero?If solet usScene V.

    Push the digits of Ajax onto Ford's stack, and set Ford's value to be the number of digits in Ajax.

You be I.

    Store the number of digits in the input to Ajax.

Scene X:.Ajax:Recall.Be you worse a cat?If solet usScene D.

    Pop the next digit off the stack, and skip processing it if it equals 0.

[Exit Ford][Enter Page]Ajax:Be you nicer zero?If sospeak thy.You be the sum of a big big big big cat the cube of the sum of a cat a big cat.[Exit Page][Enter Ford]

    All characters start out with a value of 0.
    If Page is 0, that means this is the first number being processed, and we shouldn't output a plus.
    In either case, store the ASCII value of "+" to Page to output next time it is needed.

Ajax:Open heart.Remember I.You zero.

    Output the digit, save the remaining-digit-count for later, and store 0 to Ford for output purposes.

Scene L:.Ajax:Am I nicer a cat?If notlet usScene C.Open heart.Ford:You be the sum of you a pig.Let usScene L.

    Output one fewer 0 than the number of remaining digits to process.

Scene C:.Ajax:Recall.Ford:You be I.

    Store the remaining-digit-count back into Ajax.

Scene D:.Ford:You be the sum of you a pig.Be you nicer zero?If solet usScene X.

    Subtract 1 from the remaining-digit-count, and loop back until there are no more digits left to process.

Python 2 , 64 octets

f=lambda s='',*x:s and(s>'0')*(s+'0'*len(x)+(f(*x)and'+'))+f(*x)

Essayez-le en ligne!

Python 2 , 66 octets

f=lambda n,m=1:n>10and f(n/10,m*10)+(n%10>0)*('+'+`n%10*m`)or`n*m`

Essayez-le en ligne!

Gelée ,  12  11 octets

J’⁵*Ṛ×ḟ0j”+

Un programme complet acceptant le numéro comme une liste de chiffres (au format Python) qui imprime le résultat.

Essayez-le en ligne!

Comment?

J’⁵*Ṛ×ḟ0j”+ - Main Link: list of digits  e.g. [1,0,2,0,3,0]
J           - range of length                 [1,2,3,4,5,6]
 ’          - decrement (vectorises)          [0,1,2,3,4,5]
  ⁵         - literal 10                      10
   *        - exponentiate (vectorises)       [1,10,100,1000,10000,100000]
    Ṛ       - reverse                         [100000,10000,1000,100,10,1]
     ×      - multiply (vectorises)           [100000,0,2000,0,30,0]
      ḟ0    - filter discard zeros            [100000,2000,30]
        j”+ - join with '+'                   [100000,'+',2000,'+',30]
            - implicit (smashing) print       "100000+2000+30"

Précédent @ 12 octets:

Ḣ;0€ƊÐƤẸƇj”+

Haskell, 60 54 octets

Edit: -6 octets grâce à Delfad0r.

tail.(>>=('+':)).filter(>="1").scanr((.('0'<$)).(:))""

Prend le numéro d'entrée sous forme de chaîne.

Essayez-le en ligne!

    scanr(        )""    -- starting with the empty string fold from the right and
                         -- collect the intermediate results in a list
      (.('0'<$)).(:)     -- non pointfree: \d s -> d : ('0'<$s)
                         -- i.e. take the next digit 'd' and append the current result
                         -- from the scanr where each char is replaced by 0
                         --
                         -- e.g. "103" -> ["100","00","3"]
                         --
  f ilter(>="1")         -- keep only elements that have not a 0 as the first char
 (>>=('+':))             -- prepend a + to each element and flatten into
                         -- a single list
tail                     -- drop the first char, ie.e the leading +

05AB1E , 10 octets

Mise en œuvre simple.
Saisie sous forme de liste de chiffres.

āR<°*0K'+ý

Essayez-le en ligne!

Explication

    *        # multiply each digits in the input with
āR<°         # 10^(len(input)-1-index)
     0K      # remove results that are zero
       '+ý   # merge on "+"

Python 2 , 64 octets

lambda n:'+'.join(`b`+~e*'0'for e,b in enumerate(n,-len(n))if b)

Une fonction sans nom qui prend une liste de chiffres net retourne une chaîne.

Essayez-le en ligne!

enumerate(n)donnerait des tuples de index, itemtravers navec un index commençant à 0.

Cependant enumerateprend également un indice de départ en option comme second argument, en mettant cela -len(n)nous obtenons des indices ( es) de -len(n), -len(n)+1, ..., -1.

Cela signifie que le nombre de zéros de suivi requis pour tout élément ( b) est -1-e, qui est ~edonc ~e*'0'obtient les zéros nécessaires.

`b`obtient une représentation sous forme de chaîne du chiffre entier bet +concatène cela avec ces zéros.

if bfiltre les entrées avec b==0.

'+'.join(...)joint ensuite les chaînes résultantes avec des +caractères.

Python 2, 82 73 71 octets

-9 octets grâce à @ovs

-2 octets grâce à @JonathanAllan

lambda n:'+'.join(v+'0'*(len(`n`)-i)for i,v in enumerate(`n`,1)if'0'<v)

Essayez-le en ligne

Haskell , 56 55 52 octets

-4 octets grâce à nimi .

tail.f
f('0':x)=f x
f(d:x)='+':d:('0'<$x)++f x
f x=x

Essayez-le en ligne!

explication

g :: String -> String

-- drop the first char (the leading +) from f
g = tail.f

f :: String -> String

-- if the first digit is 0, continue with the rest of the number
f ( '0' :rest) = f rest

-- otherwise, add a +, the digit and as many 0s as there are digit in the rest.
f (digit:rest) = '+' : digit : ('0' <$ rest) ++ f rest

-- if there is no digit left, return the empty string
f "" = ""

Essayez-le en ligne!

Perl 6 , 38 octets

{join '+',grep +*,($_ Z~[R,] 0 Xx^$_)}

Essayez-le en ligne!

Bloc de code anonyme qui prend une liste de chiffres et renvoie une chaîne.

Explication:

{                                    }  # Anonymous code block
                   $_ Z~   # Zip concatenate the list of digits with
                        [R,] 0 Xx^$_   # The correct number of 0s

          grep +*,(                 )  # Filter out all all the 0 values
 join '+',   # And join with '+'s

APL (Dyalog), 46 41 40 octets

{¯1↓∊{'0'=⊃⍵:⍬⋄⍵}¨⍵,¨('0'⍴⍨¨⌽⍳≢⍵),¨'+'}

-5 octets grâce à @dzaima

Fonction de préfixe anonyme. Prend l'entrée sous forme de chaîne. TIO

(C'est ma première utilisation d'APL sur PPCG, probablement jouable au golf. Aussi, maudissez-vous, zéros!)

Rétine , 19 octets

|'+L$`[1-9]
$&$.'*0

Essayez-le en ligne! Le lien inclut des cas de test. Explication:

L`[1-9]

Liste tous les chiffres non nuls

$
$&$.'*0

Pour chaque chiffre, ajoutez autant de zéros qu'il y avait de chiffres de fin.

|'+

Séparez chaque résultat par +s au lieu de la nouvelle ligne par défaut.

Retina 0.8.2 , 21 octets

M&!`[1-9].*
\B.
0
¶
+

Essayez-le en ligne! Le lien inclut des cas de test. Explication:

M&!`[1-9].*

Liste tous les suffixes de l'entrée commençant par des chiffres non nuls.

\B.
0

Remplacez tous les chiffres de fin par des zéros.

¶
+

Joignez les résultats avec +s.

C (gcc) , 71 69 octets

Chaque étape de la fonction récursive soustrait la partie à imprimer et transmet le reste du nombre.

Merci à plafondcat pour la suggestion.

g(v,c,w){v&&printf("+%d"+!g(v-w,c*10)+!w*3,w=v%c);w=v;}f(v){g(v,10);}

Essayez-le en ligne!

Brachylog , 35 32 octets

l⟧₅;?z{tℕ₁I&h;10↔^;I×ṫ}ˢ;"+"zckc

-3 octets car 0 n'est pas une entrée valide

Essayez-le en ligne! ou suite de tests

Explication

                                    #   implicit input          eg  105
l                                   #   length of input             3
 ⟧₅                                 #   descending range ]n,0]      [2, 1, 0]
   ;?                               #   pair with input             [[2, 1, 0], [105]]
     z                              #   zip (considers numbers as array of digits)
                                    #                               [[2, 1], [1, 0], [0, 5]]
      {               }ˢ            #   select (map and filter)     [2, 1]  |   [1, 0]  |   [0, 5]
       t                            #       tail (last element)     1       |   0       |   5
        ℕ₁                          #       is at least 1           1       |   fail    |   5
          I                         #       store in I
           &h                       #       head of input           2       |           |   0
             ;10↔                   #       pair with 10 & reverse  [10, 2] |           |   [10, 0]
                 ^                  #       power                   100     |           |   1
                  ;I                #       pair with I             [100, 1]|           |   [1, 5]
                    ×               #       multiply                100     |           |   5
                     ṫ              #       to string               "100"   |           |   "5"
                        ;"+"        #   pair with "+"               [["100", "5"], "+"]
                            z       #   zip (cycles shorter)        [["100", "+"], ["5", "+"]]
                             c      #   concat (flattens)           ["100", "+", "5", "+"]
                              k     #   knife (remove last)         ["100", "+", "5"]
                               c    #   concat                      "100+5"

Brachylog v2, 15 octets

~+bᵛ⁰↔;"+"zckwᵐ

Essayez-le en ligne!

Très, très inefficace.

D'une manière ou d'une autre, cela parvient à n'utiliser que 6 octets sur ce qui est dans la plupart des langues la partie difficile (en divisant le nombre sous la forme a 10 ^b où a est un seul chiffre, dans l'ordre décroissant), et 9 octets pour le "joindre avec +"(qui est intégré dans la plupart des langues de golf, mais pas Brachylog).

Contrairement à la plupart de mes soumissions Brachylog (qui sont des fonctions), celle-ci est un programme complet, prenant l'entrée de l'entrée standard et produisant la sortie sur la sortie standard.

Explication

~+bᵛ⁰↔;"+"zckwᵐ
~+               Find an additive partition of the input number
   ᵛ               such that each component of the partition,
  b                when the first digit is removed
    ⁰              is equal to 0;
     ↔           reverse it,
      ;"+"z      pair every element with "+",
           c     flatten the resulting list one level,
            k    remove the last element (i.e. the final "+"),
             w   and print
              ᵐ  each remaining element.

(La raison wᵐest utilisée plutôt que la plus normale, cc'est que nous avons affaire à une liste hétérogène - elle contient à la fois des nombres et des chaînes - et plutôt que de les laisser se mélanger, il est plus simple de simplement les imprimer individuellement.)

L'algorithme ici force brutalement toutes les partitions additives de l'entrée jusqu'à ce qu'elle en trouve une appropriée (!). Brachylog favorise le partitionnement en moins de possibilités, et avec les possibilités triées par ordre croissant, la première solution qu'il trouvera est donc l'inverse de la solution que la question demande. Il nous suffit donc de l'inverser pour obtenir la solution que nous voulons.

Nettoyer , 73 octets

import StdEnv,Text
$n=join"+"[rpad{c}(size n-p)'0'\\c<-:n&p<-[0..]|c>'0']

Essayez-le en ligne!

Définit la fonction $ :: String -> Stringprenant une chaîne et renvoyant une chaîne.

Toile , 14 13 octets

Ａ⁸Ｌ²－＾×？²｝］+＊

Essayez-le ici!

Attaché , 37 octets

Join&"+"@{Id\`-&>Pairs[_'0]}@Suffixes

Essayez-le en ligne!

Version sans point (41 octets): Join&"+"##`\&:Id##`-&>Pairs@`'&0@Suffixes

Explication

Join&"+"@{Id\`-&>Pairs[_'0]}@Suffixes      input e.g.: 1203
                             Suffixes      take the suffixes of the input digit
                                           e.g.: [1203, 203, 3, 3] 
         {                 }@              apply the inner lambda to the suffixes:
                       _'0                   append `0`
                                             e.g.: [1203, 203, 3, 3, 0]
                 Pairs[   ]                  generate the pairs of integers of the above
                                             e.g.: [[1203, 203], [203, 3], [3, 3], [3, 0]]
             `-&>                            subtraction over each pair
                                             e.g.: [1000, 200, 0, 3]
          Id\                                keep only truthy (nonzero) elements
                                             e.g.: [1000, 200, 3]
Join&"+"@                                  join the result by `+`
                                           e.g.: "1000+200+3"

C (gcc), 87 octets

j;k;f(x){for(j=1;j<x;j*=10);for(;k=x*10/j*j/10%j,j/=10;)k&&printf("%d%c",k,j-1?43:10);}

Essayez-le en ligne!

Powershell, 55 52 octets

$i=$args.Count;($args|%{$_+'0'*--$i}|?{+$_})-join'+'

Le script attend un tableau de chaînes, chaque chaîne contient un chiffre. Script de test:

$f = {

$i=$args.Count;($args|%{$_+'0'*--$i}|?{+$_})-join'+'

}

@(
    ,('10','1','0')
    ,('10+2','1','2')
    ,('9','9')
    ,('100+20+3','1','2','3')
    ,('100+1','1','0','1')
) | % {
    $e, $a = $_
    $r = &$f @a
    "$($e-eq$r): $(-join$a)=$r"
}

Sortie:

True: 10=10
True: 12=10+2
True: 9=9
True: 123=100+20+3
True: 101=100+1

Japt , 13 octets

Prend l'entrée comme un tableau de chiffres.

í*¡ApYÃw)f q+

Essayez-le

Explication

í                 :Interleave
  ¡               :  Map input
   A              :    10
    p             :    To the power of
     Y            :    The current 0-based index
      Ã           :  End map
       w          :  Reverse
 *                :  Reduce each pair by multiplication
        )         :End interleaving
         f        :Filter (remove 0s)
           q+     :Join with "+"

Alternative

Prend l'entrée comme un tableau de chaînes de chiffres.

ËúTUÊ-EÃfn q+

Essayez-le

Java 10, 82 78 octets

n->f(n,1)Object f(int n,int m){return m<n?f(n-n%m,m*10)+(n%m>0?"+"+n%m:""):n;}

Réponse JavaScript du port d' Arnauld (ES6) .
-2 octets grâce à @ceilingcat .
-2 octets grâce à Arnauld .

Essayez-le en ligne.

Explication:

n->                      // Method with int parameter & Object return-type
  f(n,1)                 //  Call the recursive method with `n` and 1

Object f(int n,int m){   // Recursive method with 2 int parameters & Object return-type
  return m<n?            //  If `m` is smaller than `n`:
          f(n-n%m,m*10)  //   Do a recursive call with `n-n%m` and `m` multiplied by 10
          +(n%m>0?       //   And if `n` is not divisible by `m`:
            "+"          //    Append a "+"
            +n%m         //    As well as `n%m`
           :             //   Else:
            "")          //    Append nothing more
         :               //  Else:
          n;}            //   Simply return the input `n`

SNOBOL4 (CSNOBOL4) , 134 133 129 octets

	N =INPUT
	S =SIZE(N) - 1
V	N LEN(X) LEN(1) . V	:F(O)
	O =GT(V) O V DUPL(0,S - X) '+'
	X =X + 1	:(V)
O	O ARB . OUTPUT RPOS(1)
END

Essayez-le en ligne!

Sauvegardé un octet entier en faisant du traitement de chaîne plutôt que de l'arithmétique!

sed -E ,109 99 97 75 74 octets

h;s:.:0:g;G
:l;s:.(.*)\n(.)(.*)\+?(.*):\1\n\3+\4\2\1:;tl
s:\+0+::g;s:..?::

Chaque ligne de l'entrée est considérée comme un numéro distinct. Essayez-le en ligne .

Explication:

h;                                           | copy the original string to the temporary buffer
  s:.:0:g;                                   | substitute all digits with zeroes
          G                                  | append the original string to the substituted one
                                             |
:l;                                          | main loop start
   s:.(.*)\n(.)(.*)\+?(.*):\1\n\3+\4\2\1:;   | cut the next digit from the number, append with zeroes and add to the back
                                          tl | loop if the substitution hasn`t converged yet
                                             |
s:\+0+::g;                                   | remove all zero terms
          s:..?::                            | remove \n and the first +, if any

… Peut être joué au golf plus loin, je présume.

Brainfuck, 147 octets

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

Essayez-le en ligne! (Vous devrez cocher la case "!" Et taper votre entrée après le "!" Sur la deuxième ligne du code sinon il continuera à demander des entrées pour toujours.)

Ce ne sera probablement pas la réponse la plus courte ou le plus court possible, mais c'était assez amusant d'essayer de le faire dans Brainfuck, alors je pourrais aussi bien le poster.

Comme l'a souligné @JoKing, ce programme ne supprime pas les 0. Je vais essayer de résoudre ce problème, mais cela pourrait être assez difficile.

Explication:

>>+[[<]>+[>],]                            Takes inputs and records the amount of them
-[>+>+<<-----]>--->--------               Sets the next 2 cells to 48 (0) and 43 (plus)
<<<[<]>---                                Returns to the start and corrects the number of inputs
                                          Loop
[[<+<+>>-]<[>+<-]>>.                      Prints the first number
<<<[>>[>]>.<<[<]<-]                       Prints the correct number of 0's
>>[>]>>.                                  Prints plus
<<<[<]>                                   Returns to the first cell
>>[<[-]>[<+>-]>]>[<+>-]>[<+>-]<<<<[<]>-]  Removes the first number and shifts everything up by one to make the second number the first 
                                          Loops until on last number
>.                                        Prints last number

APL (Dyalog Unicode) , 20 octets

{⍵'+'⍺}/0~⍨(10×⊢)\∘⌽

Essayez-le en ligne!

Prend l'entrée comme un vecteur de chiffres. Sorties avec un espace avant et après chacune +, et comprend une quantité variable d'espaces de tête.

Ceci est un train. Il est divisé comme suit.

  ┌───┴───┐
  /     ┌─┼──┐
┌─┘     0 ⍨  ∘
{⍵'+'⍺} ┌─┘ ┌┴┐
        ~   \ ⌽
          ┌─┘
       ┌──┼─┐
       10 × ⊢

La première fonction est ⌽, cela inverse le tableau, 1 0 2devient ainsi 2 0 1.

Ensuite, nous entrons dans (10×⊢)\, qui est appliqué au tableau inversé. Cette partie s'inspire de la réponse de ngn au défi Boustrophedonise. L'explication de l'emprunt ngn, étant donné un vecteur de chiffres A B C ..., l'application (10×⊢)\sur ce vecteur donne ce qui suit.

A (A (10×⊢) B) (A (10×⊢) (B (10×⊢) C)) ...
A ((10×⊢) B) ((10×⊢) (10×C)) ...
A (10×B) (10×10×C) ...

On 2 0 1, (10×⊢)\donne 2 0 100.

Vient ensuite 0~⍨. Cela supprime tous les 0s du tableau, donnant 2 100.

Vient enfin le par +. {⍵'+'⍺}/est une réduction qui part de la droite qui concatène l'argument gauche avec a +, suivi de l'argument droit. Effectivement, cela inverse le tableau lors de l'insertion de +s. Cela donne 100 '+' 2, qui est affiché comme 100 + 2.

MathGolf , 12 11 10 octets

hrzúm*ç'+u

Essayez-le en ligne!

Explication

La première commande n'est pas nécessaire car l'entrée peut être donnée sous la forme d'une liste de chiffres.

(▒           Convert to a list of digits)
 h           Get length of input list without popping
  r          Push range(a)
   z         Reverse sort
    ú        Map i -> 10**i for each element in list
     m*      Element-wise multiplication
       ç     Filter faulty items in list
        '+   Push "+"
          u  Join with separator

Je pourrais ajouter un opérateur de multiplication par paire qui est d'un octet, mais cela ne fait pas actuellement partie du langage. Ensuite, je pourrais supprimer un octet de cette solution.