W tym wyzwaniu dostajesz dwa słowa: Twoim zadaniem jest ustalenie, czy są obok siebie .

Dwie litery sąsiadują, jeśli:

1. Są to ta sama litera lub
2. Są przylegające leksykograficznie.

Przykładowo, J znajduje się w sąsiedztwie I , J i K, tylko. Z nie sąsiaduje z A

Dwa słowa sąsiadują, jeśli:

1. Są tej samej długości i
2. Każda litera przylega do innej litery w innym słowie.

Na przykład, CAT sąsiaduje SAD , a C> D, A, A, T>> s .
ZA DARMO nie sąsiaduje z GRRD (każde E potrzebuje litery do połączenia) .

Wejście wyjście

Masz dwa ciągi znaków i musisz zwrócić prawdziwą wartość, jeśli są sąsiednie, w przeciwnym razie wartość fałsz. Powinieneś wrócić w ciągu minuty dla wszystkich poniższych przypadków testowych.

Możesz założyć, że ciągi będą zawierać tylko wielkie litery, litery alfabetu.

Dwa ciągi znaków mogą być przekazywane jako lista lub łączone z cudzysłowami lub bez nich.

Przypadki testowe

Prawda:

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

To jest golf golfowy , więc wygrywa najkrótsza ważna odpowiedź!

CJam, 14 13 12 bajtów

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

Wypróbuj online! lub zweryfikuj wszystkie przypadki testowe jednocześnie .

Algorytm

Niech s i t będą dwoma posortowanymi słowami o tej samej długości. Aby s i t były leksykograficznie przylegające (LA), konieczne i wystarczające jest, aby wszystkie pary odpowiadających im znaków były również LA.

Warunek jest wyraźnie wystarczający dla wszystkich słów i niezbędny dla słów o długości 1 .

Teraz przyjmijmy, s i t mają długość n> 1 i pozwolić i b są pierwszymi znakami, wzgl., Z s i t .

Od s i t są LA, istnieją pewne bijective odwzorowanie φ między bohaterami s i bohaterów t takie, że x i φ (x) to la dla wszystkich x w S , co oznacza, że | x - cp (x) | ≤ 1 dla wszystkich x w s .

Niech C = φ (a) i d = φ ^-1 (b) . Ze względu 's i b jest minimalności, a ≤ D (1) i b ≤ C (2) .

Ponadto, jako b i d , i i C i LA, d ≤ b + 1 (3), i c ≤ a + 1 (4) .

Łącząc (1) i (3) oraz (2) i (4) , otrzymujemy, że a ≤ d ≤ b + 1 i b ≤ c ≤ a + 1 , z którego wywnioskujemy, że a - 1 ≤ b ≤ a + 1 , a w związku z tym, że i b są la.

Teraz, łącząc (1) i (4) oraz (2) i (3) , otrzymujemy, że c - 1 ≤ a ≤ d i d - 1 ≤ b ≤ c , z którego wywnioskujemy, że c - 1 ≤ d ≤ c + 1 , a w związku z tym, że c i d są la.

Zatem jeśli redefiniujemy φ o φ (a) = b oraz φ (d) = c , | x - φ (x) | ≤ 1 nadal utrzymać dla wszystkich x w s , a w szczególności dla wszystkich x w S [1:] .

W ten sposób, y [0] = a i T [0] = B i s: [1] i T [1:] , to la.

Ponieważ s [1:] ma długość n - 1 , dowodzi to konieczności indukcji.

Kod

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 bajtów

c!S!odXl2<

Wykorzystuje to podejście Dennisa : najpierw posortuj i porównaj znaki w pasujących pozycjach.

