Image Battle of Colors


33

ขอแสดงความยินดีกับ @kuroineko เพื่อผลงานที่ดีที่สุดและได้รับรางวัล 200 รางวัลจาก @TheBestOne (นักกีฬายอดเยี่ยม!)

เขียนโปรแกรมให้มีสีมากที่สุดของภาพก่อนที่โปรแกรมฝ่ายค้านจะทำ

กฎโดยย่อ

  • โปรแกรมของคุณจะได้รับรูปภาพสีของคุณและจำนวนเต็ม N
  • ทุกครั้งที่คุณได้รับการอัปเดตพิกเซลจากโปรแกรมอื่น ๆ และถามถึงการอัพเดท N ของคุณ
  • คุณสามารถอัปเดตพิกเซลสีขาวที่อยู่ถัดจากพิกเซลสีของคุณ
  • โปรแกรมที่เพิ่มจำนวนพิกเซลมากที่สุดชนะ

กฎในรายละเอียด

โปรแกรมของคุณจะได้รับชื่อไฟล์ภาพ PNG, สีบ้านและตัวเลข N จำนวน N คือจำนวนพิกเซลสูงสุดที่โปรแกรมของคุณอาจใช้สีในแต่ละตา

ตัวอย่าง: MyProg arena.png (255,0,0) 30

ภาพอินพุตจะเป็นรูปสี่เหลี่ยมผืนผ้าที่มีด้านข้างยาวระหว่าง 20 ถึง 1,000 พิกเซล มันจะประกอบด้วยพิกเซลสีดำสีขาวและสี โปรแกรมของคุณอาจเลือกลำดับพิกเซลสีขาวเป็นสีของคุณเองโดยมีเงื่อนไขว่าพิกเซลใหม่แต่ละพิกเซลต้องมีพิกเซลเพื่อนบ้านอย่างน้อยหนึ่งในสี่ของพิกเซลสีของคุณเอง รูปภาพจะมีสีของคุณอย่างน้อยหนึ่งพิกเซล นอกจากนี้ยังอาจมีพิกเซลสีที่ไม่ได้กำหนดโปรแกรมไว้ ไม่ได้ใช้ช่องอัลฟา

เป้าหมายของคุณคือเพื่อป้องกันคู่ต่อสู้ของคุณและเขียนสีของคุณเป็นพิกเซลมากเท่าที่คุณสามารถ

แต่ละเทิร์นโปรแกรมของคุณจะยอมรับ 1 หรือมากกว่าหนึ่งบรรทัดข้อความบน STDIN และเขียนบรรทัดที่ประกอบด้วยพิกัดพิกเซลบน STDOUT จำไว้ว่าให้กำหนด STDOUT เป็น unbuffered หรือล้างบัฟเฟอร์ STDOUT ในแต่ละเทิร์น

ลำดับของผู้เล่นที่เรียกว่าเทิร์นแต่ละเทิร์นจะถูกสุ่มเลือก ซึ่งหมายความว่าฝ่ายตรงข้าม (หรือโปรแกรมของคุณ) อาจมี 2 รอบติดต่อกัน

โปรแกรมของคุณจะถูกส่งcolour (N,N,N) chose X,Y X,Y ... X,Yข้อความข้อมูลที่อธิบายพิกเซลที่กรอกในโปรแกรมเครื่องเล่น หากผู้เล่นไม่มีการเคลื่อนไหวหรือไม่มีการเคลื่อนไหวที่ถูกต้องคุณจะไม่ได้รับข้อความเกี่ยวกับการเคลื่อนไหวของผู้เล่น โปรแกรมของคุณจะถูกส่งข้อความเกี่ยวกับการเคลื่อนไหวที่คุณยอมรับ (ถ้าคุณระบุการเคลื่อนไหวที่ถูกต้องอย่างน้อยหนึ่งครั้ง) พิกเซล 0,0 อยู่ที่มุมซ้ายบนของภาพ

เมื่อได้รับpick pixelsโปรแกรมของคุณจะแสดงผลX,Y X,Y ... X,Yได้สูงสุด N พิกเซล (อนุญาตให้ใช้สตริงที่ว่างซึ่งประกอบด้วย '\ n' เท่านั้น) พิกเซลจะต้องอยู่ในลำดับของการลงจุด หากพิกเซลไม่ถูกต้องพิกเซลนั้นจะถูกละเว้นและจะไม่อยู่ในรายงานต่อผู้เล่น โปรแกรมของคุณมีเวลา 2 วินาทีในการเริ่มต้นหลังจากที่เริ่ม แต่เพียง 0.1 วินาทีเพื่อตอบด้วยคำตอบทุกเทิร์นมิฉะนั้นมันจะพลาดเทิร์นนั้น การอัปเดตพิกเซลที่ส่งหลังจาก 0.1 วินาทีจะบันทึกข้อผิดพลาด หลังจาก 5 ข้อผิดพลาดโปรแกรมของคุณถูกระงับและจะไม่ถูกส่งการปรับปรุงหรือpick pixelsการร้องขอ

เมื่อโปรแกรมการตัดสินได้รับตัวเลือกพิกเซลที่ว่างเปล่าหรือไม่ถูกต้องจากทุกโปรแกรมของผู้เล่นที่ไม่ถูกระงับภาพจะถูกพิจารณาว่าสมบูรณ์และโปรแกรมจะถูกส่งข้อความ "exit" โปรแกรมจะต้องยุติลงหลังจากได้รับ "ทางออก"

เกณฑ์การให้คะแนน

ผู้ตัดสินจะทำคะแนนหลังจากภาพเสร็จสมบูรณ์ คะแนนของคุณจะเป็นจำนวนพิกเซลที่อัปเดตแล้วหารด้วยการจับพิกเซลเฉลี่ยรอบนั้นซึ่งแสดงเป็นเปอร์เซ็นต์

จำนวนพิกเซลที่เพิ่มลงในภาพโดยเครื่องเล่นของคุณคือ A จำนวนพิกเซลทั้งหมดที่เพิ่มโดยเครื่องเล่น P ทั้งหมดคือ T avg = T/P score = 100*A/avg

โพสต์คะแนน

มีการให้คู่ต่อสู้อ้างอิง "The Blob" สำหรับแต่ละคำตอบให้ตั้งชื่อบอทของคุณด้วยชื่อภาษาและคะแนนของคุณ (โดยเฉลี่ยที่เกิดเหตุ 1 ถึง 4) กับคู่ต่อสู้อ้างอิง รูปภาพหรืออนิเมชั่นของหนึ่งในการต่อสู้ของคุณก็ดีเช่นกัน ผู้ชนะคือโปรแกรมที่มีคะแนนสูงสุดเทียบกับบอตอ้างอิง

ถ้า Blob พิสูจน์ให้ชนะง่ายเกินไปฉันอาจเพิ่มรอบที่สองพร้อมกับคู่ต่อสู้อ้างอิงที่แข็งแกร่งกว่า

คุณอาจต้องการทดสอบกับโปรแกรมผู้เล่น 4 โปรแกรมขึ้นไป คุณสามารถทดสอบบอตของคุณจากบอตอื่น ๆ ที่โพสต์เป็นคำตอบ

ผู้พิพากษา

โปรแกรมผู้ตัดสินต้องใช้ Python Imaging Library (PIL) ทั่วไปและควรติดตั้งได้ง่ายจากตัวจัดการแพ็คเกจระบบปฏิบัติการของคุณบน Linux ฉันมีรายงานว่า PIL ใช้งานไม่ได้กับ 64 บิต Python บน Windows 7 ดังนั้นโปรดตรวจสอบว่า PIL จะทำงานให้คุณก่อนที่จะเริ่มการท้าทายนี้หรือไม่ (อัปเดต 2015-01-25)

#!/usr/bin/env python
# Judge Program for Image Battle challenge on PPCG.
# Runs on Python 2.7 on Ubuntu Linux. May need edits for other platforms.
# V1.0 First release.
# V1.1 Added Java support
# V1.2 Added Java inner class support
# usage: judge cfg.py
import sys, re, random, os, shutil, subprocess, datetime, time, signal
from PIL import Image

ORTH = ((-1,0), (1,0), (0,-1), (0,1))
def place(loc, colour):
    # if valid, place colour at loc and return True, else False
    if pix[loc] == (255,255,255):
        plist = [(loc[0]+dx, loc[1]+dy) for dx,dy in ORTH]
        if any(pix[p]==colour for p in plist if 0<=p[0]<W and 0<=p[1]<H):
            pix[loc] = colour
            return True
    return False

def updateimage(image, msg, bot):
    if not re.match(r'(\s*\d+,\d+)*\s*', msg):
        return []
    plist = [tuple(int(v) for v in pr.split(',')) for pr in msg.split()]
    plist = plist[:PIXELBATCH]
    return [p for p in plist if place(p, bot.colour)]

class Bot:
    botlist = []
    def __init__(self, name, interpreter=None, colour=None):
        self.prog = name
        self.botlist.append(self)
        callarg = re.sub(r'\.class$', '', name)  # Java fix
        self.call = [interpreter, callarg] if interpreter else [callarg]
        self.colour = colour
        self.colstr = str(colour).replace(' ', '')
        self.faults = 0
        self.env = 'env%u' % self.botlist.index(self)
        try: os.mkdir(self.env)
        except: pass
        if name.endswith('.class'): # Java inner class fix
            rootname = re.sub(r'\.class$', '', name)
            for fn in os.listdir('.'):
                if fn.startswith(rootname) and fn.endswith('.class'):
                    shutil.copy(fn, self.env)
        else:
            shutil.copy(self.prog, self.env)
        shutil.copy(imagename, self.env)
        os.chdir(self.env)
        args = self.call + [imagename, self.colstr, `PIXELBATCH`]
        self.proc = subprocess.Popen(args, stdin=subprocess.PIPE, 
            stdout=subprocess.PIPE, stderr=subprocess.PIPE)
        os.chdir('..')
    def send(self, msg):
        if self.faults < FAULTLIMIT:
            self.proc.stdin.write(msg + '\n')
            self.proc.stdin.flush()
    def read(self, timelimit):
        if self.faults < FAULTLIMIT:
            start = time.time()
            inline = self.proc.stdout.readline()
            if time.time() - start > timelimit:
                self.faults += 1
                inline = ''
            return inline.strip()
    def exit(self):
        self.send('exit')

from cfg import *
for i, (prog, interp) in enumerate(botspec):
    Bot(prog, interp, colourspec[i])

image = Image.open(imagename)
pix = image.load()
W,H = image.size

