Если даны две строки, найдите таблицу перевода ( подстановочный шифр ) между ними, если перевод невозможен, выведите false. Ответ должен быть свернут и создан слева направо. Первый символ для перевода между словами должен быть первым в таблице перевода. В дополнение к этому, любое письмо, которое не переведено (в том же месте, где оно было изначально), НЕ должно быть в таблице перевода.

Вероятно, наиболее легко определить с помощью примеров:

Допустимые случаи

"bat", "sap" => ["bt","sp"]

Обратите внимание на порядок, вывод ["tb","ps"]не действителен для этой задачи.

"sense", "12n12" => ["se","12"]

Обратите внимание, как nне переводится, потому что это отношение 1 к 1.

"rabid", "snail" => ["rabd","snal"]

Обратите внимание, как iне переводится, потому что это отношение 1 к 1.

"ass", "all" => ["s","l"]

A не включен, он остается прежним, sможет отображаться lиз-за совпадения с шаблоном.

"3121212", "ABLBLBL" => ["312","ABL"]

Совмещает рисунок идеально.

Ложные дела

"banana", "angular" => false

(не такой же длины, невозможно).

"animal", "snails" => false

(каждый символ может использоваться только ОДИН РАЗ на каждой стороне перевода).

"can","cnn" => false

(n неявно используется в переводе, поэтому определение таблицы перевода с n-> a будет недопустимым)

Таким образом, [aimal,sails]является неверным ответом, что делает эту ложь.

"a1", "22" => false

Смотрите "предостережения", это указано как ложь. В этом случае это потому что aи 1не может быть сопоставлено 2. (Каждый символ может использоваться только ОДИН РАЗ на каждой стороне перевода).

Этот ответ, кажется, хороший тест: /codegolf//a/116807/59376

Если у вас есть вопросы по поводу функциональности двух незарегистрированных пар слов, обратитесь к этой реализации.

Правила ввода / вывода

• Вход может быть в виде массива из 2 элементов или в виде 2 отдельных входов.
• Вывод может быть в виде массива или новой строки / пробела, аналогично тому, как я это показал.
• Ложный вывод может быть 0, -1 или ложным. Ошибка / пустой вывод тоже в порядке.
• Вам гарантировано, что aне будет равных bи aни bпустых.
• aи bявляются печатными последовательностями букв только для ASCII.

Предостережения

• Переводы должны выполняться слева направо, см. Пример 1.
• Вы не должны выводить символы, которые остаются прежними.
• Ваша программа может принимать только две строки aиb .
• Каждый символ может использоваться только ОДИН РАЗ на каждой стороне перевода. Это то, что делает перевод с snailsнаanimals невозможно.
• Рекурсивных замен быть не должно. Пример рекурсивной замены: "a1","22"->[a1,12]где a сначала заменяется на 1, затем оба результирующих 1 заменяются на 2. Это не правильно, предположим, что все переводы происходят независимо друг от друга, то есть это ложно. Значение: «a1» с таблицей перевода [a1,12] оценивается как 12 (не 22)

JavaScript (ES6), 128 байт

f=
(s,t)=>!t[s.length]&&[...s].every((c,i)=>n[d=t[i]]==c||d&&!m[c]&&!n[d]&&(n[m[c]=d]=c,c==d||(a+=c,b+=d)),m={},n={},a=b='')&&[a,b]

<div oninput=o.textContent=f(s.value,t.value)><input id=s><input id=t><pre id=o>

JavaScript (ES6), 108 107 105 106 байт

Редактировать : Исправлено для поддержки входов, таких как"22" / "a1" это должно быть ложным.

Возвращает либо 0массив двух строк.

f=(a,b,x)=>[...a].some((c,i)=>d[C=b[i]]?d[C]!=c:(d[C]=c)!=C&&(s+=c,t+=C,!C),s=t='',d=[])?0:x||f(b,a,[s,t])

Отформатировано и прокомментировано

f = (                       // given:
  a,                        // - a = first string
  b,                        // - b = second string
  x                         // - x = reference result from previous iteration,
) =>                        //       or undefined
  [...a].some((c, i) =>     // for each character c at position i in a:
    d[                      //   if we already have a translation
      C = b[i]              //   of the character C at the same position in b,
    ] ?                     //   then:
      d[C] != c             //     return true if it doesn't equal c
    :                       //   else:
      (d[C] = c) != C &&    //     store the translation C -> c in the dictionary
      (                     //     if the characters are different:
        s += c, t += C,     //       append them to the translation strings s and t
        !C                  //       return true if C is undefined
      ),                    //
    s = t = '', d = []      //   initialize s, t and d  
  ) ?                       // if some() returns true:
    0                       //   there was a translation error: abort
  :                         // else:
    x ||                    //   if this is the 2nd iteration, return x
    f(b, a, [s, t])         //   else do a recursive call with (b, a)

