Dalam tantangan ini, Anda diberikan dua kata: Tugas Anda adalah untuk menentukan apakah mereka berbatasan .

Dua huruf berdekatan jika:

1. Mereka adalah surat yang sama, atau
2. Mereka berbatasan secara leksikografis.

Misalnya, J berdekatan dengan I , J , dan K saja. Z tidak berdekatan dengan A

Dua kata berdekatan jika:

1. Mereka memiliki panjang yang sama, dan
2. Setiap huruf berdekatan dengan huruf unik dengan kata lain.

Misalnya, CAT berdekatan dengan SAD , seperti C> D, A> A, T> S .
GRATIS tidak berdekatan dengan GRRD (setiap E membutuhkan surat untuk dipasangkan) .

Input output

Anda melewati dua string, dan Anda harus mengembalikan nilai kebenaran jika berbatasan, jika tidak nilai palsu. Anda harus kembali dalam satu menit untuk semua kasus uji di bawah ini.

Anda dapat mengasumsikan bahwa string hanya akan berisi huruf besar, huruf alfabet.

Dua string dapat diteruskan sebagai daftar, atau digabungkan, dengan atau tanpa tanda kutip.

Uji Kasus

Benar:

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

Ini adalah kode-golf , jadi jawaban terpendek yang valid menang!

CJam, 14 13 12 byte

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

Cobalah online! atau verifikasi semua kasus uji sekaligus .

Algoritma

Misalkan s dan t adalah dua kata yang diurutkan dengan panjang yang sama. Agar s dan t berbatasan leksikografis (LA), perlu dan memadai bahwa semua pasangan karakter yang bersesuaian juga LA.

Kondisi ini jelas cukup untuk semua kata, dan diperlukan untuk kata-kata panjang 1 .

Sekarang, anggap s dan t memiliki panjang n> 1 , dan biarkan a dan b menjadi karakter pertama, resp., Dari s dan t .

Karena s dan t adalah LA, ada beberapa pemetaan bijective φ antara karakter s dan karakter t sehingga x dan φ (x) adalah LA untuk semua x dalam s , yang berarti bahwa | x - φ (x) | ≤ 1 untuk semua x dalam s .

Misalkan c = φ (a) dan d = φ ^-1 (b) . Karena sebuah 's dan b ' s minimalitas, sebuah ≤ d (1) dan b ≤ c (2) .

Selanjutnya, karena b dan d , dan a dan c , dan LA, d ≤ b + 1 (3) dan c ≤ a + 1 (4) .

Dengan menggabungkan (1) dan (3) , dan (2) dan (4) , kita mendapatkan bahwa ≤ d ≤ b + 1 dan b ≤ c ≤ a + 1 , dari mana kita menyimpulkan bahwa a - 1 ≤ b ≤ a +1 dan, oleh karena itu, bahwa a dan b adalah LA.

Sekarang, dengan menggabungkan (1) dan (4) , dan (2) dan (3) , kita mendapatkan c - 1 ≤ a ≤ d dan d - 1 ≤ b ≤ c , dari mana kita menyimpulkan bahwa c - 1 ≤ d ≤ c +1 dan, oleh karena itu c dan d adalah LA.

Jadi, jika kita mendefinisikan ulang φ oleh φ (a) = b dan φ (d) = c , | x - φ (x) | ≤ 1 akan tetap berlaku untuk semua x dalam s dan, khususnya, untuk semua x dalam s [1:] .

Dengan cara ini, s [0] = a dan t [0] = b , dan s [1:] dan t [1:] , adalah LA.

Karena s [1:] memiliki panjang n - 1 , ini membuktikan perlunya dengan induksi.

Kode

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<

Ini menggunakan pendekatan Dennis : mengurutkan pertama dan membandingkan karakter dalam posisi yang cocok.

