_{이것은 최근에 언어 Add ++ 에 추가 한 기능에서 영감을 얻었습니다 . 따라서 Add ++로 짧은 답변을 제출하지만 이기면 받아들이지 않습니다 (공평하지 않음).}

숫자는 곱할 수 있지만 문자열은 할 수 없을 때 싫어하지 않습니까? 그래서 당신은 그것을 바로 잡아야합니까?

비어 있지 않은 두 개의 문자열을 입력으로 사용하여 곱한 버전을 출력하는 함수 또는 전체 프로그램을 작성해야합니다.

문자열을 어떻게 곱합니까? 내가 말해 줄게!

두 개의 문자열을 곱하려면 두 개의 문자열을 사용하여 각 문자를 비교하십시오. 그런 다음 코드 포인트가 가장 높은 문자가 출력에 추가됩니다. 동일하면 문자를 출력에 추가하십시오.

문자열의 길이가 같을 수는 없습니다. 길이가 다른 경우 최종 문자열의 길이는 가장 짧은 문자열의 길이입니다. 입력은 항상 소문자이며 0x20 - 0x7E대문자를 제외한 인쇄 가능한 ASCII 범위 ( )의 문자를 포함 할 수 있습니다 .

문자열,리스트 등과 같은 합리적인 형식으로 출력 할 수 있습니다.이 도전에서는 정수가 합리적인 출력 방법이 아닙니다.

hello,및의 입력을 사용하면 world!이것이 작동하는 방식입니다.

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

최종 출력 그래서 hello,및 world!것 worlo,!

더 많은 테스트 사례

(단계없이)

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.

이것은 코드 골프 이므로 가장 짧은 코드가 승리합니다! 루크!

하스켈, 11 바이트

zipWith max

온라인으로 사용해보십시오!

설명 할 것이 많지 않습니다.

05AB1E , 4 바이트

øΣà?

05AB1E 인코딩을 사용합니다 . 온라인으로 사용해보십시오!

펄 6 , 22 바이트

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

보너스로 두 개가 아닌 여러 개의 배수를 사용할 수 있습니다.

Japt , 16 바이트

ñl g îUy ®¬ñ oÃq

온라인으로 테스트하십시오! 입력을 두 문자열의 배열로 가져옵니다.

최소 및 최대 내장 기능이 없으면 Japt가 손상되었지만 여전히 다소 괜찮은 점수를 얻습니다 ...

설명

 ñ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

젤리 , 5 바이트

żœ-"«

온라인으로 사용해보십시오!

작동 원리

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

예

하자 의 =은 혼합 및 t 대담 = .

ż수율 ["bb", "lo", "el", "nd", 'd', 'e', 'd']. 마지막 세 요소는 문자입니다.

«벡터화, 최소 최소값이므로을 산출 ['b', 'l', 'e', 'd', 'd', 'e', 'd']합니다.

œ-"첫 번째 배열 의 n ^번째 문자열 / 문자에서 두 번째 배열 의 n ^번째 문자를 정확히 한 번 제거 하여 yield를 산출 합니다. 는 IS MULTISET 뺄셈 원자, 퀵 는 벡터화 수 있습니다.["b", "o", "l", "n", "", "", ""]œ-"

인쇄 될 때 간단히 boln을 읽습니다 .

PHP> = 7.1, 52 바이트

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

PHP 샌드 박스 온라인

PHP> = 7.1, 69 바이트

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

PHP 샌드 박스 온라인

PHP> = 7.1, 70 바이트

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

PHP 샌드 박스 온라인

Alice , 8 바이트

/oI\
@m+

온라인으로 사용해보십시오!

설명

Alice는이 연산자 (내가 superimpose )를 가지고 있지만 출력을 더 짧은 문자열의 길이로 제한하지 않습니다 (대신 더 긴 문자열의 나머지 문자가 추가됩니다). 그러나 두 문자열 중 더 긴 문자열을 더 짧은 문자열의 길이로 자르는 연산자도 있습니다.

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

레티 나 , 28 바이트

{O^`
G`.
^.+$

M!\*`^.
Rm`^.

온라인으로 사용해보십시오!

설명

{O^`

The {Retina는 작업 문자열을 변경하지 못할 때까지 전체 프로그램을 루프로 실행하도록 지시합니다. O비어 있지 않은 줄을 기본적으로 정렬하는 정렬 단계로 만듭니다. 이 ^옵션은 결과를 반대로 바꿉니다. 실제로, 비어 있지 않은 두 줄의 반대 행을 가져 와서 가장 큰 선행 문자가있는 줄을 맨 위에 놓습니다.

G`.

빈 줄이 있으면 버립니다.

^.*$

한 줄만 남으면 한 줄은 비어 있었고 다른 줄도 제거하여 프로세스를 중지합니다.

M!\*`^.

여기서 많은 구성이 진행됩니다. 이것은 M작업 문자열 ( )의 첫 번째 문자 ( ) 와 일치 하고 ^., 반환하고 ( !) 후행 줄 바꿈없이 ( ) 인쇄 \한 다음 작업 문자열을 이전 값 ( *)으로 되돌 립니다. 다시 말해, 실제로 문자열을 변경하지 않고 작업 문자열의 첫 문자 (최대 선행 문자)를 간단히 인쇄합니다.

Rm`^.

마지막으로 각 줄에서 첫 번째 문자를 제거하여 다음 반복에서 다음 문자를 처리합니다.

C, 58 바이트

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

온라인 시도

• -8 바이트 @Steadybox

자바 스크립트 (ES6), 47 45 바이트

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]의 끝을 지나서 false를 편리하게 반환합니다 b. 편집 : @ETHproductions 덕분에 2 바이트가 절약되었습니다.

젤리 , 6 바이트

żḊ€ṁ@»

온라인으로 사용해보십시오!

Mathematica, 78 바이트

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

Mathematica에는 이미 또 다른 대답이 있습니다 . 이 답변은 문자열 목록으로 입력을 받으므로 대신 대신 /@사용할 수 있습니다 . 변수에 할당하는 대신 객체에서 긴 함수 이름을 사용할 수 있습니다 . (실제로 각 Mathematica 내장 심볼 이름은 기능에서 최대 한 번 사용됩니다)#{##}Map

자바 8 124 120 117 63 바이트

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

@ Khaled.K 덕분에 -4 바이트 . @Jakob
덕분에 -3 바이트 .

입력은 두 개의 문자 배열이며로 시작됩니다 ArrayIndexOutOfBoundsException.

설명:

여기에서 시도하십시오.

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 바이트

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

C #은 암시가 char에 int(a가 있기 때문에 변환 char실제로 int좋은 아래가), 대신 짧은 문자열을 찾고 단지 실패 할 때까지 시도

MATL , 8 바이트

otX>cwA)

