Due parole sono isomorfi se hanno lo stesso modello di ripetizioni di lettere. Ad esempio, entrambi ESTATEe DUELEDhanno un modelloabcdca

ESTATE
DUELED

abcdca

poiché le lettere 1 e 6 sono uguali, le lettere 3 e 5 sono uguali e nient'altro. Questo significa anche che le parole sono correlate da un codice di sostituzione, qui con la corrispondenza E <-> D, S <-> U, T <-> E, A <-> L.

Scrivi un codice che impiega due parole e controlla se sono isomorfi. Vince il minor numero di byte.

Input: due stringhe non vuote di lettere maiuscole A..Z. Se lo desideri, puoi prenderli come una raccolta di due stringhe o come singola stringa con un separatore.

Output: un valore di Verità coerente per le coppie che sono isomorfi e un valore di Falsey coerente se non lo sono. Stringhe di diverse lunghezze sono input validi che non sono mai isomorfi.

Casi test:

Vero:

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

falso:

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

Sentiti libero di aggiungere altri casi di test che ritieni utili.

Classifica

Ecco uno snippet di stack per generare sia una classifica regolare che una panoramica dei vincitori per lingua.

Per assicurarti che la tua risposta venga visualizzata, ti preghiamo di iniziare la risposta con un titolo, usando il seguente modello Markdown:

# Language Name, N bytes

dov'è Nla dimensione del tuo invio. Se si migliora il punteggio, è possibile mantenere i vecchi punteggi nel titolo, colpendoli. Per esempio:

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

-:&=

uso

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

Spiegazione

• = con 1 argomento crea una tabella di uguaglianza confrontando gli elementi dell'input e il suo 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
  

• -:con 2 argomenti controlla la loro uguaglianza (come ==generalmente fa). Funziona anche con matrici di dimensioni diverse (o anche tipi diversi).

• f&gapplica g a entrambi gli input separatamente e quindi applica f ai due risultati insieme così x f&g y == f(g(x), g(y)).

• Quindi nel nostro caso confrontiamo le due tabelle di uguaglianza.

Provalo online qui.

K, 5 byte

Questa ha una soluzione deliziosamente elegante in K!

~/=:'

L'operatore "gruppo" (monadico =) crea precisamente la firma che vogliamo per la parola isomorfismo; raccolta dei vettori degli indici di ciascun elemento di un vettore, con i gruppi ordinati per aspetto:

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

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

