Dadas dos cadenas, genera una tercera cadena que no es igual a ninguna de las dos entradas, pero que tiene la misma longitud (en caracteres) que cualquiera de las entradas. Se garantiza que haya al menos una salida válida.

Casos de prueba

Los casos de prueba se citan para mostrar que son cadenas. Las salidas son una de las muchas posibles.

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"

Reglas

• Puede elegir su dominio de entrada, pero debe estar compuesto al menos por ASCII imprimible, y su dominio de salida debe ser el mismo que su dominio de entrada.
• Las longitudes de entrada pueden ser iguales o diferentes.
• La salida debe ser válida con probabilidad 1; es decir, puede generar cadenas aleatorias hasta que una sea válida (y en teoría podría tener un bucle infinito), pero no puede simplemente generar una cadena aleatoria y esperar que sea válida. Tenga en cuenta que esto significa que su salida no necesita ser determinista.
• Se permiten nuevas líneas finales automáticas, pero no cuentan para la longitud de la salida.
• Debido a preguntas sobre errores de memoria, debe funcionar dentro de los 60 segundos hasta las longitudes de entrada de 6. Una respuesta que funciona para eso y teóricamente funciona para cadenas más largas está bien, pero algo que los errores de memoria en la computadora moderna para la longitud de entrada 4no son válidos.

Este es el código de golf , por lo que la respuesta más corta en bytes gana.

05AB1E , 8 7 bytes

øvAyм¬?

Utiliza la codificación 05AB1E . Pruébalo en línea!

Haskell, 43 bytes

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

Toma la cadena max (lexicográficamente más tarde), que sabemos que no está vacía; reemplaza todos los caracteres con uno de "a", "b" y "c" usando <$; y devuelve el primero que no es ninguna de las entradas. Creo que esto es similar a la respuesta de Neil's Charcoal y / o la respuesta de geokavel CJam .

(He acechado por un tiempo, pero esta es la primera vez que respondo en este sitio; ¡Hola!)

Brainfuck, 97 bytes

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

Ejecute el código en línea (tenga en cuenta que "memoria dinámica" debe seleccionarse en la parte inferior derecha)

Desafío impresionante! Pensé que sería trivial, pero terminó siendo realmente difícil. Sigo volviendo a ello porque siento que debería haber una solución elegante de BF de 20 o más bytes. En este punto, estoy bastante feliz de que (aparentemente) lo hice funcionar en BF.

La entrada se toma como str1+ \0+ str2, donde las cadenas son caracteres consecutivos distintos de cero de 1 byte.

Las devoluciones (first str1 + first str2) or (first str1 + 1) or 2. Este algoritmo fue pensado por el brillante @ ØrjanJohansen, (presumiblemente) basado en mi (roto) 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

Jalea , 8 bytes

żḟ@€ØAZḢ

Pruébalo en línea!

¿Cómo?

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

Editar: - 5 bytes gracias a @ Mr.Xcoder

Editar: +10 bytes para corregir un error

Editar: -3 bytes gracias a @betaveros

Editar: -3 bytes usando max en lugar de pop

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

Pruébalo en línea!

Carbón de leña , 22 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Genera todas las cadenas de caracteres en mayúscula repetidas a la longitud de la entrada más larga y sobreimprime todas aquellas que no aparecen en la entrada. En otras palabras, la salida es normalmente a ZZZ...menos que sea una de las entradas, en cuyo caso es a YYY...menos que sea la otra entrada, en cuyo caso es XXX....

Mathematica, 111 bytes

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

pruébelo en línea (pegue el código con ctrl + v, coloque la entrada al final y presione shift + enter)

entrada

["pruebame"]

Gracias @ No hay un árbol para comprobar y jugar golf -21 bytes

Perl 6 , 38 30 bytes

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

Pruébalo en línea!

Codeblock anónimo que toma la entrada como una lista de dos cadenas y devuelve el primer número 1111...con una cantidad no vacía de 1s que no está en la entrada.

Explicación:

{                          }   # 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 utilizando incorporado array argv, -10 bytes mediante el uso de eliminación de prefijo y RC_EXPAND_PARAM, -1 byte por inlining la expansión de llaves.

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

Pruébalo en línea!

Primero, este fue un desafío increíble, revisé un montón de ideas antes de aterrizar en este.

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

@y *no son identificadores, de modo ${ :|@}y ${ :|*}no trabajo, por lo tanto, el uso de${ :|argv}

Este método funcionará hasta 93 entradas y encontrará un 94o que es único. Simplemente reemplace el {1..3}con el rango máximo posible {~..!}.

Zsh , 48 47 bytes *

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

Pruébalo en línea!

Método completamente nuevo, cortesía del envío Perl 6 de JoKing, pero no funciona en cadenas grandes (n> 20) debido a restricciones de tamaño entero. $@[(I)$i]es una búsqueda de matriz inversa al índice más grande, generará cero (falso en la expansión aritmética) si $ i no se encuentra en los parámetros de la línea de comando.

MATL , 12 bytes

c"1Y2@X-1)&h

La entrada es un conjunto de celdas de cadenas que contienen caracteres ASCII imprimibles. La salida se forma a partir de las letras 'ABC'y, por lo tanto, pertenece al dominio de entrada.

Pruébalo en línea!

Explicación

La salida es tan larga como la cadena de entrada más larga. Su n carácter -ésimo es la primera carta del 'ABC'que es diferente de la n caracter -ésimo de ambas cadenas 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

Pruébalo en línea!

