Una pregunta similar a esta se hizo hace un par de años , pero esta es aún más complicada.

El desafío es simple. Escribir un programa (en el idioma de su elección) que ejecuta repetidamente el código sin necesidad de utilizar ninguna estructura de repetición, como while, for, do while, foreacho goto( Así que por todo lo que nitpickers, no se puede utilizar un bucle ). Sin embargo, la recursión no está permitida, en la función que se llama a sí misma sentido (véase la definición a continuación) . Eso haría este desafío demasiado fácil.

No hay restricciones sobre lo que debe ejecutarse en el ciclo, pero publique una explicación con su respuesta para que otros puedan entender exactamente lo que se está implementando.

Para aquellos que pueden estar colgados en las definiciones, la definición de un bucle para esta pregunta es:

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

Y la definición de recursión para esta pregunta será su definición de función recursiva estándar:

A function that calls itself.

El ganador será la respuesta que tenga más votos positivos el 16 de julio a las 10 a.m., hora del este. ¡Buena suerte!

ACTUALIZAR:

Para calmar la confusión que aún se expresa, esto puede ayudar:

Reglas como se indicó anteriormente:

• No uses bucles o goto
• Las funciones no pueden llamarse a sí mismas
• Haz lo que quieras en el 'bucle'

Si desea implementar algo y las reglas no lo rechazan explícitamente, continúe y hágalo. Muchas respuestas ya han torcido las reglas.

Rubí

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

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

ahem

Manifestación

Se aclara la garganta, imprime "Plátano" 3070 veces y también pone "Naranja, ¿te alegra que no haya dicho plátano?".

Utiliza la ridícula funcionalidad de definición de método justo a tiempo de Ruby para definir cada método que se encuentra alfabéticamente entre las palabras 'ahem' y 'también' ("ahem", "ahen", "aheo", "ahep", "aheq", "aher", "ahes", "ahet", "aheu", "ahev" ...) para imprimir primero Banana y luego llamar al siguiente en la lista.

Python - 16

o cualquier otro idioma con eval.

exec"print 1;"*9

CSharp

He expandido el código de una manera más legible, ya que esto ya no es un código de golf y he agregado un contador de incrementos para que la gente pueda ver que este programa hace algo.

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

(No hagas esto nunca por favor).

Al inicio, creamos una nueva instancia de la Pclase, que cuando el programa intenta salir llama al GC que llama al finalizador que crea una nueva instancia de la Pclase, que cuando intenta limpiar crea una nueva Pque llama al finalizador. .

El programa finalmente muere.

Editar: Inexplicablemente, esto solo se ejecuta alrededor de 45k veces antes de morir. No sé cómo el GC descubrió mi complicado bucle infinito, pero lo hizo. El resumen es que parece que no lo resolvió y que el hilo simplemente se cortó después de aproximadamente 2 segundos de ejecución: https://stackoverflow.com/questions/24662454/how-does-a-garbage-collector-avoid-an -infinite-loop-here

Edit2: si crees que esto es demasiado parecido a la recursión, considera mi otra solución: https://codegolf.stackexchange.com/a/33268/23300

Utiliza la reificación de métodos genéricos para que en tiempo de ejecución genere constantemente nuevos métodos y cada método en término llama a un método nuevo. También evito usar referenceparámetros de tipo, ya que normalmente el tiempo de ejecución puede compartir el código para esos métodos. Con un valueparámetro de tipo, el tiempo de ejecución se ve obligado a crear un nuevo método.

Befunge

.

El viejo Befunge sale 0 (de una pila vacía) casi para siempre, a medida que las líneas se envuelven.

JS

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

Fun fun!

Una función que crea otra función con el mismo cuerpo que ella misma y luego la ejecuta.

Mostrará hola al final cuando se alcance el límite de la pila y todo se derrumbe.

Descargo de responsabilidad: no podrá hacer nada en su navegador hasta que se alcance el límite de pila.

Y otro, más malvado :

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

Crea una función que abre una ventana, luego crea una función dentro de esa ventana que es una copia de la función y luego la ejecuta.

