सफेद हाथी विनिमय

Question

यह जुलाई में क्रिसमस है, इसलिए एक आभासी सफेद हाथी उपहार विनिमय की तुलना में जश्न मनाने का बेहतर तरीका क्या है!

इस किंग ऑफ द हिल चैलेंज के लिए, आपको एक बॉट बनाना होगा जो कि व्हाइट एलिफेंट एक्सचेंज के सिमुलेशन में खेलता है , जो उच्चतम-मूल्य वाले वर्तमान में प्राप्त करने की कोशिश कर रहा है।

खेल के नियमों

• खेल कई राउंड में खेला जाएगा, प्रत्येक घुमावों की एक चर संख्या से बना होता है।
• राउंड सेटअप : खेल में जितने खिलाड़ी होते हैं, उतने ही प्रस्तुत होंगे, जिनमें से प्रत्येक का मूल्य सीमा में समान रूप से समान रूप से होता है, यह मान तब तक अज्ञात रहता है जब तक कि वर्तमान "खोला" नहीं जाता है। खिलाड़ियों को एक कतार में यादृच्छिक क्रम में रखा जाएगा। पहला खिलाड़ी कतार के सामने से पॉप किया जाएगा।
• जब यह एक खिलाड़ी की बारी है, तो वे या तो एक वर्तमान को खोल सकते हैं या किसी अन्य खिलाड़ी के वर्तमान को चुरा सकते हैं, उस खिलाड़ी को पासिंग टर्न दे सकते हैं जिसका वर्तमान चोरी हो गया था।
  • प्रत्येक वर्तमान को 3 बार तक चुराया जा सकता है।
  • आप उस खिलाड़ी से चोरी नहीं कर सकते जो सिर्फ आपसे चुराता है।
  • प्रत्येक खिलाड़ी एक समय में केवल एक ही उपस्थित हो सकता है।
• एक प्रेजेंट खुलने के बाद, अगले खिलाड़ी को कतार के सामने से पॉप करते हुए खेलते हैं। यह अगले क्रम का खिलाड़ी होगा जिसने अभी तक टर्न नहीं लिया है।
• राउंड एंड : जब सभी प्रस्तुतियाँ खोली गई हैं, तो राउंड समाप्त होता है, और प्रत्येक खिलाड़ी द्वारा आयोजित वर्तमान का मूल्य उस खिलाड़ी के स्कोर में जोड़ा जाता है। एक नया दौर शुरू होता है, प्रत्येक खिलाड़ी के पास अब कोई मौजूद नहीं होता है और खिलाड़ी का क्रम बदल जाता है।
• गेम एंड : गेम तब खत्म होगा जब कम से कम एक खिलाड़ी ने 100 500 अंक हासिल किए हों, जीत के साथ खिलाड़ी को उच्चतम कुल मूल्य के साथ पुरस्कार प्रदान किए जाएंगे ।

कोडिंग

सभी प्रस्तुतियाँ पायथन 3.7 के साथ संगत होनी चाहिए। आपको एक ऐसा वर्ग लिखना होगा जो सीधे विरासत में मिला हो WhiteElephantBot। उदाहरण के लिए:

class FooBot(WhiteElephantBot):
    # Your implementation here

आप अपने बॉट क्लास में एक __init__विधि (जो एक तर्क लेता है name) प्रदान कर सकते हैं , जिसे कॉल करना होगा super().__init__(name)। आपकी कक्षा take_turnमें इस क्रम में निम्नलिखित तर्कों की अपेक्षा करने की एक विधि होनी चाहिए :

• players: उन खिलाड़ियों के नामों की सूची, बदले में, उन सभी खिलाड़ियों की जो अभी तक प्रस्तुत नहीं हुए हैं।
• presents: एक डिक्शनरी जिसमें खिलाड़ी के नाम के 2-टुपल्स होते हैं, जिसमें उस खिलाड़ी के पास मौजूद मूल्य और वर्तमान में कितनी बार चोरी हुई है। इसमें केवल अन्य खिलाड़ी शामिल होंगे जो वर्तमान में प्रस्तुतियां दे रहे हैं।
• just_stole: यदि अंतिम कार्रवाई एक चोरी थी, तो यह उस खिलाड़ी का नाम होगा जिसने सिर्फ चुराया था। यदि नहीं, तो यह होगा None।

