Policz na zawsze

71

Napisz program, który liczy się na zawsze, zaczynając od jednego.

Zasady:

  • Twój program musi się zalogować na STDOUTakceptowalną alternatywę, jeśli STDOUTnie jest dostępna.
  • Twój program musi być pełnym programem, który można uruchomić, a nie funkcją lub fragmentem kodu.
  • Twój program musi wypisać każdą liczbę ze znakiem oddzielającym pomiędzy nimi (nowy wiersz, spacja, tabulator lub przecinek), ale musi to być spójne dla wszystkich liczb.
  • Można drukować numery w systemie dziesiętnym, w jednoskładnikowa lub w bazie 256, gdzie każda cyfra jest reprezentowana przez wartość bajtów .
  • Twój program musi liczyć co najmniej do 2 128 (włącznie) bez problemów i bez braku pamięci na rozsądnym komputerze stacjonarnym. W szczególności oznacza to, że jeśli używasz jednoargumentowej, nie możesz przechowywać w pamięci jednoznacznej reprezentacji bieżącego numeru.
  • W przeciwieństwie do naszych zwykłych zasad, możesz swobodnie używać języka (lub wersji językowej), nawet jeśli jest on nowszy niż to wyzwanie. Języki napisane specjalnie w celu przesłania 0-bajtowej odpowiedzi na to wyzwanie są uczciwą grą, ale nie są szczególnie interesujące.

    Pamiętaj, że musi być tłumacz, aby można było przetestować zgłoszenie. Zezwala się (a nawet zachęca) do samodzielnego napisania tego tłumacza dla wcześniej niewdrożonego języka.

  • Nie chodzi o znalezienie języka z najkrótszym rozwiązaniem tego problemu (są takie, w których pusty program rozwiązuje problem) - chodzi o znalezienie najkrótszego rozwiązania w każdym języku. Dlatego żadna odpowiedź nie zostanie oznaczona jako zaakceptowana.

Katalog

Fragment kodu na dole tego postu generuje katalog na podstawie odpowiedzi a) jako listy najkrótszych rozwiązań dla każdego języka oraz b) jako ogólnej tabeli wyników.

Aby upewnić się, że Twoja odpowiedź się pojawi, zacznij od nagłówka, korzystając z następującego szablonu Markdown:

## Language Name, N bytes

gdzie Njest rozmiar twojego zgłoszenia. Jeśli poprawić swój wynik, to może zachować stare porachunki w nagłówku, uderzając je przez. Na przykład:

## Ruby, <s>104</s> <s>101</s> 96 bytes

Jeśli chcesz umieścić w nagłówku wiele liczb (np. Ponieważ twój wynik jest sumą dwóch plików lub chcesz osobno wymienić kary za flagi tłumacza), upewnij się, że rzeczywisty wynik jest ostatnią liczbą w nagłówku:

## Perl, 43 + 2 (-p flag) = 45 bytes

Możesz także ustawić nazwę języka jako link, który pojawi się we fragmencie:

## [><>](http://esolangs.org/wiki/Fish), 121 bytes

vrwim
źródło
29
Nie jestem pewien, w jaki sposób połączyć wyjście musi każdy numer z charakterem oddzielającej pomiędzy ze mogą drukować numerów [...] w bazie 256 .
Dennis
6
Czy w przypadku przyszłych wyzwań mogę polecić piaskownicę , aby wszystkie te szczegóły mogły zostać uporządkowane, zanim ludzie zaczną publikować odpowiedzi? :)
Martin Ender
3
@IlmariKaronen Interpretuję to jako limit pamięci, a nie limit czasu. ewentualnie limit czasu na przyrost. po prostu ustaw licznik na 2 ** 128-10 i sprawdź, ile czasu zajmuje wykonanie ostatnich dziesięciu kroków.
Sparr
5
Czy możemy mieć wyjściowe zera na wyjściu?
Paŭlo Ebermann
4
Ugh !!! Mam odpowiedź na temat TI-89 (56b), ale nie mogę opublikować b / c Jestem nowy na stronie i nie mam Rep 10+!
gregsdennis,

Odpowiedzi:

63

Labirynt , 5 bajtów

):
\!

IP Adres IP w kodzie się kręci round

Odpowiednie instrukcje:

)       Increment top of stack (stack has infinite zeroes at bottom)
:       Duplicate top of stack
!       Output top of stack
\       Output newline
Sp3000
źródło
77
Program jest smutny, że się nie zatrzymuje ...
Optymalizator
7
@Optimizer def sad (rzeczywiście):
YoYoYonnY
1
Dlaczego to nie 4 bajty?
Aurel Bílý
2
@ Aurel300 Piąty bajt jest nowej linii pomiędzy :i\
SP3000
@ Sp3000 Ah, tak. Głupi ja. :)
Aurel Bílý
46

