BrainF *** edBotsForBattling - Ein Brainf *** -Turnier

88

Alle Bots in der Kampfarena wurden plötzlich überlistet und niemand kann erklären, warum. Aber wen interessiert es, solange sie noch kämpfen können - obwohl Brainfuck die einzige Sprache ist, die sie noch verstehen.


Es ist schon eine Weile her, dass ich den Gewinner von BrainFuckedBotsForBattling bekannt gebe: Herzlichen Glückwunsch an LymiaAluysia, die mit NyurokiMagicalFantasy gewonnen hat!


Anzeigetafel

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

Endgültige Ergebnisse vom 09.10.2014

EDIT6 : Verworfene Protokolle aufgrund extremer Größe und Laufzeit. Sie können sie selbst generieren, indem Sie die Zeilen in auskommentieren RunThisTournament.py.

EDIT5 : Abkürzungsbehandlung im Controller implementiert, keine großen Laufzeiten mehr. Dies hat den Nebeneffekt, dass Zahlen und Klammern nicht mehr als Kommentare behandelt werden. Sie können sie weiterhin verwenden, wenn Sie eine kommentierte Version bereitstellen möchten. Es wäre jedoch sehr hilfreich, wenn auch eine unkommentierte Version Ihres Codes vorhanden wäre , sodass ich die Kommentare nicht manuell entfernen muss. Vielen Dank!

EDIT4 : Der Titel wurde geändert, da das Turnier von den aktuellen Netzwerkfragen entfernt wurde. Vielen Dank an @Geobits für den Hinweis!

BEARBEITEN3 : Kommentare in bf-Programmen, die aufgrund eines unerwarteten Ergebnisses entfernt wurden, sollten jetzt behoben werden. Wenn jemand ein Problem mit dem Entfernen seiner Kommentare hat, melden Sie dies bitte.

EDIT2 : Da es auf meinem ziemlich langsamen Computer zu einer arkanen Laufzeit kam, habe ich das Zeitlimit von 100000 Zyklen auf 10000 Zyklen gesenkt. Nicht, dass irgendjemand das Ergebnis eines laufenden Spiels über diesen Punkt hinaus gedreht hätte.

EDIT1 : Ein Fehler im Konvertierungsskript wurde behoben, der dazu führte, dass der Interpreter Zahlen in kommentierten Programmen nicht ignorierte.


Beschreibung

Dies ist ein Brainfuck- Turnier, das von BF Joust inspiriert wurde . Zwei Bots (Brainfuck-Programme) kämpfen in einer Arena, die durch ein Memory-Tape dargestellt wird, gegeneinander. Jede Zelle kann Werte von -127 bis 128 enthalten und an ihren Grenzen umbrechen (also 128 + 1 = -127).

Gültige Anweisungen sind ähnlich wie beim regulären Brainfuck. Das bedeutet:

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

Die Arena hat eine Größe von 10 bis 30 Zellen, die pseudozufällig für jede Schlacht ausgewählt werden. An beiden Enden befindet sich ein "Flag", das einen Anfangswert von 128 hat, während alle anderen Zellen auf Null gesetzt werden. Das Ziel Ihres Bots ist es, die feindliche Flagge für 2 aufeinanderfolgende Zyklen auf Null zu setzen, bevor er Ihre eigene Flagge auf Null setzt.

Jeder Bot startet bei seiner eigenen Flagge, die aus seiner eigenen Perspektive Zelle [0] ist. Der Gegner befindet sich auf der anderen Seite des Bandes.

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

Beide Bots führen ihre Aktion gleichzeitig aus, dies wird als ein Zyklus angesehen. Das Spiel endet nach 10000 Zyklen oder sobald eine der Gewinnbedingungen erreicht ist. Wenn eines der Programme sein Ende erreicht, hört es einfach auf, bis zum Ende des Spiels etwas zu tun, kann aber trotzdem gewinnen.


Gewinnbedingungen

Ihr Bot gewinnt unter einer der folgenden Bedingungen:

  • Die Flagge deines Feindes wird vor deiner genullt
  • Ihr Feind bewegt seinen Zeiger aus dem Band (wird >auf Ihre Flagge oder <auf eigene Faust ausgeführt)
  • Der Wert Ihrer Flagge ist nach 10000 Zyklen weiter von 0 entfernt als der Wert der Flagge Ihres Gegners

Regeln

