^{Không phải là một bản dupe cho điều này . Câu hỏi đó yêu cầu cụ thể để đếm mãi mãi, trong khi câu hỏi này cho phép nhiều cách tiếp cận khác.}

Viết chương trình hoặc hàm, với thời gian và bộ nhớ vô hạn, sẽ in ra một đầu ra không định kỳ vô hạn.

Làm rõ

• 'Infinite' có nghĩa là giải pháp tiếp tục xuất ra một cái gì đó mà không cần thêm bất kỳ đầu vào hoặc hoạt động nào sau khi khởi động thành công chương trình hoặc chức năng.
• "Không định kỳ" có nghĩa là đầu ra không có khả năng lặp lại cùng một phần mãi mãi (bất kể khoảng thời gian đó là bao lâu). Một ví dụ về giải pháp hợp lệ sẽ là in các chữ số của một số vô tỷ.
• Các giải pháp ngẫu nhiên sẽ không được tính trừ khi bạn có thể chứng minh rằng nó phù hợp với yêu cầu. Các giải pháp dựa trên ngày / thời gian cũng có thể không hợp lệ nếu chúng không được lưu trữ với độ chính xác tùy ý.

Người chiến thắng

Mã ngắn nhất (tính bằng byte) thắng.

Lục giác , 2 byte

