अद्यतन: आरंभ करने के लिए एक पायथन फ्रेमवर्क जोड़ा गया।
क्रेशर-बॉट्स द्वारा अंतरिक्ष-स्टेशन को पीछे छोड़ दिया गया है। स्टेशन से बाहर निकलने से पहले आप हमारे कई महंगे और नाजुक टेक-बॉट्स को "खरगोश" कह सकते हैं, जिसे स्टेशन से बाहर निकलने वाले टेलीकॉमर्स को भेजना चाहिए, लेकिन कोल्हू-बॉट गलियारों में गश्त लगा रहे हैं।
आपके प्रोग्राम को ASCII मैप दिया गया है, और प्रत्येक मोड़ पर बताया गया है कि कोल्हू-बॉट कहां हैं और आपके वर्तमान खरगोश हैं। क्रशर-बॉट्स से परहेज करते हुए आपके प्रोग्राम को तब अपने खरगोशों को एक्जिट टेलिफ़ोन की ओर ले जाना चाहिए।
क्रियान्वयन
अजगर 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निर्देशिका में छवियों की एक श्रृंखला बनाता है । यदि आपके पायथन इंस्टॉलेशन को PIL इमेज लाइब्रेरी (पिलो के रूप में डाउनलोड) नहीं मिल रही है, तो कोई भी इमेज जेनरेट नहीं होगी। मैं ImageMagick के साथ छवि श्रृंखला को एनिमेट कर रहा हूं। उदाहरण के लिए:
convert -delay 100 -loop 0 anim/run01* run1anim.gifआपके जवाब के साथ दिलचस्प एनिमेशन या चित्र पोस्ट करने के लिए आपका स्वागत है।
आप इन सुविधाओं को बंद कर सकते हैं और नियंत्रक प्रोग्राम की पहली कुछ पंक्तियों में सेटिंग GRIDLOG
= Falseऔर / या करके गति बढ़ा सकते हैं MKIMAGE = False।
सुझाया गया पायथन ढांचा
आरंभ करने में सहायता के लिए, यहां पाइथन में एक ढांचा है। पहला कदम नक्शा फ़ाइल में पढ़ना और बाहर निकलने के लिए रास्ते खोजना है। प्रत्येक मोड़ में स्टोर करने के लिए कुछ कोड होना चाहिए जहां क्रशर हैं, और कोड जो यह तय करता है कि हमारे खरगोशों को कहां स्थानांतरित किया जाए। के साथ शुरू करने के लिए सबसे सरल रणनीति खरगोशों को क्रशर की अनदेखी से बाहर निकलने की ओर बढ़ रही है - कुछ खरगोशों के माध्यम से मिल सकती है।
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()