Ihr Beitrag sollte einen Namen für Ihren Bot und dessen Code enthalten.

  • Sie können die folgende Abkürzungssyntax verwenden, um den Code besser lesbar zu machen:
    • ZB (+)*4ist das Gleiche wie ++++, dies gilt für alle Befehle mit Ausnahme nicht übereinstimmender Klammern in Klammern, da die Schleifenlogik mit der Abkürzungslogik kollidiert. Bitte verwenden Sie [-[-[-statt([-)*3
  • Jedes andere Zeichen als +-><[].ist ein Kommentar und wird daher mit Ausnahme der ()*Abkürzungen ignoriert

Bots, die sich nicht an die Regeln halten, werden vom Turnier ausgeschlossen.

  • Es ist nur einfaches Brainfuck erlaubt, keine anderen Varianten, die Prozeduren oder arithmetische Operationen unterstützen
  • Der Quellcode Ihres Bots sollte keine unvergleichlichen Klammern enthalten

Sie können sich darüber informieren , grundlegende Strategien aber nicht eines anderen eigenen Code für Ihre eigenen Bot verwenden.


Wertung

Die Punktzahl eines Bots wird durch die Anzahl der Siege gegen alle anderen Bots bestimmt. Eine Begegnung zwischen 2 Bots besteht aus 10 Übereinstimmungen mit unterschiedlichen Längen des Speicherbands, was eine maximale Punktzahl von 10 Punkten pro Begegnung ergibt. Ein Unentschieden bringt für dieses Spiel keine Punkte.


Steuerungsprogramm

Sie finden das Steuerungsprogramm auf Github, zusammen mit den vollständigen Protokollen der Kämpfe. Die Rangliste wird hier veröffentlicht, sobald sie erstellt wurde.

Fühlen Sie sich frei, das Repository zu klonen und Ihren Bot auf eigene Faust gegen die anderen auszutesten. Verwenden Sie python Arena.py yourbot.bf otherbot.bf, um ein Match auszuführen. Sie können die Bedingungen mit den Befehlszeilenflags -mund ändern -t. Wenn Ihr Terminal keine ANSI-Escape-Sequenzen unterstützt, --no-colordeaktivieren Sie die farbige Ausgabe mit dem Flag.


Beispiel Bots

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

Der DecoyBot gewinnt jedes Match mit einer Bandlänge von mehr als zehn, da der FastClearBot die kleinen, aber nicht die größeren Köder meiden kann. Die einzige Situation, in der der FastClearBot gegen DecoyBot gewinnen kann, ist, wenn er schnell genug ist, um die feindliche Flagge zu erreichen, bevor sein Gegner große Köder aufgebaut hat.

Chiffre
quelle
5
Original gefällt mir. Ich habe nur Angst, dass dies nicht genug strategische Tiefe zulässt, aber das könnte nur ich sein.
ɐɔı14uʇǝɥʇs
11
Mit Befunge würde das noch mehr Spaß machen .
IchBinKeinBaum
6
Ich habe eine BF Jousting- Webseite gefunden, auf der sich Jousting- Matches anzeigen lassen.
PhiNotPi
4
Vielen Dank für das Hosting von KOTH, Cipher. Muss eine Menge Arbeit mit so vielen Einsendungen sein.
AndoDaan
3
Ich möchte mich lieber bei allen für die Teilnahme bedanken ^^
Cipher

Antworten:

18

Nyuroki Magische Fantasie

Ich denke, es ist an der Zeit, ernst zu werden ~ Ich habe meinen Compiler für eine kleine HLL fertiggestellt, um das Schreiben von BF Joust-Programmen zu vereinfachen. Dies war mein erster ernsthafter Versuch, etwas daraus zu machen. Das Konzept des Bots ist ziemlich einfach. Es setzt ein paar Lockvögel unterschiedlicher Polarität auf, dann wird es verrückt mit einem großen Wackelspiel und einem umgekehrten Versatz in der Mitte.

Oh, übrigens, die erwartete Punktzahl beträgt ungefähr 577 Punkte gegenüber dem Hügel der letzten Runde. Das ist eine Gewinnquote von 93%. <3

Kompiliert | Quellcode

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

Edit : Ich habe ein paar Siege mehr aus Nyuroki gequetscht.

Edit 2 : Hey, schau, ich habe es wieder getan!

Edit 3 : Nachdem ich eine Weile mit einem dummen Parsing-Bug in Arena.py gerungen habe, habe ich endlich eine weitere Verbesserung in ~ Dies ist, was ich unter "Zeit zum Ernst werden" verstehe. <3

Lymia Aluysia
quelle
Scheint, als müsste Loke etwas umstellen :-) Ich liebe deine Sprache. War der Fehler in Arena.py, dass Sie Leerzeichen zwischen )und *oder zwischen *und Nummer hatten?
Sylwester
@ Sylwester Viel schlimmer. Loops gehen, wohin sie nicht gehen sollten: github.com/redevined/brainfuck/pull/6
Lymia Aluysia
Herzlichen Glückwunsch zu # 1. Die Gewinnquote von 92,5% wird schwer zu übertreffen sein.
Sylwester
Gut gemacht, aber ist das nicht Missbrauch? Die verschachtelten Schleifen sind effektiv 21 Fakultäten = 5 * 10 ^ 19. Mit anderen Worten, es ist praktisch nicht zu einem einfachen Brainfuck zu erweitern.
Weston
1
@weston Ja. Und die meisten Programme auf dem am weitesten entwickelten BF Joust Hill ( codu.org/eso/bfjoust/in_egobot - schauen Sie sich zum Beispiel smartlock an) sind noch schlimmer. Es ist keine besonders große Sache, da dies eine Art Abkürzung ist. Es macht Strategien, die ansonsten aufgrund ihrer Länge unrentabel wären, realisierbar. :)
Lymia Aluysia
43

Tarngerät Bot

Dieser Bot versucht im Grunde, seine Basis zu verbergen, so dass andere Bots direkt daran vorbei und vom Band entfernt werden.

(-)*127(-+--+-++)*12500
PhiNotPi
quelle
4
Sehr klug, musste meinen Bot anpassen, um dies zu berücksichtigen.
Moop
2
Dies ist meiner Meinung nach eine der klügsten hier.
Almo
+ f für den ersten Umhang. Das habe ich vorher nicht bemerkt, nachdem ich Ràn gemacht habe, aber es ist eine ähnliche Idee, eine andere Anwendung.
Sylwester
19

Burly Balder v3

Burly Balder ist ein mittelschwerer, langsamer Ansturm. Es macht zwei große Lockvögel, bevor es in den Rush-Modus geht. Im Rush-Modus hat es eine Schleife, die nur 4 Schritte pro Null-Zelle verwendet, und wenn es sich um eine Nicht-Null-Zelle handelt, hat es eine Fallanalyse für [-18,18], bevor es blind mit 107 reduziert, bevor es mit gelöscht wird [-.]. Er setzt in 242 Schritten eine unveränderte Flagge frei, 114 mehr als eine unsichere -*128 und 14 weniger als eine naive [-]. Wenn eine Zelle geräumt ist, hinterlässt er weiterhin eine Spur von -2 Ködern. Er hat einen Sonderfall nur für Index 9, um einige Schritte für Spiele der Größe 10 zu speichern, und es verlässt die Zelle mit einem Lockvogel.

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

Wissenswertes: Balder ist ein nordischer Gott und Sohn von Odin. Er ist vor allem für die Geschichte seines Todes bekannt : Er hatte Angst um seine Sicherheit, also versuchten die anderen Götter, jede Bedrohung vorherzusagen und abzuwehren. Er wurde schließlich von Loki getötet, da sie vergaßen, ihn vor Mistelzweigen zu schützen, während sie ihn vor Schwertern und Pfeilen schützten.

Sylwester
quelle
2
Ihre Lockvögel bringen mich um. Gut gemacht.
AndoDaan
1
@AndoDaan Danke. Du BeatYouMatewarst schlau. Ich befürchte, dass die Lockvögel der meisten Bots in der nächsten Runde noch größer werden, bis sie eine Strafe erhalten. Dann werden vielleicht noch weitere coole Strategien auftauchen :)
Sylwester
2
Das Problem bei der Vergrößerung des Lockvogels besteht darin, dass die Leistung bei kürzeren Bändern gegen schnelle Angriffs-Bots abgewogen wird. Mit 10 zufälligen Runden ist es wahrscheinlicher, dass sich ein Sweet Spot ändert, abhängig davon, wie schnell die anderen Einträge angreifen.
Komintern
2
Ja, du bist immer noch derjenige, den du schlagen musst.
AndoDaan
4
@AndoDaan Mit so vielen nordischen Göttern, die mich unterstützen, scheinen die zufälligen Arena-Größen zu meinen Gunsten zu sein :-)
Sylwester
13

