Twój przyjaciel próbuje włamać się do skarbca, który ma szczególny system blokowania: wymaga pewnej liczby delikatnych uderzeń w określone miejsce. Twój przyjaciel odkrył numer (z zakresu 1 ... 99999) i posiada gadżet, który powoduje wymagane pukanie. Jednak gadżet jest tłumaczem Brainfuck! Więc twój przyjaciel musi nakarmić go programem Brainfuck, który oczywiście powinien być możliwie jak najkrótszy (operacje wejścia / wyjścia gadżetu są wolne).

Twoim zadaniem jest mu pomóc! Napisz program lub podprogram, w dowolnym języku, który przyjmuje jako dane wejściowe liczbę Ni wyprowadza program Brainfuck, który nie przyjmuje danych wejściowych i wyświetla ciąg drukowalnych znaków ASCII (wyłączając znak spacji - kody z zakresu 33 ... 126) długości N.

Przykład: dla danych wejściowych 10może to być

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

(ale jestem pewien, że można to skrócić!)

Twój wynik będzie sumą długości twoich wyników dla następujących wartości N(są to liczby losowe):

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

Aha, a ty prześlesz swój kod (program generujący) do swojego przyjaciela przez Twitter. Upewnij się więc, że ma 140 znaków lub mniej!

PS Język Brainfuck ma wiele wariantów. Załóżmy, że taśma jest nieskończona w obu kierunkach (lub „wystarczająco okrągła i wystarczająco duża”), a komórki mają 32-bitową pojemność całkowitą (skończoną i zdolną do przechowywania liczb do 99999). Również bez owijania: gdy komórka się przepełnia, maszyna sam się niszczy!

Python 2, wynik: 1021

Właśnie zdałem sobie sprawę, że ten konkurs jest dość stary, ale mimo to, ponieważ wymyśliłem lepsze rozwiązanie niż te opublikowane, opublikowałem go również.

Oto 102-bajtowy skrypt python, który wykonuje zadanie:

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

Chodzi o to, aby użyć kodowania base 5 dla N (najlepsza baza przynajmniej dla obecnych wejść, które nie wydają się zbyt „losowe”, wygląda na to, że zostały arbitralnie wybrane przez OP), i napisać ogólny algorytm Brainfuck do dekodować liczbę o dowolnej długości (liczba jest kodowana z każdą cyfrą powiększoną o jedną w celu wykrycia końca konwersji). Wybrałem wydrukowanie znaku 35 #, znak 36 $jest równoważny.

Możesz uruchomić następujący skrypt bash, aby uzyskać wynik:

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

Dzięki bardziej zaawansowanemu programowi, który zastępuje kodowanie mnożeniem małych liczb i wybiera najlepszą bazę do kodowania każdej liczby, mogę osiągnąć 958 znaków Brainfuck, ale Python jest zdecydowanie zbyt gadatliwy (a ja jestem dość złym / leniwym golfistą), aby aby uzyskać konwerter na 144 bajty!

BrainF ***, wynik: 193,313

Nie ma mniej niż 140 znaków (147, tak blisko !!), więc to nie może wygrać, ale myślałem, że to było fajne.

Drukuje 43 znaki plus, a następnie Nkropki. Niezbyt optymalne.

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

Jeśli ktoś mógłby pomóc to skrócić, bardzo bym to uwielbiał.

J, łączny wynik = 1481

(W przypadku mojego poprzedniego wpisu i wyjaśnienia sprawdź historię zmian.)

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

Ta funkcja generuje zagnieżdżone pętle BF na podstawie 10 cyfr liczby wejściowej. Sprawdzenie wszystkich rozsądnych zasad i wybranie najmniejszego kodu BF poprawiłoby wynik przy niewielkiej ilości.

Programy BF dla zestawu testowego:

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

Obliczanie wyniku na zestawie testowym:

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

Pyth, 1702

Rekonstrukcja liczb przy użyciu współczynników N + x.

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

CJam, 52 74 108 bajtów, ogółem = 1304 1244 1210

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

Skrypt testowy (wolny w tłumaczu 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, ogółem = 193281

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

Wiem, że to źle, ale dzisiaj miałem ochotę napisać Befunge. Najlepszą częścią Befunge jest to, że programy są jeszcze mniej zrozumiałe niż rzeczywiste języki gry w golfa, szczególnie gdy ponownie wykorzystują kod: D

Używa podobnego algorytmu do odpowiedzi CJam Martina Büttnera :

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

CJam, 40 + N, ogółem: 193265

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

Aby rozpocząć, oto podstawowe rozwiązanie. Generuje następujący kod:

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

gdzie _są Nkopie +.

Uruchom generator tutaj.

Befunge-93-24 + N, ogółem = 193009

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

Używa przedrostka, +++[>++++[>++++<-]<-]>>aby ustawić pierwszy indeks taśmy na „0” z 24 znakami. Program Befunge jest bardzo prosty i generuje, że wraz z N '. postacie.