打印 1 到 1000 不带循环或条件答案

【问题标题】：Printing 1 to 1000 without loop or conditionals打印 1 到 1000 不带循环或条件
【发布时间】：2011-06-01 21:41:37
【问题描述】：

任务：打印从 1 到 1000 的数字，而不使用任何循环或条件语句。不要只写 1000 次 printf() 或 cout 语句。

你会如何使用 C 或 C++ 来做到这一点？

【问题讨论】：

显而易见的答案是使用 500 次调用 printf 并每次打印两个数字，不是吗？
printf("从 1 到 1000 的数字");
:? 不是条件语句（它是一个表达式）...
面试是你大放异彩的机会。告诉他们“没有循环或条件？这简直是天方夜谭。我不用电脑也能做到！”然后拿出笔和记事本。他们可能会让你一头雾水，但只是解释说，如果你不能指望内置的语言结构，你真的不能假设任何事情。
就我个人而言，我认为有几个答案有聪明、有趣的解决方案。我还认为，虽然这很容易成为一个糟糕的面试问题，但它可能有很好的价值，只要面试官真的不是在寻找一个完全格式良好的解决方案，而是在寻找受访者是否考虑了表明了解 TMP 或以不寻常的方式使用结构。我认为如果将其用作纯粹的“正确/错误”问题会很糟糕，但如果将其用作讨论的起点，我会看到很多价值。

标签： c++ c printf

【解决方案1】：

这个实际上编译为没有任何条件的程序集：

#include <stdio.h>
#include <stdlib.h>

void main(int j) {
  printf("%d\n", j);
  (&main + (&exit - &main)*(j/1000))(j+1);
}

编辑：添加了“&”，因此它会考虑地址，从而避免指针错误。

标准 C 中的上述版本，因为它不依赖于函数指针的算术运算：

#include <stdio.h>
#include <stdlib.h>

void f(int j)
{
    static void (*const ft[2])(int) = { f, exit };

    printf("%d\n", j);
    ft[j/1000](j + 1);
}

int main(int argc, char *argv[])
{
    f(1);
}

【讨论】：

好吧，这个答案中的代码显然既不是 C 也不是 C++，所以只有当我们放弃要求时才可以。那么任何答案都可能符合条件，因为假设的编译器可能只是从任何输入生成所需的程序。
@PP，解释起来很长，但基本上，j 最初是 1，因为它实际上是 argc，如果程序在没有参数的情况下调用，则它是 1。然后，j/1000 是 0，直到 j 变为 1000，然后是 1。 (exit - main) 当然是exit() 和main() 的地址的区别。这意味着(main + (exit - main)*(j/1000)) 是main()，直到j 变为1000，之后变为exit()。最终结果是在程序启动时调用main()，然后在递增j 的同时递归调用自身999 次，然后调用exit()。呼:)
这是我见过的最惊人的 C 滥用之一。但它会在所有平台上运行吗？
@Mark：这是main的非标准签名，不允许递归调用main，减去函数指针的结果是不确定的。
是的，是的，由于@ybungalobill 给出的原因，它不是严格合法的 C++ 代码，但我必须 +1 纯粹的精神错乱以及它确实可以在几个平台上编译和工作的事实。有时正确回答“但这不是标准的！”是“谁在乎！” :)

【解决方案2】：

编译时间递归！ :P

#include <iostream>
template<int N>
struct NumberGeneration{
  static void out(std::ostream& os)
  {
    NumberGeneration<N-1>::out(os);
    os << N << std::endl;
  }
};
template<>
struct NumberGeneration<1>{
  static void out(std::ostream& os)
  {
    os << 1 << std::endl;
  }
};
int main(){
   NumberGeneration<1000>::out(std::cout);
}

【讨论】：

有人可以向我解释这是如何工作的吗？相当令人印象深刻。
@Zack：让我们现实一点，我们正在从一个为故意避免循环而编写的程序中打印 1,000 行。性能不是问题。
对于那些好奇地编译它的人：在 g++ 中，设置 -ftemplate-depth-1000。默认模板递归最大值为 500。
这仍然使用条件：模式匹配是一种美化的 if。
@dreamlax：这只是我多年来从经验中学到的东西之一：使用'\n'，除非你真的想刷新，使用++i，除非你真的需要@的前一个值987654324@，通过const 参考，除非您有充分的理由不...当开发人员停止考虑这些（或什至从未开始）时，他们迟早会遇到重要的问题，只有他们甚至不知道有些地方可能很重要。

【解决方案3】：

#include <stdio.h>
int i = 0;
p()    { printf("%d\n", ++i); }
a()    { p();p();p();p();p(); }
b()    { a();a();a();a();a(); }
c()    { b();b();b();b();b(); }
main() { c();c();c();c();c();c();c();c(); return 0; }

我很惊讶似乎没有人发布这个 - 我认为这是最明显的方式。 1000 = 5*5*5*8.

【讨论】：