Descargo de responsabilidad: si va a permitir la apertura de ventanas emergentes, la única forma de terminar esto será reiniciando su computadora

Ensamblaje x86 / DOS

    org 100h

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

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

¿Dije que no hay recursión inversa de la cola ? ¿Hice?

Cómo funciona

La retinstrucción, utilizada para regresar de una función, en realidad saca la dirección de retorno de la pila (que normalmente se coloca allí por el correspondiente call) y salta a ella. Aquí en cada iteración tenemos pushla dirección del punto de entrada en la pila antes de regresar, generando así un bucle infinito.

Java

Directamente desde XKCD

¡Es un juego interminable de captura entre padres e hijos!

El objetivo de CHILDse establece en PARENTy el objetivo de PARENTes CHILD. Cuando las PARENTllamadas AIM, arroja la instancia de la BALLclase y es capturada por la instrucción catch. La instrucción catch luego llama a PARENT.TARGET.AIMdonde está el objetivo CHILD. La CHILDinstancia hace lo mismo y "devuelve la pelota" al padre.

Bash, 3 personajes

yes

yes repetidamente devolverá 'y' a la consola

Editar: se alienta a todos a editar esta línea:

yes something | xargs someaction

(gracias a Olivier Dulac)

C, 35 caracteres

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

El programa se ejecuta solo. No estoy seguro de si esto se considera recurrencia o no.

C (con GCC incorporado - también parece funcionar con el sonido metálico)

• No hay bucles explícitos
• No hay gotos explícitos
• Sin recursividad
• Simplemente un buen juego anticuado con la pila (niños, no intenten esto en casa sin supervisión):

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

Explicación:

• main()primeras llamadas frameloop(NULL). En este caso, use el __builtin_return_address()incorporado para obtener la dirección de retorno (in main()) a la que frameloop()volverá. Le devolvemos esta dirección.
• printf() para mostrar que estamos girando
• ahora llamamos frameloop()con la dirección de retorno de la llamada anterior. Buscamos en la pila la dirección de retorno actual y, cuando la encontramos, sustituimos la dirección de retorno anterior.
• Luego regresamos de la segunda frameloop()llamada. Pero dado que la dirección de devolución fue pirateada arriba, terminamos regresando al punto en main()el que debería regresar la primera llamada. Así terminamos en un bucle.

La búsqueda de la dirección de retorno en la pila sería, por supuesto, más limpia como un bucle, pero desenrollé algunas iteraciones en aras de que no haya ningún bucle.

Salida:

$ 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

El siguiente código no contiene ninguna función recursiva (incluso indirectamente), no tiene primitiva de bucle y no llama a ninguna función recursiva incorporada (solo usa IOla salida y el enlace), pero repite una acción dada de manera indefinida:

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

La función extractno llama a nada, ycsolo llama extracty mainllama solo ycy putStrLny >>, que no son recursivas.

Explicación: El truco está en el tipo de datos recursivo Strange. Es un tipo de datos recursivo que se consume a sí mismo, lo que, como se muestra en el ejemplo, permite la repetición arbitraria. Primero, podemos construir extract x, que esencialmente expresa la auto aplicación x xen el cálculo lambda sin tipo. Y esto permite construir el combinador Y definido como λf.(λx.f(xx))(λx.f(xx)).

Actualización: como se sugiere, estoy publicando una variante que está más cerca de la definición de Y en el cálculo lambda sin tipo:

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

Lo siguiente genera una cuenta regresiva de 10 a "¡Despegue!" usando metaprogramación de plantilla.

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

Puede parecer un ejemplo clásico de recursión, pero en realidad no lo es, al menos técnicamente, según su definición. El compilador generará diez funciones diferentes . countdown<10>imprime "T menos 10" y luego llama countdown<9>, y así sucesivamente hasta countdown<0>, que imprime "¡Despegue!" y luego regresa La recursión ocurre cuando compila el código, pero el ejecutable no contiene ninguna estructura de bucle.

