두 단어가 동일한 문자 반복 패턴을 갖는 경우 이소 형입니다. 예를 들어, 모두 ESTATE와 DUELED패턴을 가지고abcdca

ESTATE
DUELED

abcdca

글자 1과 6이 같기 때문에 글자 3과 5는 같고 더 이상 없습니다. 이것은 또한 단어가 대체 암호와 관련이 있으며 여기서는 일치하는을 의미 E <-> D, S <-> U, T <-> E, A <-> L합니다.

두 단어를 사용하여 동형인지 확인하는 코드를 작성하십시오. 가장 적은 바이트가 이깁니다.

입력 : 대문자의 두 비어 있지 않은 문자열 A..Z. 원하는 경우이 문자열을 두 개의 문자열 모음 또는 구분 기호가있는 단일 문자열로 사용할 수 있습니다.

출력 : 동형 인 쌍에 대해 일관된 Truthy 값 및 일관 되지 않은 Falsey 값 . 길이가 다른 문자열은 결코 동형이 아닌 유효한 입력입니다.

테스트 사례 :

참된:

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 CD

유용한 테스트 사례를 자유롭게 추가하십시오.

리더 보드

다음은 일반 리더 보드와 언어 별 수상자 개요를 생성하는 스택 스 니펫입니다.

답변이 표시되도록하려면 다음 마크 다운 템플릿을 사용하여 헤드 라인으로 답변을 시작하십시오.

# Language Name, N bytes

N제출물의 크기는 어디에 있습니까 ? 당신이 당신의 점수를 향상시킬 경우에, 당신은 할 수 있습니다 를 통해 눈에 띄는에 의해, 헤드 라인에 오래된 점수를 유지한다. 예를 들어 :

# 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 바이트

-:&=

용법

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

설명

• = 인수가 1이면 입력 요소와 그 너브를 비교하는 등가 테이블을 만듭니다.

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

• -:두 개의 인수를 사용하면 ( ==일반적으로하는 것처럼 ) 동등성을 검사합니다 . 이것은 다른 크기의 매트릭스 (또는 다른 유형)에서도 작동합니다.

• f&g두 입력에 각각 g를 적용한 다음 두 결과에 f를 적용 x f&g y == f(g(x), g(y))합니다.

• 우리의 경우 두 평등 테이블을 비교합니다.

여기에서 온라인으로 사용해보십시오.

K, 5 바이트

K에는 유쾌하고 우아한 솔루션이 있습니다!

~/=:'

"group"연산자 (monadic =)는 단어 동 형사상에서 원하는 시그니처를 정확하게 생성합니다. 모양별로 순서대로 그룹화 된 벡터의 각 요소의 인덱스 벡터를 수집합니다.

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

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

한 쌍의 문자열을 벡터로 취하면 각 요소에 그룹을 적용한 =:'다음 ( ~) 깊은 평등 연산자 인 "match"( ) 로 줄여야합니다 .

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

파이썬 2, 41 바이트

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

CJam, 9 바이트

r_f#r_f#=

1단어가 동형인지 아닌지 인쇄 합니다 0.

CJam 통역사 에서 온라인으로 사용해보십시오 .

작동 원리

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.

자바 스크립트, ES7, 62 55 54 52 51 바이트

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

논리는 간단합니다. 두 입력을 해당 문자 인덱스 값으로 변환하고 해당 배열을 문자열로 변환하고 비교합니다.

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

아래 스 니펫을 사용하여 위의 코드를 사용해보십시오.

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

@ edc65 덕분에 2 바이트 절약

배쉬 + 코어 유틸리티, 38

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

우리는 여기서 진실 / 거짓의 일반적인 쉘 아이디어를 사용하고 있습니다-0은 성공 또는 참을 의미하고 0이 아닌 것은 오류 또는 거짓을 의미합니다

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

하스켈, 33 29

편집하다:

이것은 너무 늦었지만 2015 년 3 월에만 전주곡에 추가 된 응용 프로그램을 사용 하여이 개선 사항을 발견했습니다.

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

구 버전:

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

점검 기능은 (%)

이것은 각 문자열마다 "평등 레코드"를 생성하여 작동합니다. 두 개의 인덱스 ij마다 동일한 문자를 가지고 있는지 여부를 기록합니다. 두 인덱스 i, j에 대한 레코드가 항상 같은 위치에 있도록 레코드가 정렬되므로 레코드의 동등성을 확인하면 문자열의 패턴이 같은지 여부가 리턴됩니다.

