คำถามที่คล้ายกับคำถามนี้ถูกถามเมื่อสองสามปีก่อนแต่คำถามนี้ก็ยิ่งซับซ้อน

ความท้าทายนั้นง่าย เขียนโปรแกรม (ในภาษาของคุณเลือก) ที่ซ้ำ ๆ รันรหัสโดยไม่ต้องใช้โครงสร้างการทำซ้ำใด ๆ เช่นwhile, for, do while, foreachหรือgoto( ดังนั้นสำหรับสิ่งที่คุณ nitpickers คุณไม่สามารถใช้ห่วง ) อย่างไรก็ตามการเรียกซ้ำไม่ได้รับอนุญาตในการทำงานที่เรียกตัวเองรู้สึก (ดูคำนิยามด้านล่าง) นั่นจะทำให้ความท้าทายนี้ง่ายเกินไป

ไม่มีข้อ จำกัด ในสิ่งที่ต้องดำเนินการในลูปแต่โพสต์คำอธิบายด้วยคำตอบของคุณเพื่อให้ผู้อื่นสามารถเข้าใจสิ่งที่ถูกนำไปใช้

สำหรับผู้ที่อาจวางสายบนคำจำกัดความนิยามของวนสำหรับคำถามนี้คือ:

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

และคำจำกัดความของการสอบถามซ้ำสำหรับคำถามนี้จะเป็นนิยามฟังก์ชันการเรียกซ้ำมาตรฐานของคุณ:

A function that calls itself.

ผู้ชนะจะเป็นคำตอบที่มีผู้โหวตมากที่สุดในวันที่ 16 กรกฎาคมเวลา 10.00 น. ตามเวลาฝั่งตะวันออก โชคดี!

UPDATE:

หากต้องการสงบความสับสนที่ยังคงแสดงออกอยู่อาจช่วย:

กฎที่ระบุไว้ข้างต้น:

• อย่าใช้ลูปหรือข้ามไป
• ฟังก์ชั่นไม่สามารถเรียกตัวเองว่า
• ทำทุกอย่างที่คุณต้องการใน 'ลูป'

หากคุณต้องการนำบางสิ่งมาใช้และกฎไม่ได้ห้ามอย่างชัดเจนให้ดำเนินการต่อไป คำตอบจำนวนมากก้มกฏอยู่แล้ว

ทับทิม

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

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

ahem

การสาธิต

ล้างลำคอพิมพ์ "Banana" 3070 ครั้งแล้วใส่ "ส้มคุณดีใจที่ฉันไม่ได้พูดกล้วยเลย"

วิธีนี้ใช้ฟังก์ชันการกำหนดเมธอดแบบทันเวลาที่ไร้สาระของรูบี้เพื่อกำหนดวิธีการที่เรียงตามตัวอักษรระหว่างคำว่า 'อะแฮ่ม' และ 'ยัง' ("อะแฮ่ม", "อาเฮน", "อาเฮ๊ป", "อะเฮ๊ก") "aher", "ahes", "ahet", "aheu", "ahev" ... ) เพื่อพิมพ์ Banana ก่อนแล้วจึงเรียกรายการต่อไปในรายการ

Python - 16

หรือภาษาอื่นใดที่มีการประเมินผล

exec"print 1;"*9

CSharp

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

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

โปรดอย่าทำอย่างนี้เลย)

เมื่อเริ่มต้นเราสร้างอินสแตนซ์ใหม่ของPคลาสซึ่งเมื่อโปรแกรมพยายามออกจากการเรียก GC ซึ่งเรียก finalizer ซึ่งสร้างอินสแตนซ์ใหม่ของPคลาสซึ่งเมื่อพยายามล้างข้อมูลจะสร้างใหม่Pที่เรียก finalizer .

ในที่สุดโปรแกรมก็จะตาย

แก้ไข: อย่างลึกลับนี้จะทำงานเพียงประมาณ 45k ครั้งก่อนตาย ฉันไม่ค่อยรู้ว่า GC หาห่วงอนันต์อันไร้ขอบเขตของฉันได้อย่างไร แต่มันก็เป็นเช่นนั้น สั้น ๆ ดูเหมือนว่ามันไม่ได้คิดออกและเธรดเพิ่งถูกฆ่าหลังจากผ่านไปประมาณ 2 วินาทีของการดำเนินการ: https://stackoverflow.com/questions/24662454/how-does-a-garbage-collector-avoid-an -infinite วง-ที่นี่

