Dos palabras son isomorfos si tienen el mismo patrón de repeticiones de letras. Por ejemplo, ambos ESTATEy DUELEDtienen patrónabcdca

ESTATE
DUELED

abcdca

Como las letras 1 y 6 son iguales, las letras 3 y 5 son iguales y nada más. Esto también significa que las palabras están relacionadas por un cifrado de sustitución, aquí con la coincidencia E <-> D, S <-> U, T <-> E, A <-> L.

Escriba código que tome dos palabras y verifique si son isomorfos. Pocos bytes ganan.

Entrada: Dos cadenas de letras mayúsculas no vacías A..Z. Si lo desea, puede tomarlos como una colección de dos cadenas o como una sola cadena con un separador.

Salida: Un valor de Verdad consistente para pares que son isomorfos, y un valor de Falsey consistente si no lo son. Las cadenas de diferentes longitudes son entradas válidas que nunca son isomorfos.

Casos de prueba:

Cierto:

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

Siéntase libre de agregar más casos de prueba que considere útiles.

Tabla de clasificación

Aquí hay un fragmento de pila para generar una tabla de clasificación regular y una descripción general de los ganadores por idioma.

Para asegurarse de que su respuesta se muestre, comience con un título, usando la siguiente plantilla de Markdown:

# Language Name, N bytes

¿Dónde Nestá el tamaño de su envío? Si mejora su puntaje, puede mantener los puntajes antiguos en el título, tachándolos. Por ejemplo:

# 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 

Explicación

• = con 1 argumento crea una tabla de igualdad que compara los elementos de la entrada y su protuberancia.

  ='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 argumentos verifica su igualdad (como ==generalmente lo hace). Esto también funciona para matrices de diferentes tamaños (o incluso para diferentes tipos).

• f&gaplica g tanto de entrada por separado y luego se aplica f a los dos resultados juntos así x f&g y == f(g(x), g(y)).

• Entonces, en nuestro caso, comparamos las dos tablas de igualdad.

Pruébelo en línea aquí.

K, 5 bytes

¡Esto tiene una solución deliciosamente elegante en K!

~/=:'

El operador "grupo" (monádico =) crea precisamente la firma que queremos para la palabra isomorfismo; reuniendo vectores de los índices de cada elemento de un vector, con los grupos ordenados por apariencia:

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

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

Tomando un par de cadenas como vector, solo necesitamos aplicar el grupo a cada elemento ( =:') y luego reducir con "match" ( ~), el operador de igualdad 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 1si las palabras son isomorfos y 0si no lo son.

Pruébelo en línea en el intérprete de CJam .

Cómo 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)

La lógica es simple. Simplemente convierto ambas entradas en sus valores de índice de caracteres correspondientes, convierto esa matriz en una cadena y la 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

Pruebe el código anterior usando el fragmento a continuación.

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 guardados gracias a @ edc65

Bash + coreutils, 38

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

Tenga en cuenta que estamos usando la idea habitual de la verdad / falsedad aquí: cero significa ÉXITO o VERDADERO y no cero significa error 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

EDITAR:

Esto es demasiado tarde, pero encontré esta mejora con los solicitantes, que se agregaron al preludio solo en marzo de 2015.

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

Versión antigua:

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

la función de verificación es (%)

esto funciona generando para cada cadena su "registro de igualdad": para cada dos índices ij, registra si tienen caracteres iguales. el registro está ordenado de modo que el registro para dos índices i, j siempre esté en el mismo lugar * y, por lo tanto, verificar la igualdad de los registros devolvería si las cadenas tienen o no el mismo patrón.

por ejemplo, el registro de igualdad de "ABC" es [1,0,0,0,1,0,0,0,1](1 para verdadero, 0 para falso): allí es Truedonde se compara cualquier índice consigo mismo. cualquier otro lugar es falso. (omitir estos controles puede ser más eficiente, pero es más difícil en términos de golf)

* _{si las cadenas son de la misma longitud. de lo contrario, devuelve falso solo porque los registros son de diferentes longitudes}

Haskell, 45 41 bytes

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

Devoluciones Trueo False, por ejemplo, "ESTATE" ! "DUELED"-> True.

Utiliza el método map-char-to-first-index como se ve en muchas otras respuestas. Las listas de asociaciones son útiles, porque las entradas anteriores triunfan. "aba"se convierte [(a,1),(b,2),(a,3)]donde lookupsiempre busca a-> 1.

Editar: @Mauris encontró 4 bytes para guardar.

Brainfuck, 169 168 162 144 140 131 130

Compatible con bff de Alex Pankratov (intérprete de brainfuck usado en SPOJ e ideone) y BFI de Thomas Cort (usado en Anarchy Golf).

La entrada esperada es dos cadenas separadas por una pestaña, sin nueva línea después de la segunda cadena. La salida es 1para isomorfos y 0para no isomorfos, lo cual es conveniente para verificar los resultados visualmente, aunque no es la opción más corta. ( Actualización: versión más corta con \x01y \x00como salida y \x00como separador en la parte inferior de la respuesta).

Demostración sobre ideona.

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

Este problema resulta ser muy bueno para el brainfuck.

La idea básica con la indexación es ir hacia atrás desde el final del prefijo de cadena actual. Si el carácter no se ha producido anteriormente, podemos tomar la longitud del prefijo de la cadena. Por ejemplo:

STATES
123255

La indexación en el código es en realidad un poco diferente, pero utiliza el mismo principio.

