En este desafío, se le pasan dos palabras: su trabajo es determinar si son adyacentes .

Dos letras son adyacentes si:

1. Son la misma letra, o
2. Son lexicográficamente adyacentes.

Por ejemplo, J es adyacente a I , J y K solamente. Z no es adyacente a A

Dos palabras son adyacentes si:

1. Son de la misma longitud, y
2. Cada letra es adyacente a una letra única en la otra palabra.

Por ejemplo, CAT es adyacente a SAD , como C> D, A> A, T> S .
FREE no es adyacente a GRRD (cada E necesita una letra para emparejarse) .

De entrada y salida

Se le pasan dos cadenas y necesita devolver un valor verdadero si son adyacentes, de lo contrario, un valor falso. Debe regresar dentro de un minuto para todos los casos de prueba a continuación.

Puede suponer que las cadenas solo contendrán letras alfabéticas en mayúsculas.

Las dos cadenas pueden pasarse como una lista, o concatenarse, con o sin comillas.

Casos de prueba

Verdad:

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

Este es el código de golf , por lo que gana la respuesta válida más corta.

CJam, 14 13 12 bytes

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

Pruébalo en línea! o verificar todos los casos de prueba a la vez .

Algoritmo

Let s y t ser ordenados dos palabras de la misma longitud. Para s y t a ser lexicográficamente adyacente (LA), es necesario y suficiente que todos los pares de sus caracteres correspondientes son también LA.

La condición es claramente suficiente para todas las palabras y necesaria para palabras de longitud 1 .

Ahora, supongamos que s y t tienen longitud n> 1 , y sea una y b ser los primeros caracteres, resp., De s y t .

Dado que s y t son LA, hay una cierta biyectiva φ entre los personajes de s y los personajes de t tal que x y φ (x) se Ángeles para todo x en s , lo que significa que | x - φ (x) | ≤ 1 para todas las x en s .

Deje c = φ (a) y d = φ ^-1 (b) . Debido a la minimidad de a y de b , a ≤ d (1) y b ≤ c (2) .

Además, desde b y d , y a y c , y LA, d ≤ b + 1 (3) y c ≤ a + 1 (4) .

Al combinar (1) y (3) , y (2) y (4) , obtenemos que a ≤ d ≤ b + 1 y b ≤ c ≤ a + 1 , de donde deducimos que a - 1 ≤ b ≤ a + 1 y, por tanto, que una y b son lA.

Ahora, combinando (1) y (4) , y (2) y (3) , obtenemos que c - 1 ≤ a ≤ d y d - 1 ≤ b ≤ c , de donde deducimos que c - 1 ≤ d ≤ c + 1 y, por tanto, que c y d son LA.

Por lo tanto, si redefinimos φ por φ (a) = b y φ (D) = c , | x - φ (x) | ≤ 1 se mantendrá para todas las x en s y, en particular, para todas las x en s [1:] .

De esta manera, es [0] = A y T [0] = b , y s [1:] y t [1:] , son LA.

Como s [1:] tiene una longitud n - 1 , esto demuestra la necesidad por inducción.

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<

Esto utiliza el enfoque de Dennis : ordenar primero y comparar caracteres en posiciones coincidentes.

La entrada es una matriz de cadenas, con el formato {'CAT 'SAD'}.

La salida es una matriz de ceros y unos. Un resultado es verdadero si contiene todos (se acuerda que es verdadero).

Utiliza la versión actual (10.2.1) , que es anterior a este desafío.

EDITAR: Se Xlha cambiado el nombre de la función |en las versiones más nuevas del idioma (y oya no es necesario). El siguiente enlace incluye esas modificaciones.

Pruébalo en línea!

Explicacion :

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

Enfoque antiguo, que acepta las cadenas como entradas separadas: 12 bytes :

SiSXhcodXl2<

EDITAR : el código en el enlace ha sido modificado según los cambios en el idioma; Ver comentario arriba.

Pruébalo en línea !

Explicacion :

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

Puede probarlo guardando eso como adj.hy luego usando este adj.carchivo:

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

Luego compila usando gcc adj.c -o adj. El resultado es:

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)

Función anónima simple, tengo que tener una verificación de longitud por separado porque zipsolo contaminaré. Hay una función similar en itertools( zip_longest) que rellenaría cadenas vacías, pero sería bastante costoso.

Prueba con

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

produce:

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 guardados thx @Neil
Editar 2 4 bytes guardar thx @ Mwr247

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

Nota: comprobación de adyacencia en un par de letras. Tome el par como base 36 número n , si las letras son iguales, entonces n = a*36+a = a*37. Si hay una diferencia de 1, entonces n = a*36+a+1 = a*37+1o n = a*36+a-1 = a*37-1. Entonces n % 37debe ser 0, 1 o 36. Y n%37%36debe ser 0 o 1.

Nota 2: el '0' agregado se utiliza para garantizar que ayb tengan la misma longitud. Es más corto quea.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 prueba

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 afeitado 5 bytes
• @ user81655 afeitado 2 bytes

Pyth, 37 31 bytes

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

¡Pruébelo en línea con todos los casos de prueba!

