Este desafío se basa en esta pregunta de Stackoverflow .

Con un número positivo como entrada, imprímalo como la suma de cada dígito multiplicado por su representación de potencia de 10.

Entrada

Un número, como un entero, una cadena o una lista de dígitos / caracteres.

• El número será estrictamente positivo.
• Si acepta el número como una cadena o lista, no comenzará con a 0.

Salida

Una cadena que representa una suma de cada dígito de base 10 relevante, cada uno multiplicado por su respectiva potencia de base 10. Una suma se representa como a + b. Si lo desea, puede usar hasta un espacio alrededor de cada lado del +letrero. Los operandos se enumeran en orden descendente.

• 0 nunca puede ser un operando válido.
• El +letrero (rodeado o no por espacios) puede no ser la parte inicial o posterior.

Ejemplos

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

Salidas inválidas

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

Este es el código de golf, por lo que gana el código más corto en bytes.

Python 3: 83 80 79 Bytes

¡Pruébelo en línea!

Mi primera presentación de Code Golf.

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

-3 Bytes por ovs. Gracias por ese consejo útil :) -4 Bytes por mypetlion. Gracias por ese consejo de acortamiento :)

Jalea , 9 bytes

ḊƬḌQIAj”+

Pruébalo en línea!

Cómo funciona

ḊƬḌ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 bytes

Toma la entrada como un entero.

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

Pruébalo en línea!

Comentado

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 bytes

Suponiendo que todos los enteros estén por debajo de 1e10, que de todos modos es más grande que el entero máximo de 32 bits ...

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

Pruébalo en línea!

Lenguaje de programación Shakespeare , 807 806 805 804 bytes

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

Pruébalo en línea!

-23 bytes si un carácter nulo puede salir primero

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

Explicación

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

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

Pruébalo en línea!

Python 2 , 66 bytes

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

Pruébalo en línea!

Jalea ,  12  11 bytes

J’⁵*Ṛ×ḟ0j”+

Un programa completo que acepta el número como una lista de dígitos (en formato Python) que imprime el resultado.

Pruébalo en línea!

¿Cómo?

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"

Anterior @ 12 bytes:

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

Haskell, 60 54 bytes

Editar: -6 bytes gracias a Delfad0r.

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

Toma el número de entrada como una cadena.

Pruébalo en línea!

    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 bytes

Implementación directa.
Entrada como lista de dígitos.

āR<°*0K'+ý

Pruébalo en línea!

Explicación

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

Python 2 , 64 bytes

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

Una función sin nombre que toma una lista de dígitos n, y devuelve una cadena.

Pruébalo en línea!

enumerate(n)produciría tuplas de index, itemtravés ncon un índice que comienza en 0.

Sin embargo enumeratetambién tiene un índice de partida opcional como segundo argumento, estableciendo este a -len(n)obtenemos índices ( es) de -len(n), -len(n)+1, ..., -1.

Esto significa que el número de ceros finales requeridos para cualquier elemento ( b) es -1-e, que es ~easí que ~e*'0'obtiene los ceros finales necesarios.

`b`obtiene una representación de cadena del dígito entero by +concatena esto con esos ceros.

if bfiltra las entradas con b==0.

'+'.join(...)luego une las cadenas resultantes con +caracteres.

Python 2, 82 73 71 bytes

-9 bytes gracias a @ovs

-2 bytes gracias a @JonathanAllan

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

Pruébalo en línea

Haskell , 56 55 52 bytes

-4 byte gracias a nimi .

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

Pruébalo en línea!

explicación

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 "" = ""

Pruébalo en línea!

Perl 6 , 38 bytes

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

Pruébalo en línea!

Bloque de código anónimo que toma una lista de dígitos y devuelve una cadena.

Explicación:

{                                    }  # 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 bytes

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

-5 bytes gracias a @dzaima

Función de prefijo anónimo. Toma la entrada como una cadena. TIO

(Esta es la primera vez que uso APL en PPCG, probablemente golfable. Además, ¡maldito sea, ceros!)

Retina , 19 bytes

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

Pruébalo en línea! El enlace incluye casos de prueba. Explicación:

L`[1-9]

Listar todos los dígitos distintos de cero

$
$&$.'*0

Para cada dígito, agregue tantos ceros como dígitos restantes.

|'+

Separe cada resultado con +s en lugar de la nueva línea predeterminada.

Retina 0.8.2 , 21 bytes

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

Pruébalo en línea! El enlace incluye casos de prueba. Explicación:

M&!`[1-9].*

Enumere todos los sufijos de la entrada que comienzan con dígitos distintos de cero.

\B.
0

Reemplace todos los dígitos finales con ceros.

¶
+

Une los resultados con +s.

C (gcc) , 71 69 bytes

Cada paso de la función recursiva resta la parte que imprimirá y pasa el resto del número.

Gracias a ceilingcat por la sugerencia.

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

