Dwa słowa są izomorfami, jeśli mają ten sam wzór powtarzania liter. Na przykład, zarówno ESTATEi DUELEDmają wzórabcdca

ESTATE
DUELED

abcdca

ponieważ litery 1 i 6 są takie same, litery 3 i 5 są takie same i nic więcej. Oznacza to również, że słowa są powiązane szyfrem podstawienia, tutaj z dopasowaniem E <-> D, S <-> U, T <-> E, A <-> L.

Napisz kod, który wymaga dwóch słów i sprawdza, czy są to izomorfy. Wygrywa najmniej bajtów.

Dane wejściowe: dwa niepuste ciągi wielkich liter A..Z. Jeśli chcesz, możesz wziąć je jako zbiór dwóch ciągów lub jako pojedynczy ciąg z separatorem.

Dane wyjściowe: spójna wartość prawdy dla par, które są izomorfami , i spójna wartość Falsey, jeśli nie są. Ciągi o różnych długościach są poprawnymi danymi wejściowymi, które nigdy nie są izomorfami.

Przypadki testowe:

Prawdziwe:

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

Fałszywe:

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

Dodaj więcej przypadków testowych, które okażą się przydatne.

Tabela liderów

Oto fragment kodu, który pozwala wygenerować zarówno zwykłą tabelę wyników, jak i przegląd zwycięzców według języka.

Aby upewnić się, że twoja odpowiedź się pojawi, zacznij od nagłówka, korzystając z następującego szablonu Markdown:

# Language Name, N bytes

gdzie Njest rozmiar twojego zgłoszenia. Jeśli poprawić swój wynik, to może zachować stare porachunki w nagłówku, uderzając je przez. Na przykład:

# 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 bajty

-:&=

Stosowanie

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

Wyjaśnienie

• = z 1 argumentem tworzy tabelę równości porównującą elementy wejścia i jego wierzchołka.

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

• -:z 2 argumentami sprawdza ich równość (jak ==zwykle robi). Działa to również dla matryc o różnych rozmiarach (lub nawet różnych typach).

• f&gstosuje g do obu danych wejściowych oddzielnie, a następnie stosuje f do obu wyników razem tak x f&g y == f(g(x), g(y)).

• W naszym przypadku porównujemy dwie tabele równości.

Wypróbuj online tutaj.

K, 5 bajtów

To zachwycająco eleganckie rozwiązanie w K!

~/=:'

Operator „grupowy” (monadyczny =) tworzy dokładnie taki podpis, jaki chcemy w przypadku izomorfizmu słów; zbieranie wektorów indeksów każdego elementu wektora, z grupami uporządkowanymi według wyglądu:

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

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

