BrainF *** edBotsForBattling - Um torneio Brainf ***

88

Todos os bots na arena de batalha foram repentinamente fodidos e ninguém pode explicar o porquê. Mas quem se importa desde que ainda seja capaz de lutar - embora Brainfuck seja a única língua que eles entendem mais.


Já faz um tempo desde a última submissão, então finalmente vou anunciar o vencedor de BrainFuckedBotsForBattling: Parabéns a LymiaAluysia por vencer com NyurokiMagicalFantasy!


Placar

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

Pontuações finais de 09.10.2014

EDIT6 : Logs descartados devido ao tamanho e tempo de execução extremos. Você pode gerá-los você mesmo, descomentando as linhas RunThisTournament.py.

EDIT5 : Implementado tratamento de abreviação no controlador, sem grandes tempos de execução. Isso tem o efeito colateral de que números e parênteses não são mais tratados como comentários. Você ainda pode usá-los se desejar fornecer uma versão anotada, mas seria muito útil se também houvesse uma versão não comentada do seu código , portanto, não preciso remover os comentários manualmente. Obrigado!

EDIT4 : O título foi alterado porque o torneio foi removido das perguntas da rede quente. Obrigado a @ GeeBits por apontar isso!

EDIT3 : Comentários removidos em programas bf, devido a um resultado inesperado, devem ser corrigidos agora. Se alguém tiver algum problema com a remoção de seus comentários, informe.

EDIT2 : Como causou um tempo de execução arcano no meu computador muito lento, reduzi o limite de tempo limite de 100000 ciclos para 10000 ciclos. Não que alguém tenha desviado o resultado de um jogo de corrida além desse ponto.

EDIT1 : Corrigido um erro no script de conversão, fazendo com que o intérprete não ignorasse os números nos programas comentados.


Descrição

Este é um torneio Brainfuck inspirado em BF Joust . Dois bots (programas Brainfuck) estão lutando entre si em uma arena representada por uma fita de memória. Cada célula pode conter valores de -127 a 128 e quebrar em seus limites (então 128 + 1 = -127).

Instruções válidas são semelhantes às do Brainfuck comum, o que significa:

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

A arena tem um tamanho de 10 a 30 células, que é pseudo-aleatoriamente escolhida a cada batalha. Nas duas extremidades, há um 'sinalizador' localizado com um valor inicial de 128, enquanto todas as outras células são zeradas. O objetivo do seu bot é zerar a bandeira do inimigo por 2 ciclos consecutivos antes que ele zere sua própria bandeira.

Cada bot começa com sua própria bandeira, que é a célula [0] de sua própria perspectiva. O oponente está localizado no outro lado da fita.

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

Ambos os bots executam suas ações simultaneamente, isso é considerado um ciclo. O jogo termina após 10000 ciclos ou assim que uma das condições vencedoras é atingida. Se um dos programas chegar ao fim, ele simplesmente pára de fazer qualquer coisa até o final do jogo, mas ainda pode vencer.


Condições vencedoras

Seu bot vence em uma das seguintes condições:

  • A bandeira do seu inimigo é zerada antes da sua
  • Seu inimigo move o ponteiro para fora da fita (é executado >em sua bandeira ou <por conta própria)
  • O valor da sua bandeira está mais longe de 0 do que o valor da bandeira do seu oponente após 10000 ciclos

Regras