Input adalah larik string, dengan format {'CAT 'SAD'}.

Output adalah array dari nol dan satu. Hasilnya adalah kebenaran jika berisi semua (ini disetujui untuk menjadi kebenaran).

Menggunakan rilis saat ini (10.2.1) , yang lebih awal dari tantangan ini.

EDIT: Fungsi Xltelah diubah namanya menjadi |versi bahasa yang lebih baru (dan otidak lagi diperlukan). Tautan di bawah ini mencakup modifikasi tersebut.

Cobalah online!

Penjelasan :

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

Pendekatan lama, yang menerima string sebagai input terpisah: 12 byte :

SiSXhcodXl2<

EDIT : kode dalam tautan telah dimodifikasi sesuai dengan perubahan dalam bahasa; lihat komentar di atas.

Cobalah online !

Penjelasan :

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

Anda dapat mengujinya dengan menyimpannya adj.hlalu menggunakan adj.cfile ini :

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

Kemudian kompilasi menggunakan gcc adj.c -o adj. Outputnya adalah:

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)

Fungsi anonim yang sederhana, saya harus memiliki pemeriksaan yang terpisah untuk panjang karena ziphanya akan digabungkan. Ada fungsi serupa di itertools( zip_longest) yang akan mengisi string kosong, tapi itu akan cukup mahal.

Menguji dengan

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

menghasilkan:

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

Edit 4 byte disimpan thx @Neil
Edit 2 4 byte simpan thx @ Mwr247

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

Catatan: pemeriksaan kedekatan pada sepasang huruf. Ambil pasangan sebagai basis 36 angka n , jika hurufnya sama, maka n = a*36+a = a*37. Jika ada perbedaan 1 maka n = a*36+a+1 = a*37+1atau n = a*36+a-1 = a*37-1. Jadi n % 37harus 0, 1 atau 36. Dan n%37%36harus 0 atau 1.

Catatan 2: tambah '0' digunakan untuk memastikan bahwa a dan b memiliki panjang yang sama. Itu lebih pendeka.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)

Uji Kasus

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 mencukur 5 byte
• @ user81655 mencukur 2 byte

Pyth, 37 31 byte

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

Cobalah secara online dengan semua kasus uji!

Dipotong 6 byte dengan menggunakan notasi pengurangan yang dipersingkat ( -Falih-alih .U-bZ)

Solusi yang diinspirasi oleh Dennis

Pengiriman pertama ke codegolf!

Penjelasan

Kita dapat membagi ekspresi menjadi dua bagian, yang dibandingkan dengan &untuk menghasilkan hasilnya. Saya akan mencoba menjelaskan dengan menulis beberapa pseudo-Python

Pertama-tama kita periksa bahwa panjang kedua kata itu 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

Kemudian, kami menerapkan metode 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] 

