Một câu hỏi tương tự như thế này đã được hỏi vài năm trước , nhưng câu hỏi này thậm chí còn khó hơn.

Thử thách rất đơn giản. Viết một chương trình (trong ngôn ngữ của bạn lựa chọn) mà liên tục thực thi mã mà không sử dụng bất kỳ cấu trúc lặp lại như while, for, do while, foreachhoặc goto( Vì vậy, cho tất cả các bạn nitpickers, bạn không thể sử dụng một vòng lặp ). Tuy nhiên, đệ quy không được phép, trong hàm gọi chính nó (xem định nghĩa bên dưới) . Điều đó sẽ làm cho thách thức này quá dễ dàng.

Không có hạn chế về những gì cần được thực hiện trong vòng lặp, nhưng đăng một lời giải thích với câu trả lời của bạn để người khác có thể hiểu chính xác những gì đang được thực hiện.

Đối với những người có thể bị treo trên các định nghĩa, định nghĩa của một vòng lặp cho câu hỏi này là:

A programming language statement which allows code to be repeatedly executed.

Và định nghĩa đệ quy cho câu hỏi này sẽ là định nghĩa hàm đệ quy tiêu chuẩn của bạn:

A function that calls itself.

Người chiến thắng sẽ là câu trả lời có nhiều lượt ủng hộ nhất vào ngày 16 tháng 7 lúc 10 giờ sáng theo giờ miền đông. Chúc may mắn!

CẬP NHẬT:

Để làm dịu sự nhầm lẫn vẫn đang được thể hiện, điều này có thể giúp:

Các quy tắc như đã nêu ở trên:

• Đừng sử dụng các vòng lặp hoặc goto
• Chức năng không thể tự gọi
• Làm bất cứ điều gì bạn muốn trong 'vòng lặp'

Nếu bạn muốn thực hiện một cái gì đó và các quy tắc không cho phép rõ ràng, hãy tiếp tục và thực hiện nó. Nhiều câu trả lời đã bẻ cong các quy tắc.

Hồng ngọc

def method_missing(meth,*args)
  puts 'Banana'
  send(meth.next)
end

def also
  puts "Orange you glad I didn't say banana?"
end

ahem

Bản giới thiệu

Xóa cổ họng của nó, in "Banana" 3070 lần, và cũng đặt "Orange bạn vui vì tôi không nói chuối?".

Điều này sử dụng chức năng định nghĩa phương thức đúng lúc vô lý của Ruby để xác định mọi phương thức nằm theo thứ tự abc giữa các từ 'ahem' và 'cũng' ("ahem", "ahen", "aheo", "ahep", "aheq", "Aher", "ahes", "ahet", "aheu", "ahev" ...) để in Banana đầu tiên và sau đó gọi tiếp theo trong danh sách.

Con trăn - 16

hoặc bất kỳ ngôn ngữ khác với eval.

exec"print 1;"*9

CSharp

Tôi đã mở rộng mã thành một kiểu dễ đọc hơn vì đây không còn là mã golf nữa và đã thêm một bộ đếm tăng dần để mọi người thực sự có thể thấy rằng chương trình này làm gì đó.

class P{
    static int x=0;
    ~P(){
        System.Console.WriteLine(++x);
        new P();
    }
    static void Main(){
        new P();
    }
}

(Đừng làm điều này bao giờ xin vui lòng).

Khi bắt đầu, chúng ta tạo một thể hiện mới của Plớp, khi chương trình cố gắng thoát lệnh gọi GC sẽ gọi bộ hoàn thiện tạo ra một thể hiện mới của Plớp, khi nó cố gắng dọn sạch sẽ tạo ra một cái mới Pgọi là bộ hoàn thiện .. .

Chương trình cuối cùng đã chết.

Chỉnh sửa: Không thể giải thích điều này chỉ chạy khoảng 45 nghìn lần trước khi chết. Tôi hoàn toàn không biết làm thế nào mà GC tìm ra vòng lặp vô hạn khó khăn của tôi nhưng nó đã làm. Nói ngắn gọn là có vẻ như nó đã không tìm ra và sợi chỉ bị giết sau khoảng 2 giây thực hiện: https://stackoverflow.com/questions/24662454/how-does-a-garbage-collector-avoid-an -infinite-loop-here

Edit2: Nếu bạn nghĩ rằng điều này hơi quá giống như đệ quy, hãy xem xét giải pháp khác của tôi: https://codegolf.stackexchange.com/a/33268/23300

