Desafio

Calcule a soma estranha de dois números naturais (também conhecidos como adição lunar):

Dado A=... a2 a1 a0e B=... b2 b1 b0dois números naturais escritos na base decimal, a soma estranha é definida, com base na operação máxima , como: 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)

Entrada

Dois números naturais

É permitido todo o seguinte:

• Cordas com preenchimento zero (mesmo comprimento)
• Cordas acolchoadas no espaço esquerdo
• Cordas acolchoadas no espaço direito
• Matriz de duas cordas acolchoadas
• Conjunto de caracteres 2D preenchido com espaço

Resultado

Um número natural

Exemplo

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

Regras

• A entrada e a saída podem ser fornecidas em qualquer formato conveniente (escolha o formato mais apropriado para o seu idioma / solução).
• Não há necessidade de lidar com valores negativos ou entrada inválida
• Um programa completo ou uma função são aceitáveis. Se uma função, você pode retornar a saída em vez de imprimi-la.
• Se possível, inclua um link para um ambiente de teste on-line para que outras pessoas possam experimentar seu código!
• As brechas padrão são proibidas.
• Isso é código-golfe, portanto todas as regras usuais de golfe se aplicam e o código mais curto (em bytes) vence.

Python 2 , 20 bytes

lambda*a:map(max,*a)

Experimente online!

E / S como listas de dígitos com preenchimento 0.

Geléia , 1 byte

»

Experimente online!

E / S como listas de dígitos com preenchimento 0.

R , 68 bytes 65

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

Experimente online!

Entrada como números inteiros, saída como lista de dígitos.

Se listas de dígitos com preenchimento zero fossem permitidas, simplesmente pmaxseria suficiente.

MATL , 2 bytes

X>

Escolha o formato mais apropriado para o seu idioma / solução

O formato de entrada é: matriz de caracteres 2D de duas linhas, cada uma correspondente a uma linha, com o número menor preenchido à esquerda com espaços. Por exemplo

17210
  701

que em MATL é definido como

['17210'; '  701']

Experimente online!

Explicação

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

Python 2 , 73 60 56 bytes

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

Experimente online!

Recebe a entrada como duas cadeias e retorna uma lista de dígitos

Alternativo:

Recebe entrada como dois números inteiros; mesma saída

Python 2 , 60 59 bytes

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

Experimente online!

Java 10, 78 57 bytes

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

Entrada como duas matrizes de caracteres preenchidos com espaço.

Modifica a primeira matriz de entrada em vez de retornar uma nova para salvar 21 bytes (graças a @ OlivierGrégoire ).

Experimente online.

Explicação:

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 bytes

-2 bytes graças a Jonah

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

Experimente online!

Entrada e saída como lista (s) de dígitos

Japonês, 9 8 7 bytes

Recebe a entrada como uma matriz de matrizes de dígitos.

mÔÕÔËrw

Tente

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

Se aceitar matrizes preenchidas com zero como entrada é permitida (atualmente ela se enquadra em um "formato conveniente", mas desconfio que essa não seja a intenção do desafiante), isso pode ser de 3 bytes.

íwV

Tente

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

Perl 6 , 37 bytes

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

Experimente online!

Recebe a entrada como uma lista de listas de dígitos.

05AB1E , 9 6 5 bytes

-3 graças a Emigna
-1 graças a Shaggy

íζ€àR

Recebe entrada como uma lista de listas de dígitos

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

Experimente online! ou Experimente todos os casos de teste

Perl 6 , 15 bytes

{[~] [Zmax] $_}

Experimente online!

Aceita entrada como uma lista de matrizes de caracteres preenchidas com espaço, embora para esse desafio o formato de entrada relaxado o torne bastante chato. Como alternativa, aqui está o programa que pega uma lista de dois números inteiros:

Perl 6 , 41 bytes

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

Experimente online!

Se você não se importa com uma quantidade enorme de espaço em branco, também pode remover o +da frente.

Explicação:

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

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

Entrada / saída como strings, experimente online!

Explicação

A função psubstitui cada caractere por um espaço, usando p b++ae, p a++bportanto, tem o mesmo comprimento. Dessa forma, podemos usar zipWithsem perder nenhum elemento, usando maxcom ele funciona porque um (espaço) tem um ponto de código mais baixo do que qualquer um dos caracteres ['0'..'9'].

