输入一个正数，将其输出为每个数字的总和乘以10的幂。

输入项

一个数字，作为整数，字符串或数字/字符列表。

该数字将严格为正。
如果您接受数字作为字符串或列表，则它不会以开头0。

输出量

一个字符串，表示每个相关的以10为底的数字的总和，每个数字均乘以其各自的以10为底的幂。总和表示为a + b。如果需要，您可以在+标志的两边最多使用一个空格。操作数以降序列出。

0 永远不能是有效的操作数。
该+符号（是否用空格包围）可能不是开头或结尾部分。

例子

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

无效的输出

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

这是代码高尔夫球，因此以字节为单位的最短代码胜出！

code-golf number

— 奥利维尔·格雷戈尔（OlivierGrégoire）
source

沙盒

— OlivierGrégoire18年

Python 3：83 80 79字节

在线尝试！

我第一次提交Code Golf。

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

ovs -3字节。感谢您的有用提示：) -4字节（由mypetlion提供）。谢谢您的缩短提示:)

— 马佳思
source

欢迎来到PPCG！您可以通过重新排列你的if语句来提高你的分数if'0'<t[i]，并从改变你的公式x-i-1来x+~i。这是逐步更改的TIO链接。

— ovs

将print语句更改print(*[t[i]+'0'*(x+~i)for i in range(x)if'0'<t[i]],sep='+')为保存1个字节。

— mypetlion 18/09/10

10

果冻，9个字节

ḊƬḌQIAj”+

在线尝试！

怎么运行的

ḊƬḌ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 '+'.

— 丹尼斯
source

3

聪明的方法！

— Quintec's

8

JavaScript（ES6），47个字节

将输入作为整数。

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

在线尝试！

已评论

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

— Arnauld
source

7

R，55个字节

假设整数都在1e10以下，无论如何都大于最大32位整数...

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

在线尝试！

— 多伊
source

好吧，10^(nchar(n):1-1理论上适用于任何整数...

— Giuseppe

1

可以，但是请看一下所有这些额外的字节！

— J.Doe '18

7

莎士比亚程序设计语言，807个 806 805 804字节

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

在线尝试！

-23个字节（如果可能先输出空字符）

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

说明

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

— 乔西亚·瑞安（JosiahRyanW）
source

6

Python 2，64个字节

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

在线尝试！

Python 2，66字节

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

在线尝试！

— ovs
source

6

果冻， 12 11 字节

J’⁵*Ṛ×ḟ0j”+

接受数字作为数字列表（Python格式）的完整程序，该程序将打印结果。

在线尝试！

怎么样？

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字节：

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

— 乔纳森·艾伦
source

5

Haskell，60 54字节

编辑：-6个字节，感谢Delfad0r。

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

将输入数字作为字符串。

在线尝试！

    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 +

— 妮米
source

2

tail.(>>=('+':)).filter(>="1").scanr((.('0'<$)).(:))""节省6个字节在线尝试！。

— Delfad0r

1

@ Delfad0r：很好，非常感谢！

— nimi

4

05AB1E，10个字节

直接执行。
输入为数字列表。

āR<°*0K'+ý

在线尝试！

说明

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

— 艾米尼亚
source

4

Python 2，64个字节

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

一个未命名的函数，使用数字列表n并返回一个字符串。

在线尝试！

enumerate(n)将产生的元组index, item跨n与索引开始0。

但是enumerate也有一个可选的开始索引作为其第二个参数，通过设置这对-len(n)我们得到指数（e第）-len(n)，-len(n)+1...， -1。

这意味着任何项（b）所需的尾随零数为-1-e，~e因此 ~e*'0'可以获取所需的尾随零数。

`b`获取整数的字符串表示形式，b并将+其与那些零连接。

if b使用过滤出条目b==0。

'+'.join(...)然后将结果字符串与+字符连接起来。

— 乔纳森·艾伦
source

4

Python 2，82 73 71字节

-9个字节，感谢@ovs

-2个字节，感谢@JonathanAllan

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

在线尝试

— 唐千
source

4

Haskell，56 55 52字节

-4字节感谢nimi。

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

在线尝试！

说明

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

在线尝试！

— ovs
source

3

Perl 6、38个字节

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

在线尝试！

匿名代码块，它接受一个数字列表并返回一个字符串。

说明：

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

— 乔·金
source

3

APL（Dyalog），46 41 40字节

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

-5个字节，感谢@dzaima

匿名前缀功能。将输入作为字符串。蒂奥

（这是我第一次在PPCG上使用APL，可能是高尔夫球用的。而且，请诅咒您，零！）

— 金泰克
source

41个字节，包含⎕IO←0

— dzaima

3

视网膜，19字节

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

在线尝试！链接包括测试用例。说明：

L`[1-9]

列出所有非零数字

$
$&$.'*0

对于每个数字，请附加与尾随数字一样多的零。

|'+

用+s代替每个结果而不是默认的换行符。

视网膜0.8.2，21字节

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

在线尝试！链接包括测试用例。说明：

M&!`[1-9].*

列出以非零数字开头的所有输入后缀。

\B.
0

将所有尾随数字替换为零。

¶
+

将结果与+s相连。

— 尼尔
source

3

C（gcc），71 69字节

递归函数的每一步都减去将要打印的部分，并将其余的数字继续传递。

感谢天花板猫的建议。

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

在线尝试！

— 埃里克·F
source

3

Brachylog，35 32字节

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

-3个字节，导致0无效输入

在线尝试！或测试者

说明

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

— 克罗佩卜
source

OP现在已指定0不是您必须处理的输入，因此可以|∧Ṡ从末尾删除。:)

