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

Напевно, найлегше визначитись через приклади:

Дійсні справи

"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

Якщо у вас виникли питання щодо функціональності двох пар, які не є в списку, перейдіть до цієї реалізації.

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

• Вхід може бути двома елементами або як два окремі входи.
• Вихід може бути як обмежений масив, так і новий рядок / простір, аналогічно тому, як я показав.
• Неправдивий вихід може бути 0, -1 або помилковим. Помилка / Порожній вихід також добре.
• Вам гарантовано, що aне буде рівним bі ні, aі bне буде порожнім.
• aі bє послідовностями літер лише для друку.

Коваджі

• Переклади повинні відбуватися зліва направо (див. Приклад 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;

Тестові шафи

Розширено

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 для помилкового висновку 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;

Тестові шафи

Розширено

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 для хибного виводу 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);

Тестові шафи

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;

Тестові шафи

Розширено

[,$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-байтна версія в Горубі, яка є Рубі, але з прапором для гольфу, встановленим при складанні перекладача. Крім усього іншого, це дозволяє скоротити виклики методів до їх найкоротшого унікального ідентифікатора.

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

Безумовно:

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

Якби тільки замовлення не мало значення ...

Рода , 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 рядки, розділені пробілом.

k, 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 bytes

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

Input and output are arrays on the stack.

PHP (>=7.1), 165 bytes

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

prints 0 for falsy, associative array else. Run with -r or test it online.

breakdown

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