प्रत्येक तर्क अपरिवर्तनीय या एक नई वस्तु होगी ताकि उनमें से किसी को भी म्यूट करने से खेल पर प्रभाव न पड़े। यदि आप चाहें, तो आप किसी भी तर्क की एक प्रति रख सकते हैं।

इसके लिए एक उदाहरण मूल्य presents:

{
    'Alice':   (0.35, 0),
    'Bob':     (0.81, 2),
    'Charlie': (0.57, 1)
}

आपकी take_turnविधि उस खिलाड़ी का नाम वापस करना चाहिए जिसे आप चोरी करना चाहते हैं या Noneवर्तमान को खोलना चाहते हैं। यदि यह अपवाद उठाता है, strया इसके अलावा कुछ और लौटाता है None, या किसी खिलाड़ी का नाम जिसे आप चुरा नहीं सकते हैं, तो आप डिफ़ॉल्ट रूप से एक वर्तमान खोल देंगे।

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

से विरासत में WhiteElephantBot, आपके पास एक ऐसी steal_targetsविधि तक पहुंच होगी जो प्रस्तुतियों को तानाशाही में ले जाएगी और just_stoleउन खिलाड़ियों के नामों की सूची लौटाएगी जिनसे आप चोरी कर सकते हैं।

आपकी लिपि के किसी भी मॉड्यूल को आपकी प्रविष्टि के शीर्ष पर आयात किया जाना चाहिए।

परीक्षण चालक

परीक्षण चालक यहां पाया जा सकता है । आपको from white_elephant import WhiteElephantBotअपने पोस्ट किए गए उत्तर में शामिल करने की आवश्यकता नहीं है , हालांकि एक स्थानीय मॉड्यूल को ऐसा करने की आवश्यकता होगी।

बेसलाइन प्रतियोगी

• रैंडम : एक नया वर्तमान खोलने के लिए या चोरी करने के लिए यादृच्छिक रूप से चुनता है, चोरी के लक्ष्य के साथ समान रूप से बेतरतीब ढंग से चुना जाता है।
• लालची : सबसे मूल्यवान वर्तमान चुरा सकता है जो चोरी हो सकता है। यदि कोई उपहार नहीं चुराया जा सकता है, तो एक वर्तमान खोलें।
• अच्छा : हमेशा एक नया वर्तमान खोलता है। कभी चोरी नहीं करता।

अतिरिक्त नियम

• सभी अपवादों को पकड़ना आपकी जिम्मेदारी है। यदि आपकी कक्षा एक अपवाद को पकड़ने में विफल रहती है, तो उसे अयोग्य घोषित कर दिया जाएगा। इसके अलावा, कृपया KeyboardInterrupts को न पकड़ें।
• खेलों के बीच स्थिति को बचाने में असमर्थता को बायपास करने के लिए फ़ाइलों या अन्य तरीकों का उपयोग न करें। उदाहरण के लिए, आप एक तंत्रिका नेटवर्क स्थिति को एक फ़ाइल मिड-रन में सहेज नहीं सकते हैं।
• आपके बॉट को कक्षा कोड और संबंधित स्थिरांक के भीतर स्व-निहित होना चाहिए।
• आप केवल मानक पुस्तकालय आयात का उपयोग कर सकते हैं।
• प्रदर्शन की कोई सख्त आवश्यकता नहीं है। उचित और विवेकपूर्ण बनें। यदि प्रदर्शन एक मुद्दा बन जाता है, तो मैं समय सीमा जोड़ने का अधिकार सुरक्षित रखता हूं।
• प्रति व्यक्ति एक प्रविष्टि। यदि आप एक से अधिक प्रविष्टि जमा करते हैं, तो आपके बॉट एक साथ काम नहीं कर सकते हैं। मैं अभी प्रति व्यक्ति के लिए कई प्रविष्टियों की अनुमति देने जा रहा हूं, हालांकि बाद में अगर यह एक समस्या बन जाती है तो मैं इसे दोबारा खोल सकता हूं।
• यह एक खुली प्रतियोगिता है जिसमें कोई अलग अंतिम तिथि नहीं है। जब भी महत्वपूर्ण परिवर्तन हुए हैं, मैं किसी भी समय सक्षम हूं।

