Zwei Wörter sind Isomorphe, wenn sie das gleiche Muster von Buchstabenwiederholungen aufweisen. Zum Beispiel beide ESTATEund DUELEDhaben Musterabcdca

ESTATE
DUELED

abcdca

da die buchstaben 1 und 6 gleich sind, sind die buchstaben 3 und 5 gleich und nichts weiter. Dies bedeutet auch, dass die Wörter durch eine Substitutionschiffre miteinander verbunden sind, hier mit der Übereinstimmung E <-> D, S <-> U, T <-> E, A <-> L.

Schreiben Sie Code, der zwei Wörter enthält und prüft, ob es sich um Isomorphe handelt. Wenigste Bytes gewinnt.

Eingabe: Zwei nicht leere Zeichenfolgen mit Großbuchstaben A..Z. Wenn Sie möchten, können Sie diese als Sammlung von zwei Zeichenfolgen oder als einzelne Zeichenfolge mit einem Trennzeichen verwenden.

Ausgabe: Ein konsistenter Wahrheitswert für isomorphe Paare und ein konsistenter Falsey-Wert, falls dies nicht der Fall ist . Zeichenfolgen unterschiedlicher Länge sind gültige Eingaben, die niemals isomorph sind.

Testfälle:

Wahr:

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

Falsch:

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

Fühlen Sie sich frei, weitere Testfälle hinzuzufügen, die Sie nützlich finden.

Bestenliste

Hier ist ein Stack-Snippet, um sowohl eine reguläre Rangliste als auch eine Übersicht der Gewinner nach Sprache zu generieren.

Um sicherzustellen, dass Ihre Antwort angezeigt wird, beginnen Sie Ihre Antwort mit einer Überschrift. Verwenden Sie dazu die folgende Markdown-Vorlage:

# Language Name, N bytes

Wo Nist die Größe Ihres Beitrags? Wenn Sie Ihren Score zu verbessern, Sie können alte Rechnungen in der Überschrift halten, indem man sich durch das Anschlagen. Zum Beispiel:

# 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

-:&=

Verwendungszweck

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

Erläuterung

• = Mit 1 Argument wird eine Gleichheitstabelle erstellt, in der die Elemente der Eingabe und ihres Nubs verglichen werden.

  ='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
  

• -:mit 2 Argumenten wird die Gleichheit überprüft (wie ==allgemein üblich). Dies funktioniert auch für Matrizen unterschiedlicher Größe (oder sogar für unterschiedliche Typen).

• f&gWendet g separat auf beide Eingaben an und wendet dann f zusammen auf die beiden Ergebnisse an x f&g y == f(g(x), g(y)).

• In unserem Fall vergleichen wir also die beiden Gleichheitstabellen.

Probieren Sie es hier online aus.

K, 5 Bytes

Dies hat eine herrlich elegante Lösung in K!

~/=:'

Der "Gruppen" -Operator (monadisch =) erzeugt genau die Signatur, die wir für den Wortisomorphismus benötigen. Sammeln von Vektoren der Indizes jedes Elements eines Vektors, wobei die Gruppen nach Erscheinungsbild geordnet sind:

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

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

