(เพียงเปิด 50 แท็บใน Google Chrome: D (แค่ล้อเล่นคุณไม่สามารถทำได้))

โค้ดสั้นที่สุดสำหรับดิสก์ I / O ที่ไม่มีขีด จำกัด ภาษาใด ๆ ตัวอย่าง 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 / Batch: 4 ไบต์

%0>x

ไฟล์ชุดนี้จะเรียกตัวเอง ( %0) และการเปลี่ยนเส้นทาง ( >) xส่งออกไปยังไฟล์ที่เรียกว่า เนื่องจาก echo เปิดอยู่โดยค่าเริ่มต้นสิ่งนี้จะส่งออกพา ธ และคำสั่ง

PowerShell v2 +, 10 ไบต์

for(){1>1}

เพียงวนforซ้ำอย่างไม่มีที่สิ้นสุดด้วยการวนซ้ำที่ว่างเปล่า การวนซ้ำแต่ละครั้งเราส่งออกจำนวนเต็ม1(แปลงเป็นสตริงโดยนัย) ด้วยตัว> ดำเนินการเปลี่ยนเส้นทางซึ่งจะเขียนทับไฟล์ที่มีชื่อ1ในไดเรกทอรีท้องถิ่น

Pyth, 6 ไบต์

#.w]]0

คำสั่งแฟ้มผลลัพธ์เพียง Pyth .wคือ เมื่อเรียกบนสตริงมันจะเขียนสตริงนั้นไปยังไฟล์ในโหมดผนวกซึ่งไม่ดีสำหรับวัตถุประสงค์ของคำถามนี้ เมื่อเรียกใช้บนอาเรย์ 2 มิติมันจะเขียนอิมเมจที่สอดคล้องกับไฟล์นั้นโดยเขียนทับเนื้อหาของไฟล์ นั่นคือสิ่งที่โปรแกรมนี้ทำ ชื่อไฟล์ที่เป็นค่าเริ่มต้นคือo.pngโปรแกรมนี้เขียนทับไฟล์o.pngด้วยอิมเมจสีขาวขนาด 1 พิกเซล #เป็นวงไม่สิ้นสุด

หากคุณต้องการคำตอบที่สั้นกว่า (แต่น่าเบื่อกว่าคำตอบอื่น ๆ ของฉัน):

Bash, 5 ไบต์

>w;$0

ฉันสามารถทำให้สั้นลงถ้ามีคำสั่ง (น้อยกว่า 3 ไบต์ยาว) ที่เขียนอะไรบางอย่างไปยังดิสก์ I / O สิ่งที่ต้องการsyncจะใช้งานได้ แต่syncคือ 4 ไบต์ by

หมายเหตุ: สิ่งนี้จะไม่ทำงานเมื่อเรียกใช้จาก bash เท่านั้นเมื่อใส่สคริปต์และเรียกใช้เป็นชื่อสคริปต์ (เช่นecho 'w>w;$0' > bomb; chmod 755 bomb; ./bomb)

Ruby, 22 20 ไบต์

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

ตัดทอนและเขียน1ไฟล์aซ้ำ ๆ

ขอบคุณVentero 2 ไบต์!

cmd, 14 ไบต์

:a
cd>1
goto a

เขียนทับไฟล์อย่างไม่สิ้นสุด1ด้วยสตริงไปยังไดเรกทอรีปัจจุบัน

ฉันใหม่ที่นี่: windows new lines ( 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 ไบต์:

ในขณะที่ (exec ('> 1 dir'));

คำแนะนำก่อนหน้านี้โดย @manatwork 30 ไบต์:

ในขณะที่ (file_put_contents (1,1));

ไม่ผ่านการทดสอบ (ไม่มี php ในคอมพิวเตอร์เครื่องนี้) 43 ไบต์:

สำหรับ ($ A = fopen (1, 'w'); fputs ($ ที่ 1); fclose ($ a))

ขนาด 45 ไบต์ดั้งเดิมของกอล์ฟ:

$ a = fopen (1, 'w'); ในขณะที่ (fputs ($ ที่ 1)) ย้อนกลับ ($ a);

โพสต์แรกของฉันที่นี่เข้าร่วมเพราะฉันต้องลองทำสิ่งนี้: ตราบใดที่การเขียนไฟล์สำเร็จให้ย้อนตัวชี้ไฟล์เพื่อเริ่มต้น

ไม่สามารถมีขนาดเล็กกว่า file_put_contents ()

sh, 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

Bash, 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

สิ่งนี้ไม่สามารถแข่งขันกับสาย PowerShell ขนาด 10 ไบต์ได้อย่างแน่นอน แต่จะยึดติดกับตัวอื่น ๆ ดูคำตอบอื่น ๆ ของฉันสำหรับรุ่น 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 และกระสุนที่คล้ายบอร์นอื่น ๆ ทำให้สามารถวนdo ... doneซ้ำได้โดยไม่มีรั้วหากเงื่อนไขมีการคั่นอย่างเหมาะสม

อีกทางเลือกด้วยwhile:

while {} {:>:}

โปรดสังเกตว่า:เป็น builtin คุณไม่สามารถระงับการวนซ้ำนี้ได้

หลักการเหมือนกับคำตอบของ Digital Trauma - ไม่มีอะไรถูกเขียนลงไฟล์ IO นั้นหมดจดจากการสร้างและตัดทอนไฟล์

สนิม 84 ไบต์

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

File::create ตัดทอนไฟล์ที่มีอยู่แล้วเพื่อให้แน่ใจว่าเราไม่ได้ใช้พื้นที่ดิสก์หมด

คอมไพเลอร์ที่ใช้ (1.9 ทุกคืน) ออกคำเตือนเกี่ยวกับผลลัพธ์ที่ไม่ได้ใช้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);}