> <> , 8 bajtów

01+:nao!

Kroki:

  • Naciśnij 0 na stosie
  • Dodaj 1 do górnego elementu stosu
  • Zduplikowany element górnego stosu
  • Wyprowadzaj górę stosu jako liczbę
  • Wyjście nowego wiersza
  • Przejdź do kroku 2, owijając się i przeskakując następną instrukcję (krok 11)

(Program mniej wydajny (a więc nieprawidłowy)) llnao.

randomra
źródło
66
+1 za niecierpliwy domagający się głosowania domyślnie w wierszu kodu, który w zasadzie czyta „plus jeden, teraz!”.
Janus Bahs Jacquet
24

Haskell, 21 bajtów

main=mapM_ print[1..]

Liczby całkowite o dowolnej dokładności i nieskończone listy ułatwiają to :-)

Na szczęście mapM_jest w Preludium. Gdyby Data.Traversabletak było, moglibyśmy nawet zmniejszyć go do 19 bajtów:

main=for_[1..]print
Bergi
źródło
Czy nie ma symbolu, który uogólnia mapę / mapM itp?
JDługosz
@ JDługosz: nie, że wiem
Bergi,
Ach, ponieważ musiałoby to jeszcze doprowadzić do sequencetego, aby wyjście naprawdę się wydarzyło.
JDługosz
nie jest po prostu [1..]dozwolone, ponieważ wypisuje wszystkie liczby przecinkiem między nimi? czy pierwszy [to wszystko schrzanić?
Baconaro,
@Baconaro: to lista, nic nie drukuje. GHCi drukuje wynik, jeśli wpiszesz termin w replice, ale nie jest to program uruchamialny. I tak, prowadzenie [nie jest dozwolone.
Bergi,
23

Gol> <> , 3 bajty

P:N

Kroki:

  • Dodaj 1 do górnego elementu stosu (na początku jest to domyślnie 0)
  • Zduplikowany element górnego stosu
  • Pop i wypisz górę stosu jako liczbę i nowy wiersz
  • Przejdź do kroku 1, gdy dotarliśmy do końca linii
randomra
źródło
21

Marbelous , 11450 4632 bajtów

Drukowanie miejsc po przecinku to ból !!

Zdecydowanie nie wygrywam z tym, ale pomyślałem, że dam temu szansę. Mam nadzieję, że to w porządku, że uzupełnia wyjście do 40 zer (aby zmieścić 2 ^ 128).

00@0..@1..@2..@3..@4..@5..@6..@7..@8..@9..@A..@B..@C..@D..@E..@F..@G..@H..@I..@J
\\++..00..00..00..00..00..00..00..00..00..00..00..00..00..00..00..00..00..00..00
..EhunEhunEhunEhunEhunEhunEhunEhunEhunEhunEhunEhunEhunEhunEhunEhunEhunEhunEhunEhun
....AddtAddtAddtAddtAddtAddtAddtAddtAddtAddtAddtAddtAddtAddtAddtAddtAddtAddtAddt
..&7..&7..&7..&7..&7..&7..&7..&7..&7..&7..&7..&7..&7..&7..&7..&7..&7..&7..&7..&7\/
../\&8..........................................................................
....@0..........................................................................
....../\&8......................................................................
....//..@1......................................................................
........../\&8..................................................................
......////..@2..................................................................
............../\&8..............................................................
........//////..@3..............................................................
................../\&8..........................................................
..........////////..@4..........................................................
....................../\&8......................................................
............//////////..@5......................................................
........................../\&8..................................................
..............////////////..@6..................................................
............................../\&8..............................................
................//////////////..@7..............................................
................................../\&8..........................................
..................////////////////..@8..........................................
....................................../\&8......................................
....................//////////////////..@9......................................
........................................../\&8..................................
......................////////////////////..@A..................................
............................................../\&8..............................
........................//////////////////////..@B..............................
................................................../\&8..........................
..........................////////////////////////..@C..........................
....................................................../\&8......................
............................//////////////////////////..@D......................
........................................................../\&8..................
..............................////////////////////////////..@E..................
............................................................../\&8..............
................................//////////////////////////////..@F..............
................................................................../\&8..........
..................................////////////////////////////////..@G..........
....................................................................../\&8......
....................................//////////////////////////////////..@H......
........................................................................../\&8..
......................................////////////////////////////////////..@I..
............................................................................../\&8
........................................//////////////////////////////////////..@J
&9&9&9&9&9&9&9&9&9&9&9&9&9&9&9&9&9&9&9&9
Sixteenbytedecimalprintermodulewitharegi

:Sixteenbytedecimalprintermodulewitharegi
}J}J}I}I}H}H}G}G}F}F}E}E}D}D}C}C}B}B}A}A}9}9}8}8}7}7}6}6}5}5}4}4}3}3}2}2}1}1}0}00A
/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A
%A..%A..%A..%A..%A..%A..%A..%A..%A..%A..%A..%A..%A..%A..%A..%A..%A..%A..%A..%A..
+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O..
+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O..

