(Просто откройте 50 вкладок в Google Chrome: D (шучу, нет, вы не можете))

Кратчайший код для бесконечного дискового ввода-вывода любого языка, пример C #:

using System.IO;

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

Вы не можете просто заполнить весь диск, так как тогда он остановится в конце и будет конечным.

И вы не можете заниматься только чтением, должно произойти бесконечное написание. (Это должно убить мой SSD после достаточного времени выполнения.)

Взломать! :)

DOS / Пакет: 4 байта

%0>x

Этот пакетный файл будет вызывать себя ( %0) и перенаправлять ( >) вывод в файл с именем x. Так как эхо включено по умолчанию, это выведет путь и команду.

PowerShell v2 +, 10 байт

for(){1>1}

Просто бесконечно петли с пустой forпетлей. На каждой итерации мы выводим целое число 1(неявно преобразуемое в строку) с помощью > оператора перенаправления , который перезаписывает файл с именем 1в локальном каталоге.

Pyth, 6 байт

#.w]]0

Только команда выходного файла Pyth является .w. При вызове строки она записывает эту строку в файл в режиме добавления, что не подходит для целей этого вопроса. При вызове двумерного массива он записывает соответствующее изображение в этот файл, перезаписывая содержимое файла. Это то, что делает эта программа. По умолчанию выводится имя файла o.png, поэтому эта программа бесконечно перезаписывает файл o.png1-пиксельным белым изображением. #это бесконечный цикл.

Если вы хотите более короткий (но более скучный, чем мой) ответ:

Баш, 5 байт

>w;$0

Я мог бы сделать это короче, если есть команда (длиной менее 3 байтов), которая записывает что-то на дисковый ввод-вывод. Что-то вроде syncбы сработало, но syncстоит 4 байта 😛

Примечание: это не работает, когда запускается прямо из bash, только когда вставляется в скрипт и запускается как имя скрипта. (то есть echo 'w>w;$0' > bomb; chmod 755 bomb; ./bomb)

Рубин, 22 20 байт

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

Неоднократно усекает и записывает 1в файл a.

Спасибо Ventero за 2 байта!

cmd, 14 байтов

:a
cd>1
goto a

Бесконечно перезаписывает файл 1со строкой в ​​текущий каталог

Я новичок здесь: Windows новые строки ( CR LF) считаются как два байта?

Bash + coreutils, 10

yes \>b|sh

Записывает непрерывный поток >b, который передается shдля оценки. >bпросто обрезает файл bс нулевым байтом каждый раз.

Perl 5, 27 32 22 байта

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

Если достаточно просто изменить метку времени изменения файла ...

Быстрое объяснение:

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

Предыдущее решение (32 байта): {{open my$h,'>o';print$h 1}redo}

Изменить: {open F,'O';print F 1;redo} ← Не проверять код перед публикацией; теперь я должен был это исправить.

PHP, 60 30 17 16 15 байт

Обновлен еще раз в соответствии с предложенным @manatwork:

while(!`cd>1`);

Тоже сейчас проверено.

Немного обмана 22 байта:

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

Ранее предложение @manatwork 30 байтов:

в то время как (file_put_contents (1,1));

НЕ ИСПЫТАНО (на этом компьютере нет php) 43 байта:

для ($ а = FOPEN (1, 'W'); fputs ($ а, 1); fclose ($ а))

Оригинальные 45 байтов в гольфе:

$ А = Еореп (1, 'W'); при этом (fputs ($ а, 1)) перемотке ($ A);

Мой первый пост здесь присоединился, потому что мне просто нужно было это опробовать: пока запись в файл будет успешной, перемотайте указатель файла, чтобы начать.

Просто не может быть меньше, чем file_put_contents ().

ш, 11 байт

w>w;exec $0

Сохраните это в файл без специальных символов, таких как loop.sh, сделайте его исполняемым, и запустите его с ./loop.shили подобным.

Это записывает вывод команды wв файл w, каждый раз перезаписывая предыдущее значение. Затем он заменяет себя новой версией той же программы, поэтому он может работать бесконечно.

C 95 94 93 89 78 90 89 76 75 байтов

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

Опять же, sudo watch -n1 lsof -p `pidof inf`кажется, говорит, что это действительно.

^{КАК Я НЕ ВИДЕЛ, ЧТО ПРОСТРАНСТВО D: <}

Спасибо @Jens за то, что сбрил 13 байтов: D

Баш, 26 байт

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

Если бы я расширил эту строку, я бы получил это:

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