มันจะหมดไฟล์ descriptors อย่างรวดเร็วแม้ว่า; สิ่งนี้สามารถเอาชนะได้ด้วย:

45 , 43 ไบต์

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

C บน amd64 Linux, 36 ไบต์ (เวลาประทับเท่านั้น), 52 49 ไบต์ (กิจกรรมบนดิสก์จริง)

ฉันเขียนโค้ดตั้งopen(2)ค่าสถานะอย่างหนักดังนั้นจึงไม่สามารถพกพาไปยัง ABIs อื่น ๆ ได้ Linux บนแพลตฟอร์มอื่น ๆ อาจใช้แบบเดียวกันO_TRUNCเป็นต้น แต่ POSIX OS อื่นอาจไม่รองรับ

+4 ไบต์เพื่อส่งผ่านสิทธิ์ที่ถูกต้องเพื่อให้แน่ใจว่าไฟล์ถูกสร้างขึ้นพร้อมสิทธิ์การเขียนของเจ้าของดูด้านล่าง (สิ่งนี้เกิดขึ้นกับ gcc 5.2)

ค่อนข้างพกพา ANSI C, 38/51 ไบต์ (เวลาประทับเท่านั้น), 52/67 ไบต์ (กิจกรรมบนดิสก์จริง)

ตามคำตอบของ @ Cat พร้อมด้วยคำแนะนำจาก @Jens