— DLosc

3

Brachylog v2，15个字节

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

在线尝试！

非常非常低效。

不知何故，这个管理上使用的是在大多数语言中最难的部分只有6个字节（分裂成数形式一个 10 ^b，其中一个是一位数，按降序排列），以及整个9个字节的“联同+”（这是大多数高尔夫语言的内置功能，但不包括Brachylog）。

与我的大多数Brachylog提交（函数）不同，这是一个完整的程序，从标准输入中获取输入，并在标准输出中生成输出。

说明

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

（之所以wᵐ使用它而不是更普通的原因是c，我们正在处理一个异构列表-它包含数字和字符串-而不是让它们混合使用，最简单的是将它们全部单独打印是最简单的。）

该算法在所有输入的加性分区上都采用蛮力运算，直到找到合适的加法（！）。Brachylog赞成将可能性划分为较少的可能性，并且将可能性按升序排序，因此，它将找到的第一个解决方案是问题所要求的解决方案的逆向。因此，我们只需将其反转即可获得所需的解决方案。

— ais523
source

2

干净，73字节

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

在线尝试！

定义$ :: String -> String接受字符串并返回字符串的函数。

— 巨大
source

2

画布，14 13 字节

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

在这里尝试！

— 宰马
source

2

附件，37字节

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

在线尝试！

无点版本（41字节）： Join&"+"##`\&:Id##`-&>Pairs@`'&0@Suffixes

说明

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"

— 科纳·奥布莱恩
source

2

C（gcc），87个字节

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

在线尝试！

— 比萨184
source

2

Powershell，55 52字节

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

脚本需要一个字符串数组，每个字符串包含一个数字。测试脚本：

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

输出：

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

— 疯狂的
source

2

Japt，13个字节

将输入作为数字数组。

í*¡ApYÃw)f q+

试试吧

说明

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

另类

将输入作为数字字符串数组。

ËúTUÊ-EÃfn q+

试试吧

— 毛茸茸
source

2

Java 10，82 78字节

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

Arnauld的JavaScript（ES6）答案端口。
-2个字节感谢@ceilingcat。
-2个字节感谢Arnauld。

在线尝试。

