Dans ce défi, vous passez deux mots: Votre travail consiste à déterminer s'ils sont adjacents .

Deux lettres sont adjacentes si:

1. Ce sont la même lettre, ou
2. Ils sont lexicographiquement adjacents.

Par exemple, J est adjacent à I , J et K uniquement. Z n'est pas adjacent à A

Deux mots sont adjacents si:

1. Ils ont la même longueur, et
2. Chaque lettre est adjacente à une lettre unique dans l'autre mot.

Par exemple, CAT est adjacent à SAD , comme C> D, A> A, T> S .
FREE n'est pas adjacent à GRRD (chaque E a besoin d'une lettre pour s'associer ) .

Entrée sortie

Vous passez deux chaînes et vous devez renvoyer une valeur véridique si elles sont adjacentes, sinon une valeur fausse. Vous devez revenir dans une minute pour tous les cas de test ci-dessous.

Vous pouvez supposer que les chaînes ne contiendront que des lettres alphabétiques majuscules.

Les deux chaînes peuvent être passées sous forme de liste, ou concaténées, avec ou sans guillemets.

Cas de test

Vérité:

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

Faux:

A C
A Z
B J
JK J
CC BA
CE D
DJENSKE GDJCLMT
DEFGHIJKL HJLHMCHE
IJKLIJKLKIJL LIJLLHJLJLLL 
AWSUKMEGICOQY RSHXBLJLNQDFZ
QQSQQRRQSTTUQQQRRS PQTTPPTTQTPQPPQRTT
ELKNSDUVWELSKJFESD DKJELKNSUELSDUFEUS

C'est le code-golf , donc la réponse valide la plus courte l'emporte!

CJam, 14 13 12 octets

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

Essayez-le en ligne! ou vérifiez tous les cas de test à la fois .

Algorithme

Soit s et t deux mots triés de même longueur. Pour que s et t soient lexicographiquement adjacents (LA), il est nécessaire et suffisant que toutes les paires de ses caractères correspondants soient également LA.

La condition est clairement suffisante pour tous les mots et nécessaire pour les mots de longueur 1 .

Supposons maintenant que s et t aient une longueur n> 1 , et que a et b soient les premiers caractères, respectivement, de s et t .

Puisque s et t sont LA, il existe une correspondance bijective φ entre les caractères de s et les caractères de t tels que x et φ (x) sont LA pour tout x dans s , ce qui signifie que | x - φ (x) | ≤ 1 pour tous les x en s .

Soit c = φ (a) et d = φ ^-1 (b) . En raison de la 's et b ' de la minimalité, un ≤ d (1) et b ≤ c (2) .

De plus, puisque b et d , et a et c , et LA, d ≤ b + 1 (3) et c ≤ a + 1 (4) .

En combinant (1) et (3) , et (2) et (4) , nous obtenons que a ≤ d ≤ b + 1 et b ≤ c ≤ a + 1 , dont nous déduisons que a - 1 ≤ b ≤ a + 1 et, par conséquent, que a et b sont LA.

Maintenant, en combinant (1) et (4) , et (2) et (3) , nous obtenons que c - 1 ≤ a ≤ d et d - 1 ≤ b ≤ c , dont nous déduisons que c - 1 ≤ d ≤ c + 1 et donc que c et d sont LA.

Ainsi, si nous redéfinissons φ par φ (a) = b et φ (d) = c , | x - φ (x) | ≤ 1 sera toujours valable pour tous les x dans s et, en particulier, pour tous les x dans s [1:] .

De cette façon, s [0] = a et t [0] = b , et s [1:] et t [1:] , sont LA.

Puisque s [1:] a une longueur n - 1 , cela prouve la nécessité par induction.

Code

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 octets

c!S!odXl2<

Cela utilise l'approche de Dennis : triez d'abord et comparez les caractères dans les positions correspondantes.

L'entrée est un tableau de chaînes, au format {'CAT 'SAD'}.

