Vérifier si les mots sont des isomorphes


63

Deux mots sont isomorphes s'ils ont le même motif de répétition de lettre. Par exemple, les deux ESTATEet DUELEDont un motifabcdca

ESTATE
DUELED

abcdca

parce que les lettres 1 et 6 sont identiques, les lettres 3 et 5 sont identiques et rien d’autre. Cela signifie également que les mots sont liés par un chiffre de substitution, ici avec la correspondance E <-> D, S <-> U, T <-> E, A <-> L.

Écrivez un code qui prend deux mots et vérifie s’ils sont isomorphes. Le moins d'octets gagne.

Entrée: deux chaînes de lettres majuscules non vides A..Z. Si vous le souhaitez, vous pouvez les prendre comme une collection de deux chaînes ou comme une seule chaîne avec un séparateur.

Sortie: une valeur de vérité cohérente pour les paires qui sont des isomorphes et une valeur de Falsey cohérente si elles ne le sont pas. Les chaînes de différentes longueurs sont des entrées valides qui ne sont jamais isomorphes.

Cas de test:

Vrai:

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

Faux:

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

N'hésitez pas à ajouter d'autres cas de test que vous jugez utiles.

Classement

Voici un extrait de pile permettant de générer à la fois un classement régulier et un aperçu des gagnants par langue.

Pour vous assurer que votre réponse apparaît, commencez votre réponse par un titre, en utilisant le modèle Markdown suivant:

# Language Name, N bytes

Nest la taille de votre soumission. Si vous améliorez votre score, vous pouvez conserver les anciens scores en les effaçant. Par exemple:

# Ruby, <s>104</s> <s>101</s> 96 bytes


Les longueurs des deux entrées sont-elles garanties identiques?
Optimiseur

@Optimizer Non, les longueurs peuvent être différentes.
xnor

@ Jakube Non, votre code devrait en théorie fonctionner avec des entrées de n'importe quelle longueur. Cela ne pose aucun problème si d'importantes entrées échouent sur le matériel en raison de problèmes tels que le dépassement de capacité de la mémoire ou la profondeur de la pile.
xnor

Ok, je vais supprimer ma réponse.
Jakube

Cas de test important: ABAB CD(pour les approches de type zip)
Sp3000

Réponses:


95

J, 4 octets

-:&=

Usage

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

Explication

  • = avec 1 argument crée un tableau d'égalité comparant les éléments de l'entrée et son 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
    
  • -:avec 2 arguments vérifie leur égalité (comme le fait ==généralement). Cela fonctionne aussi pour les matrices de tailles différentes (ou même de types différents).

  • f&gapplique g aux deux entrées séparément puis applique f aux deux résultats ensemble ainsi x f&g y == f(g(x), g(y)).

  • Donc, dans notre cas, nous comparons les deux tables d’égalité.

Essayez-le en ligne ici.


2
Une approche intéressante et élégante. Sans équivalent &, la chose la plus proche que vous puissiez faire à K serait probablement la suivante ~/{x=/:x}': elle est un peu plus longue.
JohnE

17
Jésus. Cela doit être un concurrent pour le Hall of Fame CodeGolf.
Brian Gordon

Wow, =je ne pensais pas que la classification aurait un autre usage que celui de compter les occurrences.
miles

37

K, 5 octets

Cela a une solution délicieusement élégante dans K!

~/=:'

L'opérateur "group" (monadique =) crée précisément la signature que nous voulons pour l'isomorphisme des mots; regroupement des vecteurs des indices de chaque élément d'un vecteur, avec les groupes ordonnés par apparence:

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

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

