Bei dieser Herausforderung werden Ihnen zwei Wörter übergeben: Ihre Aufgabe ist es, zu bestimmen, ob sie benachbart sind .

Zwei Buchstaben stehen nebeneinander, wenn:

1. Sie sind der gleiche Buchstabe oder
2. Sie grenzen lexikografisch aneinander.

Zum Beispiel J ist neben I , J und K nur. Z grenzt nicht an A

Zwei Wörter stehen nebeneinander, wenn:

1. Sie sind gleich lang und
2. Jeder Buchstabe grenzt an einen eindeutigen Buchstaben im anderen Wort.

Zum Beispiel CAT ist an benachbartes SAD , wie C> D, A> A, T> S .
FREE steht nicht neben GRRD (jedes E benötigt einen Buchstaben zum Koppeln ) .

Input-Output

Sie haben zwei Zeichenfolgen übergeben und müssen einen Wahrheitswert zurückgeben, wenn sie benachbart sind, andernfalls einen falschen Wert. Sie sollten innerhalb einer Minute für alle unten aufgeführten Testfälle zurückkehren.

Sie können davon ausgehen, dass die Zeichenfolgen nur Großbuchstaben enthalten.

Die beiden Zeichenfolgen können als Liste oder verkettet mit oder ohne Anführungszeichen übergeben werden.

Testfälle

Wahrheit:

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

Falsch:

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

Das ist Code-Golf , also gewinnt die kürzeste gültige Antwort!

CJam, 14 13 12 Bytes

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

Probieren Sie es online! oder überprüfen Sie alle Testfälle auf einmal .

Algorithmus

Es seien s und t zwei sortierte Wörter gleicher Länge. Damit s und t lexikographisch benachbart sind (LA), ist es notwendig und ausreichend, dass alle Paare der entsprechenden Zeichen ebenfalls LA sind.

Die Bedingung ist eindeutig für alle Wörter ausreichend und für Wörter der Länge 1 erforderlich .

Nehmen wir nun an, dass s und t die Länge n> 1 haben und a und b die ersten Zeichen von s bzw. t sind .

Da s und t LA sind, gibt es eine bijektive Abbildung φ zwischen den Zeichen von s und den Zeichen von t, so dass x und φ (x) für alle x in s LA sind , was bedeutet, dass | x - φ (x) | ≤ 1 für alle x in s .

Sei c = = (a) und d = φ ^-1 (b) . Aufgrund der Minimalität von a und b sind a ≤ d (1) und b ≤ c (2) .

Da außerdem b und d und a und c und LA sind, ist d ≤ b + 1 (3) und c ≤ a + 1 (4) .

Durch Kombinieren von (1) und (3) und (2) und (4) erhalten wir, dass a ≤ d ≤ b + 1 und b ≤ c ≤ a + 1 , woraus wir ableiten, dass a - 1 ≤ b ≤ a + 1 und daher, dass a und b LA sind.

Wenn wir nun (1) und (4) sowie (2) und (3) kombinieren , erhalten wir c - 1 ≤ a ≤ d und d - 1 ≤ b ≤ c , woraus wir ableiten, dass c - 1 ≤ d ist ≤ c + 1 und daher sind c und d LA.

Wenn wir also φ durch φ (a) = b und φ (d) = c neu definieren , gilt | x - φ (x) | ≤ 1 gilt weiterhin für alle x in s und insbesondere für alle x in s [1:] .

Auf diese Weise sind s [0] = a und t [0] = b und s [1:] und t [1:] LA.

Da s [1:] die Länge n - 1 hat , beweist dies die Notwendigkeit durch Induktion.

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 Bytes

c!S!odXl2<

Hierbei wird Dennis 'Ansatz verwendet : Zuerst sortieren und Zeichen in übereinstimmenden Positionen vergleichen.

