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


88

Tutti i robot nell'arena di battaglia sono stati improvvisamente colpiti dal cervello e nessuno può spiegare il perché. Ma chi se ne frega finché sono ancora in grado di combattere, anche se Brainfuck è l'unica lingua che capiscono più.


È passato un po 'di tempo dall'ultima presentazione, quindi finalmente annuncerò il vincitore di BrainFuckedBotsForBattling: Congratulazioni a LymiaAluysia per aver vinto con NyurokiMagicalFantasy!


tabellone segnapunti

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

I punteggi finali del 09.10.2014

EDIT6 : registri scartati a causa di dimensioni e runtime estremi. Puoi generarli tu stesso decommentando le linee RunThisTournament.py.

EDIT5 : implementata la gestione delle abbreviazioni nel controller, nessun tempo di esecuzione enorme. Ciò ha l'effetto collaterale che numeri e parentesi non vengono più trattati come commenti. Puoi comunque usarli se vuoi fornire una versione annotata, ma sarebbe molto utile se ci fosse anche una versione non commentata del tuo codice , quindi non ho bisogno di rimuovere i commenti manualmente. Grazie!

EDIT4 : modificato il titolo, perché il torneo è stato rimosso dalle domande sulla rete attiva . Grazie a @Geobits per averlo segnalato!

EDIT3 : i commenti rimossi nei programmi bf, a causa di un risultato imprevisto, dovrebbero essere corretti ora. Se qualcuno ha un problema con la rimozione dei suoi commenti, si prega di segnalare.

EDIT2 : Dal momento che ha causato un runtime arcano sul mio computer piuttosto lento, ho ridotto il limite di timeout da 100000 cicli a 10000 cicli. Non che nessuno abbia comunque superato il risultato di un gioco in esecuzione oltre questo punto.

EDIT1 : corretto un bug nello script convert che impediva all'interprete di ignorare i numeri nei programmi commentati.


Descrizione

Questo è un torneo Brainfuck ispirato a BF Joust . Due robot (programmi Brainfuck) si combattono in un'arena rappresentata da un nastro di memoria. Ogni cella può contenere valori compresi tra -127 e 128 e andare a capo (quindi 128 + 1 = -127).

Le istruzioni valide sono simili al normale Brainfuck, il che 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

L'arena ha una dimensione da 10 a 30 celle che viene scelta in modo pseudorandom ogni battaglia. Ad entrambe le estremità si trova un 'flag' che ha un valore iniziale di 128, mentre tutte le altre celle sono azzerate. L'obiettivo del tuo bot è di azzerare la bandiera del nemico per 2 cicli consecutivi prima che azzeri la tua bandiera.

Ogni bot inizia con la sua bandiera, che è cella [0] dalla sua prospettiva. L'avversario si trova dall'altra parte del nastro.

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

Entrambi i robot eseguono la loro azione contemporaneamente, questo è considerato un ciclo. Il gioco termina dopo 10000 cicli o non appena viene raggiunta una delle condizioni vincenti. Se uno dei programmi raggiunge la fine, smette semplicemente di fare qualcosa fino alla fine del gioco, ma può comunque vincere.


Condizioni vincenti

Il tuo bot vince in una delle seguenti condizioni:

  • La bandiera del tuo nemico viene azzerata prima della tua
  • Il tuo nemico sposta il suo puntatore fuori dal nastro (viene eseguito >sulla tua bandiera o <da solo)
  • Il valore della tua bandiera è più lontano da 0 rispetto al valore della bandiera del tuo avversario dopo 10000 cicli

Regole

Il tuo post dovrebbe contenere un nome per il tuo bot e il suo codice.

  • È possibile utilizzare la seguente sintassi delle abbreviazioni per rendere più leggibile il codice:
    • eg (+)*4è uguale a ++++, questo vale per qualsiasi istruzione eccetto parentesi senza pari tra parentesi poiché la logica del loop si scontra con la logica dell'abbreviazione. Si prega di utilizzare [-[-[-invece di([-)*3
  • Ogni personaggio diverso da quello +-><[].è un commento e quindi ignorato, ad eccezione ()*delle abbreviazioni

I robot che non seguono le regole saranno esclusi dal torneo.

  • È consentito solo Brainfuck di base, nessuna altra variante che supporti procedure o operazioni aritmetiche
  • Il codice sorgente del bot non deve contenere parentesi senza pari

Puoi informarti sulle strategie di base ma non utilizzare il codice di un altro per il tuo bot.


punteggio

Il punteggio di un bot è determinato dal numero di vittorie contro tutti gli altri bot. Un incontro tra 2 robot consiste di 10 partite con lunghezze di nastro di memoria diverse, il che si traduce in un punteggio massimo di 10 punti per incontro. Un pareggio non dà punti per questa partita.


Programma di controllo

Puoi trovare il programma di controllo su github, insieme ai registri completi delle battaglie. La classifica verrà pubblicata qui una volta generata.