time.sleep(INITTIME)
total = 0
for turn in range(1, MAXTURNS+1):
    random.shuffle(Bot.botlist)
    nullbots = 0
    for bot in Bot.botlist:
        bot.send('pick pixels')
        inmsg = bot.read(TIMELIMIT)
        newpixels = updateimage(image, inmsg, bot)
        total += len(newpixels)
        if newpixels:
            pixtext = ' '.join('%u,%u'%p for p in newpixels)
            msg = 'colour %s chose %s' % (bot.colstr, pixtext)
            for msgbot in Bot.botlist:
                msgbot.send(msg)
        else:
            nullbots += 1
    if nullbots == len(Bot.botlist):
        break
    if turn % 100 == 0: print 'Turn %s done %s pixels' % (turn, total)
for msgbot in Bot.botlist:
    msgbot.exit()

counts = dict((c,f) for f,c in image.getcolors(W*H))
avg = 1.0 * sum(counts.values()) / len(Bot.botlist)
for bot in Bot.botlist:
    score = 100 * counts[bot.colour] / avg
    print 'Bot %s with colour %s scored %s' % (bot.prog, bot.colour, score)
image.save(BATTLE+'.png')

ตัวอย่างการกำหนดค่า - cfg.py

BATTLE = 'Green Blob vs Red Blob'
MAXTURNS = 20000
PIXELBATCH = 10
INITTIME = 2.0
TIMELIMIT = 0.1
FAULTLIMIT = 5

imagename = 'arena1.png'

colourspec = (0,255,0), (255,0,0)

botspec = [
    ('blob.py', 'python'),
    ('blob.py', 'python'),
    ]

The Blob - คู่ต่อสู้อ้างอิง

# Blob v1.0 - A reference opponent for the Image Battle challenge on PPCG.
import sys, os
from PIL import Image

image = Image.open(sys.argv[1])
pix = image.load()
W,H = image.size
mycolour = eval(sys.argv[2])
pixbatch = int(sys.argv[3])

ORTH = ((-1,0), (1,0), (0,-1), (0,1))
def canchoose(loc, colour):
    if pix[loc] == (255,255,255):
        plist = [(loc[0]+dx, loc[1]+dy) for dx,dy in ORTH]
        if any(pix[p]==colour for p in plist if 0<=p[0]<W and 0<=p[1]<H):
            return True
    return False

def near(loc):
    plist = [(loc[0]+dx, loc[1]+dy) for dx,dy in ORTH]
    pboard = [p for p in plist if 0<=p[0]<W and 0<=p[1]<H]
    return [p for p in pboard if pix[p] == (255,255,255)]

def updateimage(image, msg):
    ctext, colourtext, chose, points = msg.split(None, 3)
    colour = eval(colourtext)
    plist = [tuple(int(v) for v in pr.split(',')) for pr in points.split()]
    for p in plist:
        pix[p] = colour
        skin.discard(p)
        if colour == mycolour:
            for np in near(p):
                skin.add(np)

board = [(x,y) for x in range(W) for y in range(H)]
skin = set(p for p in board if canchoose(p, mycolour))

while 1:
    msg = sys.stdin.readline()
    if msg.startswith('colour'):
        updateimage(image, msg.strip())
    if msg.startswith('pick'):
        plen = min(pixbatch, len(skin))
        moves = [skin.pop() for i in range(plen)]
        movetext = ' '.join('%u,%u'%p for p in moves)
        sys.stdout.write(movetext + '\n')
        sys.stdout.flush()
    if msg.startswith('exit'):
        break

image.save('blob.png')

อารีน่า 1

arena1.png

อารีน่า 2

arena2.png

อารีน่า 3

arena3.png

สนามกีฬา 4

arena4.png

ตัวอย่างการต่อสู้ - Blob กับ Blob

การต่อสู้ครั้งนี้มีผลลัพธ์ที่คาดการณ์ได้:

Bot blob.py with colour (255, 0, 0) scored 89.2883333333
Bot blob.py with colour (0, 255, 0) scored 89.365

ตัวอย่างการต่อสู้


คุณแน่ใจหรือว่านี่ไม่ควรเป็น [king-of-the-hill]?
Justin

ฉันคิดถึงเรื่องนั้น บอทจะไม่ต่อสู้กันเองโดยตรง พวกเขาต่อสู้บอทอ้างอิง นั่นคือการออกกฎ KOTH?
ลอจิกอัศวิน

ใช่เช่นนี้ไม่ใช่ KOTH ฉันถูกถามว่าคุณแน่ใจหรือไม่ว่าคุณต้องการต่อสู้บอทอ้างอิงมากกว่ากัน
Justin

1
@TheBestOne เพิ่มการสนับสนุน Java ยังไม่ได้ทดสอบกับโปรแกรม Java แจ้งให้เราทราบหากไม่ได้ผล
ลอจิกอัศวิน

1
มีการวางตำแหน่งพิกเซล 10 พิกเซลดังนั้นในภายหลังพิกเซลอาจขึ้นอยู่กับตำแหน่งพิกเซลก่อนหน้า พวกเขาสามารถสร้างซึ่งกันและกันตามที่คุณแนะนำ
Logic Knight

คำตอบ:


17

ColorFighter - C ++ - กิน swallowers สองสามอันสำหรับอาหารเช้า

แก้ไข

  • ล้างรหัส
  • เพิ่มการเพิ่มประสิทธิภาพที่เรียบง่าย แต่มีประสิทธิภาพ
  • เพิ่มภาพเคลื่อนไหว GIF บางส่วน

พระเจ้าฉันเกลียดงู (แค่แกล้งพวกมันคือแมงมุมอินดี้)

ที่จริงฉันรัก Python ฉันหวังว่าฉันเป็นเด็กขี้เกียจน้อยและเริ่มเรียนรู้อย่างถูกต้องนั่นคือทั้งหมด

ทั้งหมดนี้ถูกกล่าวว่าฉันต้องต่อสู้กับงูรุ่น 64 บิตเพื่อให้ผู้พิพากษาทำงาน การทำให้ PIL ทำงานกับ Python เวอร์ชัน 64 บิตภายใต้ Win7 นั้นต้องใช้ความอดทนมากกว่าที่ฉันพร้อมที่จะอุทิศให้กับความท้าทายนี้ดังนั้นในที่สุดฉันก็เปลี่ยน (อย่างเจ็บปวด) เป็นเวอร์ชั่น Win32

นอกจากนี้ผู้พิพากษามีแนวโน้มที่จะผิดพลาดอย่างรุนแรงเมื่อบอทช้าเกินไปที่จะตอบสนอง
ฉันไม่ได้ซ่อมมัน แต่มันเกี่ยวกับการอ่านคำตอบที่ว่างเปล่าหลังจากหมดเวลากับ stdin

การปรับปรุงเล็กน้อยจะนำเอา stderr ไปยังไฟล์สำหรับแต่ละบอท ซึ่งจะช่วยลดความยุ่งยากในการติดตามสำหรับการดีบักโพสต์ชันสูตร

ยกเว้นปัญหาเล็กน้อยเหล่านี้ฉันพบว่าผู้พิพากษาใช้งานง่ายและน่าใช้
รุ่งโรจน์สำหรับความท้าทายที่สร้างสรรค์และสนุกสนาน

รหัส

#define _CRT_SECURE_NO_WARNINGS // prevents Microsoft from croaking about the safety of scanf. Since every rabid Russian hacker and his dog are welcome to try and overflow my buffers, I could not care less.
#include "lodepng.h"
#include <vector>
#include <deque>
#include <iostream>
#include <sstream>
#include <cassert>   // paranoid android
#include <cstdint>   // fixed size types
#include <algorithm> // min max

using namespace std;

// ============================================================================
// The less painful way I found to teach C++ how to handle png images
// ============================================================================
typedef unsigned tRGB;
#define RGB(r,g,b) (((r) << 16) | ((g) << 8) | (b))
class tRawImage {
public:
    unsigned w, h;

    tRawImage(unsigned w=0, unsigned h=0) : w(w), h(h), data(w*h * 4, 0) {}
    void read(const char* filename) { unsigned res = lodepng::decode(data, w, h, filename); assert(!res);  }
    void write(const char * filename)
    {
        std::vector<unsigned char> png;
        unsigned res = lodepng::encode(png, data, w, h, LCT_RGBA); assert(!res);
        lodepng::save_file(png, filename);
    }
    tRGB get_pixel(int x, int y) const
    {
        size_t base = raw_index(x,y);
        return RGB(data[base], data[base + 1], data[base + 2]);
    }
    void set_pixel(int x, int y, tRGB color)
    {
        size_t base = raw_index(x, y);
        data[base+0] = (color >> 16) & 0xFF;
        data[base+1] = (color >>  8) & 0xFF;
        data[base+2] = (color >> 0) & 0xFF;
        data[base+3] = 0xFF; // alpha
    }
private:
    vector<unsigned char> data;
    void bound_check(unsigned x, unsigned y) const { assert(x < w && y < h); }
    size_t raw_index(unsigned x, unsigned y) const { bound_check(x, y); return 4 * (y * w + x); }
};

// ============================================================================
// coordinates
// ============================================================================
typedef int16_t tCoord;

struct tPoint {
    tCoord x, y;
    tPoint operator+  (const tPoint & p) const { return { x + p.x, y + p.y }; }
};

typedef deque<tPoint> tPointList;

// ============================================================================
// command line and input parsing
// (in a nice airtight bag to contain the stench of C++ string handling)
// ============================================================================
enum tCommand {
    c_quit,
    c_update,
    c_play,
};

class tParser {
public:
    tRGB color;
    tPointList points;

    tRGB read_color(const char * s)
    {
        int r, g, b;
        sscanf(s, "(%d,%d,%d)", &r, &g, &b);
        return RGB(r, g, b);
    }

    tCommand command(void)
    {
        string line;
        getline(cin, line);

        string cmd = get_token(line);
        points.clear();

        if (cmd == "exit") return c_quit;
        if (cmd == "pick") return c_play;

        // even more convoluted and ugly than the LEFT$s and RIGHT$s of Apple ][ basic...
        if (cmd != "colour")
        {
            cerr << "unknown command '" << cmd << "'\n";
            exit(0);
        }
        assert(cmd == "colour");
        color = read_color(get_token(line).c_str());
        get_token(line); // skip "chose"
        while (line != "")
        {
            string coords = get_token(line);
            int x = atoi(get_token(coords, ',').c_str());
            int y = atoi(coords.c_str());
            points.push_back({ x, y });
        }
        return c_update;
    }

private:
    // even more verbose and inefficient than setting up an ADA rendezvous...
    string get_token(string& s, char delimiter = ' ')
    {
        size_t pos = 0;
        string token;
        if ((pos = s.find(delimiter)) != string::npos)
        {
            token = s.substr(0, pos);
            s.erase(0, pos + 1);
            return token;
        }
        token = s; s.clear(); return token;
    }
};

