लूप या सशर्त के बिना 1 से 1000 तक मुद्रण

Question

कार्य : किसी भी लूप या सशर्त विवरण का उपयोग किए बिना 1 से 1000 तक संख्या प्रिंट करें। केवल 1000 बार printf()या coutकथन न लिखें ।

आप ऐसा कैसे करेंगे कि C या C ++ का उपयोग करें?

Comments

स्पष्ट उत्तर है कि printfहर बार 500 कॉल का उपयोग करें और दो नंबर प्रिंट करें, नहीं?

— जेम्स मैकनेलिस

प्रिंटफ ("1 से 1000 तक की संख्या");

— जॉन्डविदजोन

:?एक सशर्त कथन नहीं है (यह एक अभिव्यक्ति है) ...

— क्रिस लूत्ज़

साक्षात्कार आपके चमकने का मौका। उन्हें बताएं "छोरों या सशर्त बिना? बच्चे का खेल। मैं इसे कंप्यूटर के बिना कर सकता हूं!" फिर कलम और नोटपैड बाहर खींचो। वे आपको एक भ्रमित रूप दे सकते हैं, लेकिन सिर्फ यह समझाएं कि यदि आप भाषा निर्माण में भरोसा नहीं कर सकते, तो आप वास्तव में कुछ भी नहीं मान सकते।

— JohnFx

व्यक्तिगत रूप से, मुझे लगता है कि ऐसे कई उत्तर थे जिनमें चतुर, दिलचस्प समाधान थे। मुझे यह भी लगता है कि जबकि यह आसानी से एक भयानक साक्षात्कार प्रश्न हो सकता है, इसमें अच्छा मूल्य हो सकता है, जब तक कि साक्षात्कारकर्ता वास्तव में पूरी तरह से अच्छी तरह से गठित समाधान के लिए इतना नहीं देख रहा है कि क्या साक्षात्कारकर्ता दृष्टिकोण पर विचार करता है टीएमपी का ज्ञान या असामान्य तरीकों से निर्माण का उपयोग करना। मुझे लगता है कि यह बुरा होगा अगर इसे एक शुद्ध 'मिला-सही / गलत' प्रश्न के रूप में उपयोग किया जाता है, लेकिन अगर इसे चर्चा के शुरुआती बिंदु के रूप में उपयोग किया जाता है, तो मैं बहुत अधिक मूल्य देख सकता हूं।

— माइकल बूर

Answer 1

संकलन समय पुनरावृत्ति! : पी

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

Comments

क्या कोई मुझे समझा सकता है कि यह कैसे काम करता है? बहुत प्रभावशाली।

— गत

@Zack: चलो असली है, हम लूप से बचने के लिए जानबूझकर लिखे गए प्रोग्राम से 1,000 लाइनों को प्रिंट कर रहे हैं। प्रदर्शन कोई मुद्दा नहीं है।

— ड्रीमलैक्स

इसको संकलित करने के लिए उत्सुक लोगों के लिए: जी ++ में, सेट-फीटमप्लेट-डेप्थ -१०००। डिफ़ॉल्ट टेम्पलेट पुनरावर्तन अधिकतम 500 है।

— टॉम

यह अभी भी सशर्त का उपयोग करता है: पैटर्न मिलान यदि एक महिमा है।

— डेविड के।

@dreamlax: यह उन चीजों में से एक है जिसे मैंने वर्षों से अनुभव से सीखा है: '\n'जब तक आप वास्तव में फ्लश करना चाहते हैं, ++iतब तक उपयोग करें जब तक आपको वास्तव में पूर्व मूल्य की आवश्यकता न हो i, constसंदर्भ द्वारा पास करें जब तक कि आपके पास अच्छा कारण न हो ... जब डेवलपर्स इन के बारे में सोचना बंद कर देते हैं (या कभी भी शुरू नहीं करते हैं), तो वे जल्दी या बाद में, एक समस्या में भाग लेते हैं जहां यह मायने रखता है, केवल वे भी नहीं जानते थे कि जहां यह मामला हो सकता है।

