ในความท้าทายนี้คุณจะถูกส่งผ่านคำสองคำ: งานของคุณคือการตรวจสอบว่าพวกเขาจะอยู่ติดกัน

ตัวอักษรสองตัวติดกันหาก:

1. พวกเขาเป็นตัวอักษรเดียวกันหรือ
2. พวกมันอยู่ติดกันด้วยคำ

ตัวอย่างเช่นJอยู่ติดกับI , JและKเท่านั้น Zไม่ได้อยู่ติดกับA

คำสองคำติดกันหาก:

1. ความยาวเท่ากันและ
2. ตัวอักษรแต่ละตัวอยู่ติดกับตัวอักษรที่ไม่ซ้ำกันในคำอื่น ๆ

ยกตัวอย่างเช่นกสท.อยู่ติดกับSADเป็นC> D, A> A, T> S
ฟรีไม่ได้อยู่ติดกับGRRD (แต่ละEต้องการเป็นตัวอักษรให้คู่กับ)

Input / Output

คุณถูกส่งผ่านสองสตริงและคุณจำเป็นต้องส่งคืนค่าความจริงหากอยู่ติดกันมิฉะนั้นเป็นค่าเท็จ คุณควรกลับมาภายในหนึ่งนาทีสำหรับทุกกรณีทดสอบด้านล่าง

คุณสามารถสันนิษฐานได้ว่าสตริงจะมีตัวอักษรตัวพิมพ์ใหญ่และตัวอักษรเท่านั้น

ทั้งสองสตริงสามารถส่งผ่านเป็นรายการหรือตัดแบ่งโดยมีหรือไม่มีเครื่องหมายอัญประกาศ

กรณีทดสอบ

Truthy:

A A
A B
C B
DD CE
DE FC
ABCD BCDE
AACC DBBB
DJENSKE FDJCLMT
DEFGHIJKL HJLEHMCHE
IKLIJJLIJKKL LJLJLJLJLJHI
ACEGIKMOQSUWY BLNPRDFTVHXJZ
QQSQQRRQSTTUQQRRRS PQTTPPTTQTPQPPQRTP
ELKNSDUUUELSKJFESD DKJELKNSUELSDUFEUS

Falsy:

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

นี่คือรหัสกอล์ฟดังนั้นคำตอบที่สั้นที่สุดจะชนะ!

CJam, 14 13 12 bytes

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

ลองออนไลน์! หรือตรวจสอบกรณีทดสอบทั้งหมดในครั้งเดียว

ขั้นตอนวิธี

ปล่อย sและtเป็นคำที่เรียงลำดับสองคำที่มีความยาวเท่ากัน สำหรับsและtที่จะอยู่ติดกันกับคำศัพท์ (LA) มันเป็นสิ่งจำเป็นและเพียงพอที่ตัวละครที่เกี่ยวข้องทั้งหมดจะเป็น LA

สภาพเป็นที่ชัดเจนเพียงพอสำหรับทุกคำและจำเป็นสำหรับคำพูดของความยาว1

ทีนี้สมมุติว่าsและtมีความยาวn> 1แล้วปล่อยaและBเป็นตัวอักษรตัวแรก, resp. ของsและเสื้อ

ตั้งแต่sและเสื้อมี LA, มีบางทำแผนที่ bijective φระหว่างตัวละครของsและตัวอักษรของเสื้อเช่นว่าxและφ (x)กำลัง LA สำหรับทุกxในsซึ่งหมายความว่า | x - φ (x) | ≤ 1สำหรับทุกxในs

Let c = φ (ก)และd = φ ^-1 (ข) เพราะการ 'และB ' s minimality, ≤ d (1)และข≤ค (2)

นอกจากนี้ตั้งแต่bและdและaและ Cและ LA, d ≤ B + 1 (3)และค≤ A + 1 (4)

โดยการรวม(1)และ(3)และ(2)และ(4)เราจะได้รับa ≤ d ≤ b + 1และb ≤ c ≤ a + 1ซึ่งเราอนุมานว่า a - 1 ≤ b ≤ a + 1และดังนั้นที่และขเป็น LA

