Verifique se as palavras são isomorfas

63

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

xnor
fonte
Os comprimentos das duas entradas são garantidos como iguais?
Optimizer
@ Otimizador Não, os comprimentos podem ser diferentes.
Xnor
@Jakube Não, seu código deve, em teoria, funcionar com entradas de qualquer tamanho. Não há problema se entradas enormes falharem no hardware devido a problemas como excesso de memória ou profundidade da pilha.
Xnor
Ok Então eu vou excluir minha resposta.
Jakube 20/05
Caso de teste importante: ABAB CD(para abordagens semelhantes a zip)
Sp3000

Respostas:

95

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.

randomra
fonte
2
Uma abordagem interessante e elegante. Sem um equivalente a isso &, a coisa mais próxima que você poderia fazer em K provavelmente seria ~/{x=/:x}', o que é um pouco mais longo.
Johne
17
Jesus. Este deve ser um candidato ao corredor da fama do codegolf.
Brian Gordon
Uau, não esperava que a classificação =tivesse outro uso além da contagem de ocorrências.
miles
37

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

Python 2, 41 bytes

f=lambda a,b:map(a.find,a)==map(b.find,b)
ygramul
fonte
4
Essa foi a solução que me inspirou a criar esse desafio!
Xnor 22/05
12

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

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.

2 bytes salvos graças a @ edc65

Optimizer
fonte
7
1, tentei, funciona bem. +0em vez de +""?
Edc65 19/05/19
11
@ edc65 wow, typecasting WTF
Otimizador
11
Percebi agora que as strings são 'A-Z', para que você possa usar a pesquisa com segurança em vez de indexOf e cortar mais 1 byte.
Edc65 20/05
as compreensões do array não foram cortadas do es7 eventualmente? onde esse código funciona? Eu acho que só no mozilla #
11117 DanielIndie
8

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
$ 
Trauma Digital
fonte
8

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

orgulhoso haskeller
fonte
6

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.

nimi
fonte
Você pode substituir (flip lookup$zip l[1..])por (`lookup`zip l[1..]).
Lynn
6

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.

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

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>

edc65
fonte
11
Às vezes, simples é mais curto;)
Optimizer
5

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))
flodel
fonte
bata-me a isso! (+1)
shadowtalker
Eu acho que all( (g=...)(x)==g(y))é mais curto do 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]}

É 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]}
Maçaneta da porta
fonte
11
Isso deve salvar 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]}e você pode obtê-lo para baixo para 68 se você usar um hash para obter a substituição:t=->x{h={};i=9;x.gsub!(/./){|c|h[c]||h[c]=i+=1}};f=->a,b{t[a]==t[b]}
blutorange
5

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"));
    }
}
Ypnypn
fonte
Eu não acho que isso funcionará corretamente se as seqüências tiverem comprimentos diferentes.
JohnE 20/05
@JohnE Sim, faz.
Ypnypn
Ah, ok- acho que a versão "expandida" é enganosa.
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)
O número um
fonte
Onde está a entrada / saída dessa?
DJMcMayhem
@DJMcMayhem gé a principal função, fé auxiliar. Há uma opção confusa de variável gdentro f, mas é uma variável vinculada não relacionada. A g=é opcional conforme a regra que permite funções anon, o que salva dois caracteres.
Xnor 20/05
4

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.

isaacg
fonte
O primeiro formato de entrada está bom. Estou interessado em saber como você está se reduzindo para verificar a igualdade, mas não sei como Ffunciona. O que é <binary>F?
Xnor 20/05
@xnor <binary>F<seq>está <binary>dobrado <seq>. É equivalente a intercalar <binary>entre cada par de elementos de <seq>. Assim, <binary>Fem uma sequência de 2 elementos, simplesmente se aplica a função à sequência, equivalente a .*em Pyth ou *em Python.
Isaacg
Eu pensei que a Qtrilha estava implícita em Pyth?
Cyoce
@Cyoce Naquela época, esse recurso foi adicionado em abril de 2016, quase um ano depois.
Isaacg
4

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

Oitava, 26 bytes

@(s,t)isequal(s==s',t==t')
alefalpha
fonte
3
Parece interessante. explicação?
Proud haskeller # 23/15
==é a matriz igualdade elemento-wise, e desde se s'são de tamanhos diferentes, "broadcasting" da oitava automaticamente tenta obter matrizes de mesmo tamanho para operar - que neste caso significa repetir a linha se colunas'
rakslice
É a mesma abordagem da solução Matlab do @ LuisMendo, mas a expansão é explícita.
rakslice
4

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
escoteiro
fonte
4

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

Adão
fonte
você pode ver o produto interno? :)
ngn 30/09/17
@ngn Sim, claro. Apenas eu.
Adám 30/09/17
O link superior deve estar vinculado à solução antiga?
Zacharý
Pena que isso não funciona em matrizes de classificação mais alta: P
Zacharý
11
@ Zacharý como prometido: ngn.github.io/apl-codegolf-2017/readme.txt
ngn
3

Mathematica, 46 bytes

Equal@@Values@*PositionIndex/@Characters@{##}&
alefalpha
fonte
3

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.

blutorange
fonte
3

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

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

Jaytea
fonte
2

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.

histocrata
fonte
1

Cobra, 72 bytes

do(a='',b='')=(for i in a get a.indexOf(i))==for i in b get b.indexOf(i)
Furioso
fonte
Tem certeza de que isso marca o AB CCcaso de teste False?
Xnor 21/05
@xnor corrigido agora
Οurous
1

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.

C5H8NNaO4
fonte
11
Não foi possível mover ;l=cpara for(l=j=2;j--;e salvar um 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 se verdadeiro, nada se falso.

Gabriel Benamy
fonte
1

Lisp comum, 76 bytes

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

Experimente online!

Renzo
fonte
1

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

HatsuPointerKun
fonte
11
Parece que você não usa nada do cabeçalho da string, então você pode removê-lo e fazer com que o usuário o inclua?
Zacharý 1/10/19
Faz este trabalho para 161 bytes?
Zachary
@ Zachary Se você adicionar o ecomo argumento de find, sim, ele funciona
HatsuPointerKun
Naquele momento em que você é derrotado pelo Brainfuck,> _ <
Zacharý 14/10
1

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)

kamoroso94
fonte