Buna benzer bir soru birkaç yıl önce soruldu , ancak bu daha zorlu.

Zor olan basittir. Defalarca gibi herhangi tekrarlama yapıları kullanmadan kod çalıştırır (seçtiğiniz dilde) bir program yazın while, for, do while, foreachveya goto( tüm nitpickers için Yani, bir döngü kullanamazsınız ). Ancak, tekrar eden fonksiyona, kendi kendine çağrı işlevinde izin verilmez (aşağıdaki tanıma bakınız) . Bu, bu zorluğu çok kolaylaştıracaktır.

Döngüde nelerin yapılması gerektiğine dair bir kısıtlama yoktur, ancak cevabınızla ilgili bir açıklama yapın, böylece başkalarının tam olarak neyin uygulandığını anlayabilmesini sağlayabilirsiniz.

Tanımlara asılabilir olanlar için, bu soru için bir döngü tanımı şöyledir:

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

Ve bu soru için özyinelemenin tanımı, standart özyinelemeli işlev tanımınız olacaktır:

A function that calls itself.

Kazanan, 16 Temmuz günü saat 10.00’da Doğu’da en fazla oyu alan cevap olacak. İyi şanslar!

GÜNCELLEME:

Hala ifade edilmekte olan karışıklığı sakinleştirmek yardımcı olabilir:

Yukarıda belirtilen kurallar:

• Döngü veya goto kullanmayın
• İşlevler kendilerini arayamaz
• 'Döngüde' ne istersen yap

Bir şeyi uygulamak istiyorsan ve kurallar açıkça yasaklamıyorsa, devam et ve yap. Pek çok cevap, kuralları çoktan eğmiştir.

Yakut

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

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

ahem

gösteri

Boğazını temizler, "Muz" u 3070 kez basar ve ayrıca "Turuncu, muz demediğime sevindin mi?" Koyar.

Bu, Ruby'nin 'ahem' ve 'ayrıca' ("ahem", "ahen", "aheo", "ahep", "aheq" sözcükleri arasındaki alfabetik olarak tanımlayan her yöntemi tanımlamak için tam zamanlı yöntem tanımı işlevini kullanır, "aher", "ahes", "ahet", "aheu", "ahev" ...) önce Muz'u yazdırmak ve sonra listedeki bir sonraki kişiyi aramak.

Python - 16

veya eval ile birlikte başka bir dilde.

exec"print 1;"*9

CSharp

Artık kod golf olmadığından ve insanlar bu programın bir şeyler yaptığını görebilmeleri için bir artış sayacı eklediğinden, kodu daha okunaklı bir şekilde genişlettim.

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

(Lütfen bunu yapma lütfen).

Başlangıçta P, programdan çıkmaya çalıştığında Psınıfın yeni bir örneğini yaratan sonlandırıcıyı çağıran GC'yi çağırır , bu da temizlemeye çalıştığında Psonlandırıcıyı çağıran yeni bir tane oluşturur . .

Program sonunda ölür.

Düzenleme: Açıkçası bu ölmeden önce sadece yaklaşık 45k kez çalışır. GC'nin zorlu sonsuz döngümü nasıl çözdüğünü tam olarak bilmiyorum ama oldu. Kısa, anlaşılmadığı anlaşılıyor ve iş parçacığı yaklaşık 2 saniye süren işten sonra öldürüldü: https://stackoverflow.com/questions/24662454/how-does-a-garbage-collector-avoid-an -Sonsuz döngü-burada

Düzenleme2: Bunun özyinelemeye göre biraz fazla olduğunu düşünüyorsanız, benim diğer çözümümüzü düşünün: https://codegolf.stackexchange.com/a/33268/23300

Genel yöntemlerin yeniden düzenlenmesini kullanır, böylece çalışma zamanında sürekli olarak yeni yöntemler üretir ve terimdeki her yöntem yeni basılmış bir yöntemi çağırır. Ayrıca reference, çalışma zamanları bu yöntemler için kodu paylaşabildiğinden, tür parametrelerini kullanmaktan da kaçınırım . Bir valuetür parametresi ile çalışma zamanı yeni bir yöntem oluşturmaya zorlanır.

Befunge

.

İyi eski Befunge, satırlar sarılırken hemen hemen 0 (boş bir yığından) 0 verir.

JS

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

İşlev eğlenceli!

Kendisiyle aynı gövdeyle başka bir işlev oluşturan ve daha sonra onu çalıştıran bir işlev.

Yığın limitine ulaşıldığında ve her şey çöktüğünde sonunda hi gösterilecektir.

Feragatname: Tarayıcınızda yığın sınırına ulaşana kadar hiçbir şey yapamazsınız.

Ve bir tane daha, daha kötü :

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

