কিংডম বিল্ডারের একটি খেলা স্কোর করুন

16

আমি এখানে কোড গল্ফের একটি নতুন ফর্ম চেষ্টা করতে চাই। বোনাসগুলির মতো, চ্যালেঞ্জের সমস্ত অংশই শেষ করতে হবে না, তবে প্রতিটি উত্তরকে নির্দিষ্ট আকারের একটি উপসেট বাস্তবায়ন করতে হবে (এবং এমন একটি কোর রয়েছে যা প্রতিটি উত্তরটি প্রয়োগ করতে হবে)। সুতরাং গল্ফিংয়ের পাশাপাশি এই চ্যালেঞ্জটি এমন বৈশিষ্ট্যগুলির একটি সেট নির্বাচন করা জড়িত যা একসাথে ভাল হয়।

নিয়ম

কিংডম বিল্ডার একটি বোর্ড গেম, এটি একটি (পয়েন্টি টপ) হেক্স গ্রিডে খেলা হয়। বোর্ডটি চারটি (এলোমেলোভাবে) কোয়াড্র্যান্ট দ্বারা গঠিত, যার প্রতিটিতে 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 টি alচ্ছিক স্কোর রয়েছে যার মধ্যে 3 টি প্রতিটি গেমের জন্য বেছে নেওয়া হয়। Following নীচে , আমি সমস্ত 9 স্কোর বর্ণনা করব এবং প্রতিটি খেলোয়াড় কত পয়েন্ট পাবে তার উদাহরণ হিসাবে উপরের সেটআপটি ব্যবহার করব।

Game আসল গেমটিতে 10 টি স্কোর রয়েছে তবে আমি দুটি ছেড়ে যাব কারণ কেউই তাদের গল্ফ দিতে চায় না।

মূল স্কোর। একজন খেলোয়াড় প্রতিটি স্তম্ভের জন্য 3 পয়েন্ট পায় যার Cপাশেই একটি বন্দোবস্ত রয়েছে। উদাহরণ স্কোর: 18, 0, 15, 12।

.চ্ছিক স্কোর।

  1. একজন খেলোয়াড় প্রতিটি অনুভূমিক সারির জন্য 1 পয়েন্ট পান যার উপর তাদের কমপক্ষে একটি বন্দোবস্ত রয়েছে।

    উদাহরণ স্কোর: 14, 20, 12, 16।

  2. প্রতিটি খেলোয়াড়ের জন্য, তাদের বেশিরভাগ বসতিগুলির অনুভূমিক সারিটি সন্ধান করুন (টাইয়ের ক্ষেত্রে কোনও চয়ন করুন)। একজন খেলোয়াড় সেই সারিতে প্রতিটি নিষ্পত্তির জন্য 2 পয়েন্ট পায় ।

    উদাহরণ স্কোর: 14 (সারি 16), 8 (সারি 4, 5 বা 6), 28 (সারি 11), 10 (সারি 1)।

  3. একজন খেলোয়াড় এটারের পাশের প্রতিটি বন্দোবস্তের জন্য 1 পয়েন্ট পান W।

    উদাহরণ স্কোর: 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 (চতুর্ভুজ 2), 0 (চতুর্ভুজ 3), 15 (চতুর্ভুজ 1 বা 2), 27 (চতুর্ভুজ 3)।

  7. খেলোয়াড় প্রতিটি সংযুক্ত বসতির গ্রুপের জন্য 1 পয়েন্ট পান।

    উদাহরণ স্কোর: 7, 5, 6, 29।

  8. একজন খেলোয়াড় সংযোগ স্থাপনার প্লেয়ারের বৃহত্তম গ্রুপে প্রতি 2 টি বন্দোবস্তের জন্য 1 পয়েন্ট পান ।

    উদাহরণ স্কোর: 4, 10, 8, 2।

চ্যালেঞ্জ

গেমের মতো আপনি 3 চ্ছিক স্কোরগুলির মধ্যে 3 বেছে নেবেন এবং কোর স্কোর এবং সেই তিনটি স্কোরের উপর ভিত্তি করে একটি প্রদত্ত বোর্ড স্কোর করবেন। আপনার কোড 4 স্কোর একটি তালিকা উত্পাদন করা উচিত। পছন্দের ক্ষেত্রে একটি বিধিনিষেধ রয়েছে যদিও: আমি স্কোরগুলিকে 3 টি গ্রুপে ভাগ করেছি এবং আপনি প্রতিটি গ্রুপের একটি বাস্তবায়ন করতে পারেন:

  • 1 এবং 2 এর একটি প্রয়োগ করুন ।
  • 3, 4, 5 এবং 6 এর মধ্যে একটি প্রয়োগ করুন ।
  • 7 এবং 8 এর মধ্যে একটি প্রয়োগ করুন ।

আপনি STDIN, কমান্ড-লাইন আর্গুমেন্ট, প্রম্পট বা ফাংশন প্যারামিটারের মাধ্যমে ইনপুট নিয়ে একটি প্রোগ্রাম বা ফাংশন লিখতে পারেন। আপনি ফলাফলটি ফেরত দিতে বা এটি মুদ্রণ করতে পারবেন STDOUT।