— एसबीआई

Answer 2

यह वास्तव में विधानसभा के लिए संकलित है जिसमें कोई भी शर्त नहीं है:

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

Comments

खैर, इस उत्तर में कोड स्पष्ट रूप से न तो सी और न ही सी ++ है, इसलिए यह केवल तभी ठीक है जब हम आवश्यकता को स्क्रैप करते हैं। तब कोई भी उत्तर अर्हता प्राप्त कर सकता है क्योंकि एक काल्पनिक संकलक किसी भी इनपुट से आवश्यक कार्यक्रम का उत्पादन कर सकता है।

— eq-

@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()जब प्रोग्राम शुरू होता है, तब कहा जाता है, फिर वृद्धि करते समय स्वयं को 999 बार कॉल करता है j, फिर कॉल करता है exit()। व्हीव :)

— Frédéric Hamidi

यह सीआई की अब तक की सबसे अद्भुत गालियों में से एक है। लेकिन क्या यह सभी प्लेटफार्मों पर काम करेगा?

— 22

@ मर्क: यह मुख्य का गैर मानक हस्ताक्षर है, आपको मुख्य रूप से पुनरावर्ती कॉल करने के लिए अस्वीकृत किया गया है, और फ़ंक्शन पॉइंटर्स को घटाने का परिणाम अपरिभाषित है।

— याकॉव गल्का

हाँ, हाँ, यह कड़ाई से कानूनी सी ++ कोड नहीं है क्योंकि @ybungalobill देता है, लेकिन मुझे सरासर पागलपन और इस तथ्य के लिए +1 करना है कि यह कुछ प्लेटफार्मों पर संकलन और काम करता है। ऐसे समय होते हैं जब सही प्रतिक्रिया "लेकिन यह मानक नहीं है!" "कौन परवाह करता है!" :)

— j_random_hacker

Answer 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.

Comments

लोगों ने इसे पोस्ट किया है। अन्य संस्करण वैश्विक उपयोग करने के बजाय प्रिंट करने के लिए संख्या को पास करते हैं, लेकिन यह अनिवार्य रूप से एक ही समाधान है।

— क्रिस लुत्ज़

@ क्रिस, वे मैक्रो या टेम्पलेट्स में व्यक्त एक ही तर्क का उपयोग करते हैं, कोड आकार को उड़ाते हैं, है ना? आप एक हजार प्रिंटआउट के बजाय आउटपुट स्ट्रिंग को स्वयं उत्पन्न कर सकते हैं।

— दारा बेकन

अरे हाँ, मैं देख रहा हूँ कि कीथ का जवाब पूरी स्ट्रिंग, कूल उत्पन्न करता है। :) मैंने यह खो दिया।

— डेरियस बेकन

ठीक है, अच्छा प्रयास है, लेकिन अजीब है कि आपने 8 को 2 * 2 * 2 में विघटित नहीं किया है और इस तरह से अनूठे प्रमुख कारक का उपयोग करें

— डेविड हेफर्नन

Answer 4

ऐसा लगता है कि इसे छोरों का उपयोग करने की आवश्यकता नहीं है

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

Comments

कोई यह तर्क copyदे सकता है कि धोखा देना

— जॉन डिब्लिंग

printf

— जोहान्स

@litb: ध्यान दें मैं नहीं कहा है कि "का उपयोग कर copy रहा है धोखा दे"

— जॉन Dibling

@ जॉन: नकल है धोखा दे। क्या आपको इसमें शक है? : पी

— नवाज

1 से 10 के पैमाने पर, क्या मौका है जो मैं बाइनरी का उपयोग कर रहा हूं?

— जॉर्डन

Answer 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) रनटाइम एक्सप्रेशन के लिए भी उपयोग किया जा सकता है । ]

Comments

