Dadas duas seqüências, encontre a tabela de conversão ( cifra de substituição ) entre as duas, se a tradução não for possível, a saída será falsa. A resposta deve ser minimizada e criada da esquerda para a direita. O primeiro caractere a ser traduzido entre as palavras deve ser o primeiro na tabela de tradução. Além disso, qualquer letra que não seja traduzida (no mesmo local em que foi originalmente) NÃO deve estar na tabela de tradução.

Provavelmente, mais facilmente definido através de exemplos:

Casos válidos

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

Observe a ordem, uma saída de ["tb","ps"]não é válida para este desafio.

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

Observe como o nnão é traduzido porque é uma relação de 1 para 1.

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

Observe como o inão é traduzido porque é uma relação de 1 para 1.

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

A não está incluído, permanece o mesmo, spode ser mapeado ldevido à correspondência de padrões.

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

Corresponde perfeitamente ao padrão.

Falsy Cases

"banana", "angular" => false

(não é do mesmo tamanho, impossível).

"animal", "snails" => false

(cada caractere só pode ser usado UMA VEZ em cada lado da tradução).

"can","cnn" => false

(n é implicitamente usado na tradução, portanto, definir uma tabela de tradução com n-> a seria inválido)

Assim, [aimal,sails]é uma resposta inválida, tornando essa falsidade.

"a1", "22" => false

Veja "advertências", isso é listado como falso. Nesse caso, é porque ae 1não é possível mapear os dois 2. (Cada caractere só pode ser usado UMA VEZ em cada lado da tradução).

Esta resposta parece ser uma boa referência: /codegolf//a/116807/59376

Se você tiver dúvidas sobre a funcionalidade de dois pares de palavras não listados, adie para esta implementação.

Regras de E / S

• A entrada pode ser como uma matriz de 2 elementos ou como 2 entradas separadas.
• A saída pode ser delimitada por uma matriz ou nova linha / espaço, semelhante à forma como eu a mostrei.
• A saída falsa pode ser 0, -1 ou falsa. Erro / Saída vazia também está bem.
• Você está garantido de que anão será igual be anem bestará vazio.
• ae bsão seqüências de letras somente para impressão ASCII.

Ressalvas

• As traduções devem ocorrer da esquerda para a direita, veja o exemplo 1.
• Você não deve gerar caracteres que permaneçam iguais.
• Seu programa pode ter apenas duas seqüências de caracteres ae b.
• Cada caractere só pode ser usado UMA VEZ em cada lado da tradução. Isto é o que faz a tradução do snailsque animalsimpossível.
• Substituições recursivas não devem ocorrer. Exemplo de substituição recursiva: "a1","22"->[a1,12]onde a é substituído primeiro por 1, os 1s resultantes são substituídos por 2. Isso não está correto, suponha que todas as traduções ocorram independentemente uma da outra, o que significa que isso é falso. Significado: "a1" com tabela de tradução de [a1,12] é avaliado como 12 (não 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 : corrigido para suportar entradas como essas "22" / "a1"que devem ser falsas.

Retorna uma 0ou uma matriz de duas cadeias.

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

Formatado e 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 teste

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 salvos 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 teste

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 false Output true como string

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 teste

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

A segunda resposta pode ser reduzida para isso se matrizes associativas forem permitidas

imprime 0 para false Output true como array associativo em vez de string

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 teste

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 teste

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

Gelatina , 18 bytes

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

Link monádico sem nome (função de uma entrada) obtendo uma lista, que retorna:
uma lista vazia nos casos de falsey; ou
uma lista contendo duas listas de caracteres nos casos reais.

Experimente online! (o rodapé divide a lista com um espaço para evitar a impressão de uma representação distorcida)
... ou consulte uma suíte de testes .

Quão?

Ạ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).*

Experimente online!

Leva entrada ;separada. A saída também é ;separada. Entradas falsas são significadas por saídas vazias.

Eu sei que isso é dolorosamente detalhado, ainda estou tentando reduzir bytes. A maioria desses bytes é para excluir entradas falsas.

