(Il suffit d'ouvrir 50 onglets dans Google Chrome: D (je plaisante, non, vous ne pouvez pas))

Code le plus court pour les E / S disque infinies n’importe quel langage, exemple en C #:

using System.IO;

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

Cependant, vous ne pouvez pas simplement remplir le disque en entier, car cela s’arrêterait à la fin et serait fini.

Et vous ne pouvez pas lire uniquement, une écriture infinie doit se produire. (Il doit tuer mon SSD après suffisamment de temps d'exécution.)

Obtenez craquer! :)

DOS / Lot: 4 octets

%0>x

Ce fichier de commandes s'appellera ( %0) et redirigera ( >) la sortie vers un fichier appelé x. Comme echo est activé par défaut, le chemin et la commande seront générés.

PowerShell v2 +, 10 octets

for(){1>1}

forBoucle simplement infiniment avec une boucle vide . À chaque itération, nous produisons l'entier 1(converti implicitement en chaîne) avec l' > opérateur de redirection , qui écrase le fichier nommé 1dans le répertoire local.

Pyth, 6 octets

#.w]]0

La seule commande de sortie de fichier de Pyth est .w. Lorsqu'il est appelé sur une chaîne, il écrit cette chaîne dans un fichier en mode ajout, ce qui ne sert à rien pour les besoins de cette question. Lorsqu'il est appelé sur un tableau 2D, il écrit l'image correspondante dans ce fichier, en remplaçant le contenu du fichier. C'est ce que fait ce programme. Le nom de sortie du fichier par défaut est o.png, de sorte que ce programme écrase infiniment le fichier o.pngavec une image blanche de 1 pixel. #est une boucle infinie.

Si vous voulez une réponse plus courte (mais plus ennuyeuse que mon autre):

Bash, 5 octets

>w;$0

Je pourrais rendre cela plus court s'il y avait une commande (moins de 3 octets) qui écrit quelque chose sur les E / S du disque. Quelque chose comme ça syncmarcherait, mais syncc'est 4 octets

Remarque: cela ne fonctionne pas lorsqu'il est exécuté directement à partir de bash, uniquement lorsqu'il est placé dans un script et exécuté sous le nom du script. (ie echo 'w>w;$0' > bomb; chmod 755 bomb; ./bomb)

Ruby, 22 à 20 octets

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

À plusieurs reprises, tronque et écrit un 1dans le fichier a.

Merci à Ventero pour 2 octets!

cmd, 14 octets

:a
cd>1
goto a

Écrase infiniment le fichier 1avec la chaîne dans le répertoire en cours

Je suis nouveau ici: les nouvelles lignes de Windows ( CR LF) sont-elles comptées comme deux octets?

Bash + coreutils, 10

yes \>b|sh

Écrit un flux continu de >b, qui est dirigé vers shpour évaluation. >btronque simplement un fichier appelé bà zéro octet à chaque fois.

Perl 5, 27 32 22 octets

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

Si le simple changement de l'horodatage de modification d'un fichier suffit ...

Explication rapide:

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

Solution précédente (32 octets): {{open my$h,'>o';print$h 1}redo}

Edit: {open F,'O';print F 1;redo} ← N'a pas testé le code avant de poster; maintenant je devais le corriger.

PHP, 60 30 17 16 15 octets

Mis à jour encore une fois selon les suggestions de @manatwork:

while(!`cd>1`);

Aussi maintenant testé.

Un peu de tricherie 22 octets:

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

Suggestion précédente de @manatwork 30 octets:

while (file_put_contents (1,1));

NOT TESTED (pas de php disponible sur cet ordinateur) 43 octets:

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

Un original golfique de 45 octets:

$ a = fopen (1, 'w'); tandis que (fputs ($ a, 1)) rembobine ($ a);

Mon premier post ici, rejoint parce que je devais simplement essayer ceci: tant que l'écriture de fichier réussit, rembobinez le pointeur de fichier pour commencer.

Ne peut tout simplement pas être plus petit que file_put_contents ().

sh, 11 octets

w>w;exec $0

Enregistrez-le dans un fichier sans caractères spéciaux, tel que loop.sh, rendez-le exécutable et exécutez-le avec ./loop.shou similaire.

Ceci écrit la sortie de la commande wdans le fichier w, écrasant la valeur précédente à chaque fois. Ensuite, il se remplace par une nouvelle version du même programme, afin de pouvoir fonctionner à l'infini.

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

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

Encore une fois, sudo watch -n1 lsof -p `pidof inf`semble dire que c'est valide.

^{COMMENT NE VOIS-JE PAS CET ESPACE D: <}

Merci @Jens d' avoir réduit 13 octets: D

Bash, 26 octets

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

Si je devais développer ce one-line, j'obtiendrais ceci:

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

Cela ne peut pas rivaliser avec la ligne PowerShell de 10 octets, mais elle se démarquera des autres. Voir mon autre réponse pour la version à 6 octets.

TI-BASIC, 12 octets

While 1
Archive A
UnArchive A
End

Solution alternative de l'utilisateur lirtosiast avec la même taille:

While 1
SetUpEditor
Archive ∟1
End

Cela fonctionnera avec les calculatrices des séries TI-83 + et TI-84 +.

Oui, cela fonctionne aussi si A est déjà archivé ou n'est pas initialisé du tout au début du programme! Le programme n’a que 12 octets à cause de la tokenisation .

CPython 3.5, 33 16 octets

while 1:open("a")

Oui vraiment. :RÉ

MATL , 10 octets

`1[]T3$Z#T

Explication

Il s'agit d'une boucle infinie qui écrit le numéro 1 dans un fichier appelé inoutdans le répertoire en cours, écrasant le contenu du fichier précédent.

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

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

Ecrivez la chaîne "a"dans un fichier nommé "b"et recommencez. writeFileécrase le fichier s'il existe.

JavaScript (Node.js), 43 41 octets

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

Écrit nulldans un fichier nommé a, puis recommencez.

ZSH, 14 octets

for ((;;)) :>:

Zsh, contrairement à Bash et aux autres coques de type Bourne, autorise les boucles sans la do ... doneclôture , à condition que la condition soit correctement délimitée.

Alternativement, avec while:

while {} {:>:}

Notez que :c'est un construit. Vous ne pouvez pas suspendre cette boucle.

Le principe est le même que dans la réponse de Digital Trauma : rien n'est écrit dans le fichier, l'IO provient uniquement de la création et de la troncature du fichier.

Rouille, 84 octets

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

File::create tronque un fichier existant, assurant ainsi que nous ne manquons pas d’espace disque.

Le compilateur utilisé (1.9 Nightly) émet un avertissement sur le résultat inutilisé de write(...)mais compile néanmoins.

C, 92 octets

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

Bien qu’il semble que vous puissiez économiser 1 octet sur

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

Le problème avec cette boucle est que + ne vous donne pas l'ordre garanti.

Ou récursif - ne devrait pas déborder si le compilateur implémente correctement la récursion finale (f est dans une portée interne explicite)

85 octets

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

Mathematica, 14 octets

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

Ecrit à plusieurs reprises la chaîne "a"dans un fichier nommé adans le répertoire en cours, en la créant si elle n'existe pas.

C, 40 octets

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

Il va rapidement manquer de descripteurs de fichiers; ceci peut être surmonté avec:

45 , 43 octets

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

C sur amd64 Linux, 36 octets (horodatage uniquement), 52 49 octets (activité réelle du disque)

Je code en dur les open(2)drapeaux, donc ce n'est pas portable pour les autres ABI. Linux sur d'autres plates-formes utilise probablement la même chose O_TRUNC, etc., mais pas les autres systèmes d'exploitation POSIX.

+4 octets pour passer un argument d'autorisation correct afin de vous assurer que le fichier est créé avec un accès en écriture propriétaire, voir ci-dessous. (Ceci arrive avec gcc 5.2)

ANSI C relativement portable, 38/51 octets (horodatage uniquement), 52/67 octets (activité réelle du disque)

Basé sur la réponse de @Chat, avec un conseil de @Jens.

Le premier nombre est destiné aux implémentations dans lesquelles une valeur intpeut être FILE *fopen()retournée, le deuxième nombre si nous ne pouvons pas le faire. Sous Linux, il se trouve que les adresses de segment de mémoire se situent dans les 32 bits d'espace disque, de sorte que cela fonctionne même sans -m32ou -mx32. (Déclarer void*fopen();est plus court que #include <stdio.h>)

Métadonnées d'horodatage I / O uniquement :

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

Écrire un octet, frapper le disque sous Linux 4.2.0 + XFS + lazytime:

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

writeest la condition de boucle for, ce qui est correct car elle renvoie toujours 1. closeest l'incrément.

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

Explication de la version non portable:

Le fichier est créé avec des autorisations aléatoires. Avec gcc5.2, avec -O0ou -O3, il arrive que l’autorisation d’écriture du propriétaire soit incluse, mais cela n’est pas garanti. 0666est un nombre décimal 438. Un 3ème argument openprendrait encore 4 octets . Nous sommes déjà en train de coder en dur O_TRUNC, etc., mais cela pourrait rompre avec un compilateur ou une libc différent sur le même ABI.

Nous ne pouvons pas omettre le 2nd argument open, car la valeur de garbage inclut O_EXCL, et O_TRUNC|O_APPENDdonc, open échoue avec EINVAL.

Nous n'avons pas besoin de sauvegarder la valeur de retour de open(). Nous supposons que c'est 3parce que ça le sera toujours. Même si nous commençons par ouvrir fd 3, il sera fermé après la première itération. Dans le pire des cas, opencontinue d'ouvrir de nouveaux fichiers jusqu'à ce que 3 soit le dernier descripteur de fichier disponible. Ainsi, jusqu'aux premiers 65531 write()appels pourraient échouer avec EBADF, mais fonctionneront ensuite normalement avec chaque opencréation fd = 3.

577 = 0x241 = O_WRONLY|O_CREAT|O_TRUNCsous Linux x86-64. Sans cela O_TRUNC, le temps d'inode mod et le temps de changement ne sont pas mis à jour, donc un argument plus court n'est pas possible. O_TRUNCest toujours essentiel pour la version qui appelle writepour générer une activité de disque réelle et non pour réécrire en place.

Je vois des réponses qui open("a",1). O_CREAT est requis s'il an'existe pas déjà. O_CREATest défini comme octal 0100 (64, 0x40) sous Linux.

Aucune ressource ne fuit, elle peut donc fonctionner pour toujours. stracesortie:

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

ou

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

J'ai eu la valeur décimale des opendrapeaux pour cette ABI en utilisant strace -eraw=openma version C ++.

Sur un système de fichiers avec l' lazytimeoption de montage Linux activée, une modification qui affecte uniquement les horodatages d'inode ne provoquera qu'une écriture par 24 heures. Avec cette option de montage désactivée, la mise à jour d'horodatage peut constituer un moyen viable d'user votre disque SSD. (Cependant, plusieurs autres réponses ne font que des métadonnées d'E / S).

alternatives:

plus court non-travail :

main(){for(;;)close(write(open("a",577),"",3));}utilise writela valeur de retour pour passer un 3argument à fermer. Il enregistre un autre octet, mais ne fonctionne pas avec gcc -O0 ou -O3 sur amd64. La poubelle du 3ème argument openest différente et n'inclut pas l'autorisation d'écriture. aest créé la première fois, mais les itérations futures échouent -EACCESS.

plus long, fonctionnel, avec différents appels système :

main(c){for(open("a",65);pwrite(3,"",1);)sync();} réécrit un octet sur place et appelle sync()à synchroniser tous les systèmes de fichiers à l'échelle du système. La lumière de lecteur reste allumée.

Nous ne nous soucions pas de quel octet, nous ne passons donc pas le 4ème argument à écrire. Yay pour les fichiers clairsemés:

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

Écrire un octet avec un décalage de ~ 128 To a conduit xfs à utiliser 300 ko d'espace pour contenir la carte d'étendue, je suppose. N'essayez pas ceci sur OS X avec HFS +: IIRC, HFS + ne supporte pas les fichiers fragmentés, il va donc remplir le disque.

XFS est un système de fichiers 64 bits approprié, prenant en charge des fichiers individuels allant jusqu'à 8 exaoctets . c'est-à-dire 2 ^ 63-1, la valeur maximale off_tpeut être retenue.

strace sortie:

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

Raquette, 46 octets

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

Facteur, 73 octets

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

Définit le contenu du fichier sur l'octet nul pour toujours.

CBM BASIC 7.0, 9 octets

0dS"a":rU

Ce programme, lorsqu'il est exécuté, s'enregistre de manière répétée sur le disque. Voici une version plus lisible qui n'utilise pas les abréviations de mots-clés BASIC:

0 dsave "a" : run

Python, 32 octets

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

Notez que s'il est exécuté sur python 3, cela produira un nombre infini d'avertissements. En outre, il manquera probablement de fds s'il est exécuté dans une implémentation sans calcul en parallèle.

Dyalog APL 15.0, 17 octets (non concurrents)

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

Chrome rend actuellement U + 2262 incorrect. La ligne ci-dessus devrait ressembler (⊢⊣⊃⎕NPUT⊢)⍣̸≡'A'1.

Ceci n’est pas concurrentiel car la version 15 n’a pas encore été publiée.

Applique ⍣la fonction (⊢⊣⊃⎕NPUT⊢)sur 'A'1jusqu'à ce que l'entrée est modifié (jamais):

⊢⊣⊃⎕NPUT⊢ est un train de fonction:

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

Le plus à droite ⊢revient 'A'1non modifié; ceci (nom de fichier, overwrite-flag) sera le bon argument pour ``NPUT '.

'' Renvoie le premier élément de 'A'1( 'A'); ce sont les données à écrire.

Ensuite, ⎕NPUTest exécuté et indique le nombre d'octets écrits (2 ou 3 selon le système d'exploitation); cela devient le bon argument pour le ⊣.

Le plus ⊢à gauche retourne à nouveau 'A'1non modifié; c'est l'argument de gauche à la ⊢.

⊣ignore son argument de droite et renvoie l'argument de gauche ( 'A'1), cela devient la nouvelle valeur alimentée ⍣.

Comme la nouvelle valeur est identique à l’ancienne, l’opération est poursuivie (pour toujours).

SmileBASIC, 12 octets

SAVE"A
EXEC.

éditeur de texte vim, 10 octets

qa:w<enter>@aq@a

8 octets si vous ne pouvez pas la commande d'exécution @a