预处理程序滥用!

#include <stdio.h>

void p(int x) { printf("%d\n", x); }

#define P5(x) p(x); p(x+1); p(x+2); p(x+3); p(x+4);
#define P25(x) P5(x) P5(x+5) P5(x+10) P5(x+15) P5(x+20)
#define P125(x) P25(x) P25(x+50) P25(x+75) P25(x+100)
#define P500(x) P125(x) P125(x+125) P125(x+250) P125(x+375)

int main(void)
{
  P500(1) P500(501)
  return 0;
}

预处理程序(参见gcc -E input.c)非常有趣。

看起来它不需要使用循环

printf("1 10 11 100 101 110 111 1000\n");

我不想破坏它，但递归和循环在机器级别本质上是相同的事情。

区别在于JMP/JCC与CALL指令的使用。两者都有大致相同的周期时间，并刷新指令管道。

我最喜欢的递归技巧是手工编写返回地址的PUSH，并对函数使用JMP。然后函数正常工作，并在结束时返回，但返回到其他地方。这对于更快地解析非常有用，因为它减少了指令管道刷新。

最初的海报可能是一个完整的展开，这是模板的人想出的;或者将页内存放入终端，如果您确切地知道终端文本存储在哪里。后者需要大量的洞察力和风险，但几乎不需要计算能力，并且代码没有像连续1000个打印文件那样的麻烦。

template <int remaining>
void print(int v) {
 printf("%d\n", v);
 print<remaining-1>(v+1);
}

template <>
void print<0>(int v) {
}

print<1000>(1);

这是我的两个解。第一个是c#，第二个是C语言:

C#:

const int limit = 1000;

Action<int>[] actions = new Action<int>[2];
actions[0] = (n) => { Console.WriteLine(n); };
actions[1] = (n) => { Console.WriteLine(n);  actions[Math.Sign(limit - n-1)](n + 1); };

actions[1](0);

C:

#define sign(x) (( x >> 31 ) | ( (unsigned int)( -x ) >> 31 ))

void (*actions[3])(int);

void Action0(int n)
{
    printf("%d", n);
}

void Action1(int n)
{
    int index;
    printf("%d\n", n);
    index = sign(998-n)+1;
    actions[index](++n);
}

void main()
{
    actions[0] = &Action0;
    actions[1] = 0; //Not used
    actions[2] = &Action1;

    actions[2](0);
}

Manglesky的解决方案很棒，但还不够模糊。: -):

#include <stdio.h>
#define TEN(S) S S S S S S S S S S
int main() { int i = 1; TEN(TEN(TEN(printf("%d\n", i++);))) return 0; }