Étant donné deux chaînes, recherchez la table de traduction ( chiffrement de substitution ) entre les deux, si la traduction n'est pas possible, affichez false. La réponse doit être minimisée et créée de gauche à droite. Le premier caractère à traduire entre les mots doit être le premier du tableau de traduction. En plus de cela, toute lettre qui n'est pas traduite (au même endroit qu'à l'origine), NE DOIT PAS être dans la table de traduction.

Probablement le plus facilement défini par des exemples:

Cas valides

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

Notez la commande, une sortie de ["tb","ps"]n'est pas valide pour ce défi.

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

Remarquez comment le nn'est pas traduit car il s'agit d'une relation 1 à 1.

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

Remarquez comment le in'est pas traduit car il s'agit d'une relation 1 à 1.

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

A n'est pas inclus, il reste le même, speut être mappé en lraison de la correspondance de modèle.

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

Correspond parfaitement au motif.

Cas de falsification

"banana", "angular" => false

(pas la même longueur, impossible).

"animal", "snails" => false

(chaque caractère ne peut être utilisé UNE FOIS de chaque côté de la traduction).

"can","cnn" => false

(n est implicitement utilisé dans la traduction, par conséquent, définir une table de traduction avec n-> a serait invalide)

Ainsi, [aimal,sails]est une réponse invalide, ce qui rend cette fausse.

"a1", "22" => false

Voir "mises en garde", cela est répertorié comme falsifié. Dans ce cas, c'est parce que aet 1ne peuvent pas tous les deux correspondre à 2. (Chaque caractère ne peut être utilisé UNE FOIS de chaque côté de la traduction).

Cette réponse semble être une bonne référence: /codegolf//a/116807/59376

Si vous avez des questions sur la fonctionnalité de deux paires de mots non répertoriés, reportez-vous à cette implémentation.

Règles d'E / S

• L'entrée peut être un tableau à 2 éléments ou 2 entrées distinctes.
• La sortie peut être un tableau ou une nouvelle ligne / délimitée par un espace, similaire à la façon dont je l'ai montré.
• La fausse sortie peut être 0, -1 ou fausse. Une sortie erronée / vide convient également.
• Vous êtes assuré que ace ne sera pas égal bet ni ani bne sera vide.
• aet bsont des séquences de lettres imprimables en ASCII uniquement.

Avertissements

• Les traductions doivent se produire de gauche à droite, voir l'exemple 1.
• Vous ne devez pas générer de caractères qui restent identiques.
• Votre programme ne peut prendre que deux chaînes aet b.
• Chaque caractère ne peut être utilisé UNE FOIS de chaque côté de la traduction. Ce qui fait la traduction snailsd' animalsimpossible.
• Les remplacements récursifs ne devraient pas se produire. Exemple de remplacement récursif: "a1","22"->[a1,12]où a est d'abord remplacé par un 1, puis les deux 1 résultants sont remplacés par 2. Ce n'est pas correct, supposons que toutes les traductions se produisent indépendamment les unes des autres, ce qui signifie que c'est faux. Signification: "a1" avec table de traduction de [a1,12] est évalué à 12 (pas 22)

JavaScript (ES6), 128 octets

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 octets

Modifier : corrigé pour prendre en charge des entrées telles que "22" / "a1"celles-ci devraient être fausses.

Renvoie soit 0un tableau de deux chaînes.

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

Formaté et commenté

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)

Cas de 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 octets

18 octets enregistrés par @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;

Cas de test

Étendu

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 octets

affiche 0 pour false Sortie vraie sous forme de chaîne

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;

Cas de test

Étendu

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 octets

La deuxième réponse peut être raccourcie si les tableaux associatifs sont autorisés

affiche 0 pour false Sortie true comme tableau associatif au lieu de chaîne

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

Cas de test

PHP> = 7.1, 227 octets

imprime 0 pour faux

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

Cas de test

Étendu

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

Gelée , 18 octets

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

Lien monadique sans nom (fonction à une entrée) prenant une liste, qui renvoie:
une liste vide dans les cas de falsey; ou
une liste contenant deux listes de personnages dans les cas véridiques.