Biorąc parę ciągów za wektor, musimy po prostu zastosować grupę do każdego elementu ( =:'), a następnie zmniejszyć za pomocą „match” ( ~), operatora głębokiej równości:

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

Python 2, 41 bajtów

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

CJam, 9 bajtów

r_f#r_f#=

Drukuje, 1jeśli słowa są izomorfami, a 0jeśli nie są.

Wypróbuj online w interpretatorze CJam .

Jak to działa

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 bajtów

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

Logika jest prosta. Po prostu przekształcam oba dane wejściowe na odpowiadające im wartości indeksu znaków, przekształcam tablicę w ciąg znaków i porównuję.

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

Wypróbuj powyższy kod, korzystając z fragmentu poniżej.

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 bajty zapisane dzięki @ edc65

Bash + coreutils, 38

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

Zauważ, że używamy tutaj zwykłej idei powłoki - prawda / fałsz - zero oznacza SUKCES lub PRAWDA, a niezerowa oznacza błąd lub FAŁSZ:

$ 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

EDYTOWAĆ:

jest o wiele za późno, ale zauważyłem tę poprawę za pomocą aplikacji, które zostały dodane w celu preludium dopiero w marcu 2015 roku.

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

Stara wersja:

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

funkcja sprawdzania to (%)

działa to poprzez generowanie dla każdego łańcucha „rekordu równości”: dla każdego z dwóch wskaźników ij rejestruje, czy mają one równe znaki. rekord jest uporządkowany w taki sposób, że rekord dla dwóch indeksów i, j jest zawsze w tym samym miejscu *, a zatem sprawdzenie równości rekordów zwróci, czy łańcuchy będą miały ten sam wzorzec.

na przykład zapis równości „ABC” wynosi [1,0,0,0,1,0,0,0,1](1 dla prawdy, 0 dla fałszu) - tam Truegdzie jakikolwiek indeks jest porównywany z samym sobą. gdziekolwiek indziej jest fałszem. (pomijanie tych kontroli może być bardziej wydajne, ale trudniejsze pod względem golfowym)

* _{jeśli struny są tej samej długości. w przeciwnym razie zwraca false tylko dlatego, że rekordy mają różną długość}

Haskell, 45 41 bajtów

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

Zwraca Truelub Falsenp. "ESTATE" ! "DUELED"-> True.

Używa metody map-char-to-first-index, jak widać w wielu innych odpowiedziach. Przydają się listy skojarzeń, ponieważ wcześniejsze wpisy są atutem. "aba"staje się [(a,1),(b,2),(a,3)]tam, gdzie lookupzawsze pobiera a-> 1.

Edycja: @ Mauris znalazł 4 bajty do zapisania.

Brainfuck, 169 168 162 144 140 131 130

Kompatybilny z bff Alexa Pankratova (interpreter pieprzenia mózgu używany na SPOJ i ideone) oraz BFI Thomasa Corta (używany na Anarchy Golf).

Oczekiwanym wejściem są dwa ciągi znaków oddzielone tabulatorem, bez nowego wiersza po drugim ciągu. Dane wyjściowe dotyczą 1izomorfów i 0nieizomorfów, co jest wygodne do wizualnego sprawdzania wyników, chociaż nie jest to najkrótsza opcja. ( Aktualizacja: krótsza wersja z wyjściem \x01i \x00jako wyjście oraz \x00jako separator u dołu odpowiedzi).

Demonstracja na ideonie.

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

Ten problem okazuje się bardzo miły dla pieprzenia mózgu.

Podstawową ideą indeksowania jest cofanie się od końca bieżącego prefiksu łańcucha. Jeśli znak nie występował wcześniej, możemy wziąć długość prefiksu łańcucha. Na przykład:

STATES
123255

Indeksowanie w kodzie jest nieco inne, ale wykorzystuje tę samą zasadę.

Układ pamięci jest w blokach po 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

coznacza znak, iindeks i ppoprzedni (indeks). Podczas przetwarzania pierwszego ciągu wszystkie pszczeliny mają wartość zero. Komórka po lewej stronie csłuży do przechowywania kopii bieżącego znaku, dla którego próbujemy znaleźć indeks. Komórka po lewej stronie prądu isłuży do -1łatwej nawigacji wskaźnikiem.

Istnieje wiele warunków, które należy dokładnie rozważyć. Na koniec sprawdzamy izomorfy, porównując (i,p)pary, i docieramy do klastra zerowych komórek na lewo od lewej skrajnej (i,p)pary tylko wtedy, gdy ciągi są izomorfami. Oto skomentowana wersja kodu, aby ułatwić śledzenie:

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

Aktualizacja:

Oto wersja, która drukuje \x01dla izomorfów i \x00dla nie-izomorfów. Jest to prawdopodobnie dokładniejsza interpretacja Truthy i Falsey dla pieprzenia mózgu, ze względu na sposób [i ]pracę. Jedyna różnica jest na samym końcu.

Dodatkowe: Teraz używa \x00jako separatora, aby zapisać 10 bajtów.

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

JavaScript (ES6), 62

Korzystanie z funkcji Aux, hktóra mapuje każde słowo na tablicę zawierającą pozycję każdej litery w słowie, na przykład: PASS -> [1,2,3,3]. Zwraca wartość true, jeśli hzastosowana funkcja dwóch słów daje ten sam wynik.

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

Gra w golfa:

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

Rubinowy, 83 bajty

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

Jest to funkcja, fktóra pobiera dwa argumenty i zwraca truelub false.

Wyjaśnienie:

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

Mapuje każdą postać si tjej lokalizację oraz sprawdza równość.

Rozszerzony:

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 bajtów

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 bajtów

qFmmxdkdQ

Pobiera dane w następującej formie:

"ESTATE", "DUELED"

Jeśli nie jest to możliwe, następujący kod ma 10 bajtów:

qFmmxdkd.z

i używa tego formularza wejściowego:

ESTATE
DUELED

Używa indeksu char w reprezentacji ciągu.

Matlab, 50 bajtów

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

Funkcja jest zdefiniowana jako anonimowa w celu zaoszczędzenia miejsca.

Przykład:

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

Oktawa, 26 bajtów

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

05AB1E , 6 bajtów

εæδË}Ë

Wypróbuj online!

Pobiera dane wejściowe jako listę: ['ESTATE', 'DUELED']

Objaśnienia:

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

-1 dzięki podpowiedzi ngn.

Anonimowa funkcja ukrytego przedrostka, która przyjmuje jako argument listę dwóch ciągów.

≡.⍳⍨

Wypróbuj online!

To jest produkt wewnętrzny, ale zamiast zwykłego +i ×używa

≡ identyczność

. i

⍳ɩ ndex (pierwsze wystąpienie każdego elementu)

⍨ z całą dwuelementową listą słów użytych jako oba argumenty

Jeśli wywołamy te słowa Ai B, możemy wyprowadzić poprzednie rozwiązanie w następujący sposób:

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

Poprzednie rozwiązanie