(!

Hãy thử trực tuyến!

Mã nguồn mở ra trông như:

 ( !
. . .
 . .

Điều này chỉ chạy hai lệnh này trong một vòng lặp, đó là decrement ( () và print ( !). Do đó, đầu ra là:

-1-2-3-4-5-6-7-8-9-10-11-12...

Chúng ta cần sử dụng giảm dần thay vì tăng để đảm bảo rằng chương trình lặp lại dòng đầu tiên (nếu giá trị bộ nhớ là dương, Hexagony sẽ lặp giữa dòng thứ hai và thứ ba, và kết thúc trong một vòng lặp vô hạn mà không làm gì cả).

Python 2 , 23 byte

while 1:print id;id=id,

Hãy thử trực tuyến!

Bản in

<built-in function id>
(<built-in function id>,)
((<built-in function id>,),)
(((<built-in function id>,),),)
((((<built-in function id>,),),),)

và như thế. Bắt đầu với hàm dựng sẵn id, tên biến được khởi tạo trước ngắn nhất và liên tục biến nó thành một bộ dữ liệu của chính nó.

Trong Python 3, giải pháp này dài hơn một byte vì print(), nhưng byte có thể được phục hồi từ đầu printra None:

while 1:id=print(id),id

hoặc là

while[print(id)]:id=id,

Mê cung , 3 byte

#:!

Hãy thử trực tuyến!

In tất cả các số nguyên chẵn không âm mà không có dấu phân cách:

024681012141618202224262830323436384042...

IP bị trả lại qua lại trên mã, vì vậy đây thực sự là #:!:một vòng lặp:

#  Push stack depth.
:  Duplicate.
!  Print.
:  Duplicate.

Một loạt các lựa chọn thay thế:

:#!     Prints all positive odd integers.
:)!     Prints all positive integers.
):!     Prints all positive integers.
:(!     Prints all negative integers.
(:!     Prints all negative integers.

Brachylog , 2 byte

ẉ⊥

Hãy thử trực tuyến!

Điều này in tất cả các số nguyên theo thứ tự độ lớn. Điều này sẽ không bao giờ tràn và in các số nguyên đã thấy vì Brachylog sử dụng các số nguyên không giới hạn theo mặc định.

Giải trình

ẉ      Writeln: the Input is anything, so we label it implicitely to an integer and write it
 ⊥     False: backtrack and try another integer value for the Input

> <>, 3 byte

l:n

Xuất ra một luồng số, đếm từ 0.

Tôi tin rằng số lượng tăng không chu kỳ ...

Giải trình:

l đẩy chiều dài chồng lên chồng

: nhân đôi giá trị ngăn xếp trên cùng của ngăn xếp

n giá trị đầu ra là số

Khi dòng kết thúc, nó sẽ quay trở lại từ đầu, vì vậy nó sẽ thực hiện lại, nhưng bây giờ ngăn xếp dài hơn ...

Trực tuyến

PHP, 20 byte

for(;;)echo$argc.=0;

Đầu ra này:

101001000100001000001000000100000001000000001000000000...

Nếu các đối số dòng lệnh được cung cấp, đầu ra sẽ khác, nhưng vẫn không định kỳ.

Theo như tôi hiểu tài liệu, bản thân ngôn ngữ không hạn chế độ dài của chuỗi.

JavaScript, 26 22 20 byte

for(;;)alert(Date())

(Cảnh báo: đó là xấu xa)

Haskell - 10 byte

print[1..] 

Mặc dù trong ghci bạn chỉ có thể gõ [1 ..] và điều đó sẽ tự động bắt đầu in.

Brainfuck, 13 Byte, giả sử không có mod phía trên nhưng đầu ra 256

+[[->+++.<]>]

đầu ra mã char 2 2 4 6 2 4 6 8 10 12 14 16 18 ...

xin lỗi rằng vòng lặp in mã cũ 0 2 4 6 ... 254,

Brainfuck, 13 12 byte (-1 từ Jo King)

+[[>.]<[<]+]

đầu ra mã char 0 1 0 1 1 0 1 1 1 0 ...

Thạch , 3 byte

‘Ȯß

Hãy thử trực tuyến! - cắt ngắn đầu ra và gây ra lỗi, nhưng sẽ kéo dài hơn cục bộ (cho đến khi hết bộ nhớ).

Với đầu vào ẩn bằng 0, chương trình này bao gồm một liên kết duy nhất tăng ‘, in Ȯvà sau đó gọi chính nó với giá trị mới , ß.

MATL, 4 byte

`@tD

Giải pháp này tạo ra một whilevòng lặp đẩy chỉ số của vòng lặp đến ngăn xếp, sao chép nó, in giá trị và sau đó kiểm tra xem chỉ số vòng lặp có khác không để lặp lại.

Hãy thử trực tuyến!

RProgN 2 , 13 byte

2{22.`2=2p2}:

Có nhiều twos trong đầu ra, được phân tách bằng các dòng mới sparce dần dần.

2{22.`2=2p2}:
2               # Push a two to the stack
 {         }:   # While the top of the stack is truthy
  22.           # Push the value of "2" twice, and concatenate them together.
     `2=        # Set the value of "2" to this.
        2p      # Print the value of "2"
          2     # And push the value of "2"

Mà in 2 ^ n 2s theo sau là một dòng mới cho mỗi lần lặp.

Hãy thử trực tuyến!

Befunge , 4 byte

1+:.

Hãy thử trực tuyến!

Trong Befunge, ngăn xếp không có đáy và có số không vô hạn. Mà nói:

1+ thêm một vào đầu ngăn xếp

: nhân đôi đỉnh của ngăn xếp

. in giá trị ascii của đỉnh ngăn xếp dưới dạng số

Và nó tiếp tục vô tận, bởi vì không có @việc dừng thực thi. Đây thực sự là một trong những vấn đề được giải quyết dễ dàng hơn bằng cách hoạt động của befunge ... kỳ lạ.

APL (Dyalog APL) , 8 byte

{∇⎕←0⍵}1

{emsp; một chức năng ẩn danh ...

 ∇ tái diễn

 ⎕ ← xuất ra STDOUT

 0 ⍵ danh sách hai phần tử bao gồm một số không và đối số

} áp dụng cho số một

Kết quả đầu ra này (vào dòng riêng biệt) [0,1], [0,[0,1]], [0,[0,[0,1]]]vv

Chế biến, 30 29 byte

Lưu 1 byte nhờ QwerpDerp để sử dụng millis()thay vìframeRate

void draw(){print(millis());}

Liên tục in số mili giây kể từ khi bắt đầu chương trình.

Đầu ra mẫu:

3573743914054244404574734925085205375585755916...

C (gcc) , 83 81 byte

*p,*t,*g;f(){for(t=p=malloc(1),g=--t;t<p?putchar(55):(t=g,*p++,putchar(9));t++);}

Đầu tiên phân bổ một con trỏ trên heap, sau đó hàm sẽ đếm ngược vào các địa chỉ bộ nhớ phía trước cho đến khi một segfault từ *p++ đó, do đó bị giới hạn bởi số lượng bộ nhớ trong hệ thống thay vì các loại dữ liệu được sử dụng mà cuối cùng sẽ tràn và lặp lại chuỗi. Với bộ nhớ vô hạn với khả năng đánh địa chỉ vô hạn, nó sẽ tồn tại mãi mãi.

Hãy thử trực tuyến!

7 , 2 byte

Các nhân vật tạo nên chương trình này là:

240223

Khi xem tệp trong trình chỉnh sửa, có thể sẽ cố gắng diễn giải nó thành ASCII, trong trường hợp đó nó trông như thế này:

P$

Hãy thử trực tuyến!

Chương trình có đầu vào. Tôi đã giả định ở đây rằng đầu vào là ở EOF; nếu bạn cung cấp đầu vào, có thể nó sẽ bị sập.

Giải trình

Lặp lại Zeroth

240223
240223 Nối 240223 vào phần tử ngăn xếp trên cùng

Toàn bộ chương trình ở đây là thụ động, do đó, nó sẽ nối thêm phiên bản hoạt động của chính nó vào phần tử ngăn xếp trên cùng (ban đầu trống). Chương trình nằm trong một vòng lặp ngầm định, đánh giá phần tử ngăn xếp trên cùng (trong khi để nó trên ngăn xếp) mỗi lần lặp. Vì vậy, phiên bản hoạt động sẽ chạy. (Khá nhiều tất cả 7 chương trình bắt đầu như thế này.)

Lặp lại đầu tiên

240223 
2        Sao chép phần tử ngăn xếp trên cùng
  40      Thoát phần tử ngăn xếp thứ hai, hoán đổi nó lên trên cùng
    2     Sao chép phần tử ngăn xếp trên cùng
     23   Xuất phần tử ngăn xếp trên cùng

Trước lệnh đầu ra, ngăn xếp chứa hai bản sao của 240223 (tức là thụ động). Cái trên cùng có đầu ra (không có hiệu ứng có thể quan sát được ngoài việc chọn định dạng đầu ra 2, "số"), cái bên dưới ở lại và trở thành chương trình cho lần lặp tiếp theo.

Lặp lại lần thứ hai

240223
240223 Nối 240223 vào phần tử ngăn xếp trên cùng

Giống như phép lặp zeroth, phải không? Không hẳn; ngăn xếp có nội dung khác nhau. Các ngăn xếp bây giờ là 240223dưới đây .240223240223

Lặp lại thứ ba

240223 240223 
240223         Nối 240223 vào phần tử ngăn xếp trên cùng
       2        Sao chép phần tử ngăn xếp trên cùng
       40      Thoát phần tử ngăn xếp thứ hai, hoán đổi nó lên trên cùng
          2     Sao chép phần tử ngăn xếp trên cùng
           23   Xuất phần tử ngăn xếp trên cùng

Điều này xuất ra một phần tử ngăn xếp có thêm ba giây và 0 so với 7 giây và 1. Định dạng đầu ra 2 diễn giải điều này như một yêu cầu nhập số. Chúng tôi đọc EOF, với kết quả là phần tử tiếp theo trên ngăn xếp được giảm xuống chuỗi có độ dài bằng không. Tuy nhiên, do một lỗi (có vẻ hơi hữu ích và có thể được quảng bá thành một tính năng?), Điều này chỉ xảy ra sau khi nó bắt đầu thực thi. Ngăn xếp một lần nữa có hai phần tử, 240223bên dưới , nhưng phiên bản thoát của phần tử hàng đầu này , hiện đang thực thi.24022324022324022372402236240223240223

Lặp lại thứ tư

7 240223 6 240223240223
 7 240223 6 240223240223 Nối 240223 240223240223 vào đầu ngăn xếp

Đỉnh của ngăn xếp là một chuỗi có độ dài bằng không, vì vậy về cơ bản chúng ta chỉ bỏ qua chương trình kết thúc ở đó.

Lặp lại thứ năm

240.223 240.223.240.223 
240.223               Nối 240.223 lên đỉnh ngăn xếp yếu tố
       2              Sao chép đỉnh ngăn xếp nguyên tố
       40            Thoát ngăn xếp phần tử thứ hai, trao đổi nó vào top
          2           Sao chép đỉnh ngăn xếp nguyên tố
           23         Output đỉnh ngăn xếp yếu tố
       2        Sao chép đỉnh ngăn xếp nguyên tố
       40      thoát thứ hai phần tử ngăn xếp, hoán đổi nó lên trên cùng
          2     Sao chép phần tử ngăn xếp trên cùng
           23   Xuất phần tử ngăn xếp trên cùng

Điều này rất giống với lần lặp thứ ba. Có hai thay đổi, mặc dù. Đầu tiên, bây giờ có thêm 4 số 0 và 6 so với số 1 và 7, vì vậy chúng tôi sẽ cố gắng nhập một ký tự từ đầu vào tiêu chuẩn thay vì số. Mặc dù vậy, chúng tôi vẫn nhận được EOF và cuối cùng vẫn giảm đầu ngăn xếp thành chuỗi có độ dài bằng không. Tiếp theo, có mã chạy sau khi giảm, vì vậy lần lặp tiếp theo không bắt đầu ngay lập tức. Thay vào đó, chúng tôi thực hiện một loạt các hoạt động trên phần tử có độ dài bằng không đó, kết thúc bằng ba phần tử có độ dài bằng không. Chúng ta xuất ra một, hai cái còn lại biến mất (vì đó là sự kết thúc của một lần lặp) và về cơ bản chúng ta đã ở nơi chúng ta ở cuối của lần lặp thứ ba.

Lặp lại thứ sáu

Chương trình chúng tôi sao chép từ đầu ngăn xếp bây giờ . Mọi thứ hoạt động như trong lần lặp trước cho đến khi chúng ta đạt được hướng dẫn đầu ra đầu tiên (lần đầu tiên ). Điều này hiện có thêm năm 0 và 6 so với số 1 và 7, do đó, nó đặt chế độ trong đó lệnh đầu ra tiếp theo sẽ được hiểu là yêu cầu thay đổi định dạng đầu ra. Điều này cũng dẫn đến một sự thay đổi đáng chú ý trong hành vi; vì không có yêu cầu đầu vào, chúng tôi đã không đọc EOF, và do đó không gây ra hậu quả của việc đọc EOF (phần tử ngăn xếp trên cùng mới được làm trống), và như vậy phiên bản thoát của phần tử ngăn xếp ban đầu vẫn tồn tại chứ không phải là loại bỏ. Điều này có nghĩa là tiếp theo240223240223240223240223232402không còn là không hoạt động nữa, tạo ra hai bản sao của phần tử ngăn xếp được thoát (tức là chúng hiện đã thoát kép). Chúng tôi xuất một, đặt định dạng đầu ra thành 7 ("giống như đầu vào"); định dạng đầu ra này không có lệnh I / O và không có lệnh thay đổi định dạng, vì vậy chúng tôi sẽ giữ nguyên trong phần còn lại của chương trình. Chúng tôi cũng xuất 724022362402232402232402232402236(cùng mã hóa với đầu vào) thành đầu ra tiêu chuẩn.

Dù sao, khá rõ ràng chương trình sẽ làm gì từ thời điểm này trở đi: đó là sự kết hợp của việc nối thêm nhiều bản sao khác nhau được thoát 240223lên trên cùng của ngăn xếp, thoát khỏi đỉnh ngăn xếp và xuất ra các bản sao của đỉnh ngăn xếp. Từ thời điểm này trở đi, phần tử ngăn xếp trên cùng không bao giờ bị xóa (vì chúng ta không bao giờ đọc EOF), vì vậy nó chỉ phát triển và tăng trưởng và phát triển. Việc thoát định kỳ đảm bảo rằng đầu ra không bao giờ lặp lại (vì điều đó có nghĩa là mỗi lần lặp, đầu ra đầu tiên bắt đầu với ít nhất một lần 7so với lần lặp trước đó).

Ohm , 4 byte (CP437)

¼,¡∞

In biến đếm, tăng nó và đi vào một vòng lặp vô hạn! Đủ đơn giản.

EDIT (1 tháng 3 năm 17): Trong khi tôi đang thực hiện một số cập nhật khác (sau khi tôi đăng câu trả lời này), tôi đã thay đổi hành vi của ∞. Câu trả lời cập nhật sẽ là ∞^,.

DC "hiện đại" , 9 byte

Trí nhớ vô hạn?
Sau đó, một ngăn xếp phát triển liên tục là ok?
] :-)

[zprdx]dx

Đã bình luận:

[         # start string constant
 z        #   push current stack depth
  p       #   print TOS without removing
   r      #   swap TOS and NOS
    d     #   duplicate TOS
     x    #   pop TOS and interprete it
      ]   # end string constant, push it
       d  # duplicate TOS
        x # pop TOS and interprete it

Do sử dụng rlệnh, điều này sẽ không chạy trên một số DC không ổn định.

Ruby, 21 12 byte

loop{p$.+=1}

In tất cả các số tự nhiên. Theo như tôi hiểu mô tả vấn đề, điều này sẽ ổn thôi.

PHP, 21 byte

for(;;)echo uniqid();

Sử dụng: php -r "for(;;)echo uniqid();"

Xuất ID duy nhất dựa trên thời gian hiện tại tính bằng micro giây: 58b3e065e4b4c58b3e065e4b6358b3e065e4b7b58b3e065e4b9458b3e065e4bac58b3e065e4bc458b3e065e4bdc58b3e065e4bf558b3e065e4c0e58b3e065e4c2658b3e065e4c3e58b3e065e4c5658b3e065e4c6f58b3e065e4c8758b3e065e4c9f...

như một chuỗi liên tục của: 58b3e09390617 58b3e09390651 58b3e0939068a 58b3e093906c3 58b3e093906fc ...

Perl 6 , 11 byte

say($++)xx*

In số tự nhiên.

Hãy thử trực tuyến!

Python 2, 24 byte

In 9 lần mỗi sức mạnh của 2.

n=9
while 1:print n;n+=n

Dùng thử trực tuyến

Mẻ, 7 byte

time|%0

Hoặc là:

%random%|%0

Powershell, 19 byte

Chán đếm lên trả lời.

for(){[bigint]$i++}

Phiên bản cải tiến của câu trả lời từ Count Up Forever

xếp chồng lên nhau , 9 byte

$out0 ani

Hãy thử trực tuyến! Tương tự như câu trả lời Đếm mãi mãi của tôi , điều này xuất ra các số tự nhiên từ 0, bộ đếm.

Vỏ Bourne, 11 byte

yes date|sh

TI-Basic, 11 byte

While 1
Ans+1
Disp Ans
End

GNU sed , 13 byte

Đây là một bộ đếm chính xác tùy ý trong unary. Đó là một cách thú vị để nói rằng tôi gắn 0nó vào không gian mẫu và in nó trên mỗi lần lặp (vòng lặp vô hạn).

:
s:0*:&0:p
b

Sau một thời gian, điều này thường sẽ xảy ra lỗi cấp phát bộ nhớ và dừng in, vì nó không thể lưu trữ không gian mẫu ngày càng tăng. Đó không phải là vấn đề đối với thử thách này, vì bộ nhớ được coi là vô hạn.

Hãy thử trực tuyến!(trình thông dịch này giới hạn hơn nữa các tài nguyên có sẵn theo thiết kế)

Xem trước đầu ra: chỉ có 5 dòng đầu tiên

me@LCARS:/PPCG$ echo | sed -f infinite_non_periodic.sed | head -5
0
00
000
0000
00000

Vừng , 2 byte

Sê-ri

set numout
jmp, put, add 1

SBIN

00000000: c40a                                              ..

In tất cả các số nguyên không âm theo thứ tự.

Hãy thử trực tuyến!