두 개의 문자열이 제공되면 두 입력 중 하나와 같지 않지만 입력 중 하나와 길이가 같은 (문자 단위) 세 번째 문자열을 출력하십시오. 적어도 하나의 유효한 출력이 보장됩니다.

테스트 사례

테스트 사례는 문자열임을 보여주기 위해 인용됩니다. 출력은 가능한 많은 것 중 하나입니다.

input, input -> output

"test", "test" -> "tttt"
"do", "don't" -> "dnut_"
"ye s", "yes" -> "fals"
"yes", "yes" -> "noo"
"maybe", "mayue" -> "false"
"false", "false" -> "truee"
"false", "true" -> "fatr"
"1", "" -> "0"
"", "t" -> "s"
"", "abcabc" -> "testst"
"abcdefghijklmnopqrstuvwxyz", "aaaaaaaaaaaaaaaaaaaaaaaaaa" -> "zbcdefghijklmnopqrstuvwxya"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb" -> "cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"

규칙

• 입력 도메인을 선택할 수 있지만 최소한 인쇄 가능한 ASCII로 구성되어야하며 출력 도메인은 입력 도메인과 같아야합니다.
• 입력 길이는 동일하거나 다를 수 있습니다.
• 결과는 확률 1로 유효해야합니다. 즉, 임의의 문자열이 유효해질 때까지 (및 이론적으로 무한 루프 일 수 있음) 임의의 문자열을 생성 할 수 있지만 임의의 문자열을 출력 할 수는 없으며 유효하기를 바랍니다. 즉, 출력을 결정할 필요가 없습니다.
• 자동 후행 줄 바꿈이 허용되지만 출력 길이에는 포함되지 않습니다.
• 메모리 오류에 관한 질문으로 인해 60 초 이내에 입력 길이까지 작동해야합니다 6. 그것을 위해 작동하고 이론적으로 더 긴 문자열을 위해 작동하는 대답은 괜찮지 만 입력 길이에 대한 최신 컴퓨터의 메모리 오류 4는 유효하지 않습니다.

이것은 code-golf 이므로 바이트 단위의 최단 답변이 이깁니다.

05AB1E , 8 7 바이트

øvAyм¬?

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

하스켈, 43 바이트

x!y=[s|s<-(<$max x y)<$>"abc",s/=x,s/=y]!!0

비어 있지 않은 max (사 전적으로 나중에) 문자열을 가져옵니다. <$;를 사용하여 모든 문자를 "a", "b"및 "c"중 하나로 바꿉니다 . 입력이 아닌 첫 번째를 반환합니다. 나는 이것이 Neil의 차콜 답변 및 / 또는 geokavel의 CJam 답변 과 유사하다고 생각합니다 .

(나는 잠시 동안 숨어 있었지만 이것은이 사이트에 대한 첫 번째 답변입니다. 안녕하세요!)

Brainfuck, 97 바이트

+>+[-,[>>,]<<[<<]>]>>[>]<<<[<]>[<+>>[-<+<+>>][>]<[->+<]<[-]>>>++<[<]>[.>>]>[>>]]>[+[>]+[<]>[.>>]]

온라인 코드 실행 (오른쪽 하단에서 "동적 메모리"를 선택해야 함)

대단한 도전! 나는 그것이 사소한 것이라고 생각했지만 실제로는 어려웠습니다. 우아한 20 바이트 급 BF 솔루션 이 필요 하다고 느끼기 때문에 계속해서 돌아옵니다 . 이 시점에서, 나는 BF에서 (일상적으로) 작동하도록 매우 기쁘다.

입력은 str1+ \0+ 로 간주되며 str2, 여기서 문자열은 0이 아닌 연속 1 바이트 문자입니다.

를 반환 (first str1 + first str2) or (first str1 + 1) or 2합니다. 이 알고리즘은 (아마도) 나의 (깨진) 원래의 알고리즘을 기반으로 한 훌륭한 @ ØrjanJohansen에 의해 생각되었습니다.

댓글 :

# Let (Kn) be the nth character of K
# Let (^) designate the pointer
# Let F be the first string inputted
# Let S be the second string inputted

+>+[-  # Twice do
,[>>,]  # Input string (characters separated by 1)
<<[<<]>  # Go to left of beginning of string
]>  # End on first character of second string
# If second string is null we will end one too far to the left
>[>]<<<[<]>  # If first string is null we will end there too
# We will use this to do flow control