예를 들어, "ABC"의 동일성 레코드는 [1,0,0,0,1,0,0,0,1](true의 경우 1, false의 경우 0)입니다 True. 인덱스가 자체와 비교되는 위치가 있습니다. 다른 곳은 거짓입니다. (이러한 검사를 건너 뛰는 것이 더 효율적일 수 있지만 golfng 측면에서는 더 어렵습니다)

* _{문자열의 길이가 같은 경우 그렇지 않으면 레코드의 길이가 다르기 때문에 false를 반환합니다.}

하스켈, 45 41 바이트

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

반환 True또는 False, 예를 들면 "ESTATE" ! "DUELED"-> True.

많은 다른 답변에서 볼 수 있듯이 map-char-to-first-index 방법을 사용합니다. 이전 항목이 우선하기 때문에 연결 목록이 유용합니다. 항상 페치하는 위치 "aba"가됩니다 -> .[(a,1),(b,2),(a,3)]lookupa1

편집 : @Mauris는 저장할 4 바이트를 찾았습니다.

브레인 퍽, 169 168 162 144 140 131 130

Alex Pankratov의 bff (SPOJ 및 ideone에서 사용되는 brainfuck 인터프리터) 및 Thomas Cort의 BFI (Anarchy Golf에서 사용 )와 호환 됩니다.

예상되는 입력은 탭으로 구분 된 두 개의 문자열이며 두 번째 문자열 뒤에 줄 바꿈이 없습니다. 출력은 1동형 및 0비 동형에 대한 것이며, 가장 짧은 옵션은 아니지만 결과를 시각적으로 확인하는 데 편리합니다. ( 업데이트 : 짧아 버전 \x01과 \x00출력과 같은 \x00응답의 하단 구분자).

이데온에 대한 데모 .

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

이 문제는 brainfuck에 아주 좋은 것으로 판명되었습니다.

인덱싱의 기본 아이디어는 현재 문자열 접두사 끝에서 뒤로 이동하는 것입니다. 문자가 이전에 발생하지 않은 경우 문자열 접두어의 길이를 사용할 수 있습니다. 예를 들면 다음과 같습니다.

STATES
123255

코드의 인덱싱은 실제로 약간 다르지만 동일한 원칙을 사용합니다.

메모리 레이아웃은 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

c문자, i색인 및 p이전 (색인)을 나타냅니다. 첫 번째 문자열을 처리 할 때 모든 p슬롯이 0입니다. 왼쪽의 셀 c은 색인을 찾으려고하는 현재 문자의 사본을 보유하는 데 사용됩니다. 전류 왼쪽의 셀 i은 -1포인터 탐색을 쉽게하기 위해 사용됩니다 .

신중하게 고려해야 할 조건이 많이 있습니다. 마지막으로 (i,p)쌍 을 비교하여 동형을 확인 (i,p)하고 문자열이 동형 인 경우에만 가장 왼쪽 쌍 의 왼쪽에 0 개의 셀 클러스터에 도달합니다 . 다음은 코드를 더 쉽게 따라갈 수 있도록 주석 처리 된 버전입니다.

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

최신 정보:

다음은 \x01동형 및 \x00비 동형 을 인쇄하는 버전입니다 . 이것은 방법 [과 ]작업 때문에 brainfuck에 대한 Truthy와 Falsey의 더 정확한 해석 일 것입니다. 유일한 차이점은 맨 끝에 있습니다.

추가 : 이제 \x0010 바이트를 절약하기 위해 분리 자로 사용 합니다.

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

자바 스크립트 (ES6), 62

h각 단어를 단어의 각 문자 위치를 포함하는 배열에 매핑 하는 보조 기능 사용 ( 예 : PASS-> [1,2,3,3]). 함수 h가 두 단어를 적용하면 같은 결과가 나오면 true를 반환합니다 .

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>

제 78 화

function(x,y)identical((g=function(z)match(a<-strsplit(z,"")[[1]],a))(x),g(y))

골퍼 해제 :

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

루비, 83 바이트

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

이 함수의 f두 개의 인수를 반환한다 true또는 false.

설명:

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

자바, 107

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

의 각 문자에 매핑 s및 t위치에, 그리고 평등에 대한 확인합니다.

넓히는:

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

파이썬 3, 85 바이트

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 바이트

qFmmxdkdQ

다음과 같은 형식으로 입력합니다.

"ESTATE", "DUELED"

허용되지 않으면 다음 코드는 10 바이트입니다.

qFmmxdkd.z

이 입력 양식을 사용합니다.

ESTATE
DUELED

문자열 표현에 char 색인을 사용합니다.

Matlab, 50 바이트

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

이 기능은 공간을 절약하기 위해 익명으로 정의됩니다.

예:

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

옥타브, 26 바이트

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

