Euchre বট (কার্ড খেলা)


10

এই চ্যালেঞ্জটির ধারণাটি সহজ: কার্ড গেম ইউচারে খেলতে বট তৈরি করুন।

আপনারা যারা ইতিমধ্যে তাদের চেনেন না, তারা এই চ্যালেঞ্জের সাথে সম্পর্কিত বলে আমি এখানে ইউচারের কাছে বিধিগুলি লিখেছি ।

আমি অজগর বা অনুরূপ কিছু ব্যবহার করার পরামর্শ দিচ্ছি তবে একমাত্র আসল বাধা হ'ল এটি নিয়ামক কোডের সাথে সামঞ্জস্যপূর্ণ হতে হবে

ইনপুট:

আপনার ইউচার বট খেলা বা রাউন্ডের বর্তমান পর্বের উপর নির্ভর করে বিভিন্ন ধরণের ইনপুট পাবে। সাধারণভাবে বলতে গেলে, আপনি প্রথম লাইনে গেম পর্বটি পেয়ে যাবেন তার পরে কমা এবং আপনার দলের বেশ কয়েকটি পয়েন্ট এবং তারপরে নিম্নলিখিত লাইনে প্রাসঙ্গিক ডেটা পাবেন।

কালানুক্রমিকভাবে, আপনার বট নিম্নলিখিত ক্রমে ইনপুট পাবেন:

Ordering Trump:
    js,ah,qc,ts,jc  // the cards in your hand
    2               // number of points your team has
    0               // number of tricks your team has taken
    ordering        // the phase of the game
    th              // the turned up card
    p,p             // each previous player’s decision

Naming Trump:
    js,ah,qc,ts,jc  // the cards in your hand
    2               // number of points your team has
    0               // number of tricks your team has taken
    naming          // the phase of the game
    p               // each previous player’s decision

Dealer Discarding:
    js,ah,qc,ts,jc  // the cards in your hand
    2               // number of points your team has
    0               // number of tricks your team has taken
    discard         // the phase of the game
    th              // the card you will pick up

Going alone:
    js,ah,qc,ts,jc  // the cards in your hand
    2               // number of points your team has
    0               // number of tricks your team has taken
    alone           // the phase of the game
    h               // the trump suit
    n,n             // each previous player’s decision

Your turn:
    js,ah,qc,ts,jc  // the cards in your hand
    2               // number of points your team has
    0               // number of tricks your team has taken
    turn            // the phase of the game
    h               // the trump suit
    td,8h,p         // each previous player’s card

Trick data:
                    // the cards in your hand (none, since this happens at the end of a trick)
    2               // number of points your team has
    1               // number of tricks your team has taken
    trick           // the phase of the game
    0               // the index of the following list that is your card
    js,tc,4d,js     // the cards played during the trick in the order they were played

আউটপুট:

আপনার ইউচার বটটিতে খেলা বা রাউন্ডের বর্তমান পর্বের উপর নির্ভর করে বিভিন্ন আউটপুট থাকবে।

Ordering Trump:
    p   //for pass
    OR
    o   //for order up

Naming Trump:
    p           //for pass
    OR ANY OF
    c,s,h,d     //the suit you want to name

Going alone:
    n   // no
    OR
    y   // yes

Your turn:
    js  //the card you want to play

স্কোরিং:

আপনার বটের স্কোর এটি জেতে মোট গেমের সংখ্যা।

আপনার বটটি অন্য সমস্ত বটের বিরুদ্ধে খেলবে এবং এটি সর্বদা নিজের অনুলিপি সহ অংশীদার হবে।

মন্তব্য:

পাইথন 2.7 এ এখানে একটি সাধারণ টেম্পলেট রয়েছে:

#!/usr/bin/python2.7
import sys

data = sys.stdin.readlines()

hand = data[0].strip().split(',')   # Hand as a list of strings
points = int(data[1])       # Number of points
tricks = int(data[2])       # Number of tricks

out = ''

if data[3] == 'ordering':
    card = data[4]              # The upturn card
    prev = data[5].strip().split(',')   # The previous player's decisions as a list
    # Ordering logic
    out =       # 'o' or 'p'
elif data[3] == 'naming':
    prev = data[4].strip().split(',')   # The previous player's decisions as a list
    # Naming logic
    out =       # 'p', 'h', 's', 'c', or 'd'
elif data[3] == 'discard':
    card = data[4]              # The card you'll take
    # Discarding logic
    out =       # The card you want to discard
