एक ब्लैकजैक कोठ प्रतियोगिता

Question

डांडा

जैसा कि मुझे मूल KOTH चुनौती पर काम करने के लिए एक विस्फोट हुआ था, मैं एक दूसरे के साथ आना चाहता था। मेरे लिए, इन AI चुनौतियों का मज़ा तुलनात्मक रूप से सरल बॉट को परिष्कृत करने में है, जो बहुत ही सरल खेल खेलते हैं। कार्ड गेम की संभावित प्रकृति के कारण, मुझे लगता है कि टीपीडी की तरह ही लाठी एक दिलचस्प KOTH खेल हो सकता है।

ब्लैकजैक के जूते के साथ इस वेबसाइट के विवरण से सभी नियम प्राप्त होते हैं

कार्ड और डेक के संबंध में नियम

• बॉट चार (4) प्रतियोगियों और एक (1) डीलर की तालिकाओं में खेलते हैं
• एक (1) जूता (एक फेरबदल डेक) सभी खिलाड़ियों और डीलर द्वारा साझा किया जाता है जब तक कि यह समाप्त नहीं हो जाता है, जिस बिंदु पर एक नया बेतरतीब ढंग से फेरबदल डेक जोड़ा जाएगा और खेलना जारी रहेगा। बॉट्स (वर्तमान में) इस नए डेक के अतिरिक्त के नहीं हैं। यदि इस सुविधा की कमी से पर्याप्त संकट / परेशानी होती है तो ऐसी अधिसूचना जोड़ी जा सकती है।
• प्रति राउंड 10 की खरीद है, और कार्ड मुफ्त हैं
• परफेक्ट / आदर्श हाथ का स्कोर 21 है
• सभी फेस कार्ड का मूल्य 10 है
• सभी संख्यात्मक कार्ड उनकी संख्या के लायक हैं
• इक्के 11 या 1 के लायक हैं। यह फ्रेम द्वारा स्वचालित रूप से निपटा जाएगा, न कि बॉट्स।
• के अनुसार नियम , सभी खिलाड़ियों के कार्ड फेस-अप निपटा और दिखाई देते हैं। डीलर का एक कार्ड फेस-डाउन और दूसरा फेस-अप है।

स्कोरिंग

• 21 से अधिक के स्कोर जो 1 के मान को कम करने के लिए 11 बल के रूप में इक्का का उपयोग करते हैं
• 21 से अधिक के स्कोर जो बॉट की 21 "बस्ट" की दहलीज से नीचे नहीं जा सकते हैं

विक्रेता

• डीलर तब तक ड्रॉ करता है जब तक कि वह हलचल नहीं करता है, या 17 के स्कोर तक पहुंच जाता है, जिस बिंदु पर वह खड़ा होने के लिए मजबूर होता है

बेटिंग और चिप्स

• प्रत्येक दौर के शुरू में, एक खरीद 10 का शुल्क लिया जाता है, इसलिए वहाँ एक न्यूनतम है हिस्सेदारी 10 में, और एक न्यूनतम शर्त 1. का नोट - शर्त, शर्त तर्क का निरपेक्ष मान है, तो परेशान नहीं है नकारात्मक दांव आजमा रहे हैं।
• बॉट जो खरीद नहीं सकते, उन्हें प्रतियोगिता से हटा दिया जाता है
• दांव लगाते समय, बॉट उनके पास मौजूद चिप्स से अधिक दांव नहीं लगा सकता
• यदि शर्त संभव है, तो चिप्स की शर्त को बॉट से निकाल दिया जाता है और इसे दांव पर जोड़ दिया जाता है
• एक शर्त जीतना बीओटी 2x चिप्स शर्त देता है। हालाँकि, क्योंकि दांव को बॉट के चिप्स से घटाया जाता है, बॉट भी टूट जाता है और फिर 1x बाजी जीतता है।
• बॉट केवल तभी दांव जीतते हैं जब उनका स्कोर डीलर से अधिक होता है