:/A
..}0..}0..
..>>}0....
..>>>>\\..
....//..//
../\>>\\..
....>>..//
....>>\\..
....>>....
\\>>//....
..>>......
..>>......
../\......
..../\<<..
......<<..
..\\<<//..
....~~....
....++....
....\\..//
\\....>9\/
..\\..?0..
......++..
....\\....
......{0..

:%A
@0..
}0..
<A-A
{0@0

:Eg
}0}0}0}0}0}0}0}0
^7^6^5^4^3^2^1^0
~~....~~~~..~~~~
^0^0^0^0^0^0^0^0
{0{0{0{0{0{0{0{0

:Ehun
}0..}0
Eg..&0
=8&0{0
&1\/00
0100&0
&1&1{1
{1{0

:Addt
}0}1
{1{1
Doktor
źródło
Czy drukowanie binarne byłoby krótsze?
SuperJedi224,
3
(a co z Unarym?)
Klamka
@Doorknob wyświetlający dane wyjściowe nie jest problemem. Jest to coś na Ehunplanszy, które powinno zwiększać kolejną cyfrę, ale nie działa poprawnie
TheDoctor
1
Czy wiesz, że możesz pominąć kropki na końcu każdej linii i puste linie między deskami i użyć pojedynczych znaków do nazw tablic? Musisz tylko powtórzyć tej pojedynczej postaci odpowiednią ilość czasu, aby ją wezwać. To może sprowadzić twoją odpowiedź do około 3000 bajtów.
overactor
W końcu jadę do pchania zobowiązać się do marbelous.py że zawiera wszystkie include/domyślnie
Sparr
18

C (tylko architektura 64-bitowa), 53 bajty

Opiera się na wskaźnikach o długości co najmniej 64 bitów i drukuje je w formacie szesnastkowym przy użyciu %pspecyfikatora. Program powróci zaraz, gdy osiągnie 2 ^ 128.

char*a,*b;main(){for(;++b||++a;)printf("%p%p ",a,b);}
feersum
źródło
1
Więc jeśli te wskaźniki są na każdym 64-bitowym, możesz liczyć tylko na 2 ^ 128-1, prawda?
flawr
6
Niepoprawny, ponieważ nie może liczyć do 2 ^ 128
edc65
14
Lubię CodeGolf, jeśli chodzi o wyrażanie i nagradzanie kreatywności. feersum wyraźnie nie konkuruje tutaj o zwycięstwo. Smutne jest to, że widzę wiele negatywnych opinii na temat techniki i modyfikuję sformułowanie pytania, aby upewnić się, że jego odpowiedź narusza zasady.
flodel
3
Myślałem, że słowa „przynajmniej do 2 ^ 128” były wystarczająco jasne ...
vrwim
5
@vrwim Nie napisałeś tego. Napisałeś „do 2 ^ 128”. SuperJedi edytował to kilka minut temu.
feersum
17

Sześciokąt , 12 11 10 7 bajtów

Dzięki alephalpha za dopasowanie kodu do boku 2.

10})!';

Rozłożony:

 1 0
} ) !
 ' ;

Ten jest dość prosty. 10zapisuje 10, tzn. wysuwa wiersz do początkowej krawędzi pamięci. Następnie })!';jest wielokrotnie wykonywany w pętli:

  • } przejdź do następnej krawędzi pamięci.
  • ) zwiększ to.
  • ! wydrukuj jako liczbę całkowitą.
  • ' wróć do 10.
  • ; wydrukuj jako postać.

Uważam, że jest to optymalne (choć zdecydowanie nie unikalne). Mam niech brute force napisałem skrypt do tej odpowiedzi poszukiwaniu rozwiązań 6-bajtowych przy założeniu, że będzie musiał zawierać co najmniej po jednym z ;i !i albo (albo )i nie zawierają ?, ,albo @i nie zrobił znajdź jakieś rozwiązania.

Martin Ender
źródło
13

Pyth, 4 bajty

.V1b

Wyjaśnienie:

.V1    for b in range(1 to infinity):
   b      print b
Jakube
źródło
f!\n( Link TIO ) będzie działał przez 3 bajty, ale nie jestem pewien, czy korzysta on z funkcji dodanych po Twojej odpowiedzi.
Sok
@Sok Clever. Jednak nie zmienię odpowiedzi, ponieważ myślę, że fbyła to cecha Pytha 4 lata temu.
Jakube
Też tak myślałem, dlatego zostawiłem to jako komentarz - nowe funkcje językowe do pokonania starszej odpowiedzi zawsze są tanie IMO
Sok
13

pne, 10

for(;;)++i

Niezwykłe to bc to jest krótsze niż dc.

Od man bc :

OPIS

bc jest językiem obsługującym dowolne precyzyjne liczby

Cyfrowa trauma
źródło
Gdzie to drukuje?
Bálint
@ Bálint ++ijest wyrażeniem, ale nie przypisaniem i dlatego jest jawnie wyprowadzany. Próbowałeś go uruchomić? echo 'for(;;)++i' | bcw najbliższym terminalu Linux.
Digital Trauma
W moim domu nie ma ani jednego terminala Linuksa. Byłem tylko ciekawy.
Bálint
6
@ Bálint Każdy dom powinien mieć terminal Linux.
Cyfrowa trauma
1
@ Bálint Uruchamianie tego programu należy do ciebie;)
Szalony
12

Java, 139 138 127 123 bajtów

class K{public static void main(String[]a){java.math.BigInteger b=null;for(b=b.ZERO;;)System.out.println(b=b.add(b.ONE));}}
SuperJedi224
źródło
2
Mniejsza nieskończona pętla w java jest for(;;)przeznaczona na łatwe 3 bajty.
ankh-morpork
Możesz także zapisać kolejne 2 za pomocą BigInteger b=null;b=b.ZERO;, niestety, =nulljest to potrzebne, nawet myślałem, że jest to dostęp statyczny.
TWiStErRob
A potem kolejne 9, ponieważ możesz pozbyć się importu, odwołując się BigIntegerdo FQCN tylko raz.
TWiStErRob
@TWiStErRob Jakoś nie zdawałem sobie sprawy, że będzie krótszy.
SuperJedi224,
2
W przypadku języka Java 8 lub nowszego można zastąpić klasę funkcją interfacei usunąć ją publicz funkcji. Nie chcę kopiować kodu i publikować go jako nowej odpowiedzi.
Luca H
10

Mathematica, 22 bajty

i=0;While[Echo[++i]>0]

Echo jest nową funkcją w Mathematica 10.3.

alephalpha
źródło
Echodaje cztery znaki oddzielające: znak nowej linii ">> ". Nie jestem pewien, czy jest to poprawne - może Printzamiast tego użyć ? Zapisz bajt za pomocą i=0;While[Echo@++i>0].
Roman
7

Rubin, 15 12 bajtów

loop{p$.+=1}
  • p, gdy podano liczbę całkowitą, drukuje liczbę całkowitą taką, jaka jest (dzięki uprzejmości @philomory )
  • $.to magiczna zmienna przechowująca liczbę linii odczytanych ze standardowego wejścia. Jest oczywiście inicjowany na 0, a także przypisywany :)