elif data[3] == 'alone':
    trump = data[4]             # The trump suit
    prev = data[5].strip().split(',')   # The previous player's decisions as a list
    # Alone logic
    out =       # 'y' for yes, 'n' for no
elif data[3] == 'turn':
    trump = data[4]             # The trump suit
    prev = data[5].strip().split(',')
    # Turn logic
    out =       # The card you want to play
elif data[3] == 'trick':
    trump = data[5]
    cards = data[6].strip().split(',')
    my_card = cards[int(data[4])]
    # Data logic

print(out)
  1. সর্বদা 4 টি মোট প্রতিক্রিয়া থাকবে। যদি কেউ একা হয়ে যায়, তবে তাদের অংশীদারের সাড়া তাদের পালাটিতে "পি" হবে।

  2. অপ্রয়োজনীয় ইনপুটটির পরিমাণ কমিয়ে দেওয়ার চেষ্টা করেছি, তাই অতিরিক্ত স্পষ্ট হয়ে উঠতে:

    2A। ডিলার / লিডার এবং আপনার পার্টনার যে কার্ডটি খেলেন সে সম্পর্কিত আপনার অবস্থান উভয়ই পূর্ববর্তী ফলাফলগুলির সংখ্যা দ্বারা নির্ধারণ করা যেতে পারে। আপনার এবং আপনার সঙ্গীর মধ্যে 1 জন খেলোয়াড় রয়েছে। উদাহরণস্বরূপ, আপনি যদি আপনার পালাটির শেষ লাইন হিসাবে "td, 8h, p" পান, আপনি দেখতে পাচ্ছেন যে আপনার সঙ্গী একটি 8 ঘন্টা খেলেছে, এবং অন্য দলে এমন খেলোয়াড় রয়েছে যা একা চলেছে।

  3. আপনি যদি কৌতূহলী হন তবে চুক্তিটি প্রচলিত উপায়ে করা হয় (2 এবং 3 টি কার্ডের দুটি রাউন্ডের বিকল্প প্যাকেটগুলিতে) তবে এটি আপনার বটের সাথে সত্যিই প্রাসঙ্গিক নয়, তাই ...

  4. যদি দ্বিতীয় খেলোয়াড় ট্রাম্প পর্বে অর্ডার করার সিদ্ধান্ত নেন, তবে সেই পর্বটি অব্যাহত থাকবে, তবে তাদের ফলাফলগুলি বেশ উপেক্ষা করা হবে। অন্য কথায়, যে প্রথমে অর্ডার দেয় সে অন্য কোনও আউটপুট নির্বিশেষে নেমার্স দলে থাকে।

  5. নিম্নলিখিত বিভিন্ন খেলা পর্যায়ের জন্য ডিফল্ট নীচে রয়েছে। যদি আপনি এই রাউন্ডের জন্য কোনও বৈধ প্রতিক্রিয়া আউটপুট না করেন তবে আপনার প্রতিক্রিয়াটি নীচের অংশে পরিবর্তিত হবে।

    অর্ডার ট্রাম্প: পি

    নামকরণ ট্রাম্প: পি

    বাতিল করা: (আপনার হাতে প্রথম কার্ড)

    একা যাওয়া: এন

    আপনার পালা: (আপনার হাতে প্রথম আইনী কার্ড)

  6. আপনার পরীক্ষার উদ্দেশ্যে নিয়ামক কোড এখানে

    6A। লক্ষ্য করুন আপনি দুটি বা 4 টি বটের নাম দিয়ে যেতে পারেন, আপনি যদি এটি 4 টি বট দেন তবে তারা এলোমেলোভাবে অংশীদার হয়ে যায় এবং 2 এর সাথে তারা নিজের অনুলিপিগুলিতে অংশীদার হয়।

    6b। আপনার নিয়ন্ত্রক কোডের মতো একই ডিরেক্টরিতে একটি 'বটস' ডিরেক্টরি প্রয়োজন এবং আপনার বট কোডটি বট ডিরেক্টরিতে থাকা দরকার।

  7. যাঁরা তাদের বটটি স্মরণে রাখতে চান যে কোন কার্ডগুলি খেলেছে, তাদের জন্য আপনাকে "কৌশল" পর্বের সময় সুযোগ দেওয়া হবে যা আপনার বটকে বলে যে কোন কার্ডগুলি খেলানো হয়েছিল। আপনি বট ডিরেক্টরিতে কোনও ফাইল লিখতে পারবেন যতক্ষণ না সেই ফাইলটি 1 কেবি ছাড়িয়ে যায় না।

