Hitung selamanya

71

Tulis program yang menghitung selamanya, mulai dari satu.

Aturan:

  • Program Anda harus masuk STDOUTatau alternatif yang dapat diterima, jika STDOUTtidak tersedia.
  • Program Anda harus merupakan program yang lengkap, dapat dijalankan, dan bukan fungsi atau cuplikan.
  • Program Anda harus menampilkan setiap angka dengan karakter pemisah di antaranya (baris baru, spasi, tab atau koma), tetapi ini harus konsisten untuk semua angka.
  • Anda dapat mencetak angka dalam desimal, unary, atau di dalam 256 di mana setiap digit diwakili oleh nilai byte .
  • Program Anda harus menghitung setidaknya sejauh 128 (inklusif) tanpa masalah dan tanpa kehabisan memori pada PC desktop yang wajar. Secara khusus, ini berarti jika Anda menggunakan unary, Anda tidak dapat menyimpan representasi unary dari angka saat ini dalam memori.

  • Tidak seperti aturan kami yang biasa, jangan ragu untuk menggunakan bahasa (atau versi bahasa) meskipun itu lebih baru daripada tantangan ini. Bahasa yang ditulis khusus untuk mengirimkan jawaban 0-byte untuk tantangan ini adalah permainan yang adil tetapi tidak terlalu menarik.

    Perhatikan bahwa harus ada penerjemah agar pengajuan dapat diuji. Diperbolehkan (dan bahkan dianjurkan) untuk menulis sendiri penerjemah ini untuk bahasa yang sebelumnya tidak diterapkan.

  • Ini bukan tentang menemukan bahasa dengan solusi terpendek untuk ini (ada beberapa di mana program kosong melakukan trik) - ini adalah tentang menemukan solusi terpendek dalam setiap bahasa. Karenanya, tidak ada jawaban yang akan ditandai sebagai diterima.

Katalog

Cuplikan Stack di bagian bawah posting ini menghasilkan katalog dari jawaban a) sebagai daftar solusi terpendek per bahasa dan b) sebagai leaderboard keseluruhan.

Untuk memastikan bahwa jawaban Anda muncul, silakan mulai jawaban Anda dengan tajuk utama, menggunakan templat Penurunan harga berikut:

## Language Name, N bytes

di mana Nukuran kiriman Anda. Jika Anda meningkatkan skor Anda, Anda dapat menyimpan skor lama di headline, dengan mencoretnya. Misalnya:

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

Jika Anda ingin memasukkan beberapa angka dalam tajuk Anda (mis. Karena skor Anda adalah jumlah dari dua file atau Anda ingin membuat daftar hukuman penterjemah secara terpisah), pastikan bahwa skor sebenarnya adalah angka terakhir di tajuk:

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

Anda juga dapat membuat nama bahasa menjadi tautan yang kemudian akan muncul di cuplikan:

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

Tampilkan cuplikan kode

code-golf  number  counting 
— vrwim
sumber
29
Saya tidak yakin bagaimana cara menggabungkan harus menampilkan setiap angka dengan karakter pemisah di antara dengan dapat mencetak angka [...] pada basis 256 .
— Dennis
6
Untuk tantangan di masa mendatang, bolehkah saya merekomendasikan kotak pasir sehingga semua detail ini dapat diselesaikan sebelum orang mulai mengirim jawaban? :)
— Martin Ender
3
@IlmariKaronen Saya menafsirkannya sebagai batas memori, bukan batas waktu. mungkin batas waktu per-kenaikan. cukup setel penghitung ke 2 ** 128-10 dan lihat berapa lama untuk mengambil sepuluh langkah terakhir itu.
— Sparr
5
Bisakah kita memiliki nol terkemuka di output?
— Paŭlo Ebermann
4
Ugh !!! Saya punya jawaban untuk TI-89 (56b), tetapi saya tidak dapat memposting b / c Saya baru di situs ini dan tidak memiliki Rep 10+!
— gregsdennis