แก้ไข 2: หากคุณคิดว่านี่เป็นเรื่องเล็กน้อยเหมือนการเรียกซ้ำให้พิจารณาโซลูชันอื่นของฉัน: https://codegolf.stackexchange.com/a/33268/23300

มันใช้การทำให้เป็นจริงของวิธีการทั่วไปเพื่อให้มันรันไทม์อย่างต่อเนื่องคือการสร้างวิธีการใหม่และแต่ละวิธีในระยะเรียกวิธีการสร้างใหม่ ฉันยังหลีกเลี่ยงการใช้referenceพารามิเตอร์ประเภทตามปกติรันไทม์สามารถแบ่งปันรหัสสำหรับวิธีการเหล่านั้น ด้วยvalueพารามิเตอร์ประเภทรันไทม์ถูกบังคับให้สร้างวิธีการใหม่

Befunge

.

Befunge เก่าดีเอาท์พุท 0 (จากสแต็กเปล่า) ค่อนข้างมากตลอดไปเนื่องจากมีเส้นล้อมรอบ

JS

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

ฟังก์ชั่นสนุก!

ฟังก์ชั่นที่สร้างฟังก์ชั่นอื่นโดยมีเนื้อความเดียวกันกับตัวมันเองจากนั้นเรียกใช้งาน

มันจะแสดง hi เมื่อสิ้นสุดเมื่อถึงขีด จำกัด ของ stack และสิ่งทั้งหมดยุบ

คำเตือน: คุณจะไม่สามารถทำอะไรในเบราว์เซอร์ของคุณจนกว่าจะถึงขีด จำกัด ของสแต็ก

และอีกหนึ่งความชั่วร้ายที่มากขึ้น:

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

มันสร้างฟังก์ชั่นที่เปิดหน้าต่างจากนั้นสร้างฟังก์ชั่นภายในหน้าต่างนั้นซึ่งเป็นสำเนาของฟังก์ชั่นแล้วเรียกใช้มัน

ข้อจำกัดความรับผิดชอบ: หากคุณอนุญาตให้เปิดป๊อปอัปวิธีเดียวที่จะเสร็จสิ้นคือการรีสตาร์ทคอมพิวเตอร์ของคุณ

x86 ชุดประกอบ / DOS

    org 100h

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

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

ฉันไม่ได้บอกว่าไม่มีการเรียกซ้ำหางย้อนกลับหรือไม่? ใช่ฉัน

มันทำงานอย่างไร

retการเรียนการสอนที่ใช้ในการกลับมาจากการทำงานจริงปรากฏอยู่กลับมาจากสแต็ค (ซึ่งปกติจะใส่โดยมีที่สอดคล้องกันcall) และกระโดดไป ที่นี่ในการวนซ้ำแต่ละครั้งเราจะpushระบุที่อยู่จุดเริ่มต้นบนสแต็กก่อนส่งคืนดังนั้นจึงสร้างการวนซ้ำไม่สิ้นสุด

ชวา

ส่งตรงจาก XKCD

มันเป็นเกมที่ไม่มีที่สิ้นสุดที่จับกันระหว่างพ่อแม่กับลูก!

เป้าหมายของการCHILDมีการตั้งค่าPARENTและเป้าหมายของการเป็นPARENT CHILDเมื่อมีการPARENTเรียกAIMมันจะส่งอินสแตนซ์ของBALLคลาสและถูกดักจับโดยคำสั่ง catch คำสั่งจับแล้วโทรที่เป้าหมายคือPARENT.TARGET.AIM เช่นไม่เหมือนกันและ "โยนลูกกลับ" เพื่อแม่CHILDCHILD

Bash, 3 ตัวอักษร

yes

ใช่จะส่งคืน 'y' ไปยังคอนโซลเป็นประจำ

แก้ไข: ทุกคนได้รับการสนับสนุนให้แก้ไขบรรทัดนี้:

yes something | xargs someaction

(ขอบคุณ Olivier Dulac)

C, 35 ตัวอักษร

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

โปรแกรมดำเนินการเอง ฉันไม่แน่ใจว่านี่เป็นการพิจารณาการเรียกซ้ำหรือไม่

