Esse desafio é baseado nesta questão do Stackoverflow .

Com um número positivo como entrada, produza-o como a soma de cada dígito multiplicado por sua representação de potência-10.

Entrada

Um número, como um número inteiro, uma sequência de caracteres ou uma lista de dígitos / caracteres.

• O número será estritamente positivo.
• Se você aceitar o número como uma sequência ou lista, ele não começará com a 0.

Saída

Uma sequência que representa uma soma de cada dígito relevante da base 10, cada um multiplicado pelo seu respectivo poder da base 10. Uma soma é representada como a + b. Você pode usar até um espaço ao redor de cada lado da +placa, se desejar. Os operandos são listados em ordem decrescente.

• 0 nunca pode ser um operando válido.
• O +sinal (cercado ou não por espaços) pode não ser a parte inicial ou final.

Exemplos

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

Saídas inválidas

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

Isso é código-golfe, então o código mais curto em bytes vence!

Python 3: 83 80 79 bytes

Experimente Online!

Minha primeira submissão ao 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. Obrigado por essa dica útil :) -4 Bytes por mypetlion. Obrigado por essa dica de encurtamento :)

Geléia , 9 bytes

ḊƬḌQIAj”+

Experimente online!

Como 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

Recebe a entrada como um número inteiro.

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

Experimente online!

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

Supondo que números inteiros estejam abaixo de 1e10, que é maior que o número máximo máximo de 32 bits de qualquer maneira ...

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

Experimente online!

Linguagem de programação de 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.

Experimente online!

-23 bytes se um caractere nulo puder ser gerado primeiro

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

Explicação

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

Experimente online!

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`

Experimente online!

Geléia ,  12  11 bytes

J’⁵*Ṛ×ḟ0j”+

Um programa completo que aceita o número como uma lista de dígitos (no formato Python) que imprime o resultado.

Experimente online!

Quão?

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"

@ 12 bytes anteriores:

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

Haskell, 60 54 bytes

Edit: -6 bytes graças a Delfad0r.

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

Toma o número de entrada como uma sequência.

Experimente online!

    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

Implementação direta.
Insira como lista de dígitos.

āR<°*0K'+ý

Experimente online!

Explicação

    *        # 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)

Uma função sem nome que pega uma lista de dígitos ne retorna uma string.

Experimente online!

enumerate(n)produziria tuplas de index, itemdiâmetro ncom um índice começando em 0.

No entanto enumerate, também tem um índice de partida opcional como seu segundo argumento, definindo isso para -len(n)chegarmos índices ( es) de -len(n), -len(n)+1, ..., -1.

Isso significa que o número de zeros à direita necessários para qualquer item ( b) é -1-e, obtendo ~eassim ~e*'0'os zeros à direita necessários.

`b`obtém uma representação de string do dígito inteiro be +concatena isso com esses zeros.

if bfiltra as entradas com b==0.

'+'.join(...)depois une as seqüências resultantes aos +caracteres.

Python 2, 82 73 71 bytes

-9 bytes graças a @ovs

-2 bytes graças a @JonathanAllan

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

Experimente Online

Haskell , 56 55 52 bytes

-4 bytes graças a nimi .

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

Experimente online!

explicação

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

Experimente online!

Perl 6 , 38 bytes

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

Experimente online!

Bloco de código anônimo que pega uma lista de dígitos e retorna uma string.

Explicação:

{                                    }  # 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 graças a @dzaima

Função de prefixo anônimo. Recebe a entrada como uma sequência. TIO

(Esta é a minha primeira vez usando APL no PPCG, provavelmente jogável. Além disso, maldição, zeros!)

Retina , 19 bytes

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

Experimente online! O link inclui casos de teste. Explicação:

L`[1-9]

Listar todos os dígitos diferentes de zero

$
$&$.'*0

Para cada dígito, anexe quantos zeros houverem dígitos finais.

|'+

Separe cada resultado com +s em vez da nova linha padrão.

Retina 0.8.2 , 21 bytes

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

Experimente online! O link inclui casos de teste. Explicação:

M&!`[1-9].*

Liste todos os sufixos da entrada que começam com dígitos diferentes de zero.

\B.
0

Substitua todos os dígitos finais por zeros.

¶
+

Junte os resultados com +s.

C (gcc) , 71 69 bytes

Cada etapa da função recursiva subtrai a parte que será impressa e passa o restante do número.

Agradecimentos a ceilingcat pela sugestão.

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

Experimente online!

Braquilog , 35 32 bytes

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

-3 bytes porque 0 não é uma entrada válida

Experimente online! ou testinguite

Explicação

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

Experimente online!

Muito, muito ineficiente.

De alguma forma, isso consegue usar apenas 6 bytes na parte mais difícil da maioria dos idiomas (dividindo o número no formato a 10 ^b, onde a é um dígito, em ordem decrescente) e 9 bytes inteiros para a "junção com +"(embutido na maioria dos idiomas de golfe, mas não no Brachylog).

Ao contrário da maioria dos meus envios de Brachylog (que são funções), este é um programa completo, recebendo informações de entrada padrão e produzindo saída com saída padrão.

Explicação

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

(O motivo wᵐé usado e não o mais normal cé que estamos lidando com uma lista heterogênea - ela contém números e seqüências de caracteres - e, em vez de permitir que elas se misturem, é mais simples imprimi-las todas individualmente.)

O algoritmo aqui força bruta sobre todas as partições aditivas da entrada até encontrar uma adequada (!). O Brachylog favorece o particionamento em menos possibilidades, e com as possibilidades classificadas em ordem crescente, então a primeira solução que ele encontrará é o inverso da solução que a pergunta está pedindo. Então, basta revertê-lo para obter a solução que queremos.

Limpo , 73 bytes

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

Experimente online!

Define a função que $ :: String -> Stringpega uma string e retorna uma string.

Tela , 14 13 bytes

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

Experimente aqui!

Anexo , 37 bytes

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

Experimente online!

Versão sem ponto (41 bytes): Join&"+"##`\&:Id##`-&>Pairs@`'&0@Suffixes

Explicação

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

Experimente online!

Powershell, 55 52 bytes

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

O script espera uma matriz de strings, cada string contém um dígito. Script de teste:

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

Saída:

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

Japonês , 13 bytes

Recebe a entrada como uma matriz de dígitos.

í*¡ApYÃw)f q+

Tente

Explicação

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

Alternativo

Recebe a entrada como uma matriz de cadeias de dígitos.

ËúTUÊ-EÃfn q+

Tente

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

Resposta JavaScript do Porto de Arnauld (ES6) .
-2 bytes graças a @ceilingcat .
-2 bytes graças a Arnauld .

Experimente online.

Explicação:

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

Experimente online!

Salvou um byte inteiro, processando as strings em vez da 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 linha da entrada é considerada um número separado. Experimente online .

Explicação:

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

... pode ser jogado mais longe, eu presumo.

Brainfuck, 147 bytes

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

Experimente online! (Você precisará marcar a caixa marcada com "!" E digitar sua entrada após o "!" Na segunda linha do código, caso contrário, continuará solicitando entradas para sempre.)

Provavelmente, não será a resposta mais curta ou a menor possível, mas foi muito divertido tentar fazer isso em Brainfuck, para que eu possa postá-la.

Como o @JoKing apontou, este programa não remove 0s. Vou tentar corrigir isso, mas pode ser bastante difícil.

Explicação:

>>+[[<]>+[>],]                            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×⊢)\∘⌽

Experimente online!

Recebe entrada como um vetor de dígitos. Produz um espaço antes e depois de cada um +e inclui uma quantidade variável de espaços à esquerda.

Este é um trem. Está dividido no seguinte.

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

A primeira função é ⌽, isso inverte a matriz, assim 1 0 2torna - se 2 0 1.

Então entramos (10×⊢)\, que é aplicado à matriz invertida. Esta parte é inspirada na resposta da ngn ao desafio Boustrophedonise. A explicação do ngn de empréstimo, dado um vetor de dígitos A B C ..., que se aplica (10×⊢)\a esse vetor fornece o seguinte.

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

Em 2 0 1, (10×⊢)\dá 2 0 100.

Em seguida vem 0~⍨. Isso remove todos os 0s da matriz, dando 2 100.

Finalmente vem o +s. {⍵'+'⍺}/é uma redução que começa da direita que concatena o argumento esquerdo com a +, seguido pelo argumento direito. Efetivamente, isso reverte a matriz ao inserir +s. Isso fornece 100 '+' 2, que é exibido como 100 + 2.

MathGolf , 12 11 10 bytes

hrzúm*ç'+u

Experimente online!

Explicação

O primeiro comando não é necessário, pois a entrada pode ser fornecida como uma 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

Posso adicionar um operador de multiplicação em pares que é de um byte, mas que atualmente não faz parte do idioma. Então eu poderia remover um byte desta solução.