(Öffne einfach 50 Tabs in Google Chrome: D (nur ein Scherz, nein, das kannst du nicht))

Kürzester Code für unendliche Festplatten-E / A in einer beliebigen Sprache, C # -Beispiel:

using System.IO;

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

Sie können jedoch nicht einfach die gesamte Festplatte füllen, da diese am Ende stehen bleiben und endlich sein würde.

Und man kann nicht nur lesen, es muss unendlich viel geschrieben werden. (Es muss meine SSD nach genügend Laufzeit töten.)

Los geht's! :)

DOS / Batch: 4 Bytes

%0>x

Diese Batch-Datei ruft sich selbst auf ( %0) und leitet >die Ausgabe in eine aufgerufene Datei um ( ) x. Da das Echo standardmäßig aktiviert ist, werden der Pfad und der Befehl ausgegeben.

PowerShell v2 +, 10 Byte

for(){1>1}

Schleifen Sie einfach unendlich mit einer leeren forSchleife. Bei jeder Iteration geben wir die Ganzzahl 1(implizit in eine Zeichenfolge konvertiert) mit dem > Umleitungsoperator aus , der die 1im lokalen Verzeichnis angegebene Datei überschreibt .

Pyth, 6 Bytes

#.w]]0

Pyths einziger Dateiausgabebefehl ist .w. Beim Aufrufen einer Zeichenfolge wird diese Zeichenfolge im Anhänge-Modus in eine Datei geschrieben, was für den Zweck dieser Frage nicht geeignet ist. Wenn es in einem 2D-Array aufgerufen wird, schreibt es das entsprechende Bild in diese Datei und überschreibt den Dateiinhalt. Genau das macht dieses Programm. Der Standardname für die Dateiausgabe ist o.png, sodass dieses Programm die Datei unendlich o.pngmit einem 1-Pixel-Weißbild überschreibt . #ist eine Endlosschleife.

Wenn Sie eine kürzere (aber langweiligere als meine andere) Antwort wünschen:

Bash, 5 Bytes

>w;$0

Ich könnte das kürzer machen, wenn es einen Befehl gibt (weniger als 3 Bytes lang), der etwas auf Disk I / O schreibt. Sowas syncwürde funktionieren, ist aber sync4 Bytes 😛

Hinweis: Dies funktioniert nicht, wenn Sie direkt von Bash ausgeführt werden, sondern nur, wenn Sie ein Skript einfügen und es als Skriptname ausführen. (ie echo 'w>w;$0' > bomb; chmod 755 bomb; ./bomb)

Ruby, 22 bis 20 Bytes

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

Schneidet wiederholt ab und schreibt ein 1in die Datei a.

Danke an Ventero für 2 Bytes!

cmd, 14 bytes

:a
cd>1
goto a

Überschreibt die Datei unbegrenzt 1mit der Zeichenfolge in das aktuelle Verzeichnis

Ich bin neu hier: Werden Windows New Lines ( CR LF) als zwei Bytes gezählt?

Bash + Coreutils, 10

yes \>b|sh

Schreibt einen kontinuierlichen Stream von >b, der shzur Auswertung weitergeleitet wird. >bKürzt einfach eine aufgerufene Datei bjedes Mal auf null Byte.

Perl 5, 27 32 22 Bytes

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

Wenn das Ändern des Änderungszeitstempels einer Datei ausreicht ...

Schnelle Erklärung:

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

Vorherige Lösung (32 Bytes): {{open my$h,'>o';print$h 1}redo}

Bearbeiten: {open F,'O';print F 1;redo} ← Code vor dem Posten nicht getestet; jetzt musste ich es korrigieren.

PHP, 60 30 17 16 15 Bytes

Nochmals aktualisiert, wie von @manatwork vorgeschlagen:

while(!`cd>1`);

Auch jetzt getestet.

Ein bisschen schummeln 22 Bytes:

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

Vorheriger Vorschlag von @manatwork 30 Bytes:

while (file_put_contents (1,1));

NICHT GETESTET (auf diesem Computer ist kein PHP verfügbar) 43 bytes:

für ($ a = fopen (1, 'w'); fputs ($ a, 1); fclose ($ a))

Ein Golf Original 45 Bytes:

