_{Questo è stato ispirato da una funzione che ho recentemente aggiunto alla mia lingua Add ++ . Pertanto invierò una breve risposta in Add ++ ma non accetterò se vince (non sarebbe giusto)}

Non lo odi quando puoi moltiplicare i numeri ma non le stringhe? Quindi dovresti correggerlo, vero?

Devi scrivere una funzione o un programma completo che accetta due stringhe non vuote come input e produce la loro versione moltiplicata.

Come si moltiplicano le stringhe? Vi dirò!

Per moltiplicare due stringhe, prendi due stringhe e confronta ogni carattere. Il carattere con il punto di codice più alto viene quindi aggiunto all'output. Se sono uguali, aggiungi semplicemente il carattere all'output.

Non è garantito che le stringhe siano uguali in lunghezza. Se le lunghezze sono diverse, la lunghezza della stringa finale è la lunghezza della stringa più corta. L'input sarà sempre in minuscolo e può contenere qualsiasi carattere nell'intervallo ASCII stampabile ( 0x20 - 0x7E), escluse le lettere maiuscole.

Puoi produrre in qualsiasi formato ragionevole, come stringa, elenco, ecc. Sii ragionevole, i numeri interi non sono un modo sensato di produrre in questa sfida.

Con gli input di hello,e world!, ecco come funziona

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,")

Quindi l'output finale per hello,e world!sarebbe worlo,!

Altri casi di test

(senza passaggi)

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.

Questo è un codice-golf quindi vince il codice più corto! Luok!

Haskell, 11 byte

zipWith max

Provalo online!

Non c'è molto da spiegare.

05AB1E , 4 byte

øΣà?

Utilizza la codifica 05AB1E . Provalo online!

Perl 6 , 22 byte

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

Come bonus, accetta un numero qualsiasi di multiplicandi, non solo due.

Japt , 16 byte

ñl g îUy ®¬ñ oÃq

Provalo online! Accetta l'input come una matrice di due stringhe.

La mancanza di min e max integrati fa male a Japt qui, ma riesce comunque a ottenere un punteggio abbastanza decente ...

Spiegazione

 ñ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

Gelatina , 5 byte

żœ-"«

Provalo online!

Come funziona

żœ-"«  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.

Esempio

Let s = blended et t = bold .

żrese ["bb", "lo", "el", "nd", 'd', 'e', 'd']. Gli ultimi tre elementi sono personaggi.

«è il minimo vettoriale, diadico, quindi cede ['b', 'l', 'e', 'd', 'd', 'e', 'd'].

œ-"rimuove esattamente una ricorrenza dell'n- ^esimo carattere nel secondo array dall'n- ^esima stringa / carattere nel primo array, cedendo ["b", "o", "l", "n", "", "", ""]. œ-è l' atomo di sottrazione multiset e la rapida lo "rende vettoriale.

Quando viene stampato, si legge semplicemente boln .

PHP> = 7.1, 52 byte

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

PHP Sandbox online

PHP> = 7,1, 69 byte

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

PHP Sandbox online

PHP> = 7,1, 70 byte

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

PHP Sandbox online

Alice , 8 byte

/oI\
@m+

Provalo online!

Spiegazione

Anche Alice ha questo operatore (che ho chiamato sovrapposizione ) ma non limita l'output alla lunghezza della stringa più corta (invece, vengono aggiunti i caratteri rimanenti della stringa più lunga). Tuttavia, ha anche un operatore per troncare il più lungo di due stringhe alla lunghezza di quello più corto.

/   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.

Retina , 28 byte

