Viết chương trình chạy mãi mãi và phân bổ càng nhiều bộ nhớ trên heap càng lâu, ít nhất là cho đến khi bạn đạt đến giới hạn của hệ điều hành về số lượng bộ nhớ có thể được phân bổ.

Nhiều hạt nhân sẽ không thực sự dự trữ bộ nhớ mà bạn phân bổ cho đến khi bạn sử dụng nó cho một thứ gì đó, vì vậy nếu chương trình của bạn bằng C hoặc một số ngôn ngữ cấp thấp khác, bạn sẽ phải đảm bảo rằng bạn viết một cái gì đó cho mỗi trang. Nếu bạn đang sử dụng ngôn ngữ được dịch, có lẽ bạn sẽ không phải lo lắng về điều này.

Mã ngắn nhất sẽ thắng.

Funge-98 ( cfunge), 1 byte

9

Tôi đã đăng nó sớm hơn, nhưng đã quyết định thử nghiệm nó, và phải mất một thời gian để máy tính của tôi trở lại trạng thái có thể sử dụng được. cfungelưu trữ ngăn xếp Funge trên đống hệ điều hành (có thể kiểm chứng dễ dàng bằng cách chạy chương trình với giới hạn bộ nhớ nhỏ, điều mà tôi nên làm trước đó!), vì vậy, một ngăn xếp tăng trưởng vô hạn (như với chương trình này, chỉ cần đẩy 9liên tục; Các chương trình Funge bao bọc từ cuối dòng trở lại bắt đầu theo mặc định) sẽ phân bổ bộ nhớ mãi mãi. Chương trình này có khả năng cũng hoạt động trong một số triển khai Befunge-93.

Thú vị hơn:

"NULL #(4

