Thử thách này dựa trên câu hỏi Stackoverflow này .

Với một số dương làm đầu vào, hãy xuất nó thành tổng của mỗi chữ số nhân với đại diện lũy thừa 10 của nó.

Đầu vào

Một số, dưới dạng số nguyên, chuỗi hoặc danh sách các chữ số / ký tự.

• Con số sẽ hoàn toàn tích cực.
• Nếu bạn chấp nhận số dưới dạng một chuỗi hoặc danh sách, nó sẽ không bắt đầu bằng a 0.

Đầu ra

Một chuỗi đại diện cho tổng của mỗi chữ số cơ sở có liên quan 10, mỗi chữ số nhân với công suất cơ sở 10 tương ứng của nó. Một tổng được đại diện là a + b. Bạn có thể sử dụng tối đa một khoảng trống xung quanh mỗi bên của +dấu hiệu nếu bạn muốn. Các toán hạng được liệt kê theo thứ tự giảm dần.

• 0 không bao giờ có thể là một toán hạng hợp lệ.
• Các +dấu hiệu (bao quanh hay không bằng dấu cách) có thể không phải là phần đầu hoặc cuối.

Ví dụ

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

Đầu ra không hợp lệ

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

Đây là mã golf, vì vậy mã ngắn nhất tính bằng byte sẽ thắng!

Python 3: 83 80 79 byte

Dùng thử trực tuyến!

Mã Golf đầu tiên của tôi nộp.

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

-3 Byte bằng lò nướng. Cảm ơn bạn vì lời khuyên hữu ích đó :) -4 Byte bởi mypetlion. Cảm ơn bạn cho mẹo rút ngắn đó :)

Thạch , 9 byte

ḊƬḌQIAj”+

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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

Lấy đầu vào là một số nguyên.

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

Hãy thử trực tuyến!

Đã bình luậ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

R , 55 byte

Giả sử số nguyên đều dưới 1e10, lớn hơn số nguyên 32 bit tối đa ...

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

Hãy thử trực tuyến!

Ngôn ngữ lập trình Shakespeare , 807 806 805 804 byte

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

Hãy thử trực tuyến!

-23 byte nếu một ký tự null có thể được xuất ra đầu tiên

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

Giải trình

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

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

Hãy thử trực tuyến!

Python 2 , 66 byte

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

Hãy thử trực tuyến!

Thạch ,  12  11 byte

J’⁵*Ṛ×ḟ0j”+

Một chương trình đầy đủ chấp nhận số dưới dạng danh sách các chữ số (ở định dạng Python) sẽ in kết quả.

Hãy thử trực tuyến!

Làm sao?

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 byte trước:

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

Haskell, 60 54 byte

Chỉnh sửa: -6 byte nhờ Delfad0r.

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

Lấy số đầu vào dưới dạng một chuỗi.

Hãy thử trực tuyến!

    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 byte

Thẳng tiến thực hiện.
Nhập dưới dạng danh sách các chữ số.

āR<°*0K'+ý

Hãy thử trực tuyến!

Giải trình

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

Python 2 , 64 byte

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

Hàm không tên có danh sách các chữ số nvà trả về một chuỗi.

Hãy thử trực tuyến!

enumerate(n)sẽ mang lại bộ dữ liệu index, itemngang nvới một chỉ số bắt đầu từ 0.

Tuy nhiên enumeratecũng có một chỉ số khởi đầu không bắt buộc như là đối số thứ hai của mình, bằng cách thiết lập này để -len(n)chúng ta có được chỉ số ( es) của -len(n), -len(n)+1, ..., -1.

Điều này có nghĩa là số lượng các số 0 được yêu cầu cho bất kỳ mục nào ( b) là -1-e, ~edo đó ~e*'0'sẽ nhận được các số không theo yêu cầu.

`b`lấy một đại diện chuỗi của chữ số nguyên bvà +nối chuỗi này với các số không.

if blọc ra các mục với b==0.

'+'.join(...)sau đó nối các chuỗi kết quả lên với các +ký tự.