Jawaban:

63

Labirin , 5 byte

):
\!

♫ IP dalam kode berputar-putar ♫

Instruksi yang relevan:

)       Increment top of stack (stack has infinite zeroes at bottom)
:       Duplicate top of stack
!       Output top of stack
\       Output newline
— Sp3000
sumber
77
Program ini menyedihkan bahwa itu tidak berhenti ..
— Pengoptimal
7
@Optimizer def sad (memang):
— YoYoYonnY
1
Mengapa ini bukan 4 byte?
— Aurel Bílý
2
@ Aurel300 Byte kelima adalah baris baru antara :dan\
— Sp3000
@ Sp3000 Ah, ya. Saya konyol. :)
— Aurel Bílý
46

> <> , 8 byte

01+:nao!

Langkah:

  • Tekan 0 pada tumpukan
  • Tambahkan 1 ke elemen tumpukan atas
  • Gandakan elemen tumpukan atas
  • Keluarkan bagian atas tumpukan sebagai angka
  • Keluarkan baris baru
  • Lanjutkan ke langkah 2 dengan membungkus dan melompati instruksi berikutnya (langkah 11)

(Program yang kurang efisien memori (karenanya tidak valid) llnao.)

— randomra
sumber
66
Memberi +1 untuk menuntut-upvote tidak sabar yang tersirat dalam deretan kode yang pada dasarnya berbunyi "plus satu, sekarang!".
— Janus Bahs Jacquet
24

Haskell, 21 byte

main=mapM_ print[1..]

Bilangan bulat presisi tak tentu dan daftar tak terbatas memudahkan ini :-)

Untungnya mapM_ada di Prelude. Jika Data.Traversableya, kita bahkan dapat mengecilkannya menjadi 19 byte:

main=for_[1..]print
— Bergi
sumber
Apakah tidak ada simbol yang menggeneralisasikan peta / mapM dll?
— JDługosz
@ JDługosz: bukan yang saya tahu
— Bergi
Ah, karena masih harus sampai sequencepada hasil untuk mendapatkan hasil yang benar-benar terjadi.
— JDługosz
bukankah hanya [1..]diizinkan, karena mencetak semua angka dengan koma di antara saya? atau [sekrup pertama semuanya?
— Baconaro
@Baconaro: itu daftar, tidak mencetak apa pun. GHCi mencetak hasilnya jika Anda memasukkan istilah dalam repl, tetapi itu bukan program yang bisa dijalankan. Dan ya, pemimpin [juga tidak diizinkan.
— Bergi
23

Gol> <> , 3 byte

P:N

Langkah:

  • Tambahkan 1 ke elemen tumpukan atas (pada awalnya itu adalah 0 implisit)
  • Gandakan elemen tumpukan atas
  • Pop dan output bagian atas tumpukan sebagai angka dan baris baru
  • Bungkus ke langkah 1 saat kami mencapai ujung garis
— randomra
sumber
21

Marbelous , 11450 4632 byte

Mencetak desimal itu menyusahkan !!

Jelas tidak menang dengan yang ini, tapi saya pikir saya akan mencobanya. Saya harap tidak apa-apa karena bantalan output ke 40 nol (agar sesuai 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
— Dokter
sumber
Apakah pencetakan biner akan lebih pendek?
— SuperJedi224
3
(atau bagaimana dengan unary?)
— Gagang Pintu
@ Doorknob menampilkan output bukan masalah. Ini adalah sesuatu di Ehunpapan yang seharusnya menambah digit berikutnya, tetapi tidak berfungsi dengan baik
— TheDoctor
1
Tahukah Anda bahwa Anda dapat meninggalkan periode di akhir setiap baris dan baris kosong di antara papan dan menggunakan karakter tunggal untuk nama papan? Anda hanya perlu mengulangi karakter tunggal itu dalam jumlah waktu yang sesuai untuk memanggilnya. Ini bisa membuat jawaban Anda menjadi sekitar 3000 byte.
— overactor
Akhirnya saya akan mendorong komit ke marbelous.py yang mencakup semuanya include/secara default
— Sparr
18

C (arsitektur 64-bit saja), 53 byte

Bergantung pada pointer setidaknya 64 bit dan mencetaknya dalam hex menggunakan %pspecifier. Program akan kembali tepat ketika mencapai 2 ^ 128.

char*a,*b;main(){for(;++b||++a;)printf("%p%p ",a,b);}
— feersum
sumber
1
Jadi jika pointer tersebut masing-masing 64 bit, Anda hanya bisa menghitung 2 ^ 128-1, kan?
— flawr
6
Tidak valid karena tidak dapat menghitung hingga 2 ^ 128
— edc65
14
Saya suka CodeGolf ketika itu tentang mengekspresikan dan menghargai kreativitas. feersum jelas tidak bersaing untuk menang di sini. Melihat banyak downvotes pada masalah teknis dan untuk mengubah kata-kata dari pertanyaan untuk memastikan jawabannya melanggar, membuat saya sedih.
— flodel
3
Saya pikir kata-kata "paling tidak sejauh 2 ^ 128" cukup jelas ...
— vrwim
5
@vrwim Anda tidak menulisnya. Anda menulis "hingga 2 ^ 128". SuperJedi mengeditnya beberapa menit yang lalu.
— feersum
17

Hexagony , 12 11 10 7 byte

Terima kasih kepada alephalpha karena memasukkan kode ke dalam panjang sisi 2.

10})!';

Dibuka:

 1 0
} ) !
 ' ;