गेमप्ले ब्रेकडाउन

एक हाथ

1. जब खेल शुरू होता है, तो प्रत्येक खिलाड़ी एक-एक कार्ड को निपटाता है, और उनके चिप्स से $ 10 खरीद-शुल्क / न्यूनतम शर्त घटाया जाता है।
2. सौदागर खींचता है
3. एक दूसरा पास बनाया गया है, और सभी खिलाड़ियों के लिए एक और कार्ड दिया गया है।
4. सौदागर खींचता है
5. तब और उसी क्रम में, जैसा कि वे निपटाए गए थे) प्रत्येक बॉट को "प्रोग्रामर के इंटरफेस" अनुभाग में वर्णित के रूप में निष्पादित किया गया है और इसे एक चाल या स्टैंड बनाना चाहिए । सट्टेबाजी को एक चाल माना जाता है। ध्यान दें कि अन्य मोड़ों को बनाने के लिए किसी व्यक्ति की योग्यता नहीं है। सट्टेबाजी करना और फिर एक कार्ड खींचना बहुत संभव है, और कई कार्डों को खींचना संभव है और वे खड़े होने से पहले शर्त लगाते हैं।
6. जब सभी बॉट्स का पर्दाफाश हो जाता है या खड़ा हो जाता है, तो डीलर 17 की सीमा तक खेलता है
7. बॉट के स्कोर तब डीलर की तुलना में होते हैं, दांव जीते जाते हैं और हार जाते हैं

एक चक्कर

को पांच (5) हाथ बनाने के लिए माना जाता है। हाथों के बीच, प्रतियोगियों की सूची खिलाड़ियों को हटाने के लिए छांटी जाती है और फिर यह सुनिश्चित करने के लिए आगे की प्रक्रिया की जाती है कि सभी बॉट एक ही संख्या में खेलें (इस तथ्य के लिए एक प्रावधान है कि प्रविष्टियों की संख्या समान रूप से चार-बॉट टेबल में विभाजित नहीं होगी। )।

प्रोग्रामर का इंटरफ़ेस और कानूनी चाल

कार्डशार्क फ़ाइल में प्रलेखित:

#   DOCUMENTATION
#       INPUT SPECIFICATION
#          $ ./foo.bar <hand-score> <hand> <visible cards> <stake> <chips>
#          <hand-score>     is the present integer value of the player's hand.
#          <hand>           is a space-free string of the characters [1-9],A,J,Q,K
#          <visible cards>  every dealt card on the table. when new shoes are brought
#                           into play, cards drawn therefrom are simply added to this list
#                           NOTE: the first TWO (2) cards in this list belong to the dealer.
#                             one however will be "hidden" by a "#". the other is visible.
#                           !!! THE LIST IS CLEARED AT THE END OF HANDS, NOT SHOES !!!
#          <stake>          the  number of chips which the bot has bet this hand
#          <chips>          the number of chips which the bot has
#       SAMPLE INPUT
#          $ ./foo.bar 21 KJA KQKJA3592A 25 145
#
#       OUTPUT SPECIFICATION
#          "H"|"S"|"D"|"B"  (no quotes in output)
#          "H"              HIT - deal a card
#          "S"              STAND - the dealer's turn
#          "D"              DOUBLEDOWN - double the bet, take one card. FIRST MOVE ONLY
#          "B 15"           BET - raises the bot's stakes by $15.

कार्ड फ़ाइल में जैसा (अभी) प्रलेखित है:

#       class CARD
#           card is a container for representing paper playing cards in
#           otherwise fairly functional programming.
#           letter()
#               gets the letter used to identify the card in a string  
#               LETTER MAPPINGS  
#                   Ace     :   'A'
#                   Two     :   '2'
#                   Three   :   '3'
#                   Four    :   '4'
#                   Five    :   '5'
#                   Six     :   '6'
#                   Seven   :   '7'
#                   Eight   :   '8'
#                   Nine    :   '9'
#                   Ten     :   'T'
#                   Jack    :   'J'
#                   Queen   :   'Q'
#                   King    :   'K'
#                   "Hidden":   '#'