{O^`
G`.
^.+$

M!\*`^.
Rm`^.

Provalo online!

Spiegazione

{O^`

Il {dice a Retina di eseguire l'intero programma in un ciclo fino a quando non riesce a cambiare la stringa di lavoro. Orende questa una fase di ordinamento che ordina le linee non vuote per impostazione predefinita. L' ^opzione inverte il risultato. Quindi, in effetti, otteniamo una specie inversa delle due linee se non sono vuote, mettendo la linea con il personaggio principale più grande in alto.

G`.

Elimina le righe vuote se ce ne sono.

^.*$

Se rimane una sola riga, una delle righe era vuota e rimuoviamo anche l'altra per interrompere il processo.

M!\*`^.

Molta configurazione in corso qui. Questo corrisponde a ( M) il primo carattere nella stringa di lavoro ( ^.), lo restituisce ( !), lo stampa senza un trascinamento di riga ( \) e quindi ripristina la stringa di lavoro al valore precedente ( *). In altre parole, stampiamo semplicemente il primo carattere della stringa di lavoro (che è il massimo carattere iniziale) senza cambiare effettivamente la stringa.

Rm`^.

Infine, rimuoviamo il primo carattere da ogni riga, in modo che la successiva iterazione elabori il carattere successivo.

C, 58 byte

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

Prova online

• -8 byte @Steadybox

JavaScript (ES6), 47 45 byte

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>

c>b[i]Restituisce comodamente falso oltre la fine di b. Modifica: salvato 2 byte grazie a @ETHproductions.

Gelatina , 6 byte

żḊ€ṁ@»

Provalo online!

Mathematica, 78 byte

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

C'è già un'altra risposta in Mathematica . Questa risposta accetta input come un elenco di stringhe, quindi /@può essere utilizzata al #posto di {##}. E possiamo solo Mapil nome della funzione lunga sull'oggetto invece di assegnarlo alle variabili. (in effetti, ogni nome di simbolo incorporato di Mathematica viene utilizzato al massimo una volta nella funzione)

Java 8, 124 120 117 63 byte

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

-4 byte grazie a @ Khaled.K .
-3 byte grazie a @Jakob .

Gli input sono due array di caratteri e si ferma con un ArrayIndexOutOfBoundsException.

Spiegazione:

Provalo qui.

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 byte

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

C # è implicita charalla intconversione (perché una charè in realtà un intsotto) che è bello, e invece di cercare più breve stringa cercano solo fino al fallimento

MATL , 8 byte

otX>cwA)

L'input è un array di celle di stringhe, nel formato {'abcd' 'efg'}

Provalo online!

A parte questo, funziona anche per più di due stringhe .

Spiegazione

Considera l'input {'blended' 'bold'}. Lo stack è mostrato sottosopra, con gli elementi più recenti di seguito.

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 byte

Codice:

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

Casi 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 byte

-3 byte grazie a musicman523. -10 byte grazie a Blender.

Accetta input come un elenco di stringhe.

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

Provalo online!

V , 28, 24 , 21 byte

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

Provalo online!

hexdump:

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

Tre byte salvati grazie a @ nmjcman101!

Spiegazione:

Í             " 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 byte

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

L'input è un elenco di due stringhe. Il programma esce con un errore (dopo aver prodotto l'output giusto) se le due stringhe hanno lunghezze diverse.

Provalo online!

Spiegazione

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 byte

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

Sì per la composizione della funzione :) Restituisce una sequenza di caratteri anziché una stringa, ma funzionano principalmente allo stesso modo in Clojure tranne quando si stampa o si abbina regex.

Purtroppo maxnon funziona con i personaggi.

Javascript (ES2015), 66 63 49 byte

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

Spiegazione:

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

Versione precedente:

//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

Retina , 55 36 byte

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

Provalo online! Spiegazione: Una riga ha il prefisso per contenere il risultato. Mentre entrambe le stringhe hanno ancora caratteri rimanenti, gli input vengono ordinati e il carattere principale con il punto di codice più alto viene spostato sul risultato mentre l'altro carattere iniziale viene eliminato. Alla fine il risultato viene stampato.

Buccia , 2 byte

z▲

Provalo online!

"Ungolfed" / Spiegato

Fa uso di zip fquello tronca l'elenco più breve in modo che ci siano sempre due argomenti per f, ad esempio 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 byte

-9 byte con sintassi di riferimento della funzione -4 byte con funzione di estensione

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

Se s e x sono nell'ambito e non in una funzione, questo metodo ha solo 16 byte

s.zip(x,::maxOf)

dimostrazione

PowerShell, 75 byte

-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

Salva come file .ps1 ed esegui

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

In precedenza, 78 byte:

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

J, 25 byte

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

spiegazione

metà dei byte va a risolvere assicurandosi che entrambi gli input abbiano la lunghezza degli input più breve (mi piacerebbe vedere un miglioramento su questa porzione, se qualcuno ne ha uno):

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

<.&#è il minimo delle due lunghezze e {."1,:accetta che molti caratteri di entrambe le righe della tabella a 2 righe siano costituiti dalla stringa sinistra sovrapposta a quella destra.

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

Usa il verbo Under &.per convertire ogni carattere nel suo indice ascii, prendi il massimo dei due numeri e poi riconvertiscilo in caratteri.

Provalo online!

Collezioni Java 8 + Eclipse, 70 64 byte

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

ae bprovengono entrambi MutableList<Character>da raccolte di eclissi.

Aggiungi ++ , 8 byte

D,f,@@,^

Provalo online!

Nelle versioni da 0.4 a 1.11, gli ^esponenti due numeri o "moltiplicano" due stringhe, a seconda del tipo di argomenti.

Mathematica, 102 byte

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

ingresso

["blended", "bold"]

APL (Dyalog) , 22 byte

Accetta due (o più!) Stringhe come argomento corretto.

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

Provalo online!

{ una funzione anonima in cui l'argomento giusto è rappresentato da ⍵

 ⎕UCS i simboli dal U nicode C haracter S et corrispondenti al

 ⌈⌿ valore massimo in ciascuna colonna di

 ⎕UCS i punti di codice della U nicode C haracter S et per la

 ↑ matrified (matrice dall'elenco di stringhe)

 ⍵ argomenti

 ↑¨⍨ ciascuno limitato al

 ⌊/ minimo di

 ≢¨ le lunghezze

 ⍵ degli argomenti

}