Napisz najkrótszy program w swoim ulubionym języku, aby zinterpretować program „ pieprzony mózg ”. Program jest odczytywany z pliku. Wejście i wyjście to standardowe wejście i standardowe wyjście.
- Rozmiar komórki: 8-bitowy bez znaku. Przepełnienie jest niezdefiniowane.
- Rozmiar tablicy: 30000 bajtów (bez kółek)
- Złe polecenia nie są częścią danych wejściowych
Komentarze zaczynają się od # i rozciągają do końca wierszaKomentarze nie zawierają wszystkiego+-.,[]<>
- brak symbolu EOF
Bardzo dobry test można znaleźć tutaj . Odczytuje liczbę, a następnie drukuje liczby pierwsze do tej liczby. Aby zapobiec gniciu linków, oto kopia kodu:
compute prime numbers
to use type the max number then push Alt 1 0
===================================================================
======================== OUTPUT STRING ============================
===================================================================
>++++++++[<++++++++>-]<++++++++++++++++.[-]
>++++++++++[<++++++++++>-]<++++++++++++++.[-]
>++++++++++[<++++++++++>-]<+++++.[-]
>++++++++++[<++++++++++>-]<+++++++++.[-]
>++++++++++[<++++++++++>-]<+.[-]
>++++++++++[<++++++++++>-]<+++++++++++++++.[-]
>+++++[<+++++>-]<+++++++.[-]
>++++++++++[<++++++++++>-]<+++++++++++++++++.[-]
>++++++++++[<++++++++++>-]<++++++++++++.[-]
>+++++[<+++++>-]<+++++++.[-]
>++++++++++[<++++++++++>-]<++++++++++++++++.[-]
>++++++++++[<++++++++++>-]<+++++++++++.[-]
>+++++++[<+++++++>-]<+++++++++.[-]
>+++++[<+++++>-]<+++++++.[-]
===================================================================
======================== INPUT NUMBER ============================
===================================================================
+ cont=1
[
- cont=0
>,
======SUB10======
----------
[ not 10
<+> cont=1
=====SUB38======
----------
----------
----------
--------
>
=====MUL10=======
[>+>+<<-]>>[<<+>>-]< dup
>>>+++++++++
[
<<<
[>+>+<<-]>>[<<+>>-]< dup
[<<+>>-]
>>-
]
<<<[-]<
======RMOVE1======
<
[>+<-]
]
<
]
>>[<<+>>-]<<
===================================================================
======================= PROCESS NUMBER ===========================
===================================================================
==== ==== ==== ====
numd numu teid teiu
==== ==== ==== ====
>+<-
[
>+
======DUP======
[>+>+<<-]>>[<<+>>-]<
>+<--
>>>>>>>>+<<<<<<<< isprime=1
[
>+
<-
=====DUP3=====
<[>>>+>+<<<<-]>>>>[<<<<+>>>>-]<<<
=====DUP2=====
>[>>+>+<<<-]>>>[<<<+>>>-]<<< <
>>>
====DIVIDES=======
[>+>+<<-]>>[<<+>>-]< DUP i=div
<<
[
>>>>>+ bool=1
<<<
[>+>+<<-]>>[<<+>>-]< DUP
[>>[-]<<-] IF i THEN bool=0
>>
[ IF i=0
<<<<
[>+>+<<-]>>[<<+>>-]< i=div
>>>
- bool=0
]
<<<
- DEC i
<<
-
]
+>>[<<[-]>>-]<<
>[-]< CLR div
=====END DIVIDES====
[>>>>>>[-]<<<<<<-] if divides then isprime=0
<<
>>[-]>[-]<<<
]
>>>>>>>>
[
-
<<<<<<<[-]<<
[>>+>+<<<-]>>>[<<<+>>>-]<<<
>>
===================================================================
======================== OUTPUT NUMBER ===========================
===================================================================
[>+<-]>
[
======DUP======
[>+>+<<-]>>[<<+>>-]<
======MOD10====
>+++++++++<
[
>>>+<< bool= 1
[>+>[-]<<-] bool= ten==0
>[<+>-] ten = tmp
>[<<++++++++++>>-] if ten=0 ten=10
<<- dec ten
<- dec num
]
+++++++++ num=9
>[<->-]< dec num by ten
=======RROT======
[>+<-]
< [>+<-]
< [>+<-]
>>>[<<<+>>>-]
<
=======DIV10========
>+++++++++<
[
>>>+<< bool= 1
[>+>[-]<<-] bool= ten==0
>[<+>-] ten = tmp
>[<<++++++++++>>>+<-] if ten=0 ten=10 inc div
<<- dec ten
<- dec num
]
>>>>[<<<<+>>>>-]<<<< copy div to num
>[-]< clear ten
=======INC1=========
<+>
]
<
[
=======MOVER=========
[>+<-]
=======ADD48========
+++++++[<+++++++>-]<->
=======PUTC=======
<.[-]>
======MOVEL2========
>[<<+>>-]<
<-
]
>++++[<++++++++>-]<.[-]
===================================================================
=========================== END FOR ===============================
===================================================================
>>>>>>>
]
<<<<<<<<
>[-]<
[-]
<<-
]
======LF========
++++++++++.[-]
@
Przykładowy przebieg:
$ python2 bf.py PRIME.BF
Primes up to: 100
2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97
code-golf
interpreter
brainfuck
Alexandru
źródło
źródło
,
EOF? Czy to od nas zależy, czy wybierzesz wartość przy,
EOF? A może zachowanie EOF jest całkowicie niezdefiniowane?Odpowiedzi:
Perl, 120
138Działa bezbłędnie hello.bf i primes.bf:
Inicjalizacja: Kod operacji do tabeli translacji Perla jest przechowywany w
%c
. Czytelny formularz wygląda następująco:Krok 1: Wprowadź dane programu Slurp
$_
i przekształć je w kod Perla za pomocą tabeli translacji. Komentarze są automatycznie usuwane (zastępowane przezundef
) na tym etapie.Krok 2: Rozpakuj wszystkie
$b[$p]
wystąpieniaKrok 3: Uruchom program za pomocą
eval
.źródło
qw
składni Perla, aby%c
bezpośrednio zdefiniować - dobre dla 7 mniej znaków (musisz powiedziećprint+chr$b[$p]
iord(getc)
chociaż)Python (bez ewaluacji), 317 bajtów
źródło
f(u,c,k)
while b*c[c[0]]and j<1
sięwhile b*c[c[0]]*(j<1)
16-bitowy kod maszynowy 8086: 168 bajtów
Oto wersja zakodowana w standardzie base64 , przekonwertuj i zapisz jako „bf.com” i uruchom z wiersza polecenia systemu Windows: „bf progname”
EDYTOWAĆ
Oto jakiś asembler (w stylu A86) do stworzenia pliku wykonywalnego (musiałem to odtworzyć, ponieważ zgubiłem oryginalne źródło!)
źródło
pieprzenie mózgu ,
843691 bajtówEdycja: postanowiłem ponownie to sprawdzić i znalazłem zaskakującą liczbę sposobów gry w golfa poza bajtami
Pobiera to dane wejściowe w postaci, w
code!input
której!input
opcja jest opcjonalna. Symuluje także komórki ujemne bez użycia samych komórek ujemnych i może przechowywać do(30000-(length of code+6))/2
komórek.Wypróbuj online!
źródło
Ruby 1.8.7,
188185149147 znakówNieco czytelna wersja:
Jak widzisz, bezwstydnie ukradłem twój pomysł na tłumaczenie na język hosta, a następnie za pomocą eval, aby go uruchomić.
źródło
>0
zamiast testowania równość:!=0
. Specyfikacja mówi „bez znaku”, a przepełnienie jest niezdefiniowane.3e4
będzie również działać w przeciwieństwie do30000
File.read($*.pop).bytes
-> też$<.bytes
powinno działać{?a,"foo"}
który jest równoważny z{?a=>"foo"}
. I testowanie tutaj pokazuje, że faktycznie może zastąpićFile.read($*.pop).bytes
z$<
bez żadnych problemów. Również wstawienie wszystkiego do czegoś takiego jakeval"a[0]..."+$<.bytes.map{?.,"putc a[i]",...}*";"
skraca rozwiązanie o kolejne kilka znaków.Binary Lambda Calculus 112
Program pokazany na zrzucie szesnastkowym poniżej
oczekuje, że jego dane wejściowe będą składały się z programu Brainfuck (patrząc tylko na bity 0,1,4 w celu rozróżnienia między -. + <>] [), a następnie a], a następnie danych wejściowych dla programu Brainfuck.
Zapisz powyższy zrzut heksowy za pomocą xxd -r> bf.Blc
Chwyć interpreter blc z https://tromp.github.io/cl/cl.html
Witaj świecie!
źródło
Retina 0.8.2 ,
386391386 bajtówKod zawiera niedrukowalne
0x00
znaki NUL ( ). Nie jest jeszcze super golfa, ponieważ jest już naprawdę wolny, a jeśli będę grać w golfa więcej, nie wiem, ile czasu zajmie ukończenie. Wydaje się, że upłynął limit czasu na próbce znalezienia pierwszego.Mogą występować błędy w tłumaczu online lub w moim programie (nowe wiersze nie są wyświetlane na wyjściu?).
Przyjmuje dane wejściowe jak
<code>│<input>
. Nie, to nie jest potok (|
). To znak UnicodeU+2502
. Kod wykorzystuje również znaki Unicodeÿ▶◀├║
. Znaki Unicode są używane do obsługi wprowadzania wszystkich znaków ASCII. Dlatego te znaki należy oddzielić od kodu znakiem innym niż ASCII.Wypróbuj online
Zauważ, że jest tam końcowy znak nowej linii.
Krótkie wyjaśnienie:
Zero
0x00
są używane do taśmy, która jest nieskończona. Pierwsza zamiana ustawia interpreter w postaci▶<code>│<input>├<output>║▶<tape>
, w której pierwszy▶
jest wskaźnikiem kodu, a drugi wskaźnikiem taśmy.ÿ
to0xFF
(255), które jest używane do transliteracji (używanej do implementacji+
i-
) do zawijania komórek z powrotem do zera.◀
służy tylko do odczytu (w przypadku, gdy program jest zatrzymany w środku lub chcesz zobaczyć wykonanie programu w połowie). W przeciwnym razie nie można określić, w którą stronę porusza się wskaźnik.Skomentowany kod:
Kliknij tutaj, aby uzyskać kod z zerami zamiast pustych bajtów. Wszelkie wystąpienia
$0
nie powinny być zastępowane zerami.Edycja : teraz obsługuje puste dane wejściowe i pomija końcowe znaki nowej linii.
Nieskończone wyjście jest teraz obsługiwane. (403 bajty)
źródło
<code>
, a<tape>
obok siebie (choć byłoby więcej znaków) tak, że przejście do tłumacza SMBF byłoby łatwiejsze, jeśli kiedykolwiek zdecydujesz się zrobić.TI-BASIC, 264 bajty
Z powodu ograniczeń w TI-BASIC, to tak naprawdę nie kwalifikuje się do tego wyzwania, ponieważ łamie zasadę 2; RAM kalkulatorów jest bardzo ograniczony, a zrobienie czegoś takiego
30000->dim(L1
(używam L1 do stosu / tablicy) zmusi go do rzuceniaERR:MEMORY
. W związku z tym stos / tablica zaczyna się od wielkości 1 i rośnie, jeśli wskaźnik wskazuje na element poza jego końcem. Łamie także zasadę 3, ponieważ już łamie zasadę 2, więc równie dobrze mogę nie zawracać sobie głowy limitem wielkości komórki.Nawiasem mówiąc, prawdopodobnie nadal można grać w golfa ... Wprowadziłem jedną lub dwie zmiany w tym celu od pierwszego przesłania, ale jeśli poniższa wersja nie działa, wróć do edycji od 6 maja 2015 roku i skorzystaj z niej zamiast tego kod. Ponadto, ponieważ tak naprawdę nie ma ASCII w TI-BASIC, przyjmuje dane liczbowe o dowolnej wielkości (i wszystko, co zwraca liczbę, na przykład zmienną lub wyrażenie) jako dane wejściowe, a następnie wypisuje liczby.
Użyj SourceCodera, aby wbudować go w plik .8xp, a następnie wyślij go do kalkulatora za pomocą TI-Connect lub TILP lub czegoś takiego, i uruchom go, włączając w to swój program typu „pieprzenie mózgu” w podwójnych cudzysłowach, a następnie dwukropek i dowolną nazwę programu TI-BASIC. Na przykład, jeśli nazwał ją BRAINF, można uruchomić program tak:
"brainfuck goes here":prgmBRAINF
. Jeśli masz powłokę na swojej Calc, który przechwytuje inne polecenia, gdy wykryjeprgm
znak, choć to zrobić:"brainfuck goes here" -> press ENTER -> prgmBRAINF
.Jeśli nie masz sposobu na podłączenie kalkulatora do komputera, a zamiast tego chcesz wpisać to na kalkulatorze (nie mogę sobie wyobrazić, dlaczego chcesz, ale dygresję) zauważ, że
->
jest toSTO>
przycisk nad ON klucz,~
jest symbolem ujemnym obok ENTER i zastępuje wszystkie wystąpieniaL<number>
odpowiednim tokenem listy znalezionym na2ND -> <number on keypad>
Dzięki thomas-kwa (przynajmniej myślę, że to jego nazwa użytkownika Stack) za pomoc w optymalizacji tego, szczególnie z instrukcjami
[
i]
.źródło
Ans+S
?S-sum(not(cumSum(L4(Ans)=seq(L4(X),X,Ans+1,dim(L4->S
. (a-a=0
). I hej, nie martw się, że zapomnisz tutaj o JEDNEJ kolejności operacji, widziałem wielu ludzi, którzy zapominają o kolejności operacji dla%
(mod) na wyzwaniu.Python
275248255Postanowiłam spróbować.
źródło
exec t
?). Jeśli użyjesz końcówki S. Mark , a także przekształcisz całyfor
cykl w jedną linię, możesz zmniejszyć ją do 243 znaków.[]
ważny, choć trywialny program bf. Zasugerowałem edycję, która to rozwiązuje, ale zwiększa liczbę znaków. Aby jeszcze bardziej zmniejszyć liczbę znaków, możeszfrom sys import *
i używaj'i+=1,...'.split(',')
zamiast['i+=1',...]
.+1
, ale wiele ulepszeń zostało zasugerowanych i nie zostało wdrożonych.Haskell,
457413znakówTen kod „kompiluje” program BF do
IO
działania w postaciState -> IO State
suwaka na nieskończonym łańcuchu.Smutne, że musiałem wydać 29 znaków, aby wyłączyć buforowanie. Bez nich to działa, ale nie widzisz monitów przed wpisaniem danych wejściowych. Sam kompilator (
b
,f
ik
) ma tylko 99 znaków, środowisko wykonawcze (#
i%
) ma 216. Sterownik z / stan początkowy kolejne 32.aktualizacja 2011-02-15: Wprowadzono sugestie JB, zmieniono nieco nazwę i zaostrzono
main
źródło
IO
, a argumenty z justSystem
(-19). Niepokoi mnie również kwestia buforowania, ponieważ specyfikacja tak naprawdę nie wspomina o tym, a najczęściej głosowana odpowiedź nawet nie I / O. Jeśli trzeba go zachować, to chyba krótszehFlush
po każdym zapisie niż zmienić ustawienia globalne buforowania (-34 + 15).Przenośnik, 953
To może być najpiękniejszy kod, jaki kiedykolwiek zobaczysz:
źródło
C
284362 (z pliku)Liczby pierwsze:
Skompilowano i uruchomiono pomyślnie VS2008
Oryginalne rozwiązanie nie rozpoznało pętli, które początkowo były ustawione na zero. Wciąż trochę miejsca na golfa. Ale w końcu rozwiązuje program Prime Number.
Nie golfowany:
Testy:
Witaj świecie
Zgnilizna 13
źródło
l
) przy każdej pętli? Myślę, że powinieneś sprawdzić bieżącą lokalizację head (p
).l
w buforze osiągnął zero, i łamie się, w przeciwnym razie resetuje strumień z powrotem do oryginalnej pętli[
. Jest to konieczne w przypadku zagnieżdżonych[
pętli.break;else
przezreturn;
.(c==62)?a:b
z(c-62)?b:a
.PHP 5.4,
296294273263261209191183178166 znaków:Dałem mu szansę bez użycia eval, ale ostatecznie musiałem go użyć
Wszystkie polecenia działają. To mocno nadużywa zmiennych zmiennych i wyrzuca ostrzeżenia. Jednak jeśli ktoś zmieni swoje php.ini na ostrzeżenia o squelch (lub potoki stderr na / dev / null), działa to świetnie.
Weryfikacja (przykład „Hello World!” Z Wikipedii ): http://codepad.viper-7.com/O9lYjl
Niegolfowany,
367365335296267 znaków:Należy to uruchomić za pomocą wiersza polecenia:
php bf.php hello.bf
źródło
Windows PowerShell, 204
Dość prosta konwersja instrukcji, a następnie
Invoke-Expression
.Historia:
3e4
jest krótszy niż30000
.switch
.Write-Host
.źródło
C, 333 znaków
To mój pierwszy interpreter BF i pierwszy golf, który musiałem debugować.
Działa to na generatorze liczb pierwszych w systemie Mac OS X / GCC, ale
#include<string.h>
może być konieczne dodatkowe, kosztem 19 dodatkowych znaków, jeśli niejawna definicjastrchr
nie działa na innej platformie. Zakłada równieżO_RDONLY == 0
. Poza tym pominięcieint
deklaracjiM
zapisuje 3 znaki, ale wydaje się, że nie jest to zgodne z C99. To samo z trzecim*
wb()
.Zależy to od szczegółów kodowania ASCII. Wszystkie operatory Brainfuck są parami komplementarnymi oddzielonymi odległością 2 w przestrzeni kodu ASCII. Każda funkcja w tym programie implementuje parę operatorów.
źródło
#define
drobnych poprawek, a użycie zamiast tabeli funkcji byłoby również bardziej przydatne. Podoba mi się numer 333 i tabela: v).||
.CJam, 75 bajtów
Wypróbuj online: odwracacz strun , Hello World .
Wyjaśnienie
Pobiera kod w pierwszym wierszu STDIN i wprowadza wszystkie wiersze poniżej.
Co z tą magiczną listą?
Wynikowa lista jest następująca:
Generujemy fragmenty dla
+
i>
od tych dla-
i<
, po prostu zmieniając lewe pareny („dekrementacja” CJam) na prawe parens („inkrement” CJam).źródło
F #: 489 znaków
Poniższy program nie przeskakuje do instrukcji „[” / „]”, ale skanuje kod źródłowy w poszukiwaniu następnego pasującego tokena. To oczywiście spowalnia, ale wciąż może znajdować liczby pierwsze poniżej 100. Typy liczb całkowitych F # nie przepełniają się, ale zawijają.
Oto krótka wersja:
Paskudne gotcha było to, że program primes.bf dusi się na nowej linii Windows. Aby go uruchomić, musiałem zapisać numer wejściowy w formacie tekstowym w formacie UNIX i podać go do programu za pomocą potoku:
Edycja: wprowadzenie Alt + 010, a następnie Enter również działa w Windows cmd.exe
Oto dłuższa wersja:
źródło
Delfy,
397382378371366364328 znakówZjedz to Delphi!
Tutaj ten sam kod, wcięty i skomentowany:
Ten zajął mi kilka godzin, ponieważ nie jest to typ kodu, który zwykle piszę, ale baw się dobrze!
Uwaga: Test główny działa, ale nie kończy się na 100, ponieważ czyta # 13 (CR) przed # 10 (LF) ... czy inne zgłoszenia również mają ten problem, gdy działają na systemach operacyjnych CRLF?
źródło
C, 260 + 23 = 283 bajtów
Stworzyłem program C, który można znaleźć tutaj .
Musi zostać skompilowany za pomocą
gcc -D"q(a,b)"="*c-a||(b);" -o pmmbf pmmbf.c
i może być wywoływany w następujący sposób: wpmmbf ",[.-]" 30000
którym pierwszy argument (cytowany) zawiera program bf do uruchomienia, drugi określa, jak duża powinna być taśma.źródło
-D"q(a,b)"="*c-a||(b);"
opcji, ponieważ wydaje mi się to (przynajmniej w moim ograniczonym rozumieniu), aby pomóc ci zmniejszyć kod.define
i nowej linii, ale nie sądzę, że to naprawdę koszerne. W każdym razie z cytatami, komentarzami igcc -D
wcale nie widzę przewagi.C 267
Uruchom jako ./a.out primes.bf
Wersja bez golfa:
źródło
Python 2, 223
Przyznaję, że poddałem recyklingowi mój stary program (ale musiałem go nieco zmienić, ponieważ stara wersja nie miała danych wejściowych, ale sprawdzanie błędów ...).
Działa poprawnie kalkulator liczb pierwszych.
Widzę teraz, że Alexandru ma odpowiedź, która ma pewne podobieństwa. I tak opublikuję wiele odpowiedzi, ponieważ myślę, że są w tym nowe pomysły.
źródło
C (gcc) Linux x86_64,
884 621 525 487 439 383 358354 bajtówWypróbuj online!
Jest to JIT, który kompiluje kod BF do języka maszynowego x86_64 w czasie wykonywania. Wykonuje tłumaczenia prostą tak powszechnie występujące sekwencje, takie jak
>>>
,<<<
,+++
i---
nie są coalesced do szybszych instrukcji.Wersja mniej golfowa:
źródło
C
374368Czyta z pliku. Przechodzi test PRIME.BF.
Zastosowanie: ./a.out PRIME.BF
Przeformatowany:
źródło
Lua, 285
Nieco czytelna wersja:
Działa świetnie
Lua, 478, bez obciążania
Wersja do odczytu:
źródło
Brainfuck, 948 bajtów
Zajęło to trochę czasu. Grałem w interpretera Brainfuck przez ... nie mnie.
źródło
Przypomnijmy , 594 bajty
W skrócie: Recall nie ma operatorów arytmetycznych w klasycznym sensie, ma jedynie operacje bitowe. Nie możesz po prostu „dodać” itp. Recall jest również ściśle oparty na stosach.
Przykład 1: Wydrukuj coś
Wejście:
Wynik:
Przykład 2: Wyprowadzanie liczb kwadratowych do 100
Wejście:
Wynik:
Ten przykład może potrwać kilka minut i może spowodować komunikat „ta karta jest zawieszona”. Zignoruj to i poczekaj.
źródło
OCaml (lex), 497 znaków
OCamllex jest częścią standardowej dystrybucji OCaml.
Zapisz jako b.mll i uruchom z
Nie lubię parsowania ręcznie, więc użyłem dostarczonego generatora leksykalnego. Z odczytanych tokenów tworzymy funkcję dla całego programu brainf * ck.
źródło
C # (2861 znaków, ~ 84 linii)
To nie jest najładniejsze rozwiązanie problemu i prawdopodobnie nie wszystko z tego „golfa”, ponieważ nie martwiłem się tak długo, jak powinienem być. (Nie usunąłem komentarzy ani dodatkowej białej spacji). Chciałem tylko spróbować czegoś w nowym języku, aby zobaczyć, czy mogę. Gdybym to zrobił ponownie, porzuciłbym użycie stosu do powrotu z „]” i po prostu spojrzałem wstecz. Uruchom bez argumentów wiersza poleceń, uruchamia program hello world podany w opisie problemu. Akceptuje jeden argument wiersza poleceń, nazwę pliku programu do uruchomienia.
Edycja: Usunięto nieużywane odwołania.
źródło
C (gcc) ,
273268 bajtówWypróbuj online!
-5 dzięki pułapce cat
Pobiera dane wejściowe ze standardowego wejścia.
To trochę zależy od środowiska, ale jest dość spójne. Jest to efektywne rozwiązanie dla c. Zapisuje odpowiedni program C do pliku wc, kompiluje go i uruchamia jako żądany plik wykonywalny. Zatem jako efekt bonusowy faktycznie kompiluje kod bf i pozostawia go
a.out
jako plik binarny. Pamiętaj, że w zależności od systemu może być konieczna modyfikacja ostatniego ciągu. W szczególności większość kompilatorów systemu Windows c nazywa domyślny plik wykonywalny „a.exe”. Na szczęście, o ile mi wiadomo, wszystkie mają tę samą długość, więc liczba bajtów jest taka sama. (chociaż jeśli nie masz zdefiniowanego cc, może być konieczne dodanie litery takiej jak gcc do polecenia kompilacji, dodanie 1 bajtu).Wiem, że ten wątek jest trochę stary, ale nie widziałem jeszcze tego stylu rozwiązania C, więc pomyślałem, że go dodam.
źródło
[EDYTOWAĆ]
C ++ 11, 355, czyta z pliku:
Test
http://ideone.com/b7vO4
[STARA WERSJA]
C ++ 11, 391, aby zobaczyć: http://ideone.com/yZHVv
źródło