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

กฎระเบียบ

Kingdom Builderเป็นเกมกระดานที่เล่นบนกริด hex (จุดสูงสุด) กระดานประกอบด้วยสี่ส่วน (แบบสุ่ม) ซึ่งแต่ละกลุ่มมีเซลล์ Hex10 เท่า 10x10 (ดังนั้นกระดานเต็มจะเป็น 20x20) สำหรับจุดประสงค์ของการท้าทายนี้แต่ละเซลล์ฐานสิบหกมีทั้งน้ำ ( W), ภูเขา ( M) เมือง ( T), ปราสาท ( C) หรือว่างเปล่า ( .) ดังนั้นจตุภาคอาจดูเหมือน

. . W . . . . . . .
 . M W W . . . . . .
. M . . W . . . T .
 M M . W . . . . . .
. . M . W W . . . .
 . . . . . W W W W W
. T . . . . . . . .
 . . W . . C . . . .
. . W W . . . . M . 
 . . . . . . . M M .

แถวที่สองจะถูกชดเชยไปทางขวาจากแถวแรกเสมอ ผู้เล่น1จะ4สามารถวางได้ถึง 40 การตั้งถิ่นฐานในแต่ละเซลล์ว่าง (ตามกฎบางอย่างที่เราจะไม่สนใจสำหรับความท้าทายนี้) บอร์ดที่เป็นไปได้ในตอนท้ายของเกมมีดังต่อไปนี้:

3 3 W . . . 4 . 4 . . 2 W . 4 . . 4 . 4
 3 M W W . 1 1 . . 4 2 W . 3 C 4 4 . . 4
3 M 2 2 W 1 1 1 T 3 2 W 4 3 . 1 4 . 4 .
 M M . W 2 2 . . . 2 2 W 3 . 1 1 1 . . .
. 4 M . W W 2 2 2 2 W W 3 . 1 4 . T . .
 . . . . . W W W W W . 3 C 1 . . 2 2 2 2
. T 1 1 1 1 . . 2 . . 4 . . . 2 2 M M M
 4 . W 4 . C 4 4 . . . . . . 2 M M M M M
. 4 W W . . . 4 M . . W . W . 2 2 2 M M
 . . . . . . . M M . . W W . . . . 2 M .
. . . 3 3 3 3 3 3 3 3 3 3 3 3 3 3 2 . 1
 M 3 3 . . . . . . . . 4 . T 2 . 2 4 1 .
M M . C . 4 . 4 . . . . . 1 2 4 2 1 1 .
 M . . 1 . 4 . . . . M M 1 2 . . 2 1 . .
. . . W 1 1 4 1 1 . . . 1 2 . . 2 W W W
 . . 1 1 W 1 T . 1 1 1 1 T . . 2 W . 4 .
. 1 1 W . 3 3 . . . . . . . . 2 W 4 C 3
 C 1 3 3 3 . 3 . 4 . 4 . 4 . . 2 W 1 1 M
4 3 3 4 . M 4 3 . . . . . . . 2 W . . .
 . . . 4 . M M 3 . . 4 4 . 4 . 2 W W . .

เราจะติดป้ายกำกับควอดเทอร์เช่น

1 2
3 4

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

^{†มี 10 คะแนนในเกมจริง แต่ฉันจะออกสองเพราะไม่มีใครอยากตีกอล์ฟ}

คะแนนหลัก ผู้เล่นจะได้รับ3 คะแนนสำหรับแต่ละCastle ที่พวกเขามีการตั้งถิ่นฐานติดกับ คะแนนตัวอย่าง: 18, 0, 15, 12

คะแนนเสริม

1. ผู้เล่นจะได้รับ1 คะแนนสำหรับแต่ละแถวแนวนอนซึ่งพวกเขามีการตัดสินอย่างน้อยหนึ่งครั้ง

   คะแนนตัวอย่าง: 14, 20, 12, 16