说明：

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`

— 凯文·克鲁伊森
source

我想这个答案对于原始问题也将是有效的。：）（可能n%m是为可读性分配了一个变量。）

— Arnauld

1

真好！我最初的解决方案是91个字节。

— 奥利维尔·格雷戈雷（OlivierGrégoire），

1

@ceilingcat其实m<n应该可以。

— Arnauld

2

SNOBOL4（CSNOBOL4），134个 133 129字节

	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

在线尝试！

通过执行字符串处理而不是算术来节省整个字节！

— 朱塞佩
source

2

SED-E，109 99 97 75 74字节

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

输入的每一行都被视为一个单独的数字。在线尝试。

说明：

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

我想……还可以打高尔夫球。

— hidefromkgb
source

您好，欢迎来到PPCG。您的答案看起来不错，尽管我不明白您为什么添加了BADC0FFEE测试用例。我认为挑战仅在于十进制表示形式。

— 乔纳森·弗雷希

根据挑战规范，您不需要处理01010101010或000000。那会节省任何字节吗？

— 丹尼斯

@Dennis最有可能不是，因为前导零和介于两者之间的行为相同，因此无论如何我都需要擦除它们。

— hidefromkgb

2

Brainfuck，147字节

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

在线尝试！（您必须勾选标记为“！”的框，并在代码第二行的“！”之后键入您的输入，否则它将永远永远要求输入。）

它可能不会是最短的答案，也可能不会是最短的答案，但是尝试在Brainfuck上这样做很有趣，所以我不妨发布它。

正如@JoKing指出的那样，该程序不会删除0。我将尝试解决此问题，但可能会很难。

说明：

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

— FinW
source

抱歉，但这不会删除指定的零。在线尝试！

— Jo King

谢谢，我没有注意到。我将尝试解决此问题。我在的同时，我将编辑我的帖子

— FinW

2

APL（Dyalog Unicode），20字节

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

在线尝试！

将输入作为数字向量。每个输出之前和之后都有一个空格+，并包含可变数量的前导空格。

这是火车。它分为以下几种。

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

第一个功能是⌽，这会反转数组，因此1 0 2成为2 0 1。

然后我们进入(10×⊢)\，它应用于反向数组。这部分的灵感来自于ngn对Boustrophedonise挑战的回答。在给定一个数字向量的情况下，借用ngn的解释，对该向量A B C ...应用(10×⊢)\以下内容。

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

上2 0 1，(10×⊢)\给2 0 100。

接下来来0~⍨。这会将所有0s从数组中移除，从而给出2 100。

终于来了+。{⍵'+'⍺}/是从右边开始的缩小，该缩小将左边的arg与+，然后是右边的arg连接起来。有效地，这会在插入+s时反转数组。这给出了100 '+' 2，显示为100 + 2。

— 克里蒂希·石印
source

2

MathGolf，12 11 10字节

hrzúm*ç'+u

在线尝试！

说明

不需要第一条命令，因为输入可以数字列表形式给出。

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

我可能会添加一个成对的乘法运算符，该运算符是一个字节，但是目前还不是该语言的一部分。然后，我可以从该解决方案中删除一个字节。

— 马克斯
source

扩大一些

输入项

输出量

例子

无效的输出

Python 3：83 80 79字节

果冻，9个字节

怎么运行的

JavaScript（ES6），47个字节

已评论

R，55个字节

莎士比亚程序设计语言，807个 806 805 804字节

说明

Python 2，64个字节

Python 2，66字节

果冻， 12 11 字节

怎么样？

Haskell，60 54字节

05AB1E，10个字节

Python 2，64个字节

Python 2，82 73 71字节

Haskell，56 55 52字节

Perl 6、38个字节

说明：

APL（Dyalog），46 41 40字节

视网膜，19字节

视网膜0.8.2，21字节

C（gcc），71 69字节

Brachylog，35 32字节

说明

Brachylog v2，15个字节

说明

干净，73字节

画布，14 13 字节

附件，37字节

说明

C（gcc），87个字节

Powershell，55 52字节

Japt，13个字节

说明

另类

Java 10，82 78字节

SNOBOL4（CSNOBOL4） ，134个 133 129字节

SED-E，109 99 97 75 74字节

说明：

Brainfuck，147字节

APL（Dyalog Unicode），20字节

MathGolf，12 11 10字节

说明

SNOBOL4（CSNOBOL4），134个 133 129字节