_{Cela a été inspiré par une fonction que j'ai récemment ajoutée à mon langage Add ++ . Par conséquent, je soumettrai une réponse courte dans Add ++ mais je ne l'accepterai pas si elle gagne (ce ne serait pas juste)}

Ne détestez-vous pas quand vous pouvez multiplier des nombres mais pas des chaînes? Vous devriez donc corriger cela, non?

Vous devez écrire une fonction ou un programme complet qui prend en entrée deux chaînes non vides et affiche leur version multipliée.

Comment multipliez-vous les cordes? Je te le dirai!

Pour multiplier deux chaînes, vous prenez deux chaînes et comparez chaque caractère. Le caractère avec le point de code le plus élevé est ensuite ajouté à la sortie. S'ils sont égaux, ajoutez simplement le caractère à la sortie.

La longueur des chaînes n'est pas garantie. Si les longueurs sont différentes, la longueur de la chaîne finale est la longueur de la chaîne la plus courte. L'entrée sera toujours en minuscules et peut contenir n'importe quel caractère de la plage ASCII imprimable ( 0x20 - 0x7E), à l'exclusion des lettres majuscules.

Vous pouvez produire dans n'importe quel format raisonnable, comme une chaîne, une liste, etc.

Avec les entrées de hello,et world!, voici comment cela fonctionne

hello,
world!

w > h so "w" is added ("w")
o > e so "o" is added ("wo")
r > l so "r" is added ("wor")
l = l so "l" is added ("worl")
d < o so "o" is added ("worlo")
! < , so "," is added ("worlo,")

Donc, la sortie finale pour hello,et world!serait worlo,!

Plus de cas de test

(sans étapes)

input1
input2 => output

programming puzzles & code golf!?
not yet graduated, needs a rehaul => prtgyetmirgduuzzlesneedsde rolful

king
object => oing

blended
bold => boln

lab0ur win.
the "super bowl" => the0usuwir.

donald j.
trumfefe! => trumlefj.

C'est un code-golf donc le code le plus court gagne! Luok!

Haskell, 11 octets

zipWith max

Essayez-le en ligne!

Rien à expliquer.

05AB1E , 4 octets

øΣà?

Utilise l' encodage 05AB1E . Essayez-le en ligne!

Perl 6 , 22 octets

{[~] [Zmax] @_».comb}

En prime, il accepte n'importe quel nombre de multiplicandes, pas seulement deux.

Japt , 16 octets

ñl g îUy ®¬ñ oÃq

Testez-le en ligne! Prend l'entrée comme un tableau de deux chaînes.

Le manque de min et max intégrés fait mal à Japt ici, mais il parvient toujours à obtenir un score quelque peu décent ...

Explication

 ñl g îUy ®   ¬ ñ oà q
Uñl g îUy mZ{Zq ñ o} q
                        // Implicit: U = input array     ["object", "king"]
       Uy               // Transpose the strings of U.   ["ok", "bi", "jn", "eg", "c ", "t "]
          mZ{      }    // Map each string Z to
             Zq ñ o     //   the larger of the two chars. (Literally Z.split().sort().pop())
                        //                               ["o", "i", "n", "g", "c", "t"]
                     q  // Join into a single string.    "oingct"
Uñl g                   // Sort the two input strings by length and take the shorter.
      î                 // Trim the previous result to this length.
                        //            "king"î"oingct" -> "oing"
                        // Implicit: output result of last expression

Gelée , 5 octets

żœ-"«

Essayez-le en ligne!

Comment ça marche

żœ-"«  Main link. Arguemts: s, t (strings)

ż      Zipwith; form all pairs of corresponding characters from s and t.
       If one of the strings is longer than the other, its extra characters are 
       appended to the array of pairs.
    «  Dyadic minimum; get all minima of corresponding characters.
       This yields the characters themselves for unmatched characters.
 œ-"   Zipwith multiset subtraction; remove a single occurrence of the minimum from
       each character pair/singleton.
       This yields the maximum for pairs, but an empty string for singletons.

Exemple

Soit s = blended et t = bold .

żrendements ["bb", "lo", "el", "nd", 'd', 'e', 'd']. Les trois derniers éléments sont des personnages.

