Третья строка


45

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

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

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

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недопустимы.

Это , поэтому выигрывает самый короткий ответ в байтах.


14
Это похоже на еще одну интересную новую категорию вопросов на этом сайте, которые легки для человека и трудны для компьютеров. Потому что компьютеры не очень хорошо разбираются! Это напоминает мне об эпизоде ​​Губки Боба, где он не спал всю ночь, пытаясь написать эссе о том, что НЕ делать на светофоре.
геокавель

2
Я понимаю, что выходной домен может быть подмножеством входного домена, да?
Луис Мендо

2
Хороший вопрос! Мне это нравится.
Исаак

2
@Quelklef Нет, это не отличается от обоих входов.
Орджан Йохансен,

3
Я предлагаю добавить «», «1» в качестве контрольного примера, так как я только что понял, что мой ответ не подходит для этого, хотя он работает для всех предоставленных контрольных примеров
Slow loris

Ответы:



14

Haskell, 43 байта

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

Принимает максимальную (лексикографически позднее) строку, которая, как мы знаем, непуста; заменяет все символы одним из символов "a", "b" и "c" с помощью <$; и возвращает первое, которое не является ни одним из входов. Я думаю, что это похоже на ответ Нила на уголь и / или ответ геокавела на CJam .

(Я скрывался некоторое время, но я впервые отвечаю на этом сайте; привет!)


9

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

Ваш «факт» является неправильным, например a=2, b=1. Вы должны добавить вместо вычитания.
Орджан Йохансен

Я думаю, что вы можете исправить Sпустую проблему, добавив >в начале, а затем выполнив [<]>самый левый байт S- если он ненулевой, он ничего не делает, иначе он переключает строки.
Орджан Йохансен

@ ØrjanJohansen О, ты прав, это может сравниться b. Но нет a.
Quelklef

@ ØrjanJohansen Ах, похоже, работает! Хорошая мысль!
Quelklef

@ ØrjanJohansen Продолжайте в том же духе: поскольку это != aтолько, если я печатаю, S/0, S/1, ...а не S/0, F/1, ...он должен работать.
Quelklef

6

Желе , 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

Возвращает B TIO
Джонатан Аллан

Алгоритм не должен в любом случае, не уверен, что вы сделали.
Джонатан Аллан

не берите в голову мой мозг, очевидно, играющий X
в шутки,

5

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:]

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


{"a","b","c"}==> {*"abc"}( 57 байт )
г-н Xcoder

(x[1:]or y[1:])==> max(x,y)[1:]?
betaveros

Или просто (x or y)[1:], я думаю, вам нужно только избегать пустой строки.
betaveros

Кстати, это позор Python-не помеченный набор литералов, потому что я действительно хотел гольф {*"abc"}в {*`id`}...
betaveros

Сохранить 1 с помощью *len(x or y)вместо +max(x,y)[1:].
Час Браун

4

Древесный уголь , 22 байта

FEα×ι⌈⟦LθLη⟧¿¬№⟦θη⟧ιPι

Попробуйте онлайн! Ссылка на подробную версию кода. Создает все строки символов в верхнем регистре, повторяемые по длине более длинного ввода, и перезаписывает все те, которые не отображаются во вводе. Другими словами, выходной сигнал обычно есть, ZZZ...если только он не является одним из входов, в этом случае он является YYY...исключением, если это не другой вход, в этом случае это XXX....


4

Mathematica, 111 байт

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


попробуйте онлайн (вставьте код с помощью Ctrl + V, поместите ввод в конец и нажмите Shift + Enter)

вход

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

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


Как я могу проверить это онлайн снова?
Стивен

добавлена ​​ссылка + инфо
J42161217

@Jenny_mathy Кажется неудачным, если первая строка - пустая строка
Halvard Hummel

2
@HalvardHummel исправлено!
J42161217

1
@ Не исправлено. Если вы считаете, что «легкая игра в гольф» является причиной понижения голосов, вы можете это сделать
J42161217

4

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

Является ли инкрементор типом bigint, или это будет переполнением для достаточно больших строк?
GammaFunction

1
@GammaFunction В Perl 6 типом номера по умолчанию является Int, который имеет бесконечную точность
Джо Кинг,

О, классно. Я собирался приспособить это к Zsh, но он использует, long longк сожалению.
GammaFunction

Вы можете обрезать 6 байтов, просто взяв первое из 00 .., 111 .., 22 .. вместо подсчета и последовательностей: tio.run/…
Phil H

@PhilH Хорошая идея! Я сократил это немного больше, придерживаясь идеи последовательности
Джо Кинг

4

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 не найден в параметрах командной строки.


3

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)

3

Haskell, 56 52 48 байт

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

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

Заменить первый символ максимума двух входных строк с a, bи cи выбрать первый , который отличается от обоих входных строк.


3