daniero
źródło
@ philomory Zazwyczaj sugeruje się użytkownikom pozostawienie komentarza sugerującego rozwiązanie oszczędzające bajty. Chciałbym też zobaczyć wyjaśnienie tego. c:
Addison Crump
7

Python 3, 33 25 bajtów

O ile rozumiem, liczby całkowite w Pythonie są dowolne i print()automatycznie tworzą nowe linie.

Dzięki za @Jakub i @ Sp3000 i @wnnmaw! Naprawdę nie znam dużo Pythona, jedyne, co wiedziałem, to to, że obsługuje liczby całkowite o dowolnym rozmiarze =)

k=1
while 1:print(k);k+=1
wada
źródło
1jest prawdziwą wartością w Pythonie (i większości innych języków). To while 1:wystarczy.
Jakube
Możesz też umieścić całość whilew jednym wierszu
Sp3000,
Możesz zapisać bajt, używając repr(k)raczej niż print(k). Ponadto liczę twój bajt jako 25 (bez mojej sugerowanej zmiany)
wnnmaw
1
Nie możesz użyć reprzamiast print. reprnic nie wyprowadza. @wnnmaw
Zach Gates
Co reprwtedy robi?
flawr
6

Przetwarzanie , 95 85 71 bajtów

java.math.BigInteger i;{i=i.ZERO;}void draw(){println(i=i.add(i.ONE));}

Próbowałem czegoś z pętlą while, ale powoduje to awarię całego Przetwarzania, więc na razie pozostanę przy tym.

(Dzięki @ SuperJedi224 i @TWiStErRob za sugestie.)