En C ++ 11 se pueden lograr efectos similares usando la constexprpalabra clave, como esta función factorial. (No es posible implementar el ejemplo de cuenta regresiva de esta manera, ya que las constexprfunciones no pueden tener efectos secundarios, pero creo que podría ser posible en el próximo C ++ 14).

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

De nuevo, esto realmente se parece a la recursividad, pero el compilador se expandirá a cabo factorial(10)en 10*9*8*7*6*5*4*3*2*1, y luego, probablemente, reemplazarlo con un valor constante de 3628800, por lo que el ejecutable no contendrá ningún bucle o código recursivo.

Java

Juguemos con el cargador de clases Java y configúrelo como su propio padre:

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

    }
}

Este bucle es realmente tan fuerte que tendrá que usar un kill -9para detenerlo :-)

Utiliza el 100,1% de la CPU de mi Mac.

Puede intentar mover System.outal final de la función principal para experimentar un comportamiento divertido alternativo.

CSharp

Uno más e igualmente malvado ::

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

Esto no es recursividad ... esta es la reificación de plantillas de código. Si bien parece que estamos llamando al mismo método, el tiempo de ejecución crea constantemente nuevos métodos. Usamos el parámetro tipo de int, ya que esto realmente lo obliga a crear un tipo completamente nuevo y cada instancia del método tiene que crear un nuevo método. No puede compartir código aquí. Eventualmente, matamos la pila de llamadas mientras espera infinitamente el regreso de int que prometimos pero que nunca cumplimos. De manera similar, seguimos escribiendo el tipo que creamos para mantenerlo interesante. Básicamente, cada C que llamamos es un método totalmente nuevo que solo tiene el mismo cuerpo. Esto no es realmente posible en un lenguaje como C ++ o D que hace sus plantillas en tiempo de compilación. Como C # JIT es súper vago, solo crea estas cosas en el último momento posible. Así,

Redcode 94 (Core War)

MOV 0, 1

Copia la instrucción en la dirección cero a la dirección uno. Debido a que en Core War todas las direcciones son relativas a la dirección actual de la PC y modulan el tamaño del núcleo, este es un bucle infinito en una sola instrucción sin salto.

Este programa (guerrero) se llama " Imp " y fue publicado por primera vez por AK Dewdney.

Dardo

Supongo que esta sería la forma clásica de hacer recursividad sin ninguna función recursiva real. Ninguna función a continuación se refiere a sí misma por su nombre, directa o indirectamente.