স্কোরবোর্ড:

Old Stager:  2
Marius:      1
Random 8020: 0

2
আমি তাদের বটগুলি লেখার পক্ষে আরও সহজ করার জন্য নমুনা বটগুলি অন্তর্ভুক্ত করার পরামর্শ দেব।
নাথান মেরিল

3
এটি জমা হিসাবে পোস্ট করুন। তবে, এলোমেলো বটের সাথে সমস্যা হ'ল এটি আপনি যে ইনপুটটি দিচ্ছেন তাতে সিংহভাগ উপেক্ষা করে। লোকেরা কোডটি অনুলিপি / পেস্ট করতে (তারপরে সংশোধন করতে) পছন্দ করে, তাই আপনার প্রাথমিক বটগুলি যত বেশি বিস্তৃত হয় তত বেশি জমা (এবং আরও ভাল জমা) আপনি পাবেন।
নাথান মেরিল

1
আমি কী ধরে নিতে পারি যে বটটি যদি পর্বের শেষ খেলোয়াড় না হয় তবে শেষ পালায় কী খেলা হয়েছিল তা জানার কোনও উপায় নেই?
প্লানাপাস

1
@ স্লেফার ভাল করে জানাচ্ছেন যে বর্তমান পালা চলাকালীন কী খেলা হয়েছিল তা জানার কোনও উপায় থাকলে, বট ট্র্যাক রাখার জন্য বট এটিকে একটি ফাইলে লিখতে পারে।
প্ল্যানাপাস

1
@ নোটহাট চার্লস আমি স্পষ্টভাবে কোনও ফাইলকে লেখার অনুমতি দেওয়ার জন্য নিয়মগুলি আপডেট করেছি
দ্য বিণস্টাল্ক

উত্তর:


2

Marius

আমি সেই বোটটি আর-তে লিখেছিলাম your

#!/usr/bin/Rscript
options(warn=-1)
infile = file("stdin")
open(infile)
input = readLines(infile,5)
hand = strsplit(input[1],",")[[1]]
phase = input[4]
if(!phase%in%c("discard","naming")) input = c(input,readLines(infile,1))
other_o = c("a","k","q","j","t","9")
alone = "n"
ord = "p"
trumpify = function(color){
    tr_suit = switch(color,
            "c" = c("c","s",rep("c",5)),
            "s" = c("s","c",rep("s",5)),
            "h" = c("h","d",rep("h",5)),
            "d" = c("d","h",rep("d",5)))
    paste(c("j","j","a","k","q","t","9"),tr_suit,sep="")
    }

if(phase%in%c("ordering","alone")){
    flip = input[5]
    if(phase=="ordering") trump = trumpify(substr(flip,2,2))
    if(phase=="alone") trump = trumpify(flip)
    hand_value = sum((7:1)[trump%in%c(hand,flip)])
    if(hand_value>13) ord = "o"
    if(hand_value>18) alone = "y"
    if(phase=="alone") cat(alone)
    if(phase=="ordering") cat(ord)
    }

if(phase=="naming"){
    name = "p"
    colors = unique(substr(hand,2,2))
    col_values = sapply(colors,function(x)sum((7:1)[trumpify(x)%in%hand]))
    if(any(col_values>13)){name = colors[which.max(col_values)]}
    cat(name)
    }

if(phase=="discard"){
    flip = input[5]
    new_hand = c(hand,flip)
    trump = trumpify(substr(flip,2,2))
    discardables = new_hand[!new_hand%in%trump]
    if(length(discardables)){
        val = sapply(substr(discardables,1,1),function(x)(6:1)[other_o==x])
        d = discardables[which.min(val)]
    }else{d = tail(trump[trump%in%new_hand],1)}
    cat(d)
    }

