(Basta abrir 50 guias no Google Chrome: D (brincadeira, não, você não pode))

Código mais curto para E / S de disco infinita em qualquer idioma, exemplo em C #:

using System.IO;

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

Você não pode simplesmente encher o disco inteiro, pois ele acabaria no final e seria finito.

E você não pode ler apenas, a escrita infinita precisa acontecer. (Ele precisa matar meu SSD após tempo de execução suficiente.)

Get cracking! :)

DOS / lote: 4 bytes

%0>x

Esse arquivo em lote se chamará ( %0) e redirecionará ( >) a saída para um arquivo chamado x. Como o eco está ativado por padrão, isso produzirá o caminho e o comando.

PowerShell v2 +, 10 bytes

for(){1>1}

Basta fazer um loop infinito com um forloop vazio . A cada iteração, produzimos o número inteiro 1(convertido implicitamente em uma string) com o > operador redirecionar , que substitui o arquivo nomeado 1no diretório local.

Pitão, 6 bytes

#.w]]0

O único comando de saída de arquivos de Pyth é .w. Quando chamada em uma string, ela grava essa string em um arquivo no modo de acréscimo, o que não é bom para o propósito desta pergunta. Quando chamado em uma matriz 2-d, ele grava a imagem correspondente nesse arquivo, substituindo o conteúdo do arquivo. É isso que este programa faz. O nome padrão da saída do arquivo é o.png, portanto, este programa substitui infinitamente o arquivo o.pngcom uma imagem branca de 1 pixel. #é um loop infinito.

Se você quer uma resposta mais curta (mas mais chata do que a minha outra):

Bash, 5 bytes

>w;$0

Eu poderia tornar isso mais curto se houver um comando (com menos de 3 bytes) que grave algo na E / S do disco. Algo como syncfuncionaria, mas synctem 4 bytes 😛

Nota: isso não funciona quando executado diretamente do bash, apenas quando colocado em um script e executado como o nome do script. (ie echo 'w>w;$0' > bomb; chmod 755 bomb; ./bomb)

Ruby, 22 20 bytes

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

Trunca e grava repetidamente um 1no arquivo a.

Obrigado ao Ventero por 2 bytes!

cmd, 14 bytes

:a
cd>1
goto a

Substitui infinitamente o arquivo 1com a sequência no diretório atual

Eu sou novo aqui: as novas linhas do Windows ( CR LF) são contadas como dois bytes?

Bash + coreutils, 10

yes \>b|sh

Grava um fluxo contínuo de >b, o qual é canalizado shpara avaliação. >bsimplesmente trunca um arquivo chamado bpara zero bytes a cada vez.

Perl 5, 27 32 22 bytes

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

Se simplesmente alterar o registro de data e hora da modificação de um arquivo for suficiente ...

Explicação 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.
}

Solução anterior (32 bytes): {{open my$h,'>o';print$h 1}redo}

Edit: {open F,'O';print F 1;redo} ← Não testou o código antes de postar; agora eu tinha que corrigi-lo.

PHP, 60 30 17 16 15 bytes

Atualizado mais uma vez de acordo com o @manatwork sugerido:

while(!`cd>1`);

Também agora testado.

Um pouco de trapaça 22 bytes:

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

Sugestão anterior de @manatwork 30 bytes:

while (file_put_contents (1,1));

NÃO TESTADO (nenhum php disponível neste computador) 43 bytes:

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

Um original com 45 bytes de golfe:

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

Meu primeiro post aqui entrou porque eu só tinha que tentar isso: contanto que a gravação do arquivo seja bem-sucedida, rebobine o ponteiro do arquivo para iniciar.

Só não pode ficar menor que o file_put_contents ().

sh, 11 bytes

w>w;exec $0

Salve isso em um arquivo sem caracteres especiais, como loop.sh, torne-o executável e execute-o com ./loop.shou similar.

Isso grava a saída do comando wno arquivo w, substituindo o valor anterior a cada vez. Em seguida, ele se substitui por uma nova versão do mesmo programa, para que possa ser executado 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));}   

Mais uma vez, sudo watch -n1 lsof -p `pidof inf`parece dizer que isso é válido.

^{COMO EU NÃO VI ESSE ESPAÇO D: <}

Obrigado @ Jens por cortar 13 bytes: D

Bash, 26 bytes

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

Se eu expandisse essa linha única, obteria o seguinte:

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

Isso não pode competir exatamente com a linha PowerShell de 10 bytes, mas se manterá contra os outros. Veja minha outra resposta para a versão de 6 bytes.

