Seu amigo está tentando arrombar um cofre que possui um sistema de travamento peculiar: requer um certo número de batidas suaves em um determinado local. Seu amigo descobriu o número (que está no intervalo de 1 a 99999) e possui um gadget que produz as batidas necessárias. No entanto, o gadget é um intérprete de Brainfuck! Portanto, seu amigo precisa alimentar um programa Brainfuck, que, obviamente, deve ser o mais curto possível (a E / S do gadget é lenta).

Sua tarefa é ajudá-lo! Escreva um programa ou uma sub-rotina, em qualquer idioma, que aceite como número de entrada Ne emita um programa Brainfuck, que não recebe entrada e gera uma sequência de caracteres ASCII imprimíveis (excluindo os códigos de caracteres de espaço no intervalo 33 ... 126) de comprimento N.

Exemplo: para entrada 10, a saída pode ser

+++++++++++++++++++++++++++++++++..........

(mas tenho certeza de que pode ser reduzido!)

Sua pontuação será a soma dos comprimentos de suas saídas para os seguintes valores de N(são números aleatórios):

55
68
15
28
841
838
522
846
4898
9004
9363
3810
13230
67175
37231
44701

Ah, e você estará transmitindo seu código (o programa gerador) para seu amigo pelo Twitter. Portanto, tenha 140 caracteres ou menos!

PS A linguagem Brainfuck tem muitas variantes. Vamos supor que a fita seja infinita nas duas direções (ou "circular e grande o suficiente"), e as células tenham capacidade int de 32 bits (finita e capaz de armazenar números até 99999). Além disso, sem quebra: quando uma célula transborda, a máquina se autodestrói!

Python 2, pontuação: 1021

Acabei de perceber que este concurso é bastante antigo, mas ainda assim, como achei uma solução melhor do que as postadas, também a publiquei.

Aqui está um script python de 102 bytes que faz o trabalho:

n=input()
s='>'
while n:
    s+='>'+'+'*(n%5+1);n/=5
print s+'[->[-<+++++>]<<]<+++++++[>+++++<-]>>[-<.>]'

A idéia é usar a codificação da base 5 para N (melhor base, pelo menos para as entradas atuais, que não parecem muito "aleatórias", a propósito, parece que foram escolhidas arbitrariamente pelo OP) e escrever um algoritmo genérico de Brainfuck para decodificar um número de tamanho arbitrário (o número é codificado com cada dígito aumentado em um para detectar o final da conversão). Eu escolhi imprimir o caractere 35 #, o caractere 36 $é equivalente.

Você pode executar o seguinte script bash para obter a pontuação:

i=0
while read p; do
  i=$((i+`echo $p | python convert.py | wc -m`))
done
echo $i

Com um programa mais avançado que substitui a codificação pela multiplicação por números pequenos e escolhe a melhor base para codificar cada número, eu posso alcançar 958 caracteres Brainfuck, mas o Python é muito detalhado (e eu sou um jogador muito ruim / preguiçoso) para para obter o conversor em 144 bytes!

BrainF ***, pontuação: 193,313

Não tem menos de 140 caracteres (é 147, tão perto !!), então isso não pode vencer, mas eu achei legal.

Imprime 43 sinais de adição e depois Npontos. Não é o ideal.

>++++++[>+++++++<-]>+[->+>+<<]>[->.<]<<+[[-]>[-],[+[-----------[>[-]++++++[<------>-]<--<<[->>++++++++++<<]>>[-<<+>>]<+>]]]<]>>>+++<<<<[>>>>.<<<<-]

Se alguém puder ajudar a diminuir isso, eu adoraria.

J, pontuação total = 1481

(Para minha entrada e explicação anteriores, verifique o histórico de revisões.)

