几年前曾提出过类似的问题，但这个问题甚至更棘手。

挑战很简单。写一个程序（在您所选择的语言），其不使用任何重复的结构，如重复执行代码while，for，do while，foreach或goto（所以对于你nitpickers，你不能用一个循环）。但是，在调用自身的函数中，不允许递归（请参见下面的定义）。那将使这一挑战变得太容易了。

对于循环中需要执行的内容没有任何限制，但是可以在答案中发布说明，以便其他人可以准确地了解正在执行的内容。

对于那些可能迷恋定义的人，此问题的循环定义为：

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

这个问题的递归定义将是您的标准递归函数定义：

A function that calls itself.

7月16日东部时间上午10点，获胜者将是投票最多的答案。祝好运！

更新：

为了平息仍在表达的困惑，这可能会有所帮助：

上述规则：

• 不要使用循环或转到
• 函数不能调用自己
• 在“循环”中做任何你想做的事

如果您想实现某些东西而规则没有明确禁止这样做，请继续进行。许多答案已经违反了规则。

红宝石

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次，并输入“橙色，您高兴我没有说香蕉吗？”。

它使用Ruby荒谬的即时方法定义功能来定义按字母顺序位于“ ahem”和“ also”（“ ahem”，“ ahen”，“ aheo”，“ ahep”，“ aheq”， “ aher”，“ ahes”，“ ahet”，“ aheu”，“ ahev” ...）首先打印香蕉，然后调用列表中的下一个。

Python-16

或任何其他具有eval的语言。

exec"print 1;"*9

尖锐的

我已经将代码扩展为更具可读性的方式，因为这不再是代码编程，并添加了一个增量计数器，以便人们可以实际看到此程序正在执行某些操作。

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

（请永远不要这样做）。

在开始时，我们创建P该类的新实例，当程序尝试退出时，将调用GC，该GC调用终结器，该终结器创建P该类的新实例，当其尝试清理时，该实例将创建一个调用终结器的新实例P。 。

该程序最终死亡。

编辑：莫名其妙地，这只在死亡前运行了大约45,000次。我不太清楚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+")()") })()

功能有趣！

一个函数，该函数创建与自身具有相同主体的另一个函数，然后运行它。

当达到堆栈限制并且整个对象折叠时，它将在最后显示hi。

免责声明：在达到堆栈限制之前，您将无法在浏览器中执行任何操作。

还有一个，更多的邪恶：

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在返回之前在堆栈上的入口点地址，从而生成一个无限循环。

爪哇

直接从XKCD

这是父母与孩子之间永无止境的捉迷藏游戏！

的目标CHILD设置为PARENT，目标PARENT为CHILD。当PARENT调用时AIM，它将引发BALL该类的实例，并由catch语句捕获。然后catch语句调用PARENT.TARGET.AIM目标为的位置CHILD。该CHILD实例确实相同，“丢球后”的父母。

重击，3个字符

yes

是，将反复向控制台返回“ y”

编辑：鼓励所有人编辑此行：

yes something | xargs someaction

（感谢Olivier Dulac）

C，35个字符

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

程序自行执行。我不确定这是否被视为递归。

C（带有GCC内置函数-似乎也可以与clang一起使用）

• 没有明确的循环
• 没有明确的提示
• 没有递归
• 只是把老式的东西弄乱了（孩子们，不要在没有监督的情况下在家尝试）：

#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()内建函数获取将返回的返回地址（in main()）frameloop()。我们返回此地址。
• printf() 表示我们正在循环
• 现在，我们frameloop()使用上次呼叫的返回地址进行呼叫。我们在堆栈中查找当前的返回地址，当找到它时，我们将替换先前的返回地址。
• 然后，我们从第二次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调用just yc和putStrLnand >>，这不是递归的。

说明：诀窍在于递归数据类型Strange。它是一种消耗自己的递归数据类型，如示例中所示，它允许任意重复。首先，我们可以构造extract x，它本质上x x在无类型的lambda演算中表示自我应用。并且这允许构造定义为的Y组合器λf.(λx.f(xx))(λx.f(xx))。

更新：按照建议，我发布了一个变体，它更接近于无类型lambda演算中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倒计时到“ Blast off！”。使用模板元编程。

#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类加载器，并将其设置为自己的父级：

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

    }
}

