In questa sfida, ti vengono passate due parole: il tuo compito è determinare se sono adiacenti .

Due lettere sono adiacenti se:

1. Sono la stessa lettera, o
2. Sono lessicograficamente adiacenti.

Ad esempio, J è adiacente a I , J e K soltanto. Z non è adiacente ad A

Due parole sono adiacenti se:

1. Hanno la stessa lunghezza e
2. Ogni lettera è adiacente a una lettera unica nell'altra parola.

Ad esempio, CAT è adiacente alla SAD , come C> D, A> A, T> S .
FREE non è adiacente a GRRD (ogni E ha bisogno di una lettera da abbinare) .

Input Output

Vengono passate due stringhe e è necessario restituire un valore di verità se sono adiacenti, altrimenti un valore di falsa. Dovresti tornare entro un minuto per tutti i casi di test di seguito.

Puoi presumere che le stringhe conterranno solo lettere maiuscole e alfabetiche.

Le due stringhe possono essere passate come elenco o concatenate, con o senza virgolette.

Casi test

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

Questo è code-golf , quindi vince la risposta valida più breve!

CJam, 14 13 12 byte

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

Provalo online! oppure verifica tutti i casi di test contemporaneamente .

Algoritmo

Let s e t essere due ordinate parole della stessa lunghezza. Per s e t siano lessicograficamente adiacente (LA), è necessario e sufficiente che tutte le coppie di suoi caratteri corrispondenti sono anche LA.

La condizione è chiaramente sufficiente per tutte le parole e necessaria per le parole di lunghezza 1 .

Ora, supponiamo che s e t abbiano lunghezza n> 1 e che a e b siano i primi caratteri, rispettivamente, di s e t .

Dato che s e t sono LA, esiste una mappatura biiettiva φ tra i caratteri di se i caratteri di t in modo tale che x e φ (x) siano LA per tutti x in s , nel senso che | x - φ (x) | ≤ 1 per tutte le x in s .

Sia c = φ (a) e d = φ ^-1 (b) . A causa di un 's e b s' minimalità, a ≤ d (1) e b ≤ c (2) .

Inoltre, poiché b e d , e a e c , e LA, d ≤ b + 1 (3) e c ≤ a + 1 (4) .

Combinando (1) e (3) , e (2) e (4) , otteniamo che a ≤ d ≤ b + 1 e b ≤ c ≤ a + 1 , da cui deduciamo che a - 1 ≤ b ≤ a + 1 e, quindi, che un e b sono lA.

Ora, combinando (1) e (4) , (2) e (3) , otteniamo che c - 1 ≤ a ≤ d e d - 1 ≤ b ≤ c , da cui deduciamo che c - 1 ≤ d ≤ c + 1 e, quindi, che c e d sono LA.

Pertanto, se ridefiniamo φ per φ (a) = b e φ (d) = c , | x - φ (x) | ≤ 1 deterrà ancora per tutti x in s e, in particolare, per tutti x in s [1:] .

In questo modo, s [0] = a et [0] = b , e s [1:] et [1:] , sono LA.

Poiché s [1:] ha lunghezza n - 1 , ciò dimostra la necessità per induzione.

Codice

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 byte

c!S!odXl2<

Questo utilizza l'approccio di Dennis : ordina prima e confronta i personaggi in posizioni corrispondenti.

L'input è una matrice di stringhe, con il formato {'CAT 'SAD'}.

L'output è un array di zeri e uno. Un risultato è veritiero se contiene tutti (si concorda che sia vero).

Utilizza la versione corrente (10.2.1) , precedente a questa sfida.

EDIT: la funzione Xlè stata rinominata |nelle versioni più recenti della lingua (e onon è più necessaria). Il link seguente include tali modifiche.

Provalo online!

Spiegazione :

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

Vecchio approccio, che accetta le stringhe come input separati: 12 byte :

SiSXhcodXl2<

EDIT : il codice nel link è stato modificato in base alle modifiche nella lingua; vedi commento sopra.

Provalo online !

Spiegazione :

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 byte

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

Puoi testarlo salvandolo come adj.he quindi usando questo adj.cfile:

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

Quindi compilare usando gcc adj.c -o adj. L'output è:

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 byte

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

Semplice funzione anonima, devo avere un controllo separato per la lunghezza perché zipsi contatterà. Esiste una funzione simile in itertools( zip_longest) che riempie le stringhe vuote, ma sarebbe piuttosto costoso.

Test 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

Modifica 4 byte salvati thx @Neil
Modifica 2 4 byte salvati thx @ Mwr247

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

Nota: controllo di adiacenza su una coppia di lettere. Prendi la coppia come base 36 numero n , se le lettere sono uguali, allora n = a*36+a = a*37. Se c'è una differenza di 1 allora n = a*36+a+1 = a*37+1o n = a*36+a-1 = a*37-1. Quindi n % 37deve essere 0, 1 o 36. E n%37%36deve essere 0 o 1.

Nota 2: lo "0" aggiunto viene utilizzato per garantire che aeb abbiano la stessa lunghezza. È più breve alloraa.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 byte 116 byte 111 byte 109 byte

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

Casi test

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>

Credito

• @ rink.attendant.6 rasato 5 byte
• @ user81655 rasato 2 byte

Pyth, 37 31 byte

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

Provalo online con tutti i casi di test!

Rimozione di 6 byte utilizzando la notazione ridotta abbreviata ( -Fanziché .U-bZ)

Soluzione ispirata a Dennis

Primo invio a codegolf!