Python 2, 82 73 71 byte

-9 byte nhờ @ovs

-2 byte nhờ @Jonathan ALLan

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

Dùng thử trực tuyến

Haskell , 56 55 52 byte

-4 byte nhờ nimi .

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

Hãy thử trực tuyến!

giải trình

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

Hãy thử trực tuyến!

Perl 6 , 38 byte

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

Hãy thử trực tuyến!

Khối mã ẩn danh nhận danh sách các chữ số và trả về một chuỗi.

Giải trình:

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

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

-5 byte nhờ @dzaima

Hàm tiền tố ẩn danh. Đưa đầu vào dưới dạng một chuỗi. TIO

(Đây là lần đầu tiên tôi sử dụng APL trên PPCG, có thể chơi được. Ngoài ra, hãy nguyền rủa bạn, số không!)

Võng mạc , 19 byte

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

Hãy thử trực tuyến! Liên kết bao gồm các trường hợp thử nghiệm. Giải trình:

L`[1-9]

Liệt kê tất cả các chữ số khác không

$
$&$.'*0

Đối với mỗi chữ số, nối thêm nhiều số không có các chữ số ở cuối.

|'+

Tách từng kết quả bằng +s thay vì dòng mới mặc định.

Võng mạc 0.8.2 , 21 byte

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

Hãy thử trực tuyến! Liên kết bao gồm các trường hợp thử nghiệm. Giải trình:

M&!`[1-9].*

Liệt kê tất cả các hậu tố của đầu vào bắt đầu bằng các chữ số khác không.

\B.
0

Thay thế tất cả các chữ số dấu bằng số không.

¶
+

Tham gia kết quả với +s.

C (gcc) , 71 69 byte

Mỗi bước của hàm đệ quy sẽ trừ đi phần mà nó sẽ in và chuyển phần còn lại của số trên.

Cảm ơn trần nhà cho lời đề nghị.

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

Hãy thử trực tuyến!

Brachylog , 35 32 byte

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

-3 byte gây ra 0 không phải là đầu vào hợp lệ

Hãy thử trực tuyến! hoặc TestSuite

Giải trình

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

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

Hãy thử trực tuyến!

Rất, rất không hiệu quả.

Bằng cách nào đó, điều này quản lý để sử dụng chỉ có 6 byte vào những gì là trong hầu hết các ngôn ngữ phần cứng (tách số thành dạng một 10 ^b nơi một là một chữ số duy nhất, theo thứ tự giảm dần), và toàn bộ 9 byte cho "tham gia với +"(Được tích hợp trong hầu hết các ngôn ngữ chơi gôn, nhưng không phải là Brachylog).

Không giống như hầu hết các bài nộp Brachylog của tôi (là các hàm), đây là một chương trình đầy đủ, lấy đầu vào từ đầu vào tiêu chuẩn và sản xuất đầu ra trên đầu ra tiêu chuẩn.

Giải trình

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

(Lý do wᵐđược sử dụng thay vì bình thường hơn clà chúng tôi đang xử lý một danh sách không đồng nhất - nó chứa cả số và chuỗi - và thay vì cho phép chúng trộn lẫn, đơn giản nhất là chỉ in riêng lẻ.)

Thuật toán ở đây brute-force trên tất cả các phân vùng phụ gia của đầu vào cho đến khi tìm thấy một phân vùng phù hợp (!). Brachylog ưu tiên phân vùng thành ít khả năng hơn và với các khả năng được sắp xếp theo thứ tự tăng dần, vì vậy giải pháp đầu tiên mà nó sẽ tìm thấy là sự đảo ngược của giải pháp mà câu hỏi đang yêu cầu. Vì vậy, chúng ta chỉ cần đảo ngược nó để có được giải pháp mà chúng ta muốn.

Sạch sẽ , 73 byte

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

Hãy thử trực tuyến!

Xác định hàm $ :: String -> Stringlấy một chuỗi và trả về một chuỗi.

Canvas , 14 13 byte

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

Hãy thử nó ở đây!

