Défi

Calculez la somme étrange de deux nombres naturels (également appelés addition lunaire):

Étant donné A=... a2 a1 a0et B=... b2 b1 b0deux nombres naturels écrits dans la base décimale, la somme étrange est définie, basée sur l' opération maximale , comme: 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)

Contribution

Deux nombres naturels

Tout ce qui suit est autorisé:

• Cordes sans rembourrage (même longueur)
• Cordes rembourrées dans l'espace gauche
• Cordes rembourrées dans l'espace droit
• Tableau de deux cordes rembourrées
• Tableau de caractères 2D à remplissage d'espace

Production

Un nombre naturel

Exemple

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

Règles

• L'entrée et la sortie peuvent être données dans n'importe quel format pratique (choisissez le format le plus approprié pour votre langue / solution).
• Pas besoin de gérer des valeurs négatives ou des entrées invalides
• Un programme complet ou une fonction sont acceptables. S'il s'agit d'une fonction, vous pouvez renvoyer la sortie plutôt que de l'imprimer.
• Si possible, veuillez inclure un lien vers un environnement de test en ligne afin que d'autres personnes puissent essayer votre code!
• Les failles standard sont interdites.
• Il s'agit de code-golf, donc toutes les règles de golf habituelles s'appliquent et le code le plus court (en octets) l'emporte.

Python 2 , 20 octets

lambda*a:map(max,*a)

Essayez-le en ligne!

E / S sous forme de listes de chiffres pré-remplies.

Gelée , 1 octet

»

Essayez-le en ligne!

E / S sous forme de listes de chiffres pré-remplies.

R , 68 65 octets

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

Essayez-le en ligne!

Entrée sous forme d'entiers, sortie sous forme de liste de chiffres.

Si des listes de chiffres à remplissage nul étaient autorisées, pmaxcela suffirait.

MATL , 2 octets

X>

Choisissez le format le plus approprié pour votre langue / solution

Le format d'entrée est le suivant: tableau de caractères 2D de deux lignes, chacune correspondant à une ligne, avec le nombre le plus court rempli à gauche avec des espaces. Par exemple

17210
  701

qui dans MATL est défini comme

['17210'; '  701']

Essayez-le en ligne!

Explication

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

Python 2 , 73 60 56 octets

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

Essayez-le en ligne!

Prend l'entrée en deux chaînes et retourne une liste de chiffres

Alternative:

Prend l'entrée comme deux entiers; même sortie

Python 2 , 60 59 octets

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

Essayez-le en ligne!

Java 10, 78 57 octets

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

Saisissez deux tableaux de caractères à espace.

Modifie le premier tableau d'entrée au lieu d'en renvoyer un nouveau pour économiser 21 octets (merci à @ OlivierGrégoire ).

Essayez-le en ligne.

Explication:

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 octets

-2 octets grâce à Jonah

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

Essayez-le en ligne!

Entrée et sortie sous forme de liste (s) de chiffres

Japt, 9 8 7 octets

Prend l'entrée comme un tableau de tableaux de chiffres.

mÔÕÔËrw

Essayez-le

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

Si la prise de tableaux à remplissage nul en entrée est autorisée (elle relèverait actuellement d'un "format pratique" mais je soupçonne que ce n'est pas l'intention du challenger), cela peut être de 3 octets.

íwV

Essayez-le

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

Perl 6 , 37 octets

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

Essayez-le en ligne!

Prend la saisie sous forme de liste de listes de chiffres.

05AB1E , 9 6 5 octets

-3 grâce à Emigna
-1 grâce à Shaggy

íζ€àR

Prend la saisie comme une liste de listes de chiffres

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

Essayez-le en ligne! ou Essayez tous les cas de test

Perl 6 , 15 octets

{[~] [Zmax] $_}

Essayez-le en ligne!

Prend l'entrée comme une liste de tableaux de caractères à espace rembourré, bien que pour ce défi, le format d'entrée laxiste le rend plutôt ennuyeux. Alternativement, voici le programme qui prend à la place une liste de deux entiers:

Perl 6 , 41 octets

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

Essayez-le en ligne!

Si cela ne vous dérange pas une énorme quantité d'espace, vous pouvez également supprimer le +par l'avant.

Explication:

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

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

Entrée / sortie sous forme de chaînes, essayez-le en ligne!

Explication

La fonction premplace chaque caractère par un espace, en utilisant p b++aet p a++bsont donc de la même longueur. De cette façon, nous pouvons utiliser zipWithsans perdre aucun élément, l'utiliser maxavec cela fonctionne car un (espace) a un point de code inférieur à n'importe lequel des caractères ['0'..'9'].

JavaScript (ES6), 51 49 octets

NB: Cette réponse a été publiée avant que les formats d'E / S en vrac ne soient explicitement autorisés. Avec des tableaux de chiffres à remplissage nul, cela peut être fait en 33 octets (mais c'est beaucoup moins intéressant, à mon humble avis).

