Dadas dos cadenas, encuentre la tabla de traducción ( cifrado de sustitución ) entre las dos, si la traducción no es posible, la salida es falsa. La respuesta debe minimizarse y crearse de izquierda a derecha. El primer carácter a traducir entre palabras debe ser el primero en la tabla de traducción. Además de esto, cualquier carta que no esté traducida (en el mismo lugar que estaba originalmente), NO debe estar en la tabla de traducción.

Probablemente más fácilmente definido a través de ejemplos:

Casos Válidos

"bat", "sap" => ["bt","sp"]

Observe el pedido, una salida de ["tb","ps"]no es válida para este desafío.

"sense", "12n12" => ["se","12"]

Observe cómo nno se traduce porque es una relación 1 a 1.

"rabid", "snail" => ["rabd","snal"]

Observe cómo ino se traduce porque es una relación 1 a 1.

"ass", "all" => ["s","l"]

A no está incluido, permanece igual, se spuede asignar ldebido a la coincidencia de patrón.

"3121212", "ABLBLBL" => ["312","ABL"]

Combina perfectamente con el patrón.

Falsy Cases

"banana", "angular" => false

(No es de la misma longitud, imposible).

"animal", "snails" => false

(cada carácter solo se puede usar UNA VEZ en cada lado de la traducción).

"can","cnn" => false

(n se usa implícitamente en la traducción, por lo tanto, definir una tabla de traducción con n-> a no sería válido)

Por lo tanto, [aimal,sails]es una respuesta no válida, lo que hace que esto sea falso.

"a1", "22" => false

Ver "advertencias", esto aparece como falso. En este caso, es porque ay 1no se pueden asignar a ambos 2. (Cada carácter solo se puede usar UNA VEZ en cada lado de la traducción).

Esta respuesta parece ser un buen punto de referencia: /codegolf//a/116807/59376

Si tiene preguntas sobre la funcionalidad de dos pares de palabras que no figuran en la lista, consulte esta implementación.

Reglas de E / S

• La entrada puede ser como una matriz de 2 elementos o como 2 entradas separadas.
• La salida puede ser como una matriz o nueva línea / espacio delimitado, similar a como lo he mostrado.
• La salida falsa puede ser 0, -1 o falsa. La salida de error / vacío también está bien.
• Le garantizamos que ano será igual by que atampoco bestará vacío.
• ay bson secuencias de letras imprimibles solo en ASCII.

Advertencias

• Las traducciones deben ocurrir de izquierda a derecha, ver ejemplo 1.
• No debe generar caracteres que sigan siendo los mismos.
• Su programa solo puede tomar dos cadenas ay b.
• Cada carácter solo se puede usar UNA VEZ en cada lado de la traducción. Esto es lo que hace la traducción de snailsa animalsimposible.
• Los reemplazos recursivos no deberían ocurrir. Ejemplo de reemplazo recursivo: "a1","22"->[a1,12]donde a se reemplaza primero por 1, luego los 1 resultantes se reemplazan por 2. Esto no es correcto, suponga que todas las traducciones ocurren independientemente unas de otras, lo que significa que esto es falso. Significado: "a1" con la tabla de traducción de [a1,12] se evalúa a 12 (no 22)

JavaScript (ES6), 128 bytes

f=
(s,t)=>!t[s.length]&&[...s].every((c,i)=>n[d=t[i]]==c||d&&!m[c]&&!n[d]&&(n[m[c]=d]=c,c==d||(a+=c,b+=d)),m={},n={},a=b='')&&[a,b]

<div oninput=o.textContent=f(s.value,t.value)><input id=s><input id=t><pre id=o>

JavaScript (ES6), 108 107 105 106 bytes

Editar : "22" / "a1"se corrigió para admitir entradas como esa que deberían ser falsas.

Devuelve una 0o una matriz de dos cadenas.

f=(a,b,x)=>[...a].some((c,i)=>d[C=b[i]]?d[C]!=c:(d[C]=c)!=C&&(s+=c,t+=C,!C),s=t='',d=[])?0:x||f(b,a,[s,t])

Formateado y comentado

