ผู้ใช้จะซ่อนและคอมพิวเตอร์จะพยายามค้นหา

ก่อนอื่นโปรแกรมจะรับอินพุตสำหรับขนาดของกริด เช่น 5x5, 10x10, 15x15 เป็นต้นตารางจะไม่ใช่ตารางที่สมบูรณ์แบบเสมอไป

ตารางเป็นเหมือนกระดานหมากรุก:

_______________________________
|     |     |     |     |     |
| A1  |     |     |     |     | A
|_____|_____|_____|_____|_____|
|     |     |     |     |     |
|     | B2  |     |     |     | B
|_____|_____|_____|_____|_____|
|     |     |     |     |     |
|     |     | C3  |     |     | C
|_____|_____|_____|_____|_____|
|     |     |     |     |     |
|     |     |     | D4  |     | D
|_____|_____|_____|_____|_____|
|     |     |     |     |     |
|     |     |     |     | E5  | E
|_____|_____|_____|_____|_____|
   1     2     3     4     5

ตอนนี้ผู้ใช้จะเลือกสี่เหลี่ยมเช่นB2(โดยไม่บอกคอมพิวเตอร์)

คอมพิวเตอร์จะเริ่มเดาสี่เหลี่ยม yถ้ามันหยิบตารางที่ถูกต้องผู้ใช้จะตอบสนองกับ ถ้าไม่พวกเขาจะใส่ทิศทางกระเบื้องของพวกเขามาจากที่เลือก (N, NE, E, SE, S, SW, W)

ดังนั้นหากผู้ใช้เลือกB2และคอมพิวเตอร์เดาผู้ใช้จะป้อนข้อมูลC3NW

นี่คือตัวอย่างของเอาต์พุตและอินพุต:

Grid?
5x5

C3?
NW

C2?
N

B2?
y

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

สิ่งนี้จะได้คะแนนแตกต่างจากความท้าทายปกติเล็กน้อย

ผู้ชนะคือโปรแกรมที่ใช้การคาดเดาจำนวนต่ำสุด (โดยเฉลี่ย) เพื่อคาดเดาสี่เหลี่ยมที่ถูกต้อง กรณีทดสอบที่จะเฉลี่ยจะเป็นสี่เหลี่ยมที่เป็นไปได้ทั้งหมดใน 5x5 และใน 10x10

อย่างไรก็ตามต้องทำงานกับทุกรูปแบบของตารางได้ถึง 26 แถว (เช่น 5x8, 6x2, 20x5 เป็นต้น)

โปรดระบุวิธีที่จะทำการทดสอบเช่น JSFiddle

และสุดท้ายในกรณีที่เสมอกันโปรแกรมที่สั้นที่สุดจะชนะ

Python 3.6 , 466 398 392 bytes, minimax

x, y = 1, 1
w, h = [int(x) for x in input('Grid?\n').split('x')]


def split_factor(a, b):
    N = b-y
    W = a-x
    S = h+~N
    E = w+~W
    return max(1, N, W, S, E, N*W, S*W, S*E, N*E)


def move(a, b):
    *Z, = zip([a, x, a, a+1, x, x, a+1, a+1],
              [y, b, b+1, b, y, b+1, b+1, y],
              [1, a-x, 1, w+x+~a, a-x, a-x, w+x+~a, w+x+~a],
              [b-y, 1, h+y+~b, 1, b-y, h+y+~b, h+y+~b, b-y])
    return Z[['N', 'W', 'S', 'E', 'NW', 'SW', 'SE', 'NE'].index(d)]

d = ''
while d != 'y':
    print()
    splits = {(a, b): split_factor(a, b) for a in range(x, x+w) for b in range(y, y+h)}
    a, b = min(splits, key=splits.get)
    d = input(f'{a}{"ABCDEFGHIJKLMNOPQRSTUVWXYZ"[b]}?\n')
    x, y, w, h = move(a, b)

อินพุตและเอาต์พุตควรอยู่ในรูปแบบที่แสดงในตัวอย่าง สิ่งนี้จะค้นหาสี่เหลี่ยมจัตุรัสที่มี "ตัวประกอบแยก" น้อยที่สุด - ซึ่งเป็นพื้นที่ที่ใหญ่ที่สุดที่เหลือซึ่งอาจเป็นผลมาจากคำตอบของผู้เล่น (เช่น NW, E, y, ฯลฯ ) - และคาดเดาว่า ใช่นั่นคือศูนย์กลางของพื้นที่ที่เหลืออยู่ในเกมนี้เสมอ แต่เทคนิคการลดขนาดเคสที่แย่ที่สุดนั้นจะทำงานได้ดีกว่าในเกมที่คล้ายกันซึ่งมีกฎแตกต่างกัน