ตอนนี้โดยการรวม(1)และ(4)และ(2)และ(3)เราจะได้c - 1 ≤ a ≤ dและd - 1 ≤ b ≤ cจากที่เราอนุมานว่า c - 1 ≤ d ≤ c + 1และดังนั้นcและdนั้นคือ LA

ดังนั้นถ้าเรานิยามφโดยφ (a) = bและφ (d) = c , | x - φ (x) | ≤ 1จะยังคงถือสำหรับทุกxในsและโดยเฉพาะอย่างยิ่งสำหรับทุกxในs [1:]

วิธีนี้s [0] = aและt [0] = bและs [1:]และt [1:]คือ LA

เนื่องจากs [1:]มีความยาวn - 1สิ่งนี้พิสูจน์ความจำเป็นโดยอุปนัย

รหัส

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ไบต์

c!S!odXl2<

สิ่งนี้ใช้ วิธีของเดนนิส : เรียงลำดับแรกและเปรียบเทียบอักขระในตำแหน่งที่ตรงกัน

อินพุตเป็นอาร์เรย์ของสตริงที่มีรูปแบบ {'CAT 'SAD'}การป้อนข้อมูลเป็นอาร์เรย์ของสตริงที่มีรูปแบบ

เอาท์พุทเป็นอาร์เรย์ของศูนย์และคน ผลที่ได้คือความจริงถ้ามันมีทุกคน (นี่คือตกลงที่จะเป็นจริง)

ใช้รีลีสปัจจุบัน (10.2.1)ซึ่งเร็วกว่าความท้าทายนี้

แก้ไข:ฟังก์ชั่นXlถูกเปลี่ยนชื่อเป็น|ภาษาเวอร์ชันใหม่กว่า (และoไม่จำเป็นอีกต่อไป) ลิงค์ด้านล่างรวมถึงการแก้ไขเหล่านั้น

ลองออนไลน์!

คำอธิบาย :

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

วิธีเก่าซึ่งยอมรับสตริงเป็นอินพุตแยก: 12 ไบต์ :

SiSXhcodXl2<

แก้ไข : รหัสในลิงค์ได้รับการแก้ไขตามการเปลี่ยนแปลงในภาษา; ดูความคิดเห็นด้านบน

ลองออนไลน์ !

คำอธิบาย :

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 ไบต์

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

คุณสามารถทดสอบได้โดยการบันทึกเป็นadj.hแล้วใช้adj.cไฟล์นี้:

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

gcc adj.c -o adjคอมไพล์แล้วใช้ ผลลัพธ์คือ:

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 ไบต์

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

ฟังก์ชั่นไม่ระบุตัวตนที่เรียบง่ายฉันจะต้องมีการตรวจสอบความยาวแยกต่างหากเพราะzipเพียงแค่จะ contatenate มีฟังก์ชั่นที่คล้ายกันในitertools(zip_longest ) ซึ่งจะรองสตริงว่างเปล่า แต่มันจะค่อนข้างแพง

ทดสอบกับ

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

ผลิต:

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

แก้ไข 4 ไบต์บันทึก thx @Neil
แก้ไข 2 4 ไบต์บันทึก thx @ Mwr247

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

หมายเหตุ: คำคุณศัพท์ตรวจสอบคู่ของตัวอักษร ใช้คู่เป็นตัวเลขฐาน 36 nn = a*36+a = a*37ถ้าตัวอักษรที่มีค่าเท่ากันแล้ว หากมีความแตกต่างจาก 1 แล้วหรือn = a*36+a+1 = a*37+1 n = a*36+a-1 = a*37-1ดังนั้นn % 37ต้องเป็น 0, 1 หรือ 36 และn%37%36ต้องเป็น 0 หรือ 1

หมายเหตุ 2: การเพิ่ม '0' ถูกใช้เพื่อให้แน่ใจว่า a และ b มีความยาวเท่ากัน มันสั้นกว่านั้นa.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 ไบต์ 116 ไบต์ 111 ไบต์ 109 ไบต์

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

กรณีทดสอบ

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>

เครดิต

• @ rink.attendant.6 ตัด 5 ไบต์
• @ user81655 ลบออก 2 ไบต์

Pyth, 37 31 ไบต์

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

ลองออนไลน์กับทุกกรณีทดสอบ!

โกนออกได้ 6 ไบต์โดยใช้สัญลักษณ์ลดขนาดสั้นลง ( -Fแทน.U-bZ)

โซลูชันได้แรงบันดาลใจจากDennis

การส่งครั้งแรกเพื่อ codegolf!

คำอธิบาย

เราสามารถแยกนิพจน์เป็นสองส่วนซึ่งเปรียบเทียบกับ&ผลลัพธ์ที่ได้ ฉันจะพยายามอธิบายด้วยการเขียน pseudo-Python

ก่อนอื่นเราตรวจสอบว่าความยาวของทั้งสองคำเหมือนกัน

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

จากนั้นเราใช้วิธีการของเดนนิส:

       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] 