Dane wejściowe to tablica ciągów o formacie {'CAT 'SAD'}.

Dane wyjściowe to tablica zer i jedynek. Wynik jest prawdomówny, jeśli zawiera wszystkie ( zgodnie z prawdą).

Wykorzystuje aktualną wersję (10.2.1) , która jest wcześniejsza niż to wyzwanie.

EDYCJA:Xl Nazwa funkcji została zmieniona na |nowsze wersje języka (i onie jest już konieczna). Poniższy link zawiera te modyfikacje.

Wypróbuj online!

Objaśnienie :

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

Stare podejście, które akceptuje ciągi jako osobne dane wejściowe: 12 bajtów :

SiSXhcodXl2<

EDYCJA : kod w linku został zmodyfikowany zgodnie ze zmianami w języku; patrz komentarz powyżej.

Wypróbuj online !

Objaśnienie :

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 bajty

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

Możesz to przetestować, zapisując to jako, adj.ha następnie używając tego adj.cpliku:

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

Następnie skompiluj za pomocą gcc adj.c -o adj. Dane wyjściowe to:

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 bajtów

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

Prosta anonimowa funkcja, muszę mieć osobne sprawdzenie długości, ponieważ zippo prostu się skontaktuję. Istnieje podobna funkcja w itertools( zip_longest), która wstawiałaby puste ciągi, ale byłoby to dość kosztowne.

Testowanie z

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

produkuje:

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

Edytuj 4 bajty zapisane thx @ Nee
Edytuj 2 4 bajty zapisane thx @ Mwr247

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

Uwaga: sprawdzanie sąsiedztwa pary liter. Przyjąć parę jako podstawa 36 liczba n , gdy litery są równe, to n = a*36+a = a*37. Jeśli występuje różnica 1, n = a*36+a+1 = a*37+1lub n = a*36+a-1 = a*37-1. n % 37Musi więc wynosić 0, 1 lub 36. I n%37%36musi być 0 lub 1.

Uwaga 2: dodane „0” służy do zapewnienia, że ​​aib mają tę samą długość. Jest więc krótszya.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 bajtów 116 bajtów 111 bajtów 109 bajtów

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

Przypadki testowe

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>

Kredyt

• @ rink.attendant.6 wygolił 5 bajtów
• @ user81655 ogolił się z 2 bajtów

Pyth, 37 31 bajtów

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

Wypróbuj online ze wszystkimi testami!

Ogolono 6 bajtów za pomocą skróconej notacji redukującej ( -Fzamiast .U-bZ)

Rozwiązanie inspirowane Dennis

Pierwsze zgłoszenie do codegolf!

Wyjaśnienie

Możemy podzielić wyrażenie na dwie części, które są porównywane w &celu uzyskania wyniku. Spróbuję wyjaśnić, pisząc jakiś pseudo-Python

Najpierw sprawdzamy, czy długość dwóch słów jest taka sama

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

Następnie stosujemy metodę Dennisa:

       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] 

Następnie używamy -operatora do filtrowania wszystkich elementów tej listy, które nie są w [Z1( [0, 1]), i sprawdzamy, czy wynik jest pustą listą zqY

JavaScript (ES6), 87 bajtów

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

Używa symetrycznego zerowego sprawdzania zakresu przez podzielenie przez wartość maksymalną, a następnie obcięcie za pomocą bitowego „lub” ( |). Krótszy niż konieczność wykonania dwóch kontroli lub jednej z Math.abs().

Haskell, 67 63 bajtów

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

Przykład użycia: f "FREE" "GRRD"-> False.

Jak to działa (uwaga: fjest częściowo pozbawiona punktów, a drugi parametr bnie pojawia się w definicji):

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

Edycja: @xnor znalazł 4 bajty do zapisania. Dzięki!

C, 172 bajty

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

Przypadki testowe

$ 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 bajtów

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)

Być może uda się to skrócić. Obecnie nie jest konkurencyjny w stosunku do Pythona ani JavaScript, ale używa nieco innego podejścia, więc pomyślałem, że go opublikuję.

Wyjaśnienie

Ten kod jest naprawdę mylący dla kogoś, kto nie mówi płynnie w PowerShell, więc postaram się go rozbić na angielski najlepiej jak potrafię ...

Zaczynamy param($a,$b)od normalnego przyjmowania danych wejściowych .

Cała reszta kodu jest tak naprawdę jedną instrukcją i może być uszkodzona, (...)-and(...)aby przetestować dwie instrukcje boolowskie z -andoperatorem.