C (กับ GCC builtins - ดูเหมือนว่าจะทำงานกับเสียงดังกราว)

• ไม่มีลูปอย่างชัดเจน
• ไม่มี gotos ชัดเจน
• ไม่มีการเรียกซ้ำ
• แค่เล่นกับสแต็คเก่า ๆ (เด็ก ๆ อย่าลองทำที่บ้านโดยไม่มีผู้ดูแล):

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

คำอธิบาย:

• main()frameloop(NULL)สายแรก ในกรณีนี้ใช้__builtin_return_address()builtin เพื่อรับที่อยู่ผู้ส่ง (ในmain()) ที่frameloop()จะกลับไป เราส่งคืนที่อยู่นี้
• printf() เพื่อแสดงว่าเรากำลังวนซ้ำ
• ตอนนี้เราโทรหาframeloop()ด้วยที่อยู่ผู้ส่งสำหรับการโทรก่อนหน้า เราดูสแต็กสำหรับที่อยู่ผู้ส่งคืนปัจจุบันและเมื่อเราพบเราจะแทนที่ที่อยู่ผู้ส่งก่อนหน้านี้
• จากนั้นเรากลับจากการframeloop()โทรครั้งที่สอง แต่เนื่องจากที่อยู่ผู้ส่งถูกแฮ็กข้างต้นเราจึงกลับไปที่จุดmain()ที่การโทรครั้งแรกควรกลับไป ดังนั้นเราจบลงในวง

การค้นหาที่อยู่ผู้ส่งคืนในสแต็คแน่นอนว่าจะสะอาดกว่าแบบวนซ้ำ แต่ฉันไม่ได้ลงทะเบียนซ้ำเพื่อดูว่าไม่มีการวนซ้ำใด ๆ

เอาท์พุท:

$ 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

รหัสต่อไปนี้ไม่มีฟังก์ชั่นวนซ้ำ (แม้แต่ทางอ้อม) ไม่มีการวนซ้ำแบบดั้งเดิมและไม่เรียกใช้ฟังก์ชันการเรียกซ้ำแบบใด ๆ ในตัว (ใช้เฉพาะIOเอาต์พุตและการรวมเท่านั้น)

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

ฟังก์ชั่นextractไม่เรียกอะไรycเรียกเพียงextractและmainเรียกร้องเพียงycและputStrLnและ>>ที่ไม่ได้เรียกซ้ำ

คำอธิบาย:Strangeเคล็ดลับคือในชนิดข้อมูล recursive เป็นชนิดข้อมูลแบบเรียกซ้ำที่ใช้เองซึ่งดังที่แสดงในตัวอย่างอนุญาตการทำซ้ำโดยพลการ อันดับแรกเราสามารถสร้างextract xได้ซึ่งเป็นการแสดงออกถึงการประยุกต์ใช้ด้วยตนเองx xในแคลคูลัสแลมบ์ดาที่ไม่ได้พิมพ์ออกมา และสิ่งนี้จะช่วยให้การสร้างCombinator วายλf.(λx.f(xx))(λx.f(xx))กำหนดให้เป็น

อัปเดต:ตามที่แนะนำฉันกำลังโพสต์ชุดตัวเลือกที่ใกล้เคียงกับคำนิยามของYในแคลคูลัสแลมบ์ดาที่ไม่ได้พิมพ์มากขึ้น:

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

ผลลัพธ์ต่อไปนี้นับถอยหลังจาก 10 ถึง "Blast off!" ใช้ metaprogramming แม่แบบ

#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;
}

มันอาจดูเหมือนเป็นตัวอย่างคลาสสิกของการเรียกซ้ำ แต่อย่างน้อยในทางเทคนิคก็ไม่ได้ขึ้นอยู่กับคำนิยามของคุณ คอมไพเลอร์จะสร้างสิบฟังก์ชั่นที่แตกต่างกัน countdown<10>พิมพ์ "T ลบ 10" จากนั้นโทรcountdown<9>และอื่น ๆ ลงไปcountdown<0>ซึ่งพิมพ์ "Blast off!" แล้วส่งคืน การเรียกซ้ำเกิดขึ้นเมื่อคุณคอมไพล์รหัส แต่การปฏิบัติการไม่มีโครงสร้างวนลูปใด ๆ

