(Solo abre 50 pestañas en Google Chrome: D (es broma, no, no puedes))

Código más corto para E / S de disco infinito en cualquier idioma, ejemplo de C #:

using System.IO;

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

Sin embargo, no puede simplemente llenar todo el disco, ya que al final se detendría y sería finito.

Y no puedes leer solo, tiene que suceder una escritura infinita. (Tiene que matar mi SSD después de suficiente tiempo de ejecución).

¡Manos a la obra! :)

DOS / Lote: 4 bytes

%0>x

Este archivo por lotes se llamará a sí mismo ( %0) y redirigirá ( >) la salida a un archivo llamado x. Como echo está activado de forma predeterminada, esto generará la ruta y el comando.

PowerShell v2 +, 10 bytes

for(){1>1}

Simplemente realiza un bucle infinito con un forbucle vacío . En cada iteración, sacamos el entero 1(implícitamente convertido a una cadena) con el > operador de redireccionamiento , que sobrescribe el archivo nombrado 1en el directorio local.

Pyth, 6 bytes

#.w]]0

El único comando de salida de archivo de Pyth es .w. Cuando se invoca en una cadena, escribe esa cadena en un archivo en modo anexar, lo que no es bueno para el propósito de esta pregunta. Cuando se llama en una matriz de 2-d, escribe la imagen correspondiente en ese archivo, sobrescribiendo el contenido del archivo. Eso es lo que hace este programa. El nombre de salida del archivo predeterminado es o.png, por lo que este programa sobrescribe infinitamente el archivo o.pngcon una imagen blanca de 1 píxel. #Es un bucle infinito.

Si quieres una respuesta más corta (pero más aburrida que la otra):

Bash, 5 bytes

>w;$0

Podría hacerlo más corto si hay un comando (menos de 3 bytes de longitud) que escribe algo en la E / S del disco. Algo así syncfuncionaría, pero synces de 4 bytes 😛

Nota: esto no funciona cuando se ejecuta directamente desde bash, solo cuando se coloca un script y se ejecuta como el nombre del script. (es decir echo 'w>w;$0' > bomb; chmod 755 bomb; ./bomb)

Ruby, 22 20 bytes

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

Se trunca y escribe repetidamente 1a en el archivo a.

¡Gracias a Ventero por 2 bytes!

cmd, 14 bytes

:a
cd>1
goto a

Sobrescribe infinitamente el archivo 1con la cadena en el directorio actual

Soy nuevo aquí: ¿Las nuevas líneas de Windows ( CR LF) se cuentan como dos bytes?

Bash + coreutils, 10

yes \>b|sh

Escribe una secuencia continua de >b, que se canaliza shpara su evaluación. >bsimplemente trunca un archivo llamado ba cero bytes cada vez.

Perl 5, 27 32 22 bytes

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

Si basta con cambiar la marca de tiempo de modificación de un archivo ...

Explicación rápida:

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

Solución anterior (32 bytes): {{open my$h,'>o';print$h 1}redo}

Editar: {open F,'O';print F 1;redo} ← No probé el código antes de publicarlo; ahora tenía que corregirlo.

PHP, 60 30 17 16 15 bytes

Actualizado una vez más según @manatwork sugirió:

while(!`cd>1`);

También ahora probado.

Un poco de trampa 22 bytes:

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

Sugerencia anterior de @manatwork 30 bytes:

while (file_put_contents (1,1));

NO PROBADO (no hay php disponible en esta computadora) 43 bytes:

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

Un original de golf de 45 bytes:

$ a = fopen (1, 'w'); mientras que (fputs ($ a, 1)) rebobina ($ a);

Mi primera publicación aquí, me uní porque solo tenía que probar esto: mientras la escritura del archivo tenga éxito, rebobina el puntero del archivo para comenzar.

Simplemente no puede ser más pequeño que el file_put_contents ().

sh, 11 bytes

w>w;exec $0

Guarde esto en un archivo sin caracteres especiales, como loop.sh, hágalo ejecutable y ejecútelo con ./loop.sho similar.

Esto escribe la salida del comando wen el archivo w, sobrescribiendo el valor anterior cada vez. Luego, se reemplaza con una nueva versión del mismo programa, por lo que puede ejecutarse infinitamente.

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

Nuevamente, sudo watch -n1 lsof -p `pidof inf`parece decir que esto es válido.

^{¿CÓMO NO HE VISTO ESE ESPACIO D: <}

Gracias @Jens por recortar 13 bytes: D

Bash, 26 bytes

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

Si tuviera que expandir esta línea, obtendría esto:

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

Esto no puede competir exactamente con la línea PowerShell de 10 bytes, pero se mantendrá firme frente a los demás. Vea mi otra respuesta para la versión de 6 bytes.

