(Cukup buka 50 tab di Google Chrome: D (hanya bercanda, tidak Anda tidak bisa))

Kode terpendek untuk disk I / O tak terbatas bahasa apa pun, C # contoh:

using System.IO;

namespace FileApp {
    static class Program {
        public static void Main() {
            do {
                File.WriteAllText("a", "a");
                File.Delete("a");
            } while (true);
        }
    }
}

Anda tidak bisa hanya mengisi seluruh disk, karena pada akhirnya akan berhenti dan akan terbatas.

Dan Anda tidak bisa hanya membaca, tulisan yang tak terbatas harus terjadi. (Ini harus membunuh SSD saya setelah runtime yang cukup.)

Dapatkan retak! :)

DOS / Batch: 4 byte

%0>x

File batch ini akan memanggil dirinya sendiri ( %0) dan mengarahkan ulang ( >) output ke file yang disebut x. Karena gema aktif secara default, ini akan menampilkan path dan perintah.

PowerShell v2 +, 10 byte

for(){1>1}

Cukup loop tanpa batas dengan forloop kosong . Setiap iterasi, kami mengeluarkan integer 1(secara implisit dikonversi menjadi string) dengan > operator pengalihan , yang menimpa file yang disebutkan 1dalam direktori lokal.

Pyth, 6 byte

#.w]]0

Perintah keluaran file hanya Pyth adalah .w. Ketika dipanggil pada string, string itu dituliskan ke file dalam mode append, yang tidak baik untuk keperluan pertanyaan ini. Ketika dipanggil pada array 2-d, itu menulis gambar yang sesuai untuk file itu, menimpa isi file. Itulah yang dilakukan oleh program ini. Nama output file default adalah o.png, jadi program ini secara tak terbatas menimpa file o.pngdengan gambar putih 1-pixel. #adalah loop tak terbatas.

Jika Anda ingin jawaban yang lebih pendek (tapi lebih membosankan daripada yang lain):

Bash, 5 byte

>w;$0

Saya bisa membuatnya lebih pendek jika ada perintah (kurang dari 3 byte panjang) yang menulis sesuatu ke disk I / O. Sesuatu seperti syncakan berfungsi, tetapi sync4 byte 😛

Catatan: ini tidak berfungsi saat dijalankan langsung dari bash, hanya ketika dimasukkan ke dalam skrip dan dijalankan sebagai nama skrip. (yaitu echo 'w>w;$0' > bomb; chmod 755 bomb; ./bomb)

Ruby, 22 20 byte

loop{open(?a,?w)<<1}

Berulang kali memotong dan menulis 1ke file a.

Terima kasih kepada Ventero untuk 2 byte!

cmd, 14 byte

:a
cd>1
goto a

Infinitly menimpa file 1dengan string ke direktori saat ini

Saya baru di sini: Apakah baris baru windows ( CR LF) dihitung sebagai dua byte?

Bash + coreutils, 10

yes \>b|sh

Menulis aliran berkelanjutan >b, yang disalurkan ke shuntuk evaluasi. >bcukup memotong file yang dipanggil bke nol byte setiap kali.

Perl 5, 27 32 22 byte

{{open my$h,'>o'}redo}

Jika hanya mengubah stempel waktu modifikasi file sudah cukup ...

Penjelasan cepat:

{ # Braces implicitly create/mark a loop.
    { # They also create closures, for `my` variables.
        open my $filehandle, '>', 'o';    # Writing to file "o".
        # close $filehandle;   # Called implicitly when
                               # variable gets destroyed.
    } # $filehandle gets destroyed because there are no references to it.
    redo; # ...the loop.
}

Solusi sebelumnya (32 byte): {{open my$h,'>o';print$h 1}redo}

Sunting: {open F,'O';print F 1;redo} ← Tidak menguji kode sebelum memposting; sekarang saya harus memperbaikinya.

PHP, 60 30 17 16 15 byte

Diperbarui lagi seperti yang disarankan @manatwork:

while(!`cd>1`);

Juga sekarang diuji.

Sedikit kecurangan 22 byte:

while (exec ('> 1 dir'));

Saran sebelumnya oleh @manatwork 30 byte:

while (file_put_contents (1,1));

TIDAK DIUJI (tidak tersedia php di komputer ini) 43 byte:

untuk ($ a = fopen (1, 'w'); fputs ($ a, 1); fclose ($ a))

Asli 45 byte golf:

$ a = fopen (1, 'w'); while (fputs ($ a, 1)) rewind ($ a);

Posting pertama saya di sini, bergabung karena saya hanya harus mencoba ini: selama file berhasil ditulis, mundur file pointer untuk memulai.

Hanya tidak bisa lebih kecil dari file_put_contents ().

sh, 11 byte

w>w;exec $0