f = (                       // given:
  a,                        // - a = first string
  b,                        // - b = second string
  x                         // - x = reference result from previous iteration,
) =>                        //       or undefined
  [...a].some((c, i) =>     // for each character c at position i in a:
    d[                      //   if we already have a translation
      C = b[i]              //   of the character C at the same position in b,
    ] ?                     //   then:
      d[C] != c             //     return true if it doesn't equal c
    :                       //   else:
      (d[C] = c) != C &&    //     store the translation C -> c in the dictionary
      (                     //     if the characters are different:
        s += c, t += C,     //       append them to the translation strings s and t
        !C                  //       return true if C is undefined
      ),                    //
    s = t = '', d = []      //   initialize s, t and d  
  ) ?                       // if some() returns true:
    0                       //   there was a translation error: abort
  :                         // else:
    x ||                    //   if this is the 2nd iteration, return x
    f(b, a, [s, t])         //   else do a recursive call with (b, a)

Casos de prueba

f=(a,b,x)=>[...a].some((c,i)=>d[C=b[i]]?d[C]!=c:(d[C]=c)!=C&&(s+=c,t+=C,!C),s=t='',d=[])?0:x||f(b,a,[s,t])

// truthy
console.log(f('bat','sap'))
console.log(f('sense','12n12'))
console.log(f('rabid','snail'))
console.log(f('ass','all'))
console.log(f('3121212','ABLBLBL'))

// falsy
console.log(f('banana','angular'))
console.log(f('animal','snails'))
console.log(f('a1','22'))
console.log(f('22','a1'))
console.log(f('aaa','bab'))
console.log(f('abc','abcd'))
console.log(f('abcd','abc'))

PHP> = 7.1, 130 bytes

18 bytes guardados por @Titus

for([,$x,$y]=$argv;a&$o=$y[$i];)$o==($p=$x[$i++])?:$k[$c[$p]=$o]=$p;echo$y==strtr($x,$c)&$x==strtr($y,$k)?join($k)." ".join($c):0;

Casos de prueba

Expandido

for([,$x,$y]=$argv;a&$o=$y[$i];)
$o==($p=$x[$i++])?:$k[$c[$p]=$o]=$p; # if char string 1 not equal char string 2 make key=char1 value=char2 and key array
echo$y==strtr($x,$c) # boolean replacement string 1 equal to string 2
    &$x==strtr($y,$k) # boolean replacement string 2 equal to string 1
    ?join($k)." ".join($c) # output for true cases
:0; #Output false cases

PHP> = 7.1, 148 bytes

imprime 0 para falso Salida verdadera como cadena

for([,$x,$y]=$argv;a&$o=$y[$i];$i++)$x[$i]==$o?:$c[$x[$i]]=$o;echo$y==strtr($x,($f=array_flip)($k=$f($c)))&$x==strtr($y,$k)?join($k)." ".join($c):0;

Casos de prueba

Expandido

for([,$x,$y]=$argv;a&$o=$y[$i];$i++)
$x[$i]==$o?:$c[$x[$i]]=$o; # if char string 1 not equal char string 2 set key=char1 value=char2
echo$y==strtr($x,($f=array_flip)($k=$f($c))) # boolean replacement string 1 equal to string 2
&$x==strtr($y,$k) # boolean replacement string 2 equal to string 1
    ?join($k)." ".join($c) # output for true cases
:0; #Output false cases

PHP> = 7.1, 131 bytes

La segunda respuesta se puede acortar a esto si se permiten matrices asociativas

imprime 0 para falso Salida verdadero como matriz asociativa en lugar de cadena

for([,$x,$y]=$argv;a&$o=$y[$i];$i++)$x[$i]==$o?:$c[$x[$i]]=$o;print_r($y==strtr($x,($f=array_flip)($f($c)))&$x==strtr($y,$k)?$c:0);

Casos de prueba

PHP> = 7.1, 227 bytes

imprime 0 para falso

[,$x,$y]=$argv;echo strlen($x)==strlen($y)?strtr($x,$c=array_filter(($f=array_flip)($z=$f(array_combine(($p=str_split)($x),$p($y)))),function($v,$k){return$k!=$v;},1))==$y&$x==strtr($y,$z)?join(array_keys($c))." ".join($c):0:0;

Casos de prueba

Expandido

[,$x,$y]=$argv; # 
echo strlen($x)==strlen($y) #compare string lengths
?strtr($x,  # replace function
$c=array_filter( # filter 
($f=array_flip)($z=$f( # # remove doubles like in testcase: a1 => 22
    array_combine(($p=str_split)($x),$p($y))  # replacement array keys string 1 values string 2 
))
    ,function($v,$k){return$k!=$v;},1)) # remove all keys that equal to values in array
    ==$y # boolean replacement string 1 equal to string 2
&$x==strtr($y,$z) # boolean replacement string 2 equal to string 1        
?join(array_keys($c))." ".join($c) # output for true cases
    :0 # Output if replacement from string 1 is not equal to string 2
