Sebuah pertanyaan yang mirip dengan ini telah diajukan beberapa tahun yang lalu , tetapi yang ini lebih rumit.

Tantangannya sederhana. Menulis sebuah program (dalam bahasa pilihan Anda) yang berulang kali mengeksekusi kode tanpa menggunakan struktur pengulangan seperti while, for, do while, foreachatau goto( Jadi untuk semua nitpickers Anda, Anda tidak dapat menggunakan loop ). Namun, rekursi tidak diperbolehkan, dalam fungsi yang menamakan dirinya sendiri (lihat definisi di bawah) . Itu akan membuat tantangan ini terlalu mudah.

Tidak ada batasan pada apa yang perlu dieksekusi dalam loop, tetapi posting penjelasan dengan jawaban Anda sehingga orang lain dapat memahami dengan tepat apa yang sedang dilaksanakan.

Bagi mereka yang mungkin terpaku pada definisi, definisi loop untuk pertanyaan ini adalah:

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

Dan definisi rekursi untuk pertanyaan ini akan menjadi definisi fungsi rekursif standar Anda:

A function that calls itself.

Pemenang akan menjadi jawaban yang paling banyak mendapat dukungan pada 16 Juli pukul 10 pagi waktu bagian timur. Semoga berhasil!

MEMPERBARUI:

Untuk menenangkan kebingungan yang masih diungkapkan ini dapat membantu:

Aturan sebagaimana dinyatakan di atas:

• Jangan gunakan loop atau goto
• Fungsi tidak bisa menyebut diri mereka sendiri
• Lakukan apa pun yang Anda inginkan di 'lingkaran'

Jika Anda ingin menerapkan sesuatu dan aturannya tidak secara eksplisit melarangnya, silakan dan lakukan. Banyak jawaban sudah melanggar aturan.

Rubi

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

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

ahem

Demo

Bersihkan tenggorokannya, mencetak "Pisang" 3070 kali, dan juga menempatkan "Oranye, kau senang aku tidak mengatakan pisang?".

Ini menggunakan fungsi definisi metode just-in-time yang konyol dari Ruby untuk mendefinisikan setiap metode yang secara alfabetis terletak antara kata 'ahem' dan 'juga' ("ahem", "ahen", "aheo", "ahep", "ahep", "aheq", "aher", "ahes", "ahet", "aheu", "ahev" ...) untuk pertama-tama mencetak Pisang dan kemudian memanggil yang berikutnya dalam daftar.

Python - 16

atau bahasa lain dengan eval.

exec"print 1;"*9

CSharp

Saya telah memperluas kode menjadi cara yang lebih mudah dibaca karena ini bukan lagi kode golf dan menambahkan penghitung kenaikan sehingga orang dapat benar-benar melihat bahwa program ini melakukan sesuatu.

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

(Jangan pernah melakukan ini).

Pada awal kita membuat instance baru dari Pkelas, yang ketika program mencoba untuk keluar memanggil GC yang memanggil finalizer yang membuat instance baru Pkelas, yang ketika mencoba untuk membersihkan menciptakan baru Pyang memanggil finalizer .. .

Program akhirnya mati.

Sunting: Secara misterius ini hanya berjalan sekitar 45 ribu kali sebelum mati. Saya tidak tahu bagaimana GC menemukan loop tak terbatas saya yang rumit tapi ternyata berhasil. Singkatnya sepertinya tidak mengetahuinya dan utas baru saja terbunuh setelah sekitar 2 detik eksekusi: https://stackoverflow.com/questions/24662454/how-does-a-garbage-collector-avoid-an -infinite-loop-sini

Sunting2: Jika Anda pikir ini agak terlalu mirip rekursi pertimbangkan solusi saya yang lain: https://codegolf.stackexchange.com/a/33268/23300

Ini menggunakan reifikasi metode generik sehingga pada saat runtime itu terus-menerus menghasilkan metode baru dan masing-masing metode dalam istilah panggilan metode yang baru dicetak. Saya juga menghindari menggunakan referenceparameter tipe, karena biasanya runtime dapat membagikan kode untuk metode tersebut. Dengan valueparameter tipe, runtime dipaksa untuk membuat metode baru.

Dibalik

.

Befunge tua yang baik menghasilkan 0 (dari tumpukan kosong) cukup lama, karena garis membungkus.

JS

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

Berfungsi menyenangkan!

Fungsi yang membuat fungsi lain dengan tubuh yang sama dengan dirinya sendiri dan kemudian menjalankannya.

Ini akan menampilkan hi di akhir ketika batas stack tercapai dan semuanya runtuh.

Penafian: Anda tidak akan dapat melakukan apa pun di browser Anda sampai batas tumpukan tercapai.

Dan satu lagi, lebih jahat :

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

