이 도전에서, 당신은 두 단어가 전달됩니다 : 당신의 임무는 그들이 인접 한지 결정하는 것 입니다.

다음과 같은 경우 두 글자가 인접 해 있습니다.

1. 그들은 같은 편지이거나
2. 그들은 사 전적으로 인접 해 있습니다.

예를 들어, J 는 I , J 및 K 에만 인접 합니다. Z 는 A에 인접하지 않습니다

다음과 같은 경우 두 단어가 인접 해 있습니다.

1. 그들은 같은 길이이며
2. 각 문자는 다른 단어에서 고유 한 문자와 인접 해 있습니다.

예를 들어, CAT 는 C> D, A> A, T> S 와 같이 SAD에 인접합니다 . FREE 는 GRRD 와 인접하지 않습니다 (각 E 에는 쌍을 이루는 글자가 필요합니다)
.

입출력

두 개의 문자열을 전달 받았으므로 인접한 값이면 값을 반환하고 그렇지 않으면 거짓 값을 반환해야합니다. 아래의 모든 테스트 사례에 대해 1 분 이내에 돌아와야합니다.

문자열에 알파벳 대문자 만 포함한다고 가정 할 수 있습니다.

두 문자열은 따옴표를 포함하거나 포함하지 않고 목록으로 전달하거나 연결할 수 있습니다.

테스트 사례

진실한 :

A A
A B
C B
DD CE
DE FC
ABCD BCDE
AACC DBBB
DJENSKE FDJCLMT
DEFGHIJKL HJLEHMCHE
IKLIJJLIJKKL LJLJLJLJLJHI
ACEGIKMOQSUWY BLNPRDFTVHXJZ
QQSQQRRQSTTUQQRRRS PQTTPPTTQTPQPPQRTP
ELKNSDUUUELSKJFESD DKJELKNSUELSDUFEUS

거짓 :

A C
A Z
B J
JK J
CC BA
CE D
DJENSKE GDJCLMT
DEFGHIJKL HJLHMCHE
IJKLIJKLKIJL LIJLLHJLJLLL 
AWSUKMEGICOQY RSHXBLJLNQDFZ
QQSQQRRQSTTUQQQRRS PQTTPPTTQTPQPPQRTT
ELKNSDUVWELSKJFESD DKJELKNSUELSDUFEUS

이것은 code-golf 이므로 가장 짧은 유효한 답변이 승리합니다!

CJam, 14 13 12 바이트

r$r$.-:)3,-!

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 한 번에 확인하십시오 .

연산

하자 의 와 t이 두 수는 같은 길이의 단어를 분류. 들어 S 및 t는 (LA)를 전적으로 인접하여, 그것의 대응하는 모든 문자 쌍을 또한 LA 것을 필요 충분하다.

조건은 모든 단어에 대해 명확하고 길이가 1 인 단어에 필요합니다 .

이제 s 와 t의 길이가 n> 1 이고 a 와 b 가 s 와 t 의 첫 문자 라고 가정 하십시오 .

이후 S 와 T는 LA를하고, 일부 전단 사 매핑이 φ 의 문자 사이 의 및 문자 t 등 그 X 와 φ (X)는 모두 LA를하는 X 에서 의 그 의미 | φ (x)를 - X를 | ≤ 1 모든 X 에서 의 .

c = φ (a) 및 d = φ ^-1 (b) 이라고하자 . 때문에 'S 및 B 의 minimality, ≤ d를 (1) 및 B ≤ C (2) .

또한, b 및 d , a 및 c 및 LA이므로 d ≤ b + 1 (3) 및 c ≤ a + 1 (4) 입니다.

(1) 과 (3) , (2) 와 (4) 를 결합함으로써 a ≤ d ≤ b + 1 및 b ≤ c ≤ a + 1 을 얻습니다 . 이로부터 a-1 ≤ b ≤ a + 1 이므로 a 와 b 는 LA입니다.

이제 (1) 과 (4) 와 (2) 와 (3)을 결합 하여 c-1 ≤ a ≤ d 및 d-1 ≤ b ≤ c를 얻습니다. 이로부터 c-1 ≤ d ≤ c + 1 이므로 c 와 d 는 LA입니다.