Sentiti libero di clonare il repository e prova il tuo bot contro gli altri da solo. Utilizzare python Arena.py yourbot.bf otherbot.bfper eseguire una partita. È possibile modificare le condizioni con i flag della riga di comando -me -t. Se il terminale non supporta le sequenze di escape ANSI, utilizzare il --no-colorflag per disabilitare l'output colorato.


Bot di esempio

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

Il DecoyBot vincerà ogni partita con una lunghezza del nastro superiore a dieci, poiché FastClearBot può evitare i piccoli esche, ma non quelli più grandi. L'unica situazione in cui FastClearBot può vincere contro DecoyBot è quando è abbastanza veloce da raggiungere la bandiera del nemico prima che il suo avversario abbia accumulato grandi esche.


5
Originale, mi piace Temo solo che ciò non consentirà una profondità strategica sufficiente, ma che potrei essere solo io.
Augıʇǝɥʇuʎs

11
Questo sarebbe ancora più divertente con Befunge .
IchBinKeinBaum,

6
Ho trovato una pagina web di BF Jousting che può eseguire e visualizzare partite di giostre.
PhiNotPi il

4
Grazie per aver ospitato questo KOTH, Cipher. Deve essere molto lavoro con così tante proposte.
AndoDaan,

3
Preferirei ringraziare tutti per aver ancora partecipato ^^
Cipher

Risposte:


18

Nyuroki Magical Fantasy

Penso che sia giunto il momento di fare sul serio ~ Ho finito il mio compilatore per un po 'di HLL per rendere più semplice la scrittura di programmi BF Joust. Questo è stato il mio primo serio tentativo di fare qualcosa con esso. Il concetto del bot è piuttosto semplice. Imposta alcune esche di diverse polarità, quindi impazzisce con una grande oscillazione libera con un offset inverso al centro.

Oh, a proposito, il punteggio atteso è di circa 577 punti contro la collina dell'ultimo round. Questa è una percentuale di vincita del 93%. <3

Compilato | Codice sorgente

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

Modifica : ho ottenuto qualche altra vittoria su Nyuroki.

Modifica 2 : Ehi, guarda, l'ho fatto di nuovo!

Modifica 3 : Dopo aver lottato per un po 'con uno stupido bug di analisi in Arena.py, ho finalmente ottenuto un altro miglioramento in ~ Questo è ciò che intendo per "tempo di fare sul serio", sai. <3


Sembra che Loke abbia bisogno di qualche aggiustamento :-) Adoro la tua lingua. Il bug in Arena.py che avevi spazi bianchi tra )e *o tra *e il numero?
Sylwester,

@Sylwester Molto peggio. Loop che vanno dove non dovrebbero andare: github.com/redevined/brainfuck/pull/6
Lymia Aluysia

Complimenti con il n. 1. Il tasso di vincita del 92,5% sarà difficile da eguagliare.
Sylwester,

Ben fatto, ma questo abuso di stenografia non è? I loop nidificati sono effettivamente 21 fattoriale = 5 * 10 ^ 19. In altre parole è effettivamente espandibile nel brainfuck di base.
Weston,