Nehmen wir ein Paar von Strings als Vektor, müssen wir nur die Gruppe auf jedes Element anwenden ( =:') und dann mit "match" ( ~) den Deep-Equality-Operator reduzieren :

  ~/=:'("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#=

Gibt aus, 1ob es sich bei den Wörtern um Isomorphe handelt und 0ob dies nicht der Fall ist.

Probieren Sie es online im CJam-Interpreter aus .

Wie es funktioniert

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 Byte

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

Die Logik ist einfach. Ich konvertiere einfach beide Eingaben in die entsprechenden Zeichenindexwerte, konvertiere das Array in einen String und vergleiche.

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

Probieren Sie den obigen Code mit dem folgenden Snippet aus.

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 gespart dank @ edc65

Bash + Coreutils, 38

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

Beachten Sie, dass wir hier die übliche Shell-Idee von Wahr / Falsch verwenden - Null bedeutet ERFOLG oder WAHR und ungleich Null bedeutet Fehler oder FALSCH:

$ 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

BEARBEITEN:

Das ist viel zu spät, aber ich habe diese Verbesserung mit Hilfe von Bewerbern festgestellt, die erst im März 2015 zum Auftakt hinzugefügt wurden.

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

Alte Version:

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

Die Prüffunktion ist (%)

Dies funktioniert, indem für jeden String ein "Gleichheits-Datensatz" generiert wird: Für jeden der beiden Indizes ij wird aufgezeichnet, ob sie gleiche Zeichen haben. Der Datensatz ist so angeordnet, dass sich der Datensatz für zwei Indizes i, j immer an derselben Stelle befindet.

Beispiel: Der Gleichheitsnachweis von "ABC" lautet [1,0,0,0,1,0,0,0,1](1 für wahr, 0 für falsch). Dort wird Trueein Index mit sich selbst verglichen. irgendwo anders ist falsch. (Das Überspringen dieser Prüfungen ist zwar effizienter, aber in Bezug auf das Golfspiel schwieriger)

* _{wenn die Saiten gleich lang sind. Andernfalls wird false zurückgegeben, nur weil die Datensätze unterschiedlich lang sind}

Haskell, 45 41 Bytes

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

Rückgabe Trueoder FalsezB "ESTATE" ! "DUELED"-> True.

Verwendet die Map-Char-To-First-Index-Methode, wie sie in vielen anderen Antworten verwendet wird. Assoziationslisten sind praktisch, weil frühere Einträge Trumpf sind. "aba"wird [(a,1),(b,2),(a,3)]wo lookupimmer geholt a-> 1.

Edit: @Mauris hat 4 Bytes zum Speichern gefunden.

Brainfuck, 169 168 162 144 140 131 130

Kompatibel mit Alex Pankratovs BFF (Brainfuck-Interpreter für SPOJ und Ideone) und Thomas Corts BFI (für Anarchy Golf).

Die erwartete Eingabe besteht aus zwei durch ein Tabulatorzeichen getrennten Zeichenfolgen ohne Zeilenumbruch nach der zweiten Zeichenfolge. Die Ausgabe erfolgt 1für Isomorphe und 0Nicht-Isomorphe. Dies ist praktisch, um die Ergebnisse visuell zu überprüfen, obwohl dies nicht die kürzeste Option ist. ( Update: kürzere Version mit \x01und \x00als Ausgabe und \x00als Trennzeichen am Ende der Antwort.)

Demonstration auf ideone.

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

Dieses Problem erweist sich für Brainfuck als sehr schön.

Die Grundidee bei der Indizierung besteht darin, vom Ende des aktuellen Zeichenfolgepräfixes aus rückwärts voranzugehen. Wenn das Zeichen noch nicht vorgekommen ist, können wir die Länge des Zeichenfolgepräfixes verwenden. Zum Beispiel:

STATES
123255

Die Indizierung im Code unterscheidet sich zwar geringfügig, verwendet jedoch dasselbe Prinzip.

Das Speicherlayout ist in 5er-Blöcken:

0 0 0 0 0 0 c 0 i p 0 c 0 i p 0 c 0 i p 0 0 0 0

csteht für Zeichen, ifür Index und pfür Vorheriges (Index). Wenn der erste String verarbeitet wird, sind alle pSlots Null. Die Zelle links von enthält ceine Kopie des aktuellen Zeichens, dessen Index wir suchen. In der Zelle links neben dem aktuellen iWert befindet sich ein -1Symbol für eine einfache Zeigernavigation.

Es gibt viele Bedingungen, die sorgfältig geprüft werden müssen. Am Ende überprüfen wir die Isomorphen durch Vergleichen der (i,p)Paare und erreichen den Cluster von Nullzellen links vom äußersten linken (i,p)Paar genau dann, wenn die Zeichenfolgen Isomorphen sind. Hier ist eine kommentierte Version des Codes, um das Verfolgen zu erleichtern:

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

Aktualisieren:

Hier ist eine Version, die \x01für Isomorphe und \x00für Nicht-Isomorphe gedruckt wird . Dies ist wahrscheinlich eine genauere Interpretation von Truthy and Falsey für Brainfuck, aufgrund der Art [und der ]Arbeitsweise. Der einzige Unterschied ist ganz am Ende.

Zusätzlich: Jetzt \x00als Trennzeichen verwenden, um 10 Bytes zu sparen.

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

JavaScript (ES6), 62

Verwenden einer Aux-Funktion h, die jedes Wort einem Array zuordnet, das die Position jedes Buchstabens im Wort enthält, zum Beispiel: PASS -> [1,2,3,3]. Geben Sie true zurück, wenn die hangewendete Funktion für beide Wörter dasselbe Ergebnis liefert.

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

Entgolft:

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 ist eine Funktion f, die zwei Argumente akzeptiert und trueoder zurückgibt false.

Erläuterung:

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

Karten jedes Zeichen sund tseine Lage und prüft auf Gleichheit.

Erweitert:

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

Nimmt Eingaben in folgender Form vor:

"ESTATE", "DUELED"

Ist dies nicht akzeptabel, beträgt der folgende Code 10 Byte:

qFmmxdkd.z

und benutzt dieses Eingabeformular:

ESTATE
DUELED

Verwendet den Index von char in der Zeichenfolgendarstellung.

Matlab, 50 Bytes

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

Die Funktion ist als anonym definiert, um Platz zu sparen.

Beispiel:

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

Oktave, 26 Bytes

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

05AB1E , 6 Bytes

εæδË}Ë

