บทนำ

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

กลศาสตร์

รถของคุณเริ่มต้นที่มุมบนซ้ายของแผนที่ 8x8 และพยายามที่จะปลอดภัยที่มุมล่างขวา รถมีทิศทาง (เริ่มแรกไปทางขวา) วัดโดยเพิ่มทีละ 90 องศา รถสามารถดำเนินการอย่างใดอย่างหนึ่งจากสองการกระทำ:

1. ขับไปข้างหน้าหนึ่งสี่เหลี่ยมหรือ
2. หมุนตามเข็มนาฬิกา 90 องศาจากนั้นขับไปข้างหน้าหนึ่งช่อง

โปรดทราบว่ารถไม่สามารถเลี้ยวได้เร็วพอที่จะเลี้ยวได้ 180 องศาในหนึ่งตาราง

สี่เหลี่ยมบางอันเป็นอุปสรรค หากรถเข้าสู่จัตุรัสสิ่งกีดขวางก็เกิดปัญหา ทุกอย่างที่อยู่นอกสนาม 8x8 นั้นถือว่าเป็นอุปสรรคดังนั้นการขับรถนอกเส้นทางนั้นจึงเทียบเท่ากับการกระแทก

ตารางด้านล่างขวาคือจัตุรัสที่ปลอดภัยซึ่งช่วยให้รถหลบหนีจากสิ่งกีดขวางได้ สี่เหลี่ยมเริ่มต้นและสี่เหลี่ยมปลอดภัยถือว่าไม่เป็นอุปสรรค

งาน

คุณต้องเขียนโปรแกรมหรือฟังก์ชั่นที่ใช้เป็นอาเรย์ของ 8x8 (เมทริกซ์, ลิสต์ของรายการ, ฯลฯ ) ซึ่งแสดงถึงเส้นทางของสิ่งกีดขวาง โปรแกรมส่งคืนหรือพิมพ์บูลีนหรือสิ่งที่คล้ายกัน ถ้ามันเป็นไปได้สำหรับรถที่จะให้มันไปตารางปลอดภัยโดยไม่ crashing (เช่นถ้าแผนที่จะแก้ปัญหาได้) ออกเป็นมิฉะนั้นก็TrueFalse

เกณฑ์การให้คะแนน

กฎของรหัสกอล์ฟมาตรฐาน - ผู้ชนะคือรหัสที่มีจำนวนไบต์น้อยที่สุด

โบนัส:

• หากสำหรับแผนที่ที่แก้ไขได้รหัสของคุณจะแสดงชุดข้อมูลไดรเวอร์ที่ถูกต้องซึ่งนำรถไปยังจัตุรัสที่ปลอดภัยให้หักคะแนน 10 เปอร์เซ็นต์จากคะแนนของคุณ ตัวอย่างรูปแบบเอาท์พุทอาจเป็นSRSSR(ระบุตรง, ขวา, ตรง, ตรง, ขวา) เอาต์พุตนี้จะแทนที่Trueเอาต์พุตมาตรฐาน

• หากสำหรับแผนที่ที่ไม่สามารถแก้ไขได้ผลลัพธ์ของรหัสของคุณจะแยกแยะระหว่างสถานการณ์ที่ความผิดพลาดไม่สามารถหลีกเลี่ยงได้และสถานการณ์ที่เป็นไปได้ที่จะขับไปรอบ ๆ เส้นทางของสิ่งกีดขวางตลอดไปให้หักคะแนนร้อยละ 10 ตัวอย่างผลลัพธ์อาจเกิดขึ้นได้Crashหากการชนไม่สามารถหลีกเลี่ยงได้หรือStuckหากรถติดค้างในเส้นทางของสิ่งกีดขวางตลอดไป เอาต์พุตเหล่านี้จะแทนที่Falseเอาต์พุตมาตรฐานสำหรับแผนที่ที่ไม่สามารถแก้ไขได้

ตัวอย่าง

หากโปรแกรมได้รับอาร์เรย์ 8x8 เช่นนี้

[[0, 0, 0, 0, 0, 1, 0, 0],
 [0, 0, 0, 0, 0, 0, 1, 0], 
 [1, 1, 0, 0, 0, 0, 0, 0], 
 [0, 1, 0, 1, 0, 0, 0, 0], 
 [0, 0, 1, 1, 0, 0, 0, 0], 
 [0, 0, 0, 0, 1, 0, 1, 0], 
 [0, 0, 0, 0, 0, 0, 1, 0], 
 [0, 1, 1, 0, 0, 0, 1, 0]]

