Herausforderung

Berechnen Sie die seltsame Summe zweier natürlicher Zahlen (auch Mondaddition genannt):

Gegeben A=... a2 a1 a0und B=... b2 b1 b0zwei natürliche Zahlen im Dezimalsystem Basis geschrieben, die seltsame Summe definiert ist , auf der Basis des maximalen Betrieb, wie: 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)

Eingang

Zwei natürliche Zahlen

Folgendes ist erlaubt:

• Null gepolsterte Saiten (gleiche Länge)
• Mit Leerzeichen gepolsterte Zeichenfolgen
• Mit Leerzeichen aufgefüllte Saiten
• Array von zwei gepolsterten Zeichenfolgen
• 2D-Leerzeichenfeld

Ausgabe

Eine natürliche Zahl

Beispiel

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

Regeln

• Die Ein- und Ausgabe kann in jedem beliebigen Format erfolgen (wählen Sie das für Ihre Sprache / Lösung am besten geeignete Format).
• Es müssen keine negativen Werte oder ungültige Eingaben verarbeitet werden
• Es ist entweder ein vollständiges Programm oder eine Funktion zulässig. Bei einer Funktion können Sie die Ausgabe zurückgeben, anstatt sie zu drucken.
• Fügen Sie nach Möglichkeit einen Link zu einer Online-Testumgebung hinzu, damit andere Benutzer Ihren Code ausprobieren können!
• Standardlücken sind verboten.
• Dies ist Codegolf, daher gelten alle üblichen Golfregeln, und der kürzeste Code (in Byte) gewinnt.

Python 2 , 20 Bytes

lambda*a:map(max,*a)

Probieren Sie es online!

E / A als mit 0 aufgefüllte Ziffernlisten.

Gelee , 1 Byte

»

Probieren Sie es online!

E / A als mit 0 aufgefüllte Ziffernlisten.

R , 68 65 Bytes

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

Probieren Sie es online!

Eingabe als Ganzzahl, Ausgabe als Ziffernliste.

Wenn Zero-Padding-Listen von Ziffern erlaubt pmaxwären, würde dies einfach ausreichen.

MATL , 2 Bytes

X>

Wählen Sie das für Ihre Sprache / Lösung am besten geeignete Format

Das Eingabeformat ist: 2D-Zeichen-Array mit zwei Zeilen, die jeweils einer Zeile entsprechen, wobei die kürzere Zahl links mit Leerzeichen aufgefüllt ist. Beispielsweise

17210
  701

was in MATL definiert ist als

['17210'; '  701']

Probieren Sie es online!

Erläuterung

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

Probieren Sie es online!

Nimmt die Eingabe als zwei Zeichenfolgen und gibt eine Liste mit Ziffern zurück

Alternative:

Nimmt die Eingabe als zwei Ganzzahlen auf; gleiche Ausgabe

Python 2 , 60 59 Bytes

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

Probieren Sie es online!

Java 10, 78 57 Bytes

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

Eingabe als zwei mit Leerzeichen aufgefüllte Zeichenfelder.

Ändert das erste Input-Array, anstatt ein neues zurückzugeben, um 21 Bytes zu sparen (danke an @ OlivierGrégoire ).

Probieren Sie es online aus.

Erläuterung:

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 danke an Jonah

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

Probieren Sie es online!

Ein- und Ausgabe als Ziffernliste

Japt, 9 8 7 Bytes

Übernimmt die Eingabe als Array von Ziffern-Arrays.

mÔÕÔËrw

Versuch es

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

Wenn die Eingabe von Arrays mit Null-Auffüllungen zulässig ist (dies würde derzeit unter ein "praktisches Format" fallen, aber ich vermute, dass dies nicht die Absicht des Herausforderers ist), können dies 3 Bytes sein.

íwV

Versuch es

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

Perl 6 , 37 Bytes

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

Probieren Sie es online!

Übernimmt die Eingabe als Liste von Ziffernlisten.

05AB1E , 9 6 5 Bytes

-3 danke an Emigna
-1 danke an Shaggy

íζ€àR

Nimmt die Eingabe als Liste von Ziffernlisten

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

Probieren Sie es online! oder Probieren Sie alle Testfälle aus

Perl 6 , 15 Bytes

{[~] [Zmax] $_}

Probieren Sie es online!

Nimmt Eingaben als eine Liste von mit Leerzeichen aufgefüllten Zeichenfeldern, obwohl es für diese Herausforderung aufgrund des laxen Eingabeformats ziemlich langweilig ist. Alternativ ist hier das Programm, das stattdessen eine Liste mit zwei ganzen Zahlen erstellt:

Perl 6 , 41 Bytes

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

Probieren Sie es online!

Wenn Ihnen eine große Menge an Leerzeichen nichts ausmacht, können Sie diese auch +von der Vorderseite entfernen .

Erläuterung:

{                                       }  # 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=(' '<$)

Eingabe / Ausgabe als Zeichenketten, online ausprobieren!