EDIT1: 100 से 500 तक विजयी स्कोर बदला ताकि रैंकिंग अधिक सुसंगत हो। टेस्ट ड्राइवर में एक नया बगफिक्स होता है और यह जीत के स्कोर में बदलाव को भी दर्शाता है।

EDIT2: आवश्यक आयात पर स्पष्ट नोट।

---

लीडरबोर्ड (अगस्त 8, 2018 के अनुसार)

1. नमूनाबोट (500.093)
2. LastMinuteBot (486.163)
3. रॉबिनहुड (463.160)
4. OddTodd (448.825)
5. GreedyBot (438.520)
6. SecondPlaceBot (430.598)
7. थ्रेसहोल्डबॉट (390.480)
8. जुआरी (313.362)
9. नाइसबोट (275.536)
10. रैंडमबॉट (256.172)
11. गुडसमैन (136.298)

Comments

क्या किसी पंक्ति में चोरी की संख्या हो सकती है? जब मैंने खेला है, आमतौर पर एक पंक्ति या कुछ में 2 चोरी की सीमा होती है, और तीसरे व्यक्ति को एक खोलना होगा। यह एक ही उपहार को प्रति बार एक से अधिक बार चोरी होने से रोकता है।

— mbomb007

@ mbomb007 हां। चेन-चोरी असीमित है, अन्य नियमों को छोड़कर जो चोरी करने के लिए कुछ निश्चित प्रतिरक्षा बनाते हैं: प्रत्येक वर्तमान केवल 3 बार चोरी हो सकता है और आप उस खिलाड़ी से चोरी नहीं कर सकते जो सिर्फ आपसे चोरी करता है।

— बीफस्टर

क्या आप एक वर्तमान चुरा सकते हैं और फिर आपके पास जो मूल है उसे फिर से चुरा सकते हैं?

— आउटगॉल्फ जूल

@EriktheOutgolfer: हाँ, जब तक बीच में एक और मोड़ था। आपके वर्तमान में चोरी होने के तुरंत बाद आप दोबारा चोरी नहीं कर सकते।

— बीफस्टर

यांकी स्वैप !? आगे क्या है, एक साझा जन्मदिन की पार्टी?

— एनजीएम

Answer 1

LastMinuteBot

(कोड के कंकाल के लिए @ मेनमोनिक के लिए बड़े धन्यवाद के साथ, क्योंकि मैं मुश्किल से पायथ को जानता हूं)।

class LastMinuteBot(WhiteElephantBot):
    def take_turn(self, players, presents, just_stole):
        targets = self.steal_targets(presents, just_stole)
        if len(targets) <= 1:
            return None

        target = None

        # If most of the presents are already distributed, try to steal an 
        #  un-restealable gift of high value
        if len(presents) > (len(players) + len(presents)) * 0.75:
            at_threshold = [t for t in targets if presents[t][1]==2 and presents[t][0]>=0.8]
            if at_threshold:
                target = max(at_threshold, key=lambda x: presents[x][0])

        # Otherwise, take the best available
        if not target:
            target = max(targets, key=lambda x: presents[x][0])

        return target if presents[target][0] > 0.5 else None

इस तथ्य का लाभ उठाएं कि उपहारों को तीन बार से अधिक चोरी नहीं किया जा सकता है, यदि आप एक उच्च मूल्य का उपहार पाते हैं, तो तीसरा स्वयं चोरी करें और अधिकांश उपहार खोले गए हैं।

Comments

सरल, अभी तक सुशोभित

— r_j

Answer 2

अजीब टोड

class OddTodd(WhiteElephantBot):
    def take_turn(self, players, presents, just_stole):

        targets = self.steal_targets(presents, just_stole)

        # if none to steal, pick present
        if len(targets) <= 1:
            return None

        # steals the best gift that he can, as long as he's the 1st/3rd steal
        targets = [t for t in targets if presents[t][1] % 2 == 0]
        if targets:
            return max(targets, key=lambda x:presents[x][0])

        else:
            return None

सबसे अच्छा उपहार जो वह कर सकता है चुराता है, लेकिन उपहार चोरी करने के लिए दूसरा व्यक्ति नहीं होना चाहता, क्योंकि अगर यह उससे चोरी हो जाता है तो वह उसे वापस नहीं पा सकता है।

