Питання, подібне до цього, було задано пару років тому , але це ще складніше.

Завдання проста. Напишіть програму (в вашому мовою на вибір) , який багаторазово виконує код без використання будь - яких повторення структур , таких як 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 ранку за східним часом. Удачі!

ОНОВЛЕННЯ:

Заспокоїти розгубленість, яка все ще виражається, це може допомогти:

Правила, як зазначено вище:

• Не використовуйте циклів або goto
• Функції не можуть називати себе
• Робіть все, що завгодно, у "циклі"

Якщо ви хочете щось реалізувати, і правила цього прямо не забороняють, продовжуйте це робити. У багатьох відповідях правила вже зігнуті.

Рубін

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

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

ahem

Демо

Очищає горло, друкує "Банан" 3070 разів, а також ставить "Апельсин ти радий, що я не сказав банан?".

Це використовує смішні функціональні можливості визначення методу Рубі, щоб визначити кожен метод, який знаходиться в алфавітному порядку між словами "ах" і "також" ("ах", "ахен", "ахео", "ахеп", "ахек", "aher", "ahes", "ahet", "aheu", "ahev" ...) спочатку надрукуйте Banana, а потім зателефонуйте наступному у списку.

Пітон - 16

або будь-якою іншою мовою з eval.

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, який викликає фіналізатор, створює новий екземпляр Pкласу, який при спробі очищення створює новий, Pякий викликає фіналізатор .. .

Програма врешті-решт гине.

Редагувати: Незрозуміло, що це відбувається лише близько 45 тис. Разів перед смертю. Я не зовсім знаю, як GC з'ясував мій хитрий нескінченний цикл, але це так. Коротше, схоже, він цього не зрозумів, і нитка просто загинула приблизно через 2 секунди виконання: https://stackoverflow.com/questions/24662454/how-does-a-garbage-collector-avoid-an -нескінченна-петля-тут

Edit2: Якщо ви вважаєте, що це занадто багато, як рекурсія, розгляньте моє інше рішення: https://codegolf.stackexchange.com/a/33268/23300

Він використовує переосмислення загальних методів так, що під час виконання він постійно генерує нові методи, і кожен метод в терміні називає новоспечений метод. Я також уникаю використання referenceпараметрів типу, оскільки зазвичай час виконання може надавати код для цих методів. З valueпараметром типу час виконання змушений створювати новий метод.

Befunge

.

Старий добрий Befunge виводить 0 (з порожнього стека) майже назавжди, коли лінії обертаються.

JS

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

Функція весело!

Функція, яка створює іншу функцію з тим самим тілом, що і сама, а потім виконує її.

Він з’явиться привіт в кінці, коли буде досягнуто ліміту стека і вся справа згортається.

Відмова від відповідальності: ви не зможете робити нічого у своєму браузері, поки не буде досягнуто ліміту стека.

І ще одне, більше зла :

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вказуємо адресу входу на стеку перед поверненням, створюючи таким чином нескінченний цикл.

Java

Прямо від XKCD

Це нескінченна гра на вилов між батьком і дитиною!

Мета CHILDзадана, PARENTа мета PARENT- CHILD. Під час PARENTвиклику AIMвін викидає екземпляр BALLкласу, і він потрапляє у заяву catch. Потім заява про вилов називає, PARENT.TARGET.AIMде є ціль CHILD. CHILDПримірник робить те ж саме і «кидає м'яч назад» батькові.

Баш, 3 символи

yes

так, неодноразово повертається "y" на консоль

Редагувати: усім рекомендується редагувати цей рядок:

yes something | xargs someaction

(спасибі Олів'є Дулаку)

C, 35 символів

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

Програма виконує себе. Я не впевнений, вважається це рекурсією чи ні.

C (із вбудованими GCC - також, здається, працює з клангом)

• Немає явних циклів
• Немає явних готів
• Рекурсії немає
• Просто гарний старомодний возитися зі стеком (діти, не намагайтеся цього вдома без нагляду):

#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()вбудований, щоб отримати зворотну адресу (в main()), до frameloop()якої повернетесь. Ми повертаємо цю адресу.
• printf() щоб показати, що ми лупимо
• тепер ми дзвонимо frameloop()із зворотною адресою попереднього дзвінка. Ми переглядаємо стек поточної зворотної адреси, і коли ми знаходимо її, підміняємо попередню зворотну адресу.
• Потім повертаємося з 2-го 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
$ 

Хаскелл

Наведений нижче код не містить рекурсивної функції (навіть опосередковано), не має циклічної примітиви та не викликає жодної вбудованої рекурсивної функції (використовує лише 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. Це рекурсивний тип даних, який споживає себе, що, як показано в прикладі, дозволяє довільне повторення. По-перше, ми можемо побудувати extract x, що по суті виражає самозастосування x xв нетиповому рахунку лямбда. І це дозволяє побудувати комбінатор Y, визначений як λ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 до "Вибух!" використовуючи метапрограмування шаблонів.

#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

Давайте пограємо з завантажувачем класу Java та встановимо його як власного батька:

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

    }
}