// ============================================================================
// pathing
// ============================================================================
class tPather {

public:
    tPather(tRawImage image, tRGB own_color)
        : arena(image)
        , w(image.w)
        , h(image.h)
        , own_color(own_color)
        , enemy_threat(false)
    {
        // extract colored pixels and own color areas
        tPointList own_pixels;
        color_plane[neutral].resize(w*h, false);
        color_plane[enemies].resize(w*h, false);
        for (size_t x = 0; x != w; x++)
        for (size_t y = 0; y != h; y++)
        {
            tRGB color = image.get_pixel(x, y);
            if (color == col_white) continue;
            plane_set(neutral, x, y);
            if (color == own_color) own_pixels.push_back({ x, y }); // fill the frontier with all points of our color
        }

        // compute initial frontier
        for (tPoint pixel : own_pixels)
        for (tPoint n : neighbour)
        {
            tPoint pos = pixel + n;
            if (!in_picture(pos)) continue;
            if (image.get_pixel(pos.x, pos.y) == col_white)
            {
                frontier.push_back(pixel);
                break;
            }
        }
    }

    tPointList search(size_t pixels_required)
    {
        // flood fill the arena, starting from our current frontier
        tPointList result;
        tPlane closed;
        static tCandidate pool[max_size*max_size]; // fastest possible garbage collection
        size_t alloc;
        static tCandidate* border[max_size*max_size]; // a FIFO that beats a deque anytime
        size_t head, tail;
        static vector<tDistance>distance(w*h); // distance map to be flooded
        size_t filling_pixels = 0; // end of game  optimization

    get_more_results:

        // ready the distance map for filling
        distance.assign(w*h, distance_max);

        // seed our flood fill with the frontier
        alloc = head = tail = 0;
        for (tPoint pos : frontier)
        {
            border[tail++] = new (&pool[alloc++]) tCandidate (pos);
        }

        // set already explored points
        closed = color_plane[neutral]; // that's one huge copy

        // add current result
        for (tPoint pos : result)
        {
            border[tail++] = new (&pool[alloc++]) tCandidate(pos);
            closed[raw_index(pos)] = true;
        }

        // let's floooooood!!!!
        while (tail > head && pixels_required > filling_pixels)
        {
            tCandidate& candidate = *border[head++];
            tDistance  dist = candidate.distance;
            distance[raw_index(candidate.pos)] = dist++;
            for (tPoint n : neighbour)
            {
                tPoint pos = candidate.pos + n;
                if (!in_picture (pos)) continue;
                size_t index = raw_index(pos);
                if (closed[index]) continue;
                if (color_plane[enemies][index])
                {
                    if (dist == (distance_initial + 1)) continue; // already near an enemy pixel

                    // reached the nearest enemy pixel
                    static tPoint trail[max_size * max_size / 2]; // dimensioned as a 1 pixel wide spiral across the whole map
                    size_t trail_size = 0;

                    // walk back toward the frontier
                    tPoint walker = candidate.pos;
                    tDistance cur_d = dist;
                    while (cur_d > distance_initial)
                    {
                        trail[trail_size++] = walker;
                        tPoint next_n;
                        for (tPoint n : neighbour)
                        {
                            tPoint next = walker + n;
                            if (!in_picture(next)) continue;
                            tDistance prev_d = distance[raw_index(next)];
                            if (prev_d < cur_d)
                            {
                                cur_d = prev_d;
                                next_n = n;
                            }
                        }
                        walker = walker + next_n;
                    }

                    // collect our precious new pixels
                    if (trail_size > 0)
                    {
                        while (trail_size > 0)
                        {
                            if (pixels_required-- == 0) return result;       // ;!; <-- BRUTAL EXIT
                            tPoint pos = trail[--trail_size];
                            result.push_back (pos);
                        }
                        goto get_more_results; // I could have done a loop, but I did not bother to. Booooh!!!
                    }
                    continue;
                }

                // on to the next neighbour
                closed[index] = true;
                border[tail++] = new (&pool[alloc++]) tCandidate(pos, dist);
                if (!enemy_threat) filling_pixels++;
            }
        }

        // if all enemies have been surrounded, top up result with the first points of our flood fill
        if (enemy_threat) enemy_threat = pixels_required == 0;
        tPathIndex i = frontier.size() + result.size();
        while (pixels_required--) result.push_back(pool[i++].pos);
        return result;
    }

    // tidy up our map and frontier while other bots are thinking
    void validate(tPointList moves)
    {
        // report new points
        for (tPoint pos : moves)
        {
            frontier.push_back(pos);
            color_plane[neutral][raw_index(pos)] = true;
        }

        // remove surrounded points from frontier
        for (auto it = frontier.begin(); it != frontier.end();) 
        {
            bool in_frontier = false;
            for (tPoint n : neighbour)
            {
                tPoint pos = *it + n;
                if (!in_picture(pos)) continue;
                if (!(color_plane[neutral][raw_index(pos)] || color_plane[enemies][raw_index(pos)]))
                {
                    in_frontier = true;
                    break;
                }
            }
            if (!in_frontier) it = frontier.erase(it); else ++it; // the magic way of deleting an element without wrecking your iterator
        }       
    }

    // handle enemy move notifications
    void update(tRGB color, tPointList points)
    {
        assert(color != own_color);

        // plot enemy moves
        enemy_threat = true;
        for (tPoint p : points) plane_set(enemies, p);

        // important optimization here :
        /*
         * Stop 1 pixel away from the enemy to avoid wasting moves in dogfights.
         * Better let the enemy gain a few more pixels inside the surrounded region
         * and use our precious moves to get closer to the next threat.
         */
        for (tPoint p : points) for (tPoint n : neighbour) plane_set(enemies, p+n);

        // if a new enemy is detected, gather its initial pixels
        for (tRGB enemy : known_enemies) if (color == enemy) return;
        known_enemies.push_back(color);
        tPointList start_areas = scan_color(color);
        for (tPoint p : start_areas) plane_set(enemies, p);
    }

private:
    typedef uint16_t tPathIndex;

    typedef uint16_t tDistance;
    static const tDistance distance_max     = 0xFFFF;
    static const tDistance distance_initial = 0;

    struct tCandidate {
        tPoint pos;
        tDistance distance;
        tCandidate(){} // must avoid doing anything in this constructor, or pathing will slow to a crawl
        tCandidate(tPoint pos, tDistance distance = distance_initial) : pos(pos), distance(distance) {}
    };

    // neighbourhood of a pixel
    static const tPoint neighbour[4];

    // dimensions
    tCoord w, h; 
    static const size_t max_size = 1000;

    // colors lookup
    const tRGB col_white = RGB(0xFF, 0xFF, 0xFF);
    const tRGB col_black = RGB(0x00, 0x00, 0x00);
    tRGB own_color;
    const tRawImage arena;
    tPointList scan_color(tRGB color)
    {
        tPointList res;
        for (size_t x = 0; x != w; x++)
        for (size_t y = 0; y != h; y++)
        {
            if (arena.get_pixel(x, y) == color) res.push_back({ x, y });
        }
        return res;
    }

    // color planes
    typedef vector<bool> tPlane;
    tPlane color_plane[2];
    const size_t neutral = 0;
    const size_t enemies = 1;
    bool plane_get(size_t player, tPoint p) { return plane_get(player, p.x, p.y); }
    bool plane_get(size_t player, size_t x, size_t y) { return in_picture(x, y) ? color_plane[player][raw_index(x, y)] : false; }
    void plane_set(size_t player, tPoint p) { plane_set(player, p.x, p.y); }
    void plane_set(size_t player, size_t x, size_t y) { if (in_picture(x, y)) color_plane[player][raw_index(x, y)] = true; }
    bool in_picture(tPoint p) { return in_picture(p.x, p.y); }
    bool in_picture(int x, int y) { return x >= 0 && x < w && y >= 0 && y < h; }
    size_t raw_index(tPoint p) { return raw_index(p.x, p.y); }
    size_t raw_index(size_t x, size_t y) { return y*w + x; }

    // frontier
    tPointList frontier;

    // register enemies when they show up
    vector<tRGB>known_enemies;

    // end of game optimization
    bool enemy_threat;
};

// small neighbourhood
const tPoint tPather::neighbour[4] = { { -1, 0 }, { 1, 0 }, { 0, -1 }, { 0, 1 } };

// ============================================================================
// main class
// ============================================================================
class tGame {
public:
    tGame(tRawImage image, tRGB color, size_t num_pixels)
        : own_color(color)
        , response_len(num_pixels)
        , pather(image, color)
    {}

    void main_loop(void)
    {
        // grab an initial answer in case we're playing first
        tPointList moves = pather.search(response_len);
        for (;;)
        {
            ostringstream answer;
            size_t        num_points;
            tPointList    played;

            switch (parser.command())
            {
            case c_quit: 
                return;

            case c_play:
                // play as many pixels as possible
                if (moves.size() < response_len) moves = pather.search(response_len);
                num_points = min(moves.size(), response_len);
                for (size_t i = 0; i != num_points; i++)
                {
                    answer << moves[0].x << ',' << moves[0].y;
                    if (i != num_points - 1) answer << ' '; // STL had more important things to do these last 30 years than implement an implode/explode feature, but you can write your own custom version with exception safety and in-place construction. It's a bit of work, but thanks to C++ inherent genericity you will be able to extend it to giraffes and hippos with a very manageable amount of code refactoring. It's not anyone's language, your C++, eh. Just try to implode hippos in Python. Hah!
                    played.push_back(moves[0]);
                    moves.pop_front();
                }
                cout << answer.str() << '\n';

                // now that we managed to print a list of points to stdout, we just need to cleanup the mess
                pather.validate(played);
                break;

            case c_update:
                if (parser.color == own_color) continue; // hopefully we kept track of these already
                pather.update(parser.color, parser.points);
                moves = pather.search(response_len); // get cracking
                break;
            }
        }
    }

private:
    tParser parser;
    tRGB    own_color;
    size_t  response_len;
    tPather pather;
};

