В этом задании вам передают два слова: ваша задача - определить, находятся ли они рядом .

Две буквы соседствуют, если:

1. Это одно и то же письмо, или
2. Они лексикографически смежные.

Например, J примыкает к I , J и K только. Z не соседствует с A

Два слова соседствуют, если:

1. Они одинаковой длины и
2. Каждая буква соседствует с уникальной буквой в другом слове.

Например, КПП примыкает к САД , так как C> D, A> A, T> S .
FREE не примыкает к 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

Falsy:

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 в s , что означает, что | x - φ (x) | ≤ 1 для всех х в с .

Пусть c = φ (a) и d = φ ^-1 (b) . Из-за минимальности a 's и 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 в s и, в частности, для всех x в 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 тогда и только тогда она содержит все те (это согласовано быть truthy).

Использует текущий выпуск (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

Редактировать 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 байтов
• @ user81655 сбрил 2 байта

Pyth, 37 31 байт

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

Попробуйте онлайн со всеми тестовыми примерами!

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

Решение, вдохновленное Деннисом

Первая подача в 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

Затем мы применяем метод Денниса:

       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)

Используется проверка симметричного диапазона с нулевым центрированием путем деления на максимальное значение, а затем усечения с побитовым «или» ( |). Короче, чем две проверки или одна с 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 (то есть длина) двух новых символьных массивов. Каждое внутреннее имя ($a=[char[]]$a|sort)берет исходное входное слово, повторно преобразует его в массив символов, затем сортирует его и снова сохраняет в ту же переменную. Мы делаем это для обоих $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}

Expanded:

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, если мы должны снабдить {и}, 63 с f ←)

Я не лучший APLer, но это слишком весело.

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

=/⍴¨∊¨⍺⍵ входы одинаково длинны?

∧ и все ниже

(⍺{⌈/⍴¨⍺⍵}⍵)⍴¨⍺[⍋⍺]⍵[⍋⍵] сортируйте оба входа и формируйте их так, чтобы они были самыми длинными из них (они оборачиваются, если вы сделаете их длиннее, чем они есть)

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

0=+/2≤ суммируйте значения, большие или равные двум, и проверьте, равен ли результат 0

K (ок) , 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:@/:~)

ungolfed

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

объяснил

• &(3&u:@/:~) сортирует оба аргумента и конвертирует их в числа ascii
• ,: создает матрицу 2 xn, где n - количество символов в аргументах
• -/ вычитает одну строку из другой, давая список длины n, представляющий расстояние соответствующих символов
• (2>|) возвращает 1, если абсолютное значение расстояния меньше 2, в противном случае 0
• */умножает все эти 0s и 1s вместе: следовательно, конечный результат равен 1, если все пары соответствующих символов смежны.

Попробуйте онлайн!