Nó sử dụng sự hợp nhất hóa các phương thức chung để trong thời gian chạy, nó liên tục tạo ra các phương thức mới và mỗi phương thức trong thuật ngữ gọi một phương thức mới được đúc. Tôi cũng tránh sử dụng referencecác tham số kiểu, vì thông thường thời gian chạy có thể chia sẻ mã cho các phương thức đó. Với một valuetham số kiểu, bộ thực thi buộc phải tạo một phương thức mới.

Befunge

.

Befunge cũ tốt xuất ra 0 (từ một ngăn xếp trống) gần như mãi mãi, khi các dòng bao quanh.

Mã não

(f=function(){ console.log('hi!'); eval("("+f+")()") })()

Chức năng vui!

Một chức năng tạo ra một chức năng khác có cùng cơ thể với chính nó và sau đó chạy nó.

Nó sẽ hiển thị hi ở cuối khi đạt đến giới hạn ngăn xếp và toàn bộ sự việc sụp đổ.

Tuyên bố miễn trừ trách nhiệm: bạn sẽ không thể làm bất cứ điều gì trong trình duyệt của mình cho đến khi đạt đến giới hạn ngăn xếp.

Và một điều khác, ác hơn :

function f(){ var tab = window.open(); tab.f = f; tab.f()}()

Nó tạo ra một chức năng mở ra một cửa sổ, sau đó tạo ra một chức năng trong cửa sổ đó là bản sao của chức năng và sau đó chạy nó.

Tuyên bố miễn trừ trách nhiệm: nếu bạn cho phép mở cửa sổ bật lên, cách duy nhất để hoàn thành việc này sẽ là khởi động lại máy tính của bạn

lắp ráp x86 / DOS

    org 100h

start:
    mov dx,data
    mov ah,9h
    int 21h
    push start
    ret

data:
    db "Hello World!",10,13,"$"

Tôi đã nói không đệ quy đuôi đảo ngược ? Tôi đã làm

Làm thế nào nó hoạt động

Lệnh ret, được sử dụng để trả về từ một hàm, thực sự bật địa chỉ trả về từ ngăn xếp (thường được đặt ở đó bởi tương ứng call) và nhảy đến nó. Ở đây tại mỗi lần lặp, chúng ta sẽ pushghi địa chỉ điểm vào ngăn xếp trước khi quay trở lại, do đó tạo ra một vòng lặp vô hạn.

Java

Trực tiếp từ XKCD

Đây là một trò chơi không bao giờ kết thúc giữa cha mẹ và con cái!

Mục tiêu của CHILDđược đặt thành PARENTvà mục tiêu của PARENTlà CHILD. Khi các PARENTcuộc gọi AIM, nó ném thể hiện của BALLlớp và nó bị bắt bởi câu lệnh bắt. Câu lệnh bắt sau đó gọi PARENT.TARGET.AIMnơi mà mục tiêu là CHILD. Các CHILDví dụ cũng làm như vậy và "ném bóng trở lại" cho phụ huynh.

Bash, 3 ký tự

yes

có sẽ liên tục trả 'y' cho bàn điều khiển

Chỉnh sửa: Mọi người được khuyến khích chỉnh sửa dòng này:

yes something | xargs someaction

(cảm ơn Olivier Dulac)

C, 35 ký tự

main(int a,char**v){execv(v[0],v);}

Chương trình tự thực thi. Tôi không chắc chắn nếu điều này được coi là đệ quy hay không.

C (với các nội trang GCC - dường như cũng hoạt động với tiếng kêu)

• Không có vòng lặp rõ ràng
• Không có hình ảnh rõ ràng
• Không đệ quy
• Chỉ cần làm hỏng kiểu cũ với đống đồ (trẻ em, đừng thử điều này ở nhà mà không có sự giám sát):

#include <stdio.h>

void *frameloop (void *ret_addr) {
    void **fp;
    void *my_ra = __builtin_return_address(0);

    if (ret_addr) {
        fp = __builtin_frame_address(0);
        if (*fp == my_ra) return (*fp = ret_addr);
        else fp++;
        if (*fp == my_ra) return (*fp = ret_addr);
        else fp++;
        if (*fp == my_ra) return (*fp = ret_addr);
        else fp++;
        if (*fp == my_ra) return (*fp = ret_addr);
        return NULL;
    } else {
        return (my_ra);
    }
}

