Date due stringhe, trova la tabella di traduzione ( cifra di sostituzione ) tra le due, se la traduzione non è possibile, l'output è falso. La risposta deve essere ridotta a icona e creata da sinistra a destra. Il primo carattere da tradurre tra le parole deve essere il primo nella tabella di traduzione. Inoltre, qualsiasi lettera non tradotta (nello stesso posto in cui era originariamente), NON dovrebbe trovarsi nella tabella di traduzione.

Probabilmente il più facilmente definito attraverso esempi:

Casi validi

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

Notare l'ordinamento, un output di ["tb","ps"]non è valido per questa sfida.

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

Nota come nnon viene tradotto perché è una relazione 1 a 1.

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

Nota come inon viene tradotto perché è una relazione 1 a 1.

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

A non è incluso, rimane lo stesso, spuò essere mappato a lcausa della corrispondenza del modello.

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

Abbina perfettamente il modello.

Casi falsi

"banana", "angular" => false

(non della stessa lunghezza, impossibile).

"animal", "snails" => false

(ogni personaggio può essere usato UNA VOLTA su ciascun lato della traduzione).

"can","cnn" => false

(n viene utilizzato implicitamente nella traduzione, pertanto la definizione di una tabella di traduzione con n-> a non sarebbe valida)

Pertanto, [aimal,sails]è una risposta non valida, rendendo questa falsa.

"a1", "22" => false

Vedi "avvertenze", questo è elencato come falsy. In questo caso, è perché ae 1non è possibile mappare entrambi 2. (Ogni personaggio può essere usato UNA VOLTA su ciascun lato della traduzione).

Questa risposta sembra essere un buon punto di riferimento: /codegolf//a/116807/59376

Se hai domande sulla funzionalità di due coppie di parole non elencate, rinvia a questa implementazione.

Regole I / O

• L'input può essere un array di 2 elementi o come 2 input separati.
• L'output può essere delimitato da array o newline / spazio, in modo simile a come l'ho mostrato.
• L'output falso può essere 0, -1 o falso. Anche l'output errato / vuoto va bene.
• Sei garantito che anon sarà uguale be né ané bsarà vuoto.
• ae bsono sequenze di lettere stampabili solo in ASCII.

Avvertenze

• Le traduzioni devono avvenire da sinistra a destra, vedi esempio 1.
• Non devi emettere caratteri che rimangono gli stessi.
• Il tuo programma può contenere solo due stringhe ae b.
• Ogni personaggio può essere usato UNA VOLTA su ciascun lato della traduzione. Questo è ciò che rende la traduzione dal snailsal animalsimpossibile.
• I sostituti ricorsivi non dovrebbero verificarsi. Esempio di sostituzione ricorsiva: "a1","22"->[a1,12]dove a viene prima sostituito da 1, quindi entrambi i risultanti 1 vengono sostituiti con 2. Questo non è corretto, supponiamo che tutte le traduzioni avvengano indipendentemente l'una dall'altra, il che significa che si tratta di una falsa. Significato: "a1" con tabella di traduzione di [a1,12] restituisce 12 (non 22)

JavaScript (ES6), 128 byte

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 byte

Modifica : risolto per supportare input come quelli "22" / "a1"che dovrebbero essere falsi.

Restituisce uno 0o un array di due stringhe.

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

Formattato e commentato

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)

Casi test

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 byte

18 byte salvati da @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;

Casi test

allargato

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 byte

stampa 0 per falso Output true come stringa

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;

Casi test

allargato

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 byte

La seconda risposta può essere abbreviata se sono consentite le matrici associative

stampa 0 per falso Output true come array associativo anziché stringa

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

Casi test

PHP> = 7.1, 227 byte

stampa 0 per 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;

Casi test

allargato