geokavel
źródło
Co ze spacjami? Jestem pewien, import java.math.*;BigInteger i=BigInteger.ZERO;void draw(){println(i=i.add(BigInteger.ONE));}że zadziała.
SuperJedi224,
Tak, właśnie to naprawiłem.
geokavel
Czy przetwarzanie pozwala na BigInteger.ONEzmianę na i.ONE?
SuperJedi224,
@ SuperJedi224 Tak, robi. Dzięki!
geokavel
W porządku, głosuj pozytywnie.
SuperJedi224,
6

Samau , 2 bajty

N)

Wyjaśnienie:

N     push the infinite list [0 1 2 ...] onto the stack
 )    increase by 1

Gdy wyjściem programu jest lista, skrajne nawiasy kwadratowe są pomijane.

alephalpha
źródło
Czy lista nie drukuje całej zawartości jednocześnie? Jeśli ta lista jest nieskończona , prawdopodobnie nie zmieści się w pamięci ani na ekranie i nigdy nie przestanie być generowana, więc nigdy nie zostanie wydrukowana.
kot
1
@cat Samau jest napisany w Haskell i jest leniwy . Nie wygeneruje całej listy przed wydrukowaniem.
alephalpha
Tylko jedna głowa do góry. Na stronie GitHub dla Samau w opisie @„push” jest błędnie napisane.
Carcigenicate
@Carcigenicate Dziękujemy.
alephalpha
6

JavaScript (ES6), 99 94 67 bajtów

for(n=[i=0];;)(n[i]=-~n[i++]%10)&&alert([...n].reverse(i=0).join``)

alertjest ogólnie przyjętym STDOUTodpowiednikiem JavaScript, ale użycie go oznacza, że ​​kolejne liczby są automatycznie rozdzielane. Założyłem, że z tego powodu wypisywanie znaku po liczbie nie jest konieczne.

użytkownik 81655
źródło
12
Dlatego mam blokadę wyskakujących okienek.
Comintern
1
tylko mówiąc: dla (i = 0 ;;) alert (i ++) Nie sądzę, że potrzebujesz wszystkich tych kontroli
towc
3
@towc To nie zadziała. Wszystkie liczby są 64-bitowymi liczbami zmiennoprzecinkowymi w JavaScript, które mają maksymalną bezpieczną wartość całkowitą równą, 2^53ale pytanie wymaga, aby je podnieść 2^128.
user81655,
1
och, uczciwy punkt ...
towc
5

Matlab, 132 bajty

a=0;while 1;b=a==9;n=find(cumsum(b)-(1:numel(b)),1);a(n)=a(n)+1;a(1:n-1)=0;if ~numel(n);a=[0*a,1];end;disp([a(end:-1:1)+'0','']);end

Ok, myślę, że jest to pierwsza poważna odpowiedź, która wykonuje to zadanie bez trywialnej liczby całkowitej wielkości arytmetycznej. Ten program implementuje liczbę całkowitą o dowolnym rozmiarze jako tablicę liczb całkowitych. Każda liczba całkowita ma zawsze wartość od 0 do 9, więc każdy element tablicy reprezentuje jedną cyfrę dziesiętną. Rozmiar tablicy zostanie zwiększony o jeden, gdy tylko będziemy na np 999. Rozmiar pamięci nie stanowi tutaj problemu, ponieważ 2^128wymaga tylko tablicy o długości 39.

a=0;
while 1
    b=a==9;
    %first number that is not maxed out
    n=find(cumsum(b)-(1:numel(b)),1);
    %increase that number, and sett all maxed out numbers to zero
    a(n)=a(n)+1; 
    a(1:n-1)=0;
    if ~numel(n) %if we maxed out all entries, add another digit
        a=[0*a,1];
    end    
    disp([a(end:-1:1)+'0',''])%print all digits
end
wada
źródło
5

C ++, 146 141 138 bajtów

Korzystanie z biblioteki standardowej bigint jest chyba najbardziej nudny sposób odpowiedzieć na to pytanie, ale ktoś musiał to zrobić.

#include<stdio.h>
#include<boost/multiprecision/cpp_int.hpp>
int main(){for(boost::multiprecision::uint512_t i=1;;){printf("%u\n",i++);}}

Nie golfowany:

#include<cstdio>
#include<boost/multiprecision/cpp_int.hpp>

int main()
{
    for(boost::multiprecision::uint512_t i=1;;)
    {
        std::printf("%u\n", i++);
    }
}

Powodem, dla którego gra w golfa jest używana, stdio.ha nie, cstdiojest unikanie konieczności używaniastd:: nazw.

To jest moja pierwsza gra w golfa w C ++, daj mi znać, jeśli są jakieś sztuczki, aby to jeszcze skrócić.