Die Eingabe ist ein Array von Zeichenfolgen mit dem Format {'CAT 'SAD'}.

Die Ausgabe ist ein Array aus Nullen und Einsen. Ein Ergebnis ist truthy iff es nur Einsen enthält (dies wird vereinbart truthy sein).

Verwendet die aktuelle Version (10.2.1) , die älter als diese Herausforderung ist.

BEARBEITEN: Die Funktion Xlwurde |in neueren Sprachversionen umbenannt (und oist nicht mehr erforderlich). Der unten stehende Link enthält diese Änderungen.

Probieren Sie es online!

Erklärung :

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

Alter Ansatz, der die Zeichenfolgen als separate Eingaben akzeptiert: 12 Bytes :

SiSXhcodXl2<

BEARBEITEN : Der Code im Link wurde aufgrund der Änderungen in der Sprache geändert. siehe Kommentar oben.

Probieren Sie es online !

Erklärung :

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

Sie können es testen, indem Sie das speichern adj.hund dann diese adj.cDatei verwenden:

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

Dann kompilieren Sie mit gcc adj.c -o adj. Die Ausgabe ist:

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)

Einfache anonyme Funktion, ich muss eine separate Prüfung für die Länge haben, weil zipnur contatenate wird. Theres eine ähnliche Funktion in itertools( zip_longest), die leere Zeichenfolgen auffüllen würde, aber das wäre ziemlich teuer.

Testen mit

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

produziert:

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

Bearbeite 4 Bytes, die dank @Neil gespeichert wurden
Bearbeite 2 4 Bytes, die dank @ Mwr247 gespeichert wurden

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

Hinweis: Adjazenzprüfung an einem Buchstabenpaar. Nehmen Sie das Paar als Basis 36 Nummer n , wenn die Buchstaben gleich sind, dann n = a*36+a = a*37. Wenn es einen Unterschied von 1 gibt, dann n = a*36+a+1 = a*37+1oder n = a*36+a-1 = a*37-1. Also n % 37muss 0, 1 oder 36 sein. Und n%37%36muss 0 oder 1 sein.

Anmerkung 2: Die hinzugefügte „0“ wird verwendet, um sicherzustellen, dass a und b dieselbe Länge haben. Es ist dann kürzera.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)

Testfälle

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>

Kredit

• @ rink.attendant.6 5 Bytes rasiert
• @ user81655 hat 2 Bytes entfernt

Pyth, 37 31 Bytes

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

Probieren Sie es online mit allen Testfällen!

6 Bytes mit der verkürzten Reduktionsnotation ( -Fanstelle von .U-bZ) abgeschnitten

Von Dennis inspirierte Lösung

Erste Einreichung bei Codegolf!

Erläuterung

Wir können den Ausdruck in zwei Teile aufteilen, die verglichen werden, &um das Ergebnis auszugeben. Ich werde versuchen zu erklären, indem ich etwas Pseudo-Python schreibe

Zuerst prüfen wir, ob die Länge der beiden Wörter gleich ist

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

Dann wenden wir Dennis 'Methode an:

       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] 