Pruébalo en línea!

Brachylog , 35 32 bytes

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

-3 bytes porque 0 no es una entrada válida

Pruébalo en línea! o testuite

Explicación

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

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

Pruébalo en línea!

Muy, muy ineficiente.

De alguna manera, esto logra usar solo 6 bytes en lo que en la mayoría de los idiomas es la parte difícil (dividir el número en la forma a 10 ^b donde a es un solo dígito, en orden descendente) y un total de 9 bytes para "unirse con +"(que está incluido en la mayoría de los idiomas de golf, pero no en Brachylog).

A diferencia de la mayoría de mis presentaciones de Brachylog (que son funciones), este es un programa completo, que toma información de entrada estándar y produce salida en salida estándar.

Explicación

~+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 razón que wᵐse usa en lugar de la más normal ces que estamos tratando con una lista heterogénea, que contiene números y cadenas, y en lugar de permitir que se mezclen, es más simple imprimirlos todos individualmente).

El algoritmo aquí fuerza bruta sobre todas las particiones aditivas de la entrada hasta que encuentre una adecuada (!). Brachylog favorece la partición en menos posibilidades, y con las posibilidades ordenadas en orden ascendente, por lo que la primera solución que encontrará es el reverso de la solución que está planteando la pregunta. Entonces solo tenemos que revertirlo para obtener la solución que queremos.

Limpio , 73 bytes

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

Pruébalo en línea!

Define la función que $ :: String -> Stringtoma una cadena y devuelve una cadena.

Lienzo , 14 13 bytes

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

Pruébalo aquí!

Adjunto , 37 bytes

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

Pruébalo en línea!

Versión sin puntos (41 bytes): Join&"+"##`\&:Id##`-&>Pairs@`'&0@Suffixes

Explicación

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 bytes

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

Pruébalo en línea!

Powershell, 55 52 bytes

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

El script espera una matriz de cadenas, cada cadena contiene un dígito. Script de prueba:

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

Salida:

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

Japt , 13 bytes

Toma la entrada como una matriz de dígitos.

í*¡ApYÃw)f q+

Intentalo

Explicación

í                 :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 "+"

Alternativa

Toma la entrada como una matriz de cadenas de dígitos.

ËúTUÊ-EÃfn q+

Intentalo

Java 10, 82 78 bytes

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

Respuesta de JavaScript del puerto de Arnauld (ES6) .
-2 bytes gracias a @ceilingcat .
-2 bytes gracias a Arnauld .

Pruébalo en línea.

Explicación:

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 bytes

	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

Pruébalo en línea!

¡Salvó un byte completo al procesar cadenas en lugar de aritmética!

sed -E ,109 99 97 75 74 bytes

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

Cada línea de la entrada se considera un número separado. Pruébalo en línea .

Explicación:

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

... se puede jugar más golf, supongo.

Brainfuck, 147 bytes

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

Pruébalo en línea! (Deberá marcar la casilla marcada "!" Y escribir su entrada después de "!" En la segunda línea del código; de lo contrario, continuará solicitando entradas para siempre).

Probablemente no será la respuesta más corta o jugará golf lo más corto posible, pero fue muy divertido intentar hacer esto en Brainfuck, por lo que podría publicarlo.

Como señaló @JoKing, este programa no elimina los 0. Intentaré solucionar esto, pero puede ser bastante difícil.

Explicación:

>>+[[<]>+[>],]                            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 bytes

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

Pruébalo en línea!

Toma la entrada como un vector de dígitos. Salidas con un espacio antes y después de cada uno +, e incluye una cantidad variable de espacios iniciales.

Este es un tren. Se divide en lo siguiente.

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

La primera función es ⌽, esto invierte la matriz, por lo que se 1 0 2convierte 2 0 1.

Luego entramos (10×⊢)\, que se aplica a la matriz invertida. Esta parte está inspirada en la respuesta de ngn al desafío Boustrophedonise. Tomando prestada la explicación de ngn, dado un vector de dígitos A B C ..., la aplicación (10×⊢)\en este vector da lo siguiente.

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

En 2 0 1, (10×⊢)\da 2 0 100.

Luego viene 0~⍨. Esto elimina todos los 0s de la matriz, dando 2 100.

Finalmente llega el +s. {⍵'+'⍺}/es una reducción que comienza desde la derecha que concatena el argumento izquierdo con a +, seguido del argumento derecho. Efectivamente, esto invierte la matriz al insertar +s. Esto da 100 '+' 2, que se muestra como 100 + 2.

MathGolf , 12 11 10 bytes

hrzúm*ç'+u

Pruébalo en línea!

Explicación

El primer comando no es necesario ya que la entrada se puede dar como una lista de dígitos.

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

Podría agregar un operador de multiplicación por pares que es un byte, pero que actualmente no es parte del lenguaje. Entonces podría eliminar un byte de esta solución.