1
@weston Sì. E la maggior parte dei programmi sulla collina BF Joust più sviluppata ( codu.org/eso/bfjoust/in_egobot - per esempio, dai un'occhiata a smartlock) sono anche peggio. Non è un grosso problema, dal momento che è una specie di scorciatoia. Rende possibili strategie che non sarebbero praticabili altrimenti a causa della lunghezza pura. :)
Lymia Aluysia,

43

Cloaking Device Bot

Questo bot in pratica cerca di nascondere la sua base, facendo in modo che altri robot si muovano oltre e fuori dal nastro.

(-)*127(-+--+-++)*12500

4
Molto intelligente, ho dovuto adattare il mio bot per tenere conto di questo.
Moop,

2
Questo è uno dei più intelligenti qui, secondo me.
Almo,

+ f per il primo cloaker. Non l'avevo notato prima dopo aver realizzato Ràn, ma è un'idea simile, un'applicazione diversa.
Sylwester,

19

Burly Balder v3

Burly Balder è una corsa mediamente lenta. Fa due grandi esche prima di entrare in modalità corsa. In modalità rush ha un loop che usa solo 4 passi per ogni cella zero e quando una cella diversa da zero ha un'analisi del caso per [-18,18] prima di ridurre alla cieca con 107 prima di cancellare con [-.]. Cancella una bandiera invariata in 242 passaggi, 114 in più di un incerto -*128 e 14 in meno di un ingenuo [-]radura. Quando una cella viene cancellata, continua a lasciare una scia di -2 esche. Ha un caso speciale solo per l'indice 9 per salvare alcuni passaggi per i giochi di dimensione 10 e lascia la cella con 1 esca.

>((-)*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

Curiosità: Balder è un dio nordico e figlio di Odino. È noto soprattutto per la storia della sua morte : aveva paura per la sua sicurezza, quindi gli altri dei hanno cercato di prevedere e difendersi da ogni minaccia. Alla fine è stato ucciso da Loki da quando lo hanno protetto contro spade e frecce, ma si sono dimenticati di proteggerlo dal vischio.


2
I tuoi esche mi stanno uccidendo. Molto bene.
AndoDaan,

1
@AndoDaan Grazie. Sei BeatYouMatestato intelligente. Temo che le esche sulla maggior parte dei robot diventeranno ancora più grandi il prossimo round fino a quando non darà una penalità. Quindi avremo forse altre strategie interessanti emergenti :)
Sylwester,

2
Il problema con l'aumento della dimensione dell'esca è che si scambia con le prestazioni su nastri più corti contro i robot di attacco veloci. Con 10 round casuali è più probabile un punto debole che cambia a seconda della velocità con cui le altre voci attaccano.
Comintern,

2
Sì, sei ancora quello da battere.
AndoDaan,

4
@AndoDaan Con così tanti dei nordici che mi supportano, le dimensioni casuali dell'arena sembrano essere a mio favore :-)
Sylwester,

13

EvoBot 1

Questo è un semplice bot creato tramite algoritmo genetico. Ho iniziato con un modello e il mio programma ha lentamente modificato i numeri per creare un miglior guerriero-robot. Il codice seguente è stato modificato per aumentare la leggibilità.

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

Ho usato le altre voci del concorso per misurare l'idoneità dei diversi candidati.

Dato che questo è stato il mio primo tentativo di evobot, ho iniziato con un modello semplice:

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

Prevedo che questo bot riceverà un punteggio nell'intervallo da 50 a 60 anni.

Attualmente sto lavorando a un modello di esca inversa.

EvoBot 2

Questo è un bot creato dallo stesso algoritmo genetico, ma con il seguente modello:

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

Questo bot utilizza la strategia di richiamo inverso per impostare 4 esche di altezza variabile. Il bot risultante è:

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

Mi aspetto che questo nuovo bot abbia un rendimento migliore rispetto ai precedenti robot, probabilmente guadagnando un punteggio negli anni '70 (probabilmente molto più alto di quello dato che ci sono molte nuove voci).


2
+1 per algoritmi genetici. Ho una grande fiducia in loro. Spero che i tuoi robot facciano bene.
AndoDaan,

12

Alternatore

Presuppone che la maggior parte delle persone azzeri una cella aggiungendola o sottraendola, quindi in media ogni cella impiegherà 128 turni a zero.

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

Versione annotata

(>+>-)*4       Move eight squares alternating polarity    
>+             Move one more
(
    >          Move to the next square
    [-]        Zero it
    [.]        Wait while it is zero
)*21           Repeat

Accidenti, le tue ultime modifiche migliorano la percentuale di vincite per Alternatore contro Geronimo dal ~ 60% al ~ 90%. Bello.
Ingo Bürk,

sì, mi sono trasferito 18 volte quando l'ho fatto (> +> -) * 9, quindi sarebbe caduto dal nastro. Sciocco errore.
Moop,

Anche proteggere Geronimo aggiungendo / sottraendo alternativamente a zero la cella non cambia affatto la mia percentuale di vincita. L'alternatore potrebbe essere il vincitore qui - usa pochi cilindri per impostare una trappola abbastanza difficile da rompere.
Ingo Bürk,

Ehi, correggimi se sbaglio, ma questo bot non si sposta automaticamente dal board se il board è lungo 10? Si sta muovendo di 10 quadrati prima di tentare di impostare qualsiasi cosa su zero.
Ripristina Monica il

11

Quindi, qualcun altro qui utilizza un algoritmo genetico per provare a creare programmi qui. Bene ... molto tempo fa, ho scritto un evolutore BF Joust per una collina in corso in un canale IRC. Ho deciso di provare anche per questo concorso ~

E ... a differenza dell'altra persona con un evolutore, il mio evolutore può effettivamente cambiare più programma rispetto ai conteggi ripetuti. :)

NestDarwin (generazione 309)

Questo è il miglior risultato finora ottenuto dal mio evolutore. Non sono sicuro di quanto la struttura nidificata sia di aiuto in questo caso, ma strutture come questa erano ciò che lo sviluppatore dovrebbe essere in grado di fare. La prestazione prevista sulla collina del 27.08.2014 è di 474 punti. (Calcolato eseguendo la battaglia su tutte le 21 lunghezze di nastro e moltiplicando per 10/21. Nota che questo non è normalizzato per il fatto che questa collina ha un programma extra su di essa)

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

EDIT : elenco modificato di programmi che voglio entrare in questa collina. Si è evoluto durante la notte. :)


EDIT 2 : sono andato e ho analizzato manualmente l'output dell'evolutore. Nonostante sembri molto diverso, NestDarwin è fondamentalmente una versione ottimizzata di TinyDarwin ... Ridotta al minimo manualmente (con funzionalità identica) e analizzata:

(-)*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.