这个循环实际上是如此强大，您必须使用a kill -9来停止它:-)

它使用Mac的100,1％的CPU。

您可以尝试System.out在主要功能的末尾移动，以尝试其他有趣的行为。

尖锐的

同样邪恶的一个：

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

这不是递归...这是代码模板的形式化。看起来我们在调用同一方法，而运行时正在不断创建新方法。我们使用int的类型参数，因为这实际上迫使它创建一个全新的类型，并且该方法的每个实例都必须添加一个新方法。它不能在此处共享代码。最终，我们终止了调用栈，因为它无限期地等待我们承诺但从未交付过的int的返回。以类似的方式，我们继续编写我们创建的类型以使其有趣。基本上，我们调用的每个C都是一个具有相同主体的全新方法。对于像C ++或D这样在编译时执行其模板的语言，这实际上是不可能的。由于C＃JIT非常懒惰，因此它只会在最后可能的时刻创建这些东西。从而，

Redcode 94（核心战争）

MOV 0, 1

将指令从地址0复制到地址1。因为在《核心战争》中，所有地址都相对于当前的PC地址，并且与核心的大小取模，所以这是一条非跳转指令中的无限循环。

该程序（战士）称为“ 小鬼 ”，最早由AK Dewdney发布。

镖

我想这将是没有任何实际递归函数的经典递归方法。下面的任何函数都不会直接或间接地通过名称引用自身。

（在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)

C信号

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

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

该程序的行为显然是非常不确定的，但是今天，在我的计算机上，该程序一直在打印“ Hello，world！”。

埃马克斯·利斯普（Emacs Lisp）

这是展示Lisp强大功能的绝佳时机，其中“代码就是数据，数据就是代码”。当然，这些示例效率很低，因此切勿在实际环境中使用。

宏生成的代码是假定循环的展开版本，并且所生成的代码是在运行时评估的。

repeat-it：允许您循环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它允许您指定将绑定到循环索引的符号。它使用扩展时间符号来确保index变量在每个循环开始时都已正确设置，无论您是否在循环体内修改了它的值。

(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. 每次迭代开始时总是正确设置index变量

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

Haskell，24个字符

sequence_ (repeat (print "abc"))

或简写形式（包含24个字符）

sequence_$repeat$print"" 

（尽管文本已更改，但仍会循环-这将无限打印两个引号和一个换行符）

说明：print“ abc”本质上是一个仅打印“ abc”的I / O操作。
repeat是一个函数，它使用值x并返回仅由x组成的无限列表。
sequence_是一个函数，它接收I / O动作的列表，并返回按顺序执行所有动作的I / O动作。

因此，从根本上说，该程序制作了打印“ abc”命令的无限列表，然后重复执行它们。没有循环或递归。

ASM（用于Linux的x86 + I / O）

您微不足道的高级语言会费劲多少都无所谓，它仍然仅仅是隐藏的指令指针操作。最后，它将是某种“ goto”（jmp），除非您感到无聊足以在运行时展开循环。

您可以在Ideone上测试代码

您还可以在Matteo Italia DOS代码中签出此想法的更精炼版本。

它以0..9的字符串开头，并用A..J替换，不使用直接跳转（因此可以说没有“跳转”发生），也没有重复发生。

代码可能会因滥用地址计算而变得更小，但是使用在线编译器会很麻烦，因此我将其保留不变。

核心部分：

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)

打印“ Hello world！” 给定的次数。

说明：函数z实现了严格的Z定点组合器，该组合器（未递归定义）允许表达任何递归算法。

z80机器码

在可以在每个地址执行并且将ROM映射到任何地方的环境中，将填充零的ROM 64kb映射到整个地址空间。

它的作用：什么都没有。反复。

工作原理：处理器将开始执行，字节00是一条nop指令，因此它将继续执行，到达地址$ffff，环绕至$0000，然后继续执行nops，直到将其重置为止。

为了使其更具趣味性，请使用其他值填充内存（请注意避免控制流指令）。

Perl正则表达式

(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十次。

编辑：将“字符”更改为零宽度位置，以更精确地获得更好的易懂性。请参阅此stackoverflow问题的答案。

T-SQL -12

print 1
GO 9

实际上更多的是Sql Server Management Studio的怪癖。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;

打印当前时间并重新加载页面。