ইনপুটটির জন্য আপনি যে কোনও সুবিধাজনক 1D বা 2D তালিকা / স্ট্রিং ফর্ম্যাট বেছে নিতে পারেন। আপনি পুরো সংলগ্ন তথ্যের সাথে গ্রাফ ব্যবহার করতে পারবেন না । আপনার অনুপ্রেরণার প্রয়োজন হলে এখানে হেক্স গ্রিডে কিছু ভাল পড়া is

আপনার আউটপুটটি কোনও সুবিধাজনক, দ্ব্যর্থহীন তালিকা বা স্ট্রিং ফর্ম্যাটে হতে পারে।

এটি কোড গল্ফ, তাই সংক্ষিপ্ত উত্তরটি (বাইটে) জেতে।

আরও অনুমান

আপনি ধরে নিতে পারেন ...

  • ... প্রতিটি খেলোয়াড়ের কমপক্ষে 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
code-golf  game  array-manipulation  grid  hexagonal-grid 
— মার্টিন ইন্ডার
সূত্র
সমন্বয় নির্বিশেষে এমন কোনও বোর্ড রয়েছে যেখানে এক খেলোয়াড় সর্বদা জিতে?
— থ্রিএফএক্স
@ থ্রিএফএক্স যেহেতু প্রতি খেলোয়াড়ের জনবসতির সংখ্যার উপরের নীচে আবদ্ধতা 1, এটি সেট আপ করা মোটামুটি সহজ। ;) তবে প্রতিটি খেলোয়াড়ের জন্য সমান সংখ্যক বসতি স্থাপন করার পরে, আমি আসলে জানি না।
— মার্টিন এন্ডার

উত্তর:

5

পাইথন 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 ব্যবহার করে In ইনপুটটি প্রতিটি ঘরের প্রতিনিধিত্বকারী অক্ষরের তালিকার একটি তালিকা। উদাহরণস্বরূপ বোর্ডটি সহজে পরীক্ষা করতে, আমরা এটি করতে পারি:

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]

হেক্স গ্রিড পরিচালনা করছে

যেহেতু আমরা একটি হেক্স গ্রিডে রয়েছি, তাই প্রতিবেশীদের সাথে আমাদের কিছুটা আলাদা আচরণ করতে হবে। যদি আমরা আমাদের প্রতিনিধিত্ব হিসাবে একটি traditionalতিহ্যবাহী 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 ম, দ্বিতীয়, 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
— Sp3000
সূত্র
def Fএকটি অভ্যন্তরীণ ফাংশন চেয়ে পৃথক ফাংশন হতে পারে না ? kথেকে সরানো যাবে না def F:?
— জাস্টিন
@ কুইনকুনস Fহ'ল বন্যা ভরাট ফাংশন এবং এতে অ্যাক্সেসের প্রয়োজন রয়েছে J, তাই এটি Jপ্যারামিটার হিসাবে পাস করার সময় এটি সংরক্ষণ করতে পারে (আমি গভীর কপিটি পেতে পারি কিনা তা দেখার জন্য আমি কিছুটা পরীক্ষা করব)। kযদিও আপনি ঠিক বলেছেন , ধন্যবাদ :) (শর্ট
— সার্কিটের
2

উত্তর সেট প্রোগ্রামিং, 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.

এএসপি যুক্তিযুক্ত প্রোগ্রামিং ভাষা পরিবারের অন্তর্গত, এখানে পটাসকো কাঠামোর দ্বারা অবতীর্ণ , বিশেষত ক্লিঙ্গো (গ্রাউন্ডার গ্রিংগো + সলভার ক্লস্প)। দৃষ্টান্ত সীমাবদ্ধতার কারণে, এটি প্রদত্ত বোর্ডকে সরাসরি আউটপুট হিসাবে নিতে পারে না, সুতরাং ডেটাগুলির একটি প্রাক-প্রসেসিং প্রয়োজনীয় (এখানে পাইথনটিতে সম্পাদিত)। এই প্রিপ্রোসেসিং মোট বাইট স্কোর গণনা করা হয় না।

এটি আমার প্রথম কোড গল্ফ এবং উদ্দেশ্যটি হ'ল সত্য যে গেমটি জয়ের চেয়ে আমি গল্ফের আগে কখনও দেখিনি seen তদুপরি, আমি এএসপি-র বিশেষজ্ঞ থেকে অনেক দূরে, কম বাইটের ফলাফলের জন্য কোডের অনেকগুলি অপ্টিমাইজেশন অবশ্যই সম্পাদন করা যেতে পারে।

জ্ঞানের প্রতিনিধিত্ব

পাইথন কোড রয়েছে যা বোর্ডকে পরমাণুতে রূপান্তর করে:

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__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).

যেখানে বি (0,0,3) এমন একটি পরমাণু যা বর্ণনা করে যে প্লেয়ার 3 এর স্থানাঙ্ক (0; 0) এ একটি নিষ্পত্তি রয়েছে।

এএসপি সমাধান

অনেকগুলি alচ্ছিক স্কোর প্রয়োগ করে এএসপি কোড রয়েছে:

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

যেখানে এস (,,৩,6) বলেছেন যে প্লেয়ার alচ্ছিক স্কোর with সহ points পয়েন্ট অর্জন করে এবং এস (টি, ৪,62২) বলে প্লেয়ার মোট total২ পয়েন্ট লাভ করেছে (কোর + ১ + ৩ +))।

অভিনব টেবিল রাখতে পার্স করা সহজ!

— aluriak
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.