(Pruébelo en 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

No muy original pero pequeño. 20 caracteres

setInterval(alert,1)

Señales en C

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

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

El comportamiento de este programa obviamente es muy indefinido, pero hoy, en mi computadora, sigue imprimiendo "¡Hola, mundo!".

Emacs Lisp

Este es un buen momento para mostrar el poderoso diseño de Lisp donde "el código es datos y los datos son código". Por supuesto, estos ejemplos son muy ineficientes y esto nunca debe usarse en un contexto real.

Las macros generan código que es una versión desenrollada del supuesto bucle y ese código generado es lo que se evalúa en tiempo de ejecución.

Repetirlo: le permite recorrer N veces

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

prueba de repetición:

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

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

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

repetir-con-índice:

Esta macro es similar, repeat-itpero en realidad funciona igual que la macro de bucle común, do-timesle permite especificar un símbolo que estará vinculado al índice del bucle. Utiliza un símbolo de tiempo de expansión para garantizar que la variable de índice esté configurada correctamente al comienzo de cada ciclo, independientemente de si modifica o no su valor durante el cuerpo del ciclo.

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

prueba de repetir con índice:

Esta prueba muestra que:

1. El cuerpo evalúa N veces

2. la variable de índice siempre se establece correctamente al comienzo de cada iteración

3. cambiar el valor de un símbolo llamado "reserva" no alterará el índice

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

Cálculo lambda sin tipo

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

Haskell, 24 personajes

sequence_ (repeat (print "abc"))

o en forma condensada, con 24 caracteres

sequence_$repeat$print"" 

(aunque se cambia el texto, esto seguirá en bucle; esto imprimirá dos comillas y una nueva línea infinitamente)

explicación: print "abc" es básicamente una acción de E / S que simplemente imprime "abc".
repetir es una función que toma un valor x y devuelve una lista infinita hecha de solo x.
secuencia_ es una función que toma una lista de acciones de E / S y devuelve una acción de E / S que realiza todas las acciones secuencialmente.

así que, básicamente, este programa hace una lista infinita de comandos de impresión "abc" y los ejecuta repetidamente. sin bucles ni recursividad.

ASM (x86 + E / S para Linux)

No importa cuánto batallarán sus insignificantes lenguajes de alto nivel, seguirá siendo solo una manipulación oculta del puntero de instrucción. Al final, será una especie de "goto" (jmp), a menos que esté lo suficientemente aburrido como para desenrollar el bucle en tiempo de ejecución.

Puedes probar el código en Ideone

También puede consultar una versión más refinada de esta idea en el código DOS de Matteo Italia .

Comienza con una cadena de 0..9 y la reemplaza con A..J, no se utilizan saltos directos (así que digamos que no ocurrió "goto"), tampoco recurrencia.

El código probablemente podría ser más pequeño con algún cálculo de abuso de dirección, pero trabajar en el compilador en línea es molesto, así que lo dejaré como está.

Parte central:

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

Código completo

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 preprocesador

Una pequeña "técnica" que se me ocurrió durante un desafío de ofuscación. No hay recursión de funciones, pero hay ... ¿recursividad de archivos?

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

Escribí / probé esto usando gcc. Obviamente, su compilador debe admitir la __INCLUDE_LEVEL__macro (o, alternativamente, la __COUNTER__macro con algunos ajustes) para que esto se compile. Debería ser bastante obvio cómo funciona esto, pero por diversión, ejecute el preprocesador sin compilar el código (use el -Eindicador con gcc).

PHP

Aquí hay uno con PHP. Incluye bucles al incluir el mismo archivo hasta que el contador alcance $ 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
?>

Lo mismo que un bucle for:

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

Pitón

El siguiente código no contiene ninguna función recursiva (directa o indirecta), no tiene primitiva de bucle y no llama a ninguna función incorporada (excepto 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)

Imprime "¡Hola mundo!" un número dado de veces

Explicación: La función zimplementa el estricto combinador de punto fijo Z , que (aunque no está definido recursivamente) permite expresar cualquier algoritmo recursivo.

código máquina z80

En un entorno donde puede ejecutar en cada dirección y asignar ROM en cualquier lugar, asigne 64kb de ROM llenos de ceros a todo el espacio de direcciones.

Lo que hace: nada. Repetidamente.

Cómo funciona: el procesador comenzará a ejecutarse, el byte 00es una nopinstrucción, por lo que simplemente continuará, alcanzará la dirección $ffff, se ajustará $0000y continuará ejecutando nops hasta que lo reinicie.

Para hacerlo un poco más interesante, llene la memoria con algún otro valor (tenga cuidado de evitar las instrucciones de control de flujo).

Perl-regex

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

manifestación

o pruébalo como:

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

El (?!)nunca coincide. Entonces, el motor de expresiones regulares intenta hacer coincidir cada posición de ancho cero en la cadena coincidente.

El (q x x x 10)es el mismo que (" " x 10)- repita las spacediez veces.

Editar: cambió los "caracteres" a posiciones de ancho cero para ser más precisos para una mejor comprensión. Vea las respuestas a esta pregunta de stackoverflow .

T-SQL -12

print 1
GO 9

En realidad, es más una peculiaridad de Sql Server Management Studio. GO es un separador de script y no forma parte del lenguaje T-SQL. Si especifica GO seguido de un número, ejecutará el bloque tantas veces.

C#

Imprime todos los enteros desde uint.MaxValue a 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 (en navegador)

¿Qué tal esto?

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

Imprime la hora actual y vuelve a cargar la página.