Prendendo una coppia di stringhe come vettore, dobbiamo solo applicare il gruppo a ciascun elemento ( =:') e quindi ridurre con "match" ( ~), l'operatore di uguaglianza profonda:

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

Python 2, 41 byte

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

CJam, 9 byte

r_f#r_f#=

Stampa 1se le parole sono isomorfi e 0se non lo sono.

Provalo online nell'interprete CJam .

Come funziona

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 byte

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

La logica è semplice Semplicemente converto entrambi gli input nei corrispondenti valori dell'indice dei caratteri, converto quell'array in stringa e lo confronto.

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

Prova il codice sopra usando lo snippet qui sotto.

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 byte salvati grazie a @ edc65

Bash + coreutils, 38

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

Nota che stiamo usando la solita idea shell di verità / falsità qui - zero significa SUCCESSO o VERO e diverso da zero significa errore o FALSO:

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

MODIFICARE:

è troppo tardi, ma ho riscontrato questo miglioramento usando gli applicativi, che sono stati aggiunti al preludio solo a marzo 2015.

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

Vecchia versione:

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

la funzione di controllo è (%)

funziona generando per ogni stringa il suo "record di uguaglianza": per ogni due indici ij, registra se hanno caratteri uguali. il record viene ordinato in modo che il record per due indici i, j sia sempre nello stesso posto * e quindi il controllo dell'uguaglianza dei record restituirebbe se le stringhe hanno o meno lo stesso modello.

ad esempio, il record di uguaglianza di "ABC" è [1,0,0,0,1,0,0,0,1](1 per vero, 0 per falso) - c'è Truedove viene confrontato qualsiasi indice con se stesso. altrove è un falso. (saltare questi controlli potrebbe essere più efficiente, ma è più difficile in termini di golf)

* _{se le stringhe hanno la stessa lunghezza. altrimenti restituisce false solo perché i record hanno lunghezze diverse}

Haskell, 45 41 byte

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

Restituisce Trueo False, ad es. "ESTATE" ! "DUELED"-> True.

Utilizza il metodo map-char-to-first-index come visto in molte altre risposte. Gli elenchi delle associazioni sono utili, perché le voci precedenti vincono. "aba"diventa [(a,1),(b,2),(a,3)]dove lookuprecupera sempre a-> 1.

Modifica: @Mauris ha trovato 4 byte da salvare.

Brainfuck, 169 168 162 144 140 131 130

Compatibile con bff di Alex Pankratov (interprete brainfuck usato su SPOJ e ideone) e BFI di Thomas Cort (usato su Anarchy Golf).

L'input previsto è di due stringhe separate da una scheda, senza newline dopo la seconda stringa. L'output è 1per gli isomorfi e 0per i non isomorfi, il che è conveniente per controllare visivamente i risultati, sebbene non sia l'opzione più breve. ( Aggiornamento: versione più breve con \x01e \x00come output e \x00come separatore nella parte inferiore della risposta.)

Dimostrazione su ideone.

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

Questo problema si rivela molto utile per il cervello.

L'idea di base con l'indicizzazione è di tornare indietro dalla fine del prefisso di stringa corrente. Se il carattere non si è mai verificato in precedenza, possiamo prendere la lunghezza del prefisso della stringa. Per esempio:

STATES
123255

L'indicizzazione nel codice è in realtà leggermente diversa ma utilizza lo stesso principio.

Il layout della memoria è in blocchi di 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

csta per carattere, iindice e pprecedente (indice). Quando viene elaborata la prima stringa, tutti gli pslot sono zero. La cella a sinistra di cviene utilizzata per contenere una copia del carattere corrente di cui stiamo cercando di trovare l'indice. La cella a sinistra della corrente iviene utilizzata per contenere a -1per una facile navigazione del puntatore.

Ci sono molte condizioni che devono essere considerate attentamente. Alla fine, controlliamo gli isomorfi confrontando le (i,p)coppie e raggiungiamo il cluster di zero celle a sinistra della (i,p)coppia più a sinistra se e solo se le stringhe sono isomorfi. Ecco una versione commentata del codice per facilitarne il seguito:

,+
[                       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
+++++++[<+++++++>-]
<.

Aggiornare:

Ecco una versione che stampa \x01per isomorfi e \x00per non isomorfi. Questa è probabilmente un'interpretazione più accurata di Truthy e Falsey per Brainfuck, a causa del modo [e del ]lavoro. L'unica differenza è alla fine.

Ulteriore: ora usando \x00come separatore per salvare 10 byte.

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

JavaScript (ES6), 62

Utilizzando una funzione aux hche associa ciascuna parola a un array contenente la posizione di ciascuna lettera nella parola, ad esempio: PASS -> [1,2,3,3]. Restituisce vero se la funzioneh applicata alle due parole dà lo stesso risultato.

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-giocato a 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))

Rubino, 83 byte

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

È una funzione fche accetta due argomenti e restituisce trueo false.

Spiegazione:

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

Mappa ogni personaggio di set alla sua posizione e verifica l'uguaglianza.

Allargato:

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 byte

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 byte

qFmmxdkdQ

Accetta input nel seguente formato:

"ESTATE", "DUELED"

Se ciò non è accettabile, il codice seguente è 10 byte:

qFmmxdkd.z

e utilizza questo modulo di input:

ESTATE
DUELED

Utilizza l'indice di char nella rappresentazione di stringa.

Matlab, 50 byte

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

La funzione è definita come anonima per risparmiare spazio.

Esempio:

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

Ottava, 26 byte

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