int main (int argc, char **argv) {
    void *ret_addr;
    int i = 0;

    ret_addr = frameloop(NULL);
    printf("Hello World %d\n", i++);
    if (i < 10) {
        frameloop(ret_addr);
    }
}

Giải trình:

• main()cuộc gọi đầu tiên frameloop(NULL). Trong trường hợp này, sử dụng __builtin_return_address()nội dung dựng sẵn để lấy địa chỉ trả về (trong main()) frameloop()sẽ trở về. Chúng tôi trả lại địa chỉ này.
• printf() để hiển thị chúng tôi đang lặp
• bây giờ chúng tôi gọi frameloop()với địa chỉ trả lại cho cuộc gọi trước. Chúng tôi xem qua ngăn xếp cho địa chỉ trả lại hiện tại và khi chúng tôi tìm thấy nó, chúng tôi thay thế địa chỉ trả lại trước đó.
• Chúng tôi sau đó trở về từ frameloop()cuộc gọi thứ 2 . Nhưng vì địa chỉ trả lại đã bị hack ở trên, cuối cùng chúng tôi sẽ quay trở lại điểm main()mà cuộc gọi đầu tiên sẽ quay lại. Vì vậy, chúng tôi kết thúc trong một vòng lặp.

Việc tìm kiếm địa chỉ trả về trong ngăn xếp tất nhiên sẽ sạch hơn như một vòng lặp, nhưng tôi đã không kiểm soát một vài lần lặp lại vì mục đích không lặp lại bất cứ điều gì.

Đầu ra:

$ CFLAGS=-g make frameloop
cc -g    frameloop.c   -o frameloop
$ ./frameloop 
Hello World 0
Hello World 1
Hello World 2
Hello World 3
Hello World 4
Hello World 5
Hello World 6
Hello World 7
Hello World 8
Hello World 9
$ 

Haskell

Đoạn mã sau không chứa hàm đệ quy (thậm chí là gián tiếp), không lặp nguyên hàm lặp và không gọi bất kỳ hàm đệ quy tích hợp nào (chỉ sử dụng IOđầu ra và ràng buộc), nhưng nó lặp lại một hành động nhất định:

data Strange a = C (Strange a -> a)

