(Wystarczy otworzyć 50 kart w Google Chrome: D (żartuję, nie, nie możesz))

Najkrótszy kod dla nieskończonego dysku we / wy w dowolnym języku, przykład w C #:

using System.IO;

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

Nie możesz po prostu zapełnić całego dysku, ponieważ wtedy zatrzyma się na końcu i będzie skończony.

I nie możesz robić tylko czytania, musi się zdarzyć nieskończone pisanie. (Musi zabić mój dysk SSD po wystarczającym czasie działania.)

Zaskocz! :)

DOS / Batch: 4 bajty

%0>x

Ten plik wsadowy wywoła się ( %0) i przekieruje ( >) dane wyjściowe do pliku o nazwie x. Ponieważ echo jest domyślnie włączone, spowoduje to wyświetlenie ścieżki i polecenia.

PowerShell v2 +, 10 bajtów

for(){1>1}

Po prostu zapętlaj nieskończenie za pomocą pustej forpętli. Podczas każdej iteracji wypisujemy liczbę całkowitą 1(domyślnie przekonwertowaną na ciąg) za pomocą > operatora przekierowania , który zastępuje plik o nazwie 1w katalogu lokalnym.

Pyth, 6 bajtów

#.w]]0

Jedyne polecenie wyjściowe pliku Pytha to .w. Po wywołaniu ciągu zapisuje ten ciąg do pliku w trybie dołączania, co nie jest dobre na potrzeby tego pytania. Po wywołaniu na tablicy 2-d zapisuje odpowiedni obraz do tego pliku, zastępując zawartość pliku. Tak właśnie działa ten program. Domyślna nazwa pliku wyjściowego to o.png, więc ten program nieskończenie zastępuje plik o.pngbiałym 1-pikselowym obrazem. #jest nieskończoną pętlą.

Jeśli chcesz krótszej (ale bardziej nudnej od mojej drugiej) odpowiedz:

Bash, 5 bajtów

>w;$0

Mógłbym to skrócić, jeśli istnieje polecenie (o długości mniejszej niż 3 bajty), które zapisuje coś na dysku we / wy. Coś takiego syncdziałałoby, ale syncma 4 bajty 😛

Uwaga: to nie działa, gdy jest uruchamiany bezpośrednio z bash, tylko gdy jest umieszczony w skrypcie i działa jako nazwa skryptu. (tj. echo 'w>w;$0' > bomb; chmod 755 bomb; ./bomb)

Rubin, 22 20 bajtów

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

Wielokrotnie obcina i zapisuje 1do pliku a.

Dzięki Ventero za 2 bajty!

cmd, 14 bajtów

:a
cd>1
goto a

Nieskończenie zastępuje plik 1ciągiem do bieżącego katalogu

Jestem tu nowy: czy nowe linie systemu Windows ( CR LF) są liczone jako dwa bajty?

Bash + coreutils, 10

yes \>b|sh

Zapisuje ciągły strumień >b, który jest przesyłany do shoceny. >bpo prostu obcina plik wywoływany bza każdym razem do zera bajtów.

Perl 5, 27 32 22 bajtów

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

Jeśli wystarczy zmiana znacznika czasu modyfikacji pliku ...

Szybkie wyjaśnienie:

{ # 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.
}

Poprzednie rozwiązanie (32 bajty): {{open my$h,'>o';print$h 1}redo}

Edycja: {open F,'O';print F 1;redo} ← Nie testowałem kodu przed opublikowaniem; teraz musiałem to poprawić.

PHP, 60 30 17 16 15 bajtów

Zaktualizowany jeszcze raz zgodnie z sugestią @manatwork:

while(!`cd>1`);

Również teraz przetestowane.

Trochę oszukiwania 22 bajtów:

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

Wcześniejsza sugestia @manatwork 30 bajtów:

while (file_put_contents (1,1));

NIE TESTOWANE (brak php na tym komputerze) 43 bajty:

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

Oryginalne 45 bajtów w golfa:

$ a = fopen (1, 'w'); while (fputs ($ a, 1)) przewijanie do tyłu ($ a);