[,$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 byte

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

Collegamento monadico senza nome (funzione a un input) che prende un elenco, che restituisce:
un elenco vuoto nei casi falsi; o
un elenco contenente due elenchi di personaggi nei casi veritieri.

Provalo online! (il piè di pagina divide l'elenco con uno spazio per evitare di stampare una rappresentazione sfumata)
... o vedere una suite di test .

Come?

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

.+
$&;$&
+`^\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).*

Provalo online!

Accetta input ;separato. Anche l'output è ;separato. I falsi input sono indicati da output vuoti.

So che questo è dolorosamente dettagliato, sto ancora cercando di ridurre i byte. La maggior parte di questi byte viene utilizzata per eliminare i falsi input.

Le modifiche

• Si scopre che ho avuto un difetto significativo con il mio programma. Ora è stato risolto, ma al costo di oltre 40 byte.

• È stato riscontrato un altro errore in cui il mio programma non ha dichiarato a1;22falso l'input , ma sono stato in grado di mantenere il programma sotto i 250 byte dopo averlo corretto

Spiegazione

(una spiegazione più dettagliata arriverà a breve)

Innanzitutto dobbiamo verificare se la lunghezza delle stringhe aeb sono lo stesso o no. In caso contrario, eliminiamo tutto.

Duplica l'input per preservarlo mentre eseguiamo alcuni test di lunghezza.

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

Ora in un ciclo, eliminiamo il primo carattere di ae il primo carattere di bfino a quando una delle stringhe diventa vuota.

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

Ora ci sono possibilità per lo "spazio modello".

• ;;abc Entrambe le stringhe hanno la stessa lunghezza
• def;;abc a è più lungo di b
• ;def;abc b è più lungo di a

Ora dobbiamo svuotare l'input se le stringhe non hanno la stessa lunghezza (scenari 2 e 3). Questo è ciò che fa questa sostituzione di seguito. Rimuove il testo che corrisponde agli scenari 2 e 3.

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

Ciò rimuove i caratteri che non sono traslitterati nelle stringhe ae b. abc;1b2=>ac;12

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

Dopodiché, dobbiamo rimuovere i caratteri duplicati. sese;1212=> se;12, ma questo conserva input comeaba;123

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

Infine, eliminiamo l'input se sono presenti caratteri duplicati associati a caratteri diversi come aba;123o a1;22.

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

E infine, rimuovere i caratteri duplicati.

Gelatina , 28 26 byte

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

Provalo 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

Rubino, 133 byte

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

Provalo online!

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

Solo per i calci, ecco una versione da 84 byte in Goruby, che è Ruby, ma con una bandiera da golf impostata durante la compilazione dell'interprete. Tra le altre cose, ti consente di abbreviare le chiamate di metodo al loro identificatore univoco più breve.

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

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

Provalo online!

• -4 byte! grazie a mbomb007 per aver suggerito l'uso di tab invece di spazio.

• modificato il formato di input, sempre grazie a mbomb007.

Python 3.6, 211 185 181 181 byte

Esce con un errore per risultati falsi.

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

Ciò richiede Python 3.6, che è possibile eseguire in una shell qui .

È possibile testarlo senza l'ordinamento di output corretto su TIO qui . (TIO non ha 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 solo l'ordine non avesse importanza ...

Röda , 108 119 byte

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

Provalo online!

Questa è una funzione che accetta due elenchi di caratteri dallo stream e ne invia due agli stream.

Questo potrebbe essere più triste se mi fosse permesso di restituire coppie.

Spiegazione (obsoleta):

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

Ecco una soluzione di sottolineatura che non contiene variabili (114 byte):

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

Sono molti caratteri di sottolineatura.

AWK, 140 byte

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}

Utilizzo: inserire il codice FILEquindi:

awk -f FILE <<< "string1 string2"

Le stringhe di input devono essere separate da spazi.

L'output è vuoto se falliscono o 2 stringhe separate da uno spazio.

k, 28 byte

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

Spiegazione:

{                          } /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 byte

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

Provalo online!

{...}  funzione anonima:

 Se…

  ⍺⍵ gli argomenti

  ⍳⍨¨ quando autoindicizzati (ovvero le prime occorrenze dei loro elementi in se stessi)

  ≡/ sono equivalenti

 : poi:

  ⍺(... )⍵ applica la seguente funzione tacita agli argomenti:

   ,¨ concatenare gli elementi corrispondenti (errori nelle lunghezze non corrispondenti)

   é quindi filtra per ( éè solo la funzione primitiva /)

   ≠ dove le stringhe sono diverse

  ∪ unico (rimuovi duplicati)

  ↓⍉↑ trasporre la lista di coppie in coppia di liste (lit. mescolare in tabella, trasporre tabella, dividere in liste)

 altrimenti, non fare nulla

CJam, 38 byte

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

Input e output sono array nello stack.

PHP (> = 7.1), 165 byte

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

stampe 0per falsy, array associativo altro. Esegui con -ro prova online .

abbattersi

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