Два слова являются изоморфами, если они имеют одинаковый шаблон повторения букв. Например, оба 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

Не стесняйтесь добавлять больше тестов, которые вы считаете полезными.

Leaderboard

Вот фрагмент стека, который генерирует как регулярную таблицу лидеров, так и обзор победителей по языкам.

Чтобы убедиться, что ваш ответ обнаружен, начните его с заголовка, используя следующий шаблон уценки:

# 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
  

• -:с 2 аргументами проверяет их равенство (как ==обычно делает). Это работает и для матриц разного размера (или даже разных типов).

• f&gприменяет g к обоим входным данным по отдельности, а затем применяет f к двум результатам вместе x f&g y == f(g(x), g(y)).

• Итак, в нашем случае мы сравниваем две таблицы равенства.

Попробуйте это онлайн здесь.

К 5 байт

Это восхитительно элегантное решение в K!

~/=:'

Оператор «группа» (монадический =) создает именно ту сигнатуру, которую мы хотим для изоморфизма слова; сбор векторов индексов каждого элемента вектора с группами, упорядоченными по внешнему виду:

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

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

Взяв пару строк в качестве вектора, нам просто нужно применить группу к каждому элементу ( =:'), а затем уменьшить с помощью «match» ( ~), оператора глубокого равенства:

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

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

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

2 байта сохранены благодаря @ edc65

Bash + coreutils, 38

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

Обратите внимание, что здесь мы используем обычную идею оболочки истина / ложь - ноль означает УСПЕХ или ИСТИНА, а ненулевое значение означает ошибку или ЛОЖЬ:

$ 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 года.

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](1 для истины, 0 для ложной) - там, Trueгде любой индекс сравнивается с самим собой. где-нибудь еще является ложным. (пропуск этих проверок может быть более эффективным, но сложнее с точки зрения игры в гольф)

* _{если строки имеют одинаковую длину. в противном случае он возвращает false только потому, что записи имеют разную длину}

Haskell, 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)]там, где lookupвсегда выбирает a-> 1.

Изменить: @Mauris нашел 4 байта для сохранения.

Brainfuck, 169 168 162 144 140 131 130

Совместим с bff Алекса Панкратова (интерпретатор brainfuck, используемый на SPOJ и ideone) и BFI Томаса Корта (используется на Anarchy Golf).

Ожидаемый ввод - две строки, разделенные табуляцией, без новой строки после второй строки. Вывод предназначен 1для изоморфов и 0неизоморф, что удобно для визуальной проверки результатов, хотя и не является самым коротким вариантом. ( Обновление: сокращенный вариант с \x01и в \x00качестве выходного сигнала , и в \x00качестве разделителя в нижней части ответа.)

Демонстрация на идеоне.

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

Эта проблема, оказывается, очень хороша для мозгового срыва.

Основная идея индексации - вернуться назад от конца текущего строкового префикса. Если символ ранее не встречался, мы можем взять длину префикса строки. Например:

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слоты равны нулю. Ячейка слева от cсодержит копию текущего символа, индекс которого мы пытаемся найти. Ячейка слева от текущего iиспользуется -1для удобной навигации по указателю.

Есть много условий, которые необходимо тщательно продумать. В конце мы проверяем изоморфы, сравнивая (i,p)пары, и достигаем кластера с нулевыми ячейками слева от самой левой (i,p)пары тогда и только тогда, когда строки являются изоморфами. Вот закомментированная версия кода, чтобы было легче следовать:

,+
[                       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неизоморф. Это, пожалуй, более точная интерпретация Истины и Фолси для мозгового срыва, из-за способа [и ]работы. Разница только в самом конце.

Дополнительно: теперь используется \x00в качестве разделителя для сохранения 10 байтов.

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

JavaScript (ES6), 62

Использование вспомогательной функции, hкоторая отображает каждое слово в массив, содержащий положение каждой буквы в слове, например: PASS -> [1,2,3,3]. Вернуть true, если функция hприменила два слова и даст одинаковый результат.

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

Де-golfed:

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его местоположение и проверяет равенство.

Expanded:

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 байт

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 (Дьялог) , 5 4 байта

-1 благодаря подсказке ngn.

Функция анонимного молчаливого префикса, которая принимает список из двух строк в качестве аргумента.

≡.⍳⍨

Попробуйте онлайн!

Это внутренний продукт, но вместо обычного +и ×он использует

≡ одинаковости

. а также

⍳ɩ NDEX (первое вхождение каждого элемента)

⍨ со всем двухэлементным списком слов, используемых в качестве обоих аргументов

Если мы назовем слова Aи B, то мы можем вывести предыдущее решение следующим образом:

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

Предыдущее решение

Функция анонимного молчаливого префикса, которая принимает список из двух строк в качестве аргумента.

≡/⍳⍨¨

Попробуйте онлайн!

≡ одинаковости

/ через

⍳ɩ NDEX (первое вхождение каждого элемента ...)

⍨ селфи (… сама по себе)

¨ каждого

Mathematica, 46 байтов

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

Рубин, 50 байтов

30 байтов короче код рубина. Написанный до того, как я взглянул на решения, проверяет для каждого символа обеих строк, совпадает ли индекс первого вхождения этого символа; то есть. преобразует строку в ее нормализованную форму и 01121т. д. и сравнивает их.

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

Тестовые случаи на ideone В качестве дополнительного бонуса это нарушает подсветку кода ideone.

Шелуха , 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 в первом слове:

Посмотрите вперед на второе слово и установите обратные ссылки, чтобы вспомнить, как далеко мы продвинулись, а также букву Y во втором слове, соответствующем X.

Для каждой буквы 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)

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

Просто заменяет каждое вхождение первой буквы на обратное значение индекса. Повторяет это для каждого персонажа.

Он делает то же самое для обоих входов и сравнивает сгенерированный шаблон.

Сравнение довольно уродливо, но я не хочу использовать массив для хранения и сравнения.

Perl, 38 байт

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

Беги как perl -E '($_,$a)=@ARGV;eval"y/$_/$a/";say$_~~$a' RAMBUNCTIOUSLY THERMODYNAMICS

Печатает 1, если истина, ничего, если ложь.

Common Lisp, 76 байт

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

Попробуйте онлайн!

C ++, 213 196 162 байта

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

Чтобы вызвать лямбду, вам нужно передать 2 аргумента std::stringтипа данных

Код для тестирования:

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заголовочный файл

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