Проверьте, являются ли слова изоморфами

63

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

XNOR
источник
Являются ли длины двух входов одинаковыми?
Оптимизатор
@ Оптимизатор Нет, длина может быть разной.
xnor
@Jakube Нет, ваш код теоретически должен работать с входами любой длины. Это нормально, хотя, если огромные входные данные терпят неудачу на оборудовании из-за проблем как переполнение памяти или глубина стека
xnor
Хорошо, тогда я удалю свой ответ.
Якуб
Важный контрольный пример: ABAB CD(для zip-подобных подходов)
Sp3000

Ответы:

95

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

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

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

randomra
источник
2
Интересный и элегантный подход. Без эквивалента &, вероятно, самое близкое, что вы могли бы сделать в K ~/{x=/:x}', это намного дольше.
JohnE
17
Иисус. Это должен быть претендент на зал славы Codegolf.
Брайан Гордон
Ничего себе, не ожидал, что классификация =будет иметь какое-либо иное использование, чем для подсчета случаев.
миль
37

К 5 байт

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

~/=:'

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

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

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

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

  ~/=:'("RAMBUNCTIOUSLY";"THERMODYNAMICS")
1
  ~/=:'("BANANA";"SERENE")
0
Johne
источник
15

Python 2, 41 байт

f=lambda a,b:map(a.find,a)==map(b.find,b)
ygramul
источник
4
Это было решение, которое вдохновило меня на создание этой задачи!
xnor
12

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.
Деннис
источник
10

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

Попробуйте приведенный выше код, используя фрагмент ниже.

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

оптимизатор
источник
7
+1, попробовал, работает хорошо. +0вместо +""?
edc65
1
@ edc65 вау, приведение типов WTF
Оптимизатор
1
Я только сейчас понял, что строки «A-Z», так что вы можете безопасно использовать поиск вместо indexOf и сократить еще 1 байт.
edc65
Массивы не были вырезаны из es7 в конце концов? где работает этот код? Я думаю, что только в
Mozilla
8

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
$ 
Цифровая травма
источник
8

Хаскелл, 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 только потому, что записи имеют разную длину

гордый хаскеллер
источник
6

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 байта для сохранения.

Ними
источник
Вы можете заменить (flip lookup$zip l[1..])на (`lookup`zip l[1..]).
Линн
6

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

+
[
  -
  >+<
  [
    >>-<
    [
      <
      [
        >+<
        <<<<-<+>>>>>-
      ]
      ++[->+]
      ->+[+<-]
      >[<<<<]
      <
    ]
    <[>+<-]
    +[->+]
    <->
    >>>
  ]
  >
  [
    [[-]<<<<<]
    >>>>
  ]
  <,+
]
>>>+>+
[
  [<->-]
  <[>>>>>]
  <<<<
]
-<[>]
<+.
Митч Шварц
источник
5

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>

edc65
источник
1
Иногда просто короче;)
Оптимизатор
5

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))
flodel
источник
бей меня к этому! (+1)
теневик
Я думаю, что all( (g=...)(x)==g(y))короче identical...
Джузеппе
5