En prenant une paire de chaînes comme vecteur, il suffit d’appliquer un groupe à chaque élément ( =:') puis de réduire avec "match" ( ~), l’opérateur d’égalité profonde:

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

15

Python 2, 41 octets

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

4
C'est la solution qui m'a inspiré pour créer ce défi!
xnor

12

CJam, 9 octets

r_f#r_f#=

Imprime 1si les mots sont isomorphes et 0s'ils ne le sont pas.

Essayez-le en ligne dans l' interprète CJam .

Comment ça fonctionne

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.

10

JavaScript, ES7, 62 55 54 52 51 octets

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

La logique est simple. Je convertis simplement les deux entrées en leurs valeurs d'index de caractères correspondantes, convertis ce tableau en chaîne et comparons.

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

Essayez le code ci-dessus en utilisant l'extrait ci-dessous.

2 octets enregistrés grâce à @ edc65


7
+1, j'ai essayé, ça marche bien. +0au lieu de +""?
edc65

1
@ edc65 wow, conversion de typographie WTF
Optimiseur,

1
Je viens de réaliser que les chaînes sont 'A-Z', vous pouvez donc utiliser en toute sécurité search au lieu de indexOf et couper un octet supplémentaire.
edc65

La compréhension du tableau n’a-t-elle pas été supprimée d’es7 finalement? Où ce code fonctionne-t-il? Je pense que dans Mozilla
DanielIndie

8

Bash + coreutils, 38

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

Notez que nous utilisons ici l’idée habituelle de vérité / fausseté: zéro signifie SUCCÈS ou VRAI et non nul signifie erreur ou FAUX:

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

8

Haskell, 33 ans 29

MODIFIER:

c'est beaucoup trop tard, mais j'ai trouvé cette amélioration en utilisant des applications, qui n'ont été ajoutées à prélude qu'en mars 2015.

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

Ancienne version:

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

la fonction de vérification est (%)

cela fonctionne en générant pour chaque chaîne son "enregistrement d'égalité": pour chaque deux index ij, il enregistre s'ils ont des caractères égaux. l'enregistrement est ordonné de sorte que l'enregistrement de deux index i, j soit toujours au même endroit * et que, par conséquent, le fait de vérifier l'égalité des enregistrements renverrait si les chaînes ont le même motif.

Par exemple, l'enregistrement d'égalité de "ABC" est [1,0,0,0,1,0,0,0,1](1 pour vrai, 0 pour faux) - il existe un Trueendroit où tout index est comparé à lui-même. n'importe où ailleurs est un faux. (sauter ces vérifications pourrait être plus efficace, mais est plus difficile en termes de golf)

* si les cordes ont la même longueur. sinon, il retourne false simplement parce que les enregistrements ont des longueurs différentes


6

Haskell, 45 41 octets

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

Retourne Trueou False, par exemple "ESTATE" ! "DUELED"-> True.

Utilise la méthode map-char-to-first-index, comme le montrent de nombreuses autres réponses. Les listes d'associations sont pratiques, car les entrées précédentes ont l'avantage. "aba"devient [(a,1),(b,2),(a,3)]lookupva toujours chercher a-> 1.

Edit: @Mauris a trouvé 4 octets à sauvegarder.


Vous pouvez remplacer (flip lookup$zip l[1..])par (`lookup`zip l[1..]).
Lynn

6

Brainfuck, 169 168 162 144 140 131 130

Compatible avec le bff d' Alex Pankratov (interprète brainfuck utilisé sur SPOJ et idéone) et le BFI de Thomas Cort (utilisé sur Anarchy Golf).

L'entrée attendue est deux chaînes séparées par un onglet, sans nouvelle ligne après la deuxième chaîne. La sortie 1concerne les isomorphes et les 0non-isomorphes, ce qui est pratique pour vérifier les résultats visuellement, bien que ce ne soit pas l'option la plus courte. ( Mise à jour: version plus courte avec \x01et \x00comme sortie et \x00comme séparateur au bas de la réponse.)

Démonstration sur ideone.

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

Ce problème s'avère être très gentil pour un brainfuck.

L'idée de base de l'indexation est de revenir en arrière à partir de la fin du préfixe de chaîne actuel. Si le caractère ne s'est pas déjà produit, nous pouvons prendre la longueur du préfixe de chaîne. Par exemple:

STATES
123255

L'indexation dans le code est en fait légèrement différente mais utilise le même principe.

La disposition de la mémoire est en blocs 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

creprésente le caractère, iindex et pprécédent (index). Lorsque la première chaîne est en cours de traitement, tous les pemplacements sont nuls. La cellule située à gauche de ccontient une copie du caractère actuel dont nous essayons de trouver l'index. La cellule située à gauche du courant isert à contenir un -1pointeur pour faciliter la navigation.

Il y a beaucoup de conditions qui doivent être considérées avec soin. À la fin, nous vérifions les isomorphes en comparant les (i,p)paires et nous atteignons le groupe de cellules zéro situé à gauche de la (i,p)paire la plus à gauche si et seulement si les chaînes sont des isomorphes. Voici une version commentée du code pour le rendre plus facile à suivre:

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

Mise à jour:

Voici une version qui s’imprime \x01pour les isomorphes et \x00pour les non-isomorphes. C'est sans doute une interprétation plus précise de Truthy et Falsey pour un brainfuck, à cause du chemin [et du ]travail. La seule différence est à la toute fin.

Supplémentaire: utilisez maintenant \x00comme séparateur pour économiser 10 octets.

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

5

JavaScript (ES6), 62

Utilisation d'une fonction aux hqui mappe chaque mot à un tableau contenant la position de chaque lettre du mot, par exemple: PASS -> [1,2,3,3]. Renvoie true si la fonction happliquée aux deux mots donne le même résultat.

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>


1
Parfois, simple est plus court;)
Optimiseur

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