Yang ini cukup sederhana. 10menulis 10, yaitu linefeed ke tepi memori awal. Kemudian })!';berulang kali dieksekusi dalam satu lingkaran:

  • } pindah ke tepi memori berikutnya.
  • ) tambahkan itu.
  • ! cetak sebagai integer.
  • ' kembali ke 10.
  • ; cetak sebagai karakter.

Saya percaya bahwa ini optimal (walaupun sejauh ini tidak unik). Saya telah membiarkan skrip brute force yang saya tulis untuk pencarian jawaban ini untuk solusi 6-byte dengan asumsi bahwa itu harus mengandung setidaknya satu masing-masing ;dan !dan salah satu (atau ), dan tidak akan mengandung ?, ,atau @, dan itu tidak temukan solusinya.

— Martin Ender
sumber
13

Pyth, 4 byte

.V1b

Penjelasan:

.V1    for b in range(1 to infinity):
   b      print b
— Jakube
sumber
f!\n( TIO link ) akan bekerja selama 3 byte, tidak yakin apakah itu menggunakan fitur apa pun yang telah ditambahkan setelah jawaban Anda.
— Sok
@ Sok Pintar. Namun, saya tidak akan mengubah jawaban karena saya pikir itu fadalah fitur Pyth 4 tahun yang lalu.
— Jakube
Saya juga berpikir demikian, itulah sebabnya saya meninggalkannya sebagai komentar - fitur bahasa baru untuk mengalahkan jawaban yang lebih lama selalu terasa murah IMO
— Sok
13

bc, 10

for(;;)++i

Tidak biasa yaitu bclebih pendek dari dc.

Dari man bc:

DESKRIPSI

bc adalah bahasa yang mendukung angka presisi acak

— Trauma Digital
sumber
Di mana ini mencetaknya?
— Bálint
@ Bálint ++iadalah sebuah ekspresi, tetapi bukan sebuah tugas, dan karenanya dikeluarkan secara eksplisit. Apakah Anda mencoba menjalankannya? echo 'for(;;)++i' | bcdi terminal Linux terdekat Anda.
— Digital Trauma
Saya tidak memiliki terminal Linux di rumah saya. Saya penasaran.
— Bálint
6
@ Bálint Setiap rumah harus memiliki terminal Linux.
— Digital Trauma
1
@ Bálint Menjalankan program ini adalah penggunaan Anda;)
— Insane
12