EvoBot 1

Dies ist ein einfacher Bot, der über einen genetischen Algorithmus erstellt wurde. Ich begann mit einer Vorlage und mein Programm passte die Zahlen langsam an, um einen besseren Krieger-Bot zu erstellen. Der folgende Code wurde bearbeitet, um die Lesbarkeit zu verbessern.

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

Die anderen Wettbewerbsbeiträge habe ich genutzt, um die Fitness der verschiedenen Kandidaten zu messen.

Da dies mein erster Versuch mit einem Evobot war, begann ich mit einer einfachen Vorlage:

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

Ich gehe davon aus, dass dieser Bot eine Punktzahl im Bereich von 50 bis 60 Jahren erhalten wird.

Ich arbeite gerade an einer Reverse-Decoy-Vorlage.

EvoBot 2

Dies ist ein Bot, der mit demselben genetischen Algorithmus erstellt wurde, jedoch mit der folgenden Vorlage:

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

Dieser Bot verwendet die Reverse-Decoy-Strategie, um 4 Lockvögel unterschiedlicher Höhe einzustellen. Der resultierende Bot ist:

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

Ich erwarte, dass dieser neue Bot besser abschneidet als die vorherigen Bots und möglicherweise in den 70er Jahren ein Ergebnis erzielt (wahrscheinlich viel höher, da es viele neue Einträge gibt).

PhiNotPi
quelle
2
+1 für genetische Algorithmen. Ich habe großes Vertrauen in sie. Ich hoffe, Ihre Bots machen es gut.
AndoDaan
12

Generator

Es wird davon ausgegangen, dass die meisten Benutzer eine Zelle auf Null setzen, indem sie diese entweder addieren oder subtrahieren. Im Durchschnitt dauert es also für jede Zelle 128 Runden bis Null.

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

Kommentierte Version

(>+>-)*4       Move eight squares alternating polarity    
>+             Move one more
(
    >          Move to the next square
    [-]        Zero it
    [.]        Wait while it is zero
)*21           Repeat
Moop
quelle
Verdammt, Ihre letzten Änderungen verbessern die Gewinnrate für Alternator gegen Geronimo von ~ 60% auf ~ 90%. Nett.
Ingo Bürk
Ja, ich bewegte mich 18 Mal, als ich (> +> -) * 9 tat, damit es vom Band fiel. Dummer Fehler.
Moop
Selbst wenn ich Geronimo schütze, indem ich abwechselnd Null addiere / subtrahiere, ändert das nichts an meiner Gewinnrate. Die Lichtmaschine könnte hier als Sieger hervorgehen - mit wenigen Handgriffen wird eine ziemlich schwer zu knackende Falle aufgestellt.
Ingo Bürk
Hey, korrigiere mich, wenn ich falsch liege, aber entfernt sich dieser Bot nicht automatisch von der Tafel, wenn die Tafel 10 lang ist? Es bewegt sich 10 Felder vor dem Versuch, etwas auf Null zu setzen.
Ein Boschman
11

Also, jemand anderes hier benutzt einen genetischen Algorithmus, um hier Programme zu erstellen. Nun ... vor langer Zeit habe ich einen BF-Joust-Evolver für einen laufenden Hügel in einem IRC-Kanal geschrieben. Ich habe beschlossen, es auch für diesen Wettbewerb zu versuchen ~

Und ... im Gegensatz zu der anderen Person mit einem Evolver kann mein Evolver tatsächlich mehr vom Programm ändern als die Anzahl der Wiederholungen. :)

NestDarwin (Generation 309)

Dies ist das beste Ergebnis, das mein Evolver bisher erzielt hat. Ich bin mir nicht sicher, wie sehr die verschachtelte Struktur in diesem Fall hilft, aber Strukturen wie diese sollten vom Evolver unterstützt werden. Die erwartete Leistung am 27.08.2014 beträgt 474 Punkte. (Berechnet durch Ausführen des Kampfes auf allen 21 Bandlängen und Multiplizieren mit 10/21. Beachten Sie, dass dies nicht normalisiert ist, da auf diesem Hügel ein zusätzliches Programm vorhanden ist.)

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

EDIT : Geänderte Liste der Programme, die ich in diesen Hügel eingeben möchte. Über Nacht lief Evolver. :)


