Một trò chơi có tỷ lệ nguyên tử

Nhiệm vụ của bạn là tạo một bot chơi Atomas , với số điểm cao nhất.

Cách trò chơi hoạt động:

Bảng trò chơi bắt đầu với một vòng gồm 6 "nguyên tử", với các số từ 1đến 3. Bạn có thể "chơi" một nguyên tử giữa hai nguyên tử hoặc trên một nguyên tử khác, tùy thuộc vào chính nguyên tử đó.

Bạn có thể có một nguyên tử bình thường, hoặc một nguyên tử đặc biệt.

Nguyên tử bình thường:

Bạn có thể chơi một nguyên tử bình thường giữa bất kỳ hai nguyên tử có sẵn trên bảng.

Bạn bắt đầu với các nguyên tử trong phạm vi 1 to 3, nhưng phạm vi tăng thêm 1 lần sau mỗi 40 lần di chuyển (vì vậy sau 40 lần di chuyển, phạm vi sẽ trở thành 2 to 4).

Nếu có các nguyên tử trên bảng thấp hơn phạm vi, nó có 1 / no. of atoms of that number on the boardcơ hội sinh sản.

Giả sử bạn có một 2trò chơi và bảng trông như thế này:

   1 1 2 1

Hãy đặt 2bên phải của 1.

Hội đồng quản trị bây giờ trở thành:

   1 1 2 1 2

Lưu ý: bảng bao quanh, do đó, 1ở phía bên trái thực sự là bên cạnh 2bên phải. Điều này sẽ quan trọng sau này.

Có 4 loại nguyên tử "đặc biệt" và chúng là:

Nguyên +tử:

Nguyên tử này được chơi giữa hai nguyên tử. Nó có 1 trong 5 cơ hội sinh sản.

Nếu các nguyên tử ở cả hai phía của +nguyên tử giống nhau, phản ứng tổng hợp xảy ra. Đây là cách nó hoạt động:

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.

Thí dụ:

   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].

Nếu các nguyên tử ở cả hai phía của +nguyên tử là khác nhau, thì +ở lại trên bảng.

Thí dụ:

   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)

Nguyên -tử:

Nguyên tử này được chơi trên một nguyên tử khác. Nó có 1 trong 10 cơ hội sinh sản.

Nguyên -tử loại bỏ một nguyên tử khỏi bảng và cho bạn lựa chọn:

• chơi nguyên tử bị loại bỏ vòng tiếp theo, hoặc
• biến nó thành một nguyên tử + để chơi vòng tiếp theo.

Thí dụ:

   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)

Nguyên +tử đen (B ):

Nguyên tử này được chơi giữa 2 nguyên tử. Nó có 1 trong 80 cơ hội sinh sản và chỉ sinh sản một khi điểm của bạn> 750.

Nguyên tử này về cơ bản giống như +nguyên tử, ngoại trừ việc nó hợp nhất bất kỳ hai nguyên tử nào với nhau, thậm chí +là. Từ đó trở đi, nó tuân theo +quy luật (nó chỉ hợp nhất các nguyên tử lại với nhau nếu các nguyên tử ở cả hai phía của nguyên tử hợp nhất là bằng nhau).

Nguyên tử hợp nhất là kết quả của màu đen +bằng:

• nguyên tử số cao hơn trong phản ứng tổng hợp + 3
• 4nếu hai nguyên tử hợp nhất là +của

Thí dụ:

   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)

Một vi dụ khac:

   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)

Nguyên tử nhân bản ( C):

Nguyên tử này được chơi trên một nguyên tử khác. Nó có 1 trong 60 cơ hội sinh sản và chỉ sinh sản một khi điểm của bạn> 1500.

Nguyên tử nhân bản cho phép bạn chọn một nguyên tử và chơi nó vào vòng tiếp theo.

Thí dụ:

   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

Đây là bản dựng của tôi trong trò chơi, trong Python 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()

Cách thức hoạt động của bot:

Đầu vào

• Bot của bạn sẽ nhận được 2 đầu vào: nguyên tử hiện đang chơi và trạng thái của bảng.
• Nguyên tử sẽ như vậy:
  • +cho một +nguyên tử
  • -cho một -nguyên tử
  • Bcho một +nguyên tử đen
  • C cho một nguyên tử nhân bản
  • {atom} cho một nguyên tử bình thường
• Trạng thái của hội đồng quản trị sẽ như vậy:
  • atom 0 atom 1 atom 2... atom n, với các nguyên tử được phân tách bằng khoảng trắng ( atom nkết thúc trở lại atom 1, để mô phỏng bảng trò chơi "vòng")
• Hai cái này sẽ được phân tách bằng a /.

Ví dụ đầu vào:

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)

Đầu ra

• Bạn sẽ xuất ra một chuỗi, tùy thuộc vào nguyên tử đang chơi là gì.

  • Nếu nguyên tử có nghĩa là được chơi giữa hai nguyên tử:

    • Xuất ra khoảng trống bạn muốn chơi nguyên tử. Các khoảng trống giống như ở giữa mỗi nguyên tử, như vậy:

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

      ( gap ncho biết bạn muốn đặt nguyên tử giữa atom 1và nguyên tử n) Vì vậy, hãy xuất 2nếu bạn muốn chơi nguyên tử trên gap 2.

  • Nếu nguyên tử có nghĩa là được chơi trên một nguyên tử:
    • Xuất ra nguyên tử mà bạn muốn chơi trên đó, vì vậy 2nếu bạn muốn chơi nguyên tử trên atom 2.
  • Nếu nguyên tử là -:
    • Xuất ra nguyên tử mà bạn muốn chơi, theo sau là khoảng trắng, sau đó là y/nlựa chọn biến nguyên tử thành +sau, vì vậy 2, "y"nếu bạn muốn chơi nguyên tử trên atom 2và bạn muốn biến nó thành a +. Lưu ý: điều này đòi hỏi 2 đầu vào, thay vì 1.

Kết quả ví dụ:

(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)

• Để làm cho bot hoạt động, bạn phải đi đến Popenbit (ở cuối đoạn mã) và thay thế nó bằng bất cứ điều gì làm cho chương trình của bạn chạy như một danh sách Pythonic (vì vậy nếu chương trình của bạn là derp.java, hãy thay thế ["python", "bot.py"]bằng ["java", "derp.java"]).

Thông số kỹ thuật cụ thể của câu trả lời:

• Đặt toàn bộ mã bot của bạn vào câu trả lời. Nếu nó không phù hợp, nó không được tính.
• Mỗi người dùng được phép có nhiều hơn 1 bot, tuy nhiên, tất cả họ nên ở trong các bài trả lời riêng biệt.
• Ngoài ra, đặt tên cho bot của bạn.

Ghi điểm:

• Bot có số điểm cao nhất sẽ thắng.
  • Bot của bạn sẽ được kiểm tra 20 trò chơi và điểm cuối cùng là trung bình của 20 trò chơi.
• Bộ ngắt kết nối sẽ là thời điểm tải lên câu trả lời.

• Vì vậy, câu trả lời của bạn sẽ được định dạng như thế này:

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

Chúc may mắn!

Python ,raftBot, Điểm = 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))

Tôi thấy rằng bộ điều khiển:

• gặp sự cố khi điểm vượt quá 1500;
• không hợp nhất các nguyên tử trong các trường hợp tương tự.

Python, RandomBot, Điểm = 7.95

Không có gì quá lạ mắt, chỉ là một bot ngẫu nhiên.

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)

Python, BadPlayer, Điểm = 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()

Chỉ là một bot rất xấu thường làm cho bộ điều khiển bị sập