felixphew
źródło
Może mógłbyś użyć '\n'zamiast std::endl, zaoszczędziłby Ci 8 bajtów. Może być też sposób na użycie CPP #define do skompresowania niektórych powtórzeń,
Kenney
@ Kenney Dziękuję za to! (To oszczędza tylko 5 bajtów, a nie 8). Myślę, że mogłem wymyślić sposób na ulepszenie tej sekcji jeszcze krócej.
felixphew
Nie wiem boost (i nie powiedziałbym też, że jest to standard), ale nie jest idomyślnie skonstruowany z wartością 0? Następnie możesz usunąć definicję i przełączyć przyrostowy na preincremet, co pozwoli zaoszczędzić 2b
Zereges
Co powiesz na przestarzałe #import?
connectyourcharger
5

C # .NET 4.0, 111 103 102 97 bajtów

class C{static void Main(){System.Numerics.BigInteger b=1;for(;;)System.Console.WriteLine(b++);}}

Nie znalazłem tutaj żadnej odpowiedzi w języku C #, więc musiałem tylko napisać jedną.

.NET 4.0 jest wymagany, ponieważ jest to pierwsza wersja, która zawiera BigInteger . Musisz jednak odwołać się do System.Numerics.dll .

Z wcięciem:

class C
{
    static void Main()
    {   
        System.Numerics.BigInteger b = 1;
        for (;;)
            System.Console.WriteLine(b++);
    }
}

Dzięki sweerpotato, Kvam, Berend za uratowanie niektórych bajtów

Kazarp
źródło
Możesz zapisać 8 bajtów za pomocą class C{static void Main(){var b=System.Numerics.BigInteger.One;for(;;)System.Console.WriteLine(b++);}}: ~)!
sweerpotato,
1
Przenieś deklarację b Console.WriteLinedo struktury pętli:class C{static void Main(){for(var b=System.Numerics.BigInteger.One;;Console.WriteLine(b++));}}
Kvam
Nadal potrzebujesz System. To oszczędza jeden bajt!
sweerpotato,
Tak, masz rację.
Kvam
Jeśli dodasz using System;(13 bajtów), możesz pozbyć się System.(7 bajtów) dwa razy, oszczędzając 1 bajt.
Kenney
5

Clojure, 17 bajtów

(map prn (range))

Leniwe sekwencje i dowolne liczby całkowite precyzji ułatwiają to (tak jak w przypadku Haskell i CL). prnoszczędza mi kilka bajtów, ponieważ nie muszę drukować ciągu formatu. doseqprawdopodobnie byłby bardziej idiomatyczny, ponieważ tutaj mamy do czynienia tylko z efektami ubocznymi; mapnie ma większego sensu w użyciu, ponieważ utworzy sekwencję nil(która jest wartością zwracaną dla każdego z nichprn wywołania.

Zakładając, że liczę na zawsze, sekwencja wskaźnika zerowego wynikająca z tej operacji nigdy nie zostanie zwrócona.

MONODA43
źródło
4

MarioLANG , 11 bajtów

+<
:"
>!
=#

Zainspirowany odpowiedzią Martina Büttnera na inne pytanie .

alephalpha
źródło
Czy na pewno działa to bez problemów do 2 ^ 128?
flawr
1
To wygląda znajomo. :)
Martin Ender
@flawr MarioLANG ma interpreter języka Ruby, a typ liczbowy Ruby ma dowolną precyzję.
Martin Ender
@flawr To zależy od tłumacza. Tłumacz, którego używam, jest napisany w języku Ruby i obsługuje dowolną precyzję.
alephalpha
4

CJam, 7 bajtów

0{)_p}h

Wyjaśnienie:

0         e# Push a zero to the stack
 {        e# Start a block
  )         e# Increment top of stack
   _        e# Duplicate top of stack
    p       e# Print top of stack
     }    e# End block
      h   e# Do-while loop that leaves the condition on the stack

Uwaga: Należy użyć interpretera Java.

GamrCorps
źródło
4

C, 89 bajtów

Nowe podejście (implementujące moduł przyrostowy bitowy) w C:

b[999],c,i;main(){for(;;)for(i=c=0,puts(b);i++<998;)putchar(48+(c?b[i]:(b[i]=c=!b[i])));}

Mniej golfa

int b[999], c, i;
main() {
  for(;;)
    for(i=c=0, puts(b); i++ < 998;)
      putchar(48 + (c ? b[i] : (b[i] = c = !b[i])));
}

Zakończyć

Ta wersja ma niewielką wadę, polegającą na tym, że się nie kończy (co obecnie nie jest wymagane). Aby to zrobić, musisz dodać 3 znaki:

b[129],c=1,i;main(){for(;c;)for(i=c=0,puts(b);i++<128;)putchar(48+(c?b[i]:(b[i]=c=!b[i])));}
Helco
źródło
4
W rzeczywistości nie powinno to zakończyć się. Takie jest znaczenieforever
edc65
4

Foo , 6 bajtów

(+1$i)

Wyjaśnienie

(    )    Loop
 +1       Add one to current element
   $i     Output current element as a decimal integer
Zach Gates
źródło
4

Minkolang , 4 bajty

1+dN

Wypróbuj tutaj. (Właściwie uważaj. 3 sekundy czasu wystarczyły, aby dostać się do ~ 40 000).

1+dodaje 1 na górze stosu, dduplikuje go i Nwysyła górę stosu jako liczbę całkowitą z końcową spacją. Zapętla się, ponieważ Minkolang jest toroidalny, więc gdy licznik programu zejdzie z prawej krawędzi, ponownie pojawi się po lewej.

El'endia Starman
źródło
4

Zestaw Intel 8086+, 19 bajtów

68 00 b8 1f b9 08 00 31 ff f9 83 15 00 47 47 e2 f9 eb f1

Oto podział:

68 00 b8                push   0xb800             # CGA video memory
1f                      pop    ds                 # data segment
b9 08 00           L1:  mov    cx, 8              # loop count
31 ff                   xor    di, di             # ds:di = address of number
f9                      stc                       # set carry
83 15 00           L2:  adc    word ptr [di], 0   # add with carry
47                      inc    di
47                      inc    di
e2 f9                   loop   L2
eb f1                   jmp    L1

Wysyła 128 bitową liczbę w 8 górnych lewych pozycjach ekranu. Każda pozycja ekranu zawiera 8-bitowy znak ASCII i dwa 4-bitowe kolory.

Uwaga: otacza 2 128 ; wystarczy zmienić 8in, mov cx, 8aby 9wyświetlić liczbę 144 bitów, a nawet 80*25pokazać liczby do 2 32000 .

Bieganie

Skompresowana bzip2 1.44Mb, dyskietka startowa zakodowana w standardzie base64 Obraz

Wygeneruj obraz dyskietki, kopiując i wklejając następujące elementy

QlpoOTFBWSZTWX9j1uwALTNvecBAAgCgAACAAgAAQAgAQAAAEABgEEggKKAAVDKGgAaZBFSMJgQa
fPsBBBFMciogikZcWgKIIprHJDS9ZFh2kUZ3QgggEEh/i7kinChIP7HrdgA=

w tym wierszu poleceń:

base64 -d | bunzip2 > floppy.img

i biegać na przykład z qemu -fda floppy.img -boot a

Rozruchowy ISO 1,8 Mb

Jest to obraz ISO zakodowany w formacie bzip2 w formacie base64. Wygeneruj ISO, wklejając

QlpoOTFBWSZTWZxLYpUAAMN/2//fp/3WY/+oP//f4LvnjARo5AAQAGkAEBBKoijAApcDbNgWGgqa
mmyQPU0HqGCZDQB6mQ0wTQ0ZADQaAMmTaQBqekyEEwQaFA0AA0AxBoAAA9Q0GgNAGg40NDQ0A0Bi
BoDIAANNAA0AyAAABhFJNIJiPSmnpMQDJpp6nqeo0ZDQaAANB6IA0NAGj1EfIBbtMewRV0acjr8u
b8yz7cCM6gUUEbDKcCdYh4IIu9C6EIBehb8FVUgEtMIAuvACCiO7l2C0KFaFVABcpglEDCLmQqCA
LTCAQ5EgnwJLyfntUzNzcooggr6EnTje1SsFYLFNW/k+2BFABdH4c4vMy1et4ZjYii1FbDgpCcGl
mhZtl6zX+ky2GDOu3anJB0YtOv04YISUQ0JshGzAZ/3kORdb6BkTDZiYdBAoztZA1N3W0LJhITAI
2kSalUBQh60i3flrmBh7xv4TCMEHTIOM8lIurifMNJ2aXr0QUuLDvv6b9HkTQbKYVSohRPsTOGHi
isDdB+cODOsdh31Vy4bZL6mnTAVvQyMO08VoYYcRDC4nUaGGT7rpZy+J6ZxRb1b4lfdhtDmNwuzl
E3bZGU3JTdLNz1uEiRjud6oZ5kAwqwhYDok9xaVgf0m5jV4mmGcEagviVntDZOKGJeLjyY4ounyN
CWXXWpBPcwSfNOKm8yid4CuocONE1mNqbd1NtFQ9z9YLg2cSsGQV5G3EhhMXKLVC2c9qlqwLRlw4
8pp2QkMAMIhSZaSMS4hGb8Bgyrf4LMM5Su9ZnKoqELyQTaMAlqyQ3lzY7i6kjaGsHyAndc4iKVym
SEMxZGG8xOOOBmtNNiLOFECKHzEU2hJF7GERK8QuCekBUBdCCVx4SDO0x/vxSNk8gKrZg/o7UQ33
Fg0ad37mh/buZAbhiCIAeeDwUYjrZGV0GECBAr4QVYaP0PxP1TQZJjwT/EynlkfyKI6MWK/Gxf3H
V2MdlUQAWgx9z/i7kinChITiWxSo