«est le minimum dyadique vectorisant, donc il donne ['b', 'l', 'e', 'd', 'd', 'e', 'd'].

œ-"supprime exactement une occurrence du n ^ème caractère du deuxième tableau de la n ^ème chaîne / caractère du premier tableau, ce qui donne ["b", "o", "l", "n", "", "", ""]. œ-est l' atome de soustraction multiset , et le rapide le "rend vectorisé.

Une fois imprimé, il lit simplement boln .

PHP> = 7.1, 52 octets

for(;$t=min(~$argv[1][$i],~$argv[2][$i++]);)echo~$t;

PHP Sandbox Online

PHP> = 7.1, 69 octets

for([,$a,$b]=$argv;(~$c=$a[$i])&&~$d=$b[$i++];)$r.=max($c,$d);;echo$r;

PHP Sandbox Online

PHP> = 7.1, 70 octets

for([,$a,$b]=$argv;(~$c=$a[$i])&&~$d=$b[$i++];)$r.=$c>$d?$c:$d;echo$r;

PHP Sandbox Online

Alice , 8 octets

/oI\
@m+

Essayez-le en ligne!

Explication

Alice a également cet opérateur (que j'ai appelé superposition ) mais il ne limite pas la sortie à la longueur de la chaîne la plus courte (à la place, les caractères restants de la chaîne plus longue sont ajoutés). Cependant, il dispose également d'un opérateur pour tronquer la plus longue de deux chaînes à la longueur de la plus courte.

/   Reflect to SE, switch to Ordinal. The IP bounces diagonally up and down
    through the code.
m   Truncate, doesn't really do anything right now.
I   Read a line of input.
    The IP bounces off the bottom right corner and turns around.
I   Read another line of input.
m   Truncate the longer of the two input lines to the length of the shorter.
+   Superimpose: compute their elementwise maximum. 
o   Output the result.
@   Terminate the program.

Rétine , 28 octets

{O^`
G`.
^.+$

M!\*`^.
Rm`^.

Essayez-le en ligne!

Explication

{O^`

Le {dit à Retina d'exécuter le programme entier en boucle jusqu'à ce qu'il ne parvienne pas à changer la chaîne de travail. Oen fait une étape de tri qui trie les lignes non vides par défaut. L' ^option inverse le résultat. Donc, en fait, nous obtenons un tri inverse des deux lignes si elles ne sont pas vides, en plaçant la ligne avec le plus grand caractère de tête en haut.

G`.

Jeter les lignes vides s'il y en a.

^.*$

S'il ne reste qu'une ligne, l'une des lignes était vide et nous supprimons également l'autre pour arrêter le processus.

M!\*`^.

Beaucoup de configuration en cours ici. Cela correspond à ( M) le premier caractère de la chaîne de travail ( ^.), le renvoie ( !), l'imprime sans retour à la ligne ( \), puis rétablit la chaîne de travail à sa valeur précédente ( *). En d'autres termes, nous imprimons simplement le premier caractère de la chaîne de travail (qui est le premier caractère maximal) sans réellement changer la chaîne.

Rm`^.

Enfin, nous supprimons le premier caractère de chaque ligne, afin que la prochaine itération traite le caractère suivant.

C, 58 octets

f(char*s,char*t){putchar(*s>*t?*s:*t);*++s&&*++t&&f(s,t);}

Essayez en ligne

• -8 octets @Steadybox

JavaScript (ES6), 47 45 octets

f=
(a,b)=>a.replace(/./g,(c,i)=>c>b[i]?c:[b[i]])

<div oninput=o.textContent=f(a.value,b.value)><input id=a><input id=b><pre id=o>

Renvoie c>b[i]commodément false après la fin de b. Edit: sauvé 2 octets grâce à @ETHproductions.

Gelée , 6 octets

żḊ€ṁ@»

Essayez-le en ligne!

Mathematica, 78 octets

FromCharacterCode[Max/@Thread[#~Take~Min[Length/@x]&/@(x=ToCharacterCode@#)]]&

Il y a déjà une autre réponse dans Mathematica . Cette réponse prend l'entrée comme une liste de chaînes, elle /@peut donc être utilisée à la #place de {##}. Et nous pouvons simplement Maple nom de fonction long sur l'objet au lieu de l'assigner à des variables. (en fait, chaque nom de symbole intégré Mathematica est utilisé au plus une fois dans la fonction)

Java 8, 124 120 117 63 octets

a->b->{for(int i=0;;i++)System.out.print(a[i]>b[i]?a[i]:b[i]);}

-4 octets grâce à @ Khaled.K .
-3 octets grâce à @Jakob .

Les entrées sont deux tableaux de caractères, et cela s'arrête avec un ArrayIndexOutOfBoundsException.

Explication:

Essayez-le ici.

a->b->{                       // Method with two char-array parameters and no return-type
  for(int i=0;;i++)           //  Loop `i` from 0 up indefinitely (until an error is given)
    System.out.print(         //   Print:
      a[i]>b[i]?a[i]:b[i]);}  //    The character that has the highest unicode value

C #, 81 78 octets

a=>b=>{var s="";try{for(int q=0;;q++)s+=a[q]>b[q]?a[q]:b[q];}catch{}return s;}

C # a implicite char à la intconversion (car a charest en fait un intdessous), ce qui est bien, et au lieu de chercher la chaîne la plus courte, essayez jusqu'à l'échec

MATL , 8 octets

otX>cwA)

L'entrée est un tableau de cellules de chaînes, au format {'abcd' 'efg'}

Essayez-le en ligne!

En passant, cela fonctionne aussi pour plus de deux chaînes .

Explication

Tenez compte des commentaires {'blended' 'bold'}. La pile est montrée à l'envers, avec des éléments plus récents ci-dessous.

o    % Implicitly input a cell array of strongs. Convert to numeric
     % vector of code points. This right-pads with zeros if needed
     %   STACK: [98 108 101 110 100 101 100;
                 98 111 108 100   0   0   0]
tX>  % Duplicate. Maximum of each column
     %   STACK: [98 108 101 110 100 101 100;
                 98 111 108 100   0   0   0],
                [98 111 108 110 100 101 100]
c    % Convert to char
     %   STACK: [98 108 101 110 100 101 100;
                 98 111 108 100   0   0   0],
                'bolnded'
w    % Swap
     %   STACK: 'bolnded'
                [98 108 101 110 100 101 100;
                 98 111 108 100   0   0   0]
A    % All: gives true (shown as 1) for columns containing only nonzeros
     %   STACK: 'bolnded'
                [1 1 1 1 0 0 0]
)    % Use as logical index (mask). Implicitly display
     %   STACK: 'boln'

R, 103 octets

Code:

n=min(sapply(y<-strsplit(scan(,"",sep="\n"),""),length));cat(mapply(max,el(y)[1:n],y[[2]][1:n]),sep="")

Cas de test:

> n=min(sapply(y<-strsplit(scan(,"",sep="\n"),""),length));cat(mapply(max,el(y)[1:n],y[[2]][1:n]),sep="")
1: programming puzzles & code golf!?
2: not yet graduated, needs a rehaul
3: 
Read 2 items
prtgretmirgduuzzlesneedsde rolful
> x <- scan(,"",sep=NULL)
1: asd asd 
3: 
Read 2 items
> n=min(sapply(y<-strsplit(scan(,"",sep="\n"),""),length));cat(mapply(max,el(y)[1:n],y[[2]][1:n]),sep="")
1: king
2: object
3: 
Read 2 items
oing
> n=min(sapply(y<-strsplit(scan(,"",sep="\n"),""),length));cat(mapply(max,el(y)[1:n],y[[2]][1:n]),sep="")
1: lab0ur win.
2: the "super bowl"
3: 
Read 2 items
the0usuwir.

Python 2 , 47 44 34 octets

-3 octets grâce à musicman523. -10 octets grâce à Blender.

Prend l'entrée comme une liste de chaînes.

lambda a:''.join(map(max,zip(*a)))

Essayez-le en ligne!

V , 28, 24 , 21 octets

Í./&ò
dd{JdêHPÎúúx
Íî

Essayez-le en ligne!

Hexdump:

00000000: cd2e 2f26 f20a 6464 7b4a 64ea 4850 cefa  ../&..dd{Jd.HP..
00000010: fa78 0acd ee                             .x...

Trois octets enregistrés grâce à @ nmjcman101!

Explication:

Í             " Globally substitute:
 .            "   Any character
  /           " With:
   &          "   That character
    ò         "   And a newline
dd            " Delete this line
  {           " Move to the first empty line
   J          " Delete this line
    dê        " Columnwise delete the second word
      HP      " Move to the first line, and paste the column we just deleted
        Î     " On every line:
         úú   "   Sort the line by ASCII value
           x  "   And delete the first character
Í             " Remove all:
 î            "   Newlines

CJam , 12 octets

q~z{1/~e>o}%

L'entrée est une liste de deux chaînes. Le programme se termine avec une erreur (après avoir produit la bonne sortie) si les deux chaînes ont des longueurs différentes.

Essayez-le en ligne!

Explication

q~              e# Read input and evaluate
  z             e# Zip: list of strings of length 2, or 1 if one string is shorter
   {      }%    e# Map this block over list
    1/          e# Split the string into array of (1 or 2) chars
      ~         e# Dump the chars onto the stack
       e>       e# Maximum of two chars. Error if there is only one char
         o      e# Output immediately, in case the program will error

Clojure, 31 octets

#(map(comp last sort list)% %2)

Oui pour la composition des fonctions :) Renvoie une séquence de caractères au lieu d'une chaîne, mais ils fonctionnent principalement de la même manière dans Clojure, sauf lors de l'impression ou de la correspondance d'expression régulière.

Malheureusement, maxne fonctionne pas avec les personnages.

Javascript (ES2015), 66 63 49 octets

a=>b=>[...a].map((c,i)=>c>b[i]?c:b[i]||'').join``

Explication:

a=>b=>                       // Function with two string parameters
  [...a]                     // Split a into array of characters
    .map((c, i) =>           // Iterate over array
      c>b[i] ? c : b[i]||'') //   Use the character with the larger unicode value until the end of the larger string
    .join``                  // Join the array into a string

Versions précédentes:

//ES2015
a=>b=>[...a].map((c,i)=>c>b[i]?c:b[i]).slice(0,b.length).join``    //63
a=>b=>a.split``.map((c,i)=>c>b[i]?c:b[i]).slice(0,b.length).join`` //66
a=>b=>a.split``.map((c,i)=>c>b[i]?c:b[i]).slice(0,Math.min(a.length,b.length)).join``   //85
a=>b=>{for(i=-1,c='';++i<Math.min(a.length,b.length);)c+=a[i]>b[i]?a[i]:b[i];return c}  //86
a=>b=>{for(i=-1,c='';++i<Math.min(a.length,b.length);)c+=a[d='charCodeAt'](i)>b[d](i)?a[i]:b[i];return c}   //105
a=>b=>a.split``.map((c,i)=>c[d='charCodeAt']()>b[d](i)?c:b[i]).slice(0,Math.min(a.length,b.length)).join``  //106

//With array comprehensions
a=>b=>[for(i of a.split``.map((c,i)=>c>b[i]?c:b[i]))i].slice(0,b.length).join``                             //79
a=>b=>[for(i of a.split``.map((c,i)=>c>b[i]?c:b[i]))i].slice(0,Math.min(a.length,b.length)).join``          //98
a=>b=>[for(i of ' '.repeat(Math.min(a.length,b.length)).split``.map((_,i)=>a[i]>b[i]?a[i]:b[i]))i].join``   //105
a=>b=>[for(i of Array.apply(0,Array(Math.min(a.length,b.length))).map((_,i)=>a[i]>b[i]?a[i]:b[i]))i].join`` //107
a=>b=>[for(i of a.split``.map((c,i)=>c[d='charCodeAt']()>b[d](i)?c:b[i]))i].slice(0,Math.min(a.length,b.length)).join``        //119
a=>b=>[for(i of ' '.repeat(Math.min(a.length,b.length)).split``.map((_,i)=>a[d='charCodeAt'](i)>b[d](i)?a[i]:b[i]))i].join``   //124
a=>b=>[for(i of Array.apply(0,Array(Math.min(a.length,b.length))).map((_,i)=>a[d='charCodeAt'](i)>b[d](i)?a[i]:b[i]))i].join`` //127

Rétine , 55 36 octets

^
¶
{O`¶.*
}`¶.(.*)¶(.)
$2¶$1¶
1!`.*

Essayez-le en ligne! Explication: une ligne est préfixée pour contenir le résultat. Alors que les deux chaînes ont encore des caractères, les entrées sont triées et le caractère de tête avec le point de code le plus élevé est déplacé vers le résultat tandis que l'autre caractère de tête est supprimé. Enfin, le résultat est imprimé.

Husk , 2 octets

z▲

Essayez-le en ligne!

"Ungolfed" / Expliqué

Fait usage de zip fcela tronque la liste plus courte de sorte qu'il y a toujours deux arguments pour f, par exemple zip f [1,2] [3,4,5] == zip f [1,2] [3,4] == [f 1 3, f 2 4]:

z   -- zip the implicit lists A,B with  - e.g. "ab" "bcd" (lists of characters)
 ▲  -- maximum                          -      [max 'a' 'b', max 'b' 'c']
    -- implicitly print the result      -      "bc"

Kotlin, 50 41 37 octets

-9 octets avec la syntaxe de référence de fonction -4 octets avec la fonction d'extension

fun String.x(o:String)=zip(o,::maxOf)

Si s et x sont dans la portée et non dans une fonction, cette méthode ne fait que 16 octets

s.zip(x,::maxOf)

Démo

PowerShell, 75 octets

-join(1..(($a,$b=$args)|sort l*)[0].length|%{(,$a[$_-1],$b[$_-1]|sort)[1]})
#            ^input array unpack
#       ^string index generation offset by 1
#                         ^sort by length property, so output length matches shorter input
#                                           ^loop over indices
#                                       max of the two characters^
# ^output join

Enregistrer en tant que fichier .ps1 et exécuter

PS C:\> .\Get-MultipliedString.ps1 'hello,' 'world!'
worlo,

Auparavant, 78 octets:

$i=0;-join$(while(($a=$args[0][$i])-and($b=$args[1][$i++])){($a,$b)[$b-gt$a]})

J, 25 octets

>./&.(a.&i.)@(<.&#{."1,:)

explication

la moitié des octets vont à la résolution en s'assurant que les deux entrées ont la longueur des entrées la plus courte (j'aimerais voir une amélioration sur cette partie, si quelqu'un en a une):

(<.&#{."1,:)

<.&#est le minimum des deux longueurs, et {."1,:prend autant de caractères des deux lignes du tableau à 2 lignes composé de la chaîne de gauche empilée en haut de la droite.

>./&.(a.&i.)

Utilisez le verbe Under &.pour convertir chaque caractère en son index ascii, prenez le maximum des deux nombres, puis reconvertissez-le en caractères.

Essayez-le en ligne!

Collections Java 8 + Eclipse, 70 64 octets

a->b->a.zip(b).collect(p->(char)Math.max(p.getOne(),p.getTwo()))

aet bsont tous deux MutableList<Character>issus de collections eclipse.

Ajouter ++ , 8 octets

D,f,@@,^

Essayez-le en ligne!

Dans les versions 0.4 à 1.11, ^exposants deux nombres ou "multiplie" deux chaînes, selon le type des arguments.

Mathematica, 102 octets

T=ToCharacterCode;L=Length;(a=T@#;b=T@#2;FromCharacterCode@Table[Max[a[[i]],b[[i]]],{i,L@a~Min~L@b}])&

contribution

["mélangé", "gras"]

APL (Dyalog) , 22 octets

Prend deux (ou plus!) Chaînes comme argument de droite.

{⎕UCS⌈⌿⎕UCS↑⍵↑¨⍨⌊/≢¨⍵}

Essayez-le en ligne!

{ une fonction anonyme où le bon argument est représenté par ⍵

 ⎕UCS les symboles de l' U nicode C haracter S et qui correspondent à la

 ⌈⌿ valeur maximale dans chaque colonne de

 ⎕UCS les points de code à partir du U nicode C haracter S et pour la

 ↑ matrifié (matrice de la liste des chaînes)

 ⍵ arguments

 ↑¨⍨ chacun plafonné au

 ⌊/ minimum de

 ≢¨ les longueurs

 ⍵ des arguments

}