Deux mots sont isomorphes s'ils ont le même motif de répétition de lettre. Par exemple, les deux ESTATEet DUELEDont un motifabcdca

ESTATE
DUELED

abcdca

parce que les lettres 1 et 6 sont identiques, les lettres 3 et 5 sont identiques et rien d’autre. Cela signifie également que les mots sont liés par un chiffre de substitution, ici avec la correspondance E <-> D, S <-> U, T <-> E, A <-> L.

Écrivez un code qui prend deux mots et vérifie s’ils sont isomorphes. Le moins d'octets gagne.

Entrée: deux chaînes de lettres majuscules non vides A..Z. Si vous le souhaitez, vous pouvez les prendre comme une collection de deux chaînes ou comme une seule chaîne avec un séparateur.

Sortie: une valeur de vérité cohérente pour les paires qui sont des isomorphes et une valeur de Falsey cohérente si elles ne le sont pas. Les chaînes de différentes longueurs sont des entrées valides qui ne sont jamais isomorphes.

Cas de test:

Vrai:

ESTATE DUELED
DUELED ESTATE
XXX YYY
CBAABC DEFFED
RAMBUNCTIOUSLY THERMODYNAMICS
DISCRIMINATIVE SIMPLIFICATION

Faux:

SEE SAW
ANTS PANTS
BANANA SERENE
BANANA SENSES
AB CC
XXY XYY
ABCBACCBA ABCBACCAB
ABAB CD

N'hésitez pas à ajouter d'autres cas de test que vous jugez utiles.

Classement

Voici un extrait de pile permettant de générer à la fois un classement régulier et un aperçu des gagnants par langue.

Pour vous assurer que votre réponse apparaît, commencez votre réponse par un titre, en utilisant le modèle Markdown suivant:

# Language Name, N bytes

où Nest la taille de votre soumission. Si vous améliorez votre score, vous pouvez conserver les anciens scores en les effaçant. Par exemple:

# Ruby, <s>104</s> <s>101</s> 96 bytes

