Sfida

Calcola la strana somma di due numeri naturali (noto anche come aggiunta lunare):

Dato A=... a2 a1 a0e B=... b2 b1 b0due numeri naturali scritti nella base decimale, la strana somma viene definita, in base all'operazione massima , come: 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)

Ingresso

Due numeri naturali

È consentito tutto quanto segue:

• Stringhe con imbottitura zero (stessa lunghezza)
• Stringhe con spazio a sinistra
• Stringhe con spazio a destra
• Matrice di due corde imbottite
• Array di caratteri 2D con riempimento di spazio

Produzione

Un numero naturale

Esempio

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

Regole

• L'input e l'output possono essere forniti in qualsiasi formato conveniente (scegli il formato più appropriato per la tua lingua / soluzione).
• Non è necessario gestire valori negativi o input non validi
• È accettabile un programma completo o una funzione. Se una funzione, è possibile restituire l'output anziché stamparlo.
• Se possibile, includi un link a un ambiente di test online in modo che altre persone possano provare il tuo codice!
• Sono vietate le scappatoie standard .
• Si tratta di code-golf quindi si applicano tutte le normali regole del golf e vince il codice più breve (in byte).

Python 2 , 20 byte

lambda*a:map(max,*a)

Provalo online!

I / O come elenchi di cifre 0 pre-riempiti.

Gelatina , 1 byte

»

Provalo online!

I / O come elenchi di cifre 0 pre-riempiti.

R , 68 65 byte

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

Provalo online!

Input come numeri interi, output come elenco di cifre.

Se fossero consentiti elenchi di cifre a spaziatura zero, semplicemente pmaxsarebbe sufficiente.

MATL , 2 byte

X>

Scegli il formato più appropriato per la tua lingua / soluzione

Il formato di input è: array di caratteri 2D di due righe, ciascuna corrispondente a una riga, con il numero più corto riempito a sinistra di spazi. Per esempio

17210
  701

che in MATL è definito come

['17210'; '  701']

Provalo online!

Spiegazione

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

Python 2 , 73 60 56 byte

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

Provalo online!

Accetta input come due stringhe e restituisce un elenco di cifre

Alternativa:

Accetta input come due numeri interi; stessa uscita

Python 2 , 60 59 byte

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

Provalo online!

Java 10, 78 57 byte

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

Immettere come due matrici di caratteri con spaziatura spaziale.

Modifica il primo array di input invece di restituirne uno nuovo per salvare 21 byte (grazie a @ OlivierGrégoire ).

Provalo online.

Spiegazione:

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 byte

-2 byte grazie a Giona

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

Provalo online!

Input e output come elenco (i) di cifre

Japt, 9 8 7 byte

Accetta l'input come una matrice di array di cifre.

mÔÕÔËrw

Provalo

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