Pareny po lewej stronie można złamać, (... -eq ...)aby sprawdzić równość dwóch obiektów. W tym przypadku obiektami są .Counts (to znaczy długość) dwóch nowych tablic znakowych. Każdy wewnętrzny paren ($a=[char[]]$a|sort)pobiera oryginalne słowo wejściowe, ponownie rzutuje je jako tablicę znaków, a następnie sortuje i zapisuje z powrotem w tej samej zmiennej. Robimy to zarówno dla, jak $ai dla $b. Lewa strona sprawdza w ten sposób, że słowa wejściowe są tej samej długości. Jeśli nie są one tej samej długości, ta połowa zewnętrznej instrukcji boolowskiej zakończy się niepowodzeniem i Falsezostanie wygenerowana.

Przechodząc do prawej strony, ponownie testujemy dwie instrukcje boolowskie (... -and ...). Lewa strona sprawdza, czy coś jest większe niż lub równe ujemnemu 1 z -ge-1. Coś jest zerowe, element skonstruowanej matrycy $c, który jest utworzony:

• przyjmując zakres dozwolonych wskaźników 0..($a.count-1)
• podłączony do pętli |%{...}
• przy każdej iteracji pętli bierzemy wartości ASCII indeksowanego znaku $ai odejmujemy wartość ASCII indeksowanego znaku w$b
• który jest następnie |sortedytowany przez wartość liczbową

Druga strona instrukcji przyjmuje maksymalną wartość $c[-1]tablicy i zapewnia, że ​​jest ona mniejsza niż lub równa 1 z -le1.

Zatem, jeśli dwa ciągi wejściowe są rzeczywiście sąsiadujące, $ctablica będzie podobna @(-1,-1,-1...0,0,0...1,1,1). Tak więc pierwszym elementem będzie, -1a ostatnim elementem będzie 1. Jeśli nie są one sąsiadujące, różnica w wartościach ASCII dla konkretnej pary albo będzie, < -1albo > 1, więc ta połowa zewnętrznego boolowskiego testu zakończy się niepowodzeniem i Falsezostanie wyprowadzona.

Tylko wtedy, gdy obie strony przejdą, wyjdzie True, a zatem łańcuchy są LA.

Rdza, 269 264 bajtów

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}

Rozszerzony:

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
}

Przypadki testowe:

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 bajtów (znaków)

(61, jeśli musimy dostarczyć {i}, 63 z f ←)

Nie jestem najlepszym APLerem, ale to po prostu zbyt dobra zabawa.

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

=/⍴¨∊¨⍺⍵ czy dane wejściowe są równie długie?

∧ i wszystkie poniżej

(⍺{⌈/⍴¨⍺⍵}⍵)⍴¨⍺[⍋⍺]⍵[⍋⍵] posortuj oba dane wejściowe i ułóż je tak, aby były jak najdłuższe z nich (zawijają się, jeśli zwiększysz ich długość)

|¨∊-/{⎕av⍳⍵} konwertuj oba wektory char na wektory int ich wartości ascii, wykonaj odejmowanie wektora i bezwzględnie wszystkie wartości

0=+/2≤ zsumuj wartości większe lub równe dwa i sprawdź, czy wynik jest równy 0

K (oK) , 27 bajtów

Rozwiązanie:

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

Wypróbuj online!

Przykłady:

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

Wyjaśnienie:

Najpierw posortuj każdy ciąg, następnie pad do tej samej długości, następnie weź jeden z drugiego (wartości znaków ASCII znaków), wynik kwadratowy, ponieważ nie ma wbudowanego abs, weź maksymalną różnicę i sprawdź, czy jest mniejsza niż 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 bajtów

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

bez golfa

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

wyjaśnił

• &(3&u:@/:~) sortuje oba argumenty i konwertuje je na liczby ascii
• ,: tworzy macierz 2 xn, gdzie n jest liczbą znaków argumentów
• -/ odejmuje jeden wiersz od drugiego, dając listę długości n reprezentującą odległość odpowiednich znaków
• (2>|) zwraca 1, jeśli wartość bezwzględna odległości jest mniejsza niż 2, w przeciwnym razie 0
• */mnoży wszystkie te 0si 1razem: stąd końcowy wynik to 1 iff wszystkie pary odpowiednich znaków są sąsiadujące.

Wypróbuj online!