Sua postagem deve conter um nome para seu bot e seu código.

  • Você pode usar a seguinte sintaxe de abreviação para tornar seu código mais legível:
    • por exemplo, (+)*4é o mesmo que ++++, isso é válido para qualquer instrução, exceto parênteses sem parênteses entre parênteses, pois a lógica do loop colide com a lógica de abreviação. Por favor use em [-[-[-vez de([-)*3
  • Qualquer outro caractere que não +-><[].seja um comentário e, portanto, ignorado, exceto as ()*abreviações

Bots que não seguirem as regras serão excluídos do torneio.

  • Somente o Brainfuck básico é permitido, nenhuma outra variante que suporte procedimentos ou operações aritméticas
  • O código-fonte do seu bot não deve conter colchetes incomparáveis

Você pode se informar sobre estratégias básicas, mas não use o código de outra pessoa para o seu próprio bot.


Pontuação

A pontuação de um bot é determinada pelo número de vitórias contra todos os outros bots. Um encontro entre 2 bots consiste em 10 partidas com diferentes comprimentos de fita de memória, o que resulta em uma pontuação máxima de 10 pontos por encontro. Um empate não resulta em pontos para esta partida.


Programa de controle

Você pode encontrar o programa de controle no github, junto com os registros completos das batalhas. A tabela de classificação será postada aqui assim que for gerada.

Sinta-se livre para clonar o repositório e experimentar seu bot contra os outros por conta própria. Use python Arena.py yourbot.bf otherbot.bfpara executar uma partida. Você pode modificar as condições com os sinalizadores de linha de comando -me -t. Se o seu terminal não suportar seqüências de escape ANSI, use o --no-colorsinalizador para desativar a saída colorida.


Bots de exemplo

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

O DecoyBot vence todas as partidas com um comprimento de fita superior a dez, pois o FastClearBot pode evitar os pequenos chamarizes, mas não os maiores. A única situação em que o FastClearBot pode vencer o DecoyBot é quando é rápido o suficiente para alcançar a bandeira do inimigo antes que seu oponente construa grandes chamarizes.

Cifra
fonte
5
Original, eu gosto. Só tenho medo de que isso não permita profundidade estratégica suficiente, mas isso pode ser apenas eu.
ɐɔıʇǝɥʇuʎs
11
Isso seria ainda mais divertido com o Befunge .
IchBinKeinBaum
6
Eu encontrei uma página da Web BF Jousting que pode executar e visualizar correspondências de justas.
PhiNotPi 23/08
4
Obrigado por hospedar este KOTH, Cipher. Deve haver muito trabalho com tantas submissões.
AndoDaan
3
Prefiro agradecer a todos por ainda participarem ^^ #
Cipher

Respostas:

18

Nyuroki Magical Fantasy

Eu acho que está na hora de falar a sério ~ Eu terminei meu compilador para um pouco de HLL para facilitar a escrita de programas BF Joust. Esta foi a minha primeira tentativa séria de fazer algo com isso. O conceito do bot é bem simples. Ele configura alguns chamarizes de polaridades variadas e depois enlouquece com uma grande oscilação clara com um deslocamento reverso claro no meio.

Ah, a propósito, a pontuação esperada é de aproximadamente 577 pontos contra a colina da última rodada. Essa é uma taxa de vitória de 93%. <3

Compilado | Código fonte

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 : Eu espremi mais algumas vitórias de Nyuroki.

Edit 2 : Ei, olha, eu fiz de novo!

Edit 3 : Depois de lutar um pouco com um bug estúpido de análise no Arena.py, finalmente consegui outra melhoria em ~ Isto é o que quero dizer com "hora de levar a sério", você sabe. <3

Lymia Aluysia
fonte
Parece que o Loke precisa de alguns ajustes :-) Ame seu idioma. Foi o bug no Arena.py que você tinha em branco entre )e *ou entre *e número?
21418 Sylwester
@Sylwester Muito, muito pior. Loops indo para onde eles não deveriam ir: github.com/redevined/brainfuck/pull/6
Lymia Aluysia
Parabéns com # 1. Vai ser difícil igualar a taxa de vitórias de 92,5%.
21413 Sylwester
Muito bem, mas não é esse abuso taquigráfico? Os loops aninhados são efetivamente 21 fatoriais = 5 * 10 ^ 19. Em outras palavras, é efetivamente inexpansível no cérebro básico.
weston
1
@weston Sim. E a maioria dos programas no BF Joust Hill mais desenvolvido ( codu.org/eso/bfjoust/in_egobot - dê uma olhada no smartlock, por exemplo) é ainda pior. Não é um problema particularmente importante, já que esse é o ponto de vista abreviado. Torna viáveis ​​as estratégias que, de outra forma, seriam inviáveis ​​devido ao grande comprimento. :)
Lymia Aluysia
43

Bot do dispositivo de camuflagem

Esse bot basicamente tenta esconder sua base, fazendo com que outros bots passem por ele e saiam da fita.

(-)*127(-+--+-++)*12500
PhiNotPi
fonte
4
Muito esperto, tive que ajustar meu bot para explicar isso.
Moop
2
Este é um dos mais inteligentes aqui, na minha opinião.
Almo
+ f para o primeiro camuflador. Eu não percebi isso antes depois de fazer Ràn, mas é uma idéia semelhante, aplicação diferente.
Sylwester
19

Burly Balder v3

Burly Balder é uma corrida lenta média. Faz dois chamarizes grandes antes de entrar no modo rápido. No modo acelerado, ele possui um loop que usa apenas 4 etapas em cada célula zero e, quando uma célula diferente de zero, faz uma análise de caso para [-18,18] antes de reduzir cegamente com 107 antes de limpar com [-.]. Ele limpa uma bandeira inalterada em 242 etapas, 114 a mais que uma incerta -*128 e 14 a menos que uma [-]clara ingênua . Quando uma célula é limpa, ele continua deixando um rastro de -2 chamarizes. Ele tem um caso especial apenas para o índice 9 salvar algumas etapas para jogos de tamanho 10 e deixa a célula com um chamariz.

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

Curiosidades: Balder é um deus nórdico e filho de Odin. Ele é conhecido principalmente pela história de sua morte : estava com medo de sua segurança, então os outros deuses tentaram prever e se proteger contra todas as ameaças. Ele acabou sendo morto por Loki, pois enquanto eles o protegiam contra espadas e flechas, eles se esqueceram de protegê-lo contra o visco.

Sylwester
fonte
2
Seus chamarizes estão me matando. Bem feito.
precisa saber é o seguinte
1
@AndoDaan Thanks. Você BeatYouMatefoi inteligente. Temo que os chamarizes na maioria dos bots fiquem ainda maiores na próxima rodada até que dê uma penalidade. Então vamos talvez ter algumas estratégias mais frescas :) emergentes
Sylwester
2
O problema com o aumento do tamanho do engodo é que ele opera com desempenho em fitas mais curtas contra robôs de ataque rápido. Com 10 rodadas aleatórias, é mais provável que haja um ponto ideal que mude dependendo da rapidez com que as outras entradas atacam.
Comintern
2
Sim, você ainda é o único a vencer.
AndoDaan
4
@AndoDaan Com tantos deuses nórdicos para me apoiar na arena aleatória tamanhos parecem estar em meu favor :-)
Sylwester
13

