Comprueba si las palabras son isomorfos

63

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

xnor
fuente
¿Se garantiza que las longitudes de las dos entradas sean iguales?
Optimizador
@Optimizer No, las longitudes pueden ser diferentes.
xnor
@Jakube No, su código debería en teoría funcionar con entradas de cualquier longitud. Sin embargo, está bien si las grandes entradas fallan en el hardware debido a problemas como el desbordamiento de la memoria o la profundidad de la pila.
xnor
Ok, entonces borraré mi respuesta.
Jakube
Caso de prueba importante: ABAB CD(para enfoques tipo zip)
Sp3000

Respuestas:

95

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

randomra
fuente
2
Un enfoque interesante y elegante. Sin un equivalente a eso &, lo más cercano que podrías hacer en K probablemente sería ~/{x=/:x}', que es un poco más largo.
JohnE
17
Jesús. Esto tiene que ser un contendiente para el salón de la fama codegolf.
Brian Gordon
Wow, no esperaba que la clasificación =tuviera otro uso que no sea para contar sucesos.
millas
37

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
JohnE
fuente
15

Python 2, 41 bytes

f=lambda a,b:map(a.find,a)==map(b.find,b)
ygramul
fuente
44
¡Esta fue la solución que me inspiró a crear este desafío!
xnor
12

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.
Dennis
fuente
10

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.

2 bytes guardados gracias a @ edc65

Optimizador
fuente
77
+1, lo intenté, funciona bien. +0en lugar de +""?
edc65
1
@ edc65 wow, tipografía WTF
Optimizer
1
Me di cuenta ahora que las cadenas son 'A-Z', por lo que puede usar la búsqueda de forma segura en lugar de indexOf y cortar 1 byte más.
edc65
¿finalmente no se han eliminado las comprensiones de la matriz de es7? ¿Dónde funciona este código? creo que solo en mozilla
DanielIndie
8

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
$ 
Trauma digital
fuente
8

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

orgulloso Haskeller
fuente
6

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.

nimi
fuente
Puedes reemplazar (flip lookup$zip l[1..])por (`lookup`zip l[1..]).
Lynn
6

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.

+
[
  -
  >+<
  [
    >>-<
    [
      <
      [
        >+<
        <<<<-<+>>>>>-
      ]
      ++[->+]
      ->+[+<-]
      >[<<<<]
      <
    ]
    <[>+<-]
    +[->+]
    <->
    >>>
  ]
  >
  [
    [[-]<<<<<]
    >>>>
  ]
  <,+
]
>>>+>+
[
  [<->-]
  <[>>>>>]
  <<<<
]
-<[>]
<+.
Mitch Schwartz
fuente
5

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>

edc65
fuente
1
A veces, simple es más corto;)
Optimizer
5

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))
flodel
fuente
vencerme! (+1)
shadowtalker
Creo que all( (g=...)(x)==g(y))es más corto que identical...
Giuseppe
5

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]}
Pomo de la puerta
fuente
1
Esto debería ahorrar 4 bytes: t=->x{z=?`;x.chars.to_a.uniq.map{|c|x.gsub!(c,z.succ!)};x};f=->a,b{t[a]==t[b]}y podría t=->x{h={};i=9;x.gsub!(/./){|c|h[c]||h[c]=i+=1}};f=->a,b{t[a]==t[b]}
reducirlo
5

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"));
    }
}
Ypnypn
fuente
No creo que esto funcione correctamente si las cadenas tienen longitudes diferentes.
JohnE
@JohnE Sí, lo hace.
Ypnypn
Ah, está bien. Creo que la versión "expandida" es engañosa.
JohnE
4

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)
El numero uno
fuente
¿Dónde está la entrada / salida en este?
DJMcMayhem
@DJMcMayhem ges la función principal, fes auxiliar. Hay una elección confusa de variable gdentro f, pero es una variable ligada no relacionada. g=Es opcional según la decisión que permite funciones anon, lo que ahorra dos caracteres.
xnor
4

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.

isaacg
fuente
El primer formato de entrada está bien. Estoy interesado en cómo se está reduciendo para verificar la igualdad, pero no estoy claro sobre cómo Ffunciona el pliegue. ¿Qué es <binary>F?
xnor
@xnor <binary>F<seq>está <binary>doblado <seq>. Es equivalente a intercalar <binary>entre cada par de elementos de <seq>. Por lo tanto, <binary>Fen una secuencia de 2 elementos simplemente aplica la función a la secuencia, equivalente a .*Pyth o *Python.
isaacg
Pensé que el seguimiento Qestaba implícito en Pyth?
Cyoce
@Cyoce no en aquel entonces: esa característica se agregó en abril de 2016, casi un año después.
isaacg
4

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
Luis Mendo
fuente
4

Octava, 26 bytes

@(s,t)isequal(s==s',t==t')
alephalpha
fuente
3
Parece interesante. ¿explicación?
Haskeller orgulloso
==es la matriz igualdad elemento a elemento, y desde sy s'son de diferentes tamaños, "radiodifusión" de Octave automáticamente intenta obtener matrices del mismo tamaño para operar en - que en este caso significa la repetición de la fila sy la columnas'
rakslice
Es el mismo enfoque que la solución Matlab de @ LuisMendo, pero allí la expansión es explícita.
rakslice
4

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
scottinet
fuente
4

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

Adán
fuente
puedes ver el producto interno? :)
ngn
@ngn Sí, por supuesto. Tonto de mí.
Adám
¿Se supone que el enlace superior está vinculado a la solución anterior?
Zacharý
Lástima que esto no funcione en matrices de mayor rango: P
Zacharý
1
@ Zacharý según lo prometido: ngn.github.io/apl-codegolf-2017/readme.txt
ngn
3

Mathematica, 46 bytes

Equal@@Values@*PositionIndex/@Characters@{##}&
alephalpha
fuente
3

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.

blutorange
fuente
3

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  ]
ბიმო
fuente
3

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

jaytea
fuente
2

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.

histocrat
fuente
1

Cobra, 72 bytes

do(a='',b='')=(for i in a get a.indexOf(i))==for i in b get b.indexOf(i)
Οurous
fuente
¿Estás seguro de que esto marca el AB CCcaso de prueba Falso?
xnor
@xnor arreglado ahora
Ο
1

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.

C5H8NNaO4
fuente
1
No se podía mover ;l=ca for(l=j=2;j--;y guardar un byte?
Jonathan Frech
1

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.

Gabriel Benamy
fuente
1

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!

Renzo
fuente
1

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

HatsuPointerKun
fuente
1
No parece que uses nada del encabezado de la cadena, ¿puedes eliminarlo y hacer que el usuario lo incluya?
Zacharý
¿Funciona esto por 161 bytes?
Zacharý
@ Zacharý Si agrega el eargumento de find, sí, funciona
HatsuPointerKun
Ese momento en que Brainfuck te supera> _ <
Zacharý
1

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)

kamoroso94
fuente