TI-BASIC, 12 bytes

While 1
Archive A
UnArchive A
End

Solução alternativa pelo usuário lirtosiast com o mesmo tamanho:

While 1
SetUpEditor
Archive ∟1
End

Isso funcionará nas calculadoras TI-83 + e TI-84 +.

Sim, isso também funciona se A já estiver arquivado ou não for inicializado no início do programa! O programa tem apenas 12 bytes devido à tokenização .

CPython 3.5, 33 16 bytes

while 1:open("a")

Sim com certeza. : D

MATL , 10 bytes

`1[]T3$Z#T

Explicação

Este é um loop infinito que grava número 1 em um arquivo chamado inoutno diretório atual, substituindo o conteúdo do arquivo 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

Escreva a string "a"em um arquivo nomeado "b"e repita. writeFilesobrescreve o arquivo, se existir.

JavaScript (Node.js), 43 41 bytes

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

Grava nullem um arquivo chamado ae repita.

ZSH, 14 bytes

for ((;;)) :>:

O Zsh, diferentemente do Bash e de outras conchas do tipo Bourne, permite loops sem a do ... donecerca , desde que a condição seja adequadamente delimitada.

Alternativamente, com while:

while {} {:>:}

Observe que :é um builtin. Você não pode suspender esse loop.

O princípio é o mesmo da resposta do Digital Trauma - nada é gravado no arquivo, o IO é apenas para criar e truncar o arquivo.

Ferrugem, 84 bytes

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

File::create trunca um arquivo existente, garantindo assim que o espaço em disco não fique vazio.

O compilador usado (1.9 Nightly) emite um aviso sobre o resultado não utilizado, write(...)mas compila mesmo assim.

C, 92 bytes

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

Embora pareça que você poderia economizar 1 byte

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

o problema com esse loop é que + não fornece a ordem garantida.

Ou recursivo - não deve estourar se o compilador implementar corretamente a recursão de cauda (f está em um escopo 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]

Grava repetidamente a string "a"em um arquivo nomeado ano diretório atual, criando-o se não existir.

C, 40 bytes

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

Porém, ele rapidamente ficará sem descritores de arquivo; isso pode ser superado com:

45 , 43 bytes

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

C no amd64 Linux, 36 bytes (somente timestamp), 52 49 bytes (atividade em disco real)

Eu open(2)codifico os sinalizadores, portanto, isso não é portátil para outras ABIs. O Linux em outras plataformas provavelmente usa o mesmo O_TRUNC, etc., mas outros sistemas operacionais POSIX podem não.

+4 bytes para passar um argumento de permissão correto para garantir que o arquivo seja criado com acesso de gravação do proprietário, veja abaixo. (Isso funciona com o gcc 5.2)

ANSI C um tanto portátil, 38/51 bytes (somente carimbo de data / hora), 52/67 bytes (atividade em disco real)

Com base na resposta de @ Cat, com uma dica de @Jens.

O primeiro número é para implementações em que um intpode reter FILE *fopen()o valor de retorno, o segundo número, se não pudermos fazer isso. No Linux, os endereços de heap estão com pouco espaço de endereço de 32 bits; portanto, ele funciona mesmo sem -m32ou -mx32. (A declaração void*fopen();é menor que #include <stdio.h>)

Somente E / S de metadados de carimbo de data e hora :

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

Escrevendo um byte, atingindo o disco no Linux 4.2.0 + XFS + lazytime:

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

writeé a condição do loop for, o que é bom, pois sempre retorna 1. closeé o 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

Explicação da versão não portátil:

O arquivo é criado com permissões aleatórias de lixo. Com o gcc5.2, com -O0ou -O3, inclui permissão de gravação do proprietário, mas isso não é garantido. 0666é decimal 438. Um terceiro argumento openlevaria outros 4 bytes . Nós já estamos codificando O_TRUNC e assim por diante, mas isso pode ocorrer com um compilador ou libc diferente na mesma ABI.

Não podemos omitir o segundo argumento para open, porque o valor do lixo inclui O_EXCL, e O_TRUNC|O_APPEND, portanto, a abertura falha com EINVAL.

Não precisamos salvar o valor de retorno open(). Nós assumimos que é 3, porque sempre será. Mesmo se começarmos com o fd 3 aberto, ele será fechado após a primeira iteração. Na pior das hipóteses, opencontinua abrindo novos fds até que 3 seja o último descritor de arquivo disponível. Portanto, até as primeiras 65531 write()chamadas podem falhar EBADF, mas funcionarão normalmente com toda a opencriação de fd = 3.

577 = 0x241 = O_WRONLY|O_CREAT|O_TRUNCno x86-64 Linux. Sem O_TRUNC, o tempo de modificação do inode e o tempo de alteração não são atualizados, portanto, um argumento mais curto não é possível. O_TRUNCainda é essencial para a versão que chama writepara produzir a atividade real do disco, não para reescrever no local.

Eu vejo algumas respostas isso open("a",1). O_CREAT é necessário se aainda não existir. O_CREATé definido como octal 0100 (64, 0x40) no Linux.

Nenhum vazamento de recursos, portanto, ele pode ser executado para sempre. straceresultado:

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

Eu tenho o valor decimal dos opensinalizadores para este ABI usando strace -eraw=openna minha versão C ++.

Em um sistema de arquivos com a lazytimeopção de montagem Linux ativada, uma alteração que afeta apenas os carimbos de data / hora do inode causará apenas uma gravação a cada 24 horas. Com essa opção de montagem desativada, a atualização do carimbo de data / hora pode ser uma maneira viável de desgastar seu SSD. (No entanto, várias outras respostas fazem apenas E / S de metadados).

alternativas:

menos tempo de trabalho :

main(){for(;;)close(write(open("a",577),"",3));}usa writeo valor de retorno para passar um 3argumento para fechar. Ele salva outro byte, mas não funciona com o gcc -O0 ou -O3 no amd64. O lixo no terceiro argumento para opené diferente e não inclui permissão de gravação. aé criado na primeira vez, mas todas as iterações futuras falham -EACCESS.

por mais tempo, trabalhando, com diferentes chamadas do sistema :

main(c){for(open("a",65);pwrite(3,"",1);)sync();} reescreve um byte no local e chama sync()para sincronizar todos os sistemas de arquivos em todo o sistema. Isso mantém a luz da unidade acesa.

Nós não nos importamos com qual byte, então não passamos o quarto argumento para escrever. Yay para arquivos esparsos:

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

Escrever um byte em um deslocamento de ~ 128TiB levou ao xfs usando 300kiB de espaço para armazenar o mapa de extensão, eu acho. Não tente fazer isso no OS X com o HFS +: IIRC, o HFS + não suporta arquivos esparsos; portanto, ele preencherá o disco.

O XFS é um sistema de arquivos adequado de 64 bits, suportando arquivos individuais de até 8 exabytes . ou seja, 2 ^ 63-1, o valor máximo off_tpode ser mantido.

strace resultado:

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

Raquete, 46 bytes

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

Fator, 73 bytes

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

Define o conteúdo do arquivo para o byte nul para sempre.

CBM BASIC 7.0, 9 bytes

0dS"a":rU

Este programa, quando executado, se salva repetidamente em disco. Aqui está uma versão mais legível que não usa abreviações de palavras-chave BASIC:

0 dsave "a" : run

Python, 32 bytes

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

Observe que, se executado no python 3, isso produzirá um número infinito de avisos. Além disso, provavelmente ficará sem fds se for executado em uma implementação sem refcounting.

Dyalog APL 15.0, 17 bytes (não concorrente)

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

Atualmente, o Chrome processa U + 2262 errado. A linha acima deve parecer (⊢⊣⊃⎕NPUT⊢)⍣̸≡'A'1.

Isso não é concorrente porque a versão 15 ainda não foi lançada.

Aplica-se ⍣a função (⊢⊣⊃⎕NPUT⊢)em 'A'1até que a entrada é alterado (ou seja, nunca):

⊢⊣⊃⎕NPUT⊢ é um trem de função:

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

O mais à direita ⊢ retorna sem 'A'1modificação; este (nome do arquivo, sinalizador de substituição) será o argumento correto para `PNPUT '.

'⊃' retorna o primeiro elemento de 'A'1('A' ); esses são os dados a serem gravados.

Em seguida, ⎕NPUTé executado e relata quantos bytes foram gravados (2 ou 3, dependendo do SO); este se torna o argumento certo para o⊣ .

O mais à esquerda ⊢novamente retorna sem 'A'1modificação; este é o argumento da esquerda para o⊢ .

⊣ignora seu argumento da direita e retorna o argumento da esquerda ( 'A'1), esse se torna o novo valor alimentado para⍣ .

Como o novo valor é idêntico ao antigo, a operação é continuada (para sempre).

SmileBASIC, 12 bytes

SAVE"A
EXEC.

editor de texto vim, 10 bytes

qa:w<enter>@aq@a

8 bytes se você não puder executar o comando de execução @a