Quindi, un programma quasi identico sarebbe il seguente ... che è fondamentalmente una versione super-ottimizzata di TinyDarwin.

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

TinyDarwin era il seguente. Non molto diverso, eh? Lo ritirerò dalla collina. Pensavo fosse distinto, ma ... beh, mi sbagliavo.

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

È diventato evidente che l'attuale collina non è abbastanza forte da permetterle di evolvere cose molto più complesse. :(


1
Complimenti per il primo posto. Il programma di algo genetico è in grado di utilizzare la tua versione attuale come modello e continuare con le nuove versioni per migliorarla ulteriormente?
Sylwester,

Ottimo lavoro con il primo posto. Sono così felice che un algoritmo genetico (beh, il suo spawn) sia arrivato lì!
AndoDaan,

Ora, se potessimo prendere i risultati di tutti i giochi, evolvere di più, aggiungere un po 'di apprendimento automatico ... allora noi pietosi umani non avremo più alcuna possibilità: P
Sp3000,

@Sylwester Sort of? La mia rappresentazione interna usa un sistema di attivazione genica (mal concepito) che dovrebbe far evolvere la sovrastruttura (e in pratica non lo fa davvero). Non riesco a rimettere il programma finale e recuperare la rappresentazione interna, ma posso mettere le istruzioni in un singolo gene e lasciarlo continuare ad evolversi (per quanto ciò possa aiutare).
Lymia Aluysia,

@ Sp3000 Purtroppo il mio algoritmo riesce a malapena a progredire sulla ben sviluppata collina #esoterica. Sarebbe bello se potessi fare una cosa del genere, ma, ahimè, la mia abilità negli algoritmi genetici non è abbastanza buona. Probabilmente rilascerò il mio evolutore un giorno quando avrò ripulito tutti i miei brutti hack.
Lymia Aluysia,

10

Orso polare MK II

Esistono due tipi di orsi polari : quelli che rimangono intrappolati e quelli che intrappolano altre persone.

Cerca di indovinare la polarità dell'avversario e quindi utilizza tali informazioni per bloccare l'avversario in un ciclo infinito. Funziona bene contro semplici strategie di compensazione e in qualche modo casualmente contro altre. Le trap possono essere facilmente evitate, quindi potrei aggiungere alcune strategie di backup in un secondo momento.

>++>- 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 [-]

È possibile dimezzare la dimensione del codice con (]< (+)*290 (>)*9 ... [-])*2?
Sylwester,

@Sylwester Non posso perché l'altra metà usa +e l'altra usa -.
Mika Lammi,

L'orso polare non funziona molto bene con gli offset compensati ... un'idea fantastica però
Sp3000

@ Sp3000 Sei sicuro? Ho provato con diversi offset e polarità (come [(+)*3[-]], [(-)*6[+]]) e funziona benissimo (almeno per offset abbastanza piccoli).
Mika Lammi,

Oh, so cosa c'è che non va: / Stavo provando programmi come il >>>>>>>>>((-)*4[+][--.]>)*21doppio controllo della cella e il tuo (+/-)*290stava causando l'attivazione del secondo loop off-sync. Non è colpa della cancellazione dell'offset.
Sp3000,

10

Pacifist Bot

Il mio bot crede che la violenza non sia mai la risposta e cercherà di evitare il combattimento a tutti i costi.

(.)*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

8
Mi sono preso la libertà di rimuovere i "." Nei tuoi commenti poiché contano come codice Brainfuck e rendono il tuo bot un po 'più lento del necessario. Se i punti sono intenzionali, sentiti libero di correggermi!
Cifra il

Oh giusto, i. Sono stati piuttosto sciocchi da parte mia, grazie per averli rimossi: p
mmphilips

9

Qualcuno là?

Guarda periodicamente dietro per determinare quando il nemico ha iniziato a eliminare le esche, quindi si precipita avanti.

Sembra fare bene, ma non sono sicuro che sia a causa della strategia o solo perché sto aggiungendo 10 a ogni cella prima di cancellare.

Modifica: risolto un problema logico. La prima volta che scrivo un programma brainfuck. È all'altezza del suo nome.

>>>+<(+)*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

+1: Questo è il primo bot che ho visto esca le stringhe (oltre a +/- 1) oltre le prime 9 celle. Su nastri più lunghi, è un assassino. Retrofitting Lightfoot Plodder ancora un po '...
DLosc

9

WALL-E 2.0

Si precipita nella posizione 9 e ne aggiunge 128, vincendo rapidamente nell'arena della dimensione 10 se l'avversario non ha modificato il valore iniziale di bandiera. Su arene più grandi, questo funziona come grande esca. Dopodiché riempie lo spazio tra la posizione 9 e la propria bandiera con grandi esche. Quando vengono posizionate le esche, cerca posizioni non vuote e cerca di cancellarle rapidamente.

La versione 2.0 crea esche più grandi e ha una certa tolleranza contro la modifica del valore iniziale del flag. Può anche passare alla strategia di backup se le cose iniziano a sembrare pelose.

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