EvoBot 1

Este é um bot simples criado via algoritmo genético. Comecei com um modelo e meu programa ajustou lentamente os números para criar um melhor robô-guerreiro. O código abaixo foi editado para aumentar a legibilidade.

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

Eu usei as outras entradas na competição para medir a adequação dos diferentes candidatos.

Como essa foi minha primeira tentativa de evobot, comecei com um modelo simples:

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

Prevejo que este bot receberá uma pontuação na faixa de 50 a 60 anos.

Atualmente, estou trabalhando em um modelo de chamariz reverso.

EvoBot 2

Este é um bot criado pelo mesmo algoritmo genético, mas com o seguinte modelo:

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

Este bot usa a estratégia de engodo reverso para definir 4 engodos de altura variável. O bot resultante é:

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

Eu espero que este novo bot se saia melhor do que os bots anteriores, possivelmente obtendo uma pontuação nos anos 70 (provavelmente muito maior do que isso, pois existem muitas novas entradas).

PhiNotPi
fonte
2
+1 para algoritmos genéticos. Eu tenho muita fé neles. Espero que seus bots se saiam bem.
AndoDaan
12

Alternador

Ele supõe que a maioria das pessoas zere uma célula adicionando ou subtraindo a ela, portanto, em média, cada célula fará 128 voltas a zero.

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

Versão anotada

(>+>-)*4       Move eight squares alternating polarity    
>+             Move one more
(
    >          Move to the next square
    [-]        Zero it
    [.]        Wait while it is zero
)*21           Repeat
Moop
fonte
Porra, suas últimas alterações melhoram a taxa de vitória do Alternator contra o Geronimo de ~ 60% para ~ 90%. Agradável.
Ingo Bürk
Sim, eu estava me movendo 18 vezes quando fiz (> +> -) * 9, para que caísse da fita. Erro bobo.
Moop
Mesmo protegendo o Geronimo adicionando / subtraindo alternadamente a zero a célula não altera minha taxa de vitória. O alternador pode ser o vencedor aqui - ele usa poucos cilindros para definir uma armadilha bastante difícil de quebrar.
Ingo Bürk
Ei, me corrija se eu estiver errado, mas esse bot não sai automaticamente do fórum se o fórum tiver 10 anos de duração? Está movendo 10 quadrados antes de tentar definir qualquer coisa como zero.
A Boschman
11

Então, alguém aqui usando um algoritmo genético para tentar criar programas aqui. Bem ... há muito tempo atrás, escrevi um evolver BF Joust para uma colina em andamento em um canal de IRC. Eu decidi dar uma volta para este concurso também ~

E ... diferente da outra pessoa com um evolver, meu evolver pode realmente mudar mais do programa do que repetir contagens. :)

NestDarwin (geração 309)

Este é o melhor resultado que meu evolver conseguiu até agora. Não tenho certeza de quanto a estrutura aninhada ajuda nesse caso, mas estruturas como essa foram o que o evolver deve ser capaz de fazer. O desempenho esperado na colina 27.08.2014 é 474 pontos. (Calculado executando a batalha em todos os 21 comprimentos de fita e multiplicando por 10/21. Observe que isso não é normalizado pelo fato de que este morro tem um programa extra)

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

EDIT : Lista alterada de programas que eu quero entrar nesta colina. Ran evolver durante a noite. :)


EDIT 2 : Analisei manualmente a saída do evolver. Apesar de parecer muito diferente, o NestDarwin é basicamente uma versão otimizada do TinyDarwin ... Minimizado manualmente (com funcionalidade idêntica) e analisado:

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

Portanto, um programa quase idêntico seria o seguinte ... que é basicamente uma versão super otimizada do TinyDarwin.

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

