Duas palavras são isomorfos se tiverem o mesmo padrão de repetições de letras. Por exemplo, ambos ESTATEe DUELEDtêm padrãoabcdca

ESTATE
DUELED

abcdca

porque as letras 1 e 6 são iguais, as letras 3 e 5 são iguais e nada mais. Isso também significa que as palavras são relacionadas por uma cifra de substituição, aqui com a correspondência E <-> D, S <-> U, T <-> E, A <-> L.

Escreva um código que use duas palavras e verifique se são isomorfos. Menos bytes ganha.

Entrada: duas cadeias não vazias de letras maiúsculas A..Z. Se desejar, você pode levá-las como uma coleção de duas cadeias ou como uma única cadeia com um separador.

Saída: Um valor Truthy consistente para pares que são isomorfos e um valor Falsey consistente, se não forem. Strings de diferentes comprimentos são entradas válidas que nunca são isomorfas.

Casos de teste:

Verdadeiro:

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

Sinta-se à vontade para adicionar mais casos de teste que achar úteis.

Entre os melhores

Aqui está um snippet de pilha para gerar uma classificação regular e uma visão geral dos vencedores por idioma.

Para garantir que sua resposta seja exibida, inicie-a com um título, usando o seguinte modelo de remarcação:

# Language Name, N bytes

onde Nestá o tamanho do seu envio. Se você melhorar sua pontuação, poderá manter as pontuações antigas no título, identificando-as. Por exemplo:

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

-:&=

Uso

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

Explicação

• = com 1 argumento cria uma tabela de igualdade comparando os elementos da entrada e seu 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
  

• -:com 2 argumentos verifica sua igualdade (como ==geralmente faz). Isso funciona para matrizes de tamanhos diferentes (ou mesmo tipos diferentes) também.

• f&gaplica g às duas entradas separadamente e, em seguida, aplica f aos dois resultados juntos x f&g y == f(g(x), g(y)).

• Portanto, no nosso caso, comparamos as duas tabelas de igualdade.

Experimente online aqui.

K, 5 bytes

Isso tem uma solução deliciosamente elegante no K!

~/=:'

O operador "group" (monádico =) cria precisamente a assinatura que queremos para o isomorfismo da palavra; reunindo vetores dos índices de cada elemento de um vetor, com os grupos ordenados por aparência:

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

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

Tomando um par de strings como vetor, precisamos aplicar o grupo a cada elemento ( =:') e reduzir com "match" ( ~), o operador de igualdade profunda:

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

Python 2, 41 bytes

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

CJam, 9 bytes

r_f#r_f#=

Imprime 1se as palavras são isomorfas e 0se não são.

Experimente online no intérprete CJam .

Como funciona

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 bytes

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

A lógica é simples. Simplesmente converto ambas as entradas em seus valores de índice de caracteres correspondentes, converto essa matriz em string e comparo.

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

Experimente o código acima usando o snippet abaixo.

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 bytes salvos graças a @ edc65

Bash + coreutils, 38

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

Observe que estamos usando a ideia usual de shell de verdade / falsidade aqui - zero significa SUCESSO ou VERDADEIRO e diferente de zero significa erro ou 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

EDITAR:

é tarde demais, mas eu encontrei essa melhoria usando aplicativos, que foram adicionados ao prelúdio apenas em março de 2015.

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

Versão antiga:

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

a função de verificação é (%)

isso funciona gerando para cada string seu "registro de igualdade": para cada dois índices ij, ele registra se eles têm caracteres iguais. o registro é ordenado para que o registro para dois índices i, j esteja sempre no mesmo local * e, portanto, a verificação da igualdade dos registros retornaria se as seqüências tinham ou não o mesmo padrão.

por exemplo, o registro de igualdade de "ABC" é [1,0,0,0,1,0,0,0,1](1 para verdadeiro, 0 para falso) - é aí Trueque qualquer índice é comparado a si mesmo. em qualquer outro lugar é falso. (pular essas verificações pode ser mais eficiente, mas é mais difícil em termos de golfe)

* _{se as cordas tiverem o mesmo comprimento. caso contrário, ele retornará false apenas porque os registros são de comprimentos diferentes}

Haskell, 45 41 bytes

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

Retorna Trueou False, por exemplo, "ESTATE" ! "DUELED"-> True.

Usa o método map-char-to-first-index, como visto em muitas outras respostas. As listas de associação são úteis, porque as entradas anteriores superam. "aba"torna-se [(a,1),(b,2),(a,3)]onde lookupsempre busca a-> 1.

Edit: @Mauris encontrou 4 bytes para salvar.

Brainfuck, 169 168 162 144 140 131 130

Compatível com Alex Pankratov bff (intérprete brainfuck usado em SPOJ e ideone) e de Thomas Cort BFI (usado em Anarchy Golf).

A entrada esperada são duas cadeias separadas por uma guia, sem nova linha após a segunda cadeia. A saída é 1para isomorfos e 0não isomorfos, o que é conveniente para verificar os resultados visualmente, embora não seja a opção mais curta. ( Atualização: versão mais curta com \x01e \x00como saída e \x00como separador na parte inferior da resposta.)

Demonstração em ideone.

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

Esse problema acaba sendo muito bom para o cérebro.

A idéia básica com a indexação é voltar ao final do prefixo de cadeia atual. Se o caractere não ocorreu anteriormente, podemos obter o comprimento do prefixo da string. Por exemplo:

STATES
123255

A indexação no código é realmente um pouco diferente, mas usa o mesmo princípio.

O layout da memória está em blocos 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

csignifica caractere, iíndice e panterior (índice). Quando a primeira cadeia está sendo processada, todos os pslots são zero. A célula à esquerda de cé usada para armazenar uma cópia do caractere atual do qual estamos tentando encontrar o índice. A célula à esquerda da corrente ié usada para reter um -1para facilitar a navegação do ponteiro.

Existem muitas condições que precisam ser consideradas com cuidado. No final, verificamos isomorfos comparando os (i,p)pares e alcançamos o cluster de zero células à esquerda do (i,p)par mais à esquerda se, e somente se, as cadeias de caracteres são isomorfos. Aqui está uma versão comentada do código para facilitar o acompanhamento:

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

Atualizar:

Aqui está uma versão que imprime \x01para isomorfos e \x00não isomorfos. Esta é sem dúvida uma interpretação mais precisa de Truthy e Falsey para o cérebro, por causa da maneira [e do ]trabalho. A única diferença está no final.

Adicional: Agora, use \x00como um separador para salvar 10 bytes.

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

JavaScript (ES6), 62

Usando uma função aux hque mapeia cada palavra para uma matriz que contém a posição de cada letra na palavra, por exemplo: PASS -> [1,2,3,3]. Retorne true se a função haplicada as duas palavras der o mesmo resultado.

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

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 bytes

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

É uma função fque recebe dois argumentos e retorna trueou false.

Explicação:

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

Mapeia cada caractere de se tpara seu local e verifica a igualdade.

Expandido:

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 bytes

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)