void main(int argc, char * argv[])
{
    // process command line
    tRawImage raw_image; raw_image.read (argv[1]);
    tRGB my_color = tParser().read_color(argv[2]);
    int num_pixels               = atoi (argv[3]);

    // init and run
    tGame game (raw_image, my_color, num_pixels);
    game.main_loop();
}

สร้างปฏิบัติการ

ฉันใช้LODEpng.cppและLODEpng.hเพื่ออ่านภาพ png
เกี่ยวกับวิธีที่ง่ายที่สุดที่ฉันพบในการสอนภาษา C ++ ที่ล่าช้านี้วิธีการอ่านภาพโดยไม่ต้องสร้างห้องสมุดครึ่งโหล
เพียงรวบรวม & ลิงก์ LODEpng.cpp พร้อมกับตัวหลักและบ็อบเป็นลุงของคุณ

ฉันรวบรวมกับ MSVC2013 แต่เนื่องจากฉันใช้คอนเทนเนอร์พื้นฐาน STL เพียงไม่กี่ตัว (deque และเวกเตอร์) มันอาจทำงานได้กับ gcc (ถ้าคุณโชคดี)
หากไม่เป็นเช่นนั้นฉันอาจลองใช้งานโครงสร้าง MinGW แต่ตรงไปตรงมาฉันรู้สึกเบื่อหน่ายกับปัญหาการพกพา C ++

ฉันทำ C / C ++ แบบพกพาค่อนข้างมากในสมัยของฉัน (ในคอมไพเลอร์แปลกใหม่สำหรับโปรเซสเซอร์ 8 ถึง 32 บิตเช่นเดียวกับ SunOS, Windows จาก 3.11 ถึง Vista และ Linux จากวัยเด็กถึง Ubuntu cooing zebra หรืออะไรก็ตามดังนั้นฉันคิดว่า ฉันมีความคิดที่ดีเกี่ยวกับความหมายของการพกพา แต่ในเวลานั้นไม่จำเป็นต้องจดจำ (หรือค้นพบ) ความแตกต่างมากมายระหว่างการตีความ GNU และ Microsoft ของสเปคที่คลุมเครือและป่องของมอนสเตอร์ STL

ผลลัพธ์กับนกนางแอ่น

arena1 arena2 arena3 arena4

มันทำงานอย่างไร

ที่แกนกลางนี่คือเส้นทางการไหลท่วมท้นที่รุนแรงของสัตว์เดรัจฉาน

เขตแดนของสีของผู้เล่น (เช่นพิกเซลที่มีเพื่อนบ้านสีขาวอย่างน้อยหนึ่งตัว) ถูกใช้เป็นเมล็ดพันธุ์เพื่อดำเนินการอัลกอริธึมการไหลของระยะทางแบบคลาสสิค

เมื่อจุดใดจุดหนึ่งถึงจุดจบของสีของศัตรูเส้นทางย้อนกลับจะถูกคำนวณเพื่อสร้างสตริงของพิกเซลที่เคลื่อนที่ไปยังจุดที่ศัตรูใกล้ที่สุด

กระบวนการซ้ำจนกว่าจะมีการรวบรวมคะแนนมากพอเพื่อตอบสนองความยาวที่ต้องการ

การทำซ้ำนี้มีราคาแพงโดยเฉพาะอย่างยิ่งเมื่อต้องต่อสู้กับศัตรู
ทุกครั้งที่พบว่ามีพิกเซลจำนวนหนึ่งที่นำจากชายแดนสู่พิกเซลศัตรู (และเราต้องการคะแนนมากขึ้นเพื่อให้คำตอบเสร็จสมบูรณ์) การเติมน้ำท่วมนั้นจะทำซ้ำตั้งแต่เริ่มต้นโดยมีเส้นทางใหม่ที่เพิ่มเข้ามาในชายแดน หมายความว่าคุณต้องเติมน้ำท่วม 5 ครั้งขึ้นไปเพื่อรับคำตอบ 10 พิกเซล

หากไม่สามารถเข้าถึงพิกเซลศัตรูได้จะมีการเลือกประเทศเพื่อนบ้านของพิกเซลชายแดนโดยเด็ดขาด
อัลกอริธึมจะพัฒนาไปสู่การเติมน้ำท่วมที่ไม่มีประสิทธิภาพ แต่สิ่งนี้จะเกิดขึ้นหลังจากผลของเกมได้รับการตัดสินแล้ว (เช่นไม่มีดินแดนที่เป็นกลางพอที่จะต่อสู้เพื่อ)
ฉันปรับมันให้เหมาะสมเพื่อให้ผู้พิพากษาไม่ใช้เวลานานในการเติมแผนที่เมื่อมีการจัดการแข่งขัน ในสถานะปัจจุบันเวลาดำเนินการจะถูกเพิกเฉยเมื่อเทียบกับผู้พิพากษาเอง

เนื่องจากไม่ทราบสีของศัตรูตั้งแต่เริ่มต้นภาพอารีน่าเริ่มต้นจะถูกเก็บไว้เพื่อคัดลอกพื้นที่เริ่มต้นของศัตรูเมื่อมันเคลื่อนที่เป็นครั้งแรก
หากรหัสเล่นก่อนมันจะท่วมพิกเซลเต็ม ๆ

สิ่งนี้ทำให้อัลกอริทึมสามารถต่อสู้กับคู่ต่อสู้จำนวนมากและอาจเป็นปฏิปักษ์ใหม่ที่มาถึงจุดสุ่มในเวลาหรือสีปรากฏขึ้นโดยไม่ต้องเริ่มต้นพื้นที่ (แม้ว่าจะไม่มีประโยชน์จริง ๆ )

การจัดการศัตรูแบบสีต่อสีจะอนุญาตให้มีการทำงานร่วมกันของบ็อตสองกรณี (การใช้พิกัดพิกเซลเพื่อส่งสัญญาณการรับรู้ลับ)
ฟังดูสนุกฉันจะลองดู :)

การคำนวณเส้นทางหนักจะทำทันทีที่มีข้อมูลใหม่ (หลังจากการแจ้งเตือนการเคลื่อนย้าย) และการเพิ่มประสิทธิภาพบางอย่าง (การอัพเดตชายแดน) จะดำเนินการหลังจากได้รับการตอบสนองแล้ว (เพื่อทำการคำนวณให้มากที่สุดเท่าที่จะเป็นไปได้ )

ที่นี่อีกครั้งอาจมีวิธีในการทำสิ่งที่ลึกซึ้งยิ่งขึ้นถ้ามีฝ่ายตรงข้ามมากกว่า 1 คน (เช่นการยกเลิกการคำนวณหากมีข้อมูลใหม่พร้อมใช้งาน) แต่ในอัตราใดก็ตามที่ฉันไม่เห็นว่าจำเป็นต้องใช้มัลติทาสกิ้ง สามารถทำงานกับโหลดเต็ม

ปัญหาประสิทธิภาพการทำงาน

ทั้งหมดนี้ไม่สามารถทำงานได้หากไม่มีการเข้าถึงข้อมูลที่รวดเร็ว (และพลังการประมวลผลมากกว่าโปรแกรม Appolo ทั้งหมดเช่นพีซีเฉลี่ยของคุณเมื่อใช้ในการทำมากกว่าโพสต์ทวีตเล็กน้อย)

ความเร็วนั้นขึ้นอยู่กับคอมไพเลอร์เป็นอย่างมาก โดยปกติแล้ว GNU จะชนะ Microsoft ด้วยอัตรากำไร 30% (นั่นคือหมายเลขมหัศจรรย์ที่ฉันสังเกตเห็นเกี่ยวกับความท้าทายของรหัสที่เกี่ยวข้องกับการกำหนดเส้นทางอื่น ๆ 3 ครั้ง) แต่ระยะทางนี้อาจแตกต่างกันไป

รหัสที่อยู่ในสถานะปัจจุบันแทบจะไม่หยุดพักบนเวที 4 Windows perfmeter รายงานการใช้งาน CPU ประมาณ 4 ถึง 7% ดังนั้นจึงควรสามารถรับมือกับแผนที่ 1,000x1000 ภายในระยะเวลาตอบสนอง 100ms

หัวใจสำคัญของอัลกอริธึมการกำหนดเส้นทางทุกเส้นทางจะอยู่ที่ FIFO (อาจเป็นไปตามสัดส่วนแม้ว่าจะไม่ใช่ในกรณีนั้น) ซึ่งจำเป็นต้องมีการจัดสรรองค์ประกอบอย่างรวดเร็ว

เนื่องจาก OP กำหนดขอบเขตของขนาดให้เหมาะสมฉันจึงทำการคำนวณทางคณิตศาสตร์บางอย่างและเห็นว่าโครงสร้างข้อมูลคงที่ที่กำหนดเป็นสูงสุด (เช่น 1.000.000 พิกเซล) จะไม่กินมากกว่าสองสิบเมกะไบต์ซึ่งพีซีโดยเฉลี่ยของคุณกินอาหารเช้า
ภายใต้ Win7 และเรียบเรียงด้วย MSVC 2013 จริง ๆ แล้วรหัสนั้นกินเนื้อที่ประมาณ 14Mb ในเวที 4 ในขณะที่สองเธรดของ Swallower ใช้มากกว่า 20Mb

ฉันเริ่มต้นด้วยคอนเทนเนอร์ STL สำหรับการสร้างต้นแบบที่ง่ายขึ้น แต่ STL ทำให้โค้ดอ่านได้น้อยลงเนื่องจากฉันไม่ต้องการสร้างคลาสเพื่อแค็ปซูลแต่ละบิตของข้อมูลเพื่อซ่อน obfuscation ออกไป (ไม่ว่าจะเป็นเพราะฉันไม่สามารถ รับมือกับ STL ถูกทิ้งให้ชื่นชมของผู้อ่าน)
ไม่ว่าผลจะออกมาช้าขนาดนั้นในตอนแรกฉันคิดว่าฉันกำลังสร้างเวอร์ชันการดีบักโดยไม่ได้ตั้งใจ

