ОНОВЛЕННЯ: Додано рамку Python для початку роботи.
Космічну станцію наздогнали дробарки. Ви повинні направити стільки наших дорогих і тендітних технологічних ботів під назвою "кролики" на телевізор виходу, перш ніж станція самознищиться, але дробарки-боти патрулюють коридори.
Вашій програмі надається карта ASCII, і кожен поворот повідомляється, де знаходяться дробарки та ваші нинішні кролики. Тоді ваша програма повинна перемістити ваших кроликів у напрямку телевізора виходу, уникаючи дробарок.
Виконання
Запустіть контролер Python 2 за допомогою:
python controller.py <mapfile> <turns> <seed> <runs> <prog>...
<prog> can be <interpreter> <yourprog> or similar.
Насіння є невеликим цілим числом, яке використовується для дробарки та вашої програми PRNG, щоб запуски повторювалися. Ваша програма повинна виконувати послідовно незалежно від фактичного використовуваного насіння. Якщо насіння дорівнює нулю, контролер буде використовувати випадкове насіння для кожного запуску.
Контролер запустить вашу програму з ім'ям текстового файлу карти та насіннєвим файлом як аргументи. Наприклад:
perl wandomwabbits.pl large.map 322
Якщо у вашій програмі використовується PRNG, слід ініціалізувати її із заданим насінням. Потім контролер надсилає ваші оновлення програми через STDIN і читає ваші кролики рухом через STDOUT.
Кожен виток контролера видаватиме 3 лінії:
turnsleft <INT>
crusher <x,y> <movesto|crushes> <x,y>; ...
rabbits <x,y> <x,y> ...
потім чекає, коли програма виведе один рядок:
move <x,y> to <x,y>; ...
ОНОВЛЕННЯ: Ваша програма матиме 2 секунди для ініціалізації до того, як контролер надішле перші рядки.
Якщо вашій програмі потрібно більше 0,5 секунди, щоб відповісти рухами після введення місця розташування кролика контролера, контролер вийде.
Якщо у сітці немає кроликів, лінія кролів не матиме значень, і ваша програма повинна вивести голу лінію "переміщення".
Не забудьте щороку вимивати вихідний потік програми, або контролер може зависнути.
Приклад
прог вхід:
turnsleft 35
crusher 22,3 crushes 21,3; 45,5 movesto 45,4
rabbits 6,4 8,7 7,3 14,1 14,2 14,3
прог. вихід:
move 14,3 to 14,4; 14,2 to 14,3; 6,4 to 7,4
Логіка контролера
Логіка кожного кроку:
- якщо повороти наліво дорівнюють нулю, роздрукуйте бал та вийдіть.
- до кожної порожньої пускової клітини додайте кролика, якщо дробарки не видно.
- для кожної дробарки визначте напрямок руху (див. нижче).
- для кожної дробарки рухайтесь, якщо це можливо.
- якщо дробарка знаходиться на місці кролика, видаліть кролика.
- вихідний поворотний рух, дії дробарки та місця кролика для програмування.
- читати запити на переміщення кроликів з програми.
- якщо кролика немає або переміщення неможливо, пропустіть.
- побудувати кожне нове місце розташування кроликів.
- якщо кролик потрапить на дробарку, кролика знищують.
- якщо кролик знаходиться у телевізійному виїзді, кроля видаляють і кількість балів збільшується.
- якщо кролики стикаються, їх обох знищують.
Кожна дробарка завжди має напрямок (один з NSEW). Дробарка слідує цій логіці навігації кожного кроку:
- Якщо один або кілька кроликів видно в будь-якому з 4 ортогональних напрямків, змініть напрямок на одного з найближчих кроликів. Зауважте, що дробарки не бачать повз іншу дробарку.
- інше вибирайте випадковим чином між відкритими вперед, вліво, вправо, якщо це можливо.
- в іншому випадку, якщо перешкоди (настінні або інші дробарки) спереду, ліворуч та праворуч, задайте напрямок позаду.
Потім для кожної дробарки:
- Якщо в новому напрямку дробарки немає перешкод, рухайтесь (і, можливо, розчавлюєте).
Символи на карті
Карта являє собою прямокутну сітку символів ASCII. Карта складається з стін
#, коридору , позицій кроликів s, виїзних телепортерів eта місць відправлення дробарок c. Лівий верхній кут - розташування (0,0).
Невелика карта
###################
# c #
# # ######## # # ##
# ###s # ####e#
# # # # ## ## #
### # ### # ## # #
# ## #
###################
Тестова карта
#################################################################
#s ############################ s#
## ## ### ############ # ####### ##### ####### ###
## ## ### # # ####### ########## # # #### ###### ###
## ## ### # ############ ####### ########## ##### ####### ###
## ## ## # ####### ########## # # ##### #### #
## ### #### #### ######## ########## ##### #### ## ###
######### #### ######## ################ ####### #### ###
######### ################# ################ c ####### ###
######### ################## ####### ####### ###########
######### ################## ######## ####### ###########
##### ### c ###### ###################
# #### ### # # # # # # # # # # ###### ############## #
# ####### #### ### #### ##### ## #
# #### ### # # # # # # # # # # ### # ### ######### #
##### ### #### ### ##### ### # ######## ####
############## ### # # # # # # # # # # ####### ## ####### ####
#### #### #### ### ### # # ### ###### ####
## ### # # # # # # # # # # ### ### # ### ##### ####
##### ######## ### # # # ##### # # # # ### ### # ##### #### ####
##### ##### ###### c # ### ### ###### ### ####
## c ######################### ### ##### ####### ### ####
##### # ### ####### ######## ### ##### c ## ## ####
##### # ####### ########## ## ######## # ######## ## ####
######### # ####### ## # ## # # # ##### # ####
### ##### # ### # ############## # ### # ### ## # ####
# ## # ### ### # ############## # ### ##### ##### ## ####
### ## ## # ### # ######## #
#s ## ###################################################e#
#################################################################
Приклад великого запуску карти
Оцінка
Щоб оцінити свою програму, запустіть контролер з тестовою картою, 500 витків, 5 пробіжок і насінням 0. Ваш бал - це загальна кількість кроликів, успішно телепортуваних зі станції в безпеку. У разі вирівнювання, відповідь з найбільшою кількістю голосів виграє.
Ваша відповідь повинна містити заголовок із зазначенням назви, мови, якою використовується та оцінка. В тілі відповідей, будь ласка, включіть результат оцінки контролера разом із номерами насіння, щоб інші могли повторити ваш пробіг. Наприклад:
Running: controller.py small.map 100 0 5 python bunny.py
Run Seed Score
1 965 0
2 843 6
3 749 11
4 509 10
5 463 3
Total Score: 30
Ви можете використовувати стандартні та вільно доступні бібліотеки, але стандартні лазівки заборонені. Ви не повинні оптимізувати свою програму для заданого насіння, підрахунку поворотів, набору функцій карти чи інших параметрів. Я залишаю за собою право змінити карту, підрахунок поворотів та висівок, якщо я підозрюю про порушення цього правила.
Код контролера
#!/usr/bin/env python
# Control Program for the Rabbit Runner on PPCG.
# Usage: controller.py <mapfile> <turns> <seed> <runs> <prog>...
# Tested on Python 2.7 on Ubuntu Linux. May need edits for other platforms.
# v1.0 First release.
# v1.1 Fixed crusher reporting bug.
# v1.2 Control for animation image production.
# v1.3 Added time delay for program to initialise
import sys, subprocess, time, re, os
from random import *
# Suggest installing Pillow if you don't have PIL already
try:
from PIL import Image, ImageDraw
except:
Image, ImageDraw = None, None
GRIDLOG = True # copy grid to run.log each turn (off for speed)
MKIMAGE = False # animation image creation (much faster when off)
IMGWIDTH = 600 # animation image width estimate
INITTIME = 2 # Allow 2 seconds for the program to initialise
point = complex # use complex numbers as 2d integer points
ORTH = [1, -1, 1j, -1j] # all 4 orthogonal directions
def send(proc, msg):
proc.stdin.write((msg+'\n').encode('utf-8'))
proc.stdin.flush()
def read(proc):
return proc.stdout.readline().decode('utf-8')
def cansee(cell):
# return a dict of visible cells containing robots with distances
see = {} # see[cell] = dist
robots = rabbits | set(crushers)
if cell in robots:
see[cell] = 0
for direc in ORTH:
for dist in xrange(1,1000):
test = cell + direc*dist
if test in walls:
break
if test in robots:
see[test] = dist
if test in crushers:
break # can't see past them
return see
def bestdir(cr, direc):
# Decide in best direction for this crusher-bot
seen = cansee(cr)
prey = set(seen) & rabbits
if prey:
target = min(prey, key=seen.get) # Find closest
vector = target - cr
return vector / abs(vector)
obst = set(crushers) | walls
options = [d for d in ORTH if d != -direc and cr+d not in obst]
if options:
return choice(options)
return -direc
def features(fname):
# Extract the map features
walls, crusherstarts, rabbitstarts, exits = set(), set(), set(), set()
grid = [line.strip() for line in open(fname, 'rt')]
grid = [line for line in grid if line and line[0] != ';']
for y,line in enumerate(grid):
for x,ch in enumerate(line):
if ch == ' ': continue
cell = point(x,y)
if ch == '#': walls.add(cell)
elif ch == 's': rabbitstarts.add(cell)
elif ch == 'e': exits.add(cell)
elif ch == 'c': crusherstarts.add(cell)
return grid, walls, crusherstarts, rabbitstarts, exits
def drawrect(draw, cell, scale, color, size=1):
x, y = int(cell.real)*scale, int(cell.imag)*scale
edge = int((1-size)*scale/2.0 + 0.5)
draw.rectangle([x+edge, y+edge, x+scale-edge, y+scale-edge], fill=color)
def drawframe(runno, turn):
if Image == None:
return
scale = IMGWIDTH/len(grid[0])
W, H = scale*len(grid[0]), scale*len(grid)
img = Image.new('RGB', (W,H), (255,255,255))
draw = ImageDraw.Draw(img)
for cell in rabbitstarts:
drawrect(draw, cell, scale, (190,190,255))
for cell in exits:
drawrect(draw, cell, scale, (190,255,190))
for cell in walls:
drawrect(draw, cell, scale, (190,190,190))
for cell in crushers:
drawrect(draw, cell, scale, (255,0,0), 0.8)
for cell in rabbits:
drawrect(draw, cell, scale, (0,0,255), 0.4)
img.save('anim/run%02uframe%04u.gif' % (runno, turn))
def text2point(textpoint):
# convert text like "22,6" to point object
return point( *map(int, textpoint.split(',')) )
def point2text(cell):
return '%i,%i' % (int(cell.real), int(cell.imag))
def run(number, nseed):
score = 0
turnsleft = turns
turn = 0
seed(nseed)
calltext = program + [mapfile, str(nseed)]
process = subprocess.Popen(calltext,
stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=errorlog)
time.sleep(INITTIME)
rabbits.clear()
crushers.clear()
crushers.update( dict((cr, choice(ORTH)) for cr in crusherstarts) )
while turnsleft > 0:
# for each empty start cell, add a rabbit if no crusher in sight.
for cell in rabbitstarts:
if cell in rabbits or set(cansee(cell)) & set(crushers):
continue
rabbits.add(cell)
# write the grid to the runlog and create image frames
if GRIDLOG:
for y,line in enumerate(grid):
for x,ch in enumerate(line):
cell = point(x,y)
if cell in crushers: ch = 'X'
elif cell in rabbits: ch = 'o'
runlog.write(ch)
runlog.write('\n')
runlog.write('\n\n')
if MKIMAGE:
drawframe(number, turn)
# for each crusher, decide move direction.
for cr, direc in crushers.items():
crushers[cr] = bestdir(cr, direc)
# for each crusher, move if possible.
actions = []
for cr, direc in crushers.items():
newcr = cr + direc
if newcr in walls or newcr in crushers:
continue
crushers[newcr] = crushers.pop(cr)
action = ' movesto '
# if crusher is at a rabbit location, remove rabbit.
if newcr in rabbits:
rabbits.discard(newcr)
action = ' crushes '
actions.append(point2text(cr)+action+point2text(newcr))
# output turnsleft, crusher actions, and rabbit locations to program.
send(process, 'turnsleft %u' % turnsleft)
send(process, 'crusher ' + '; '.join(actions))
rabbitlocs = [point2text(r) for r in rabbits]
send(process, ' '.join(['rabbits'] + rabbitlocs))
# read rabbit move requests from program.
start = time.time()
inline = read(process)
if time.time() - start > 0.5:
print 'Move timeout'
break
# if a rabbit not exist or move not possible, no action.
# if rabbit hits a crusher, rabbit is destroyed.
# if rabbit is in exit teleporter, rabbit is removed and score increased.
# if two rabbits collide, they are both destroyed.
newrabbits = set()
for p1,p2 in re.findall(r'(\d+,\d+)\s+to\s+(\d+,\d+)', inline):
p1, p2 = map(text2point, [p1,p2])
if p1 in rabbits and p2 not in walls:
if p2-p1 in ORTH:
rabbits.discard(p1)
if p2 in crushers:
pass # wabbit squished
elif p2 in exits:
score += 1 # rabbit saved
elif p2 in newrabbits:
newrabbits.discard(p2) # moving rabbit collision
else:
newrabbits.add(p2)
# plot each new location of rabbits.
for rabbit in newrabbits:
if rabbit in rabbits:
rabbits.discard(rabbit) # still rabbit collision
else:
rabbits.add(rabbit)
turnsleft -= 1
turn += 1
process.terminate()
return score
mapfile = sys.argv[1]
turns = int(sys.argv[2])
argseed = int(sys.argv[3])
runs = int(sys.argv[4])
program = sys.argv[5:]
errorlog = open('error.log', 'wt')
runlog = open('run.log', 'wt')
grid, walls, crusherstarts, rabbitstarts, exits = features(mapfile)
rabbits = set()
crushers = dict()
if 'anim' not in os.listdir('.'):
os.mkdir('anim')
for fname in os.listdir('anim'):
os.remove(os.path.join('anim', fname))
total = 0
print 'Running:', ' '.join(sys.argv)
print >> runlog, 'Running:', ' '.join(sys.argv)
fmt = '%10s %20s %10s'
print fmt % ('Run', 'Seed', 'Score')
for n in range(runs):
nseed = argseed if argseed else randint(1,1000)
score = run(n, nseed)
total += score
print fmt % (n+1, nseed, score)
print 'Total Score:', total
print >> runlog, 'Total Score:', totalКонтролер складає текстовий журнал запусків run.logта серії зображень у animкаталозі. Якщо ваша установка Python не може знайти бібліотеку зображень PIL (скачати як Подушка), зображення не будуть генеровані. Я анімував серію зображень за допомогою ImageMagick. Наприклад:
convert -delay 100 -loop 0 anim/run01* run1anim.gifЗапрошуємо розміщувати цікаві анімації чи зображення зі своєю відповіддю.
Ви можете вимкнути ці функції та пришвидшити контролер, встановивши GRIDLOG
= Falseта / або MKIMAGE = Falseв перших рядках програми контролера.
Пропоновані рамки Python
Щоб допомогти розпочати роботу, ось рамка в Python. Перший крок - прочитати у файлі карти та знайти шляхи до виходів. На кожному кроці має бути якийсь код, де зберігати дробарки, і код, який визначає, куди пересувати наших кроликів. Найпростіша стратегія для початку - переміщення кроликів до виходу з ігнорування дробарок - деякі кролівники можуть пройти.
import sys, re
from random import *
mapfile = sys.argv[1]
argseed = int(sys.argv[2])
seed(argseed)
grid = [line.strip() for line in open(mapfile, 'rt')]
#
# Process grid to find teleporters and paths to get there
#
while 1:
msg = sys.stdin.readline()
if msg.startswith('turnsleft'):
turnsleft = int(msg.split()[1])
elif msg.startswith('crusher'):
actions = re.findall(r'(\d+),(\d+) (movesto|crushes) (\d+),(\d+)', msg)
#
# Store crusher locations and movement so we can avoid them
#
elif msg.startswith('rabbits'):
moves = []
places = re.findall(r'(\d+),(\d+)', msg)
for rabbit in [map(int, xy) for xy in places]:
#
# Compute the best move for this rabbit
newpos = nextmoveforrabbit(rabbit)
#
moves.append('%u,%u to %u,%u' % tuple(rabbit + newpos))
print 'move ' + '; '.join(moves)
sys.stdout.flush()