人们已经发布了这个。其他版本将数字传递给打印而不是使用全局，但它本质上是相同的解决方案。
@Chris，他们使用在宏或模板中表达的相同逻辑，从而扩大了代码大小，对吧？您还不如自己生成输出字符串而不是一千个 printfs。
哦，是的，我看到基思的回答确实生成了整个字符串，很酷。 :) 我错过了。
嗯，很好的努力，但奇怪的是你没有将 8 分解为 2*2*2 并因此使用了唯一的素数分解

【解决方案4】：

看起来不需要使用循环

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

【讨论】：

有人可能会说使用copy 是作弊
@Johannes 实际上我很确定printf 有一个循环：p
@litb：注意我没有说“使用copy 是作弊”
@John : 抄袭是作弊。你怀疑吗？ :P
从 1 到 10，我使用二进制的机会有多大？

【解决方案5】：

这是我知道的三个解决方案。不过，第二个可能会引起争议。

// compile time recursion
template<int N> void f1()
{ 
    f1<N-1>(); 
    cout << N << '\n'; 
}

template<> void f1<1>() 
{ 
    cout << 1 << '\n'; 
}

// short circuiting (not a conditional statement)
void f2(int N)
{ 
    N && (f2(N-1), cout << N << '\n');
}

// constructors!
struct A {
    A() {
        static int N = 1;
        cout << N++ << '\n';
    }
};

int main()
{
    f1<1000>();
    f2(1000);
    delete[] new A[1000]; // (3)
    A data[1000]; // (4) added by Martin York
}

[ 编辑： (1) 和 (4) 只能用于编译时常量，(2) 和 (3) 也可以用于运行时表达式 - 结束编辑。 ]

【讨论】：

另外，我会争辩说短路不是条件......不是一个陈述，真的，而是一个条件表达式，我会说。如果我们将条件表达式定义为“在汇编程序中产生条件跳转的东西”。
阅读构造函数一时遇到的问题：标准是否要求数组中的每个项目都按顺序构造？构造函数是否有副作用很重要。我确信每个理智的编译器都将它实现为 0->1000 循环，但我想知道你是否仍然可以兼容并向后循环......
@Joseph - 构造函数不应该受到各个对象启动顺序的影响，但这是一个很好的问题。
@Joseph 这是由 12.6/3 (C++03) 定义的。初始化按订阅顺序完成。
@Joseph：它们也以相反的顺序被破坏，所以你可以很容易地使用析构函数:)

【解决方案6】：

我不会写 1000 次 printf 语句！