2. สำหรับผู้เล่นแต่ละคนให้หาแถวแนวนอนที่พวกเขาใช้ในการตั้งถิ่นฐานของพวกเขา (เลือกใด ๆ ในกรณีที่เสมอกัน) ผู้เล่นจะได้รับ2 คะแนนสำหรับการตัดสินแต่ละครั้งในแถวนั้น

   คะแนนตัวอย่าง: 14 (แถว 16), 8 (แถว 4, 5 หรือ 6), 28 (แถว 11), 10 (แถว 1)

3. ผู้เล่นจะได้รับ1 แต้มสำหรับการตัดสินแต่ละครั้งที่สร้างขึ้นถัดจากWater

   ตัวอย่างคะแนน: 13, 21, 10, 5

4. ผู้เล่นจะได้รับ1 แต้มในแต่ละการตัดสินที่อยู่ถัดจากMภูเขา

   คะแนนตัวอย่าง: 4, 12, 8, 4

5. นับการตั้งถิ่นฐานของผู้เล่นแต่ละคนในแต่ละควอแดรนท์ ต่อหนึ่งในสี่ผู้เล่นที่มีการตั้งถิ่นฐานมากที่สุดจะได้รับ12 คะแนนในแต่ละครั้งผู้เล่นที่มีการตั้งถิ่นฐานที่ใหญ่เป็นอันดับสองจะได้รับ6 คะแนนในแต่ละครั้ง

   ตัวอย่างคะแนน: 18 (6 + 0 + 6 + 6), 36 (12 + 12 + 0 + 12), 12 (0 + 0 + 12 + 0), 18 (12 + 6 + 0 + 0)

6. สำหรับผู้เล่นแต่ละคนกำหนดควอดเรนท์ที่พวกเขามีจำนวนการตั้งถิ่นฐานน้อยที่สุด ผู้เล่นได้รับ3 คะแนนสำหรับการตัดสินแต่ละครั้งในควอแดรนท์

   ตัวอย่างคะแนน: 18 (Quadrant 2), 0 (Quadrant 3), 15 (Quadrant 1 หรือ 2), 27 (Quadrant 3)

7. ผู้เล่นได้รับ1 คะแนนสำหรับแต่ละกลุ่ม

   คะแนนตัวอย่าง: 7, 5, 6, 29

8. ผู้เล่นได้รับ1 คะแนนสำหรับการชำระหนี้2ครั้งในกลุ่มการชำระหนี้ที่เชื่อมโยงกันที่ใหญ่ที่สุดของผู้เล่น

   คะแนนตัวอย่าง: 4, 10, 8, 2

ความท้าทาย

เช่นเดียวกับในเกมที่คุณจะต้องเลือก3คะแนนและเลือกกระดานที่กำหนดจากคะแนนหลักและคะแนนทั้งสาม รหัสของคุณควรสร้างรายการ 4 คะแนน แม้ว่าจะมีข้อ จำกัด หนึ่งข้อในการเลือก: ฉันได้จัดกลุ่มคะแนนออกเป็น 3 กลุ่มและคุณต้องใช้หนึ่งในแต่ละกลุ่ม:

• ดำเนินการอย่างใดอย่างหนึ่งที่ 1 และ 2
• ดำเนินการอย่างใดอย่างหนึ่ง3, 4, 5 และ 6
• ดำเนินการอย่างใดอย่างหนึ่งที่ 7 และ 8

คุณสามารถเขียนโปรแกรมหรือฟังก์ชั่น, รับอินพุตผ่าน STDIN, อาร์กิวเมนต์บรรทัดคำสั่ง, พรอมต์หรือพารามิเตอร์ฟังก์ชัน คุณอาจส่งคืนผลลัพธ์หรือพิมพ์ไปที่ STDOUT

