লুপ বা শর্ত ছাড়াই 1 থেকে 1000 মুদ্রণ করা হচ্ছে

Question

কার্য : কোনও লুপ বা শর্তাধীন বিবৃতি না দিয়ে 1 থেকে 1000 পর্যন্ত সংখ্যা মুদ্রণ করুন। শুধু 1000 বার printf()or coutস্টেটমেন্টটি লিখবেন না ।

আপনি কীভাবে সি বা সি ++ ব্যবহার করে তা করবেন?

Comments

সুস্পষ্ট উত্তরটি হ'ল 500 বার কল করা printfএবং প্রতিবার দুটি নম্বর প্রিন্ট করা, না?

— জেমস ম্যাকনেলিস

প্রিন্টফ ("1 থেকে 1000 পর্যন্ত সংখ্যা");

— jondavidjohn

:?শর্তযুক্ত বিবৃতি নয় (এটি একটি অভিব্যক্তি) ...

— ক্রিস লুটজ

সাক্ষাত্কারটি আপনার চকমক করার সুযোগ। তাদের বলুন "লুপ বা শর্ত ছাড়াই? সন্তানের খেলা? আমি কম্পিউটার ছাড়াই এটি করতে পারি!" তারপরে কলম এবং নোটপ্যাড টানুন। তারা আপনাকে একটি বিভ্রান্ত চেহারা দিতে পারে, তবে কেবল ব্যাখ্যা করুন যে আপনি যদি ভাষা নির্মাণে গণনা করতে না পারেন তবে আপনি সত্যিই কিছু অনুমান করতে পারবেন না।

— জনএফএক্স

ব্যক্তিগতভাবে, আমি মনে করি যে বেশ কয়েকটি উত্তর ছিল যেগুলির চতুর, আকর্ষণীয় সমাধান ছিল। আমি আরও মনে করি যে এটি সহজেই একটি ভয়াবহ সাক্ষাত্কারের প্রশ্ন হতে পারে, তবে এর মধ্যে ভাল মূল্য থাকতে পারে, যতক্ষণ পর্যন্ত ইন্টারভিউওয়ালা ইন্টারভিউওয়ালা বিবেচনা করে এমন কোনও পদ্ধতির নির্দেশ করে যে কোনও ইন্টারভিউ বিবেচিত কিনা তা সন্ধানের জন্য পুরোপুরি সুগঠিত সমাধানের জন্য এতটা তত্পর নন টিএমপি সম্পর্কে জ্ঞান বা অস্বাভাবিক উপায়ে কনস্ট্রাক্ট ব্যবহার করে। আমি মনে করি এটি শুদ্ধ 'গেট-ইট-রাইট / ভুল' প্রশ্ন হিসাবে এটি ব্যবহার করা হলে এটি খারাপ হবে, তবে এটি যদি কোনও আলোচনার সূচনার পয়েন্ট হিসাবে ব্যবহৃত হয় তবে আমি অনেক মূল্য দেখতে পেতাম।

— মাইকেল বুড়

Answer 1

সংকলন সময় পুনরাবৃত্তি! : P: 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);
}

Comments

কেউ আমাকে ব্যাখ্যা করতে পারেন যে এটি কীভাবে কাজ করে? বেশ চিত্তাকর্ষক।

— গাৎ

@ জ্যাক: আসল আসুন, আমরা ইচ্ছাকৃতভাবে লুপগুলি এড়াতে লেখা প্রোগ্রাম থেকে 1000 টি লাইন মুদ্রণ করছি। পারফরম্যান্স কোনও সমস্যা নয়।

— ড্রিমলাক্স

এইগুলি সঙ্কলন করার জন্য যথেষ্ট আগ্রহী তাদের জন্য: g ++ এ, -ফিটম্প্লেট-গভীরতা -1000 সেট করুন। ডিফল্ট টেম্পলেট পুনরাবৃত্তি সর্বাধিক 500

— টম

এটি এখনও শর্তসাপেক্ষ ব্যবহার করে: প্যাটার্ন মিলটি গৌরবযুক্ত যদি if

— ডেভিড কে।

@ ড্রিমলাক্স: আমি বছরের পর বছর ধরে অভিজ্ঞতা থেকে শিখেছি এটিগুলির মধ্যে একটি: '\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);
}

---

সম্পাদনা: '&' যুক্ত করা হয়েছে যাতে এটি ঠিকানার কারণেই পয়েন্টার ত্রুটিগুলি এড়ায়।