L'efficacia di questo bot si basa su due fatti:

  1. La maggior parte dei robot non modifica il valore iniziale della loro bandiera.
  2. Costruire esche di grandi dimensioni è più veloce che cancellarle.

Queste mura mi stanno uccidendo
Sp3000,

9

Lethal Loke V2.1 (con vischio)

Questo è ovviamente un robot mortale e uccide non solo il bellissimo Burly Balder a con il vischio, ma vince quasi ogni volta anche contro gli altri robot. È un mezzo combinato e una corsa veloce. Il mio test mi dà un punteggio di 567

File BFJ compilato per la battaglia , sorgente del generatore BFJ di Racket:

#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))

Curiosità : Loke (Loki) è un dio della mitologia nordica a cui piace giocare con tutti e ingannarli. È un mutaforma (in animali e persone) e di solito va per la sua strada. Nelle storie con cui spesso viaggia e assiste gli altri dei, fa piccoli trucchi e agita le cose. Oltre a uccidere Balder, generò Hel (la dea dell'inferno / Helvete), la bestia Fenrir e il serpente di Midgard che dà inizio a Ragnarok (armageddon nordico).

Come funziona

All'inizio fa una grande esca (-17), quindi +-traccia il modello fino all'indice 7. Scansione in avanti da 13 a 13 lasciando una scia di (+ 10, -32) + esche ma quando rileva un set si interromperà e avvia una modalità di corsa media * 1. Se non viene impostata alcuna cella, avvierà anche la modalità di corsa lenta * 3.

* 1 In modalità rush medio ha rilevato l'attività dell'avversario in uno degli indici 7-13 e parte dall'indice 2. Alcuni avversari lasciano uno zero e altri lasciano un valore diverso e ora ha i mezzi per rilevare l'attività dell'avversario prima di fare esche in indice 2-6 (-32, + 10) +. Se la cella non ha un valore atteso (-1, 1) o ha finito di fare tutti i richiami, passa in modalità veloce * 2.

* 2 La modalità di punta veloce che si aspetta sia stata rilevata in modo che le esche non funzionino. Speriamo che quelli che abbiamo già impostato stiano fermando l'avversario e ci concentriamo sul correre attraverso le esche degli avversari. Comincia a correre nel punto più lontano che conosciamo in base alla scansione precedente [9,14] o all'indice 9 se siamo stati fatti prima. Ha un caso speciale per il primo esca in cui aggiungiamo solo 120 e plodd 27 poiché non vuole ridurre il valore al di sotto dello zero in caso sia una trappola, ma per ogni esca dopo esserci spostati a [-8,8] prima di aumentare di 120 e avanzando di 27 gradini prima di proseguire nella cella successiva.

La modalità di corsa lenta è stata rimossa poiché non ha influenzato il punteggio con la collina corrente e rende il mio bot un po 'più piccolo (ma non molto).


3
Ora stiamo iniziando a vedere la follia. Mi piace.
Sp3000,

@ Sp3000 YandereBotv2 era il motivo per cui avevo bisogno di pensare al nuovo oltre ad aumentare i richiami e i valori di swing. Aveva un percentile di vittoria più alto rispetto al hurd rispetto a tutti i robot dell'ultimo round, quindi sei stato sfortunato con le dimensioni dell'arena.
Sylwester,

Ahaha forse - penso di aver bisogno di un piano di appoggio contro le crescenti dimensioni dell'esca: / Mi piace molto come hai diverse modalità però
Sp3000

sospiro . Dovrò far funzionare meglio il mio HLL per BF Joust in modo che il mio evolutore possa avere di nuovo una possibilità. Congratulazioni per # 1 ~
Lymia Aluysia,

@LymiaAluysia Grazie. Sono stato più sorpreso di Balder. Conto su una nuova versione di NestDarwin, YandereBot e Mickey :-)
Sylwester,

8

Geronimo

È persino più offensivo del bot BestOffense di kaine in quanto non crea alcuna difesa. La strategia qui è: gli altri cercheranno di essere intelligenti, ma essere intelligenti richiede cicli. Quindi passiamo alla parte in cui sappiamo che il nemico è dentro e cancelliamo tutto ciò che troviamo.

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

Sembra vincere la maggior parte delle partite contro i robot di esempio dell'OP e il bot di Kaine.


7

SternBot

Un vero bot mezzo serio ora che le cose sono iniziate. Affrontare la natura similare di alcuni di questi robot.

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

1
SternBot mi dà problemi di parità :(
Sp3000,

7

DoNothingBot

La migliore difesa (...) è l'ignoranza.

.

Non fa niente.

EDIT: Wow, sono stato sorpreso di vedere che ha fatto un lavoro migliore rispetto a almeno il 20% di tutti i bot =) (Questo significa che utilizza una strategia superiore o ...?)


