Desafío

Calcule la extraña suma de dos números naturales (también conocida como suma lunar):

Dado A=... a2 a1 a0y B=... b2 b1 b0dos números naturales escritos en la base decimal, la suma extraña se define, en función de la operación 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

Dos números naturales

Todo lo siguiente está permitido:

• Cuerdas con relleno cero (misma longitud)
• Cuerdas acolchadas en el espacio izquierdo
• Cuerdas acolchadas en el espacio derecho
• Matriz de dos cuerdas acolchadas
• Matriz de caracteres 2D rellena de espacio

Salida

A números naturales

Ejemplo

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

Reglas

• La entrada y la salida se pueden proporcionar en cualquier formato conveniente (elija el formato más apropiado para su idioma / solución).
• No es necesario manejar valores negativos o entradas inválidas
• Un programa completo o una función son aceptables. Si es una función, puede devolver el resultado en lugar de imprimirlo.
• Si es posible, incluya un enlace a un entorno de prueba en línea para que otras personas puedan probar su código.
• Las lagunas estándar están prohibidas.
• Este es el código de golf, por lo que se aplican todas las reglas habituales de golf, y gana el código más corto (en bytes).

Python 2 , 20 bytes

lambda*a:map(max,*a)

Pruébalo en línea!

E / S como listas de dígitos rellenadas con 0.

Gelatina , 1 byte

»

Pruébalo en línea!

E / S como listas de dígitos rellenadas con 0.

R , 68 65 bytes

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

Pruébalo en línea!

Entrada como enteros, salida como lista de dígitos.

Si se permitieran listas de dígitos con relleno cero, entonces simplemente pmaxsería suficiente.

MATL , 2 bytes

X>

Elija el formato más apropiado para su idioma / solución

El formato de entrada es: matriz de caracteres 2D de dos filas, cada una correspondiente a una línea, con el número más corto con espacios a la izquierda. Por ejemplo

17210
  701

que en MATL se define como

['17210'; '  701']

Pruébalo en línea!

Explicación

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

Pruébalo en línea!

Toma la entrada como dos cadenas y devuelve una lista de dígitos

Alternativa:

Toma la entrada como dos enteros; misma salida

Python 2 , 60 59 bytes

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

Pruébalo en línea!

Java 10, 78 57 bytes

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

Ingrese como dos matrices de caracteres con espacio.

Modifica la primera matriz de entrada en lugar de devolver una nueva para guardar 21 bytes (gracias a @ OlivierGrégoire ).

Pruébalo en línea.

Explicación:

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 gracias a Jonás

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

Pruébalo en línea!

Entrada y salida como lista (s) de dígitos

Japt, 9 8 7 bytes

Toma la entrada como una matriz de matrices de dígitos.

mÔÕÔËrw

Intentalo

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

Si se permiten las matrices rellenas con ceros como entrada (actualmente estaría en un "formato conveniente" pero sospecho que esa no es la intención del retador), entonces esto puede ser de 3 bytes.

íwV

Intentalo

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

Perl 6 , 37 bytes

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

Pruébalo en línea!

Toma la entrada como una lista de listas de dígitos.

05AB1E , 9 6 5 bytes

-3 gracias a Emigna
-1 gracias a Shaggy

íζ€àR

Toma datos como una lista de listas de dígitos

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

Pruébalo en línea! o Pruebe todos los casos de prueba

Perl 6 , 15 bytes

{[~] [Zmax] $_}

Pruébalo en línea!

Toma la entrada como una lista de matrices de caracteres rellenas de espacio, aunque para este desafío el formato de entrada laxa lo hace bastante aburrido. Alternativamente, aquí está el programa que toma una lista de dos enteros en su lugar:

Perl 6 , 41 bytes

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

Pruébalo en línea!

Si no le importa una gran cantidad de espacio en blanco, también puede eliminar el + desde el frente.

Explicación:

{                                       }  # 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 / salida como cadenas, pruébelo en línea!

Explicación