ฉันคิดว่านี่เป็นส่วนหนึ่งเนื่องจากการใช้งาน STL ของ Microsoft ที่ไม่น่าเชื่ออย่างไม่น่าเชื่อ (ในกรณีที่เวกเตอร์และบิตเซ็ตทำการตรวจสอบที่ถูกผูกไว้หรือการดำเนินการเกี่ยวกับ Crypic อื่น ๆ ในโอเปอเรเตอร์ [] ตัวเอง

ฉันสามารถรับมือกับไวยากรณ์และการพกพาที่โหดเหี้ยม (เช่น Microsoft vs GNU) ได้หากมีการแสดง แต่ก็ไม่เป็นเช่นนั้น

ตัวอย่างเช่นdequeช้าโดยเนื้อแท้เพราะมันสับข้อมูลจำนวนมากเกี่ยวกับการทำบัญชีเกี่ยวกับการรอโอกาสที่จะปรับขนาดซุปเปอร์สมาร์ทซึ่งฉันไม่สามารถดูแลน้อยลง
แน่ใจว่าฉันสามารถใช้ตัวจัดสรรแบบกำหนดเองและตัวแบ่งเท็มเพลตแบบกำหนดเองอื่น ๆ ได้ แต่ตัวจัดสรรแบบกำหนดเองเพียงอย่างเดียวมีค่าใช้จ่ายไม่กี่ร้อยบรรทัดของรหัสและส่วนที่ดีกว่าของวันในการทดสอบ โครงสร้างที่ทำด้วยมือที่ทำด้วยมือนั้นมีโค้ดประมาณ 0 เส้น (แม้ว่าจะเป็นอันตรายมากกว่า แต่อัลกอริทึมจะไม่ทำงานหากฉันไม่รู้ - หรือฉันคิดว่ารู้ - กำลังทำอะไรอยู่)

ดังนั้นในที่สุดฉันก็เก็บคอนเทนเนอร์ STL ไว้ในส่วนที่ไม่สำคัญของรหัสและสร้างตัวจัดสรรที่โหดร้ายของตัวเองและ FIFO ด้วยอาร์เรย์สองแถวในปี 1970 และกางเกงขาสั้นที่ไม่มีลายเซ็นสามตัว

กลืนน้ำลาย

ตามที่ผู้เขียนได้ยืนยันรูปแบบที่ผิดปกติของ Swallower นั้นเกิดจากความล่าช้าระหว่างการเคลื่อนที่ของข้าศึกและการแจ้งเตือนจากการเดินด้าย
ระบบ perfmeter แสดงให้เห็นอย่างชัดเจนถึงเธรดทางเดินที่ใช้ CPU 100% ตลอดเวลาและรูปแบบรอยหยักมักปรากฏขึ้นเมื่อโฟกัสของการต่อสู้เปลี่ยนไปยังพื้นที่ใหม่ ภาพเคลื่อนไหวนี้ค่อนข้างชัดเจน

การเพิ่มประสิทธิภาพที่เรียบง่าย แต่มีประสิทธิภาพ

หลังจากที่ได้ดูการต่อสู้สุนัขขนาดใหญ่ระหว่าง Swallower และเครื่องบินรบของฉันฉันจำคำพูดเก่า ๆ ได้จากเกม Go: ป้องกันอย่างใกล้ชิด แต่โจมตีจากระยะไกล

มีภูมิปัญญาในเรื่องนั้น หากคุณพยายามยึดติดกับศัตรูของคุณมากเกินไปคุณจะเสียการเคลื่อนไหวอันมีค่าที่พยายามปิดกั้นเส้นทางที่เป็นไปได้แต่ละเส้นทาง ในทางตรงกันข้ามถ้าคุณอยู่ห่างออกไปเพียงหนึ่งพิกเซลคุณอาจหลีกเลี่ยงการเติมช่องว่างเล็ก ๆ ที่จะได้รับน้อยมากและใช้การเคลื่อนไหวของคุณเพื่อรับมือกับภัยคุกคามที่สำคัญกว่า

เพื่อนำความคิดนี้ไปใช้ฉันแค่ขยายการเคลื่อนไหวของศัตรู (ทำเครื่องหมายเพื่อนบ้านทั้ง 4 ของการเคลื่อนไหวแต่ละครั้งเป็นพิกเซลศัตรู)
นี่เป็นการหยุดอัลกอริทึมการพาออกหนึ่งพิกเซลห่างจากชายแดนของข้าศึกทำให้นักมวยของฉันทำงานรอบ ๆ ฝ่ายตรงข้ามโดยไม่ถูกจับในการต่อสู้สุนัขมากเกินไป

คุณสามารถเห็นการปรับปรุง
(แม้ว่าการวิ่งทั้งหมดจะไม่ประสบความสำเร็จ แต่คุณสามารถสังเกตเห็นโครงร่างที่นุ่มนวลกว่า):

ก่อน หลังจาก


1
ว้าว. ฉันคิดว่าไม่มีอะไรจะชนะ Swallower ทางออกที่ยอดเยี่ยมพร้อมคำอธิบายที่ดี ฉันจำ K&R C จากวันเก่า ๆ ที่ดี แต่จากนั้น C ไปด้านมืด ฉันคิดว่าคุณจะชอบงูใหญ่
Logic Knight

มันเป็นความสุขที่แท้จริงในการจัดการกับความท้าทายดังนั้น ... ดี .. ที่ท้าทายและสนุก สิ่งนี้ทำให้ฉันสามารถทดสอบอัญมณีขนาดเล็กของ LODEpng เต็มรูปแบบและผลลัพธ์มีแนวโน้มมากที่ฉันจะกลับไปที่ png racer ทดสอบอีกครั้งการทดสอบความรัก / ความเกลียดชังของฉันกับความสัมพันธ์ที่น่าอับอายนี้เพิ่มขึ้นอีกครั้ง

1
บางครั้งนกนางแอ่นก็ไม่อยู่กับร่องกับรอยเพื่อให้อยู่ในระยะเวลาที่กำหนด นี่เป็นเพียงบางส่วนที่ใช้สำหรับการทำเธรดหลายตัว เยี่ยมมาก !! ฉันคิดว่าฉันจะเพิ่มโบนัสเป็นสองเท่า ...
TheNumberOne

1
หมอนมีดาวน์โหลดสำหรับ 64- บิต มันสามารถใช้เช่นเดียวกับ PIL
TheNumberOne

@TheBestOne ฉันคิดอย่างนั้น จิตรกรที่โหดเหี้ยมของฉันใช้ประโยชน์จากช่วงเวลาเหล่านี้ที่ซึ่งเจ้าป่าพรุของคุณเคี้ยวข้อมูลที่ล้าสมัย :) สำหรับ PIL ฉันได้ดาวน์โหลดเกี่ยวกับ Amd64 PIL และ Pillow ทุกรุ่นที่มีใน World Wide Web แต่พวกเขาจะไม่ทำงานกับ core Python ของฉัน 63.5 บิตซึ่งอาจเป็น bootleg และ / หรือรุ่นที่ล้าสมัย อย่างไรก็ตามพอร์ต Win32 ก็ใช้งานได้เช่นกันและถ้าวันหนึ่งฉันต้องการอะไรที่เร็วกว่านี้ฉันจะต้องเปลี่ยนไปใช้ PyPy เหมือนเดิมทั้งหมด

21

Blob-Depth-Blob แรก

ภาษา = Python (3.2)

คะแนน = 111.475388276 153.34210035

อัปเดต: ตอนนี้ใช้Setคลาสที่กำหนดเองเพื่อรับpop()วิธีสร้างรูปแบบกริดซึ่งปรับปรุงพื้นที่ที่ครอบคลุมในการเริ่มต้นอย่างมากตัดส่วนใหญ่ของภาพออกจากศัตรู หมายเหตุ: ฉันกำลังใช้กริด 12 x 12 สำหรับตัวอย่างนี้ซึ่งขนาดสุ่มของกริดดูเหมือนจะให้ผลลัพธ์ที่ดีที่สุดสำหรับ arena3 (อันที่ได้คะแนนแย่ที่สุดก่อนการอัพเดต) อย่างไรก็ตามมีแนวโน้มว่าจะเหมาะสมกว่า มีขนาดกริดสำหรับการเลือกที่กำหนด

ฉันไปปรับเปลี่ยนอย่างง่าย ๆ กับบอตอ้างอิงเพื่อให้ชอบการเลือกจุดที่เป็นไปได้ที่ล้อมรอบด้วยจุดสีของตัวเองน้อยที่สุด การปรับปรุงอาจทำให้การเลือกจุดที่เป็นไปได้ที่ล้อมรอบด้วยคะแนนสีศัตรูให้ได้มากที่สุด

dfblob.py:

import sys, os
from PIL import Image

class RoomyIntPairHashSet:
    def __init__(self, firstMax, secondMax):
        self.m1 = firstMax
        self.m2 = secondMax
        self.set = [set() for i in range((firstMax - 1) * (secondMax - 1) + 1)]
        self.len = 0

    def add(self, tup):
        subset = self.set[self.gettuphash(tup)]
        self.len -= len(subset)
        subset.add(tup)
        self.len += len(subset)

    def discard(self, tup):
        subset = self.set[self.gettuphash(tup)]
        self.len -= len(subset)
        subset.discard(tup)
        self.len += len(subset)

    def pop(self):
        for s in self.set:
            if len(s) > 0:
                self.len -= 1
                return s.pop()
        return self.set[0].pop()

    def gettuphash(self, tup):
        return (tup[0] % self.m1) * (tup[1] % self.m2)

    def __len__(self):
        return self.len

gridhashwidth = 12
gridhashheight = 12
image = Image.open(sys.argv[1])
pix = image.load()
W,H = image.size
mycolour = eval(sys.argv[2])
pixbatch = int(sys.argv[3])

ORTH = ((-1,0), (1,0), (0,-1), (0,1))
def canchoose(loc, virtualneighbors, colour, num_neighbors):
    if pix[loc] == (255,255,255):
        plist = [(loc[0]+dx, loc[1]+dy) for dx,dy in ORTH]
        actual_num_neighbors = 0
        for p in plist:
            if 0<=p[0]<W and 0<=p[1]<H and pix[p]==colour or p in virtualneighbors:
                actual_num_neighbors += 1
        return num_neighbors == actual_num_neighbors
    return False

def near(loc, exclude):
    plist = [(loc[0]+dx, loc[1]+dy) for dx,dy in ORTH]
    pboard = [p for p in plist if 0<=p[0]<W and 0<=p[1]<H]
    return [p for p in pboard if pix[p] == (255,255,255) and p not in exclude]

def updateimage(image, msg):
    ctext, colourtext, chose, points = msg.split(None, 3)
    colour = eval(colourtext)
    plist = [tuple(int(v) for v in pr.split(',')) for pr in points.split()]
    for p in plist:
        pix[p] = colour
        for i in range(len(skins)):
            skins[i].discard(p)
        if colour == mycolour:
            for np in near(p, []):
                for j in range(len(skins)):
                    skins[j].discard(np)
                    if canchoose(np, [], mycolour, j + 1):
                        skins[j].add(np)