มันจะถูกตีความว่าเป็นแผนที่เช่นนี้โดยมีสี่เหลี่ยมสีดำแสดงถึงสิ่งกีดขวาง:

และทางออกที่เป็นไปได้คือ:

เนื่องจากมีวิธีแก้ปัญหาอยู่โปรแกรมควรส่งคืน / พิมพ์Trueสำหรับแผนที่นี้ SSSSRSRRRSRSSRRRSSRSSSลำดับของการเคลื่อนไหวที่แสดงที่นี่เป็น

JavaScript (ES6) - 122 124 148 162 172 178 187 190 193 208ไบต์

ขอขอบคุณ Optimizer และ DocMax สำหรับคำแนะนำที่เป็นประโยชน์ในการปรับปรุงโค้ดนี้:

F=a=>(D=(x,y,d)=>!D[i=[x,y,d]]&&(D[i]=1,x-=~d%2,y-=~-~d%2,x*y==49||!((x|y)&8||a[y][x])&&(D(x,y,d)||D(x,y,~-d%4))),D(-1,0))

ส่งคืนtrue(ความจริง) สำหรับการแก้ไขและfalse(เท็จ) สำหรับแก้ไม่ได้

ใช้งานได้เฉพาะใน Firefox ตั้งแต่วันนี้เนื่องจากคุณสมบัติของ JavaScript 1.7

คณะกรรมการทดสอบ

Python 2 - 123 125 133 146 148 150 154 160

Trueในความสำเร็จความFalseล้มเหลว

def f(h=1,v=0,b=0,x=0,y=0,c=[]):s=x,y,h,v;a=b,x+h,y+v,c+[s];return(s in c)==(x|y)&8==b[y][x]<(x&y>6or f(h,v,*a)|f(-v,h,*a))

f(b=var_containing_board)คุณต้องใส่การป้อนข้อมูลเช่น

รุ่นแลมบ์ดา - 154

ผลตอบแทน0(เท็จ) สำหรับความล้มเหลวTrueเพื่อความสำเร็จ

F=lambda b,x=0,y=0,h=1,v=0,c=[]:0if[x,y,h,v]in c or x|y>7or x|y<0 or b[y][x]else x&y==7or F(b,x+h,y+v,h,v,c+[[x,y,h,v]])or F(b,x+h,y+v,-v,h,c+[[x,y,h,v]])

ขอบคุณ Will และ Brandon ที่ทำให้ฟังก์ชั่นนั้นสั้นกว่าแลมบ์ดา นอกจากนี้สำหรับการเพิ่มการเลื่อนในแนวนอน: D

ขอบคุณ xnor สำหรับการทุบตีและตรรกะที่เหนือกว่า!

แก้ไขหมายเหตุ: ฉันมั่นใจอย่างมีเหตุผลที่b[y][x]จะไม่ถูกประหารเมื่อออกนอกระยะ เนื่องจากเราอยู่นอกของคณะกรรมการตรวจสอบประวัติจะเป็นs in c Falseจากนั้นตรวจสอบเขตแดนจะเป็น(x|y)&8 8จากนั้นไพ ธ อนจะไม่ตรวจสอบค่าสุดท้ายของ==เพราะสองรายการแรกนั้นแตกต่างกันไปแล้ว

C (GNU-C), 163 ไบต์ * 0.9 = 146.7

#C (GNU-C), 186 ไบต์ * 0.9 = 167.4

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

ฟังก์ชั่นนี้ใช้อาร์เรย์ของบิต (อันแทนค่าสี่เหลี่ยมจัตุรัสที่ถูกบล็อก) ในรูปแบบของจำนวนเต็ม 64- บิต บิตถูกจัดเรียงอย่างน้อยที่สุดถึงสำคัญที่สุดในลักษณะเดียวกับที่คุณจะอ่านหนังสือ มันจะคืนค่า -1 สำหรับการชน, 0 สำหรับการขับขี่ตลอดไปหรือ 1 สำหรับการหลบหนีไปที่มุมล่างขวา

g(long long o) {
    typeof(o) a=0,i=255,r=1,u=0,l=0,d=0,M=~0LLU/i,D;
    for( ;i--;d = D<<8&~o)
        a |= D = d|r,
        r = (r|u)*2&~M&~o,
        u = (u|l)>>8&~o,
        l = ((l|d)&~M)/2&~o;
    return a<0?:-!(d|r|u|l);
}

โปรแกรมทดสอบ