Editar% s

• Acontece que eu tinha uma falha significativa no meu programa. Está corrigido agora, mas ao custo de mais de 40 bytes.

• Outro erro foi encontrado onde meu programa não declarou a entrada como a1;22falsa, mas eu consegui manter o programa abaixo de 250 bytes depois de corrigi-lo

Explicação

(uma explicação mais detalhada estará disponível em breve)

Primeiro temos de verificar se os comprimentos das cordas ae bsão os mesmos ou não. Caso contrário, excluímos tudo.

Duplica a entrada para preservá-la enquanto fazemos alguns testes de comprimento.

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

Agora, em um loop, excluímos o primeiro caractere de ae o primeiro caractere de baté que uma das strings fique vazia.

+`                     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

Agora, existem possibilidades para o "espaço padrão".

• ;;abc Ambas as cordas têm o mesmo comprimento
• def;;abc a é maior que b
• ;def;abc b é maior que a

Agora temos que esvaziar a entrada se as seqüências não tiverem o mesmo comprimento (cenários 2 e 3). É isso que essa substituição abaixo faz. Ele remove o texto que corresponde aos cenários 2 e 3.

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

Isso remove caracteres que não são transliterados em strings ae b. abc;1b2=>ac;12

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

Depois disso, temos que remover caracteres duplicados. sese;1212=> se;12, mas isso preserva entradas comoaba;123

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

Por fim, excluímos a entrada se houver caracteres duplicados mapeados para caracteres diferentes como aba;123ou a1;22.

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

E, finalmente, remova caracteres duplicados.

Geléia , 28 26 bytes

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

Experimente online!

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

Ruby, 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)}

Experimente online!

Mais facilmente:

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

Para começar, aqui está uma versão de 84 bytes no Goruby, que é Ruby, mas com uma bandeira de golfe definida ao compilar o intérprete. Entre outras coisas, permite abreviar as chamadas de método para o menor identificador exclusivo.

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

Experimente online!

• -4 bytes! obrigado a mbomb007 por sugerir o uso de tab em vez de espaço.

• modificou o formato de entrada, novamente graças ao mbomb007.

Python 3,6, 211 185 181 178 bytes

Sai com um erro 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]]))

Isso requer Python 3.6, que você pode executar em um shell aqui .

Você pode testá-lo sem a ordem de saída correta no TIO aqui . (O TIO não possui 3.6).

Ungolfed:

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

Se apenas a ordem não importasse ...

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]}_}

Experimente online!

Essa é uma função que pega duas listas de caracteres do fluxo e envia duas listas ao fluxo.

Isso poderia ser classificador se eu tivesse permissão para retornar pares.

Explicação (desatualizada):

{
    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]
}

Aqui está uma solução de sublinhado que não contém variáveis ​​(114 bytes):

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

Isso é um monte de sublinhados.

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 o código FILEentão:

awk -f FILE <<< "string1 string2"

As cadeias de entrada precisam ser separadas por espaço em branco.

A saída está vazia se falharem ou 2 cadeias separadas por um espaço.

k, 28 bytes

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

Explicação:

{                          } /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) com AGL , 22 bytes

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

Experimente online!

{...}  função anônima:

 E se…

  ⍺⍵ os argumentos

  ⍳⍨¨ quando auto-indexado (ou seja, as primeiras ocorrências de seus elementos em si)

  ≡/ são equivalentes

 : então:

  ⍺(...)⍵  Aplique a seguinte função tácita aos argumentos:

   ,¨ concatenar elementos correspondentes (erros em comprimentos incompatíveis)

   é filtrar por ( éé apenas a função primitiva/ )

   ≠ onde as cordas são diferentes

  ∪ exclusivo (remover duplicados)

  ↓⍉↑ transpor lista de pares para par de listas (lit. misturar em tabela, transpor tabela, dividir em listas)

 mais, não faça nada

CJam, 38 bytes

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

Entrada e saída são matrizes na pilha.

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

imprime 0por outro conjunto associativo falso. Executar -rou testá-lo online .

demolir

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