따라서, 우리는 재정의하는 경우 φ 가 φ (a) = B 및 φ (d) C = , | X - φ (x)는 | ≤ 1 은 여전히 ​​모든 x in s , 특히 모든 x in s [1 :]에 대해 유지 됩니다.

이런 식으로 s [0] = a 및 t [0] = b 및 s [1 :] 및 t [1 :] 은 LA입니다.

이후 S [1] 가지고 길이 N - 1 이 유도하여 필요성을 입증한다.

암호

r               e# Read the first word from STDIN.
 $              e# Sort its characters.
  r             e# Read the second word from STDIN.
   $            e# Sort its characters.
    .-          e# Perform vectorized subtraction.
                e# This pushes either the difference of char codes of two
                e# corresponding characters or a character that has no does not
                e# correspond to a character in the other, shorter word.
      :)        e# Increment all results.
                e# In particular, this maps [-1 0 1] to [0 1 2].
        3,      e# Push the range [0 1 2].
          -     e# Perform set difference, i.e., remove all occurrences of 0, 1 and
                e# 2 from the array of incremented differences.
           !    e# Apply logical NOT. This gives 1 iff the array was empty iff
                e# all differences gave -1, 0 or 1.

MATL , 10 12 17 바이트

c!S!odXl2<

이것은 Dennis의 접근법을 사용합니다 : 먼저 정렬하고 일치하는 위치에서 문자를 비교하십시오.