Это не может точно конкурировать с 10-байтовой линией PowerShell, но она будет противостоять другим. Смотрите мой другой ответ для 6-байтовой версии.

TI-BASIC, 12 байтов

While 1
Archive A
UnArchive A
End

Альтернативное решение от пользователя lirtosiast с тем же размером:

While 1
SetUpEditor
Archive ∟1
End

Это будет работать на калькуляторах серии TI-83 + и TI-84 +.

Да, это также работает, если A уже заархивирован или вообще не инициализируется при запуске программы! Программа занимает всего 12 байтов из-за токенизации .

CPython 3.5, 33 16 байт

while 1:open("a")

Да, действительно. : D

MATL , 10 байт

`1[]T3$Z#T

объяснение

Это бесконечный цикл, который записывает число 1 в файл, вызываемый inoutв текущем каталоге, перезаписывая содержимое предыдущего файла.

`       % 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 байтов

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

Запишите строку "a"в файл с именем "b"и повторите. writeFileперезаписывает файл, если он существует.

JavaScript (Node.js), 43 41 байт

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

Записывает nullв файл с именем a, затем повторите.

ZSH, 14 байтов

for ((;;)) :>:

Zsh, в отличие от Bash и других Bourne-подобных оболочек, допускает петли без do ... doneограждения , при условии, что условие соответствующим образом разграничено.

В качестве альтернативы, с while:

while {} {:>:}

Обратите внимание, что :это встроенный. Вы не можете приостановить этот цикл.

Принцип тот же, что и в ответе Digital Trauma - в файл ничего не записывается, IO - это просто создание и усечение файла.

Ржавчина, 84 байта

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

File::create обрезает существующий файл, таким образом гарантируя, что у нас не останется свободного места на диске.

Используемый компилятор (1.9 Nightly) выдает предупреждение о неиспользованном результате, write(...)но тем не менее компилируется.

C 92 байта

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

Хотя, похоже, вы можете сэкономить 1 байт

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

проблема с этим циклом в том, что + не дает вам гарантированный заказ.

Или рекурсивный - не должен переполняться, если компилятор правильно реализует хвостовую рекурсию (f находится в явной внутренней области видимости)

85 байт

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

Mathematica, 14 байтов

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

Повторно записывает строку "a"в файл с именем aв текущем каталоге, создавая ее, если она не существует.

C, 40 байтов

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

Тем не менее, он быстро исчерпает файловые дескрипторы; это можно преодолеть с помощью:

45 , 43 байта

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

C в amd64 Linux, 36 байт (только временная метка), 52 49 байт (реальная активность диска)

Я жестко open(2)кодирую флаги, так что это не переносимо на другие ABI. Linux на других платформах, вероятно, использует то же самое O_TRUNCи т. Д., Но другие операционные системы POSIX не могут.

+4 байта для передачи правильного аргумента разрешения, чтобы убедиться, что файл создан с правами записи владельца, см. Ниже. (Это работает с gcc 5.2)

несколько переносимый ANSI C, 38/51 байт (только временная метка), 52/67 байт (реальная активность диска)

Основано на ответе @ Cat с подсказкой @Jens.

