Trong thử thách này, bạn được thông qua hai từ: Công việc của bạn là xác định xem chúng có liền kề nhau không .

Hai chữ cái liền kề nếu:

1. Chúng là cùng một chữ cái, hoặc
2. Chúng liền kề từ vựng.

Ví dụ, J là tiếp giáp với tôi , J và K mà thôi. Z không kề A

Hai từ liền kề nếu:

1. Chúng có cùng chiều dài, và
2. Mỗi chữ cái liền kề với một chữ cái duy nhất trong từ khác.

Ví dụ, CAT tiếp giáp với SAD , như C> D, A> A, T> S .
MIỄN PHÍ không liền kề với GRRD (mỗi E cần một chữ cái để ghép với) .

Đầu ra đầu vào

Bạn được thông qua hai chuỗi và bạn cần trả về một giá trị trung thực nếu chúng nằm liền kề, nếu không là giá trị giả. Bạn nên quay lại trong vòng một phút cho tất cả các trường hợp thử nghiệm dưới đây.

Bạn có thể giả sử rằng các chuỗi sẽ chỉ chứa chữ hoa, chữ cái.

Hai chuỗi có thể được thông qua dưới dạng một danh sách, hoặc nối, có hoặc không có dấu ngoặc kép.

Các trường hợp thử nghiệm

Sự thật:

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

Giả mạo:

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

Đây là môn đánh gôn , vì vậy câu trả lời hợp lệ ngắn nhất sẽ thắng!

CJam, 14 13 12 byte

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

Hãy thử trực tuyến! hoặc xác minh tất cả các trường hợp thử nghiệm cùng một lúc .

Thuật toán

Đặt s và t là hai từ được sắp xếp có cùng độ dài. Để s và t liền kề từ vựng (LA), điều cần thiết và đủ là tất cả các cặp ký tự tương ứng của nó cũng là LA.

Điều kiện rõ ràng là đủ cho tất cả các từ và cần thiết cho các từ có độ dài 1 .

Bây giờ, giả sử s và t có độ dài n> 1 , và để a và b là các ký tự đầu tiên, resp., Của s và t .

Vì s và t là LA, nên có một số ánh xạ phỏng đoán φ giữa các ký tự của s và các ký tự của t sao cho x và (x) là LA cho tất cả x trong s , có nghĩa là | x - φ (x) | ≤ 1 cho tất cả x tính bằng s .

Đặt c = φ (a) và d = φ ^-1 (b) . Do tính tối thiểu của a và b , a ≤ d (1) và b ≤ c (2) .

Hơn nữa, vì b và d , và a và c , và LA, d ≤ b + 1 (3) và c ≤ a + 1 (4) .

Bằng cách kết hợp (1) và (3) và (2) và (4) , chúng ta có được a ≤ d ≤ b + 1 và b ≤ c ≤ a + 1 , từ đó ta suy ra rằng a - 1 b a + 1 và, do đó, a và b là LA.

Bây giờ, bằng cách kết hợp (1) và (4) , và (2) và (3) , chúng ta có được c - 1 a ≤ d và d - 1 b ≤ c , từ đó chúng ta suy ra rằng c - 1 d ≤ c + 1 và do đó c và d là LA.

Do đó, nếu chúng ta xác định lại φ bởi (a) = b và (d) = c , | x - φ (x) | ≤ 1 sẽ vẫn giữ cho tất cả x trong s và đặc biệt, cho tất cả x trong s [1:] .

Theo cách này, s [0] = a và t [0] = b và s [1:] và t [1:] , là LA.

Vì s [1:] có độ dài n - 1 , điều này chứng tỏ sự cần thiết bằng cảm ứng.

Mã

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 byte

c!S!odXl2<

Điều này sử dụng phương pháp của Dennis : sắp xếp trước và so sánh các ký tự trong các vị trí khớp.

Đầu vào là một chuỗi các chuỗi, với định dạng {'CAT 'SAD'}.

Đầu ra là một mảng các số không và số một. Một kết quả là sự thật nếu nó chứa tất cả những cái (điều này được đồng ý là sự thật).

Sử dụng bản phát hành hiện tại (10.2.1) , sớm hơn thử thách này.

EDIT: Chức năng Xlđã được đổi tên thành |các phiên bản mới hơn của ngôn ngữ (và okhông còn cần thiết nữa). Liên kết dưới đây bao gồm những sửa đổi.

Hãy thử trực tuyến!

Giải thích :

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

Cách tiếp cận cũ, chấp nhận các chuỗi dưới dạng đầu vào riêng biệt: 12 byte :

SiSXhcodXl2<

EDIT : mã trong liên kết đã được sửa đổi theo các thay đổi trong ngôn ngữ; xem bình luận ở trên.

Hãy thử trực tuyến !

Giải thích :

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 byte

#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;}

Bạn có thể kiểm tra nó bằng cách lưu nó adj.hvà sau đó sử dụng adj.ctệp này :

#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;
}