স্ট্যান্ডার্ড সিতে উপরের এই সংস্করণটি, যেহেতু এটি ফাংশন পয়েন্টারে গাণিতিকের উপর নির্ভর করে না:

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

@ পিপি, এটি ব্যাখ্যা করা বেশ দীর্ঘ, তবে মূলত 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()। হুই :)

— ফ্রেডেরিক হামিদি

এটি সিআই এর মধ্যে সবচেয়ে আশ্চর্যজনক আপত্তিগুলির মধ্যে একটি। তবে এটি কি সমস্ত প্ল্যাটফর্মে কাজ করবে?

— কিওয়ারটি

@ মার্ক: এটি মূলটির অ-মানক স্বাক্ষর, আপনাকে প্রধান পুনরাবৃত্তভাবে কল করতে নিষেধ করা হয়েছে, এবং ফাংশন পয়েন্টারগুলি বিয়োগের ফলাফলটি অপরিজ্ঞাত।

— ইয়াকভ গালকা

হ্যাঁ, হ্যাঁ, এটি ইউবঙ্গোলোবিল যে কারণে দেয় তার জন্য এটি কঠোরভাবে আইনী সি ++ কোড নয়, তবে নিছক উন্মাদনার জন্য এবং এটি কয়েকটি প্ল্যাটফর্মে সংকলন করে কাজ করে যাওয়ায় আমাকে +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যে একটি লুপ রয়েছে: পি

— আইসক্রিম

@ লিটব: দ্রষ্টব্য আমি বলিনি যে "ব্যবহার copy করা প্রতারণা করছে"

— জন ডিবলিং

@ জন: কপি করা প্রতারণা করছে। তুমি কি সন্দেহ কর? : পি

— নওয়াজ

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 (সি ++ 03) দ্বারা সংজ্ঞায়িত করা হয়েছে। সূচনা সাবস্ক্রিপশন ক্রমে করা হয়।

— জোহানেস স্কাউব -

@ জোসেফ: এবং সেগুলিও বিপরীত ক্রমে ধ্বংস হয়ে গেছে, যাতে আপনি কোনও ডেস্ট্রাক্টরকে খুব সহজেই ব্যবহার করতে পারেন :)

— j_random_hacker

Answer 6

আমি 1000 বার প্রিন্টএফ স্টেটমেন্ট লিখছি না!

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", 'ডাব্লু') খুলুন। লিখুন ('প্রিন্টফ ("% s"));'% ("\ n"। জোরে ([স্ট্রিং (এক্স) এক্সরেঞ্জে (1,1000)]) ))

— টাইলার ইভি

আমি আশা করি আপনি যে লাইনটি তৈরি করতে যে প্রোগ্রামটি লিখেছেন তাতে লুপ নেই!

— জাইউং কিম

একটি ভিম ম্যাক্রো দ্রুত কাজটি করত।

— স্ট্যাকড ক্রুকড

পার্ল একটি বিট এটি অভিনব উপায়ে উত্পন্ন:$r='printf("'; for (1..1000) { $r.="$_\\n" } $r.='");'; print $r;

— সিডিল

Answer 7

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

এটি সমস্ত সংখ্যা মুদ্রণ করে না , তবে এটি "1 থেকে 1000 পর্যন্ত সংখ্যা মুদ্রণ করে" does জয়ের জন্য অস্পষ্ট প্রশ্ন! :)

Comments

'প্রিন্টফের পরে আমার প্রিয় ("1 থেকে 1000" পর্যন্ত সংখ্যার নম্বর)) - নির্বোধ প্রশ্নের মূর্খ উত্তরগুলির প্রয়োজন।

— সেংস্ট্রম

এটা সত্যিই দারুন. প্রশ্নে অস্পষ্টতার সুবিধা নেওয়ার জন্য +1। হাহা

— নওয়াজ

সম্পাদিত; print "Print numbers from 1 to 1000."

— কোনওভাবেই

বাহ, এই প্রশ্নের উত্তরগুলিতে ইদানীং কিছুটা ভাঙচুর হয়েছে। কিছু আমাকে বলছে আমাদের সেই লকটি historicalতিহাসিক লকে আপগ্রেড করা উচিত।

— 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

আপনার fflush (stdout) কল করা উচিত; প্রতিটি প্রিন্টএফ () এর পরে ... যখন কোনও প্রোগ্রাম ক্রাশ হয়ে যায় তখন আউটপুট বাফারটি স্ক্রিনে মুদ্রিত হওয়ার নিশ্চয়তা নেই।