board = [(x,y) for x in range(W) for y in range(H)]
skins = []
for i in range(1, 1 + len(ORTH)):
    skin = RoomyIntPairHashSet(gridhashwidth, gridhashheight)
    skins.append(skin)
    for p in board:
        if canchoose(p, [], mycolour, i):
            skin.add(p)

while 1:
    msg = sys.stdin.readline()
    print("got message "+ msg, file=sys.stderr)
    if msg.startswith('colour'):
        print("updating image", file=sys.stderr)
        updateimage(image, msg.strip())
        print("updated image", file=sys.stderr)
    if msg.startswith('pick'):
        moves = []
        print("picking moves", file=sys.stderr)
        virtualskins = [RoomyIntPairHashSet(gridhashwidth, gridhashheight) for i in range(len(skins))]
        for i in range(pixbatch):
            for j in range(len(skins)):
                if len(virtualskins[j]) > 0 or len(skins[j]) > 0:
                    move = None
                    if len(virtualskins[j]) > 0:
                        move = virtualskins[j].pop()
                    else:
                        move = skins[j].pop()
                    moves.append(move)
                    print("picking move (%u,%u) " % move, file=sys.stderr)
                    for p in near(move, moves):
                        for k in range(len(skins)):
                            virtualskins[k].discard(p)
                            if canchoose(p, moves, mycolour, k + 1):
                                virtualskins[k].add(p)
                    break
        movetext = ' '.join('%u,%u'%p for p in moves)
        print("picked %u moves" % (len(moves)), file=sys.stderr)
        sys.stdout.write(movetext + '\n')
        sys.stdout.flush()
    if msg.startswith('exit') or len(msg) < 1:
        break

image.save('dfblob.png')

ผู้ตัดสินดั้งเดิมได้รับการปรับเปลี่ยนเล็กน้อยเพื่อทำงานกับ Python 3.2 (และเพื่อเพิ่มฟังก์ชั่นการบันทึกอย่างคร่าว ๆ ให้กับบอท + บันทึกภาพเวทีเป็นระยะเพื่อสร้างภาพเคลื่อนไหว):

import sys, re, random, os, shutil, subprocess, datetime, time, signal, io
from PIL import Image

ORTH = ((-1,0), (1,0), (0,-1), (0,1))
def place(loc, colour):
    # if valid, place colour at loc and return True, else False
    if pix[loc] == (255,255,255):
        plist = [(loc[0]+dx, loc[1]+dy) for dx,dy in ORTH]
        if any(pix[p]==colour for p in plist if 0<=p[0]<W and 0<=p[1]<H):
            pix[loc] = colour
            return True
    return False

def updateimage(image, msg, bot):
    if not re.match(r'(\s*\d+,\d+)*\s*', msg):
        return []
    plist = [tuple(int(v) for v in pr.split(',')) for pr in msg.split()]
    plist = plist[:PIXELBATCH]
    return [p for p in plist if place(p, bot.colour)]

class Bot:
    botlist = []
    def __init__(self, name, interpreter=None, colour=None):
        self.prog = name
        self.botlist.append(self)
        callarg = re.sub(r'\.class$', '', name)
        self.call = [interpreter, callarg] if interpreter else [callarg]
        self.colour = colour
        self.colstr = str(colour).replace(' ', '')
        self.faults = 0
        self.env = 'env%u' % self.botlist.index(self)
        try: os.mkdir(self.env)
        except: pass
        shutil.copy(self.prog, self.env)
        shutil.copy(imagename, self.env)
        os.chdir(self.env)
        args = self.call + [imagename, self.colstr, str(PIXELBATCH)]
        errorfile = 'err.log'
        with io.open(errorfile, 'wb') as errorlog:
            self.proc = subprocess.Popen(args, stdin=subprocess.PIPE, 
                stdout=subprocess.PIPE, stderr=errorlog)
        os.chdir('..')
    def send(self, msg):
        if self.faults < FAULTLIMIT:
            self.proc.stdin.write((msg+'\n').encode('utf-8'))
            self.proc.stdin.flush()
    def read(self, timelimit):
        if self.faults < FAULTLIMIT:
            start = time.time()
            inline = self.proc.stdout.readline().decode('utf-8')
            if time.time() - start > timelimit:
                self.faults += 1
                inline = ''
            return inline.strip()
    def exit(self):
        self.send('exit')

from cfg import *
for i, (prog, interp) in enumerate(botspec):
    Bot(prog, interp, colourspec[i])

image = Image.open(imagename)
pix = image.load()
W,H = image.size
os.mkdir('results')