if(phase=="turn"){
    trump = trumpify(input[5])
    fold = strsplit(gsub("[[:punct:]]","",input[6]),",")[[1]]
    if(length(fold)&!any(is.na(fold))){
        fold_c = substr(fold[1],2,2)
        f_suit = if(fold_c!=input[5]){paste(other_o,fold_c,sep="")}else{trump}
        l = length(f_suit)
        current = (l:1)[f_suit%in%fold]
        if(any(hand%in%f_suit)){
            playable = hand[hand%in%f_suit]
            val = sapply(playable,function(x)(l:1)[f_suit==x])
            if(all(max(val)>current)){
                play = playable[which.max(val)]
            }else{play = playable[which.min(val)]}
        }else if(any(hand%in%trump)){
            playable = hand[hand%in%trump]
            val = sapply(playable,function(x)(7:1)[trump==x])
            if(!any(fold%in%trump)){
                play = playable[which.min(val)]
            }else{
                trumped = fold[fold%in%trump]
                val_o = max((7:1)[trump%in%trumped])
                play = ifelse(any(val>val_o), playable[which.min(val[val>val_o])], playable[which.min(val)])
            }
        }else{
            val = sapply(substr(hand,1,1),function(x)(6:1)[other_o==x])
            play = hand[which.min(val)]
            }
    }else{
        col = c("c","s","h","d")
        non_tr = col[col!=input[5]]
        aces = paste("a",non_tr,sep="")
        if(any(hand%in%aces)){
            play = hand[hand%in%aces][1]
        }else if(any(hand%in%trump)){
            playable = hand[hand%in%trump]
            val = sapply(playable,function(x)(7:1)[trump==x])
            play = playable[which.max(val)]
        }else{
            val = sapply(substr(hand,1,1),function(x)(6:1)[other_o==x])
            play = hand[which.max(val)]
        }
    }
    cat(play)   
}

বোট যখন ডিফেন্ডিংয়ের সময় আমি "টার্ন" যুক্তি প্রয়োগ করিনি তখন সম্ভবত আমি এটি সংশোধন করব, তবে এখনই এটি পোস্ট করছি যাতে লোকেরা যাতে পরীক্ষা করতে পারে তার জন্য আরও একটি বট থাকে।

আপাতত, এটি কেবলমাত্র মৌলিক কৌশল প্রয়োগ করে যেমন একটি টেক্কা, ট্রাম্প বা অন্য কোনও উচ্চ কার্ডের সাহায্যে নেতৃত্ব দেওয়া; সম্ভব হলে উচ্চতর কার্ডের সাথে অনুসরণ করা বা যদি না হয় তবে সর্বনিম্ন মূল্যবান কার্ড খেলুন; যখন হাতটির উচ্চমূল্য থাকে তখন অর্ডার করা এবং সেই রঙের নামকরণ যাতে হাতে সর্বাধিক মান হত; হাত খুব উচ্চ মূল্য আছে যখন একা যাওয়া। প্রতিটি কার্ডের "মান" খুব সহজেই গণনা করা হয়: প্রথম জ্যাকের জন্য ট্রাম্পের মান 7 থেকে শুরু হয় এবং ট্রাম্প স্যুট বরাবর হ্রাস পায়।


1

ওল্ড স্টেজার

এই বটটি কিছু সাধারণ নিয়ম অনুসরণ করে যা তাকে দীর্ঘকাল ধরে ভালভাবে পরিবেশন করেছে:

  • স্বজ্ঞাতভাবে প্রতিটি কার্ডে একটি স্কোর বরাদ্দ করুন
  • হাতের স্কোর যথেষ্ট ভাল হলে ট্রাম্প চয়ন করুন
  • সত্যিই ভাল হাত ক্ষেত্রে একা
  • প্রথম খেললে সেরা কার্ড চয়ন করুন
  • যদি তারা বিজয়ী হয় তবে বিরোধীদের চেয়ে আরও ভাল কার্ড চয়ন করুন
  • অংশীদার জিতে থাকলে বা জেতা সম্ভব না হলে সবচেয়ে খারাপ কার্ডটি চয়ন করুন

আমি নিয়ামকটিতে পরীক্ষার জন্য লক্ষ্য স্কোর 10 থেকে 100 এ বাড়িয়েছি। ফলাফলগুলি এখনও খুব এলোমেলো, তবে আগের চেয়ে স্থিতিশীল।

#!/usr/bin/python2.7
from __future__ import print_function
import sys, re, math

base = 1.2
playThreshold = 27.0
aloneThreshold = 36.0
sameColor = { 'd' : 'h', 'h' : 'd', 's' : 'c', 'c' : 's' , '' : '', 'n' : 'n' }
cardValue = { 'p' : 0, '9' : 1, 't' : 2, 'j' : 3, 'q' : 4, 'k' : 5, 'a' : 6 }