EDIT 2 : Ich habe die Ausgabe des Evolvers manuell analysiert. Obwohl NestDarwin sehr unterschiedlich aussieht, ist es im Grunde eine optimierte Version von TinyDarwin ... Manuell minimiert (mit identischer Funktionalität) und analysiert:

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

Also, ein fast identisches Programm wäre wie folgt ... das ist im Grunde eine super optimierte Version von TinyDarwin.

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

TinyDarwin war wie folgt. Nicht sehr verschieden, hun? Ich ziehe es einfach vom Hügel zurück. Ich dachte, es sei eindeutig, aber ... nun, ich habe mich geirrt.

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

Es hat sich gezeigt, dass der aktuelle Hügel nicht stark genug ist, um komplexere Dinge zu entwickeln. :(

Lymia Aluysia
quelle
1
Herzlichen Glückwunsch zum ersten Platz. Kann das genetische Algo-Programm Ihre aktuelle Version als Vorlage verwenden und mit den neuen Versionen fortfahren, um sie noch weiter zu verbessern?
Sylwester
Tolle Arbeit mit dem ersten Platz. Ich bin so froh, dass ein genetischer Algorithmus (na ja, sein Spawn) es geschafft hat!
AndoDaan
Wenn wir nun die Ergebnisse aller Spiele nutzen, uns weiterentwickeln, maschinelles Lernen hinzufügen könnten ... dann hätten wir erbärmlichen Menschen keine Chance mehr: P
Sp3000 30.08.14
@ Sylwester Art von? Meine interne Repräsentation verwendet ein (schlecht durchdachtes) Genaktivierungssystem, mit dem sich der Überbau entwickeln soll (und in der Praxis nicht wirklich). Ich kann das endgültige Programm nicht zurücksetzen und die interne Repräsentation wiederherstellen, aber ich kann die Anweisungen in ein einzelnes Gen einfügen und es weiterentwickeln lassen (wie viel das auch helfen würde).
Lymia Aluysia
@ Sp3000 Leider kann mein Algorithmus auf dem gut ausgebauten #esoteric hill kaum Fortschritte machen. Es wäre schön, wenn ich so etwas tun könnte, aber leider sind meine Fähigkeiten in genetischen Algorithmen einfach nicht gut genug. Ich werde wahrscheinlich irgendwann meinen Evolver freigeben, wenn ich alle meine hässlichen Hacks aufgeräumt habe.
Lymia Aluysia
10

Eisbär Mk II

Es gibt zwei Arten von Eisbären : diejenigen, die gefangen werden, und diejenigen, die andere Menschen fangen.

Versucht, die Polarität des Gegners zu erraten und verwendet diese Informationen, um den Gegner in eine Endlosschleife zu locken. Funktioniert gut gegen einfache Clearing-Strategien und etwas zufällig gegen andere. Überfüllungen können leicht vermieden werden, so dass ich später einige Sicherungsstrategien hinzufügen kann.

>++>- 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
quelle
Sie können die Codegröße mit halbieren (]< (+)*290 (>)*9 ... [-])*2?
Sylwester
@ Sylwester Ich kann nicht, weil die andere Hälfte verwendet +und die andere verwendet -.
Mika Lammi
Eisbär macht sich nicht besonders gut mit versetzten
Löschungen
@ Sp3000 Bist du sicher? Ich habe versucht , mit mehreren Versetzungen und Polaritäten (wie [(+)*3[-]], [(-)*6[+]]) und es funktioniert super (zumindest für ganz kleine Offsets).
Mika Lammi
Oh, ich weiß, was los ist: / Ich habe versucht, Programme wie >>>>>>>>>((-)*4[+][--.]>)*21das zu testen, die die Zelle doppelt überprüfen, und Sie haben (+/-)*290die zweite Off-Sync-Schleife ausgelöst. Nicht der Fehler des Offset-Clear.
Sp3000
10

Pazifistischer Bot

Mein Bot glaubt, dass Gewalt niemals die Antwort ist und wird versuchen, Kämpfe um jeden Preis zu vermeiden.

(.)*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
quelle
8
Ich habe mir erlaubt, die in Ihren Kommentaren enthaltenen. Zu entfernen, da sie als Brainfuck-Code gelten und Ihren Bot ein wenig langsamer als nötig machen würden. Wenn die Punkte absichtlich sind, zögern Sie nicht, mich zu korrigieren!
Chiffre
Oh
ja,
9

Jemand da?

Schaut regelmäßig nach hinten, um festzustellen, wann der Feind damit begonnen hat, seine Köder zu räumen, und eilt dann voran.

Scheint gut zu sein, aber ich bin mir nicht sicher, ob das an der Strategie liegt oder nur daran, dass ich vor dem Löschen jeder Zelle 10 hinzufüge.

Bearbeiten: Ein Logikproblem wurde behoben. Zum ersten Mal ein Brainfuck-Programm schreiben. Es macht seinem Namen alle Ehre.

>>>+<(+)*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
quelle
+1: Dies ist der erste Bot, den ich gesehen habe, der Täuschkörper (mit Ausnahme von +/- 1) über die ersten 9 Zellen hinaus streicht. Bei längeren Bändern ist das ein Killer. Lightfoot Plodder jetzt
nachrüsten
9

WAND-E 2.0

Rennt zu Position 9 und fügt 128 hinzu. Gewinnt schnell in der Arena der Größe 10, wenn der Gegner den anfänglichen Flaggenwert nicht geändert hat. Auf größeren Arenen funktioniert dies als großer Köder. Danach füllt es den Raum zwischen Position 9 und eigener Flagge mit großen Ködern. Wenn Lockvögel platziert werden, wird nach nicht leeren Stellen gesucht und versucht, diese schnell zu löschen.

Version 2.0 baut größere Täuschkörper und hat eine gewisse Toleranz gegen das Ändern des anfänglichen Flag-Werts. Es kann auch zu einer Backup-Strategie wechseln, wenn die Dinge haarig aussehen.

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