Первое число для реализаций, где intможет содержать FILE *fopen()возвращаемое значение, второе число, если мы не можем этого сделать. В Linux адреса кучи находятся в младших 32 битах адресного пространства, поэтому он работает даже без -m32или -mx32. (Объявление void*fopen();короче чем #include <stdio.h>)

Только метаданные ввода-вывода метки времени :

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

Запись байта, фактически попадание на диск в Linux 4.2.0 + XFS + lazytime:

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

writeэто условие цикла for, которое хорошо, поскольку оно всегда возвращает 1. closeэто приращение.

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

Объяснение непереносимой версии:

Файл создан со случайными разрешениями мусора. С gcc5.2, с -O0или -O3, бывает, что есть разрешение владельца на запись, но это не гарантируется. 0666является десятичным 438. 3-й аргумент to openзаймет еще 4 байта . Мы уже жестко программируем O_TRUNC и так далее, но это может нарушить другой компилятор или libc на том же ABI.

Мы не можем опустить 2-й аргумент в open, потому что значение мусора включает в себя O_EXCL, и O_TRUNC|O_APPEND, так что open не удается с EINVAL.

Нам не нужно сохранять возвращаемое значение из open(). Мы предполагаем это 3, потому что так будет всегда. Даже если мы начнем с открытия fd 3, он будет закрыт после первой итерации. В худшем случае, openпродолжает открывать новые fds до тех пор, пока 3 не станет последним доступным дескриптором файла. Таким образом, до первых 65531 write()вызовов может произойти сбой EBADF, но затем он будет работать нормально при каждом openсоздании fd = 3.

577 = 0x241 = O_WRONLY|O_CREAT|O_TRUNCв x86-64 Linux. Без O_TRUNCэтого время модификации и изменения inode не обновляются, поэтому более короткое значение arg невозможно. O_TRUNCвсе еще важно для версии, которая вызываетwrite фактическую активность диска, а не перезаписывает на месте.

Я вижу некоторые ответы, которые open("a",1). O_CREAT требуется, если aеще не существует. O_CREATопределяется как восьмеричное 0100 (64, 0x40) в Linux.

Нет утечки ресурсов, поэтому он может работать вечно. straceвыход:

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

или же

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

Я получил десятичное значение openфлагов для этого ABI, используемого strace -eraw=openв моей версии C ++.

В файловой системе с lazytimeвключенной опцией монтирования Linux изменение, затрагивающее только метки времени inode, будет вызывать только одну запись в сутки. Если эта опция монтирования отключена, обновление метки времени может стать жизнеспособным способом изнашивания вашего SSD. (Тем не менее, несколько других ответов делают только ввод / вывод метаданных).

альтернативы:

короче нерабочий :

main(){for(;;)close(write(open("a",577),"",3));}использует writeвозвращаемое значение для передачи 3аргумента для закрытия. Он сохраняет другой байт, но не работает с gcc -O0 или -O3 на amd64. Мусор в 3-м аргументе openотличается и не включает разрешения на запись. aсоздается в первый раз, но все будущие итерации терпят неудачу -EACCESS.

длиннее, работает, с разными системными вызовами :

main(c){for(open("a",65);pwrite(3,"",1);)sync();} перезаписывает байт на месте и вызывает sync()синхронизацию всех файловых систем в масштабе всей системы. Это поддерживает свет на диске.

Нам не важно, какой байт, поэтому мы не передаем 4-й аргумент в pwrite. Yay для разреженных файлов:

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

Полагаю, что запись одного байта со смещением ~ 128 ТБ привела к тому, что xfs использовал пространство в 300 КБ для хранения карты экстентов. Не пытайтесь сделать это на OS X с HFS +: IIRC, HFS + не поддерживает разреженные файлы, поэтому он заполнит диск.

XFS - это правильная 64-битная файловая система, поддерживающая отдельные файлы до 8 эксабайт . т.е. 2 ^ 63-1, максимальное значение off_tможет удерживаться.

strace выход:

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

Ракетка, 46 байт

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

Фактор, 73 байта

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

Устанавливает содержимое файла в нулевой байт навсегда.

CBM BASIC 7.0, 9 байтов

0dS"a":rU

Эта программа при запуске многократно сохраняет себя на диск. Вот более читаемая версия, в которой не используются сокращения ключевых слов BASIC:

0 dsave "a" : run

Python, 32 байта

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

Обратите внимание, что при запуске на Python 3 это приведет к бесконечному количеству предупреждений. Кроме того, он, вероятно, исчерпает fds, если будет запущен в реализации без повторного подсчета.

Dyalog APL 15,0, 17 байт (не конкурирует)

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

Chrome в настоящее время делает U + 2262 неправильным. Вышеуказанная строка должна выглядеть(⊢⊣⊃⎕NPUT⊢)⍣̸≡'A'1 .

Это не конкурирует, потому что версия 15 еще не была выпущена.

Относится ⍣к функции (⊢⊣⊃⎕NPUT⊢)на 'A'1до тех пор , пока вход изменяется (т.е. никогда):

⊢⊣⊃⎕NPUT⊢ это функциональный поезд:

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

Правый ⊢возвращается 'A'1без изменений; this (имя файла, overwrite-flag) будет правильным аргументом для `PNPUT '.

«⊃» возвращает первый элемент 'A'1( 'A'); это данные для записи.

затем ⎕NPUT запускается и сообщает, сколько байтов было записано (2 или 3 в зависимости от ОС); это становится правильным аргументом⊣ .

Крайний левый ⊢снова возвращается 'A'1без изменений; это левый аргумент ⊢.

⊣игнорирует свой правый аргумент и возвращает левый аргумент ( 'A'1), это становится новым значением, переданным⍣ .

Поскольку новое значение идентично старому, операция продолжается (навсегда).

SmileBASIC, 12 байт

SAVE"A
EXEC.

текстовый редактор vim, 10 байт

qa:w<enter>@aq@a

8 байт, если вы не можете выполнить команду @a