ใน C ++ 11 เราสามารถใช้เอฟเฟกต์ที่คล้ายกันโดยใช้constexprคำสำคัญเช่นฟังก์ชันแฟคทอเรียล (เป็นไปไม่ได้ที่จะใช้ตัวอย่างการนับถอยหลังด้วยวิธีนี้เนื่องจากconstexprฟังก์ชั่นไม่สามารถมีผลข้างเคียง แต่ฉันคิดว่ามันอาจเป็นไปได้ใน C ++ 14 ที่กำลังจะมาถึง)

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

อีกครั้งนี้ดูเหมือนว่าการเรียกซ้ำ แต่คอมไพเลอร์จะขยายออกfactorial(10)ไป10*9*8*7*6*5*4*3*2*1แล้วอาจแทนที่ด้วยค่าคงที่3628800ดังนั้นปฏิบัติการจะไม่มีรหัสวนซ้ำหรือเรียกซ้ำ

ชวา

มาเล่นกับ Java class loader และตั้งเป็น parent ของมัน:

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());

    }
}

วงนี้จริง ๆ แล้วคุณจะต้องใช้ a kill -9เพื่อหยุดมัน :-)

มันใช้ CPU ของ Mac ของฉันได้ 100,1%

คุณสามารถลองย้ายส่วนSystem.outท้ายของฟังก์ชั่นหลักเพื่อทดลองพฤติกรรมตลก ๆ

CSharp

อีกคนหนึ่งที่ชั่วร้ายและเท่าเทียมกัน ::

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

นี่ไม่ใช่การเรียกซ้ำ ... นี่เป็นการยืนยันเทมเพลตของรหัส ในขณะที่เรากำลังเรียกใช้วิธีการเดียวกัน แต่รันไทม์กำลังสร้างวิธีการใหม่อยู่ตลอดเวลา เราใช้พารามิเตอร์ type ของ int เนื่องจากจริง ๆ แล้วมันบังคับให้สร้างชนิดใหม่ทั้งหมดและแต่ละอินสแตนซ์ของเมธอดต้อง jit วิธีการใหม่ ไม่สามารถแบ่งปันรหัสได้ที่นี่ ในที่สุดเราจะฆ่า call stack เพราะจะรอการส่งคืน int ที่เราสัญญาไว้ แต่ไม่เคยส่งมอบ ในแบบเดียวกันเราเขียนแบบที่เราสร้างขึ้นเพื่อให้มันน่าสนใจ โดยทั่วไป C แต่ละตัวที่เราเรียกว่าเป็นวิธีการใหม่ที่น่าสนใจซึ่งมีรูปร่างเหมือนกัน นี่เป็นไปไม่ได้ในภาษาอย่าง C ++ หรือ D ที่ทำเทมเพลตในเวลารวบรวม เนื่องจาก C # JIT นั้นขี้เกียจสุด ๆ มันจะสร้างสิ่งนี้ในช่วงเวลาที่เป็นไปได้สุดท้ายเท่านั้น ดังนั้น,

Redcode 94 (สงครามแกน)

MOV 0, 1

คัดลอกคำสั่งที่ศูนย์ที่อยู่ไปยังที่อยู่หนึ่ง เนื่องจากใน Core War ที่อยู่ทั้งหมดสัมพันธ์กับที่อยู่พีซีปัจจุบันและโมดูโลขนาดของแกนนี่เป็นลูปที่ไม่มีที่สิ้นสุดในหนึ่งคำสั่งไม่กระโดด

โปรแกรมนี้ (นักรบ) เรียกว่า " Imp " และเผยแพร่ครั้งแรกโดย AK Dewdney

โผ

ฉันเดาว่านี่จะเป็นวิธีคลาสสิคในการเรียกซ้ำโดยไม่มีฟังก์ชันเวียนเกิดขึ้นจริง ไม่มีฟังก์ชั่นด้านล่างอ้างถึงตัวเองโดยใช้ชื่อโดยตรงหรือโดยอ้อม

(ลองที่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;
  });
}

JS

ไม่ได้ต้นฉบับมาก แต่เล็ก 20 ตัวอักษร

setInterval(alert,1)

สัญญาณใน C

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

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

เห็นได้ชัดว่าพฤติกรรมของโปรแกรมนี้มีความชัดเจนมาก แต่วันนี้บนคอมพิวเตอร์ของฉันมันยังคงพิมพ์ "Hello, world!"

Emacs Lisp