La sortie est un tableau de zéros et de uns. Un résultat est véridique si elle contient tous les éléments (ce qui est convenu pour être véridique).

Utilise la version actuelle (10.2.1) , antérieure à ce défi.

EDIT: la fonction Xla été renommée |dans les nouvelles versions de la langue (et on'est plus nécessaire). Le lien ci-dessous inclut ces modifications.

Essayez-le en ligne!

Explication :

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

Ancienne approche, qui accepte les chaînes comme entrées séparées: 12 octets :

SiSXhcodXl2<

EDIT : le code du lien a été modifié en fonction des changements de langue; voir le commentaire ci-dessus.

Essayez-le en ligne !

Explication :

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 octets

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

Vous pouvez le tester en l'enregistrant sous adj.het en utilisant ce adj.cfichier:

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

Compilez ensuite avec gcc adj.c -o adj. La sortie est:

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 octets

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

Fonction anonyme simple, je dois avoir une vérification séparée de la longueur car zipelle ne fera que contaténer. Il existe une fonction similaire dans itertools( zip_longest) qui remplirait les chaînes vides, mais ce serait assez coûteux.

Test avec

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

produit:

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

Modifier 4 octets enregistrés thx @Neil
Modifier 2 4 octets enregistrés thx @ Mwr247

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

Remarque: contrôle d'adjacence sur une paire de lettres. Prenez la paire comme un nombre de base n 36 , si les lettres sont égales, alors n = a*36+a = a*37. S'il y a une différence de 1, alors n = a*36+a+1 = a*37+1ou n = a*36+a-1 = a*37-1. n % 37Doit donc être 0, 1 ou 36. Et n%37%36doit être 0 ou 1.

Remarque 2: le «0» ajouté est utilisé pour garantir que a et b ont la même longueur. C'est plus court alorsa.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 octets 116 octets 111 octets 109 octets

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

Cas de 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>

Crédit

• @ rink.attendant.6 rasé de 5 octets
• @ user81655 rasé de 2 octets

Pyth, 37 31 octets

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

Essayez-le en ligne avec tous les cas de test!

Réduit 6 octets en utilisant la notation de réduction raccourcie ( -Fau lieu de .U-bZ)

Solution inspirée de Dennis

Première soumission à codegolf!

Explication

Nous pouvons diviser l'expression en deux parties, qui sont comparées à &pour produire le résultat. Je vais essayer d'expliquer en écrivant du pseudo-Python

On vérifie d'abord que la longueur des deux mots est la même

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

Ensuite, nous appliquons la méthode 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] 

Nous utilisons ensuite l' -opérateur pour filtrer tous les éléments de cette liste qui ne sont pas dans [Z1( [0, 1]), et vérifions que le résultat est une liste vide avecqY

JavaScript (ES6), 87 octets

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

Utilise une vérification de plage symétrique de centrage zéro en divisant par la valeur maximale, puis en tronquant avec un "ou" ( |) au niveau du bit . Plus court que d'avoir à faire deux contrôles, ou un avec Math.abs().

Haskell, 67 63 octets

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

Exemple d'utilisation: f "FREE" "GRRD"-> False.

Comment cela fonctionne (note: fest partiellement sans point et le deuxième paramètre bn'apparaît pas dans la définition):

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 a trouvé 4 octets à enregistrer. Merci!

C, 172 octets

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

Cas de 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 octets

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)

Il pourrait être possible de raccourcir ce délai. Ce n'est pas actuellement compétitif avec Python ou JavaScript, mais il utilise une approche légèrement différente, alors j'ai pensé que je le publierais.

Explication

Ce code est vraiment déroutant pour quelqu'un qui ne maîtrise pas PowerShell, donc je vais essayer de le décomposer en anglais du mieux que je peux ...

Nous commençons par prendre les entrées param($a,$b)comme d'habitude.