Prend l'entrée comme deux entiers. Renvoie un entier.

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

Essayez-le en ligne!

Commenté

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

Version alternative

Même format d'E / S.

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

Essayez-le en ligne!

Tcl , 156 octets

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

Essayez-le en ligne!

Pas très golfique, mais j'ai dû essayer. Va jouer au golf plus tard!

Lot, 120 octets

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

Prend l'entrée comme paramètres de ligne de commande. La version de 188 octets fonctionne sur des entiers de longueur arbitraire:

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

Prend entrée sur STDIN.

Brindille , 125 octets

Quand j'ai vu ce défi, j'ai pensé: "laissez-moi utiliser un langage de modèle!

J'avais tort ... tellement tort ... ... Mais c'était amusant!

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

Cela nécessite que "strict_variables" soit défini sur false (valeur par défaut).

Pour utiliser cette macro, vous pouvez faire comme ceci:

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

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

Doit afficher 167.

Vous pouvez essayer ceci dans https://twigfiddle.com/rg0biy
("strict_variables" désactivé, il est activé par défaut sur le site Web)

Husk , 5 octets

↔¤żY↔

Prend facilement les entrées / sorties sous forme de liste de chiffres, essayez-les en ligne ou vérifiez tout!

Explication

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

|>E:o

Exécuter et déboguer

Ce programme prend l'entrée comme un tableau de chaînes.

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

Exécutez celui-ci

C'est la première fois que je vois une utilisation de l'instruction de superposition "à l'état sauvage".

SNOBOL4 (CSNOBOL4) , 153 octets

	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

Essayez-le en ligne!

Pyth, 5 octets

meSdC

Prend l'entrée comme un tableau de deux chaînes remplies d'espace.

meSd       map greatest
    C      on the transpose of input

Essayez-le ici .

Japt , 4 octets

L'entrée est considérée comme un tableau de deux tableaux de nombres à 0.

y_rw

Essayez-le en ligne!

Ceylan, 55/99

Avec des chaînes 0 ou remplies d'espace de même longueur (renvoyant un itérable de caractères):

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

Avec des chaînes à 0 ou à espace (renvoyant une chaîne):

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

Avec des chaînes de longueur éventuellement différente (renvoyant une chaîne):

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

C # (.NET Core) , 57 octets

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

-1 octets en ajoutant currying

Essayez-le en ligne

Rubis , 25 octets

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

Essayez-le en ligne!

Liste pré-remplie bla bla. (Bien que cela ressemble un peu à de la triche.)

Retina 0.8.2 , 39 octets

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

Essayez-le en ligne! Le lien inclut une suite de tests. La version précédente de 45 octets de Retina 1 accepte les chaînes non rembourrées:

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

Essayez-le en ligne! Le lien inclut une suite de tests. Explication:

P^`.+

Remplissez les deux valeurs à la même longueur. (Retina 1 uniquement. Il existe des moyens d'émuler cela dans Retina 0.8.2 mais ils ne sont pas très golfiques.)

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

Transposer les valeurs.

%O`.

Triez chaque paire dans l'ordre.

¶.?

Supprimez tous les chiffres bas et les nouvelles lignes excédentaires.

Fusain , 8 octets

⭆θ⌈⟦ι§ηκ

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

 θ          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 version 10 octets "ajoute" n'importe quel nombre de chaînes rembourrées:

⭆§θ⁰⌈Ｅθ§λκ

Essayez-le en ligne! Le lien est vers la version détaillée du code. La version précédente de 14 octets accepte les chaînes non remplies:

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

  θ             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 version 17 octets "ajoute" n'importe quel nombre de chaînes:

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

Essayez-le en ligne! Le lien est vers la version détaillée du code.

Mathematica 50 octets

a = 543; b = 791;

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

(* 793 *)