เพื่อไม่ให้สับสนกับรหัสผ่านท่านอธิการ !

กำหนดสตริงคำตอบ (truthy / falsy หรือสองค่าที่สอดคล้องกัน) ถ้ามันถือว่ารหัสผ่านซึ่งเป็นที่แข็งแกร่งกับบาทหลวง

รหัสผ่านมีความแข็งแกร่งต่ออธิการถ้าเป็นสตริงที่ประกอบด้วยตัวอักษรสลับ (ในa-h) และตัวเลข (เป็น1-8) เพื่อให้แต่ละคู่ของอักขระสามารถตีความได้ว่าเป็นรูปสี่เหลี่ยมจัตุรัสบนกระดานหมากรุกและถ้าคุณวางเบี้ยสีขาวไว้ในแต่ละตารางชื่อ ในรหัสผ่านจากนั้นไม่มีวิธีใดที่อธิการสีขาวจะเดินทางในทุก ๆ การเคลื่อนไหวติดต่อกันไม่ว่าจะเป็นสี่เหลี่ยมใด ๆ ใน1แถวแรก ( ) ไปจนถึงสี่เหลี่ยมใด ๆ ใน8แถวสุดท้าย ( )

ตัวอย่าง

รหัสผ่านที่แข็งแกร่งกับบาทหลวง

• a1b1c1d1e1f1g1h1
• a8b8c8d8e8f8g8h8
• a1b2c3d4d5f5f4g3g4h2b5
• h4g4f4e4c4b4a4c3e3
• a1b1c1d1e1f1g1a8b8c8d8e8f8g8
• b4b5d4d5f4f5g3h5

ตัวอย่างเช่นa1b1c1d1e1f1g1a8b8c8d8e8f8g8สอดคล้องกับตำแหน่งและb4b5d4d5f4f5g3h5สอดคล้องกับตำแหน่ง

รหัสผ่านอ่อนแอต่อบาทหลวง

• a4c4e4g4g5d6f6e3d2b2 (รูปแบบที่ดี แต่ไม่แข็งแรง - ขอบคุณ Jo King สำหรับตัวอย่างนี้!)
• b1c1d1e1f1g1h1a8b8c8d8e8f8g8 (รูปแบบที่ดี แต่ไม่แข็งแรง)
• h4g4f4e4c4b4a4c3 (รูปแบบที่ดี แต่ไม่แข็งแรง)
• d4 (รูปแบบที่ดี แต่ไม่แข็งแรง)
• b4b5d4d5f4f5g2h5 (รูปแบบที่ดี แต่ไม่แข็งแรง)
• correct horse battery staple (ที่ไม่ดีเกิดขึ้น)
• 1a1b1c1d1e1f1g8a8b8c8d8e8f8g (ที่ไม่ดีเกิดขึ้น)
• a (ที่ไม่ดีเกิดขึ้น)
• aa (ที่ไม่ดีเกิดขึ้น)

Ruby, 115 182 163 ไบต์

->s{z=('00'..'99').map{|x|x=~/[09]/||s[(x[1].ord+48).chr+x[0]]};(11..18).map &g=->x{z[x]||[x-11,x-9,x+z[x]=9,x+11].map(&g)};s=~/^([a-h][1-8])*$/&&(z[81,9]-[9])[8]}

ลองออนไลน์!

ผลตอบแทนที่1แข็งแกร่งและnilอ่อนแอ (+67 ไบต์ใช้เพื่อพิจารณาว่า "การย้อนรอย")

->s{
 z=                             # this is the board
 ('00'..'99').map{|x|           # coordinates are described as y*10 + x
  x=~/[09]/||                   # truthy if out of bounds...
  s[(x[1].ord+48).chr+x[0]]     # ...or impassable
 }                              # now only the passable squares are falsey
 (11..18).map                   # for each x position at y=1,
  &g=->x{                       # call helper function on that square
   z[x]||                       # if the square is passable (i.e. falsey),
    [x-11,x-9,x+z[x]=9,x+11]    # mark it impassable by setting to 9 (truthy)
     .map(&g)                   # call helper recursively for each neighbor
  }
 s=~/^([a-h][1-8])*$/           # make sure the input was valid,
 &&(z[81,9]-[9])[8]             # and check that the last row was never reached
}

เทคนิคเล็กน้อยที่ใช้:

• แทนที่จะใช้ช่วงตัวเลข0..99เราจะใช้ช่วงของสตริง'00'..'99'เพื่อให้ตัวเลขนั้นถูกเติมด้านซ้ายเป็น 2 หลักโดยอัตโนมัติและทำให้เป็นสตริง นี้จะทำให้ออกจากขอบเขตการตรวจสอบสั้นมาก - การจับคู่กับ /[09]/regex