입력은 문자열 형식의 셀형 배열입니다. {'abcd' 'efg'}

온라인으로 사용해보십시오!

제쳐두고, 이것은 또한 두 개 이상의 문자열에서 작동 합니다 .

설명

입력을 고려하십시오 {'blended' 'bold'}. 스택은 아래에 최신 요소와 함께 거꾸로 표시됩니다.

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 바이트

암호:

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

테스트 사례 :

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

파이썬 2 , 47 44 34 바이트

musicman523 덕분에 -3 바이트. 블렌더 덕분에 -10 바이트.

문자열 목록으로 입력을받습니다.

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

온라인으로 사용해보십시오!

V , 28, 24 , 21 바이트

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

온라인으로 사용해보십시오!

16 진 덤프 :

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

@ nmjcman101 덕분에 3 바이트가 절약되었습니다!

설명:

Í             " 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 바이트

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

입력은 두 문자열의 목록입니다. 두 문자열의 길이가 다른 경우 프로그램은 올바른 출력을 생성 한 후 오류와 함께 종료됩니다.

온라인으로 사용해보십시오!

설명

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

클로저, 31 바이트

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

함수 구성에 대한 예 :) 문자열 대신 일련의 문자를 반환하지만 인쇄 또는 정규식 일치를 제외하고 Clojure에서 대부분 동일한 방식으로 작동합니다.

슬프게도 max캐릭터와 함께 작동하지 않습니다.

자바 스크립트 (ES2015), 66 63 49 바이트

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

설명:

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

이전 버전:

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

망막 , 55 36 바이트

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

온라인으로 사용해보십시오! 설명 : 결과를 보유하기 위해 행이 앞에 붙습니다. 두 문자열에 여전히 문자가 남아 있지만 입력이 정렬되고 코드 포인트가 가장 높은 선행 문자가 결과로 이동하고 다른 선행 문자는 삭제됩니다. 마지막으로 결과가 인쇄됩니다.

껍질 , 2 바이트

z▲

온라인으로 사용해보십시오!

"골프 해제"/ 설명

차종은의 사용 zip f에 대한 두 개의 인수는 항상 존재하도록하는 자릅니다 짧은 목록을 f예는 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"

코 틀린, 50 41 37 바이트

함수 참조 구문이있는 -9 바이트 확장 기능이있는 -4 바이트

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

s 및 x가 범위 내에 있고 함수가 아닌 경우이 메소드는 16 바이트에 불과합니다.

s.zip(x,::maxOf)

데모

PowerShell, 75 바이트

-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

.ps1 파일로 저장하고 실행하십시오.

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

이전에는 78 바이트 :

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

J, 25 바이트

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

설명

바이트의 절반은 두 입력이 더 짧은 입력 길이를 갖도록 해결하는 것입니다 (누구나 가지고 있다면이 부분의 개선을보고 싶습니다).

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

<.&#는 두 길이 중 최소값이며 {."1,:2 열 테이블의 두 행에서 오른쪽 문자열 위에 쌓인 왼쪽 문자열로 구성된 많은 문자를 가져옵니다.

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

Under 동사 사용 &. 를 각 문자를 ASCII 인덱스로 변환하고 두 숫자를 최대로 사용한 다음 다시 문자로 변환하십시오.

온라인으로 사용해보십시오!

Java 8 + Eclipse 컬렉션, 70 64 바이트

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

a그리고 b모두 MutableList<Character>일식 컬렉션입니다.

++ 추가 , 8 바이트

D,f,@@,^

온라인으로 사용해보십시오!

버전 0.4에서 1.11까지는 ^인수 유형에 따라 두 숫자를 지수화하거나 두 문자열을 "곱셈"합니다.

수학, 102 바이트

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

입력

[ "혼합", "굵게"]

APL (Dyalog) , 22 바이트

2 개 이상의 문자열을 올바른 인수로 사용합니다.

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

온라인으로 사용해보십시오!

{ 올바른 인수가 ⍵ 로 표시되는 익명 함수

 ⎕UCS 로부터 심볼 U nicode C haracter S 받는 등의 대응

 ⌈⌿ 각 열의 최대 값

 ⎕UCS 로부터 코드 포인트 U nicode C haracter S 값 Et위한

 ↑ matrified (문자열 목록의 행렬)

 ⍵ 인수

 ↑¨⍨ 각각에 캡

 ⌊/ 최소

 ≢¨ 길이

 ⍵ 논쟁의

}