TinyDarwin foi o seguinte. Não é muito diferente, hun? Eu só vou retirá-lo da colina. Eu pensei que era distinto, mas ... bem, eu estava errado.

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

Tornou-se aparente que a colina atual não é forte o suficiente para permitir que evolua coisas muito mais complexas. :(

Lymia Aluysia
fonte
1
Parabéns com o primeiro lugar. O programa de algo genético é capaz de usar sua versão atual como modelo e continuar com as novas versões para melhorá-la ainda mais?
29414 Sylwester
Ótimo trabalho com o primeiro lugar. Estou tão feliz que um algoritmo genético (bem, sua desova) chegou lá!
AndoDaan
Agora, se pudéssemos ter os resultados de todos os jogos, evoluir mais, adicionar um pouco de aprendizado de máquina ... então nós seres humanos lamentáveis deixarão de ter qualquer chance: P
SP3000
@Sylwester Mais ou menos? Minha representação interna usa um sistema de ativação gênica (mal pensado) que deveria permitir que ela evoluísse a superestrutura (e na prática, na verdade não). Não posso colocar o programa final de volta e recuperar a representação interna, mas posso colocar as instruções em um único gene e deixá-lo continuar evoluindo (por mais que isso ajude).
Lymia Aluysia
@ Sp3000 Infelizmente, meu algoritmo mal pode progredir na bem desenvolvida colina esotérica. Seria bom se eu pudesse fazer isso, mas, infelizmente, minha habilidade em algoritmos genéticos simplesmente não é boa o suficiente. Provavelmente liberarei meu evolver algum dia quando limpar todos os meus feios hacks.
Lymia Aluysia
10

Urso polar Mk II

Existem dois tipos de ursos polares : aqueles que ficam presos e aqueles que prendem outras pessoas.

Tenta adivinhar a polaridade do oponente e depois usa essas informações para prender o oponente em um loop infinito. Funciona bem contra estratégias simples de compensação e um tanto aleatoriamente contra outras. As armadilhas podem ser facilmente evitadas, por isso posso adicionar algumas estratégias de backup posteriormente.

>++>- 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
fonte
Você pode reduzir pela metade o tamanho do código (]< (+)*290 (>)*9 ... [-])*2?
precisa
@Sylwester não posso porque a outra metade usa +e a outra usa -.
Mika Lammi
O Urso Polar não fazer muito bem com espaços livres de compensação ... idéia incrível embora
SP3000
@ Sp3000 Você tem certeza? Tentei com várias compensações e polaridades (como [(+)*3[-]], [(-)*6[+]]) e ele funciona muito bem (pelo menos para muito pequenas compensações).
Mika Lammi
Ah, eu sei o que há de errado: / Eu estava tentando programas como >>>>>>>>>((-)*4[+][--.]>)*21o de verificar duas vezes a célula e a sua, (+/-)*290causando o acionamento do segundo loop fora de sincronização. Não é culpa da compensação de offset.
Sp3000 27/08/14
10

Bot Pacifista

Meu bot acredita que a violência nunca é a resposta e tentará evitar o combate a todo custo.

(.)*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
fonte
8
Tomei a liberdade de remover os '.' Em seus comentários, pois eles contariam como código Brainfuck e tornariam seu bot um pouco mais lento que o necessário. Se os pontos forem deliberados, fique à vontade para me corrigir!
233
. Oh direito do eram bastante tolo de mim, obrigado por removê-los: p
mmphilips
9

Alguém aí?

Periodicamente, olha para trás para determinar quando o inimigo começou a limpar seus engodos e depois se apressa.

Parece fazer bem, mas não tenho certeza se é por causa da estratégia ou apenas porque estou adicionando 10 a cada célula antes de limpar.

Editar: corrigido um problema de lógica. Primeira vez que escrevi um programa de foda cerebral. Faz jus ao seu 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
ccarton
fonte
+1: Este é o primeiro bot que eu vi que as seqüências de caracteres enganam (além de +/- 1) além das 9 primeiras células. Em fitas mais longas, isso é um assassino. Atualizando o Lightfoot Plodder um pouco mais agora ...
DLosc
9

WALL-E 2.0

Corre para o local 9 e adiciona 128, ganhando rapidamente na arena tamanho 10 se o oponente não tiver alterado o valor inicial da bandeira. Em arenas maiores, isso funciona como isca grande. Depois disso, preenche o espaço entre o local 9 e a própria bandeira com grandes chamarizes. Quando os chamarizes são colocados, ele procura por locais não vazios e tenta limpá-los rapidamente.

A versão 2.0 cria engodos maiores e tem alguma tolerância em relação à alteração do valor inicial do sinalizador. Também pode mudar para a estratégia de backup se as coisas começarem a parecer peludas.

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