Mój pierwszy post tutaj, dołączyłem, ponieważ musiałem to wypróbować: dopóki zapis pliku się powiedzie, przewiń wskaźnik pliku, aby rozpocząć.

Po prostu nie może być mniejszy niż file_put_contents ().

sh, 11 bajtów

w>w;exec $0

Zapisz to do pliku bez znaków specjalnych, takiego jak loop.sh, spraw, aby był wykonywalny i uruchom go za pomocą ./loop.shlub podobnego.

Spowoduje to zapisanie wyniku polecenia wdo pliku w, za każdym razem nadpisując poprzednią wartość. Następnie zastępuje się nową wersją tego samego programu, dzięki czemu może działać bez końca.

C, 95 94 93 89 78 90 89 76 75 bajtów

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

Znowu sudo watch -n1 lsof -p `pidof inf`wydaje się, że to prawda.

^{JAK NIE ZOBACZYŁEM TEGO PRZESTRZENI D: <}

Dzięki @Jens za zgolenie 13 bajtów: D

Bash, 26 bajtów

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

Gdybym rozwinął ten linijkę, otrzymałbym to:

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

To nie może dokładnie konkurować z 10-bajtową linią PowerShell, ale będzie się utrzymywać na tle innych. Zobacz moją drugą odpowiedź dla wersji 6-bajtowej.

TI-BASIC, 12 bajtów

While 1
Archive A
UnArchive A
End

Alternatywne rozwiązanie użytkownika lirtosiast o tym samym rozmiarze:

While 1
SetUpEditor
Archive ∟1
End

Będzie to działać na serii kalkulatorów TI-83 + i TI-84 +.

Tak, działa to również, jeśli A jest już zarchiwizowane lub w ogóle nie zostało zainicjowane na początku programu! Program ma tylko 12 bajtów z powodu tokenizacji .

CPython 3.5, 33 16 bajtów

while 1:open("a")

Tak naprawdę. :RE

MATL , 10 bajtów

`1[]T3$Z#T

Wyjaśnienie

Jest to nieskończona pętla, która zapisuje liczbę 1 do pliku wywoływanego inoutw bieżącym katalogu, zastępując zawartość poprzedniego pliku.

`       % 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 bajtów

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

Zapisz ciąg "a"do pliku o nazwie "b"i powtórz. writeFilenadpisuje plik, jeśli istnieje.

JavaScript (Node.js), 43 41 bajtów

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

Zapisuje nulldo pliku o nazwie a, a następnie powtórz.

ZSH, 14 bajtów

for ((;;)) :>:

Zsh, w przeciwieństwie do Bash i innych muszli podobnych do Bourne'a, pozwala na pętle bez do ... doneogrodzenia , pod warunkiem, że warunek jest odpowiednio ograniczony.

Alternatywnie z while:

while {} {:>:}

Zauważ, że :jest wbudowany. Nie możesz zawiesić tej pętli.

Zasada jest taka sama jak w odpowiedzi Digital Trauma - do pliku nic nie jest zapisywane, IO polega wyłącznie na tworzeniu i obcinaniu pliku.

Rdza, 84 bajtów

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

File::create obcina istniejący plik, dzięki czemu nie zabraknie miejsca na dysku.

Używany kompilator (1.9 Nightly) wyświetla ostrzeżenie o niewykorzystanym wyniku, write(...)ale mimo to kompiluje.

C, 92 bajty

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

Choć wygląda na to, że możesz zaoszczędzić 1 bajt

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

problem z tą pętlą polega na tym, że + nie daje ci gwarantowanej kolejności.

Lub rekurencyjny - nie powinien się przepełniać, jeśli kompilator poprawnie implementuje rekurencję ogona (f ma wyraźny zakres wewnętrzny)

85 bajtów

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

Mathematica, 14 bajtów

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

Wielokrotnie zapisuje ciąg "a"do pliku o nazwie aw bieżącym katalogu, tworząc go, jeśli nie istnieje.

C, 40 bajtów

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

