З урахуванням двох рядків, виведіть третій рядок, який не дорівнює жодному з двох входів, але має таку ж довжину (у символах), як і будь-який із входів. Гарантійно буде хоча б один дійсний вихід.

Випробування

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

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

(Я ховався на деякий час, але це вперше я відповідаю на цьому сайті; привіт!)

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

Математика, 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...з не порожньої кількості 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

Зш , 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.

Рубін, 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

Спробуйте тут!

Піт , 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або x, якщо потрібно, якщо виявить, що один із входів насправді був послідовністю усіх z.

Perl 5 , 68 байт

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

Пояснення:

• починається з (рядок літери "a" до тих пір, як перший рядок) або другий рядок, якщо це хибно, тобто нульова довжина
• продовжує збільшуватись до тих пір, поки це не відрізнятиметься і від першого, і від другого

Починаючи з "a" s, слід було уникати збільшення до точки, де 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 байт завдяки кроку Хен

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-й рядку, а потім перевіряє, чи є одна й та сама перша вхідна таблиця.

** Зауважте, ^ не обробляє 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;}

Спробуйте в Інтернеті!