Diese Herausforderung basiert auf dieser Stackoverflow-Frage .

Mit einer positiven Zahl als Eingabe geben Sie diese als Summe jeder Ziffer multipliziert mit ihrer Zehnerpotenz aus.

Eingang

Eine Zahl, eine Ganzzahl, eine Zeichenfolge oder eine Liste von Ziffern / Zeichen.

• Die Zahl ist ausschließlich positiv.
• Wenn Sie die Nummer als Zeichenfolge oder Liste akzeptieren, beginnt sie nicht mit einem 0.

Ausgabe

Eine Zeichenfolge, die eine Summe aller relevanten 10-Basis-Ziffern darstellt, die jeweils mit ihrer jeweiligen 10-Basis-Potenz multipliziert werden. Eine Summe wird dargestellt als a + b. +Wenn Sie möchten, können Sie auf jeder Seite des Zeichens bis zu ein Leerzeichen verwenden . Die Operanden werden in absteigender Reihenfolge aufgelistet.

• 0 kann niemals ein gültiger Operand sein.
• Das +(von Leerzeichen umgebene oder nicht von Leerzeichen umgebene) Zeichen darf nicht der führende oder nachfolgende Teil sein.

Beispiele

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

Ungültige Ausgaben

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

Das ist Code-Golf, also gewinnt der kürzeste Code in Bytes!

Python 3: 83 80 79 Bytes

Probieren Sie es online!

Mein erster Code Golf Beitrag.

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

-3 Bytes von ovs. Vielen Dank für diesen nützlichen Tipp :) -4 Bytes von mypetlion. Danke für diesen Verkürzungstipp :)

Gelee , 9 Bytes

ḊƬḌQIAj”+

Probieren Sie es online!

Wie es funktioniert

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

Übernimmt die Eingabe als Ganzzahl.

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

Probieren Sie es online!

Kommentiert

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

Angenommen, alle Ganzzahlen liegen unter 1e10, was ohnehin größer als die maximale 32-Bit-Ganzzahl ist ...

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

Probieren Sie es online!

Shakespeare Programming Language , 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.

Probieren Sie es online!

-23 Byte, wenn zuerst ein Nullzeichen ausgegeben werden darf

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

Erläuterung

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

Probieren Sie es 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`

Probieren Sie es online!

Jelly ,  12  11 Bytes

J’⁵*Ṛ×ḟ0j”+

Ein vollständiges Programm, das die Nummer als Ziffernliste (im Python-Format) akzeptiert und das Ergebnis druckt.

Probieren Sie es online!

Wie?

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"

Vorherige @ 12 Bytes:

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

Haskell, 60 54 Bytes

Edit: -6 Bytes dank Delfad0r.

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

Nimmt die eingegebene Nummer als Zeichenfolge.

Probieren Sie es 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

Einfache Implementierung.
Eingabe als Ziffernliste.

āR<°*0K'+ý

Probieren Sie es online!

Erläuterung

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

Eine unbenannte Funktion, die eine Liste von Ziffern aufnimmt nund eine Zeichenfolge zurückgibt.

Probieren Sie es online!

enumerate(n)würde Tupel von index, itemacross nmit einem Index ab ergeben 0.

Doch enumerateauch einen optionalen Startindex als zweites Argument nimmt, um diese Einstellung zu -len(n)uns Indizes (get en) -len(n), -len(n)+1..., -1.

Das heißt , die Anzahl der erforderlichen nachfolgende Nullen für jeden Punkt ( b) ist -1-e, das ist ~eso ~e*'0'die erforderlichen nachgestellten Nullen erhält.

`b`Ruft eine Zeichenfolgendarstellung der Ganzzahlziffer ab bund +verknüpft diese mit diesen Nullen.

if bfiltert die Einträge mit b==0.

'+'.join(...)Fügt dann die resultierenden Zeichenfolgen mit +Zeichen zusammen.

Python 2, 82 73 71 Bytes

-9 Bytes dank @ovs

-2 Bytes dank @JonathanAllan

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

Probieren Sie es online

Haskell , 56 55 52 Bytes

-4 byte dank nimi .

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

Probieren Sie es online!

Erläuterung

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

Probieren Sie es online!

Perl 6 , 38 Bytes

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

Probieren Sie es online!

Anonymer Codeblock, der eine Liste von Ziffern verwendet und eine Zeichenfolge zurückgibt.

Erläuterung:

{                                    }  # 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 dank @dzaima

Anonyme Präfixfunktion. Übernimmt die Eingabe als Zeichenfolge. TIO

(Dies ist mein erstes Mal, dass ich APL auf PPCG verwende, wahrscheinlich golfen kann. Verfluche dich auch, Nullen!)

Retina , 19 Bytes

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

Probieren Sie es online!Link enthält Testfälle. Erläuterung:

L`[1-9]

Listen Sie alle Ziffern ungleich Null auf

$
$&$.'*0

Fügen Sie für jede Ziffer so viele Nullen hinzu, wie hintere Ziffern vorhanden waren.

|'+

Trennen Sie jedes Ergebnis mit +s anstelle der Standard-Newline.

Retina 0.8.2 , 21 Bytes

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

Probieren Sie es online! Link enthält Testfälle. Erläuterung:

M&!`[1-9].*

Listet alle Suffixe der Eingabe auf, die mit Ziffern ungleich Null beginnen.

\B.
0

Ersetzen Sie alle nachfolgenden Ziffern durch Nullen.

¶
+

Verbinden Sie die Ergebnisse mit +s.

C (gcc) , 71 69 Bytes

Jeder Schritt der rekursiven Funktion subtrahiert den zu druckenden Teil und übergibt den Rest der Zahl.

Danke an ceilingcat für den Vorschlag.

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

Probieren Sie es online!

Brachylog , 35 32 Bytes

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

-3 Bytes, weil 0 keine gültige Eingabe ist

Probieren Sie es online! oder Testsuite

Erläuterung

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

Probieren Sie es online!

Sehr, sehr ineffizient.

Irgendwie schafft es dies, nur 6 Bytes für den in den meisten Sprachen schwierigen Teil (Aufteilen der Zahl in die Form a 10 ^b, wobei a eine einzelne Ziffer ist, in absteigender Reihenfolge) und ganze 9 Bytes für den "Join with" zu verwenden +"(was in den meisten Golfsprachen eingebaut ist, aber nicht in Brachylog).

Im Gegensatz zu den meisten meiner Brachylog-Einreichungen (die Funktionen sind) ist dies ein vollständiges Programm, bei dem die Eingabe von der Standardeingabe übernommen und die Ausgabe auf der Standardausgabe erstellt wird.

Erläuterung

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

(Der Grund dafür wᵐist, cdass wir es mit einer heterogenen Liste zu tun haben, die sowohl Zahlen als auch Zeichenfolgen enthält. Statt diese zu mischen, ist es am einfachsten, sie alle einzeln auszudrucken.)

Der Algorithmus überwindet dabei alle additiven Partitionen der Eingabe, bis er eine passende findet (!). Brachylog bevorzugt die Unterteilung in weniger Möglichkeiten und sortiert die Möglichkeiten in aufsteigender Reihenfolge. Die erste Lösung ist also die Umkehrung der Lösung, nach der die Frage gestellt wird. Wir müssen es also nur umkehren, um die gewünschte Lösung zu erhalten.

Sauber , 73 Bytes

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

Probieren Sie es online!

Definiert die Funktion, $ :: String -> Stringdie eine Zeichenfolge übernimmt und eine Zeichenfolge zurückgibt.

Canvas , 14 13 Bytes

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

Probieren Sie es hier aus!

Attache , 37 Bytes

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

Probieren Sie es online!

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

Erläuterung

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

Probieren Sie es online!

Powershell, 55 52 Bytes

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

Skript erwartet ein Array von Zeichenfolgen, jede Zeichenfolge enthält eine Ziffer. Testskript:

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

Ausgabe:

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

Japt , 13 Bytes

Nimmt die Eingabe als ein Array von Ziffern.

í*¡ApYÃw)f q+

Versuch es

Erläuterung

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

Alternative

Übernimmt die Eingabe als Array von Ziffernfolgen.

ËúTUÊ-EÃfn q+

Versuch es

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

Antwort von Port of Arnauld auf JavaScript (ES6) .
-2 Bytes dank @ceilingcat .
-2 Bytes danke an Arnauld .

Probieren Sie es online aus.

Erläuterung:

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

Probieren Sie es online!

Sparte ein ganzes Byte, indem du Zeichenketten verarbeitest und nicht Arithmetik!

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:..?::

Jede Zeile der Eingabe wird als separate Nummer betrachtet. Probieren Sie es online aus .

Erläuterung:

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

… Kann man wohl weiter Golf spielen.

Brainfuck, 147 Bytes

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

Probieren Sie es online! (Sie müssen das mit "!" Markierte Kästchen ankreuzen und Ihre Eingabe nach dem "!" In der zweiten Codezeile eingeben, andernfalls werden Sie für immer nach Eingaben gefragt.)

Es wird wahrscheinlich nicht die kürzeste Antwort sein oder auf die kürzeste Antwort golfen, aber es hat ziemlich Spaß gemacht, dies in Brainfuck zu versuchen, also könnte ich es auch posten.

Wie @JoKing hervorhob, entfernt dieses Programm keine Nullen. Ich werde versuchen, das zu beheben, aber es könnte ziemlich schwierig sein.

Erläuterung:

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

Probieren Sie es online!

Übernimmt die Eingabe als Vektor von Ziffern. Ausgaben mit einem Leerzeichen vor und nach jedem+ und enthält eine variable Anzahl führender Leerzeichen.

Das ist ein Zug. Es ist wie folgt unterteilt.

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

Die erste Funktion ist ⌽, dies kehrt das Array um, 1 0 2wird also 2 0 1.

Dann kommen wir (10×⊢)\zu dem umgekehrten Array. Dieser Teil ist inspiriert von Ngns Antwort auf die Boustrophedonise-Herausforderung. Die Erklärung von ngn auszuleihen, wenn ein Vektor von Ziffern gegeben A B C ...ist und (10×⊢)\auf diesen Vektor angewendet wird, ergibt das Folgende.

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

Auf 2 0 1, (10×⊢)\gibt 2 0 100.

Als nächstes kommt 0~⍨. Dies entfernt alle 0s aus dem Array und gibt 2 100.

Endlich kommt das +s. {⍵'+'⍺}/ist eine Reduktion, die von rechts beginnt und das linke Argument mit einem verkettet +, gefolgt vom rechten Argument. Tatsächlich wird das Array beim Einfügen von +s umgekehrt . Das gibt 100 '+' 2, was als angezeigt wird 100 + 2.

MathGolf , 12 11 10 Bytes

hrzúm*ç'+u

Probieren Sie es online!

Erläuterung

Der erste Befehl wird nicht benötigt, da die Eingabe als Ziffernliste erfolgen kann.

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

Ich könnte einen paarweisen Multiplikationsoperator hinzufügen, der aus einem Byte besteht, der aber derzeit nicht Teil der Sprache ist. Dann könnte ich ein Byte aus dieser Lösung entfernen.