このチャレンジでは、2つの単語が渡されます。あなたの仕事は、それらが隣接しているかどうかを判断することです。

次の場合、2つの文字が隣接しています。

1. 同じ文字、または
2. それらは辞書的に隣接しています。

たとえば、JはI、J、およびKのみに隣接しています。 ZはAに隣接していません

次の場合、2つの単語が隣接します。

1. それらは同じ長さであり、
2. 各文字は、他の単語の一意の文字に隣接しています。

たとえば、C> D、A> A、T> Sのように、CATはSADに隣接しています。FREEはGRRDに隣接していません（各Eとペアにする文字が必要
です）。

入出力

2つの文字列が渡され、それらが隣接している場合は真の値を返し、そうでない場合は偽の値を返す必要があります。以下のすべてのテストケースについては、1分以内に戻る必要があります。

文字列には大文字のアルファベットのみが含まれると想定できます。

2つの文字列は、引用符付きまたは引用符なしでリストとして渡すか、連結できます。

テストケース

真実：

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,-!

オンラインでお試しください！または、すべてのテストケースを一度に検証します。

アルゴリズム

レッツSとTは、同じ長さの2つのソート言葉も。以下のためにSとT（LA）辞書式に隣接するように、その対応する文字のすべての対もLAであることが必要かつ十分です。

条件は、すべての単語に対して明らかに十分であり、長さ1の単語に必要です。

ここで、sとtの長さがn> 1であり、aとbがそれぞれsとtの最初の文字であると仮定します。

以来、SおよびTは、いくつかの全単射マッピングが存在し、LAであるφの文字間Sとの文字TようにX及びφ（x）はすべてのためにLAであるXでのその意味、| X - φ（X）は、| ≤1すべてのためのxにおけるsの。

ましょC =φ（）およびD =φ ^-1（B） 。以下のための、およびBの極小、≤D（1）及びB≤C（2） 。

さらに、bとd、およびaとc、およびLAであるため、d≤b + 1（3）およびc≤a + 1（4）となります。

組み合わせることにより、（1）と（3） 、及び（2）及び（4） 、我々は、その取得≤D≤B + 1およびB≤C≤A + 1、我々は推測そこから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です。

したがって、我々は再定義する場合はφによってφ（）= Bとφ（D）= C、| X - φ（x）は| ≤1は、sのすべてのx、特にs [1：]のすべてのxに対して保持されます。

このように、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<

これはデニスのアプローチを使用します。最初にソートし、一致する位置の文字を比較します。

入力は、形式の文字列の配列です{'CAT 'SAD'}。

出力はゼロと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

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

単純な匿名関数zipです。連結するだけなので、長さを個別にチェックする必要があります。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

JavaScript（ES6）、86 90 94

THX @Neilを保存した4バイトを編集します。THX @ Mwr247を保存した
2バイトを編集します。

(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 % 37、0、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

すべてのテストケースでオンラインで試してください！

短縮された縮小表記を使用して（の-F代わりに.U-bZ）6バイト削ります

デニスに触発されたソリューション

codegolfへの最初の提出！

説明

式を2つの部分に分割し、それらを比較し&て結果を出力できます。疑似Pythonを書いて説明しよう

まず、2つの単語の長さが同じであることを確認します

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

次に、デニスの方法を適用します。

       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)

最大値で除算し、ビット単位の「or」（|）で切り捨てることにより、ゼロ中心の対称範囲チェックを使用します。2つのチェック、または1つのチェックを行うよりも短いMath.abs()。

Haskell、67 63バイト

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

使用例：f "FREE" "GRRD"-> False。

仕組み（注：f部分的にポイントbがなく、2番目のパラメーターは定義に表示されません）：

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)通常どおり入力を開始することから始めます。

残りのコード全体は実際には1つのステートメントであり(...)-and(...)、-and演算子を使用して2つのブールステートメントをテストするために分割できます。

左側の括弧は(... -eq ...)、2つのオブジェクトの等価性をテストするために破損する可能性があります。この場合、オブジェクトは.Count2つの新しい文字配列のs（つまり長さ）です。各内部括弧($a=[char[]]$a|sort)は、元の入力ワードを取得し、それをchar-arrayとして再キャストし、ソートして同じ変数に再保存します。との両方で$aそれを行い$bます。したがって、左側では、入力語が同じ長さであることを確認します。それらが同じ長さでない場合、外側のブール文のこの半分は失敗し、False出力されます。

右側に移動して、再び2つのブールステートメントをテストしてい(... -and ...)ます。左側は、何かがで負の1以上であるかどうかをテストし-ge-1ます。何かが構築され、配列の0番目の要素である$cによって作成され、：

• 許可されたインデックスの範囲を取ります 0..($a.count-1)
• ループにパイプ |%{...}
• ループの各反復で、インデックス付き文字$aのASCII値を取得し、インデックス付き文字のASCII値を減算します$b
• その後|sort、数値によって編集されます

ステートメントのもう一方の側は、$c[-1]配列の最大値を取り、それが1以下であることを保証し-le1ます。

したがって、2つの入力文字列が実際に隣接している場合、$c配列はのようなものになります@(-1,-1,-1...0,0,0...1,1,1)。したがって、最初の要素はに-1なり、最後の要素はになります1。それらが隣接していない場合、特定のペアのASCII値の差のいずれかであろう< -1、または> 1、外側ブールテストのこの半分は失敗するので、とFalse出力されます。

両方のパスがTrue出力される場合にのみ、文字列はLAです。

さび、269264バイト

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）

私は最高のAPLerではありませんが、とても楽しいです。

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

=/⍴¨∊¨⍺⍵ 入力は等しく長いですか？

∧ 以下のすべて

(⍺{⌈/⍴¨⍺⍵}⍵)⍴¨⍺[⍋⍺]⍵[⍋⍵] 両方の入力を並べ替えて、2つの入力の中で最長になるように整形します（入力を長くすると、折り返します）

|¨∊-/{⎕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

説明：

最初に各文字列を並べ替え、次に同じ長さになるようにパディングし、次に他の文字列から1つ（文字の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:@/:~) 両方の引数をソートし、それらにアスキー数値に変換します
• ,: 2 xn行列を作成します。ここで、nは引数の文字数です
• -/ ある行を他の行から減算し、対応する文字の距離を表す長さnのリストを提供します
• (2>|) 距離の絶対値が2より小さい場合は1を返し、そうでない場合は0を返します
• */これらすべての0sと1sを乗算します。したがって、最終結果は、対応するcharのすべてのペアが隣接している場合に1になります。

オンラインでお試しください！