2
Alcuni degli altri robot si suicidano in piccole arene. per esempio. Il giocatore d'azzardo va direttamente nella 20a cella e per i giochi con 10-19 si perde, anche controDoNothingBot
Sylwester,

2
Solo per curiosità, l'ho passato attraverso il mio tester (riproduce tutte le lunghezze del nastro) contro le altre voci. Ecco il muro della vergogna ... +1
Comintern

Haha, grazie per averlo condiviso - mi aspettavo che potessero esserci una o due pecore nere ma non mi aspettavo che "sconfiggesse" così tanti robot =)
flawr

7

CounterPunch: modificato

Combinazione equilibrata di costruzione di una forte difesa e attacco.

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

commentata:

(+)*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

Difende in modo simile al Backtracker di @ Geobit , ma si difende dagli attaccanti veloci mettendo prima un esca veloce davanti alla bandiera.

L'attacco è una compensazione annidata con polarità opposta per eliminare rapidamente le esche con valori piccoli. Lo scenario peggiore dovrebbe essere un esca di 64 (entrambe le polarità).

Modifica 1: migliora l'efficienza dell'attacco contro i richiami (si è verificato un errore logico nel cambio di polarità).

Modifica 2: Il test indica che la pausa si comporta leggermente meglio nel ciclo più interno.


6

Backtracker

Una strategia di esca inversa. Inizia a posare le esche sul davanti, in modo che nessuno salti il ​​resto mentre le sto costruendo.

Se la tavola ha dimensioni inferiori a 20 o giù di lì, questo non funziona contro i robot ad attacco rapido, dato che ci passeremo l'uno contro l'altro prima di iniziare l'esca.

(>)*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: io non BF, ma questo come fa quello che voglio per me. In caso contrario, per favore fammi ora.


6

Non posso toccarlo

Questo è un programma orientato alla difesa che tenta di determinare come l'avversario sta liberando le celle e costruisce un esca delle dimensioni appropriate.

>---    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]

Attualmente sto lavorando a una versione che può vincere contro entrambe le polarità.


6

ImpatientTripwire (aka YandereBot)

Cerca di essere un tripwire in modo che possa posare le esche (per lo più) della polarità corrispondente, ma si arrende se impieghi troppo tempo e presuppone invece che tu sia la parità opposta. Ha un tripwire inverso per le piccole schede.

(+)*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

Versione corrente: 1.3 - modificata per fare meglio su schede più piccole, a scapito della perdita di giochi a causa del passaggio di nemici durante il controllo del tripwire

Versioni precedenti: 1.2.1

(Ho bisogno di un algoritmo più chiaro: /)


1
OMG 411k completamente espanso e messo a nudo: -O il codice di Chiper si blocca su questo.
Sylwester,

Ho appena cambiato alcuni dei commenti in modo che ora funzioni con il nuovo codice di Cipher
Sp3000,

dall'ultima modifica, le parentesi senza pari tra parentesi si comportano in modo strano poiché la logica del ciclo si scontra con la logica dell'abbreviazione. posso cambiare costrutti come ([)*300torna a [[[ and so on?
Cifra

@Cipher Sì, provaci - anche se la versione di pastebin dovrebbe essere esattamente questo
Sp3000

1
3 ° è un bel posto dove entrare. Molto bene.
AndoDaan,

5

Lightfoot Plodder - EDITED

Basato sul Plodder , questo veloce behemoth è in grado di "avanzare rapidamente" attraverso 0 consecutivi rapidamente fino a raggiungere qualcosa di diverso da zero (a quel punto inizia a muoversi come previsto).

Ora migliorato con un algoritmo di scrematura più robusto, che consente anche l'avanzamento rapido attraverso esche piccole e esche più grandi.

Modifica n. 2 : ora è in grado di tornare alla scrematura se trova più sacche di zeri.

>(-)*4
>(-)*7
>(-)*4
>(+)*7
>(-)*17
>(+)*3
> -
>(-)*10
>(+)*16[-]<-
([
[>>
 [+
  [--
   [+++
    [<+>(+)*14[-]]
   ]
  ]
 ]<-
]>>
[(+)*126(+.)*4>]
<]+)*10

Bello "comodo" cambio di dimensioni lì :)
Lily Chung,

@IstvanChung Molto conveniente. ;) Più mi avrebbe rallentato troppo, perdendo punti rispetto a molti altri robot. Se avessi reso Bigger più grande, non credo che avrei cercato di tenere il passo.
DLosc,

Bene, ho aumentato leggermente le dimensioni per vedere come funziona. Penso che Bigger potrebbe essere in grado di ottenere dimensioni ancora maggiori, ma non ho tempo di provarlo a fondo. In bocca al lupo!
Lily Chung,

Adoro la contromisura contro i robot Cloacking e il fatto che questo in realtà assomigli alla programmazione BF :)
Sylwester,

5

Riluttante Rán v2

La strategia è semplice Cerca di convincere l'avversario a pensare che la sua bandiera sia un'esca e precede il tabellone e si libera (una specie di tripwire / vibratore). Dopo 10 round completi lei si arrende e cerca di determinare se l'avversario è alla sua bandiera e in caso contrario realizzerà -17 esche fino a quando non colpisce una cella impostata. Il metodo di clearing che usa è un caso speciale per [-12,12] e inizia a muoversi in modo simile 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
]

