Развернуть некоторое число

23

Эта задача основана на этом вопросе Stackoverflow .

Если в качестве входных данных положительное число, выведите его в виде суммы каждой цифры, умноженной на представление степени 10.

вход

Число, как целое число, строка или список цифр / символов.

  • Число будет строго положительным.
  • Если вы примете число в виде строки или списка, оно не будет начинаться с 0.

Выход

Строка, представляющая сумму всех соответствующих цифр base-10, каждая из которых умножается на соответствующую мощность base-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 
— Оливье Грегуар
источник
— Оливье Грегуар
— caird coinheringaahing
Можем ли мы вывести сумму в обратном порядке? Ex. 123 = 3 + 20 + 100
— Quintec
1
разрешены ли начальные и конечные пробелы?
— августа
2
Каков ожидаемый результат для входа 0? (Если 0 является недопустимым вводом в первую очередь, то он должен быть удален из примеров недействительных выводов IMO)
— Педро A

Ответы:

11

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='+')

-3 байта ов. Спасибо за полезный совет :) -4 байта от mypetlion. Спасибо за этот совет

— Гарет Ма
источник
Добро пожаловать в PPCG! Вы можете улучшить свой счет, изменив порядок выражения if на if'0'<t[i]и изменив формулу с x-i-1на x+~i. Вот ссылка TIO с пошаговыми изменениями.
— овс
Измените printоператор, print(*[t[i]+'0'*(x+~i)for i in range(x)if'0'<t[i]],sep='+')чтобы сохранить 1 байт.
— Mypetlion
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 '+'.
— Деннис
источник
3
Умный подход!
— Quintec
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
источник
7

р , 55 байт

Предполагая, что целые числа меньше 1e10, что в любом случае больше, чем максимальное 32-битное целое число ...

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

Попробуйте онлайн!

— j.doe
источник
Ну, 10^(nchar(n):1-1теоретически будет работать для любого целого числа ...
— Джузеппе
1
Было бы, но посмотрите на все эти дополнительные байты!
— J.Doe
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
источник
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”+
— Джонатан Аллан
источник
5

Хаскелл, 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 +
— Ними
источник
2
tail.(>>=('+':)).filter(>="1").scanr((.('0'<$)).(:))""экономит 6 байт Попробуйте онлайн! ,
— Delfad0r
1
@ Delfad0r: хорошо, спасибо большое!
— Ними
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 "+"
— Emigna
источник
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(...)затем объединяет полученные строки с +символами.

— Джонатан Аллан
источник
4

Haskell , 56 55 52 байта

-4 байта благодаря Ними .

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

Попробуйте онлайн!

— овс
источник
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
— Джо Кинг
источник
3

APL (Dyalog), 46 41 40 байтов

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

-5 байт благодаря @dzaima

Функция анонимного префикса. Принимает ввод в виде строки. TIO

(Это мой первый раз, когда я использую APL на PPCG, возможно, в гольф. Кроме того, проклинаю вас, ноль!)

— Quintec
источник
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

Замените все завершающие цифры нулями.

¶
+

Присоединяйтесь к результатам с +.

— Нил
источник
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);}

Попробуйте онлайн!

— ErikF
источник
3

Брахилог , 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"
— Kroppeb
источник
ОП теперь указал, что 0 не является вводом, который вы должны обрабатывать, поэтому вы можете удалить его |∧Ṡс конца. :)
— DLosc
3

Brachylog v2, 15 байт

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

Попробуйте онлайн!

Очень, очень неэффективно.

Каким-то образом это позволяет использовать только 6 байтов на том, что в большинстве языков является жесткой частью (разбиение числа на форму a 10 b, где a - одна цифра в порядке убывания), и целых 9 байтов для «соединения с +"(который встроен в большинство языков игры в гольф, но не на брахилог).

В отличие от большинства моих представлений на брахилоге (которые являются функциями), это полная программа, получающая данные из стандартного ввода и производящая вывод в стандартном выводе.

объяснение

~+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
источник
2

Атташе , 37 байт

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

Попробуйте онлайн!

Версия Pointfree (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"
— Конор О'Брайен
источник
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
— Mazzy
источник
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+

Попытайся

— мохнатый
источник
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;}

Порт Арно JavaScript (ES6) ответ «s .
-2 байта благодаря @ceilingcat .
-2 байта благодаря Арно .

Попробуйте онлайн.

Объяснение:

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`
— Кевин Круйссен
источник
Я полагаю, что этот ответ также будет правильным для исходного вопроса . :) (Может быть, с n%mприсвоением переменной для удобства чтения.)
— Арно
1
Ницца! Мое оригинальное решение было 91 байт.
— Оливье Грегуар,
1
@ceilingcat На самом деле, m<nдолжно работать.
— Арно
2

сед-Е ,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
источник
Привет и добро пожаловать в PPCG. Ваш ответ выглядит хорошо, хотя я не понимаю, почему вы добавили тестовый набор BADC0FFEE . Я думаю, что проблема заключается только в десятичных представлениях.
— Джонатан Фрех,
Вам не нужно обрабатывать 01010101010или 000000, в соответствии со спецификацией задачи. Сохраняет ли это какие-либо байты?
— Деннис
@Dennis Скорее всего нет, поскольку ведущие нули и промежуточные ведут себя одинаково, поэтому мне все равно нужно их стереть.
— hidefromkgb
2

Brainfuck, 147 байтов

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

Попробуйте онлайн! (Вам нужно будет поставить галочку в поле «!» И ввести свой ввод после «!» Во второй строке кода, в противном случае он будет продолжать запрашивать ввод навсегда.)

Вероятно, это не будет самый короткий ответ или игра в гольф к самому короткому из возможных, но было довольно интересно попробовать сделать это в Brainfuck, так что я мог бы также опубликовать это.

Как отметил @JoKing, эта программа не удаляет нули. Я постараюсь это исправить, но это может быть довольно сложно.

Объяснение:

>>+[[<]>+[>],]                            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
источник
Извините, но это не удаляет нули, как указано. Попробуйте онлайн!
— Джо Кинг,
Спасибо, я этого не заметил. Я постараюсь это исправить. Пока я буду, я буду редактировать свой пост
— 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.

Наконец приходит +с. {⍵'+'⍺}/это сокращение, начинающееся справа, которое объединяет левый аргумент с a +, за которым следует правый аргумент. По сути, это инвертирует массив при вставке +s. Это дает 100 '+' 2, который отображается как 100 + 2.

— Kritixi Lithos
источник
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

Я мог бы добавить оператор попарного умножения, который составляет один байт, но это не является частью языка. Тогда я мог бы удалить один байт из этого решения.

— maxb
источник
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.