printf("1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n11\n12\n13\n14\n15\n16\n17\n18\n19\n20\n21\n22\n23\n24\n25\n26\n27\n28\n29\n30\n31\n32\n33\n34\n35\n36\n37\n38\n39\n40\n41\n42\n43\n44\n45\n46\n47\n48\n49\n50\n51\n52\n53\n54\n55\n56\n57\n58\n59\n60\n61\n62\n63\n64\n65\n66\n67\n68\n69\n70\n71\n72\n73\n74\n75\n76\n77\n78\n79\n80\n81\n82\n83\n84\n85\n86\n87\n88\n89\n90\n91\n92\n93\n94\n95\n96\n97\n98\n99\n100\n101\n102\n103\n104\n105\n106\n107\n108\n109\n110\n111\n112\n113\n114\n115\n116\n117\n118\n119\n120\n121\n122\n123\n124\n125\n126\n127\n128\n129\n130\n131\n132\n133\n134\n135\n136\n137\n138\n139\n140\n141\n142\n143\n144\n145\n146\n147\n148\n149\n150\n151\n152\n153\n154\n155\n156\n157\n158\n159\n160\n161\n162\n163\n164\n165\n166\n167\n168\n169\n170\n171\n172\n173\n174\n175\n176\n177\n178\n179\n180\n181\n182\n183\n184\n185\n186\n187\n188\n189\n190\n191\n192\n193\n194\n195\n196\n197\n198\n199\n200\n201\n202\n203\n204\n205\n206\n207\n208\n209\n210\n211\n212\n213\n214\n215\n216\n217\n218\n219\n220\n221\n222\n223\n224\n225\n226\n227\n228\n229\n230\n231\n232\n233\n234\n235\n236\n237\n238\n239\n240\n241\n242\n243\n244\n245\n246\n247\n248\n249\n250\n251\n252\n253\n254\n255\n256\n257\n258\n259\n260\n261\n262\n263\n264\n265\n266\n267\n268\n269\n270\n271\n272\n273\n274\n275\n276\n277\n278\n279\n280\n281\n282\n283\n284\n285\n286\n287\n288\n289\n290\n291\n292\n293\n294\n295\n296\n297\n298\n299\n300\n301\n302\n303\n304\n305\n306\n307\n308\n309\n310\n311\n312\n313\n314\n315\n316\n317\n318\n319\n320\n321\n322\n323\n324\n325\n326\n327\n328\n329\n330\n331\n332\n333\n334\n335\n336\n337\n338\n339\n340\n341\n342\n343\n344\n345\n346\n347\n348\n349\n350\n351\n352\n353\n354\n355\n356\n357\n358\n359\n360\n361\n362\n363\n364\n365\n366\n367\n368\n369\n370\n371\n372\n373\n374\n375\n376\n377\n378\n379\n380\n381\n382\n383\n384\n385\n386\n387\n388\n389\n390\n391\n392\n393\n394\n395\n396\n397\n398\n399\n400\n401\n402\n403\n404\n405\n406\n407\n408\n409\n410\n411\n412\n413\n414\n415\n416\n417\n418\n419\n420\n421\n422\n423\n424\n425\n426\n427\n428\n429\n430\n431\n432\n433\n434\n435\n436\n437\n438\n439\n440\n441\n442\n443\n444\n445\n446\n447\n448\n449\n450\n451\n452\n453\n454\n455\n456\n457\n458\n459\n460\n461\n462\n463\n464\n465\n466\n467\n468\n469\n470\n471\n472\n473\n474\n475\n476\n477\n478\n479\n480\n481\n482\n483\n484\n485\n486\n487\n488\n489\n490\n491\n492\n493\n494\n495\n496\n497\n498\n499\n500\n501\n502\n503\n504\n505\n506\n507\n508\n509\n510\n511\n512\n513\n514\n515\n516\n517\n518\n519\n520\n521\n522\n523\n524\n525\n526\n527\n528\n529\n530\n531\n532\n533\n534\n535\n536\n537\n538\n539\n540\n541\n542\n543\n544\n545\n546\n547\n548\n549\n550\n551\n552\n553\n554\n555\n556\n557\n558\n559\n560\n561\n562\n563\n564\n565\n566\n567\n568\n569\n570\n571\n572\n573\n574\n575\n576\n577\n578\n579\n580\n581\n582\n583\n584\n585\n586\n587\n588\n589\n590\n591\n592\n593\n594\n595\n596\n597\n598\n599\n600\n601\n602\n603\n604\n605\n606\n607\n608\n609\n610\n611\n612\n613\n614\n615\n616\n617\n618\n619\n620\n621\n622\n623\n624\n625\n626\n627\n628\n629\n630\n631\n632\n633\n634\n635\n636\n637\n638\n639\n640\n641\n642\n643\n644\n645\n646\n647\n648\n649\n650\n651\n652\n653\n654\n655\n656\n657\n658\n659\n660\n661\n662\n663\n664\n665\n666\n667\n668\n669\n670\n671\n672\n673\n674\n675\n676\n677\n678\n679\n680\n681\n682\n683\n684\n685\n686\n687\n688\n689\n690\n691\n692\n693\n694\n695\n696\n697\n698\n699\n700\n701\n702\n703\n704\n705\n706\n707\n708\n709\n710\n711\n712\n713\n714\n715\n716\n717\n718\n719\n720\n721\n722\n723\n724\n725\n726\n727\n728\n729\n730\n731\n732\n733\n734\n735\n736\n737\n738\n739\n740\n741\n742\n743\n744\n745\n746\n747\n748\n749\n750\n751\n752\n753\n754\n755\n756\n757\n758\n759\n760\n761\n762\n763\n764\n765\n766\n767\n768\n769\n770\n771\n772\n773\n774\n775\n776\n777\n778\n779\n780\n781\n782\n783\n784\n785\n786\n787\n788\n789\n790\n791\n792\n793\n794\n795\n796\n797\n798\n799\n800\n801\n802\n803\n804\n805\n806\n807\n808\n809\n810\n811\n812\n813\n814\n815\n816\n817\n818\n819\n820\n821\n822\n823\n824\n825\n826\n827\n828\n829\n830\n831\n832\n833\n834\n835\n836\n837\n838\n839\n840\n841\n842\n843\n844\n845\n846\n847\n848\n849\n850\n851\n852\n853\n854\n855\n856\n857\n858\n859\n860\n861\n862\n863\n864\n865\n866\n867\n868\n869\n870\n871\n872\n873\n874\n875\n876\n877\n878\n879\n880\n881\n882\n883\n884\n885\n886\n887\n888\n889\n890\n891\n892\n893\n894\n895\n896\n897\n898\n899\n900\n901\n902\n903\n904\n905\n906\n907\n908\n909\n910\n911\n912\n913\n914\n915\n916\n917\n918\n919\n920\n921\n922\n923\n924\n925\n926\n927\n928\n929\n930\n931\n932\n933\n934\n935\n936\n937\n938\n939\n940\n941\n942\n943\n944\n945\n946\n947\n948\n949\n950\n951\n952\n953\n954\n955\n956\n957\n958\n959\n960\n961\n962\n963\n964\n965\n966\n967\n968\n969\n970\n971\n972\n973\n974\n975\n976\n977\n978\n979\n980\n981\n982\n983\n984\n985\n986\n987\n988\n989\n990\n991\n992\n993\n994\n995\n996\n997\n998\n999\n1000\n");