คุณสามารถเลือกรูปแบบรายการ / สตริง 1D หรือ 2D ที่สะดวกสำหรับอินพุต คุณไม่สามารถใช้กราฟที่มีข้อมูลการเติมเต็ม นี่คือการอ่านที่ดีในกริดฐานสิบหกหากคุณต้องการแรงบันดาลใจ

ผลลัพธ์ของคุณอาจอยู่ในรูปแบบรายการหรือรูปแบบสตริงที่สะดวกและชัดเจน

นี่คือรหัสกอล์ฟดังนั้นคำตอบที่สั้นที่สุด (เป็นไบต์) ชนะ

ข้อสันนิษฐานเพิ่มเติม

คุณอาจคิดว่า ...

• ... ผู้เล่นแต่ละคนมีการชำระอย่างน้อย 1 ครั้งและมีการตั้งถิ่นฐานของผู้เล่นแต่ละคนไม่เกิน 40 คน
• ... แต่ละด้านประกอบด้วยเมืองหนึ่งและสองปราสาทหรือสองเมืองและหนึ่งปราสาท
• ... เมืองและปราสาทอยู่ห่างกันพอที่จะไม่สามารถตั้งถิ่นฐานอยู่ติดกับสองของพวกเขา

กรณีทดสอบ

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

Chosen Scores      Total Player Scores
1 3 7              52 46 43 62
1 3 8              49 51 45 35
1 4 7              43 37 41 61
1 4 8              40 42 43 34
1 5 7              57 61 45 75
1 5 8              54 66 47 48
1 6 7              57 25 48 84
1 6 8              54 30 50 57
2 3 7              52 34 59 56
2 3 8              49 39 61 29
2 4 7              43 25 57 55
2 4 8              40 30 59 28
2 5 7              57 49 61 69
2 5 8              54 54 63 42
2 6 7              57 13 64 78
2 6 8              54 18 66 51

Python 2, 367 ไบต์

T=range(20)
N=lambda r,c:{(a,b)for a,b in{(r+x/3-1,c+x%3-1+(x/3!=1)*r%2)for x in[0,1,3,5,6,7]}if-1<b<20>a>-1}
def S(B):
 def F(r,c):j=J[r][c]!=i;J[r][c]*=j;j or map(F,*zip(*N(r,c)));return j
 J=map(list,B);X=lambda r,c,x,y:x+y in{B[r][c]+B[a][b]for a,b in N(r,c)};return[sum((i in B[r])+20*(3*X(r,c,"C",i)-~X(r,c,i,"W")-F(r,c))for r in T for c in T)/20for i in"1234"]

โปรแกรมใช้คะแนน 1, 3, 7 อินพุตเป็นรายการของตัวอักษรที่แสดงถึงแต่ละเซลล์ เพื่อทดสอบบอร์ดตัวอย่างง่าย ๆ เราสามารถทำ:

board = """
3 3 W . . . 4 . 4 . . 2 W . 4 . . 4 . 4
 3 M W W . 1 1 . . 4 2 W . 3 C 4 4 . . 4
3 M 2 2 W 1 1 1 T 3 2 W 4 3 . 1 4 . 4 .
 M M . W 2 2 . . . 2 2 W 3 . 1 1 1 . . .
. 4 M . W W 2 2 2 2 W W 3 . 1 4 . T . .
 . . . . . W W W W W . 3 C 1 . . 2 2 2 2
. T 1 1 1 1 . . 2 . . 4 . . . 2 2 M M M
 4 . W 4 . C 4 4 . . . . . . 2 M M M M M
. 4 W W . . . 4 M . . W . W . 2 2 2 M M
 . . . . . . . M M . . W W . . . . 2 M .
. . . 3 3 3 3 3 3 3 3 3 3 3 3 3 3 2 . 1
 M 3 3 . . . . . . . . 4 . T 2 . 2 4 1 .
M M . C . 4 . 4 . . . . . 1 2 4 2 1 1 .
 M . . 1 . 4 . . . . M M 1 2 . . 2 1 . .
. . . W 1 1 4 1 1 . . . 1 2 . . 2 W W W
 . . 1 1 W 1 T . 1 1 1 1 T . . 2 W . 4 .
. 1 1 W . 3 3 . . . . . . . . 2 W 4 C 3
 C 1 3 3 3 . 3 . 4 . 4 . 4 . . 2 W 1 1 M
4 3 3 4 . M 4 3 . . . . . . . 2 W . . .
 . . . 4 . M M 3 . . 4 4 . 4 . 2 W W . .
"""

