Neste desafio, você recebe duas palavras: Seu trabalho é determinar se elas são adjacentes .

Duas letras são adjacentes se:

1. Eles são a mesma letra ou
2. Eles são lexicograficamente adjacentes.

Por exemplo, J é adjacente a I , J e K apenas. Z não é adjacente a A

Duas palavras são adjacentes se:

1. Eles têm o mesmo comprimento e
2. Cada letra é adjacente a uma letra única na outra palavra.

Por exemplo, CAT é adjacente a SAD , como C> D, A> A, T> S .
FREE não é adjacente ao GRRD (cada E precisa de uma letra para emparelhar) .

Entrada / Saída

Você recebe duas cadeias de caracteres e precisa retornar um valor verdadeiro se elas forem adjacentes, caso contrário, um valor falso. Você deve retornar dentro de um minuto para todos os casos de teste abaixo.

Você pode assumir que as seqüências conterão apenas letras alfabéticas maiúsculas.

As duas cadeias podem ser passadas como uma lista ou concatenadas, com ou sem aspas.

Casos de teste

Verdade:

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

Isso é código-golfe , então a resposta mais curta e válida vence!

CJam, 14 13 12 bytes

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

Experimente online! ou verifique todos os casos de teste de uma só vez .

Algoritmo

Let s e t ser dois ordenados palavras do mesmo comprimento. Para que s e t sejam lexicograficamente adjacentes (LA), é necessário e suficiente que todos os pares de seus caracteres correspondentes também sejam LA.

A condição é claramente suficiente para todas as palavras e necessária para palavras de tamanho 1 .

Agora, suponha que s e t tenham comprimento n> 1 e que a e b sejam os primeiros caracteres, respectivamente, de s e t .

Como s e t são LA, existe algum mapeamento bijetivo φ entre os caracteres de s e os caracteres de t, de modo que x e φ (x) são LA para todo x em s , o que significa que | x - φ (x) | ≤ 1 para todos os x em s .

Deixe c = φ (a) e d = φ ^-1 (b) . Por causa de um 's e b ' s minimalidade, um ≤ d (1) e b ≤ c (2) .

Além disso, desde que b e d , e a e c , e LA, d ≤ b + 1 (3) e c ≤ a + 1 (4) .

Ao combinar (1) e (3) e (2) e (4) , obtemos que a ≤ d ≤ b + 1 e b ≤ c ≤ a + 1 , dos quais deduzimos que a - 1 ≤ b ≤ a + 1 e, portanto, que um e b são LA.

Agora, combinando (1) e (4) e (2) e (3) , obtemos que c - 1 ≤ a ≤ d e d - 1 ≤ b ≤ c , a partir da qual deduzimos que c - 1 ≤ d ≤ c + 1 e, portanto, c e d são LA.

Assim, se redefinir φ por φ (a) = b e φ (d) = c , | x - φ (x) | ≤ 1 ainda vai realizar para todos x no s e, em particular, para todo x no s [1:] .

Dessa forma, s [0] = a e t [0] = b e s [1:] e t [1:] são LA.

Como s [1:] tem comprimento n - 1 , isso prova a necessidade por indução.

Código

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 bytes

c!S!odXl2<

Isso usa a abordagem de Dennis : classifique primeiro e compare os caracteres nas posições correspondentes.

A entrada é uma matriz de strings, com o formato {'CAT 'SAD'}.

Saída é uma matriz de zeros e uns. Um resultado é verdadeiro se contiver todos (é acordado que isso é verdade).

Usa a versão atual (10.2.1) , que é anterior a esse desafio.

EDIT: A função Xlfoi renomeada para |nas versões mais recentes do idioma (e onão é mais necessária). O link abaixo inclui essas modificações.

Experimente online!

Explicaçã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

Abordagem antiga, que aceita as seqüências de caracteres como entradas separadas: 12 bytes :

SiSXhcodXl2<

EDIT : o código no link foi modificado de acordo com as alterações no idioma; veja o comentário acima.

Experimente online !

Explicação :

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 bytes

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

Você pode testá-lo salvando isso como adj.he depois usando este adj.carquivo:

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

Em seguida, compile usando gcc adj.c -o adj. A saída é:

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 bytes

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

Função anônima simples, eu tenho que ter uma verificação separada para o comprimento, porque zipapenas contatenar. Existe uma função semelhante em itertools( zip_longest) que preencheria cadeias vazias, mas isso seria bastante caro.

Testando com

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

produz:

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

Editar 4 bytes salvos thx @Neil
Editar 2 4 bytes salvos thx @ Mwr247

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

Nota: verificação de adjacência em um par de letras. Tome o par como um número base 36 n , se as letras forem iguais, então n = a*36+a = a*37. Se houver uma diferença de 1, então n = a*36+a+1 = a*37+1ou n = a*36+a-1 = a*37-1. Portanto, n % 37deve ser 0, 1 ou 36. E n%37%36deve ser 0 ou 1.

Nota 2: o '0' adicionado é usado para garantir que a e b tenham o mesmo comprimento. É mais curto entãoa.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 bytes 116 bytes 111 bytes 109 bytes

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

Casos de teste

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>

Crédito

• @ rink.attendant.6 raspou 5 bytes
• @ user81655 eliminado 2 bytes

Pitão, 37 31 bytes

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

Experimente online com todos os casos de teste!

Retirou 6 bytes usando a notação reduzida reduzida (em -Fvez de .U-bZ)

Solução inspirada em Dennis

Primeira submissão ao codegolf!

Explicação

Podemos dividir a expressão em duas partes, que são comparadas com &a saída do resultado. Vou tentar explicar escrevendo alguns pseudo-Python

Primeiro, verificamos se o comprimento das duas palavras é o mesmo

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

Em seguida, aplicamos o método de 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] 

