Búsqueda de huevos de Pascua

Bot encuentra huevo antes de que conejito encuentre huevo. Bot feliz.

Visión general

¡Este es un desafío del rey de la colina en honor a la Pascua y la tradición de la caza del huevo de Pascua!

Tu bot tiene una visión de dos espacios en cada dirección, incluidas las diagonales, creando un cuadrado de 5x5 a tu alrededor que puedes ver. ¡Está buscando huevos, y el que encuentre más huevos gana!

El tablero

El tablero consistirá en os, que son huevos de Pascua, #s, que son paredes, *s, que son otros jugadores, y s, que son espacios vacíos.

• Será un cuadrado con longitud de borde (number of entries) * 3.
• Estará rodeado de muros.
• Dentro de las paredes habrá una variedad de paredes de líneas rectas colocadas al azar #, que tendrán una longitud aleatoria entre 2 y 10 inclusive. Habrá (number of entries) * 3de ellos.
• Los huevos se colocarán al azar. Habrá (number of entries) * 4de ellos, y solo se generarán en cuadrados en blanco ( ).
• Debe haber al menos 7 entradas para que el proceso de generación de la placa funcione correctamente.

Aquí hay un JSFiddle que generará un tablero aleatorio para que lo pruebe. Aquí hay un ejemplo, con (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#
#                   #
#####################

Después de que se genera el tablero, cada jugador se coloca en un cuadrado aleatorio (espacio vacío).

Entrada

Tomarás seis líneas de entrada. Las primeras cinco líneas son su campo de visión (los espacios fuera de los límites del tablero estarán representados por X, y el espacio intermedio siempre será *usted), y la sexta línea estará vacía (al principio).

Salida

Saldrá tres líneas. Primero, la dirección en la que quieres moverte:

1  2  3
8 YOU 4
7  6  5

(9 es un no-op si no quiere moverse), segundo, uno de Atack, Conza u otro N(esto se explicará en profundidad pronto), y la tercera línea será cualquier cadena de longitud hasta 1024 Esta será la memoria de tu bot. Puede usarlo para lo que desee, o puede dejarlo en blanco. Esta memoria será la sexta línea de entrada a su programa en la próxima ejecución.

Se ignoran todas las líneas de salida adicionales, y si solo hay una línea, se supone que la segunda está en blanco.

Moviente

El siguiente proceso se utiliza para determinar dónde se mudó:

• Si, cuando te mueves, terminas en un espacio vacío ( ), tu jugador se coloca en ese espacio.
• Si terminas en una pared ( #), tu movimiento es ignorado y pierdes tu turno.
• Si terminas en un huevo ( o) o en un jugador ( *), esta información se almacena y se usará después de que todos se hayan movido.

Después de que todos se han movido, se resuelven las ambigüedades.

Si hay dos jugadores que han aterrizado en el mismo espacio, ¡se produce una pelea! Aquí es donde entra A/ C/ Npara jugar. Attack supera a otro N(ataque normal), otro Nsupera a un Ckilo (no se puede contrarrestar nada) y Conza supera a un Asegundo (contraataque). El jugador que gana esta pelea se queda en su casilla, y el jugador que pierde vuelve a la casilla original en la que comenzó. En caso de empate, ambos jugadores vuelven a donde estaban.

Si un jugador perdido o empatado vuelve a donde estaba y hay otro jugador allí, no hay pelea y el otro jugador también volverá a su espacio original. Si este espacio tiene otro jugador, ese jugador regresa, y esto continúa hasta que todos los jugadores estén en espacios diferentes.

Si hay tres o más jugadores en un espacio, todos vuelven a sus posiciones originales.

Si algún jugador todavía está parado sobre un huevo ...

• Si el jugador elige A, el huevo se destruye.
• Si el jugador elige C, no pasa nada y el jugador vuelve a su espacio original.
• Si el jugador elige N, ¡el jugador recoge el huevo! La puntuación del jugador se incrementa en uno y el huevo se elimina.

Idiomas

Puede usar cualquier idioma que esté disponible gratuitamente en Windows, OSX y Linux, para garantizar la equidad entre cada concursante. Si el código no se puede ejecutar libremente pero puede compilarse o empaquetarse en un formato que sí lo es, incluya este formato en su respuesta también. Idealmente, si puede compilar su código en un lenguaje más común (es decir, CoffeeScript -> JavaScript), hágalo.

Puntuación

Su puntaje será el número promedio de huevos que recolecta de cada diez carreras. Una carrera termina cuando se recogen todos los huevos o cuando (number of entries * 25)han pasado los turnos. Me aseguraré manualmente de que sea posible alcanzar todos los huevos para cada mapa (generando mapas continuamente hasta que todos los huevos sean accesibles).

Marcador

Se agregará un marcador cuando se cumplan todas las siguientes condiciones:

• Se han enviado al menos siete entradas válidas con un puntaje positivo o cero (sin voto negativo)
• Han transcurrido al menos 48 horas desde la creación de este desafío (UTC 14:23)

Las reglas no cambiarán durante este período previo al concurso, excepto para agregar aclaraciones donde una regla no estaba clara. Una vez que se coloca el marcador, el programa de prueba también se publicará aquí para que pueda probar sus entradas. El código de prueba para esto todavía está en progreso, pero es jugable y funciona. Aquí está el repositorio de GitHub.

Cart'o'Gophers

Aquí hay otra presentación, y esta en realidad está destinada a ser competitiva. De nuevo, está en Ruby. Así que ejecútalo con ruby cartogophers.rb. Esto tardó mucho más de lo esperado ...

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}"

Este bot recuerda lo que ha visto antes e intenta construir un mapa más grande en cada turno. Luego usa una búsqueda de amplitud para el huevo y las cabezas más cercanas de esa manera. Si no se puede alcanzar un huevo en el mapa actual, el bot se dirige al borde abierto más cercano de su mapa (para expandir el mapa rápidamente en una dirección en la que aún puede moverse).

Este bot aún no tiene el concepto de otros bots y tampoco tiene una estrategia de lucha. Como no he encontrado una forma confiable de determinar si mi mudanza ha sido exitosa, esto puede causar algunos problemas. Simplemente siempre asumo que el movimiento ha sido exitoso, por lo que si no se trata de parches nuevos, se cargarán en el mapa en los lugares incorrectos, lo que puede o no ser perjudicial para la búsqueda de caminos.

El bot usa la memoria para almacenar el mapa y su nueva posición en el mapa (suponiendo que el movimiento sea exitoso). El mapa se almacena sin saltos de línea, comprimido y codificado en base64 (junto con el número de filas del mapa, para que los saltos de línea se puedan volver a insertar). Esta compresión reduce el tamaño a aproximadamente un tercio del mapa sin comprimir, por lo que con una sombra de más de 1000 bytes, podría almacenar un mapa de aproximadamente 3000 celdas, que corresponde aproximadamente a explorar completamente un mapa con 18 bots. Mientras no haya tantas presentaciones, no creo que pueda molestarme en encontrar una solución para ese caso.

Después de algunas pruebas en 5 dumbbotsy 1 naivebot(mi otra presentación), tuvo un desempeño realmente malo (como 1 o 2 huevos) o superó a los demás por un margen considerable (7 a 9 huevos). Puedo pensar en una mejor estrategia de lucha y cómo puedo determinar si realmente me moví o no. Ambos podrían mejorar algo el puntaje.

Ah, y si te estás preguntando sobre el nombre del bot, deberías leer The Order of The Stick ( último panel de este cómic ).

EDITAR: Hubo algunos errores al detectar los bordes del mapa descubierto. Ahora que los he solucionado, este bot siempre obtiene puntajes de aproximadamente 20contra 5 dumbbotsy 1 naivebot. Eso es más como eso! Si agrega $stderr.puts mapa mi bot ahora, realmente puede ver cómo descubre sistemáticamente el mapa y mientras tanto recoge todos los huevos. También he decidido elegir en Alugar de Nno pisar un huevo, para reducir la probabilidad de volver a la celda original del bot (que en parte arruina el mapa).

(No funciona tan bien contra 6 naivebots, especialmente porque es muy posible terminar en un "punto muerto" con otro bot cuando ambos quieren agarrar un huevo repetidamente y elegir N. Tengo que pensar en eso ... )

Conejito de java

Este conejito aún no ha terminado de crecer (todavía planeo hacer cambios), pero es un punto de partida por ahora. Busca el huevo más cercano y se dirige hacia él. No hay detección de muro o detección fuera de límites (todavía). Él irá a recoger el huevo en el que aterriza, pero de lo contrario intentará empujar y atacar cualquier otra cosa. Si no hay huevos cercanos, comenzará a seguir al conejito más cercano. Pueden saber algo que él no sabe. De lo contrario, simplemente elegirá una dirección aleatoria para caminar. Y es bastante olvidadizo (no usa la variable de memoria).

Planes para avanzar:

• Tomar decisiones basadas en muros / fuera de límites
• Elija caminos con un propósito, en lugar de al azar
• Usa la memoria para determinar la dirección en la que iba antes

Actualización 1 Mi conejito seguirá a otros conejos si no ve un huevo. También refactorizó el código "buscar el huevo más cercano" en su propio método.

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 (en Ruby)

Aquí hay un bot muy simplista para poner en marcha el huevo (queremos llegar a esos 7 envíos rápidamente, ¿verdad?). Mi Ruby no es muy idiomático, por lo que este código puede hacer que los rubíes adecuados se encojan de dolor. Lea bajo su propio riesgo.

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}
"

Corre con ruby naivebot.rb.

Simplemente estoy codificando algunos casos, donde un huevo es visible y no está obstruido por una pared. Ni siquiera va por el huevo más cercano, sino que elige el primer movimiento que tiene sentido. Si no se encuentra ese huevo, el bot realiza un movimiento aleatorio. Ignora a todos los demás jugadores y nunca ataca ni contraataca.

WallFolower

(juego de palabras deliberado) en 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)))

Se mueve a un huevo si hay un huevo a la vista, pero solo si está más cerca de ese huevo que otro robot. Si hay un empate en la distancia, lo intenta de todos modos. De lo contrario, sigue un muro LH (actualmente no está bien implementado).

Todavía necesita trabajo en el muro, pero publicaré esto aquí de todos modos.