:0; #Output for different lengths

Jalea , 18 bytes

ẠaQ⁼µ€Ạ
z0EÐḟQZẋÇ$

Enlace monádico sin nombre (función de una entrada) tomando una lista, que devuelve:
una lista vacía en los casos de falsey; o
una lista que contiene dos listas de caracteres en los casos verdaderos.

Pruébalo en línea! (el pie de página divide la lista con un espacio para evitar imprimir una representación borrosa)
... o vea un conjunto de pruebas .

¿Cómo?

ẠaQ⁼µ€Ạ - Link 1, valid?: mapping list
    µ€  - perform the code to the left for €ach mapping entry
Ạ       -     none of mapping entry falsey? (this & Main's z0 handle unequal input lengths)
  Q     -     deduplicate mapping entry
   ⁼    -     is equal to mapping list? (non-vectorising)
 a      -     and
      Ạ - none falsey (both mapping lists must pass that test)
        - The whole function returns 1 if the mapping list is acceptable, 0 if not

z0EÐḟQZẋÇ$ - Main link: list of strings
z0         - transpose with filler 0 (unequal lengths make pairs containing zeros)
   Ðḟ      - filter discard:
  E        -     all equal? (removes the untranslated character pairs)
     Q     - deduplicate (removes the repeated translation pairs)
      Z    - transpose (list of pairs to pair of lists)
         $ - last two links as a monad:
       ẋ   -     repeat list this many times:
        Ç  -         call last link (1) as a monad

Retina , 194 191 185 229 225 241 bytes

.+
$&;$&
+`^\w(\w*;)\w
$1
^;\w.*|.+;;.*|;;

^((.)*)(.)(.*;(?<-2>.)*(?(2)(?!)))\3
$1$4
+`((.)(.)*)\2((.)*;.*(.)(?<-3>.)*(?(3)(?!)))\6((?<-5>.)*(?(5)(?!)))$
$1$4$7
^(.)*(.)(.)*(\2)?.*;(?<-1>.)*(?(1)(?!))(.)(?<-3>.)*(?(3)(?!))(?(4)(?!\5)|\5).*

Pruébalo en línea!

Toma entrada ;separada. La salida es también; separada. Las entradas falsas se representan con salidas vacías.

Sé que esto es dolorosamente detallado, todavía estoy tratando de reducir bytes. La mayoría de estos bytes van a eliminar entradas falsas.

Ediciones

• Resulta que tuve un defecto significativo con mi programa. Ahora está arreglado, pero a un costo de más de 40 bytes.

• Se encontró otro error donde mi programa no declaró la entrada a1;22falsa, pero pude mantener el programa por debajo de 250 bytes después de arreglarlo

Explicación

(una explicación más detallada vendrá en breve)

Primero tenemos que verificar si las longitudes de las cadenas ayb son iguales o no. Si no lo están, eliminamos todo.

Duplica la entrada para preservarla mientras hacemos algunas pruebas de longitud.

.+                      Matches everything
$&;$&                   $& indicates the match, so $&;$& will duplicate the match and separate it with a semi-colon

Ahora en un bucle, eliminamos el primer carácter de ay el primer carácter de bhasta que una de las cadenas quede vacía.

+`                     Repeatedly (until no more substitutions could be made) replace
  ^\w                   A word character (letter or number) at the beginning
     (\w*;)             Capture Group 1: matches any number of word characters and a semicolon
           \w           And a word character after the semi-colon
                       with
$1                      The result of the first capture group

Ahora hay posibilidades para el "espacio de patrones".

• ;;abc Ambas cuerdas son de igual longitud
• def;;abc a es más largo que b
• ;def;abc b es más largo que a

Ahora tenemos que vaciar la entrada si las cadenas no tienen la misma longitud (escenarios 2 y 3). Esto es lo que hace esta sustitución a continuación. Elimina el texto que coincide con los escenarios 2 y 3.

^;\w.*|.+;;.*|;;

Esto elimina los caracteres que no se transcriben en cadenas ay b. abc;1b2=>ac;12

^((.)*)(.)(.*;(?<-2>.)*(?(2)(?!)))\3
$1$4

Después de eso, tenemos que eliminar los caracteres duplicados. sese;1212=> se;12, pero esto conserva entradas comoaba;123

+`((.)(.)*)\2((.)*;.*(.)(?<-3>.)*(?(3)(?!)))\6((?<-5>.)*(?(5)(?!)))$
$1$4$7

Finalmente, eliminamos la entrada si hay caracteres duplicados que se asignan a diferentes caracteres como aba;123o a1;22.

^(.)*(.)(.)*(\2)?.*;(?.)*(?(1)(?!))(.)(?.)*(?(3)(?!))(?(4)(?!\5)|\5).*

Y finalmente, elimine los caracteres duplicados.

Jalea , 28 26 bytes

QL$€⁼L€
EÐḟQZK0Ç?
ZÇ0L€E$?

Pruébalo en línea!

QL$€⁼L€      Checks validity of mapping
QL$€          number of unique characters in mapping
    ⁼         equals
     L€       number of characters in mapping

EÐḟQZK0Ç?  Writes valid mapping or 0
EÐḟ           filter maps where a = b
   Q          filter duplicate maps
    Z         zip by column [["ac"],["bd"]] => ["ab","cd"]
     K0Ç?   print if valid map, else print 0

ZÇ0L€E$?      main link: takes an array of 2 strings
Z              zip by column: ["ab", "cd"] => [["ac"],["bd"]]
 Ç     ?       print mapping if
   L€E$         all pairs are same length (returns 0 if initial strings were
  0             else 0

Rubí, 133 bytes

->a,b{a.size!=b.size||(m=a.chars.zip b.chars).any?{|i,j|m.any?{|k,l|(i==k)^(j==l)}}?0:m.select{|x,y|x!=y}.uniq.transpose.map(&:join)}

Pruébalo en línea!

Más legible:

->a, b{
    # Pair the letters in each string - [AB, AB, AB,...]
    pairs = a.chars.zip(b.chars)

    # If there's any combination of two pairs that share one character but not both,
    # or if the strings have different lengths, then the input's invalid.
    if a.size != b.size || pairs.any?{|i,j| pairs.any? {|k, l| (i==k)!=(j==l) }} 
        return 0 # 0 isn't actually falsy in Ruby, but this challenge allows it anyway
    end
    return pairs.select{|x,y| x != y} # Remove unchanged letters
                .uniq                 # Remove duplicates
                .transpose            # Change [AB, AB, AB] form to [AAA, BBB] form.
                .map(&:join)          # Convert the arrays back into strings
}

Solo por diversión, aquí hay una versión de 84 bytes en Goruby, que es Ruby, pero con una bandera de golf al compilar el intérprete. Entre otras cosas, le permite abreviar las llamadas de método a su identificador único más corto.

->a,b{a.sz!=b.sz||(m=a.ch.z b).ay?{|i,j|m.y?{|k,l|(i==k)^(j==l)}}?0:m.rj{|x,y|x==y}.u.tr.m(&:j)}

Python 2 , 198,193,189,182,179,175,169, 165 bytes

def f(a,b):
 r=([""]*2,0)[len(a)!=len(b)]
 for u,v in zip(a,b):
	if r:
		q,w=r
		f=q.find(u)
		if u!=v:r=(([q+u,w+v],r)[f>-1 and w[f]==v],0)[f<0 and v in w]
 print r

Pruébalo en línea!

• -¡4 bytes! Gracias a mbomb007 por sugerir el uso de tab en lugar de espacio.

• modificó el formato de entrada, nuevamente gracias a mbomb007.

Python 3.6, 211 185 181 178 bytes

Sale con un error para resultados falsos.

def f(x,y,d={}):
    for a,b in zip(x,y):1/(a not in d or b==d[a]or len(x)-len(y));d[a]=b;1/([*d.values()].count(b)<2)
    return map(''.join,zip(*[x for x in d.items()if x[0]!=x[1]]))

Esto requiere Python 3.6, que puede ejecutar en un shell aquí .

Puede probarlo sin el orden de salida correcto en TIO aquí . (TIO no tiene 3.6).

Sin golf:

from collections import*
d=OrderedDict()                     # keep order
x,y=input()
if len(x)!=len(y):1/0               # equal lengths
for a,b in zip(x,y):
    if a in d and d[a]!=b:1/0       # no duplicate keys
    else:d[a]=b
    if d.values().count(b)>1:1/0    # no duplicate values
print map(''.join,zip(*[x for x in d.items()if x[0]!=x[1]])) # format, no no-ops

Si solo el orden no importara ...

Röda , 108 119 bytes

{c=[{_<>_|[[_,_]]|orderedUniq}()]d=[]e=[]c|_|{{d+=a;e+=b}if[a!=b]}for a,b[d,e]if[0,1]|{|n|c|[_[n]]|sort|count|[_2=1]}_}

Pruébalo en línea!

Esta es una función que toma dos listas de caracteres del flujo y empuja dos listas al flujo.

Esto podría ser clasificador si se me permitiera devolver pares.

Explicación (desactualizada):

{
    c=[{
        _<>_|       /* pull two lists and interleave them */
        [[_,_]]|    /* "unflat", create lists from pairs */
        orderedUniq /* remove duplicates */
    }()]            /* c is a list of the pairs */
    d=[]
    e=[]
    c| /* push the pairs to the stream */
    _| /* flat */
    {  /* for each pair (a, b): */
        { /* if a != b (remove "1-to-1 relations"):  */
            d+=a;
            e+=b
        }if[a!=b]
    }for a,b
    /* return d and e if no character is mapped to more than one character */
    [d,e]if c|[_[0]]|sort|count|[_2=1]
}

Aquí hay una solución de subrayado que no contiene variables (114 bytes):

{[[{_<>_}()|[[_,_]]|unorderedUniq]]|[[_()|_|[_]if[_1!=_2]],[_1()|_|[_2]if[_1!=_2]]]if[[_1()|_][::2],[_1()|_][1::2]]|[sort(_)|count|[_2=1]]}

Eso es un montón de guiones bajos.

AWK, 140 bytes

BEGIN{RS="(.)"}RT~/\W/{S=1}RT~/\w/&&S{if(RT!=x=A[++b]){if(B[z=RT]==""){B[z]=x
c=c x
d=d z}a=B[z]!=x?0:a}}!S{A[++a]=RT}END{if(a==b)print c,d}

Uso: Coloque el código en FILEentonces:

awk -f FILE <<< "string1 string2"

Las cadenas de entrada deben estar separadas por espacios en blanco.

La salida está vacía si fallan, o 2 cadenas separadas por un espacio.

k, 28 bytes

{$[(y?y)~x?x;+?(~=/)#x,'y;]}

Explicación:

{                          } /function that takes in two strings, x and y
 $[         ;            ;]  /if statement (to check if there is a mapping)
         x?x                 /first index of [each letter in x] in x
   (y?y)                     /first index of [each letter in y] in y
        ~                    /make sure they match
                     x,'y    /zip together the two strings
               (~=/)#        /remove equal pairs
              ?              /unique pairs only
             +               /transpose ("unzip", in a way)

APL (Dyalog) con AGL , 22 bytes

{≡/⍳⍨¨⍺⍵:↓⍉↑∪⍺(≠é,¨)⍵}

Pruébalo en línea!

{... } función anónima:

 Si…

  ⍺⍵ los argumentos

  ⍳⍨¨ cuando se autoindexa (es decir, las primeras apariciones de sus elementos en sí mismos)

  ≡/ son equivalentes

 : luego:

  ⍺(...)⍵  aplique la siguiente función tácita a los argumentos:

   ,¨ concatenar elementos correspondientes (errores en longitudes que no coinciden)

   é luego filtrar por ( ées solo la función primitiva/ )

   ≠ donde las cuerdas son diferentes

  ∪ único (eliminar duplicados)

  ↓⍉↑ transponer lista de pares a pares de listas (literalmente, mezclar en tabla, transponer tabla, dividir en listas)

 de lo contrario, no hagas nada

CJam, 38 bytes

{_:,~={1\/;}:K~z{)\c=!},L|z_{_L|=K}%;}

La entrada y la salida son matrices en la pila.

PHP (> = 7.1), 165 bytes

for([,$x,$y]=$argv;a&$c=$x[$i];$t[$c]=$d)$z+=($d=$y[$i++])&&$d==($t[$c]??$d);foreach($t as$a=>$b)$a==$b?:$r[$a]=$b;print_r($z<$i|array_unique($r)<$t||a&$y[$i]?0:$t);

impresiones 0para falsas, matriz asociativa más. Ejecutar -ro probarlo en línea .

Descompostura

for([,$x,$y]=$argv;         # import arguments to $x and $y
    a&$c=$x[$i];            # loop through $x
    $t[$c]=$d)                  # 2. add pair to translation
$z+=                            # 1. increment $z if
    ($d=$y[$i++])&&             # there is a corresponding character in $y and
    $d==($t[$c]??$d);           # it equals a possible previous replacement
                            # remove identities from translation
foreach($t as$a=>$b)$a==$b?:$r[$a]=$b;
print_r(
    $z<$i                   # if not all tests passed
    |array_unique($t)<$t    # or there are duplicates in the translation
    ||a&$y[$i]              # or $y has more characters
    ?0                      # then print 0
    :$r                     # else print translation
);