इसके अलावा, मैं एक शॉर्ट-सर्किट के बारे में एक सशर्त नहीं होने के बारे में तर्क दूंगा ... एक बयान नहीं, सच है, लेकिन एक सशर्त अभिव्यक्ति है, मैं कहूंगा। बशर्ते हम एक सशर्त अभिव्यक्ति को "कुछ जो कि असेंबलर में सशर्त कूदता है" के रूप में परिभाषित करते हैं।

— कोस

प्रश्न जो कंस्ट्रक्टर एक को पढ़ते समय मुझे मारा जाता है: क्या मानक जनादेश है कि सरणी में प्रत्येक आइटम का निर्माण क्रम में किया जाना चाहिए? इससे फर्क पड़ेगा कि कंस्ट्रक्टर का साइड इफेक्ट है या नहीं। मुझे यकीन है कि प्रत्येक समझदार कंपाइलर इसे 0-> 1000 लूप के रूप में लागू करता है, लेकिन मुझे आश्चर्य है कि अगर आप अभी भी आज्ञाकारी और लूप बैकवर्ड हो सकते हैं ...

— जोसेफ गार्विन

@ जोसेफ - कंस्ट्रक्टर एक को प्रभावित नहीं किया जाना चाहिए कि व्यक्तिगत वस्तुओं को किस क्रम में शुरू किया गया है, लेकिन यह एक अच्छा सवाल है।

— क्रिस लुत्ज़

@ जोसेफ इसे 12.6 / 3 (C ++ 03) द्वारा परिभाषित किया गया है। आरंभिक सदस्यता क्रम में किया जाता है।

— जोहान्स स्काउब -

@ जोसेफ: और वे उल्टे क्रम में भी नष्ट हो जाते हैं, इसलिए आप एक विध्वंसक का उपयोग आसानी से कर सकते हैं :)

— j_random_hacker

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

आपका स्वागत है ;)

Comments

मुझे आशा है कि आपने उस पंक्ति को बनाने के लिए एक कार्यक्रम लिखा था।

— मार्टिन

खुला ("1000.c", 'w')। लिखें ('printf ("% s"); "% (" \ n ")। xoin (x (x) x x के लिए xrange (1,1000)]) ))

— टायलर इव्स

मुझे उम्मीद है कि आपने उस लाइन को जनरेट करने के लिए जो प्रोग्राम लिखा था उसमें लूप नहीं था!

— जेयॉन्ग किम

एक विम मैक्रो जल्दी से काम करेगा।

— 19

पर्ल का एक सा यह एक फैंसी तरीके से उत्पन्न करता है:$r='printf("'; for (1..1000) { $r.="$_\\n" } $r.='");'; print $r;

— sidyll

Answer 7

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

यह सभी नंबरों को प्रिंट नहीं करता है , लेकिन यह "1 से 1000 तक नंबर प्रिंट करता है।" जीत के लिए अस्पष्ट प्रश्न! :)

Comments

मेरे पसंदीदा के बाद 'प्रिंटफ ("संख्या 1 से 1000 तक") - मूर्खतापूर्ण प्रश्नों के लिए मूर्खतापूर्ण उत्तर की आवश्यकता होती है।

— सेजस्ट्रॉम

यह कमाल का है। प्रश्न में अस्पष्टता का लाभ उठाने के लिए +1। हहा

— नवाज

संपादित; किसी भी तरह से, आकार या रूप में इस कोड ने नहीं किया print "Print numbers from 1 to 1000."- जीत के लिए अस्पष्ट प्रश्न, गलत विवरण चूसना :)

— sehe

वाह, इस सवाल के जवाबों पर हाल ही में थोड़ी बर्बरता हुई है। कुछ मुझे बताता है कि हमें उस ताले को एक ऐतिहासिक लॉक में अपग्रेड करना चाहिए।

— BoltClock

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

संकलित करें, फिर शेल प्रॉम्प्ट पर निष्पादित करें:

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

यह वास्तव में 1 से 1000 तक संख्याओं को प्रिंट करता है, बिना किसी लूप या सशर्त के!

Comments