입력은 형식의 문자열 배열입니다 {'CAT 'SAD'}.

출력은 0과 1의 배열입니다. 결과는 모든 것을 포함하면 진실입니다 (이것은 진실한 것으로 동의 됩니다).

이 문제보다 빠른 현재 릴리스 (10.2.1)를 사용합니다 .

편집 : 기능 Xl이 |최신 버전의 언어 로 변경 되었으며 더 o이상 필요하지 않습니다. 아래 링크에는 이러한 수정 사항이 포함되어 있습니다.

온라인으로 사용해보십시오!

설명 :

c         % implicitly cell array of strings and convert to 2D char array. 
          % This pads with spaces if needed
!S!       % sort each row
o         % convert array from char to double
d         % difference between elements in the same column
Xl        % absolute value of each entry
2         % number literal
<         % each entry becomes 1 if smaller than 2 (adjacent letters), and 0 otherwise

문자열을 별도의 입력으로 허용하는 오래된 접근 방식 : 12 바이트 :

SiSXhcodXl2<

편집 : 링크의 코드가 언어의 변경 사항에 따라 수정되었습니다. 위의 주석을 참조하십시오.

온라인으로 사용해보십시오 !

설명 :

S         % implicitly input first string and sort
iS        % input second string and sort
Xh        % build cell array with these two strings
c         % convert to 2D char array. This pads with spaces if needed
o         % convert array from char to double
d         % difference between elements in the same column
Xl        % absolute value of each entry
2         % number literal
<         % each entry becomes 1 if smaller than 2 (adjacent letters), and 0 otherwise

C, 233 바이트

#include <stdlib.h>
#include <string.h>
#define h char
#define r return
int c(void*a,void*b){r*(h*)a-*(h*)b;}int a(h*s,h*t){int l=strlen(s),m=strlen(t);if(l!=m)r 0;qsort(s,l,1,c);qsort(t,m,1,c);while(l--)if(abs(s[l]-t[l])>1)r 0;r 1;}

파일 을 다른 이름으로 저장 adj.h한 다음이 adj.c파일 을 사용하여 테스트 할 수 있습니다 .

#include <stdio.h>
#include "adj.h"

int main() {
  char aa[] = "A", A[] = "A";
  char b[] = "A", B[] = "B";
  char cc[] = "C", C[] = "B";
  char d[] = "DD", D[] = "CE";
  char e[] = "DE", E[] = "FC";
  char f[] = "ABCD", F[] = "BCDE";
  char g[] = "AACC", G[] = "DBBB";
  char hh[] = "DJENSKE", H[] = "FDJCLMT";
  char i[] = "DEFGHIJKL", I[] = "HJLEHMCHE";
  char j[] = "IKLIJJLIJKKL", J[] = "LJLJLJLJLJHI";
  char k[] = "ACEGIKMOQSUWY", K[] = "BLNPRDFTVHXJZ";
  char l[] = "QQSQQRRQSTTUQQRRRS", L[] = "PQTTPPTTQTPQPPQRTP";
  char m[] = "ELKNSDUUUELSKJFESD", M[] = "DKJELKNSUELSDUFEUS";
  char n[] = "A", N[] = "C";
  char o[] = "A", O[] = "Z";
  char p[] = "B", P[] = "J";
  char q[] = "JK", Q[] = "J";
  char rr[] = "CC", R[] = "BA";
  char s[] = "CE", S[] = "D";
  char t[] = "DJENSKE", T[] = "GDJCLMT";
  char u[] = "DEFGHIJKL", U[] = "HJLHMCHE";
  char v[] = "IJKLIJKLKIJL", V[] = "LIJLLHJLJLLL";
  char w[] = "AWSUKMEGICOQY", W[] = "RSHXBLJLNQDFZ";
  char x[] = "QQSQQRRQSTTUQQQRRS", X[] = "PQTTPPTTQTPQPPQRTT";
  char y[] = "ELKNSDUVWELSKJFESD", Y[] = "DKJELKNSUELSDUFEUS";
  char *z[] = {aa,b,cc,d,e,f,g,hh,i,j,k,l,m,n,o,p,q,rr,s,t,u,v,w,x,y};
  char *Z[] = {A ,B,C ,D,E,F,G,H ,I,J,K,L,M,N,O,P,Q,R ,S,T,U,V,W,X,Y};

  for(int _=0;_<25;_++) {
    printf("%s %s: %s\r\n", z[_], Z[_], a(z[_], Z[_]) ? "true" : "false");
  }

  return 0;
}

그런 다음을 사용하여 컴파일하십시오 gcc adj.c -o adj. 출력은 다음과 같습니다.

A A: true
A B: true
C B: true
DD CE: true
DE CF: true
ABCD BCDE: true
AACC BBBD: true
DEEJKNS CDFJLMT: true
DEFGHIJKL CEEHHHJLM: true
IIIJJJKKKLLL HIJJJJJLLLLL: true
ACEGIKMOQSUWY BDFHJLNPRTVXZ: true
QQQQQQQRRRRRSSSTTU PPPPPPPQQQQRTTTTTT: true
DDEEEFJKKLLNSSSUUU DDEEEFJKKLLNSSSUUU: true
A C: false
A Z: false
B J: false
JK J: false
CC AB: false
CE D: false
DEEJKNS CDGJLMT: false
DEFGHIJKL HJLHMCHE: false
IIIJJJKKKLLL HIJJJLLLLLLL: false
ACEGIKMOQSUWY BDFHJLLNQRSXZ: false
QQQQQQQQRRRRSSSTTU PPPPPPQQQQRTTTTTTT: false
DDEEEFJKKLLNSSSUVW DDEEEFJKKLLNSSSUUU: false

파이썬 2, 90 바이트

lambda A,B:all(ord(b)-2<ord(a)<ord(b)+2for a,b in zip(sorted(A),sorted(B)))*len(A)==len(B)

간단한 익명 함수, 나는 zipcontatenate 하기 때문에 길이를 별도로 검사해야합니다 . 빈 문자열을 채우는 비슷한 함수가 itertools( zip_longest)에 있지만 비용이 많이 듭니다.

테스트

f=lambda A,B:all(ord(b)-2<ord(a)<ord(b)+2for a,b in zip(sorted(A),sorted(B)))*len(A)==len(B)

for case in testCases.split('\n'):
    print case, f(*case.split())

생산 :

A A True
A B True
C B True
DD CE True
DE FC True
ABCD BCDE True
AACC DBBB True
DJENSKE FDJCLMT True
DEFGHIJKL HJLEHMCHE True
IKLIJJLIJKKL LJLJLJLJLJHI True
ACEGIKMOQSUWY BLNPRDFTVHXJZ True
QQSQQRRQSTTUQQRRRS PQTTPPTTQTPQPPQRTP True
ELKNSDUUUELSKJFESD DKJELKNSUELSDUFEUS True
A C False
A Z False
B J False
JK J False
CC BA False
CE D False
DJENSKE GDJCLMT False
DEFGHIJKL HJLHMCHE False
IJKLIJKLKIJL LIJLLHJLJLLL  False
AWSUKMEGICOQY RSHXBLJLNQDFZ False
QQSQQRRQSTTUQQQRRS PQTTPPTTQTPQPPQRTT False
ELKNSDUVWELSKJFESD DKJELKNSUELSDUFEUS False

자바 스크립트 (ES6), 86 90 94

편집 4는 저장 들으 @Neil 바이트
편집 2 Mwr247 @ 들으 저장 4 바이트

(a,b)=>[...[...a].sort(),0].every((x,i)=>parseInt(x+([...b].sort()[i]||0),36)%37%36<2)

참고 : 한 쌍의 글자에 대한 인접성 검사. 글자가 같은 경우 쌍을 기본 36 숫자 n 으로 취한 다음를 누릅니다 n = a*36+a = a*37. 1의 차이가 있으면 n = a*36+a+1 = a*37+1또는 n = a*36+a-1 = a*37-1. 따라서 n % 370, 1 또는 36 n%37%36이어야합니다. 0 또는 1이어야합니다.

참고 2 : 추가 된 '0'은 a와 b의 길이가 동일한 지 확인하는 데 사용됩니다. 그때는 더 짧아a.length==b.length

F=(a,b)=>[...[...a].sort(),0].every((x,i)=>parseInt(x+([...b].sort()[i]||0),36)%37%36<2)

console.log=x=>O.textContent+=x+'\n';

testOK=[['A','A'],['A','B'],['C','B'],['DD','CE'],['DE','FC'],
['ABCD','BCDE'],['AACC','DBBB'],['DJENSKE','FDJCLMT'],
['DEFGHIJKL','HJLEHMCHE'],['IKLIJJLIJKKL','LJLJLJLJLJHI'],
['ACEGIKMOQSUWY','BLNPRDFTVHXJZ'],
['QQSQQRRQSTTUQQRRRS','PQTTPPTTQTPQPPQRTP'],
['ELKNSDUUUELSKJFESD','DKJELKNSUELSDUFEUS']];
testFail=[['A','C'],['A','Z'],['B','J'],['JK','J'],['CC','BA'],['CE','D'],
['DJENSKE','GDJCLMT'],['DEFGHIJKL','HJLHMCHE'],
['IJKLIJKLKIJL','LIJLLHJLJLLL',''],
['AWSUKMEGICOQY','RSHXBLJLNQDFZ'],
['QQSQQRRQSTTUQQQRRS','PQTTPPTTQTPQPPQRTT'],
['ELKNSDUVWELSKJFESD','DKJELKNSUELSDUFEUS']];

console.log('TRUE')
testOK.forEach(t=>{
  var a=t[0],b=t[1],r=F(a,b)
  console.log(r+' '+a+' '+b)
})  
console.log('FALSE')
testFail.forEach(t=>{
  var a=t[0],b=t[1],r=F(a,b)
  console.log(r+' '+a+' '+b)
})

<pre id=O></pre>

JavaScript ES6, 117 바이트 116 바이트 111 바이트 109 바이트

(j,k)=>j.length==k.length&&(f=s=>[...s].sort())(j).every((c,i)=>Math.abs(c[h='charCodeAt']()-f(k)[i][h]())<2)

테스트 사례

a=(j,k)=>j.length==k.length&&(f=s=>[...s].sort())(j).every((c,i)=>Math.abs(c[h='charCodeAt']()-f(k)[i][h]())<2);
// true
console.log('A A:', a('A', 'A'));
console.log('A B:', a('A', 'B'));
console.log('C B:', a('C', 'B'));
console.log('DD CE:', a('DD', 'CE'));
console.log('DE FC:', a('DE', 'FC'));
console.log('ABCD BCDE:', a('ABCD', 'BCDE'));
console.log('AACC DBBB:', a('AACC', 'DBBB'));
console.log('DJENSKE FDJCLMT:', a('DJENSKE', 'FDJCLMT'));
console.log('DEFGHIJKL HJLEHMCHE:', a('DEFGHIJKL', 'HJLEHMCHE'));
console.log('IKLIJJLIJKKL LJLJLJLJLJHI:', a('IKLIJJLIJKKL', 'LJLJLJLJLJHI'));
console.log('ACEGIKMOQSUWY BLNPRDFTVHXJZ:', a('ACEGIKMOQSUWY', 'BLNPRDFTVHXJZ'));
console.log('QQSQQRRQSTTUQQRRRS PQTTPPTTQTPQPPQRTP:', a('QQSQQRRQSTTUQQRRRS', 'PQTTPPTTQTPQPPQRTP'));
console.log('ELKNSDUUUELSKJFESD DKJELKNSUELSDUFEUS:', a('ELKNSDUUUELSKJFESD', 'DKJELKNSUELSDUFEUS'));

// false
console.log('A C:', a('A', 'C'));
console.log('A Z:', a('A', 'Z'));
console.log('B J:', a('B', 'J'));
console.log('JK J:', a('JK', 'J'));
console.log('CC BA:', a('CC', 'BA'));
console.log('CE D:', a('CE', 'D'));
console.log('DJENSKE GDJCLMT:', a('DJENSKE', 'GDJCLMT'));
console.log('DEFGHIJKL HJLHMCHE:', a('DEFGHIJKL', 'HJLHMCHE'));
console.log('IJKLIJKLKIJL LIJLLHJLJLLL:', a('IJKLIJKLKIJL', 'LIJLLHJLJLLL'));
console.log('AWSUKMEGICOQY RSHXBLJLNQDFZ:', a('AWSUKMEGICOQY', 'RSHXBLJLNQDFZ'));
console.log('QQSQQRRQSTTUQQQRRS PQTTPPTTQTPQPPQRTT:', a('QQSQQRRQSTTUQQQRRS', 'PQTTPPTTQTPQPPQRTT'));
console.log('ELKNSDUVWELSKJFESD DKJELKNSUELSDUFEUS:', a('ELKNSDUVWELSKJFESD', 'DKJELKNSUELSDUFEUS'));

<!-- results pane console output; see http://meta.stackexchange.com/a/242491 -->
<script src="http://gh-canon.github.io/stack-snippet-console/console.min.js"></script>

신용

• @ rink.attendant.6 5 바이트를 면도
• @ user81655 2 바이트를 깎았습니다.

Pyth, 37 31 바이트

&qZ-FmldK.zqY-m.a-FdCmmCkSdK[Z1

모든 테스트 사례와 함께 온라인으로 사용해보십시오!

단축 된 단축 표기법을 사용하여 6 바이트를 줄 -F였습니다 ( 대신 .U-bZ)

Dennis에서 영감을 얻은 솔루션

codegolf에 첫 번째 제출!

설명

식을 두 부분으로 나눌 수 &있으며 결과를 출력하기 위해 비교됩니다 . 의사 파이썬을 작성하여 설명하려고합니다.

먼저 두 단어의 길이가 같은지 확인합니다

mldK.z         lengths = map(lambda d: len(d), K=all_input())
.U-bZmldK.z    diff = reduce(lambda b, Z: b - Z, lengths)
qZ.U-bZmldK.z  diff == 0

그런 다음 Dennis의 방법을 적용합니다.

       K                                                      # ['CAT', 'SAD']
 m   SdK           sort = map(lambda d: sorted(d), K)         # ['ACT', 'ADS']
 mmCkSdK           ascii = map(lambda d: sorted(d), map(lambda k: ord(k), K))
                                                              # [[65, 67, 84], [65, 68, 83]]
CmmCkSdK           zipped = zip(*ascii)                       # [[65, 65], [67, 68], [84, 83]]
m.U-bZd CmmCkSdK   map(lambda d: d[0] - d[1], zipped)         # [0, -1, 1]
m.a.U-bZd CmmCkSdK map(lambda d: abs(d[0] - d[1]), zipped)    # [0, 1, 1] 

그런 다음 -연산자를 사용하여 [Z1( [0, 1])에 없는 해당 목록의 모든 요소를 ​​필터링 하고 결과가 비어있는 목록인지 확인합니다.qY

JavaScript (ES6), 87 바이트

(a,b)=>![...a].sort().some((d,i)=>(d[c='charCodeAt']()-([...b].sort()[i]||c)[c]())/2|0)

최대 값으로 나눈 다음 비트 단위 "또는"( |) 으로 자르면 0 중심 대칭 범위 검사를 사용합니다 . 두 번의 점검을 수행하는 것보다 짧거나를 사용하는 것보다 짧습니다 Math.abs().

하스켈, 67 63 바이트

import Data.List
f a=any(null.(a\\)).mapM(\x->[pred x..succ x])

사용 예 : f "FREE" "GRRD"-> False.

작동 방식 (참고 : f부분적으로 포인트 b가 없으며 정의에 두 번째 매개 변수 가 표시되지 않음) :

mapM(\x->[pred x..succ x])      -- for each letter of b make a list of the
                                -- predecessor, the letter itself and the successor.
                                -- Make a list of every possible combination
                                -- thereof, e.g "dr" ->
                                -- ["cq","cr","cs","dq","dr","ds","eq","er","es"] 
any(null.(a\\))                 -- see if the difference between any of the
                                -- combinations and the other parameter a is
                                -- empty, i.e. they have the same elements

편집 : @xnor는 저장할 4 바이트를 찾았습니다. 감사!

C, 172 바이트

#define q(x)qsort(x,strlen(x),1,c)
c(x,y)char*x,*y;{return*x-*y;}main(a,v,w)char**v,*w,*a;{for(q(w=v[1]),q(a=v[2]);*w&&*a&&abs(*w-*a)<2;w++,a++);printf("%d",abs(*w-*a)<2);}

테스트 사례

$ bash -x test.sh
+ bash -x test.sh
+ ./a.out A A
1+ ./a.out A B
1+ ./a.out C B
1+ ./a.out DD CE
1+ ./a.out DE FC
1+ ./a.out ABCD BCDE
1+ ./a.out AACC DBBB
1+ ./a.out DJENSKE FDJCLMT
1+ ./a.out DEFGHIJKL HJLEHMCHE
1+ ./a.out IKLIJJLIJKKL LJLJLJLJLJHI
1+ ./a.out ACEGIKMOQSUWY BLNPRDFTVHXJZ
1+ ./a.out QQSQQRRQSTTUQQRRRS PQTTPPTTQTPQPPQRTP
1+ ./a.out ELKNSDUUUELSKJFESD DKJELKNSUELSDUFEUS
1+ ./a.out A C
0+ ./a.out A Z
0+ ./a.out B J
0+ ./a.out JK J
0+ ./a.out CC BA
0+ ./a.out CE D
0+ ./a.out DJENSKE GDJCLMT
0+ ./a.out DEFGHIJKL HJLHMCHE
0+ ./a.out IJKLIJKLKIJL LIJLLHJLJLLL
0+ ./a.out AWSUKMEGICOQY RSHXBLJLNQDFZ
0+ ./a.out QQSQQRRQSTTUQQQRRS PQTTPPTTQTPQPPQRTT
0+ ./a.out ELKNSDUVWELSKJFESD DKJELKNSUELSDUFEUS
0++

PowerShell, 140 바이트

param($a,$b)(($a=[char[]]$a|sort).Count-eq($b=[char[]]$b|sort).Count)-and(($c=0..($a.Count-1)|%{+$a[$_]-$b[$_]}|sort)[0]-ge-1-and$c[-1]-le1)

더 짧아 질 수 있습니다. 현재 Python이나 JavaScript와는 경쟁이 없지만 약간 다른 접근 방식을 사용하므로 게시 할 것이라고 생각했습니다.

설명

이 코드는 PowerShell에 유창하지 않은 사람에게는 혼란 스럽습니다. 가능한 한 영어로 세분화하려고 노력할 것입니다 ...

우리는 param($a,$b)정상적으로 입력 을 시작 합니다.

나머지 코드 전체는 실제로 하나의 명령문이며 연산자를 (...)-and(...)사용하여 두 개의 부울 명령문을 테스트하기 위해 중단 될 수 있습니다 -and.

왼쪽 (... -eq ...)물체는 두 물체의 동등성을 테스트하기 위해 파손될 수 있습니다 . 이 경우 객체는 .Count두 개의 새 문자 배열 의 s (길이)입니다. 각각의 내부 paren ($a=[char[]]$a|sort)은 원래 입력 단어를 가져 와서 문자 배열로 다시 캐스트 한 다음 정렬하여 다시 동일한 변수에 다시 저장합니다. 우리는 모두 그렇게 $a하고 $b. 따라서 왼쪽은 입력 단어의 길이가 같은지 확인합니다. 길이가 같지 않으면 외부 부울 명령문의이 절반이 실패하고 False출력됩니다.

오른쪽으로 이동하여를 사용하여 두 개의 부울 명령문을 다시 테스트 (... -and ...)합니다. 왼쪽 은에서로 음수보다 크거나 같은 것을 테스트합니다 -ge-1. 무언가 구축 된 어레이의 영차-요소 $c에 의해 생성된다 :

• 허용되는 인덱스의 범위를 복용 0..($a.count-1)
• 루프로 파이프 |%{...}
• 루프를 반복 할 때마다 색인 문자의 ASCII 값을 가져와 색인 문자 $a의 ASCII 값을 뺍니다.$b
• 그런 다음 |sort숫자로 표시됩니다

명령문의 다른 쪽은 $c[-1]배열 의 최대 값 을 가져와 로 1보다 작거나 같도록 -le1합니다.

따라서 두 입력 문자열이 실제로 인접한 경우 $c배열은 다음과 같습니다 @(-1,-1,-1...0,0,0...1,1,1). 첫 번째 요소는-1 이고 마지막 요소는입니다 1. 인접하지 않으면 특정 쌍의 ASCII 값 차이가 < -1또는 > 1이므로 외부 부울 테스트의이 절반이 실패하고 False출력됩니다.

양면이 통과 할 경우에만 True문자열이 LA입니다.

녹, 269 264 바이트

fn a(w:&str,x:&str)->bool{if w.len()==x.len(){return{let mut c:Vec<char>=w.chars().collect();let mut d:Vec<char>=x.chars().collect();c.sort();d.sort();for(e,f)in c.iter().zip(d.iter()){if(((*e as u8)as f64)-((*f as u8)as f64)).abs()>1f64{return false}}true}}false}

넓히는:

fn are_adjacent(w: &str, x: &str)->bool{

    if w.len() == x.len(){

        return {

            let mut c : Vec<char> = w.chars().collect();
            let mut d : Vec<char> = x.chars().collect();

            c.sort();
            d.sort();

            for (e,f) in c.iter().zip(d.iter()){
                if (((*e as u8) as f64) - ((*f as u8) as f64)).abs() > 1f64{
                    return false
                } 
            }

            true
        }
    }

    false
}

테스트 사례 :

fn main(){
    assert_eq!(true,are_adjacent("A","B"));
    assert_eq!(true,are_adjacent("A","B"));
    assert_eq!(true,are_adjacent("C","B"));
    assert_eq!(true,are_adjacent("DD","CE"));
    assert_eq!(true,are_adjacent("DE","FC"));
    assert_eq!(true,are_adjacent("ABCD","BCDE"));
    assert_eq!(true,are_adjacent("AACC","DBBB"));
    assert_eq!(true,are_adjacent("DJENSKE","FDJCLMT"));
    assert_eq!(true,are_adjacent("DEFGHIJKL","HJLEHMCHE"));
    assert_eq!(true,are_adjacent("IKLIJJLIJKKL","LJLJLJLJLJHI"));
    assert_eq!(true,are_adjacent("ACEGIKMOQSUWY","BLNPRDFTVHXJZ"));
    assert_eq!(true,are_adjacent("QQSQQRRQSTTUQQRRRS","PQTTPPTTQTPQPPQRTP"));
    assert_eq!(true,are_adjacent("ELKNSDUUUELSKJFESD","DKJELKNSUELSDUFEUS"));

    assert_eq!(false,are_adjacent("A","C"));
    assert_eq!(false,are_adjacent("A","Z"));
    assert_eq!(false,are_adjacent("B","J"));
    assert_eq!(false,are_adjacent("JK","J"));
    assert_eq!(false,are_adjacent("CC","BA"));
    assert_eq!(false,are_adjacent("CE","D"));
    assert_eq!(false,are_adjacent("DJENSKE","GDJCLMT"));
    assert_eq!(false,are_adjacent("DEFGHIJKL","HJLHMCHE"));
    assert_eq!(false,are_adjacent("IJKLIJKLKIJL","LIJLLHJLJLLL"));
    assert_eq!(false,are_adjacent("AWSUKMEGICOQY","RSHXBLJLNQDFZ"));
    assert_eq!(false,are_adjacent("QQSQQRRQSTTUQQQRRS","PQTTPPTTQTPQPPQRTT"));
    assert_eq!(false,are_adjacent("QQSQQRRQSTTUQQQRRS","PQTTPPTTQTPQPPQRTT"));
    assert_eq!(false,are_adjacent("ELKNSDUVWELSKJFESD","DKJELKNSUELSDUFEUS"));
}

APL, 59 바이트 (문자)

(61과 f, 63을 f ←로 공급해야하는 경우)

나는 최고의 APLer는 아니지만 너무 재미있다.

(0=+/2≤|¨∊-/{⎕av⍳⍵}¨(⍺{⌈/⍴¨⍺⍵}⍵)⍴¨⍺[⍋⍺]⍵[⍋⍵])∧=/⍴¨∊¨⍺⍵

=/⍴¨∊¨⍺⍵ 입력이 똑같이 길습니까?

∧ 그리고 아래의 모든

(⍺{⌈/⍴¨⍺⍵}⍵)⍴¨⍺[⍋⍺]⍵[⍋⍵] 두 입력을 정렬하고 두 입력 중 가장 긴 길이를 갖도록 모양을 조정하십시오 (입력 시간보다 길면 줄 바꿈).

|¨∊-/{⎕av⍳⍵} 두 char 벡터를 ASCII 값의 int 벡터로 변환하고 벡터 빼기를 수행하고 모든 값을 절대적으로 변환

0=+/2≤ 2 이상의 값을 합산하고 결과가 0인지 확인

K (oK) , 27 바이트

해결책:

2>|/x*x:-/(|/#:'x)$x@'<:'x:

온라인으로 사용해보십시오!

예 :

2>|/x*x:-/(|/#:'x)$x@'<:'x:("QQSQQRRQSTTUQQRRRS";"PQTTPPTTQTPQPPQRTP")
1
2>|/x*x:-/(|/#:'x)$x@'<:'x:("DEFGHIJKL";"HJLHMCHE")
0
2>|/x*x:-/(|/#:'x)$x@'<:'x:("AAA";"AAA")
1
2>|/x*x:-/(|/#:'x)$x@'<:'x:("AAA";"AA")
0

설명:

먼저 각 문자열을 정렬 한 다음 동일한 길이로 채운 다음 다른 문자열 중 하나를 가져옵니다 (문자의 ASCII 값), 내장이 없으므로 제곱 결과 abs, 최대 차이를 취하고 2보다 작은 지 확인하십시오.

2>|/x*x:-/(|/#:'x)$x@'<:'x: / the solution
                         x: / save input to variable x
                      <:'   / ascending sorted indices (<:) for each (') list
                   x@'      / apply (@) each (') of these indices to the input (x)                             
          (      )$         / pad
             #:'x           / count (#:) each (') list (x)
           |/               / max (|) over (/) to get maximum
        -/                  / subtract (-) over (/) to take 2nd list from 1st
      x:                    / save in variable x
    x*                      / multiply by x (so square)
  |/                        / max over to get maximum distance
2>                          / is 2 greater than (>) to this maximum? returns 1 (true) or 0 (false)

J, 27 바이트

[:*/@(2>|)[:-/,:&(3&u:@/:~)

언 골프

[: */@(2 > |) [: -/ ,:&(3&u:@/:~)

설명

• &(3&u:@/:~) 두 인수를 모두 정렬하여 ASCII 숫자로 변환
• ,: 2 xn 행렬을 작성합니다. 여기서 n은 인수의 문자 수입니다.
• -/ 한 행을 다른 행에서 빼서 해당 문자의 거리를 나타내는 길이 n의 목록을 제공합니다.
• (2>|) 거리의 절대 값이 2보다 작 으면 1을, 그렇지 않으면 0을 반환
• */모든 0s와 1s를 모두 곱합니다 . 따라서 최종 결과는 1이며 해당하는 모든 문자 쌍이 인접 해 있습니다.

온라인으로 사용해보십시오!