Simpan ini ke file tanpa karakter khusus, seperti loop.sh, buat itu dapat dieksekusi, dan jalankan dengan ./loop.shatau serupa.

Ini menulis output dari perintah wke file w, menimpa nilai sebelumnya setiap kali. Kemudian, ia mengganti dirinya sendiri dengan versi baru dari program yang sama, sehingga dapat berjalan tanpa batas.

C, 95 94 93 89 78 90 89 76 75 byte

#include<stdio.h>
main(){for(FILE*f=fopen("a","w");;fputc(0,f),fclose(f));}   

Sekali lagi, sudo watch -n1 lsof -p `pidof inf`sepertinya mengatakan ini valid.

^{BAGAIMANA SAYA TIDAK MELIHAT RUANG YANG D: <}

Terima kasih @Jens untuk mencukur 13 byte: D

Bash, 26 byte

yes>y&while :;do rm y;done

Jika saya ingin memperluas one-liner ini, saya akan mendapatkannya:

yes > y &      # Write out infinitely to the file y in the current directory
while true     # Let's do something forever
do             # Here's what we're going to do
    rm y       # delete y
done           # That's all we're going to do

Ini tidak bisa benar-benar bersaing dengan garis PowerShell 10 byte, tetapi akan bertahan sendiri terhadap yang lain. Lihat jawaban saya yang lain untuk versi 6 byte.

TI-BASIC, 12 byte

While 1
Archive A
UnArchive A
End

Solusi alternatif oleh pengguna lirtosiast dengan ukuran yang sama:

While 1
SetUpEditor
Archive ∟1
End

Ini akan bekerja pada seri kalkulator TI-83+ dan TI-84+.

Ya, ini juga berfungsi jika A sudah diarsipkan atau tidak diinisialisasi sama sekali pada awal program! Program ini hanya 12 byte karena tokenization .

CPython 3.5, 33 16 byte

while 1:open("a")

Ya benar : D

MATL , 10 byte

`1[]T3$Z#T

Penjelasan

Ini adalah loop tak terbatas yang menulis nomor 1 ke file yang disebut inoutdi direktori saat ini, menimpa konten file sebelumnya.

`       % do...while loop
  1     %   push number 1
  []    %   push empty array
  T     %   push "true"
  3$Z#  %   fwrite function. First input is file content. Second is file name;
        %   defaults to "inout" if empty. Third indicates that any previous
        %   file contents should be discarded
  T     %   push "true": loop condition 
        % implicitly end loop. Loop condition is "true", so the loop is infinite

Haskell, 20 byte

f=writeFile"b""a">>f

Tulis string "a"ke file bernama "b"dan ulangi. writeFilemenimpa file jika ada.

JavaScript (Node.js), 43 41 byte

(c=x=>require("fs").writeFile("a",x,c))()

Menulis nullke file bernama a, lalu ulangi.

ZSH, 14 byte

for ((;;)) :>:

Zsh, tidak seperti Bash dan cangkang mirip Bourne lainnya, memungkinkan loop tanpa do ... donepagar , asalkan kondisinya sesuai dibatasi.

Atau, dengan while:

while {} {:>:}

Perhatikan bahwa itu :adalah builtin. Anda tidak dapat menangguhkan loop ini.

Prinsipnya sama dengan jawaban Digital Trauma - tidak ada yang tertulis pada file, IO murni dari membuat dan memotong file.

Rust, 84 Bytes

fn main(){loop{use std::io::Write;std::fs::File::create("a").unwrap().write(b"a");}}

File::create memotong file yang sudah ada, sehingga memastikan bahwa kami tidak kehabisan ruang disk.

Compiler yang digunakan (1.9 Nightly) mengeluarkan peringatan tentang hasil yang tidak digunakan dari write(...)tetapi mengkompilasi.

C, 92 byte

#include <stdio.h>
main(){for(FILE*f=fopen("a","w+");fprintf(f," "),!fclose(f);;);return 0;}

Meskipun sepertinya Anda bisa menghemat 1 byte

  for(FILE*f=fopen("a","w+");fprintf(f," ")+fclose(f);;){}

masalah dengan loop itu adalah + tidak memberi Anda pesanan yang dijamin.

Atau rekursif - tidak boleh meluap jika kompiler dengan benar mengimplementasikan rekursi ekor (f berada dalam lingkup bagian dalam yang eksplisit)

85 byte

#include <stdio.h>
main(){{FILE*f=fopen("a","w+");fprintf(f," ");fclose(f);}main();}

Mathematica, 14 byte

For[,1>0,a>>a]

Berulang kali menulis string "a"ke file yang bernama adi direktori saat ini, membuatnya jika tidak ada.

C, 40 byte

main(){for(;;)write(open("a",1)," ",1);}