Рубин , 53 байта

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

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

В основном генерирует строки a...a, b...bи c...cи выбирает первую, не входную.


1
Сбой, если первый ввод - пустая строка.
Сильвио Майоло,

@SilvioMayolo исправлено
Конор О'Брайен



3

Pyth, 7 8 байт

hC-LG.T

1 байт благодаря Якубе

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

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

Учитывая две строки как кортеж, мы транспонируем их ( .T), затем отображаем полученную пару символов или один символ, вычитая символ (ы) из алфавита lowerase с помощью -LG, затем транспонируем полученный список строк неиспользуемых символов с помощью C, затем возвращаем первая такая строка с h. Он состоит из первой буквы в алфавитном порядке, которой нет ни в одной строке, для каждой позиции.




2

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.

2

Perl 5, 82 79 байт

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

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

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


2

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

1
Я думаю, что это не удастся, если первая строка пуста.
Эрджан Йохансен

Совершенно верно! Исправлена.
Ред.

2

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

1
Я не уверен, что этому можно дать последовательный входной домен, удовлетворяющий правилам. Что делать, если *a==255и *b==0?
Орджан Йохансен,

Вы правы. Исправлено, по стоимости 8 байт.
Скоттинет

Там. Я не мог позволить этому решению иметь тот же байтовый счет, что и Java! :-)
Скоттинет

Если вы не ограничиваетесь печатью ASCII, вы можете использовать однозначные числа.
Орджан Йохансен

Если я не понял, это было бы против этого правила вызова.
scottinet

2

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"

1
Вы можете поставить xи в yпределах одной substrкоманды. Также фигурные скобки и returnне нужны:function(x,y)sub("^.",letters[!letters%in%substr(c(x,y),1,1)][1],x)
user2390246

1
Вы можете избавиться от returnэтого, поскольку это функция, а скобки - от одного лайнера.
Джузеппе

Стреляй, я только что понял, что f("","1")доходность "", которая равна первому входу ... может быть, это следует добавить в качестве еще одного тестового случая
Slow loris

2

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.


1
Учитывая вывод вашего третьего контрольного примера, он выводит строку длины три: Попробуйте онлайн!
Стивен

Ах, дерьмо. Теперь мне нужно узнать, как работает Unicode, чтобы исправить это, не взорвав счетчик байтов ...
Jakob


2

Баш, 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"

(довольно улучшение по сравнению с оригиналом ... )


1
Хороший метод! Вы можете использовать =и ||в последней строке, и использовать, ${x:-empty_fallback}чтобы удалить начальный троичный. Кроме того, вам нужны кавычки в конце эхо для случая конечных пробелов. Обязательный
TIO


1
Мне нравится то , что вы собираетесь с shift, я получил его , чтобы связать мой метод в двух различных методов .
GammaFunction




1

Japt , 17 байт

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

Повторяет буквы A-Z до длины более длинного ввода, удаляет значения из ввода и получает первый элемент в массиве.

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

Старое решение, 18 байт

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

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

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


Не удалось ["abcdefghijklmnopqrstuvwxyz", "AAAAAAAAAAAAAAAAAAAAAAAAAA"]. Когда он запускался несколько раз, он возвращался "AAAAAAAAAAAAAAAAAAAAAAAAAA"(так же, как и мой ответ
Pyth

Это не удается для ["D", ""]. если вы запустите его несколько раз, вы получите «D»
J42161217

Спасибо, я подумал, что были случаи, которые я не проверял. Исправлено только +1 байт.
Джастин Маринер,

Ìдолжны работать на месте g1 для сохранения 2 байта (в массиве 2 элемента g1= gJ) , но, как представляется, ошибка с Ìпри использовании ;.
Лохматый

@ Шэгги Да, я думаю, что причина Jбольше не -1в том, чтобы ;изменить ее на ,. Вот почему я использовал 1в первую очередь.
Джастин Маринер

1

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)

Выводит наименьшее целое число с той же длиной, что и первый из входов с ненулевой длиной.


Сохранение байт с в iкачестве параметра функции по умолчанию: def f(x,y,i=1):. Я думаю, что вы можете сохранить еще один байт, while10*iно я не уверен.
Стивен

Вы можете заменить while i*10<10**len(x or y)or str(i)in x+yна while i<10**~-len(x or y)or str(i)in x+y ( 72 байта )
г-н Xcoder

И вы также можете использовать рекурсию для сохранения байтов: f=lambda x,y,i=1:(i<10**~-len(x or y)or str(i)in x+y)and f(x,y,i*2)or i( 71 байт )
Mr. Xcoder

1

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:]

Любые улучшения будут оценены!


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.

У кого-нибудь есть идеи о том, как вернуть true, только если оба бита в массиве имеют значение false (NOR)? В настоящее время я занимаюсь :+!.
геокавель

Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.