不客气；）

【讨论】：

我希望你写了一个程序来生成那行。
open("1000.c",'w').write('printf("%s");' % ("\n".join([str(x) for x in xrange(1,1000)])))
我希望您编写的生成该行的程序不包含循环！
一个 Vim 宏可以快速完成这项工作。
一点 Perl 以一种奇特的方式生成它：$r='printf("'; for (1..1000) { $r.="$_\\n" } $r.='");'; print $r;

【解决方案7】：

printf("%d\n", 2);
printf("%d\n", 3);

它不会打印所有数字，但它会“打印从 1 到 1000 的数字”。模棱两可的问题！ :)

【讨论】：

我最喜欢在 'printf("numbers from 1 to 1000")' 之后 - 愚蠢的问题需要愚蠢的答案。
这太棒了。 +1 利用问题中的歧义。哈哈
已编辑；这段代码print "Print numbers from 1 to 1000."绝不是任何形状或形式-获胜的模棱两可的问题，不准确的描述糟透了:)
哇，最近这个问题的答案有点被破坏了。有些东西告诉我我们应该将该锁升级为历史锁。

【解决方案8】：

触发致命错误！这是文件，countup.c：

#include <stdio.h>
#define MAX 1000
int boom;
int foo(n) {
    boom = 1 / (MAX-n+1);
    printf("%d\n", n);
    foo(n+1);
}
int main() {
    foo(1);
}

编译，然后在 shell 提示符下执行：

$ ./countup
1
2
3
...
996
997
998
999
1000
Floating point exception
$

这确实打印了从 1 到 1000 的数字，没有任何循环或条件！

【讨论】：

你应该调用 fflush(stdout);在每个 printf() 之后...当程序崩溃时，不能保证输出缓冲区会打印在屏幕上。
@zakk：这不是绝对必要的 - 默认情况下 stdout 是行缓冲的，所以 \n 足以刷新输出。
stdout 是行缓冲的如果可以确定它是一个交互式设备，否则它是完全缓冲的。如果教授将标准输出重定向到文件进行自动检查，您将失败:-)
stackoverflow 的危险（例如在嵌入式环境中）

【解决方案9】：

使用系统命令：

system("/usr/bin/seq 1000");

【讨论】：

很有可能/usr/bin/seq 在内部使用循环。 :)
@jokester：你的意思是，因为 Solaris/BSD 没有seq 实用程序（在默认设置中）？
我讨厌这么说（好吧，不，我不知道），但是您的解决方案中有一个错误。它不会打印出正确的数字集。 :) 解决方法如下：system("/bin/echo {1..1000}"); 如果您先编写了单元测试...
某个聪明的家伙决定改变我的答案，所以这不是我的错误。

【解决方案10】：

未经测试，但应该是香草标准 C：

void yesprint(int i);
void noprint(int i);

typedef void(*fnPtr)(int);
fnPtr dispatch[] = { noprint, yesprint };

void yesprint(int i) {
    printf("%d\n", i);
    dispatch[i < 1000](i + 1);
}

void noprint(int i) { /* do nothing. */ }

int main() {
    yesprint(1);
}

【讨论】：

@Prasoon：这是一种关系。
要求是“无条件”（if、switch 等）。不是“无条件”
< 不是条件。它是一个关系运算符。 if / else 是一个条件语句。 ?: 是一个条件运算符。 < 只是一个返回布尔值的运算符。它可能是一条没有跳转或任何东西的单一机器指令。
@Chris Lutz：在 x86 上，有 3 条指令：cmpl、setle 和 movzbl。 x86-64 就是加上cltq。 PowerPC 是 2 条指令：cmpwi 和 crnot。
1 - i / 1000。没有比较！

【解决方案11】：

与这里的其他人相比有点无聊，但可能是他们想要的。

#include <stdio.h>

int f(int val) {
    --val && f(val);
    return printf( "%d\n", val+1);
}

void main(void) {
    f(1000);
}

【讨论】：

缩短了。在 main 外部设置 i=1，然后在 main 内部设置： printf("%d\n", 11 - i) && --i && main(i);
@Jens Schauder：在f() 的第一行利用懒惰的&& 评估。
这并不无聊，它很简单。如果你可以用一个简短的函数来做同样的事情，就像你可以用大量的模板魔法一样，那么你应该用这个函数来做:)
&& 是有条件的。数学 AND 将评估双方（如 Java & 和 Ada "AND" 所做的）。 && 将仅评估第二个运算符 if （这里是）第一个为真。或其他示例：在 Ada 中，短路运算符称为“OR THEN” - 使用 THEN 表示条件方面。抱歉，您也可以使用 ? : 运算符。
无需道歉。 && 是一个比较运算符。三元运算符是一个条件。

【解决方案12】：

任务从未指定程序必须在 1000 之后终止。

void f(int n){
   printf("%d\n",n);
   f(n+1);
}

int main(){
   f(1);
}

（如果你运行 ./a.out 没有额外的参数，可以缩短到这个）