Anonimowa funkcja ukrytego przedrostka, która przyjmuje jako argument listę dwóch ciągów.

≡/⍳⍨¨

Wypróbuj online!

≡ identyczność

/ przez

⍳ɩ ndex (pierwsze wystąpienie każdego elementu ...)

⍨ selfie (… samo w sobie)

¨ każdego

Mathematica, 46 bajtów

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

Rubinowy, 50 bajtów

30 bajtów krótszego kodu ruby. Napisane przed przyjrzeniem się rozwiązaniom, sprawdzają dla każdego znaku obu ciągów, czy indeks pierwszego wystąpienia tego znaku pasuje; to znaczy. przekształca ciąg znaków w znormalizowaną formę 01121itp. i porównuje je.

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

Testowanie przypadków na ideone Jako dodatkowy bonus łamie to wyróżnianie kodu ideone.

Łuska , 5 bajtów

¤=´×=

Wypróbuj online!

Wyjaśnienie

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

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

Temat powinien składać się z dwóch słów oddzielonych spacją, tak jak w OP. Oto pobieżne wyjaśnienie:

Dla każdej litery X w pierwszym słowie:

Spójrz w przyszłość na drugie słowo i ustal odniesienia, aby przypomnieć sobie, jak daleko jesteśmy, a także literę Y w drugim słowie odpowiadającym X.

Dla każdej litery Z powyżej bieżącej pozycji w pierwszym słowie:

Ustal podobne referencje jak powyżej.

Spójrz w przód na odpowiednią literę w drugim słowie i sprawdź, czy Z = X, a następnie dopasuj Y, w przeciwnym razie dopasuj literę, która nie jest Y.

Ta iteracja może zakończyć się, gdy dopasujemy ją do przedostatniej litery w pierwszym słowie. W tym momencie, ponieważ nie jest konieczne dalsze sprawdzanie poprawności, pozostaje tylko sprawdzenie, czy słowa mają taką samą długość (odnośnik tylny zawierający nagromadzone podłańcuchy drugiego słowa jest zawsze za jedną literą).

Ruby, 31 bajtów

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

Proc, który pobiera tablicę ciągów znaków i sprawdza, czy są one względem siebie izomorficzne. tr s,'a-z'z tymi argumentami normalizuje ciąg s, zastępując każdą literę n-tą literą w alfabecie, gdzie njest największym indeksem, z którym ta litera pojawia się w ciągu. Na przykład estatestaje się fbedef, podobnie jak dueled.

Kobra, 72 bajty

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

JavaScript (ES5), 142 98

Całkiem spory, ale jeszcze nie widziałem wersji 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)

Po prostu zastępuje każde wystąpienie pierwszej litery jego odwrotną wartością indeksu. Powtarza to dla każdej postaci.

Robi to samo dla obu wejść i porównuje wygenerowany wzór.

Porównanie jest dość brzydkie, ale nie chcę używać tablicy do przechowywania i porównywania.

Perl, 38 bajtów

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

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

Drukuje 1 jeśli prawda, nic jeśli fałsz.

Common Lisp, 76 bajtów

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

Wypróbuj online!

C ++, 213 196 162 bajtów

-51 bajtów dzięki Zacharýmu

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

Aby wywołać lambda, musisz przekazać 2 argumenty std::stringtypu danych

Kod do przetestowania:

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

dla kodu testującego, w tym iostreami stringpliku nagłówkowego jest wymagany

JavaScript (ES6), 52 51 50 bajtów

Ta wersja nie korzysta ze zrozumienia tablic i pobiera dane wejściowe przy użyciu składni curry.

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

const isomorph = a=>b=>(f=x=>0+[...x].map(c=>x.search(c)))(a)==f(b);
const tests = [
  {input: ["ESTATE", "DUELED"], expected: true},
  {input: ["DUELED", "ESTATE"], expected: true},
  {input: ["XXX", "YYY"], expected: true},
  {input: ["CBAABC", "DEFFED"], expected: true},
  {input: ["RAMBUNCTIOUSLY", "THERMODYNAMICS"], expected: true},
  {input: ["DISCRIMINATIVE", "SIMPLIFICATION"], expected: true},
  {input: ["SEE", "SAW"], expected: false},
  {input: ["ANTS", "PANTS"], expected: false},
  {input: ["BANANA", "SERENE"], expected: false},
  {input: ["BANANA", "SENSES"], expected: false},
  {input: ["AB", "CC"], expected: false},
  {input: ["XXY", "XYY"], expected: false},
  {input: ["ABCBACCBA", "ABCBACCAB"], expected: false},
  {input: ["ABAB", "CD"], expected: false}
];

for(const { input: [str1, str2], expected } of tests) {
  console.log(`isomorph("${str1}")("${str2}") = ${isomorph(str1)(str2)}, expected = ${expected}`);
}