[  # Only run if both strings were non null

# Tape:    S0 ' F0 ' S1 ' F1 ' S2 ' F2 ' etc
#          ^

<+>>  # Let F0* = F0 (plus) 1  (is 1 as of now; F0 will be added later)
[-<+<+>>] # Let A = S0 (plus) F0
# A may or may not be zero
# F0* may or may not be zero
# Tape:    F0* ' A ' 0  ' S1 ' F1 ' etc
#                ^

[>]<[->+<]  # Let B = A or F0*
# B may or may not be zero
<[-]>>  # Clear F0*
# Tape:     0 ' B ' 0 ' S1 ' F1 ' etc    (if A was zero)
#               ^
# OR        0 ' 0 ' B ' s1 ' F1 ' etc    (if A was nonzero)
#                   ^

# Let C = B or 2
# C will be guaranteed nonzero and unique from S0 and F0
>++<[<]>  # Create C
[.>>]  # Print (using S or F; does not matter)

>[>>]  # End on a zero cells with zero cells all to the right
# This is necessary for the coming functionality
# also as to not loop
]  # End non null block

# Now we consider if one of the strings was null
# Tape:    0 ' E0 ' 0 ' E1 ' etc    (if one string was null)
#          ^
# Tape:    0 '  0 ' 0 '  0 ' etc    (if neither string was null)
#          ^
# Where E is F or S (we don't care)

>[  # Execute only if one string was null

+  # Let A = E0 (plus) 1
# A may or many not be zero
# Tape: 0 ' A ' 0 ' E1 ' etc
#           ^

[>]+[<]>  # Let B = A or 1
# B is guaranteed nonzero and != E0
# Tape: 0 ' B ' ? ' E1 ' 0 ' E2 ' etc
#           ^

[.>>]  # Print

# End on zero cell as not to loop
]  # End null block

젤리 , 8 바이트

żḟ@€ØAZḢ

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

어떻게?

żḟ@€ØAZḢ - Link: list of characters, a; list of characters, b
ż        - zip a and b
    ØA   - uppercase alphabet
 ḟ@€     - filter discard for €ach (swap @rguments)
      Z  - transpose the result
       Ḣ - head

파이썬 3 , 62 47 57 54 51 바이트

편집 : - @ Mr.Xcoder 덕분에 5 바이트

편집하다: 버그 수정을 위해 +10 바이트

편집 : @betaveros 덕분에 -3 바이트

편집 : pop 대신 max를 사용하여 -3 바이트

lambda x,y:max({*"abc"}-{x[:1],y[:1]})+max(x,y)[1:]

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

숯 , 22 바이트

ＦＥα×ι⌈⟦ＬθＬη⟧¿¬№⟦θη⟧ιＰι

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 더 긴 입력 길이까지 반복되는 모든 대문자 문자열을 생성하고 입력에 나타나지 않는 모든 문자열을 겹쳐 인쇄합니다. 즉, ZZZ...입력이 입력 중 하나가 아닌 한 출력은 일반적으로 YYY...다른 입력이 아닌 경우에는 그렇지 않습니다 XXX....

Mathematica, 111 바이트