void main(int n) {
   printf("%d\n", n);
   main(n+1);
}

【讨论】：

不过，它不会停在 1000 处。它一直在继续。
只有在放弃 C 或 C++ 的要求时才能缩短。然后任何“程序”都可以，因为理论上的编译器可以生成您想要的程序（从任何输入）。
@eq 同样，编译和运行都很好……
事后想到：我们甚至可以避开明显数学。如果我们使用rand()，我们将打印所有从 1 到 1000 的数字。最终 =:P
@pooh：不一定，因为 rand() 有可能在某个序列之后重复，并且该序列可能不在此问题的解决方案集中

【解决方案13】：

简单易行！ :P

#include <iostream>

static int current = 1;

struct print
{
    print() { std::cout << current++ << std::endl; }
};

int main()
{
    print numbers [1000];
}

【讨论】：

您可能想要执行“static int current = 0”，否则会从 2 打印到 1001。
我将 ++current 更改为 current++

【解决方案14】：

#include <stdio.h>
#define Out(i)       printf("%d\n", i++);
#define REP(N)       N N N N N N N N N N
#define Out1000(i)   REP(REP(REP(Out(i))));
void main()
{
 int i = 1;
 Out1000(i);
}

【讨论】：

嗯。宏。晚餐吃什么。

【解决方案15】：

我们可以启动 1000 个线程，每个线程打印一个数字。安装OpenMPI，使用mpicxx -o 1000 1000.cpp编译并使用mpirun -np 1000 ./1000运行。您可能需要使用limit 或ulimit 来增加描述符限制。请注意，这会相当慢，除非您有大量内核！

#include <cstdio>
#include <mpi.h>
using namespace std;

int main(int argc, char **argv) {
  MPI::Init(argc, argv);
  cout << MPI::COMM_WORLD.Get_rank() + 1 << endl;
  MPI::Finalize();
}

当然，数字不一定按顺序打印，但题中并不要求它们按顺序打印。

【讨论】：

库中的隐式循环？但是无论如何都要为新方法 +1。
@Chris 大多数解决方案不是在某处有隐藏循环吗？
我想，如果您采用“编译器中的循环”方法。因为（在MPI::Init() 中的参数的可能循环之外）我无法想象在你的 1000.cpp 程序的实际二进制文件中有任何循环，我给了你一个 +1，即使你执行时肯定有循环在运行它。

【解决方案16】：

使用纯 C：

#include<stdio.h>

/* prints number  i */ 
void print1(int i) {
    printf("%d\n",i);
}

/* prints 10 numbers starting from i */ 
void print10(int i) {
    print1(i);
    print1(i+1);
    print1(i+2);
    print1(i+3);
    print1(i+4);
    print1(i+5);
    print1(i+6);
    print1(i+7);
    print1(i+8);
    print1(i+9);
}

/* prints 100 numbers starting from i */ 
void print100(int i) {
    print10(i);
    print10(i+10);
    print10(i+20);
    print10(i+30);
    print10(i+40);
    print10(i+50);
    print10(i+60);
    print10(i+70);
    print10(i+80);
    print10(i+90);
}

/* prints 1000 numbers starting from i */ 
void print1000(int i) {
    print100(i);
    print100(i+100);
    print100(i+200);
    print100(i+300);
    print100(i+400);
    print100(i+500);
    print100(i+600);
    print100(i+700);
    print100(i+800);
    print100(i+900);
}


int main() {
        print1000(1);
        return 0;
}

当然，您可以对其他基数（2：print2 print4 print8 ...）实现相同的想法，但这里的数字 1000 建议基数为 10。您也可以减少一点添加中间函数的行数：@987654322 @ 和其他等效替代方案。

【讨论】：

为什么数字 1000 建议以 10 为底？在任何以B 为基数的位置符号中，1000 都是一个完全有效的数字，并且始终等于B^3。
我的意思是，考虑到数字是如何以 10 为基数表示的，分解“10x10x10”本身就建议了，但其他替代方案也是可能的。我想我应该说“分解”而不是“基础”

【解决方案17】：

只需使用带有特殊迭代器的 std::copy() 即可。

#include <algorithm>
#include <iostream>
#include <iterator>

struct number_iterator
{
    typedef std::input_iterator_tag iterator_category;
    typedef int                     value_type;
    typedef std::size_t             difference_type;
    typedef int*                    pointer;
    typedef int&                    reference;

    number_iterator(int v): value(v)                {}
    bool operator != (number_iterator const& rhs)   { return value != rhs.value;}
    number_iterator operator++()                    { ++value; return *this;}
    int operator*()                                 { return value; }
    int value;
};



int main()
{
    std::copy(number_iterator(1), 
              number_iterator(1001), 
              std::ostream_iterator<int>(std::cout, " "));
}

【讨论】：