Sau đó biên dịch bằng cách sử dụng gcc adj.c -o adj. Đầu ra là:

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

Python 2, 90 byte

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

Chức năng ẩn danh đơn giản, tôi phải có một kiểm tra riêng về độ dài vì zipsẽ chỉ tương tác. Có một hàm tương tự trong itertools( zip_longest) sẽ đệm các chuỗi trống, nhưng điều đó sẽ khá tốn kém.

Kiểm tra với

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

sản xuất:

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

JavaScript (ES6), 86 90 94

Chỉnh sửa 4 byte đã lưu thx @Neil
Chỉnh sửa 2 4 byte lưu thx @ Mwr247

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

Lưu ý: kiểm tra kề nhau trên một cặp chữ cái. Lấy cặp làm cơ sở 36 số n , nếu các chữ cái bằng nhau, thì n = a*36+a = a*37. Nếu có chênh lệch 1 thì n = a*36+a+1 = a*37+1hay n = a*36+a-1 = a*37-1. Vậy n % 37phải là 0, 1 hoặc 36. Và n%37%36phải là 0 hoặc 1.

Lưu ý 2: '0' được thêm vào được sử dụng để đảm bảo rằng a và b có cùng độ dài. Nó ngắn hơn rồia.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 byte 116 byte 111 byte 109 byte

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

Các trường hợp thử nghiệm

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>

tín dụng

• @ rink.attguard.6 cạo đi 5 byte
• @ user81655 cạo đi 2 byte

Bình thường, 37 31 byte

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

Hãy thử trực tuyến với tất cả các trường hợp thử nghiệm!

Cạo sạch 6 byte bằng cách sử dụng ký hiệu rút gọn rút gọn ( -Fthay vì .U-bZ)

Giải pháp lấy cảm hứng từ Dennis

Trình đầu tiên cho codegolf!

Giải trình

Chúng ta có thể chia biểu thức thành hai phần, được so sánh với &kết quả đầu ra. Tôi sẽ cố gắng giải thích bằng cách viết một số giả Python

Đầu tiên chúng tôi kiểm tra xem độ dài của hai từ có giống nhau không

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

Sau đó, chúng tôi áp dụng phương pháp của 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] 

Sau đó, chúng tôi sử dụng -toán tử để lọc tất cả các thành phần của danh sách đó không có trong [Z1( [0, 1]) và kiểm tra xem kết quả có phải là danh sách trống khôngqY

JavaScript (ES6), 87 byte

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

Sử dụng kiểm tra phạm vi đối xứng trung tâm bằng không bằng cách chia cho giá trị tối đa, sau đó cắt ngắn bằng bitwise "hoặc" ( |). Ngắn hơn là phải thực hiện hai kiểm tra, hoặc một với Math.abs().

Haskell, 67 63 byte

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

Ví dụ sử dụng: f "FREE" "GRRD"-> False.

Cách thức hoạt động (lưu ý: flà một phần không có điểm và tham số thứ hai bkhông xuất hiện trong định nghĩa):

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

Chỉnh sửa: @xnor tìm thấy 4 byte để lưu. Cảm ơn!

C, 172 byte

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

Các trường hợp thử nghiệm

$ 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 byte

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)

Có thể có được điều này ngắn hơn. Hiện tại nó không cạnh tranh được với Python hoặc JavaScript, nhưng nó sử dụng một cách tiếp cận hơi khác, vì vậy tôi nghĩ rằng tôi sẽ đăng nó.

Giải trình

Mã này thực sự khó hiểu đối với người không rành về PowerShell, vì vậy tôi sẽ cố gắng chia nó thành tiếng Anh tốt nhất có thể ...

Chúng tôi bắt đầu với việc lấy đầu vào param($a,$b)như bình thường.

Toàn bộ phần còn lại của mã thực sự là một câu lệnh và có thể được phá vỡ (...)-and(...)để kiểm tra hai câu lệnh Boolean với -andtoán tử.