Die Wirksamkeit dieses Bots basiert auf zwei Fakten:

  1. Die meisten Bots ändern den Anfangswert ihrer Flagge nicht.
  2. Das Erstellen großer Lockvögel geht schneller als das Löschen.
Mika Lammi
quelle
Diese Mauern bringen mich um
Sp3000
9

Lethal Loke V2.1 (mit Mistel)

Dies ist natürlich ein tödlicher Bot und er tötet nicht nur den schönen Burly Balder a mit Mistel, sondern gewinnt fast jedes Mal auch gegen die anderen Bots. Es ist ein kombinierter mittlerer und schneller Ansturm. Mein Test gibt mir eine Punktzahl von 567

Kompilierte BFJ-Datei für den Kampf , Racket BFJ-Generator Quelle:

#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) ist ein Gott in der nordischen Mythologie, der gerne mit allen spielt und sie austrickst. Er ist ein Gestaltwandler (in Tiere und Menschen) und geht normalerweise seine eigenen Wege. In den Geschichten reist er oft mit und hilft den anderen Göttern und macht kleine Tricks und rührt Dinge auf. Er hat nicht nur Balder getötet, sondern auch Hel (Göttin der Hölle / Helvete), das Biest Fenrir und die Midgard-Schlange gezeugt, die Ragnarok (Nordisches Armageddon) startet.

Wie es funktioniert

Zu Beginn macht er einen großen (-17) Lockvogel und dann ein +-Muster bis zum Index 7. Er tastet vorwärts von bis 13 ab und hinterlässt eine Spur von (+ 10, -32) + Lockvögeln, aber wenn er einen Satz erkennt, bricht er ab und starte einen mittleren * 1 Rush-Modus. Wenn keine Zellen gesetzt sind, startet er auch den langsamen * 3 Rush-Modus.

* 1 Im Modus "Mittlerer Ansturm" hat er die Aktivität eines Gegners in einem der Indizes 7-13 erkannt und startet bei Index 2. Einige Gegner hinterlassen eine Null und andere einen anderen Wert. Er hat nun die Möglichkeit, die Aktivität eines Gegners zu erkennen, bevor er Lockvögel macht Index 2-6 (-32, + 10) +. Wenn die Zelle nicht den erwarteten Wert (-1, 1) hat oder alle Täuschungsmanöver beendet sind, wechselt er in den schnellen * 2-Rush-Modus.

* 2 Der Fast-Rush-Modus, von dem er vermutet, dass er erkannt wurde, sodass Köder nicht funktionieren. Wir hoffen, dass diejenigen, die wir bereits festgelegt haben, den Gegner stoppen und sich darauf konzentrieren, durch die Köder des Gegners zu rennen. Er beginnt an dem weitesten Punkt zu eilen, den wir aufgrund des vorherigen Scans [9,14] oder Index 9 kennen, wenn wir früher gemacht wurden. Er hat einen Sonderfall für den ersten Lockvogel, bei dem wir nur 120 addieren und 27 plotten, da er den Wert nicht unter Null reduzieren möchte, falls es sich um eine Falle handelt, aber für jeden Lockvogel, nachdem wir bei [-8,8] wackeln, bevor wir um erhöhen 120 und 27 Schritte vorwärts zur nächsten Zelle.

Der Slow Rush-Modus wurde entfernt, da er sich nicht auf die Punktzahl des aktuellen Hügels auswirkte und meinen Bot ein wenig kleiner (aber nicht sehr) macht.

Sylwester
quelle
3
Jetzt fangen wir an, Wahnsinn zu sehen. Ich mag das.
Sp3000
@ Sp3000 YandereBotv2 war der Grund, warum ich neu denken musste, abgesehen davon, dass ich nur die Lockvögel und Swing-Werte erhöhte. Es hatte ein höheres Gewinn-Perzentil gegen die Hürde als alle Bots der letzten Runde, so dass Sie mit Arena-Größen einfach Pech hatten.
Sylwester
Ahaha vielleicht - ich glaube , ich brauche einen Gegenplan gegen die ständig steigenden Köder Größen: / Ich mag wirklich , wie man verschiedene Modi haben allerdings
SP3000
Seufzer . Ich muss dafür sorgen, dass mein HLL für BF Joust besser funktioniert, damit mein Evolver wieder eine Chance hat. Herzlichen Glückwunsch zu # 1 ~
Lymia Aluysia
@ LymiaAluysia Vielen Dank. Ich war mehr von Balder überrascht. Ich zähle auf eine neue Version von NestDarwin, YandereBot und Mickey :-)
Sylwester
8

Geronimo

Ist noch offensiver als Kaines BestOffense-Bot, da er keine Verteidigung aufbaut. Die Strategie hier lautet: Andere werden versuchen, klug zu sein, aber klug zu sein braucht Zyklen. Kommen wir also zu dem Teil, in dem sich der Feind befindet, und klären Sie alles, was wir finden.

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

Scheint die meisten Matches gegen die Beispielbots des OP und Kaines Bot zu gewinnen.

Ingo Bürk
quelle
7

SternBot

Ein wirklicher halb ernster Bot, jetzt wo die Dinge angefangen haben. Behandlung der Ähnlichkeit einiger dieser Bots.

(>->+>)*3(>[+]>[-])*21
kaine
quelle
1
SternBot gibt mir Paritätsprobleme :(
Sp3000
7

DoNothingBot

Die beste Verteidigung (...) ist Unwissenheit.

.

Es macht nichts.

EDIT: Wow, ich war erstaunt zu sehen, dass es einen besseren Job gemacht hat als die mindestens 20% aller Bots =) (Bedeutet das, dass es eine überlegene Strategie verwendet oder ....?)