$ a = fopen (1, 'w'); while (fputs ($ a, 1)) Rücklauf ($ a);

Mein erster Beitrag hier ist beigetreten, weil ich dies nur ausprobieren musste: Solange das Schreiben der Datei erfolgreich ist, spulen Sie den Dateizeiger zurück, um zu beginnen.

Kann einfach nicht kleiner als die file_put_contents () werden.

sh, 11 Bytes

w>w;exec $0

Speichern Sie dies in einer Datei ohne Sonderzeichen wie loop.sh, machen Sie sie ausführbar und führen Sie sie mit ./loop.shoder ähnlichem aus.

Dadurch wird die Ausgabe des Befehls win die Datei geschrieben wund der vorherige Wert jedes Mal überschrieben. Anschließend wird es durch eine neue Version desselben Programms ersetzt, sodass es unendlich ausgeführt werden kann.

C 95 94 93 89 78 90 89 76 75 Bytes

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

Auch hier sudo watch -n1 lsof -p `pidof inf`scheint zu sagen, dass dies gültig ist.

^{WIE HABE ICH DIESEN RAUM NICHT GESEHEN?}

Vielen Dank an @Jens für das Abschneiden von 13 Bytes: D

Bash, 26 Bytes

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

Wenn ich diesen Einzeiler erweitern würde, würde ich Folgendes bekommen:

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

Dies kann nicht mit der 10-Byte-PowerShell-Linie konkurrieren, kann sich aber gegen die anderen behaupten. Siehe meine andere Antwort für die 6-Byte-Version.

TI-BASIC, 12 Bytes

While 1
Archive A
UnArchive A
End

Alternative Lösung durch den Benutzer lirtosiast mit der gleichen Größe:

While 1
SetUpEditor
Archive ∟1
End

Dies funktioniert mit den Taschenrechnern der Serien TI-83 + und TI-84 +.

Ja, das funktioniert auch, wenn A bereits archiviert ist oder beim Programmstart gar nicht initialisiert wird! Das Programm hat aufgrund der Tokenisierung nur 12 Byte .

CPython 3.5, 33 16 Bytes

while 1:open("a")

Ja wirklich. : D

MATL , 10 Bytes

`1[]T3$Z#T

Erläuterung

Dies ist eine Endlosschleife, die die Nummer 1 in eine inoutim aktuellen Verzeichnis aufgerufene Datei schreibt und den Inhalt der vorherigen Datei überschreibt.

`       % 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 Bytes

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

Schreiben Sie die Zeichenfolge "a"in eine Datei mit dem Namen "b"und wiederholen Sie. writeFileüberschreibt die Datei, falls vorhanden.

JavaScript (Node.js), 43 bis 41 Byte

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

Schreibt nullin eine Datei mit dem Namen aund wiederholt sie.

ZSH, 14 Bytes

for ((;;)) :>:

Zsh erlaubt im Gegensatz zu Bash und anderen Bourne-ähnlichen Muscheln Schleifen ohne do ... doneZaun , sofern die Bedingung angemessen abgegrenzt ist.

Alternativ mit while:

while {} {:>:}

Beachten Sie, dass dies :ein eingebautes ist. Sie können diese Schleife nicht aussetzen.

Das Prinzip ist dasselbe wie in der Antwort von Digital Trauma - nichts wird in die Datei geschrieben, die E / A besteht lediglich aus dem Erstellen und Abschneiden der Datei.

Rust, 84 Bytes

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

File::create Kürzt eine vorhandene Datei und stellt so sicher, dass der Speicherplatz nicht knapp wird.

Der verwendete Compiler (1.9 Nightly) gibt eine Warnung über das nicht verwendete Ergebnis aus write(...), kompiliert aber trotzdem.

C 92 Bytes

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

Es sieht zwar so aus, als könnten Sie 1 Byte speichern

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

Das Problem mit dieser Schleife ist, dass + Ihnen nicht die garantierte Reihenfolge gibt.

Oder rekursiv - sollte nicht überlaufen, wenn der Compiler die Endrekursion ordnungsgemäß implementiert (f liegt in einem expliziten inneren Bereich)

85 Bytes

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

Mathematica, 14 Bytes

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

Schreibt die Zeichenfolge wiederholt "a"in eine Datei mit dem Namen aim aktuellen Verzeichnis und erstellt sie, wenn sie nicht vorhanden ist.