Curiosità: Rán è una dea marina della mitologia nordica che porta i marinai prima di morire in mare.


5

Topolino V4

Per V4 ho usato lo stesso metodo di V3, rispetto ai bot aggiornati ma con più popolazioni simultanee (30 non 10).

Sviluppato contro tutti e 60 i robot, incluso BurlyBalderV3e LethalLoke(ma escluso 2botsonecup che non è compatibile con la mia rigorosa implementazione).

Ho scoperto robot e tassi di successo incredibilmente diversi se ho iniziato con semi casuali diversi. Così ho deciso di separare questi diversi punti di partenza in popolazioni e di lasciarle occasionalmente impollinare.

In 1400 generazioni, 30 popolazioni in continua evoluzione hanno creato questo programma:

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

Calcolo il tasso di vincita di questo bot per essere del 90,0% rispetto al raccolto corrente. (Lunghezze nastro 1135/125/0 vinte / perse / pareggiate).

Informazioni V3

Percentuale di vincita calcolata dell'89,2% (lunghezze nastro 1124/62/74 vinte / perse / pareggiate).

Informazioni V2

Il programma di generazione ora ha un'analisi per dire quale parte della fine del programma non è in uso e lo ritaglia prima di generare le generazioni successive da esso. Ciò significa che le mutazioni casuali si verificano solo nelle parti utilizzate del programma e quindi l'evoluzione è più veloce.

72% rispetto al raccolto attuale al momento. (892/204/143 lunghezze di nastro vinte / perse / pareggiate).

V1 info

31500 generazioni, affrontati solo 12 robot. 65% (lunghezze nastro perse / perse / pareggiate 165/80/7). Uso tutte le 21 lunghezze di nastro.

I potenziali robot sono classificati in base a:

  • la maggior parte vince allora;
  • la maggior parte disegna quindi;
  • tempo più veloce disegnato allora;
  • tempo più veloce vinto

banalità

  • Topolino prende il nome dal mio gatto e;
  • Per parafrasare TS Elliot: The Naming of Cats is a difficult matter, It isn't just one of your brainfuck bots
  • Il mio algoritmo genetico e java bf vm è su github .
  • Il VM è in grado di eseguire un torneo completo in meno di 4 secondi su un singolo core di un i7 (attenzione: i risultati non sono sempre identici al motore dei tornei).

Non sarebbe meglio usare tutti e 60 i robot?
Sylwester,

@Sylwester Forse, principalmente perché non è così lento. Ci sono volute due ore per farlo. Anche se si è evoluto più lentamente, più robot ha dovuto affrontare. Ho pensato che se batte i migliori, andrà bene. Non sono stato in grado di eseguire il torneo vero e proprio per confermare, problemi di pitone. Quindi ho pensato di postarlo e vedere ...
Weston,

@weston Forse potremmo aiutarti con i tuoi problemi con Python?
Cipher

@Cipher grazie, ho aperto un problema sul github github.com/redevined/brainfuck/issues/2
weston,

@Sylwester Uso la maggior parte dei robot ora poiché il mio generatore è molto più veloce e multithread.
Weston,

4

Giocatore

Questo è strettamente correlato al mio bot Geronimo. Ma dove Geronimo sta giocando una cosa certa, il giocatore d'azzardo cerca di essere più veloce facendo quello che fa meglio: il gioco d'azzardo: va alla 20a cella e inizia a zero da lì.

Ciò significa che potrebbe facilmente perdere solo perché l'arena non è così grande. Ma se lo è, potrebbero essere i pochi cicli che contano.

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

Curiosità: stavo davvero prendendo in considerazione l'idea di inserire un gruppo di robot che sembrano tutti (>)*X(>[-])*Ydove X in 9..29e dove Y = 30 - X. Ma penso che inserire venti robot sarebbe un po 'troppo :) O addirittura quaranta se avessi due versioni, una con zero-s [+]e una che lo fa [-].


Un numero come 13 o 14 non ti darebbe percentuali di vincita migliori di 20?
Moop,

Sì forse. Voglio solo per il mezzo. È interessante notare che se vado a sinistra anziché a destra, le mie possibilità di vincita diminuiscono di molto. Mi sarei aspettato il contrario.
Ingo Bürk,

Dal momento che ogni combatte bot partite quindi contro qualsiasi altra bot, anche il 40 di coloro che non sarebbe sollevare le probabilità che molto - e ho avuto un momento difficile di copiare e incollare: D
Cipher

4

Dumbot

Un bot straordinariamente stupido che fa solo confusione con l'ambiente e spera che i robot che combatte vadano via dal nastro.

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

