_{Dies wurde durch eine Funktion inspiriert, die ich kürzlich zu meiner Sprache Add ++ hinzugefügt habe . Deshalb werde ich eine kurze Antwort in Add ++ einreichen, aber ich werde es nicht akzeptieren, wenn es gewinnt (es wäre nicht fair)}

Hassen Sie es nicht, wenn Sie Zahlen multiplizieren können, aber keine Strings? Also solltest du das korrigieren, richtig?

Sie müssen eine Funktion oder ein vollständiges Programm schreiben, das zwei nicht leere Zeichenfolgen als Eingabe und Ausgabe ihrer multiplizierten Version verwendet.

Wie multipliziert man Saiten? Ich werde Ihnen sagen!

Um zwei Zeichenfolgen zu multiplizieren, nehmen Sie zwei Zeichenfolgen und vergleichen jedes Zeichen. Das Zeichen mit dem höchsten Codepunkt wird dann zur Ausgabe hinzugefügt. Wenn sie gleich sind, fügen Sie einfach das Zeichen zur Ausgabe hinzu.

Es wird nicht garantiert, dass die Saiten gleich lang sind. Wenn die Längen unterschiedlich sind, ist die Länge der letzten Zeichenfolge die Länge der kürzesten Zeichenfolge. Die Eingabe erfolgt immer in Kleinbuchstaben und kann beliebige Zeichen im druckbaren ASCII-Bereich ( 0x20 - 0x7E) mit Ausnahme von Großbuchstaben enthalten.

Sie können in jedem vernünftigen Format wie Zeichenfolge, Liste usw. ausgeben. Seien Sie vernünftig, Ganzzahlen sind in dieser Herausforderung keine vernünftige Methode für die Ausgabe.

Mit Eingaben von hello,und world!funktioniert das so

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

Also die endgültige Ausgabe für hello,und world!wäre worlo,!

Weitere Testfälle

(ohne Stufen)

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.

Dies ist ein Code-Golf, also gewinnt der kürzeste Code! Luok!

Haskell, 11 Bytes

zipWith max

Probieren Sie es online!

Es gibt nicht viel zu erklären.

05AB1E , 4 Bytes

øΣà?

Verwendet die 05AB1E- Codierung. Probieren Sie es online!

Perl 6 , 22 Bytes

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

Als Bonus akzeptiert es eine beliebige Anzahl von Multiplikanden, nicht nur zwei.

Japt , 16 Bytes

ñl g îUy ®¬ñ oÃq

Online testen! Übernimmt die Eingabe als Array von zwei Zeichenfolgen.

Das Fehlen von Min- und Max-Built-Ins schadet Japt hier, schafft es aber dennoch, ein anständiges Ergebnis zu erzielen ...

Erläuterung

 ñ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

Gelee , 5 Bytes

żœ-"«

Probieren Sie es online!

Wie es funktioniert

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

Beispiel

Sei s = gemischt und t = fett .

żAusbeuten ["bb", "lo", "el", "nd", 'd', 'e', 'd']. Die letzten drei Elemente sind Zeichen.

«ist das vektorisierende dyadische Minimum, also ergibt es ['b', 'l', 'e', 'd', 'd', 'e', 'd'].

œ-"Entfernt genau ein Vorkommen des n- ^ten Zeichens im zweiten Array aus der n- ^ten Zeichenfolge / dem n- ^ten Zeichen im ersten Array ["b", "o", "l", "n", "", "", ""]. œ-ist das Multiset-Subtraktionsatom , und das schnelle bewirkt , "dass es vektorisiert.

Beim Drucken lautet dies einfach boln .

PHP> = 7.1, 52 Bytes

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

PHP Sandbox Online

PHP> = 7.1, 69 Bytes

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

PHP Sandbox Online

PHP> = 7.1, 70 Bytes

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

PHP Sandbox Online

Alice , 8 Bytes