Probieren Sie es online!

Nimmt Eingaben als Liste: ['ESTATE', 'DUELED']

Erklärungen:

    εæδË}Ë   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 dank ngns hinweis.

Anonyme implizite Präfixfunktion, die eine Liste von zwei Zeichenfolgen als Argument verwendet.

≡.⍳⍨

Probieren Sie es online!

Dies ist ein inneres Produkt, aber anstelle des Üblichen +und ×es verwendet

≡ Identität

. und

⍳ der ɩ ndex (das erste Vorkommen jedes Elements)

⍨ mit der gesamten aus zwei Elementen bestehenden Liste von Wörtern, die als beide Argumente verwendet werden

Wenn wir die Wörter Aund nennen B, können wir die vorherige Lösung wie folgt ableiten:

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

Vorherige Lösung

Anonyme implizite Präfixfunktion, die eine Liste von zwei Zeichenfolgen als Argument verwendet.

≡/⍳⍨¨

Probieren Sie es online!

≡ Identität

/ über

⍳ der ɩ ndex (das erste Vorkommen jedes Elements…)

⍨ Selfie (… an sich)

¨ von jedem

Mathematica, 46 Bytes

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

Ruby, 50 Bytes

30 Bytes kürzerer Ruby-Code. Bevor ich mir die Lösungen anschaute, prüfte ich für jedes Zeichen beider Zeichenketten, ob der Index des ersten Auftretens des Zeichens übereinstimmt. dh transformiert einen String in seine normalisierte Form 01121usw. und vergleicht diese.

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

Testfälle auf Ideone Als zusätzlicher Bonus wird die Code-Hervorhebung von Ideone aufgehoben.

Schale , 5 Bytes

¤=´×=

Probieren Sie es online!

Erläuterung

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

Betreff sollte zwei durch Leerzeichen getrennte Wörter sein, wie im OP. Hier ist eine flüchtige Erklärung:

Für jeden Buchstaben X im ersten Wort:

Schauen Sie vorwärts zum zweiten Wort und setzen Sie die Referenzen zurück, um sich daran zu erinnern, wie weit wir entfernt sind, sowie den Buchstaben Y im zweiten Wort, der X entspricht.

Für jeden Buchstaben Z nach der aktuellen Position im ersten Wort:

Stellen Sie ähnliche Rückverweise wie oben her.

Suchen Sie im zweiten Wort nach dem entsprechenden Buchstaben und prüfen Sie, ob Z = X und dann ein Y übereinstimmen. Anderenfalls stimmen Sie mit einem Buchstaben überein, der nicht Y ist.

Diese Iteration kann enden, wenn wir bis zum vorletzten Buchstaben im ersten Wort übereinstimmen. Da zu diesem Zeitpunkt keine weitere Validierung erforderlich ist, muss lediglich geprüft werden, ob die Wörter gleich lang sind (die Rückreferenz, die akkumulierende Teilzeichenfolgen des zweiten Wortes enthält, steht immer 1 Buchstabe dahinter).

Ruby, 31 Bytes

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

Ein Proc, der ein Array von Zeichenfolgen verwendet und prüft, ob diese zueinander isomorph sind. tr s,'a-z'Mit diesen Argumenten wird eine Zeichenfolge normalisiert, sindem jeder Buchstabe durch den n-ten Buchstaben im Alphabet ersetzt wird. Dabei nhandelt es sich um den größten Index, mit dem dieser Buchstabe in der Zeichenfolge angezeigt wird. Zum Beispiel estatewird fbedef, wie es tut 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

Ziemlich groß, aber ich habe noch keine ES5-Version gesehen.

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)

Ersetzt einfach jedes Vorkommen des ersten Buchstabens durch seinen umgekehrten Indexwert. Wiederholt dies für jeden Charakter.

Dies gilt auch für beide Eingaben und für den Vergleich des generierten Musters.

Der Vergleich ist ziemlich hässlich, aber ich möchte kein Array zum Speichern und Vergleichen verwenden.

Perl, 38 Bytes

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

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

Gibt 1 aus, wenn wahr, nichts, wenn falsch.

Common Lisp, 76 Bytes

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

Probieren Sie es online!

C ++, 213 196 162 Bytes

-51 Bytes dank 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;};

Um das Lambda aufzurufen, müssen Sie 2 Argumente vom std::stringDatentyp übergeben

Code zum Testen:

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

für den Code, einschließlich Tests iostreamund stringHeader - Datei ist erforderlich

JavaScript (ES6), 52 51 50 Byte

Diese Version verwendet kein Array-Verständnis und nimmt Eingaben mithilfe der Currying-Syntax entgegen.

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