Essayez-le en ligne! (le pied de page divise la liste avec un espace pour éviter d'imprimer une représentation floue)
... ou consultez une suite de tests .

Comment?

Ạ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

Rétine , 194 191 191 185 229 225 241 octets

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

Essayez-le en ligne!

Prend l'entrée ;séparément. La sortie est également ;séparée. Les fausses entrées sont signifiées par des sorties vides.

Je sais que c'est douloureusement verbeux, j'essaie toujours de réduire les octets. La plupart de ces octets servent à supprimer les fausses entrées.

Modifications

• Il s'avère que j'avais un défaut important avec mon programme. Il est maintenant corrigé, mais au prix de plus de 40 octets.

• Une autre erreur a été trouvée où mon programme n'a pas déclaré l'entrée a1;22fausse, mais j'ai pu garder le programme sous 250 octets après l'avoir corrigé

Explication

(une explication plus détaillée sera disponible sous peu)

Nous devons d'abord vérifier si les longueurs de chaînes aetb sont identiques ou non. Si ce n'est pas le cas, nous supprimons tout.

Duplique l'entrée pour la conserver pendant que nous effectuons des tests de longueur.

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

Maintenant, dans une boucle, nous supprimons le premier caractère de aet le premier caractère deb jusqu'à ce qu'une des chaînes devienne vide.

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

Il y a maintenant des possibilités pour "l'espace modèle".

• ;;abc Les deux chaînes sont de longueur égale
• def;;abc a est plus long que b
• ;def;abc b est plus long que a

Maintenant, nous devons vider l'entrée si les chaînes ne sont pas de la même longueur (scénarios 2 et 3). C'est ce que fait cette substitution ci-dessous. Il supprime le texte correspondant aux scénarios 2 et 3.

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

Cela supprime les caractères qui ne sont pas translittérés dans les chaînes aet b. abc;1b2=>ac;12

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

Après cela, nous devons supprimer les caractères en double. sese;1212=> se;12, mais cela préserve les entrées commeaba;123

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

Enfin, nous supprimons l'entrée s'il y a des caractères en double qui correspondent à différents caractères comme aba;123ou a1;22.

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

Et enfin, supprimez les caractères en double.

Gelée , 28 26 octets

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

Essayez-le en ligne!

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

Rubis, 133 octets

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

Essayez-le en ligne!

Plus lisible:

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

Juste pour les coups de pied, voici une version de 84 octets dans Goruby, qui est Ruby, mais avec un indicateur de golf défini lors de la compilation de l'interpréteur. Entre autres, il vous permet d'abréger les appels de méthode en leur identifiant unique le plus court.

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

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

Essayez-le en ligne!

• -4 octets! merci à mbomb007 pour avoir suggéré l'utilisation de tabulation au lieu d'espace.

• modifié le format d'entrée, encore une fois grâce à mbomb007.

Python 3.6, 211 185 181 178 octets

Quitte avec une erreur pour les résultats de falsification.

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

Cela nécessite Python 3.6, que vous pouvez exécuter dans un shell ici .

Vous pouvez le tester sans le bon ordre de sortie sur TIO ici . (TIO n'a pas 3.6).

Non 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 seulement l'ordre n'avait pas d'importance ...

Roda , 108 119 octets

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

Essayez-le en ligne!

Il s'agit d'une fonction qui prend deux listes de caractères du flux et pousse deux listes vers le flux.

Cela pourrait être plus simple si je pouvais retourner des paires.

Explication (obsolète):

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

Voici une solution de soulignement qui ne contient aucune variable (114 octets):

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

Cela fait beaucoup de soulignements.

AWK, 140 octets

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}

Utilisation: placez le code dans FILE:

awk -f FILE <<< "string1 string2"

Les chaînes d'entrée doivent être séparées par des espaces.

La sortie est vide en cas d'échec, ou 2 chaînes séparées par un espace.

k, 28 octets

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

Explication:

{                          } /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) avec AGL , 22 octets

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

Essayez-le en ligne!

{…}  Fonction anonyme:

 Si…

  ⍺⍵ les arguments

  ⍳⍨¨ lorsqu'ils sont auto-indexés (c'est-à-dire les premières occurrences de leurs éléments en eux-mêmes)

  ≡/ sont équivalents

 : ensuite:

  ⍺(… )⍵ Appliquez la fonction tacite suivante aux arguments:

   ,¨ concaténer les éléments correspondants (erreurs sur les longueurs incompatibles)

   é puis filtrer par ( éest juste la fonction primitive /)

   ≠ où les cordes sont différentes

  ∪ unique (supprimer les doublons)

  ↓⍉↑ transposer la liste de paires en paire de listes (littéralement mélanger dans une table, transposer une table, diviser en listes)

 sinon, ne fais rien

CJam, 38 octets

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

L'entrée et la sortie sont des tableaux sur la pile.

PHP (> = 7.1), 165 octets

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 0pour faux, tableau associatif autrement. Exécutez-le -rou testez-le en ligne .

panne

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