var QUESTION_ID=50472;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),e.has_more?getAnswers():process()}})}function shouldHaveHeading(e){var a=!1,r=e.body_markdown.split("\n");try{a|=/^#/.test(e.body_markdown),a|=["-","="].indexOf(r[1][0])>-1,a&=LANGUAGE_REG.test(e.body_markdown)}catch(n){}return a}function shouldHaveScore(e){var a=!1;try{a|=SIZE_REG.test(e.body_markdown.split("\n")[0])}catch(r){}return a}function getAuthorName(e){return e.owner.display_name}function process(){answers=answers.filter(shouldHaveScore).filter(shouldHaveHeading),answers.sort(function(e,a){var r=+(e.body_markdown.split("\n")[0].match(SIZE_REG)||[1/0])[0],n=+(a.body_markdown.split("\n")[0].match(SIZE_REG)||[1/0])[0];return r-n});var e={},a=1,r=null,n=1;answers.forEach(function(s){var t=s.body_markdown.split("\n")[0],o=jQuery("#answer-template").html(),l=(t.match(NUMBER_REG)[0],(t.match(SIZE_REG)||[0])[0]),c=t.match(LANGUAGE_REG)[1],i=getAuthorName(s);l!=r&&(n=a),r=l,++a,o=o.replace("{{PLACE}}",n+".").replace("{{NAME}}",i).replace("{{LANGUAGE}}",c).replace("{{SIZE}}",l).replace("{{LINK}}",s.share_link),o=jQuery(o),jQuery("#answers").append(o),e[c]=e[c]||{lang:c,user:i,size:l,link:s.share_link}});var s=[];for(var t in e)e.hasOwnProperty(t)&&s.push(e[t]);s.sort(function(e,a){return e.lang>a.lang?1:e.lang<a.lang?-1:0});for(var o=0;o<s.length;++o){var l=jQuery("#language-template").html(),t=s[o];l=l.replace("{{LANGUAGE}}",t.lang).replace("{{NAME}}",t.user).replace("{{SIZE}}",t.size).replace("{{LINK}}",t.link),l=jQuery(l),jQuery("#languages").append(l)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",answers=[],page=1;getAnswers();var SIZE_REG=/\d+(?=[^\d&]*(?:&lt;(?:s&gt;[^&]*&lt;\/s&gt;|[^&]+&gt;)[^\d&]*)*$)/,NUMBER_REG=/\d+/,LANGUAGE_REG=/^#*\s*([^,]+)/;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script><link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"><div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table></div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table></div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody></table><table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody></table>

J, 4 octets

-:&=

Usage

   'THERMODYNAMICS' (-:&=) 'RAMBUNCTIOUSLY'  NB. parens are optional
1 

Explication

• = avec 1 argument crée un tableau d'égalité comparant les éléments de l'entrée et son nub.

  ='ESTATE' gives the binary matrix
  
  = | E S T A T E    
  --+------------
  E | 1 0 0 0 0 1
  S | 0 1 0 0 0 0
  T | 0 0 1 0 1 0
  A | 0 0 0 1 0 0
  

• -:avec 2 arguments vérifie leur égalité (comme le fait ==généralement). Cela fonctionne aussi pour les matrices de tailles différentes (ou même de types différents).

• f&gapplique g aux deux entrées séparément puis applique f aux deux résultats ensemble ainsi x f&g y == f(g(x), g(y)).

• Donc, dans notre cas, nous comparons les deux tables d’égalité.

Essayez-le en ligne ici.

K, 5 octets

Cela a une solution délicieusement élégante dans K!

~/=:'

L'opérateur "group" (monadique =) crée précisément la signature que nous voulons pour l'isomorphisme des mots; regroupement des vecteurs des indices de chaque élément d'un vecteur, avec les groupes ordonnés par apparence:

  ="ABBAC"
(0 3
 1 2
 ,4)

  ="DCCDF"
(0 3
 1 2
 ,4)

En prenant une paire de chaînes comme vecteur, il suffit d’appliquer un groupe à chaque élément ( =:') puis de réduire avec "match" ( ~), l’opérateur d’égalité profonde:

  ~/=:'("RAMBUNCTIOUSLY";"THERMODYNAMICS")
1
  ~/=:'("BANANA";"SERENE")
0

Python 2, 41 octets

f=lambda a,b:map(a.find,a)==map(b.find,b)

CJam, 9 octets

r_f#r_f#=

Imprime 1si les mots sont isomorphes et 0s'ils ne le sont pas.

Essayez-le en ligne dans l' interprète CJam .

Comment ça fonctionne

r    e# Read a whitespace separated token from STDIN.
_    e# Push a copy.
f#   e# Get the indexes of all characters from the first copy in the second.
r_f# e# Repeat for the second word.
=    e# Check for equality.

JavaScript, ES7, 62 55 54 52 51 octets

f=(x,y,g=z=>[for(i of z)z.search(i)]+0)=>g(x)==g(y)

La logique est simple. Je convertis simplement les deux entrées en leurs valeurs d'index de caractères correspondantes, convertis ce tableau en chaîne et comparons.

f=(x, y,                  // Create a function named f which takes two arguments x and y
   g=                     // There is a third default argument to f which equals to
     z=>                  // and arrow function which takes argument z
     [                    // Return this array which is created using array comprehension
      for(i of z)         // For each character of z
      z.search(i)         // Use the index of that character in z in place of the character
     ]+0                  // And finally type cast that array to a string
                          // Here, the array elements are automatically joined by a ','
                          // and appended by a 0.
                          // Its funny how JS type casts Array + Number to a string
   )=>                    // Now the body of function f starts
      g(x)==g(y)          // It simply returns if index map of x equals index map of y

Essayez le code ci-dessus en utilisant l'extrait ci-dessous.

f=(x,y,g=z=>[for(i of z)z.search(i)]+0)=>g(x)==g(y)

// for cross browser testing, here is a slightly modified ES5 version of above function

if (!f) {
  function f(x, y) {
    function g(z) {
      var Z = [];
      for (var i = 0; i < z.length; i++) {
        Z[i] = z.search(z[i])
      }
      return Z + 0;
    }
    return g(x) == g(y);
  }
}

B.onclick=function() {
  O.innerHTML = f(D.value, E.value);
  
};

<pre>f(<input id=D />,<input id=E />)</pre><button id=B >Run</button>
<br>
<output id=O />

2 octets enregistrés grâce à @ edc65

Bash + coreutils, 38

[ `tr $@<<<$1``tr $2 $1<<<$2` = $2$1 ]

Notez que nous utilisons ici l’idée habituelle de vérité / fausseté: zéro signifie SUCCÈS ou VRAI et non nul signifie erreur ou FAUX:

$ for t in "ESTATE DUELED" "DUELED ESTATE" "XXX YYY" "CBAABC DEFFED" "RAMBUNCTIOUSLY THERMODYNAMICS" "DISCRIMINATIVE SIMPLIFICATION" "SEE SAW" "ANTS PANTS" "BANANA SERENE" "BANANA SENSES" "AB CC" "XXY XYY" "ABCBACCBA ABCBACCAB"; do
> ./isomorph.sh $t
> echo $t $?
> done
ESTATE DUELED 0
DUELED ESTATE 0
XXX YYY 0
CBAABC DEFFED 0
RAMBUNCTIOUSLY THERMODYNAMICS 0
DISCRIMINATIVE SIMPLIFICATION 0
SEE SAW 1
ANTS PANTS 1
BANANA SERENE 1
BANANA SENSES 1
AB CC 1
XXY XYY 1
ABCBACCBA ABCBACCAB 1
$ 

Haskell, 33 ans 29

MODIFIER:

c'est beaucoup trop tard, mais j'ai trouvé cette amélioration en utilisant des applications, qui n'ont été ajoutées à prélude qu'en mars 2015.

s%k=g s==g k
g s=(==)<$>s<*>s

Ancienne version:

s%k=g s==g k
g s=[a==b|a<-s,b<-s]

la fonction de vérification est (%)

cela fonctionne en générant pour chaque chaîne son "enregistrement d'égalité": pour chaque deux index ij, il enregistre s'ils ont des caractères égaux. l'enregistrement est ordonné de sorte que l'enregistrement de deux index i, j soit toujours au même endroit * et que, par conséquent, le fait de vérifier l'égalité des enregistrements renverrait si les chaînes ont le même motif.

Par exemple, l'enregistrement d'égalité de "ABC" est [1,0,0,0,1,0,0,0,1](1 pour vrai, 0 pour faux) - il existe un Trueendroit où tout index est comparé à lui-même. n'importe où ailleurs est un faux. (sauter ces vérifications pourrait être plus efficace, mais est plus difficile en termes de golf)

* _{si les cordes ont la même longueur. sinon, il retourne false simplement parce que les enregistrements ont des longueurs différentes}

Haskell, 45 41 octets

h l=map(`lookup`zip l[1..])l
x!y=h x==h y

Retourne Trueou False, par exemple "ESTATE" ! "DUELED"-> True.

Utilise la méthode map-char-to-first-index, comme le montrent de nombreuses autres réponses. Les listes d'associations sont pratiques, car les entrées précédentes ont l'avantage. "aba"devient [(a,1),(b,2),(a,3)]où lookupva toujours chercher a-> 1.

Edit: @Mauris a trouvé 4 octets à sauvegarder.

Brainfuck, 169 168 162 144 140 131 130

Compatible avec le bff d' Alex Pankratov (interprète brainfuck utilisé sur SPOJ et idéone) et le BFI de Thomas Cort (utilisé sur Anarchy Golf).

L'entrée attendue est deux chaînes séparées par un onglet, sans nouvelle ligne après la deuxième chaîne. La sortie 1concerne les isomorphes et les 0non-isomorphes, ce qui est pratique pour vérifier les résultats visuellement, bien que ce ne soit pas l'option la plus courte. ( Mise à jour: version plus courte avec \x01et \x00comme sortie et \x00comme séparateur au bas de la réponse.)

Démonstration sur ideone.

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

Ce problème s'avère être très gentil pour un brainfuck.

L'idée de base de l'indexation est de revenir en arrière à partir de la fin du préfixe de chaîne actuel. Si le caractère ne s'est pas déjà produit, nous pouvons prendre la longueur du préfixe de chaîne. Par exemple:

STATES
123255

L'indexation dans le code est en fait légèrement différente mais utilise le même principe.

La disposition de la mémoire est en blocs de 5:

0 0 0 0 0 0 c 0 i p 0 c 0 i p 0 c 0 i p 0 0 0 0

creprésente le caractère, iindex et pprécédent (index). Lorsque la première chaîne est en cours de traitement, tous les pemplacements sont nuls. La cellule située à gauche de ccontient une copie du caractère actuel dont nous essayons de trouver l'index. La cellule située à gauche du courant isert à contenir un -1pointeur pour faciliter la navigation.

Il y a beaucoup de conditions qui doivent être considérées avec soin. À la fin, nous vérifions les isomorphes en comparant les (i,p)paires et nous atteignons le groupe de cellules zéro situé à gauche de la (i,p)paire la plus à gauche si et seulement si les chaînes sont des isomorphes. Voici une version commentée du code pour le rendre plus facile à suivre:

,+
[                       while there is input
  -
  ---------
  >+<                   increment char (adjust later)
  [                     if not tab
    >>-<                set navigation flag
    [                   loop to find index
      <                 travel to copy
      [
        >+<             restore char
        <<<<-<+>>>>>-   compare chars and create copy
      ]
      ++[->+]           travel between navigation flags
      ->+[+<-]          increment index by 2 and go back
      >[<<<<]           proceed if not fallen off string
      <                 compare chars
    ]
    <[>+<-]             restore char (or no op)
    +[->+]              go back to navigation flag
    <->                 adjust char
    >>>                 alignment
  ]
  >
  [                     if tab
    [[-]<<<<<]          erase chars and go to beginning
    >>>>                alignment
  ]
  <,+
]
>>>+>+                  check string lengths and start loop
[
  [<->-]                compare indices
  <[>>>>>]              realign if not equal
  <<<<                  proceed
]
-<[>]                   cell to left is zero iff isomorphs
+++++++[<+++++++>-]
<.

Mise à jour:

Voici une version qui s’imprime \x01pour les isomorphes et \x00pour les non-isomorphes. C'est sans doute une interprétation plus précise de Truthy et Falsey pour un brainfuck, à cause du chemin [et du ]travail. La seule différence est à la toute fin.

Supplémentaire: utilisez maintenant \x00comme séparateur pour économiser 10 octets.

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

JavaScript (ES6), 62

Utilisation d'une fonction aux hqui mappe chaque mot à un tableau contenant la position de chaque lettre du mot, par exemple: PASS -> [1,2,3,3]. Renvoie true si la fonction happliquée aux deux mots donne le même résultat.

f=(a,b,h=w=>0+[for(c of(n=k=[],w))k[c]=k[c]||++n])=>h(b)==h(a)

// TEST

;[
// True
 ['ESTATE','DUELED']
,['DUELED','ESTATE']
,['XXX','YYY']
,['CBAABC','DEFFED']
,['RAMBUNCTIOUSLY','THERMODYNAMICS']
,['DISCRIMINATIVE','SIMPLIFICATION']

// False:

,['SEE','SAW']
,['ANTS','PANTS']
,['BANANA','SERENE']
,['BANANA','SENSES']
,['XXY','XYY']
,['ABCBACCBA','ABCBACCAB']
]
.forEach(t=>(f(t[0],t[1])?OK:KO).innerHTML+=t+'\n')

Ok<br>
<pre id=OK></pre><br>
KO<br>
<pre id=KO></pre>

R, 78

function(x,y)identical((g=function(z)match(a<-strsplit(z,"")[[1]],a))(x),g(y))

De-golfé:

word_to_num <- function(word) {
   chars <- strsplit(word,"")[[1]]
   match(chars, chars)
}
are_isomorph <- function(word1, word2) identical(word_to_num(word1), 
                                                 word_to_num(word2))

Ruby, 83 octets

t=->x{y=0;z=?`;x.gsub!(y[0],z.succ!)while y=x.match(/[A-Z]/);x};f=->a,b{t[a]==t[b]}

C'est une fonction fqui prend deux arguments et retourne trueou false.

Explication:

test = -> str {
    y = nil  # we're just initializing this; it doesn't matter to what
             # this is the variable we use to store the `match' result
    z = '`'  # backtick is the ASCII character before `a'
    while y = str.match(/[A-Z]/) do  # while there is an uppercase letter in str
        str.gsub!(y[0], z.succ!)  # replace all instances of the uppercase letter
                                  # with the next unused lowercase letter
    end
    str  # return the new string
}
# self-explanatory
f=->a,b{test[a]==test[b]}

Java, 107

(s,t)->java.util.Arrays.equals(s.chars().map(s::indexOf).toArray(),t.chars().map(t::indexOf).toArray())

Mappe chaque caractère de set tà son emplacement, et vérifie l'égalité.

Étendu:

class Isomorphs {
    public static void main(String[] args) {
        java.util.function.BiFunction<String, String, Boolean> f =
            (s, t) -> java.util.Arrays.equals(
                                              s.chars().map(s::indexOf).toArray(),
                                              t.chars().map(t::indexOf).toArray()
                                             )
           ;
        System.out.println(f.apply("XXY", "XYY"));
    }
}

Python 3, 85 octets

f=lambda a,b:''.join(map(lambda g:dict(zip(a,b))[g],a))==b
g=lambda a,b:f(a,b)&f(b,a)

Pyth, 9 octets

qFmmxdkdQ

Prend les entrées sous la forme suivante:

"ESTATE", "DUELED"

Si ce n'est pas acceptable, le code suivant est 10 octets:

qFmmxdkd.z

et utilise ce formulaire de saisie:

ESTATE
DUELED

Utilise l'index de char dans la représentation sous forme de chaîne.

Matlab, 50 octets

f=@(s,t)isequal(bsxfun(@eq,s,s'),bsxfun(@eq,t,t'))

La fonction est définie comme anonyme pour économiser de l'espace.

Exemple:

>> f=@(s,t)isequal(bsxfun(@eq,s,s'),bsxfun(@eq,t,t'));
>> f('ESTATE','DUELED')
ans =
     1
>> f('ANTS','PANTS')
ans =
     0

Octave, 26 octets

@(s,t)isequal(s==s',t==t')

05AB1E , 6 octets

εæδË}Ë

Essayez-le en ligne!

Prend les entrées sous forme de liste: ['ESTATE', 'DUELED']

Explications:

    εæδË}Ë   Full program
    ε        Apply on each
     æ         Powerset
      δË       For each generated substring: 1 if all equal, 0 otherwise
        }    End for each
         Ë   1 if all equal, 0 otherwise