我认为您的代码从 0 开始。也同意 Chris，我多年前看到的问题是“除了 IO 之外没有任何库”。还 +1 :)
@Chris Lutz：复制的实现是未定义的。我什至可以使用上面的模板代码（你只是不知道）。所以你不能说它使用循环，因为我们不知道。
实际上，我最挑剔的不是std::copy 中的隐式循环，而是operator !=() 中的隐式条件。无论如何，这是处理范围的巧妙方法，而聪明的方法正是我在回答此类问题时所寻求的。
具体实现未定义
@selvaiyyamperumal：不确定你在说什么。但是，如果您在谈论行为，那么标准与您不同。 “实现定义的行为”意味着它定义明确，但必须由实现明确记录。 “未定义的行为”意味着任何事情都可能发生。

【解决方案18】：

函数指针（ab）使用。没有预处理器魔法来增加输出。 ANSI C.

#include <stdio.h>

int i=1;

void x10( void (*f)() ){
    f(); f(); f(); f(); f();
    f(); f(); f(); f(); f();
}

void I(){printf("%i ", i++);}
void D(){ x10( I ); }
void C(){ x10( D ); }
void M(){ x10( C ); }

int main(){
    M();
}

【讨论】：

这就是我的想法。前人说过5*5*5*8=1000。我认为他错过了明显的 10^3 很有趣。不错的解决方案！

【解决方案19】：

#include <iostream>
#include <iterator>
using namespace std;

int num() { static int i = 1; return i++; }
int main() { generate_n(ostream_iterator<int>(cout, "\n"), 1000, num); }

【讨论】：

【解决方案20】：

丑陋的 C 答案（每 10 次方仅展开一个堆栈帧）：

#define f5(i) f(i);f(i+j);f(i+j*2);f(i+j*3);f(i+j*4)
void f10(void(*f)(int), int i, int j){f5(i);f5(i+j*5);}
void p1(int i){printf("%d,",i);}
#define px(x) void p##x##0(int i){f10(p##x, i, x);}
px(1); px(10); px(100);

void main()
{
  p1000(1);
}

【讨论】：

一切正常，但为什么是“void main()”？坏习惯很少去？ :P
@Nawaz：因为这是一个秘密的 Windows GUI 应用程序，所以没关系。我只称它为“主要”，因为我在考虑龙虾并且拼写很糟糕。

【解决方案21】：

堆栈溢出：

#include <stdio.h>

static void print_line(int i)
{   
 printf("%d\n", i); 
 print_line(i+1);
}   

int main(int argc, char* argv[])
{   
 //get up near the stack limit
 char tmp[ 8388608 - 32 * 1000 - 196 * 32 ];
 print_line(1);
}

这是一个 8MB 的堆栈。每个函数调用似乎需要大约 32 个字节（因此是 32 * 1000）。但是当我运行它时，我只得到了 804（因此是 196 * 32；也许 C 运行时在堆栈中还有其他部分，你也必须扣除）。

【讨论】：

【解决方案22】：

函数指针的乐趣（不需要那些新奇的 TMP）：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>


#define MSB(typ) ((sizeof(typ) * CHAR_BIT) - 1)

void done(int x, int y);
void display(int x, int y);

void (*funcs[])(int,int)  = {
    done,
    display
};

void done(int x, int y)
{
    exit(0);
}

void display(int x, int limit)
{
    printf( "%d\n", x);
    funcs[(((unsigned int)(x-limit)) >> MSB(int)) & 1](x+1, limit);
}


int main()
{
    display(1, 1000);
    return 0;
}

附带说明：我将禁止条件扩展到逻辑和关系运算符。如果允许逻辑否定，递归调用可以简化为：

funcs[!!(limit-1)](x+1, limit-1);

【讨论】：

我喜欢您使用位移位的方式。但是经过您事后的简化，双重爆炸有什么作用？它是按位还是逻辑？我迷路了，谷歌让我绕圈子funcs[!!(limit-1)](x+1, limit-1);
我宁愿有一个 ! 并切换函数指针数组元素，但我不知道这是否会与你的其他疯狂配合。
@Chris：我完全同意——但直到发布后我才考虑使用逻辑/关系运算符，我认为单行补丁会更合适。此外，它更适合整个问题的混淆感觉。

【解决方案23】：

我觉得这个答案会非常简单易懂。

int print1000(int num=1)
{
    printf("%d\n", num);

    // it will check first the num is less than 1000. 
    // If yes then call recursive function to print
    return num<1000 && print1000(++num); 
}

int main()
{
    print1000();
    return 0;        
}

【讨论】：

你的答案使用了条件语句，根据问题是禁止的。
条件语句是 if else 等。我只是使用了逻辑运算！希望很清楚！
即使在您的 cmets 中，您也写过“如果是，则调用递归函数进行打印”。以不明显的方式编写的条件仍然是条件。 num 默认也是一个条件。

【解决方案24】：

我错过了所有的乐趣，所有好的 C++ 答案都已经发布了！

这是我能想出的最奇怪的事情，但我不敢打赌它是合法的 C99：p

#include <stdio.h>