Рубин, 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]}
Дверная ручка
источник
1
Это должно сэкономить 4 байта:, t=->x{z=?`;x.chars.to_a.uniq.map{|c|x.gsub!(c,z.succ!)};x};f=->a,b{t[a]==t[b]}и вы можете уменьшить его до 68, если вы используете хеш для замены:t=->x{h={};i=9;x.gsub!(/./){|c|h[c]||h[c]=i+=1}};f=->a,b{t[a]==t[b]}
blutorange
5

Ява, 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"));
    }
}
Ypnypn
источник
Я не думаю, что это будет работать правильно, если строки имеют разную длину.
JohnE
@JohnE Да, это так.
Ypnypn
Ах, хорошо, я думаю, что «расширенная» версия вводит в заблуждение.
JohnE
4

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)
Номер один
источник
Где вход / выход на этом?
DJMcMayhem
@DJMcMayhem g- основная функция, fпомощник. Там очень запутанным выбор переменной gвнутри f, но это не связано связанной переменной .. Для g=необязателен в соответствии с постановлением , позволяя функции Анон, что экономит два символа.
xnor
4

Pyth, 9 байт

qFmmxdkdQ

Принимает ввод в следующем виде:

"ESTATE", "DUELED"

Если это не приемлемо, следующий код составляет 10 байтов:

qFmmxdkd.z

и использует эту форму ввода:

ESTATE
DUELED

Использует индекс char в строковом представлении.

isaacg
источник
Первый формат ввода в порядке. Мне интересно, как вы уменьшаете, чтобы проверить равенство, но мне неясно, как Fработает сложение. Что <binary>F?
xnor
@xnor <binary>F<seq>будет <binary>загибают <seq>. Это эквивалентно вкраплению <binary>между каждой парой элементов <seq>. Таким образом, <binary>Fдля последовательности из 2 элементов просто применяется функция к последовательности, эквивалентная .*в Pyth или *Python.
Исаак
Я думал, что отставание Qбыло скрыто в Pyth?
Cyoce
@Cyoce Не тогда - эта функция была добавлена ​​в апреле 2016 года, почти год спустя.
Исаак
4

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
Луис Мендо
источник
4

Октава, 26 байт

@(s,t)isequal(s==s',t==t')
alephalpha
источник
3
Выглядит интересно. объяснение?
гордый haskeller
==является матричным поэлементным равенством, и поскольку sи s'имеют разные размеры, «широковещание» октавы автоматически пытается получить матрицы одинакового размера для работы - что в этом случае означает повторение строки sи столбцаs'
rakslice
Это тот же подход, что и решение Matlab от @ LuisMendo, но там расширение явное.
Ракслице
4

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
scottinet
источник
4

APL (Дьялог) , 5 4 байта

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

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

≡.⍳⍨

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

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

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

. а также

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

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

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

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

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

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

≡/⍳⍨¨

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

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

/ через

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

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

¨ каждого

Адам
источник
Вы видите внутренний продукт? :)
ngn
@ngn Да, конечно. Дурак я.
адам
Должна ли верхняя ссылка ссылаться на старое решение?
Захари
Жаль, что это не работает на массивах более высокого ранга: P
Zacharý
1
@ Zacharý, как и было обещано: ngn.github.io/apl-codegolf-2017/readme.txt
ngn
3

Mathematica, 46 байтов

Equal@@Values@*PositionIndex/@Characters@{##}&
alephalpha
источник
3

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

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

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

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

blutorange
источник
3

Шелуха , 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  ]
ბიმო
источник
3

PCRE, 84 байта

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

Тема должна состоять из двух слов, разделенных пробелами, как в OP. Вот краткое объяснение:

Для каждой буквы X в первом слове:

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

Для каждой буквы Z после текущей позиции в первом слове:

Установите аналогичные обратные ссылки, как указано выше.

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

Эта итерация может закончиться, как только мы найдем предпоследнюю букву в первом слове. На этом этапе, поскольку дальнейшая проверка не требуется, остается только проверить, что слова имеют одинаковую длину (обратная ссылка, содержащая накопительные подстроки второго слова, всегда отстает на 1 букву).

jaytea
источник
2

Рубин, 31 байт

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

Proc, который принимает массив строк и проверяет, изоморфны ли они друг другу. tr s,'a-z'с этими аргументами нормализует строку s, заменяя каждую букву n-й буквой в алфавите, где nэто наибольший индекс, с которым эта буква появляется в строке. Например, estateстановится fbedef, как делает dueled.

histocrat
источник
1

Кобра, 72 байта

do(a='',b='')=(for i in a get a.indexOf(i))==for i in b get b.indexOf(i)
Οurous
источник
Вы уверены, что это помечает AB CCконтрольный пример False?
xnor
@xnor исправлена ​​сейчас
Mayurous
1

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)

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

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

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

C5H8NNaO4
источник
1
Не могли бы вы не двигаться , ;l=cчтобы for(l=j=2;j--;и сохранить байты?
Джонатан Фрех
1

Perl, 38 байт

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

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

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

Габриэль Бенами
источник
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заголовочный файл

HatsuPointerKun
источник
1
Не похоже, что вы используете что-либо из заголовка строки, так что вы можете удалить его и сделать так, чтобы пользователь сам включил его?
Захари
Имеет ли эта работа для 161 байт?
Захари
@ Zacharý Если вы добавите eаргумент как find, да, это работает
HatsuPointerKun
В тот момент, когда тебя побеждает Брейнфак, хотя> _ <
Захарий
1

JavaScript (ES6), 52 51 50 байт

Эта версия не использует понимание массива и принимает ввод с использованием синтаксиса каррирования.

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

kamoroso94
источник