स्कोरिंग प्रणाली के लिए स्रोत कोड यहाँ है

नमूना बॉट

लिम 17

#!/usr/bin/env python
import sys
s = sys.argv
if int(s[1]) < 17:
    print "H"
else:
    print "S"

प्रवेश भाषाएँ

वर्तमान में, जावा, c / c ++, पायथन और लिस्प समर्थित हैं। अन्य भाषाओं में प्रस्तुतियाँ शामिल करने के लिए एक उचित प्रयास किया जाएगा, लेकिन याद रखें कि अंतिम प्रतियोगिता लिनक्स बॉक्स पर चलाई जाएगी।

विजेता का चयन

विजेता बॉट का लेखक होगा जिसने लगातार एक से अधिक तालिकाओं और राउंड की निर्धारित संख्या से अधिक चिप्स अर्जित किए। 3 जून को विजेता की घोषणा की जाएगी, लेकिन अगर अभी भी प्रस्तुतियाँ आ रही हैं तो घोषणा में देरी हो सकती है। प्रतियोगिता अनिश्चित काल तक विस्तारित रही।

Comments

प्रश्न: क्या दृश्य-कार्ड में उन खिलाड़ियों को शामिल किया गया है जो अपने हाथों में हैं?

— dmckee --- पूर्व-मध्यस्थ ने

दूसरा प्रश्न: क्या हम जानते हैं कि कितने कार्ड निपटाए गए हैं जिन्हें हम नहीं देख सकते हैं?

— dmckee --- पूर्व-मध्यस्थ ने

# 1 का जवाब - हाँ; # 2 का उत्तर - इस इंजन को जिस तरह से लागू किया गया है, उसमें छिपे कार्ड नहीं हैं। दृश्य-कार्ड हर कार्ड है जिसे मौजूदा दौर के दौरान उपभोग किए गए प्रत्येक जूते से निपटाया गया है। दृश्य-कार्ड रिटर्न नए जूतों पर साफ नहीं किया जाता है (क्योंकि पुराने जूते का हिस्सा शायद अभी भी खेल में है), लेकिन इसके बजाय गोल करने की मंजूरी दी गई है। यह एक वास्तुकला पसंद है जिसे मैंने सादगी के लिए बनाया है, जिसे यदि आप छिपे हुए कार्ड की कमी के कारण समस्याग्रस्त पाते हैं तो संशोधित किया जा सकता है।

— गिरफ्तारी

अद्यतन: नियमों की कड़ी की जाँच करें। इंजन अब छिपे हुए कार्डों को लागू करता है, लेकिन वर्तमान में एकमात्र छिपा हुआ कार्ड डीलर के आधार कार्डों में से एक है।

— गिरफ्तारी

बॉट कैसे भेद कर सकता है कि कौन सा दृश्य कार्ड डीलर है?

— cthom06

Answer 1

BlackJackDavey

बोरिंग, पुराने जमाने के सी। ANSI या c99 के तहत संकलक करना चाहिए।

/* BlackJackDavey
 *
 * A entry for
 * http://codegolf.stackexchange.com/questions/2698/a-blackjack-koth-contest
 * copyright 2011 
 *
 * Currently expects a slightly extended version of the spec. Two
 * expected changes:
 * - Tens will be represented as 'T'
 * - The visible card string will include '#' for those cards whose
 *     *backs* we can see (slight improvement in card counting technique)
 * 
 * No disaster if neither feature is present, just sligtly degraded
 * performance.
 */
#include <stdio.h>
#include <string.h>

/* A full deck has a total value of 4*( (11*5) + (3*10) + ace ) where
 * ace is 11 or according to our need.
 **/
int fullWeight(const int current){
  int ace = (current>10) ? 1 : 11;
  return 4 * ( 11*5 + 3*10 + ace);
}
/* Return the value of a particular card in the context of our
 * current score
 */