int i = 1;
int main(int argc, char *argv[printf("%d\n", i++)])
{
  return (i <= 1000) && main(argc, argv);
}

还有一个，有点作弊：

#include <stdio.h>
#include <boost/preprocessor.hpp>

#define ECHO_COUNT(z, n, unused) n+1
#define FORMAT_STRING(z, n, unused) "%d\n"

int main()
{
    printf(BOOST_PP_REPEAT(1000, FORMAT_STRING, ~), BOOST_PP_ENUM(LOOP_CNT, ECHO_COUNT, ~));
}

最后的想法，同样的作弊：

#include <boost/preprocessor.hpp>
#include <iostream>

int main()
{
#define ECHO_COUNT(z, n, unused) BOOST_PP_STRINGIZE(BOOST_PP_INC(n))"\n"
    std::cout << BOOST_PP_REPEAT(1000, ECHO_COUNT, ~) << std::endl;
}

【讨论】：

我记得调用 main 会导致未定义的行为。
这是完全合法的 C。@ybungalobill：你一定在想 C++，其中明确禁止调用 main()。
@Michael：也许吧，我对 C 不是很熟悉。
我认为使用 Boost 意味着 C++。无论如何，对于 Boost.PP 解决方案的赞誉。
逻辑运算符 && 和 || 很可能属于“条件”，因为它们会短路（?: 也是如此）。

【解决方案25】：

如鱼得水：

int main(int argc, char* argv[])
{
    printf(argv[0]);
}

执行方法：

printer.exe "1;2;3;4;5;6;7;8;9;10;11;12;13;14;15;16;17;18;19;20;21;22;23;24;25;26;27;28;29;30;31;32;33;34;35;36;37;38;39;40;41;42;43;44;45;46;47;48;49;50;51;52;53;54;55;56;57;58;59;60;61;62;63;64;65;66;67;68;69;70;71;72;73;74;75;76;77;78;79;80;81;82;83;84;85;86;87;88;89;90;91;92;93;94;95;96;97;98;99;100;101;102;103;104;105;106;107;108;109;110;111;112;113;114;115;116;117;118;119;120;121;122;123;124;125;126;127;128;129;130;131;132;133;134;135;136;137;138;139;140;141;142;143;144;145;146;147;148;149;150;151;152;153;154;155;156;157;158;159;160;161;162;163;164;165;166;167;168;169;170;171;172;173;174;175;176;177;178;179;180;181;182;183;184;185;186;187;188;189;190;191;192;193;194;195;196;197;198;199;200;201;202;203;204;205;206;207;208;209;210;211;212;213;214;215;216;217;218;219;220;221;222;223;224;225;226;227;228;229;230;231;232;233;234;235;236;237;238;239;240;241;242;243;244;245;246;247;248;249;250;251;252;253;254;255;256;257;258;259;260;261;262;263;264;265;266;267;268;269;270;271;272;273;274;275;276;277;278;279;280;281;282;283;284;285;286;287;288;289;290;291;292;293;294;295;296;297;298;299;300;301;302;303;304;305;306;307;308;309;310;311;312;313;314;315;316;317;318;319;320;321;322;323;324;325;326;327;328;329;330;331;332;333;334;335;336;337;338;339;340;341;342;343;344;345;346;347;348;349;350;351;352;353;354;355;356;357;358;359;360;361;362;363;364;365;366;367;368;369;370;371;372;373;374;375;376;377;378;379;380;381;382;383;384;385;386;387;388;389;390;391;392;393;394;395;396;397;398;399;400;401;402;403;404;405;406;407;408;409;410;411;412;413;414;415;416;417;418;419;420;421;422;423;424;425;426;427;428;429;430;431;432;433;434;435;436;437;438;439;440;441;442;443;444;445;446;447;448;449;450;451;452;453;454;455;456;457;458;459;460;461;462;463;464;465;466;467;468;469;470;471;472;473;474;475;476;477;478;479;480;481;482;483;484;485;486;487;488;489;490;491;492;493;494;495;496;497;498;499;500;501;502;503;504;505;506;507;508;509;510;511;512;513;514;515;516;517;518;519;520;521;522;523;524;525;526;527;528;529;530;531;532;533;534;535;536;537;538;539;540;541;542;543;544;545;546;547;548;549;550;551;552;553;554;555;556;557;558;559;560;561;562;563;564;565;566;567;568;569;570;571;572;573;574;575;576;577;578;579;580;581;582;583;584;585;586;587;588;589;590;591;592;593;594;595;596;597;598;599;600;601;602;603;604;605;606;607;608;609;610;611;612;613;614;615;616;617;618;619;620;621;622;623;624;625;626;627;628;629;630;631;632;633;634;635;636;637;638;639;640;641;642;643;644;645;646;647;648;649;650;651;652;653;654;655;656;657;658;659;660;661;662;663;664;665;666;667;668;669;670;671;672;673;674;675;676;677;678;679;680;681;682;683;684;685;686;687;688;689;690;691;692;693;694;695;696;697;698;699;700;701;702;703;704;705;706;707;708;709;710;711;712;713;714;715;716;717;718;719;720;721;722;723;724;725;726;727;728;729;730;731;732;733;734;735;736;737;738;739;740;741;742;743;744;745;746;747;748;749;750;751;752;753;754;755;756;757;758;759;760;761;762;763;764;765;766;767;768;769;770;771;772;773;774;775;776;777;778;779;780;781;782;783;784;785;786;787;788;789;790;791;792;793;794;795;796;797;798;799;800;801;802;803;804;805;806;807;808;809;810;811;812;813;814;815;816;817;818;819;820;821;822;823;824;825;826;827;828;829;830;831;832;833;834;835;836;837;838;839;840;841;842;843;844;845;846;847;848;849;850;851;852;853;854;855;856;857;858;859;860;861;862;863;864;865;866;867;868;869;870;871;872;873;874;875;876;877;878;879;880;881;882;883;884;885;886;887;888;889;890;891;892;893;894;895;896;897;898;899;900;901;902;903;904;905;906;907;908;909;910;911;912;913;914;915;916;917;918;919;920;921;922;923;924;925;926;927;928;929;930;931;932;933;934;935;936;937;938;939;940;941;942;943;944;945;946;947;948;949;950;951;952;953;954;955;956;957;958;959;960;961;962;963;964;965;966;967;968;969;970;971;972;973;974;975;976;977;978;979;980;981;982;983;984;985;986;987;988;989;990;991;992;993;994;995;996;997;998;999;1000"