Java, 139 138 127 123 byte

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
sumber
2
Infinite loop yang lebih kecil di java adalah for(;;)untuk 3 byte yang mudah.
— ankh-morpork
Anda juga dapat menyimpan 2 lainnya dengan BigInteger b=null;b=b.ZERO;, sayangnya =nulldibutuhkan, bahkan berpikir itu adalah akses statis.
— TWiStErRob
Dan kemudian 9 lagi, karena Anda dapat menyingkirkan impor dengan referensi BigIntegeroleh FQCN hanya sekali.
— TWiStErRob
@TWiStErRob Entah bagaimana, saya tidak menyadari itu akan lebih pendek.
— SuperJedi224
2
Untuk Java 8 atau lebih baru, Anda dapat mengganti kelas dengan interfacedan menghapus publicdari fungsi. Jangan ingin menyalin kode Anda dan mempostingnya sebagai jawaban baru.
— Luca H
10

Mathematica, 22 byte

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

Echo adalah fungsi baru di Mathematica 10.3.

— alephalpha
sumber
Echomemberikan empat karakter yang terpisah: baris baru plus ">> ". Tidak yakin ini valid - mungkin menggunakan Printsebagai gantinya? Juga, simpan byte dengan i=0;While[Echo@++i>0].
— Roman
7

Ruby, 15 12 byte

loop{p$.+=1}
  • p, ketika diberi bilangan bulat, mencetak bilangan bulat apa adanya (milik @ philomory )
  • $.adalah variabel magis yang menahan jumlah baris yang dibaca dari stdin. Ini jelas diinisialisasi ke 0, dan juga ditugaskan :)
— daniero
sumber
@ philomory Biasanya disarankan bagi pengguna untuk meninggalkan komentar yang menyarankan solusi byte-saving mereka. Juga, saya ingin melihat penjelasan untuk yang ini. c:
— Addison Crump
7

Python 3, 33 25 byte

Sejauh yang saya mengerti, bilangan bulat Python presisi yang sewenang-wenang, dan print()secara otomatis menghasilkan baris baru.

Terima kasih untuk @ Jakub dan @ Sp3000 dan @wnnmaw! Saya benar-benar tidak tahu banyak python, satu-satunya yang saya tahu adalah itu mendukung bilangan bulat ukuran arbitrer =)

k=1
while 1:print(k);k+=1
— cacat
sumber
1adalah nilai kebenaran dalam Python (dan sebagian besar bahasa lainnya). Jadi while 1:cukup.
— Jakube
Selain itu, Anda dapat menempatkan keseluruhannya whiledalam satu baris
— Sp3000
Anda dapat menyimpan byte dengan menggunakan repr(k)daripada print(k). Juga, saya menghitung ukuran byte Anda sebagai 25 (tanpa perubahan yang saya sarankan)
— wnnmaw
1
Anda tidak dapat menggunakan reprbukan print. reprtidak menghasilkan apa pun. @wnnmaw
— Zach Gates
Lalu apa yang reprharus dilakukan?
— flawr
6

Memproses , 95 85 71 byte

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

Saya mencoba sesuatu dengan loop sementara tetapi menyebabkan semua Proses macet, jadi saya akan tetap dengan ini untuk saat ini.

(Terima kasih kepada @ SuperJedi224 dan @TWiStErRob untuk saran.)

— geokavel
sumber
Ada apa dengan ruang? Saya cukup yakin import java.math.*;BigInteger i=BigInteger.ZERO;void draw(){println(i=i.add(BigInteger.ONE));}akan berhasil.
— SuperJedi224
Ya, baru saja perbaiki itu.
— geokavel
Apakah Pemrosesan memungkinkan BigInteger.ONEuntuk diubah i.ONE?
— SuperJedi224
@ SuperJedi224 Ya, benar. Terima kasih!
— geokavel
Baiklah, dapatkan upvote.
— SuperJedi224
6