รุ่นที่อ่านไม่ได้:

x=y=d=1
w,h=map(int,input('Grid?\n').split('x'))
while d!='y':print();s={(a,b):max(b-y,h+y+~b)*max(w+x+~a,a-x)for a in range(x,x+w)for b in range(y,y+h)};a,b=min(s,key=s.get);d=input(f'{a}{chr(64+b)}?\n');*z,=zip([a+1,x,a+1,x,a,a,a+1,x],[b+1,b+1,y,y,b+1,y,b,b],[w+x+~a,a-x,w+x+~a,a-x,1,1,w+x+~a,a-x],[h+y+~b,h+y+~b,b-y,b-y,h+y+~b,b-y,1,1]);x,y,w,h=z[~'WENS'.find(d)or-'NWNESWSE'.find(d)//2-5]

Mathematica พฤติกรรมที่ดีที่สุดในกรณีทดสอบ 260 ไบต์

For[a=f=1;{c,h}=Input@Grid;z=Characters;t=<|Thread[z@#->#2]|>&;r="";v=Floor[+##/2]&;b:=a~v~c;g:=f~v~h,r!="y",r=Input[g Alphabet[][[b]]];{{a,c},{f,h}}={t["NSu",{{a,b-1},{b+1,c},{b,b}}]@#,t["uWX",{{g,g},{f,g-1},{g+1,h}}]@#2}&@@Sort[z@r/.{c_}:>{c,"u"}/."E"->"X"]]

โปรแกรมนี้สามารถทดสอบได้โดยการตัดและวางโค้ดข้างต้นลงในวุลแฟรมเมฆ (ทดสอบอย่างรวดเร็วแม้ว่า: ฉันคิดว่ามีการ จำกัด เวลาสำหรับแต่ละโปรแกรมที่เรียกใช้) การคาดเดาของโปรแกรมดูเหมือนว่าจะ2 cเป็นแทนที่จะเป็นC2แต่อย่างอื่นก็จะทำงานตามข้อกำหนดข้างต้น ตารางจะต้องมีการป้อนข้อมูลเป็นคู่ลำดับของจำนวนเต็มเช่น{26,100}และการตอบสนองต่อการคาดเดาของโปรแกรมจะต้องมีการป้อนข้อมูลเป็นสตริงเหมือนหรือ"NE""y"

โปรแกรมติดตามหมายเลขแถวที่เล็กที่สุดและใหญ่ที่สุดและหมายเลขคอลัมน์ที่สอดคล้องกับอินพุตจนถึงและเดาจุดศูนย์กลางของ subgrid ของความเป็นไปได้เสมอ (การปัดเศษ NW) โปรแกรมนี้ถูกกำหนดไว้แล้วดังนั้นจึงง่ายต่อการคำนวณจำนวนเดาที่ต้องการโดยเฉลี่ยบนกริดคงที่ ในตาราง 10x10 โปรแกรมต้องใช้การคาดเดา 1 ครั้งสำหรับสแควร์เดี่ยว 2 เดาสำหรับ 8 สแควร์ส 3 ครั้งสำหรับ 64 สแควร์สและ 4 ครั้งสำหรับ 27 สแควร์ที่เหลือโดยเฉลี่ย 3.17; และนี่คือค่าต่ำสุดทางทฤษฎีโดยกำหนดลำดับการเดา 1, 2-เดาและอื่น ๆ อีกมากมายที่จะนำไปสู่การเดาที่ถูกต้อง แน่นอนโปรแกรมควรบรรลุขั้นต่ำทางทฤษฎีในตารางขนาดใด ๆ ด้วยเหตุผลที่คล้ายกัน (บนตาราง 5x5 จำนวนการทายโดยเฉลี่ยคือ 2.6)

คำอธิบายรหัสเล็กน้อยแม้ว่าจะตรงไปตรงมาค่อนข้างอื่นนอกเหนือจากการเล่นกอล์ฟ (ฉันแลกเปลี่ยนลำดับของคำสั่งการเริ่มต้นบางคำสั่งเพื่อวัตถุประสงค์ในการเก็บข้อมูล - ไม่มีผลต่อจำนวนไบต์)

1  For[a = f = 1; z = Characters; t = <|Thread[z@# -> #2]|> &;
2      v = Floor[+##/2] &; b := a~v~c; g := f~v~h;
3      r = ""; {c, h} = Input@Grid, 
4    r != "y", 
5    r = Input[g Alphabet[][[b]]];
6      {{a, c}, {f, h}} = {t["NSu", {{a, b - 1}, {b + 1, c}, {b, b}}]@#, 
7        t["uWX", {{g, g}, {f, g - 1}, {g + 1, h}}]@#2} & @@ 
8        Sort[z@r /. {c_} :> {c, "u"} /. "E" -> "X"]
   ]

บรรทัดที่ 1-3 จะเริ่มต้นForลูปซึ่งจริงๆแล้วเป็นเพียงWhileลูปในการปลอมตัวดังนั้นเดี๋ยวก่อนสองไบต์ที่น้อยกว่า ช่วงแถวหมายเลขและคอลัมน์หมายเลขที่เป็นไปได้ทุกช่วงเวลาจะถูกเก็บไว้{{a, c}, {f, h}}และการเดากึ่งกลางในโปรแกรมย่อยนั้นจะคำนวณโดยฟังก์ชั่นที่{b, g}กำหนดไว้ในบรรทัดที่ 2 บรรทัดที่ 3 เริ่มต้นcคอลัมน์สูงสุดและคอลัมน์สูงสุดhจากอินพุตของผู้ใช้และ ยังเตรียมrข้อมูลเบื้องต้นซึ่งเป็นตัวแปรทดสอบลูปและอินพุตผู้ใช้ที่ตามมา

ในขณะที่การทดสอบในบรรทัดที่ 4 เป็นที่พอใจบรรทัดที่ 5 ได้รับอินพุตจากผู้ใช้โดยที่พรอมต์มาจากการเดาปัจจุบัน{b, g}( Alphabet[][[b]]]แปลงหมายเลขแถวเป็นตัวอักษร) จากนั้นบรรทัดที่ 6-8 จะอัปเดต subgrid-of-possible (และต่อไปนี้เป็นการคาดเดาครั้งถัดไป) ตัวอย่างเช่นt["NSu", {{a, b - 1}, {b + 1, c}, {b, b}}](ตามนิยามของton line 1) จะขยายเป็น

<| "N" -> {a, b - 1}, "S" -> {b + 1, c}, "u" -> {b, b}|>

ที่ซึ่งคุณสามารถดูหมายเลข min-row และ max-row ที่ได้รับการอัพเดตตามข้อมูลล่าสุดของผู้ใช้ บรรทัดที่ 8 แปลงป้อนข้อมูลใด ๆ ไปได้ที่จะมีคำสั่งให้คู่ของตัวละครในรูปแบบ{ "N" | "S" | "u", "u" | "W" | "X"}; ที่นี่"u"หมายถึงแถวหรือคอลัมน์ที่ถูกต้องและ"X"ย่อมาจากตะวันออก (เพื่อให้Sortทำงานได้อย่างสวยงาม) เมื่อผู้ใช้ป้อนข้อมูลในที่สุด"y"บรรทัดเหล่านี้จะโยนข้อผิดพลาด แต่จากนั้นการทดสอบลูปจะล้มเหลวและข้อผิดพลาดจะไม่ถูกนำเสนอ

แบทช์แบ่งและพิชิต

@echo off
set z = ABCDEFGHIJKLMNOPQRSTUVWXYZ
set /p g = Grid?
set /a w = 0, n = 0, e = %g :x= + 1, s = % + 1
:l
set /a x = (w + e) / 2, y = (n + s) / 2
call set c = %%z :~%y%,1%%
set /p g = %c %%x%?
if %g :w=.% == %g % set /a w = x
if %g :n=.% == %g % set /a n = y
if %g :e=.% == %g % set /a e = x
if %g :s=.% == %g % set /a s = y
if %g :y=.% == %g % goto l

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

ที่ 369 ไบต์ฉันไม่ได้คาดหวังว่าจะเอาชนะใครดังนั้นฉันจึงออกจากช่องว่างเพื่อความสะดวกในการอ่าน