-- Extract a value out of 'Strange'
extract :: Strange a -> a
extract (x@(C x')) = x' x

-- The Y combinator, which allows to express arbitrary recursion
yc :: (a -> a) -> a
yc f =  let fxx = C (\x -> f (extract x))
        in extract fxx

main = yc (putStrLn "Hello world" >>)

Chức năng extractkhông gọi bất cứ điều gì, ycchỉ cần gọi extractvà mainchỉ gọi ycvà putStrLnvà >>, mà không phải là đệ quy.

Giải thích: Thủ thuật nằm ở kiểu dữ liệu đệ quy Strange. Đó là một kiểu dữ liệu đệ quy tiêu thụ chính nó, như trong ví dụ, cho phép lặp lại tùy ý. Đầu tiên, chúng ta có thể xây dựng extract x, về cơ bản thể hiện sự tự ứng dụng x xtrong phép tính lambda chưa được đánh dấu. Và điều này cho phép xây dựng tổ hợp Y được định nghĩa là λf.(λx.f(xx))(λx.f(xx)).

Cập nhật: Như đã đề xuất, tôi đang đăng một biến thể gần với định nghĩa của Y trong phép tính lambda chưa được đánh dấu:

data Strange a = C (Strange a -> a)

-- | Apply one term to another, removing the constructor.
(#) :: Strange a -> Strange a -> a
(C f) # x = f x
infixl 3 #

-- The Y combinator, which allows to express arbitrary recursion
yc :: (a -> a) -> a
yc f =  C (\x -> f (x # x)) # C (\x -> f (x # x))

main = yc (putStrLn "Hello world" >>)

C ++

Sau đây xuất ra một bộ đếm ngược từ 10 đến "Blast off!" sử dụng siêu lập trình mẫu.

#include <iostream>

template<int N>
void countdown() {
    std::cout << "T minus " << N << std::endl;
    countdown<N-1>();
}

template<>
void countdown<0>() {
    std::cout << "Blast off!" << std::endl;
}

int main()
{
    countdown<10>();
    return 0;
}

Nó có thể trông giống như một ví dụ cổ điển về đệ quy, nhưng thực tế, ít nhất là về mặt kỹ thuật, tùy thuộc vào định nghĩa của bạn. Trình biên dịch sẽ tạo ra mười chức năng khác nhau . countdown<10>in "T trừ 10" và sau đó gọi countdown<9>, và cứ thế countdown<0>, in ra "Blast off!" và sau đó trở về. Đệ quy xảy ra khi bạn biên dịch mã, nhưng tệp thực thi không chứa bất kỳ cấu trúc lặp nào.

Trong C ++ 11, người ta có thể đạt được các hiệu ứng tương tự bằng cách sử dụng constexprtừ khóa, chẳng hạn như chức năng giai thừa này. (Không thể thực hiện ví dụ đếm ngược theo cách này, vì các constexprhàm không thể có tác dụng phụ, nhưng tôi nghĩ có thể có trong C ++ 14 sắp tới.)

constexpr int factorial(int n)
{
    return n <= 1 ? 1 : (n * factorial(n-1));
}

Một lần nữa điều này thực sự trông giống như đệ quy, nhưng trình biên dịch sẽ mở rộng ra factorial(10)vào 10*9*8*7*6*5*4*3*2*1, và sau đó có thể thay thế nó bằng một giá trị không đổi của 3628800, do đó thực thi sẽ không chứa bất kỳ vòng lặp hoặc mã đệ quy.

Java

Hãy chơi với trình nạp lớp Java và đặt nó làm cha mẹ của chính nó:

import java.lang.reflect.Field;

public class Loop {
    public static void main(String[] args) throws Exception {
        System.out.println("Let's loop");
        Field field = ClassLoader.class.getDeclaredField("parent");
        field.setAccessible(true);
        field.set(Loop.class.getClassLoader(), Loop.class.getClassLoader());

    }
}

Vòng lặp này thực sự rất mạnh, bạn sẽ phải sử dụng kill -9để ngăn chặn nó :-)

Nó sử dụng 100,1% CPU Mac của tôi.

Bạn có thể thử di chuyển System.outở cuối chức năng chính để thử nghiệm một hành vi hài hước xen kẽ.

CSharp

Thêm một kẻ độc ác nữa

public class P{

    class A<B>{
        public static int C<T>(){
            System.Console.WriteLine(typeof(T));
            return C<A<T>>();
        }
    }
    public static void Main(){
        A<P>.C<int>();
    }
}

Đây không phải là đệ quy ... đây là sự thống nhất của các mẫu mã. Mặc dù có vẻ như chúng ta đang gọi cùng một phương thức, bộ thực thi liên tục tạo ra các phương thức mới. Chúng tôi sử dụng tham số kiểu của int, vì điều này thực sự buộc nó phải tạo ra một kiểu hoàn toàn mới và mỗi thể hiện của phương thức phải đưa ra một phương thức mới. Nó không thể chia sẻ mã ở đây. Cuối cùng, chúng ta giết ngăn xếp cuộc gọi vì nó chờ đợi vô hạn cho sự trở lại của int mà chúng ta đã hứa nhưng không bao giờ được giao. Theo cách tương tự, chúng tôi tiếp tục viết loại chúng tôi tạo ra để giữ cho nó thú vị. Về cơ bản, mỗi C mà chúng ta gọi là một phương thức hoàn toàn mới chỉ có cùng một cơ thể. Điều này thực sự không khả thi trong một ngôn ngữ như C ++ hoặc D thực hiện các mẫu của họ tại thời điểm biên dịch. Vì, C # JIT là siêu lười biếng, nó chỉ tạo ra thứ này vào thời điểm cuối cùng có thể. Do vậy,

Redcode 94 (Chiến tranh cốt lõi)

MOV 0, 1

Hướng dẫn sao chép tại địa chỉ 0 đến địa chỉ một. Bởi vì trong Core War, tất cả các địa chỉ đều liên quan đến địa chỉ PC hiện tại và modulo kích thước của lõi, đây là một vòng lặp vô hạn trong một lệnh, không nhảy ,.

Chương trình này (chiến binh) được gọi là " Imp " và lần đầu tiên được xuất bản bởi AK Dewdney.

Phi tiêu

Tôi đoán đây sẽ là cách thức đệ quy cổ điển mà không có bất kỳ chức năng đệ quy thực tế nào. Không có chức năng dưới đây đề cập đến chính nó theo tên, trực tiếp hoặc gián tiếp.

(Hãy thử tại dartpad.dartlang.org )

// Strict fixpoint operator.
fix(f) => ((x)=>f(x(x))) ((x)=>(v)=>f(x(x))(v));
// Repeat action while it returns true.
void repeat(action) { fix((rep1) => (b) { if (b()) rep1(b); })(action); }

main() {
  int x = 0;
  repeat(() {  
    print(++x);
    return x < 10;
  });
}

Mã não

Không nguyên bản nhưng nhỏ. 20 ký tự.

setInterval(alert,1)

Tín hiệu trong C

#include <stdio.h>
#include <signal.h>

int main(void) {
    signal(SIGSEGV, main);
    *(int*)printf("Hello, world!\n") = 0;
    return 0;
}

Hành vi của chương trình này rõ ràng là không xác định được rất nhiều, nhưng ngày nay, trên máy tính của tôi, nó cứ in "Xin chào, thế giới!".

Emacs Lisp

Đây là thời điểm tuyệt vời để thể hiện thiết kế mạnh mẽ của Lisp trong đó "mã là dữ liệu và dữ liệu là mã". Cấp, những ví dụ này rất không hiệu quả và điều này không bao giờ nên được sử dụng trong bối cảnh thực tế.

Các macro tạo mã là phiên bản chưa được kiểm soát của vòng lặp được cho là và mã được tạo đó là những gì được đánh giá khi chạy.

repeat-it: cho phép bạn lặp N lần

(defmacro repeat-it (n &rest body)
  "Evaluate BODY N number of times.
Returns the result of the last evaluation of the last expression in BODY."
  (declare (indent defun))
  (cons 'progn (make-list n (cons 'progn body))))

kiểm tra lặp lại:

;; repeat-it test
(progn
  (setq foobar 1)

  (repeat-it 10
    (setq foobar (1+ foobar)))

  ;; assert that we incremented foobar n times
  (assert (= foobar 11)))

lặp lại với chỉ mục:

Macro này giống như repeat-itnhưng nó thực sự hoạt động giống như macro lặp chung, do-timesnó cho phép bạn chỉ định một biểu tượng sẽ được liên kết với chỉ mục vòng lặp. Nó sử dụng ký hiệu thời gian mở rộng để đảm bảo rằng biến chỉ số được đặt chính xác ở đầu mỗi vòng lặp bất kể bạn có sửa đổi giá trị của nó trong thân vòng lặp hay không.

(defmacro repeat-it-with-index (var-and-n &rest body)
  "Evaluate BODY N number of times with VAR bound to successive integers from 0 inclusive to n exclusive..
VAR-AND-N should be in the form (VAR N).
Returns the result of the last evaluation of the last expression in BODY."
  (declare (indent defun))
  (let ((fallback-sym (make-symbol "fallback")))
    `(let ((,(first var-and-n) 0)
           (,fallback-sym 0))
       ,(cons 'progn
              (make-list (second var-and-n)
                         `(progn
                            (setq ,(first var-and-n) ,fallback-sym)
                            ,@body
                            (incf ,fallback-sym)))))))