Itu menciptakan fungsi yang membuka jendela, lalu menciptakan fungsi di dalam jendela itu yang merupakan salinan dari fungsi, dan kemudian menjalankannya.

Penafian: jika Anda mengizinkan popup dibuka, satu-satunya cara untuk menyelesaikannya adalah dengan memulai ulang komputer Anda

x86 assembly / DOS

    org 100h

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

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

Apakah saya mengatakan tidak ada rekursi ekor terbalik ? Benarkah saya?

Bagaimana itu bekerja

The retinstruksi, digunakan untuk kembali dari fungsi, sebenarnya muncul alamat pengirim dari tumpukan (yang biasanya diletakkan di sana oleh yang sesuai call) dan melompat untuk itu. Di sini, di setiap iterasi kami pushalamat entrypoint pada stack sebelum kembali, sehingga menghasilkan loop tak terbatas.

Jawa

Langsung dari XKCD

Ini adalah permainan tangkapan tanpa akhir antara orangtua dan anak!

Target CHILDdiatur ke PARENTdan target PARENTadalah CHILD. Ketika PARENTpanggilan AIM, itu melempar instance dari BALLkelas dan itu ditangkap oleh pernyataan tangkapan. Pernyataan tangkapan kemudian memanggil di PARENT.TARGET.AIMmana targetnya adalah CHILD. Mesin CHILDvirtual melakukan hal yang sama dan "melempar bola kembali" ke induk.

Bash, 3 karakter

yes

ya akan berulang kali mengembalikan 'y' ke konsol

Sunting: Semua orang didorong untuk mengedit baris ini:

yes something | xargs someaction

(terima kasih kepada Olivier Dulac)

C, 35 karakter

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

Program mengeksekusi sendiri. Saya tidak yakin apakah ini dianggap rekursi atau tidak.

C (dengan GCC bawaan - juga tampaknya bekerja dengan dentang)

• Tidak ada loop eksplisit
• Tidak ada foto eksplisit
• Tidak ada rekursi
• Hanya cara kuno yang baik-baik saja dengan tumpukan (anak-anak, jangan coba ini di rumah tanpa pengawasan):

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

Penjelasan:

• main()panggilan pertama frameloop(NULL). Dalam hal ini gunakan __builtin_return_address()builtin untuk mendapatkan alamat pengirim main()yang frameloop()akan kembali ke. Kami mengembalikan alamat ini.
• printf() untuk menunjukkan kita mengulang
• sekarang kita panggil frameloop()dengan alamat pengirim untuk panggilan sebelumnya. Kami melihat melalui tumpukan untuk alamat pengirim saat ini, dan ketika kami menemukannya, kami mengganti alamat pengirim sebelumnya.
• Kami kemudian kembali dari frameloop()panggilan ke-2 . Tetapi karena alamat pengirim diretas di atas, kami akhirnya kembali ke titik di main()mana panggilan pertama harus kembali. Jadi kita berakhir dalam satu lingkaran.

Pencarian untuk alamat pengirim di stack tentu saja akan lebih bersih sebagai sebuah loop, tapi saya membuka beberapa iterasi demi tidak mengulangi apa pun.

Keluaran:

$ 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

Kode berikut ini tidak mengandung fungsi rekursif (bahkan secara tidak langsung), tidak ada pengulangan primitif dan tidak memanggil fungsi rekursifIO bawaan (hanya menggunakan keluaran dan pengikatan), namun kode ini mengulangi tindakan yang diberikan secara pasti:

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

Fungsi extracttidak memanggil apa pun, ycpanggilan adil extractdan mainpanggilan adil ycdan putStrLndan >>, yang tidak berulang.

Penjelasan: Caranya adalah pada tipe data rekursif Strange. Ini adalah tipe data rekursif yang mengkonsumsi sendiri, yang, seperti yang ditunjukkan dalam contoh, memungkinkan pengulangan sewenang-wenang. Pertama, kita dapat membangun extract x, yang pada dasarnya mengekspresikan penerapan diri x xdalam kalkulus lambda yang tidak diketik. Dan ini memungkinkan untuk membangun kombinator Y yang didefinisikan sebagai λf.(λx.f(xx))(λx.f(xx)).

Pembaruan: Seperti yang disarankan, saya memposting varian yang lebih dekat dengan definisi Y dalam kalkulus lambda yang tidak diketik:

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

Berikut ini menampilkan hitungan mundur dari 10 ke "Blast off!" menggunakan metaprogramming template.

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

Ini mungkin terlihat seperti contoh klasik rekursi, tetapi sebenarnya tidak, setidaknya secara teknis, tergantung pada definisi Anda. Kompiler akan menghasilkan sepuluh fungsi berbeda . countdown<10>mencetak "T minus 10" dan kemudian memanggil countdown<9>, dan seterusnya ke countdown<0>, yang mencetak "Lepaskan!" dan kemudian kembali. Rekursi terjadi ketika Anda mengkompilasi kode, tetapi executable tidak mengandung struktur pengulangan.