Samau , 2 byte

N)

Penjelasan:

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

Ketika output dari sebuah program adalah daftar, tanda kurung dihilangkan.

— alephalpha
sumber
Tidakkah suatu daftar mencetak semua isinya sekaligus? Jika daftar ini tidak terbatas , maka tidak mungkin masuk dalam memori atau di layar Anda , dan itu tidak akan pernah berhenti dihasilkan, sehingga tidak akan pernah dicetak.
— kucing
1
@cat Samau ditulis dalam Haskell, dan itu malas . Itu tidak akan menghasilkan seluruh daftar sebelum mencetaknya.
— alephalpha
Hanya kepala. Di halaman GitHub untuk Samau, dalam deskripsi @, "push" salah eja.
— Carcigenicate
@Carcigenicate Terima kasih.
— alephalpha
6

JavaScript (ES6), 99 94 67 byte

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

alertadalah STDOUTsetara yang diterima secara umum untuk JavaScript tetapi menggunakannya berarti bahwa angka berurutan dipisahkan secara otomatis. Saya berasumsi bahwa mengeluarkan karakter setelah nomor tidak perlu karena ini.

— pengguna81655
sumber
12
Inilah mengapa saya memiliki pemblokir pop-up.
— Comintern
1
hanya mengatakan: untuk (i = 0 ;;) lansiran (i ++) Saya tidak berpikir Anda membutuhkan semua kontrol itu
— towc
3
@towc Itu tidak akan berfungsi. Semua angka adalah 64 bit mengapung dalam JavaScript yang memiliki nilai integer aman maksimum 2^53tetapi pertanyaannya mengharuskan untuk naik ke 2^128.
— user81655
1
oh, titik adil ...
— towc
5

Matlab, 132 byte

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, saya pikir ini adalah jawaban serius pertama yang menyelesaikan tugas ini tanpa built-in integer ukuran yang sepele. Program ini mengimplementasikan bilangan bulat ukuran arbitrer sebagai array bilangan bulat. Setiap integer selalu antara 0 dan 9, sehingga setiap elemen array mewakili satu angka desimal. Ukuran array akan ditingkatkan satu setelah kita berada di eg 999. Ukuran memori tidak ada masalah di sini, karena 2^128hanya membutuhkan panjang array 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
— cacat
sumber
5

C ++, 146 141 138 byte

Menggunakan perpustakaan bigint standar mungkin merupakan cara paling membosankan untuk menjawab pertanyaan ini, tetapi seseorang harus melakukannya.

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

Tidak Disatukan:

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

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

Alasan penggunaan versi golf stdio.hdan bukan cstdioadalah untuk menghindari keharusan menggunakan std::namespace.

Ini adalah pertama kalinya saya bermain golf di C ++, beri tahu saya jika ada trik untuk mempersingkat ini lebih lanjut.

— obat mujarab
sumber
Mungkin Anda bisa menggunakan '\n'bukan std::endl, akan menghemat 8 byte. Juga mungkin ada cara untuk menggunakan CPP #define untuk mengompres beberapa pengulangan,
— Kenney
@ Kenney Terima kasih untuk itu! (Ini hanya menghemat 5 byte, bukan 8.) Saya pikir saya mungkin telah menemukan cara untuk men-tweak bagian itu bahkan lebih pendek.
— felixphew
Saya tidak tahu peningkatan (dan saya tidak akan mengatakan itu standar baik) tetapi tidak idibangun secara default dengan nilai 0? Anda kemudian dapat menghapus definisi dan beralih postincrement ke preincremet yang akan menghemat 2b
— Zereges
Bagaimana dengan yang sudah usang #import?
— connectyourcharger
5

C # .NET 4.0, 111 103 102 97 byte

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

Saya tidak menemukan jawaban C # di sini, jadi saya hanya perlu menulis satu.

.NET 4.0 diperlukan, karena ini adalah versi pertama yang menyertakan BigInteger . Anda harus merujuk System.Numerics.dll .