C 40 Bytes

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

Es werden jedoch schnell keine Dateideskriptoren mehr vorhanden sein. Dies kann überwunden werden mit:

45 , 43 Bytes

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

C unter amd64 Linux, 36 Bytes (nur Zeitstempel), 52 49 Bytes (echte Festplattenaktivität)

Ich codiere die open(2)Flags hart , so dass dies nicht auf andere ABIs übertragbar ist. Linux auf anderen Plattformen verwendet wahrscheinlich dasselbe O_TRUNCusw., andere POSIX-Betriebssysteme jedoch möglicherweise nicht.

+4 Bytes , um ein korrektes Berechtigungsargument zu übergeben, um sicherzustellen, dass die Datei mit dem Schreibzugriff des Besitzers erstellt wurde (siehe unten). (Dies funktioniert mit gcc 5.2)

etwas portables ANSI C, 38/51 Bytes (nur Zeitstempel), 52/67 Bytes (echte Festplattenaktivität)

Basierend auf der Antwort von @ Cat, mit einem Tipp von @Jens.

Die erste Zahl ist für Implementierungen intgedacht FILE *fopen(), bei denen der Rückgabewert eines can hold ist, die zweite Zahl, wenn wir das nicht können. Unter Linux befinden sich Heap-Adressen in den unteren 32 Bit des Adressraums, daher funktioniert dies auch ohne -m32oder -mx32. (Deklaration void*fopen();ist kürzer als #include <stdio.h>)

Nur Zeitstempel-Metadaten-E / A :

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

Schreiben eines Bytes unter Linux 4.2.0 + XFS + lazytime:

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

writeist die for-Schleifenbedingung, die in Ordnung ist, da sie immer 1 zurückgibt. Ist closedas Inkrement.

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

Erklärung der nicht portierbaren Version:

Die Datei wird mit zufälligen Speicherbereinigungen erstellt. In gccVersion 5.2, mit -O0oder -O3, ist möglicherweise eine Schreibberechtigung für den Eigentümer enthalten, dies kann jedoch nicht garantiert werden. 0666ist dezimal 438. Ein drittes Argument für openwürde weitere 4 Bytes benötigen . Wir haben bereits O_TRUNC und so weiter hartcodiert, aber dies kann mit einem anderen Compiler oder einer anderen libc auf demselben ABI zu Problemen führen.

Wir können nicht die 2. arg verzichten open, da der Garbage Wert enthalten geschieht O_EXCL, und O_TRUNC|O_APPEND, so offen nicht mit EINVAL.

Der Rückgabewert von muss nicht gespeichert werden open(). Wir gehen davon aus 3, dass es so ist , weil es immer so sein wird. Auch wenn wir mit fd 3 open beginnen, wird es nach der ersten Iteration geschlossen. Im schlimmsten Fall werden so lange openneue FDS geöffnet, bis 3 der letzte verfügbare Dateideskriptor ist. Bis zu den ersten 65531- write()Aufrufen konnte dies fehlschlagen EBADF, funktioniert dann aber normal mit jeder openErstellung von fd = 3.

577 = 0x241 = O_WRONLY|O_CREAT|O_TRUNCunter x86-64 Linux. Ohne O_TRUNCwerden die Inode-Mod-Zeit und die Änderungszeit nicht aktualisiert, so dass ein kürzeres Argument nicht möglich ist. O_TRUNCist immer noch wichtig für die Version, die writezum Erzeugen der tatsächlichen Festplattenaktivität aufruft , und nicht zum erneuten Schreiben.

Ich sehe einige Antworten darauf open("a",1). O_CREAT ist erforderlich, falls anoch nicht vorhanden. O_CREATist unter Linux als oktal 0100 (64, 0x40) definiert.

Keine Ressourcenlecks, daher kann es für immer ausgeführt werden. straceAusgabe:

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

oder

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

Ich habe den Dezimalwert der openFlags für dieses ABI strace -eraw=openin meiner C ++ - Version erhalten.

Auf einem Dateisystem mit lazytimeaktivierter Linux- Mount-Option führt eine Änderung, die sich nur auf Inode-Zeitstempel auswirkt, nur zu einem Schreibvorgang pro 24 Stunden. Wenn diese Einhängeoption deaktiviert ist, kann die Zeitstempelaktualisierung möglicherweise die SSD strapazieren. (Einige andere Antworten führen jedoch nur Metadaten-E / A aus.)

Alternativen:

kürzer arbeitslos :

main(){for(;;)close(write(open("a",577),"",3));}Verwendet writeden Rückgabewert von 's, um ein 3Argument zum Schließen zu übergeben. Es speichert ein weiteres Byte, funktioniert aber nicht mit gcc -O0 oder -O3 auf amd64. Der Müll im 3. Argument openist anders und enthält keine Schreibrechte. awird das erste Mal erstellt, aber zukünftige Iterationen scheitern alle mit -EACCESS.

länger arbeiten, mit verschiedenen Systemaufrufen :

main(c){for(open("a",65);pwrite(3,"",1);)sync();} Schreibt ein Byte an Ort und Stelle neu und ruft sync()auf, um alle Dateisysteme systemweit zu synchronisieren. Dadurch bleibt die Laufwerksanzeige eingeschaltet.

Es ist uns egal welches Byte, also übergeben wir das 4. Argument nicht an pwrite. Ja für spärliche Dateien:

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

Das Schreiben eines Bytes mit einem Offset von ~ 128 TB führte dazu, dass xfs 300 KB Speicherplatz für die Extent-Map benötigte. Versuchen Sie dies nicht unter OS X mit HFS +: IIRC, HFS + unterstützt keine Sparse-Dateien, daher wird die Festplatte gefüllt.

XFS ist ein richtiges 64-Bit-Dateisystem, das einzelne Dateien mit bis zu 8 Exabyte unterstützt . Dh 2 ^ 63-1, der Maximalwert off_tkann halten.

strace Ausgabe:

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

Schläger, 46 Bytes

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

Faktor 73 Bytes

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

Setzt den Dateiinhalt für immer auf das Null-Byte.

CBM BASIC 7.0, 9 Bytes

0dS"a":rU

Wenn dieses Programm ausgeführt wird, speichert es sich wiederholt auf der Festplatte. Hier ist eine besser lesbare Version, die keine BASIC-Schlüsselwortabkürzungen verwendet:

0 dsave "a" : run

Python, 32 Bytes

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

Beachten Sie, dass unter Python 3 unendlich viele Warnungen ausgegeben werden. Außerdem wird es wahrscheinlich keine FDS mehr geben, wenn es in einer Implementierung ohne erneute Zählung ausgeführt wird.

Dyalog APL 15.0, 17 Bytes (nicht konkurrierend)

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

Chrome rendert derzeit U + 2262 falsch. Die obige Zeile sollte so aussehen(⊢⊣⊃⎕NPUT⊢)⍣̸≡'A'1 .

Dies ist nicht konkurrierend, da Version 15 noch nicht veröffentlicht wurde.

Wendet ⍣die Funktion (⊢⊣⊃⎕NPUT⊢)an, 'A'1bis der Eingang geändert wird (dh nie):

⊢⊣⊃⎕NPUT⊢ ist ein Funktionszug:

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

Das Recht kommt ⊢zurück'A'1 unverändert zurück. Dies (Dateiname, Überschreib-Flag) ist das richtige Argument für `⎕NPUT '.

'⊃' gibt das erste Element von 'A'1(zurück'A' ) zurück; Dies sind die zu schreibenden Daten.

Dann ⎕NPUTwird ausgeführt und gemeldet, wie viele Bytes geschrieben wurden (2 oder 3, je nach Betriebssystem). Dies wird das richtige Argument für die⊣ .

Das äußerste linke Ende ⊢kehrt 'A'1unverändert zurück. Dies ist das linke Argument für die ⊢.

⊣Ignoriert das rechte Argument und gibt das linke Argument ( 'A'1) zurück, dies wird der neue Wert, dem zugeführt wird ⍣.

Da der neue Wert mit dem alten identisch ist, wird die Operation (für immer) fortgesetzt.

SmileBASIC, 12 Bytes

SAVE"A
EXEC.

VIM-Texteditor, 10 Byte

qa:w<enter>@aq@a

8 Bytes, wenn Sie den Ausführungsbefehl nicht könnten @a