Afeitado de 6 bytes mediante el uso de la notación reducida de reducción (en -Flugar de .U-bZ)

Solución inspirada en Dennis

Primera sumisión a codegolf!

Explicación

Podemos dividir la expresión en dos partes, que se comparan con la &salida del resultado. Trataré de explicar escribiendo algunos pseudo-Python

Primero comprobamos que la longitud de las dos palabras es la misma

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

Luego, aplicamos el 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] 

Luego usamos el -operador para filtrar todos los elementos de esa lista que no están en [Z1( [0, 1]), y verificamos que el resultado sea una lista vacía conqY

JavaScript (ES6), 87 bytes

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

Utiliza una verificación de rango simétrico centrado en cero dividiendo por el valor máximo, luego truncando con un bit "o" ( |). Más corto que tener que hacer dos controles, o uno con Math.abs().

Haskell, 67 63 bytes

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

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

Cómo funciona (nota: festá parcialmente libre de puntos y el segundo parámetro bno aparece en la definición):

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

Editar: @xnor encontró 4 bytes para guardar. ¡Gracias!

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 prueba

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

Podría ser posible acortar esto. Actualmente no es competitivo con Python o JavaScript, pero utiliza un enfoque ligeramente diferente, así que pensé que lo publicaría.

Explicación

Este código es realmente confuso para alguien que no domina PowerShell, por lo que intentaré descomponerlo en inglés lo mejor que pueda ...

Comenzamos con la entrada de param($a,$b)forma normal.

El resto del código es en realidad una declaración, y se puede dividir (...)-and(...)para probar dos declaraciones booleanas con el -andoperador.

Los parens de la izquierda se pueden dividir (... -eq ...)para probar la igualdad de dos objetos. En este caso, los objetos son la .Counts (es decir, la longitud) de dos nuevas matrices de caracteres. Cada par interno ($a=[char[]]$a|sort)toma la palabra de entrada original, la vuelve a lanzar como una matriz de caracteres, luego la ordena y la vuelve a guardar en la misma variable. Hacemos eso para ambos $ay $b. El lado izquierdo verifica que las palabras de entrada tengan la misma longitud. Si no tienen la misma longitud, esta mitad de la declaración booleana externa fallará y se Falsegenerará.

Moviéndonos hacia el lado derecho, nuevamente estamos probando dos declaraciones booleanas con (... -and ...). El lado izquierdo comprueba si algo es mayor que o igual a negativo 1 con -ge-1. El algo es el elemento cero de una matriz construida $c, que es creada por:

• tomando un rango de los índices permitidos 0..($a.count-1)
• entubado en un bucle |%{...}
• En cada iteración del bucle, tomamos los valores ASCII del carácter indexado $ay restamos el valor ASCII del carácter indexado en$b
• que luego se |sorted por valor numérico

El otro lado de la declaración toma el valor máximo $c[-1]de la matriz y asegura que sea menor o igual que 1 con -le1.

Por lo tanto, si las dos cadenas de entrada son realmente adyacentes, la $cmatriz será algo así @(-1,-1,-1...0,0,0...1,1,1). Entonces el primer elemento será -1y el último elemento será 1. Si no son adyacentes, la diferencia en los valores ASCII para un par particular será < -1o > 1, por lo que esta mitad de la prueba booleana externa fallará y se Falsegenerará.

Solo si ambos lados pasan se emitirán Truey, por lo tanto, las cadenas son LA.

Óxido, 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 prueba:

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 si tenemos que suministrar {y}, 63 con f ←)

No soy el mejor APLer, pero es demasiado divertido.

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

=/⍴¨∊¨⍺⍵ son las entradas igualmente largas?

∧ y todo lo siguiente

(⍺{⌈/⍴¨⍺⍵}⍵)⍴¨⍺[⍋⍺]⍵[⍋⍵] clasifica ambas entradas y dales forma para que sean tan largas como las más largas (se ajustan si las haces más largas de lo que son)

|¨∊-/{⎕av⍳⍵} convierta ambos vectores de caracteres en vectores int de sus valores ascii, reste un vector y obtenga todos los valores absolutos

0=+/2≤ resumir valores mayores o iguales a dos y verificar si el resultado es igual a 0

K (oK) , 27 bytes

Solución:

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

Pruébalo en línea!

Ejemplos:

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

Explicación:

Primero ordene cada cadena, luego rellene para que tenga la misma longitud, luego tome una de la otra (valores ASCII de caracteres), resultado cuadrado ya que no hay incorporado abs, tome la diferencia máxima y verifique si eso es 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:@/:~)

sin golf

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

explicado

• &(3&u:@/:~) ordena ambos argumentos y los convierte a números ascii
• ,: crea una matriz de 2 xn, donde n es el número de caracteres de los argumentos
• -/ resta una fila de la otra, dando una lista de longitud n que representa la distancia de los caracteres correspondientes
• (2>|) devuelve 1 si el valor absoluto de la distancia es menor que 2, de lo contrario 0
• */multiplica todos esos 0sys 1juntos: por lo tanto, el resultado final es 1 si todos los pares de caracteres correspondientes son adyacentes.

Pruébalo en línea!