Bir pencereyi açan bir fonksiyon yaratır, daha sonra fonksiyonun bir kopyası olan pencerede bir fonksiyon yaratır ve çalıştırır.

Feragatname: Açılır pencerelerin açılmasına izin verirseniz, bunu bitirmenin tek yolu bilgisayarınızı yeniden başlatmak olacaktır.

x86 montajı / DOS

    org 100h

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

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

Ters bir kuyruk özyinelemesi olmadığını söylemiş miydim ? Ben mi yaptım

Nasıl çalışır

retBir fonksiyondan döndürmek için kullanılan kullanıcı, (aslında, normal olarak, ilgili orada konur yığından dönüş adresini çıkar call) ve buna atlar. Burada her yinelemede push, geri dönmeden önce yığında giriş noktası adresi, böylece sonsuz bir döngü oluşturur.

Java

XKCD'den doğrudan

Bir ebeveyn ve çocuk arasında hiç bitmeyen bir avlanma oyunu!

Hedef CHILDolarak ayarlanır PARENTve hedef PARENTolduğunu CHILD. Ne zaman PARENTaramaları AIM, bunun örneğini atar BALLsınıfının ve onu yakalamak deyimi tarafından yakalanır. Catch ifadesi daha sonra PARENT.TARGET.AIMhedefin olduğu yeri çağırır CHILD. CHILDÖrneğin aynı işi yapar ve ebeveyne "topu geri atar".

Bash, 3 karakter

yes

evet, 'y' yi tekrar tekrar konsola döndürür

Düzenleme: Herkes bu satırı düzenlemeye teşvik edilir:

yes something | xargs someaction

(Olivier Dulac sayesinde)

C, 35 karakter

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

Program kendini yürütür. Bunun özyineleme olarak kabul edilip edilmediğinden emin değilim.

C (GCC yerleşikleriyle birlikte - aynı zamanda clang ile de çalışıyor gibi)

• Açık döngüler yok
• Açık bir şekilde gitme
• Özyineleme yok
• Yığınla uğraşmak sadece eski moda güzeldi (çocuklar, bunu süpervizyon olmadan evde denemeyin):

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

Açıklama:

• main()ilk aramalar frameloop(NULL). Bu durumda __builtin_return_address(), geri dönecek adresi (in main()) almak için yerleşik kodu frameloop()kullanın. Bu adresi iade ediyoruz.
• printf() döngüdüğümüzü göstermek için
• şimdi bir frameloop()önceki aramanın dönüş adresini arayacağız. Mevcut iade adresinin yığınını araştırıyoruz ve bulduğumuzda önceki dönüş adresinin yerine geçiyoruz.
• Sonra 2. frameloop()çağrıdan geri dönüyoruz. Ancak geri dönüş adresi saldırıya uğradığından main(), ilk çağrının geri dönmesi gereken noktaya geri dönüyoruz . Böylece bir döngüye gireriz.

Yığın içinde dönüş adresinin aranması elbette bir döngü olarak daha temiz olurdu, fakat herhangi bir döngü olmaması için birkaç yinelemeyi açtım.

Çıktı:

$ 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

Aşağıdaki kod özyinelemeli bir işlev içermez (dolaylı olarak bile), döngüsel ilkel içermez ve yerleşik özyinelemeli işlev çağrısı yapmaz (yalnızca IOçıktısını ve ciltlemeyi kullanır ), ancak belirli bir işlemi kesin olarak tekrarlar:

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

Fonksiyon extractşey demiyor, ycsadece çağırır extractve mainsadece çağırır ycve putStrLnve >>özyinelemeli olmayan, hangi.

Açıklama: Hile özyinelemeli veri türünde Strange. Örnekte gösterildiği gibi, rasgele tekrarlamaya izin veren, kendisini tüketen özyinelemeli bir veri türüdür. İlk olarak, yazılmamış lambda matematiğinde extract xkendi kendine uygulamayı ifade eden temel yapı kurabiliriz x x. Ve bu, olarak tanımlanan Y birleştiricisinin oluşturulmasına izin verir λf.(λx.f(xx))(λx.f(xx)).

Güncelleme: Önerildiği gibi, yazılmamış lambda hesabında Y tanımına daha yakın olan bir değişken gönderiyorum :

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

Aşağıdaki 10'dan "Patlamaya!" şablon metaprogramlama kullanarak.

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

Klasik bir özyineleme örneği gibi görünebilir, ancak aslında en azından teknik olarak tanımınıza bağlı değildir. Derleyici on farklı işlev üretecektir . countdown<10>"T eksi 10" yazdırır ve ardından çağırır countdown<9>, ve böyle devam eder countdown<0>, "Patlama!" ve sonra döner. Kod tekrarladığınızda özyineleme gerçekleşir, ancak çalıştırılabilir döngü yapıları içermez.