Comments

लाइन 11 पर सिंटैक्स त्रुटि। आपको अपनी सूची समझने ==की बजाय एक की आवश्यकता है =।

— बीफस्टर

तय है, धन्यवाद! अजगर का ज्यादा इस्तेमाल न करें।

— brian_t

Answer 3

SecondPlaceBot

class SecondPlaceBot(WhiteElephantBot):
    def take_turn(self, players, presents, just_stole):
        targets = self.steal_targets(presents, just_stole)
        if len(targets) <= 1:
            return None

        # If most of the presents are already distributed, take the second best.
        if len(presents) > (len(players) + len(presents)) * 0.8:
            target = sorted(targets, key=lambda x: presents[x][0])[-2]
        # Otherwise, take the best and hope someone steals it later.
        else:
            target = max(targets, key=lambda x: presents[x][0])

        return target if presents[target][0] > 0.5 else None

हर कोई सबसे मूल्यवान उपहार के लिए लड़ रहा है। अगला सबसे अच्छा उपहार लगभग अच्छा है, लेकिन चोरी होने की संभावना बहुत कम है।

Answer 4

ThresholdBot

import random

class ThresholdBot(WhiteElephantBot):
    def __init__(self, name):
        self.name = name
        # Choose a minimum value to be happy.
        self.goal = 1 - random.random() ** 2

    def take_turn(self, players, presents, just_stole):
        # Find who has a gift that's sufficiently valuable.
        targets = self.steal_targets(presents, just_stole)
        targets = [x for x in targets if presents[x][0] >= self.goal]
        targets = sorted(targets, key=lambda x: presents[x][0])

        if not targets:
            return None

        # Choose a target (biased toward the best gifts).
        weighted = []
        for i, target in enumerate(targets, 1):
            weighted += [target] * i ** 2
        return random.choice(weighted)

हम वास्तव में सबसे अच्छा उपहार पाने के बारे में परवाह नहीं करते हैं , बस कुछ अच्छा है । जब तक चोरी करने लायक कुछ है, तब तक हम करेंगे।

Answer 5

SampleBot

import random

class SampleBot(WhiteElephantBot):
    def rollout(self, values, counts, just_stole, next_move):
        targets = set()
        move_chosen = False
        for i, (v, n) in enumerate(zip(values, counts)):
            if v and n < 3 and i != just_stole and i != 0:
                targets.add(i)
        for i in range(len(values)):
            if values[i]:
                break
            while True:
                if not targets:
                    break
                if move_chosen:
                    j = max(targets, key=lambda i: values[i])
                    if values[j] < 0.5:
                        break
                else:
                    move_chosen = True
                    if next_move is None:
                        break
                    j = next_move
                values[i] = values[j]
                counts[i] = counts[j] + 1
                values[j] = 0
                counts[j] = 0
                if just_stole is not None and counts[just_stole] < 3:
                    targets.add(just_stole)
                if j in targets:
                    targets.remove(j)
                just_stole = i
                i = j
            values[i] = random.random()
            for player in (just_stole, i):
                if player is not None and values[player] and counts[player] < 3:
                    targets.add(player)
        return values[0]
    def take_turn(self, players, presents, just_stole, n_rollouts=2000):
        names = [self.name] + players + list(presents.keys())
        values = [presents[name][0] if name in presents else None for name in names]
        counts = [presents[name][1] if name in presents else 0 for name in names]
        if just_stole is not None:
            just_stole = names.index(just_stole)
        targets = [None]
        for i, (v, n) in enumerate(zip(values, counts)):
            if v and n < 3 and i != just_stole and i != 0:
                targets.append(i)
        if len(targets) == 1:
            return targets[0]
        scores = [0. for _ in targets]
        n = n_rollouts // len(targets)
        for i, target in enumerate(targets):
            for _ in range(n):
                scores[i] += self.rollout(list(values), list(counts), just_stole, target) / float(n)
        target_index = targets[scores.index(max(scores))]
        if target_index is None:
            return None
        return names[target_index]

लालच से काम करने वाले प्रत्येक खिलाड़ी के साथ 2000 सिमुलेशन चलाता है और सर्वश्रेष्ठ कार्रवाई चुनता है।