(Non sono sicuro che funzioni, anche se non sbaglia!)

Annotato (con quello che penso che faccia):

(+)*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.

(Sarò sconcertato se questo vince una sola battaglia)


1
la tua seconda riga azzererà effettivamente la cella per addizione e quindi sottrarrà una sette volte di seguito.
orgoglioso haskeller il

1
@proudhaskeller Hai ragione ... Questo è quello che ottengo cercando di fare cose Brainfuck con poco sonno. Ho appena reso più semplice invece di capire come farlo correttamente.
Sellyme,

4

CropCircleBot

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

Questo Bot utilizza algoritmi avanzati che sono stati trasmessi dagli alieni attraverso i cerchi nel grano che hanno posizionato sulla terra. Cambierà l'umanità e fornirà enormi progressi tecnologici e persino risolverà molti problemi ambientali.


Sai che non dovresti mai usare] [, giusto?
CalcolatriceFeline

Non posso, puoi spiegare perché?
Flawr

Quando lasci un ciclo, la cella corrente è 0. Quindi, salti il ​​ciclo successivo perché la cella sul puntatore è ancora 0.
CalculatorFeline

Oh, ho sempre pensato che il controllo avvenga alla fine del ciclo?
flawr

Si verifica anche all'inizio. In alcune implementazioni, [non fa nulla, ma è un linguaggio completamente diverso (newbiefuck sul wiki di esolang)
CalculatorFeline

4

BeatYouMate

E poiché tutti dovrebbero pubblicare un bot che batterà il primo bot che pubblicano, ecco un bot di posa 5+ esca:

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

4

CleverAndDetermined

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

Imposta alcune piccole trappole, quindi corre dall'altra parte e cerca di cancellare tutto, sopra o sotto lo zero. Non funziona ----.


+++prima [-]è davvero intelligente per evitare semplici trappole!
Ingo Bürk,

Ha generato un'eccezione a causa di un impareggiabile (, posso trattarlo come un commento?
Cipher

@Cipher Lo aggiusterò, scusa.
isaacg,

4

MetaJSRandomBot

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

L'idea alla base di questo bot sta facendo qualcosa di totalmente casuale che è ancora un codice js valido senza troppa inutilità. Ho scritto il seguente codice ( link JSFiddle ) per generarlo. Vediamo quanto bene =)

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);

4

Roulette Prussiana

La roulette russa ha fatto una scommessa con il suo amico prussiano, e ora è il suo turno di giocare.

>(+)*5(-.[>.[>(-)*10]]>>)*1000

Hai 2 decrementi di puntatore e solo 1 incremento nel tuo ciclo principale - questo ti farà saltare fuori dalla tua fine del nastro.
Comintern,

2
Questo si eliminerà comunque.
orgoglioso haskeller il

All'inizio hai un vantaggio seguito da un meno. 2 cicli sprecati.
Weston,

4

Più grande

La corsa agli armamenti inizia !!

Costruisce e distrugge muri di altezza 16 18, più grandi della maggior parte dei concorrenti. Ha anche una piccola logica per battere il cloaker, i difensori della bandiera, gli anti-alternatori e i robot che assumono una bandiera intatta

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

Versione annotata

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

3

PatientBot

Un bot in parte serio. questo bot tenterà di vincere entro il limite di 100000 cicli. andrà alla bandiera nemica mettendo alcune trappole sulla strada, diminuendola un po ', torna indietro e difendi la bandiera.

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

supporrà che tutto sia maggiore di 1 o minore di -1 sia la bandiera e quando ne incontrerà uno, tornerà indietro. si difende semplicemente incrementando costantemente. questo presuppone che la maggior parte dei programmi utilizzerà [] per verificare se il flag è diventato 0, quindi (+) * 100000 sarà molto più veloce

Modifica: impossibile farlo funzionare sull'interprete BF Joust. mi sto arrendendo. forse dovresti dirmi come migliorare il mio codice.

Modifica: ora il bot si posiziona appena prima del flag 2, e dopo aver diminuito un po 'il flag, cerca un 2. questo ha lo scopo di annullare lo scenario in cui il bot troverebbe una cella 0 diversa da quella prima del bandiera.


Il tuo bot sembra uccidersi su un nastro (abbastanza raro, lo ammetto) con lunghezza 10 poiché all'inizio ci sono 10 '>'. A parte questo, [<]non è una buona idea, poiché si ripete fino a quando la cella sotto il puntatore è uguale a zero , che è una delle celle davanti alla tua bandiera o semplicemente si suicida se il tuo puntatore raggiunge la bandiera (dal momento che la tua bandiera si spera non sia zero ).
Cipher

@Cipher Notare che il bot non mette una trappola nel posto proprio davanti alla bandiera - la mia idea era quella di segnare questo punto in modo che il bot costruisse la sua difesa lì. C'è un modo migliore? A volte, il nemico a volte cancella le trappole e poi il robot si ferma prima che dovrebbe.
orgoglioso haskeller il
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.