Tu tarea es hacer un bot que juegue Atomas , con la puntuación más alta.
Cómo funciona el juego:
El tablero de juego comienza con un anillo de 6 "átomos", con números que van desde 1
hasta3
. Puede "jugar" un átomo entre dos átomos, o en otro átomo, dependiendo del átomo mismo.
Puede tener un átomo normal o un átomo especial.
El átomo normal:
Puedes jugar un átomo normal entre dos átomos disponibles en el tablero.
Comienzas con átomos en el rango 1 to 3
, pero el rango aumenta en 1 una vez cada 40 movimientos (así que después de 40 movimientos, el rango se convierte 2 to 4
).
Si hay átomos en el tablero que son más bajos que el rango, tiene una 1 / no. of atoms of that number on the board
posibilidad de desovar.
Digamos que tienes 2
que jugar, y el tablero se ve así:
1 1 2 1
Coloquemos el 2
a la derecha del 1
.
El tablero ahora se convierte en:
1 1 2 1 2
Nota: el tablero se enrolla, por lo que 1
el extremo izquierdo está realmente al lado del2
del extremo derecho. Esto será importante más adelante.
Hay 4 tipos de átomos "especiales", y son:
El +
átomo:
Este átomo se juega entre dos átomos. Tiene una probabilidad de 1 en 5 de desovar.
Si los átomos en ambos lados del +
átomo son iguales, se produce la fusión. Así es como funciona:
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.
Ejemplo:
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].
Si los átomos en ambos lados del +
átomo son diferentes, entonces el +
permanece en el tablero.
Ejemplo:
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)
El -
átomo:
Este átomo se juega en otro átomo. Tiene una probabilidad de 1 en 10 de desovar.
El -
átomo elimina un átomo del tablero y le da la opción de:
- jugar el átomo eliminado la próxima ronda, o
- conviértelo en un átomo + para jugar la próxima ronda.
Ejemplo:
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)
El +
átomo negro (B
):
Este átomo se juega entre 2 átomos. Tiene una probabilidad de 1 en 80 de generar, y solo genera una vez que su puntaje> 750.
Este átomo es básicamente el mismo que el +
átomo, excepto que fusiona dos átomos cualquiera, incluso +
el de uno. A partir de entonces, sigue la +
regla (solo fusiona átomos juntos si los átomos en ambos lados del átomo fusionado son iguales).
El átomo fusionado como resultado del negro +
es igual a:
- el mayor número de átomos en la fusión + 3
4
si los dos átomos fusionados son+
de
Ejemplo:
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)
Otro ejemplo:
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)
El átomo clon (C
):
Este átomo se juega en otro átomo. Tiene una probabilidad de 1 en 60 de generar, y solo genera una vez que su puntaje> 1500.
El átomo de clonación te permite elegir un átomo y jugarlo la próxima ronda.
Ejemplo:
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
Aquí está mi versión del juego, en 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ómo funciona el bot:
Entrada
- Tu bot obtendrá 2 entradas: el átomo que está actualmente en juego y el estado del tablero.
- El átomo será así:
+
para un+
átomo-
para un-
átomoB
para un+
átomo negroC
para un átomo clon{atom}
para un átomo normal
- El estado del tablero será así:
atom 0 atom 1 atom 2... atom n
, con los átomos separados por espacios (atom n
vuelve aatom 1
, para simular un tablero de juego "en anillo")
- Estos dos estarán separados por a
/
.
Entradas de ejemplo:
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)
Salida
Producirá una cadena, dependiendo de cuál sea el átomo en juego.
Si el átomo está destinado a ser jugado entre dos átomos:
Emite el espacio en el que quieres jugar el átomo. Los espacios son como entre cada átomo, así:
atom 0, GAP 0, atom 1, GAP 1, atom 2, GAP 2... atom n, GAP N
(
gap n
indica que desea colocar el átomo entreatom 1
y el átomon
) Entonces, dé salida2
si desea reproducir el átomogap 2
.
- Si el átomo está destinado a ser jugado en un átomo:
- Emite el átomo con el que quieres jugar, así que
2
si quieres jugar con el átomoatom 2
.
- Emite el átomo con el que quieres jugar, así que
- Si el átomo es un
-
:- Emite el átomo en el que quieres jugar, seguido de un espacio, seguido de la
y/n
opción de convertir el átomo en un+
más tarde, así que2, "y"
si quieres jugar el átomoatom 2
y quieres convertirlo en a+
. Nota: esto requiere 2 entradas, en lugar de 1.
- Emite el átomo en el que quieres jugar, seguido de un espacio, seguido de la
Salidas de ejemplo:
(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)
- Para que el bot funcione, debe ir al
Popen
bit (al final del código) y reemplazarlo con lo que haga que su programa se ejecute como una lista Pythonic (por lo tanto, si su programa lo esderp.java
, reemplace["python", "bot.py"]
con["java", "derp.java"]
).
Especificaciones específicas de respuesta:
- Coloque el código completo de su bot en la respuesta. Si no encaja, no cuenta.
- Cada usuario tiene permitido tener más de 1 bot, sin embargo, todos deben estar en publicaciones de respuestas separadas.
- Además, dale un nombre a tu bot.
Tanteo:
- El bot con la puntuación más alta gana.
- Su bot será probado durante 20 juegos, y la puntuación final es el promedio de los 20 juegos.
- El desempate será el momento de la carga de la respuesta.
Entonces su respuesta tendrá el siguiente formato:
{language}, {bot name} Score: {score}
¡Buena suerte!
input_atom\natom0 atom1 .... atomn\n
para STDIN
+
en la lista de elementos, pero esto no se encuentra en ninguna parte de la descripción textual
+
para un-
átomo? Si eligey
, ¿se le garantizará obtener un+
próximo movimiento?