Une question similaire à celle-ci a été posée il y a quelques années , mais celle-ci est encore plus délicate.

Le défi est simple. Ecrire un programme (en langue de votre choix) qui exécute de façon répétée le code sans utiliser de structures de répétition telles que while, for, do while, foreachou goto( Donc , pour tout ce que vous tatillons, vous ne pouvez pas utiliser une boucle ). Cependant, la récursion n’est pas autorisée, dans la fonction qui s’appelle sens (voir la définition ci-dessous) . Cela rendrait ce défi beaucoup trop facile.

Il n'y a aucune restriction sur ce qui doit être exécuté dans la boucle, mais postez une explication avec votre réponse afin que les autres puissent comprendre exactement ce qui est mis en œuvre.

Pour ceux qui peuvent être accrochés sur les définitions, la définition d'une boucle pour cette question est la suivante:

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

Et la définition de la récursivité pour cette question sera votre définition de fonction récursive standard:

A function that calls itself.

Winner sera la réponse qui aura le plus de votes positifs le 16 juillet à 10 heures, heure de l’Est. Bonne chance!

MISE À JOUR:

Pour calmer la confusion qui est toujours exprimée, ceci peut aider:

Règles comme indiqué ci-dessus:

• Ne pas utiliser de boucles ou goto
• Les fonctions ne peuvent pas s'appeler
• Faites ce que vous voulez dans la "boucle"

Si vous voulez implémenter quelque chose et que les règles ne l'interdisent pas explicitement, allez-y et faites-le. Beaucoup de réponses ont déjà plié les règles.

Rubis

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

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

ahem

Démo

Il s'éclaircit la gorge, imprime "Banana" 3070 fois et ajoute "Orange, tu es content de ne pas avoir dit banane?".

Ceci utilise la fonctionnalité ridicule de définition de méthode juste à temps de Ruby pour définir chaque méthode située alphabétiquement entre les mots "ahem" et "aussi" ("ahem", "ahen", "aheo", "ahep", "aheq", "aher", "ahes", "ahet", "aheu", "ahev" ...) pour imprimer d'abord Banana puis appeler le suivant dans la liste.

Python - 16

ou toute autre langue avec eval.

exec"print 1;"*9

CSharp

J'ai élargi le code de manière plus lisible car il ne s'agit plus de code de golf et j'ai ajouté un compteur d'incrément pour que les gens puissent réellement voir que ce programme fait quelque chose.

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

