Dadas duas seqüências, produza uma terceira sequência que não é igual a nenhuma das duas entradas, mas tem o mesmo comprimento (em caracteres) que qualquer uma das entradas. É garantido que haja pelo menos uma saída válida.

Casos de teste

Os casos de teste são citados para mostrar que são cadeias. As saídas são uma das muitas possíveis.

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"

Regras

• Você pode escolher seu domínio de entrada, mas ele deve ser composto de pelo menos ASCII imprimível e seu domínio de saída deve ser o mesmo que seu domínio de entrada.
• Os comprimentos de entrada podem ser iguais ou diferentes.
• A saída deve ser válida com probabilidade 1; isto é, você pode gerar seqüências aleatórias até que uma seja válida (e teoricamente você pode executar um loop infinito), mas não pode simplesmente gerar uma sequência aleatória e esperar que seja válida. Observe que isso significa que sua saída não precisa ser determinística.
• Novas linhas de rastreamento automáticas são permitidas, mas elas não contam para o comprimento da saída.
• Devido a perguntas relacionadas a erros de memória, ele deve funcionar dentro de 60 segundos até os comprimentos de entrada de 6. Uma resposta que funciona para isso e teoricamente funciona para seqüências mais longas é OK, mas algo que Erros de memória no computador moderno para o comprimento da entrada 4não seja válido.

Isso é código-golfe , então a resposta mais curta em bytes vence.

05AB1E , 8 7 bytes

øvAyм¬?

Usa a codificação 05AB1E . Experimente online!

Haskell, 43 bytes

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

Pega a string max (lexicograficamente mais tarde), que sabemos que não é vazia; substitui todos os caracteres por um de "a", "b" e "c" usando <$; e retorna o primeiro que não é uma das entradas. Acho que isso é semelhante à resposta do Neil's Charcoal e / ou da resposta do geokavel CJam .

(Eu espreitei por um tempo, mas esta é minha primeira vez respondendo neste site; oi!)

Brainfuck, 97 bytes

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

Execute o código online (observe que "memória dinâmica" deve ser selecionada no canto inferior direito)

Desafio incrível! Eu pensei que seria trivial, mas acabou sendo realmente difícil. Continuo voltando, porque sinto que deve haver uma solução elegante de BF de 20 ou mais bytes. Neste ponto, estou muito feliz por ter (aparentemente) conseguido que funcionasse no BF.

A entrada é tomada como str1+ \0+ str2, onde as seqüências de caracteres são caracteres consecutivos diferentes de zero byte.

Retorna (first str1 + first str2) or (first str1 + 1) or 2. Este algoritmo foi pensado pelo brilhante ØrjanJohansen, (presumivelmente) baseado no meu (quebrado) original.

Comentado:

# 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

Gelatina , 8 bytes

żḟ@€ØAZḢ

Experimente online!

Quão?

żḟ@€Ø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 bytes

Edit: - 5 bytes graças a @ Mr.Xcoder

Editar: +10 bytes para corrigir um erro

Edit: -3 bytes graças a @betaveros

Editar: -3 bytes usando max em vez de pop

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

Experimente online!

Carvão , 22 bytes

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

Experimente online! Link é a versão detalhada do código. Gera todas as seqüências de caracteres em maiúsculas repetidas para o comprimento da entrada mais longa e superimprime todas as que não aparecem na entrada. Em outras palavras, a saída é normalmente, a ZZZ...menos que seja uma das entradas; nesse caso, a YYY...menos que seja a outra entrada; nesse caso, é XXX....

Mathematica, 111 bytes

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

experimente online (cole o código com ctrl + v, insira a entrada no final e pressione Shift + Enter)

entrada

["me teste"]

thanx @Não existe uma árvore para verificar e jogar golfe -21 bytes

Perl 6 , 38 30 bytes

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

Experimente online!

Código de bloqueio anônimo que recebe entrada como uma lista de duas cadeias e retorna o primeiro número 1111...com uma quantidade não vazia de 1s que não está na entrada.

Explicação:

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

-4 bytes usando incorporado matriz argv, -10 bytes usando remoção prefixo e RC_EXPAND_PARAM, -1 byte por inlining a expansão cinta.

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

Experimente online!

Primeiro, este foi um desafio incrível, passei por uma tonelada de idéias antes de aterrar nessa.