आपको फ़्लफ़श (स्टडआउट) को कॉल करना चाहिए; प्रत्येक प्रिंटफ () के बाद ... जब कोई प्रोग्राम क्रैश होता है तो यह गारंटी नहीं दी जाती है कि आउटपुट बफर स्क्रीन पर मुद्रित किया जाएगा।

— १

@zakk: यह कड़ाई से आवश्यक नहीं है - डिफ़ॉल्ट रूप से स्टडआउट लाइन बफर है, इसलिए \nआउटपुट फ्लश करने के लिए पर्याप्त होगा।

— भजन

यदि यह एक संवादात्मक उपकरण होने के लिए निर्धारित किया जा सकता है, तो stdout लाइन बफ़र है , अन्यथा यह पूरी तरह से बफ़र्ड है। यदि प्रोफेसर स्वचालित जाँच के लिए किसी फ़ाइल पर रीडायरेक्ट करता है, तो आप फेल हो

— जायेंगे

— स्टैकओवरफ्लो

Answer 9

सिस्टम कमांड का उपयोग करना:

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

Comments

उच्च मौका /usr/bin/seqआंतरिक रूप से एक लूप का उपयोग करता है। :)

@ जोस्टर: आपका मतलब है, क्योंकि सोलारिस / बीएसडी की seqउपयोगिता (डिफ़ॉल्ट सेटअप में) नहीं है? <grin />

— sehe

मुझे यह कहने से नफरत है (ठीक है, नहीं, मैं नहीं), लेकिन आपके समाधान में एक बग है। यह संख्याओं के सही सेट का प्रिंट आउट नहीं लेता है। :) यहाँ ठीक है: system("/bin/echo {1..1000}"); यदि केवल आपने पहले यूनिट टेस्ट लिखा था ...

— डॉन ब्रैनसन

कुछ उज्ज्वल दोस्त ने मेरे जवाब को बदलने का फैसला किया, इसलिए यह मेरी गलती नहीं है।

— मोइनुद्दीन

Answer 10

अनुपचारित, लेकिन वेनिला मानक सी होना चाहिए:

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

Comments

@Prasoon: यह एक रिश्ता है।

— याकोव गल्का

आवश्यकता "कोई शर्त नहीं" है (यदि, स्विच, आदि)। नहीं "कोई स्थिति नहीं"

— jon_darkstar

<एक शर्त नहीं है। यह एक रिलेशनल ऑपरेटर है। if/ elseएक सशर्त बयान है। ?:एक सशर्त ऑपरेटर है। <बस एक ऑपरेटर है जो बूलियन मान लौटाता है। यह शायद कोई जंप या कुछ भी नहीं के साथ एक एकल मशीन निर्देश है।

— क्रिस लुत्ज़

@Chris लुट्ज़: 86 पर, यह 3 निर्देश दिया गया है: cmpl, setle, और movzbl। x86-64 यह है कि प्लस ए cltq। पावरपीसी 2 निर्देश हैं: cmpwiऔर crnot।

— एडम रोसेनफील्ड

1 - i / 1000। कोई तुलना नहीं!

— थाई

Answer 11

यहां दूसरों की तुलना में थोड़ा उबाऊ है, लेकिन शायद वे जो खोज रहे हैं।

#include <stdio.h>

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

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

Comments

इसे छोटा कर दिया। सेट i = 1 मुख्य के बाहर और फिर मुख्य के अंदर: प्रिंटफ ("% d \ n", 11 - i) और& --i && मुख्य (i);

— jftuga

@ जेंस स्काउडर: &&की पहली पंक्ति में आलसी मूल्यांकन का लाभ उठाकर f()।

— राफेल डॉवगर्ड

यह उबाऊ नहीं है, यह सरल है। यदि आप एक छोटे से कार्य के साथ एक ही कार्य कर सकते हैं जैसा कि आप टेम्पलेट जादू की एक बड़ी गड़बड़ी के साथ कर सकते हैं, तो आपको इसे फ़ंक्शन के साथ करना चाहिए :)

— amertune