kiểm tra lặp lại với chỉ số:

Thử nghiệm này cho thấy:

1. Cơ thể đánh giá N lần

2. biến chỉ số luôn được đặt chính xác ở đầu mỗi lần lặp

3. thay đổi giá trị của biểu tượng có tên "dự phòng" sẽ không gây rối với chỉ mục

;; repeat-it-with-index test
(progn
  ;; first expected index is 0
  (setq expected-index 0)

  ;; start repeating
  (repeat-it-with-index (index 50)
    ;; change the value of a  'fallback' symbol
    (setq fallback (random 10000))
    ;; assert that index is set correctly, and that the changes to
    ;; fallback has no affect on its value
    (assert (= index expected-index))
    ;; change the value of index
    (setq index (+ 100 (random 1000)))
    ;; assert that it has changed
    (assert (not (= index expected-index)))
    ;; increment the expected value
    (incf expected-index))

  ;; assert that the final expected value is n
  (assert (= expected-index 50)))

Giải tích lambda

λf.(λx.f (x x)) (λx.f (x x))

Haskell, 24 ký tự

sequence_ (repeat (print "abc"))

hoặc ở dạng cô đọng, có 24 ký tự

sequence_$repeat$print"" 

(mặc dù văn bản đã được thay đổi, nhưng điều này vẫn sẽ lặp lại - điều này sẽ in hai dấu ngoặc kép và một dòng mới vô hạn)