C ++ 11'de constexpr, bu faktörsal işlev gibi anahtar kelimeyi kullanarak benzer etkiler elde edilebilir . (Geri sayım örneğini bu şekilde uygulamak mümkün değildir, çünkü constexprişlevlerin yan etkileri olamaz, ancak yaklaşan C ++ 14'te mümkün olabileceğini düşünüyorum.)

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

Yine bu gerçekten özyineleme gibi görünüyor, ama derleyici dışarı genişleyecektir factorial(10)içine 10*9*8*7*6*5*4*3*2*1ve sonra muhtemelen sabit bir değerle değiştirir 3628800, böylece çalıştırılabilir herhangi döngü veya özyinelemeli kod içermeyecektir.

Java

Java sınıf yükleyicisiyle oynayalım ve kendi ebeveyni olarak ayarlayalım:

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

    }
}

Bu döngü aslında o kadar güçlüdür ki kill -9onu durdurmak için bir a kullanmak zorundasınız :-)

Mac işlemcimin% 100,1'ini kullanıyor.

System.outAlternatif bir komik davranış denemek için ana işlevin sonunda hareket ettirmeyi deneyebilirsiniz .

CSharp

Bir tane daha ve aynı derecede kötü ::

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

Bu özyineleme değildir ... bu, kod şablonlarının yeniden düzenlenmesidir. Görünüşe göre aynı yöntemi çağırıyoruz, çalışma zamanı sürekli olarak yeni yöntemler oluşturuyor. İnt türünü kullanırız, çünkü bu onu tamamen yeni bir tür oluşturmaya zorlar ve yöntemin her bir örneği yeni bir yöntemi denemek zorunda kalır. Burada paylaşım kod yazamaz. Sonunda, söz verdiğimiz ancak asla teslim edilmediğimiz int'nin geri dönüşünü sonsuz beklediği için çağrı yığınını öldürürüz. Benzer şekilde, ilginç tutmak için yarattığımız türü yazmaya devam ediyoruz. Temel olarak çağırdığımız her C, aynı gövdeye sahip olan, son derece yeni bir yöntemdir. Bu, şablonları derleme zamanında yapan C ++ veya D gibi bir dilde mümkün değildir. C # JIT süper tembel olduğundan, sadece bu şeyi mümkün olan en son anda yaratır. Böylece,

Redcode 94 (Çekirdek Savaşı)

MOV 0, 1

Bir adrese sıfır adresindeki komutu kopyalar. Çekirdek Savaşı'nda tüm adresler mevcut PC adreslerine göre olduğundan ve çekirdeğin boyutundan modulo olduğu için, bu, atlamayan bir komutta sonsuz bir döngüdür.

Bu program (savaşçı) " Imp " olarak adlandırılır ve ilk AK Dewdney tarafından yayınlandı.

Dart oyunu

Sanırım bu, gerçek bir özyinelemeli işlev olmadan özyinelemenin klasik yolu olurdu. Aşağıdaki hiçbir işlev doğrudan veya dolaylı olarak isminden söz etmez.

( Dartpad.dartlang.org adresinde deneyin )

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

Çok orijinal değil, küçük. 20 karakter.

setInterval(alert,1)

C sinyalleri

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

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

Bu programın davranışı açık bir şekilde çok tanımsız, ancak bugün bilgisayarımda "Merhaba dünya!" Yazıyor.

Emacs Lisp

Lisp'in "kodun veri ve verilerin kod olduğu" güçlü tasarımını göstermenin tam zamanı. Verilmiş, bu örnekler çok verimsiz ve bu asla gerçek bağlamda kullanılmamalıdır.

Makrolar, söz konusu döngünün kontrolsüz bir sürümü olan ve üretilen kodun çalışma zamanında değerlendirildiği kod üretir.

tekrarla: N kere tekrarlamanıza izin verir

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

tekrarla testi:

;; 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-ile-index:

Bu makro gibidir repeat-itancak gerçekte, genel döngü döngüsü makrosu gibi çalışır do-times, döngü indeksine bağlanacak bir sembol belirlemenizi sağlar. Döngü gövdesi sırasındaki değerini değiştirip değiştirmemenizden bağımsız olarak, indeks değişkeninin her döngünün başında doğru ayarlandığından emin olmak için bir genişleme süresi sembolü kullanır.

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

Endeksle tekrarla testi:

Bu test şunları göstermektedir:

1. Vücut N kere değerlendirir

2. Dizin değişkeni her yinelemenin başında her zaman doğru bir şekilde ayarlanır

3. "geri dönüş" adlı bir sembolün değerini değiştirmek endekse karışmaz

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

Türlenmemiş lambda taşı

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

Haskell, 24 karakter

sequence_ (repeat (print "abc"))

veya yoğunlaştırılmış biçimde, 24 karakter

sequence_$repeat$print"" 

