두 개의 문자열이 주어지면, 둘 사이 의 변환 표 ( 대체 암호 )를 찾으십시오 . 변환이 불가능하면 false를 출력하십시오. 답을 최소화하고 왼쪽에서 오른쪽으로 만들어야합니다. 단어 사이에서 번역 될 첫 번째 문자는 번역 표에서 첫 번째 문자 여야합니다. 이 외에도 번역되지 않은 (원래와 같은 장소에있는) 문자는 번역 표에 없어야합니다.

아마도 예제를 통해 가장 쉽게 정의 할 수 있습니다.

유효한 사례

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

순서에 주목하십시오. 출력은 ["tb","ps"]이 챌린지에 유효하지 않습니다.

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

n이 관계가 일대일 관계이기 때문에 어떻게 번역되지 않는지 주목하십시오 .

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

i이 관계가 일대일 관계이기 때문에 어떻게 번역되지 않는지 주목하십시오 .

"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

나열되지 않은 두 단어 쌍의 기능에 대한 질문이있는 경우이 구현을 연기하십시오.

I / O 규칙

• 입력은 2 요소 배열 또는 2 개의 개별 입력일 수 있습니다.
• 출력은 배열 방식 또는 줄 바꿈 / 공백으로 구분할 수 있으며 표시 된 방식과 비슷합니다.
• 거짓 출력은 0, -1 또는 false 일 수 있습니다. 오류 / 빈 출력도 좋습니다.
• 당신은 a같지 않으며 비어 b있지 a않을 b것입니다.
• a그리고 b문자의 인쇄-ASCII 전용 시퀀스입니다.

경고

• 번역은 왼쪽에서 오른쪽으로 이루어져야합니다 (예 1 참조).
• 동일하게 유지되는 문자를 출력해서는 안됩니다.
• 귀하의 프로그램은 두 개의 문자열에 걸릴 수 있습니다 a와 b.
• 각 문자는 번역의 양쪽에서 한 번만 사용할 수 있습니다. 이것이 번역 snails을 animals불가능 하게 만드는 것 입니다.
• 재귀 교체가 발생하지 않아야합니다. 재귀 대체의 예 : "a1","22"->[a1,12]a가 먼저 1로 대체되고 결과로 생성 된 1이 모두 2로 대체됩니다. 이것은 정확하지 않습니다. 모든 번역이 서로 독립적으로 발생한다고 가정합니다. 이는 잘못된 것입니다. 의미 : [a1,12]의 번역 표가있는 "a1"은 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>

자바 스크립트 (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 바이트

@Titus에 의해 절약 된 18 바이트

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

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

연관 배열이 허용되는 경우 두 번째 대답은 이것으로 단락 될 수 있습니다

false 대신 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 바이트

false로 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ẋÇ$

이름이없는 모나드 링크 (1 입력 기능)는 다음과
같은 목록을 가져옵니다. 또는
진실한 경우에 두 개의 문자 목록을 포함하는 목록.

온라인으로 사용해보십시오! 바닥 글은 밀린 표현을 인쇄하지 않도록 공백으로 목록을 분할합니다.
... 또는 테스트 스위트를 참조하십시오.

어떻게?

Ạ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;22false로 선언하지 않은 또 다른 실수가 발견 되었지만 프로그램을 수정 한 후 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
}

킥을 위해 여기에 Ruby 인 84 바이트 버전의 Goruby가 있지만, 인터프리터를 컴파일 할 때 골프 플래그가 설정되어 있습니다. 무엇보다도 메소드 호출을 가장 짧은 고유 식별자로 축약 할 수 있습니다.

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

파이썬 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 덕분에 입력 형식이 수정되었습니다.

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

{_:,~={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
);