Fehler
quelle
2
Einige der anderen Bots begehen auf kleinen Arenen Selbstmord. z.B. Der Spieler geht direkt in die 20. Zelle und für Spiele mit 10-19 verliert er sogar gegenDoNothingBot
Sylwester
2
Aus Neugier durchlief ich meinen Tester (spielt alle Bandlängen ab) gegen die anderen Einträge. Siehe, die Mauer der Schande ... +1
Komintern
Haha, danke fürs Teilen - ich hatte erwartet, dass es ein oder zwei schwarze Schafe geben könnte, aber ich hatte nicht erwartet, dass es so viele Bots "besiegt" =)
fehlerhaft
7

CounterPunch - Bearbeitet

Ausgewogene Kombination aus Aufbau einer starken Verteidigung und anschließendem Angriff.

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

Kommentiert:

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

Verteidigt sich ähnlich wie @ Geobits Backtracker , aber verteidigt sich gegen schnelle Angreifer, indem zuerst ein schneller Köder vor die Flagge gesetzt wird.

Attack ist verschachteltes Löschen mit entgegengesetzter Polarität, um Lockvögel mit kleineren Werten schnell zu beseitigen. Das schlimmste Szenario sollte ein Lockvogel von 64 sein (beide Polaritäten).

Edit 1: Verbessert die Angriffseffizienz gegen Täuschkörper (hatte einen logischen Fehler bei der Polaritätsumschaltung).

Edit 2: Das Testen zeigt an, dass die Pause in der innersten Schleife etwas besser funktioniert.

Komintern
quelle
6

Backtracker

Eine Reverse-Decoy-Strategie. Legen Sie Lockvögel von vorne nach hinten ab, damit niemand den Rest überspringt, während ich sie baue.

Wenn das Board weniger als 20 oder so groß ist, funktioniert dies nicht bei Fast-Attack-Bots, da wir uns nur überholen, bevor ich anfange zu täuschen.

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

Hinweis: Ich bin kein BF, aber so macht es mir was ich will. Wenn nicht, bitte lassen Sie mich jetzt.

Geobits
quelle
6

Kann das nicht berühren

Dies ist ein verteidigungsorientiertes Programm, mit dem versucht wird, festzustellen, wie der Gegner Zellen räumt, und ein Lockvogel mit der entsprechenden Größe erstellt wird.

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

Ich arbeite derzeit an einer Version, die gegen beide Polaritäten gewinnen kann.

PhiNotPi
quelle
6

Ungeduldiger Tripwire (aka YandereBot)

Versucht, ein Stolperdraht zu sein, damit er (meistens) mit der entsprechenden Polarität Täuschungsmanöver auslöst, gibt jedoch auf, wenn Sie zu lange brauchen, und geht davon aus, dass Sie die entgegengesetzte Parität haben. Hat einen umgekehrten Tripwire für kleine Boards.

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

Aktuelle Version: 1.3 - Bessere Leistung auf kleineren Brettern auf Kosten von Spielverlusten aufgrund von Feinden, die sich während der Tripwire-Überprüfung vorbeischleichen

Frühere Versionen: 1.2.1

(Ich brauche einen klareren Algorithmus: /)