(metin değiştirilse de, bu yine de döngüye girecektir - bu iki tırnak işareti ve sonsuz bir şekilde yeni bir satır yazacaktır)

açıklama: "abc" yazdır, temel olarak sadece "abc" yazdıran bir giriş / çıkış işlemidir.
yineleme, x değerini alan ve yalnızca x değerinden oluşan sonsuz bir liste döndüren bir işlevdir.
dizisi_, bir g / Ç eylemlerinin listesini alan ve tüm eylemleri sırayla yapan bir g / ç işlemi döndüren bir işlevdir.

Bu nedenle, temel olarak, bu program "abc" komutlarının yazdırılmayan sonsuz bir listesini yapar ve bunları tekrar tekrar yürütür. döngü veya özyineleme olmadan.

ASM (Linux için x86 + I / O)

Bu cılız yüksek seviyeli dillerin ne kadar mücadele edeceği önemli değil, yine de sadece gizli talimat gösterici manipülasyonu olacak. Sonunda, çalışma zamanında döngüyü açmak için yeterince sıkılmadığınız sürece, bir çeşit "goto" (jmp) olacaktır.

Ideone'da kodu test edebilirsiniz

Bu fikrin daha ayrıntılı versiyonunu Matteo Italia DOS kodunda da inceleyebilirsiniz .

0..9 string ile başlar ve onu A..J ile değiştirir, doğrudan atlamalar kullanılmaz (yani "goto" olmadığını söyleriz).

Kod, adres hesaplamanın kötüye kullanılmasıyla daha küçük olabilir, ancak çevrimiçi derleyici üzerinde çalışmak zahmetlidir, bu yüzden olduğu gibi bırakacağım.

Çekirdek kısmı:

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

Bütün kod

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 önişlemci

Şaşırtma mücadelesinde karşılaştığım küçük bir "teknik". İşlev tekrarı yok, fakat dosya tekrarı var mı?

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

Bunu gcc kullanarak yazdım / test ettim. Açıkçası, derleyicinizin derlemesi için __INCLUDE_LEVEL__makroyu (veya alternatif __COUNTER__olarak bazı ince ayarlı makroyu) desteklemesi gerekir. Bunun nasıl çalıştığı oldukça açık olmalıdır, ancak eğlence için, işlemciyi kodu derlemeden çalıştırın ( -Ebayrağı gcc ile kullanın ).

PHP

İşte PHP ile bir tane. Sayaç $ max değerine ulaşana kadar aynı dosyayı dahil ederek döngüler:

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

Bir for döngüsü için aynı:

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

piton

Aşağıdaki kod özyinelemeli bir işlev içermez (doğrudan veya dolaylı), döngüsel ilkel içermez ve herhangi bir yerleşik işlevi çağırmaz (hariç 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)

"Merhaba dünya!" verilen sayıda.

Açıklama: İşlev zuygulayan katı Z sabit noktalı bir bağdaştırıcının herhangi bir yinelemeli bir algoritma ifade sağlar (yinelemeli tanımlanmamış ise).

z80 makine kodu

Her adreste çalıştırabileceğiniz ve her yerde ROM eşleyebileceğiniz bir ortamda, sıfır ile dolu olan 64kb ROM'u tüm adres alanına eşleyin.

Ne yapar: hiçbir şey. Defalarca.

Nasıl çalışır: İşlemci çalışmaya başlayacaktır, bayt 00bir noptalimattır, bu yüzden siz devam edecek, adrese ulaşacak, $ffffetrafa $0000sarılacak ve nopsiz yeniden başlatana kadar s çalışmaya devam edecektir .

Biraz daha ilginç yapmak için, belleği başka bir değerle doldurun (kontrol akışı talimatlarını önlemek için dikkatli olun).

Perl-regex

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

gösteri

veya şu şekilde deneyin:

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

(?!)Asla denk. Bu nedenle regex motoru , eşleşen dizedeki her sıfır genişlik konumuyla eşleşmeye çalışır .

(q x x x 10)Aynıdır (" " x 10)tekrarlamak - spaceon kere.

Düzenleme: daha iyi anlaşılması için "karakterleri" sıfır genişlik pozisyonlarına dönüştürdü. Bu stackoverflow sorusunun cevaplarına bakınız .

T-SQL -12

print 1
GO 9

Aslında Sql Server Management Studio'nun bir tutam daha fazla. GO, bir komut dosyası ayırıcısıdır ve T-SQL dilinin bir parçası değildir. GO ve ardından bir sayı belirtirseniz, bloğu o kadar çok yürütür.

C #

Uint.MaxValue ile 0 arasındaki tüm tamsayıları yazdırır.

   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 (tarayıcıda)

Buna ne dersin?

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

Geçerli saati yazdırır ve sayfayı yeniden yükler.