f(long long o){typeof(o)a=0,i=255,r=1,u=0,l=0,d=0,M=~0LLU/i,D;for(;i--;d=D<<8&~o)a|=D=d|r,r=(r|u)*2&~M&~o,u=(u|l)>>8&~o,l=((l|d)&~M)/2&~o;return a<0?:-!(d|r|u|l);}
{
    char* s[] = {"Crash", "Stuck", "Escape"};
    #define P(x) puts(s[f(x)+1])
    L ex = 0x4640500C0A034020;
    P(ex);
    L blocked = 0x4040404040404040;
    P(blocked);

    L dead = 0x10002;
    P(dead);

    return 0;
}

เอาท์พุต

Escape
Stuck
Crash

Python ตัวแปลงอาร์เรย์เป็นหกเหลี่ยม:

a2b=lambda(A):"0x%X"%sum(A[i/8][i%8]<<i for i in range(64))

Python, 187 213

207 ตัวอักษรโบนัส 10% สำหรับเส้นทางการพิมพ์

b=map(ord," "*9+" ".join("".join("o "[i]for i in j)for j in input())+" "*9)
def r(p,d,s):
 p+=(1,9,-1,-9)[d]
 if b[p]&1<<d:b[p]^=1<<d;return(s+"S")*(p==79)or r(p,d,s+"S")or r(p,(d+1)%4,s+"R")
print r(8,0,"")

ในอินพุตทดสอบพบเส้นทางที่แตกต่างกันเล็กน้อย: SSSSRSRSRRSSRSSRRSRSSRSSSSS

วิธีการทั่วไปคือการเปลี่ยนอินพุตให้เป็นช่องว่างและoเอสก่อน ช่องว่างมีเลขฐานสิบหก20ดังนั้นบิตที่ต่ำกว่าทั้งสี่จะไม่ถูกตั้งค่า oมีเลขฐานสิบหกของ6Fดังนั้นบิตต่ำสี่ชุดทั้งหมด

เส้นขอบของoถูกวางไว้รอบกระดานดังนั้นเราไม่ต้องกังวลเกี่ยวกับดัชนีที่ไม่ดี

ขณะที่เราเดินข้ามกระดานเราใช้บิตในแต่ละแผ่นเพื่อดูว่าเราได้รับอนุญาตให้ผ่านเมื่อมาจากด้านนั้นหรือไม่ ด้วยวิธีนี้เราหลีกเลี่ยงการวนซ้ำไม่สิ้นสุด ไม่เพียงพอที่จะมีบูลีนเดียวต่อหนึ่งแผ่นเนื่องจากทิศทางทางออกของคุณขึ้นอยู่กับทิศทางการเข้าของคุณเพื่อให้สามารถเยี่ยมชมไทล์ได้สองครั้ง

จากนั้นเราทำการค้นหาแบบเรียกซ้ำเพื่อหาเส้นทางที่ปลอดภัย

Javascript - 270 - 20% = 216 262 - 20% = 210 bytes

เนื่องจากควรมีทางออกอย่างน้อยหนึ่งวิธีที่ได้รับโบนัสทั้งสอง (และไม่นำไปสู่ความลึกของกองซ้อนที่ไร้สาระ;) ...

minified:

V=I=>{n=[N=[0,0,0]];v={};v[N]='';O='C';for(S='';n[0];){m=[];n.map(h=>{[x,y,d]=h;D=i=>[1,0,-1,0][d+i&3];p=v[h];for(j=2;j--;){O=v[c=[X=x+D(j),Y=y+D(3-3*j)),d+j&3]]?'K':O;J=X|Y;J<0||J>7||I[Y][X]||v[c]?O:(m.push(c),v[c]=p+'SR'[j])}S=(x&y)>6?p:S});n=m;}return S||O;};

ขยาย:

V = I => {
    n = [N=[0,0,0]];
    v = {};
    v[N] = '';
    O = 'C';

    for( S = ''; n[0]; ) {
        m = [];
        n.map( h => {
            [x,y,d] = h;
            D = i => [1,0,-1,0][d+i&3];
            p = v[h];
            for( j = 2; j--; ) {
                O = v[c = [X = x+D(j),Y = y+D(3-3*j),d+j&3]] ? 'K' : O;
                J = X|Y;
                J<0 || J>7 || I[Y][X] || v[c] ? O : (
                    m.push( c ),
                    v[c] = p + 'SR'[j]
                );
            }

            S = (x&y) > 6 ? p : S;
        } );
        n = m;
    }
    return S || O;
};

vเป็น Hashtable ด้วยปุ่มที่มีอเนกประสงค์รัฐ(x,y,d)ที่สอดคล้องกับ (x, y) dประสานงานและทิศทางของรายการ แต่ละคีย์มีค่าที่เกี่ยวข้องซึ่งเป็นสตริงของการย้ายS(แบบตรง) และR(เลี้ยวขวา) ที่จำเป็นในการเข้าถึงสถานะแทนด้วยคีย์

