BrainF *** edBotsForBattling - Un torneo Brainf ***

88

Todos los bots en el campo de batalla de repente se pusieron a pensar y nadie puede explicar por qué. Pero a quién le importa mientras puedan pelear, aunque Brainfuck es el único idioma que entienden.


Ha pasado un tiempo desde la última presentación, así que finalmente anunciaré al ganador de BrainFuckedBotsForBattling: ¡ Felicitaciones a LymiaAluysia por ganar con NyurokiMagicalFantasy!


Marcador

|       Owner        |          Bot            Score |
|--------------------|-------------------------------|
| LymiaAluysia       | NyurokiMagicalFantasy -  600  |
| Sylwester          | LethalLokeV2.1        -  585  |
| weston             | MickeyV4              -  584  |
| Sp3000             | YandereBot            -  538  |
| Comintern          | CounterPunch          -  512  |
| Sylwester          | BurlyBalderV3         -  507  |
| LymiaAluysia       | NestDarwin            -  493  |
| IstvanChung        | Bigger                -  493  |
| Manu               | DecoyMaster           -  489  |
| archaephyrryx      | Wut                   -  478  |
| DLosc              | LightfootPlodder      -  475  |
| archaephyrryx      | 99BottlesOfBats       -  461  |
| Sylwester          | TerribleThorV2        -  458  |
| MikaLammi          | WallE2.0              -  443  |
| Mikescher          | MultiVAC              -  441  |
| archaephyrryx      | Twitcher              -  439  |
| Timtech            | MetalDetector         -  438  |
| AndoDaan           | BeatYouMate           -  433  |
| csarchon           | TheWallmaster         -  427  |
| Sparr              | SeeSawRush            -  412  |
| archaephyrryx      | Stitcher              -  406  |
| PhiNotPi           | RandomOscillator      -  403  |
| ccarton            | AnybodyThere          -  398  |
| Comintern          | 2BotsOneCup           -  392  |
| kaine              | SternBot              -  387  |
| PhiNotPi           | EvoBot2               -  385  |
| PhiNotPi           | EvoBot1               -  381  |
| Brilliand          | TimedAttack           -  373  |
| Sylwester          | ReluctantRanV2        -  373  |
| AndoDaan           | PrimesAndWonders      -  359  |
| Nax                | TruthBot              -  357  |
| DLosc              | Plodder               -  356  |
| weston             | FastTrapClearBot      -  345  |
| MikaLammi          | PolarBearMkII         -  340  |
| Sp3000             | ParanoidBot           -  336  |
| Moop               | Alternator            -  319  |
| TestBot            | FastClearBot          -  302  |
| icedvariables      | PyBot                 -  293  |
| TestBot            | DecoyBot              -  293  |
| kaine              | BestOffense           -  291  |
| Geobits            | Backtracker           -  289  |
| bornSwift          | ScribeBot             -  280  |
| IngoBuerk          | Geronimo              -  268  |
| flawr              | CropCircleBot         -  239  |
| plannapus          | CleanUpOnAisleSix     -  233  |
| frederick          | ConBot                -  230  |
| frederick          | 128Bot                -  222  |
| AndoDaan           | EndTitled             -  219  |
| PhiNotPi           | CloakingDeviceBot     -  215  |
| AndoDaan           | GetOffMate            -  206  |
| DLosc              | ScaredyBot            -  205  |
| isaacg             | CleverAndDetermined   -  202  |
| PhiNotPi           | CantTouchThis         -  202  |
| Moop               | StubbornBot           -  174  |
| Cruncher           | StallBot              -  168  |
| IngoBuerk          | Gambler               -  157  |
| BetaDecay          | RussianRoulette       -  129  |
| flawr              | DoNothingBot          -  123  |
| SebastianLamerichs | Dumbot                -  115  |
| mmphilips          | PacifistBot           -  112  |
| SeanD              | DontUnderstand        -  92   |
| proudHaskeller     | PatientBot            -  83   |
| frederick          | Dumberbot             -  70   |
| flawr              | MetaJSRandomBot       -  68   |
| Darkgamma          | TheRetard             -  61   |
| BetaDecay          | Roomba                -  61   |
| BetaDecay          | PrussianRoulette      -  31   |
| frederick          | Dumbestbot            -  0    |

Puntajes finales del 09.10.2014

EDITAR6 : Registros descartados debido al tamaño extremo y tiempo de ejecución. Puede generarlos usted mismo descomentando las líneas RunThisTournament.py.

EDIT5 : Se implementó el manejo de abreviaturas en el controlador, ya no hay tiempos de ejecución enormes. Esto tiene el efecto secundario de que los números y paréntesis ya no se tratan como comentarios. Todavía puede usarlos si desea proporcionar una versión anotada, pero sería muy útil si también hubiera una versión no comentada de su código , por lo que no necesito eliminar los comentarios manualmente. ¡Gracias!

EDITAR4 : Cambió el título, porque el torneo se eliminó de las preguntas de la red. ¡Gracias a @Geobits por señalar esto!

EDITAR3 : Los comentarios eliminados en los programas bf, debido a un resultado inesperado, deberían repararse ahora. Si alguien tiene problemas para eliminar sus comentarios, por favor repórtelo.

EDIT2 : Dado que causó un tiempo de ejecución arcano en mi computadora bastante lenta, reduje el límite de tiempo de espera de 100000 ciclos a 10000 ciclos. No es que nadie haya convertido el resultado de un juego en ejecución más allá de este punto de todos modos.

EDITAR1 : se corrigió un error en el script de conversión que hacía que el intérprete no ignorara los números en los programas comentados.


Descripción

Este es un torneo Brainfuck inspirado en BF Joust . Dos bots (programas Brainfuck) están luchando entre sí en una arena que está representada por una cinta de memoria. Cada celda puede contener valores desde -127 hasta 128 y ajustarse a sus límites (por lo tanto, 128 + 1 = -127).

Las instrucciones válidas son similares a Brainfuck regular, lo que significa:

+ : Increment cell at your pointer's location by 1
- : Decrement cell at your pointer's location by 1
> : Move your memory pointer by 1 cell towards the enemy flag
< : Move your memory pointer by 1 cell away from the enemy flag
[ : Jump behind the matching ']'-bracket if the cell at your pointer's location equals 0
] : Jump behind the matching '['-bracket if the cell at your pointer's location is not 0
. : Do nothing

La arena tiene un tamaño de 10 a 30 celdas que se elige pseudoaleatoriamente en cada batalla. En ambos extremos se encuentra una 'bandera' que tiene un valor inicial de 128, mientras que todas las demás celdas están puestas a cero. El objetivo de tu bot es poner a cero la bandera del enemigo durante 2 ciclos consecutivos antes de que ponga a cero tu propia bandera.

Cada bot comienza en su propia bandera, que es la celda [0] desde su propia perspectiva. El oponente se encuentra al otro lado de la cinta.

[ 128 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 128 ]
   ^                                             ^
my bot                                       other bot

Ambos bots ejecutan su acción simultáneamente, esto se considera un ciclo. El juego termina después de 10000 ciclos o tan pronto como se alcance una de las condiciones ganadoras. Si uno de los programas llega a su fin, simplemente deja de hacer nada hasta el final del juego, pero aún puede ganar.


Condiciones ganadoras

Su bot gana bajo una de las siguientes condiciones:

  • La bandera de tu enemigo se pone a cero antes que la tuya
  • Su enemigo mueve su puntero fuera de la cinta (se ejecuta >en su bandera o <solo)
  • El valor de su bandera está más lejos de 0 que el valor de la bandera de su oponente después de 10000 ciclos.

Reglas