board = [row.split() for row in board.strip().split("\n")]
print S(board)

# [52, 46, 43, 62]

การจัดการกริดฐานสิบหก

เนื่องจากเราอยู่ในกริดหกเหลี่ยมเราจึงต้องจัดการกับเพื่อนบ้านที่แตกต่างกันเล็กน้อย ถ้าเราใช้กริด 2 มิติแบบดั้งเดิมเพื่อเป็นตัวแทนของเราเราก็(1, 1)มี:

. N N . .       . N N . .                (0, 1), (0, 2)            (-1, 0), (-1, 1)
 N X N . .  ->  N X N . .  -> Neighbours (1, 0), (1, 2) -> Offsets (0, -1), (0, 1)
. N N . .       . N N . .                (2, 1), (2, 2)            (1, 0), (1, 1)

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

(-1, -1), (-1, 0), (0, -1), (0, 1), (1, -1), (1, 0)

สิ่งเดียวที่เปลี่ยนไปคือคู่ที่ 1, 2, 5 และ 6 ได้ลดพิกัดที่สองลง 1

ฟังก์ชั่นแลมบ์ดาNจะจับคู่พิกัด(row, col)และส่งกลับเพื่อนบ้านทั้งหมดของเซลล์ภายในตาราง ความเข้าใจภายในสร้างการชดเชยด้านบนโดยการแยกพวกมันออกมาจากการเข้ารหัส 3 ฐานอย่างง่ายโดยเพิ่มพิกัดที่สองหากแถวนั้นเป็นเลขคี่และเพิ่มการชดเชยลงในเซลล์เพื่อถามเพื่อนบ้าน ความเข้าใจภายนอกนั้นจะกรองทิ้งเพื่อนบ้านที่อยู่ภายในขอบเขตของตาราง

Ungolfed

def neighbours(row, col):
    neighbour_set = set()

    for dr, dc in {(-1,-1), (-1,0), (0,-1), (0,1), (1,-1), (1,0)}:
        neighbour_set.add((row + dr, col + dc + (1 if dr != 0 and row%2 == 1 else 0)))

    return {(r,c) for r,c in neighbour_set if 20>r>-1 and 20>c>-1}

def solve(board):
    def flood_fill(char, row, col):
        # Logic negated in golfed code to save a few bytes
        is_char = (dummy[row][col] == char)
        dummy[row][col] = "" if is_char else dummy[row][col]

        if is_char:
            for neighbour in neighbours(row, col):
                flood_fill(char, *neighbour)

        return is_char

    def neighbour_check(row, col, char1, char2):
        return board[row][col] == char1 and char2 in {board[r][c] for r,c in neighbours(row, col)}

    dummy = [row[:] for row in board] # Need to deep copy for the flood fill
    scores = [0]*4

    for i,char in enumerate("1234"):
        for row in range(20):
            for col in range(20):
                scores[i] += (char in board[row])                        # Score 1
                scores[i] += 20 * 3*neighbour_check(row, col, "C", char) # Core score
                scores[i] += 20 * neighbour_check(row, col, char, "W")   # Score 3
                scores[i] += 20 * flood_fill(char, row, col)             # Score 7

        # Overcounted everything 20 times, divide out
        scores[i] /= 20

    return scores

ชุดคำตอบการเขียนโปรแกรม 629 ไบต์