me battre à elle! (+1)
shadowtalker

Je pense que all( (g=...)(x)==g(y))c'est plus court que identical...
Giuseppe

5

Ruby, 83 octets

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

C'est une fonction fqui prend deux arguments et retourne trueou false.

Explication:

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

1
Cela devrait économiser 4 octets t=->x{z=?`;x.chars.to_a.uniq.map{|c|x.gsub!(c,z.succ!)};x};f=->a,b{t[a]==t[b]}t=->x{h={};i=9;x.gsub!(/./){|c|h[c]||h[c]=i+=1}};f=->a,b{t[a]==t[b]}
:,

5

Java, 107

(s,t)->java.util.Arrays.equals(s.chars().map(s::indexOf).toArray(),t.chars().map(t::indexOf).toArray())

Mappe chaque caractère de set tà son emplacement, et vérifie l'égalité.

Étendu:

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

Je ne pense pas que cela fonctionnera correctement si les chaînes ont des longueurs différentes.
JohnE

@JohnE Oui, c'est le cas.
Ypnypn

Ah, d'accord, je pense que la version "développée" est trompeuse.
JohnE

4

Python 3, 85 octets

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ù se trouve l'entrée / sortie sur celui-ci?
DJMcMayhem

@DJMcMayhem gest la fonction principale, fest une aide. Il y a un choix déroutant de variable à l' gintérieur f, mais c'est une variable liée non liée. Le g=choix est facultatif, selon la décision autorisant les fonctions anon, qui enregistre deux caractères. '
xnor

4

Pyth, 9 octets

qFmmxdkdQ

Prend les entrées sous la forme suivante:

"ESTATE", "DUELED"

Si ce n'est pas acceptable, le code suivant est 10 octets:

qFmmxdkd.z

et utilise ce formulaire de saisie:

ESTATE
DUELED

Utilise l'index de char dans la représentation sous forme de chaîne.


Le premier format d'entrée convient. Je suis intéressé par la façon dont vous réduisez pour vérifier l’égalité, mais je ne comprends pas bien comment ça Fmarche. C'est quoi <binary>F?
xnor

@xnor <binary>F<seq>est <binary>replié <seq>. Cela équivaut à intercaler <binary>chaque paire d'éléments de <seq>. Ainsi, <binary>Fsur une séquence de 2 éléments, la fonction est simplement appliquée à la séquence, ce qui équivaut à .*Pyth ou *à Python.
isaacg

Je pensais que la fuite Qétait implicite dans Pyth?
Cyoce

@Cyoce Pas à l'époque - cette fonctionnalité a été ajoutée en avril 2016, presque un an plus tard.
isaacg

4

Matlab, 50 octets

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

La fonction est définie comme anonyme pour économiser de l'espace.

Exemple:

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

4

Octave, 26 octets

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

3
Semble intéressant. explication?
fier haskeller

==correspond à l'élément matrice, et depuis set s'sont de tailles différentes, la "diffusion" d'octave essaie automatiquement de faire fonctionner des matrices de la même taille - ce qui dans ce cas signifie répéter la ligne set la colonnes'
rakslice

C'est la même approche que la solution Matlab de @ LuisMendo, mais l'expansion est explicite.
Rakslice

4

05AB1E , 6 octets

εæδË}Ë

Essayez-le en ligne!

Prend les entrées sous forme de liste: ['ESTATE', 'DUELED']

Explications:

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

4

APL (Dyalog) , 5 à 4 octets

-1 grâce à l'allusion de ngn.

Fonction de préfixe tacite anonyme qui prend comme argument une liste de deux chaînes.

≡.⍳⍨

Essayez-le en ligne!

Ceci est un produit interne, mais au lieu de l'habituel +et ×il utilise

 identité

. et

 le ɩ ndex (la première occurrence de chaque élément)

 avec la liste complète de mots à deux éléments utilisés comme deux arguments

Si nous appelons les mots Aet B, alors nous pouvons déduire la solution précédente comme suit:

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

Solution précédente

Fonction de préfixe tacite anonyme qui prend comme argument une liste de deux chaînes.

≡/⍳⍨¨

Essayez-le en ligne!

 identité

/ à travers

 le ɩ ndex (la première occurrence de chaque élément…)

 selfie (… en soi)

¨ de chaque


pouvez-vous voir le produit intérieur? :)
NDGN

@ ngn Oui bien sûr. Que je suis bête.
Adám

Le lien en haut est-il censé se connecter à l'ancienne solution?
Zacharý

Dommage que cela ne fonctionne pas avec les tableaux de rang supérieur: P
Zacharý

1
ngn

3

Mathematica, 46 octets

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

3

Ruby, 50 octets

Code ruby ​​plus court de 30 octets. Ecrit avant de jeter un coup d'œil aux solutions, vérifie pour chaque caractère des deux chaînes si l'index de la première occurrence de ce caractère correspond; c'est à dire. transforme une chaîne en sa forme normalisée, 01121etc. et les compare.

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

Cas de test sur ideone En tant que bonus supplémentaire, cela interrompt la mise en surbrillance du code de l'idéone.


3

Husk , 5 octets

¤=´×=

Essayez-le en ligne!

Explication

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

3

PCRE, 84 octets

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

Le sujet doit être composé de deux mots séparés par des espaces, comme dans le PO. Voici une explication superficielle:

Pour chaque lettre X dans le premier mot:

Examinez le deuxième mot et établissez des références en arrière pour rappeler à quel point nous en sommes ainsi que la lettre Y dans le deuxième mot correspondant à X.

Pour chaque lettre Z passée la position actuelle dans le premier mot:

Établissez des références arrière similaires à celles mentionnées ci-dessus.

Recherchez la lettre correspondante dans le deuxième mot et vérifiez si Z = X correspond à Y, sinon correspond à une lettre qui n'est pas Y.

Cette itération peut se terminer une fois que nous avons mis en correspondance jusqu'à l'avant-dernière lettre du premier mot. À ce stade, puisqu’aucune validation supplémentaire n’est nécessaire, il ne reste plus qu’à vérifier que les mots sont de longueur égale (la référence arrière contenant les sous-chaînes accumulées du deuxième mot est toujours en retard d’une lettre).


2

Ruby, 31 octets

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

Un Proc qui prend un tableau de chaînes et vérifie si certaines sont isomorphes les unes par rapport aux autres. tr s,'a-z'avec ces arguments, normalise une chaîne sen remplaçant chaque lettre par la nième lettre de l'alphabet, où nest le plus grand indice avec lequel cette lettre apparaît dans la chaîne. Par exemple, estatedevient fbedef, comme le fait dueled.


1

Cobra, 72 octets

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

Etes-vous sûr que ceci marque le AB CCcas test False?
xnor

@xnor corrigé maintenant
jeudi

1

JavaScript (ES5), 142 98

C'est assez gros, mais je n'ai pas encore vu de version 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)

Remplace simplement chaque occurrence de la première lettre par sa valeur d'index inverse. Répète ceci pour chaque personnage.

Il fait la même chose pour les deux entrées et compare le motif généré.

La comparaison est assez moche, mais je ne voudrais pas utiliser un tableau pour le stocker et le comparer.


1
Pourriez - vous pas déplacer ;l=cà for(l=j=2;j--;et enregistrer un octet?
Jonathan Frech

1

Perl, 38 octets

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

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

Imprime 1 si vrai, rien si faux.



1

C ++, 213 196 162 octets

-51 octets grâce à 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;};

Pour appeler le lambda, vous devez passer 2 arguments de std::stringtype données.

Code à tester:

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

pour le code qui teste, y compris iostreamet le stringfichier d'en-tête est requis


1
Il ne semble pas que vous utilisiez quelque chose de l'en-tête de chaîne. Pouvez-vous donc le supprimer et demander à l'utilisateur de l'inclure lui-même?
Zacharý

Est- ce que cela fonctionne pour 161 octets?
Zacharý

@ Zacharý Si vous ajoutez l' eargument de find, oui, cela fonctionne
HatsuPointerKun

Ce moment où vous êtes battu par Brainfuck cependant> _ <
Zacharý

1

JavaScript (ES6), 52 51 50 octets

Cette version n'utilise pas la compréhension des tableaux et accepte les entrées en utilisant la syntaxe de currying.

a=>b=>(f=x=>0+[...x].map(c=>x.search(c)))(a)==f(b)

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.