Se è consentito prendere array con zero zero come input (attualmente rientrerebbe in un "formato conveniente" ma sospetto che non sia l'intento dello sfidante), questo può essere di 3 byte.

íwV

Provalo

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

Perl 6 , 37 byte

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

Provalo online!

Accetta input come un elenco di elenchi di cifre.

05AB1E , 9 6 5 byte

-3 grazie a Emigna
-1 grazie a Shaggy

íζ€àR

Accetta input come un elenco di elenchi di cifre

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

Provalo online! oppure Prova tutti i casi di test

Perl 6 , 15 byte

{[~] [Zmax] $_}

Provalo online!

Prende l'input come un elenco di array di caratteri riempiti di spazio, sebbene per questa sfida il formato di input lassista lo renda piuttosto noioso. In alternativa, ecco il programma che prende invece un elenco di due numeri interi:

Perl 6 , 41 byte

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

Provalo online!

Se non ti dispiace una grande quantità di spazi bianchi, puoi anche rimuovere la +parte anteriore.

Spiegazione:

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

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

Input / output come stringhe, provalo online!

Spiegazione

La funzione psostituisce ogni carattere con uno spazio, usando p b++ae p a++bsono quindi della stessa lunghezza. In questo modo possiamo usare zipWithsenza perdere alcun elemento, usarlo maxcon esso funziona perché uno (spazio) ha un punto di codice inferiore rispetto a qualsiasi dei caratteri ['0'..'9'].

JavaScript (ES6), 51 49 byte

NB: questa risposta è stata pubblicata prima che i formati I / O liberi fossero esplicitamente autorizzati. Con array di cifre a spaziatura zero, questo può essere fatto in 33 byte (ma è molto meno interessante, IMHO).

Accetta input come due numeri interi. Restituisce un numero intero.

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

Provalo online!

Commentate

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

Versione alternativa

Stesso formato I / O.

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

Provalo online!

Tcl , 156 byte

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

Provalo online!

Non molto da golf, ma ho dovuto provarlo. Lo giocherò più tardi!

Lotto, 120 byte

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

Accetta input come parametri della riga di comando. La versione a 188 byte funziona su numeri interi di lunghezza 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%

Accetta input su STDIN.

Ramoscello , 125 byte

Quando ho visto questa sfida, ho pensato: "fammi usare un linguaggio modello! Sicuramente è una buona scelta"

Ho sbagliato ... così sbagliato .... ... Ma è stato divertente!

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

Ciò richiede che "strict_variables" sia impostato su false(valore predefinito).

Per usare questa macro, puoi fare così:

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

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

Dovrebbe essere visualizzato 167.

Puoi provarlo in https://twigfiddle.com/rg0biy
("strict_variables" impostato su off, è attivo per impostazione predefinita sul sito Web)

Buccia , 5 byte

↔¤żY↔

Prende comodamente input / output come elenco di cifre, provalo online o verifica tutto!

Spiegazione

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

|>E:o

Esegui ed esegui il debug

Questo programma accetta input come una matrice di stringhe.

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

Esegui questo

Questa è la prima volta che vedo un uso per l'istruzione overlay "in the wild".

SNOBOL4 (CSNOBOL4) , 153 byte

	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

Provalo online!

Pyth, 5 byte

meSdC

Accetta input come array di due stringhe con spaziatura spaziale.

meSd       map greatest
    C      on the transpose of input

Provalo qui .

Japt , 4 byte

L'input viene considerato come un array di due array di numeri con riempimento 0.

y_rw

Provalo online!

Ceylon, 55/99

Con stringhe con 0 o spaziate della stessa lunghezza (restituendo un iterabile di caratteri):

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

Con stringhe con 0 o spazio (restituendo una stringa):

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

Con stringhe di lunghezza probabilmente diversa (che restituisce una stringa):

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

C # (.NET Core) , 57 byte

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

-1 byte aggiungendo curry

Provalo online

Rubino , 25 byte

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

Provalo online!

Elenco pre-imbottito blah blah. (Anche se sembra un po 'barare.)

Retina 0.8.2 , 39 byte

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

Provalo online! Il link include la suite di test. La versione precedente di Retina 1 a 45 byte accetta stringhe non imbottite:

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

Provalo online! Il link include la suite di test. Spiegazione:

P^`.+

Riempi entrambi i valori alla stessa lunghezza. (Solo Retina 1. Esistono modi per emulare questo in Retina 0.8.2 ma non sono molto golfy.)

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

Trasporre i valori.

%O`.

Ordina ogni coppia in ordine.

¶.?

Elimina tutte le cifre basse e le nuove righe in eccesso.

Carbone , 8 byte

⭆θ⌈⟦ι§ηκ

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

 θ          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 versione a 10 byte "aggiunge" un numero qualsiasi di stringhe imbottite:

⭆§θ⁰⌈Ｅθ§λκ

Provalo online! Il collegamento è alla versione dettagliata del codice. La versione precedente di 14 byte accetta stringhe non imbottite:

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

  θ             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 versione a 17 byte "aggiunge" un numero qualsiasi di stringhe:

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

Provalo online! Il collegamento è alla versione dettagliata del codice.

Mathematica 50 byte

a = 543; b = 791;

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

(* 793 *)