นี่เป็นเวลาที่ยอดเยี่ยมในการแสดงการออกแบบที่ทรงพลังของ Lisp โดยที่ "รหัสคือข้อมูลและข้อมูลคือรหัส" จริงอยู่ที่ตัวอย่างเหล่านี้ไม่มีประสิทธิภาพมากและไม่ควรใช้ในบริบทจริง

แมโครสร้างรหัสที่เป็นรุ่นที่ไม่ได้ควบคุมของวนซ้ำที่ควรได้รับและรหัสที่สร้างขึ้นนั้นเป็นสิ่งที่ถูกประเมินที่รันไทม์

เล่นซ้ำ: ให้คุณวนซ้ำ 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))))

ทดสอบซ้ำ:

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

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

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

ซ้ำมันมีดัชนี:

มาโครนี้มีลักษณะเหมือนกันrepeat-itแต่ใช้งานได้จริงเช่นเดียวกับมาโครลูปทั่วไปซึ่งdo-timesอนุญาตให้คุณระบุสัญลักษณ์ที่จะถูกผูกไว้กับดัชนีลูป มันใช้สัญลักษณ์เวลาการขยายเพื่อให้แน่ใจว่าตัวแปรดัชนีถูกตั้งค่าอย่างถูกต้องที่จุดเริ่มต้นของแต่ละวงไม่ว่าคุณจะปรับเปลี่ยนค่าของมันหรือไม่ระหว่างการวนรอบร่างกาย

(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)))))))

ทดสอบซ้ำพร้อมดัชนี:

การทดสอบนี้แสดงให้เห็นว่า:

1. ร่างกายประเมิน N ครั้ง

2. ตัวแปรดัชนีจะถูกตั้งค่าอย่างถูกต้องที่จุดเริ่มต้นของแต่ละการวนซ้ำ

3. การเปลี่ยนค่าของสัญลักษณ์ชื่อ "fallback" จะไม่ทำให้ยุ่งเหยิงกับดัชนี

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

แคลคูลัสแลมบ์ดาที่ยังไม่พิมพ์

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

Haskell, 24 ตัวอักษร

sequence_ (repeat (print "abc"))

หรือในรูปแบบย่อมี 24 ตัวอักษร

sequence_$repeat$print"" 

(แม้ว่าข้อความจะเปลี่ยนแปลง แต่จะยังคงวนซ้ำ - จะพิมพ์เครื่องหมายคำพูดสองบรรทัดและขึ้นบรรทัดใหม่ไม่สิ้นสุด)

คำอธิบาย: พิมพ์ "abc" นั้นเป็นการกระทำของ i / o ที่เพิ่งพิมพ์ "abc"
ซ้ำเป็นฟังก์ชั่นที่ใช้ค่า x และส่งกลับรายการที่ไม่มีที่สิ้นสุดที่ทำจาก x เท่านั้น
sequence_ เป็นฟังก์ชั่นที่รับรายการของแอ็คชั่น i / o และส่งคืนแอ็คชัน i / o ที่ดำเนินการทั้งหมดตามลำดับ

ดังนั้นโดยทั่วไปโปรแกรมนี้จะสร้างรายการคำสั่ง "abc" ที่ไม่มีที่สิ้นสุดและดำเนินการคำสั่งเหล่านั้นซ้ำ ๆ ไม่มีลูปหรือเรียกซ้ำ

ASM (x86 + I / O สำหรับ Linux)

ไม่สำคัญว่าภาษาระดับสูงที่อ่อนแอของคุณจะต้องดิ้นรนเพียงใดมันจะยังคงเป็นเพียงการชี้แนะที่ซ่อนอยู่ ในท้ายที่สุดมันจะเป็น "goto" (jmp) เว้นแต่คุณจะรู้สึกเบื่อที่จะเปิดลูปใน runtime

คุณสามารถทดสอบโค้ดบนIdeone

นอกจากนี้คุณยังสามารถตรวจสอบรุ่นกลั่นมากขึ้นของความคิดนี้ในรหัสมัตเตโอเลีย DOS

มันเริ่มต้นด้วยสตริง 0..9 และแทนที่ด้วย A..J ไม่มีการใช้การกระโดดโดยตรง (ดังนั้นสมมติว่าไม่มีการ "ข้าม" เกิดขึ้น) ไม่เกิดขึ้นอีก

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

