У цьому виклику вам передають два слова: Ваше завдання - визначити, чи вони суміжні .

Дві букви суміжні, якщо:

1. Вони однакові букви, або
2. Вони лексикографічно суміжні.

Наприклад, J примикає до I , J і K тільки. Z не примикає до A

Два слова є суміжними, якщо:

1. Вони однакової довжини, і
2. Кожна літера сусідить з унікальною літерою іншим словом.

Наприклад, КПП примикає до САД , так як C> D, A> A, T> S .
БЕЗКОШТОВНО не примикає до GRRD (кожному E потрібен лист для пари) .

Введення-виведення

Вам передаються два рядки, і вам потрібно повернути триєдине значення, якщо вони суміжні, інакше помилкове значення. Ви повинні повернутися протягом хвилини для всіх тестових випадків нижче.

Можна припустити, що рядки будуть містити лише великі, алфавітні літери.

Два рядки можуть бути передані у вигляді списку, або об'єднані, з лапками або без них.

Випробування

Truthy:

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

Це кодовий гольф , тому найкоротша правильна відповідь виграє!

CJam, 14 13 12 байт

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

Спробуйте в Інтернеті! або перевірити всі тестові справи одразу .

Алгоритм

Нехай s і t - два сортовані слова однакової довжини. Щоб s і t були лексикографічно суміжними (LA), необхідно і достатньо, щоб усі пари відповідних символів були також LA.

Ця умова явно достатня для всіх слів і необхідна для слів довжиною 1 .

Тепер припустимо, що s і t мають довжину n> 1 , і нехай a і b будуть першими символами, відповідно, s і t .

Оскільки s і t - LA, існує деяке бієктивне відображення φ між символами s та символами t таким чином, що x і φ (x) - LA для всіх x in s , тобто | x - φ (x) | ≤ 1 для всіх х в с .

Нехай c = φ (a) і d = φ ^-1 (b) . Через мінімальність a 'і b ' a ≤ 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<

Для цього використовується підхід Денніса : сортуйте спочатку і порівнюйте персонажів у відповідних позиціях.

Введення - це масив рядків з форматом {'CAT 'SAD'}.

Вихід - це масив нулів і одиниць. Результатом є truthy iff, якщо він містить усі (це погодиться бути truthy).

Використовується поточний випуск (10.2.1) , який є раніше, ніж цей виклик.

EDIT: Функція 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<

EDIT : код у посиланні змінено відповідно до змін мови; див. коментар вище.

Спробуйте в Інтернеті !

Пояснення :

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

Змінити 4 байти збережено thx @Neil
Змінити 2 4 байти зберегти thx @ Mwr247

(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 байт
• @ користувач81655 поголив 2 байти

Pyth, 37 31 байт

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

Спробуйте в Інтернеті з усіма тестовими кейсами!

Поголили 6 байтів, використовуючи скорочені позначення скорочення ( -Fзамість .U-bZ)

Рішення, натхнене Деннісом

Перше подання на кодогольф!

Пояснення

Ми можемо розділити вираз на дві частини, які порівнюються з &результатом. Спробую пояснити, написавши якийсь псевдо-Пітон

Спочатку перевіряємо, чи довжина двох слів однакова

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)

Використовує перевірку симетричного діапазону нульоцентричного діапазону шляхом ділення на значення max, а потім обрізання на бітові "або" ( |). Коротше, ніж робити два перевірки, або один з 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не відображається у визначенні):

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 ...)для перевірки рівності двох об'єктів. У цьому випадку об'єктами є .Counts (тобто довжина) двох нових char-масивів. Кожен внутрішній батько ($a=[char[]]$a|sort)приймає оригінальне введене слово, повторно вводить його як масив char, потім сортує його та знову зберігає в ту саму змінну. Ми робимо це для обох $aі $b. Лівий бік таким чином перевіряє, чи є вхідні слова однакової довжини. Якщо вони не однакової довжини, ця половина зовнішнього булевого твердження вийде з ладу і Falseбуде виведена.

Переходячи до правого боку, ми знову тестуємо два булеві твердження за допомогою (... -and ...). Ліва сторона перевіряє, чи є щось більше, ніж або рівне мінус 1 -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, якщо нам доведеться поставити {and}, 63 f f ←)

Я не найбільший APLer, але це просто занадто весело.

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

=/⍴¨∊¨⍺⍵ чи вхід однаковий?

∧ і все нижче

(⍺{⌈/⍴¨⍺⍵}⍵)⍴¨⍺[⍋⍺]⍵[⍋⍵] сортуйте обидва входи та сформуйте їх так довго, як найдовший з двох (вони загортаються, якщо ви зробите їх довше, ніж вони є)

|¨∊-/{⎕av⍳⍵} перетворять обидва char вектори в int вектори їх значень ascii, роблять векторне віднімання та абсолютні всі значення

0=+/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>|) повертає 1, якщо абсолютне значення відстані менше 2, 0 в іншому випадку
• */помножує всі ці 0s і 1s разом: отже, кінцевий результат дорівнює 1, якщо всі пари відповідних знаків суміжні.

Спробуйте в Інтернеті!