Учитывая две строки, выведите третью строку, которая не равна ни одному из двух входов, но имеет ту же длину (в символах), что и любой из входов. Там гарантированно будет хотя бы один действительный вывод.

Тестовые случаи

Тестовые случаи цитируются, чтобы показать, что они являются строками. Выходы являются одними из многих возможных.

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" с помощью <$; и возвращает первое, которое не является ни одним из входов. Я думаю, что это похоже на ответ Нила на уголь и / или ответ геокавела на 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 байта, используя максимум вместо поп

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)

вход

["Проверь меня"]

спасибо @ Не дерево для проверки и игры в гольф -21 байт

Perl 6 , 38 30 байт

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

Попробуйте онлайн!

Анонимный кодовый блок, который принимает входные данные в виде списка из двух строк и возвращает первое число из 1111... с непустым значением 1, которого нет во входных данных.

Объяснение:

{                          }   # 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

Input - это массив ячеек, содержащий печатные символы 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 байт благодаря Якубе

Тестирование

Мы используем .Tтранспонирование с сохранением длины, а неC усечение транспонирования, чтобы оно работало на входах, где одна строка пуста.

Учитывая две строки как кортеж, мы транспонируем их ( .T), затем отображаем полученную пару символов или один символ, вычитая символ (ы) из алфавита lowerase с помощью -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.

Рубин, 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/;$_}

Принимает input как два отдельных аргумента и возвращает третью строку.

Подпрограмма пытается создать строку, очень похожую на первую строку, но с первым не- zсимволом, замененным на z. Затем он обрабатывает угловые случаи, заменяя первый символ на yили x, если необходимо, если обнаруживает, что один из входных данных на самом деле был последовательностью всех z.

Perl 5 , 68 байт

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

Объяснение:

• начинается с (строка буквы «а» до первой строки) или со второй строки, если она ложна, то есть нулевой длины
• продолжает увеличивать это до тех пор, пока оно не будет отличаться от первого и второго

Начиная с "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 байт

Лямбда (карри) из 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.

Я не знаю мельчайших подробностей 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∘~¨,⌿↑⎕

Попробуйте онлайн!

Баш, 115 .. 77 байт

Заменяет первый символ первой (непустой) входной строки на 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 к 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;}

Попробуйте онлайн!