05AB1E , 6 byte

εæδË}Ë

Provalo online!

Accetta input come elenco: ['ESTATE', 'DUELED']

spiegazioni:

    εæδË}Ë   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 byte

-1 grazie al suggerimento di ngn.

Funzione di prefisso tacito anonimo che accetta come argomento un elenco di due stringhe.

≡.⍳⍨

Provalo online!

Questo è un prodotto interiore, ma al posto del solito +e ×lo utilizza

≡ identità

. e

⍳ il ɩ ndex (la prima occorrenza di ciascun elemento)

⍨ con l'intero elenco di parole a due elementi usato come entrambi gli argomenti

Se chiamiamo le parole Ae B, allora possiamo derivare la soluzione precedente come segue:

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

Soluzione precedente

Funzione di prefisso tacito anonimo che accetta come argomento un elenco di due stringhe.

≡/⍳⍨¨

Provalo online!

≡ identità

/ attraverso

⍳ il de ndex (la prima occorrenza di ciascun elemento ...)

⍨ selfie (... in sé)

¨ di ciascuna

Mathematica, 46 byte

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

Rubino, 50 byte

Codice rubino più breve di 30 byte. Scritto prima di dare un'occhiata alle soluzioni, controlla per ogni carattere di entrambe le stringhe se l'indice della prima occorrenza di quel personaggio corrisponde; vale a dire. trasforma una stringa nella sua forma normalizzata01121 ecc. e confronta quelle.

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

Casi di prova su ideone Come bonus aggiuntivo, questo rompe l'evidenziazione del codice di ideone.

Buccia , 5 byte

¤=´×=

Provalo online!

Spiegazione

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

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

Il soggetto dovrebbe essere due parole separate da spazio, come nel PO. Ecco una breve spiegazione:

Per ogni lettera X nella prima parola:

Guardare avanti alla seconda parola e stabilire riferimenti indietro per ricordare quanto siamo lontani così come la lettera Y nella seconda parola corrispondente a X.

Per ogni lettera Z oltre la posizione corrente nella prima parola:

Stabilire riferimenti posteriori simili come sopra.

Guarda avanti nella lettera corrispondente nella seconda parola e controlla se Z = X corrisponde a una Y, altrimenti trova una lettera che non è Y.

Questa iterazione può terminare una volta abbinata fino alla penultima lettera della prima parola. A questo punto, poiché non è necessaria alcuna ulteriore convalida, non resta che verificare che le parole abbiano la stessa lunghezza (il riferimento posteriore contenente sottostringhe accumulate della seconda parola è sempre dietro di 1 lettera).

Rubino, 31 byte

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

Un Proc che accetta una serie di stringhe e controlla se ce ne sono isomorfi. tr s,'a-z'con questi argomenti normalizza una stringa ssostituendo ogni lettera con l'ennesima lettera dell'alfabeto, dove nè il più grande indice con cui quella lettera appare nella stringa. Ad esempio, estatediventa fbedef, così come dueled.

Cobra, 72 byte

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

JavaScript (ES5), 142 98

Abbastanza grande, ma non ho ancora visto una versione 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)

Sostituisce semplicemente ogni ricorrenza della prima lettera con il suo valore di indice inverso. Lo ripete per ogni personaggio.

Fa lo stesso per entrambi gli input e confronta il modello generato.

Il confronto è abbastanza brutto, ma non voglio usare un array per archiviarlo e confrontarlo.

Perl, 38 byte

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

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

Stampa 1 se vero, niente se falso.

Lisp comune, 76 byte

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

Provalo online!

C ++, 213 196 162 byte

-51 byte grazie a 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;};

Per chiamare lambda, è necessario passare 2 argomenti che sono di std::stringtipo dati

Codice da testare:

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

per il codice che viene testato, inclusi iostreame stringfile di intestazione

JavaScript (ES6), 52 51 50 byte

Questa versione non utilizza la comprensione dell'array e accetta input utilizzando la sintassi del curry.

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