int cardWeight(const char c, const int current){
 switch (c) {
 case '1': case '2': case '3': case '4': case '5':
 case '6': case '7': case '8': case '9':
   return (c - '0');
 case 'T': case 'J': case 'Q': case 'K':
   return 10;
 case 'A':
   return current>10 ? 1 : 11;
 }
 return 0;
}
/* returns the mean card *value* to be expected from the deck 
 *
 * Works by computing the currently unknown value and diviing by the
 * number of remaining cards 
 */
float weight(const char*known, const int current){
  int weight = fullWeight(current);
  int count=52;
  int uCount=0;
  const char*p=known;
  while (*p != '\0') {
    if (*p == '#') { /* Here '#' is a stand in for the back of a card */
      uCount++;
    } else {
      weight -= cardWeight(*p,current);
    }
    count--;
    p++;
    if ( count==0 && *p != '\0') {
      count += 52;
      weight += fullWeight(current);
    }
  }
  return (1.0 * weight)/(count+uCount);
}


int main(int argc, char*argv[]){
  int score=atoi(argv[1]);
  const char*hand=argv[2];
  const char*visible=argv[3];
  int stake=atoi(argv[4]);
  int chips=atoi(argv[5]);

  /* If current stake is less than 10, bet all the rest because a loss
     does not leave us enough to continue */
  if (chips < 10 && chips > 0) {
    printf("B %d\n",chips);
    return 0;
  }
  /* First round stategy differs from the rest of the game */
  if (strlen(hand)==2 && stake==10) {
    switch(score){
    case 10:
    case 11: /* Double down on particularly strong hands */
      if (chips >= 10) {
    printf("D\n");
    return 0;
      }
      break;
    default:
      break;
    };
  }
  /* In future rounds or when first round spcialls don't apply it is
     all about maximizing chance of getting a high score */
  if ((score + weight(visible,score)) <= 21) {
    /* if the oods are good for getting away with it, hit */
    printf("H\n");
    return 0;
  }
  /* Here odd are we bust if we hit, but if we are too low, the dealer
     probably makes it.*/
  printf("%c\n", score>14 ? 'S' : 'H');
  return 0;
}

यहां की रणनीति टिप्पणियों में प्रलेखित है, लेकिन बहुत सीधे आगे है। अतिरिक्त दांव केवल दो मामलों में किए जाते हैं (अगले दौर के लिए पर्याप्त हिस्सेदारी नहीं, या डबल डाउन), और इसे बदलने की आवश्यकता हो सकती है।

खेल कैसीनो जुआरी के लिए पेश किए गए गाइडों से कुछ अलग है कि इसमें डीलर के कार्ड दिखाने के बारे में कोई विशेष जानकारी नहीं है (या क्या हम उस पर अंतिम प्रविष्टि में प्रवेश कर सकते हैं visible?), इसलिए कुछ जादुई संख्याओं का अनुमान है।

टिप्पणियों में दो सवालों के जवाब के आधार पर कुछ मामूली डीडलिंग की आवश्यकता हो सकती है।

खेल से नाम, मेरा पहला नाम और पुराना लोक गाथा ।

Comments

टी कार्ड द्वारा प्रस्तुत दस कार्ड आईएस है। सूची के साथ प्रतियोगिता पोस्ट को अपडेट करेगा।

— गिरफ्तारी

Answer 2

रैखिक बेट

#!/usr/bin/env python
from __future__ import division
import sys
s = sys.argv

c=150    # chip modifier
f=15     # stand score

if int(s[1]) < f:
    print "H"
else:
    if int(s[4]) == 10:
        print "B", (int(s[1])/21)*c
    else:
        print "S"

यह बॉट 17 रणनीति का एक संशोधन है। यह बॉट तब तक खींचता है जब तक कि यह 15 (f) के स्कोर से अधिक न हो जाए और फिर int (c * (स्कोर / 21)) चिप को दांव लगाता है। इस तरह से जहां भी संभव होगा बॉट आक्रामक तरीके से दांव लगाएगा।