A eficácia desse bot é baseada em dois fatos:

  1. A maioria dos bots não altera o valor inicial de sua bandeira.
  2. Construir chamarizes grandes é mais rápido do que limpá-los.
Mika Lammi
fonte
Estas paredes estão me matando
SP3000
9

Lethal Loke V2.1 (com visco)

É claro que este é um robô mortal e ele mata não apenas a bela Burly Balder com visco, mas ganha quase sempre contra os outros bots. É uma corrida média e rápida combinada. Meu teste me dá uma pontuação de 567

Arquivo BFJ compilado para batalha , fonte do gerador Racket BFJ:

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

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


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

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

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

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

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

(display (generate-loke2))

Curiosidades : Loke (Loki) é um deus da mitologia nórdica que gosta de brincar com todos e enganá-los. Ele é um metamorfo (em animais e pessoas) e geralmente segue seus próprios caminhos. Nas histórias, ele costuma viajar e ajudar os outros deuses e faz pequenos truques e agita as coisas. Além de matar Balder, ele foi pai de Hel (deusa do inferno / Helvete), a besta Fenrir e a serpente Midgard que inicia Ragnarok (armageddon nórdico).

Como funciona

No começo, ele faz um grande chamariz (-17) e cria um +-padrão até o índice 7. Ele avança de 13 para 13 deixando um rastro de (+ 10, -32) + chamarizes, mas quando detecta um conjunto, ele aborta e inicie um modo de aceleração médio * 1. Se nenhuma célula estiver definida, ele também iniciará o modo de aceleração lento * 3.

* 1 No modo de corrida média, ele detectou a atividade do oponente em um dos índices 7-13 e ele começa no índice 2. Alguns oponentes deixam um zero e outros deixam um valor diferente e agora ele tem meios de detectar a atividade do oponente enquanto antes de fazer iscas. índice 2-6 (-32, + 10) +. Se o valor não for esperado da célula (-1, 1) ou ele terminar de fazer todos os chamarizes, ele entrará no modo rápido * 2 rush.

* 2 No modo de corrida rápida, ele espera que tenha sido detectado para que os engodos não funcionem. Esperamos que os que já definimos parem o oponente e se concentrem em passar pelas armadilhas do oponente. Ele começa a correr no ponto mais distante que conhecemos, com base na varredura anterior [9,14] ou no índice 9, se formos feitos antes disso. Ele tem um caso especial para o primeiro engodo, onde adicionamos 120 e 27, já que ele não deseja reduzir o valor abaixo de zero, é uma armadilha, mas para cada engodo depois de passarmos a [-8,8] antes de aumentar em 120 e dando 27 passos antes de avançar para a próxima célula.

O modo slow rush foi removido, pois não afetou a pontuação na colina atual e torna meu bot um pouco menor (mas não muito).

Sylwester
fonte
3
Agora estamos começando a ver insanidade. Eu gosto disso.
Sp3000
@ Sp3000 YandereBotv2 foi a razão pela qual eu precisava pensar de novo, além de apenas aumentar os chamarizes e os valores de oscilação. Ele teve um percentual de vitórias mais alto do que todos os bots da última rodada, então você não teve sorte com os tamanhos de arena.
Sylwester
Ahaha talvez - Acho que preciso de um contraplano contra os tamanhos cada vez maiores chamarizes: / Eu realmente gosto de como você tem modos diferentes, embora
SP3000
suspiro . Vou precisar que meu HLL para BF Joust funcione melhor para que meu evolver possa ter uma chance novamente. Parabéns por # 1 ~
Lymia Aluysia
@LymiaAluysia Thanks. Fiquei mais surpreso com Balder. Eu estou contando com um novo versões do NestDarwin, YandereBot e Mickey :-)
Sylwester
8

Geronimo

É ainda mais ofensivo do que o bot BestOffense de kaine, pois não cria nenhuma defesa. A estratégia aqui é: outros tentarão ser espertos, mas ser esperto leva ciclos. Então, vamos pular para a parte em que sabemos que o inimigo está e limpar tudo o que encontramos.

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

Parece ganhar a maioria dos jogos contra os bots de exemplo do OP e o bot de kaine.

Ingo Bürk
fonte
7

SternBot

Um bot meio sério agora que tudo começou. Abordando a natureza simulada de alguns desses bots.

(>->+>)*3(>[+]>[-])*21
Kaine
fonte
1
O SternBot me fornece problemas de paridade :(
Sp3000 26/08
7

DoNothingBot

A melhor defesa (...) é a ignorância.

.

Não faz nada.

EDIT: Uau, fiquei surpreso ao ver que ele fez um trabalho melhor do que mais de pelo menos 20% de todos os bots =) (Isso significa que ele usa uma estratégia superior ou ....?)