&& एक सशर्त है। एक गणितीय AND दोनों पक्षों का मूल्यांकन करेगा (जैसे जावा और Ada "और" करता है)। && केवल दूसरे ऑपरेटर का मूल्यांकन करेगा यदि (यहां यह है) पहला सच है। या अन्य उदाहरण: Ada में शॉर्ट-सर्किट ऑपरेटर को "OR THEN" कहा जाता है - सशर्त पहलू को इंगित करने के लिए THEN का उपयोग करना। क्षमा करें, आप बस इस्तेमाल किया जा सकता है? : ऑपरेटर।

— मार्टिन

माफी मांगने की कोई जरूरत नहीं है। && एक तुलना ऑपरेटर है। टर्नेरी संचालक एक सशर्त है।

— आरोन

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

Comments

यह 1000 पर नहीं रुकता है, हालांकि। यह बस चलता रहता है।

— रेमी लेबेउ

केवल तभी छोटा किया जा सकता है जब आप C या C ++ की आवश्यकता को कम करते हैं। फिर कोई भी "प्रोग्राम" करेगा, क्योंकि एक सैद्धांतिक संकलक उस प्रोग्राम को उत्पन्न कर सकता है जिसे आप (किसी इनपुट से) चाहते हैं।

— eq-

@ ईक अगेन, यह संकलन करता है और ठीक चलता है ...

— मार्क मैक्डोनाल्ड

एक विचार के रूप में: हम भी स्पष्ट गणित से बच सकते हैं । यदि हम काम करते हैं rand(), तो हम उन सभी की संख्या 1 से 1000 तक प्रिंट करेंगे। आखिरकार =: P

@pooh: जरूरी नहीं है, क्योंकि रैंड () के पास निश्चित अनुक्रम के बाद दोहराने का मौका है, और वह क्रम इस समस्या के समाधान में नहीं गिर सकता है

— dchhetri

Answer 13

बहुत आसान! : पी

#include <iostream>

static int current = 1;

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

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

Comments

आप "स्थिर इंट करंट = 0" करना चाहते हैं अन्यथा 2 से 1001 तक प्रिंट होगा।

— शिनोक

मैंने ++ को वर्तमान से वर्तमान ++ में बदल दिया

— ज़ेलिक्स

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

Comments

Ummmm। मैक्रो। यह रात के खाने के लिए है।

— EvilTeach

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

बेशक, संख्या अनिवार्य रूप से क्रम में मुद्रित नहीं की जाएगी, लेकिन सवाल उन्हें आदेश देने की आवश्यकता नहीं है।

Comments

पुस्तकालय में निहित लूप? लेकिन एक नए दृष्टिकोण के लिए वैसे भी +1।

— क्रिस लुत्ज़

@ क्रिस ज्यादातर समाधान कहीं एक छिपे हुए पाश नहीं है?

— मोइनुद्दीन

मुझे लगता है, अगर आप "संकलक में छोरों" दृष्टिकोण लेते हैं। चूंकि (तर्कों पर संभावित लूप के बाहर MPI::Init()) मैं आपके 1000.cpp प्रोग्राम के वास्तविक बाइनरी में किसी भी लूप की कल्पना नहीं कर सकता, मैंने आपको +1 दिया, हालांकि जब आप इसे निष्पादित करते हैं तो निश्चित रूप से लूप चल रहे होते हैं।

— क्रिस लुत्ज़

Answer 16

सादे सी के साथ:

#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: प्रिंट 2 प्रिंट 4 प्रिंट 8 ...) लेकिन संख्या 1000 यहां सुझाए गए आधार 10. आप मध्यवर्ती कार्यों को जोड़ने वाली लाइनों की संख्या को थोड़ा कम कर सकते हैं: print2() print10() print20() print100() print200() print1000()और अन्य समकक्ष विकल्प।

Comments

1000 नंबर बेस 10 का सुझाव क्यों देता है? आधार के साथ किसी भी स्थिति संकेतन में B, 1000 पूरी तरह से मान्य संख्या है और हमेशा बराबर होती है B^3।

— फिलिप