/oI\
@m+

Probieren Sie es online!

Erläuterung

Alice hat auch diesen Operator (den ich als " Überlagern" bezeichnet habe ), aber er beschränkt die Ausgabe nicht auf die Länge der kürzeren Zeichenfolge (stattdessen werden die verbleibenden Zeichen der längeren Zeichenfolge angehängt). Es hat jedoch auch einen Operator, der die längere von zwei Zeichenfolgen auf die Länge der kürzeren abschneidet.

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

Probieren Sie es online!

Erläuterung

{O^`

Das {weist Retina an, das gesamte Programm in einer Schleife auszuführen, bis die Arbeitszeichenfolge nicht mehr geändert werden kann. Omacht dies zu einer Sortierstufe, die standardmäßig nicht leere Zeilen sortiert. Die ^Option kehrt das Ergebnis um. Tatsächlich erhalten wir also eine umgekehrte Sortierung der beiden Zeilen, wenn sie nicht leer sind, wobei die Zeile mit dem größeren führenden Zeichen oben steht.

G`.

Leere Zeilen, falls vorhanden, verwerfen.

^.*$

Wenn nur noch eine Zeile übrig ist, war eine der Zeilen leer, und die andere wird ebenfalls entfernt, um den Vorgang abzubrechen.

M!\*`^.

Hier wird viel konfiguriert. Dies entspricht ( M) dem ersten Zeichen in der Arbeitszeichenfolge ( ^.), gibt es zurück ( !), druckt es ohne nachfolgenden Zeilenumbruch ( \) und setzt dann die Arbeitszeichenfolge auf ihren vorherigen Wert zurück ( *). Mit anderen Worten, wir drucken einfach das erste Zeichen der Arbeitszeichenfolge (das maximale führende Zeichen), ohne die Zeichenfolge tatsächlich zu ändern.

Rm`^.

Schließlich entfernen wir das erste Zeichen aus jeder Zeile, sodass die nächste Iteration das nächste Zeichen verarbeitet.

C 58 Bytes

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

Versuchen Sie es online

• -8 Bytes @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>

Gibt c>b[i]nach dem Ende von zweckmäßigerweise false zurück b. Bearbeiten: 2 Bytes dank @ETHproductions gespeichert.

Gelee , 6 Bytes

żḊ€ṁ@»

Probieren Sie es online!

Mathematica, 78 Bytes

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

In Mathematica gibt es bereits eine andere Antwort . Diese Antwort wird als Liste von Zeichenfolgen eingegeben und /@kann daher #anstelle von verwendet werden {##}. Und wir können nur Mapden langen Funktionsnamen für das Objekt verwenden, anstatt ihn Variablen zuzuweisen. (Tatsächlich wird jeder in Mathematica integrierte Symbolname höchstens einmal in der Funktion verwendet.)

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 dank @ Khaled.K .
-3 Bytes dank @Jakob .

Eingaben bestehen aus zwei Zeichen-Arrays und enden mit einem ArrayIndexOutOfBoundsException.

Erläuterung:

Probieren Sie es hier aus.

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 # hat implizit charauf intUmwandlung (weil ein chareigentlich eine ist intunten) , das ist schön, und statt die Suche nach kürzester Zeichenfolge nur versuchen , bis zum Versagen

MATL , 8 Bytes

otX>cwA)

Die Eingabe ist ein Zellenarray von Zeichenfolgen im Format {'abcd' 'efg'}

Probieren Sie es online!

Nebenbei funktioniert dies auch für mehr als zwei Saiten .

Erläuterung

Betrachten Sie die Eingabe {'blended' 'bold'}. Der Stapel wird verkehrt herum mit neueren Elementen angezeigt.

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

Code:

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

Testfälle:

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

-3 Bytes dank musicman523. -10 Bytes dank Blender.

Übernimmt die Eingabe als Liste von Zeichenfolgen.

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