flawr
fonte
2
Alguns dos outros bots se suicidam em pequenas arenas. por exemplo. Gambler vai diretamente para a célula 20 e para os jogos wth 10-19 vai soltas, mesmo contraDoNothingBot
Sylwester
2
Por curiosidade, eu passei isso através do meu testador (reproduz todos os comprimentos de fita) nas outras entradas. Eis o muro da vergonha ... +1
Comintern
Haha, Obrigado por compartilhar - Eu esperava que pode haver uma ou duas ovelhas negras, mas eu não esperava que ele 'derrotas' tantos bots =)
flawr
7

CounterPunch - Editado

Combinação equilibrada de construir uma forte defesa e depois atacar.

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

Anotado:

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

Defende semelhante ao Backtracker do @ Geobit , mas defende contra atacantes velozes colocando um engodo rápido na frente da bandeira primeiro.

O ataque é limpo com polaridade oposta para limpar rapidamente os chamarizes com valores pequenos. O pior cenário deve ser um chamariz de 64 (qualquer polaridade).

Edit 1: Melhorar a eficiência de ataque contra chamarizes (houve um erro lógico na troca de polaridade).

Editar 2: o teste indica que a pausa tem um desempenho um pouco melhor no loop mais interno.

Comintern
fonte
6

Backtracker

Uma estratégia de chamariz reversa. Comece a colocar iscas na parte de trás da frente, para que ninguém pule o resto enquanto eu as construo.

Se o tabuleiro for menor que o tamanho 20 ou mais, isso não funcionará contra robôs de ataque rápido, já que passaremos um pelo outro antes que eu comece a enganar.

(>)*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: Eu não BF, mas isso faz o que eu quero para mim. Caso contrário, deixe-me agora.

Geobits
fonte
6

Não pode tocar nisto

Este é um programa orientado para a defesa que tenta determinar como o oponente está limpando as células e cria um chamariz do tamanho apropriado.

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

Atualmente, estou trabalhando em uma versão que pode vencer as duas polaridades.

PhiNotPi
fonte
6

ImpatientTripwire (tcp YandereBot)

Tenta ser um fio de trip para que ele possa colocar iscas (principalmente) da polaridade correspondente, mas desiste se você demorar demais e assume que você é a paridade oposta. Possui um fio de trip reverso para pequenas placas.

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

Versão atual: 1.3 - editada para se sair melhor em placas menores, à custa de perder jogos devido a inimigos passando furtivamente durante a verificação de fios

Versões anteriores: 1.2.1

(Preciso de um algoritmo claro melhor: /)

Sp3000
fonte
1
OMG 411k totalmente expandido e despojado: -O código do Chiper depende disso.
26414 Sylwester
Acabei de alterar alguns dos comentários para que agora funcione com o novo código da Cipher
Sp3000 27/08/2014
desde a edição mais recente, os colchetes inigualáveis ​​entre parênteses se comportam estranhos, pois a lógica do loop colide com a lógica da abreviação. posso mudar construções como ([)*300voltar para [[[ and so on?
Cipher
@Cipher Sim, ir para ele - embora a versão pastebin deve ser exatamente exatamente isso
SP3000
1
3rd é um bom lugar para entrar. Bem feito.
AndoDaan
5

Lightfoot Plodder - EDITADO

Com base no Plodder , esse gigante veloz é capaz de "avançar rapidamente" através de z consecutivos rapidamente, até atingir algo diferente de zero (nesse ponto, começa a trabalhar como esperado).

Agora aprimorado com um algoritmo de skimming mais robusto, que também permite avançar rapidamente através de pequenos chamarizes e chamarizes maiores.

Edição # 2 : Agora é possível voltar ao skimming se encontrar mais bolsões de zeros.

>(-)*4
>(-)*7
>(-)*4
>(+)*7
>(-)*17
>(+)*3
> -
>(-)*10
>(+)*16[-]<-
([
[>>
 [+
  [--
   [+++
    [<+>(+)*14[-]]
   ]
  ]
 ]<-
]>>
[(+)*126(+.)*4>]
<]+)*10
DLosc
fonte
Mudança de tamanho "conveniente" agradável lá :):
Lily Chung
@IstvanChung Muito conveniente. ;) Mais um pouco teria me atrasado muito, perdendo pontos para vários outros bots. Se você tornasse o Bigger maior, acho que não tentaria acompanhar o ritmo.
DLosc
Bem, aumentamos um pouco o tamanho para ver como ele funciona. Acho que o Bigger pode conseguir um tamanho ainda maior, mas não tem tempo para testá-lo completamente. Boa sorte!
Lily Chung
Amo a medida contra contra os bots Cloacking eo fato de que este realmente se parece com programação BF :)
Sylwester
5

Rán relutante v2

A estratégia é fácil. Tente fazer com que o oponente pense que a bandeira dela é uma isca e passe antes do tabuleiro e solte (uma espécie de arame / vibrador). Após 10 rodadas completas, ela desiste e tenta determinar se o oponente está em sua bandeira e, caso contrário, fará -17 iscas até atingir uma célula definida. O método de limpeza que ela usa é um caso especial para [-12,12] e começa a andar de maneira semelhante 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
]

