Bu zorluk, bu Stackoverflow sorusuna dayanıyor .

Girdi olarak pozitif bir sayı ile, onu her 10 basamağın gösterimi ile çarpılan toplamın toplamı olarak verin.

Giriş

Bir tamsayı olarak bir sayı, bir dize veya rakam / karakter listesi.

• Sayı kesinlikle pozitif olacak.
• Numarayı bir dize veya liste olarak kabul ederseniz, a ile başlamaz 0.

Çıktı

Her biri ilgili 10 bazının çarpımıyla, her 10 baz bazın bir rakamını temsil eden bir dize. Bir toplam olarak temsil edilir a + b. İsterseniz, +işaretin her iki yanında bir taneye kadar boşluk kullanabilirsiniz . İşlenenler azalan düzende listelenir.

• 0 asla geçerli bir işlenen olamaz.
• +İşareti (boşluk ile çevrili ya da değil) ön ya da arka bölüm olabilir.

Örnekler

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

Geçersiz çıktılar

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

Bu kod-golf yani bayt cinsinden en kısa kod kazanır!

Python 3: 83 80 79 Bayt

Çevrimiçi Deneyin!

İlk Code Golf gönderim.

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

-3 Bayt by ovs. Bu yararlı bahşiş için teşekkür ederim :) -4) Bu kısaltma ipucu için teşekkür ederim :)

Jöle , 9 bayt

ḊƬḌQIAj”+

Çevrimiçi deneyin!

Nasıl çalışır

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

Bir tamsayı olarak girdi alır.

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

Çevrimiçi deneyin!

Yorumlananlar

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 bayt

Tamsayıların hepsinin 1e10'un altında olduğunu varsayarsak, bu maksimum 32 bit tamsayıdan daha büyüktür ...

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

Çevrimiçi deneyin!

Shakespeare Programlama Dili , 807 806 805 804 bayt

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

Çevrimiçi deneyin!

İlk önce bir boş karakter çıkarsa -23 bayt

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

açıklama

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

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

Çevrimiçi deneyin!

Python 2 , 66 bayt

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

Çevrimiçi deneyin!

Jöle ,  12  11 bayt

J’⁵*Ṛ×ḟ0j”+

Sayıyı, basılan bir sayı listesi (Python biçiminde) olarak kabul eden tam bir program.

Çevrimiçi deneyin!

Nasıl?

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"

Önceki @ 12 bayt:

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

Haskell, 60 54 bayt

Düzenleme: Delfad0r sayesinde -6 bayt.

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

Giriş numarasını dize olarak alır.

Çevrimiçi deneyin!

    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 bayt

Dümdüz ileri uygulama.
Rakam listesi olarak girin.

āR<°*0K'+ý

Çevrimiçi deneyin!

açıklama

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

Python 2,64 bayt

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

Rakamların bir listesini alan nve bir dize döndüren adlandırılmamış bir işlev .

Çevrimiçi deneyin!

enumerate(n)başlangıçtan itibaren bir indeks ile index, itemgenelinde tuples verecekti .n0