Su publicación debe contener un nombre para su bot y su código.

  • Puede usar la siguiente sintaxis de abreviatura para hacer que su código sea más legible:
    • por ejemplo, (+)*4es lo mismo ++++, esto es válido para cualquier instrucción, excepto paréntesis sin paréntesis, ya que la lógica de bucle colisiona con la lógica de abreviatura. Por favor, use en [-[-[-lugar de([-)*3
  • Cualquier otro carácter que +-><[].sea ​​un comentario y, por lo tanto, se ignora, excepto las ()*abreviaturas

Los bots que no sigan las reglas serán excluidos del torneo.

  • Solo se permite Brainfuck básico, no hay otras variantes que admitan procedimientos u operaciones aritméticas.
  • El código fuente de su bot no debe contener corchetes sin igual

Puede informarse sobre estrategias básicas, pero no use el código de otro para su propio bot.


Puntuación

La puntuación de un bot está determinada por el número de victorias contra todos los demás bots. Un encuentro entre 2 bots consiste en 10 partidos con diferentes longitudes de cinta de memoria, lo que resulta en una puntuación máxima de 10 puntos por encuentro. Un empate no genera puntos para este partido.


Programa de control

Puedes encontrar el programa de control en github, junto con los registros completos de las batallas. La tabla de clasificación se publicará aquí una vez que se haya generado.

Siéntase libre de clonar el repositorio y pruebe su bot contra los demás por su cuenta. Se usa python Arena.py yourbot.bf otherbot.bfpara correr un partido. Puede modificar las condiciones con los indicadores de línea de comandos -my -t. Si su terminal no admite secuencias de escape ANSI, use la --no-colorbandera para deshabilitar la salida en color.


Bots de ejemplo

FastClearBot.bf

(>)*9       Since the tape length is at least 10, the first 9 cells can be easily ignored
([          Find a non-zero cell
+++         Increment at first, since it could be a decoy
[-]         Set the cell to zero
]>          Move on to the next cell
)*21        Repeat this 21 times

DecoyBot.bf

>(+)*10     Set up a large defense in front of your flag
>(-)*10     Set up another one with different polarity
(>+>-)*3    Create some small decoys
(>[-]       Move on and set the next cell to zero
.           Wait one round, in case it is the enemy's flag
)*21        Repeat this 21 times

DecoyBot ganará cada partida con una longitud de cinta superior a diez, ya que FastClearBot puede evitar los señuelos pequeños, pero no los más grandes. La única situación en la que FastClearBot puede ganar contra DecoyBot es cuando es lo suficientemente rápido como para alcanzar la bandera del enemigo antes de que su oponente haya acumulado grandes señuelos.

Cifrar
fuente
55
Original, me gusta. Solo tengo miedo de que esto no permita suficiente profundidad estratégica, pero podría ser solo yo.
Augıʇǝɥʇuʎs
11
Esto sería aún más divertido con Befunge .
IchBinKeinBaum
66
Encontré una página web de BF Jousting que puede ejecutar y visualizar coincidencias de justas.
PhiNotPi
44
Gracias por alojar este KOTH, Cipher. Debe haber mucho trabajo con tantas presentaciones.
AndoDaan
3
Prefiero decir gracias a todos por seguir participando ^^
Cipher

Respuestas:

18

Nyuroki Magical Fantasy

Creo que es hora de tomar en serio ~ Terminé mi compilador para un poco de HLL para facilitar la escritura de programas BF Joust. Este fue mi primer intento serio de hacer algo con eso. El concepto del bot es bastante simple. Configura algunos señuelos de polaridades variables, luego se vuelve loco con un gran movimiento de despeje con un claro de compensación inversa en el medio.

Ah, por cierto, el puntaje esperado es de aproximadamente 577 puntos contra la colina de la última ronda. Esa es una tasa de ganancia del 93%. <3

Compilado | Código fuente

Nyuroki Magical Fantasy by Lymia Aluysia
Released under the terms of MIT license

>>>>>>>>++<--<+<--<++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+<-------------------------------------------------------------<---------------
----------------------------------------------<++++++++++++++++++++++++++++++++
+++++++++++++++++++++++++++++<(-)*19(>)*8(>[-[-[-[(+)*3+[+[+[(-)*6-[-[-[-[-[-[-
[-[-[-[(+)*16+[+[+[+[+[+[+[+[(-)*24-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[(+)*41+[+[
+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[(+)*82[[+.].]--(>[-[-[-[(+)*3+[+[+[(-)*6-
[-[-[-[-[-[-[-[-[-[(+)*16+[+[+[+[+[+[+[+[(-)*24-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[
-[(+)*41+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[(+)*82[[+.].]--(>[-[-[-[(+)*3
+[+[+[(-)*6-[-[-[-[-[-[-[-[-[-[(+)*16+[+[+[+[+[+[+[+[(-)*24-[-[-[-[-[-[-[-[-[-[
-[-[-[-[-[-[-[(+)*41+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[(+)*82[[+.].]--(>
[-[-[-[(+)*3+[+[+[(-)*6-[-[-[-[-[-[-[-[-[-[(+)*16+[+[+[+[+[+[+[+[(-)*24-[-[-[-[
-[-[-[-[-[-[-[-[-[-[-[-[-[(+)*41+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[(+)*
82[[+.].]--(>[-[-[-[(+)*3+[+[+[(-)*6-[-[-[-[-[-[-[-[-[-[(+)*16+[+[+[+[+[+[+[+[(
-)*24-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[(+)*41+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[
+[+[+[+[(+)*82[[+.].]--(>[-[-[-[(+)*3+[+[+[(-)*6-[-[-[-[-[-[-[-[-[-[(+)*16+[+[+
[+[+[+[+[+[(-)*24-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[(+)*41+[+[+[+[+[+[+[+[+[+[+[
+[+[+[+[+[+[+[+[+[+[(+)*82[[+.].]--(>[-[-[-[(+)*3+[+[+[(-)*6-[-[-[-[-[-[-[-[-[-
[(+)*16+[+[+[+[+[+[+[+[(-)*24-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[(+)*41+[+[+[+[+[
+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[(+)*82[[+.].]--(>[-[-[-[(+)*3+[+[+[(-)*6-[-[-[-
[-[-[-[-[-[-[(+)*16+[+[+[+[+[+[+[+[(-)*24-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[(+)*
41+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[(+)*82[[+.].]--(>[-[-[-[(+)*3+[+[+[
(-)*6-[-[-[-[-[-[-[-[-[-[(+)*16+[+[+[+[+[+[+[+[(-)*24-[-[-[-[-[-[-[-[-[-[-[-[-[
-[-[-[-[(+)*41+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[(+)*82[[+.].]--(>[-[-[-
[(+)*3+[+[+[(-)*6-[-[-[-[-[-[-[-[-[-[(+)*16+[+[+[+[+[+[+[+[(-)*24-[-[-[-[-[-[-[
-[-[-[-[-[-[-[-[-[-[(+)*41+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[(+)*82[[+.]
.]--(>[-[-[-[(+)*3+[+[+[(-)*6-[-[-[-[-[-[-[-[-[-[(+)*16+[+[+[+[+[+[+[+[(-)*24-[
-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[(+)*41+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+
[(+)*82[[+.].]--(>[-[-[-[(+)*3+[+[+[(-)*6-[-[-[-[-[-[-[-[-[-[(+)*16+[+[+[+[+[+[
+[+[(-)*24-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[(+)*41+[+[+[+[+[+[+[+[+[+[+[+[+[+[+
[+[+[+[+[+[+[(+)*82[[+.].]--(>[-[-[-[(+)*3+[+[+[(-)*6-[-[-[-[-[-[-[-[-[-[(+)*16
+[+[+[+[+[+[+[+[(-)*24-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[(+)*41+[+[+[+[+[+[+[+[+
[+[+[+[+[+[+[+[+[+[+[+[+[(+)*82[[+.].]--(>[-[-[-[(+)*3+[+[+[(-)*6-[-[-[-[-[-[-[
-[-[-[(+)*16+[+[+[+[+[+[+[+[(-)*24-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[(+)*41+[+[+
[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[(+)*82[[+.].]--(>[-[-[-[(+)*3+[+[+[(-)*6-[
-[-[-[-[-[-[-[-[-[(+)*16+[+[+[+[+[+[+[+[(-)*24-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-
[(+)*41+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[(+)*82[[+.].]--(>[-[-[-[(+)*3+
[+[+[(-)*6-[-[-[-[-[-[-[-[-[-[(+)*16+[+[+[+[+[+[+[+[(-)*24-[-[-[-[-[-[-[-[-[-[-
[-[-[-[-[-[-[(+)*41+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[(+)*82[[+.].]--(>[
-[-[-[(+)*3+[+[+[(-)*6-[-[-[-[-[-[-[-[-[-[(+)*16+[+[+[+[+[+[+[+[(-)*24-[-[-[-[-
[-[-[-[-[-[-[-[-[-[-[-[-[(+)*41+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[(+)*82
[[+.].]--(>[-[-[-[(+)*3+[+[+[(-)*6-[-[-[-[-[-[-[-[-[-[(+)*16+[+[+[+[+[+[+[+[(-)
*24-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[(+)*41+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[
+[+[+[(+)*82[[+.].]--(>[-[-[-[(+)*3+[+[+[(-)*6-[-[-[-[-[-[-[-[-[-[(+)*16+[+[+[+
[+[+[+[+[(-)*24-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[(+)*41+[+[+[+[+[+[+[+[+[+[+[+[
+[+[+[+[+[+[+[+[+[(+)*82[[+.].]--(>[-[-[-[(+)*3+[+[+[(-)*6-[-[-[-[-[-[-[-[-[-[(
+)*16+[+[+[+[+[+[+[+[(-)*24-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[(+)*41+[+[+[+[+[+[
+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[(+)*82[[+.].]-->[-[-[-[(+)*3+[+[+[(-)*6-[-[-[-[-[
-[-[-[-[-[(+)*16+[+[+[+[+[+[+[+[(-)*24-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[(+)*41+
[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[(+)*82[[+.].]--]]]]]]]]]]]]]]]]]]]]]]]
]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]--]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]
]]]]]]]]]]]]]]]]]]]]]]]]]]--)*2]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]
]]]]]]]]]]]]]]]--)*3]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]
]]]]--)*4]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]--)*5]]
]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]--)*6]]]]]]]]]]]]]
]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]--)*7]]]]]]]]]]]]]]]]]]]]]]]]
]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]--)*8]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]
]]]]]]]]]]]]]]]]]]]]]]]]]]]]--)*9]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]
]]]]]]]]]]]]]]]]]--)*10]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]
]]]]]]]--)*11]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]--)
*12]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]--)*13]]]]]]]
]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]--)*14]]]]]]]]]]]]]]]]]
]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]--)*15]]]]]]]]]]]]]]]]]]]]]]]]]]]
]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]--)*16]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]
]]]]]]]]]]]]]]]]]]]]]]]]]]--)*17]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]
]]]]]]]]]]]]]]]]--)*18]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]
]]]]]]--)*19]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]--)*
20]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]--)*21

Editar : Exprimí algunas victorias más de Nyuroki.

Edición 2 : ¡Oye, mira, lo hice de nuevo!

Edición 3 : Después de luchar por un tiempo con un estúpido error de análisis en Arena.py, finalmente obtuve otra mejora en ~ Esto es lo que quiero decir con "hora de ponerse serio", ya sabes. <3

Lymia Aluysia
fuente
Parece que Loke necesita algunos ajustes :-) Me encanta tu idioma. ¿Era el error en Arena.py que tenía un espacio en blanco entre )y *o entre *y número?
Sylwester
@Sylwester Mucho, mucho peor. Bucles que van a donde no deberían ir: github.com/redevined/brainfuck/pull/6
Lymia Aluysia
Felicidades con el n. ° 1. El porcentaje de victorias del 92,5% será difícil de igualar.
Sylwester
Bien hecho, pero ¿no es este abuso de taquigrafía? Los bucles anidados son efectivamente 21 factoriales = 5 * 10 ^ 19. En otras palabras, es efectivamente inexpugnable en un brainfuck básico.
Weston
1
@weston Sí. Y la mayoría de los programas en la colina BF Joust más desarrollada ( codu.org/eso/bfjoust/in_egobot - eche un vistazo a smartlock, por ejemplo) son aún peores. No es un gran problema, ya que este es el punto de taquigrafía. Hace que las estrategias que de otra manera serían inviables debido a la longitud total sean viables. :)
Lymia Aluysia
43

Dispositivo de camuflaje Bot

Este bot básicamente trata de ocultar su base, por lo que otros bots se moverán más allá de él y fuera de la cinta.

(-)*127(-+--+-++)*12500
PhiNotPi
fuente
44
Muy inteligente, tuve que ajustar mi bot para dar cuenta de esto.
Moop
2
Este es uno de los más inteligentes aquí, en mi opinión.
Almo
+ f para la primera capa. No lo noté antes después de hacer Ràn, pero es una idea similar, una aplicación diferente.
Sylwester
19

Burly Balder v3

Burly Balder es una carrera media lenta. Hace dos señuelos grandes antes de pasar al modo apresurado. En el modo acelerado, tiene un bucle que solo usa 4 pasos cada celda cero y cuando una celda distinta de cero tiene un análisis de caso para [-18,18] antes de reducir a ciegas con 107 antes de borrar con [-.]. Despeja una bandera sin cambios en 242 pasos, 114 más que un claro incierto -*128 y 14 menos que un [-]claro ingenuo . Cuando se despeja una celda, continúa dejando un rastro de -2 señuelos. Tiene un caso especial solo para el índice 9 para guardar algunos pasos para juegos de tamaño 10 y deja la celda con un señuelo 1.

>((-)*18>)*2                                  Make two minus seventeen decoys
(->)*6                                        Move to cell nine

[                                             special case for ten cell game 
   +[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[       if not minus one to minus eighteen 
   (-)*18                                     decrease by eighteen
   -[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[       if not plus one to plus eighteen
       (-)*107                                decrease by hundred and seven
       [-.]                                   slow clear
   ]]]]]]]]]]]]]]]]]]                         end plus conditionals
   ]]]]]]]]]]]]]]]]]]                         end minus conditionals
]                                             end special case
+
([>                                           while true go right
  [                                           start clear cell 
   +[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[       if not minus one to minus eighteen 
   (-)*18                                     decrease by eighteen
   -[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[       if not plus one to plus eighteen
       (-)*107                                decrease by hundred and seven
       [-.]                                   slow clear
   ]]]]]]]]]]]]]]]]]]                         end plus conditionals
   ]]]]]]]]]]]]]]]]]]                         end minus conditionals
  ]                                           end clear cell
  --                                          set to minus two 
 ]                                            while true end
 -                                           decrease and loop
)*5                                          In case of clash or initial column minus seven is zero

Trivia: Balder es un dios nórdico e hijo de Odin. Es conocido principalmente por la historia de su muerte : tenía miedo por su seguridad, por lo que los otros dioses trataron de predecir y proteger contra todas las amenazas. Finalmente fue asesinado por Loki, ya que mientras lo protegieron contra espadas y flechas, olvidaron protegerlo contra el muérdago.

Sylwester
fuente
2
Tus señuelos me están matando. Bien hecho.
AndoDaan
1
@AndoDaan Gracias. Tu BeatYouMatefuiste inteligente. Me temo que los señuelos en la mayoría de los bots se harán aún más grandes la próxima ronda hasta que se penalice. Entonces quizás tengamos algunas estrategias más geniales emergentes :)
Sylwester
2
El problema con el aumento del tamaño del señuelo es que se intercambia con el rendimiento en cintas más cortas contra los bots de ataque rápido. Con 10 rondas aleatorias, es más probable que un punto dulce cambie según la velocidad de ataque de las otras entradas.
Comintern
2
Sí, sigues siendo el único a vencer.
AndoDaan
44
@AndoDaan Con tantos dioses nórdicos que me apoyan, los tamaños de arena aleatorios parecen estar a mi favor :-)
Sylwester
13

EvoBot 1

Este es un bot simple creado a través de un algoritmo genético. Comencé con una plantilla, y mi programa ajustó lentamente los números para crear un mejor robot guerrero. El siguiente código ha sido editado para aumentar la legibilidad.

>+>---(>)*6(>[+++[-]])*30

Usé las otras entradas en la competencia para medir la aptitud de los diferentes candidatos.

Dado que este fue mi primer intento con un evobot, comencé con una plantilla simple:

>(+)*n>(-)*n(>)*n(>[(+)*n[-]])*30  #template

Predigo que este bot recibirá una puntuación en el rango de 50 a 60.

Actualmente estoy trabajando en una plantilla de señuelo inverso.

EvoBot 2

Este es un bot creado por el mismo algoritmo genético, pero con la siguiente plantilla:

>>>>(-)*n<(+)*n<(-)*n<(+)*n(>)*8(>[+++[-]])*30  #template

Este bot utiliza la estrategia de señuelo inverso para establecer 4 señuelos de altura variable. El bot resultante es:

>>>>(-)*4<(+)*6<(-)*7<(+)*8(>)*8(>[+++[-]])*30

Espero que a este nuevo bot le vaya mejor que a los bots anteriores, posiblemente obteniendo una puntuación en los años 70 (probablemente mucho más alto que eso ya que hay muchas entradas nuevas).

PhiNotPi
fuente
2
+1 para algoritmos genéticos. Tengo gran fe en ellos. Espero que a tus bots les vaya bien.
AndoDaan
12

Alternador

Se supone que la mayoría de las personas pondrá a cero una celda al sumarla o restarla, por lo que, en promedio, cada celda tomará 128 vueltas a cero.

(>+>-)*4>+(>[-][.])*21

Versión anotada

(>+>-)*4       Move eight squares alternating polarity    
>+             Move one more
(
    >          Move to the next square
    [-]        Zero it
    [.]        Wait while it is zero
)*21           Repeat
Trapeador
fuente
Maldición, tus últimos cambios mejoran la tasa de victorias de Alternador contra Gerónimo de ~ 60% a ~ 90%. Agradable.
Ingo Bürk
Sí, me estaba moviendo 18 veces cuando lo hice (> +> -) * 9, por lo que se caería de la cinta. Error tonto.
Moop
Incluso proteger a Geronimo sumando / restando alternativamente a cero la celda no cambia mi tasa de ganancia en absoluto. El alternador podría salir como el ganador aquí: utiliza pocos cylces para establecer una trampa bastante difícil de romper.
Ingo Bürk
Oye, corrígeme si me equivoco, pero ¿este bot no se mueve automáticamente fuera del tablero si el tablero tiene 10 largos? Se mueve 10 casillas antes de intentar poner algo a cero.
Un Boschman el
11

Entonces, alguien más aquí está usando un algoritmo genético para tratar de hacer programas aquí. Bueno ... hace mucho tiempo, escribí un BF Joust evolver para una colina en curso en un canal IRC. Decidí darle un giro a este concurso también ~

Y ... a diferencia de la otra persona con un evolver, mi evolver en realidad puede cambiar más del programa más que los recuentos repetidos. :)

NestDarwin (Generación 309)

Este es el mejor resultado que mi evolucionador ha llegado hasta ahora. No estoy seguro de cuánto ayuda la estructura anidada en este caso, pero estructuras como esta era lo que el evolucionista debía hacer. El rendimiento esperado en la colina del 27.08.2014 es de 474 puntos. (Calculado ejecutando la batalla en las 21 longitudes de cinta y multiplicándolo por 21/10. Tenga en cuenta que esto no está normalizado por el hecho de que esta colina tiene un programa adicional)

(-)*5(>[(-)*4----[.+]]--((-)*5(>[(-)*4----[.+]]--((-)*5(>[(-)*4----[.+]]--((-)*5(>[(-)*4----[.+]]--)*10000)*10000)*10000)*10000)*10000)*10000)*10000

EDITAR : Se modificó la lista de programas que quiero ingresar a esta colina. Corrió evolver durante la noche. :)


EDIT 2 : Fui y analicé manualmente la salida del evolver. A pesar de verse muy diferente, NestDarwin es básicamente una versión optimizada de TinyDarwin ... Minimizado manualmente (con idéntica funcionalidad) y analizado:

(-)*5                     Break stuff that assumes flag size.
(>[(-)*8[.+]](-)*7)*3     Make a few larger decoys next to our flag. 
                          The clear loop is basically dead code here.
                          Few things are going to approach so fast, so.
(>[(-)*8[.+]](-)*2)*10000 And go on an rampage with an offset clear!
                          I presume the slow clear is to beat tripwires.

Entonces, un programa casi idéntico sería el siguiente ... que es básicamente una versión súper optimizada de TinyDarwin.

(-)*5(>.(-)*7)*3(>[(-)*8[.+]](-)*2)*10000

TinyDarwin fue como sigue. No muy diferente, cariño? Solo voy a retirarlo de la colina. Pensé que era distinto, pero ... bueno, estaba equivocado.

((-)*5>[(-)*4.[+.]].)*10000

Es evidente que la colina actual no es lo suficientemente fuerte como para permitirle evolucionar cosas mucho más complejas. :(

Lymia Aluysia
fuente
1
Felicidades con el primer lugar. ¿El programa de algo genético puede usar su versión actual como plantilla y continuar con las nuevas versiones para mejorarla aún más?
Sylwester
Gran trabajo con el primer lugar. ¡Estoy tan feliz de que un algoritmo genético (bueno, su engendro) haya llegado hasta allí!
AndoDaan
Ahora, si pudiéramos tomar los resultados de todos los juegos, evolucionar más, agregar algo de aprendizaje automático ... entonces los humanos lamentables ya no tendremos ninguna posibilidad: P
Sp3000
¿@Sylwester tipo de? Mi representación interna utiliza un sistema de activación génica (mal pensado) que se supone que le permite desarrollar una superestructura (y en la práctica, en realidad no lo hace). No puedo volver a poner el programa final y recuperar la representación interna, pero puedo poner las instrucciones en un solo gen y dejar que continúe evolucionando (por mucho que eso ayude).
Lymia Aluysia
@ Sp3000 Desafortunadamente, mi algoritmo apenas puede avanzar en la colina #esotérica bien desarrollada. Sería bueno si pudiera hacer algo así, pero, por desgracia, mi habilidad con los algoritmos genéticos no es lo suficientemente buena. Probablemente lanzaré mi Evolver algún día cuando limpie todos mis hacks feos.
Lymia Aluysia
10

Oso polar Mk II

Hay dos tipos de osos polares : los que quedan atrapados y los que atrapan a otras personas.

Intenta adivinar la polaridad del oponente y luego usa esa información para bloquear al oponente en un bucle infinito. Funciona bien contra estrategias de limpieza simples y algo aleatoriamente contra otras. Las trampas se pueden evitar fácilmente, por lo que podría agregar algunas estrategias de respaldo más adelante.

>++>- create polar bear traps
[[]]<
[][
[[]]<
(+)*290 (>)*9  (+)*120 (.+)*16 (<)*9
(+)*112 (>)*10 (+)*120 (.+)*16 (<)*10
(+)*112 (>)*11 (+)*120 (.+)*16 (<)*11
(+)*112 (>)*12 (+)*120 (.+)*16 (<)*12
(+)*111 (>)*13 (+)*120 (.+)*16 (<)*13
(+)*111 (>)*14 (+)*120 (.+)*16 (<)*14
(+)*111 (>)*15 (+)*120 (.+)*16 (<)*15
(+)*110 (>)*16 (+)*120 (.+)*16 (<)*16
(+)*110 (>)*17 (+)*120 (.+)*16 (<)*17
(+)*110 (>)*18 (+)*120 (.+)*16 (<)*18
(+)*109 (>)*19 (+)*120 (.+)*16 (<)*19
(+)*109 (>)*20 (+)*120 (.+)*16 (<)*20
(+)*109 (>)*21 (+)*120 (.+)*16 (<)*21
(+)*108 (>)*22 (+)*120 (.+)*16 (<)*22
(+)*108 (>)*23 (+)*120 (.+)*16 (<)*23
(+)*108 (>)*24 (+)*120 (.+)*16 (<)*24
(+)*107 (>)*25 (+)*120 (.+)*16 (<)*25
(+)*107 (>)*26 (+)*120 (.+)*16 (<)*26
(+)*107 (>)*27 (+)*120 (.+)*16 (<)*27
(+)*106 (>)*28 (+)*120 (.+)*16 (<)*28
(+)*106 (>)*29 (+)*120 (.+)*16 (<)*29
(+)*106 (>)*29 [-]
]<
(-)*290 (>)*9  (+)*120 (.+)*16 (<)*9
(-)*112 (>)*10 (+)*120 (.+)*16 (<)*10
(-)*112 (>)*11 (+)*120 (.+)*16 (<)*11
(-)*112 (>)*12 (+)*120 (.+)*16 (<)*12
(-)*111 (>)*13 (+)*120 (.+)*16 (<)*13
(-)*111 (>)*14 (+)*120 (.+)*16 (<)*14
(-)*111 (>)*15 (+)*120 (.+)*16 (<)*15
(-)*110 (>)*16 (+)*120 (.+)*16 (<)*16
(-)*110 (>)*17 (+)*120 (.+)*16 (<)*17
(-)*110 (>)*18 (+)*120 (.+)*16 (<)*18
(-)*109 (>)*19 (+)*120 (.+)*16 (<)*19
(-)*109 (>)*20 (+)*120 (.+)*16 (<)*20
(-)*109 (>)*21 (+)*120 (.+)*16 (<)*21
(-)*108 (>)*22 (+)*120 (.+)*16 (<)*22
(-)*108 (>)*23 (+)*120 (.+)*16 (<)*23
(-)*108 (>)*24 (+)*120 (.+)*16 (<)*24
(-)*107 (>)*25 (+)*120 (.+)*16 (<)*25
(-)*107 (>)*26 (+)*120 (.+)*16 (<)*26
(-)*107 (>)*27 (+)*120 (.+)*16 (<)*27
(-)*106 (>)*28 (+)*120 (.+)*16 (<)*28
(-)*106 (>)*29 (+)*120 (.+)*16 (<)*29
(-)*106 (>)*29 [-]
Mika lammi
fuente
Puede reducir a la mitad el tamaño del código con (]< (+)*290 (>)*9 ... [-])*2?
Sylwester
@Sylwester No puedo porque la otra mitad usa +y la otra usa -.
Mika Lammi
Oso polar no funciona muy bien con compensaciones de compensación ... aunque es una idea increíble
Sp3000
@ Sp3000 ¿Estás seguro? Intenté con varias compensaciones y polaridades (como [(+)*3[-]], [(-)*6[+]]) y funciona muy bien (al menos para compensaciones bastante pequeñas).
Mika Lammi
Oh, sé lo que está mal: / Estaba probando programas como el >>>>>>>>>((-)*4[+][--.]>)*21que verifica dos veces la celda y (+/-)*290estaba causando que se disparara el segundo bucle fuera de sincronización. No es culpa del claro compensado.
Sp3000
10

Bot pacifista

Mi bot cree que la violencia nunca es la respuesta y tratará de evitar el combate a toda costa.

(.)*8       Since it takes at least 9 turns for a bot to come to mine, remain idle for 8
>           Skedaddle over one spot
([(>)*8     If a bot has approached, RUN
[(<)*8      If you accidentally ran into a bot, run the other way this time
]].         If it's safe here, chill out
)*6249      keep running until the end of battle, or until tired
mmphilips
fuente
8
Me tomé la libertad de eliminar los '.' En sus comentarios, ya que contarían como código Brainfuck y harían que su bot fuera un poco más lento de lo necesario. Si los puntos son deliberados, ¡no dudes en corregirme!
Cifrado
Oh, claro. Los fueron bastante tontos de mi parte, gracias por eliminarlos: p
mmphilips
9

¿Alguien?

Periódicamente mira hacia atrás para determinar cuándo el enemigo ha comenzado a limpiar sus señuelos, luego se apresura hacia adelante.

Parece hacerlo bien, pero no estoy seguro de si eso se debe a la estrategia o simplemente porque estoy agregando 10 a cada celda antes de borrar.

Editar: se corrigió un problema de lógica. Primera vez escribiendo un programa de brainfuck. Hace honor a su nombre.

>>>+<(+)*5<(-)*5>>             Initial defense
[                              While he hasn't passed us yet
  (>[([(+)*10[-]]>)*29])*4     Jump ahead four, checking for enemy
  +                            Front marker
  <<<<                         Check behind
  [                            If he hasn't passed us yet
    >>>
    (+)*5<(-)*5                Set decoys in reverse
    <<[-]                  
  ]
  >>>>                         Check ahead
]                              
([-[(+)*10[-]]]>)*29           Clear to the end
ccarton
fuente
+1: este es el primer bot que he visto que encadena señuelos (que no sean +/- 1) más allá de las primeras 9 celdas. En cintas más largas, eso es un asesino. Readaptando Lightfoot Plodder un poco más ahora ...
DLosc
9

WALL-E 2.0

Se apresura a la ubicación 9 y agrega 128, ganando rápidamente en la arena de tamaño 10 si el oponente no ha cambiado el valor inicial de la bandera. En arenas más grandes, esto funciona como señuelo grande. Después de eso, llena el espacio entre la ubicación 9 y la propia bandera con grandes señuelos. Cuando se colocan señuelos, busca ubicaciones no vacías e intenta borrarlas rápidamente.

La versión 2.0 construye señuelos más grandes y tiene cierta tolerancia contra el cambio del valor del indicador inicial. También puede cambiar a una estrategia de respaldo si las cosas comienzan a verse complicadas.

(>)*9
(+)*128 <
< [ (<)*7 ((-+-)*256)*15 ] > [ (<)*8 ((+-+)*256)*15 ]
(-)*47 < (+)*63 < (-)*72 < (+)*69 <
(-)*84 < (+)*66 < (-)*76 < (+)*66 <
++++ (>)*9 +.+.+.----.-.-. (>[-[++[(+)*124.+.+.+.+.+.+.+.+.>]]])*21

La efectividad de este bot se basa en dos hechos:

  1. La mayoría de los bots no cambian el valor inicial de su bandera.
  2. Construir señuelos grandes es más rápido que borrarlos.
Mika lammi
fuente
Estas paredes me están matando
Sp3000
9

Lethal Loke V2.1 (con muérdago)

Por supuesto, este es un bot mortal y mata no solo al hermoso Burly Balder a con muérdago, sino que también gana casi todas las veces contra los otros bots. Es una carrera combinada media y rápida. Mi examen me da un puntaje de 567

Archivo BFJ compilado para la batalla , fuente del generador Racket BFJ:

#lang racket
;; bare minimum bfj support
(define (bf . args)
  (apply string-append 
         (map (lambda (x) 
                (if (number? x)
                    (number->string x)
                    x))
              args)))

(define (dup x num)  
  (let loop ((n num) (lst '()))
    (cond ((< n 0) (error "Negative n"))
          ((zero? n) (apply bf lst))
          (else (loop (sub1 n) (cons x lst))))))


;; Useful procedures
(define (wiggle amount default-zero n)
  (let rec ((n n))
    (if (zero? n)
        ""
        (bf "["
            (dup "-[" amount)
            (bf "(+)*" amount)
            (dup "+[" amount)
            default-zero
            ">"
            (rec (sub1 n))
            (dup "]" (* amount 2))
            "]"))))

(define (goto from to)
  (let* ((dst (- to from))
         (op (if (> dst 0) ">" "<"))
         (abs (if (> dst 0) dst (- dst))))
    (if (= from to) 
        ""
        (bf "(" op ")*" abs))))

(define max-position 30)
(define initial-decoy  "(-)*17")
(define small-decoy "(+)*10")
(define large-decoy "(-)*32")
(define flag-position 7)
(define decoy-phase-end-position 14)
(define wiggle-amount 8)
(define plodd-clear "..(+)*120(+.)*27>")
(define plodd-inner-clear (bf "(+)*" 
                              (- 78 wiggle-amount) 
                              "..(+)*42(+.)*27"))
;; Main body of Loke V2
(define (generate-loke2)
  (bf ">" 
      initial-decoy
      ">->+>->+>->"
      (let gen-rec ((n flag-position) (p #t))
        (if (> n decoy-phase-end-position)
            (bf (medium-slow n))
            (bf "[" 
                (medium-slow n)
                "]" 
                (if p small-decoy large-decoy)
                ">"
                (gen-rec (+ n 1) (not p)))))))

;; Retreat goes back to home
;; leaving a trail of flags
;; from flag position
(define (medium-slow last-index)
  (bf (goto last-index 2)
      (let medium-rec ((n 2) (p #f))
        (if (= n flag-position)
                (fast-rush n last-index)
            (bf (if p "-" "+")
                "[" (fast-rush n (max 9 last-index)) "]" 
                (if p small-decoy large-decoy)
                ">"
                (medium-rec (+ n 1) (not p)))))))

(define (fast-rush cur-position last-known)
  (bf (goto cur-position last-known)      
      "([" plodd-clear 
      "("
      (wiggle wiggle-amount
              plodd-inner-clear 
              (- max-position last-known 1))
      ">)*" (- max-position last-known)
      "]>)*" (- max-position last-known)))

(display (generate-loke2))

Trivia : Loke (Loki) es un dios en la mitología nórdica que le gusta jugar con todos y engañarlos. Es un cambiaformas (en animales y personas) y generalmente sigue sus propios caminos. En las historias a menudo viaja y ayuda a los otros dioses y hace pequeños trucos y agita las cosas. Además de matar a Balder, engendró a Hel (diosa del infierno / Helvete), la bestia Fenrir y la serpiente Midgard que inicia Ragnarok (armageddon nórdico).

Cómo funciona

Al principio, hace un señuelo grande (-17) y luego crea un +-patrón hasta el índice 7. Escanea hacia adelante desde 13 dejando un rastro de señuelos (+ 10, -32) +, pero cuando detecta un conjunto, abortará e iniciar un modo medio * 1 rush. Si no hay celdas configuradas, también iniciará el modo lento * 3 rush.

* 1 En el modo de carrera media, ha detectado actividad del oponente en uno de los índices 7-13 y comienza desde el índice 2. Algunos oponentes dejan un cero y otros dejan un valor diferente y ahora tiene medios para detectar la actividad del oponente mientras antes de hacer señuelos en índice 2-6 (-32, + 10) +. Si la celda no tiene el valor esperado (-1, 1) o si ha terminado de hacer todos los señuelos, pasa al modo rápido * 2 rush.

* 2 El modo de aceleración rápida que espera que haya sido detectado para que los señuelos no funcionen. Esperamos que los que ya hemos establecido detengan al oponente y se centren en atravesar señuelos de oponentes. Comienza a apresurarse en el punto más lejano que conocemos según el escaneo anterior [9,14] o el índice 9 si nos hicieron antes de eso. Él tiene un caso especial para el primer señuelo en el que simplemente agregamos 120 y plodd 27, ya que no quiere reducir el valor por debajo de cero en caso de que sea una trampa, pero para cada señuelo después de movernos a [-8,8] antes de aumentar 120 y avanzando 27 pasos antes de continuar hacia la celda siguiente.

Se eliminó el modo de aceleración lenta ya que no afectó el puntaje con la colina actual y hace que mi bot sea un poco más pequeño (pero no mucho).

Sylwester
fuente
3
Ahora estamos empezando a ver locura. Me gusta.
Sp3000
@ Sp3000 YandereBotv2 fue la razón por la que necesitaba pensar en algo nuevo además de aumentar los señuelos y los valores de swing. Tuvo un mayor percentil de victorias contra el obstáculo que todos los bots de la última ronda, por lo que no tuvo suerte con los tamaños de arena.
Sylwester
Ajaja tal vez, creo que necesito un contraplan contra los tamaños cada vez mayores de señuelo: / Realmente me gusta cómo tienes diferentes modos
Sp3000
suspiro . Tendré que hacer que mi HLL for BF Joust funcione mejor para que mi evolver pueda tener una oportunidad nuevamente. Felicidades por # 1 ~
Lymia Aluysia
@LymiaAluysia Gracias. Estaba más sorprendido de Balder. Cuento con una nueva versión de NestDarwin, YandereBot y Mickey :-)
Sylwester
8

Geronimo

Es aún más ofensivo que el robot BestOffense de kaine, ya que no acumula ninguna defensa. La estrategia aquí es: otros tratarán de ser inteligentes, pero ser inteligente requiere ciclos. Pasemos a la parte en la que sabemos que está el enemigo y eliminemos todo lo que encontremos.

(>)*9(>[-])*21

Parece ganar la mayoría de los partidos contra los bots de ejemplo del OP y el bot de Kaine.

Ingo Bürk
fuente
7

SternBot

Un verdadero bot medio serio ahora que las cosas han comenzado. Abordar la naturaleza simular de algunos de estos bots.

(>->+>)*3(>[+]>[-])*21
kaine
fuente
1
SternBot me da problemas de paridad :(
Sp3000
7

No hacer nada

La mejor defensa (...) es la ignorancia.

.

No hace nada

EDITAR: Wow, me sorprendió ver que hizo un mejor trabajo que más del 20% de todos los bots =) (¿Esto significa que usa una estrategia superior o ...?)

falla
fuente
2
Algunos de los otros robots se suicidan en pequeñas arenas. p.ej. Gambler va directamente a la celda 20 y para los juegos wth 10-19 se sueltas, incluso contraDoNothingBot
Sylwester
2
Solo por curiosidad, ejecuté esto a través de mi probador (reproduce todas las longitudes de cinta) contra las otras entradas. Contempla el muro de la vergüenza ... +1
Comintern
Jaja, gracias por compartir, esperaba que pudiera haber una o dos ovejas negras, pero no esperaba que 'derrotara' a tantos bots =)
error
7

CounterPunch - Editado

Combinación equilibrada de construir una defensa fuerte y luego atacar.

(+)*6>(-)*12(>)*7(<(-)*12<(+)*12)*3(>)*7(([-([(-)*6[+.]])*5])*4>)*21

Anotado:

(+)*6                             Switch polarity of the flag
>(-)*12                           Build a quick decoy in front of the flag
(>)*7(<(-)*12<(+)*12)*3           Hop out and start building decoys backward
(>)*7                             Tally ho!
(([-([(-)*6[+.]])*5])*4>)*21      Clear toward the opposite end

Defiende de manera similar al Backtracker de @ Geobit , pero se defiende contra los atacantes rápidos colocando primero un señuelo rápido frente a la bandera.

El ataque es un despeje anidado con polaridad opuesta para limpiar rápidamente los señuelos con valores pequeños. El peor de los casos debería ser un señuelo de 64 (polaridad).

Edición 1: Mejora la eficiencia de ataque contra señuelos (tuvo un error lógico en el cambio de polaridad).

Edición 2: Las pruebas indican que la pausa funciona ligeramente mejor en el bucle más interno.

Comintern
fuente
6

Backtracker

Una estrategia de señuelo inverso. Comienza a colocar señuelos desde la parte delantera hacia atrás, para que nadie se salte el resto mientras los estoy construyendo.

Si el tablero es menor que el tamaño 20 más o menos, esto no funciona contra los bots de ataque rápido, ya que nos pasaremos antes de comenzar a decodificar.

(>)*9((-)*4<+<-<(+)*4<)*2(>)*8(>[-])*21

(>)*9                   Jump ahead 9
((-)*4<+<-<(+)*4<)*2    Lay down alternating polarity/size decoys for 8 spots behind
(>)*8                   Jump back forward
(>[-])*21               Clear until flag

Nota: No hago BF, pero esto me hace lo que quiero. Si no, déjame ahora.

Geobits
fuente
6

No puedo tocar esto

Este es un programa orientado a la defensa que intenta determinar cómo el oponente limpia las celdas y construye un señuelo del tamaño apropiado.

>---    create 1st decoy
>+      decoy for timing
>+      decoy for waiting
[]<     tripwire activated!
[<-->]  increase size of 1st decoy while opponent clears 2nd decoy
(>)*8   attack!
[+(<)*9(+)*20(>)*9]    slowly clear, while going back to stop enemy progress
>[+(<)*10(+)*22(>)*10]
>[+(<)*11(+)*24(>)*11]
>[+(<)*12(+)*26(>)*12]
>[+(<)*13(+)*28(>)*13]
>[+(<)*14(+)*30(>)*14]
>[+(<)*15(+)*32(>)*15]
>[+(<)*16(+)*34(>)*16]
>[+(<)*17(+)*36(>)*17]
>[+(<)*18(+)*38(>)*18]
>[+(<)*19(+)*40(>)*19]
>[+(<)*20(+)*42(>)*20]
>[+(<)*21(+)*44(>)*21]
>[+(<)*22(+)*46(>)*22]
>[+(<)*23(+)*48(>)*23]
>[+(<)*24(+)*50(>)*24]
>[+(<)*25(+)*52(>)*25]
>[+(<)*26(+)*54(>)*26]
>[+(<)*27(+)*56(>)*27]
>[+(<)*28(+)*58(>)*28]

Actualmente estoy trabajando en una versión que puede ganar contra ambas polaridades.

PhiNotPi
fuente
6

ImpatientTripwire (también conocido como YandereBot)

Intenta ser un cable trampa para que pueda colocar señuelos de (en su mayoría) la polaridad correspondiente, pero se da por vencido si toma demasiado tiempo y asume que es la paridad opuesta. Tiene un cable invertido para tablas pequeñas.

(+)*5                                     Toggles the base
>-                                        Sets up reverse tripwire
>>++>-->                                  Sets up basic decoys    
(+)*20                                    Makes a massive antioffset tripwire
(([)*150                                  Waits for a while
    <<<<                                  Goes to check on the other tripwire
    +[
      <                                   Bot found you and is furious
      ((+)*128 (>)*9 (+.)*55 (<)*9)*5     Tries to tie you up
      ((+)*128 (>)*10 (+.)*54 (<)*10)*5   And torture you
      ((+)*128 (>)*11 (+.)*53 (<)*11)*5   As it destroys the world
      ((+)*128 (>)*12 (+.)*52 (<)*12)*5
      ((+)*128 (>)*13 (+.)*51 (<)*13)*6
      ((+)*128 (>)*14 (+.)*50 (<)*14)*6
      ((+)*128 (>)*15 (+.)*49 (<)*15)*6
      ((+)*128 (>)*16 (+.)*48 (<)*16)*6
      ((+)*128 (>)*17 (+.)*47 (<)*17)*6
      ((+)*128 (>)*18 (+.)*46 (<)*18)*6
      ((+)*128 (>)*19 (+.)*45 (<)*19)*6
      ((+)*128 (>)*20 (+.)*44 (<)*20)*6
      ((+)*128 (>)*21 (+.)*43 (<)*21)*6
      ((+)*128 (>)*22 (+.)*42 (<)*22)*7
      ((+)*128 (>)*23 (+.)*41 (<)*23)*7
      ((+)*128 (>)*24 (+.)*40 (<)*24)*7
      ((+)*128 (>)*25 (+.)*39 (<)*25)*7
      ((+)*128 (>)*26 (+.)*38 (<)*26)*7
      ((+)*128 (>)*27 (+.)*37 (<)*27)*7
      ((+)*128 (>)*28 (+.)*36 (<)*28)*8
      ((+)*128 (>)*29 (+.)*35 (<)*29)*8      
    ]-
    >>>>)*2                                 Waits again
      <(+)*20                               Bot got stood up, is sad
      <(+)*20                               Sets up some decoys
      <(+)*20                               Grabs a knife
      <(-)*20                               Licks the blade
      <(-)*5                                Locks the house
      >>>>>>>>                              Goes to hunt you down
     (
       >                                    Start searching
       [
         +[+[+[                             Search from minus three
         ---
         -[-[-[                             To plus three
         (-)*17                             If that's no good, do an offset
         [+]                                Clear by adding
         [-.--]                             Just in case
         ]]]]]]                             I would duplicate the program to skip these like at
       ]                                    the bottom but the file would get too large
       [--.---]                             Also just in case
       -                                    Leave a small trail
     )*22
(
  ]                                         Skip the bracket closing
  <(-)*20                                   Bot found you and is happy
  <(-)*20                                   Has just the perfect presents for you
  <(-)*20                                   You like decoys right?
  <(+)*20                                   Here's a plus one in case you are sneaky
  <(-)*5
  >>>>>>>>                                  Time to hunt you down

  (>[+[+[+[----[-[-[(-)*17[+][-.--]]]]]]]][--.---]-)*22
)*300

Versión actual: 1.3 : editada para mejorar en tableros más pequeños, a expensas de perder juegos debido a que los enemigos se escabullen durante la comprobación de cables triples

Versiones pasadas: 1.2.1

(Necesito un mejor algoritmo claro: /)

Sp3000
fuente
1
OMG 411k completamente expandido y despojado: -O El código de Chiper simplemente depende de esto.
Sylwester
Solo cambié algunos de los comentarios para que ahora funcione con el nuevo código de Cipher
Sp3000
desde la última edición, los paréntesis sin paréntesis entre paréntesis se comportan de manera extraña ya que la lógica del bucle choca con la lógica de la abreviatura. ¿Puedo cambiar construcciones como ([)*300volver a [[[ and so on?
Cifrado
@Cipher Sí, adelante, aunque la versión pastebin debería ser exactamente eso
Sp3000
1
3rd es un buen lugar para entrar. Bien hecho.
AndoDaan
5

Lightfoot Plodder - EDITADO

Basado en el Plodder , este veloz gigante puede "avanzar rápidamente" a través de ceros consecutivos rápidamente hasta que alcanza algo distinto de cero (en ese momento comienza a avanzar como se esperaba).

Ahora mejorado con un algoritmo de descremado más robusto, que también permite el avance rápido a través de señuelos pequeños y señuelos más grandes propios.

Edición n. ° 2 : ahora puede volver al descremado si encuentra más focos de ceros.

>(-)*4
>(-)*7
>(-)*4
>(+)*7
>(-)*17
>(+)*3
> -
>(-)*10
>(+)*16[-]<-
([
[>>
 [+
  [--
   [+++
    [<+>(+)*14[-]]
   ]
  ]
 ]<-
]>>
[(+)*126(+.)*4>]
<]+)*10
DLosc
fuente
Bonito cambio de tamaño "conveniente" allí :)
Lily Chung
@IstvanChung Muy conveniente. ;) Cualquier otra me habría frenado demasiado, perdiendo puntos a varios otros bots. Si hicieras a Bigger más grande, no creo que intente mantener el ritmo.
DLosc
Bueno, he aumentado un poco el tamaño para ver cómo funciona. Creo que Bigger podría lograr un tamaño aún mayor, pero no tengo tiempo para probarlo a fondo. ¡Buena suerte!
Lily Chung
Me encanta la contramedida contra los bots Cloacking y el hecho de que esto realmente se parece a la programación BF :)
Sylwester
5

Reacio Rán v2

La estrategia es fácil. Trate de hacer que el oponente piense que su bandera es un señuelo y preceda más allá del tablero y se suelte (una especie de cable / vibrador). Después de 10 rondas completas, se da por vencida e intenta determinar si el oponente está en su bandera y si no, hará -17 señuelos hasta que golpee una celda establecida. El método de limpieza que usa es un caso especial para [-12,12] y comienza a trabajar de manera similar a Loke.

>>-<<                                  set a flag
(.)*11                                 wait for sixteenth step
((-)*256)*10                           reduce by ten rounds
                                       We give up check flags
> [(>)*7                               detected fast rush mode
    (-[>[
        -[-[-[-[-[-[-[-[-[-[-[-[       from plus one to twelve
        (+)*12                         reduce by twelwe
        +[+[+[+[+[+[+[+[+[+[+[+[       from minus one to twelve
          (+)*66..(+)*41(+.)*17>       increase and plod
        ]]]]]]]]]]]]]]]]]]]]]]]]]-])*3 
  ](-)*31
>+[(>)*6                               detected fast rush mode
    (-[>[
        -[-[-[-[-[-[-[-[-[-[-[-[       from plus one to twelve
        (+)*12                         reduce by twelwe
        +[+[+[+[+[+[+[+[+[+[+[+[       from minus one to twelve
          (+)*66..(+)*41(+.)*17>       increase and plod
        ]]]]]]]]]]]]]]]]]]]]]]]]]-])*3 
  ](-)*21
[>[                                    propably a trapper so we move slow
    ..+..-(+)*119(+.)*17               plodd the first cell so we dont go to zero on low positive
    ([>[
        -[-[-[-[-[-[-[-[-[-[-[-[       from plus one to twelve
        (+)*12                         reduce by twelwe
        +[+[+[+[+[+[+[+[+[+[+[+[       from minus one to twelve
          (+)*66..(+)*41(+.)*17>       increase and plod
        ]]]]]]]]]]]]]]]]]]]]]]]]]-]-)*3 
  ](-)*17
]

Trivia: Rán es una diosa del mar de la mitología nórdica que lleva a los marineros antes de que mueran en el mar.

Sylwester
fuente
5

Mickey V4

Para V4 utilicé el mismo método que V3, contra los bots actualizados pero con más poblaciones concurrentes (30 no 10).

Desarrollado contra los 60 bots, incluidos BurlyBalderV3y LethalLoke(pero excluyendo 2botsonecup que no es compatible con mi implementación estricta).

Descubrí bots muy diferentes y tasas de éxito si comencé con diferentes semillas aleatorias. Así que decidí separar estos diferentes puntos de partida en poblaciones y dejar que ocasionalmente realizaran una polinización cruzada.

En 1400 generaciones, 30 poblaciones en evolución simultánea crearon este programa:

++>------>->---<<<------------->------>->
---->------------->>--->------<----------
------<------<-<<--<------------->-------
-<-->------>------->----------->---------
----->-------->------->----------------[>
[--[-[+]]]>[--[+]]-]-------[>[--[-[+]]]>[
--[+]]-]<--<------>------->--------------
--[>[--[-[+]]]>[--[+]]-]<--<-------------
--------->------>->-<-----

Calculo que la tasa de ganancia de este bot es del 90.0% con respecto al cultivo actual. (Longitudes de cinta 1135/125/0 ganadas / perdidas / extraídas).

Información V3

Tasa de ganancia calculada del 89,2% (1124/62/74 longitudes de cinta ganadas / perdidas / sorteadas).

Información V2

El programa de generación ahora tiene un análisis para determinar qué parte del final del programa no se usa y lo recorta antes de generar las próximas generaciones. Esto significa que las mutaciones aleatorias ocurren solo en partes usadas del programa y, por lo tanto, la evolución es más rápida.

72% contra la cosecha actual en el momento. (892/204/143 longitudes de cinta ganadas / perdidas / sorteadas).

Información V1

31500 generaciones, solo 12 bots enfrentados. 65% (165/80/7 longitudes de cinta ganadas / perdidas / sorteadas). Yo uso las 21 longitudes de cinta.

Los bots potenciales se clasifican por:

  • la mayoría gana entonces;
  • la mayoría dibuja entonces;
  • tiempo más rápido dibujado entonces;
  • el tiempo más rápido ganado

Trivialidades

  • Mickey lleva el nombre de mi gato y;
  • Parafraseando a TS Elliot: The Naming of Cats is a difficult matter, It isn't just one of your brainfuck bots
  • Mi algoritmo genético java bf vm está en github .
  • El vm es capaz de ejecutar un torneo completo en menos de 4 segundos en un solo núcleo de un i7 (precaución: los resultados no siempre son idénticos al motor de torneos).
Weston
fuente
¿No sería mejor usar los 60 bots?
Sylwester
@Sylwester Tal vez, principalmente no lo hice porque es muy lento. Tomó dos horas para hacer esto. Además, aunque evolucionó más lentamente, más bots tuvo que enfrentar. Pensé que si vence a los mejores, les irá bien. No he podido ejecutar el torneo real para confirmar, problemas de Python. Así que pensé en publicarlo y ver ...
weston
@weston ¿Quizás podamos ayudarlo con sus problemas con Python?
Cipher
@Cipher gracias, abrí un número en github github.com/redevined/brainfuck/issues/2
weston el
@Sylwester Ahora uso la mayoría de los bots ya que mi generador es mucho más rápido y multiproceso.
Weston
4

Jugador

Esto está estrechamente relacionado con mi bot de Geronimo. Pero donde Geronimo está jugando una cosa segura, el jugador intenta ser más rápido haciendo lo que hace mejor: apostar: va a la celda 20 y comienza a cero desde allí.

Eso significa que podría perder fácilmente simplemente porque la arena no es tan grande. Pero si es así, podrían ser los pocos ciclos que cuentan.

(>)*19(>[-])*11

Dato curioso: Realmente estaba considerando ingresar a un grupo de bots que parecen todos (>)*X(>[-])*Ydónde X in 9..29y Y = 30 - X. Pero creo que ingresar veinte bots sería un poco demasiado :) O incluso cuarenta si tuviera dos versiones, una con cero [+]y otra que lo haga [-].

Ingo Bürk
fuente
¿Un número como 13 o 14 no le daría mejores porcentajes de ganancia que 20?
Moop
Si quizas. Solo quiero para el medio. Curiosamente, si solo voy a la izquierda en lugar de a la derecha, mis posibilidades de ganar disminuyen mucho. Hubiera esperado lo contrario.
Ingo Bürk
Como cada peleas bot continuación partidos contra cualquier otro robot, incluso 40 de los que no se elevaría las posibilidades de que gran parte - y tenía un tiempo difícil de copiar y pegar: D
Cipher
4

Tonto

Un bot notablemente estúpido que solo se mete con el medio ambiente y espera que los bots con los que lucha se salgan de la cinta.

(+)*50(>-)*7(([.])*50(+)*50>)*7([-])*256

(No estoy seguro de si esto funciona, ¡aunque no se produce un error!)

Anotado (con lo que creo que hace):

(+)*50      Increase home cell by 50
(>-)*7      For next 7 cells, decrement once
(           Open loop
([.])*50    If cell is non-zero, do nothing. If cell is zero... Still do nothing? I'unno.
(+)*50      Now let's increment it fifty times for some reason.
>)*7        And let's do the above two instructions ten times more, in the next 7 cells
([-])*256    If the cell we're on is non-zero, decrement it continuously and hope it's the enemy.

(Seré escalonado si esto gana una sola batalla)

Sellyme
fuente
1
su segunda línea realmente pondrá a cero la celda mediante la suma, y ​​luego restará una siete veces seguidas.
orgulloso Haskeller
1
@proudhaskeller Tienes razón ... Eso es lo que obtengo por intentar hacer cosas de Brainfuck con poco sueño. Acabo de simplificarlo en lugar de averiguar cómo hacerlo correctamente.
Sellyme
4

CropCircleBot

[>>[+][-]-<[-][+]+][>[+][-]<[-][+]++]

Este Bot utiliza algoritmos avanzados que fueron transmitidos por extraterrestres a través de círculos de cultivo que colocaron en la tierra. Cambiará a la humanidad y proporcionará enormes avances tecnológicos e incluso resolverá muchos problemas ambientales.

falla
fuente
Sabes que nunca deberías usar] [, ¿verdad?
CalculatorFeline
Yo no, ¿puedes explicar por qué?
flawr
Cuando deja un bucle, la celda actual es 0. Luego, omite el siguiente bucle porque la celda en el puntero sigue siendo 0.
CalculatorFeline
Oh, ¿siempre pensé que la verificación ocurre al final del ciclo?
flawr
También ocurre al principio. En algunas implementaciones, [no hace nada, pero ese es un lenguaje completamente diferente (newbiefuck en el wiki de esolang)
CalculatorFeline
4

BeatYouMate

Y debido a que todos deberían publicar un bot que supere al primer bot que publiquen, aquí hay un bot de señuelo 5+:

(>------>+++++++)*4>([(+)*6[-]]>)*21
AndoDaan
fuente
4

CleverAndDetermined

>+>-(>+++[-])*21

Establece algunas trampas pequeñas, luego corre hacia el otro lado e intenta despejar todo, por encima o por debajo de cero. Falla en ----.

isaacg
fuente
+++¡antes [-]es realmente inteligente evitar trampas simples!
Ingo Bürk
Lanzó una excepción debido a una incomparable (, ¿puedo tratarlo como un comentario?
Cifrado el
@ Cipher lo arreglaré, lo siento.
isaacg
4

MetaJSRandomBot

+[[>-[->+]>>[-]>-<<[>][+]<]+<]->

La idea detrás de este bot es hacer algo totalmente aleatorio que todavía sea un código js válido sin demasiada inutilidad. Escribí el siguiente código ( enlace JSFiddle ) para generarlo. Veamos qué tan bien lo hace =)

var nchars = 30;
var nbrack = 10;
var alphab = "+ - < >".split(' ');
var s = [];
for(var i=0;i<nchars;i++){
    s.push(alphab[(Math.random()*alphab.length)|0]);
}
var ind1,ind2;
for(var i=0;i<nbrack;i++){
    ind1 = (s.length*Math.random())|0;
    s.splice(ind1,0,'[');
    ind2 = ((s.length-ind1-1)*Math.random())|0 + ind1;
    s.splice(ind2,0,']');
}
s = s.join('')
for(var i=0;i<Math.max(nchars,nbrack);i++){//remove useless stuff
    s=s.replace('[]','');
    s=s.replace('+-','+');
    s=s.replace('-+','-');
    s=s.replace('<>','');
    s=s.replace('><','');
}
alert(s);
falla
fuente
4

Ruleta Prusiana

La Ruleta Rusa hizo una apuesta con su amigo Prusiano, y ahora es su turno de jugar.

>(+)*5(-.[>.[>(-)*10]]>>)*1000
Decaimiento Beta
fuente
Tiene 2 decrementos de puntero y solo 1 incremento en su bucle principal; esto lo sacará de su propio extremo de la cinta.
Comintern
2
Esto todavía se tirará solo.
orgulloso Haskeller
Justo al principio tienes un más seguido de un menos. 2 ciclos desperdiciados.
Weston
4

Más grande

¡Comienza la carrera armamentista!

Ambos construyen y destruyen paredes de altura 16 18, más grandes que la mayoría de los competidores. También tiene un poco de lógica para vencer al camuflaje, a los defensores de la bandera, a los antiaternadores y a los bots que asumen una bandera intacta

+>->+>+>-(>(-)*18>(+)*18)*2(>([(+)*18[-][-[+]]])*2)*21

Versión anotada

Off by one
==========
Adjust own flag a little for fun
-

Decoy stage
===========
Build decoys

>->+>+>-        Add four quick walls to deter rushers
                Also throw off bots depending on the alternation
(>(-)*18
 >(+)*18)*2     Build four large decoys

Clear stage
===========
(               Repeat the following forever:
  >             Move forward
  ([            Skip if the space is zeroed already
      (+)*18    Bust negative decoys smaller than 18
      [-]       Clear
      [-[+]]    Check that the wall is actually cleared; if it isn't,
                clear in the opposite direction to defeat bots that try
                to sense our clear direction and defend the flag
  ])*2          Repeat the "non-zero" check to guard against the cloaker
)*21
Lily Chung
fuente
3

PacienteBot

Un bot en parte serio. este bot intentará ganar por el límite de 100000 ciclos. irá a la bandera enemiga mientras pone algunas trampas en el camino, disminuya un poco, regrese y defienda la bandera.

>++>->->+>+>->->+(>+[-[-[(<)*9--[<--](+)*10000]]])*20

asumirá que todo lo que sea mayor que 1 o menor que -1 es la bandera, y cuando encuentre una, volverá. defiende simplemente incrementando constantemente. esto supone que la mayoría de los programas usarán [] para verificar si el indicador se convirtió en 0, por lo que (+) * 100000 será mucho más rápido

Editar: no puede hacer que funcione en el intérprete BF Joust. tiro la toalla. tal vez deberías decirme cómo mejorar mi código.

Editar: ahora el bot hace el lugar justo antes de la bandera 2, y después de disminuir un poco la bandera, busca un 2. Esto está destinado a cancelar el escenario en el que el bot encontraría una celda 0 distinta de la anterior a la bandera.

orgulloso Haskeller
fuente
Su bot parece matarse en una cinta (bastante rara, lo admito) con una longitud de 10 ya que hay 10 '>' al principio. Aparte de eso, [<]no es una buena idea, ya que se repite retrocediendo hasta que la celda debajo de su puntero es igual a cero , que es una de las celdas frente a su bandera o simplemente suicidio si su puntero llega a la bandera (ya que su bandera ojalá no sea cero ).
Cifrado el
@Cipher Note que el bot no pone una trampa en el lugar justo delante de la bandera; mi idea era marcar este lugar para que el bot construyera su defensa allí. ¿Hay una mejor manera? En ocasiones, el enemigo despeja las trampas y luego el robot se detiene antes de lo que debería.
orgulloso Haskeller