Curiosidades: Rán é uma deusa do mar da mitologia nórdica que leva marinheiros antes de morrerem no mar.

Sylwester
fonte
5

Mickey V4

Para a V4, usei o mesmo método da V3, contra os bots atualizados, mas com populações mais concorrentes (30 e não 10).

Desenvolvido contra todos os 60 bots, incluindo BurlyBalderV3e LethalLoke(mas excluindo o 2botsonecup, que é compilável pela minha estrita implementação).

Descobri bots muito diferentes e taxas de sucesso se eu começasse com sementes aleatórias diferentes. Então, decidi separar esses diferentes pontos de partida em populações e deixá-los ocasionalmente polinizar.

Em 1400 gerações, 30 populações em evolução simultânea criaram este programa:

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

Calculo que a taxa de vitórias deste bot seja 90,0% em relação à safra atual. (1135/125/0 comprimentos de fita vencidos / perdidos / empatados).

Informação V3

Taxa de vitórias calculada de 89,2% (1124/62/74 comprimentos de fita ganhos / perdidos / empatados).

Informação V2

O programa de geração agora tem uma análise para determinar qual parte do final do programa não está sendo usada e a apara antes de gerar as próximas gerações. Isso significa que mutações aleatórias ocorrem apenas em partes usadas do programa e, portanto, a evolução é mais rápida.

72% em relação à safra atual da época. (892/204/143 comprimentos de fita vencidos / perdidos / empatados).

Informação V1

31500 gerações, apenas 12 bots enfrentados. 65% (comprimentos de fita 165/80/7 vencidos / perdidos / empatados). Eu uso todos os 21 comprimentos de fita.

Os bots em potencial são classificados por:

  • mais vitórias então;
  • a maioria chama então;
  • tempo mais rápido desenhado então;
  • tempo mais rápido ganho

Jogo de perguntas sobre cultura geral

  • Mickey tem o nome de meu gato e;
  • Parafraseando TS Elliot: The Naming of Cats is a difficult matter, It isn't just one of your brainfuck bots
  • Meu java bf vm e o algoritmo genético estão no github .
  • O vm é capaz de executar um torneio completo em menos de 4 segundos em um único núcleo de um i7 (cuidado - os resultados nem sempre são idênticos ao mecanismo de torneios).
Weston
fonte
Não seria melhor usar todos os 60 bots?
21414 Sylwester
@Sylwester Talvez, principalmente, não fiz porque é muito lento. Demorou duas horas para fazer isso. Além disso, embora tenha evoluído mais lentamente, mais bots teve que lidar. Imaginei que, se vencer os melhores, vai dar certo. Não fui capaz de executar o torneio real para confirmar problemas com python. Então pensei que tinha acabado postá-lo e ver ...
Weston
@weston Talvez possamos ajudá-lo com seus problemas de python?
Cipher
@ Cipher obrigado, eu abri um problema no github github.com/redevined/brainfuck/issues/2
weston
@Sylwester Eu uso a maioria dos bots agora, pois meu gerador é muito mais rápido e multithread.
weston 02/09
4

Jogador

Isso está intimamente relacionado ao meu bot Geronimo. Mas onde Geronimo está jogando com certeza, o Jogador tenta ser mais rápido, fazendo o que faz melhor: jogar: vai para a vigésima cela e começa a zerar a partir daí.

Isso significa que pode facilmente perder apenas porque a arena não é tão grande. Mas, se for, podem ser os poucos ciclos que contam.

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

Curiosidade: Eu estava realmente pensando em entrar em um monte de bots que parecem (>)*X(>[-])*Yonde X in 9..29e onde Y = 30 - X. Mas acho que digitar vinte bots seria um pouco demais :) Ou até quarenta se eu tivesse duas versões, uma com zero [+]e outra com isso [-].

Ingo Bürk
fonte
Um número como 13 ou 14 não forneceria porcentagens de vitória melhores que 20?
Moop
Sim talvez. Eu só quero o meio. Curiosamente, se eu apenas for para a esquerda, em vez de para a direita, minhas chances de vitória diminuem bastante. Teria esperado o contrário.
Ingo Bürk
Uma vez que cada lutas bot então partidas contra qualquer outro bot, mesmo 40 daqueles que não iria levantar as chances de que muito - e eu tive um tempo difícil de copiar e colar: D
Cipher
4

Dumbot

Um bot notavelmente estúpido que mexe com o meio ambiente e espera que todos os bots que ele enfrenta sejam eliminados.

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

(Não tenho certeza se isso funciona - mas não há erro!)