giải thích: in "abc" về cơ bản là một hành động i / o chỉ in "abc".
repeat là một hàm lấy một giá trị x và trả về một danh sách vô hạn chỉ gồm x.
Sequ_ là một hàm lấy danh sách các hành động i / o và trả về một hành động i / o thực hiện tất cả các hành động theo tuần tự.

vì vậy, về cơ bản, chương trình này tạo một danh sách vô hạn các lệnh in "abc" và liên tục thực thi chúng. không có vòng lặp hoặc đệ quy.

ASM (x86 + I / O cho Linux)

Không quan trọng các ngôn ngữ cấp cao trừng phạt của bạn sẽ vật lộn đến mức nào, nó vẫn sẽ chỉ là thao tác con trỏ lệnh ẩn. Cuối cùng, nó sẽ là một loại "goto" (jmp), trừ khi bạn đủ chán để bỏ vòng lặp trong thời gian chạy.

Bạn có thể kiểm tra mã trên Ideone

Bạn cũng có thể kiểm tra phiên bản tinh chỉnh hơn của ý tưởng này trong mã Matteo Italia DOS .

Nó bắt đầu bằng chuỗi 0..9 và thay thế nó bằng A..J, không có bước nhảy trực tiếp nào được sử dụng (vì vậy hãy nói rằng không có "goto" nào xảy ra), cũng không tái phát.

Mã có thể có thể nhỏ hơn với một số lạm dụng tính toán địa chỉ, nhưng làm việc trên trình biên dịch trực tuyến thật khó chịu vì vậy tôi sẽ để nó như vậy.

Phần cốt lõi:

mov dl, 'A' ; I refuse to explain this line!
mov ebx, msg ; output array (string)

call rawr   ; lets put address of "rawr" line on stack
rawr: pop eax ; and to variable with it! In same time we are breaking "ret"

add eax, 4 ; pop eax takes 4 bytes of memory, so for sake of stack lets skip it
mov [ebx], dl ; write letter
inc dl ; and proceed to next 
inc ebx
cmp dl, 'J' ; if we are done, simulate return/break by leaving this dangerous area
jg print

push eax ; and now lets abuse "ret" by making "call" by hand
ret

Toàn bộ mã

section     .text
global      _start                              

_start:

;<core>
mov dl, 'A'
mov ebx, msg

call rawr
rawr: pop eax

add eax, 4
mov [ebx], dl
inc dl
inc ebx
cmp dl, 'J'
jg print

push eax
ret
;</core>

; just some Console.Write()
print:
    mov     edx,len
    mov     ecx,msg
    mov     ebx,1
    mov     eax,4
    int     0x80

    mov     eax,1
    xor     ebx, ebx
    int     0x80

section     .data

msg     db  '0123456789',0xa
len     equ $ - msg

C Tiền xử lý

Một "kỹ thuật" nhỏ mà tôi đã nghĩ ra trong một thử thách khó khăn. Không có đệ quy hàm, nhưng có ... đệ quy tập tin?

noloop.c:

#if __INCLUDE_LEVEL__ == 0
int main() 
{
    puts("There is no loop...");
#endif
#if __INCLUDE_LEVEL__ <= 16
    puts(".. but Im in ur loop!");
    #include "noloop.c"
#else
    return 0;
}
#endif

Tôi đã viết / kiểm tra điều này bằng cách sử dụng gcc. Rõ ràng trình biên dịch của bạn cần hỗ trợ __INCLUDE_LEVEL__macro (hoặc thay vào đó là __COUNTER__macro với một số điều chỉnh) để biên dịch. Nó khá rõ ràng về cách thức hoạt động của nó, nhưng để giải trí, hãy chạy bộ tiền xử lý mà không biên dịch mã (sử dụng -Ecờ với gcc).

PHP

Đây là một với PHP. Vòng lặp bằng cách bao gồm cùng một tệp cho đến khi bộ đếm đạt $ max:

<?php
if (!isset($i))
    $i = 0;        // Initialize $i with 0
$max = 10;         // Target value

// Loop body here
echo "Iteration $i <br>\n";

$i++;               // Increase $i by one on every iteration

if ($i == $max)
    die('done');    // When $i reaches $max, end the script
include(__FILE__);  // Proceed with the loop
?>

Giống như một vòng lặp for:

<?php
for ($i = 0; $i < 10; $i++) {
    echo "Iteration $i <br>\n";
}
die('done');
?>

Con trăn

Đoạn mã sau không chứa hàm đệ quy (trực tiếp hoặc gián tiếp), không có vòng lặp nguyên thủy và không gọi bất kỳ hàm dựng sẵn nào (ngoại trừ print):