Spiegazione

Possiamo dividere l'espressione in due parti, che vengono confrontate con &l'output del risultato. Proverò a spiegare scrivendo alcuni pseudo-Python

Per prima cosa controlliamo che la lunghezza delle due parole sia la stessa

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

Quindi, applichiamo il metodo di 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] 

Quindi utilizziamo l' -operatore per filtrare tutti gli elementi di quell'elenco che non sono in [Z1( [0, 1]) e controlliamo che il risultato sia un elenco vuoto conqY

JavaScript (ES6), 87 byte

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

Utilizza un controllo di intervallo simmetrico zero-centrico dividendo per il valore massimo, quindi troncando con un bit "o" ( |). Più corto di dover fare due controlli, o uno con Math.abs().

Haskell, 67 63 byte

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

Esempio di utilizzo: f "FREE" "GRRD"-> False.

Come funziona (nota: fè parzialmente privo di punti e il secondo parametro bnon appare nella definizione):

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

Modifica: @xnor ha trovato 4 byte da salvare. Grazie!

C, 172 byte

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

Casi test

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

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)

Potrebbe essere possibile ottenere questo più breve. Al momento non è competitivo con Python o JavaScript, ma utilizza un approccio leggermente diverso, quindi ho pensato di pubblicarlo.

Spiegazione

Questo codice è davvero confuso per qualcuno che non parla fluentemente PowerShell, quindi cercherò di suddividerlo in inglese nel miglior modo possibile ...

Iniziamo prendendo input param($a,$b)normalmente.

L'intero resto del codice è in realtà un'istruzione e può essere interrotto (...)-and(...)per testare due istruzioni booleane con l' -andoperatore.

Le parentesi sinistre possono essere rotte (... -eq ...)per verificare l'uguaglianza di due oggetti. In questo caso, gli oggetti sono la .Counts (cioè la lunghezza) di due nuovi array di caratteri. Ogni paren interno ($a=[char[]]$a|sort)prende la parola di input originale, la ricodifica come char-array, quindi la ordina e salva nuovamente nella stessa variabile. Lo facciamo per entrambi $ae $b. Il lato sinistro verifica quindi che le parole di input abbiano la stessa lunghezza. Se non hanno la stessa lunghezza, questa metà dell'istruzione booleana esterna avrà esito negativo e Falseverrà emessa.

Passando al lato destro, stiamo di nuovo testando due dichiarazioni booleane con (... -and ...). Il lato sinistro verifica se qualcosa è maggiore o uguale a 1 negativo con -ge-1. Il qualcosa è l'elemento zeroth di un array costruito $c, creato da:

• prendendo una gamma di indici consentiti 0..($a.count-1)
• convogliato in un loop |%{...}
• ad ogni iterazione del ciclo, prendiamo i valori ASCII del carattere indicizzato $ae sottraggiamo il valore ASCII del carattere indicizzato in$b
• che viene quindi modificato in |sortbase al valore numerico

L'altro lato dell'istruzione assume il valore massimo $c[-1]dell'array e garantisce che sia inferiore o uguale a 1 con -le1.

Pertanto, se le due stringhe di input sono effettivamente adiacenti, l' $carray sarà simile @(-1,-1,-1...0,0,0...1,1,1). Quindi il primo elemento sarà -1e l'ultimo sarà 1. Se non sono adiacenti, la differenza nei valori ASCII per una particolare coppia sarà < -1o > 1, quindi questa metà del test booleano esterno fallirà e Falseverrà emessa.

Solo se entrambe le parti passeranno Truein output, le stringhe saranno quindi LA.

Ruggine, 269 264 byte

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}

Allargato:

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
}

Casi test:

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

(61 se dobbiamo fornire {e}, 63 con f ←)

Non sono il più grande APLer, ma è semplicemente troppo divertente.

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

=/⍴¨∊¨⍺⍵ gli ingressi sono ugualmente lunghi?

∧ e tutto quanto sotto

(⍺{⌈/⍴¨⍺⍵}⍵)⍴¨⍺[⍋⍺]⍵[⍋⍵] ordina entrambi gli input e modellali in modo che siano i più lunghi dei due (si avvolgono se li rendi più lunghi di loro)

|¨∊-/{⎕av⍳⍵} converte entrambi i vettori di caratteri in vettori int dei loro valori ASCII, esegue una sottrazione vettoriale e assolve tutti i valori

0=+/2≤ sommare valori maggiori o uguali a due e verificare se il risultato è uguale a 0

K (oK) , 27 byte

Soluzione:

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

Provalo online!

Esempi:

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

Spiegazione:

Prima ordina ogni stringa, poi il pad deve avere la stessa lunghezza, quindi prendine uno dall'altro (valori ASCII dei caratteri), risultati quadrati in quanto non è incorporato abs, prendi la differenza massima e controlla se è inferiore a 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 byte

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

ungolfed

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

ha spiegato

• &(3&u:@/:~) ordina entrambi gli argomenti e li converte in numeri ASCII
• ,: crea una matrice 2 xn, dove n è il numero di caratteri degli arg
• -/ sottrae una riga dall'altra, fornendo un elenco di lunghezza n che rappresenta la distanza dei caratteri corrispondenti
• (2>|) restituisce 1 se il valore assoluto della distanza è inferiore a 2, 0 altrimenti
• */moltiplica tutti quei 0S e 1s insieme: di conseguenza, il risultato finale è 1 se e solo se tutte le coppie di caratteri corrispondenti sono adiacenti.

Provalo online!