Sp3000
quelle
1
OMG 411k vollständig erweitert und entfernt: -O Chipers Code hängt nur daran.
Sylwester
Ich habe nur
Seit der letzten Bearbeitung verhalten sich nicht übereinstimmende Klammern in Klammern seltsam, da die Schleifenlogik mit der Abkürzungslogik kollidiert. Kann ich Konstrukte wie ([)*300zurück zu ändern [[[ and so on?
Chiffre
@Cipher Ja, mach schon - obwohl die Pastebin-Version genau das sein sollte
Sp3000
1
3. ist ein schöner Ort, um hereinzukommen. Gut gemacht.
AndoDaan
5

Lightfoot Plodder - BEARBEITET

Basierend auf dem Plodder kann dieser schnelle Koloss schnell durch aufeinanderfolgende Nullen " vorspulen" , bis er einen Wert ungleich Null erreicht (an diesem Punkt beginnt er wie erwartet mit dem Trotten).

Verbessert mit einem robusteren Skimming-Algorithmus, der auch das schnelle Vorwärtsspulen durch kleine und größere Täuschkörper ermöglicht.

Edit # 2 : Kann jetzt wieder zum Überfliegen zurückkehren, wenn mehr Nullentaschen gefunden werden.

>(-)*4
>(-)*7
>(-)*4
>(+)*7
>(-)*17
>(+)*3
> -
>(-)*10
>(+)*16[-]<-
([
[>>
 [+
  [--
   [+++
    [<+>(+)*14[-]]
   ]
  ]
 ]<-
]>>
[(+)*126(+.)*4>]
<]+)*10
DLosc
quelle
Schöne "bequeme" Größenänderung dort :)
Lily Chung
@IstvanChung Sehr praktisch. ;) Mehr hätte mich zu sehr gebremst und Punkte an mehrere andere Bots verloren. Wenn Sie Bigger größer machen würden, würde ich nicht versuchen, Schritt zu halten.
DLosc
Nun, ich habe die Größe ein wenig vergrößert, um zu sehen, wie es funktioniert. Ich denke, dass Bigger in der Lage sein könnte, eine noch größere Größe herauszuholen, aber keine Zeit hat, sie gründlich zu testen. Viel Glück!
Lily Chung
Ich liebe die Gegenmaßnahme gegen die Cloacking-Bots und die Tatsache, dass dies tatsächlich wie BF-Programmierung aussieht :)
Sylwester
5

Widerstrebende Rán v2

Die Strategie ist einfach. Versuchen Sie, die Gegnerin dazu zu bringen, zu glauben, dass ihre Flagge ein Köder ist, und gehen Sie am Brett vorbei und locker (eine Art Tripwire / Vibrator). Nach 10 vollen Runden gibt sie auf und versucht festzustellen, ob die Gegnerin an ihrer Fahne ist, und wenn nicht, macht sie -17 Täuschungsmanöver, bis sie eine festgelegte Zelle trifft. Die Clearing-Methode, die sie verwendet, ist ein Spezialfall für [-12,12] und beginnt, ähnlich wie Loke zu plotten.

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

Wissenswertes: Rán ist eine Meeresgöttin der nordischen Mythologie, die Seeleute nimmt, bevor sie auf See sterben.

Sylwester
quelle
5

Mickey V4

Für V4 habe ich die gleiche Methode wie für V3 verwendet, gegen die aktualisierten Bots, aber mit mehr gleichzeitigen Populationen (30, nicht 10).

Entwickelt gegen alle 60 Bots, einschließlich BurlyBalderV3und LethalLoke(außer 2botsonecup, was durch meine strikte Implementierung nicht kompilierbar ist).

Ich entdeckte wild unterschiedliche Bots und Erfolgsraten, wenn ich mit verschiedenen zufälligen Samen begann. Deshalb habe ich beschlossen, diese verschiedenen Ausgangspunkte in Populationen aufzuteilen und sie gelegentlich durch Fremdbestäubung untersuchen zu lassen.

In 1400 Generationen haben 30 sich gleichzeitig entwickelnde Bevölkerungsgruppen dieses Programm erstellt:

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

Ich berechne die Gewinnrate dieses Bots auf 90,0% gegenüber der aktuellen Ernte. (1135/125/0 Bandlängen gewonnen / verloren / gezogen).

V3 info

Berechnete Gewinnrate von 89,2% (1124/62/74 Bandlängen gewonnen / verloren / gezogen).

V2 info

Das Generierungsprogramm verfügt nun über eine Analyse, um festzustellen, welcher Teil des Programmendes nicht verwendet wird, und schneidet ihn ab, bevor die nächsten Generierungen daraus generiert werden. Dies bedeutet, dass zufällige Mutationen nur in den verwendeten Programmteilen auftreten und die Entwicklung daher schneller verläuft.

72% gegen die aktuelle Ernte zu der Zeit. (892/204/143 Bandlängen gewonnen / verloren / gezogen).

V1 info

31500 Generationen standen nur 12 Bots gegenüber. 65% (165/80/7 Bandlängen gewonnen / verloren / gezogen). Ich benutze alle 21 Bandlängen.

Potenzielle Bots sind sortiert nach:

  • die meisten gewinnen dann;
  • die meisten zieht dann;
  • schnellste Zeit, die dann gezogen wurde;
  • schnellste Zeit gewonnen

Trivia

  • Mickey ist nach meiner Katze benannt und;
  • Um TS Elliot zu paraphrasieren: The Naming of Cats is a difficult matter, It isn't just one of your brainfuck bots
  • Mein Java bf vm und genetischer Algorithmus ist auf Github .
  • Der VM ist in der Lage, ein komplettes Turnier in weniger als 4 Sekunden auf einem einzigen Kern eines i7 durchzuführen (Vorsicht - die Ergebnisse sind nicht immer identisch mit denen der Turniermaschine).
Weston
quelle
Wäre es nicht besser, alle 60 Bots zu verwenden?
Sylwester
@ Sylwester Vielleicht habe ich es hauptsächlich nicht getan, weil es so langsam ist. Es dauerte zwei Stunden, um dies zu tun. Auch wenn es sich langsamer entwickelte, je mehr Bots es zu bewältigen hatte. Ich dachte mir, wenn es die Top-Jungs schlägt, wird es gut gehen. Ich war nicht in der Lage, das eigentliche Turnier durchzuführen, um Python-Probleme zu bestätigen. Also dachte ich würde es einfach posten und sehen ...
Weston
@weston Vielleicht können wir Ihnen bei Ihren Python-Problemen helfen?
Chiffre
@Cipher danke, ich habe ein Problem auf der Seite github github.com/redevined/brainfuck/issues/2
weston
@ Sylwester Ich benutze jetzt die meisten Bots, da mein Generator viel schneller und multithreadingfähiger ist.
Weston
4

Spieler

Dies hängt eng mit meinem Geronimo-Bot zusammen. Aber wo Geronimo eine sichere Sache spielt, versucht der Spieler, schneller zu sein, indem er das tut, was er am besten kann - Glücksspiel: Er geht in die 20. Zelle und beginnt von dort aus mit der Nullstellung.

Das bedeutet, dass es leicht verlieren kann, nur weil die Arena nicht so groß ist. Aber wenn es so ist, könnten es die wenigen Zyklen sein, die zählen.

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

Fun Fact: Ich habe wirklich darüber nachgedacht, ein paar Bots einzutragen, die alle so aussehen wie (>)*X(>[-])*Ywo X in 9..29und Y = 30 - X. Aber ich denke, die Eingabe von zwanzig Bots wäre etwas zu viel :) Oder sogar vierzig, wenn ich zwei Versionen hätte, eine mit Null [+]und eine mit Null [-].

Ingo Bürk
quelle
Würden Sie mit einer Zahl wie 13 oder 14 nicht bessere Gewinnquoten als mit 20 erzielen?
Moop
Ja vielleicht. Ich will nur für die Mitte. Interessanterweise verringern sich meine Gewinnchancen um ein Vielfaches, wenn ich nur nach links statt nach rechts gehe. Hätte das Gegenteil erwartet.
Ingo Bürk
Da jeder Bot kämpft heben dann Spiele gegen jede andere bot, sogar 40 von denen , nicht Ihre Chancen , dass viel - und ich hatte eine harte Zeit das Kopieren und Einfügen: D
Cipher
4

Dumbot

Ein bemerkenswert dummer Bot, der nur mit der Umwelt herumwirbelt und hofft, dass die Bots, mit denen er kämpft, vom Band laufen.

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

(Ich bin mir nicht sicher, ob das überhaupt funktioniert - es kommt aber nicht zu Fehlern!)

Kommentiert (mit dem, was ich denke, dass es tut):

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

