परमाणु अनुपात का एक खेल


21

आपका कार्य एक बॉट बनाते हैं जो सबसे अधिक स्कोर के साथ, एटोमस की भूमिका निभाता है ।

खेल कैसे काम करता है:

Gameboard यहां से संख्या के साथ, 6 "परमाणुओं" की एक अंगूठी के साथ शुरू होता 1करने के लिए 3। आप दो परमाणुओं के बीच एक परमाणु को "खेल" सकते हैं, या किसी अन्य परमाणु पर, परमाणु पर ही निर्भर करता है।

आप या तो एक सामान्य परमाणु, या एक विशेष परमाणु रख सकते हैं।

सामान्य परमाणु:

आप बोर्ड पर किसी भी दो उपलब्ध परमाणुओं के बीच एक सामान्य परमाणु खेल सकते हैं।

आप रेंज में परमाणुओं के साथ शुरू करते हैं 1 to 3, लेकिन हर 40 चालों में एक बार सीमा बढ़ जाती है (इसलिए 40 चालों के बाद, सीमा बन जाती है 2 to 4)।

यदि बोर्ड पर परमाणु होते हैं जो सीमा से कम होते हैं, तो यह 1 / no. of atoms of that number on the boardस्पॉनिंग का एक मौका होता है।

मान लें कि आपके पास 2खेलने के लिए एक है, और बोर्ड इस तरह दिखता है:

   1 1 2 1

आइए जगह 2के अधिकार के लिए 1

बोर्ड अब बन गया है:

   1 1 2 1 2

नोट: बोर्ड चारों ओर से घूमता है, इसलिए 1बाईं ओर वास्तव में 2सबसे दाईं ओर स्थित है। यह बाद में महत्वपूर्ण होगा।

"विशेष" परमाणु के 4 प्रकार हैं, और वे हैं:

+परमाणु:

यह परमाणु दो परमाणुओं के बीच खेला जाता है। इसमें 1 से 5 स्पॉनिंग की संभावना है।

यदि परमाणु के दोनों किनारों पर +परमाणु समान हैं, तो संलयन होता है। यहां देखिए यह कैसे काम करता है:

The two atoms fuse together to create an atom one higher.
(So, two 3 atoms fuse together to form one 4 atom.)
While the atoms on both sides of the fused atom are equal:
    If the atoms on the side >= the fused atom:
        The new fused atom = the old fused atom's value + 2.
    If the atoms on the side < the fused atom:
        The new fused atom = the old fused atom's value + 1.

उदाहरण:

   1 1 3 2 2 3  (the 1 on the left-hand side "wraps back" 
                 to the 3 on the right-hand side)

Let's use the + on the two 2's in the middle.