— zakk

@ জাক্ক: এটি কঠোরভাবে প্রয়োজনীয় নয় - ডিফল্টরূপে স্টডআউটটি লাইন বাফার হয়, সুতরাং \nআউটপুটটি ফ্লাশ করার জন্য যথেষ্ট হবে।

— স্মৃতি 12

এটি একটি ইন্টারেক্টিভ ডিভাইস হিসাবে নির্ধারণ করা যেতে পারে যদি স্টডআউট লাইন বাফার হয় , অন্যথায় এটি পুরোপুরি বাফার করে। যদি অধ্যাপক স্বয়ংক্রিয় চেকিংয়ের জন্য কোনও ফাইলে পুনঃনির্দেশ করেন তবে আপনি ব্যর্থ হবেন :-)

— প্যাক্সিডিয়াবল

— স্ট্যাকওভারফ্লো

Answer 9

সিস্টেম কমান্ড ব্যবহার করে:

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

Comments

উচ্চ সুযোগ /usr/bin/seqঅভ্যন্তরীণভাবে একটি লুপ ব্যবহার করে। :)

@ জোকসটার: আপনার অর্থ, কারণ সোলারিস / বিএসডি এর কোনও seqইউটিলিটি নেই (ডিফল্ট সেটআপে)? <গ্রিন />

— শেঠ

আমি এটি বলতে ঘৃণা করি (ভাল, না আমি তা করি না), তবে আপনার সমাধানে একটি ত্রুটি রয়েছে। এটি সংখ্যার সঠিক সেট প্রিন্ট করে না। :) এখানে ঠিক আছে: system("/bin/echo {1..1000}"); কেবল যদি আপনি ইউনিট পরীক্ষাটি প্রথমে লিখতেন ...

— ডন ব্রানসন

কিছু উজ্জ্বল বন্ধু আমার উত্তর পরিবর্তন করার সিদ্ধান্ত নিয়েছে, সুতরাং এটি আমার ভুল নয়।

— মoinনুদিন ২

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

@ প্রসূন: এটি একটি সম্পর্ক।

— ইয়াকভ গালকা

প্রয়োজনীয়তা হ'ল "শর্ত ছাড়াই" (যদি, স্যুইচ, ইত্যাদি)। "শর্ত নেই"

— jon_darkstar

<শর্ত নয়। এটি একটি রিলেশনাল অপারেটর। if/ elseএকটি শর্তাধীন বিবৃতি। ?:একটি শর্তসাপেক্ষ অপারেটর। <একটি অপারেটর যা একটি বুলিয়ান মান প্রদান করে। এটি সম্ভবত কোনও একক মেশিনের নির্দেশনা যার সাথে কোনও লাফ বা কিছুই নেই।

— ক্রিস লুটজ

@Chris Lutz: x86, এটা 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()।

— রাফা ডগির্ড

এটি বিরক্তিকর নয়, এটি সহজ। আপনি যদি টেমপ্লেট ম্যাজিকের বিশাল জগাখিচুড়ি দিয়ে যেমন শর্ট ফাংশন দিয়ে একই জিনিস করতে পারেন, তবে আপনার এই ফাংশনটি করা উচিত :)

— অ্যামার্টুন

&& শর্তসাপেক্ষ। একটি গাণিতিক অ্যান্ড উভয় পক্ষের মূল্যায়ন করবে (যেমন জাভা এবং অ্যাডা "এবং" কর)। && কেবলমাত্র দ্বিতীয় অপারেটরকে মূল্যায়ন করবে যদি (এখানে এটি থাকে) প্রথম সত্য হয়। বা অন্য উদাহরণ: অ্যাডায় এটি শর্ট সার্কিট অপারেটরকে "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 এ থামে না। এটা ঠিক চলছে।

— রেমি Lebeau

আপনি যদি সি বা সি ++ এর প্রয়োজনীয়তা স্ক্র্যাপ করেন তবেই ছোট করা যায়। তারপরে যে কোনও "প্রোগ্রাম" করবে, কারণ একটি তাত্ত্বিক সংকলক আপনার পছন্দসই প্রোগ্রামটি তৈরি করতে পারে (যে কোনও ইনপুট থেকে)।

— eq-

@ ইক অয়েইন, এটি সংকলন করে ঠিক জরিমানা…

— মার্ক ম্যাকডোনাল্ড

