_{Esto se inspiró en una función que agregué recientemente a mi lenguaje Add ++ . Por lo tanto, enviaré una respuesta corta en Add ++ pero no la aceptaré si gana (no sería justo)}

¿No odias cuando puedes multiplicar números pero no cadenas? Entonces deberías corregir eso, ¿verdad?

Debe escribir una función o programa completo que tome dos cadenas no vacías como entrada y salida de su versión multiplicada.

¿Cómo multiplicas las cuerdas? ¡Te diré!

Para multiplicar dos cadenas, toma dos cadenas y compara cada personaje. El carácter con el punto de código más alto se agrega a la salida. Si son iguales, simplemente agregue el carácter a la salida.

No se garantiza que las cadenas tengan la misma longitud. Si las longitudes son diferentes, la longitud de la cadena final es la longitud de la cadena más corta. La entrada siempre estará en minúscula y puede contener cualquier carácter en el rango ASCII imprimible (0x20 - 0x7E ), excluyendo letras mayúsculas.

Puede generar en cualquier formato razonable, como cadena, lista, etc. Sea sensato, los enteros no son una forma sensata de generar en este desafío.

Con entradas de hello,y world!, así es como funciona

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

¡Entonces el resultado final para hello,y world!sería worlo,!

Más casos de prueba

(sin pasos)

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.

Este es un código de golf, ¡el código más corto gana! Luok!

Haskell, 11 bytes

zipWith max

Pruébalo en línea!

No hay mucho que explicar.

05AB1E , 4 bytes

øΣà?

Utiliza la codificación 05AB1E . Pruébalo en línea!

Perl 6 , 22 bytes

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

Como beneficio adicional, acepta cualquier número de multiplicandos, no solo dos.

Japt , 16 bytes

ñl g îUy ®¬ñ oÃq

¡Pruébelo en línea! Toma la entrada como una matriz de dos cadenas.

La falta de incorporaciones mínimas y máximas lastimó a Japt aquí, pero aún logra lograr una puntuación algo decente ...

Explicación

 ñ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

Jalea , 5 bytes

żœ-"«

Pruébalo en línea!

Cómo funciona

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

Ejemplo

Deje s = mezclado y t = negrita .

żrendimientos ["bb", "lo", "el", "nd", 'd', 'e', 'd']. Los últimos tres elementos son personajes.

«es el vectorizante, mínimo diádico, por lo que rinde ['b', 'l', 'e', 'd', 'd', 'e', 'd'].

œ-"quita exactamente una ocurrencia de la n ^º carácter en la segunda matriz a partir de la n ^º cadena / carácter en la primera matriz, produciendo ["b", "o", "l", "n", "", "", ""]. œ-es el átomo de resta de múltiples conjuntos, y el rápido "hace que se vectorice.

Cuando se imprime, esto simplemente lee boln .

PHP> = 7.1, 52 bytes

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

PHP Sandbox en línea

PHP> = 7.1, 69 bytes

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

PHP Sandbox en línea

PHP> = 7.1, 70 bytes

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

PHP Sandbox en línea

Alice , 8 bytes

/oI\
@m+

Pruébalo en línea!

Explicación

Alice también tiene este operador (al que llamé superponer ) pero no limita la salida a la longitud de la cadena más corta (en cambio, se añaden los caracteres restantes de la cadena más larga). Sin embargo, también tiene un operador para truncar la más larga de dos cadenas a la longitud de la más corta.

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