Erläuterung

Die Funktion persetzt jedes Zeichen durch ein Leerzeichen p b++aund hat p a++bdamit die gleiche Länge. Auf diese Weise können wir verwenden, zipWithohne Elemente zu verlieren. Die Verwendung maxfunktioniert, da a (Leerzeichen) einen niedrigeren Codepunkt als jedes der Zeichen hat ['0'..'9'].

JavaScript (ES6), 51 49 Byte

NB: Diese Antwort wurde veröffentlicht, bevor die losen E / A-Formate ausdrücklich zugelassen wurden. Bei mit Nullen aufgefüllten Ziffernfeldern kann dies in 33 Bytes erfolgen (ist aber meiner Meinung nach viel weniger interessant).

Nimmt die Eingabe als zwei Ganzzahlen. Gibt eine ganze Zahl zurück.

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

Probieren Sie es online!

Kommentiert

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

Alternative Version

Gleiches E / A-Format.

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

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

Probieren Sie es online!

Nicht sehr golfig, aber ich musste es versuchen. Wird es später Golf spielen!

Batch, 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%

Übernimmt Eingaben als Befehlszeilenparameter. Die 188-Byte-Version kann für Ganzzahlen beliebiger Länge verwendet werden:

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

Übernimmt die Eingabe für STDIN.

Zweig , 125 Bytes

Als ich diese Herausforderung sah, dachte ich mir: "Lass mich eine Vorlagensprache verwenden! Sicher passt das."

Ich habe mich geirrt ... so falsch ... aber es hat Spaß gemacht!

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

Dies setzt voraus, dass "strict_variables" auf false(Standardwert) gesetzt ist.

Um dieses Makro zu verwenden, können Sie wie folgt vorgehen:

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

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

Sollte 167 anzeigen.

Sie können dies unter https://twigfiddle.com/rg0biy versuchen
("strict_variables" ist deaktiviert und auf der Website standardmäßig aktiviert).

Schale , 5 Bytes

↔¤żY↔

Nimmt die Eingabe / Ausgabe bequem als Ziffernliste, probiert sie online aus oder überprüft alle!

Erläuterung

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

Führen Sie es aus und debuggen Sie es

Dieses Programm nimmt Eingaben als Array von Zeichenfolgen entgegen.

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

Führen Sie dieses aus

Dies ist das erste Mal, dass ich eine Verwendung für die Overlay-Anweisung "in the wild" gesehen habe.

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

Probieren Sie es online!

Pyth, 5 Bytes

meSdC

Übernimmt die Eingabe als Array von zwei mit Leerzeichen aufgefüllten Zeichenfolgen.

meSd       map greatest
    C      on the transpose of input

Probieren Sie es hier aus .

Japt , 4 Bytes

Die Eingabe wird als Array von zwei mit 0 aufgefüllten Zahlen-Arrays interpretiert.

y_rw

Probieren Sie es online!

Ceylon, 55/99

Mit 0- oder mit Leerzeichen aufgefüllten Zeichenfolgen gleicher Länge (die eine Iterationsfolge von Zeichen zurückgeben):

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

Mit mit 0 oder Leerzeichen aufgefüllten Zeichenfolgen (Rückgabe einer Zeichenfolge):

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

Mit Zeichenketten von möglicherweise unterschiedlicher Länge (Rückgabe einer Zeichenkette):

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 Bytes durch Hinzufügen von currying

Probieren Sie es online

Ruby , 25 Bytes

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

Probieren Sie es online!

Vorgefüllte Liste bla bla. (Obwohl es sich ein bisschen wie Schummeln anfühlt.)

Retina 0.8.2 , 39 Bytes

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

Probieren Sie es online! Link enthält Testsuite. Die vorherige 45-Byte- Version von Retina 1 akzeptiert nicht gepolsterte Zeichenfolgen:

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

Probieren Sie es online! Link enthält Testsuite. Erläuterung:

P^`.+

Füllen Sie beide Werte auf die gleiche Länge auf. (Nur Retina 1. Es gibt Möglichkeiten, dies in Retina 0.8.2 zu emulieren, aber sie sind nicht sehr golfen.)

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

Transponieren Sie die Werte.

%O`.

Sortieren Sie jedes Paar in der Reihenfolge.

¶.?

Löschen Sie alle niedrigen Stellen und überschüssigen Zeilenumbrüche.

Kohle , 8 Bytes

⭆θ⌈⟦ι§ηκ

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

 θ          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-Byte-Version "fügt" beliebig viele gepolsterte Zeichenfolgen hinzu:

⭆§θ⁰⌈Ｅθ§λκ

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Die vorherige 14-Byte-Version akzeptiert ungepolsterte Zeichenfolgen:

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

  θ             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

Die 17-Byte-Version "fügt" eine beliebige Anzahl von Zeichenfolgen hinzu:

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes.

Mathematica 50 Bytes

a = 543; b = 791;

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

(* 793 *)