Вызов

Вычислите странную сумму двух натуральных чисел (также называемых лунным сложением):

Для заданных A=... a2 a1 a0и B=... b2 b1 b0двух натуральных чисел, записанных в десятичной базе, странная сумма определяется на основе максимальной операции следующим образом: A+B=... max(a2,b2) max(a1,b1) max(a0,b0)

   ...         a2         a1         a0
 + ...         b2         b1         b0
 ----------------------------------------
   ...  max(a2,b2) max(a1,b1) max(a0,b0)

вход

Два натуральных числа

Все следующее разрешено:

• Струны с нулевой подкладкой (одинаковой длины)
• Строки с отступом влево
• Строки с пробелами в правой части
• Массив из двух строк
• 2D симметричный массив символов

Выход

А натуральные числа

пример

1999+2018-->2999
17210+701-->17711
32+17-->37
308+250-->358
308+25-->328

правила

• Ввод и вывод могут быть предоставлены в любом удобном формате (выберите наиболее подходящий формат для вашего языка / решения).
• Нет необходимости обрабатывать отрицательные значения или неверный ввод
• Либо полная программа или функция приемлемы. Если функция, вы можете вернуть вывод, а не распечатать его.
• Если возможно, укажите ссылку на среду онлайн-тестирования, чтобы другие люди могли опробовать ваш код!
• Стандартные лазейки запрещены.
• Это код-гольф, поэтому применяются все обычные правила игры в гольф, и выигрывает самый короткий код (в байтах).

Python 2 , 20 байт

lambda*a:map(max,*a)

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

Ввод / вывод в виде 0-предварительно заполненных списков цифр.

Желе , 1 байт

»

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

Ввод / вывод в виде 0-предварительно заполненных списков цифр.

R , 68 65 байт

function(x)apply(outer(x,10^(max(nchar(x)):1-1),`%/%`)%%10,2,max)

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

Ввод в виде целых чисел, вывод в виде списка цифр.

Если бы списки цифр были дополнены нулями, то просто pmaxхватило бы.

MATL , 2 байта

X>

Выберите наиболее подходящий формат для вашего языка / решения

Формат ввода: 2D-массив символов из двух строк, каждая из которых соответствует строке, с более коротким числом, дополненным пробелами. Например

17210
  701

который в MATL определяется как

['17210'; '  701']

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

объяснение

      % Implicit input: 2D char array with two rows 
X>    % Take maximum of (code points of) each column
      % Implicit display

Python 2 , 73 60 56 байт

lambda a,b:map(max,zip(a.rjust(len(b)),b.rjust(len(a))))

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

Принимает ввод в виде двух строк и возвращает список цифр

Альтернатива:

Принимает ввод как два целых числа; тот же выход

Python 2 , 60 59 байт

lambda*i:map(max,zip(*['%*d'%(len(`max(i)`),v)for v in i]))

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

Java 10, 78 57 байт

a->b->{for(int i=a.length;i-->0;)if(a[i]<b[i])a[i]=b[i];}

Вводится в виде двух массивов символов с пробелами.

Изменяет первый входной массив вместо того, чтобы возвращать новый, чтобы сохранить 21 байт (благодаря @ OlivierGrégoire ).

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

Объяснение:

a->b->{            // Method with two char-array parameters and String return-type
  for(int i=a.length;i-->0;)
                   //  Loop `i` in the range (length, 0]:
    if(a[i]<b[i])  //   If the `i`'th character in input `a` is smaller than in input `b`:
      a[i]=b[i];}  //    Change the `i`'th character in `a` to the `i`'th character of `b`

J , 14 12 байт

-2 байта благодаря Ионе

(>./@,:)&.|.

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

Ввод и вывод в виде списка (ов) цифр

Japt, 9 8 7 байт

Принимает ввод как массив массивов цифр.

mÔÕÔËrw

Попытайся

m            :Map
 Ô           :  Reverse
  Õ          :Transpose
   Ô         :Reverse
    Ë        :Map
     r       :  Reduce by
      w      :  Maximum

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

íwV

Попытайся

í       :Interleave the first input
  V     :With the second
 w      :Reduce each pair by maximum

Perl 6 , 37 байт

{[R~] roundrobin($_».reverse)».max}

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

Вводит в виде списка списков цифр.

05AB1E , 9 6 5 байт

-3 благодаря Эмигне
-1 благодаря Шегги

íζ€àR

Принимает ввод как список списков цифр

í      # Reverse both inputs
 ζ     # Zip
  ۈ   # Keep the bigger digits
    R  # Reverse