Dengan lekukan:

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

Berkat sweerpotato, Kvam, Berend untuk menghemat beberapa byte

— Kazarp
sumber
Anda dapat menyimpan 8 byte dengan class C{static void Main(){var b=System.Numerics.BigInteger.One;for(;;)System.Console.WriteLine(b++);}}: ~)!
— sweerpotato
1
Pindahkan deklarasi b dan Console.WriteLineke dalam struktur loop:class C{static void Main(){for(var b=System.Numerics.BigInteger.One;;Console.WriteLine(b++));}}
— Kvam
Kamu masih butuh System. Itu menghemat satu byte sekalipun!
— sweerpotato
Ya kamu benar.
— Kvam
Jika Anda menambahkan using System;(13 byte) Anda dapat menghapus System.(7 byte) dua kali, menghemat 1 byte.
— Kenney
5

Clojure, 17 byte

(map prn (range))

Urutan malas dan integer presisi sewenang-wenang membuat ini mudah (seperti untuk Haskell dan CL). prnmenyelamatkan saya beberapa byte karena saya tidak perlu mencetak string format. doseqmungkin akan lebih idiomatis karena di sini kita hanya berurusan dengan efek samping; maptidak masuk akal untuk digunakan karena akan membuat urutan nil(yang merupakan nilai balik dari setiap prnpanggilan.

Dengan asumsi saya menghitung selamanya, urutan pointer nol yang dihasilkan dari operasi ini tidak pernah dikembalikan.

— MONODA43
sumber
4

MarioLANG , 11 byte

+<
:"
>!
=#

Terinspirasi oleh jawaban Martin Büttner dalam pertanyaan lain .

— alephalpha
sumber
Apakah Anda yakin ini berfungsi tanpa masalah hingga 2 ^ 128?
— flawr
1
— Martin Ender
@ flawr MarioLANG memiliki interpreter Ruby, dan tipe integer Ruby memiliki presisi yang berubah-ubah.
— Martin Ender
@ flawr Tergantung pada penerjemah. Juru bahasa yang saya gunakan ditulis dalam Ruby, dan mendukung presisi yang sewenang-wenang.
— alephalpha
4

CJam, 7 byte

0{)_p}h

Penjelasan:

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

Catatan: Harus menggunakan juru bahasa Java.

— GamrCorps
sumber
4

C, 89 byte

Pendekatan baru (menerapkan bitwise incrementer) di 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])));}

Kurang golf

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])));
}

Mengakhiri

Versi ini memiliki sedikit cacat, bahwa itu tidak berakhir (yang bukan keharusan saat ini). Untuk melakukan ini, Anda harus menambahkan 3 karakter:

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
sumber
4
Bahkan seharusnya tidak berakhir. Itulah arti dariforever
— edc65
4

Foo , 6 byte

(+1$i)

Penjelasan

(    )    Loop
 +1       Add one to current element
   $i     Output current element as a decimal integer
— Zach Gates
sumber
4

Minkolang , 4 byte

1+dN

Coba di sini. (Yah, sebenarnya, hati-hati. 3 detik waktu menjalankan sudah cukup untuk mendapatkan hingga ~ 40.000.)

1+menambahkan 1 ke atas tumpukan, dmenggandakannya, dan Nmenampilkan bagian atas tumpukan sebagai integer dengan ruang tambahan. Ini loop karena Minkolang adalah toroidal, jadi ketika penghitung program berbunyi di tepi kanan, ia muncul kembali di sebelah kiri.

— El'endia Starman
sumber
4

Intel 8086+ Assembly, 19 byte

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

Berikut ini rinciannya:

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

Ini menghasilkan angka 128 bit pada posisi layar 8 kiri atas. Setiap posisi layar memegang karakter ASCII 8-bit dan dua warna 4 bit.

Catatan: ia membungkus sekitar 128 ; hanya mengubah 8dalam mov cx, 8untuk 9menunjukkan sejumlah 144 bit, atau bahkan 80*25untuk menunjukkan angka sampai dengan 2 32000 .