অনাগ্রহী হিসাবে: আমরা এমনকি স্পষ্ট এড়াতে পারি গণিত । যদি আমরা নিয়োগ করি তবে আমরা rand()তাদের সকলের সংখ্যা 1 থেকে 1000 পর্যন্ত মুদ্রণ করব

@ পুহ: অগত্যা, যেহেতু র‌্যান্ড () এর নির্দিষ্ট ক্রমের পরে পুনরাবৃত্তি হওয়ার সম্ভাবনা রয়েছে এবং এই ক্রমটি এই সমস্যার সমাধানের সমাধানে না পড়তে পারে

— ছত্রি ri

Answer 13

পাই হিসাবে সহজ! : P: P

#include <iostream>

static int current = 1;

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

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

Comments

আপনি "স্ট্যাটিক int- এ বর্তমান = 0" অন্যথায় প্রিন্ট হবে 2 থেকে 1001 কি করতে চাইবেন

— Shinnok

আমি ++ বর্তমানকে ++

— জেলিক্সে

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। ম্যাক্রো। এটি রাতের খাবারের জন্য

— এভিলটিচ

Answer 15

আমরা 1000 থ্রেড চালু করতে পারি, প্রতিটি সংখ্যার একটি মুদ্রণ। ওপেনএমপিআই ইনস্টল করুন , ব্যবহার করে সংকলন করুন 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 করুন।

— ক্রিস লুটজ

@ ক্রিস বেশিরভাগ সমাধানের কোথাও কোনও গোপন লুপ থাকে না?

— মoinনুদিন