หมายเลขแรกสำหรับการใช้งานที่intสามารถเก็บFILE *fopen()ค่าส่งคืนของจำนวนที่สองถ้าเราไม่สามารถทำเช่นนั้น บน Linux, ที่อยู่กองเกิดขึ้นจะอยู่ในระดับต่ำ 32 บิตของพื้นที่ที่อยู่จึงทำงานได้โดยไม่ต้องหรือ-m32 -mx32(การประกาศvoid*fopen();สั้นกว่า#include <stdio.h>)

ข้อมูลเมตาของ Timestamp I / O เท่านั้น :

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-loop ซึ่งใช้ได้เนื่องจากมันส่งคืน 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 openจะใช้เวลาอีก 4 ไบต์ เรากำลังเข้ารหัส O_TRUNC อย่างหนักอยู่แล้ว แต่สิ่งนี้อาจแตกต่างกับคอมไพเลอร์หรือ libc อื่นใน ABI เดียวกัน

เราไม่สามารถละเว้นหาเรื่องที่ 2 openเพราะค่าขยะที่เกิดขึ้นที่จะรวมO_EXCLและเปิดจึงล้มเหลวด้วยO_TRUNC|O_APPENDEINVAL

open()เราไม่จำเป็นต้องบันทึกค่าตอบแทนจาก เราถือว่ามันเป็น3เพราะมันจะเป็น แม้ว่าเราเริ่มต้นด้วยการเปิด fd 3 มันจะถูกปิดหลังจากการทำซ้ำครั้งแรก กรณีที่เลวร้ายที่สุดopenยังคงเปิด fds ใหม่จนกระทั่ง 3 เป็นตัวบ่งชี้ไฟล์ล่าสุดที่มีอยู่ ดังนั้นการwrite()โทรถึง65531 ครั้งแรกอาจล้มเหลวด้วยEBADFแต่จะทำงานได้ตามปกติกับopenการสร้างทุกfd = 3

577 = 0x241 = O_WRONLY|O_CREAT|O_TRUNCบน x86-64 Linux หากไม่มีO_TRUNCinode mod time และเวลาเปลี่ยนแปลงจะไม่ได้รับการอัพเดตดังนั้นจึงไม่สามารถหาเรื่องที่สั้นลงได้ 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 จะทำให้การเขียนหนึ่งครั้งต่อ 24 ชั่วโมงเท่านั้น เมื่อปิดใช้งานตัวเลือกการเมาท์การอัปเดตเวลาอาจเป็นวิธีที่ทำให้ SSD ของคุณทำงานได้ (อย่างไรก็ตามคำตอบอื่น ๆ อีกหลายคำตอบทำเพียงเมตาดาต้า I / O)

ทางเลือก:

สั้นไม่ทำงาน :

main(){for(;;)close(write(open("a",577),"",3));}ใช้writeค่าส่งคืนเพื่อส่งผ่าน3อาร์กิวเมนต์ให้ปิด มันจะช่วยประหยัดไบต์อื่น แต่ไม่ทำงานกับ gcc -O0 หรือ -O3 ใน amd64 ขยะใน ARG ลำดับที่ 3 openนั้นแตกต่างกันและไม่มีสิทธิ์ในการเขียน aได้รับการสร้างขึ้นเป็นครั้งแรก -EACCESSแต่การทำซ้ำในอนาคตทั้งหมดล้มเหลวด้วย

อีกต่อไปทำงานด้วยการเรียกระบบที่แตกต่างกัน :

main(c){for(open("a",65);pwrite(3,"",1);)sync();} เขียนไบต์แบบแทนที่และการโทรsync()เพื่อซิงค์ระบบไฟล์ทั้งหมดทั่วทั้งระบบ นี่จะทำให้ไฟของไดรฟ์สว่างขึ้น

เราไม่สนใจว่าจะใช้ไบท์ไหนดังนั้นเราจึงไม่ผ่าน ARG ลำดับที่ 4 ไปยัง pwrite Yay สำหรับไฟล์ที่กระจัดกระจาย:

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

การเขียนหนึ่งไบต์ที่ออฟเซ็ตของ ~ 128TiB นำไปสู่ ​​xfs โดยใช้พื้นที่ 300kiB เพื่อเก็บแผนที่ขอบเขตฉันเดา อย่าลองทำสิ่งนี้ใน OS X ด้วย HFS +: IIRC, HFS + ไม่รองรับไฟล์ที่กระจัดกระจายดังนั้นมันจะเติมดิสก์

XFS เป็นระบบแฟ้ม 64bit เหมาะสมสนับสนุนแต่ละไฟล์ได้ถึง 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

ตั้งค่าเนื้อหาไฟล์เป็น nul ไบต์ตลอดไป

CBM BASIC 7.0, 9 ไบต์

0dS"a":rU

โปรแกรมนี้เมื่อเรียกใช้จะบันทึกตัวเองลงดิสก์ซ้ำหลายครั้ง นี่เป็นรุ่นที่อ่านได้มากกว่าซึ่งไม่ใช้ตัวย่อคำหลักพื้นฐาน:

0 dsave "a" : run

Python ขนาด 32 ไบต์

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

โปรดทราบว่าหากทำงานบน python 3 สิ่งนี้จะสร้างคำเตือนจำนวนไม่สิ้นสุด นอกจากนี้มันอาจจะหมด fds หากทำงานในการใช้งานที่ไม่ใช่ refcounting

Dyalog APL 15.0, 17 ไบต์ (ไม่แข่งขัน)

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

ปัจจุบัน Chrome แสดงผล U + 2262 ไม่ถูกต้อง บรรทัดข้างต้นควรมีลักษณะ(⊢⊣⊃⎕NPUT⊢)⍣̸≡'A'1ดังนี้

นี่ไม่ใช่การแข่งขันเพราะเวอร์ชัน 15 ยังไม่วางจำหน่าย

ใช้⍣ฟังก์ชั่น(⊢⊣⊃⎕NPUT⊢)เปิด'A'1จนกระทั่งอินพุตถูกเปลี่ยน (เช่นไม่มี):

⊢⊣⊃⎕NPUT⊢ เป็นรถไฟฟังก์ชั่น:

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

ขวาสุด⊢ผลตอบแทนที่'A'1ยังไม่แปร; สิ่งนี้ (ชื่อไฟล์, การเขียนทับแฟล็ก) จะเป็นอาร์กิวเมนต์ที่ถูกต้องสำหรับ `⎕NPUT '

'⊃' ส่งคืนองค์ประกอบแรกของ'A'1( 'A'); นี่คือข้อมูลที่จะเขียน

จากนั้น⎕NPUTจะรันและรายงานจำนวนไบต์ที่ถูกเขียน (2 หรือ 3 ขึ้นอยู่กับระบบปฏิบัติการ); ⊣นี้จะกลายเป็นข้อโต้แย้งสิทธิที่จะ

ซ้ายสุด⊢จะส่งกลับ'A'1ไม่ได้แก้ไข ⊢นี้เป็นข้อโต้แย้งซ้ายไป

⊣ละเว้นการโต้แย้งสิทธิของและส่งกลับอาร์กิวเมนต์ซ้าย ( 'A'1) ⍣นี้จะกลายเป็นค่าใหม่เลี้ยง

เนื่องจากค่าใหม่นั้นเหมือนกันกับค่าเก่าการดำเนินการจึงดำเนินการต่อ (ตลอดไป)

SmileBASIC ขนาด 12 ไบต์

SAVE"A
EXEC.

แก้ไขข้อความเป็นกลุ่ม 10 ไบต์

qa:w<enter>@aq@a

8 ไบต์หากคุณไม่สามารถใช้คำสั่งการดำเนินการ @a