Kami kemudian menggunakan -operator untuk memfilter semua elemen dari daftar yang tidak ada dalam [Z1( [0, 1]), dan memeriksa bahwa hasilnya adalah daftar kosong denganqY

JavaScript (ES6), 87 byte

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

Menggunakan pemeriksaan rentang simetris nol-sentris dengan membaginya dengan nilai maks, kemudian memotong dengan bitwise "atau" ( |). Lebih pendek daripada harus melakukan dua cek, atau satu dengan Math.abs().

Haskell, 67 63 byte

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

Contoh penggunaan: f "FREE" "GRRD"-> False.

Cara kerjanya (catatan: fsebagian bebas dari titik dan parameter kedua btidak muncul dalam definisi):

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

Sunting: @xnatau ditemukan 4 byte untuk disimpan. Terima kasih!

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

Uji Kasus

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

Mungkin lebih pendek. Saat ini tidak bersaing dengan Python atau JavaScript, tetapi menggunakan pendekatan yang sedikit berbeda, jadi saya pikir saya akan mempostingnya.

Penjelasan

Kode ini benar-benar membingungkan bagi seseorang yang tidak fasih menggunakan PowerShell, jadi saya akan mencoba memecahnya menjadi bahasa Inggris sebaik mungkin ...

Kami mulai dengan mengambil input param($a,$b)seperti biasa.

Seluruh sisa kode sebenarnya adalah satu pernyataan, dan dapat dipecah (...)-and(...)untuk menguji dua pernyataan Boolean dengan -andoperator.

Paren kiri dapat dipecah (... -eq ...)untuk menguji kesetaraan dua objek. Dalam contoh ini, objek adalah .Counts (yaitu, panjang) dari dua array char baru. Setiap paren bagian dalam ($a=[char[]]$a|sort)mengambil kata input asli, memasangnya kembali sebagai char-array, lalu mengurutkannya dan menyimpan kembali ke variabel yang sama. Kami melakukan itu untuk keduanya $adan $b. Dengan demikian sisi kiri memverifikasi bahwa kata-kata yang dimasukkan memiliki panjang yang sama. Jika panjangnya tidak sama, setengah dari pernyataan Boolean luar ini akan gagal dan Falseakan menjadi output.

Pindah ke sisi kanan, kami lagi menguji dua pernyataan Boolean dengan (... -and ...). Sisi kiri menguji apakah sesuatu lebih besar dari atau sama dengan negatif 1 dengan -ge-1. The sesuatu adalah zeroth-elemen array dibangun $c, yang dibuat oleh:

• mengambil kisaran indeks yang diizinkan 0..($a.count-1)
• disalurkan ke dalam lingkaran |%{...}
• setiap iterasi dari loop, kita mengambil nilai ASCII dari karakter yang diindeks $adan mengurangi nilai ASCII dari karakter yang diindeks dalam$b
• yang kemudian |sortdiedit dengan nilai numerik

Sisi lain dari pernyataan mengambil nilai maksimal $c[-1]array dan memastikan itu kurang dari atau sama dengan 1 dengan -le1.

Jadi, jika dua string input berdekatan, $carray akan menjadi seperti @(-1,-1,-1...0,0,0...1,1,1). Jadi elemen pertama adalah elemen -1terakhir 1. Jika mereka tidak berdekatan, perbedaan nilai ASCII untuk pasangan tertentu akan menjadi < -1atau > 1, sehingga setengah dari tes Boolean luar akan gagal, dan Falseakan menjadi output.

Hanya jika kedua belah pihak lulus akan Truemenjadi output, dan karenanya string adalah LA.

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

Diperluas:

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
}

Kasus uji:

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

(61 jika kita harus menyediakan {and}, 63 dengan f ←)

Saya bukan APLer terhebat, tapi itu terlalu menyenangkan.

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

=/⍴¨∊¨⍺⍵ Apakah inputnya sama panjang?

∧ dan semua yang di bawah ini

(⍺{⌈/⍴¨⍺⍵}⍵)⍴¨⍺[⍋⍺]⍵[⍋⍵] urutkan kedua input dan bentuk menjadi sepanjang terpanjang dari keduanya (mereka membungkus jika Anda membuatnya lebih lama dari mereka)

|¨∊-/{⎕av⍳⍵} konversikan kedua vektor char menjadi vektor int dari nilai ascii mereka, lakukan pengurangan vektor dan absolut semua nilai

0=+/2≤ jumlahkan nilai yang lebih besar dari atau sama dengan dua dan periksa apakah hasilnya sama dengan 0

K (oK) , 27 byte

Larutan:

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

Cobalah online!

Contoh:

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

Penjelasan:

Pertama, urutkan setiap string, lalu pad dengan panjang yang sama, lalu ambil satu dari yang lain (nilai ASCII dari karakter), hasil kuadrat karena tidak ada built-in abs, ambil perbedaan maksimum dan periksa apakah kurang dari 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:@/:~)

dijelaskan

• &(3&u:@/:~) mengurutkan kedua argumen, dan mengonversinya menjadi angka ascii
• ,: menciptakan matriks 2 xn, di mana n adalah jumlah karakter dari argumen
• -/ kurangi satu baris dari yang lain, berikan daftar panjang n yang mewakili jarak karakter yang sesuai
• (2>|) mengembalikan 1 jika nilai absolut dari jarak kurang dari 2, 0 sebaliknya
• */mengalikan semua 0s dan 1s bersama-sama: karenanya, hasil akhirnya adalah 1 jika semua pasangan karakter terkait berdekatan.

Cobalah online!