Dalam C ++ 11 orang dapat mencapai efek yang sama menggunakan constexprkata kunci, seperti fungsi faktorial ini. (Ini tidak mungkin untuk menerapkan contoh hitung mundur dengan cara ini, karena constexprfungsi tidak dapat memiliki efek samping, tapi saya pikir itu mungkin terjadi di C ++ 14 mendatang.)

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

Sekali lagi ini benar-benar tampak seperti rekursi, tetapi kompiler akan berkembang factorial(10)menjadi 10*9*8*7*6*5*4*3*2*1, dan kemudian mungkin menggantinya dengan nilai konstan 3628800, sehingga executable tidak akan berisi kode perulangan atau rekursif.

Jawa

Mari bermain dengan pemuat kelas Java dan atur sebagai induknya sendiri:

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

    }
}

Loop ini sebenarnya sangat kuat sehingga Anda harus menggunakan kill -9untuk menghentikannya :-)

Ini menggunakan 100,1% dari CPU Mac saya.

Anda dapat mencoba untuk memindahkan System.outdi akhir fungsi utama untuk bereksperimen perilaku lucu alternatif.

CSharp

Satu lagi yang sama jahatnya ::

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

Ini bukan rekursi ... ini adalah reifikasi templat kode. Meskipun tampaknya kami memanggil metode yang sama, runtime terus-menerus membuat metode baru. Kami menggunakan tipe parameter int, karena ini benar-benar memaksanya untuk membuat seluruh tipe baru dan setiap instance dari metode harus membuang metode baru. Tidak dapat memberi kode berbagi di sini. Akhirnya, kami membunuh tumpukan panggilan karena menunggu kembalinya int yang kami janjikan tetapi tidak pernah dikirimkan. Dengan cara yang sama, kami terus menulis jenis yang kami buat agar tetap menarik. Pada dasarnya setiap C yang kita panggil adalah metode baru yang benar-benar baru yang hanya memiliki tubuh yang sama. Ini tidak benar-benar mungkin dalam bahasa seperti C ++ atau D yang melakukan templat mereka pada waktu kompilasi. Karena, C # JIT sangat malas, itu hanya menciptakan hal-hal ini pada saat-saat terakhir. Jadi,

Redcode 94 (Perang Inti)

MOV 0, 1

Salinan instruksi di alamat nol ke alamat satu. Karena dalam Core War semua alamat relatif terhadap alamat PC saat ini dan memodul ukuran inti, ini adalah loop tak terbatas dalam satu instruksi, non-lompat.

Program ini (prajurit) disebut " Imp " dan pertama kali diterbitkan oleh AK Dewdney.

Anak panah

Saya kira ini akan menjadi cara klasik untuk melakukan rekursi tanpa fungsi rekursif yang sebenarnya. Tidak ada fungsi di bawah ini mengacu pada namanya sendiri, secara langsung atau tidak langsung.