El diseño de la memoria está en bloques 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 carácter, iíndice y panterior (índice). Cuando se procesa la primera cadena, todas las pranuras son cero. La celda a la izquierda de cse usa para contener una copia del carácter actual del que estamos tratando de encontrar el índice. La celda a la izquierda de la corriente ise usa para mantener un -1para una fácil navegación del puntero.

Hay muchas condiciones que deben considerarse cuidadosamente. Al final, verificamos si hay isomorfos comparando los (i,p)pares, y llegamos al grupo de celdas cero a la izquierda del (i,p)par más a la izquierda si y solo si las cadenas son isomorfos. Aquí hay una versión comentada del código para que sea más fácil de seguir:

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

Actualizar:

Aquí hay una versión que imprime \x01para isomorfos y \x00para no isomorfos. Esto podría decirse que es una interpretación más precisa de Truthy y Falsey para el cerebro, debido a la forma [y el ]trabajo. La única diferencia está al final.

Adicional: ahora se usa \x00como separador para guardar 10 bytes.

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

JavaScript (ES6), 62

Usando una función auxiliar hque asigna cada palabra a una matriz que contiene la posición de cada letra en la palabra, por ejemplo: PASS -> [1,2,3,3]. Devuelve verdadero si la función haplica las dos palabras da el mismo 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-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 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]}

Es una función fque toma dos argumentos y devuelve trueo false.

Explicación:

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

Mapea cada personaje de sy ta su ubicación, y verifica la igualdad.

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)

Pyth, 9 bytes

qFmmxdkdQ

Toma entrada de la siguiente forma:

"ESTATE", "DUELED"

Si eso no es aceptable, el siguiente código es de 10 bytes:

qFmmxdkd.z

y usa este formulario de entrada:

ESTATE
DUELED

Utiliza el índice de char en la representación de cadena.

Matlab, 50 bytes

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

La función se define como anónima para ahorrar espacio.

Ejemplo:

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

Octava, 26 bytes

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

05AB1E , 6 bytes

εæδË}Ë

Pruébalo en línea!

Toma la entrada como una lista: ['ESTATE', 'DUELED']

Explicaciones:

    εæδË}Ë   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 gracias a la pista de ngn.

Función de prefijo tácito anónimo que toma una lista de dos cadenas como argumento.

≡.⍳⍨

Pruébalo en línea!

Este es un producto interno, pero en lugar de lo habitual +y ×utiliza

≡ similitud

. y

⍳ el ɩ ndex (la primera aparición de cada elemento)

⍨ con la lista completa de dos elementos de palabras usadas como ambos argumentos

Si llamamos a las palabras Ay B, entonces podemos derivar la solución anterior de la siguiente manera:

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

Solución previa

Función de prefijo tácito anónimo que toma una lista de dos cadenas como argumento.

≡/⍳⍨¨

Pruébalo en línea!

≡ similitud

/ a través de

⍳ el ɩ ndex (la primera aparición de cada elemento ...)

⍨ selfie (... en sí mismo)

¨ de cada

Mathematica, 46 bytes

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

Ruby, 50 bytes.

Código ruby ​​30 bytes más corto. Escrito antes de echar un vistazo a las soluciones, verifica para cada carácter de ambas cadenas si el índice de la primera aparición de ese carácter coincide; es decir. transforma una cadena a su forma normalizada, 01121etc. y las compara.

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

Casos de prueba en ideone Como una ventaja adicional, esto rompe el resaltado del código de ideone.

Casco , 5 bytes

¤=´×=

Pruébalo en línea!

Explicación

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

El asunto debe ser dos palabras separadas por espacios, como en el OP. Aquí hay una explicación superficial:

Para cada letra X en la primera palabra:

Mire hacia adelante a la segunda palabra y establezca referencias para recordar qué tan avanzado estamos, así como la letra Y en la segunda palabra correspondiente a X.

Para cada letra Z más allá de la posición actual en la primera palabra:

Establezca referencias posteriores similares a las anteriores.

Mire hacia adelante a la letra correspondiente en la segunda palabra y verifique si Z = X luego coincida con una Y, de lo contrario, coincida con una letra que no sea Y.

Esta iteración puede terminar una vez que hayamos hecho coincidir hasta la penúltima letra en la primera palabra. En este punto, dado que no es necesaria una validación adicional, todo lo que queda es probar que las palabras tienen la misma longitud (la referencia posterior que contiene las subcadenas acumuladas de la segunda palabra siempre está detrás de 1 letra).

Ruby, 31 bytes

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

Un proceso que toma una serie de cadenas y comprueba si alguno es isomorfo entre sí. tr s,'a-z'con estos argumentos se normaliza una cadena sal reemplazar cada letra con la enésima letra del alfabeto, donde nes el índice más grande con el que aparece esa letra en la cadena. Por ejemplo, se estateconvierte fbedef, como lo hace 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

Muy grande, pero todavía no vi una versión 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)

Simplemente reemplaza cada aparición de la primera letra con su valor de índice inverso. Repite esto para cada personaje.

Hace lo mismo para ambas entradas y compara el patrón generado.

La comparación es bastante fea, pero no quiero usar una matriz para almacenarla y compararla.

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 si es verdadero, nada si es falso.

Lisp común, 76 bytes

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

Pruébalo en línea!

C ++, 213 196 162 bytes

-51 bytes gracias 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 llamar a lambda, debe pasar 2 argumentos que son std::stringde tipo de datos

Código para probar:

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 el código que pone a prueba, incluyendo iostreamy stringse requiere un archivo de cabecera

JavaScript (ES6), 52 51 50 bytes

Esta versión no utiliza la comprensión de la matriz y toma datos utilizando la sintaxis de 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}`);
}