Comments

यह बॉट वास्तव में क्या करता है?

— बीफस्टर

@Beefster लालच में काम करने वाले प्रत्येक खिलाड़ी के साथ 2000 यादृच्छिक गेम चलाता है, और उच्चतम औसत अंतिम स्कोर के साथ कदम बढ़ाता है।

— user1502040

नाम त्रुटि। आपको यादृच्छिक आयात करने की आवश्यकता है।

— बीफस्टर

Answer 6

रॉबिन हुड

class RobinHood(WhiteElephantBot):       
    def take_turn(self, players, presents, just_stole):
        #get the possible steal targets
        targets = self.steal_targets(presents, just_stole)
        #who stole his gift?
        targets = [x for x in targets if presents[x][1] > 0]
        #sort by value
        targets = sorted(targets, key=lambda x: presents[x][0])        
        #only steal back if it's worth it        
        targets = [x for x in targets if presents[x][0] > 0.5]

        if len(targets)>0:
           return targets.pop()

अमीर से चोरी करें जो अपना वर्तमान नहीं कमाते थे

Comments

आपके पास एक इंडेंटेशन त्रुटि है।

— बीफस्टर

Answer 7

अच्छा नेक आदमी

class GoodSamaritan(WhiteElephantBot):     
    def take_turn(self, players, presents, just_stole):  
        targets = self.steal_targets(presents, just_stole)

         #if only one player has a gift, don't steal it!
        if len(presents)<=1 or len(targets)==0:
             return None
        else:       
             #Steal the worst present  
             return min(targets, key=lambda x: presents[x][0])

अशुभ लोगों को सौभाग्य में एक और मौका दें

Answer 8

जुआरी

class Gambler(WhiteElephantBot):
    def take_turn(self, players, presents, just_stole):        
        #get the possible steal targets
        targets = self.steal_targets(presents, just_stole)        

        #last player 
        if len(players)==0:
            #lets gamble! Try and get the highest score
            return None

        #If you are not last, steal the best gift that can be restolen so maybe you can become the last player
        targets = [t for t in targets if presents[t][1]<2 ]
        if targets:
            return max(targets, key=lambda x: presents[x][0])   

जुआरी नशे का आदी है, वह अंतिम खिलाड़ी बनने की कोशिश करता है, फिर वह अन्य सभी खिलाड़ियों को हराने के लिए एक नए वर्तमान पर जुआ खेलता है।

Answer 9

Top3Bot

class Top3Bot(WhiteElephantBot):
    def __init__(self, name):
        super().__init__(name)
        self.firstturn = True

    def take_turn(self, players, presents, just_stole):
        if self.firstturn:
            num_presents = len(players) + len(presents) + 1
            self.value_limit = (num_presents - 3) / num_presents
            self.firstturn = False

        targets = self.steal_targets(presents, just_stole)

        if players:
            targets += None

        return max(
            targets,
            key=lambda name: self.steal_ranking(name, presents, len(players))
        )


    def steal_ranking(self, name, presents, presents_remaining):
        if name is None:
            return (0, 0)

        present_value = presents[name][0]
        num_steals = presents[name][1]
        if present_value >= self.value_limit:
            if num_steals == 2:
                return (5, present_value)
            elif  num_steals == 0:
                return (4, -presemt_value)
            elif num_steals == 1 and presents_remaining == 0:
                return (3, -present_value)
            else:
                return (-1, present_value)
        else:
            if num_steals < 2:
                return (2, present_value)
            else:
                return (-2, present_value)

यह बॉट संभव सबसे अच्छा वर्तमान प्राप्त करने की कोशिश नहीं करता है, लेकिन एक ऐसा वर्तमान प्राप्त करने की कोशिश करता है जो मूल्यवान है = = (n-3) / n, जहां n प्रस्तुत करने की संख्या है। ज्यादातर मामलों में, वहाँ बहुत कुछ प्रस्तुत किया जाएगा, और Top3Bot इनमें से किसी एक पर अपने हाथों को प्राप्त करने की कोशिश करेगा, लेकिन वह वास्तव में परवाह नहीं करता है कि उनमें से कौन सा मिलता है।

Comments

आपका __init__अपना selfतर्क याद आ रहा है

— बीफस्टर