मेरा मतलब सिर्फ यह है कि यह देखते हुए कि आधार १० में संख्या का प्रतिनिधित्व कैसे किया जाता है, "10x10x10" कारक ने खुद ही सुझाव दिया, लेकिन यह अन्य विकल्प संभव है। मुझे लगता है कि मुझे "आधार" के बजाय "कारक" कहा जाना चाहिए था

— leonbloy

Answer 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, " "));
}

Comments

मुझे लगता है कि आपका कोड 0. से शुरू होता है। क्रिस के साथ भी सहमत हूं, जैसा कि मैंने वर्षों पहले देखा था, "ओओ को छोड़कर किसी भी पुस्तकालय के बिना" कहा गया था। अभी तक :) :)

— याकॉव गल्का

@ क्रिस लुत्ज़: प्रतिलिपि का कार्यान्वयन अपरिभाषित है। मैं ऊपर के रूप में भी टेम्प्लेट कोड का उपयोग कर सकता हूं (आप अभी नहीं जानते हैं)। इसलिए आप यह नहीं कह सकते कि यह एक लूप का उपयोग करता है क्योंकि हम नहीं जानते।

— मार्टिन यॉर्क

वास्तव में, मेरे नाइट पिक में अंतर्निहित लूप नहीं होगा, std::copyक्योंकि इसमें अंतर्निहित शर्त है operator !=()। भले ही, यह एक सीमा को संसाधित करने में एक चतुर है, और इस तरह के सवालों के जवाब में मैं क्या देख रहा हूं, चतुर दृष्टिकोण है।

— माइकल बूर

कार्यान्वयन विशिष्ट अपरिभाषित है

— selvaiyyamperumal

@selvaiyyamperumal: निश्चित रूप से बिल्कुल नहीं कि आप किस बारे में बात कर रहे हैं। लेकिन अगर आप व्यवहार के बारे में बात कर रहे हैं तो मानक आपसे असहमत है। "कार्यान्वयन परिभाषित व्यवहार" का अर्थ है कि यह अच्छी तरह से परिभाषित है लेकिन कार्यान्वयन द्वारा स्पष्ट रूप से प्रलेखित किया जाना चाहिए। "अपरिभाषित व्यवहार" का मतलब कुछ भी हो सकता है।

— मार्टिन

Answer 18

फ़ंक्शन पॉइंटर (ab) उपयोग। आउटपुट बढ़ाने के लिए कोई प्रीप्रोसेसर जादू नहीं। ANSI सी।

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

Comments

यही मैं सोच रहा था। एक पिछले व्यक्ति ने कहा कि 5 * 5 * 5 * 8 = 1000। मुझे लगा कि यह मजाकिया था वह स्पष्ट 10 ^ 3 को याद कर रहा था। अच्छा समाधान!

— इवान मोरन

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

Answer 20

बदसूरत सी उत्तर (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);
}

Comments

सभी चीजें ठीक है, लेकिन क्यों "शून्य मुख्य ()"? बुरी आदतें शायद ही कभी जाती हैं? : पी

— नवाज

@ नवाज़: क्योंकि यह गुप्त रूप से एक विंडोज जीयूआई ऐप है, इसलिए यह कोई फर्क नहीं पड़ता। मैंने केवल इसे "मुख्य" कहा क्योंकि मैं झींगा मछली के बारे में सोच रहा था और भयानक वर्तनी है।

— मार्टिन

Answer 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; शायद सी रनटाइम स्टैक में अन्य भाग हैं जिन्हें आपको भी कटौती करनी है)।

Answer 22

फ़ंक्शन पॉइंटर्स के साथ मज़ा (उस नए fangled 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);

Comments

मुझे वह तरीका पसंद है जिसे आपने बिट शिफ्ट के साथ प्राप्त किया है। लेकिन आपके सरलीकरण के बाद, डबल धमाका क्या करता है? इसकी बिटवाइज़ या तार्किक? im लॉस्ट एंड गूगल ने मुझे सर्किलों में घूमने का मौका दियाfuncs[!!(limit-1)](x+1, limit-1);