• ภายในฟังก์ชั่นตัวช่วยในขณะสร้างรายการพิกัดใหม่[x-11, x-9, x+9, x+11]เราได้กำหนดz[x]ให้9กับกระบวนการพร้อมกันซึ่งเป็นค่าจริง (ทำเครื่องหมายสแควร์ที่เยี่ยมชม)

• ในบรรทัดสุดท้ายเราต้องการที่จะตรวจสอบว่าอาร์เรย์ไม่ได้มีz[81,9] 9เราทำสิ่งนี้โดยการลบอินสแตนซ์ทั้งหมดของ9( z[81,9]-[9]) จากนั้นขอองค์ประกอบที่ 9 ของอาร์เรย์ผลลัพธ์ ( [8]) เนื่องจากเรารู้ว่าอาเรย์นั้นมีองค์ประกอบ 9 อย่างถ้ามีการลบออกเราจะได้รับnilในขณะที่ถ้ามันยังคงอยู่ทั้งหมดเราจะได้องค์ประกอบสุดท้ายของอาร์เรย์ (ซึ่งเกิดขึ้นเสมอ1)

Python 2 , 330 318 313 309 370 ไบต์

import numpy as n
b=n.ones([8,8])
q=r=1
s=input()
l=len(s)
def g(x,y=0,p=0):
    if b[y,x]and p<32:
        if y<7:
            if x<7:
                g(x+1,y+1,p+1)
                if y:g(x+1,y-1,p+1)
            if x:
                g(x-1,y+1,p+1)
                if y:g(x-1,y-1,p+1)
        else:global q;q=0
for i in range(l/2):
    x=ord(s[2*i])-97;y=ord(s[2*i+1])-49
    if y>8or y<0 or l%2or x>8or x<0:r=0
    if r:b[7-y,x]=0
map(g,range(8))
print q&r

ลองออนไลน์!

ลองใช้เวอร์ชั่นจริงออนไลน์! (ต้นฉบับสามารถใช้การดำเนินการ 4 ^ 32 เพื่อตรวจสอบอย่างสมบูรณ์ฉันขอแนะนำให้ใช้หนึ่ง - จำนวนไบต์เดียวกันนี้)

ไม่ใช่คำตอบสั้น ๆ - ฉันไม่สามารถหาวิธีทำให้รุ่นแลมบ์ดาฟังก์ชั่นของจีนั้นสั้นกว่าตัวมันเอง

-4 ไบต์ขอบคุณ Quuxplusone

+61 bytes คิดเป็น backtracking (ขอบคุณที่ชี้ให้เห็นว่า Jo King และเคล็ดลับการเล่นกอล์ฟ)

Python 2 , 490 476 474

def f(p):
 a=[set(ord(c)-33 for c in s)for s in"* )+ *, +- ,. -/ .0 / \"2 !#13 \"$24 #%35 $&46 %'57 &(68 '7 *: )+9; *,:< +-;= ,.<> -/=? .0>@ /? 2B 13AC 24BD 35CE 46DF 57EG 68FH 7G :J 9;IK :<JL ;=KM <>LN =?MO >@NP ?O BR ACQS BDRT CESU DFTV EGUW FHVX GW JZ IKY[ JLZ\\ KM[] LN\\^ MO]_ NP^` O_ R QS RT SU TV UW VX W".split()];x=set((ord(p[i+1])-49)*8+ord(p[i])-97 for i in range(0,len(p),2))
 r=set(range(8))-x
 for i in range(99):r=set().union(*[a[c]for c in r])-x
 return all(c<56 for c in r)

ลองออนไลน์!

สิ่งนี้ทำงานโดย "เติมน้ำท่วม" ก่อนอื่นเราสร้างรายการaของช่องสี่เหลี่ยมที่อยู่ติดกับช่องสี่เหลี่ยมอื่น ๆ จากนั้นเราสร้างชุดxการยกเว้น (ขึ้นอยู่กับรหัสผ่าน) จากนั้นเราเริ่มต้นชุดrของสี่เหลี่ยมที่เข้าถึงได้ซึ่งเริ่มต้นเป็นเพียงแถวแรก (ลบด้วยการยกเว้นใด ๆ ) และ "ท่วม" ซ้ำ ๆ ออกไปด้านนอกจากที่นั่น 99 ครั้งซึ่งควรจะมากเกินพอ ในที่สุดเราทดสอบเพื่อดูว่าสี่เหลี่ยมใด ๆ ในแถวสุดท้ายสิ้นสุดลงในชุดที่เราเข้าถึงได้หรือไม่ ถ้าเป็นเช่นนั้นเรามีรหัสผ่านที่อ่อนแอ! ถ้าไม่เรามีรหัสผ่านที่คาดเดายาก