আমি মনে করি, যদি আপনি "সংকলকটিতে লুপগুলি" গ্রহণ করেন। যেহেতু (যুক্তিগুলির উপরে সম্ভাব্য লুপের বাইরে 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।

— ফিলিপ

আমি কেবল এটিই বোঝাতে চাইছি যে, সংখ্যাটি বেস 10 তে কীভাবে প্রতিনিধিত্ব করা হয়, গুণক "10x10x10" নিজেই পরামর্শ দিয়েছিল, তবে অন্যান্য বিকল্পগুলিও সম্ভব। আমার ধারণা আমার "বেস" এর পরিবর্তে "ফ্যাক্টরিয়েশন" বলা উচিত ছিল

— লিওনব্লয়

Answer 17

একটি বিশেষ পুনরাবৃত্তকারী সহ কেবল স্ট্যান্ড :: কপি () ব্যবহার করুন।

#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 থেকে শুরু হয় Also এছাড়াও ক্রিসের সাথে একমত হোন, প্রশ্নটি আমি বহু বছর আগে দেখেছি "IO ব্যতীত কোনও লাইব্রেরি ছাড়াই" হিসাবে বর্ণিত হয়েছিল। এখনও +1 :)

— ইয়াকভ গালকা

@ ক্রিস লুটজ: অনুলিপিটির বাস্তবায়ন সংজ্ঞায়িত। আমি উপরের মতো টেমপ্লেট কোডটিও ব্যবহার করতে পারি (আপনি কেবল জানেন না)। সুতরাং আপনি বলতে পারবেন না এটি একটি লুপ ব্যবহার করে কারণ আমরা জানি না।

— মার্টিন ইয়র্ক

প্রকৃতপক্ষে, আমার নিট পিক এর মধ্যে অন্তর্ভুক্ত std::copyশর্তসাপেক্ষের মতো অন্তর্নিহিত লুপ হবে না operator !=()। নির্বিশেষে, এটি একটি বুদ্ধিমান একটি পরিসীমা প্রক্রিয়াজাতকরণ গ্রহণ, এবং চতুর পন্থা আমি এই জাতীয় প্রশ্নের জবাবে কি সন্ধান করি।

— মাইকেল বুড়

নির্দিষ্টকরণ বাস্তবায়ন

— অপরিজ্ঞাত

@selvaiyyamperumal: আপনি ঠিক কী বিষয়ে কথা বলছেন তা নিশ্চিত নয় Not আপনি যদি আচরণ সম্পর্কে কথা বলছেন তবে মানটি আপনার সাথে একমত নয়। "বাস্তবায়ন সংজ্ঞায়িত আচরণ" এর অর্থ এটি যথাযথভাবে সংজ্ঞায়িত হয়েছে তবে বাস্তবায়নের মাধ্যমে স্পষ্ট করে ডকুমেন্ট করা উচিত। "অনির্ধারিত আচরণ" অর্থ যা কিছু ঘটতে পারে।

— মার্টিন ইয়র্ক

Answer 18

ফাংশন পয়েন্টার (আব) ব্যবহার। আউটপুট বাড়ানোর জন্য কোনও প্রিপ্রসেসর যাদু নেই। এএনএসআই সি।

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

এটি একটি 8 এমবি স্ট্যাকের জন্য। প্রতিটি ফাংশন আমন্ত্রণটি প্রায় 32 বাইট (তাই 32 * 1000) লাগে। তবে আমি যখন এটি চালিয়েছিলাম তখন আমি কেবল ৮০৪ এ পৌঁছেছি (সুতরাং ১৯6 * ৩২; সম্ভবত সি রানটাইমের স্ট্যাকের অন্যান্য অংশ রয়েছে যা আপনাকেও কেটে দিতে হবে)।

Answer 22

ফাংশন পয়েন্টারগুলির সাথে মজা করুন (সেই নতুন-ফ্যাংড টিএমপি-র কোনওটির প্রয়োজন নেই):

#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

বিট শিফট দিয়ে আপনি যেভাবে পেয়েছেন তা আমি পছন্দ করি। তবে আপনার সরলকরণের পরে চিন্তাভাবনার সাথে, ডাবল ব্যাং কী করে? এর বিটওয়াইজ বা যৌক্তিক? আমি হারিয়ে গিয়েছি এবং গুগল আমাকে চেনাশোনাগুলিতে ঘুরতে পেয়েছে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

আপনার উত্তরটি শর্তাধীন বিবৃতি ব্যবহার করে, যা প্রশ্ন অনুসারে নিষিদ্ধ।

— স্টিওলভ

শর্তাধীন বিবৃতি অন্যথায় যদি হয় ইত্যাদি আমি কেবল একটি লজিকাল অপারেশন ব্যবহার করেছি !! এইচপি এটা পরিষ্কার!

— পাপ্পু

এমনকি আপনার মন্তব্যে আপনি লিখেছেন "যদি হ্যাঁ তবে মুদ্রণের জন্য পুনরাবৃত্ত ফাংশনটি কল করুন"। অবিশ্বাস্য উপায়ে লেখা একটি শর্তসাপেক্ষ এখনও শর্তসাপেক্ষ। সংখ্যাটি ডিফল্টও শর্তযুক্ত।

— গেরি

Answer 24

আমি সমস্ত মজা মিস করলাম, সমস্ত ভাল সি ++ উত্তর ইতিমধ্যে পোস্ট করা হয়েছে!

এটি আমি যে অদ্ভুত বিষয়টি সামনে আসতে পেরেছি, এটি আইনি সি 99 এর জন্য আমি বাজি ধরব না: পি

#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আমার মনে আছে যেমন অপরিবর্তিত আচরণে ফলাফল কল করা ।

— ইয়াকভ গালকা

এটি পুরোপুরি আইনী সি। ইয়াবুঙ্গোবিল: আপনি অবশ্যই সি ++ এর কথা ভাবছেন, যেখানে কলিং মেইন () বিশেষভাবে অনুমোদিত নয়।

— মাইকেল ফৌকারাকিস

— @ মিশেল

আমি মনে করি বুস্ট ব্যবহারের অর্থ সি ++ রয়েছে। নির্বিশেষে, বুস্ট.পিপি সমাধানের জন্য কুডোস।

— 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()মত যুক্তি ছাড়া কল করতে পারেন?

— ক্রিস লুটজ

আমি নিজে সম্পর্কে কৌতূহল ছিল। এটি জিসিসির সাথে সঠিকভাবে কাজ করে, তবে আমি জানি না এটি ভাল সংজ্ঞাযুক্ত আচরণ কিনা if

— কিথমো

সি 99-এ সংজ্ঞায়িত, সি 89 কী বলেছে তা মনে রাখবেন না, মেমরিটি যদি পরিবেশন করে তবে কমপক্ষে এমএসভিসির কয়েকটি সংস্করণে সমস্যা সৃষ্টি করে।

— zwol

Answer 29

যদি পসিক্স সমাধানগুলি গৃহীত হয়:

#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

অন্যথায় অব্যবহৃত জে রাখার জন্য আপনার তখন সংকলক অনুকূলতা এড়ানো উচিত।

— বান্দি

তাকে কেবলমাত্র volatilej

— প্যাট্রিক শ্লিয়েটার