def z(f):
    g = lambda x: lambda w: f(lambda v: (x(x))(v), w)
    return g(g)

if __name__ == "__main__":
    def msg(rec, n):
        if (n > 0):
            print "Hello world!"
            rec(n - 1)
    z(msg)(7)

In "Xin chào thế giới!" một số lần nhất định.

Giải thích: Hàm zthực hiện bộ kết hợp điểm cố định Z nghiêm ngặt , (trong khi không được xác định đệ quy) cho phép thể hiện bất kỳ thuật toán đệ quy nào.

mã máy z80

Trong môi trường nơi bạn có thể thực thi tại mọi địa chỉ và ánh xạ ROM ở mọi nơi, hãy ánh xạ 64kb ROM chứa đầy số không vào toàn bộ không gian địa chỉ.

Nó làm gì: không có gì. Nhiều lần.

Cách thức hoạt động: bộ xử lý sẽ bắt đầu thực thi, byte 00là một noplệnh, vì vậy nó sẽ tiếp tục, tiếp cận địa chỉ $ffff, bao quanh $0000và tiếp tục thực thinop s cho đến khi bạn đặt lại nó.

Để làm cho nó thú vị hơn một chút, hãy lấp đầy bộ nhớ bằng một số giá trị khác (cẩn thận để tránh các hướng dẫn luồng điều khiển).

Perl-regex

(q x x x 10) =~ /(?{ print "hello\n" })(?!)/;

bản giới thiệu

hoặc thử nó như:

perl -e '(q x x x 10) =~ /(?{ print "hello\n" })(?!)/;'

Không (?!)bao giờ phù hợp. Vì vậy, công cụ regex cố gắng khớp từng vị trí có độ rộng bằng 0 trong chuỗi khớp.

Điều (q x x x 10)này giống như (" " x 10)- lặp lại spacemười lần.

Chỉnh sửa: thay đổi "ký tự" thành các vị trí có độ rộng bằng 0 để chính xác hơn để dễ hiểu hơn. Xem câu trả lời cho câu hỏi stackoverflow này .

T-SQL -12

print 1
GO 9

Trên thực tế, nhiều hơn một chút của Sql Server Management Studio. GO là một dấu tách tập lệnh và không phải là một phần của ngôn ngữ T-SQL. Nếu bạn chỉ định GO theo sau bởi một số, nó sẽ thực thi khối đó nhiều lần.

C #