รหัสยังรักษาสแต็คของอเนกประสงค์ (ในตัวแปรn) ที่ยังไม่ได้รับการประมวลผล สแต็กเริ่มแรกมีเพียงสาม (0,0,0) ซึ่งสอดคล้องกับสถานะที่รถหันไปทางขวาในเซลล์ (0,0) ในลูปภายนอก, for( S = ... )รูทีนจะตรวจสอบว่ามีอเนกประสงค์สามอันที่ยังไม่ได้ประมวลผลอยู่หรือไม่ n.map( ...ถ้าเป็นเช่นนั้นมันจะทำงานแต่ละที่ยังไม่ได้ผ่านสามห่วงด้านใน

วงด้านในทำห้าสิ่ง:

1. คำนวณสองการเคลื่อนไหวที่เป็นไปได้ (ขับตรงเลี้ยวขวา) ออกจากสถานะปัจจุบัน
2. หากการเคลื่อนไหวอย่างใดอย่างหนึ่งเหล่านี้นำไปสู่สถานะที่ลงทะเบียนไว้แล้วใน hashtable จะไม่สนใจการประมวลผลเพิ่มเติม เราตั้งค่าสถานะเอาต์พุต FALSE เป็นK(ติดอยู่) เนื่องจากเราพบว่ามีอย่างน้อยหนึ่งวงที่รถสามารถวนไปเรื่อย ๆ โดยไม่หยุด
3. ถ้ารัฐนั้นถูกกฎหมายและแปลกใหม่มันจะถูกเพิ่มเข้าไปใน hashtable ( v) และใน stack ของ triples ที่ยังไม่ได้ประมวลผล ( m) สำหรับรอบต่อไปของ loop นอก
4. เมื่อมีการลงทะเบียนสถานะใหม่vค่าของมันจะถูกตั้งค่าเป็นสถานะของแหล่งกำเนิด (ลำดับของการย้าย) บวกRหรือSขึ้นอยู่กับการย้ายปัจจุบัน
5. ถ้าxและyเป็น7ค่าของรัฐกำเนิด (ลำดับของการเคลื่อนไหวที่นำไปถึงรัฐกำเนิด) จะถูกคัดลอกไปยังSเนื่องจากลำดับการย้ายนี้เป็นวิธีการแก้ปัญหา

หลังจากลูปด้านในถูกยกเลิกn(สแต็ก) จะถูกแทนที่ด้วยm(สแต็กใหม่)

หลังจากวนรอบด้านนอกสิ้นสุดลง (ไม่ถึงสถานะใหม่) ฟังก์ชันจะส่งคืนเอาต์พุต หากถึง (7,7) เซลล์Sจะมีลำดับของการเคลื่อนไหวที่นำไปสู่เซลล์นี้และนี่คือผลลัพธ์ หากเซลล์ไม่ถึงSจะเป็นสตริงว่างเปล่าและรูทีนจะผ่านไปยังเอาต์พุตOซึ่งจะมีK(ติดอยู่) หากพบว่ามีลูปหรือCหากเกิดปัญหารถชนกันอย่างหลีกเลี่ยงไม่ได้

Python 339 - 10% = 305 ไบต์

ผมใช้ค้นหาความลึกแรก recursive exitซึ่งถูกยกเลิกในช่วงต้นของความสำเร็จผ่านทาง นอกจากนี้ยังมีการพิมพ์เส้นทางความสำเร็จในรูปแบบของ00001010101010101010101110100111001000, 0สำหรับตรง1เพื่อสิทธิ คำตอบจะนานกว่าคำตอบที่ดีที่สุดเนื่องจากเป็นความลึกก่อน ฉันแน่ใจว่าการปรับให้เหมาะสมกับอัลกอริทึมอาจทำให้จำนวนไบต์ลดลงได้เล็กน้อย

b=input()
D=[(-1,0),(0,-1),(1,0),(0,1)]
def a(l):
 x,y=0,0
 v=2
 for d in l:
  if d=='1':v=(v+1) % 4
  x+=D[v][0]
  y+=D[v][1]
  if x<0 or x>7 or y<0 or y>7:return 0,x,y
  if b[y][x]:return -1,x,y
 return 1,x,y
def c(l):
 if len(l) < 39:
  t,x,y=a(l)
  if t==1:
   if (x,y)==(7,7):
    print l;exit(0)
   c(l+"0")
   c(l+"1")
c("")
print 0