दोनों: हर सिक्के के दो पहलू होते हैं

26

अंतिम परिणाम उपलब्ध

परिचय

भारी विषयों ( काल्पनिक युद्ध , दुनिया भर में महामारी ...) के साथ मेरे पिछले KOTH के बाद , मैं एक नए प्रकाशस्तंभ खेल के साथ वापस आ गया हूं। इस बार, आप "बोर्ड गेम जैसी स्थिति" में सामना कर रहे हैं। उल्टा सिक्कों का ढेर वास्तव में एक बड़ी मेज के केंद्र में रखा गया है, और आप लूट का हिस्सा पाने के लिए दृढ़ हैं!

शब्दकोष

सिक्के : ऐसे टोकन जिन्हें या तो फ़्लिप किया जा सकता है या अनफ़्लिप किया जा सकता है।
अनफ्लिप्ड : टेबल पर रखे सिक्के अपने मूल्य के साथ नीचे की ओर इशारा करते हैं। यह सिक्कों की डिफ़ॉल्ट स्थिति है।
फ़्लिप किया गया : टेबल पर अंकित सिक्के उनके मूल्य को इंगित करते हुए।
स्थानीय : आपके सिक्कों के ढेर का संदर्भ देता है।
ग्लोबल : केंद्र में सिक्कों के ढेर को संदर्भित करता है।

सिद्धांत

खेल की शुरुआत में, प्रत्येक खिलाड़ी 0 अंक और 0 सिक्के (फ़्लिप या अनफ़िल्ड) के साथ शुरू होता है । खेल टर्न-आधारित है। अपनी बारी के दौरान, खिलाड़ी टेबल के केंद्र में सिक्कों के ढेर के साथ बातचीत करते हुए 3 कार्रवाई कर सकते हैं, अपने स्वयं के सिक्कों के ढेर या अन्य खिलाड़ियों के साथ।

गेम की शुरुआत में प्ले ऑर्डर को यादृच्छिक रूप से परिभाषित किया गया है। तर्क सूची में खिलाड़ियों का क्रम टर्न ऑर्डर का प्रतिनिधित्व करता है, और यह उस सूची में बाएं से दाएं जाता है। "अगला" और "पिछला" क्रमशः "उस सूची में दाईं ओर" और "उस सूची में बाईं ओर" को एक लूप के साथ संदर्भित करें यदि आप दोनों तरफ से अंतिम हैं।

खेल 50 राउंड तक या एक खिलाड़ी टर्न के अंत में केंद्र में 0 सिक्के होने तक रहता है (जिसका अर्थ है कि आप अपने 3 कार्यों को समाप्त कर देंगे, भले ही ढेर आपकी पहली कार्रवाई के बाद खाली हो, और आप सिक्कों को वापस जाने के लिए रख सकते हैं खेल जारी है)। वैश्विक सिक्कों की प्रारंभिक संख्या को इस सूत्र के साथ यादृच्छिक रूप से परिभाषित किया गया है:

(2 ^ nb_players) + (nb_players * 10) - random(1 + (nb_players ^ 2))`

प्रत्येक क्रिया से आपको अंक मिलेंगे (या आप कुछ खो देंगे) और खेल के अंत में, आपके पास मौजूद प्रत्येक सिक्का आपके बिंदुओं में जोड़ दिया जाएगा ( -1 फ़्लिप के लिए, फ़्लिप के लिए +2 )। उच्चतम स्कोर वाला खिलाड़ी जीतता है।

नियंत्रक आपको कमांड तर्कों के माध्यम से इनपुट प्रदान करता है, और आपके प्रोग्राम को स्टैडआउट के माध्यम से आउटपुट करना होता है।

वाक्य - विन्यास

इनपुट

हर बार जब आपका कार्यक्रम कहा जाता है, तो उसे इस प्रारूप में तर्क प्राप्त होंगे:

Round;YourPlayerId;Coins;PlayerId_Points_Flipped_Unflipped;PlayerId_Points_Flipped_Unflipped;...

सीमा 1-अनुक्रमित हैं।

उदाहरण इनपुट

6;2;52;1_20_3_12;0_-2_0_1;2_12_1_0

यहां, आप देखते हैं कि यह 6 वां दौर है और आप खिलाड़ी हैं। केंद्रीय ढेर में 52 सिक्के हैं। आपके पास 12 अंक, 1 फ़्लिप्ड सिक्का और 0 अनफ़िल्ड सिक्का है। अंक नकारात्मक हो सकते हैं।

उत्पादन

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

N: कुछ भी न करें
1: केंद्रीय ढेर से 1 सिक्का लें [प्रभाव: +1 स्थानीय अनफ़्लेप्ड / -1 पॉइंट / -1 ग्लोबल अनफ़्लेप्ड]
2 : केंद्रीय ढेर से 2 सिक्के लें। प्रभाव: +2 स्थानीय अनफ़िल्टर्ड / -2 अंक / -2 ग्लोबल अनफ्लिप्ड]
3 : केंद्रीय ढेर से 3 सिक्के लें। प्रभाव: +3 स्थानीय अनफ़्लेप्ड / -3 अंक / -3 वैश्विक अनफ़िल्ड किए गए]
A : अपने ढेर से 1 सिक्का वापस रखें [प्रभाव: -1 स्थानीय अनफ़्लेप्ड / +1 पॉइंट / +1 वैश्विक अप्रकाशित]
B : अपने ढेर से 2 सिक्के वापस रखें [प्रभाव: -2 स्थानीय unflipped / +2 अंक / +2 वैश्विक unflipped]
C : अपने ढेर से 3 सिक्के वापस रखें [प्रभाव: -3 स्थानीय unflipped / +3 अंक +3] वैश्विक स्तरहीन]
X : अपने ढेर से 1 सिक्का निकालें[प्रभाव: -1 स्थानीय अप्रकाशित / ० बिंदु]
Y : अपने ढेर से २ सिक्के निकालें [प्रभाव: -२ स्थानीय अप्रभावित / ० बिंदु]
Z : अपने ढेर से ३ सिक्के निकालें [प्रभाव: -३ स्थानीय अनफ़ल्टेड / ० बिंदु]
R : सिक्कों को घुमाएँ पिछले खिलाड़ी के लिए [प्रभाव: -1 बिना अंक प्राप्त किए गए प्रति अंक, फ़्लिप प्राप्त किए गए प्रति +2 अंक / सभी खिलाड़ियों पर लागू होते हैं]
T : अगले खिलाड़ी को सिक्के घुमाएँ [प्रभाव: -1 मिले हुए प्रतिफल प्राप्त हुए, प्रति फ़्लिप प्राप्त किए गए प्रति +2 अंक सभी खिलाड़ी]
F : फ्लिप 1 का सिक्का [प्रभाव: -1 स्थानीय अनफ़्लेप्ड / +1 लोकल फ़्लिप / +2 पॉइंट]
U : अनलिफ़िप 1 सिक्का [प्रभाव: +1 स्थानीय अनफ़्लेप्ड / -1 स्थानीय फ़्लिप / -2 पॉइंट]

उदाहरण आउटपुट

2FF : दो सिक्के लेता है और दो सिक्के फड़फड़ाता है -2 + 2 + 2 = 2 points

यदि आपका आउटपुट गलत है, तो नियंत्रक मान जाएगा NNN।

नियंत्रक

आप GitHub पर नियंत्रक पा सकते हैं । इसमें दो सैंपलबॉट भी शामिल हैं, जो जावा में लिखे गए हैं। इसे चलाने के लिए, प्रोजेक्ट देखें और इसे अपने जावा आईडीई में खोलें। mainकक्षा की विधि में प्रवेश बिंदु Game। जावा 8 की आवश्यकता है।

बॉट्स जोड़ने के लिए, पहले आपको जावा (.class फ़ाइलों) के लिए संकलित संस्करण या व्याख्या की गई भाषाओं के स्रोतों की आवश्यकता होगी। उन्हें प्रोजेक्ट के रूट फ़ोल्डर में रखें। फिर, playersपैकेज में एक नया जावा वर्ग बनाएं (आप पहले से मौजूद बॉट्स पर उदाहरण ले सकते हैं)। इस वर्ग को Playerविधि को ओवरराइड करने के लिए लागू करना चाहिए String getCmd()। लौटाई गई स्ट्रिंग आपके बॉट्स को चलाने के लिए शेल कमांड है। आप उदाहरण के लिए इस आदेश के साथ रूबी बॉट काम कर सकते हैं return "C:\Ruby\bin\ruby.exe MyBot.rb";:। अंत में, Gameवर्ग के शीर्ष पर खिलाड़ियों के सरणी में बॉट जोड़ें ।

नियम

  • बॉट को विशिष्ट अन्य बॉट को हरा या समर्थन करने के लिए नहीं लिखा जाना चाहिए।
  • फाइलों को लिखने की अनुमति है। कृपया "yoursubmissionname.txt" पर लिखें, गेम शुरू होने से पहले फ़ोल्डर खाली कर दिया जाएगा। अन्य बाहरी संसाधन अस्वीकृत हैं।
  • आपके सबमिशन का जवाब देने के लिए 1 सेकंड है।
  • अपने सबमिशन को संकलित करने और चलाने के लिए कमांड प्रदान करें।

समर्थित भाषाएँ

मैं हर भाषा का प्रयास और समर्थन करूंगा, लेकिन इसे मुफ्त में ऑनलाइन उपलब्ध होना चाहिए। यदि आप "मुख्यधारा" भाषा का उपयोग नहीं कर रहे हैं तो कृपया स्थापना के लिए निर्देश प्रदान करें।

फिलहाल, मैं चला सकता हूं: जावा 6-7-8, पीएचपी, रूबी, पर्ल, पायथन 2-3, लुआ, आर, नोड.जेएस, हास्केल, कोटलिन, सी ++ 11।

अंतिम परिणाम

ये 100 गेम के परिणाम हैं (अंक जोड़े गए हैं):

1. BirdInTheHand: 1017790
2. Balance: 851428
3. SecondBest: 802316
4. Crook: 739080
5. Jim: 723440
6. Flipper: 613290
7. Wheeler: 585516
8. Oracle: 574916
9. SimpleBot: 543665
10. TraderBot: 538160
11. EgoisticalBot: 529567
12. RememberMe: 497513
13. PassiveBot: 494441
14. TheJanitor: 474069
15. GreedyRotation: 447057
16. Devil: 79212
17. Saboteur: 62240

खेलों के अलग-अलग परिणाम यहां उपलब्ध हैं: http://pasted.co/63f1e924 (शुरुआती सिक्के और प्रति गेम राउंड की संख्या)।

विजेता को 50 प्रतिष्ठा का पुरस्कार दिया जाता है: मार्टिन ब्यूटनर द्वारा बर्ड इन द हैंड ।

अपनी भागीदारी के लिए आप सभी का धन्यवाद, आपको अगला KOTH ~ दिखाई देगा

king-of-the-hill 
— Thrax
स्रोत
1
" प्रभाव: -1 स्थानीय अनफ़्लेप्ड / +1 स्थानीय फ़्लिप / +2 बिंदु " मुझे गलत लगता है। क्या यह +3 अंक नहीं होना चाहिए, क्योंकि आप फ़्लिप किए गए सिक्के के लिए -1 से अनफ़िल्टर्ड सिक्के +2 तक चले गए हैं?
— पीटर टेलर
1
@PeterTaylor मुझे लगता है कि अंक सिक्कों से स्वतंत्र हैं। प्रत्येक क्रिया प्राप्त या खोए गए कई बिंदुओं से जुड़ी होती है और ये उन बिंदुओं से स्वतंत्र होते हैं जो आपको वास्तव में खेल के अंत में सिक्कों के लिए मिलते हैं।
— मार्टिन एंडर
आप सिक्कों का उल्लेख उनके "मूल्य" से करते हैं जो ऊपर या नीचे की ओर इशारा करते हैं। इन मूल्यों का क्या उपयोग किया जाता है? क्या सिक्के अलग-अलग हैं?
— user2357112
@PeterTaylor जैसा कि मार्टिन बंटनर ने कहा, आपको कार्रवाई के लिए सिक्के मिलते हैं (इस मामले में + फ़्लिपिंग के लिए) और आपको अंत में सिक्के होने के लिए अंक भी मिलते हैं (इस मामले में प्रत्येक फ़्लिप के लिए +2)।
— थ्रक्स
क्या आईडी शून्य-आधारित या एक-आधारित है?
— फ्रेडरिक

जवाबों:

12

बर्ड इन द हैंड, रूबी

def deep_copy(o)
  Marshal.load(Marshal.dump(o))
end

ID = 0
PTS = 1
FLP = 2
UFL = 3

round, id, global, *players = ARGV[0].split(';')
round = round.to_i
id = id.to_i
global = global.to_i

players.map!{ |s| s.split('_').map(&:to_i) }

nplayers = players.size

my_pos = players.find_index { |i, p, f, u| i == id }

state = {
    round: round,
    id: id,
    global: global,
    players: players,
    my_pos: my_pos,
    me: players[my_pos],
    prev_p: players[my_pos-1],
    next_p: players[(my_pos+1)%nplayers],
    ends_game: round == 50 && my_pos == nplayers-1,
    score: 0
}

moves = {
    'N' => ->s{deep_copy(s)},
    '1' => ->s{t = deep_copy(s); coins = [1, t[:global]].min; t[:global] -= coins; t[:me][UFL] += coins; t[:score] -= coins; t},
    '2' => ->s{t = deep_copy(s); coins = [2, t[:global]].min; t[:global] -= coins; t[:me][UFL] += coins; t[:score] -= coins; t},
    '3' => ->s{t = deep_copy(s); coins = [3, t[:global]].min; t[:global] -= coins; t[:me][UFL] += coins; t[:score] -= coins; t},
    'A' => ->s{t = deep_copy(s); coins = [1, t[:me][UFL]].min; t[:global] += coins; t[:me][UFL] -= coins; t[:score] += coins; t},
    'B' => ->s{t = deep_copy(s); coins = [2, t[:me][UFL]].min; t[:global] += coins; t[:me][UFL] -= coins; t[:score] += coins; t},
    'C' => ->s{t = deep_copy(s); coins = [3, t[:me][UFL]].min; t[:global] += coins; t[:me][UFL] -= coins; t[:score] += coins; t},
    'X' => ->s{t = deep_copy(s); coins = [1, t[:me][UFL]].min; t[:me][UFL] -= coins; t},
    'Y' => ->s{t = deep_copy(s); coins = [2, t[:me][UFL]].min; t[:me][UFL] -= coins; t},
    'Z' => ->s{t = deep_copy(s); coins = [3, t[:me][UFL]].min; t[:me][UFL] -= coins; t},
    'F' => ->s{t = deep_copy(s); coins = [1, t[:me][UFL]].min; t[:me][UFL] -= coins; t[:me][FLP] += coins; t[:score] += 2*coins; t},
    'U' => ->s{t = deep_copy(s); coins = [1, t[:me][FLP]].min; t[:me][FLP] -= coins; t[:me][UFL] += coins; t[:score] -= 2*coins; t},
    'R' => ->s{
        t = deep_copy(s)
        (-1...t[:players].size-1).each do |i|
            t[:players][i][FLP] = s[:players][i+1][FLP]
            t[:players][i][UFL] = s[:players][i+1][UFL]
        end
        t[:score] += 2*t[:me][FLP] - t[:me][UFL];
        t
    },
    'T' => ->s{
        t = deep_copy(s)
        (0...t[:players].size).each do |i|
            t[:players][i][FLP] = s[:players][i-1][FLP]
            t[:players][i][UFL] = s[:players][i-1][UFL]
        end
        t[:score] += 2*t[:me][FLP] - t[:me][UFL];
        t
    }
}


results = {}

'N123ABCXYZFURT'.each_char { |c1| 
    s1 = moves[c1][state]
    'N123ABCXYZFURT'.each_char { |c2| 
        s2 = moves[c2][s1]
        'N123ABCXYZFURT'.each_char { |c3| 
            s3 = moves[c3][s2]
            s3[:ends_game] ||= s3[:global] == 0
            results[c1+c2+c3] = s3
        }
    }
}

endingMoves = results.keys.select{|k| results[k][:ends_game]}

endingMoves.each{|k| results[k][:score] += 2*results[k][:me][FLP] - results[k][:me][UFL]}

$> << results.keys.shuffle.max_by {|k| results[k][:score]}

यदि हम में से किसी के पास अपने कार्यक्रमों में बग नहीं है, तो इसका मुख्य एल्गोरिथ्म संभवतः माथियास ऑरेकल के समान है। इस धारणा के आधार पर कि अंतिम दौर से पहले हम यह नहीं जान सकते कि हम किन सिक्कों के साथ समाप्त होंगे, हम तुरंत प्राप्त अंकों के आधार पर चालों के वर्तमान सेट का मूल्यांकन करते हैं, पूरी तरह से अनदेखा करते हुए कि हम किस तरह के सिक्कों को समाप्त करेंगे। साथ में। चूंकि केवल 14 3 = 2744 संभव कदम सेट हैं हम आसानी से उन सभी का अनुकरण कर सकते हैं कि वे कितने अंक लाएंगे।

हालाँकि, अगर कोई चाल सेट खेल को समाप्त करता है (या तो क्योंकि यह वैश्विक पॉट को शून्य तक कम कर देता है, या क्योंकि यह 50 का दौर है और हम इसे स्थानांतरित करने के लिए अंतिम हैं), तो यह भी सिक्कों के अंत में खाते में आता है। चाल सेट के मूल्य को निर्धारित करने के लिए चाल सेट। जब भी संभव हो, मैंने पहले खेल को समाप्त करने पर विचार किया, लेकिन इससे भयानक कदम होगा 333जब बर्तन में केवल 9 सिक्के बचे हैं।

यदि एक ही परिणाम देने वाले कई मूव सेट हैं, तो हम एक यादृच्छिक एक चुनते हैं। (मैं इसे खेल समाप्ति चाल सेट के पक्ष में पूर्वाग्रह में बदल सकता हूं।)

— मार्टिन एंडर
स्रोत
17

ओरेकल, पायथन 3

अद्यतन: विभिन्न प्रयासों के क्रम में घुमावों पर सिक्कों के कम ढेर का पक्ष लेने की कोशिश की।

import sys
import itertools
from copy import deepcopy


MOVES_REQUIRED = 3

FLIPPED = 0
UNFLIPPED = 1


def filter_neighbors(neighbors, me, size):
    limit = size - MOVES_REQUIRED
    for data in neighbors:
        i, _, flipped, unflipped = map(int, data.split('_'))
        if MOVES_REQUIRED < (me - i) % size < limit:
            continue  # Skip neighbors that are too far away
        yield i, [flipped, unflipped]


class Player:
    def __init__(self, raw_data):
        _, me, coins, *data = raw_data.split(';')

        self.num_players = len(data)
        self._me = int(me)
        self._coins = int(coins)
        self._state = dict(filter_neighbors(data, self._me, self.num_players))

    def reset(self):
        self.me = self._me
        self.coins = self._coins
        self.state = deepcopy(self._state)
        self.my_state = self.state[self.me]

    def invalid_move(self, move):
        if move in 'NRT':
            return False

        if move in '123'[:self.coins]:
            return False

        flipped, unflipped = self.my_state
        if flipped and move == 'U':
            return False
        if unflipped and move == 'F':
            return False

        if move in 'AXBYCZ'[:2 * unflipped]:
            return False

        return True

    def N(self):
        return 0

    def one(self):
        self.coins -= 1
        self.my_state[UNFLIPPED] += 1
        return -1

    def two(self):
        self.coins -= 2
        self.my_state[UNFLIPPED] += 2
        return -2

    def three(self):
        self.coins -= 3
        self.my_state[UNFLIPPED] += 3
        return -3

    def A(self):
        self.coins += 1
        self.my_state[UNFLIPPED] -= 1
        return 1

    def B(self):
        self.coins += 2
        self.my_state[UNFLIPPED] -= 2
        return 2

    def C(self):
        self.coins += 3
        self.my_state[UNFLIPPED] -= 3
        return 3

    def X(self):
        self.my_state[UNFLIPPED] -= 1
        return 0

    def Y(self):
        self.my_state[UNFLIPPED] -= 2
        return 0

    def Z(self):
        self.my_state[UNFLIPPED] -= 3
        return 0

    def R(self):
        self.me = (self.me + 1) % self.num_players
        flipped, unflipped = self.my_state = self.state[self.me]
        return 2 * flipped - unflipped

    def T(self):
        self.me = (self.me - 1) % self.num_players
        flipped, unflipped = self.my_state = self.state[self.me]
        return 2 * flipped - unflipped

    def F(self):
        self.my_state[FLIPPED] += 1
        self.my_state[UNFLIPPED] -= 1
        return 2

    def U(self):
        self.my_state[FLIPPED] -= 1
        self.my_state[UNFLIPPED] += 1
        return -2

setattr(Player, '1', Player.one)
setattr(Player, '2', Player.two)
setattr(Player, '3', Player.three)


def scenarii(player):
    for tries in itertools.product('FUABCXYZ123NRT', repeat=MOVES_REQUIRED):
        player.reset()
        points = 0
        for try_ in tries:
            if player.invalid_move(try_):
                break
            points += getattr(player, try_)()
        else:
            yield points, ''.join(tries)


if __name__ == '__main__':
    player = Player(sys.argv[1])
    print(max(scenarii(player))[1])

हर एक संभव उत्पादन की कोशिश करता है और एक है कि इस मोड़ के लिए अंक की अधिकतम राशि उपज रखो।

— 409_Conflict
स्रोत
आह, मैं इसे लागू करने वाला था, +1। :) (मैं अभी भी हो सकता है वास्तव में, क्योंकि मैं इस सुधार करने के लिए एक या दो छोटे विचारों था थोड़ा ।)
— मार्टिन Ender
@ मार्टिनबटनर ने deepcopyकेवल प्रासंगिक पड़ोसियों को रखकर अंतरिक्ष में सुधार (इस प्रकार [ ]] जटिलता के बारे में सोचा । हालांकि यह सुनिश्चित नहीं है कि यह चीजों को कैसे प्रभावित करेगा।
— 409_कॉन्फ्लिक्ट
@ थ्रैक्स मैंने प्रश्न में स्पष्टीकरण के लिए एक बग को निर्धारित किया filter_neighborsऔर संशोधित invalid_moveकिया। : मैं त्रुटि पुन: पेश कर सकते हैं नहीं है, हालांकि $ python oracle.py '4;7;2040;8_-28_1_10;9_-43_0_9;2_-10_4_3;6_-24_6_3;0_6_2_12;1_48_3_0;10_21_4_8;5_6_5_1;4_-12_3_7;7_10_1_3;3_1_1_0'प्रिंटTTR
— 409_Conflict
7

लालची रोटेशन, रूबी

round, id, global, *players = ARGV[0].split(';')
round = round.to_i
id = id.to_i
global = global.to_i

players.map!{ |s| s.split('_').map(&:to_i) }

nplayers = players.size

my_pos = players.find_index { |i, p, f, u| i == id }

prev_p = players[my_pos-1]
next_p = players[(my_pos+1)%nplayers]

prev_score = 2*prev_p[2] - prev_p[3]
next_score = 2*next_p[2] - next_p[3]

take_from = prev_p

$><< '3'
if prev_score > next_score || prev_score == next_score && prev_p[3] > next_p[3]
    $><< 'T'
else
    $><< 'R'
    take_from = next_p
end

if take_from[3] >= 3
    $><< 'C'
elsif take_from[3] >= 1
    $><< 'F'
else
    $><< 'N'
end

यह ArtOfCode के दृष्टिकोण से काफी मिलता-जुलता है, सिवाय इसके कि यह जाँच करता है कि किस पड़ोसी से हमें अधिक अंक मिल सकते हैं, और यह Cइसके बजाय चुनता है कि Fक्या हम रोटेशन के बाद 3 या अधिक सिक्कों के साथ समाप्त होते हैं।

इसे लिखने के बाद, मुझे पूरा यकीन है कि एक बेहतर तरीका यह होगा कि हर बार हर कदम पर सबसे बेहतर तरीके से लालच दिया जाए, अगर संभव हो तो रोटेशन को पूर्ववर्ती कर लें (इसके बजाय एक निश्चित तरीके से चिपके रहने के बजाय) अनफिल्टर्ड, घुमाएं, छुटकारा पाएं बेवजह "पैटर्न"।

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

— मार्टिन एंडर
स्रोत
@MegaTom वूप्स, कि पकड़ने के लिए धन्यवाद।
— मार्टिन एंडर
6

फ्लिपर, पायथन 2

फ्लिपर सिक्कों को इकट्ठा करता है और फ़्लिप किए गए फ़्लिप करने की कोशिश करता है। फ्लिपर स्मार्ट खिलाड़ी नहीं है, लेकिन खेल में एक सकारात्मक शक्ति बनने की कोशिश करता है।

import sys, random

# process input data (not used here):
args = sys.argv[1].split(';')
rounds, myid, coins = map(int, args[:3])
players = [map(int, data.split('_')) for data in args[3:]]

# implement strategy using multiples of 'N123ABCXYZRTFU':
options = '12333FFFFFFFFFFF'
print ''.join(random.choice(options) for i in range(3))

फ्लिपर को बस python flipper.py <arg>चलाने की जरूरत है ।

— तर्क नाइट
स्रोत
5

सिंपलबोट, पायथन 3

SimpleBot, अच्छी तरह से, सरल है। उन्होंने एक रणनीति बनाई है और वह इसके साथ रहना चाहते हैं।

चलाने के लिए:

python3 main.py

जहां main.pyफ़ाइल की सामग्री है:

def main():
    print("3RF")


if __name__ == "__main__":
    main()
— ArtOfCode
स्रोत
5

शेष, लुआ

संतुलन अपने टोकन में संतुलन रखने की कोशिश करेगा, यदि कोई व्यक्ति उसके खिलाफ कार्रवाई करता है Rऔर Tउसके खिलाफ कार्रवाई कम करता है। वह सोचता है कि जीवन की यह शैली सही है और इसे किसी को भी लागू करना चाहिए जो फ़्लिप / अनफ़िल्ड किए गए सिक्कों का एक अच्छा संतुलन नहीं रखता है, इसलिए उसके करीब सभी को जल्द से जल्द दंडित किया जाएगा क्योंकि यह उन्हें अंक खो सकता है।

उसे चलाने के लिए निम्न आदेश की आवश्यकता है:

lua balance.lua

जहां फ़ाइल शेष राशि। Lua में निम्नलिखित कोड कोड है:

local datas={}
local arg=arg[1]..";"

-- parse the arguments
-- add some meta datas for debuging purpose/usefulness
arg:gsub("(.-);",function(c)
  if not datas.round
  then
    datas.round=c+0
  elseif not datas.myID
  then
    datas.myID=c+0
  elseif not datas.coins
  then
    datas.coins=c+0
  else
    datas[#datas+1]={}
    datas[#datas].repr=c
    c=c.."_"
    tmp={}
    c:gsub("(.-)_",function(d) tmp[#tmp+1]=d end)
    datas[#datas].id=tmp[1]+0
    datas[#datas].points=tmp[2]+0
    datas[#datas].flip=tmp[3]+0
    datas[#datas].unflip=tmp[4]+0
    if datas[#datas].id==datas.myID
    then
      datas.myOrder=#datas
      datas.myDatas=datas[#datas]
    end
  end
end)

local actions=""
-- construct actions
for i=1,3
do
  -- if we aren't in balance and can grab more coins
  -- we do it
  if #actions==0 and datas.myDatas.unflip<=datas.myDatas.flip/2 and datas.coins>=3
  then
    actions=actions.."3"
    datas.myDatas.unflip=datas.myDatas.unflip+3
    datas.coins=datas.coins-3
  -- if we couldn't grab coins, but aren't in balance, we flip some coins
  elseif datas.myDatas.unflip>datas.myDatas.flip/2
  then
    actions=actions.."F"
    datas.myDatas.unflip=datas.myDatas.unflip-1
    datas.myDatas.flip=datas.myDatas.flip+1

  -- if we didn't have anything to do on our pile, let's punish
  -- the fools who doesn't follow the great Balance principle
  else
    previous=datas.myOrder<2 and #datas or datas.myOrder-1
    following=datas.myOrder>=#datas and 1 or datas.myOrder+1

    lossPrev=-datas[previous].flip + 2*datas[previous].unflip
    lossFoll=-datas[following].flip+ 2*datas[following].unflip
    if lossFoll>0 and lossPrev>0
    then
      actions =actions.."N"
    elseif lossFoll>=lossPrev
    then
      actions=actions.."T"
      datas[following].unflip,datas[following].flip=datas[following].flip,datas[following].unflip
    else
      actions=actions.."R"
      datas[previous].unflip,datas[previous].flip=datas[previous].flip,datas[previous].unflip
    end
  end
end
print(actions)
— Katenkyo
स्रोत
@ थ्रैक्स धन्यवाद, निश्चित। इस लाइन के लिए 1-अनुक्रमित मानों पर काम करना भूल गए ...
— काटेंको
4

द जैनीटर, पायथन 3

वह इन सभी सिक्कों के साथ अन्य खिलाड़ियों द्वारा बनाई गई गंदगी को साफ करने और उन्हें वापस पूल में डालने की कोशिश करता है।

import sys;
def Parse(S):
    T = S.split(';');
    me = eval(T[1]);
    N = len(T)-3;
    A = list(map(lambda x: list(map(lambda y:int(y),T[3+((2*N+x+me)%N)].split('_'))),range(-3,4)));    
    Dic = {}
    for a in A:
        Dic[a[0]] = a[1:];
    Dic[-1] = [me];
    return Dic;
def Recursive(Dic,me,D):
    if D==3: return '';
    V = Dic[me];
    N = max(Dic.keys());
    Next = (me+1)%N;
    Prev = (N+1+me)%N;
    for i in range(3,0,-1):
        if V[2]>=i:
            Dic[me][2] = Dic[me][2]-i;
            return chr((i-1)+ord('A'))+Recursive(Dic,me,D+1);
    if V[1]>0:
        Dic[me][1] = Dic[me][1]-1;
        Dic[me][2] = Dic[me][2]+1;
        return 'U'+Recursive(Dic,me,D+1);
    if Dic[Next][2]>Dic[Prev][2]:
        return 'T'+Recursive(Dic,Next,D+1);
    return 'R'+Recursive(Dic,Prev,D+1);
Dic = Parse(sys.argv[1]);
me = Dic[-1][0];
print(Recursive(Dic,me,0));

वह अपने सभी अनफिल्ड सिक्कों को वापस देने की कोशिश करता है, अगर उसके पास कुछ फंसे हुए सिक्के हैं तो वह उन्हें वापस ले लेगा और अगर वह अपने सभी सिक्कों से छुटकारा पा लेता है तो उसे किसी और का मिलेगा।

— Lause
स्रोत
3

बदमाश, आर

args <- strsplit(commandArgs(TRUE),";")[[1]]
state <- as.data.frame(do.call(rbind,strsplit(args[-(1:3)],"_")), stringsAsFactors=FALSE)
colnames(state) <- c("id","pts","flipped","unflipped")
state$flipped <- as.integer(state$flipped)
state$unflipped <- as.integer(state$unflipped)
nb <- nrow(state)
score <- function(place) 2*state$flipped[place]-state$unflipped[place]
my_place <- which(state$id==args[2])
next_1 <- ifelse(my_place!=nb,my_place+1,1)
next_2 <- ifelse(next_1!=nb,next_1+1,1)
next_3 <- ifelse(next_2!=nb,next_2+1,1)
previous_1 <- ifelse(my_place!=1,my_place-1,nb)
previous_2 <- ifelse(previous_1!=1,previous_1-1,nb)
previous_3 <- ifelse(previous_2!=1,previous_2-1,nb)
n <- 3
out <- c()
while(n){
    M <- N <- score(my_place)
    R <- switch(n,"1"=score(next_1),
                "2"=cumsum(c(score(next_1),score(next_2))),
                "3"=cumsum(c(score(next_1),score(next_2),score(next_3))))
    P <- switch(n,"1"=score(previous_1),
                "2"=cumsum(c(score(previous_1),score(previous_2))),
                "3"=cumsum(c(score(previous_1),score(previous_2),score(previous_3))))
    M <- c(M,M+R[-n])
    N <- c(N,N+P[-n])
    if(any(R>M & R>0)){
        action <- c("R","RR","RRR")[which.max(R-M)]
        out <- c(out, action)
        state[,3:4] <- state[c((nchar(action)+1):nb,seq_len(nchar(action))),3:4]
        n <- n-nchar(action)
    }else if(any(P>N & P>0)){
        action <- c("T","TT","TTT")[which.max(P-N)]
        out <- c(out, action)
        state[,3:4] <- state[c((nb+1-seq_len(nchar(action))),1:(nb-seq_len(nchar(action)))),3:4]
        n <- n-nchar(action)
    }else if(n>1 & all(R[1]+M[1]>c(0,P[1]+M[1],R[1]+R[2]))){
        out <- c(out,"RT")
        n <- n-2
    }else if(n>1 & all(P[1]+M[1]>c(0,R[1]+M[1],P[1]+P[2]))){
        out <- c(out,"TR")
        n <- n-2
    }else{
        out <- c(out, switch(n,"1"="A","2"="1F","3"="2FF"))
        n <- 0
        }
    }
cat(paste(out,collapse=""))

चलाने के लिए: Rscript Crook.R

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

संपादित करें: मैंने इस बॉट में थोड़ी गहराई जोड़कर इसे अगले अगले और पिछले 2 और 3 खिलाड़ी स्टैक की जांच करने के बजाय केवल अगले एक की जांच की और अगर, कुल मिलाकर, तो यह कई बार घूमने के लिए फायदेमंद है।

2 संपादित करें : @ मार्टिनबटनर के विचार के बाद, बॉट अब एक "आरटी", या "टीआर" करता है, अगर यह उसके पड़ोसियों के लिए उससे अधिक फायदेमंद होगा (अगर मैंने इसे लागू करने में कोई गड़बड़ नहीं की तो :))।

— plannapus
स्रोत
अपने संपादित करें: यदि आपके बगल वाले लड़के के पास एक टन फंसे हुए सिक्के हैं, RTRतो यह करना भी सबसे अच्छा हो सकता है, ताकि आप उसके सिक्कों से दो बार स्कोर प्राप्त कर सकें।
— मार्टिन एंडर
सच। हालांकि यह पड़ोसियों में से एक को भी देगा जो एक बार स्कोर करेगा। लेकिन मैं वास्तव में इसके बारे में सोचूंगा, यह निश्चित रूप से पता लगाने के लिए एक विचार है।
— प्लेनैपस
@ मार्टिनबटनर ओके अंत में मुझे बॉट की भावना रखते हुए इसे लागू करने का एक तरीका मिला। सलाह के लिये धन्यवाद!
— प्लेनैपस
@thrax बस इतना है कि आप अगले गेम को चलाने के दौरान मेरे बॉट को अपडेट करना नहीं भूलेंगे, मैंने सोचा कि मुझे आपको चेतावनी देनी चाहिए कि आपके गितुब रेपो में मेरे बॉट का संस्करण एक पुराना है।
— प्लेनैपस
3

जिम, रूबी

मार्टिन ब्यूटनर के लालची रोटेशन पर आधारित है ।

PlayerId = 0
Points = 1
Flipped = 2
Unflipped = 3

round, id, global, *players = ARGV[0].split(';')
round = round.to_i
id = id.to_i
global = global.to_i

if(round == 1)
    print '3FF'
    exit
end

players.map!{ |s| s.split('_').map(&:to_i) }

nplayers = players.size

my_pos = players.find_index { |a| a[PlayerId] == id }

coin_vals = players.map{|a| a[Flipped]*2 - a[Unflipped]}

move = [-1,1].max_by{|s|
    swap_gain = coin_vals.rotate(s)
    scores = (0...nplayers).map{|i|
        swap_gain[i]+players[i][Points]
    }
    scores.delete_at(my_pos)-scores.max
}
if move == 1
    print 'R'
else
    print 'T'
end

print ['1F', 'FF'][rand 2]

एक तरह से या दूसरे को घुमाएगा, इस पर निर्भर करता है कि उसे सर्वश्रेष्ठ अन्य खिलाड़ी की तुलना में सबसे अधिक अंक क्या देगा। फिर, वह त्वरित नकदी के लिए फ़्लिप करता है।

— MegaTom
स्रोत
2

TraderBot

यह बॉट तब भी घूमने की कोशिश करता है जब भी वह ऐसा होता है जो उस क्रिया में सबसे अधिक अंक लेता है। यदि यह घूम नहीं सकता है, तो अप्रभावित सिक्कों से छुटकारा पाने की कोशिश करता है या निम्नलिखित कार्यों में उन्हें बदलने के लिए कुछ और ले सकता है।

import java.util.ArrayList;

आयात java.util.ist;

सार्वजनिक वर्ग TraderBot {

class Player{
    private int id;
    private int points;
    private int flip;
    private int unflip;

    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public int getPoints() {
        return points;
    }
    public void setPoints(int points) {
        this.points = points;
    }
    public int getFlip() {
        return flip;
    }
    public void setFlip(int flip) {
        this.flip = flip;
    }
    public int getUnflip() {
        return unflip;
    }
    public void setUnflip(int unflip) {
        this.unflip = unflip;
    }


}

int round;
int coins;
int otherMaxPoints = 0;
Player myself = new Player();
List<Player> players = new ArrayList<>();

public static void main (String[] s){
    new TraderBot().play(s);
}

private void play(String[] s){
    parse(s[0]);
    System.out.println(action() + action() + action());
}

private int simRotateNext(){
    int flip, unflip;
    int maxP = Integer.MIN_VALUE;
    int myP = 0;
    for (int i = 0; i < players.size(); i++){
        flip = players.get(i).getFlip();
        unflip = players.get(i).getUnflip();
        int next = i + 1 <= players.size() - 1 ? i + 1 : 0;
        int p = 2 * flip - unflip;
        if (p > maxP && players.get(next).getId() != myself.getId()){
            maxP = p;
        } else if (players.get(next).getId() == myself.getId()){
            myP = p;
        }

    }
    return  myP - maxP;
}

private int simRotatePrev(){
    int flip, unflip;
    int maxP = Integer.MIN_VALUE;
    int myP = 0;
    for (int i = players.size() -1; i > 0; i--){
        flip = players.get(i).getFlip();
        unflip = players.get(i).getUnflip();
        int prev = i - 1 >= 0 ? i - 1 : players.size() - 1;
        int p = 2 * flip - unflip;
        if (p > maxP && players.get(prev).getId() != myself.getId()){
            maxP = p;
        } else if (players.get(prev).getId() == myself.getId()){
            myP = p;
        }
    }
    return  myP - maxP;
}

private int rotateNext(){
    int flip, unflip, nflip, nunflip;
    flip = players.get(0).getFlip();
    unflip = players.get(0).getUnflip();
    for (int i = 0; i < players.size(); i++){
        int next = i + 1 <= players.size() - 1 ? i + 1 : 0;
        nflip = players.get(next).getFlip();
        nunflip = players.get(next).getUnflip();
        players.get(next).setFlip(flip);
        players.get(next).setUnflip(unflip);
        players.get(next).setPoints(players.get(next).getPoints() + 2 * flip - unflip);
        flip = nflip;
        unflip = nunflip;
    }
    return myself.getPoints();
}

private int rotatePrev(){
    int flip, unflip,  nflip, nunflip;
    flip = players.get(players.size() -1).getFlip();
    unflip = players.get(players.size() -1).getUnflip();
    for (int i = players.size() -1; i > 0; i--){
        int prev = i - 1 >= 0 ? i - 1 : players.size() - 1;
        nflip = players.get(prev).getFlip();
        nunflip = players.get(prev).getUnflip();
        players.get(prev).setFlip(flip);
        players.get(prev).setUnflip(unflip);
        players.get(prev).setPoints(players.get(prev).getPoints() + 2 * flip - unflip);
        flip = nflip;
        unflip = nunflip;
    }
    return myself.getPoints();
}

private String action() {
    int next = simRotateNext();
    int prev = simRotatePrev();

    if (next > 0 || prev > 0){
        if (next > prev){
            rotateNext();
            return "T";
        } else {
            rotatePrev();
            return "R";
        }
    }

    if (myself.getUnflip() > 3){
        myself.unflip -= 3;
        myself.points += 3;
        return "C";
    }

    if (myself.getUnflip() > 0){
        myself.unflip -= 1;
        myself.points += 2;
        return "F";
    }

    if (myself.getPoints() > otherMaxPoints){
        return "N";
    } else {
        myself.unflip += 3;
        myself.points -= 3;
        return "3";
    }

}

private void parse(String s){
    String[] ps = s.split(";");
    round = Integer.parseInt(ps[0]);
    myself.setId(Integer.parseInt(ps[1]));
    coins = round = Integer.parseInt(ps[2]);
    for (int i = 3; i < ps.length; i++){
        String[] sp2 = ps[i].split("_");
        if (Integer.parseInt(sp2[0]) == myself.getId()){
            myself.setPoints(Integer.parseInt(sp2[1]));
            myself.setFlip(Integer.parseInt(sp2[2]));
            myself.setUnflip(Integer.parseInt(sp2[3]));
            players.add(myself);
        } else {
            Player p = new Player();
            p.setId(Integer.parseInt(sp2[0]));
            p.setPoints(Integer.parseInt(sp2[1]));
            p.setFlip(Integer.parseInt(sp2[2]));
            p.setUnflip(Integer.parseInt(sp2[3]));
            players.add(p);
            if (p.getPoints() > otherMaxPoints){
                otherMaxPoints = p.getPoints();
            }
        }
    }
}
}

चलाने के लिए: बस इसे डिफ़ॉल्ट बॉट्स के समान फ़ोल्डर में जोड़ें और फिर निम्न वर्ग बनाएं

package players;

import controller.Player;

public class TraderBot extends Player {

    @Override
    public String getCmd() {
        return "java TraderBot";
    }   
}

फिर उस वर्ग को Player[] playersसरणी में जोड़ें ।

— Averroes
स्रोत
2

व्हीलर

सिक्कों को घुमाते समय व्हीलर ने इसके लिए सर्वोत्तम संभव चाल की गणना की।

import java.util.ArrayList;
import java.util.List;

public class Wheeler {

String[] actions = {"TTT", "TTR", "TRR", "TRT", "RRR", "RRT", "RTR", "RTT"};
String paramString;

class Player{
    private int id;
    private int points;
    private int flip;
    private int unflip;

    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public int getPoints() {
        return points;
    }
    public void setPoints(int points) {
        this.points = points;
    }
    public int getFlip() {
        return flip;
    }
    public void setFlip(int flip) {
        this.flip = flip;
    }
    public int getUnflip() {
        return unflip;
    }
    public void setUnflip(int unflip) {
        this.unflip = unflip;
    }
    @Override
    public String toString() {
        return "Player [id=" + id + ", points=" + points + ", flip=" + flip + ", unflip=" + unflip + "]";
    }




}

int round;
int coins;
int otherMaxPoints = 0;
Player myself = new Player();
List<Player> players = new ArrayList<>();

public static void main (String[] s){
    new Wheeler().play(s);
}

private void play(String[] s){
    paramString = s[0];
    reset();
    System.out.println(action());
}

private int rotateNext(){
    int flip, unflip, nflip, nunflip;
    flip = players.get(0).getFlip();
    unflip = players.get(0).getUnflip();
    for (int i = 0; i < players.size(); i++){
        int next = i + 1 <= players.size() - 1 ? i + 1 : 0;
        nflip = players.get(next).getFlip();
        nunflip = players.get(next).getUnflip();
        players.get(next).setFlip(flip);
        players.get(next).setUnflip(unflip);
        players.get(next).setPoints(players.get(next).getPoints() + 2 * flip - unflip);
        flip = nflip;
        unflip = nunflip;
    }
    return myself.getPoints();
}

private int rotatePrev(){
    int flip, unflip,  nflip, nunflip;
    flip = players.get(players.size() -1).getFlip();
    unflip = players.get(players.size() -1).getUnflip();
    for (int i = players.size() -1; i > 0; i--){
        int prev = i - 1 >= 0 ? i - 1 : players.size() - 1;
        nflip = players.get(prev).getFlip();
        nunflip = players.get(prev).getUnflip();
        players.get(prev).setFlip(flip);
        players.get(prev).setUnflip(unflip);
        players.get(prev).setPoints(players.get(prev).getPoints() + 2 * flip - unflip);
        flip = nflip;
        unflip = nunflip;
    }
    return myself.getPoints();
}

private String action() {
    int maxPoints = myself.getPoints();
    String action = "1F2";
    for (String s : actions){
        int cPoints = 0;
        for (char c : s.toCharArray()){
            if (c == 'T'){
                cPoints += rotateNext();
            } else {
                cPoints += rotatePrev();
            }
        }
        if (cPoints > maxPoints){
            action = s;
        }
        reset();
    }
    return action;      
}


private void reset(){
    players = new ArrayList<>();
    String[] ps = paramString.split(";");
    round = Integer.parseInt(ps[0]);
    myself.setId(Integer.parseInt(ps[1]));
    coins = round = Integer.parseInt(ps[2]);
    for (int i = 3; i < ps.length; i++){
        String[] sp2 = ps[i].split("_");
        if (Integer.parseInt(sp2[0]) == myself.getId()){
            myself.setPoints(Integer.parseInt(sp2[1]));
            myself.setFlip(Integer.parseInt(sp2[2]));
            myself.setUnflip(Integer.parseInt(sp2[3]));
            players.add(myself);
        } else {
            Player p = new Player();
            p.setId(Integer.parseInt(sp2[0]));
            p.setPoints(Integer.parseInt(sp2[1]));
            p.setFlip(Integer.parseInt(sp2[2]));
            p.setUnflip(Integer.parseInt(sp2[3]));
            players.add(p);
            if (p.getPoints() > otherMaxPoints){
                otherMaxPoints = p.getPoints();
            }
        }
    }
}

}
— Averroes
स्रोत
2

सबोटूर, पायथन 2

import random
moves = '3R'
print '33' + ''.join(random.choice(moves))

यादृच्छिकता का मतलब है कि यह शायद बहुत अच्छी तरह से तोड़फोड़ नहीं करेगा, लेकिन बाद में मुझे लगता है कि मुझे इसका इंतजार करना होगा 'अंत' (कितने मोड़ / सिक्के बचे हैं) और फिर बारी बारी से, चोरी करने के लिए पास के उपलब्ध खिलाड़ियों को देखकर। ... वास्तव में केवल एक रोटेशन करना वास्तव में खराब लगता है, अन्य लोगों को भी रोटेशन का उपयोग करने की संभावना है। मुझे नहीं लगता कि यह बहुत अच्छा काम करेगा ...

— नील
स्रोत
जिस चीज को यह सबसे ज्यादा करता है वह है सिक्के का ढेर। साथ ही खुद को और दूसरों को बहुत सारे नकारात्मक बिंदु देते हैं।
— मेगाटॉम
@MegaTom हाँ, मुझे लगता है कि एक साइड इफेक्ट होगा, मुझे लगता है कि कुल सिक्कों के फार्मूले पर मैं एक तरह का चमक रहा हूं। मैं इसे एक यादृच्छिक संख्या बना सकता हूं। और नकारात्मक बिंदुओं पर, दूसरों को नकारात्मक अंक देना सिर्फ जीतने का एक और तरीका है!
— नील
आपको sys आयात की आवश्यकता नहीं है। : पी
— बिल्ली
2

दूसरा, पायथन 3

यह कार्यक्रम सभी संभावित 3 चाल संयोजनों के माध्यम से जाएगा और दूसरा-सबसे अच्छा एक का चयन करेगा।

क्योंकि अगर आपके पास सही कदम है, तो यह शायद एक जाल है।

संपादित करें: हटाए गए टिप्पणी-रहित इनपुट

import sys
from copy import deepcopy
from random import randint
In=str(sys.argv[1])
def V(n,f=10,t=14):
 n=str(n);z=0;s='';d='0123456789';d1='N123ABCXYZRTFU'
 for i in n:z=z*f+d.index(i)
 while z:z,m=divmod(z,t);s=d1[m]+s
 while len(s)<3:s='N'+s
 return s
In=In.split(';')
number=In[0:3]
players=In[3:]
for x in range(0,len(players)):players[x]=players[x].split('_')
for x in players:
 if number[1] in x[0]:self=x
for x in range(0,len(players)):
 for y in range(0,len(players[x])):
  players[x][y]=int(players[x][y])
for x in range(0,len(number)):number[x]=int(number[x])
Pos=list(map(V,range(0,14**3)))
B=[]
C=[]
P1=deepcopy(players)
N1=deepcopy(number)
for x in range(len(Pos)):
    P=True
    y=Pos[x]
    if '1A'in y or '2B'in y or '3C'in y or 'FU'in y or 'A1'in y or 'B2'in y or 'C3'in y or 'UF'in y:
            P=False#stupid check
    if P:#legality check
        z=0
        players=deepcopy(P1)
        number=deepcopy(N1)
        for x in players:
            if str(number[1]) in str(x[0]):self=x
        for w in range(0,3):
            if y[w] in '3':
                if int(number[2])<3:P=False;break
                else:z-=3;self[3]+=3;number[2]-=3
            if y[w] in '2':
                if int(number[2])<2:P=False;break
                else:z-=2;self[3]+=2;number[2]-=2
            if y[w] in '1':
                if int(number[2])<1:P=False;break
                else:z-=1;self[3]+=1;number[2]-=1
            if y[w] in 'A':
                if int(self[3])<1:P=False;break
                else:z+=1;self[3]-=3;number[2]+=3
            if y[w] in 'B':
                if int(self[3])<2:P=False;break
                else:z+=2;self[3]-=2;number[2]+=2
            if y[w] in 'C':
                if int(self[3])<3:P=False;break
                else:z+=3;self[3]-=1;number[2]+=1
            if y[w] in 'X':
                if int(self[3])<1:P=False;break
                else:self[3]-=1
            if y[w] in 'Y':
                if int(self[3])<2:P=False;break
                else:self[3]-=2
            if y[w] in 'Z':
                if int(self[3])<3:P=False;break
                else:self[3]-=3
            if y[w] in 'F':
                if int(self[3])<1:P=False;break
                else:z+=2;self[3]-=1;self[2]+=1
            if y[w] in 'U':
                if int(self[3])<1:P=False;break
                else:z-=2;self[3]+=1;self[2]-=1
            if y[w] in 'R':
                self[2:4]=players[(players.index(self)+1)%len(players)][2:4]
                z+=int(self[3])*-1
                z+=int(self[2])*2
            if y[w] in 'T':
                self[2:4]=players[(players.index(self)-1)%len(players)][2:4]
                z+=int(self[3])*-1
                z+=int(self[2])*2
    if P:
        C.append(z);B.append((z,y))
c=list(set(C))
c.sort()
c=c[::-1][1];D=[]
for x in B:
    if c in x:D.append(x)
print(D[randint(0,len(D)-1)][1])

संपादित करें: कोड एक यादृच्छिक कानूनी कदम छाप रहा था। इसे अब दूसरा सबसे अच्छा परिणाम लौटाया जाना चाहिए।

— मैजेंटा
स्रोत
1

डेविल्स बॉट

हालांकि इसका उत्पादन केवल शैतान की संख्या का आधा है, परिणाम काफी विनाशकारी होना चाहिए। 9 सिक्कों को मोड़ने से अंत में सिक्कों का ढेर समाप्त हो जाता है। चूँकि यह बॉट कभी भी अपने द्वारा लिए गए किसी भी सिक्के को नहीं फेकता है, यह किसी और के लिए उसके बगल में बैठने के लिए बेहद बुरा है जब इस बॉट द्वारा लिए गए प्रत्येक मोड़ के लिए रोटेशन (-9 अंक) होता है।

print("333")

कमान: python3 devil.py

मुझे बाद में कुछ वास्तविक बॉट बनाने की उम्मीद है।

— फ्रेडरिक
स्रोत
@plannapus वूप्स! मैंने उस पर ध्यान नहीं दिया। मुझे बताने के लिए धन्यवाद!
— फ्रेडरिक
1

मी मी, पायथन 3 याद रखें

इस कार्यक्रम में निश्चित सेकंडबेस्ट बॉट के खिलाफ एक परीक्षण से इनबिल्ट डेटा की एक महत्वपूर्ण मात्रा होती है।

यह सीखना चाहिए कि कौन से चालों का उपयोग करना सबसे अच्छा है, लेकिन यह अन्य खिलाड़ियों के इनपुट का उपयोग नहीं करता है।

संपादित करें: अनावश्यक बिंदु गणना को हटा दिया गया

संपादित करें: अनियोजित खिलाड़ी इनपुट

import sys
file=sys.argv[0].split('\\')[::-1][0]
from copy import deepcopy
from random import randint
In=str(sys.argv[1])
def V(n,f=10,t=14):
 n=str(n);z=0;s='';d='0123456789';d1='N123ABCXYZRTFU'
 for i in n:z=z*f+d.index(i)
 while z:z,m=divmod(z,t);s=d1[m]+s
 while len(s)<3:s='N'+s
 return s
In=In.split(';')
number=In[0:3]
players=In[3:]
for x in range(0,len(players)):players[x]=players[x].split('_')
for x in players:
 if number[1] in x[0]:self=x
for x in range(0,len(players)):
 for y in range(0,len(players[x])):
  players[x][y]=int(players[x][y])
for x in range(0,len(number)):number[x]=int(number[x])
Pos=list(map(V,range(0,14**3)))
B=[]
P1=deepcopy(players)
N1=deepcopy(number)
for x in range(len(Pos)):
    P=True
    y=Pos[x]
    if '1A'in y or '2B'in y or '3C'in y or 'FU'in y or 'A1'in y or 'B2'in y or 'C3'in y or 'UF'in y:
            P=False
    if P:
        players=deepcopy(P1)
        number=deepcopy(N1)
        for x in players:
            if str(number[1]) in str(x[0]):self=x
        for w in range(0,3):
            if y[w] in '3':
                if int(number[2])<3:P=False;break
                else:self[3]+=3;number[2]-=3
            if y[w] in '2':
                if int(number[2])<2:P=False;break
                else:self[3]+=2;number[2]-=2
            if y[w] in '1':
                if int(number[2])<1:P=False;break
                else:self[3]+=1;number[2]-=1
            if y[w] in 'A':
                if int(self[3])<1:P=False;break
                else:self[3]-=3;number[2]+=3
            if y[w] in 'B':
                if int(self[3])<2:P=False;break
                else:self[3]-=2;number[2]+=2
            if y[w] in 'C':
                if int(self[3])<3:P=False;break
                else:self[3]-=1;number[2]+=1
            if y[w] in 'X':
                if int(self[3])<1:P=False;break
                else:self[3]-=1
            if y[w] in 'Y':
                if int(self[3])<2:P=False;break
                else:self[3]-=2
            if y[w] in 'Z':
                if int(self[3])<3:P=False;break
                else:self[3]-=3
            if y[w] in 'F':
                if int(self[3])<1:P=False;break
                else:self[3]-=1;self[2]+=1
            if y[w] in 'U':
                if int(self[3])<1:P=False;break
                else:self[3]+=1;self[2]-=1
            if y[w] in 'R':
                self[2:4]=players[(players.index(self)+1)%len(players)][2:4]
            if y[w] in 'T':
                self[2:4]=players[(players.index(self)-1)%len(players)][2:4]
    if P:
        B.append(y)
Pos=list(B)
B=[]
#
C=[['NNN',0],['NN1',-1],['NN2',-2],['NN3',-3],['NNR',-6],['NNT',-1],['N1N',-1],['N11',-2],['N12',-3],['N13',-4],['N1X',-1],['N1R',-7],['N1T',-2],['N1F',1],['N1U',-3],['N2N',-2],['N21',-3],['N22',-4],['N23',-5],['N2A',-1],['N2X',-2],['N2Y',-2],['N2R',-8],['N2T',-3],['N2F',0],['N2U',-4],['N3N',-3],['N31',-4],['N32',-5],['N33',-6],['N3A',-2],['N3B',-1],['N3X',-3],['N3Y',-3],['N3Z',-3],['N3R',-9],['N3T',-4],['N3F',-1],['N3U',-5],['NRN',-6],['NR1',-7],['NR2',-8],['NR3',-9],['NRA',-5],['NRB',-4],['NRC',-3],['NRX',-6],['NRY',-6],['NRZ',-6],['NRR',-12],['NRT',-7],['NRF',-4],['NRU',-8],['NTN',-1],['NT1',-2],['NT2',-3],['NT3',-4],['NTA',0],['NTX',-1],['NTR',-7],['NTT',-2],['NTF',1],['NTU',-3],['1NN',-1],['1N1',-2],['1N2',-3],['1N3',-4],['1NA',0],['1NX',-1],['1NR',-7],['1NT',-2],['1NF',1],['1NU',-3],['11N',-2],['111',-3],['112',-4],['113',-5],['11B',0],['11X',-2],['11Y',-2],['11R',-8],['11T',-3],['11F',0],['11U',-4],['12N',-3],['121',-4],['122',-5],['123',-6],['12A',-2],['12C',0],['12X',-3],['12Y',-3],['12Z',-3],['12R',-9],['12T',-4],['12F',-1],['12U',-5],['13N',-4],['131',-5],['132',-6],['133',-7],['13A',-3],['13B',-2],['13X',-4],['13Y',-4],['13Z',-4],['13R',-10],['13T',-5],['13F',-2],['13U',-6],['1XN',-1],['1X1',-2],['1X2',-3],['1X3',-4],['1XR',-7],['1XT',-2],['1RN',-7],['1R1',-8],['1R2',-9],['1R3',-10],['1RA',-6],['1RB',-5],['1RC',-4],['1RX',-7],['1RY',-7],['1RZ',-7],['1RR',-13],['1RT',-8],['1RF',-5],['1RU',-9],['1TN',-2],['1T1',-3],['1T2',-4],['1T3',-5],['1TA',-1],['1TX',-2],['1TR',-8],['1TT',-3],['1TF',0],['1TU',-4],['1FN',1],['1F1',0],['1F2',-1],['1F3',-2],['1FR',-5],['1FT',0],['1UN',-3],['1U1',-4],['1U2',-5],['1U3',-6],['1UA',-2],['1UB',-1],['1UX',-3],['1UY',-3],['1UR',-9],['1UT',-4],['1UU',-5],['2NN',-2],['2N1',-3],['2N2',-4],['2N3',-5],['2NA',-1],['2NB',0],['2NX',-2],['2NY',-2],['2NR',-8],['2NT',-3],['2NF',0],['2NU',-4],['21N',-3],['211',-4],['212',-5],['213',-6],['21B',-1],['21C',0],['21X',-3],['21Y',-3],['21Z',-3],['21R',-9],['21T',-4],['21F',-1],['21U',-5],['22N',-4],['221',-5],['222',-6],['223',-7],['22A',-3],['22C',-1],['22X',-4],['22Y',-4],['22Z',-4],['22R',-10],['22T',-5],['22F',-2],['22U',-6],['23N',-5],['231',-6],['232',-7],['233',-8],['23A',-4],['23B',-3],['23X',-5],['23Y',-5],['23Z',-5],['23R',-11],['23T',-6],['23F',-3],['23U',-7],['2AN',-1],['2A2',-3],['2A3',-4],['2AR',-7],['2AT',-2],['2XN',-2],['2X1',-3],['2X2',-4],['2X3',-5],['2XA',-1],['2XX',-2],['2XR',-8],['2XT',-3],['2XF',0],['2XU',-4],['2YN',-2],['2Y1',-3],['2Y2',-4],['2Y3',-5],['2YR',-8],['2YT',-3],['2RN',-8],['2R1',-9],['2R2',-10],['2R3',-11],['2RA',-7],['2RB',-6],['2RC',-5],['2RX',-8],['2RY',-8],['2RZ',-8],['2RR',-14],['2RT',-9],['2RF',-6],['2RU',-10],['2TN',-3],['2T1',-4],['2T2',-5],['2T3',-6],['2TA',-2],['2TX',-3],['2TR',-9],['2TT',-4],['2TF',-1],['2TU',-5],['2FN',0],['2F1',-1],['2F2',-2],['2F3',-3],['2FA',1],['2FX',0],['2FR',-6],['2FT',-1],['2FF',2],['2UN',-4],['2U1',-5],['2U2',-6],['2U3',-7],['2UA',-3],['2UB',-2],['2UC',-1],['2UX',-4],['2UY',-4],['2UZ',-4],['2UR',-10],['2UT',-5],['2UU',-6],['3NN',-3],['3N1',-4],['3N2',-5],['3N3',-6],['3NA',-2],['3NB',-1],['3NC',0],['3NX',-3],['3NY',-3],['3NZ',-3],['3NR',-9],['3NT',-4],['3NF',-1],['3NU',-5],['31N',-4],['311',-5],['312',-6],['313',-7],['31B',-2],['31C',-1],['31X',-4],['31Y',-4],['31Z',-4],['31R',-10],['31T',-5],['31F',-2],['31U',-6],['32N',-5],['321',-6],['322',-7],['323',-8],['32A',-4],['32C',-2],['32X',-5],['32Y',-5],['32Z',-5],['32R',-11],['32T',-6],['32F',-3],['32U',-7],['33N',-6],['331',-7],['332',-8],['333',-9],['33A',-5],['33B',-4],['33X',-6],['33Y',-6],['33Z',-6],['33R',-12],['33T',-7],['33F',-4],['33U',-8],['3AN',-2],['3A2',-4],['3A3',-5],['3AR',-8],['3AT',-3],['3BN',-1],['3B1',-2],['3B3',-4],['3BA',0],['3BX',-1],['3BR',-7],['3BT',-2],['3BF',1],['3BU',-3],['3XN',-3],['3X1',-4],['3X2',-5],['3X3',-6],['3XA',-2],['3XB',-1],['3XX',-3],['3XY',-3],['3XR',-9],['3XT',-4],['3XF',-1],['3XU',-5],['3YN',-3],['3Y1',-4],['3Y2',-5],['3Y3',-6],['3YA',-2],['3YX',-3],['3YR',-9],['3YT',-4],['3YF',-1],['3YU',-5],['3ZN',-3],['3Z1',-4],['3Z2',-5],['3Z3',-6],['3ZR',-9],['3ZT',-4],['3RN',-9],['3R1',-10],['3R2',-11],['3R3',-12],['3RA',-8],['3RB',-7],['3RC',-6],['3RX',-9],['3RY',-9],['3RZ',-9],['3RR',-15],['3RT',-10],['3RF',-7],['3RU',-11],['3TN',-4],['3T1',-5],['3T2',-6],['3T3',-7],['3TA',-3],['3TX',-4],['3TR',-10],['3TT',-5],['3TF',-2],['3TU',-6],['3FN',-1],['3F1',-2],['3F2',-3],['3F3',-4],['3FA',0],['3FB',1],['3FX',-1],['3FY',-1],['3FR',-7],['3FT',-2],['3FF',1],['3UN',-5],['3U1',-6],['3U2',-7],['3U3',-8],['3UA',-4],['3UB',-3],['3UC',-2],['3UX',-5],['3UY',-5],['3UZ',-5],['3UR',-11],['3UT',-6],['3UU',-7],['RNN',-6],['RN1',-7],['RN2',-8],['RN3',-9],['RNA',-5],['RNB',-4],['RNC',-3],['RNX',-6],['RNY',-6],['RNZ',-6],['RNR',-12],['RNT',-7],['RNF',-4],['RNU',-8],['R1N',-7],['R11',-8],['R12',-9],['R13',-10],['R1B',-5],['R1C',-4],['R1X',-7],['R1Y',-7],['R1Z',-7],['R1R',-13],['R1T',-8],['R1F',-5],['R1U',-9],['R2N',-8],['R21',-9],['R22',-10],['R23',-11],['R2A',-7],['R2C',-5],['R2X',-8],['R2Y',-8],['R2Z',-8],['R2R',-14],['R2T',-9],['R2F',-6],['R2U',-10],['R3N',-9],['R31',-10],['R32',-11],['R33',-12],['R3A',-8],['R3B',-7],['R3X',-9],['R3Y',-9],['R3Z',-9],['R3R',-15],['R3T',-10],['R3F',-7],['R3U',-11],['RAN',-5],['RA2',-7],['RA3',-8],['RAA',-4],['RAB',-3],['RAC',-2],['RAX',-5],['RAY',-5],['RAZ',-5],['RAR',-11],['RAT',-6],['RAF',-3],['RAU',-7],['RBN',-4],['RB1',-5],['RB3',-7],['RBA',-3],['RBB',-2],['RBC',-1],['RBX',-4],['RBY',-4],['RBZ',-4],['RBR',-10],['RBT',-5],['RBF',-2],['RBU',-6],['RCN',-3],['RC1',-4],['RC2',-5],['RCA',-2],['RCB',-1],['RCC',0],['RCX',-3],['RCY',-3],['RCZ',-3],['RCR',-9],['RCT',-4],['RCF',-1],['RCU',-5],['RXN',-6],['RX1',-7],['RX2',-8],['RX3',-9],['RXA',-5],['RXB',-4],['RXC',-3],['RXX',-6],['RXY',-6],['RXZ',-6],['RXR',-12],['RXT',-7],['RXF',-4],['RXU',-8],['RYN',-6],['RY1',-7],['RY2',-8],['RY3',-9],['RYA',-5],['RYB',-4],['RYC',-3],['RYX',-6],['RYY',-6],['RYZ',-6],['RYR',-12],['RYT',-7],['RYF',-4],['RYU',-8],['RZN',-6],['RZ1',-7],['RZ2',-8],['RZ3',-9],['RZA',-5],['RZB',-4],['RZC',-3],['RZX',-6],['RZY',-6],['RZZ',-6],['RZR',-12],['RZT',-7],['RZF',-4],['RZU',-8],['RRN',-12],['RR1',-13],['RR2',-14],['RR3',-15],['RRA',-11],['RRB',-10],['RRC',-9],['RRX',-12],['RRY',-12],['RRZ',-12],['RRR',-18],['RRT',-13],['RRF',-10],['RRU',-14],['RTN',-7],['RT1',-8],['RT2',-9],['RT3',-10],['RTA',-6],['RTX',-7],['RTR',-13],['RTT',-8],['RTF',-5],['RTU',-9],['RFN',-4],['RF1',-5],['RF2',-6],['RF3',-7],['RFA',-3],['RFB',-2],['RFC',-1],['RFX',-4],['RFY',-4],['RFZ',-4],['RFR',-10],['RFT',-5],['RFF',-2],['RUN',-8],['RU1',-9],['RU2',-10],['RU3',-11],['RUA',-7],['RUB',-6],['RUC',-5],['RUX',-8],['RUY',-8],['RUZ',-8],['RUR',-14],['RUT',-9],['RUU',-10],['TNN',-1],['TN1',-2],['TN2',-3],['TN3',-4],['TNA',0],['TNX',-1],['TNR',-7],['TNT',-2],['TNF',1],['TNU',-3],['T1N',-2],['T11',-3],['T12',-4],['T13',-5],['T1B',0],['T1X',-2],['T1Y',-2],['T1R',-8],['T1T',-3],['T1F',0],['T1U',-4],['T2N',-3],['T21',-4],['T22',-5],['T23',-6],['T2A',-2],['T2C',0],['T2X',-3],['T2Y',-3],['T2Z',-3],['T2R',-9],['T2T',-4],['T2F',-1],['T2U',-5],['T3N',-4],['T31',-5],['T32',-6],['T33',-7],['T3A',-3],['T3B',-2],['T3X',-4],['T3Y',-4],['T3Z',-4],['T3R',-10],['T3T',-5],['T3F',-2],['T3U',-6],['TAN',0],['TA2',-2],['TA3',-3],['TAR',-6],['TAT',-1],['TXN',-1],['TX1',-2],['TX2',-3],['TX3',-4],['TXR',-7],['TXT',-2],['TRN',-7],['TR1',-8],['TR2',-9],['TR3',-10],['TRA',-6],['TRB',-5],['TRC',-4],['TRX',-7],['TRY',-7],['TRZ',-7],['TRR',-13],['TRT',-8],['TRF',-5],['TRU',-9],['TTN',-2],['TT1',-3],['TT2',-4],['TT3',-5],['TTA',-1],['TTX',-2],['TTR',-8],['TTT',-3],['TTF',0],['TTU',-4],['TFN',1],['TF1',0],['TF2',-1],['TF3',-2],['TFR',-5],['TFT',0],['TUN',-3],['TU1',-4],['TU2',-5],['TU3',-6],['TUA',-2],['TUB',-1],['TUX',-3],['TUY',-3],['TUR',-9],['TUT',-4],['TUU',-5]]
#
points=0
#
dpoints=self[1]-points
z=0
for x in range(len(Pos)):
    y=Pos[x]
    z=0
    for x in C:
     if x[0]==y:z=x[1]
    B.append((z,y))
B.sort()
B=B[::-1]
G=open(file,'r')
H=G.read().split('#')[::-1]
G.close()
G=open(file,'w')
H[3]=H[3].replace(H[3][8:-1],str(self[1]))
J=eval(H[4][3:-1])
A=[B[0][1],dpoints]
P=1
for x in range(0,len(J)):
 if J[x][0]==A[0]:J[x][1]+=A[1];P=0
if P:J.append(A)
H[4]='\nC='+str(J)+'\n'
s=''
for x in H[::-1]:s+=x;s+='#'
G.write(s[:-1])
G.close()
print(B[0][1])
— मैजेंटा
स्रोत
मुझे लगता है कि आपके पास # 5
— Averroes
इसे अब ठीक किया जाना चाहिए। इस पर ध्यान दिलाने के लिए धन्यवाद।
— मैजेंटा
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.