Le reste du code est en fait une instruction, et peut être rompu (...)-and(...)pour tester deux instructions booléennes avec l' -andopérateur.

Les parens de gauche peuvent être brisés (... -eq ...)pour tester l'égalité de deux objets. Dans ce cas, les objets sont les .Counts (c'est-à-dire la longueur) de deux nouveaux tableaux de caractères. Chaque parent interne ($a=[char[]]$a|sort)prend le mot d'entrée d'origine, le retransmet en tant que tableau de caractères, puis le trie et le réenregistre dans la même variable. Nous faisons cela pour $aet $b. Le côté gauche vérifie ainsi que les mots saisis ont la même longueur. S'ils ne sont pas de la même longueur, cette moitié de l'instruction booléenne externe échouera et Falsesera sortie.

Passant à droite, nous testons à nouveau deux instructions booléennes avec (... -and ...). Le côté gauche teste si quelque chose est supérieur ou égal à négatif 1 avec -ge-1. Le quelque chose est l'élément nul d'un tableau construit $c, qui est créé par:

• en prenant une gamme des indices autorisés 0..($a.count-1)
• sifflé dans une boucle |%{...}
• à chaque itération de la boucle, on prend les valeurs ASCII du caractère indexé $aet on soustrait la valeur ASCII du caractère indexé dans$b
• qui est ensuite |sortédité par valeur numérique

L'autre côté de l'instruction prend la valeur maximale $c[-1]du tableau et garantit qu'il est inférieur ou égal à 1 avec -le1.

Ainsi, si les deux chaînes d'entrée sont en effet adjacentes, le $ctableau ressemblera à quelque chose @(-1,-1,-1...0,0,0...1,1,1). Le premier élément sera donc-1 et le dernier élément sera 1. Si elles ne sont pas adjacents, la différence des valeurs ASCII pour une paire particulière sera soit < -1ou > 1, cette moitié du test booléen externe échouera et Falsesera sortie.

Ce n'est que si les deux côtés passent seront Truesortis, et les chaînes sont donc LA.

Rouille, 269 264 octets

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}

Étendu:

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
}

Cas de 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 octets (caractères)

(61 si nous devons fournir les {et}, 63 avec f ←)

Je ne suis pas le meilleur APLer, mais c'est trop amusant.

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

=/⍴¨∊¨⍺⍵ les entrées sont-elles également longues?

∧ et tout ce qui suit

(⍺{⌈/⍴¨⍺⍵}⍵)⍴¨⍺[⍋⍺]⍵[⍋⍵] trier les deux entrées et les façonner pour être aussi longues que les plus longues des deux (elles s'enroulent si vous les rendez plus longues qu'elles ne le sont)

|¨∊-/{⎕av⍳⍵} convertir les deux vecteurs char en vecteurs int de leurs valeurs ascii, faire une soustraction vectorielle et absolu toutes les valeurs

0=+/2≤ résumer des valeurs supérieures ou égales à deux et vérifier si le résultat est égal à 0

K (oK) , 27 octets

Solution:

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

Essayez-le en ligne!

Exemples:

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

Explication:

Triez d'abord chaque chaîne, puis remplissez la même longueur, puis prenez l'une de l'autre (valeurs ASCII des caractères), résultat carré car il n'y a pas de fonction intégrée abs, prenez la différence maximale et vérifiez si elle est inférieure à 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 octets

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

non golfé

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

expliqué

• &(3&u:@/:~) trie les deux arguments et les convertit en nombres ascii
• ,: crée une matrice 2 xn, où n est le nombre de caractères des arguments
• -/ soustrait une ligne de l'autre, donnant une liste de longueur n représentant la distance des caractères correspondants
• (2>|) renvoie 1 si la valeur absolue de la distance est inférieure à 2, sinon 0
• */multiplie tous ces 0s et 1s ensemble: par conséquent, le résultat final est 1 si toutes les paires de caractères correspondants sont adjacentes.

Essayez-le en ligne!