JavaScript (ES6), 51 49 bytes

Nota: esta resposta foi publicada antes que os formatos de E / S soltos fossem explicitamente permitidos. Com matrizes de dígitos preenchidas com zero, isso pode ser feito em 33 bytes (mas é muito menos interessante, IMHO).

Recebe a entrada como dois números inteiros. Retorna um número inteiro.

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

Experimente online!

Comentado

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

Versão alternativa

Mesmo formato de E / S.

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

Experimente online!

Tcl , 156 bytes

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)}] ""}

Experimente online!

Não sou muito golfista, mas tive que tentar. Golf mais tarde!

Lote, 120 bytes

@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%

Recebe a entrada como parâmetros da linha de comando. A versão de 188 bytes funciona em números inteiros arbitrários:

@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%

Recebe entrada em STDIN.

Galho , 125 bytes

Quando vi esse desafio, pensei: "deixe-me usar uma linguagem de modelo! Com certeza é uma boa opção"

Eu estava errado ... tão errado ... ... Mas foi divertido!

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

Isso requer que "strict_variables" esteja definido como false(valor padrão).

Para usar essa macro, você pode fazer o seguinte:

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

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

Deve exibir 167.

Você pode tentar isso em https://twigfiddle.com/rg0biy
("strict_variables" está desativado, está ativado por padrão no site)

Casca , 5 bytes

↔¤żY↔

Aceita convenientemente a entrada / saída como lista de dígitos, tente on-line ou verifique tudo!

Explicação

↔¤ż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 bytes

|>E:o

Execute e depure

Este programa recebe entrada como uma matriz de seqüências de caracteres.

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

Execute este

Esta é a primeira vez que vi um uso da instrução overlay "in the wild".

SNOBOL4 (CSNOBOL4) , 153 bytes

	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

Experimente online!

Pitão, 5 bytes

meSdC

Recebe entrada como matriz de duas seqüências de caracteres preenchidas com espaço.

meSd       map greatest
    C      on the transpose of input

Experimente aqui .

Japonês , 4 bytes

A entrada é tomada como uma matriz de duas matrizes numéricas preenchidas com 0.

y_rw

Experimente online!

Ceilão, 55/99

Com seqüências de 0 ou espaço preenchidas do mesmo comprimento (retornando uma iterável de caracteres):

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

Com strings preenchidas com 0 ou espaço (retornando uma String):

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

Com cadeias de comprimento possivelmente diferente (retornando uma String):

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

C # (.NET Core) , 57 bytes

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

-1 bytes adicionando currying

Experimente Online

Ruby , 25 bytes

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

Experimente online!

Lista pré-acolchoada blá blá. (Embora pareça um pouco trapaceiro.)

Retina 0.8.2 , 39 bytes

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

Experimente online! O link inclui o conjunto de testes. A versão anterior de Retina 1 de 45 bytes aceita cadeias de caracteres sem preenchimento:

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

Experimente online! O link inclui o conjunto de testes. Explicação:

P^`.+

Coloque os dois valores no mesmo comprimento. (Apenas Retina 1. Existem maneiras de emular isso na Retina 0.8.2, mas elas não são muito eficientes.)

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

Transponha os valores.

%O`.

Classifique cada par em ordem.

¶.?

Exclua todos os dígitos baixos e as novas linhas excedentes.

Carvão , 8 bytes

⭆θ⌈⟦ι§ηκ

Experimente online! Link é a versão detalhada do código. Explicação:

 θ          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

A versão de 10 bytes "adiciona" qualquer número de cadeias acolchoadas:

⭆§θ⁰⌈Ｅθ§λκ

Experimente online! Link é a versão detalhada do código. A versão anterior de 14 bytes aceita cadeias não preenchidas:

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

Experimente online! Link é a versão detalhada do código. Explicação:

  θ             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

A versão de 17 bytes "adiciona" qualquer número de strings:

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

Experimente online! Link é a versão detalhada do código.

Mathematica 50 bytes

a = 543; b = 791;

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

(* 793 *)