APL (Dyalog) , 5 à 4 octets

-1 grâce à l'allusion de ngn.

Fonction de préfixe tacite anonyme qui prend comme argument une liste de deux chaînes.

≡.⍳⍨

Essayez-le en ligne!

Ceci est un produit interne, mais au lieu de l'habituel +et ×il utilise

≡ identité

. et

⍳ le ɩ ndex (la première occurrence de chaque élément)

⍨ avec la liste complète de mots à deux éléments utilisés comme deux arguments

Si nous appelons les mots Aet B, alors nous pouvons déduire la solution précédente comme suit:

≡.⍳⍨ A B
A B ≡.⍳ A B
(A⍳A) ≡ (B⍳B)
(⍳⍨A) ≡ (⍳⍨B)
≡/ ⍳⍨¨ A B

Solution précédente

Fonction de préfixe tacite anonyme qui prend comme argument une liste de deux chaînes.

≡/⍳⍨¨

Essayez-le en ligne!

≡ identité

/ à travers

⍳ le ɩ ndex (la première occurrence de chaque élément…)

⍨ selfie (… en soi)

¨ de chaque

Mathematica, 46 octets

Equal@@Values@*PositionIndex/@Characters@{##}&

Ruby, 50 octets

Code ruby ​​plus court de 30 octets. Ecrit avant de jeter un coup d'œil aux solutions, vérifie pour chaque caractère des deux chaînes si l'index de la première occurrence de ce caractère correspond; c'est à dire. transforme une chaîne en sa forme normalisée, 01121etc. et les compare.

->x,y{g=->z{z.chars.map{|c|z=~/#{c}/}};g[x]==g[y]}

Cas de test sur ideone En tant que bonus supplémentaire, cela interrompt la mise en surbrillance du code de l'idéone.

Husk , 5 octets

¤=´×=

Essayez-le en ligne!

Explication

       -- implicit input A, B (strings aka character lists)       | "ab" "12"
¤=     -- apply the following function to A & B, then compare:    | [1,0,0,1] == [1,0,0,1] -> 1
  ´×   --   Cartesian product with itself under                   | ["aa","ba","ab","bb"] ["11","21","12","22"]
    =  --   equality                                              | [ 1  , 0  , 0  , 1  ] [ 1  , 0  , 0  , 1  ]

PCRE, 84 octets

^((.)(?=.+ (\3.|)(.))(?=((?=(\2|)?+.* \3\4(\7?(?(?=.*+\6)(?!\4).|\4))).)+ ))+. \3..$ 

Le sujet doit être composé de deux mots séparés par des espaces, comme dans le PO. Voici une explication superficielle:

Pour chaque lettre X dans le premier mot:

Examinez le deuxième mot et établissez des références en arrière pour rappeler à quel point nous en sommes ainsi que la lettre Y dans le deuxième mot correspondant à X.

Pour chaque lettre Z passée la position actuelle dans le premier mot:

Établissez des références arrière similaires à celles mentionnées ci-dessus.

Recherchez la lettre correspondante dans le deuxième mot et vérifiez si Z = X correspond à Y, sinon correspond à une lettre qui n'est pas Y.

Cette itération peut se terminer une fois que nous avons mis en correspondance jusqu'à l'avant-dernière lettre du premier mot. À ce stade, puisqu’aucune validation supplémentaire n’est nécessaire, il ne reste plus qu’à vérifier que les mots sont de longueur égale (la référence arrière contenant les sous-chaînes accumulées du deuxième mot est toujours en retard d’une lettre).

Ruby, 31 octets

->a{!!a.uniq!{|s|s.tr s,'a-z'}}

Un Proc qui prend un tableau de chaînes et vérifie si certaines sont isomorphes les unes par rapport aux autres. tr s,'a-z'avec ces arguments, normalise une chaîne sen remplaçant chaque lettre par la nième lettre de l'alphabet, où nest le plus grand indice avec lequel cette lettre apparaît dans la chaîne. Par exemple, estatedevient fbedef, comme le fait dueled.

Cobra, 72 octets

do(a='',b='')=(for i in a get a.indexOf(i))==for i in b get b.indexOf(i)

JavaScript (ES5), 142 98

C'est assez gros, mais je n'ai pas encore vu de version ES5.

for(l=j=2;j--;){c=prompt();for(i=c.length;i--;)c=c.replace(RegExp(c[i],"g"),i);b=l==c;l=c}alert(b)

Remplace simplement chaque occurrence de la première lettre par sa valeur d'index inverse. Répète ceci pour chaque personnage.

Il fait la même chose pour les deux entrées et compare le motif généré.

La comparaison est assez moche, mais je ne voudrais pas utiliser un tableau pour le stocker et le comparer.

Perl, 38 octets

($_,$a)=@ARGV;eval"y/$_/$a/";say$_~~$a

Courir comme perl -E '($_,$a)=@ARGV;eval"y/$_/$a/";say$_~~$a' RAMBUNCTIOUSLY THERMODYNAMICS

Imprime 1 si vrai, rien si faux.

Common Lisp, 76 octets

(lambda(a b)(equal #1=(map'list(lambda(x)(position x a))a)(setf a b a #1#)))

Essayez-le en ligne!

C ++, 213 196 162 octets

-51 octets grâce à Zacharý

#include<map>
#define F(X,x)for(auto&e:X){if(x.end()==x.find(e))x[e]=65+x.size();e=x[e];}
auto i=[](auto a,auto b){std::map<int,int>c,d;F(a,c)F(b,d)return a==b;};

Pour appeler le lambda, vous devez passer 2 arguments de std::stringtype données.

Code à tester:

std::initializer_list<std::pair<std::string, std::string>> test{
    {"ESTATE","DUELED"},
    {"DUELED","ESTATE"},
    {"XXX","YYY"},
    {"CBAABC","DEFFED"},
    {"RAMBUNCTIOUSLY","THERMODYNAMICS"},
    {"DISCRIMINATIVE","SIMPLIFICATION"},
    {"SEE","SAW"},
    {"ANTS","PANTS"},
    {"BANANA","SERENE"},
    {"BANAnA","SENSES"},
    {"AB","CC"},
    {"XXY","XYY"},
    {"ABCBACCBA","ABCBACCAB"},
    {"ABAB","AC"}
};

for (const auto& a : test) {
    std::cout << "Test with " << a.first << " and " << a.second <<
        " outputs : " << (i(a.first, a.second)?"TRUE":"FALSE") << '\n';
}

pour le code qui teste, y compris iostreamet le stringfichier d'en-tête est requis

JavaScript (ES6), 52 51 50 octets

Cette version n'utilise pas la compréhension des tableaux et accepte les entrées en utilisant la syntaxe de currying.

a=>b=>(f=x=>0+[...x].map(c=>x.search(c)))(a)==f(b)

const isomorph = a=>b=>(f=x=>0+[...x].map(c=>x.search(c)))(a)==f(b);
const tests = [
  {input: ["ESTATE", "DUELED"], expected: true},
  {input: ["DUELED", "ESTATE"], expected: true},
  {input: ["XXX", "YYY"], expected: true},
  {input: ["CBAABC", "DEFFED"], expected: true},
  {input: ["RAMBUNCTIOUSLY", "THERMODYNAMICS"], expected: true},
  {input: ["DISCRIMINATIVE", "SIMPLIFICATION"], expected: true},
  {input: ["SEE", "SAW"], expected: false},
  {input: ["ANTS", "PANTS"], expected: false},
  {input: ["BANANA", "SERENE"], expected: false},
  {input: ["BANANA", "SENSES"], expected: false},
  {input: ["AB", "CC"], expected: false},
  {input: ["XXY", "XYY"], expected: false},
  {input: ["ABCBACCBA", "ABCBACCAB"], expected: false},
  {input: ["ABAB", "CD"], expected: false}
];

for(const { input: [str1, str2], expected } of tests) {
  console.log(`isomorph("${str1}")("${str2}") = ${isomorph(str1)(str2)}, expected = ${expected}`);
}