Anotado (com o que eu acho que faz):

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

(Ficarei desconcertado se isso vencer uma única batalha)

Sellyme
fonte
1
sua segunda linha zerará a célula por adição e subtrairá uma sete vezes seguidas.
haskeller orgulhoso
1
@proudhaskeller Você está certo ... É o que eu ganho por tentar fazer coisas com o Brainfuck com pouco sono. Acabamos de simplificar, em vez de realmente descobrir como fazê-lo corretamente.
Sellyme
4

CropCircleBot

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

Este Bot usa algoritmos avançados que foram transmitidos por alienígenas através de círculos que eles colocaram na Terra. Isso mudará a humanidade e proporcionará enormes avanços tecnológicos e até resolverá muitos problemas ambientais.

flawr
fonte
Você sabe que nunca deve usar] [, certo?
CalculatorFeline
Eu não, você pode explicar o porquê?
flawr
Quando você deixar um loop, a célula atual é 0. Em seguida, pule o próximo ciclo porque a célula no ponteiro ainda é 0.
CalculatorFeline
Ah, eu sempre pensei que a verificação ocorre no final do loop?
flawr
Também ocorre no início. Em algumas implementações, [não faz nada, mas que é uma linguagem completamente diferente (newbiefuck no wiki esolang)
CalculatorFeline
4

BeatYouMate

E como todo mundo deve postar um bot que vencerá o primeiro bot que postar, aqui está um bot de engodo com mais de 5 anos:

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

CleverAndDetermined

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

Define algumas pequenas armadilhas, depois corre para o outro lado e tenta limpar tudo, acima ou abaixo de zero. Falha ----.

isaacg
fonte
+++antes [-]é realmente inteligente para evitar armadilhas simples!
Ingo Bürk
Lançou uma exceção devido a um inigualável (. Posso tratá-lo como um comentário?
Cifra
@ Cipher Eu vou consertar isso, desculpe.
Isaacg
4

MetaJSRandomBot

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

A idéia por trás desse bot é tornar algo totalmente aleatório, que ainda é um código js válido sem muita inutilidade. Eu escrevi o seguinte código ( link JSFiddle ) para gerá-lo. Vamos ver o quão bem faz =)

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);
flawr
fonte
4

Roleta Prussiana

A Roleta Russa fez uma aposta com seu amigo Prussiano, e agora é sua vez de jogar.

>(+)*5(-.[>.[>(-)*10]]>>)*1000
Beta Decay
fonte
Você tem 2 decrementos de ponteiro e apenas 1 incremento no loop principal - isso fará com que você saia da sua própria extremidade da fita.
Comintern
2
Isso ainda vai se jogar fora.
haskeller orgulhoso
Logo no início você tem um sinal de mais, seguido de um sinal de menos. 2 ciclos desperdiçados.
weston
4

Maior

A corrida armamentista começa !!

Constrói e destrói muros de altura 16 a 18, maiores que a maioria dos concorrentes. Também tem um pouco de lógica para vencer o cloaker, defensores de bandeiras, anti-alternadores e bots que assumem uma bandeira intocada

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

Versão anotada

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

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

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

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

PatientBot

Um bot parcialmente sério. este bot tentará vencer pelo limite de 100000 ciclos. ele irá para a bandeira inimiga enquanto coloca algumas armadilhas no caminho, diminui um pouco, volta e defende a bandeira.

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

assumirá que tudo maior que 1 ou menor que -1 é a bandeira e, quando encontrar uma, ela voltará. defende simplesmente incrementando constantemente. isso pressupõe que a maioria dos programas use [] para verificar se o sinalizador se tornou 0 e, portanto, (+) * 100000 será muito mais rápido

Edit: não é possível fazê-lo funcionar no intérprete BF Joust. Estou desistindo. talvez você deva me dizer como melhorar meu código.

Edit: agora o bot aparece no local logo antes da flag 2 e, depois de diminuí-la um pouco, procura um 2. Isso significa cancelar o cenário em que o bot encontraria uma célula 0 diferente da anterior à bandeira.

orgulhoso haskeller
fonte
Seu bot parece se matar em uma fita (razoavelmente rara, admito) com comprimento 10, já que existem 10 '>' no começo. Além disso, [<]não é uma boa ideia, pois ela repete o processo até que a célula sob o ponteiro seja igual a zero , que é uma das células na frente da sua bandeira ou simplesmente suicida se o ponteiro chegar à bandeira (desde a sua bandeira) espero que não seja zero ).
Cifra
@ Cipher Observe que o bot não coloca uma armadilha no local logo em frente à bandeira - minha idéia era marcar esse local para que o bot construísse sua defesa lá. Existe uma maneira melhor? Às vezes, o inimigo limpa as armadilhas e depois o bot para antes que o faça.
haskeller orgulhoso