Lari

1.44Mb bzip2 dikompresi, image64 floppy bootable dikodekan base64

Hasilkan gambar floppy dengan menyalin-menempel yang berikut ini

QlpoOTFBWSZTWX9j1uwALTNvecBAAgCgAACAAgAAQAgAQAAAEABgEEggKKAAVDKGgAaZBFSMJgQa
fPsBBBFMciogikZcWgKIIprHJDS9ZFh2kUZ3QgggEEh/i7kinChIP7HrdgA=

ke dalam commandline ini:

base64 -d | bunzip2 > floppy.img

dan jalankan dengan, misalnya, qemu -fda floppy.img -boot a

1.8Mb bootable ISO

Ini adalah image ISO terkompresi bzip2 yang dikodekan base64. Hasilkan iso dengan menempelkan

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

ke

base64 -d bunzip2 > cdrom.iso

dan konfigurasikan mesin virtual untuk mem-boot darinya.

DOS .COM

Ini adalah DOS .COM yang dikodekan base64 yang dapat dieksekusi:

aAC4H7kIADH/+YMVAEdH4vnr8Q==

Hasilkan file .COM menggunakan 

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

dan jalankan dalam (Gratis) DOS.

— Kenney
sumber
4

Perl , 34 32 30 28 26 23 byte

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

Tes dengan

perl -Mbigint -E '{say$_+=1;redo}'
— Kenney
sumber
Anda dapat mengganti for(,,){...}dengan {...;redo}untuk dua.
— primo
Ya saya melihat (perl 5.18+), tapi saya pikir itu mungkin curang; maka jawabannya akan sama. Saya baru di sini, jadi ;-)
— Kenney
1
Referensi skalar akan diperbarui secara otomatis SV UNDEF, yang bila ditambah tidak akan memicu BigIntkelebihan beban - karena itu bukan BigInt. Namun demikian, bilangan bulat integer dibuat sebagai BigInts. Tidak terlalu aneh kok;)
— primo
1
Bisakah Anda menggunakannya $-untuk menyimpannya sebagai integer dan kembali menggunakannya ++$-?
— Dom Hastings
1
@HomHastings saya diuji dengan perl -Mbigint -E '{say++$-;$-+=$-;redo}' | moredan membungkus ke 1. Itu tetap int tetapi bigint tidak masuk, sayangnya.
— Kenney
4

Marbelous, 358 byte

..@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 setengah adders dirantai bersama-sama, yang paling kanan melakukan N ++ setiap siklus dan masing-masing adder memberi makan melimpah (00 atau 01) ke yang berikutnya dalam rantai. Output dalam hex.

Penerjemah python memiliki bug di mana output dari fungsi memoized hilang, jadi Anda harus menjalankan ini dengan "-m 0" untuk membuatnya berfungsi dengan benar. Tanpa parameter itu Anda bisa melihat seberapa cepat ia akan berjalan tanpa bug, tetapi hasilnya tidak akan berfungsi dengan baik.

Catatan untuk diri sendiri: perbaiki bug itu di marbelous.py Bug ini telah diperbaiki di versi terbaru dari marbelous.py

— Sparr
sumber
4

R, 52 Bytes

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

(Catatan: gmpadalah perpustakaan eksternal, jadi Anda mungkin harus mengunduhnya agar solusi ini berfungsi)

— SnoringFrog
sumber
1
+1 ... maaf tentang semua ekstra. Untuk mendapatkan Anda kembali, Anda bisa mencoba a=gmp::as.bigz(0);repeat{cat(paste(a<-a+1,''))}. Anda mungkin ingin membuat catatan yang gmpmerupakan perpustakaan eksternal yang mungkin perlu diunduh.
— MickyT
— Giuseppe
4

BotEngine, 128 120 112 8x13 = 104

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

Output dalam biner.

— SuperJedi224
sumber
Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.