d(X,Y):-b(X,Y,_).p(1;2;3;4).n(X,Y,(((X-2;X+2),Y);((X-1;X+1),(Y-1;Y+1)))):-d(X,Y).n(X,Y,I,J):-n(X,Y,(I,J));d(I,J).t(X,Y,P):-n(X,Y,I,J);b(I,J,P).s(c,P,S*3):-S={t(X,Y,P):b(X,Y,"C")};p(P).s(1,P,S*1):-S=#count{r(Y):b(_,Y,P)};p(P).s(3,P,S):-S={b(X,Y,P):t(X,Y,"W")};p(P).o(X,Y,Y+X*100):-d(X,Y).h(P,X,Y,I,J):-o(X,Y,O);o(I,J,Q);O<Q;n(X,Y,I,J);b(X,Y,P);b(I,J,P);p(P).h(P,X,Y,I,J):-o(X,Y,O);o(I,J,Q);O<Q;h(P,X,Y,K,L);n(K,L,I,J);b(I,J,P);p(P).c(P,X,Y):-h(P,X,Y,_,_);not h(P,_,_,X,Y).c(P,X,Y):-{h(P,X,Y,_,_);h(P,_,_,X,Y)}0;b(X,Y,P);p(P).s(7,P,S):-S=#count{c(P,X,Y):c(P,X,Y)};p(P).s(t,P,C+S+T+U):-s(c,P,C);s(1,P,S);s(3,P,T);s(7,P,U).#shows/3.

ASP เป็นของตระกูลภาษาการเขียนโปรแกรมลอจิกซึ่งเป็นตัวเป็นตนที่นี่โดย กรอบ Potassco โดยเฉพาะอย่างยิ่ง Clingo (Clero Gringo + solver Clasp) โดยเฉพาะ เนื่องจากข้อ จำกัด ของกระบวนทัศน์จึงไม่สามารถรับบอร์ดเป็นเอาต์พุตโดยตรงดังนั้นจำเป็นต้องทำการประมวลผลข้อมูลล่วงหน้า (ดำเนินการที่นี่ในภาษาไพ ธ อน) การประมวลผลล่วงหน้านี้ไม่นับรวมกับคะแนนรวมไบต์

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

การนำเสนอความรู้

มีรหัสหลามที่แปลงบอร์ดเป็นอะตอม:

def asp_str(v):
    return ('"' + str(v) + '"') if v not in '1234' else str(v)

with open('board.txt') as fd, open('board.lp', 'w') as fo:
        [fo.write('b('+ str(x) +','+ str(y) +','+ asp_str(v) +').\n')
         for y, line in enumerate(fd)
         for x, v in enumerate(line) if v not in ' .\n'
        ]

ตัวอย่างเช่นอะตอม b (สำหรับ __b__oard) ที่ให้ไว้สำหรับบรรทัดแรกของบอร์ดตัวอย่างมีดังนี้:

b(0,0,3).
b(2,0,3).
b(4,0,"W").
b(12,0,4).
b(16,0,4).
b(22,0,2).
b(24,0,"W").
b(28,0,4).
b(34,0,4).
b(38,0,4).

โดยที่ b (0,0,3) เป็นอะตอมที่อธิบายว่าผู้เล่น 3 มีการชำระที่พิกัด (0; 0)

การแก้ ASP

มีรหัส ASP พร้อมคะแนนเสริมมากมายที่นำมาใช้:

% input : b(X,Y,V) with X,Y the coordinates of the V value

domain(X,Y):- b(X,Y,_).
player("1";"2";"3";"4").

% neighbors of X,Y
neighbors(X,Y,((X-2,Y);(X+2,Y);((X-1;X+1),(Y-1;Y+1)))) :- domain(X,Y).
neighbors(X,Y,I,J):- neighbors(X,Y,(I,J)) ; domain(I,J).