Jednak szybko zabraknie deskryptorów plików; można temu zaradzić poprzez:

45 , 43 bajtów

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

C na amd64 Linux, 36 bajtów (tylko znacznik czasu), 52 49 bajtów (rzeczywista aktywność dysku)

open(2)Zaszyfrowałem flagi na stałe, więc nie jest to przenośne dla innych ABI. Linux na innych platformach prawdopodobnie używa tego samego O_TRUNCitp., Ale inne systemy POSIX mogą tego nie robić.

+4 bajty, aby przekazać poprawny argument uprawnień arg, aby upewnić się, że plik został utworzony z prawem do zapisu przez właściciela, patrz poniżej. (Tak się dzieje, że działa z gcc 5.2)

nieco przenośny ANSI C, 38/51 bajtów (tylko znacznik czasu), 52/67 bajtów (rzeczywista aktywność dysku)

Na podstawie odpowiedzi @ Cat z napisem @Jens.

Pierwszy numer dotyczy implementacji, w których intmoże przechowywać FILE *fopen()wartość zwracaną, drugi numer, jeśli nie możemy tego zrobić. W systemie Linux adresy stosu znajdują się w mniejszych 32 bitach przestrzeni adresowej, więc działa nawet bez -m32lub -mx32. (Deklaracja void*fopen();jest krótsza niż #include <stdio.h>)

Tylko metadane sygnatury czasowej we / wy :

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

Zapisywanie bajtu, faktyczne uderzenie w dysk w systemie Linux 4.2.0 + XFS + lazytime:

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

writejest warunkiem pętli, co jest w porządku, ponieważ zawsze zwraca 1. closejest przyrostem.

// 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

Objaśnienie wersji nieprzenośnej:

Plik jest tworzony z losowymi uprawnieniami do śmieci. W wersji gcc5.2 z -O0lub -O3zdarza się, że zawiera on uprawnienia właściciela do zapisu, ale nie jest to gwarantowane. 0666jest dziesiętnym 438. Trzeci argument, openktóry zajmie kolejne 4 bajty . Jesteśmy już na sztywno kodować O_TRUNC i tak dalej, ale to może zepsuć się z innym kompilatorem lub libc na tym samym ABI.

Nie możemy pominąć drugiego argumentu open, ponieważ zdarza się, że wartość śmieci zawiera O_EXCL, a O_TRUNC|O_APPENDwięc otwieranie kończy się niepowodzeniem EINVAL.

Nie musimy zapisywać wartości zwracanej open(). Zakładamy, że tak 3, bo zawsze tak będzie. Nawet jeśli zaczniemy od fd 3 open, zostanie ono zamknięte po pierwszej iteracji. W najgorszym przypadku, openotwiera nowe fds, dopóki 3 nie będzie ostatnim dostępnym deskryptorem pliku. Tak więc, do pierwszych 65531 write()wywołań może się nie powieść EBADF, ale wtedy będzie działać normalnie z każdym opentworzeniem fd = 3.

577 = 0x241 = O_WRONLY|O_CREAT|O_TRUNCw systemie Linux x86-64. Bez O_TRUNCtego czas mod i-węzła i czas zmiany nie są aktualizowane, więc krótszy argument nie jest możliwy. O_TRUNCjest nadal niezbędny dla wersji, która wywołuje writerzeczywistą aktywność dysku, a nie przepisuje w miejscu.

Widzę kilka odpowiedzi na to open("a",1). O_CREAT jest wymagany, jeśli jeszcze anie istnieje. O_CREATjest zdefiniowany jako ósemkowy 0100 (64, 0x40) w systemie Linux.

Brak wycieków zasobów, dzięki czemu może działać wiecznie. stracewynik:

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

lub

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

Mam wartość dziesiętną openflag dla tego ABI, używając strace -eraw=openmojej wersji C ++.

W systemie plików z lazytimewłączoną opcją montowania Linuksa zmiana, która wpływa tylko na znaczniki czasu i-węzła, spowoduje tylko jeden zapis na 24 godziny. Po wyłączeniu tej opcji montowania aktualizacja znaczników czasu może być dobrym sposobem na zużycie dysku SSD. (Jednak kilka innych odpowiedzi dotyczy tylko metadanych I / O).

alternatywy:

krótszy niedziałający :

main(){for(;;)close(write(open("a",577),"",3));}używa writewartości zwracanej do przekazania 3argumentu do zamknięcia. Zapisuje kolejny bajt, ale nie działa z gcc -O0 lub -O3 na amd64. Śmieci w trzecim arg opensą różne i nie obejmują uprawnień do zapisu. azostanie utworzony za pierwszym razem, ale wszystkie przyszłe iteracje kończą się niepowodzeniem -EACCESS.

dłużej, działając, z różnymi wywołaniami systemowymi :

main(c){for(open("a",65);pwrite(3,"",1);)sync();} przepisuje bajt w miejscu i wywołuje sync()synchronizację wszystkich systemów plików w całym systemie. Dzięki temu świeci lampka napędu.

Nie obchodzi nas, który bajt, więc nie przekazujemy czwartego argumentu do napisania. Tak, dla rzadkich plików:

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

Napisanie jednego bajtu z przesunięciem ~ 128TiB doprowadziło do XFS przy użyciu 300kB miejsca do przechowywania mapy zasięgu, tak myślę. Nie próbuj tego w systemie OS X z HFS +: IIRC, HFS + nie obsługuje plików rzadkich, więc zapełni dysk.

XFS to właściwy 64-bitowy system plików, obsługujący pojedyncze pliki do 8 eksabajtów . tj. 2 ^ 63-1, maksymalna wartość off_tmoże utrzymać.

strace wynik:

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

Rakieta, 46 bajtów

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

Współczynnik, 73 bajty

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

Na zawsze ustawia zawartość pliku na bajt nul.

CBM BASIC 7.0, 9 bajtów

0dS"a":rU

Po uruchomieniu program wielokrotnie zapisuje się na dysku. Oto bardziej czytelna wersja, która nie używa skrótów BASIC:

0 dsave "a" : run

Python, 32 bajty

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

Zauważ, że jeśli uruchomisz na Pythonie 3, spowoduje to nieskończoną liczbę ostrzeżeń. Ponadto prawdopodobnie zabraknie FDS, jeśli zostanie uruchomiony w implementacji innej niż rozliczeniowa.

Dyalog APL 15.0, 17 bajtów (niekonkurencyjny)

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

Chrome obecnie źle interpretuje kod U + 2262. Powyższa linia powinna wyglądać (⊢⊣⊃⎕NPUT⊢)⍣̸≡'A'1.

Jest to niekonkurencyjne, ponieważ wersja 15 nie została jeszcze wydana.

Dotyczy ⍣funkcji (⊢⊣⊃⎕NPUT⊢)na 'A'1aż do wejścia zostanie zmieniony (czyli nigdy):

⊢⊣⊃⎕NPUT⊢ jest ciągiem funkcji:

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

Skrajny prawy ⊢zwraca 'A'1niezmodyfikowany; to (nazwa pliku, flaga zastępująca) będzie właściwym argumentem dla `⎕NPUT '.

„⊃” zwraca pierwszy element 'A'1( 'A'); to dane do zapisania.

Następnie ⎕NPUTjest uruchamiany i informuje, ile bajtów zostało zapisanych (2 lub 3 w zależności od systemu operacyjnego); staje się to właściwym argumentem dla ⊣.

Skrajnie lewy ⊢ponownie zwraca 'A'1niezmodyfikowany; to jest lewy argument do ⊢.

⊣ignoruje swój prawy argument i zwraca lewy argument ( 'A'1), staje się to nową wartością dostarczaną do ⍣.

Ponieważ nowa wartość jest identyczna ze starą, operacja jest kontynuowana (na zawsze).

SmileBASIC, 12 bajtów

SAVE"A
EXEC.

edytor tekstu vim, 10 bajtów

qa:w<enter>@aq@a

8 bajtów, jeśli nie można wykonać polecenia wykonania @a