{O^`
G`.
^.+$

M!\*`^.
Rm`^.

Pruébalo en línea!

Explicación

{O^`

El {le dice a Retina que ejecute todo el programa en un bucle hasta que no pueda cambiar la cadena de trabajo. Olo convierte en una etapa de clasificación que clasifica las líneas no vacías de forma predeterminada La ^opción invierte el resultado. Entonces, en efecto, obtenemos un tipo inverso de las dos líneas si no están vacías, colocando la línea con el carácter principal más grande en la parte superior.

G`.

Deseche las líneas vacías si las hay.

^.*$

Si solo queda una línea, una de las líneas estaba vacía, y también eliminamos la otra para detener el proceso.

M!\*`^.

Mucha configuración pasando aquí. Esto coincide (M ) el primer carácter de la cadena de trabajo ( ^.), lo devuelve ( !), lo imprime sin un salto de línea final ( \) y luego revierte la cadena de trabajo a su valor anterior ( *). En otras palabras, simplemente imprimimos el primer carácter de la cadena de trabajo (que es el carácter principal máximo) sin cambiar realmente la cadena.

Rm`^.

Finalmente, eliminamos el primer carácter de cada línea, de modo que la siguiente iteración procese el siguiente carácter.

C, 58 bytes

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

Probar en línea

• -8 bytes @Steadybox

JavaScript (ES6), 47 45 bytes

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>

Convenientemente c>b[i]devuelve falso pasado el final de b. Editar: Guardado 2 bytes gracias a @ETHproductions.

Jalea , 6 bytes

żḊ€ṁ@»

Pruébalo en línea!

Mathematica, 78 bytes

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

Ya hay otra respuesta en Mathematica . Esta respuesta toma la entrada como una lista de cadenas, por lo que /@se puede usar en #lugar de {##}. Y podemos simplemente Mapel nombre largo de la función en el objeto en lugar de asignarlo a las variables. (de hecho, cada nombre de símbolo incorporado de Mathematica se usa como máximo una vez en la función)

Java 8, 124 120 117 63 bytes

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

-4 bytes gracias a @ Khaled.K .
-3 bytes gracias a @Jakob .

Las entradas son dos matrices de caracteres, y se detiene con un ArrayIndexOutOfBoundsException .

Explicación:

Pruébalo aquí.

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 bytes

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

C # está implícito charen la intconversión (porque a chares realmente una parte intinferior) lo cual es bueno, y en lugar de buscar la cadena más corta, simplemente intente hasta el fallo

MATL , 8 bytes

otX>cwA)

La entrada es una matriz de celdas de cadenas, en el formato {'abcd' 'efg'}

Pruébalo en línea!

Por otro lado, esto también funciona para más de dos cadenas .

Explicación

Considere la entrada {'blended' 'bold'}. La pila se muestra al revés, con elementos más recientes a continuación.

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 bytes

Código:

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

Casos de prueba:

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

Pitón 2 , 47 44 34 bytes

-3 bytes gracias a musicman523. -10 bytes gracias a Blender.

Toma la entrada como una lista de cadenas.

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

Pruébalo en línea!

V , 28, 24 , 21 bytes

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

Pruébalo en línea!

Hexdump:

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

¡Tres bytes guardados gracias a @ nmjcman101!

Explicación:

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

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

La entrada es una lista de dos cadenas. El programa sale con un error (después de producir la salida correcta) si las dos cadenas tienen longitudes diferentes.

Pruébalo en línea!

Explicación

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 bytes

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

Yay para la composición de funciones :) Devuelve una secuencia de caracteres en lugar de una cadena, pero en su mayoría funcionan de la misma manera en Clojure, excepto cuando se imprime o coincide con expresiones regulares.

Lamentablemente maxno funciona con personajes.

Javascript (ES2015), 66 63 49 bytes

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

Explicación:

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

Versión anterior:

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

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

Pruébalo en línea! Explicación: una línea tiene el prefijo para contener el resultado. Si bien ambas cadenas aún tienen caracteres restantes, las entradas se ordenan y el carácter principal con el punto de código más alto se mueve al resultado mientras que el otro carácter principal se elimina. Finalmente se imprime el resultado.

Cáscara , 2 bytes

z▲

Pruébalo en línea!

"Ungolfed" / Explicado

Hace uso de zip feso trunca la lista más corta de modo que siempre hay dos argumentos para f, por ejemplo 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 bytes

-9 bytes con sintaxis de referencia de función -4 bytes con función de extensión

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

Si s y x están dentro del alcance y no están en una función, este método tiene solo 16 bytes

s.zip(x,::maxOf)

Manifestación

PowerShell, 75 bytes

-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

Guardar como archivo .ps1 y ejecutar

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

Anteriormente, 78 bytes:

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

J, 25 bytes

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

explicación

la mitad de los bytes se destinan a la resolución, asegurando que ambas entradas tengan una longitud de entrada más corta (me encantaría ver una mejora en esta parte, si alguien tiene una):

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

<.&#es el mínimo de las dos longitudes, y {."1,:toma esa cantidad de caracteres de ambas filas de la tabla de 2 filas que consiste en la cadena izquierda apilada encima de la derecha.

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

Use el verbo Under &.para convertir cada carácter a su índice ascii, tome el máximo de los dos números y luego vuelva a convertirlos en caracteres.

Pruébalo en línea!

Colecciones de Java 8 + Eclipse, 70 64 bytes

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

ay bambos son MutableList<Character>de colecciones de eclipse.

Añadir ++ , 8 bytes

D,f,@@,^

Pruébalo en línea!

En las versiones 0.4 a 1.11, los ^exponentes dos números o "multiplican" dos cadenas, dependiendo del tipo de argumentos.

Mathematica, 102 bytes

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

entrada

["mezclado", "negrita"]

APL (Dyalog) , 22 bytes

Toma dos (o más) cadenas como argumento correcto.

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

Pruébalo en línea!

{ una función anónima donde el argumento correcto está representado por ⍵

 ⎕UCS los símbolos de U nicode C haracter S et que corresponden a la

 ⌈⌿ valor máximo en cada columna de

 ⎕UCS los puntos de código de U nicode C haracter S et para el

 ↑ Matrified (matriz de la lista de cadenas)

 ⍵ argumentos

 ↑¨⍨ cada uno tapado en el

 ⌊/ mínimo de

 ≢¨ las longitudes

 ⍵ de los argumentos

}