% Player is next to X,Y iff has a settlement next to.
next(X,Y,P):- neighbors(X,Y,I,J) ; b(I,J,P).


% SCORES

% Core score : 3 point for each Castle "C" with at least one settlement next to.
score(core,P,S*3):- S={next(X,Y,P): b(X,Y,"C")} ; player(P).

% opt1: 1 point per settled row
score(opt1,P,S*1):- S=#count{row(Y): b(_,Y,P)} ; player(P).

% opt2: 2 point per settlement on the most self-populated row
% first, defines how many settlements have a player on each row
rowcount(P,Y,H):- H=#count{col(X): b(X,Y,P)} ; domain(_,Y) ; player(P).
score(opt2,P,S*2):- S=#max{T: rowcount(P,Y,T)} ; player(P).

% opt3: 1 point for each settlements next to a Water "W".
score(opt3,P,S):- S={b(X,Y,P): next(X,Y,"W")} ; player(P).

% opt4: 1 point for each settlements next to a Mountain "M".
score(opt4,P,S):- S={b(X,Y,P): next(X,Y,"M")} ; player(P).

% opt5:
%later…

% opt6:
%later…

% opt7: 1 point for each connected component of settlement
% first we need each coord X,Y to be orderable.
% then is defined path/5, that is true iff exists a connected component of settlement of player P
%   that links X,Y to I,J
% then is defined the connected component atom that give the smaller coords in each connected component
% then computing the score.
order(X,Y,Y+X*100):- domain(X,Y).
path(P,X,Y,I,J):- order(X,Y,O1) ; order(I,J,O2) ; O1<O2 ; % order
                  neighbors(X,Y,I,J) ; b(X,Y,P) ; b(I,J,P) ; player(P). % path iff next to
path(P,X,Y,I,J):- order(X,Y,O1) ; order(I,J,O2) ; O1<O2 ; % order
                  path(P,X,Y,K,L) ; neighbors(K,L,I,J) ; % path if path to next to
                  b(I,J,P) ; player(P).
concomp(P,X,Y):- path(P,X,Y,_,_) ; not path(P,_,_,X,Y). % at least two settlements in the connected component
concomp(P,X,Y):- 0 { path(P,X,Y,_,_) ; path(P,_,_,X,Y) } 0 ; board(X,Y,P) ; player(P). % concomp of only one settlements
score(opt7,P,S):- S=#count{concomp(P,X,Y): concomp(P,X,Y)} ; player(P).

% opt8: 0.5 point for each settlement in the bigger connected component
%later…


% total score:
score(total,P,C+S1+S2+S3):- score(core,P,C) ; score(opt1,P,S1) ; score(opt3,P,S2) ; score(opt7,P,S3).

#show. # show nothing but the others show statements
#show total_score(P,S): score(total,P,S).
%#show score/3. % scores details

โปรแกรมนี้สามารถเปิดใช้งานด้วยคำสั่ง:

clingo board.lp golf.lp 

และจะพบทางออกเดียวเท่านั้น (เป็นข้อพิสูจน์ว่ามีเพียงวิธีเดียวในการแจกจ่ายคะแนน):

s(c,1,18) s(c,2,0) s(c,3,15) s(c,4,12) s(1,1,14) s(1,2,20) s(1,3,12) s(1,4,16) s(3,1,13) s(3,2,21) s(3,3,10) s(3,4,5) s(7,1,7) s(7,2,5) s(7,3,6) s(7,4,29) s(t,1,52) s(t,2,46) s(t,3,43) s(t,4,62)

ที่ s (7,3,6) บอกว่าผู้เล่น 3 คนได้ 6 คะแนนด้วยคะแนนเสริม 7 และ s (t, 4,62) บอกว่าผู้เล่น 4 ได้รับ 62 คะแนนรวม (หลัก + 1 + 3 + 7)

แยกง่ายเพื่อให้มีตารางแฟนซี!