Контрольные примеры

f=(a,b,x)=>[...a].some((c,i)=>d[C=b[i]]?d[C]!=c:(d[C]=c)!=C&&(s+=c,t+=C,!C),s=t='',d=[])?0:x||f(b,a,[s,t])

// truthy
console.log(f('bat','sap'))
console.log(f('sense','12n12'))
console.log(f('rabid','snail'))
console.log(f('ass','all'))
console.log(f('3121212','ABLBLBL'))

// falsy
console.log(f('banana','angular'))
console.log(f('animal','snails'))
console.log(f('a1','22'))
console.log(f('22','a1'))
console.log(f('aaa','bab'))
console.log(f('abc','abcd'))
console.log(f('abcd','abc'))

PHP> = 7.1, 130 байт

18 байтов сохранено @Titus

for([,$x,$y]=$argv;a&$o=$y[$i];)$o==($p=$x[$i++])?:$k[$c[$p]=$o]=$p;echo$y==strtr($x,$c)&$x==strtr($y,$k)?join($k)." ".join($c):0;

Testcases

расширенный

for([,$x,$y]=$argv;a&$o=$y[$i];)
$o==($p=$x[$i++])?:$k[$c[$p]=$o]=$p; # if char string 1 not equal char string 2 make key=char1 value=char2 and key array
echo$y==strtr($x,$c) # boolean replacement string 1 equal to string 2
    &$x==strtr($y,$k) # boolean replacement string 2 equal to string 1
    ?join($k)." ".join($c) # output for true cases
:0; #Output false cases

PHP> = 7,1, 148 байт

выводит 0 для false. Вывод true как строка

for([,$x,$y]=$argv;a&$o=$y[$i];$i++)$x[$i]==$o?:$c[$x[$i]]=$o;echo$y==strtr($x,($f=array_flip)($k=$f($c)))&$x==strtr($y,$k)?join($k)." ".join($c):0;

Testcases

расширенный

for([,$x,$y]=$argv;a&$o=$y[$i];$i++)
$x[$i]==$o?:$c[$x[$i]]=$o; # if char string 1 not equal char string 2 set key=char1 value=char2
echo$y==strtr($x,($f=array_flip)($k=$f($c))) # boolean replacement string 1 equal to string 2
&$x==strtr($y,$k) # boolean replacement string 2 equal to string 1
    ?join($k)." ".join($c) # output for true cases
:0; #Output false cases

PHP> = 7.1, 131 байт

Второй ответ можно замкнуть на это, если разрешены ассоциативные массивы

выводит 0 для false. Вывод true как ассоциативный массив вместо строки

for([,$x,$y]=$argv;a&$o=$y[$i];$i++)$x[$i]==$o?:$c[$x[$i]]=$o;print_r($y==strtr($x,($f=array_flip)($f($c)))&$x==strtr($y,$k)?$c:0);

Testcases

PHP> = 7.1, 227 байт

печатает 0 для ложных

[,$x,$y]=$argv;echo strlen($x)==strlen($y)?strtr($x,$c=array_filter(($f=array_flip)($z=$f(array_combine(($p=str_split)($x),$p($y)))),function($v,$k){return$k!=$v;},1))==$y&$x==strtr($y,$z)?join(array_keys($c))." ".join($c):0:0;

Testcases

расширенный

[,$x,$y]=$argv; # 
echo strlen($x)==strlen($y) #compare string lengths
?strtr($x,  # replace function
$c=array_filter( # filter 
($f=array_flip)($z=$f( # # remove doubles like in testcase: a1 => 22
    array_combine(($p=str_split)($x),$p($y))  # replacement array keys string 1 values string 2 
))
    ,function($v,$k){return$k!=$v;},1)) # remove all keys that equal to values in array
    ==$y # boolean replacement string 1 equal to string 2
&$x==strtr($y,$z) # boolean replacement string 2 equal to string 1        
?join(array_keys($c))." ".join($c) # output for true cases
    :0 # Output if replacement from string 1 is not equal to string 2