Ancak enumerateaynı zamanda bu ayarlayarak, ikinci argüman olarak isteğe bağlı bir başlangıç indeksi alır -len(n)biz endeksleri (get e'lerini) -len(n), -len(n)+1, ..., -1.

Bu, herhangi bir öğe ( b) için gereken sondaki sıfırların sayısı anlamına gelir -1-e, ~ebu ~e*'0'da gereken sondaki sıfırları alır.

`b`tamsayı basamağının dize olarak temsilini alır bve +bunu bu sıfırlarla birleştirir.

if bgirişleri filtreler b==0.

'+'.join(...)daha sonra elde edilen dizeleri +karakterlerle birleştirir.

Python 2, 82 73 71 bayt

@Ovs sayesinde -9 bayt

@JonathanAllan sayesinde -2 bayt

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

Çevrimiçi Deneyin

Haskell , 56 55 52 bayt

Nimi sayesinde -4 bayt .

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

Çevrimiçi deneyin!

açıklama

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

Çevrimiçi deneyin!

Perl 6 , 38 bayt

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

Çevrimiçi deneyin!

Rakamların bir listesini alan ve bir dize döndüren adsız kod bloğu.

Açıklama:

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

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

@Dzaima sayesinde -5 bayt

Anonim önek işlevi. Bir dize olarak girdi alır. TIO

(Bu benim ilk kez PPCG'de APL kullanıyor, muhtemelen golf oynamaktadır. Ayrıca sizi lanetliyor, sıfırlar!)

Retina , 19 bayt

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

Çevrimiçi deneyin! Link, test durumlarını içerir. Açıklama:

L`[1-9]

Tüm sıfır olmayan rakamları listele

$
$&$.'*0

Her hane için, izleyen hane kadar sıfır ekleyin.

|'+

Her sonucu +varsayılan satırsonu yerine s ile ayırın .

Retina 0.8.2 , 21 bayt

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

Çevrimiçi deneyin! Link, test durumlarını içerir. Açıklama:

M&!`[1-9].*

Sıfır olmayan rakamlarla başlayan girişin tüm soneklerini listeleyin.

\B.
0

Tüm sondaki rakamları sıfırlarla değiştirin.

¶
+

+S ile sonuçları katılın .

C (gcc) , 71 69 bayt

Özyinelemeli fonksiyonun her adımı yazdırılacağı kısmı çıkarır ve sayının geri kalanını iletir.

Öneriniz için ceilingcat sayesinde.

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

Çevrimiçi deneyin!

Brachylog , 35 32 bayt

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

-3 bayt neden 0 geçerli bir giriş değil

Çevrimiçi deneyin! veya testsuite

açıklama

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

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

Çevrimiçi deneyin!

Çok, çok verimsiz.

Bir şekilde, bu forma bölme (çoğu dilde zor kısmı ne numarayı sadece 6 byte kullanarak yöneten bir 10 ^b bir "ile katılmak için tek basamaklı azalan sırada olan) ve bir bütün 9 bayt+"(çoğu golf dilinde yerleşik olan, ancak Brachylog olmayan)

Brachylog gönderimlerimin çoğundan (işlevler) farklı olarak, bu, standart girdiden girdi alan ve standart çıktıda çıktı üreten tam bir programdır.

açıklama

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

(Sebep wᵐ , normalden ziyade kullanılmasından , cheterojen bir liste ile uğraşıyor olmamızdır - hem sayı hem de dizeler içerir - ve bunların karışmasına izin vermek yerine, hepsini ayrı ayrı yazdırmak en basittir.)

Buradaki algoritma, uygun bir tane (!) Bulana kadar girdinin tüm katkılayıcı bölümleri üzerinde kaba kuvvet uygular. Brachylog, daha az olasılıklara ve artan düzende sıralanan olasılıklara ayrılmayı tercih eder, bu yüzden bulacağı ilk çözüm, sorunun sorduğu çözümün tersidir. Yani istediğimiz çözümü elde etmek için onu tersine çevirmeliyiz.

Temiz , 73 bayt

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

Çevrimiçi deneyin!

$ :: String -> StringBir dize alma ve bir dize döndürme işlevini tanımlar .

Tuval , 14 13 bayt

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

Burada dene!

Ataşesi , 37 bayt

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

Çevrimiçi deneyin!

Noktasız versiyon (41 bayt): Join&"+"##`\&:Id##`-&>Pairs@`'&0@Suffixes

açıklama

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 bayt

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

Çevrimiçi deneyin!

Powershell, 55 52 bayt

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

Script bir dizi dizisi bekler, her dize bir rakam içerir Test komut dosyası:

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

Çıktı:

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

Japt , 13 bayt

Girdiyi rakam dizisi olarak alır.

í*¡ApYÃw)f q+

Dene

açıklama

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

Alternatif

Girdiyi bir rakam dizesi olarak alır.

ËúTUÊ-EÃfn q+

Dene

Java 10, 82 78 bayt

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 Limanı'nın JavaScript (ES6) yanıtı . @Ceilingcat
sayesinde -2 bayt . Arnauld sayesinde -2 bayt .

Çevrimiçi deneyin.

Açıklama:

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 bayt

	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

Çevrimiçi deneyin!

Aritmetik işlem yerine string işlemi yaparak bir bütün baytı kurtardı!

S-E ,109 99 97 75 74 bayt

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

Girişin her satırı ayrı bir sayı olarak kabul edilir. Çevrimiçi deneyin .

Açıklama:

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

… Daha sonra golf oynayabilir, sanırım.

Brainfuck, 147 bayt

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

Çevrimiçi deneyin! ("!" İle işaretli olan kutucuğu işaretlemeniz ve girişinizi kodun ikinci satırındaki "!" İşaretinden sonra yazmanız gerekir, aksi takdirde sonsuza kadar girdi isteyecektir.)

Muhtemelen en kısa sürede cevap vermeyecek veya olabilecek en kısa sürede golf oynayamayacak, ancak Brainfuck'ta bunu denemek ve yapmak oldukça eğlenceliydi.

@JoKing'in belirttiği gibi, bu program 0'ları kaldırmaz. Bunu düzeltmeye çalışacağım ama oldukça zor olabilir.

Açıklama:

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

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

Çevrimiçi deneyin!

Girdiyi bir rakam vektörü olarak alır. Her birinden önce ve sonra bir boşluk içeren çıktılar +ve değişken miktarda ana boşluk içerir.

Bu bir tren. Aşağıdakilere ayrılmıştır.

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

İlk işlev ⌽, bu diziyi tersine çevirir, yani 1 0 2olur 2 0 1.

Sonra (10×⊢)\tersine çevrilen diziye uygulanan içeri giriyoruz . Bu bölüm ngn'in Boustrophedonise mücadelesine verdiği cevaba dayanıyor. Borçlanma ngn'in açıklaması, bir rakam vektörü verildiğinde , bu vektöre A B C ...uygulama (10×⊢)\aşağıdakileri verir.

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

Açık 2 0 1, (10×⊢)\verir 2 0 100.

Sıradaki geliyor 0~⍨. Bu 0, dizideki tüm s'leri siler 2 100.

Sonunda +s geliyor . {⍵'+'⍺}/sol argümanı a ile birleştiren sağdan başlayan ve ardından sağ argümanı içeren bir azalmadır +. Etkili, bu +s eklerken diziyi tersine çevirir . Bu 100 '+' 2, olarak görüntülenen verir 100 + 2.

MathGolf , 12 11 10 bayt

hrzúm*ç'+u

Çevrimiçi deneyin!

açıklama

Girdi basamak listesi olarak verilebildiği için ilk komut gerekli değildir.

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

Bir bayt olan bir çift çarpım operatörü ekleyebilirim, ancak şu anda dilin bir parçası değil. Sonra bu çözümden bir bayt kaldırabilirim.