class Card(object):
    def __init__(self, name, trump):
        self.name = name
        self.value = cardValue[name[0:1]]
        self.suit = name[1:2]
        self.trump = False
        self.updateScore(trump)
    def updateScore(self, trump):
        self.score = self.value
        if self.suit == trump:
            self.trump = True
            self.score += 6
        if self.value == 3:
            if self.suit == trump:
                self.score = 14
            if self.suit == sameColor[trump]:
                self.trump = True
                self.score = 13

class Cards(object):
    def __init__(self, cards, trump):
        self.list = []
        self.score = 0.0
        if cards:
            for c in cards.split(','):
                self.append(Card(c, trump))
    def append(self, card):
        self.list.append(card)
        self.score += math.pow(base, card.score)
    def updateScore(self, trump):
        self.score = 0.0
        for card in self.list:
            card.updateScore(trump)
            self.score += math.pow(base, card.score)
    def best(self):
        card = self.list[0]
        for i in self.list[1:]:
            if i.score > card.score:
                card = i
        return card
    def worst(self):
        card = self.list[0]
        for i in self.list[1:]:
            if i.score < card.score:
                card = i
        return card
    def better(self, ref):
        card = None
        for i in self.list:
            if i.score > ref.score and (card is None or i.score < card.score):
                card = i
        return card

def ordering(hand, card, decisions):
    if len(decisions) == 3:
        hand.append(card)
    return 'o' if hand.score > playThreshold else 'p'

def naming(hand):
    result = 'p'
    score = playThreshold
    for trump in ['d', 'h', 's', 'c']:
        hand.updateScore(trump)
        if hand.score > score:
            result = trump
            score = hand.score
    return result

def turn(hand, decisions):
    bestIndex = -1
    for i, d in enumerate(decisions.list):
        if d.suit:
            bestIndex = i
            break
    if bestIndex == -1:
        return hand.best()
    else:
        suit = decisions.list[bestIndex].suit
        for i in range(2, len(decisions.list)):
            if (decisions.list[i].suit == suit or decisions.list[i].trump) and decisions.list[i].score > decisions.list[bestIndex].score:
                bestIndex = i
        matching = Cards('', '')
        for card in hand.list:
            if card.suit == suit:
                matching.append(card)
        if not matching.list:
            if bestIndex == len(decisions.list) - 2:
                return hand.worst()
            for card in hand.list:
                if card.trump:
                    matching.append(card)
            if not matching.list:
                return hand.worst()
        if bestIndex == len(decisions.list) - 2:
            return matching.worst()
        card = matching.better(decisions.list[bestIndex])
        if card:
            return card
        return matching.worst()

output = ''
input = re.split('\n', re.sub(r'[^a-z0-9,\n]+', '', sys.stdin.read()))

if input[3] == 'ordering':
    output = ordering(Cards(input[0], input[4][1:2]), Card(input[4], input[4][1:2]), input[5].split(','))
elif input[3] == 'naming':
    output = naming(Cards(input[0], 'n'))
elif input[3] == 'discard':
    output = Cards(input[0], input[4][1:2]).worst().name
elif input[3] == 'alone':
    output = 'y' if Cards(input[0], input[4]).score > aloneThreshold else 'n'
elif input[3] == 'turn':
    output = turn(Cards(input[0], input[4]), Cards(input[5], input[4])).name

print(output)

0

র্যান্ডম 8020

একটি সাধারণ র্যান্ডম বট, যা সময়ের ৮০% কেটে যাবে। ইনপুট এবং আউটপুট (ক্লিয়ার আপ) দেখতে শেষ লাইনটি মন্তব্য করুন।

#!/usr/bin/python2.7
from __future__ import print_function
import sys, re, random

output = ''
input = re.split('\n', re.sub(r'[^a-z0-9,\n]+', '', sys.stdin.read()))
hand = input[0].split(',')

if input[3] == 'ordering':
    output = random.choice(['p', 'p', 'p', 'p', 'o'])
elif input[3] == 'naming':
    output = random.choice(['p', 'p', 'p', 'p', random.choice(hand)[1:2]])
elif input[3] == 'discard':
    output = random.choice(hand)
elif input[3] == 'alone':
    output = random.choice(['n', 'n', 'n', 'n', 'y'])
elif input[3] == 'turn':
    output =  random.choice(hand)
    if input[5]:
        suited = filter(lambda x: input[5][1:2] in x, hand)
        if suited:
            output = random.choice(suited)

print(output)
#print(input, " --> ", output, file=sys.stderr)
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.