Wir verwenden dann den -Operator, um alle Elemente dieser Liste zu filtern, die nicht in [Z1( [0, 1]) enthalten sind, und überprüfen, ob das Ergebnis eine leere Liste istqY

JavaScript (ES6), 87 Byte

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

Verwendet eine nullzentrische symmetrische Bereichsprüfung, indem durch den Maximalwert dividiert und dann mit einem bitweisen "oder" ( |) abgeschnitten wird . Kürzer als zwei Prüfungen oder eine mit Math.abs().

Haskell, 67 63 Bytes

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

Anwendungsbeispiel: f "FREE" "GRRD"-> False.

Wie es funktioniert (Anmerkung: fist teilweise frei von Punkten und der zweite Parameter berscheint nicht in der Definition):

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 hat 4 Bytes zum Speichern gefunden. Vielen Dank!

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

Testfälle

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

Könnte möglich sein, dies kürzer zu bekommen. Es ist derzeit nicht mit Python oder JavaScript konkurrierend, aber es verwendet einen etwas anderen Ansatz, so dass ich dachte, ich würde es posten.

Erläuterung

Dieser Code ist für jemanden, der PowerShell nicht fließend beherrscht, sehr verwirrend. Ich werde versuchen, ihn so gut ich kann in Englisch aufzuteilen ...

Wir beginnen mit der param($a,$b)normalen Eingabe .

Der gesamte Rest des Codes ist tatsächlich eine Anweisung und kann unterbrochen werden (...)-and(...), um zwei Boolesche Anweisungen mit dem -andOperator zu testen .

Die linken Parens können gebrochen werden (... -eq ...), um die Gleichheit von zwei Objekten zu testen. In diesem Fall sind die Objekte das .Counts (dh die Länge) von zwei neuen Zeichen-Arrays. Jeder innere Paren verwendet ($a=[char[]]$a|sort)das ursprüngliche Eingabewort, wandelt es in ein Zeichen-Array um, sortiert es dann und speichert es erneut in derselben Variablen. Wir machen das für beide $aund $b. Die linke Seite verifiziert somit, dass die Eingabewörter die gleiche Länge haben. Wenn sie nicht dieselbe Länge haben, schlägt diese Hälfte der äußeren Booleschen Anweisung fehl und Falsewird ausgegeben.

Auf der rechten Seite testen wir erneut zwei Boolesche Anweisungen mit (... -and ...). Die linke Seite prüft, ob etwas größer als oder gleich negativ 1 ist -ge-1. Das Etwas ist das nullte Element eines konstruierten Arrays $c, das erzeugt wird durch:

• einen Bereich der zulässigen Indizes nehmen 0..($a.count-1)
• in eine Schleife geleitet |%{...}
• Bei jeder Iteration der Schleife nehmen wir die ASCII-Werte des indizierten Zeichens in $aund subtrahieren den ASCII-Wert des indizierten Zeichens in$b
• welches dann |sortdurch numerischen Wert bearbeitet wird

Die andere Seite der Anweisung nimmt den Maximalwert $c[-1]des Arrays und stellt sicher, dass es mit 1 kleiner oder gleich 1 ist -le1.

Wenn also die beiden Eingabe-Strings tatsächlich benachbart sind, ist das $cArray ungefähr so @(-1,-1,-1...0,0,0...1,1,1). So wird das erste Element -1und das letzte Element sein 1. Wenn sie nicht benachbart sind, ist die Differenz der ASCII-Werte für ein bestimmtes Paar entweder < -1oder > 1, sodass diese Hälfte des äußeren Booleschen Tests fehlschlägt und Falseausgegeben wird.

Nur wenn beide Seiten passen, wird Trueausgegeben, und die Zeichenfolgen sind daher LA.

Rust, 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}

Erweitert:

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
}

Testfälle:

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

(61, wenn wir die {und}, 63 mit f ← versorgen müssen)

Ich bin nicht der beste APLer, aber es macht einfach zu viel Spaß.

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

=/⍴¨∊¨⍺⍵ sind die eingänge gleich lang

∧ und all das unten

(⍺{⌈/⍴¨⍺⍵}⍵)⍴¨⍺[⍋⍺]⍵[⍋⍵] Sortieren Sie beide Eingänge und formen Sie sie so, dass sie so lang wie die längste der beiden sind (sie werden umbrochen, wenn Sie sie länger machen als sie sind).

|¨∊-/{⎕av⍳⍵} Wandle beide Zeichenvektoren in int-Vektoren ihrer ASCII-Werte um, führe eine Vektorsubtraktion durch und absolviere alle Werte

0=+/2≤ Summiere Werte größer oder gleich zwei und überprüfe, ob das Ergebnis gleich 0 ist

K (oK) , 27 Bytes

Lösung:

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

Probieren Sie es online!

Beispiele:

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

Erläuterung:

Sortieren Sie zuerst die einzelnen Zeichenfolgen, und füllen Sie sie dann so auf, dass sie die gleiche Länge haben. Nehmen Sie dann die ASCII-Werte der Zeichen ab abs.

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:@/:~)

ungolfed

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

erklärt

• &(3&u:@/:~) sortiert beide Argumente und konvertiert sie in ASCII-Zahlen
• ,: Erstellt eine 2 xn-Matrix, wobei n die Anzahl der Zeichen der Argumente ist
• -/ subtrahiert eine Zeile von der anderen und gibt eine Liste der Länge n an, die den Abstand der entsprechenden Zeichen darstellt
• (2>|) Gibt 1 zurück, wenn der absolute Wert der Entfernung kleiner als 2 ist, andernfalls 0
• */multipliziert all diese 0s und 1s zusammen: daher ist das Endergebnis 1, wenn alle Paare entsprechender Zeichen benachbart sind.

Probieren Sie es online!