ข้อเสียอาจสิทธ์ (ผมไม่ทราบว่ากฎปกติที่นี่): ถ้ารหัสผ่านที่ไม่ดีที่เกิดขึ้น (เช่น "ม้าที่ถูกต้องแบตเตอรี่หลัก") Falseแล้วเราโยนยกเว้นแทนที่จะกลับ แต่เราจะส่งคืนTrueถ้ารหัสผ่านนั้นแข็งแกร่งเสมอ!

ลบ 16 ไบต์ด้วย Jo King เราอินไลน์aไว้ในที่เดียวที่มันถูกใช้และพับคณิตศาสตร์ไปเรื่อย ๆ

def f(p):
 x=set(ord(p[i])-489+8*ord(p[i+1])for i in range(0,len(p),2));r=set(range(8))-x
 for i in[1]*99:r=set().union(*[[set(ord(k)-33for k in s)for s in"* )+ *, +- ,. -/ .0 / \"2 !#13 \"$24 #%35 $&46 %'57 &(68 '7 *: )+9; *,:< +-;= ,.<> -/=? .0>@ /? 2B 13AC 24BD 35CE 46DF 57EG 68FH 7G :J 9;IK :<JL ;=KM <>LN =?MO >@NP ?O BR ACQS BDRT CESU DFTV EGUW FHVX GW JZ IKY[ JLZ\\ KM[] LN\\^ MO]_ NP^` O_ R QS RT SU TV UW VX W".split()][c]for c in r])-x
 return all(c<56for c in r)

ทำความสะอาด , 285 ไบต์

import StdEnv,Data.List
$_[_]=1<0
$a[x,y:l]=case[[u,v]\\u<-[0..7],v<-[0..7]|u==toInt x-97&&v==toInt y-49]of[p]= $[p:a]l;_=1<0
$a _=all(\[_,y]=y<7)(iter 64(nub o\e=e++[k\\[u,v]<-e,p<-[-1,1],q<-[-1,1],k<-[[abs(u+p),abs(v+q)]]|all((<>)k)a&&all((>)8)k])(difference[[e,0]\\e<-[0..7]]a))

$[]

ลองออนไลน์!

$[]จะประกอบไปด้วยอาร์กิวเมนต์แรกให้$ :: [[Int]] [Char] -> Bool\ [Char] -> Bool

ฟังก์ชั่นการทำงานโดยการใช้สตริงสองตัวอักษรในเวลาเดียวกลับเท็จถ้าสตริงอยู่ในรูปแบบที่ไม่ถูกต้องทันทีที่เห็นส่วนที่ไม่ถูกต้อง เมื่อสตริงได้รับการประมวลผลแล้วมันจะวางอธิการลงในช่องว่างเปล่าทุกด้านที่ด้านหนึ่งของบอร์ดและย้ายไปในทุก ๆ ทางที่เป็นไปได้ 64 ครั้งและตรวจสอบว่าตำแหน่งใด ๆ ที่สิ้นสุดอยู่ในแถวเป้าหมาย

ภาษา Wolfram (Mathematica) , 339 316 358 353 345 bytes

-23 ไบต์ขอบคุณ @Doorknob

+42 ไบต์คิดเป็น backtracking