(c=Characters;a=#2;While[f=Alphabet[]~RandomChoice~Length@#;f==#||f==c@a]&[#&@@c@{##}~MaximalBy~Length];""<>f)&

온라인으로 사용해보십시오 (Ctrl + V로 코드 붙여 넣기, 끝에 입력을 입력하고 Shift + Enter를 누르십시오)

입력

[ "test", "me"]

고맙습니다 @ 검사하고 골프를 치는 나무 가 아닙니다 -21 바이트

펄 6 , 38 30 바이트

{(1 x.max.comb...*∉$_).tail}

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

입력을 두 문자열의 목록으로 가져 와서 첫 번째 숫자를 반환하는 익명 코드 블록 1111... 입력에없는 비어 있지 않은 .

설명:

{                          }   # Anonymous code block
  1 x.max.comb                 # String multiply 1 by the size of the non-empty string
              ...              # Create a sequence increasing by 1
                 *∉$_          # Until the number is not in the input
 (                   ).tail    # And take the last number

Zsh , 51 47 37 36 바이트

내장 배열을 사용하여 -4 바이트 argv, 접두사 제거를 사용하여 -10 바이트 및RC_EXPAND_PARAM , -1 브레이스 확장을 인라인으로 바이트.

<<<${${${:-{1..3}${^@#?}}:|argv}[1]}

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

첫째, 이것은 굉장한 도전이었습니다. 나는 이것에 착륙하기 전에 많은 아이디어를 겪었습니다.

<<<${${${:-{1..3}${^@#?}}:|argv}[1]}
       ${:-             }            # empty fallback
                 ${ @#?}             # remove first character from each parameter
                 ${^@  }             # enable brace expansion (set -P)
           {1..3}${^@#?}             # expand to 1foo 2foo 3foo 1bar 2bar 3bar
     ${                  :|argv}     # Set difference with 'argv'
   ${                           [1]} # The first found element
<<<                                  # print to stdout

@및 *되지 식별자는 이렇게이다${ :|@} 와 ${ :|*}의 따라서 사용 일을하지 않습니다${ :|argv}

이 방법은 최대 93 개의 입력을 처리하며 고유 한 94 번째 입력을 찾습니다. 간단히{1..3}가능한 최대 범위로{~..!} .

Zsh , 48 47 바이트 *

for ((;$#i<${#${1:-$2}}||$@[(I)$i];i++)):
<<<$i

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

JoKing의 Perl 6 제출에 완전히 새로운 방법이 제공되었지만 정수 크기 제한으로 인해 큰 문자열 (n> 20)에서는 작동하지 않습니다. $@[(I)$i]가장 큰 인덱스에 대한 역 배열 조회이며, 명령 행 매개 변수에서 $ i를 찾을 수 없으면 0 (산술 확장에서는 거짓)을 출력합니다.

MATL , 12 바이트

c"1Y2@X-1)&h

입력은 인쇄 가능한 ASCII 문자를 포함하는 문자열의 셀형 배열입니다. 출력은 문자로 구성 'ABC'되므로 입력 도메인에 속합니다.

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

설명

출력은 가장 긴 입력 문자열만큼 길다. 그 N 번째 문자의 첫 문자 'ABC'즉, 상이한 n은 모두 입력 문자열의 문자 번째.

c        % Concatenate the two strings vertically. If one is shorter it is
         % right-padded with spaces. Gives a 2-row character matrix
"        % For each column
  1Y2    %   Push the string 'ABC...Z' (the upper-case letters)
  @      %   Push current column
  X-     %   Set difference
  1)     %   Get first character
  &h     %   Horizontally concatenate the results so far
         % End (implicit). Display stack (implicit)

하스켈, 56 52 48 바이트

x#y|_:t<-max x y=[c:t|c<-"abc",c:t/=x,c:t/=y]!!0

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

함께 두 입력 문자열의 최대의 첫 문자를 교체 a, b그리고 c두 입력 문자열 상이한 제 하나를 선택.

루비 , 53 바이트

->a,b{([?a,?b,?c].map{|e|e*[a,b].max.size}-[a,b])[0]}

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

기본적으로 문자열을 생성 a...a, b...b및 c...c상기 입력에 우선하지 선택한다.

ES6, 54 바이트

a=>b=>(a[0]+b[0]|0?'a':9-(a[0]^b[0]))+(a||b).substr(1)

Pyth, 7 8 바이트

hC-LG.T

Jakube 덕분에 1 바이트

테스트 스위트

우리는 전치사를 자르기 .T보다는 길이 보존 전치사를 사용 C하여 하나의 문자열이 비어있는 입력에서 작동합니다.

튜플로 두 문자열을 감안할 때, 우리는 그들이 (트랜스 .T), 다음과 lowerase 알파벳에서 문자 (들)을 차감하여 문자 또는 단일 문자의 결과 쌍을 매핑 -LG다음과 함께 사용되지 않는 문자의 문자열의 결과 목록 트랜스, C다음 수익을 와 같은 첫 번째 문자열 h. 이것은 각 위치에 대해 두 문자열 중 하나가 아닌 알파벳순으로 첫 글자로 구성됩니다.

자바 (OpenJDK 8) , 100 73 바이트

@Nevay의 마법 같은 터치 덕분에 -27 바이트! :)

a->b->{b=b.length<1?a:b;if(a.length<1||(b[0]^=2)==a[0])b[0]^=1;return b;}

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

입력 도메인 = 인쇄 가능한 ASCII + 코드 포인트 127.

루비, 56 바이트

->a,b{a,b=b,a if a<b;a[0]=([?a,?b,?c]-[a[0],b[0]])[0];a}

Pyth , 23 22 바이트

+.)-.{<G3.{,<Q1<KE1t|K

여기 사용해보십시오!

Pyth , 22 바이트

+eS-.{<G3.{,<Q1<KE1t|K

테스트 스위트!

설명

+.)-.{<G3.{,<Q1<KE1t|K  - Full program.
      <G3               - Yields the String "abc"; Alphabet[:3].
    .{                  - Set formed by the above.
         .{,<Q1<KE1     - Set formed by input_1[:1] and input_2[:1]
   -                    - Set subtraction.
 .)                     - Pop the last element.
+                       - Append.
                   t|K  - input_1[1:] or input_2[1:], relying on the result of Logical OR.

펄 5, 82 79 바이트

sub{$_=$_[0];$_=$_[1]||$_ if/^(xz*)?$/;s/[^z]/z/||s/./y/;$_ eq$_[1]&&s/./x/;$_}

입력을 두 개의 개별 인수로 취하고 세 번째 문자열을 리턴합니다.

서브 루틴은 첫 번째 문자열과 매우 유사하지만 첫 번째 z문자가 아닌 첫 번째 문자열을로 바꾸려고 시도 합니다 z. 그런 다음 입력 중 하나가 실제로 모든 시퀀스 인 경우 첫 번째 문자를 필요에 따라 y또는 로 대체하여 코너 케이스를 처리합니다 .xz

펄 5 , 68 바이트

sub{$_="a"x length $_[0]||$_[1];$_++while $_ eq$_[0]||$_ eq$_[1];$_}

설명:

• (첫 번째 문자열 인 경우 문자 "a"로 시작) 또는 false 인 경우 두 번째 문자열로 시작합니다 (예 : 길이가 0 임).
• 첫 번째와 두 번째가 다를 때까지 계속 증가시킵니다.

"a"에서 시작하면 Perl이 문자열을 길게하는 지점까지 증가하지 않아야합니다. 동일하지 않도록 두 개의 문자열 만 사용하면 오버플로 할 수 없습니다.

다음을 실행하십시오.

perl -e '$s = ' -E 'sub{$_="a"x length $_[0]||$_[1];$_++while $_ eq$_[0]||$_ eq$_[1];$_}' -E ';say $s->("z", "true")'

C (gcc) ,70 65 73 67 61 바이트

이 함수는 제공된 문자열을 변경할 수 있어야합니다 (예 : 배열 또는 동적 할당).

f(a,b)char*a,*b;{a=*a?a:b;*a=*a>70?33:99;*a+=*a==*b;puts(a);}

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

표준 ASCII 범위에서 작동

설명:

a=*a?a:b           // If a is empty, point to b instead
*a=*a>70?33:99     // Choose a different value for the 1st character of a,
                   // while giving enough space to increment it without 
                   // going back to its previous value
*a+=*a==*b         // Increment the 1st character of a if the arbitrary
                   // chosen value is equal to the value of the 1st 
                   // character of b
puts(a)            // Outputs a

R, 89 67 바이트

@Giuseppe는 9 바이트를, @ user2390246은 13 바이트를 저장했습니다.

기능

function(x,y)sub("^.",letters[!letters%in%substr(c(x,y),1,1)][1],x)

데모

# define function
f <- function(x,y)sub("^.",letters[!letters%in%substr(c(x,y),1,1)][1],x)

# test cases
f("test","test")
[1] "aest"
f("do","don't")
[1] "ao"
f("ye s","yes")
[1] "ae s"
f("maybe","mayue")
[1] "aaybe"
f("false","false")
[1] "aalse"
f("false","true")
[1] "aalse"
f("1","")
[1] "a"
f("art","bug")
[1] "crt"

자바 8, 119 바이트

람다에서 (카레) String로부터 람다 String로 String. 에 할당하십시오 Function<String, Function<String, String>>.

s->t->{String r=s.length()>t.length()?s:t;while((s+t).contains(r))r=r.substring(1)+(char)(Math.random()*128);return r;}

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

언 골프 람다

s ->
    t -> {
        String r = s.length() > t.length() ? s : t;
        while ((s + t).contains(r))
            r = r.substring(1) + (char) (Math.random() * 128);
        return r;
    }

이 솔루션은 필요한 조건이 충족 될 때까지 임의의 ASCII 문자를 더 긴 문자열로 회전시킵니다. 입력은 UTF-8이고 출력은 ASCII입니다.

나는 유니 코드의 구체적인 세부 사항을 알지 못하지만 추가 된 char코드가 이전 코드 포인트를 결합하여 단일 코드 단위를 구성 할 때이 솔루션이 실패 할 수 있다는 것은 그럴듯 해 보입니다 . 이것에 대해 더 알고있는 사람이 이것을 확인할 수 있다면 입력 도메인을 ASCII로 변경합니다.

자바 8, 126 바이트

위와 같은 유형입니다.

s->t->{String r;for(byte[]o=(s.length()>t.length()?s:t).getBytes();(s+t).contains(r=new String(o));o[0]%=128)o[0]++;return r;}

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

언 골프 람다

s ->
    t -> {
        String r;
        for (
            byte[] o = (s.length() > t.length() ? s : t).getBytes();
            (s + t).contains(r = new String(o));
            o[0] %= 128
        )
            o[0]++;
        return r;
    }

필요한 조건이 충족 될 때까지 긴 문자열의 첫 바이트가 ASCII로 줄 바꿈됩니다. 입력과 출력은 ASCII 문자열입니다.

APL (Dyalog Unicode) , 11 바이트 ^SBCS

전체 프로그램은 2 요소 중첩 목록으로 입력을받습니다.

⊃¨⎕A∘~¨,⌿↑⎕

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

배쉬, 115 .. 77 바이트

비어있는 첫 번째 입력 문자열의 첫 번째 문자를 입력에 일치하지 않을 때까지 1,2,3으로 바꿉니다. 온라인으로 사용해보십시오!

GammaFunction 덕분에 -9, -12, -9, -8 바이트

x="${1:-$2}"
for s in {1..3}"${x:1}"
{ [[ $s = @($1|$2) ]]||break;}
echo "$s"

( 원래에 비해 개선되었습니다 ... )

Perl 5 , 79 + 1 (-p) = 80 바이트

$"=<>;chop;$_=length($,=$_)>length$"?$_:$";s/./chr$&+65+$i++/e while/^($"|$,)$/

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

Japt , 17 바이트

;B¬£ñl g1 çXÃkU v

A-Z더 긴 입력 길이까지 문자 를 반복하고 입력의 값을 제거하고 배열의 첫 번째 항목을 가져옵니다.

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

이전 솔루션, 18 바이트

;@!UøX}a@ñl g1 çBö

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

알파벳에서 임의의 문자를 선택하고 입력에 없을 때까지 더 긴 입력 문자열의 길이까지 반복합니다.

파이썬 3, 74 73 바이트

Step Hen 덕분에 -1 바이트

def f(x,y,i=1):
 while i*10<10**len(x or y)or str(i)in x+y:i*=2
 print(i)

길이가 0이 아닌 첫 번째 입력과 길이가 같은 가장 낮은 정수를 인쇄합니다.

파이썬 2, 77 바이트

a=input()
b=ord(a[0][0])+1
if b==ord(a[1][0]):b+=1
print unichr(b)+a[0][1:-1]

가능성이 있다고 생각합니다. 아이디어는 첫 번째 문자열의 첫 번째 문자에 1을 추가 한 다음 다른 입력의 첫 번째 문자가 동일한 지 확인하는 것입니다.

** 참고 ^는 길이가 0 인 문자열을 처리하지 않으므로이 길이에서는 실제로 작동하지 않습니다.

길이가 0 인 슈퍼 롱 솔루션입니다.

146 바이트

a=input()
def c(i):print unichr(ord(a[i][0])+1)+a[i][1:];exit();
for x in range(2):if len(a[x-1])<1:c(x)
if a[0]==a[1]:c(1)
print a[1][0]+a[0][1:]

모든 개선 사항에 감사드립니다!

CJam, 31 30 23 바이트

q~:A:e>,3,sf*{A\f=:+!}=

인쇄 가능한 ASCII를 입력으로 사용합니다. 입력 문자열 중 하나와 길이가 같은 0, 1 또는 2의 문자열을 출력합니다. 논리는 그중 하나가 입력 문자열이 될 수 없다는 것입니다!

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

q~:A    e# Store input array as var 'A'
:e>,    e# Take the length of the lexicographically greater string in the input array
3,s     e# Generate "012"
f*      e# Repeat each number as many times as the longer string length, yielding something like ["000","111","222"]
{       e# Search array of number strings for first that returns true for this function
A\f=    e# Map each string in the input array to whether it equals the current number string (0,1)
:+!     e# Add up the array of bits and take the logical not. This returns true iff both array values were not equal to the current number string.
}=      e# Return the first number string that returns true.

C # (모노) , 94 바이트

s=>t=>{var r=s!=""?s:t;while(r==s|r==t)r=r.Substring(1).Insert(0,(char)(r[0]+1)+"");return r;}

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