Tùy viên , 37 byte

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

Hãy thử trực tuyến!

Phiên bản Pointfree (41 byte): Join&"+"##`\&:Id##`-&>Pairs@`'&0@Suffixes

Giải trình

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 byte

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

Hãy thử trực tuyến!

Powershell, 55 52 byte

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

Script mong đợi một chuỗi các chuỗi, mỗi chuỗi chứa một chữ số. Kịch bản thử nghiệm:

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

Đầu ra:

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

Japt , 13 byte

Lấy đầu vào là một mảng các chữ số.

í*¡ApYÃw)f q+

Thử nó

Giải trình

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

Thay thế

Lấy đầu vào là một chuỗi các chuỗi chữ số.

ËúTUÊ-EÃfn q+

Thử nó

Java 10, 82 78 byte

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

Câu trả lời JavaScript của cảng Arnauld (ES6) .
-2 byte nhờ @ceilingcat .
-2 byte nhờ Arnauld .

Hãy thử trực tuyến.

Giải trình:

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 byte

	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

Hãy thử trực tuyến!

Đã lưu toàn bộ byte bằng cách xử lý chuỗi thay vì số học!

sed -E ,109 99 97 75 74 byte

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

Mỗi dòng của đầu vào được coi là một số riêng biệt. Hãy thử trực tuyến .

Giải trình:

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

Tôi có thể chơi golf xa hơn, tôi đoán vậy.

Brainfuck, 147 byte

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

Hãy thử trực tuyến! (Bạn sẽ phải đánh dấu vào ô được đánh dấu "!" Và nhập thông tin đầu vào của bạn sau "!" Trên dòng thứ hai của mã nếu không nó sẽ tiếp tục yêu cầu đầu vào mãi mãi.)

Đây có lẽ sẽ không phải là câu trả lời ngắn nhất hoặc chơi golf ngắn nhất có thể nhưng nó khá thú vị để thử và làm điều này trong Brainfuck vì vậy tôi cũng có thể đăng nó.

Như @JoKing đã chỉ ra, chương trình này không xóa 0. Tôi sẽ cố gắng khắc phục điều này nhưng nó có thể khá khó khăn.

Giải trình:

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

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

Hãy thử trực tuyến!

Lấy đầu vào là một vectơ của chữ số. Đầu ra với một +khoảng trắng trước và sau mỗi khoảng trống , và bao gồm một lượng không gian hàng đầu khác nhau.

Đây là một chuyến tàu. Nó được chia thành như sau.

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

Hàm đầu tiên là ⌽, điều này đảo ngược mảng, vì vậy 1 0 2trở thành 2 0 1.

Sau đó chúng ta đi vào (10×⊢)\, được áp dụng cho mảng đảo ngược. Phần này được lấy cảm hứng từ câu trả lời của ngn cho thử thách Boustrophedonise. Mượn lời giải thích của ngn, đưa ra một vectơ các chữ số A B C ..., áp dụng (10×⊢)\trên vectơ này sẽ cho những điều sau đây.

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

Trên 2 0 1, (10×⊢)\cho 2 0 100.

Tiếp đến 0~⍨. Điều này loại bỏ tất cả 0s từ mảng, cho 2 100.

Cuối cùng cũng đến +s. {⍵'+'⍺}/là một giảm bắt đầu từ bên phải nối các đối số bên trái với a +, tiếp theo là các đối số bên phải. Thực tế, điều này đảo ngược mảng trong khi chèn +s. Điều này cho 100 '+' 2, được hiển thị như 100 + 2.

MathGolf , 12 11 10 byte

hrzúm*ç'+u

Hãy thử trực tuyến!

Giải trình

Lệnh đầu tiên là không cần thiết vì đầu vào có thể được đưa ra dưới dạng danh sách các chữ số.

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

Tôi có thể thêm một toán tử nhân theo cặp là một byte, nhưng hiện tại nó không phải là một phần của ngôn ngữ. Sau đó tôi có thể loại bỏ một byte khỏi giải pháp này.