p[m_]:=StringPartition[#,m]&;l=Range@8;f[n_]:=Check[w=(8#2+#1-8)&@@@({LetterNumber@#,FromDigits@#2}&@@@(p@1/@p[UpTo@2]@n));g=Graph[Sort/@UndirectedEdge@@@Position[Outer[EuclideanDistance@##&,#,#,1],N@Sqrt@2]&@GraphEmbedding@GridGraph@{8,8}//Union]~VertexDelete~w;c:=#~Complement~w&;m=0;Do[m+=Length@FindPath[g,i,j],{i,c@l},{j,c[l+56]}];m==0,0>1]

ลองออนไลน์!

ฉันเขียนส่วนใหญ่นี้เพื่อบัญชี backtracking ฉันคิดว่าอาจมีวิธีที่ง่ายกว่าในการกำหนดกราฟgMathematica มีGraphData[{"bishop",{8,8}}]ซึ่งเป็นกราฟของการเคลื่อนไหวทั้งหมดที่อธิการสามารถทำบนกระดานหมากรุก ( Bishop Graph ) แต่กราฟนี้รวมการเชื่อมต่อเพิ่มเติม กว่าเพื่อนบ้านแนวทแยงที่ใกล้ที่สุด หากใครรู้วิธีที่สั้นกว่าในการทำเช่นนั้นแจ้งให้ฉันทราบ เครดิตสำหรับการสร้างกราฟไปที่คำตอบ MathematicaSEนี้

ส่งคืนTrueสำหรับรหัสผ่านที่คาดเดายากสำหรับรหัสผ่านที่Falseอ่อนแอ / มีรูปแบบไม่ดี Falseโปรดทราบว่าส่วนใหญ่ของรหัสผ่านที่ไม่ดีที่เกิดขึ้นจะผลิตพวงของข้อความผิดพลาดแล้วกลับ ถ้าสิ่งนี้ไม่สอดคล้องกับกฎพวกเขาสามารถถูกระงับได้โดยเปลี่ยนf[n_]:=...เป็นการf[n_]:=Quiet@...คิดต้นทุน 6 ไบต์

Ungolfed:

p[m_] := StringPartition[#, m] &;

f[n_] :=
 Check[
  w = (8 #2 + #1 - 
       8) & @@@ ({LetterNumber@#, FromDigits@#2} & @@@ (p@1 /@ 
        p[UpTo@2]@n));
  r = GridGraph[{8, 8}];
  g = Graph[Sort /@ UndirectedEdge @@@
             Position[Outer[EuclideanDistance@## &, #, #, 1],N@Sqrt@2] &@
              GraphEmbedding@r // Union]~VertexDelete~w;
  s = Complement[{1,2,3,4,5,6,7,8},w];
  e = Complement[{57,58,59,60,61,62,63,64},w];
  m = 0;
  Do[m += Length@FindPath[g, i, j], {i, s}, {j, e}];
  If[m == 0,True,False]
  , False]

ชำรุด:

p[m_]:=StringPartition[#,m]& 

mใช้เวลาอาร์กิวเมนต์สตริงและแยกลงในรายการของสตริงแต่ละยาว

Check[...,False]

ส่งคืนFalseหากมีการสร้างข้อความแสดงข้อผิดพลาดซึ่งเป็นวิธีที่เราตรวจจับสตริงที่มีรูปแบบไม่ดี (เช่นสมมติว่าข้อความเหล่านั้นมีรูปแบบที่ถูกต้อง

(8*#2 + #1 - 8) & @@@ ({LetterNumber@#, FromDigits@#2} & @@@ (p@1 /@ 
        p[UpTo@2]@n));

รับสายของตำแหน่งจำนำและแยกมันที่"a2h5b"กลายเป็น{{"a","2"},{"h","5"},{"b"}}จากนั้นLetterNumberจะแปลงตัวอักษรเป็นตัวเลข ( a -> 1, ฯลฯ ) และFromDigitsแปลงตัวเลขให้เป็นจำนวนเต็ม ถ้าสตริงที่ไม่ดีขึ้นขั้นตอนนี้จะผลิตข้อผิดพลาดซึ่งจะถูกจับโดยกลับCheck Falseตัวเลขทั้งสองนี้จะถูกแปลงเป็นจำนวนเต็มที่สอดคล้องกับสี่เหลี่ยมจัตุรัสบนกระดาน

r = GridGraph[{8, 8}];
g = Graph[
     Sort /@ UndirectedEdge @@@ 
          Position[Outer[EuclideanDistance@## &, #, #, 1], 
           N@Sqrt@2] &@GraphEmbedding@r // Union]~VertexDelete~w;

สร้างกราฟของเส้นทแยงมุมเพื่อนบ้านที่ใกล้ที่สุดโดยลบตำแหน่งจำนำ

s = Complement[{1,2,3,4,5,6,7,8},w];
e = Complement[{57,58,59,60,61,62,63,64},w];

นี่คือรายการของจุดเริ่มต้นและจุดสิ้นสุดที่ว่างอยู่ตามลำดับ

m=0
Do[m += Length@FindPath[g, i, j], {i, s}, {j, e}];
If[m == 0,True,False]

วนรอบจุดเริ่มต้นและจุดสิ้นสุดสำหรับแต่ละคู่FindPathจะเป็นรายการเส้นทางระหว่างพวกเขา หากมีเส้นทางระหว่างพวกเขาไม่ว่าจะเป็นรายการที่ว่างเปล่าดังนั้นผลตอบแทนLength@ 0หากไม่มีเส้นทางที่ทั้งหมดแล้วmจะเป็นศูนย์และเรากลับมิฉะนั้นผลตอบแทนTrueFalse