La función preemplaza cada carácter por un espacio, utilizando p b++ay, por p a++blo tanto, tienen la misma longitud. De esta manera podemos usar zipWithsin perder ningún elemento, usarlo maxfunciona porque un (espacio) tiene un punto de código más bajo que cualquiera de los caracteres ['0'..'9'].

JavaScript (ES6), 51 49 bytes

NB: esta respuesta se publicó antes de que se permitieran explícitamente los formatos de E / S sueltos. Con matrices de dígitos con relleno de cero, esto se puede hacer en 33 bytes (en mi humilde opinión, es mucho menos interesante).

Toma la entrada como dos enteros. Devuelve un entero.

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

Pruébalo en línea!

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

Versión alternativa

Mismo formato de E / S.

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

Pruébalo en línea!

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

Pruébalo en línea!

No es muy golfista, pero tuve que probarlo. ¡Lo jugaré más tarde!

Lote de 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%

Toma datos como parámetros de línea de comandos. La versión de 188 bytes funciona en enteros de longitud arbitraria:

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

Toma entrada en STDIN.

Ramita , 125 bytes

Cuando vi este desafío, pensé: "¡permítanme usar un lenguaje de plantilla! Seguro que encaja bien"

Estaba equivocado ... tan equivocado ... ¡Pero fue 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%}

Esto requiere que "estrictas_variables" esté establecido en false(valor predeterminado).

Para usar esta macro, puede hacer lo siguiente:

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

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

Debería mostrar 167.

Puede probar esto en https://twigfiddle.com/rg0biy
("estrictas_variables" está desactivado, está activado de forma predeterminada en el sitio web)

Casco , 5 bytes

↔¤żY↔

Convenientemente toma entrada / salida como una lista de dígitos, ¡ pruébelo en línea o verifique todo!

Explicación

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

Ejecutar y depurarlo

Este programa toma la entrada como una matriz de cadenas.

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

Ejecute este

Esta es la primera vez que veo un uso para la instrucción de superposición "en estado salvaje".

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

Pruébalo en línea!

Pyth, 5 bytes

meSdC

Toma la entrada como una matriz de dos cadenas de espacio.

meSd       map greatest
    C      on the transpose of input

Probarlo aquí .

Japt , 4 bytes

La entrada se toma como una matriz de dos matrices de números con relleno de 0.

y_rw

Pruébalo en línea!

Ceilán, 55/99

Con cadenas de 0 o espacio de la misma longitud (que devuelven un iterable de caracteres)

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

Con cadenas de 0 o de espacio (devolviendo una cadena):

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

Con cadenas de longitud posiblemente diferente (devolviendo una cadena):

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 agregando curry

Pruébalo en línea

Rubí , 25 bytes.

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

Pruébalo en línea!

Lista acolchada, bla, bla. (Aunque se siente un poco como hacer trampa).

Retina 0.8.2 , 39 bytes

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

Pruébalo en línea! El enlace incluye un conjunto de pruebas. La versión anterior de Retina 1 de 45 bytes acepta cadenas sin relleno:

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

Pruébalo en línea! El enlace incluye un conjunto de pruebas. Explicación:

P^`.+

Rellene ambos valores a la misma longitud. (Retina 1 solamente. Hay formas de emular esto en Retina 0.8.2 pero no son muy golfosas).

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

Transponer los valores.

%O`.

Ordenar cada par en orden.

¶.?

Elimine todos los dígitos bajos y las líneas nuevas excedentes.

Carbón de leña , 8 bytes

⭆θ⌈⟦ι§ηκ

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

 θ          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

La versión de 10 bytes "agrega" cualquier número de cadenas acolchadas:

⭆§θ⁰⌈Ｅθ§λκ

Pruébalo en línea! El enlace es a la versión detallada del código. La versión anterior de 14 bytes acepta cadenas sin relleno:

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

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

  θ             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

La versión de 17 bytes "agrega" cualquier número de cadenas:

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

Pruébalo en línea! El enlace es a la versión detallada del código.

Mathematica 50 bytes

a = 543; b = 791;

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

(* 793 *)