— jon_darkstar

मेरे पास एक एकल होगा !और फ़ंक्शन पॉइंटर सरणी तत्वों को स्विच करेगा, लेकिन मुझे नहीं पता कि यह आपके अन्य पागलपन के साथ अच्छा खेलेगा या नहीं।

— क्रिस लूत्ज

@ क्रिस: मैं पूरी तरह सहमत हूं - लेकिन मैंने पोस्ट करने के बाद तक तार्किक / संबंध ऑपरेटरों का उपयोग करने पर विचार नहीं किया, और मुझे लगा कि एक सिंगल-लाइन पैच अधिक उपयुक्त होगा। इसके अलावा, यह समस्या के पूरे मोटे तौर पर महसूस के साथ थोड़ा बेहतर है।

— माइकल बूर

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

Comments

आपका उत्तर सशर्त बयानों का उपयोग करता है, जो प्रश्न के अनुसार निषिद्ध हैं।

— स्टेव्लोव

सशर्त बयान हैं अगर और आदि मैं सिर्फ एक तार्किक ऑपरेशन का इस्तेमाल किया !! यह स्पष्ट है!

— पप्पू

यहां तक ​​कि आपकी टिप्पणियों में आपने लिखा है "यदि हाँ, तो प्रिंट करने के लिए पुनरावर्ती फ़ंक्शन को कॉल करें"। एक अभद्र तरीके से लिखा गया एक सशर्त अभी भी एक सशर्त है। संख्या डिफ़ॉल्ट भी एक सशर्त है।

— Gerry

Answer 24

मुझे सारी मस्ती याद आ गई, सभी अच्छे C ++ उत्तर पहले ही पोस्ट कर दिए गए हैं!

यह सबसे अजीब बात है जिसके साथ मैं आ सकता था, मैं शर्त लगाऊंगा कि यह कानूनी C99 नहीं है: पी

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

Comments

mainजैसा कि मुझे याद है अपरिभाषित व्यवहार में परिणाम कहते हैं ।

— याकॉव गल्का

यह पूरी तरह से कानूनी है। सी। बंगलाबिल: आप सी ++ के बारे में सोच रहे होंगे, जहां कॉलिंग मेन () विशेष रूप से अस्वीकृत है।

— माइकल फोकरिसिस

@ मिचेल: हो सकता है, मैं सी। से बहुत परिचित नहीं हूं

— याकोव गल्का

मुझे लगता है कि बूस्ट का उपयोग सी ++ का मतलब है। भले ही, Boost.PP समाधान के लिए यश।

— me22

तार्किक ऑपरेटरों &&और ||संभावना "सशर्त" के अंतर्गत आते हैं, क्योंकि वे शॉर्ट सर्किट (होगा के रूप में ?:)।

— उदार

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

विनिर्देश यह नहीं कहता कि अनुक्रम कोड के अंदर उत्पन्न होना चाहिए :)

Answer 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];
}

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

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

मुझे बहुत गंदा लगता है; मुझे लगता है कि मैं अब स्नान करूँगा।

Comments

क्या आप इस A2()तरह के तर्क के बिना फोन कर सकते हैं ?

— क्रिस लुत्ज़

मुझे स्वयं उस पर उत्सुकता हुई। यह जीसीसी के साथ ठीक से काम करता है, लेकिन मुझे नहीं पता कि यह अच्छी तरह से परिभाषित व्यवहार है।

— कीथ्मो

C99 में अच्छी तरह से परिभाषित, याद नहीं है कि C89 ने क्या कहा था, यदि स्मृति कार्य करती है तो MSVC के कम से कम कुछ संस्करणों के साथ परेशानी होती है।

— zwol

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

Answer 30

चूंकि बग पर कोई प्रतिबंध नहीं है।

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

Comments

आपको संकलक अनुकूलन से बचना चाहिए, अन्यथा अप्रयुक्त जे रखने के लिए।

— बंदगी

उसे केवल volatileघोषणा में जोड़ने की जरूरत हैj

— पैट्रिक श्ल्टर