In ra tất cả các số nguyên từ uint.MaxValue thành 0.

   class Program
   {
      public static void Main()
      {
          uint max = uint.MaxValue;
          SuperWriteLine(ref max);
          Console.WriteLine(0);
      }

      static void SuperWriteLine(ref uint num)
      {
          if ((num & (1 << 31)) > 0) { WriteLine32(ref num); }
          if ((num & (1 << 30)) > 0) { WriteLine31(ref num); }
          if ((num & (1 << 29)) > 0) { WriteLine30(ref num); }
          if ((num & (1 << 28)) > 0) { WriteLine29(ref num); }
          if ((num & (1 << 27)) > 0) { WriteLine28(ref num); }
          if ((num & (1 << 26)) > 0) { WriteLine27(ref num); }
          if ((num & (1 << 25)) > 0) { WriteLine26(ref num); }
          if ((num & (1 << 24)) > 0) { WriteLine25(ref num); }
          if ((num & (1 << 23)) > 0) { WriteLine24(ref num); }
          if ((num & (1 << 22)) > 0) { WriteLine23(ref num); }
          if ((num & (1 << 21)) > 0) { WriteLine22(ref num); }
          if ((num & (1 << 20)) > 0) { WriteLine21(ref num); }
          if ((num & (1 << 19)) > 0) { WriteLine20(ref num); }
          if ((num & (1 << 18)) > 0) { WriteLine19(ref num); }
          if ((num & (1 << 17)) > 0) { WriteLine18(ref num); }
          if ((num & (1 << 16)) > 0) { WriteLine17(ref num); }
          if ((num & (1 << 15)) > 0) { WriteLine16(ref num); }
          if ((num & (1 << 14)) > 0) { WriteLine15(ref num); }
          if ((num & (1 << 13)) > 0) { WriteLine14(ref num); }
          if ((num & (1 << 12)) > 0) { WriteLine13(ref num); }
          if ((num & (1 << 11)) > 0) { WriteLine12(ref num); }
          if ((num & (1 << 10)) > 0) { WriteLine11(ref num); }
          if ((num & (1 << 9)) > 0) { WriteLine10(ref num); }
          if ((num & (1 << 8)) > 0) { WriteLine09(ref num); }
          if ((num & (1 << 7)) > 0) { WriteLine08(ref num); }
          if ((num & (1 << 6)) > 0) { WriteLine07(ref num); }
          if ((num & (1 << 5)) > 0) { WriteLine06(ref num); }
          if ((num & (1 << 4)) > 0) { WriteLine05(ref num); }
          if ((num & (1 << 3)) > 0) { WriteLine04(ref num); }
          if ((num & (1 << 2)) > 0) { WriteLine03(ref num); }
          if ((num & (1 <<  1)) > 0) { WriteLine02(ref num); }
          if ((num & (1 <<  0)) > 0) { WriteLine01(ref num); }
      }

      private static void WriteLine32(ref uint num) { WriteLine31(ref num); WriteLine31(ref num); }
      private static void WriteLine31(ref uint num) { WriteLine30(ref num); WriteLine30(ref num); }
      private static void WriteLine30(ref uint num) { WriteLine29(ref num); WriteLine29(ref num); }
      private static void WriteLine29(ref uint num) { WriteLine28(ref num); WriteLine28(ref num); }
      private static void WriteLine28(ref uint num) { WriteLine27(ref num); WriteLine27(ref num); }
      private static void WriteLine27(ref uint num) { WriteLine26(ref num); WriteLine26(ref num); }
      private static void WriteLine26(ref uint num) { WriteLine25(ref num); WriteLine25(ref num); }
      private static void WriteLine25(ref uint num) { WriteLine24(ref num); WriteLine24(ref num); }
      private static void WriteLine24(ref uint num) { WriteLine23(ref num); WriteLine23(ref num); }
      private static void WriteLine23(ref uint num) { WriteLine22(ref num); WriteLine22(ref num); }
      private static void WriteLine22(ref uint num) { WriteLine21(ref num); WriteLine21(ref num); }
      private static void WriteLine21(ref uint num) { WriteLine20(ref num); WriteLine20(ref num); }
      private static void WriteLine20(ref uint num) { WriteLine19(ref num); WriteLine19(ref num); }
      private static void WriteLine19(ref uint num) { WriteLine18(ref num); WriteLine18(ref num); }
      private static void WriteLine18(ref uint num) { WriteLine17(ref num); WriteLine17(ref num); }
      private static void WriteLine17(ref uint num) { WriteLine16(ref num); WriteLine16(ref num); }
      private static void WriteLine16(ref uint num) { WriteLine15(ref num); WriteLine15(ref num); }
      private static void WriteLine15(ref uint num) { WriteLine14(ref num); WriteLine14(ref num); }
      private static void WriteLine14(ref uint num) { WriteLine13(ref num); WriteLine13(ref num); }
      private static void WriteLine13(ref uint num) { WriteLine12(ref num); WriteLine12(ref num); }
      private static void WriteLine12(ref uint num) { WriteLine11(ref num); WriteLine11(ref num); }
      private static void WriteLine11(ref uint num) { WriteLine10(ref num); WriteLine10(ref num); }
      private static void WriteLine10(ref uint num) { WriteLine09(ref num); WriteLine09(ref num); }
      private static void WriteLine09(ref uint num) { WriteLine08(ref num); WriteLine08(ref num); }
      private static void WriteLine08(ref uint num) { WriteLine07(ref num); WriteLine07(ref num); }
      private static void WriteLine07(ref uint num) { WriteLine06(ref num); WriteLine06(ref num); }
      private static void WriteLine06(ref uint num) { WriteLine05(ref num); WriteLine05(ref num); }
      private static void WriteLine05(ref uint num) { WriteLine04(ref num); WriteLine04(ref num); }
      private static void WriteLine04(ref uint num) { WriteLine03(ref num); WriteLine03(ref num); }
      private static void WriteLine03(ref uint num) { WriteLine02(ref num); WriteLine02(ref num); }
      private static void WriteLine02(ref uint num) { WriteLine01(ref num); WriteLine01(ref num); }
      private static void WriteLine01(ref uint num) { Console.WriteLine(num--); }
   }

JS (trong trình duyệt)

Còn cái này thì sao?

document.write(new Date());
location = location;

In thời gian hiện tại và tải lại trang.