05AB1E , 6 바이트

εæδË}Ë

온라인으로 사용해보십시오!

입력을 목록으로 취합니다. ['ESTATE', 'DUELED']

설명 :

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

ngn의 힌트 덕분에 -1입니다.

두 문자열의 목록을 인수로 취하는 익명의 암묵적 접두사 함수.

≡.⍳⍨

온라인으로 사용해보십시오!

이것은 내적이지만, 대신에 평소 +와 ×는 사용

≡ 동일성

. 과

⍳ɩ의 ndex (각 요소의 첫 번째 발생)

⍨ 두 인자로 사용되는 단어의 전체 두 요소로 된 목록

우리가 단어를 호출하는 경우 A와 B다음과 같이 우리는 이전 솔루션을 유도 할 수있다 :

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

이전 솔루션

두 문자열의 목록을 인수로 취하는 익명의 암묵적 접두사 함수.

≡/⍳⍨¨

온라인으로 사용해보십시오!

≡ 동일성

/ 건너서

⍳ɩ의 ndex (각 요소의 첫 번째 발생 ...)

⍨ 셀카 (… 자체)

¨ 각각의

수학, 46 바이트

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

루비, 50 바이트

30 바이트 더 짧은 루비 코드. 솔루션을 살펴보기 전에 작성하여 두 문자열의 각 문자가 해당 문자의 첫 번째 발생 색인과 일치하는지 확인합니다. 즉. 문자열을 정규화 된 형식 01121등으로 변환 하고 비교합니다.

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

이데온 에 대한 테스트 사례 추가 보너스로서, 이로 인해 이데온의 코드 하이라이트가 깨집니다.

껍질 , 5 바이트

¤=´×=

온라인으로 사용해보십시오!

설명

       -- 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 바이트

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

OP에서와 같이 주제는 공백으로 구분 된 두 단어 여야합니다. 간단한 설명은 다음과 같습니다.

첫 번째 단어의 각 문자 X에 대해 :

두 번째 단어를 미리 살펴보고 X에 해당하는 두 번째 단어의 문자 Y뿐만 아니라 우리가 얼마나 멀리 있는지를 기억하기 위해 참조를 다시 설정하십시오.

첫 글자에서 현재 위치를 지나는 각 문자 Z에 대해 :

위와 유사한 역 참조를 설정하십시오.

두 번째 단어에서 해당 문자를 미리보고 Z = X인지 확인한 다음 Y와 일치하는지 확인하고, 그렇지 않으면 Y가 아닌 문자와 일치시킵니다.

이 반복은 첫 단어에서 두 번째 문자까지 일치하면 끝날 수 있습니다. 이 시점에서, 추가 검증이 필요하지 않기 때문에 남아있는 것은 단어의 길이가 같은지 테스트하는 것입니다 (두 번째 단어의 누적 서브 스트링을 포함하는 역 참조는 항상 1 글자 뒤에 있음).

루비, 31 바이트

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

문자열 배열을 가져와 서로 동형인지 검사하는 Proc. tr s,'a-z'이러한 인수를 사용하면 s각 문자를 알파벳의 n 번째 문자로 바꾸어 문자열 을 정규화합니다 . 여기서 n해당 문자가 문자열에 나타나는 가장 큰 색인입니다. 예를 들어, estate이된다 fbedef처럼, dueled.

코브라, 72 바이트

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

자바 스크립트 (ES5), 142 98

꽤 큰 것이지만 아직 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)

첫 번째 문자의 모든 항목을 역 인덱스 값으로 대체합니다. 모든 캐릭터에 대해 이것을 반복합니다.

두 입력 모두에 대해 동일하게 수행되며 생성 된 패턴을 비교합니다.

비교는 추악하지만 배열을 사용하여 저장하고 비교하고 싶지는 않습니다.

펄, 38 바이트

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

다음으로 실행 perl -E '($_,$a)=@ARGV;eval"y/$_/$a/";say$_~~$a' RAMBUNCTIOUSLY THERMODYNAMICS

true이면 1을 인쇄하고 false이면 아무것도 인쇄하지 않습니다.

공통 리스프, 76 바이트

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

온라인으로 사용해보십시오!

C ++, 213 (196) 162 바이트

Zacharý 덕분에 -51 바이트

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

람다를 호출하려면 std::string데이터 유형 인 2 개의 인수를 전달해야 합니다

테스트 코드 :

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

, 테스트를 포함하여 코드 iostream와 string헤더 파일이 필요합니다

자바 스크립트 (ES6), 52 51 50 바이트

이 버전은 배열 이해를 사용하지 않으며 카레 구문을 사용하여 입력을받습니다.

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