Đây là ý tưởng đầu tiên của tôi và là một sự phân bổ vô hạn không dựa vào ngăn xếp Funge (mặc dù nó cũng làm nổ tung ngăn xếp Funge). Để bắt đầu, "lệnh sẽ đẩy một bản sao của phần còn lại của chương trình vào ngăn xếp (đó là một chuỗi và chương trình kết thúc tròn, do đó, trích dẫn đóng cũng đóng vai trò là trích dẫn mở). Sau đó, Nphản ánh (nó không có ý nghĩa theo mặc định), làm cho chương trình chạy ngược lại. Lần "nữa chạy lại và đẩy chương trình lên ngăn xếp - ngược lại lần này, với phần Ntrên cùng của ngăn xếp - sau đó chương trình kết thúc, tải một thư viện với tên 4 chữ cái ( 4(; NULLthư viện là một phần của cfungethư viện chuẩn). NULLđịnh nghĩa tất cả các chữ cái viết hoa để phản ánh, vì vậy Lphản ánh,#bỏ qua tải thư viện trên đường trở về, 4đẩy rác chúng ta không quan tâm đến ngăn xếp và toàn bộ chương trình lặp lại từ đầu. Cho rằng việc tải thư viện nhiều lần có hiệu lực và yêu cầu danh sách lệnh của thư viện được lưu trữ một lần cho mỗi bản sao của thư viện (điều này được ngụ ý bởi ngữ nghĩa của Funge-98), nó rò rỉ bộ nhớ thông qua lưu trữ không ngăn xếp (là một phương pháp thay thế để xác định "heap", liên quan đến ngôn ngữ hơn là hệ điều hành).

Brainfuck, 5 byte

+[>+]

Điều này đòi hỏi một thông dịch viên không có giới hạn về độ dài của băng.

Bash + coreutils, 5

hoặc là

Hồng ngọc, 5

`yes`

yestạo ra sản lượng vô tận. Đưa yesvào backticks cho shell để nắm bắt tất cả đầu ra và sau đó thực hiện đầu ra đó dưới dạng một lệnh. Bash sẽ tiếp tục phân bổ bộ nhớ cho chuỗi không có hồi kết này cho đến khi hết heap. Tất nhiên kết quả đầu ra sẽ là một lệnh không hợp lệ, nhưng chúng ta nên hết bộ nhớ trước khi điều đó xảy ra.

Cảm ơn @GB vì đã chỉ ra đây là một polyglot trong ruby.

Python, 16 byte

Giữ lồng acho đến khi đạt được một lỗi:

a=0
while 1:a=a,

Một vài lần lặp đầu tiên (như bộ dữ liệu) trông như thế này:

0
(0,)
((0,),)
(((0,),),)

Vân vân và vân vân.

> <> (Cá), 1 byte

0

Hãy thử nó ở đây!

0 thực sự có thể được thay thế cho bất kỳ số thập lục phân 1-f.

Giải trình

0trong> <> chỉ đơn giản là tạo ra một codebox 1x1 cho cá bơi vào. Nó liên tục thêm một 0ngăn xếp, bơi sang phải, vòng lặp ngược lại 0, thêm nó vào ngăn xếp một lần nữa. Điều này sẽ tiếp tục mãi mãi.

Java 101 byte

class A{public void finalize(){new A();new A();}public static void main(String[]a){for(new A();;);}}

Bắt chương trình chính trong một vòng lặp vô tận sau khi tạo và ném đi một đối tượng. Bộ sưu tập rác thực hiện công việc rò rỉ bằng cách tạo 2 đối tượng cho mỗi đối tượng bị xóa

Perl, 12 byte

{$"x=9;redo}

Trong perl, xtoán tử, với một chuỗi ở bên trái và một số ở bên phải, tạo ra một chuỗi lặp lại. Vì vậy, "abc" x 3đánh giá để "abcabcabc".

Các x=nhà điều hành đột biến đối số bên trái, thay thế nội dung của biến trên trái của nó với kết quả lặp lại nội dung của nó bao nhiêu lần tùy phía bên tay phải của nó chỉ ra.

Perl có một số lượng các biến được đặt tên kỳ lạ, một trong số đó là $", có giá trị ban đầu là một khoảng trắng.

Các redonhà điều hành nhảy đến đầu của bao vây {}.

Lần đầu tiên x=toán tử được thực hiện, nó thay đổi giá trị $"từ " ""đến " ", là 9 khoảng trắng.

Lần thứ hai x=toán tử được thực hiện, nó thay đổi giá trị $"thành " ", là 81 khoảng trắng.

Lần thứ ba, $"trở thành một chuỗi không gian dài 729 byte.

Tôi nghĩ bạn có thể thấy nơi này đang diễn ra :).

sed, 5 byte

Chơi gôn

H;G;D

Sử dụng (bất kỳ đầu vào sẽ làm)

sed 'H;G;D' <<<""

Giải thích

#Append a newline to the contents of the hold space, 
#and then append the contents of the pattern space to that of the hold space.
H

#Append a newline to the contents of the pattern space, 
#and then append the contents of the hold space to that of the pattern space. 
G

#Delete text in the pattern space up to the first newline, 
#and restart cycle with the resultant pattern space.
D

Ảnh chụp màn hình

Dùng thử trực tuyến!

Haskell, 23 19 byte

main=print$sum[0..]

In tổng của một danh sách vô hạn

C ++ (sử dụng trình biên dịch g ++), 27 23 15 byte

Cảm ơn Neop đã giúp tôi xóa 4 byte

Giải pháp này không thực sự rò rỉ bất kỳ bộ nhớ nào vì nó phân bổ mọi thứ trên ngăn xếp và do đó gây ra tràn ngăn xếp. Nó chỉ đơn giản là vô hạn đệ quy. Mỗi đệ quy làm cho một số bộ nhớ được phân bổ cho đến khi ngăn xếp tràn ra.

main(){main();}

Giải pháp thay thế

Giải pháp này thực sự rò rỉ bộ nhớ.

main(){for(;;new int);}

Sản lượng đầu ra

Đây là đầu ra Valgrind sau khi kết thúc chương trình vài giây vào thời gian chạy. Bạn có thể thấy rằng nó chắc chắn là bộ nhớ bị rò rỉ.

==2582== LEAK SUMMARY:
==2582==    definitely lost: 15,104,008 bytes in 3,776,002 blocks
==2582==    indirectly lost: 0 bytes in 0 blocks
==2582==      possibly lost: 16 bytes in 4 blocks
==2582==    still reachable: 4 bytes in 1 blocks
==2582==         suppressed: 0 bytes in 0 blocks

JAVA, 81 79 78 byte

JAVA (HotSpot) 71 70 byte

Ngắn hơn các câu trả lời Java khác tại thời điểm tôi đăng (81, sau 79 byte):

class A{public static void main(String[]a){String x="1";for(;;)x+=x.intern();}}

Theo đề xuất của @Olivier Grégoire, một byte nữa có thể được lưu:

class A{public static void main(String[]a){for(String x="1";;)x+=x.intern();}}

Đặt x+=x.intern()làm tăng vòng lặp for sẽ không giúp được gì, vì dấu chấm phẩy vẫn được yêu cầu để kết thúc câu lệnh for.

Theo đề xuất của @ETHproductions, chỉ cần sử dụng x+=xcác tác phẩm:

class A{public static void main(String[]a){String x="1";for(;;)x+=x;}}

Điều này cũng có thể được hưởng lợi từ mẹo của @Olivier Grégoire:

class A{public static void main(String[]a){for(String x="1";;)x+=x;}}

Điều đáng tiếc duy nhất của tôi về điều đó là không đảm bảo phân bổ dữ liệu trên heap , vì một JVM hiệu quả có thể dễ dàng nhận ra rằng xkhông bao giờ thoát khỏi chức năng cục bộ. Việc sử dụng intern()sẽ tránh được mối lo ngại này vì cuối cùng các chuỗi được lưu trữ cuối cùng được lưu trữ trong một trường tĩnh. Tuy nhiên, HotSpot không tạo OutOfMemoryErrormã cho mã đó, vì vậy tôi đoán nó ổn.

Cập nhật: @Olivier Gregoire cũng chỉ ra rằng x+=xmã có thể chạy vào StringIndexOutOfBoundsExceptionthay vì OOMkhi có nhiều bộ nhớ. Điều này là do Java sử dụng loại 32 bit intđể lập chỉ mục các mảng (và Chuỗi chỉ là mảng của char). Điều này không ảnh hưởng đến x+=x.intern()giải pháp vì bộ nhớ cần thiết cho chuỗi sau là bậc hai theo chiều dài của chuỗi và do đó sẽ mở rộng theo thứ tự 2 ^ 62 byte được phân bổ.

Perl 6 , 13 byte

@= eager 0..*

Giải trình:

@ = lưu trữ kết quả vào một mảng không tên

eager làm cho danh sách sau đây háo hức

0 .. * phạm vi vô hạn bắt đầu từ 0

///, 7 byte

/a/aa/a

Liên tục thay thế abằng aa, quảng cáo.

Python 3, 16 byte

i=9
while 1:i*=i

Điều này xuất phát từ thực tế là không có giới hạn về kích thước số nguyên trong Python 3; thay vào đó, số nguyên có thể chiếm nhiều bộ nhớ mà hệ thống có thể xử lý (nếu có gì đó về sự hiểu biết của tôi về điều này là sai, hãy sửa lại cho tôi).

Rust, 46 byte

fn main(){loop{std::mem::forget(Box::new(1))}}

Nhận thấy một cái gì đó thú vị về chương trình Rust này, rò rỉ phân bổ heap cho đến khi hết bộ nhớ?

Đúng vậy, không có khối không an toàn. Rust đảm bảo an toàn bộ nhớ trong mã an toàn (không đọc dữ liệu chưa được khởi tạo, đọc sau miễn phí, miễn phí gấp đôi, v.v.), nhưng rò rỉ bộ nhớ được coi là hoàn toàn an toàn. Thậm chí còn có một hàm rõ ràng để làm cho trình biên dịch quên đi việc dọn dẹp RAII khỏi các biến phạm vi, mà tôi sử dụng ở đây.

TI-83 Hex hội, 7 byte

PROGRAM:M
:AsmPrgm
:EF6A4E
:C3959D
:C9

Tạo các ứng dụng vô thời hạn cho đến khi một ERR:MEMORYhệ điều hành bị ném. Chạy với Asm(prgmM). Tôi đếm từng cặp chữ số hex là một byte.

Python, 8 byte

2**9**99

Các OP đã cho phép technicality của một chương trình mà không kỹ thuật chạy "mãi mãi", nhưng bộ nhớ giao đất hơn bất kỳ máy tính có thể có thể xử lý. Đây không phải là một googolplex (nghĩa là 10**10**10011 byte), nhưng ngây thơ, cơ sở đăng nhập 2 của số này là

>>> 9**99.
2.9512665430652752e+94

tức là, 10 ^ 94 bit để thể hiện nó. WolframAlpha đặt nó lớn hơn 10 ^ 76 so với web sâu (hãy nhớ rằng có khoảng 10 ^ 80 nguyên tử trong vũ trụ ).

Tại sao 2 thay vì 9 bạn hỏi? Nó không tạo ra nhiều sự khác biệt (sử dụng 9 sẽ chỉ tăng số bit theo hệ số log2(9) = 3.2, thậm chí không thay đổi số mũ). Nhưng mặt khác, chương trình chạy nhanh hơn nhiều với 2, vì phép tính đơn giản hơn. Điều này có nghĩa là nó lấp đầy bộ nhớ ngay lập tức, trái ngược với phiên bản 9, mất nhiều thời gian hơn một chút do các tính toán cần thiết. Không cần thiết, nhưng tốt đẹp nếu bạn muốn "kiểm tra" điều này (điều mà tôi đã làm).

Thạch , 3 2 byte

-1 byte nhờ Dennis ( Wkết thúc tốt đẹp)

Wß

Một liên kết (tức là chức năng hoặc phương thức), cũng hoạt động như một chương trình đầy đủ, sẽ đệ quy kết hợp đầu vào của nó vào một danh sách.

Đầu vào bắt đầu bằng 0 nên đường chuyền đầu tiên tạo danh sách [0]
Đường chuyền thứ hai sau đó thực hiện [[0]]
đường chuyền thứ ba sau đó thực hiện điều này [[[0]]]
và cứ thế ...

3 byter trước đó, rò rỉ nhanh hơn nhiều:

;Ẇß

đệ quy nối tất cả các danh sách con liền kề không trống của đầu vào của nó với đầu vào của nó.
[0]-> [0,[0]]-> [0,[0],[0],[[0]],[0,[0]]]vân vân ...

Java 7, 106 byte

class A{public void finalize(){for(;;)Thread.yield();}public static void main(String[]a){for(;;)new A();}}

Ít chơi gôn

class A{
    @Override
    public void finalize(){
        for(;;) {
            Thread.yield();
        }
    }
    public static void main(String[]a){
        for(;;){
            new A();
        }
    }
}

Các finalizephương pháp được gọi là trên một đối tượng bằng cách thu gom rác khi thu gom rác thải xác định rằng không có nhiều tài liệu tham khảo cho các đối tượng. Tôi chỉ đơn giản là định nghĩa lại phương thức này để lặp lại mãi mãi để trình thu gom rác thực sự không bao giờ giải phóng bộ nhớ. Trong mainvòng lặp tôi tạo các đối tượng mới sẽ không bao giờ được dọn sạch nên cuối cùng điều này sẽ sử dụng hết bộ nhớ khả dụng.

Java 7 (thay thế thú vị), 216 byte

import sun.misc.*;class A{public static void main(String[]a)throws Exception{java.lang.reflect.Field f=Unsafe.class.getDeclaredField("theUnsafe");f.setAccessible(1>0);for(;;)((Unsafe)f.get(null)).allocateMemory(9);}}

Ít chơi gôn

import sun.misc.*;
class A{
    public static void main(String[]a)throws Exception{
        java.lang.reflect.Field f=Unsafe.class.getDeclaredField("theUnsafe");
        f.setAccessible(true);
        Unsafe u = (Unsafe)f.get(null);
        for(;;) {
            u.allocateMemory(9);
        }
    }
}

Đây là một niềm vui nhiều hơn bất cứ điều gì khác. Câu trả lời này sử dụng Unsafethư viện Sun là API nội bộ không có giấy tờ. Bạn có thể cần thay đổi cài đặt trình biên dịch để cho phép các API bị hạn chế. Unsafe.allocateMemoryphân bổ một lượng byte được chỉ định (không có bất kỳ kiểm tra ranh giới nào) không nằm trong heap và không thuộc quản lý bộ thu gom rác của java để bộ nhớ này sẽ bám xung quanh cho đến khi bạn gọi Unsafe.freeMemoryhoặc cho đến khi jvm hết bộ nhớ.

Haskell, 24 byte

f x=f$x*x
main=pure$!f 9

Vấn đề chính trong Haskell là đánh bại sự lười biếng. maincần phải có một số IOloại, vì vậy chỉ cần gọi main=f 9sẽ không hoạt động. Sử dụng main=pure(f 9)thang máy loại f 9đến một IOloại. Tuy nhiên, sử dụng các cấu trúc như main=pure 9không làm gì cả, 9nó được trả về hoặc hiển thị ở đâu mà chỉ bị loại bỏ, do đó không cần phải đánh giá đối số pure, do đó main=pure(f 9)không gây ra bất kỳ bộ nhớ nào được phân bổ như fkhông được gọi. Để thực thi đánh giá, các $!nhà điều hành tồn tại. Nó chỉ đơn giản là áp dụng một hàm cho một đối số nhưng đánh giá đối số trước. Vì vậy, sử dụng main=pure$!f 9đánh giá fvà do đó liên tục phân bổ bộ nhớ nhiều hơn.

dc, 7 byte

[ddx]dx

[ddx]đẩy một chuỗi chứa "ddx" vào ngăn xếp. dxsao chép nó sau đó thực thi nó dưới dạng mã (để lại một bản sao trên ngăn xếp). Khi được thực thi, nó tạo hai bản sao sau đó thực thi một bản sao, để lại một bản sao trên ngăn xếp mỗi lần.

Haskell (sử dụng ghc 8.0.1), 11 byte

m@main=m>>m

Đệ quy không đuôi. maingọi chính nó và sau đó chính nó một lần nữa.

C (linux), 23 byte

main(){while(sbrk(9));}

sbrk()tăng đỉnh của phân đoạn dữ liệu theo số byte đã cho, do đó tăng hiệu quả lượng bộ nhớ được phân bổ cho chương trình - ít nhất là như đã báo cáo trong VIRTtrường topđầu ra. Điều này chỉ hoạt động trên Linux - việc triển khai macOS rõ ràng là một mô phỏng chỉ cho phép phân bổ tối đa 4 MB.

Vì vậy, một câu trả lời chung chung hơn một chút:

C, 25 byte

main(){while(malloc(9));}

Tôi đã xem nó trên macOS Activity Monitor. Nó đã đi hết khoảng 48GB, rồi cuối cùng quá trình nhận được tín hiệu SIGKILL. FWIW macbook pro của tôi có 16GB. Hầu hết các bộ nhớ được sử dụng đã được báo cáo là nén.

Lưu ý rằng câu hỏi có hiệu quả đòi hỏi mỗi phân bổ phải được viết, điều này không xảy ra rõ ràng ở đây. Tuy nhiên, điều quan trọng cần lưu ý là đối với mỗi malloc(9)cuộc gọi, không chỉ có 9 byte người dùng yêu cầu được phân bổ. Đối với mỗi khối được phân bổ, sẽ có một tiêu đề malloc cũng được phân bổ từ đâu đó trên heap, điều này nhất thiết phải được ghi bởi các malloc()bên trong.

Perl, 4 byte

do$0

Thực thi chính nó, trong trình thông dịch hiện tại. Khi kết thúc, thực thi trở lại tập lệnh gọi, yêu cầu ngăn xếp cuộc gọi.

Vợt, 13 byte

(let l()(l)1)

Tôi không hoàn toàn chắc chắn nếu câu trả lời của tôi rơi vào câu hỏi này. Xin vui lòng cho tôi biết nếu tôi nên loại bỏ câu trả lời này.

JavaScript 22 21 17 16 15 byte

for(a=0;;)a=[a]

Đã lưu 4 byte bằng cách gói danh sách trong một danh sách khác như trong câu trả lời Jelly của @Jonathan Allan.

Đã lưu 1 byte nhờ @ETH sản phẩm

Giải pháp thay thế 15 Byte (chỉ hoạt động với các cuộc gọi đuôi thích hợp)

f=a=>f([a]);f()

Ruby, 11 byte

loop{$*<<9}

Tiếp tục đẩy 9lên $*, đó là một mảng ban đầu giữ các đối số dòng lệnh cho quy trình Ruby.

05AB1E , 2 byte

[A

Hãy thử trực tuyến! Sẽ chỉ tiếp tục đẩy abcdefghijklmnopqrstuvwyxzlên ngăn xếp mãi mãi.

Tất cả các giải pháp 2 byte có thể:

[  # Infinite loop.
 A # Push alphabet.
 0 # Push 0.
 1 # Push 1.
 2 # Push 2.
 3 # Push 3.
 4 # Push 4.
 5 # Push 5.
 6 # Push 6.
 7 # Push 7.
 8 # Push 8.
 9 # Push 9.
 T # Push 10.
 X # Push 1.
 Y # Push 2.
 ® # Push -1.
 ¶ # Push \n.
 º # Push len(stack) > 0, so 0 once then 1 for eternity.
 ð # Push a space.
 õ # Push an empty string.
 ¾ # Push 0.
 ¯ # Push [].
 M # Push -inf.
 ) # Wrap current stack in an array.

Python, 35 byte

def f(a=[]):a.append(a)
while 1:f()

a không bao giờ được phát hành và chỉ lớn hơn cho đến khi bạn đạt được MemoryError

Bạn có thể xem thực thi trên Python Tutor .

TI-BASIC, 8

:Lbl A
:While 1
:Goto A

(tất cả các mã thông báo 1 byte và hai dòng mới)

Điều này liên tục rò rỉ bộ nhớ vì luồng điều khiển có cấu trúc như Whiledự đoán được đóng bởi một Endvà đẩy một cái gì đó trên ngăn xếp (không phải ngăn xếp hệ điều hành, một ngăn xếp riêng trong bộ nhớ heap) để theo dõi điều đó. Nhưng ở đây chúng tôi đang sử dụng Gotođể rời khỏi vòng lặp (vì vậy không có gì Endđược thực thi để loại bỏ thứ đó khỏi ngăn xếp), cái Whileđược nhìn thấy lại, thứ được đẩy lại, v.v. Vì vậy, nó chỉ tiếp tục đẩy chúng cho đến khi bạn nhận đượcERR:MEMORY