Probieren Sie es online!

V , 28, 24 , 21 Bytes

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

Probieren Sie es online!

Hexdump:

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

Drei Bytes gespart dank @ nmjcman101!

Erläuterung:

Í             " 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}%

Die Eingabe ist eine Liste von zwei Zeichenfolgen. Das Programm wird mit einem Fehler beendet (nachdem die richtige Ausgabe erstellt wurde), wenn die beiden Zeichenfolgen unterschiedliche Längen haben.

Probieren Sie es online!

Erläuterung

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 for function composition :) Gibt eine Folge von Zeichen anstelle eines Strings zurück, aber diese funktionieren in Clojure meistens genauso, außer beim Drucken oder beim Regex-Abgleich.

Funktioniert leider maxnicht mit Charakteren.

Javascript (ES2015), 66 63 49 Bytes

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

Erläuterung:

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

Vorherige Versionen:

//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!`.*

Probieren Sie es online! Erläuterung: Vor einer Zeile steht das Ergebnis. Während beide Zeichenketten noch Zeichen haben, werden die Eingaben sortiert und das führende Zeichen mit dem höchsten Codepunkt zum Ergebnis verschoben, während das andere führende Zeichen gelöscht wird. Schließlich wird das Ergebnis gedruckt.

Schale , 2 Bytes

z▲

Probieren Sie es online!

"Ungolfed" / Erklärt

Macht man davon Gebrauch zip f, so schneidet man die kürzere Liste ab, so dass es immer zwei Argumente gibt f, zB 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 mit Funktionsreferenzsyntax -4 Bytes mit Erweiterungsfunktion

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

Wenn sich s und x im Gültigkeitsbereich und nicht in einer Funktion befinden, beträgt diese Methode nur 16 Byte

s.zip(x,::maxOf)

Demo

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

Als .ps1-Datei speichern und ausführen

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

Bisher 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,:)

Erläuterung

Die Hälfte der Bytes wird für die Lösung aufgewendet, um sicherzustellen, dass beide Eingaben die kürzere Eingabelänge haben (wir würden uns über eine Verbesserung dieses Teils freuen, wenn jemand eine hat):

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

<.&#ist das Minimum der beiden Längen und {."1,:benötigt so viele Zeichen aus beiden Zeilen der 2-zeiligen Tabelle, die aus der linken Zeichenfolge besteht, die über der rechten Zeichenfolge gestapelt ist.

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

Verwenden Sie das Unter-Verb &., um jedes Zeichen in seinen ASCII-Index zu konvertieren, nehmen Sie das Maximum der beiden Zahlen und konvertieren Sie es dann zurück in Zeichen.

Probieren Sie es online!

Java 8 + Eclipse - Collections, 70 64 Bytes

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

aund bstammen beide MutableList<Character>aus Eclipse-Sammlungen.

Addiere ++ , 8 Bytes

D,f,@@,^

Probieren Sie es online!

In den Versionen 0.4 bis 1.11 werden ^je nach Art der Argumente zwei Zahlen exponiert oder zwei Zeichenfolgen "multipliziert".

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

Eingang

["gemischt", "fett"]

APL (Dyalog) , 22 Bytes

Nimmt zwei (oder mehr!) Zeichenfolgen als richtiges Argument.

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

Probieren Sie es online!

{ eine anonyme Funktion, bei der das richtige Argument durch ⍵ dargestellt wird

 ⎕UCS die Symbole aus dem U nicode C haracter S et, die dem entsprechen

 ⌈⌿ Maximalwert in jeder Spalte von

 ⎕UCS der Code zeigt aus dem U nicode C haracter S et für das

 ↑ Matrifiziert (Matrix aus Liste der Zeichenketten)

 ⍵ Argumente

 ↑¨⍨ jeweils begrenzt auf die

 ⌊/ Minimum von

 ≢¨ die Längen

 ⍵ der Argumente

}