f10=.('>++++++++++<';'')rplc~;@([:(<@('+++++[>+++++++<-]>>+',;@((<'[>++++++++++')#~#)),[<@(']',~'<-','<.>'#~],[,])"0 #-i.@# )10#.inv])

Essa função gera loops BF aninhados com base nos dígitos base10 do número de entrada. Verificar todas as bases razoáveis ​​e escolher o menor código BF melhoraria a pontuação com uma pequena quantia.

Programas BF para o conjunto de testes:

   f10 every 55 68 15 28 841 838 522 846 4898 9004 9363 3810 13230 67175 37231 44701
+++++[>+++++++<-]>>+[>++++++++++[-<<.....>>]<-<.....>]                                                                                     
+++++[>+++++++<-]>>+[>++++++++++[-<<......>>]<-<........>]                                                                                 
+++++[>+++++++<-]>>+[>++++++++++[-<<.>>]<-<.....>]                                                                                         
+++++[>+++++++<-]>>+[>++++++++++[-<<..>>]<-<........>]                                                                                     
+++++[>+++++++<-]>>+[>++++++++++[>++++++++++[-<<<........>>>]<-<<....>>]<-<.>]                                                             
+++++[>+++++++<-]>>+[>++++++++++[>++++++++++[-<<<........>>>]<-<<...>>]<-<........>]                                                       
+++++[>+++++++<-]>>+[>++++++++++[>++++++++++[-<<<.....>>>]<-<<..>>]<-<..>]                                                                 
+++++[>+++++++<-]>>+[>++++++++++[>++++++++++[-<<<........>>>]<-<<....>>]<-<......>]                                                        
+++++[>+++++++<-]>>+[>++++++++++[>++++++++++[>++++++++++[-<<<<....>>>>]<-<<<........>>>]<-<<.........>>]<-<........>]                      
+++++[>+++++++<-]>>+[>++++++++++[>++++++++++[>++++++++++[-<<<<.........>>>>]<-<<<>>>]<-<<>>]<-<....>]                                      
+++++[>+++++++<-]>>+[>++++++++++[>++++++++++[>++++++++++[-<<<<.........>>>>]<-<<<...>>>]<-<<......>>]<-<...>]                              
+++++[>+++++++<-]>>+[>++++++++++[>++++++++++[>++++++++++[-<<<<...>>>>]<-<<<........>>>]<-<<.>>]<-<>]                                       
+++++[>+++++++<-]>>+[>++++++++++[>++++++++++[>++++++++++[>++++++++++[-<<<<<.>>>>>]<-<<<<...>>>>]<-<<<..>>>]<-<<...>>]<-<>]                 
+++++[>+++++++<-]>>+[>++++++++++[>++++++++++[>++++++++++[>++++++++++[-<<<<<......>>>>>]<-<<<<.......>>>>]<-<<<.>>>]<-<<.......>>]<-<.....>]
+++++[>+++++++<-]>>+[>++++++++++[>++++++++++[>++++++++++[>++++++++++[-<<<<<...>>>>>]<-<<<<.......>>>>]<-<<<..>>>]<-<<...>>]<-<.>]          
+++++[>+++++++<-]>>+[>++++++++++[>++++++++++[>++++++++++[>++++++++++[-<<<<<....>>>>>]<-<<<<....>>>>]<-<<<.......>>>]<-<<>>]<-<.>]          

Pontuação de computação no conjunto de testes:

   +/#@> f10 each 55 68 15 28 841 838 522 846 4898 9004 9363 3810 13230 67175 37231 44701
1481

Pyth, 1702

Reconstrua números usando fatores de N + x.

+holN+]++">>"*"+"Q"<<"mjk(">>"j">"m*"+"kP+Qd"<[[->[->+>+<<]>>[-<<+>>]<<<]>[-]>[-<<+>>]<<<]>"*"-"d"<<")50"++++++[>++++++<-]>>[<.>-]"

CJam, 52 74 108 bytes, total = 1304 1244 1210

ri5b_,1>{(_3<{\(@5*+}*\+}*W%)\{T+_2>:T5*-_0>"-+"=\z*}%\T+'+*a+W%{"[->+++++<]>"\}*">x[>x<-]<[->>.<<]"'x/'+6**

Um script de teste (lento no intérprete online):

q~]
{
_[0:T;
5b_,1>{(_3<{\(@5*+}*\+}*W%)\{T+_2>:T5*-_0>"-+"=\z*}%\T+'+*a+W%{"[->+++++<]>"\}*">x[>x<-]<[->>.<<]"'x/'+6**
]s
_[L:RL@0\
"-+><.]"['('){+\_{)}0?@\}{@\+\_{)}0?}{R1$c+:R;}]:`"]a"{{_aa+1$4G#%{:~~1}{;0}?}g}`+a+er:~:~
];R,@=!"Error."N+*o
}%s,

Befunge-98, N + 41, total = 193281

&>'+\:v
v^-1,\_
' >1-:v
>v^,+'_
,'    :
>ff3++^
>2f*+v
^>/9+:,
>'>,61v
, v*6+<
^/2,:<@
v >+2+,
>'<,']^

Eu sei que é ruim, mas eu estava com vontade de escrever um pouco sobre Befunge hoje. A melhor parte do Befunge é que os programas são ainda menos compreensíveis do que os idiomas de golfe reais, especialmente quando reutilizam o código: D

Usa um algoritmo semelhante à resposta CJam de Martin Büttner :

(N +'s)>+++++++++++++++++++++++++++++++++<[->.<]

CJam, 40 + N, Total: 193265

'+33*'>'+l~*"[<.>-]"

Apenas para começar, aqui está a solução de linha de base. Ele gera o seguinte código:

+++++++++++++++++++++++++++++++++>_[<.>-]

de onde _estão as Ncópias +.

Execute o gerador aqui.

Befunge-93 - 24 + N, total = 193009

&>">>]-<]-<++++>[++++>[+++"v
v  ,,,,,,,,,,,,,,,,,,,,,,, <
>:v
,v_@
"1
.-
"
^<

Isso usa um prefixo de +++[>++++[>++++<-]<-]>>para definir o primeiro índice de fita como '0' com 24 caracteres. O programa Befunge é muito básico e gera resultados junto com N '.' personagens.