Полювання на великодні яйця

Знайдіть яйце перед тим, як кролик знайде яйце. Бот щасливий.

Огляд

Це король-оф-хілл виклик на честь Великодня і пасхальне яйце полювання традиції!

Ваш бот має бачення двох пробілів у кожному напрямку, включаючи діагоналі, створюючи навколо себе квадрат 5х5, який ви можете бачити. Шукає яйця, і хто знайде найбільше яєць, той і виграє!

Дошка

Дошка буде складатися з os, що є писанками, #s, які є стінами, *s, які є іншими гравцями, і s, які є порожніми місцями.

• Це буде квадрат з довжиною краю (number of entries) * 3.
• Він буде оточений стінами.
• Всередині стін буде асортимент випадково розміщених прямолінійних стін #, які матимуть випадкову довжину від 2 до 10 включно. Буде (number of entries) * 3їх.
• Потім яйця будуть розміщені випадковим чином. Там буде (number of entries) * 4їх, і вони будуть генеруватися тільки на заготівлі ( ) квадратів.
• Для нормальної роботи ради має бути не менше 7 ентерів.

Ось JSFiddle, який генерує випадкову дошку для тестування. Ось приклад із (number of entries) = 7:

#####################
#        o         ##
#    #    o        ##
#    #o    ######  ##
######     #       ##
## o #     #       ##
##  o#   #o#    o o##
##   #o  # # o  #   #
##   # o # #    #   #
##  ##   # #  o #   #
##  #    #  o   # # #
##  # o  #   ## # # #
##  #           # # #
# o #          ## # #
# o oo         ##o  #
#o  ####### oo ##   #
#        #      #   #
#   o o o#          #
#   o ####   o     o#
#                   #
#####################

Після генерування дошки кожен гравець розміщується на випадковому квадраті (порожнє місце).

Вхідні дані

Ви візьмете шість рядків введення. Перші п’ять рядків - це ваше поле зору (пробіли поза межами дошки будуть представлені символом X, а середній простір завжди будете *ви), а шостий рядок буде порожнім (спочатку).

Вихідні дані

Ви виведете три рядки. По-перше, напрямок, у якому потрібно рухатись:

1  2  3
8 YOU 4
7  6  5

(9 - не-оп, якщо ви не хочете рухатись), по-друге, з Attack, Counter або Nщось інше (це буде пояснено незабаром у глибині), а третя лінія буде будь-яким рядком довжиною до 1024 Це буде пам'ять вашого бота. Ви можете використовувати його для чого завгодно, або можете залишити його порожнім. Потім ця пам'ять стане шостим рядком введення вашої програми при наступному запуску.

Всі подальші рядки виводу ігноруються, і якщо є лише один рядок, другий вважається порожнім.

Переміщення

Наступний процес використовується для визначення місця переїзду:

• Якщо під час переміщення ви опиняєтесь у порожньому просторі ( ), ваш програвач розміщується в цьому просторі.
• Якщо ви опинитесь у стіні ( #), ваш хід ігнорується, і ви втрачаєте свою чергу.
• Якщо ви опинитесь в яйці ( o) або гравцеві ( *), ця інформація зберігається і буде використовуватися після переміщення всіх.

Після того, як усі переїхали, двозначності вирішуються.

Якщо є два гравці, які приземлилися на одному просторі, відбувається бійка! Ось тут A/ C/ Nприходить грати. Attack beats Nothing (нормальна атака), Nothing beats Counter (ти нічого не можеш протидіяти), and Counter beats Attack (контратака). Гравець, який виграє цю боротьбу, залишається на їхній площі, а гравець, який програє, повертається до початкового квадрата, на якому вони почали. У разі нічиїх обох гравців повертаються туди, де були.

Якщо програючий або прив'язаний гравець повернеться туди, де вони були, і там є інший гравець, то бійки немає, і інший гравець також повернеться до свого початкового місця. Якщо в цьому просторі є інший гравець, той гравець повертається назад, і це триває, поки всі гравці не опиняться в різних місцях.

Якщо на одному просторі є три або більше гравців, всі вони повертаються на свої початкові позиції.

Якщо якийсь гравець все ще стоїть на яйці ...

• Якщо гравець вибрав A, яйце знищується.
• Якщо гравець вибрав C, нічого не відбувається, і гравець повертається до свого початкового простору.
• Якщо гравець вибрав N, гравець вибирає яйце! Оцінка гравця збільшується на одиницю, а яйце видаляється.

Мови

Ви можете використовувати будь-яку мову, що є у вільному доступі в Windows, OSX та Linux, щоб забезпечити справедливість серед кожного учасника. Якщо код не вільно керується, але його можна скласти або упакувати у такий формат, будь ласка, включіть цей формат у свою відповідь. В ідеалі, якщо ви можете скласти свій код на більш поширеній мові (наприклад, CoffeeScript -> JavaScript), будь ласка, зробіть це.

Оцінка балів

Ваша оцінка буде середньою кількістю яєць, які ви збираєте за десять пробіжок. Пробіг закінчується, коли всі яйця зібрані або коли (number of entries * 25)пройшли обороти. Я вручну переконуюсь, що можна досягти всіх яєць для кожної карти (постійно генеруючи карти, поки всі яйця не будуть доступні).

Табло

Таблиця буде додана, коли будуть виконані всі наступні умови:

• Надіслано щонайменше сім дійсних записів із позитивною чи нульовою оцінкою (не заперечується)
• З моменту створення цього виклику минуло щонайменше 48 годин (UTC 14:23)

Правила не змінюватимуться протягом цього періоду перед конкурсом, за винятком того, щоб додати роз'яснення, коли правило було незрозумілим. Після встановлення табло тут буде розміщена програма тестування, щоб ви могли перевірити свої записи. Код тестування для цього все ще працює, але він відтворюється і працює. Ось репортаж GitHub.

Cart'o'Gophers

Ось ще одне подання - і це насправді має бути конкурентоспроможним. Знову ж таки, це в Рубі. Тож запускайте його ruby cartogophers.rb. Це зайняло набагато більше часу, ніж очікувалося ...

require 'zlib'
require 'base64'

def encode map, coords
    zipped = Zlib::Deflate.deflate map.join
    encoded = Base64.encode64(zipped).gsub("\n",'')
    "#{coords[:x]}|#{coords[:y]}|#{map.length}|#{encoded}"
end

def decode memory
    memory =~ /^(\d+)[|](\d+)[|](\d+)[|](.*)$/
    coords = {x: $1.to_i, y: $2.to_i}
    n_rows = $3.to_i
    encoded = $4
    decoded = Base64.decode64 encoded
    unzipped = Zlib::Inflate.inflate decoded
    n_cols = unzipped.length / n_rows;
    return unzipped.scan(/.{#{n_cols}}/), coords
end

def update map, fov, coords
    if coords[:x] < 2
        map.map! { |row| '?' << row }
        coords[:x] += 1
    elsif coords[:x] >= map[0].length - 2
        map.map! { |row| row << '?' }
    end

    if coords[:y] < 2
        map.unshift '?' * map[0].length
        coords[:y] += 1
    elsif coords[:y] >= map.length - 2
        map.push '?' * map[0].length
    end

    fov.each_index do |i|
        map[coords[:y]-2+i][coords[:x]-2, 5] = fov[i]
    end

    return map, coords
end

def clean_up map
    map.each do |row|
        row.gsub!('*', ' ')
    end
end

DIRECTIONS = [
    [],
    [-1,-1],
    [ 0,-1],
    [ 1,-1],
    [ 1, 0],
    [ 1, 1],
    [ 0, 1],
    [-1, 1],
    [-1, 0],
    [ 0, 0]
]

def move_to dir, coords
    {
        x: coords[:x] + DIRECTIONS[dir][0],
        y: coords[:y] + DIRECTIONS[dir][1]
    }
end

def get map, coords
    if coords[:x] < 0 || coords[:x] >= map[0].length ||
       coords[:y] < 0 || coords[:y] >= map.length
        return '?'
    end
    map[coords[:y]][coords[:x]]
end

def set map, coords, value
    unless coords[:x] < 0 || coords[:x] >= map[0].length ||
       coords[:y] < 0 || coords[:y] >= map.length
        map[coords[:y]][coords[:x]] = value
    end
    map[coords[:y]][coords[:x]]
end

def scan_surroundings map, coords
    not_checked = [coords]
    checked = []
    cost = { coords => 0 }
    direction = { coords => 9 }
    edges = {}

    while not_checked.length > 0
        current = not_checked.pop

        checked.push current
        (-1..1).each do |i|
            (-1..1).each do |j|
                c = { x: current[:x]+i, y: current[:y]+j }
                unless not_checked.include?(c) || checked.include?(c)
                    if get(map, c) == '#'
                        checked.push c
                    elsif get(map, c) == '?'
                        checked.push c
                        edges[current] = { cost: cost[current], move: direction[current] }
                    else
                        not_checked.unshift c

                        cost[c] = cost[current] + 1
                        if direction[current] == 9 # assign initial direction
                            direction[c] = DIRECTIONS.find_index([i,j])
                        else
                            direction[c] = direction[current]
                        end

                        if get(map, c) == 'o'
                            return direction[c], if cost[c] == 1 then 'N' else 'A' end
                        end

                        edges[c] = { cost: cost[c], move: direction[c] } if c[:x] == 0 || c[:x] == map[0].length - 1 ||
                                                                            c[:y] == 0 || c[:y] == map.length - 1
                    end
                end
            end
        end
    end

    # If no egg has been found return the move to the closest edge
    nearest_edge = edges.keys.sort_by { |c| edges[c][:cost] }.first
    if edges.length > 0
        return edges[nearest_edge][:move], 'A'
    else
        # The entire map has been scanned and no more eggs are left.
        # Wait for the game to end.
        return 9, 'N'
    end
end

input = $<.read.split "\n"
fov = input[0..4]
memory = input[5]

if memory
    map, coords = decode memory
    map, coords = update(map, fov, coords)
else
    map = fov
    coords = {x: 2, y: 2}
end
clean_up map

move, attack = scan_surroundings(map, coords)

memory = encode map, move_to(move, coords)

puts "#{move}
#{attack}
#{memory}"

Цей бот запам'ятовує побачене раніше і намагається створити більшу карту на кожному кроці. Потім він використовує перший пошук в глибині найближчого яйця і голів таким чином. Якщо на поточній карті немає яйця, до якого можна дістатися, бот спрямовується до найближчого відкритого краю своєї карти (щоб швидко розгорнути карту в напрямку, в якому вона все ще може рухатися).

Цей бот ще не має концепції інших ботів і не має стратегії боротьби. Оскільки я не знайшов надійного способу визначити, чи вдався мій крок, це може спричинити деякі проблеми. Я просто вважаю, що переміщення було успішним - тому, якщо це не нові патчі, вони будуть завантажені в карту в неправильних місцях, що може бути, а може і не бути шкідливим для проходження маршруту.

Бот використовує пам'ять для зберігання карти та її нового положення на карті (якщо припустити, що переміщення буде успішним). Карта зберігається без розривів рядків, зашифрованих та base64, закодованих (разом із кількістю рядків карти, щоб розриви рядків могли бути знову вставлені). Це стиснення зменшує розмір приблизно до третини нестисненої карти, тому маючи відтінок понад 1000 байт, я міг би зберігати карту приблизно з 3000 комірок, що приблизно відповідає повному дослідженню карти з 18 ботами. Поки ніде не існує такої кількості матеріалів, я не думаю, що я можу зайнятися пошуком виправ для цього випадку.

Після декількох пробіжок на 5 dumbbotс та 1 naivebot(моє інше подання), він або справді погано (наприклад, 1 або 2 яйця), або перевершив інші за великим запасом (від 7 до 9 яєць). Я можу подумати над кращою стратегією боротьби та про те, як я можу визначити, чи дійсно я переїхав чи ні. І те й інше, можливо, зможе дещо покращити рахунок.

Ну, і якщо вам цікаво ім'я бота, вам слід прочитати «Порядок The Stick» ( остання панель цього коміксу ).

EDIT: Було кілька помилок із виявленням країв виявленої карти. Тепер, коли я їх виправив, цей бот завжди отримує бали приблизно 205 dumbbotі 1 с naivebot. Більше схоже на це! Якщо ви зараз додасте $stderr.puts mapмого бота, ви дійсно можете побачити, як він систематично розкриває карту і збирає всі яйця тим часом. Я також вирішив вибирати Aзамість того, щоб Nне наступати на яйце, щоб зменшити ймовірність повернутися до початкової клітини бота (яка частково накручує карту).

(Це не дуже добре проти 6 naivebotс, тим більше, що дуже можливо опинитися в "глухому куті" з іншим ботом, коли вони обидва рази хочуть схопити яйце і вибрати N. Мені потрібно подумати про це ... )

Ява Зайчик

Цей зайчик ще не закінчив дорослішати (я все ще планую внести зміни), але зараз це відправна точка. Він шукає найближче яйце і йде до нього. Немає виявлення стін або виявлення поза межами (поки що). Він піде забрати яйце, на яке він приземляється, але в іншому випадку спробує проштовхнути його і напасти на все інше. Якщо поблизу немає яєць, він почне слідувати за найближчим зайчиком. Вони можуть знати щось, чого він не робить. Інакше він просто вибере випадковий напрямок для прогулянки. І він досить забудькучий (не використовує змінну пам'яті).

Плани, що рухаються вперед:

• Приймайте рішення на основі стін / поза межами
• Вибирайте шляхи з метою, а не випадковим чином
• Використовуйте пам'ять, щоб визначити напрямок, в якому я йшов раніше

Оновлення 1 Мій зайчик піде за іншими зайчиками, якщо він не побачить яйце. Також відновив код «знайти найближче яйце» у свій власний метод.

import java.util.*;

public class EasterEggHunt {

    // board chars
    public static final char EGG = 'o';
    public static final char WALL = '#';
    public static final char BUNNY = '*';
    public static final char SPACE = ' ';
    public static final char OUT_OF_BOUNDS = 'X';

    // player moves
    public static final char ATTACK = 'A';
    public static final char COUNTER = 'C';
    public static final char NOTHING = 'N';

    // directions
    public static final int UPPER_LEFT = 1;
    public static final int UP = 2;
    public static final int UPPER_RIGHT = 3;
    public static final int RIGHT = 4;
    public static final int LOWER_RIGHT = 5;
    public static final int DOWN = 6;
    public static final int LOWER_LEFT = 7;
    public static final int LEFT = 8;
    public static final int STAY = 9;


    // the size of the immediate area
    // (I'll be at the center)
    public static final int VISION_RANGE = 5;

    public static void main(String[] args) {

        Scanner input = new Scanner(System.in);

        char[][] immediateArea = new char[VISION_RANGE][VISION_RANGE];

        for (int i = 0; i < VISION_RANGE; ++i) {
            String line = input.nextLine();
            for (int j = 0; j < VISION_RANGE; ++j) {
                immediateArea[i][j] = line.charAt(j);
            }
        }

        String memory = input.nextLine();

        int moveDirection = decideMoveDirection(immediateArea, memory);
        System.out.println(moveDirection);

        char action = decideAction(immediateArea, memory, moveDirection);
        System.out.println(action);

        // change the memory?
        System.out.println(memory);

    }

    private static int decideMoveDirection(char[][] immediateArea, String memory) {

        // if there's a nearby egg, go towards it
        int direction = nearestBoardObject(immediateArea, EGG);

        // if we didn't find an egg, look for a bunny
        // (maybe he knows where to find eggs)
        if (direction == STAY)
            direction = nearestBoardObject(immediateArea, BUNNY);

        // otherwise, pick a random direction and go
        // we want to also have the chance to stop and catch our breath
        if (direction == STAY)
            direction = new Random().nextInt(STAY + 1);

        return direction;
    }

    private static int nearestBoardObject(char[][] immediateArea, char boardObject) {

        // start at the center and go outward (pick a closer target over a farther one)
        int spacesAway = 1;
        int meX = immediateArea.length / 2;
        int meY = immediateArea[meX].length / 2;

        while (spacesAway <= immediateArea.length / 2) {

            // I like to look right, and go clockwise
            if (immediateArea[meX][meY + spacesAway] == boardObject)
                return RIGHT;
            if (immediateArea[meX + spacesAway][meY + spacesAway] == boardObject)
                return LOWER_RIGHT;
            if (immediateArea[meX + spacesAway][meY] == boardObject)
                return DOWN;
            if (immediateArea[meX + spacesAway][meY - spacesAway] == boardObject)
                return LOWER_LEFT;
            if (immediateArea[meX][meY - spacesAway] == boardObject)
                return LEFT;
            if (immediateArea[meX - spacesAway][meY - spacesAway] == boardObject)
                return UPPER_LEFT;
            if (immediateArea[meX - spacesAway][meY] == boardObject)
                return UP;
            if (immediateArea[meX - spacesAway][meY + spacesAway] == boardObject)
                return UPPER_RIGHT;

            ++spacesAway;
        }

        // if the target object isn't in the immediate area, stay put
        return STAY;

    }

    private static char decideAction(char[][] immediateArea, String memory, int moveDirection) {

        char destinationObject = getDestinationObject(immediateArea, moveDirection);

        switch (destinationObject) {

            case EGG:
                // don't break the egg
                return NOTHING;
            default:
                // get really aggressive on everything else
                // other players, walls, doesn't matter
                return ATTACK;

        }

    }

    private static char getDestinationObject(char[][] immediateArea, int moveDirection) {

        // start at my spot (middle of the board) and figure out which direction I'm going
        int targetX = immediateArea.length / 2;
        int targetY = immediateArea[targetX].length / 2;

        switch (moveDirection) {

            case RIGHT:
                ++targetY;
                break;
            case LOWER_RIGHT:
                ++targetX;
                ++targetY;
                break;
            case DOWN:
                ++targetX;
                break;
            case LOWER_LEFT:
                ++targetX;
                --targetY;
                break;
            case LEFT:
                --targetY;
                break;
            case UPPER_LEFT:
                --targetX;
                --targetY;
                break;
            case UP:
                --targetX;
                break;
            case UPPER_RIGHT:
                --targetX;
                ++targetY;
                break;
            // otherwise we aren't moving

        }

        return immediateArea[targetX][targetY];

    }

}

NaiveBot (в Ruby)

Ось дуже спрощений бот для отримання яєць (ми хочемо швидко вразити ці 7 подань, правда?). Мій Рубі не дуже ідіоматичний, тому цей код може викликати біль у рубістів. Читайте на свій страх і ризик.

input = $<.read
$data = input.split("\n")

def is_egg x, y
    $data[y+2][x+2] == 'o'
end

def is_wall x, y
    $data[y+2][x+2] == '#'
end

def is_empty x, y
    $data[y+2][x+2] == ' '
end

def is_player x, y
    $data[y+2][x+2] == '*'
end

if (is_egg(-2,-2) || is_egg(-2,-1) || is_egg(-1,-2)) && !is_wall(-1,-1) || is_egg(-1,-1)
    dir = 1
elsif is_egg(0,-2) && !is_wall(0,-1) || is_egg(0,-1)
    dir = 2
elsif (is_egg(2,-2) || is_egg(2,-1) || is_egg(1,-2)) && !is_wall(1,-1) || is_egg(1,-1)
    dir = 3
elsif is_egg(2,0) && !is_wall(1,0) || is_egg(1,0)
    dir = 4
elsif (is_egg(2,2) || is_egg(2,1) || is_egg(1,2)) && !is_wall(1,1) || is_egg(1,1)
    dir = 5
elsif is_egg(0,2) && !is_wall(0,1) || is_egg(0,1)
    dir = 6
elsif (is_egg(-2,2) || is_egg(-2,1) || is_egg(-1,2)) && !is_wall(-1,1) || is_egg(-1,1)
    dir = 7
elsif is_egg(-2,0) && !is_wall(-1,0) || is_egg(-1,0)
    dir = 8
else
    dir = rand(8) + 1
end

attack = 'N'
puts "#{dir}
#{attack}
"

Бігайте з ruby naivebot.rb.

Я просто важко кодую кілька випадків, коли яйце видно і не перешкоджає стіні. Навіть не йде на найближче яйце, але вибирає перший крок, який має сенс. Якщо такого яйця не знайдено, бот робить випадковий хід. Він ігнорує всіх інших гравців і ніколи не атакує і не проводить контратаки.

WallFolower

(навмисне каламбур) на Python 3 :

import sys
import random

#functions I will use
dist       = lambda p1,p2: max(abs(p2[1] - p1[1]), abs(p2[0] - p1[0]))
distTo     = lambda p    : dist((2,2), p)
cmp        = lambda x,y  : (x > y) - (x < y)
sgn        = lambda x    : (-1,0,1)[(x>0)+(x>=0)]
move       = lambda p    : (sgn(p[0] - 2), sgn(p[1] - 2))
unmove     = lambda p    : (p[0] * 2 + 2, p[1] * 2 + 2)
outputmove = lambda p    : (1,2,3,8,9,4,7,6,5)[(sgn(p[0] - 2) + 1) + 3*(sgn(p[1]-2) + 1)]
def noeggfinish(move):
    print(outputmove(unmove(move)))
    print('ACN'[random.randint(0, 2)])
    print("1"+move)
    sys.exit(0)

#beginning of main body
view    = [list(l) for l in map(input, ('',)*5)] #5 line input, all at once.
memory  = input() #currently used only as last direction moved in a tuple
eggs    = []
enemies = []
for y in range(5):
    for x in range(5):
        if   view[y][x] == 'o': eggs    += [(x,y)]
        elif view[y][x] == '*': enemies += [(x,y)]

eggs.sort(key = lambda p:distTo(p)) #sort by how close to me they are.

tiedeggs = []
end = 0
for egg in eggs[:]:
    if end:break
    for enemy in enemies:
        exec({
            -1: 'eggs.remove(egg)',
             0: 'tiedeggs += egg',
             1: 'end=1'
        }[cmp(dist(enemy, egg), distTo(egg))])
        if end:break
if eggs:
    print(outputmove(eggs[0]))
    print('N')              #no attack here
    print("0"+move(eggs[0]))
    sys.exit(0)
elif tiedeggs:
    print(outputmove(tiedeggs[0]))
    print('N')              #no attack here
    print("0"+move(tiedeggs[0]))
    sys.exit(0) 
#now there are no eggs worth going for
#do a LH wall follow

lastmove = eval(memory[1:]) #used to resolve ambiguity
if lastmove[0] and lastmove[1]:
    lastmove[random.randint(0,1)] = 0 #disregard diagonal moves
if eval(memory[0]):
    exec("check=view[%n][%n]"%{(0,-1):(0,0),(1,0):(4,0),(0,1):(4,4),(-1,0):(0,4)}[lastmove])
    if check == '#':
        noeggfinish(lastmove)
    else:pass
#currently unimplemented
#move randomly
noeggfinish(tuple([(x,y) for x in [-1,0,1] for y in [-1,0,1] if (x,y) != (0,0)))

Переміщається до яйця, якщо видно яйце, але тільки якщо воно ближче до цього яйця, ніж інший робот. Якщо на відстані є краватка, вона все одно для цього йде. В іншому випадку, чи слід СТ-стіна (наразі недостатньо реалізована).

Ще потрібно працювати над стіною, але я все-таки опублікую це.