Попробуйте онлайн! или попробуйте все тестовые случаи

Perl 6 , 15 байт

{[~] [Zmax] $_}

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

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

Perl 6 , 41 байт

{+[~] [Zmax] $_>>.fmt("%{.max}d")>>.comb}

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

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

Объяснение:

{                                       }  # Anonymous code block
             $_>>    # Map each integer to 
                 .fmt("%{.max}d") # The number padded by the max of the list spaces
                                 >>.comb   # And split each to list of characters
      [Zmax]  # Get the max of each digit at each index
              # This works because space is coerced to 0
              # Otherwise we would have to add a 0 to the formatting string
  [~]   # Join the list of digits and spaces
 +      # And coerce the string to a number to get rid of leading whitespace

Haskell , 40 байт

a#b=zipWith max(p b++a)$p a++b
p=(' '<$)

Ввод / вывод в виде строк, попробуйте онлайн!

объяснение

Функция pзаменяет каждый символ пробелом, используя p b++aи p a++b, следовательно, одинаковую длину. Таким образом, мы можем использовать zipWithбез потери каких-либо элементов, использование maxс ним работает, потому что (пробел) имеет более низкую кодовую точку, чем любой из символов ['0'..'9'].

JavaScript (ES6), 51 49 байт

NB. Этот ответ был опубликован до того, как свободные форматы ввода / вывода были явно разрешены. С заполненными нулями массивами цифр это может быть сделано в 33 байтах (но гораздо менее интересно, ИМХО).

Принимает ввод как два целых числа. Возвращает целое число.

f=(a,b,t=10)=>a|b&&(a%t<b%t?b:a)%t+t*f(a/t,b/t)|0

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

комментарии

f = (                     // f = recursive function taking:
  a,                      //   a = first integer
  b,                      //   b = second integer
  t = 10                  //   t = 10 (which is used 6 times below)
) =>                      //
  a | b                   // bitwise OR between a and b to test whether at least one of
                          // them still has an integer part
  &&                      // if not, stop recursion; otherwise:
  (                       //
    a % t < b % t ? b : a // if a % 10 is less than b % 10: use b; otherwise: use a
  ) % t +                 // isolate the last decimal digit of the selected number
  t *                     // add 10 times the result of
  f(a / t, b / t)         // a recursive call with a / 10 and b / 10
  | 0                     // bitwise OR with 0 to isolate the integer part

Альтернативная версия

Тот же формат ввода / вывода.

f=(a,b)=>a|b&&[f(a/10,b/10)]+(a%10<b%10?b:a)%10|0

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

Tcl , 156 байт

proc S a\ b {join [lmap x [split [format %0[set l [expr max([string le $a],[string le $b])]]d $a] ""] y [split [format %0$l\d $b] ""] {expr max($x,$y)}] ""}

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

Не очень в гольфе, но я должен был попробовать. Будет ли это гольф позже!

Пакет, 120 байт

@set/aw=1,x=%1,y=%2,z=0
@for /l %%i in (0,1,9)do @set/a"z+=w*((v=y%%10)+(v-=x%%10)*(v>>4)),y/=10,x/=10,w*=10
@echo %z%

Принимает ввод как параметры командной строки. 188-байтовая версия работает с целыми числами произвольной длины:

@set/px=
@set/py=
@set z=
:l
@if %x:~-1% gtr %y:~-1% (set z=%x:~-1%%z%)else set z=%y:~-1%%z%
@set x=%x:~,-1%
@set y=%y:~,-1%
@if "%x%" neq "" if "%y%" neq "" goto l
@echo %x%%y%%z%

Принимает участие в STDIN.

прут , 125 байт

Когда я увидел этот вызов, я подумал: «Позвольте мне использовать язык шаблонов! Конечно, это хорошо подходит»

Я был неправ ... так неправильно .... ... Но было весело!

{%macro a(a,b,s='')%}{%for k,x in a|reverse|split('')%}{%set s=max(x,(b|reverse|split('')[k]))~s%}{%endfor%}{{s}}{%endmacro%}

Для этого необходимо, чтобы для "strict_variables" было установлено значение false (значение по умолчанию).

Чтобы использовать этот макрос, вы можете сделать так:

{% import 'file.twig' as my_macro %}

{{ my_macro.a(195,67) }}

Должен отобразиться 167.

Вы можете попробовать это по адресу https://twigfiddle.com/rg0biy
(«strict_variables» отключен, он включен по умолчанию на веб-сайте)

Шелуха , 5 байт

↔¤żY↔