Em seguida, usamos o -operador para filtrar todos os elementos dessa lista que não estão em [Z1( [0, 1]) e verificar se o resultado é uma lista vazia comqY

JavaScript (ES6), 87 bytes

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

Usa uma verificação de faixa simétrica centrada em zero, dividindo pelo valor máximo e depois truncando com um "ou" ( |) bit a bit . Mais curto do que ter que fazer duas verificações, ou uma com Math.abs().

Haskell, 67 63 bytes

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

Exemplo de uso: f "FREE" "GRRD"-> False.

Como funciona (nota: fé parcialmente isento de pontos e o segundo parâmetro bnão aparece na definição):

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

Edit: @xnor encontrado 4 bytes para salvar. Obrigado!

C, 172 bytes

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

Casos de teste

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

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)

Pode ser possível diminuir isso. No momento, ele não é competitivo com Python ou JavaScript, mas usa uma abordagem um pouco diferente, então achei que eu a publicaria.

Explicação

Esse código é realmente confuso para alguém que não é fluente no PowerShell, então tentarei dividi-lo em inglês da melhor maneira possível ...

Começamos com a entrada param($a,$b)normal.

Todo o restante do código é na verdade uma instrução e pode ser desfeita (...)-and(...)para testar duas instruções booleanas com o -andoperador.

As parênteses à esquerda podem ser quebradas (... -eq ...)para testar a igualdade de dois objetos. Nesse caso, os objetos são os .Counts (ou seja, o comprimento) de dois novos arrays. Cada parêntese interno ($a=[char[]]$a|sort)pega a palavra de entrada original, a lança novamente como uma matriz de caracteres, depois a classifica e salva novamente na mesma variável. Fazemos isso para ambos $ae $b. O lado esquerdo verifica se as palavras de entrada têm o mesmo comprimento. Se eles não tiverem o mesmo comprimento, essa metade da instrução booleana externa falhará e Falseserá gerada.

Passando para o lado direito, estamos novamente testando duas instruções booleanas com (... -and ...). O lado esquerdo testa se algo é maior que ou igual a 1 negativo com -ge-1. O algo é o elemento zeroth de uma matriz construída $c, criada por:

• tomando uma faixa dos índices permitidos 0..($a.count-1)
• canalizado em um loop |%{...}
• a cada iteração do loop, pegamos os valores ASCII do caractere indexado $ae subtraímos o valor ASCII do caractere indexado em$b
• que é |sorteditado pelo valor numérico

O outro lado da instrução pega o valor máximo $c[-1]da matriz e garante que seja menor ou igual a 1 com -le1.

Portanto, se as duas seqüências de entrada forem de fato adjacentes, a $cmatriz será algo como@(-1,-1,-1...0,0,0...1,1,1) . Portanto, o primeiro elemento será -1e o último elemento será 1. Se eles não forem adjacentes, a diferença nos valores ASCII para um par específico será < -1ou > 1, portanto, essa metade do teste booleano externo falhará e Falseserá gerada.

Somente se os dois lados passarem será Trueemitido, e as seqüências de caracteres serão, portanto, LA.

Ferrugem, 269 264 bytes

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}

Expandido:

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
}

Casos de teste:

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

(61 se tivermos de fornecer {e}, 63 com f ←)

Eu não sou o melhor APLer, mas é muito divertido.

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

=/⍴¨∊¨⍺⍵ as entradas são igualmente longas?

∧ e todos os itens abaixo

(⍺{⌈/⍴¨⍺⍵}⍵)⍴¨⍺[⍋⍺]⍵[⍋⍵] classifique as duas entradas e modele-as para que elas sejam tão longas quanto as duas (elas se enrolam se você as alongar mais do que são)

|¨∊-/{⎕av⍳⍵} converte ambos os vetores char em vetores int de seus valores ascii, faça uma subtração vetorial e absoluta todos os valores

0=+/2≤ some valores maiores ou iguais a dois e verifique se o resultado é igual a 0

K (oK) , 27 bytes

Solução:

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

Experimente online!

Exemplos:

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

Explicação:

Primeiro, ordene cada string, depois mantenha o mesmo comprimento e depois pegue um do outro (valores ASCII de caracteres), resultado quadrado como não há built-in abs, faça a diferença máxima e verifique se é menor que 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 bytes

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

destroçado

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

explicado

• &(3&u:@/:~) classifica os dois argumentos e os converte em números ascii
• ,: cria uma matriz 2 xn, em que n é o número de caracteres dos argumentos
• -/ subtrai uma linha da outra, fornecendo uma lista do comprimento n que representa a distância dos caracteres correspondentes
• (2>|) retorna 1 se o valor absoluto da distância for menor que 2, 0 caso contrário
• */multiplica todos os se 0es 1juntos: portanto, o resultado final é 1 se todos os pares de caracteres correspondentes forem adjacentes.

Experimente online!