(Cobalah di 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

Tidak sangat asli tetapi kecil. 20 karakter.

setInterval(alert,1)

Sinyal dalam C

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

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

Perilaku program ini jelas sangat tidak terdefinisi, tetapi hari ini, di komputer saya, ia terus mencetak "Halo, dunia!".

Emacs Lisp

Ini adalah waktu yang tepat untuk memamerkan desain Lisp yang kuat di mana "kode adalah data dan data adalah kode". Memang, contoh-contoh ini sangat tidak efisien dan ini tidak boleh digunakan dalam konteks nyata.

Makro menghasilkan kode yang merupakan versi tidak terbaca dari loop yang seharusnya dan kode yang dihasilkan adalah apa yang dievaluasi saat runtime.

repeat-it: memungkinkan Anda untuk mengulang N kali

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

tes pengulangan:

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

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

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

ulangi dengan indeks:

Makro ini seperti repeat-ittetapi sebenarnya berfungsi seperti makro perulangan umum, do-timesini memungkinkan Anda menentukan simbol yang akan terikat pada indeks lingkaran. Ini menggunakan simbol waktu ekspansi untuk memastikan bahwa variabel indeks diatur dengan benar di awal setiap loop terlepas dari apakah Anda memodifikasi nilainya selama tubuh loop.

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

tes pengulangan-dengan-indeks:

Tes ini menunjukkan bahwa:

1. Tubuh mengevaluasi N kali

2. variabel indeks selalu diatur dengan benar di awal setiap iterasi

3. mengubah nilai simbol bernama "fallback" tidak akan mengacaukan indeks

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

Kalkulus lambda yang tidak diketik

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

Haskell, 24 karakter

sequence_ (repeat (print "abc"))

atau dalam bentuk kental, dengan 24 karakter

sequence_$repeat$print"" 

(walaupun teksnya diubah, ini masih akan berulang - ini akan mencetak dua tanda kutip dan baris baru tanpa batas)

PENJELASAN: mencetak "abc" pada dasarnya adalah tindakan i / o yang hanya mencetak "abc".
repeat adalah fungsi yang mengambil nilai x dan mengembalikan daftar tak terbatas yang hanya terbuat dari x.
sequence_ adalah fungsi yang mengambil daftar tindakan i / o dan mengembalikan tindakan i / o yang melakukan semua tindakan secara berurutan.

jadi, pada dasarnya, program ini membuat daftar perintah "abc" cetak yang tak terbatas, dan berulang kali mengeksekusinya. tanpa loop atau rekursi.

ASM (x86 + I / O untuk Linux)

Tidak peduli berapa banyak bahasa tingkat rendah Anda akan berjuang, itu masih akan menjadi manipulasi pointer instruksi tersembunyi. Pada akhirnya itu akan menjadi semacam "goto" (jmp), kecuali jika Anda cukup bosan untuk membuka gulungan di runtime.

Anda dapat menguji kode pada Ideone

Anda juga dapat melihat versi yang lebih baik dari ide ini dalam kode DOS Matteo Italia .

Itu dimulai dengan string 0..9 dan menggantinya dengan A..J, tidak ada lompatan langsung yang digunakan (jadi katakanlah tidak ada "goto" terjadi), tidak ada pengulangan juga.

Kode mungkin bisa lebih kecil dengan beberapa penyalahgunaan perhitungan alamat, tetapi mengerjakan kompiler online itu menyusahkan jadi saya akan membiarkannya apa adanya.

Bagian inti:

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

Seluruh kode

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 Preprocessor

Sedikit "teknik" yang saya buat selama tantangan kebingungan. Tidak ada rekursi fungsi, tetapi ada ... rekursi file?

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

Saya menulis / menguji ini menggunakan gcc. Jelas kompiler Anda perlu mendukung __INCLUDE_LEVEL__makro (atau alternatifnya __COUNTER__makro dengan beberapa penyesuaian) agar dapat dikompilasi. Seharusnya cukup jelas bagaimana ini bekerja, tetapi untuk bersenang-senang, jalankan preprocessor tanpa mengkompilasi kode (gunakan -Ebendera dengan gcc).

PHP

Inilah satu dengan PHP. Loop dengan memasukkan file yang sama hingga penghitung mencapai $ maks:

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

Sama seperti for-loop:

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

Python

Kode berikut tidak mengandung fungsi rekursif (langsung atau tidak langsung), tidak ada perulangan primitif dan tidak memanggil fungsi bawaan apa pun (kecuali 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)

Cetakan "Halo dunia!" beberapa kali.

Penjelasan: Fungsi zmengimplementasikan combinator titik tetap Z yang ketat , yang (walaupun tidak didefinisikan secara rekursif) memungkinkan untuk mengekspresikan algoritma rekursif apa pun.

kode mesin z80

Dalam lingkungan di mana Anda dapat mengeksekusi di setiap alamat dan memetakan ROM di mana-mana, peta 64kb ROM diisi dengan nol ke seluruh ruang alamat.

Apa yang dilakukannya: tidak ada. Berkali-kali.

Cara kerjanya: prosesor akan mulai mengeksekusi, byte 00adalah nopinstruksi, jadi itu hanya akan melanjutkan, mencapai alamat $ffff, membungkus sekitar $0000, dan terus mengeksekusi nopsampai Anda meresetnya.

Untuk membuatnya sedikit lebih menarik, isi memori dengan nilai lain (hati-hati untuk menghindari instruksi aliran kontrol).

Perl-regex

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

demo

atau coba sebagai:

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

Yang (?!)tidak pernah cocok. Jadi mesin regex mencoba untuk mencocokkan setiap posisi lebar nol dalam string yang cocok.

Yang (q x x x 10)sama (" " x 10)- ulangi spacesepuluh kali.

Sunting: mengubah "karakter" ke posisi nol lebar menjadi lebih tepat agar lebih mudah dipahami. Lihat jawaban untuk pertanyaan stackoverflow ini .

T-SQL -12

print 1
GO 9

Sebenarnya lebih merupakan kekhasan dari Sql Server Management Studio. GO adalah pemisah skrip dan bukan bagian dari bahasa T-SQL. Jika Anda menentukan GO diikuti oleh angka itu akan mengeksekusi blok yang berkali-kali.

C #

Mencetak semua bilangan bulat dari uint.MaxValue ke 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 (di browser)

Bagaimana dengan ini?

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

Mencetak waktu saat ini dan memuat kembali halaman.