规范并没有说必须在代码内部生成序列:)

【讨论】：

【解决方案26】：

#include <cstdlib>
#include <iostream>
#include <string>
using namespace std;

class Printer
{
public:
 Printer() { cout << ++i_ << "\n"; }
private:
 static unsigned i_;
};

unsigned Printer::i_ = 0;

int main()
{
 Printer p[1000];
}

【讨论】：

【解决方案27】：

#include <stdio.h>

void nothing(int);
void next(int);
void (*dispatch[2])(int) = {next, nothing};

void nothing(int x) { }
void next(int x)
{
    printf("%i\n", x);
    dispatch[x/1000](x+1);
}

int main()
{
    next(1);
    return 0;
}

【讨论】：

【解决方案28】：

更多的预处理器滥用：

#include <stdio.h>

#define A1(x,y) #x #y "0\n" #x #y "1\n" #x #y "2\n" #x #y "3\n" #x #y "4\n" #x #y "5\n" #x #y "6\n" #x #y "7\n" #x #y "8\n" #x #y "9\n"
#define A2(x) A1(x,1) A1(x,2) A1(x,3) A1(x,4) A1(x,5) A1(x,6) A1(x,7) A1(x,8) A1(x,9)
#define A3(x) A1(x,0) A2(x)
#define A4 A3(1) A3(2) A3(3) A3(4) A3(5) A3(6) A3(7) A3(8) A3(9)
#define A5 "1\n2\n3\n4\n5\n6\n7\n8\n9\n" A2() A4 "1000\n"

int main(int argc, char *argv[]) {
    printf(A5);
    return 0;
}

我觉得很脏；我想我现在要去洗澡了。

【讨论】：

你能打电话给A2() 没有这样的论点吗？
我自己也很好奇。它适用于 GCC，但我不知道它是否是明确定义的行为。
在 C99 中定义良好，不记得 C89 说了什么，如果有记忆的话，至少在某些版本的 MSVC 上确实会造成问题。

【解决方案29】：

如果接受 POSIX 解决方案：

#include <stdio.h>
#include <signal.h>
#include <stdlib.h>
#include <sys/time.h>
#include <pthread.h>

static void die(int sig) {
    exit(0);
}

static void wakeup(int sig) {
    static int counter = 1;
    struct itimerval timer;
    float i = 1000 / (1000 - counter);

    printf("%d\n", counter++);

    timer.it_interval.tv_sec = 0;
    timer.it_interval.tv_usec = 0;
    timer.it_value.tv_sec = 0;
    timer.it_value.tv_usec = i; /* Avoid code elimination */
    setitimer(ITIMER_REAL, &timer, 0);
}

int main() {
    pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
    signal(SIGFPE, die);
    signal(SIGALRM, wakeup);
    wakeup(0);
    pthread_mutex_lock(&mutex);
    pthread_mutex_lock(&mutex); /* Deadlock, YAY! */
    return 0;
}

【讨论】：

【解决方案30】：

因为没有bug限制..

int i=1; int main() { int j=i/(i-1001); printf("%d\n", i++); main(); }

甚至更好（？），

#include <stdlib.h>
#include <signal.h>

int i=1;
int foo() { int j=i/(i-1001); printf("%d\n", i++); foo(); }

int main()
{
        signal(SIGFPE, exit);
        foo();
}

【讨论】：

你应该避免编译器优化，以保留其他未使用的 j。
他只需要在j的声明中加上volatile