Pitão, 9 bytes

qFmmxdkdQ

Recebe entrada da seguinte forma:

"ESTATE", "DUELED"

Se isso não for aceitável, o código a seguir é 10 bytes:

qFmmxdkd.z

e usa este formulário de entrada:

ESTATE
DUELED

Usa o índice de char na representação de string.

Matlab, 50 bytes

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

A função é definida como anônima para economizar espaço.

Exemplo:

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

Oitava, 26 bytes

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

05AB1E , 6 bytes

εæδË}Ë

Experimente online!

Toma entrada como uma lista: ['ESTATE', 'DUELED']

Explicações:

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

-1 graças à dica de ngn.

Função de prefixo tácito anônimo que usa uma lista de duas seqüências de caracteres como argumento.

≡.⍳⍨

Experimente Online!

Este é um produto interno, mas em vez do usual +e ×usa

≡ identidade

. e

⍳ o ndex (a primeira ocorrência de cada elemento)

⍨ com toda a lista de dois elementos de palavras usadas como ambos os argumentos

Se chamarmos as palavras Ae B, podemos derivar a solução anterior da seguinte maneira:

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

Solução anterior

Função de prefixo tácito anônimo que usa uma lista de duas seqüências de caracteres como argumento.

≡/⍳⍨¨

Experimente online!

≡ identidade

/ através

⍳ o índice (a primeira ocorrência de cada elemento…)

⍨ selfie (… em si)

¨ De cada

Mathematica, 46 bytes

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

Ruby, 50 bytes

Código ruby ​​30 bytes mais curto. Escrito antes de dar uma olhada nas soluções, verifica cada caractere de ambas as seqüências se o índice da primeira ocorrência desse caractere corresponde; ie transforma uma string em sua forma normalizada 01121etc e as compara.

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

Casos de teste no ideone Como um bônus adicional, isso quebra o destaque do código do ideone.

Casca , 5 bytes

¤=´×=

Experimente online!

Explicação

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

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

O assunto deve ter duas palavras separadas por espaço, como no OP. Aqui está uma explicação superficial:

Para cada letra X na primeira palavra:

Olhe adiante para a segunda palavra e estabeleça referências anteriores para lembrar quanto tempo estamos, bem como a letra Y na segunda palavra correspondente a X.

Para cada letra Z além da posição atual na primeira palavra:

Estabeleça referências anteriores semelhantes às anteriores.

Observe a letra correspondente na segunda palavra e verifique se Z = X corresponde a um Y; caso contrário, corresponde a uma letra que não é Y.

Essa iteração pode terminar assim que correspondermos à penúltima letra da primeira palavra. Nesse ponto, como nenhuma validação adicional é necessária, resta apenas testar se as palavras têm o mesmo comprimento (a referência anterior que contém substratos acumulados da segunda palavra está sempre atrasada em 1 letra).

Ruby, 31 bytes

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

Um Proc que pega uma matriz de strings e verifica se alguma é isomórfica entre si. tr s,'a-z'com esses argumentos normaliza uma sequência ssubstituindo cada letra pela enésima letra do alfabeto, onde né o maior índice com o qual essa letra aparece na sequência. Por exemplo, estatetorna-se fbedef, como faz dueled.

Cobra, 72 bytes

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

JavaScript (ES5), 142 98

Bastante grande, mas ainda não vi uma versão 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)

Simplesmente substitui todas as ocorrências da primeira letra pelo seu valor de índice reverso. Repete isso para todos os caracteres.

Ele faz o mesmo para as duas entradas e compara o padrão gerado.

A comparação é bastante feia, mas não quero usar uma matriz para armazenar e compará-la.

Perl, 38 bytes

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

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

Imprime 1 se verdadeiro, nada se falso.

Lisp comum, 76 bytes

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

Experimente online!

C ++, 213 196 162 bytes

-51 bytes graças 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;};

Para chamar o lambda, você precisa passar 2 argumentos que são do std::stringtipo dados

Código a testar:

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

para o código que testa, incluindo iostreame stringarquivo de cabeçalho é necessário

JavaScript (ES6), 52 51 50 bytes

Esta versão não usa compreensão de array e recebe entradas usando a sintaxe 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}`);
}