Akan dengan cepat kehabisan deskriptor file; ini dapat diatasi dengan:

45 , 43 byte

main(f){for(f=open("a",1);;)write(f,"",1);}

C pada amd64 Linux, 36 byte (hanya timestamp), 52 49 byte (aktivitas disk nyata)

Saya membuat kode yang sulit pada open(2)flag, jadi ini tidak portabel untuk ABI lain. Linux pada platform lain kemungkinan menggunakan hal yang sama O_TRUNC, dll., Tetapi OS POSIX lain mungkin tidak.

+4 byte untuk memberikan arg izin yang benar untuk memastikan file dibuat dengan akses tulis pemilik, lihat di bawah. (Ini terjadi untuk bekerja dengan gcc 5.2)

ANSI C agak portabel, 38/51 byte (hanya cap waktu), 52/67 byte (aktivitas disk nyata)

Berdasarkan jawaban @ Cat, dengan tip dari @Jens.

Angka pertama adalah untuk implementasi di mana suatu intdapat menyimpan FILE *fopen()nilai kembali, nomor kedua jika kita tidak bisa melakukan itu. Di Linux, tumpukan alamat kebetulan berada di ruang alamat 32 bit yang rendah, sehingga bisa berfungsi bahkan tanpa -m32atau -mx32. (Mendeklarasikan void*fopen();lebih pendek dari #include <stdio.h>)

Hanya metadata I / O stempel waktu :

main(){for(;;)close(open("a",577));}   // Linux x86-64

//void*fopen();       // compile with -m32 or -mx32 or whatever, so an int holds a pointer.
main(){for(;;)fclose(fopen("a","w"));}

Menulis byte, sebenarnya memukul disk di Linux 4.2.0 + XFS + lazytime:

main(){for(;write(open("a",577),"",1);close(3));}

writeadalah kondisi for-loop, yang baik-baik saja karena selalu mengembalikan 1. closeadalah kenaikan.

// semi-portable: storing a FILE* in an int.  Works on many systems
main(f){for(;f=fopen("a","w");fclose(f))fputc(0,f);}                 // 52 bytes

// Should be highly portable, except to systems that require prototypes for all functions.
void*f,*fopen();main(){for(;f=fopen("a","w");fclose(f))fputc(0,f);}   // 67 bytes

Penjelasan dari versi non-portabel:

File dibuat dengan izin sampah acak. Dengan gcc5.2, dengan -O0atau -O3, itu terjadi untuk menyertakan izin menulis pemilik, tetapi ini tidak dijamin. 0666adalah desimal 438. Arg ke-3 openakan membutuhkan 4 byte lagi . Kami sudah mengkodekan O_TRUNC dan seterusnya, tetapi ini bisa terputus dengan kompiler atau libc yang berbeda pada ABI yang sama.

Kita tidak dapat menghilangkan argumen ke-2 open, karena nilai sampah kebetulan termasuk O_EXCL, dan O_TRUNC|O_APPEND, jadi gagal gagal EINVAL.

Kami tidak perlu menyimpan nilai pengembalian dari open(). Kami berasumsi itu 3, karena akan selalu begitu. Bahkan jika kita mulai dengan fd 3 terbuka, itu akan ditutup setelah iterasi pertama. Kasing terburuk, openterus membuka fds baru hingga 3 adalah deskriptor file terakhir yang tersedia. Jadi, hingga 65531 write()panggilan pertama bisa gagal EBADF, tetapi kemudian akan bekerja secara normal dengan setiap openpembuatan fd = 3.

577 = 0x241 = O_WRONLY|O_CREAT|O_TRUNCdi x86-64 Linux. Tanpa O_TRUNC, waktu mod inode dan waktu perubahan tidak diperbarui, jadi arg yang lebih pendek tidak mungkin. O_TRUNCmasih penting untuk versi yang memanggil writeuntuk menghasilkan aktivitas disk yang sebenarnya, bukan menulis ulang di tempat.

Saya melihat beberapa jawaban itu open("a",1). O_CREAT diperlukan jika abelum ada. O_CREATdidefinisikan sebagai oktal 0100 (64, 0x40) di Linux.

Tidak ada sumber daya bocor, sehingga bisa berjalan selamanya. stracekeluaran:

open("a", O_WRONLY|O_CREAT|O_TRUNC, 03777762713526650) = 3
close(3)                                = 0
... repeating

atau

open("a", O_WRONLY|O_CREAT|O_TRUNC, 01) = 3
write(3, "\0", 1)                       = 1   # This is the terminating 0 byte in the empty string we pass to write(2)
close(3)                                = 0

Saya mendapat nilai desimal dari openflag untuk ABI ini menggunakan strace -eraw=openversi C ++ saya.

Pada sistem file dengan lazytimeopsi pemasangan Linux diaktifkan, perubahan yang hanya memengaruhi cap waktu inode hanya akan menyebabkan satu penulisan per 24 jam. Dengan opsi pemasangan yang dinonaktifkan, pemutakhiran stempel waktu mungkin merupakan cara yang layak untuk memakai SSD Anda. (Namun, beberapa jawaban lain hanya melakukan metadata I / O).

alternatif:

lebih pendek tidak bekerja :

main(){for(;;)close(write(open("a",577),"",3));}menggunakan writenilai balik untuk melewatkan 3arg untuk menutup. Ini menyimpan byte lain, tetapi tidak bekerja dengan gcc -O0 atau -O3 pada amd64. Sampah di arg ke-3 openberbeda, dan tidak termasuk izin menulis. aakan dibuat pertama kali, tetapi iterasi di masa mendatang semuanya gagal -EACCESS.

lebih lama, bekerja, dengan panggilan sistem yang berbeda :

main(c){for(open("a",65);pwrite(3,"",1);)sync();} menulis ulang byte di tempat dan panggilan sync() untuk menyinkronkan semua sistem file di seluruh sistem. Ini membuat lampu drive menyala.

Kami tidak peduli byte mana, jadi kami tidak meneruskan argumen ke 4 ke pwrite. Yay untuk file jarang:

$ ll -s a
300K -rwx-wx--- 1 peter peter 128T May 15 11:43 a

Menulis satu byte pada offset ~ 128TiB menyebabkan xfs menggunakan 300kiB ruang untuk menampung peta sebatas, saya kira. Jangan coba ini di OS X dengan HFS +: IIRC, HFS + tidak mendukung file jarang, sehingga akan mengisi disk.

XFS adalah sistem file 64bit yang tepat, mendukung masing-masing file hingga 8 exabytes . yaitu 2 ^ 63-1, nilai maksimum off_tdapat disimpan.

strace keluaran:

open("a", O_WRONLY|O_CREAT, 03777711166007270) = 3
pwrite(3, "\0", 1, 139989929353760)     = 1
sync()                                  = 0
pwrite(3, "\0", 1, 139989929380071)     = 1
sync()                                  = 0
...

Racket, 46 byte

(do()(#f)(write-to-file'a"f"#:exists'replace))

Faktor, 73 byte

USING: io.files io.encodings
[ 0 "a" utf8 set-file-contents ] [ t ] while

Menyetel konten file ke byte nul selamanya.

CBM BASIC 7.0, 9 byte

0dS"a":rU

Program ini, ketika dijalankan, berulang kali menyimpan dirinya ke disk. Berikut adalah versi yang lebih mudah dibaca yang tidak menggunakan singkatan kata kunci BASIC:

0 dsave "a" : run

Python, 32 byte

while 1:open("a","w").write("b")

Perhatikan bahwa jika dijalankan pada python 3, ini akan menghasilkan jumlah peringatan yang tak terbatas. Juga, mungkin akan kehabisan fds jika dijalankan dalam implementasi non-penghitungan ulang.

Dyalog APL 15.0, 17 byte (tidak bersaing)

(⊢⊣⊃⎕NPUT⊢)⍣≢'A'1

Chrome saat ini membuat U + 2262 salah. Baris di atas akan terlihat seperti (⊢⊣⊃⎕NPUT⊢)⍣̸≡'A'1.

Ini tidak bersaing karena versi 15 belum dirilis.

Berlaku ⍣fungsi (⊢⊣⊃⎕NPUT⊢)pada 'A'1sampai input berubah (yaitu tidak pernah):

⊢⊣⊃⎕NPUT⊢ adalah kereta fungsi:

┌─┼───┐      
⊢ ⊣ ┌─┼─────┐
    ⊃ ⎕NPUT ⊢

Paling kanan ⊢kembali 'A'1dimodifikasi; ini (nama file, timpa-bendera) akan menjadi argumen yang tepat untuk `PNPUT '.

'⊃' mengembalikan elemen pertama dari 'A'1( 'A'); ini adalah data yang akan ditulis.

Kemudian ⎕NPUTdijalankan, dan melaporkan berapa byte yang ditulis (2 atau 3 tergantung pada OS); ini menjadi argumen yang tepat untuk ⊣.

Yang paling kiri ⊢kembali 'A'1tidak dimodifikasi; ini adalah argumen kiri ke⊢ .

⊣mengabaikan argumen kanannya dan mengembalikan argumen kiri ( 'A'1), ini menjadi nilai baru yang diumpankan ke ⍣.

Karena nilai baru identik dengan yang lama, operasi dilanjutkan (selamanya).

SmileBASIC, 12 byte

SAVE"A
EXEC.

editor teks vim, 10 byte

qa:w<enter>@aq@a

8 byte jika Anda tidak bisa menjalankan perintah @a