给定两个字符串，输出第三个字符串，该字符串不等于两个输入中的任何一个，但与两个输入中的任何一个具有相同的长度（以字符为单位）。保证至少有一个有效输出。

测试用例

引用测试用例以表明它们是字符串。输出是许多可能之一。

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是无效的。

这是代码高尔夫球，因此最短答案以字节为单位。

05AB1E，8 7字节

øvAyм¬?

使用05AB1E编码。在线尝试！

Haskell，43个字节

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

采用最大（按字典顺序）字符串，我们知道它是非空的；使用；将所有字符替换为“ a”，“ b”和“ c”之一<$。并返回两者都不是的第一个。我认为这类似于Neil的木炭答案和/或geokavel的CJam答案。

（我潜伏了一段时间，但这是我第一次在此站点上回答；嗨！）

Brainfuck，97个字节

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

在线运行代码（请注意，必须在右下角选择“动态内存”）

很棒的挑战！我以为这很琐碎，但最终却非常困难。我一直回过头来，因为我觉得应该有一些优雅的20字节BF解决方案。在这一点上，我很高兴我（貌似）在BF中完全使用了它。

输入被视为str1+ \0+ str2，其中字符串是连续的非零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

Python 3中，62个 47 57 54 51字节

编辑： -5字节感谢@ Mr.Xcoder

编辑： +10字节修复错误

编辑： -3字节感谢@betaveros

编辑： -3字节通过使用max代替pop

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）

输入

[“考验我”]

thanx @不是用于检查和打高尔夫球的树 -21个字节

Perl 6的，38 30个字节

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

在线尝试！

匿名代码块，将输入作为两个字符串的列表，并从输入中返回的第一个数字1111...以非空的1s形式返回。

说明：

{                          }   # 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，它将输出零（在算术扩展中错误）。

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)

Haskell，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

1字节感谢Jakube

测试套件

我们使用.T保留长度的转置而不是C截断转置的方式，以便它可用于一个字符串为空的输入。

给定两个字符串作为元组，我们对它们进行转置（.T），然后通过将低位字母中的字符减去来映射字符对或单个字符的映射-LG，然后使用来对未使用字符的字符串列表进行转置C，然后返回第一个这样的字符串h。对于每个位置，它由第一个字母组成，该字母按字母顺序排列，不在任何一个字符串中。

Java（OpenJDK 8），100 73字节

-27个字节感谢@Nevay的神奇触感！:)

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

在线尝试！

输入域=可打印ASCII +代码点127。

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

Perl 5，82 79字节

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

将输入作为两个单独的参数并返回第三个字符串。

该子例程尝试产生一个与第一个字符串非常相似的字符串，但是第一个非z字符用a代替z。然后，如果发现输入中的一个实际上是全数字的序列，则可以根据需要通过用y或替换第一个字符来处理特殊情况。xz

Perl 5、68个字节

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

说明：

• 以（字母“ a”的字符串与第一个字符串一样长）或第二个字符串（如果为假，即零长度）开头
• 不断增加直到它与第一和第二个都不同

从“ 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"

Java 8，119字节

Lambda（咖喱）从String到Lambda从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。

我不知道Unicode的详细细节，但是对我来说，当附加项附加char前面的代码点以形成单个代码单元时，此解决方案可能会失败，这似乎是可行的。如果对此有更多了解的人可以验证这一点，那么我将输入域更改为ASCII。

Java 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∘~¨,⌿↑⎕

在线尝试！

Bash，115个 .. 77个字节

将第一个（非空）输入字符串的第一个char替换为1,2,3，直到未找到匹配的输入。在线尝试！

-9，-12，-9，-8字节全部归功于GammaFunction

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ö

在线尝试！

从字母表中选择一个随机字符，并将其重复到较长的输入字符串的长度，直到输入中不存在该字符为止。

Python 3，74 73字节

-1字节感谢Step Hen

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

打印长度与非零长度的第一个输入相同长度的最小整数。

Python 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;}

在线尝试！