Sustituir el primer carácter de la máxima de las dos cadenas de entrada con a, by cy recoger la primera que es diferente de ambas cadenas de entrada.

Ruby , 53 bytes

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

Pruébalo en línea!

Básicamente genera las cadenas a...a, b...by c...cy selecciona el primero que no está en la entrada.

ES6, 54 bytes

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

Pyth, 7 8 bytes

hC-LG.T

1 byte gracias a Jakube

Banco de pruebas

Usamos .Ttransposición de preservación de longitud, en lugar de Ctransposición truncada, para que funcione en entradas donde una cadena está vacía.

Dadas dos cadenas como una tupla, las transponemos ( .T), luego mapeamos el par de caracteres resultante o un solo carácter restando los caracteres del alfabeto de minúsculas con -LG, luego transponemos la lista resultante de cadenas de caracteres no utilizados con C, luego regresamos la primera de esas cadenas con h. Consiste en la primera letra alfabéticamente que no está en ninguna cadena, para cada posición.

Java (OpenJDK 8) , 100 73 bytes

-27 bytes gracias al 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;}

Pruébalo en línea!

Dominio de entrada = ASCII imprimible + punto 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}

Pyth , 23 22 bytes

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

Pruébalo aquí!

Pyth , 22 bytes

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

¡Banco de pruebas!

Explicación

+.)-.{<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/;$_}

Toma la entrada como dos argumentos separados y devuelve la tercera cadena.

La subrutina intenta producir una cadena muy similar a la primera cadena pero con el primer no zcarácter reemplazado por a z. Luego se ocupa de los casos de esquina reemplazando el primer carácter con yo x, según sea necesario, si encuentra que una de las entradas era de hecho una secuencia de todos z.

Perl 5 , 68 bytes

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

Explicación:

• comienza con (cadena de letra "a" tan larga como la primera cadena) o segunda cadena si eso es falso, es decir, longitud cero
• sigue incrementándolo hasta que sea diferente del primero y el segundo

Comenzar desde "a" s era evitar incrementar hasta el punto donde Perl alarga la cadena; con solo dos cadenas para evitar ser el mismo, no podría desbordarse.

Ejecutar con:

perl -e '$s = ' -E 'sub{$_="a"x length $_[0]||$_[1];$_++while $_ eq$_[0]||$_ eq$_[1];$_}' -E ';say $s->("z", "true")'

C (gcc) ,70 sesenta y cinco 73 67 61 bytes

La función necesita que las cadenas proporcionadas sean mutables (es decir, matrices o asignadas dinámicamente).

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

Pruébalo en línea!

Funciona para la gama estándar ASCII

Explicación:

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 guardó 9 bytes, @ user2390246 guardó 13 bytes

función

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

manifestación

# 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 (al curry) de Stringa lambda de Stringa String. Asignar 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;}

Pruébalo en línea

Lambda sin golf

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 solución gira caracteres ASCII aleatorios en la cadena más larga hasta que se cumplan las condiciones requeridas. Las entradas son UTF-8 y las salidas son ASCII.

No conozco los detalles arenosos de Unicode, pero me parece plausible que esta solución pueda fallar cuando un anexo se charune al punto de código anterior para formar una sola unidad de código. Si alguien que sabe más sobre esto puede verificar esto, cambiaré el dominio de entrada a ASCII.

Java 8, 126 bytes

Mismo tipo que el anterior.

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

Pruébalo en línea

Lambda sin golf

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

Esto incrementa el primer byte de la cadena más larga, envolviendo dentro de ASCII, hasta que se cumplan las condiciones requeridas. Las entradas y salidas son cadenas ASCII.

APL (Dyalog Unicode) , ^{SBCS de} 11 bytes

Programa completo, toma la entrada como una lista anidada de 2 elementos.

⊃¨⎕A∘~¨,⌿↑⎕

Pruébalo en línea!

Bash, 115 .. 77 bytes

Reemplaza el primer carácter de la primera cadena de entrada (no vacía) con 1,2,3 hasta que no se encuentre coincidencia con ninguna de las entradas. Pruébalo en línea!

-9, -12, -9, -8 bytes, todo gracias a la función Gamma

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

(una gran mejora sobre el original ... )

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

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

Pruébalo en línea!

Japt , 17 bytes

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

Repite las letras A-Za la longitud de la entrada más larga, elimina los valores en la entrada y obtiene el primer elemento en la matriz.

Pruébalo en línea!

Solución anterior, 18 bytes

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

Pruébalo en línea!

Elige un carácter aleatorio del alfabeto y lo repite a la longitud de la cadena de entrada más larga, hasta que no esté presente en la entrada.

Python 3, 74 73 bytes

-1 byte gracias 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 el entero más bajo con la misma longitud que la primera de las entradas que tiene una longitud distinta de cero.

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]

Creo que tiene algo de potencial. La idea es que agrega 1 al primer carácter en la primera cadena, luego comprueba si el primer carácter de la otra entrada es el mismo.

** Nota, ^ no maneja cadenas de longitud 0, por lo que realmente no funciona con esta longitud.

Aquí hay una solución súper larga que funciona con longitud 0

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

Cualquier mejora sería apreciada!

CJam, 31 30 23 bytes

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

Toma ASCII imprimible como entrada. Emite una cadena de 0, 1 o 2 que tiene la misma longitud que una de las cadenas de entrada. ¡La lógica es que uno de esos no puede ser ninguna de las cadenas de entrada!

Pruébalo en línea

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

Pruébalo en línea!