จากนั้นเราจะใช้-โอเปอเรเตอร์เพื่อกรององค์ประกอบทั้งหมดของรายการนั้นที่ไม่อยู่ใน[Z1( [0, 1]) และตรวจสอบว่าผลลัพธ์นั้นเป็นรายการที่ว่างเปล่าด้วยqY

JavaScript (ES6), 87 ไบต์

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

ใช้การตรวจสอบช่วงสมมาตรเป็นศูนย์โดยการหารด้วยค่าสูงสุดจากนั้นตัดทอนด้วย bitwise "หรือ" ( |) Math.abs()สั้นกว่าที่มีการทำสองตรวจสอบหรือหนึ่งด้วย

Haskell, 67 63 ไบต์

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

ตัวอย่างการใช้งาน: ->f "FREE" "GRRD"False

วิธีการทำงาน (หมายเหตุ: fไม่มีจุดบางส่วนและพารามิเตอร์ที่สองbไม่ปรากฏในข้อกำหนด):

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

แก้ไข: @xnor พบ 4 ไบต์เพื่อบันทึก ขอบคุณ!

C, 172 ไบต์

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

กรณีทดสอบ

$ 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 ไบต์

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)

อาจเป็นไปได้ที่จะทำให้เรื่องนี้สั้นลง ขณะนี้ยังไม่แข่งขันกับ Python หรือ JavaScript แต่ใช้วิธีการที่แตกต่างกันเล็กน้อยดังนั้นฉันจึงคิดว่าฉันจะโพสต์

คำอธิบาย

รหัสนี้สร้างความสับสนให้กับบางคนที่ไม่เชี่ยวชาญใน PowerShell ดังนั้นฉันจะพยายามทำลายมันเป็นภาษาอังกฤษให้ดีที่สุดเท่าที่จะทำได้ ...

เราเริ่มต้นด้วยการป้อนข้อมูลparam($a,$b)ตามปกติ

รหัสที่เหลือทั้งหมดเป็นจริงหนึ่งคำสั่งและสามารถแตกเป็น(...)-and(...)ทดสอบสองงบบูลีนกับ-andผู้ประกอบการ

parens ด้านซ้ายสามารถถูกทำลายได้(... -eq ...)เพื่อทดสอบความเท่าเทียมกันของวัตถุสองชิ้น ในตัวอย่างนี้วัตถุเป็น.Counts (นั่นคือความยาว) ของสองอาร์เรย์ใหม่ แต่ละ paren ภายใน($a=[char[]]$a|sort)จะใช้คำที่ป้อนเข้ามาแล้วนำมันออกมาใหม่เป็น char-array จากนั้นทำการเรียงลำดับและบันทึกกลับเข้าไปในตัวแปรเดียวกันอีกครั้ง เราทำที่สำหรับทั้งสองและ$a $bด้านซ้ายมือจึงตรวจสอบว่าคำที่ป้อนมีความยาวเท่ากัน หากมันไม่ได้มีความยาวเท่ากันครึ่งหนึ่งของคำสั่งบูลีนด้านนอกนี้จะล้มเหลวFalseจะถูกส่งออก

(... -and ...)จะย้ายไปอยู่ด้านขวามือเราอีกครั้งการทดสอบสองงบบูลีนกับ การทดสอบด้านซ้ายมือไม่ว่าจะเป็นบางสิ่งบางอย่างที่ยิ่งใหญ่กว่าหรือเท่ากับลบ -ge-11 สิ่งที่เป็นข้อที่ศูนย์องค์ประกอบของอาร์เรย์สร้าง$cซึ่งถูกสร้างขึ้นโดย:

• จดดัชนีที่ได้รับอนุญาต 0..($a.count-1)
• piped เป็นวง |%{...}
• การวนซ้ำแต่ละครั้งของลูปเราใช้ค่า ASCII ของอักขระที่ทำดัชนี$aและลบค่า ASCII ของอักขระที่จัดทำดัชนีใน$b
• ซึ่งจะถูก|sortแก้ไขด้วยค่าตัวเลข

ด้านอื่น ๆ ของคำสั่งที่จะเกิดมูลค่าสูงสุด$c[-1]ของอาร์เรย์และสร้างความมั่นใจมันน้อยกว่าหรือเท่ากับ -le11

ดังนั้นหากทั้งสองสายการป้อนข้อมูลที่แท้จริงที่อยู่ติดกันที่อาร์เรย์จะเป็นสิ่งที่ชอบ$c @(-1,-1,-1...0,0,0...1,1,1)ดังนั้นองค์ประกอบแรกจะเป็นและองค์ประกอบสุดท้ายจะเป็น-1 1หากพวกเขาไม่ได้อยู่ติดกันความแตกต่างในค่า ASCII สำหรับคู่หนึ่งจะเป็น< -1หรือ> 1ดังนั้นการทดสอบบูลีนนอกครึ่งนี้จะล้มเหลวและFalseจะถูกส่งออก

หากทั้งสองฝ่ายผ่านจะTrueถูกส่งออกและสตริงจึงเป็น LA

สนิม269 264 ไบต์

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}

ขยาย:

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
}

กรณีทดสอบ:

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 ไบต์ (ตัวอักษร)

(61 ถ้าเราต้องจัดหา {และ}, 63 กับ f ←)

ฉันไม่ใช่ APLer ที่ยิ่งใหญ่ที่สุด แต่มันสนุกมากเกินไป

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

=/⍴¨∊¨⍺⍵ อินพุตมีความยาวเท่ากันหรือไม่

∧ และด้านล่างทั้งหมด

(⍺{⌈/⍴¨⍺⍵}⍵)⍴¨⍺[⍋⍺]⍵[⍋⍵] จัดเรียงทั้งอินพุตและจัดรูปร่างให้ยาวที่สุดเท่าที่ยาวที่สุดของทั้งสองตัว

|¨∊-/{⎕av⍳⍵} แปลงทั้งเวกเตอร์ถ่านให้เป็นเวกเตอร์ int ของค่า ascii ของพวกเขาทำการลบเวกเตอร์และค่าทั้งหมดทั้งหมด

0=+/2≤ สรุปค่าที่มากกว่าหรือเท่ากับสองและตรวจสอบว่าผลลัพธ์เท่ากับ 0

K (oK) , 27 ไบต์

วิธีการแก้:

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

ลองออนไลน์!

ตัวอย่าง:

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

คำอธิบาย:

ก่อนอื่นให้เรียงแต่ละสตริงจากนั้นให้ pad มีความยาวเท่ากันจากนั้นนำสตริงหนึ่งจากค่าอื่น ๆ (ค่า ASCII ของตัวอักษร) ผลลัพธ์แบบสี่เหลี่ยมเนื่องจากไม่มีบิวด์อินabsใช้ความแตกต่างสูงสุดและตรวจสอบว่าน้อยกว่า 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 ไบต์

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

ungolfed

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

อธิบาย

• &(3&u:@/:~) เรียงลำดับอาร์กิวเมนต์ทั้งสองและแปลงเป็นตัวเลข ASCII
• ,: สร้างเมทริกซ์ 2 xn โดยที่ n คือจำนวนตัวอักษรของ args
• -/ ลบหนึ่งแถวจากอีกแถวหนึ่งโดยให้รายการความยาว n เป็นระยะทางของตัวอักษรที่เกี่ยวข้อง
• (2>|) ส่งคืน 1 หากค่าสัมบูรณ์ของระยะทางน้อยกว่า 2, 0
• */คูณ0s และ1s ทั้งหมดเข้าด้วยกัน: ดังนั้นผลลัพธ์สุดท้ายคือ 1 iff ทุกคู่ที่สอดคล้องกันอยู่ติดกัน

ลองออนไลน์!