Цей цикл насправді настільки сильний, що вам доведеться використовувати його, kill -9щоб зупинити його :-)

Він використовує 100,1% мого процесора Mac.

Ви можете спробувати перемістити 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, оскільки це насправді змушує його створити абсолютно новий тип, і кожен екземпляр методу повинен створювати новий метод. Тут не можна поділитись кодом. Врешті-решт, ми вбиваємо стек викликів, оскільки він нескінченно чекає повернення int, яке ми обіцяли, але ніколи не доставляли. Аналогічно ми продовжуємо писати створений нами тип, щоб зробити його цікавим. В основному кожен C, який ми називаємо, це абсолютно новий метод, який просто має той самий корпус. Це насправді неможливо для такої мови, як C ++ або D, які роблять свої шаблони під час компіляції. Оскільки C # JIT дуже лінивий, він створює цей матеріал лише в останній можливий момент. Таким чином,

Redcode 94 (основна війна)

MOV 0, 1

Копіює інструкцію за нульовою адресою для адреси однієї Оскільки в Core War всі адреси відносяться до поточної адреси ПК і за модулем розміром ядра, це нескінченний цикл в одній інструкції, що не перестрибує.

Ця програма (воїн) називається " Imp " і вперше була опублікована А. К. Дьюдней.

Дартс

Я думаю, це був би класичний спосіб виконання рекурсії без фактичної рекурсивної функції. Жодна функція нижче не посилається на себе по імені, прямо чи опосередковано.

(Спробуйте на 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)

Сигнали в С

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

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

Поведінка цієї програми, очевидно, дуже невизначена, але сьогодні на моєму комп’ютері вона продовжує друкувати "Привіт, світ!".

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. зміна значення символу під назвою "запасний" не пов'язуватиметься з індексом

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

Хаскелл, 24 символи

sequence_ (repeat (print "abc"))

або у стислому вигляді з 24 символами

sequence_$repeat$print"" 

(хоча текст змінено, це все одно буде циклічно - це буде друкувати дві лапки та новий рядок нескінченно)

пояснення: друк "abc" - це в основному дія вводу-виводу, яка просто друкує "abc".
повтор - це функція, яка приймає значення x і повертає нескінченний список, складений лише з x.
послідовність_ - це функція, яка приймає список дій вводу-виводу і повертає дію вводу-виводу, яка виконує всі дії послідовно.

тому, в основному, ця програма складає нескінченний список команд "abc" для друку і повторно виконує їх. без петель чи рекурсії.

ASM (x86 + введення / виведення для Linux)

Не важливо, наскільки ваші мовчазні мови високого рівня будуть боротися, все одно це буде просто прихована маніпуляція з покажчиком інструкцій. Зрештою, це буде якийсь "goto" (jmp), якщо тільки вам не нудно, щоб розгорнути цикл під час виконання.

Ви можете перевірити код на Ideone

Ви також можете переглянути більш вдосконалену версію цієї ідеї у DOS-коді Matteo Italia .

Він починається з рядка 0..9 і замінює його на A..J, не використовуються прямі стрибки (тому дозвольмо сказати, що жодного "goto" не сталося), а також повторення.

Код, мабуть, міг би бути меншим, якщо зловживати розрахунком адреси, але робота над онлайн-компілятором є клопіткою, тому я залишу його таким, яким він є.

Основна частина:

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. Цикли, включивши той самий файл, поки лічильник не досягне $ 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
?>

Те саме, що для циклу for:

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

Друкує "Привіт, світ!" задана кількість разів.

Пояснення: Функція zреалізує суворий Z -комбінатор з фіксованою точкою , який (хоча не рекурсивно визначений) дозволяє виражати будь-який рекурсивний алгоритм.

z80 машинного коду

У середовищі, де ви можете виконати будь-яку адресу та скріпити карту ROM скрізь, нанесіть 64 кб ПЗУ, заповнені нулями, на весь адресний простір.

Що це робить: нічого. Неодноразово.

Як це працює: процесор почне виконувати, байт 00- це nopінструкція, тому він буде просто продовжувати, діставатиметься до адреси $ffff, обертатись $0000та продовжувати виконувати nops, поки ви не скинете її.

Щоб зробити це трохи цікавіше, заповніть пам’ять яким-небудь іншим значенням (будьте обережні, щоб уникнути інструкцій з управління потоком).

Перл-регекс

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

демонстрація

або спробуйте як:

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

(?!)Ніколи не збігаються. Отже, двигун регулярного випробовування намагається відповідати кожному положенню нульової ширини у відповідній рядку.

Те (q x x x 10)саме, що (" " x 10)- повторити spaceдесять разів.

Редагувати: змінив "символи" на позиції нульової ширини, щоб бути точнішими для кращої зрозумілості. Дивіться відповіді на це запитання про поточний процес .

T-SQL -12

print 1
GO 9

Насправді більше примх студії управління сервісом 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;

Друкує поточний час і перезавантажує сторінку.