ส่วนหลัก:

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

รหัสทั้งหมด

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

"เทคนิค" เล็ก ๆ น้อย ๆ ที่ฉันคิดขึ้นมาในระหว่างการท้าทายที่ทำให้งงงวย ไม่มีการเรียกใช้ฟังก์ชันซ้ำ แต่มี ... การเรียกใช้ไฟล์ซ้ำ

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

ฉันเขียน / ทดสอบโดยใช้ gcc เห็นได้ชัดว่าคอมไพเลอร์ของคุณจำเป็นต้องสนับสนุน__INCLUDE_LEVEL__แมโคร (หรืออีกทางหนึ่งคือ__COUNTER__มาโครที่มีการปรับแต่ง) เพื่อให้สามารถคอมไพล์ได้ มันควรจะชัดเจนว่ามันใช้งานอย่างไร แต่เพื่อความสนุกให้รันตัวประมวลผลล่วงหน้าโดยไม่ต้องคอมไพล์โค้ด (ใช้-Eแฟล็กกับ gcc)

PHP

นี่คือหนึ่งเดียวกับ PHP วนซ้ำโดยรวมไฟล์เดียวกันจนกว่าตัวนับจะถึง $ สูงสุด:

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

เช่นเดียวกับ for-loop:

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

หลาม

รหัสต่อไปนี้ไม่มีฟังก์ชั่นวนซ้ำ (โดยตรงหรือโดยอ้อม) ไม่มีการวนซ้ำดั้งเดิมและไม่เรียกใช้ฟังก์ชันในตัว (ยกเว้น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)

พิมพ์ "Hello world!" จำนวนครั้งที่กำหนด

คำอธิบาย:ฟังก์ชั่นzใช้combinator จุดคงที่Zอย่างเข้มงวดซึ่ง (ในขณะที่ไม่ได้กำหนดซ้ำ) อนุญาตให้แสดงอัลกอริทึมแบบเรียกซ้ำ

รหัสเครื่อง z80

ในสภาพแวดล้อมที่คุณสามารถดำเนินการได้ทุกที่อยู่และแผนที่ ROM ทุกหนทุกแห่งแผนที่ 64kb ของ ROM ที่เต็มไปด้วยศูนย์ถึงพื้นที่ที่อยู่ทั้งหมด

มันทำอะไร: ไม่มีอะไร ซ้ำแล้วซ้ำเล่า

วิธีการทำงาน: โปรเซสเซอร์จะเริ่มดำเนินการไบต์00เป็นnopคำสั่งดังนั้นมันจะดำเนินการต่อไปถึงที่อยู่$ffffห่อรอบ$0000และดำเนินการnopต่อจนกว่าคุณจะรีเซ็ต

เพื่อให้น่าสนใจขึ้นเล็กน้อยเติมหน่วยความจำด้วยค่าอื่น ๆ (ระวังเพื่อหลีกเลี่ยงคำสั่งโฟลว์ควบคุม)

Perl-regex

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

การสาธิต

หรือลองเป็น:

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

(?!)ไม่ตรงกับ ดังนั้นโปรแกรม regex พยายามจับคู่ตำแหน่งความกว้างศูนย์แต่ละอันในสตริงที่ตรงกัน

(q x x x 10)เป็นเช่นเดียวกับ(" " x 10)- ทำซ้ำspaceสิบครั้ง

แก้ไข: เปลี่ยน "อักขระ" เป็นตำแหน่งความกว้างศูนย์เพื่อให้แม่นยำยิ่งขึ้นเพื่อความเข้าใจที่ดีขึ้น ดูคำตอบสำหรับคำถาม stackoverflowนี้

T-SQL -12

print 1
GO 9

ที่จริงแล้วสิ่งที่แปลกมากของ Studio Management Server ของ SQL GO เป็นตัวคั่นสคริปต์และไม่ได้เป็นส่วนหนึ่งของภาษา T-SQL หากคุณระบุ GO ตามด้วยหมายเลขมันจะดำเนินการบล็อกนั้นหลายครั้ง

C #

พิมพ์จำนวนเต็มทั้งหมดจาก uint.MaxValue เป็น 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 (ในเบราว์เซอร์)

แล้วเรื่องนี้ล่ะ

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

พิมพ์เวลาปัจจุบันและโหลดหน้าซ้ำ