-> 1 1 3 3 3    (the two 2's fused together to make a 3)
-> 1 1 5        (the two 3's fused with the 3, and because 3 >= 3,
                 the new fused atom = 3 + 2 = 5)
-> 6            (the two 1's fused with the 5, since the board wraps,
                 and because 1 < 5, the new fused atom = 5 + 1 = 6)

Because the atoms on the sides of the 6 don't exist, fusion stops,
and the board is now [6].

यदि परमाणु के दोनों किनारों पर +परमाणु अलग-अलग हैं, तो +बोर्ड पर रहता है।

उदाहरण:

   1 3 2 3 1 1

Let's use the + on the 2 and 3 in the middle.

-> 1 3 2 + 3 1 1 (2 != 3, so the + stays on the board)

-परमाणु:

यह परमाणु दूसरे परमाणु पर खेला जाता है। इसमें 1 से 10 तक स्पॉनिंग होती है।

-परमाणु बोर्ड से एक परमाणु निकाल देता है, और आप या तो करने के लिए एक विकल्प देता है:

  • हटाए गए परमाणु को अगले दौर में चलाएं, या
  • अगले राउंड खेलने के लिए इसे + एटम में बदल दें।

उदाहरण:

   1 3 2 3 1 1

Let's use the - on the left-hand 2.

-> 1 3 3 1 1    (the 2 is now removed from the board)

Let's turn it into a +, and place it in between the 3's.

-> 1 4 1 1      (the two 3's fused together to make a 4)
-> 5 1          (the two 1's fused with the 4, and because 1 < 4,
                 the new fused atom = 4 + 1 = 5)

काला +परमाणु ( B):

यह परमाणु 2 परमाणुओं के बीच खेला जाता है। यह स्पॉनिंग के 80 में से 1 मौका है, और केवल एक बार आपका स्कोर> 750 के बराबर होता है।

यह परमाणु मूल रूप से +परमाणु के समान है , सिवाय इसके कि यह किसी भी दो परमाणुओं को एक साथ फ्यूज करता है, यहां तक ​​कि +। तब से, यह +नियम का पालन ​​करता है (यह केवल परमाणुओं को एक साथ फ्यूज करता है यदि फ्यूज्ड परमाणु के दोनों किनारों पर परमाणु समान हैं)।

ब्लैक के परिणामस्वरूप फ्यूज्ड एटम +बराबर है:

  • फ्यूजन में उच्च संख्या परमाणु + 3
  • 4अगर दो जुड़े हुए परमाणुओं हैं +की

उदाहरण:

   1 3 2 1 3 1

Let's use the black + on the 2 and 1 in the middle.

-> 1 3 5 3 1    (the 2 and 1 fused together to make a 2 + 3 = 5)
-> 1 6 1        (+ rule)
-> 7            (+ rule)

एक और उदाहरण:

   2 + + 2

Let's use the black + on the two +'s.

-> 2 4 2        (the two +'s fused together to make a 4)
-> 5            (+ rule)

क्लोन परमाणु ( C):

यह परमाणु दूसरे परमाणु पर खेला जाता है। इसमें 1 से 60 बार स्पॉनिंग होती है, और केवल एक बार आपका स्कोर> 1500 तक होता है।

क्लोन परमाणु आपको एक परमाणु चुनने की अनुमति देता है, और इसे अगले दौर में खेलता है।

उदाहरण:

   1 1 2 1

Let's use the clone on the 2, and place it to the right of the 1.

-> 1 1 2 1 2

यहाँ मेरे खेल का निर्माण है, पायथन 2 में:

import random
import subprocess

logs='atoms.log'
atom_range = [1, 3]
board = []
score = 0
move_number = 0
carry_over = " "
previous_moves = []

specials = ["+", "-", "B", "C"]


def plus_process(user_input):
    global board, score, previous_moves, matches
    previous_moves = []
    matches = 0

    def score_calc(atom):
        global score, matches
        if matches == 0:
            score += int(round((1.5 * atom) + 1.25, 0))
        else:
            if atom < final_atom:
                outer = final_atom - 1
            else:
                outer = atom
            score += ((-final_atom + outer + 3) * matches) - final_atom + (3 * outer) + 3
        matches += 1

    if len(board) < 1 or user_input == "":
        board.append("+")
        return None
    board_start = board[:int(user_input) + 1]
    board_end = board[int(user_input) + 1:]
    final_atom = 0
    while len(board_start) > 0 and len(board_end) > 0:
        if board_start[-1] == board_end[0] and board_end[0] != "+":
            if final_atom == 0:
                final_atom = board_end[0] + 1
            elif board_end[0] >= final_atom:
                final_atom += 2
            else:
                final_atom += 1
            score_calc(board_end[0])
            board_start = board_start[:-1]
            board_end = board_end[1:]
        else:
            break
    if len(board_start) == 0:
        while len(board_end) > 1:
            if board_end[0] == board_end[-1] and board_end[0] != "+":
                if final_atom == 0:
                    final_atom = board_end[0]
                elif board_end[0] >= final_atom:
                    final_atom += 2
                else:
                    final_atom += 1
                score_calc(board_end[0])
                board_end = board_end[1:-1]
            else:
                break
    if len(board_end) == 0:
        while len(board_start) > 1:
            if board_start[0] == board_start[-1] and board_start[0] != "+":
                if board_start[0] >= final_atom:
                    final_atom += 2
                else:
                    final_atom += 1
                score_calc(board_start[0])
                board_start = board_start[1:-1]
            else:
                break
    if matches == 0:
        board = board_start + ["+"] + board_end
    else:
        board = board_start + [final_atom] + board_end
        for a in range(len(board) - 1):
            if board[a] == "+":
                if board[(a + 1) % len(board)] == board[a - 1]:
                    board = board[:a - 1] + board[a:]
                    plus_process(a)
                    break


def minus_process(user_input, minus_check):
    global carry_over, board
    carry_atom = board[int(user_input)]
    if user_input == len(board) - 1:
        board = board[:-1]
    else:
        board = board[:int(user_input)] + board[int(user_input) + 1:]
    if minus_check == "y":
        carry_over = "+"
    elif minus_check == "n":
        carry_over = str(carry_atom)


def black_plus_process(user_input):
    global board
    if board[int(user_input)] == "+":
        if board[int(user_input) + 1] == "+":
            inter_atom = 4
        else:
            inter_atom = board[int(user_input) + 1] + 2
    else:
        if board[int(user_input)] + 1 == "+":
            inter_atom = board[int(user_input)] + 2
        else:
            inter_list = [board[int(user_input)], board[int(user_input) + 1]]
            inter_atom = (inter_list.sort())[1] + 2
    board = board[int(user_input) - 1:] + [inter_atom] * 2 + board[int(user_input) + 1:]
    plus_process(int(user_input) - 1)


def clone_process(user_input):
    global carry_over
    carry_over = str(board[int(user_input)])


def regular_process(atom,user_input):
    global board
    if user_input == "":
        board.append(random.randint(atom_range[0], atom_range[1]))
    else:
        board = board[:int(user_input) + 1] + [int(atom)] + board[int(user_input) + 1:]

def gen_specials():
    special = random.randint(1, 240)
    if special <= 48:
        return "+"
    elif special <= 60 and len(board) > 0:
        return "-"
    elif special <= 64 and len(board) > 0 and score >= 750:
        return "B"
    elif special <= 67 and len(board) > 0 and score >= 1500:
        return "C"
    else:
        small_atoms = []
        for atom in board:
            if atom not in specials and atom < atom_range[0]:
                small_atoms.append(atom)
        small_atom_check = random.randint(1, len(board))
        if small_atom_check <= len(small_atoms):
            return str(small_atoms[small_atom_check - 1])
        else:
            return str(random.randint(atom_range[0], atom_range[1]))


def specials_call(atom, user_input):
    specials_dict = {
        "+": plus_process,
        "-": minus_process,
        "B": black_plus_process,
        "C": clone_process
    }
    if atom in specials_dict.keys():
        if atom == "-":
            minus_process(user_input[0], user_input[1])
        else:
            specials_dict[atom](user_input[0])
    else:
        regular_process(atom,user_input[0])


def init():
    global board, score, move_number, carry_over, previous_moves
    board = []
    score = 0

    for _ in range(6):
        board.append(random.randint(1, 3))

    while len(board) <= 18:
        move_number += 1
        if move_number % 40 == 0:
            atom_range[0] += 1
            atom_range[1] += 1
        if carry_over != " ":
            special_atom = carry_over
            carry_over = " "
        elif len(previous_moves) >= 5:
            special_atom = "+"
        else:
            special_atom = gen_specials()
        previous_moves.append(special_atom)
        bot_command = "python yourBot.py"
        bot = subprocess.Popen(bot_command.split(),
                               stdout = subprocess.PIPE,
                               stdin = subprocess.PIPE)
        to_send="/".join([
            # str(score),
            # str(move_number),
            str(special_atom),
            " ".join([str(x) for x in board])
        ])
        bot.stdin.write(to_send)
        with open(logs, 'a') as f:f.write(to_send+'\n')
        bot.stdin.close()
        all_user_input = bot.stdout.readline().strip("\n").split(" ")
        specials_call(special_atom, all_user_input)

    print("Game over! Your score is " + str(score))

if __name__ == "__main__":
    for a in range(20):
        with open(logs, 'a') as f:f.write('round '+str(a)+'-'*50+'\n')
        init()

बॉट कैसे काम करता है:

इनपुट

  • आपके बॉट को 2 इनपुट मिलेंगे: परमाणु जो अभी प्ले में है, और बोर्ड की स्थिति।
  • परमाणु ऐसा होगा:
    • +एक +परमाणु के लिए
    • -एक -परमाणु के लिए
    • Bएक काले +परमाणु के लिए
    • C एक क्लोन परमाणु के लिए
    • {atom} एक सामान्य परमाणु के लिए
  • बोर्ड की स्थिति इस तरह होगी:
    • atom 0 atom 1 atom 2... atom nरिक्त स्थान द्वारा अलग किए गए परमाणुओं के साथ , "रिंग" गेमबोर्ड का अनुकरण करने के atom nलिए ( वापस लपेटता है atom 1)
  • ये दोनों एक होकर अलग हो जाएंगे /

उदाहरण इनपुट:

1/1 2 2 3   (the atom in play is 1, and the board is [1 2 2 3])
+/1         (the atom in play is +, and the board is [1] on its own)

उत्पादन

  • आप एक स्ट्रिंग आउटपुट करेंगे, जो इस बात पर निर्भर करेगा कि परमाणु क्या है।

    • यदि परमाणु दो परमाणुओं के बीच खेला जाता है:

      • उस अंतर को आउटपुट करें जिसमें आप परमाणु को चलाना चाहते हैं। अंतराल प्रत्येक परमाणु के बीच की तरह हैं, जैसे:

        atom 0, GAP 0, atom 1, GAP 1, atom 2, GAP 2... atom n, GAP N
        

        ( gap nइंगित करता है आप के बीच परमाणु रखना चाहते हैं atom 1और परमाणु n) उत्पादन तो 2आप पर परमाणु खेलने के लिए चाहते हैं, तो gap 2

    • यदि परमाणु एक परमाणु पर खेला जाता है:
      • उस परमाणु को आउटपुट करें जिस पर आप इसे चलाना चाहते हैं, इसलिए 2यदि आप परमाणु को खेलना चाहते हैं atom 2
    • यदि परमाणु एक है -:
      • उस परमाणु को आउटपुट करें जिसे आप इसे प्ले करना चाहते हैं, उसके बाद स्पेस, उसके बाद y/nपरमाणु को +बाद में मोड़ना पसंद करते हैं , इसलिए 2, "y"यदि आप परमाणु को खेलना चाहते हैं atom 2, और आप इसे चालू करना चाहते हैं +नोट: इसके लिए 1 के बजाय 2 इनपुट चाहिए।

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

(Atom in play is a +)
2   (you want to play the + in gap 2 - between atom 2 and 3)
(Atom in play is a -)
3 y  (you want to play the - on atom 3, and you want to change it to a +)
2 n  (you want to play the - on atom 2, and you don't want to change it)
  • बॉट काम करने के लिए, आपको Popenबिट (कोड के अंत में) के पास जाना होगा, और इसे अपने प्रोग्राम को पायथोनिक सूची के रूप में चलाने के लिए जो कुछ भी बनाता है (इसलिए यदि आपका प्रोग्राम है derp.java, तो ["python", "bot.py"]साथ बदलें ["java", "derp.java"])।

उत्तर-विशिष्ट विवरण:

  • उत्तर में अपने बॉट का पूरा कोड रखें। अगर यह फिट नहीं है, यह गिनती नहीं है।
  • प्रत्येक उपयोगकर्ता को 1 से अधिक बॉट रखने की अनुमति है, हालांकि, उन्हें सभी अलग-अलग उत्तर पोस्ट में होना चाहिए।
  • इसके अलावा, अपने बॉट को एक नाम दें।

स्कोरिंग:

  • उच्चतम स्कोर के साथ बॉट जीतता है।
    • आपके बॉट का परीक्षण 20 खेलों के लिए किया जाएगा, और अंतिम स्कोर 20 खेलों का औसत है।
  • टाई-ब्रेकर उत्तर के अपलोड का समय होगा।
  • तो आपका जवाब इस तरह होगा:

    {language}, {bot name}
    Score: {score}
    

सौभाग्य!


परमाणु कार्य के +लिए उत्पन्न कैसे होता है -? यदि आपने चुना है तो yक्या आपको +अगली चाल पर जाने की गारंटी होगी ?
टन हास्पेल

4
मेरा सुझाव है कि अपने बॉट ड्राइवर को बदल दें ताकि यह किसी भी स्टैंडअलोन प्रोग्राम को संभाल सके जो एसटीडीआईएन पर इनपुट लेता है और एसटीडीयूएसटी पर एक परिणाम देता है। इससे भाषा को स्वतंत्रता मिलनी चाहिए और इस साइट पर प्रयुक्त अधिकांश भाषाएं आसानी से ऐसा कर सकती हैं। बेशक इसका मतलब है कि एक सख्त I / O प्रारूप को परिभाषित करना, उदाहरण के input_atom\natom0 atom1 .... atomn\nलिए STDIN
टन हास्पेल

1
लगता है कि कोड +तत्व सूची में डालने में सक्षम है , लेकिन यह कहीं कहीं पर वर्णनात्मक विवरण में नहीं पाया गया है
टन हास्पेल

1
आह, मैं देख रहा हूं कि आपने प्रोग्राम को बाहरी बॉट्स कहलाने में सक्षम बनाया। हालाँकि, आपको वर्तमान चाल संख्या और STDIN पर स्कोर करने की आवश्यकता है अन्यथा बॉट भविष्य में होने वाले प्रत्येक परमाणु की संभावना की भविष्यवाणी नहीं कर सकता है
टन हास्पेल

1
यदि नियंत्रक में सुधार नहीं हुआ है तो लोगों को हल करने में समय व्यतीत होगा। मुझे सवाल पसंद है, लेकिन कार्यान्वयन नहीं।
mbomb007

जवाबों:


1

पायथन, ड्राफ्टबोट, स्कोर = 889

import random
def h(b):
    s=0
    for x in b:
        try:
            s+=int(x)
        except: 
            s+=0
    return s
def d(i):g=i.split("/");a=g[0];b=g[1].split(" ");return(a,b)
def p(a,_,j):
    v=[]
    for x in _:
        try:
            v.append(int(x))
        except: 
            v.append(0)
    try:
        v=v[:j+1]+[int(a)]+v[j+1:]
    except: 
        v=v[:j+1]+[a]+v[j+1:]
    r1=[[]];b=[x for x in v];m=range(len(b)+1)
    for k in m:
        for i in m:
            for j in range(i):
                c = b[j:i + 1]
                if len(c)%2==0 and c==c[::-1] and 0 not in c:r1.append(c)
        b.insert(0, b.pop())
    q1=max(r1,key=len)
    r2=[[]];b=[x for x in v];m=range(len(b)+1)
    for k in m:
        for i in m:
            for j in range(i):
                c = b[j:i + 1]
                if len(c)>2 and len(c)%2==1 and c==c[::-1] and "+" in c and 0 not in c:r2.append(c)
        b.insert(0, b.pop())
    q2=max(r2,key=h)
    with open('f.log', 'a') as f:f.write('pal '+str(_)+' : '+str(q1)+' : '+str(q2)+'\n')
    if q2!=[]:return 100+h(q2)
    else:return len(q1)
i=raw_input()
(a,b)=d(i)
if a in ['C','B']:print('0')
elif a=='-':print("0 y" if random.randint(0, 1) == 1 else "0 n")
else:q,j=max((p(a,b,j),j)for j in range(len(b)));print(str(j))

मैंने पाया कि नियंत्रक:

  • जब स्कोर 1500 से अधिक हो जाता है तो क्रैश;
  • ठीक से एक ही मामलों में परमाणुओं को विलय नहीं करता है।

0

पायथन, रैंडमबोट, स्कोर = 7.95

कुछ भी नहीं फैंसी, बस एक यादृच्छिक बॉट।

import random

game_input = raw_input().split("/")
current_atom = game_input[0]
board = game_input[1].split(" ")

if current_atom != "-":
    print(random.randint(0, len(board) - 1))
else:
    random_choice = " y" if random.randint(0, 1) == 1 else " n"
    print(str(random.randint(0, len(board) - 1)) + random_choice)

0

पायथन, बैडप्लेयर, स्कोर = 21.45

import random

try:
    raw_input
except:
    raw_input = input

game_input = raw_input().split("/")
current_atom = game_input[0]
board = game_input[1].split(" ")

def get_chain(board, base):
    chain = []
    board = board[:]
    try:
        while board[base] == board[base + 1]:
            chain = [board[base]] + chain + [board[base + 1]]
            del board[base]
            del board[base]
            base -= 1
    except IndexError:
        pass
    return chain

def biggest_chain(board):
    chains = []
    base = 0
    i = 0
    while i < len(board) - 1:
        chains.append([i, get_chain(board, i)])
        i += 1
    return sorted(chains, key=lambda x: len(x[1]) / 2)[-1]

def not_in_chain():
    a, b = biggest_chain(board)
    if len(b) == 0:
        print(random.randint(0, len(board) - 1))
    elif random.randint(0, 1) == 0:
        print(random.randint(a + len(b)/2, len(board) - 1))
    else:
        try:
            print(random.randint(0, a - len(b)/2 - 1))
        except:
            print(random.randint(a + len(b)/2, len(board) - 1))

if current_atom in "+B":
    a, b = biggest_chain(board)
    if len(b) == 0:
        print(0)
    else:
        print(a)
elif current_atom == "C":
    not_in_chain()
elif current_atom == "-":
    a, b = biggest_chain(board)
    if len(b) == 0:
        print(str(random.randint(0, len(board) - 1)) + " n")
    elif random.randint(0, 1) == 0:
        print(str(random.randint(a + len(b)/2, len(board) - 1)) + " n")
    else:
        try:
            print(str(random.randint(0, a - len(b)/2 - 1)) + " n")
        except:
            print(str(random.randint(0, len(board) - 1)) + " n")
else:
    not_in_chain()

बस एक बहुत बुरा बॉट जो अक्सर नियंत्रक को दुर्घटनाग्रस्त करता है


यह नियंत्रक को कैसे दुर्घटनाग्रस्त करता है? और अगर ऐसा होता है, तो यह नियंत्रक, या आपके बॉट के साथ एक समस्या है?
mbomb007

@ mbomb007 मुझे याद नहीं है कि यह दुर्घटनाग्रस्त क्यों हुआ, लेकिन क्रैश कंट्रोलर में थे
TuxCrafting

इस बॉट को बिना किसी बग के काम करना चाहिए, बस अपडेट की गई "स्टडिन" चीज़ को समायोजित करने के लिए कोड को थोड़ा बदलना चाहिए।
1
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.