(Ich werde gestaffelt sein, wenn dies eine einzelne Schlacht gewinnt)

Sellyme
quelle
1
Ihre zweite Zeile setzt die Zelle durch Addition auf Null und subtrahiert sie dann siebenmal hintereinander.
stolzer Haskeller
1
@proudhaskeller Du hast Recht ... Das bekomme ich, wenn ich versuche, Brainfuck-Sachen mit wenig Schlaf zu machen. Habe es nur einfacher gemacht, anstatt tatsächlich herauszufinden, wie es richtig gemacht wird.
Sellyme
4

CropCircleBot

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

Dieser Bot verwendet fortschrittliche Algorithmen, die von Außerirdischen durch Kornkreise übertragen wurden, die sie auf der Erde platziert haben. Es wird die Menschheit verändern, enorme technologische Fortschritte bringen und sogar viele Umweltprobleme lösen.

Fehler
quelle
Sie wissen, dass Sie niemals] [verwenden sollten, richtig?
CalculatorFeline
Ich weiß nicht, können Sie erklären, warum?
Fehler
Wenn Sie eine Schleife verlassen, ist die aktuelle Zelle 0. Dann überspringen Sie die nächste Schleife, da die Zelle am Zeiger immer noch 0 ist.
CalculatorFeline
Oh, ich dachte immer, die Prüfung erfolgt am Ende der Schleife?
Fehler
Es tritt auch am Anfang auf. In einigen Implementierungen macht [nichts, aber das ist eine völlig andere Sprache (Newbiefuck im Esolang-Wiki)
CalculatorFeline
4

BeatYouMate

Und weil jeder einen Bot posten sollte, der den ersten Bot schlägt, den er postet, ist hier ein Lockvogel mit mehr als 5:

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

Clever und bestimmt

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

Setzt ein paar kleine Fallen, rast dann auf die andere Seite und versucht, alles über oder unter Null zu beseitigen. Scheitert an ----.

isaacg
quelle
+++Vorher [-]ist es in der Tat klug, einfache Fallen zu vermeiden!
Ingo Bürk
Wurde eine Ausnahme aufgrund eines nicht übereinstimmenden Ereignisses geworfen (. Kann ich das wie einen Kommentar behandeln?
Chiffre
@Cipher Ich werde das beheben, sorry.
Isaacg
4

MetaJSRandomBot

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

Die Idee hinter diesem Bot ist, etwas total zufälliges zu machen, das immer noch ein gültiger js-Code ohne allzu große Nutzlosigkeit ist. Ich habe folgenden Code ( JSFiddle-Link ) geschrieben, um ihn zu generieren. Mal sehen, wie gut es funktioniert =)

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);
Fehler
quelle
4

Preußisches Roulette

Russisches Roulette hat mit seinem Freund Preußen eine Wette abgeschlossen und jetzt ist er an der Reihe zu spielen.

>(+)*5(-.[>.[>(-)*10]]>>)*1000
Beta-Zerfall
quelle
Sie haben 2 Zeigerdekremente und nur 1 Inkrement in Ihrer Hauptschleife - dies wird Sie von Ihrem eigenen Bandende abbringen.
Comintern
2
Das wirft sich trotzdem einfach raus.
stolzer Haskeller
Gleich zu Beginn haben Sie ein Plus, gefolgt von einem Minus. 2 verschwendete Zyklen.
Weston
4

Größer

Das Wettrüsten beginnt !!

Baut und zerstört Wände mit einer Höhe von 16 bis 18 Metern , die größer sind als die meisten Wettbewerber. Hat auch eine kleine Logik, um den Cloaker, Flaggenverteidiger, Anti-Alternatoren und Bots, die eine unberührte Flagge annehmen, zu besiegen

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

Kommentierte Version

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

PatientBot

Ein teils ernster Bot. Dieser Bot wird versuchen, bis zum Limit von 100000 Zyklen zu gewinnen. es wird zur feindlichen Flagge gehen, während ein paar Fallen in den Weg gestellt werden, es ein wenig verringern, zurückgehen und die Flagge verteidigen.

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

Es wird davon ausgegangen, dass alles, was größer als 1 oder kleiner als -1 ist, das Flag ist. Wenn es auf eines trifft, wird es zurückgehen. es verteidigt, indem es einfach ständig erhöht. Dies setzt voraus, dass die meisten Programme entweder [] verwenden, um zu überprüfen, ob das Flag 0 wurde, und daher (+) * 100000 viel schneller ist

Bearbeiten: Der BF Joust-Interpreter funktioniert nicht. Ich gebe auf. Vielleicht solltest du mir sagen, wie ich meinen Code verbessern kann.

Bearbeiten: Jetzt macht der Bot die Stelle kurz vor der Flagge 2 und nachdem er die Flagge ein wenig dekrementiert hat, sucht er nach einer 2. Dies soll das Szenario abbrechen, in dem der Bot eine andere 0-Zelle als die vor der finden würde Flagge.

stolzer haskeller
quelle
Ihr Bot scheint sich auf einem (zugegebenermaßen recht seltenen) Band der Länge 10 umzubringen, da am Anfang 10 '>' stehen. Davon abgesehen [<]ist dies keine so gute Idee, da das Zurückgehen wiederholt wird, bis die Zelle unter Ihrem Zeiger gleich Null ist. Dies ist entweder eine der Zellen vor Ihrer Flagge oder einfach Selbstmord, wenn Ihr Zeiger die Flagge erreicht (seit Ihrer Flagge) ist hoffentlich nicht Null ).
Chiffre
@Cipher Beachten Sie, dass der Bot keine Falle an der Stelle direkt vor der Flagge platziert - meine Idee war, diese Stelle zu markieren, damit der Bot dort seine Verteidigung aufbaut. Gibt es einen besseren Weg? Im Übrigen räumt der Feind manchmal die Fallen und der Bot bleibt stehen, bevor er sollte.
stolzer Haskeller