time.sleep(INITTIME)
total = 0
for turn in range(1, MAXTURNS+1):
    random.shuffle(Bot.botlist)
    nullbots = 0
    for bot in Bot.botlist:
        bot.send('pick pixels')
        inmsg = bot.read(TIMELIMIT)
        newpixels = updateimage(image, inmsg, bot)
        total += len(newpixels)
        if newpixels:
            pixtext = ' '.join('%u,%u'%p for p in newpixels)
            msg = 'colour %s chose %s' % (bot.colstr, pixtext)
            for msgbot in Bot.botlist:
                msgbot.send(msg)
        else:
            nullbots += 1
    if nullbots == len(Bot.botlist):
        break
    if turn % 100 == 0:
        print('Turn %s done %s pixels' % (turn, total))
        image.save("results/"+BATTLE+str(turn//100).zfill(3)+'.png')
for msgbot in Bot.botlist:
    msgbot.exit()

counts = dict((c,f) for f,c in image.getcolors(W*H))
avg = 1.0 * sum(counts.values()) / len(Bot.botlist)
for bot in Bot.botlist:
    score = 100 * counts[bot.colour] / avg
    print('Bot %s with colour %s scored %s' % (bot.prog, bot.colour, score))
image.save(BATTLE+'.png')

ผลลัพธ์ที่เกิดขึ้นตามเวที บอท dfblob ได้รับสีแดงสำหรับทุกสนาม

สนามกีฬา 1:

Bot dfblob.py with colour (255, 0, 0) scored 163.75666666666666
Bot blob.py with colour (0, 255, 0) scored 14.896666666666667

1

อารีน่า 2:

Bot blob.py with colour (0, 255, 0) scored 17.65563547726219
Bot dfblob.py with colour (255, 0, 0) scored 149.57006774236964

2

อารีน่า 3:

Bot blob.py with colour (0, 255, 0) scored 21.09758208782965
Bot dfblob.py with colour (255, 0, 0) scored 142.9732433108277

3

สนามกีฬา 4:

Bot blob.py with colour (0, 255, 0) scored 34.443810082244205
Bot dfblob.py with colour (255, 0, 0) scored 157.0684236785121

4


อัลกอริทึมของคุณเหมือนกับที่ฉันใช้ใน Boxer น้องชายของ Blob ฉันจะใช้ Boxer ถ้า Blob ไม่ท้าทายพอ ภาพเคลื่อนไหวที่ดีมากเช่นกัน
ลอจิกอัศวิน

ในการใช้ PIL ใน python 3 คุณใช้หมอนหรือไม่?
trichoplax

@githubphagocyte ใช่
SamYonnou

คุณใช้ซอฟต์แวร์อะไรในการสร้าง GIF เหล่านั้น
TheNumberOne

1
@TheBestOne ฉันใช้ImageMagickโดยเฉพาะคำสั่งconvert -delay 5 -loop 0 result*.png animated.gifแม้ว่า gif บางตัวจะต้องถูกตัดออกด้วยตนเองในภายหลังเพื่ออัปโหลดที่นี่
SamYonnou

18

swallower

ภาษา = Java

คะแนน = 162.3289512601408075 169.4020975612382575

แสวงหาศัตรูออกและล้อมรอบ คุณอาจต้องให้เวลานานกว่านั้น น่าจะปรับปรุงได้ค่อนข้างดี. บางครั้งพิมพ์พิกเซลที่ไม่ถูกต้อง

อัปเดต:ล้อมรอบเร็วกว่ามาก ใช้เธรดอื่นเพื่ออัปเดตลำดับความสำคัญ ส่งคืนภายในเสมอ 0.1 วินาที MAX_TURNSคะแนนควรจะเป็นไปไม่ได้ที่จะชนะโดยไม่ต้องเพิ่ม

import javax.imageio.ImageIO;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.io.BufferedReader;
import java.io.File;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
import java.util.List;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.PriorityBlockingQueue;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.stream.Collectors;

public class Swallower {

    static final byte MY_TYPE = 1;
    static final byte BLANK_TYPE = 0;
    static final byte NEUTRAL_TYPE = 2;
    static final byte ENEMY_TYPE = 3;
    private static final int WHITE = Color.WHITE.getRGB();
    private static final int MAX_TIME = 50;
    private final int color;
    private final int N;
    private final int width;
    private final int height;
    private final BufferedReader in;
    Lock borderLock;
    private final PriorityBlockingQueue<Pixel> border;
    private final Set<Pixel> borderSet;
    private final Thread updater;

    Lock imageLock;
    volatile byte[][] image;
    Lock priorityLock;
    volatile int[][] priority;
    volatile boolean updating;
    volatile private boolean exit;

    class Pixel implements Comparable<Pixel> {

        int x;
        int y;

        public Pixel(int x, int y) {
            this.x = x;
            this.y = y;
        }

        @Override
        public int compareTo(Pixel o) {
            return priority() - o.priority();
        }

        private int priority() {
            priorityLock.lock();
            int p = priority[x][y];
            priorityLock.unlock();
            return p;
        }

        public byte type() {
            imageLock.lock();
            byte i = image[x][y];
            imageLock.unlock();
            return i;
        }

        public boolean isBorder() {
            if (type() != BLANK_TYPE){
                return false;
            }
            for (Pixel p : pixelsAround()){
                if (p.type() == MY_TYPE){
                    return true;
                }
            }
            return false;
        }

        public void setType(byte newType) {
            imageLock.lock();
            image[x][y] = newType;
            imageLock.unlock();
        }

        public void setPriority(int newPriority) {
            borderLock.lock();
            boolean contains = borderSet.remove(this);
            if (contains){
                border.remove(this);
            }
            priorityLock.lock();
            priority[x][y] = newPriority;
            priorityLock.unlock();
            if (contains){
                border.add(this);
                borderSet.add(this);
            }
            borderLock.unlock();
        }

        public List<Pixel> pixelsAround() {
            List<Pixel> pixels = new ArrayList<>(4);
            if (x > 0){
                pixels.add(new Pixel(x - 1, y));
            }
            if (x < width - 1){
                pixels.add(new Pixel(x + 1, y));
            }
            if (y > 0){
                pixels.add(new Pixel(x, y - 1));
            }
            if (y < height - 1){
                pixels.add(new Pixel(x, y + 1));
            }
            return pixels;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;

            Pixel pixel = (Pixel) o;

            return x == pixel.x && y == pixel.y;

        }

        @Override
        public int hashCode() {
            int result = x;
            result = 31 * result + y;
            return result;
        }
    }

    public static void main(String[] args) throws IOException {
        BufferedImage image = ImageIO.read(new File(args[0]));
        int color = parseColorString(args[1]);
        int N = Integer.parseInt(args[2]);
        new Swallower(image, color, N).start();
    }

    private void start() throws IOException {
        updater.start();
        try {
            while (true) {
                String input = in.readLine();
                if (input.equals("exit")) {
                    exit = true;
                    if (!updating) {
                        updater.interrupt();
                    }
                    return;
                } else if (input.startsWith("colour")) {
                    updateImage(input);
                } else if (input.equals("pick pixels")) {
                    if (updating) {
                        try {
                            synchronized (Thread.currentThread()){
                                Thread.currentThread().wait(MAX_TIME);
                            }
                        } catch (InterruptedException ignored) {
                        }
                    }
                    for (int i = 0; i < N && !border.isEmpty(); i++) {
                        borderLock.lock();
                        Pixel p = border.poll();
                        borderSet.remove(p);
                        borderLock.unlock();
                        if (!p.isBorder()){
                            i--;
                            continue;
                        }
                        updateImage(MY_TYPE, p);
                        System.out.print(p.x + "," + p.y + " ");
                    }
                    System.out.println();
                }
            }
        } catch (Throwable e){
            exit = true;
            if (!updating){
                updater.interrupt();
            }
            throw e;
        }
    }

    private void updateImage(byte type, Pixel... pixels) {
        for (Pixel pixel : pixels){
            pixel.setType(type);
            if (type == MY_TYPE){
                pixel.setPriority(Integer.MAX_VALUE);
            } else {
                pixel.setPriority(0);
            }
        }
        for (Pixel pixel : pixels){
            for (Pixel p : pixel.pixelsAround()){
                if (p.type() == BLANK_TYPE){
                    addPixelToUpdate(p);
                }
                if (type == MY_TYPE && p.isBorder()){
                    borderLock.lock();
                    if (borderSet.add(p)){
                        border.add(p);
                    }
                    borderLock.unlock();
                }
            }
        }
    }

    private synchronized void addPixelToUpdate(Pixel p) {
        if (pixelsToUpdateSet.add(p)) {
            pixelsToUpdate.add(p);
            if (!updating){
                updater.interrupt();
            }
        }
    }

    Queue<Pixel> pixelsToUpdate;
    Set<Pixel> pixelsToUpdateSet;

    private void update(){
        while (true){
            if (exit){
                return;
            }
            if (pixelsToUpdate.isEmpty()){
                try {
                    updating = false;
                    while (!exit) {
                        synchronized (Thread.currentThread()) {
                            Thread.currentThread().wait();
                        }
                    }
                } catch (InterruptedException ignored){}
                continue;
            }
            updating = true;
            Pixel pixel = pixelsToUpdate.poll();
            if (pixel.type() != BLANK_TYPE){
                continue;
            }
            pixelsToUpdateSet.remove(pixel);
            updatePixel(pixel);
        }
    }

    private void updatePixel(Pixel pixel) {
        int originalPriority = pixel.priority();
        int minPriority = Integer.MAX_VALUE;
        List<Pixel> pixelsAround = pixel.pixelsAround();
        for (Pixel p : pixelsAround){
            int priority = p.priority();
            if (priority < minPriority){
                minPriority = priority;
            }
        }
        if (minPriority >= originalPriority){
            pixel.setPriority(Integer.MAX_VALUE);
            pixelsToUpdate.addAll(pixelsAround.stream().filter(p -> p.type() == 0 && p.priority() != Integer.MAX_VALUE).filter(pixelsToUpdateSet::add).collect(Collectors.toList()));
        } else {
            pixel.setPriority(minPriority + 1);
            for (Pixel p : pixelsAround){
                if (p.type() == 0 && p.priority() > minPriority + 2){
                    if (pixelsToUpdateSet.add(p)){
                        pixelsToUpdate.add(p);
                    }
                }
            }
        }

    }

    private void updateImage(String input) {
        String[] inputs = input.split("\\s");
        int color = parseColorString(inputs[1]);
        byte type;
        if (color == this.color){
            return;
        } else {
            type = ENEMY_TYPE;
        }
        Pixel[] pixels = new Pixel[inputs.length - 3];
        for (int i = 0; i < inputs.length - 3; i++){
            String[] coords = inputs[i + 3].split(",");
            pixels[i] = new Pixel(Integer.parseInt(coords[0]), Integer.parseInt(coords[1]));
        }
        updateImage(type, pixels);
    }

    private static int parseColorString(String input) {
        String[] colorString = input.split("[\\(\\),]");
        return new Color(Integer.parseInt(colorString[1]), Integer.parseInt(colorString[2]), Integer.parseInt(colorString[3])).getRGB();
    }

    private Swallower(BufferedImage image, int color, int N){
        this.color = color;
        this.N = N;
        this.width = image.getWidth();
        this.height = image.getHeight();
        this.image = new byte[width][height];
        this.priority = new int[width][height];
        for (int x = 0; x < width; x++){
            for (int y = 0; y < height; y++){
                int pixelColor = image.getRGB(x,y);
                priority[x][y] = Integer.MAX_VALUE;
                if (pixelColor == WHITE){
                    this.image[x][y] = BLANK_TYPE;
                } else if (pixelColor == this.color){
                    this.image[x][y] = MY_TYPE;
                } else {
                    this.image[x][y] = NEUTRAL_TYPE;
                }
            }
        }
        border = new PriorityBlockingQueue<>();
        borderSet = Collections.synchronizedSet(new HashSet<>());
        borderLock = new ReentrantLock();
        priorityLock = new ReentrantLock();
        imageLock = new ReentrantLock();
        for (int x = 0; x < width; x++){
            for (int y = 0; y < height; y++){
                Pixel pixel = new Pixel(x,y);
                if (pixel.type() == BLANK_TYPE){
                    if (pixel.isBorder()){
                        if (borderSet.add(pixel)){
                            border.add(pixel);
                        }
                    }
                }
            }
        }
        in = new BufferedReader(new InputStreamReader(System.in));
        updating = false;
        updater = new Thread(this::update);
        pixelsToUpdate = new ConcurrentLinkedQueue<>();
        pixelsToUpdateSet = Collections.synchronizedSet(new HashSet<>());
        exit = false;
    }

}

มันทำงานอย่างไร:

บอทนี้เก็บคิวลำดับความสำคัญของพิกเซลที่สามารถเพิ่มได้ ลำดับความสำคัญของพิกเซลศัตรูคือ 0 ลำดับความสำคัญของพิกเซลว่างเปล่าคือ 1 มากกว่าระดับความสำคัญต่ำสุดที่อยู่รอบ ๆ พิกเซลอื่น ๆ ทั้งหมดมีลำดับความสำคัญเป็นจำนวนเต็ม MAX_VALUE เธรด updater อัพเดตลำดับความสำคัญของพิกเซลอย่างต่อเนื่อง ทุก ๆ รอบจำนวนพิกเซล N ต่ำสุดจะถูกเปิดออกจากลำดับความสำคัญ

Green Blob กับ Red Swallower

คะแนนของ Blob = 1.680553372583887225

คะแนนของ Swallower = 169.4020975612382575

สนามกีฬา 1:

Bot Blob.py with colour (0, 255, 0) scored 1.2183333333333333
Bot Swallower.class with colour (255, 0, 0) scored 177.435

ป้อนคำอธิบายรูปภาพที่นี่

อารีน่า 2:

Bot Swallower.class with colour (255, 0, 0) scored 149.57829253338517
Bot Blob.py with colour (0, 255, 0) scored 0.5159187091564356

ป้อนคำอธิบายรูปภาพที่นี่

อารีน่า 3:

Bot Blob.py with colour (0, 255, 0) scored 0.727104853136361
Bot Swallower.class with colour (255, 0, 0) scored 163.343720545521

ป้อนคำอธิบายรูปภาพที่นี่

สนามกีฬา 4:

Bot Swallower.class with colour (255, 0, 0) scored 187.25137716604686
Bot Blob.py with colour (0, 255, 0) scored 4.260856594709419

ป้อนคำอธิบายรูปภาพที่นี่

กรีน Swallower vs. Red Blob

คะแนนของ Blob = 1.6852943642218457375

คะแนนของ Swallower = 169.3923095387498625

สนามกีฬา 1:

Bot Blob.py with colour (255, 0, 0) scored 1.3166666666666667
Bot Swallower.class with colour (0, 255, 0) scored 177.33666666666667

ป้อนคำอธิบายรูปภาพที่นี่

อารีน่า 2:

Bot Swallower.class with colour (0, 255, 0) scored 149.57829253338517
Bot Blob.py with colour (255, 0, 0) scored 0.49573058575466195

ป้อนคำอธิบายรูปภาพที่นี่

อารีน่า 3:

Bot Swallower.class with colour (0, 255, 0) scored 163.14367053301788
Bot Blob.py with colour (255, 0, 0) scored 0.9271548656394868

ป้อนคำอธิบายรูปภาพที่นี่

สนามกีฬา 4:

Bot Swallower.class with colour (0, 255, 0) scored 187.51060842192973
Bot Blob.py with colour (255, 0, 0) scored 4.0016253388265675

ป้อนคำอธิบายรูปภาพที่นี่

Red Swallower กับ Green Depth First Blob

คะแนนของ Swallower = 157.0749775233111925

ความลึกของคะแนน Blob แรก = 18.192783547939744

สนามกีฬา 1:

Bot Swallower.class with colour (255, 0, 0) scored 173.52166666666668
Bot dfblob.py with colour (0, 255, 0) scored 5.131666666666667

ป้อนคำอธิบายรูปภาพที่นี่

อารีน่า 2:

Bot dfblob.py with colour (0, 255, 0) scored 17.25635925887156
Bot Swallower.class with colour (255, 0, 0) scored 149.57829253338517

ป้อนคำอธิบายรูปภาพที่นี่

อารีน่า 3:

Bot Swallower.class with colour (255, 0, 0) scored 153.59801488833747
Bot dfblob.py with colour (0, 255, 0) scored 10.472810510319889

ป้อนคำอธิบายรูปภาพที่นี่

สนามกีฬา 4:

Bot dfblob.py with colour (0, 255, 0) scored 39.91029775590086
Bot Swallower.class with colour (255, 0, 0) scored 151.60193600485545

ป้อนคำอธิบายรูปภาพที่นี่

Green Swallower vs Red Depth First Blob

คะแนนของ Swallower = 154.3368355651281075

คะแนนความลึกของหยดแรก = 18.84463249420435425

สนามกีฬา 1:

Bot Swallower.class with colour (0, 255, 0) scored 165.295
Bot dfblob.py with colour (255, 0, 0) scored 13.358333333333333

ป้อนคำอธิบายรูปภาพที่นี่

อารีน่า 2:

Bot dfblob.py with colour (255, 0, 0) scored 8.91118721119768
Bot Swallower.class with colour (0, 255, 0) scored 149.57829253338517

ป้อนคำอธิบายรูปภาพที่นี่

อารีน่า 3:

Bot Swallower.class with colour (0, 255, 0) scored 157.01136822667206
Bot dfblob.py with colour (255, 0, 0) scored 7.059457171985304

ป้อนคำอธิบายรูปภาพที่นี่

สนามกีฬา 4:

Bot dfblob.py with colour (255, 0, 0) scored 46.0495522603011
Bot Swallower.class with colour (0, 255, 0) scored 145.4626815004552

ป้อนคำอธิบายรูปภาพที่นี่

Green Blob กับ Red Depth First Blob กับ Blue Swallower:

คะแนนของ Blob = 6.347962032393275525

ความลึกของคะแนน Blob แรก = 27.34842554331698275

คะแนนของ Swallower = 227.720728953415375

สนามกีฬา 1:

Bot Swallower.class with colour (0, 0, 255) scored 242.54
Bot Blob.py with colour (0, 255, 0) scored 1.21
Bot dfblob.py with colour (255, 0, 0) scored 24.3525

ป้อนคำอธิบายรูปภาพที่นี่

อารีน่า 2:

Bot dfblob.py with colour (255, 0, 0) scored 17.828356088588478
Bot Blob.py with colour (0, 255, 0) scored 0.9252889892479551
Bot Swallower.class with colour (0, 0, 255) scored 224.36743880007776

ป้อนคำอธิบายรูปภาพที่นี่

อารีน่า 3:

Bot dfblob.py with colour (255, 0, 0) scored 7.105141670032893
Bot Swallower.class with colour (0, 0, 255) scored 226.52057245080502
Bot Blob.py with colour (0, 255, 0) scored 12.621905476369092

ป้อนคำอธิบายรูปภาพที่นี่

สนามกีฬา 4:

Bot dfblob.py with colour (255, 0, 0) scored 60.10770441464656
Bot Blob.py with colour (0, 255, 0) scored 10.634653663956055
Bot Swallower.class with colour (0, 0, 255) scored 217.45490456277872

ป้อนคำอธิบายรูปภาพที่นี่

นี่คือผู้ตัดสินของ Sam Yonnou ที่มีการเปลี่ยนแปลงเล็กน้อยเพื่อให้คุณระบุไฟล์และคำสั่งแยกกัน:

import sys, re, random, os, shutil, subprocess, datetime, time, signal, io
from PIL import Image

ORTH = ((-1,0), (1,0), (0,-1), (0,1))
def place(loc, colour):
    # if valid, place colour at loc and return True, else False
    if pix[loc] == (255,255,255):
        plist = [(loc[0]+dx, loc[1]+dy) for dx,dy in ORTH]
        if any(pix[p]==colour for p in plist if 0<=p[0]<W and 0<=p[1]<H):
            pix[loc] = colour
            return True
    return False

def updateimage(image, msg, bot):
    if not re.match(r'(\s*\d+,\d+)*\s*', msg):
        return []
    plist = [tuple(int(v) for v in pr.split(',')) for pr in msg.split()]
    plist = plist[:PIXELBATCH]
    return [p for p in plist if place(p, bot.colour)]

class Bot:
    botlist = []
    def __init__(self, progs, command=None, colour=None):
        self.prog = progs[0]
        self.botlist.append(self)
        self.colour = colour
        self.colstr = str(colour).replace(' ', '')
        self.faults = 0
        self.env = 'env%u' % self.botlist.index(self)
        try: os.mkdir(self.env)
        except: pass
        for prog in progs:
            shutil.copy(prog, self.env)
        shutil.copy(imagename, self.env)
        os.chdir(self.env)
        args = command + [imagename, self.colstr, str(PIXELBATCH)]
        errorfile = 'err.log'
        with io.open(errorfile, 'wb') as errorlog:
            self.proc = subprocess.Popen(args, stdin=subprocess.PIPE, 
                stdout=subprocess.PIPE, stderr=errorlog)
        os.chdir('..')
    def send(self, msg):
        if self.faults < FAULTLIMIT:
            self.proc.stdin.write((msg+'\n').encode('utf-8'))
            self.proc.stdin.flush()
    def read(self, timelimit):
        if self.faults < FAULTLIMIT:
            start = time.time()
            inline = self.proc.stdout.readline().decode('utf-8')
            if time.time() - start > timelimit:
                self.faults += 1
                inline = ''
            return inline.strip()
    def exit(self):
        self.send('exit')

from cfg import *
for i, (progs, command) in enumerate(botspec):
    Bot(progs, command, colourspec[i])

image = Image.open(imagename)
pix = image.load()
W,H = image.size
resultdirectory = 'results of ' + BATTLE
os.mkdir(resultdirectory)

time.sleep(INITTIME)
total = 0
image.save(resultdirectory+'/'+'result000.png')
for turn in range(1, MAXTURNS+1):
    random.shuffle(Bot.botlist)
    nullbots = 0
    for bot in Bot.botlist:
        bot.send('pick pixels')
        inmsg = bot.read(TIMELIMIT)
        newpixels = updateimage(image, inmsg, bot)
        total += len(newpixels)
        if newpixels:
            pixtext = ' '.join('%u,%u'%p for p in newpixels)
            msg = 'colour %s chose %s' % (bot.colstr, pixtext)
            for msgbot in Bot.botlist:
                msgbot.send(msg)
        else:
            nullbots += 1
    if nullbots == len(Bot.botlist):
        break
    if turn % 100 == 0:
        print('Turn %s done %s pixels' % (turn, total))
        image.save(resultdirectory+'/result'+str(turn//100).zfill(3)+'.png')
image.save(resultdirectory+'/result999.png')
for msgbot in Bot.botlist:
    msgbot.exit()

resultfile = io.open(resultdirectory+'/result.txt','w')
counts = dict((c,f) for f,c in image.getcolors(W*H))
avg = 1.0 * sum(counts.values()) / len(Bot.botlist)
for bot in Bot.botlist:
    score = 100 * counts[bot.colour] / avg
    print('Bot %s with colour %s scored %s' % (bot.prog, bot.colour, score))
    print('Bot %s with colour %s scored %s' % (bot.prog, bot.colour, score), file=resultfile)
image.save(BATTLE+'.png')

ตัวอย่าง cfg:

BATTLE = 'Green DepthFirstBlob vs Red Swallower @ arena1'
MAXTURNS = 20000
PIXELBATCH = 10
INITTIME = 2.0
TIMELIMIT = .1
FAULTLIMIT = 5

imagename = 'arena1.png'

colourspec = (0,255,0), (255,0,0)

botspec = [
    (['DepthFirstBlob.py'], ['python', 'DepthFirstBlob.py']),
    (['Swallower.class','Swallower$Pixel.class'], ['java', 'Swallower']),
    ]

หมายเหตุ:ใครก็ตามที่สามารถกลืน Swallower ได้รับชื่อเสียง 100 รางวัล กรุณาโพสต์ในความคิดเห็นด้านล่างหากคุณประสบความสำเร็จในสิ่งนี้


2
@githubphagocyte ตามที่ร้องขอ
TheNumberOne

1
ทำงานได้ดีกับการเปลี่ยนแปลงของผู้พิพากษา การคัดลอกไฟล์และคำสั่งแยกต่างหากเป็นแนวคิดที่ดีและจำเป็นต้องมีการบันทึกข้อผิดพลาด
Logic Knight

1
หากคุณหมายถึง MAXTURNS อย่าลังเลที่จะเปลี่ยนแปลง มันไม่ได้เป็นส่วนหนึ่งของกฎ มันหยุดผู้ตัดสินจากการทำงานตลอดไป (แต่ฉันเดาว่าเงื่อนไขการยกเลิกจะป้องกันไม่ให้เกิดขึ้น)
Logic Knight

1
@githubphagocyte คงที่
TheNumberOne

1
หลังจากดูการต่อสู้แบบเคลื่อนไหวของคุณฉันเริ่มสงสัยว่าการต่อสู้ของ Swallower กับ Swallower จะเป็นอย่างไร คนหนึ่งจะดักอย่างรวดเร็วหรือจะเป็นการต่อสู้เพื่อครอบครองพื้นที่อย่างต่อเนื่องหรือไม่?
Logic Knight

6

สุ่ม, ภาษา = java, คะแนน = 0.43012126100275

โปรแกรมนี้สุ่มวางพิกเซลบนหน้าจอ พิกเซลบางส่วน (ถ้าไม่ทั้งหมด) จะไม่ถูกต้อง ในหมายเหตุด้านข้างมันควรจะยากที่จะสร้างโปรแกรมที่เร็วกว่าโปรแกรมนี้

import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.BufferedReader;
import java.io.File;
import java.io.InputStreamReader;

public class Random {

    static BufferedReader in = new BufferedReader(new InputStreamReader(System.in));

    static int n;

    static int height;

    static int width;

    public static void main(String[] args) throws Exception{
        BufferedImage image = ImageIO.read(new File(args[0]));
        height = image.getHeight();
        width = image.getWidth();
        n = Integer.parseInt(args[2]);
        while (true){
            String input = in.readLine();
            if (input.equals("exit")){
                return;
            }
            if (!input.equals("pick pixels")){
                continue;
            }
            for (int i = 0; i < n; i++){
                System.out.print((int) (Math.random() * width) + ",");
                System.out.print((int) (Math.random() * height) + " ");
            }
            System.out.println();
        }
    }
}

สนามกีฬา 1:

1

อารีน่า 2:

2

อารีน่า 3:

3

สนามกีฬา 4:

4


7
ผมเห็นคุณไม่ได้ลดลงเข้าสู่กับดักของการเพิ่มประสิทธิภาพก่อนวัยอันควร
Logic Knight
โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.