(Ne fais jamais ça s'il te plait).

Au démarrage, nous créons une nouvelle instance de la Pclasse qui, lorsque le programme tente de quitter, appelle le GC, qui appelle le finaliseur, qui crée une nouvelle instance de la Pclasse, qui, lorsqu'elle tente de nettoyer, en crée une nouvelle, Pqui appelle le finaliseur. .

Le programme meurt finalement.

Edit: Inexplicablement, cela ne dure que 45 000 fois environ avant de mourir. Je ne sais pas trop comment le GC a découvert ma boucle infinie délicate, mais c'est ce qui s'est passé. En bref, il semble qu'il ne l'ait pas compris et que le fil ait été tué après environ 2 secondes d'exécution: https://stackoverflow.com/questions/24662454/how-does-a-garbage-collector-avoid-an -infinite-loop-here

Edit2: Si vous pensez que cela ressemble un peu trop à la récursivité, considérez mon autre solution: https://codegolf.stackexchange.com/a/33268/23300

Il utilise la réification des méthodes génériques afin qu’au moment de l’exécution, il génère constamment de nouvelles méthodes et chaque méthode à terme appelle une méthode nouvellement créée. J'évite également d'utiliser referencedes paramètres de type, car normalement, le moteur d'exécution peut partager le code pour ces méthodes. Avec un valueparamètre de type, le moteur d'exécution est obligé de créer une nouvelle méthode.

Befunge

.

Les bons vieux Befunge affichent 0 (à partir d’une pile vide) assez longtemps, à mesure que les lignes s’enroulent

JS

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

Fonction fun!

Une fonction qui crée une autre fonction avec le même corps que lui, puis l'exécute.

Il affichera hi à la fin lorsque la limite de pile est atteinte et que tout s'effondre.

Clause de non-responsabilité: vous ne pourrez rien faire dans votre navigateur si la limite de pile est atteinte.

Et un autre, plus diabolique :

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

Il crée une fonction qui ouvre une fenêtre, puis crée une fonction dans cette fenêtre qui est une copie de la fonction, puis l'exécute.

Clause de non-responsabilité: si vous autorisez l'ouverture de fenêtres contextuelles, le seul moyen de terminer ce processus consiste à redémarrer votre ordinateur.

Assemblage x86 / DOS

    org 100h

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

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

Ai-je dit non récursion de la queue inversée ? Ai-je?

Comment ça fonctionne

L’ retinstruction, utilisée pour retourner d’une fonction, extrait en fait l’adresse de retour de la pile (qui y est normalement placée par le correspondant call) et y saute. Ici, à chaque itération, nous pushentrons l'adresse du point d'entrée sur la pile avant de retourner, générant ainsi une boucle infinie.

Java

Directement de XKCD

C'est un jeu de pêche sans fin entre un parent et un enfant!

La cible de CHILDest définie sur PARENTet la cible de PARENTest le CHILD. Lorsque les PARENTappels AIM, il lève l'instance de la BALLclasse et il est attrapé par l'instruction catch. La déclaration catch appelle alors PARENT.TARGET.AIMoù la cible est le CHILD. L' CHILDinstance fait la même chose et "renvoie la balle" au parent.

Bash, 3 personnages

yes

oui retournera à plusieurs reprises «y» à la console

Edit: tout le monde est invité à éditer cette ligne:

yes something | xargs someaction

(merci à Olivier Dulac)

C, 35 caractères

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

Le programme s’exécute. Je ne sais pas si cela est considéré comme une récursion ou non.

C (avec les fonctions intégrées GCC - semble également fonctionner avec clang)

• Pas de boucles explicites
• Aucun gotos explicite
• Pas de récursion
• Juste du bon vieux jeu avec la pile (enfants, n'essayez pas ça à la maison sans surveillance):

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

Explication:

• main()premiers appels frameloop(NULL). Dans ce cas, utilisez la commande __builtin_return_address()intégrée pour obtenir l'adresse de retour (en main()) à laquelle frameloop()renvoyer. Nous retournons cette adresse.
• printf() pour montrer que nous sommes en boucle
• Maintenant, nous appelons frameloop()avec l'adresse de retour pour l'appel précédent. Nous examinons dans la pile l’adresse de retour actuelle et, lorsque nous la trouvons, nous substituons l’adresse de retour précédente.
• Nous revenons ensuite du 2e frameloop()appel. Mais puisque l'adresse de retour a été piratée, nous finissons par revenir au point de retour main()du premier appel. Nous nous retrouvons donc dans une boucle.

La recherche de l'adresse de retour dans la pile serait bien sûr plus nette, mais j'ai déroulé quelques itérations afin d'éviter toute boucle.

Sortie:

$ 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

Le code suivant ne contient aucune fonction récursive (même indirectement), aucune primitive en boucle et n'appelle aucune fonction récursive intégrée (utilise uniquement IOla sortie et la liaison), mais répète une action donnée indéfiniment:

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

Function extractn'appelle rien, ycappelle juste extractet mainappelle juste ycet putStrLnet >>, qui ne sont pas récursifs.

Explication: L'astuce réside dans le type de données récursif Strange. C'est un type de données récursif qui se consomme lui-même et qui, comme le montre l'exemple, permet une répétition arbitraire. Premièrement, nous pouvons construire extract x, ce qui exprime essentiellement une auto-application x xdans le calcul lambda non typé. Et cela permet de construire le combinateur Y défini comme λf.(λx.f(xx))(λx.f(xx)).

Mise à jour: comme suggéré, je publie une variante plus proche de la définition de Y dans le calcul lambda non typé:

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

Ce qui suit génère un compte à rebours de 10 à "Blast off!" en utilisant un modèle de métaprogrammation.

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

Cela peut ressembler à un exemple classique de récursivité, mais ce n’est pas le cas, du moins techniquement, selon votre définition. Le compilateur générera dix fonctions différentes . countdown<10>imprime "T moins 10" puis appelle countdown<9>, et ainsi de suite, pour countdown<0>imprimer "Blast off!" et revient ensuite. La récursivité se produit lorsque vous compilez le code, mais l'exécutable ne contient aucune structure en boucle.

En C ++ 11, on peut obtenir des effets similaires en utilisant le constexprmot clé, tel que cette fonction factorielle. (Il n'est pas possible d'implémenter l'exemple de compte à rebours de cette façon, car les constexprfonctions ne peuvent pas avoir d'effets secondaires, mais je pense que cela pourrait être possible dans le prochain C ++ 14.)

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

Encore une fois cela ressemble vraiment récursion, mais le compilateur étendra sur factorial(10)dans 10*9*8*7*6*5*4*3*2*1, puis remplacez probablement avec une valeur constante de 3628800, de sorte que l'exécutable ne contient aucune mise en boucle ou un code récursif.

Java

Jouons avec le chargeur de classes Java et définissons-le comme son propre parent:

import java.lang.reflect.Field;

public class Loop {
    public static void main(String[] args) throws Exception {
        System.out.println("Let's loop");
        Field field = ClassLoader.class.getDeclaredField("parent");
        field.setAccessible(true);
        field.set(Loop.class.getClassLoader(), Loop.class.getClassLoader());

    }
}

En fait, cette boucle est si puissante que vous devrez utiliser un kill -9bouton pour l'arrêter :-)

Il utilise 100,1% du processeur de mon Mac.

Vous pouvez essayer de déplacer le System.outà la fin de la fonction principale pour expérimenter un autre comportement amusant.

CSharp

Un de plus et tout aussi méchant:

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

Ce n'est pas une récursion ... c'est une réification des modèles de code. Bien qu'il semble que nous appelions la même méthode, le moteur d'exécution crée constamment de nouvelles méthodes. Nous utilisons le paramètre type de int, car cela l’oblige à créer un tout nouveau type et chaque instance de la méthode doit remplacer une nouvelle méthode. Il ne peut pas partager de code ici. Finalement, nous éliminons la pile d’appels car elle attend indéfiniment le retour de l’int qui a été promis mais jamais livré. De la même manière, nous continuons à écrire le type que nous avons créé pour le garder intéressant. En gros, chaque C que nous appelons est une méthode totalement nouvelle qui a juste le même corps. Ce n'est pas vraiment possible dans un langage comme C ++ ou D qui font leurs templates lors de la compilation. Depuis, C # JIT est super paresseux, il ne crée ce contenu qu’au dernier moment. Ainsi,

Redcode 94 (Core War)

MOV 0, 1

Copie l'instruction à l'adresse zéro pour en adresser une. Parce que dans Core War, toutes les adresses sont relatives à l'adresse actuelle du PC et modulo à la taille du noyau. Il s'agit d'une boucle infinie dans une instruction unique.

Ce programme (guerrier) s’appelle " Imp " et a été publié pour la première fois par AK Dewdney.

Dard

Je suppose que ce serait la manière classique de faire de la récursivité sans aucune fonction récursive réelle. Aucune fonction ci-dessous ne se désigne par son nom, directement ou indirectement.

(Essayez-le à 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

Pas très original mais petit. 20 caractères.

setInterval(alert,1)

Signaux en C

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

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

Le comportement de ce programme est évidemment très indéfini, mais aujourd’hui, sur mon ordinateur, il continue d’imprimer «Hello, world!».

Emacs Lisp

C’est le moment idéal pour montrer la conception puissante de Lisp où "le code est constitué de données et les données sont le code". Certes, ces exemples sont très inefficaces et cela ne devrait jamais être utilisé dans un contexte réel.

Les macros génèrent du code qui est une version non déroulée de la boucle supposée et ce code généré correspond à ce qui est évalué au moment de l'exécution.

repeat-it: permet de boucler N fois

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

test de répétition:

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

Cette macro est semblable à la précédente, repeat-itmais elle fonctionne exactement comme la macro en boucle courante. do-timesElle vous permet de spécifier un symbole qui sera lié à l’index de la boucle. Il utilise un symbole de temps d'expansion pour s'assurer que la variable d'index est définie correctement au début de chaque boucle, que vous modifiiez ou non sa valeur pendant le corps de la boucle.

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

test de répétition avec index:

Ce test montre que:

1. Le corps évalue N fois

2. la variable d'index est toujours définie correctement au début de chaque itération

3. changer la valeur d'un symbole nommé "repli" ne gâchera pas l'index

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

Calcul lambda non typé

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

Haskell, 24 caractères

sequence_ (repeat (print "abc"))

ou sous forme condensée, avec 24 caractères

sequence_$repeat$print"" 

(bien que le texte soit modifié, cela restera en boucle - cela imprimera deux guillemets et une nouvelle ligne à l'infini)

explication: print "abc" est fondamentalement une action d'E / S qui imprime simplement "abc".
repeat est une fonction qui prend une valeur x et retourne une liste infinie composée uniquement de x.
séquence_ est une fonction qui prend une liste d'actions I / O et renvoie une action I / O qui effectue toutes les actions de manière séquentielle.

donc, fondamentalement, ce programme dresse une liste infinie de commandes print "abc" et les exécute à plusieurs reprises. sans boucles ni récursivité.

ASM (x86 + I / O pour Linux)

Peu importe combien vos langages de haut niveau insupportables vont lutter, ce sera toujours une manipulation cachée du pointeur d’instructions. En fin de compte, ce sera une sorte de "goto" (jmp), à moins que vous ne soyez assez ennuyé pour dérouler la boucle au moment de l'exécution.

Vous pouvez tester le code sur Ideone

Vous pouvez également consulter une version plus raffinée de cette idée dans le code DOS de Matteo Italia .

Il commence par la chaîne 0..9 et le remplace par A..J. Aucun saut direct n’est utilisé (disons qu’il n’ya pas eu de "goto"), pas de récurrence non plus.

Le code pourrait probablement être plus petit avec un certain abus de calcul d'adresse, mais travailler sur un compilateur en ligne est gênant, donc je vais le laisser tel quel.

Partie centrale:

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

Code entier

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 préprocesseur

Une petite "technique" que j'ai imaginée lors d'un défi d'obscurcissement. Il n'y a pas de récursion de fonction, mais il y a ... récursion de fichier?

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

J'ai écrit / testé cela en utilisant gcc. Il est évident que votre compilateur doit prendre en charge la __INCLUDE_LEVEL__macro (ou la __COUNTER__macro avec quelques modifications) pour que celle-ci soit compilée. Cela devrait être assez évident de savoir comment cela fonctionne, mais pour le plaisir, lancez le préprocesseur sans compiler le code (utilisez le -Edrapeau avec gcc).

PHP

En voici un avec PHP. Boucle en incluant le même fichier jusqu'à ce que le compteur atteigne $ 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
?>

La même chose qu'une boucle for:

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

Python

Le code suivant ne contient aucune fonction récursive (directe ou indirecte), aucune primitive en boucle et n'appelle aucune fonction intégrée (à l'exception de 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 "Bonjour tout le monde!" un nombre de fois donné.

Explanation: Function zimplémente le combinateur strict de points Z qui, sans être défini de manière récursive, permet d'exprimer tout algorithme récursif.

code machine z80

Dans un environnement où vous pouvez exécuter à chaque adresse et mapper la ROM partout, mappez 64 Ko de ROM remplie de zéros sur l'espace d'adressage entier.

Ce qu'il fait: rien. À plusieurs reprises.

Comment ça marche: le processeur va commencer à s’exécuter, l’octet 00est une nopinstruction, il va donc continuer, atteindre l’adresse $ffff, se boucler $0000et continuer à exécuter nops jusqu’à ce que vous le réinitialisiez.

Pour le rendre légèrement plus intéressant, remplissez la mémoire avec une autre valeur (veillez à éviter les instructions de flux de contrôle).

Perl-regex

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

démo

ou essayez comme:

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

Le (?!)jamais correspondre. Le moteur des expressions rationnelles essaie donc de faire correspondre chaque position de largeur zéro dans la chaîne correspondante.

Le (q x x x 10)est le même que (" " x 10)- répétez les spacedix fois.

Edit: modification des "caractères" en position de largeur zéro afin d’être plus précis pour une meilleure compréhension. Voir les réponses à cette question de stackoverflow .

T-SQL -12

print 1
GO 9

En fait, il s’agit plutôt d’une bizarrerie de Sql Server Management Studio. GO est un séparateur de script et ne fait pas partie du langage T-SQL. Si vous spécifiez GO suivi d'un numéro, le bloc sera exécuté autant de fois.

C #

Imprime tous les entiers de 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 (dans le navigateur)

Que dis-tu de ça?

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

Imprime l'heure actuelle et recharge la page.