Удобно принимает ввод / вывод в виде списка цифр, попробуйте онлайн или проверьте все!

объяснение

↔¤żY↔  -- example inputs [1,4] [3,2]
 ¤  ↔  -- reverse the arguments of: [4,1] [2,3]
  żY   -- | zipWith (keeping elements of longer) max: [4,3]
↔      -- reverse: [3,4]

Stax , 5 байт

|>E:o

Запустите и отладьте его

Эта программа принимает входные данные в виде массива строк.

|>  Right align inputs (filling with \0)
E   "Explode" array onto stack separately
:o  "Overlay" Keep the maximum element respective element from two arrays.

Запустите этот

Это первый раз, когда я увидел использование инструкции наложения «в дикой природе».

SNOBOL4 (CSNOBOL4) , 153 байта

	X =INPUT
	Y =INPUT
	Y =DUPL(0,SIZE(X) - SIZE(Y)) Y
S	X LEN(1) . A REM . X	:F(O)
	Y LEN(1) . B REM . Y
	O =O GT(A,B) A	:S(S)
	O =O B	:(S)
O	OUTPUT =O
END

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

Pyth, 5 байт

meSdC

Принимает ввод как массив из двух строк с пробелами.

meSd       map greatest
    C      on the transpose of input

Попробуй это здесь .

Japt , 4 байта

Входные данные принимаются в виде массива из двух числовых массивов с 0 дополнениями.

y_rw

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

Цейлон, 55/99

С 0- или пробелами строк одинаковой длины (возвращая итерируемые символы):

function t(String a,String b)=>zipPairs(a,b).map(max);

С 0- или пробелами (возвращая String):

String t(String a,String b)=>String(zipPairs(a,b).map(max));

Со строками разной длины (возвращая строку):

String u(String a,String b)=>String(zipPairs(a.padLeading(b.size),b.padLeading(a.size)).map(max));

C # (.NET Core) , 57 байт

a=>b=>a.Select((x,i)=>a[i]>b[i]?x:b[i])

-1 байт при добавлении карри

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

Рубин , 25 байт

->a,b{a.zip(b).map &:max}

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

Предварительно дополненный список бла-бла. (Хотя это немного похоже на обман.)

Сетчатка 0.8.2 , 39 байт

+`^(.*)(.)¶(.*)(.)
$1¶$3¶$2$4
%O`.
¶.?

Попробуйте онлайн! Ссылка включает тестовый набор. Предыдущая 45-байтовая версия Retina 1 допускает незаполненные строки:

P^`.+
+`^(.*)(.)¶(.*)(.)
$1¶$3¶$2$4
%O`.
¶.?

Попробуйте онлайн! Ссылка включает тестовый набор. Объяснение:

P^`.+

Дополните оба значения одинаковой длиной. (Только Retina 1. Есть способы подражать этому в Retina 0.8.2, но они не очень хороши).

+`^(.*)(.)¶(.*)(.)
$1¶$3¶$2$4

Транспонировать значения.

%O`.

Сортировка каждой пары в порядке.

¶.?

Удалите все младшие цифры и лишние новые строки.

Древесный уголь , 8 байт

⭆θ⌈⟦ι§ηκ

Попробуйте онлайн! Ссылка на подробную версию кода. Объяснение:

 θ          First input
⭆           Map over characters and join
  ⌈         Maximum of
   ⟦        List of
    ι       Current character of first input and
      η     Second input
     §      Indexed by
       κ    Current index
            Implicitly print

10-байтовая версия «добавляет» любое количество дополняемых строк:

⭆§θ⁰⌈Ｅθ§λκ

Попробуйте онлайн! Ссылка на подробную версию кода. Предыдущая 14-байтовая версия принимает незаполненные строки:

⭆◧θＬη⌈⟦ι§◧ηＬθκ

Попробуйте онлайн! Ссылка на подробную версию кода. Объяснение:

  θ             First input
 ◧              Padded to
   Ｌ            Length of
    η           Second input
⭆               Map over characters and join
     ⌈          Maximum of
      ⟦         List of
       ι        Current character of first input and
          η     Second input
         ◧      Padded to
           Ｌ    Length of
            θ   First input
        §       Indexed by
             κ  Current index
                Implicitly print

17-байтовая версия «добавляет» любое количество строк:

≔⌈ＥθＬιη⭆η⌈Ｅθ§◧ληκ

Попробуйте онлайн! Ссылка на подробную версию кода.

Mathematica 50 байтов

а = 543; б = 791;

FromDigits@MapThread[Max, IntegerDigits /@ {a, b}]

(* 793 *)