w

base64 -d bunzip2 > cdrom.iso

i skonfiguruj maszynę wirtualną do uruchamiania z niej.

DOS .COM

Jest to plik wykonywalny DOS .COM zakodowany w standardzie base64 :

aAC4H7kIADH/+YMVAEdH4vnr8Q==

Wygeneruj plik .COM za pomocą

/bin/echo -n aAC4H7kIADH/+YMVAEdH4vnr8Q== | base64 -d > COUNTUP.COM

i uruchom go w (darmowym) systemie DOS.

Kenney
źródło
4

Perl , 34 32 30 28 26 23 bajtów

-Mbigint -E '{say$_+=1;redo}'

Przetestuj za pomocą

perl -Mbigint -E '{say$_+=1;redo}'
Kenney
źródło
Można wymienić for(,,){...}z {...;redo}dla dwóch osób.
primo,
Tak, widziałem (perl 5.18+), ale myślałem, że to może być oszustwo; wtedy odpowiedzi byłyby takie same. Jestem tu nowy, więc ;-)
Kenney
1
Referencje skalarne zostaną automatycznie ożywione jako SV UNDEF, które po zwiększeniu nie spowodują BigIntprzeciążenia - ponieważ nie jest to BigInt. Jednak literały całkowite są tworzone jako BigInts. Naprawdę nie takie dziwne;)
primo
1
Czy możesz użyć tego, $-aby zachować go jako liczbę całkowitą i powrócić do używania ++$-?
Dom Hastings
1
@DomHastings, z którymi testowałem, perl -Mbigint -E '{say++$-;$-+=$-;redo}' | morei zawija się do 1. Pozostaje int, ale bigint nie wkracza , niestety.
Kenney
4

Cudowny, 358 bajtów

..@F..@E..@D..@C..@B..@A..@9..@8..@7..@6..@5..@4..@3..@2..@1..@001@Z01
..AddoAddoAddoAddoAddoAddoAddoAddoAddoAddoAddoAddoAddoAddoAddoAddo/\&I
00&I00&I00&I00&I00&I00&I00&I00&I00&I00&I00&I00&I00&I00&I00&I00&I....@Z
@FHd@EHd@DHd@CHd@BHd@AHd@9Hd@8Hd@7Hd@6Hd@5Hd@4Hd@3Hd@2Hd@1Hd@0Hd
0A@N
..&I
@N/\..
:Hd
}0
Hp
}0
..
{<
#include hex_out.mbl
#include arithmetic.mbl

16 pół sumatorów połączonych razem, skrajnie prawy, wykonujący N ++ w każdym cyklu, a każdy sumator podaje swój przelew (00 lub 01) do następnego w łańcuchu. Dane wyjściowe są w formacie szesnastkowym.

Interpretator python ma błąd polegający na tym, że dane wyjściowe z zapamiętanych funkcji są tracone, więc musisz uruchomić to z „-m 0”, aby działało poprawnie. Bez tego parametru można zobaczyć, jak szybko będzie działać bez błędu, ale dane wyjściowe nie będą działać poprawnie.

Uwaga do siebie: napraw ten błąd w marbelous.py Ten błąd został naprawiony w najnowszej wersji marbelous.py

Sparr
źródło
4

R, 52 bajty

a=gmp::as.bigz(1);repeat{cat(paste(a,""));a=a+1}

(Uwaga: gmpjest biblioteką zewnętrzną, więc może być konieczne pobranie jej, aby to rozwiązanie działało)

SnoringFrog
źródło
1
+1 ... przepraszam za wszystkie dodatki. Aby odzyskać parę, możesz spróbować a=gmp::as.bigz(0);repeat{cat(paste(a<-a+1,''))}. Możesz zanotować notatkę, która gmpjest biblioteką zewnętrzną, która może wymagać pobrania.
MickyT,
44 bajty :)
Giuseppe,
4

BotEngine, 128 120 112 8x13 = 104

v2 2 01
>e>S SS
   e1e1
   e2 e0 12
   > > S SS P
  ^   <e0e1 R
     ^ < <lC^
^         <

Dane wyjściowe są binarne.

SuperJedi224
źródło