Các parens bên tay trái có thể được phá vỡ (... -eq ...)để kiểm tra sự bằng nhau của hai đối tượng. Trong trường hợp này, các đối tượng là .Counts (nghĩa là độ dài) của hai mảng char mới. Mỗi paren bên trong ($a=[char[]]$a|sort)lấy từ đầu vào ban đầu, đặt lại nó thành một mảng char, sau đó sắp xếp nó và lưu lại vào cùng một biến. Chúng tôi làm điều đó cho cả hai $avà $b. Do đó, phía bên trái xác minh rằng các từ đầu vào có cùng độ dài. Nếu chúng không cùng độ dài, nửa câu lệnh Boolean bên ngoài này sẽ thất bại và Falsesẽ là đầu ra.

Di chuyển sang phía bên tay phải, chúng tôi lại kiểm tra hai câu lệnh Boolean với (... -and ...). Phía bên trái kiểm tra xem một cái gì đó lớn hơn hoặc bằng với âm 1 với -ge-1. Cái gì đó là phần tử zeroth của một mảng được xây dựng $c, được tạo bởi:

• lấy một loạt các chỉ số được phép 0..($a.count-1)
• dẫn vào một vòng lặp |%{...}
• mỗi lần lặp của vòng lặp, chúng ta lấy các giá trị ASCII của ký tự được lập chỉ mục $avà trừ giá trị ASCII của ký tự được lập chỉ mục trong$b
• mà sau đó được |sorted bởi giá trị số

Mặt khác của câu lệnh lấy giá trị tối đa $c[-1]của mảng và đảm bảo nó nhỏ hơn hoặc bằng 1 với -le1.

Vì vậy, nếu hai chuỗi đầu vào thực sự liền kề nhau, $cmảng sẽ giống như thế @(-1,-1,-1...0,0,0...1,1,1). Vì vậy, yếu tố đầu tiên sẽ là -1và yếu tố cuối cùng sẽ là 1. Nếu chúng không liền kề, sự khác biệt về giá trị ASCII cho một cặp cụ thể sẽ là < -1hoặc > 1, do đó, một nửa thử nghiệm Boolean bên ngoài này sẽ thất bại và Falsesẽ là đầu ra.

Chỉ khi cả hai bên vượt qua sẽ Truelà đầu ra và do đó chuỗi là LA.

Rust, 269 264 byte

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}

Mở rộng:

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
}

Các trường hợp thử nghiệm:

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 byte (ký tự)

(61 nếu chúng tôi phải cung cấp {và}, 63 với f ←)

Tôi không phải là APLer vĩ đại nhất, nhưng nó quá vui.

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

=/⍴¨∊¨⍺⍵ đầu vào có dài bằng nhau không?

∧ và tất cả những điều dưới đây

(⍺{⌈/⍴¨⍺⍵}⍵)⍴¨⍺[⍋⍺]⍵[⍋⍵] sắp xếp cả hai yếu tố đầu vào và định hình chúng dài nhất trong số hai đầu vào (chúng sẽ quấn quanh nếu bạn làm chúng dài hơn chúng)

|¨∊-/{⎕av⍳⍵} chuyển đổi cả vectơ char thành vectơ int của các giá trị ascii của chúng, thực hiện phép trừ vectơ và tuyệt đối tất cả các giá trị

0=+/2≤ tổng các giá trị lớn hơn hoặc bằng hai và kiểm tra xem kết quả có bằng 0 không

K (oK) , 27 byte

Dung dịch:

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

Hãy thử trực tuyến!

Ví dụ:

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

Giải trình:

Đầu tiên, sắp xếp từng chuỗi, sau đó đệm để có cùng độ dài, sau đó lấy một chuỗi từ các giá trị khác (giá trị ASCII của ký tự), kết quả vuông vì không có tích hợp abs, lấy chênh lệch tối đa và kiểm tra xem có nhỏ hơn 2 không.

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 byte

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

vô dụng

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

giải thích

• &(3&u:@/:~) sắp xếp cả hai đối số và chuyển đổi chúng thành số ascii
• ,: tạo ma trận 2 xn, trong đó n là số ký tự của các đối số
• -/ trừ đi một hàng từ hàng kia, đưa ra một danh sách độ dài n biểu thị khoảng cách của các ký tự tương ứng
• (2>|) trả về 1 nếu giá trị tuyệt đối của khoảng cách nhỏ hơn 2, 0 nếu không
• */nhân tất cả các 0s và 1s đó với nhau: do đó, kết quả cuối cùng là 1 iff tất cả các cặp ký tự tương ứng liền kề nhau.

Hãy thử trực tuyến!