:0; #Output for different lengths

Желе , 18 байт

ẠaQ⁼µ€Ạ
z0EÐḟQZẋÇ$

Безымянная монадическая ссылка (функция с одним входом) принимает список, который возвращает:
пустой список в случаях фальси; или
список, содержащий два списка символов в истинных случаях.

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

Как?

ẠaQ⁼µ€Ạ - Link 1, valid?: mapping list
    µ€  - perform the code to the left for €ach mapping entry
Ạ       -     none of mapping entry falsey? (this & Main's z0 handle unequal input lengths)
  Q     -     deduplicate mapping entry
   ⁼    -     is equal to mapping list? (non-vectorising)
 a      -     and
      Ạ - none falsey (both mapping lists must pass that test)
        - The whole function returns 1 if the mapping list is acceptable, 0 if not

z0EÐḟQZẋÇ$ - Main link: list of strings
z0         - transpose with filler 0 (unequal lengths make pairs containing zeros)
   Ðḟ      - filter discard:
  E        -     all equal? (removes the untranslated character pairs)
     Q     - deduplicate (removes the repeated translation pairs)
      Z    - transpose (list of pairs to pair of lists)
         $ - last two links as a monad:
       ẋ   -     repeat list this many times:
        Ç  -         call last link (1) as a monad

Сетчатка , 194 191 185 229 225 241 байт

.+
$&;$&
+`^\w(\w*;)\w
$1
^;\w.*|.+;;.*|;;

^((.)*)(.)(.*;(?<-2>.)*(?(2)(?!)))\3
$1$4
+`((.)(.)*)\2((.)*;.*(.)(?<-3>.)*(?(3)(?!)))\6((?<-5>.)*(?(5)(?!)))$
$1$4$7
^(.)*(.)(.)*(\2)?.*;(?<-1>.)*(?(1)(?!))(.)(?<-3>.)*(?(3)(?!))(?(4)(?!\5)|\5).*

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

Принимает входные данные ;отдельно. Выход также; разделен. Ложные входы обозначены пустыми выходами.

Я знаю, что это мучительно многословно, я все еще пытаюсь сократить байты. Большая часть этих байтов используется для удаления ложных входных данных.

Правки

• Оказывается, у меня был существенный недостаток в моей программе. Это исправлено сейчас, но стоимостью более 40 байт.

• Другая ошибка была обнаружена, когда моя программа не объявила ввод a1;22ложным, но я смог сохранить программу до 250 байт после ее исправления

объяснение

(более подробное объяснение будет в ближайшее время)

Сначала мы должны проверить, если длина строк aиb являются одинаковыми или нет. Если это не так, мы удаляем все.

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

.+                      Matches everything
$&;$&                   $& indicates the match, so $&;$& will duplicate the match and separate it with a semi-colon

Теперь в цикле мы удаляем первый символ aи первый символ bдо тех пор, пока одна из строк не станет пустой.

+`                     Repeatedly (until no more substitutions could be made) replace
  ^\w                   A word character (letter or number) at the beginning
     (\w*;)             Capture Group 1: matches any number of word characters and a semicolon
           \w           And a word character after the semi-colon
                       with
$1                      The result of the first capture group

Теперь есть возможности для «пространства образца».

• ;;abc Обе строки имеют одинаковую длину
• def;;abc a длиннее чем b
• ;def;abc b длиннее чем a

Теперь нам нужно очистить ввод, если строки не имеют одинаковую длину (сценарии 2 и 3). Это то, что делает эта замена ниже. Он удаляет текст, который соответствует сценариям 2 и 3.

^;\w.*|.+;;.*|;;

Это удаляет символы, которые не транслитерируются в строках aи b. abc;1b2=>ac;12

^((.)*)(.)(.*;(?<-2>.)*(?(2)(?!)))\3
$1$4

После этого мы должны удалить дубликаты символов. sese;1212=> se;12, но это сохраняет входные данные, такие какaba;123

+`((.)(.)*)\2((.)*;.*(.)(?<-3>.)*(?(3)(?!)))\6((?<-5>.)*(?(5)(?!)))$
$1$4$7

Наконец, мы удаляем ввод, если есть повторяющиеся символы, которые отображаются на разные символы, такие как aba;123или a1;22.

^(.)*(.)(.)*(\2)?.*;(?.)*(?(1)(?!))(.)(?.)*(?(3)(?!))(?(4)(?!\5)|\5).*

И, наконец, удалите повторяющиеся символы.

Желе , 28 26 байт

QL$€⁼L€
EÐḟQZK0Ç?
ZÇ0L€E$?

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

QL$€⁼L€      Checks validity of mapping
QL$€          number of unique characters in mapping
    ⁼         equals
     L€       number of characters in mapping

EÐḟQZK0Ç?  Writes valid mapping or 0
EÐḟ           filter maps where a = b
   Q          filter duplicate maps
    Z         zip by column [["ac"],["bd"]] => ["ab","cd"]
     K0Ç?   print if valid map, else print 0

ZÇ0L€E$?      main link: takes an array of 2 strings
Z              zip by column: ["ab", "cd"] => [["ac"],["bd"]]
 Ç     ?       print mapping if
   L€E$         all pairs are same length (returns 0 if initial strings were
  0             else 0

Рубин, 133 байта

->a,b{a.size!=b.size||(m=a.chars.zip b.chars).any?{|i,j|m.any?{|k,l|(i==k)^(j==l)}}?0:m.select{|x,y|x!=y}.uniq.transpose.map(&:join)}

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

Более читабельно:

->a, b{
    # Pair the letters in each string - [AB, AB, AB,...]
    pairs = a.chars.zip(b.chars)

    # If there's any combination of two pairs that share one character but not both,
    # or if the strings have different lengths, then the input's invalid.
    if a.size != b.size || pairs.any?{|i,j| pairs.any? {|k, l| (i==k)!=(j==l) }} 
        return 0 # 0 isn't actually falsy in Ruby, but this challenge allows it anyway
    end
    return pairs.select{|x,y| x != y} # Remove unchanged letters
                .uniq                 # Remove duplicates
                .transpose            # Change [AB, AB, AB] form to [AAA, BBB] form.
                .map(&:join)          # Convert the arrays back into strings
}

Просто для удовольствия, вот версия на 84 байта в Goruby, которая является Ruby, но с флагом гольфа, установленным при компиляции интерпретатора. Помимо прочего, он позволяет сокращать вызовы методов до их кратчайшего уникального идентификатора.

->a,b{a.sz!=b.sz||(m=a.ch.z b).ay?{|i,j|m.y?{|k,l|(i==k)^(j==l)}}?0:m.rj{|x,y|x==y}.u.tr.m(&:j)}

Python 2 , 198,193,189,182,179,175,169, 165 байт

def f(a,b):
 r=([""]*2,0)[len(a)!=len(b)]
 for u,v in zip(a,b):
	if r:
		q,w=r
		f=q.find(u)
		if u!=v:r=(([q+u,w+v],r)[f>-1 and w[f]==v],0)[f<0 and v in w]
 print r

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

• -4 байта! спасибо mbomb007 за предложение использовать вкладку вместо пробела.

• изменил формат ввода, снова благодаря mbomb007.

Python 3.6, 211 185 181 178 байт

Выход с ошибкой для ложных результатов.

def f(x,y,d={}):
    for a,b in zip(x,y):1/(a not in d or b==d[a]or len(x)-len(y));d[a]=b;1/([*d.values()].count(b)<2)
    return map(''.join,zip(*[x for x in d.items()if x[0]!=x[1]]))

Это требует Python 3.6, который вы можете запустить в оболочке здесь .

Вы можете проверить это без правильного порядка вывода на TIO здесь . (TIO не имеет 3,6).

Ungolfed:

from collections import*
d=OrderedDict()                     # keep order
x,y=input()
if len(x)!=len(y):1/0               # equal lengths
for a,b in zip(x,y):
    if a in d and d[a]!=b:1/0       # no duplicate keys
    else:d[a]=b
    if d.values().count(b)>1:1/0    # no duplicate values
print map(''.join,zip(*[x for x in d.items()if x[0]!=x[1]])) # format, no no-ops

Если бы только порядок не имел значения ...

Röda , 108 119 байт

{c=[{_<>_|[[_,_]]|orderedUniq}()]d=[]e=[]c|_|{{d+=a;e+=b}if[a!=b]}for a,b[d,e]if[0,1]|{|n|c|[_[n]]|sort|count|[_2=1]}_}

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

Это функция, которая берет два списка символов из потока и помещает два списка в поток.

Это могло бы быть сортировщиком, если бы мне разрешили возвращать пары.

Объяснение (устаревшее):

{
    c=[{
        _<>_|       /* pull two lists and interleave them */
        [[_,_]]|    /* "unflat", create lists from pairs */
        orderedUniq /* remove duplicates */
    }()]            /* c is a list of the pairs */
    d=[]
    e=[]
    c| /* push the pairs to the stream */
    _| /* flat */
    {  /* for each pair (a, b): */
        { /* if a != b (remove "1-to-1 relations"):  */
            d+=a;
            e+=b
        }if[a!=b]
    }for a,b
    /* return d and e if no character is mapped to more than one character */
    [d,e]if c|[_[0]]|sort|count|[_2=1]
}

Вот решение для подчеркивания, которое не содержит переменных (114 байт):

{[[{_<>_}()|[[_,_]]|unorderedUniq]]|[[_()|_|[_]if[_1!=_2]],[_1()|_|[_2]if[_1!=_2]]]if[[_1()|_][::2],[_1()|_][1::2]]|[sort(_)|count|[_2=1]]}

Это много подчеркиваний.

AWK, 140 байт

BEGIN{RS="(.)"}RT~/\W/{S=1}RT~/\w/&&S{if(RT!=x=A[++b]){if(B[z=RT]==""){B[z]=x
c=c x
d=d z}a=B[z]!=x?0:a}}!S{A[++a]=RT}END{if(a==b)print c,d}

Использование: Поместите код в FILEзатем:

awk -f FILE <<< "string1 string2"

Входные строки должны быть разделены пробелами.

Вывод будет пустым, если они не пройдены, или 2 строки разделены пробелом.

к, 28 байтов

{$[(y?y)~x?x;+?(~=/)#x,'y;]}

Объяснение:

{                          } /function that takes in two strings, x and y
 $[         ;            ;]  /if statement (to check if there is a mapping)
         x?x                 /first index of [each letter in x] in x
   (y?y)                     /first index of [each letter in y] in y
        ~                    /make sure they match
                     x,'y    /zip together the two strings
               (~=/)#        /remove equal pairs
              ?              /unique pairs only
             +               /transpose ("unzip", in a way)

APL (Dyalog) с AGL , 22 байта

{≡/⍳⍨¨⍺⍵:↓⍉↑∪⍺(≠é,¨)⍵}

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

{...}  Анонимная функция:

 Если…

  ⍺⍵ аргументы

  ⍳⍨¨ когда самоиндексируется (т.е. первые вхождения их элементов в себя)

  ≡/ эквивалентны

 : тогда:

  ⍺(...)⍵  Применить следующую неявную функцию к аргументам:

   ,¨ объединить соответствующие элементы (ошибки при несовпадении длин)

   é затем фильтр по ( éэто просто примитивная функция/ )

   ≠ где строки разные

  ∪ уникальный (удалить дубликаты)

  ↓⍉↑ транспонировать список пар в пары списков (горит, смешивать в таблицу, транспонировать таблицу, разбивать на списки)

 иначе ничего не делать

CJam, 38 байт

{_:,~={1\/;}:K~z{)\c=!},L|z_{_L|=K}%;}

Вход и выход - это массивы в стеке.

PHP (> = 7.1), 165 байт

for([,$x,$y]=$argv;a&$c=$x[$i];$t[$c]=$d)$z+=($d=$y[$i++])&&$d==($t[$c]??$d);foreach($t as$a=>$b)$a==$b?:$r[$a]=$b;print_r($z<$i|array_unique($r)<$t||a&$y[$i]?0:$t);

печатает 0для ложных, ассоциативный массив еще. Запустите -rили протестируйте его онлайн .

сломать

for([,$x,$y]=$argv;         # import arguments to $x and $y
    a&$c=$x[$i];            # loop through $x
    $t[$c]=$d)                  # 2. add pair to translation
$z+=                            # 1. increment $z if
    ($d=$y[$i++])&&             # there is a corresponding character in $y and
    $d==($t[$c]??$d);           # it equals a possible previous replacement
                            # remove identities from translation
foreach($t as$a=>$b)$a==$b?:$r[$a]=$b;
print_r(
    $z<$i                   # if not all tests passed
    |array_unique($t)<$t    # or there are duplicates in the translation
    ||a&$y[$i]              # or $y has more characters
    ?0                      # then print 0
    :$r                     # else print translation
);