<<<${${${:-{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

@e *não são identificadores, por isso ${ :|@}e ${ :|*}não fazer o trabalho, portanto, o uso de${ :|argv}

Este método irá trabalhar com 93 entradas e encontrar uma 94 que é única. Simplesmente substitua o {1..3}com o alcance máximo possível {~..!}.

Zsh , 48 47 bytes *

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

Experimente online!

Método completamente novo, cortesia da submissão Perl 6 do JoKing, mas não funciona em strings grandes (n> 20) devido a restrições de tamanho inteiro. $@[(I)$i]é uma pesquisa de matriz reversa para o maior índice, ele produzirá zero (falsidade na expansão aritmética) se $ i não for encontrado nos parâmetros da linha de comando.

MATL , 12 bytes

c"1Y2@X-1)&h

Input é uma matriz de células que contém caracteres ASCII imprimíveis. A saída é formada a partir das letras 'ABC'e, portanto, pertence ao domínio de entrada.

Experimente online!

Explicação

A saída é tão longa quanto a maior string de entrada. Sua n caráter -ésima é a primeira letra do 'ABC'que é diferente do n caráter -ésimo de ambas as cadeias de entrada.

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 bytes

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

Experimente online!

Substituir o primeiro caractere da máxima das duas cadeias de entrada com a, be ce escolher o primeiro que é diferente de ambas as cadeias de entrada.

Ruby , 53 bytes

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

Experimente online!

Basicamente gera as cadeias a...a, b...be c...ce seleciona o primeiro não na entrada.

ES6, 54 bytes

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

Pitão, 7 8 bytes

hC-LG.T

1 byte graças a Jakube

Suíte de teste

Utilizamos a .Ttransposição de preservação de comprimento, e não a Ctransposição de truncamento, para que funcione nas entradas em que uma sequência está vazia.

Dadas duas seqüências de caracteres como uma tupla, nós .Tas transpomos () -LG, em seguida, mapeamos o par de caracteres resultante ou o caractere único subtraindo o (s) caractere (s) do alfabeto inferior com , depois transpomos a lista resultante de strings de caracteres não utilizados com e C, em seguida, retornamos a primeira dessas cordas com h. Consiste na primeira letra alfabética que não está em nenhuma das seqüências, para cada posição.

Java (OpenJDK 8) , 100 73 bytes

-27 bytes graças ao toque mágico de @ Nevay! :)

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

Experimente online!

Domínio de entrada = ASCII imprimível + ponto de código 127.

Ruby, 56 bytes

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

Pitão , 23 22 bytes

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

Experimente aqui!

Pitão , 22 bytes

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

Suíte de teste!

Explicação

+.)-.{<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 bytes

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

Recebe a entrada como dois argumentos separados e retorna a terceira sequência.

A sub-rotina tenta produzir uma sequência muito semelhante à primeira, mas com o primeiro não zcaractere substituído por a z. Em seguida, lida com os casos de canto, substituindo o primeiro caractere por , you x, conforme necessário, se descobrir que uma das entradas era de fato uma sequência de todas z.

Perl 5 , 68 bytes

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

Explicação:

• começa com (sequência da letra "a" contanto que a primeira sequência) ou segunda sequência, se for falso, ou seja, comprimento zero
• continua aumentando isso até que seja diferente do primeiro e do segundo

Partir de "a" s era evitar incrementar até o ponto em que Perl alonga a string; com apenas duas cordas para evitar ser o mesmo, não poderia transbordar.

Executar com:

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 bytes

A função precisa que as seqüências fornecidas sejam mutáveis ​​(ou seja, matrizes ou alocadas dinamicamente).

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

Experimente online!

Funciona para a linha ASCII padrão

Explicação:

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 bytes

@Giuseppe salvou 9 bytes, @ user2390246 salvou 13 bytes

função

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

demonstração

# 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 bytes

Lambda (ao curry) de Stringpara lambda de Stringpara String. Atribuir a 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;}

Experimente Online

Lambda ungolfed

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

Esta solução gira caracteres ASCII aleatórios na cadeia mais longa até que as condições necessárias sejam atendidas. As entradas são UTF-8 e as saídas são ASCII.

Não conheço os detalhes do Unicode, mas parece plausível para mim que essa solução possa falhar quando um anexo charse une ao ponto de código anterior para formar uma única unidade de código. Se alguém que souber mais sobre isso puder verificar isso, alterarei o domínio de entrada para ASCII.

Java 8, 126 bytes

Mesmo tipo que acima.

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

Experimente Online

Lambda ungolfed

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

Isso incrementa o primeiro byte da cadeia mais longa, quebrando dentro do ASCII, até que as condições necessárias sejam atendidas. Entradas e saídas são sequências ASCII.

APL (Dyalog Unicode) , 11 bytes ^SBCS

Programa completo, recebe entrada como uma lista aninhada de 2 elementos.

⊃¨⎕A∘~¨,⌿↑⎕

Experimente online!

Bash, 115 .. 77 bytes

Substitui o primeiro caractere da primeira sequência de entrada (não vazia) por 1,2,3 até que nenhuma correspondência seja encontrada em nenhuma das entradas. Experimente Online!

-9, -12, -9, -8 bytes, tudo graças à GammaFunction

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

(uma melhoria em relação ao original ... )

Perl 5 , 79 + 1 (-p) = 80 bytes

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

Experimente online!

Japonês , 17 bytes

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

Repete as letras A-Zpara o comprimento da entrada mais longa, remove os valores na entrada e obtém o primeiro item da matriz.

Experimente online!

Solução antiga, 18 bytes

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

Experimente online!

Escolhe um caractere aleatório do alfabeto e o repete no comprimento da string de entrada mais longa, até que ele não esteja presente na entrada.

Python 3, 74 73 bytes

-1 byte graças a 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)

Imprime o número inteiro mais baixo com o mesmo comprimento que a primeira das entradas que possui um comprimento diferente de zero.

Python 2, 77 bytes

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

Eu acho que tem algum potencial. A idéia é que ele adicione 1 ao 1º caractere na 1ª sequência e verifique se o 1º caractere da outra entrada é o mesmo.

** Observe que ^ não manipula 0 strings de comprimento, portanto, ele realmente não funciona nesse comprimento.

Aqui está uma solução super longa que funciona com 0 comprimento

146 bytes

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

Qualquer melhoria seria apreciada!

CJam, 31 30 23 bytes

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

Toma ASCII imprimível como entrada. Emite uma sequência de 0, 1 ou 2 com o mesmo comprimento de uma das sequências de entrada. A lógica é que uma dessas não pode ser uma das cadeias de entrada!

Experimente Online

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 # (Mono) , 94 bytes

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

Experimente online!