TI-BASIC, 12 bytes

While 1
Archive A
UnArchive A
End

Solución alternativa por usuario de lirtosiast con el mismo tamaño:

While 1
SetUpEditor
Archive ∟1
End

Esto funcionará en las series de calculadoras TI-83 + y TI-84 +.

¡Sí, esto también funciona si A ya está archivado o no está inicializado en absoluto al inicio del programa! El programa tiene solo 12 bytes debido a la tokenización .

CPython 3.5, 33 16 bytes

while 1:open("a")

Sí, en serio. :RE

MATL , 10 bytes

`1[]T3$Z#T

Explicación

Este es un bucle infinito que escribe un número 1 en un archivo llamado inouten el directorio actual, sobrescribiendo el contenido del archivo anterior.

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

Escriba la cadena "a"en un archivo llamado "b"y repita. writeFilesobrescribe el archivo si existe.

JavaScript (Node.js), 43 41 bytes

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

Escribe nullen un archivo llamado a, luego repite.

ZSH, 14 bytes

for ((;;)) :>:

Zsh, a diferencia de Bash y otras conchas tipo Bourne, permite bucles sin la do ... donecerca , siempre que la condición esté delimitada adecuadamente.

Alternativamente, con while:

while {} {:>:}

Tenga en cuenta que :es un incorporado. No puedes suspender este bucle.

El principio es el mismo que en la respuesta de Digital Trauma : no se escribe nada en el archivo, el IO es puramente de crear y truncar el archivo.

Óxido, 84 bytes

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

File::create trunca un archivo existente, asegurando así que no nos quedemos sin espacio en disco.

El compilador utilizado (1.9 Nocturno) emite una advertencia sobre el resultado no utilizado write(...)pero, sin embargo, compila.

C, 92 bytes

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

Si bien parece que podría guardar 1 byte por

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

El problema con ese ciclo es que + no le da el pedido garantizado.

O recursivo: no debería desbordarse si el compilador implementa correctamente la recursión de cola (f está en un ámbito interno explícito)

85 bytes

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

Mathematica, 14 bytes

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

Repetidamente escribe la cadena "a"en un archivo nombrado aen el directorio actual, creándolo si no existe.

C, 40 bytes

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

Sin embargo, se quedará rápidamente sin descriptores de archivo; Esto se puede superar con:

45 , 43 bytes

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

C en amd64 Linux, 36 bytes (solo marca de tiempo), 52 49 bytes (actividad de disco real)

Codifico las open(2)banderas, por lo que esto no es portátil para otras ABI. Linux en otras plataformas probablemente usa lo mismo O_TRUNC, etc., pero otros sistemas operativos POSIX pueden no hacerlo.

+4 bytes para pasar un argumento de permiso correcto para asegurarse de que el archivo se crea con acceso de escritura del propietario, vea a continuación. (Esto sucede para trabajar con gcc 5.2)

ANSI C algo portátil, 38/51 bytes (solo marca de tiempo), 52/67 bytes (actividad real del disco)

Basado en la respuesta de @ Cat, con un consejo de @Jens.

El primer número es para implementaciones donde un valor de retorno intpuede contener FILE *fopen(), el segundo número si no podemos hacer eso. En Linux, las direcciones de montón se encuentran en los bajos 32 bits de espacio de direcciones, por lo que funciona incluso sin -m32o -mx32. (La declaración void*fopen();es más corta que #include <stdio.h>)

Marca de tiempo de E / S de metadatos solamente :

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

Escribir un byte, en realidad golpear el disco en Linux 4.2.0 + XFS + lazytime:

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

writees la condición for-loop, que está bien ya que siempre devuelve 1. closees el incremento.

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

Explicación de la versión no portátil:

El archivo se crea con permisos de basura aleatorios. Con gcc5.2, con -O0o -O3, resulta que incluye permiso de escritura del propietario, pero esto no está garantizado. 0666es decimal 438. Un tercer argumento para opentomaría otros 4 bytes . Ya estamos codificando O_TRUNC, etc., pero esto podría romperse con un compilador o libc diferente en el mismo ABI.

No podemos omitir el segundo argumento open, porque el valor de la basura incluye O_EXCL, y O_TRUNC|O_APPEND, por lo tanto, open falla EINVAL.

No necesitamos guardar el valor de retorno de open(). Asumimos que es 3, porque siempre lo será. Incluso si comenzamos con fd 3 abierto, se cerrará después de la primera iteración. En el peor de los casos, opensigue abriendo nuevos fds hasta que 3 es el último descriptor de archivo disponible. Por lo tanto, hasta las primeras 65531 write()llamadas podrían fallar EBADF, pero luego funcionarán normalmente con cada opencreación de fd = 3.

577 = 0x241 = O_WRONLY|O_CREAT|O_TRUNCen Linux x86-64. Sin O_TRUNC, el tiempo de modificación del inodo y el tiempo de cambio no se actualizan, por lo que no es posible un argumento más corto. O_TRUNCsigue siendo esencial para la versión que llama writea producir actividad de disco real, no a reescribir en su lugar.

Veo algunas respuestas que open("a",1). O_CREAT es obligatorio si aaún no existe. O_CREATse define como octal 0100 (64, 0x40) en Linux.

No hay fugas de recursos, por lo que puede ejecutarse para siempre. stracesalida:

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

o

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

Obtuve el valor decimal de las openbanderas para este ABI usando strace -eraw=openen mi versión C ++.

En un sistema de archivos con la lazytimeopción de montaje de Linux habilitada, un cambio que solo afecta a las marcas de tiempo del inodo solo causará una escritura cada 24 horas. Con esa opción de montaje desactivada, la actualización de la marca de tiempo podría ser una forma viable de desgastar su SSD. (Sin embargo, varias otras respuestas solo hacen E / S de metadatos).

alternativas:

más corto que no funciona :

main(){for(;;)close(write(open("a",577),"",3));}usa writeel valor de retorno para pasar un 3argumento para cerrar. Guarda otro byte, pero no funciona con gcc -O0 u -O3 en amd64. La basura en el 3er argumento openes diferente y no incluye permiso de escritura. ase crea la primera vez, pero todas las iteraciones futuras fallan -EACCESS.

más largo, trabajando, con diferentes llamadas al sistema :

main(c){for(open("a",65);pwrite(3,"",1);)sync();} reescribe un byte en el lugar y llama sync() para sincronizar todos los sistemas de archivos en todo el sistema. Esto mantiene la luz de la unidad encendida.

No nos importa qué byte, por lo que no pasamos el 4to argumento para escribir. Yay para archivos dispersos:

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

Supongo que escribir un byte en un desplazamiento de ~ 128TiB condujo a xfs usando 300kB de espacio para contener el mapa de extensión. No intente esto en OS X con HFS +: IIRC, HFS + no admite archivos dispersos, por lo que llenará el disco.

XFS es un sistema de archivos de 64 bits adecuado, que admite archivos individuales de hasta 8 exabytes . es decir, 2 ^ 63-1, el valor máximo off_tpuede mantenerse.

strace salida:

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

Raqueta, 46 bytes

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

Factor, 73 bytes

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

Establece el contenido del archivo en el byte nul para siempre.

CBM BASIC 7.0, 9 bytes

0dS"a":rU

Este programa, cuando se ejecuta, se guarda repetidamente en el disco. Aquí hay una versión más legible que no usa abreviaturas de palabras clave BASIC:

0 dsave "a" : run

Python, 32 bytes

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

Tenga en cuenta que si se ejecuta en Python 3, esto producirá un número infinito de advertencias. Además, probablemente se quedará sin fds si se ejecuta en una implementación sin recuento.

Dyalog APL 15.0, 17 bytes (no competidor)

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

Chrome actualmente representa U + 2262 incorrecto. La línea de arriba debería verse así (⊢⊣⊃⎕NPUT⊢)⍣̸≡'A'1.

Esto no es competitivo porque la versión 15 aún no se ha lanzado.

Se aplica ⍣la función (⊢⊣⊃⎕NPUT⊢)en 'A'1hasta que la entrada se cambia (es decir, nunca):

⊢⊣⊃⎕NPUT⊢ es un tren funcional:

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

El más a la derecha ⊢vuelve 'A'1sin modificar; Este (nombre de archivo, sobrescribir-bandera) será el argumento correcto para `⎕NPUT '.

'⊃' devuelve el primer elemento de 'A'1( 'A'); Esta es la información a escribir.

Luego ⎕NPUTse ejecuta e informa cuántos bytes se escribieron (2 o 3 dependiendo del sistema operativo); esto se convierte en el argumento correcto para el ⊣.

El extremo izquierdo ⊢vuelve nuevamente 'A'1sin modificaciones; Este es el argumento izquierdo de la ⊢.

⊣ignora su argumento derecho y devuelve el argumento izquierdo ( 'A'1), este se convierte en el nuevo valor alimentado ⍣.

Como el nuevo valor es idéntico al anterior, la operación continúa (para siempre).

SmileBASIC, 12 bytes

SAVE"A
EXEC.

editor de texto vim, 10 bytes

qa:w<enter>@aq@a

8 bytes si no puede el comando de ejecución @a