यह निर्धारित करना कि कोई संख्या या तो दस में से कई है या किसी विशेष सीमा के भीतर है

Question

मेरे पास कुछ लूप हैं जो मुझे अपने कार्यक्रम में चाहिए। मैं छद्म कोड लिख सकता हूं लेकिन मुझे पूरी तरह से यकीन नहीं है कि उन्हें तार्किक रूप से कैसे लिखा जाए।

मुझे जरूरत है -

if (num is a multiple of 10) { do this }

if (num is within 11-20, 31-40, 51-60, 71-80, 91-100) { do this }
else { do this } //this part is for 1-10, 21-30, 41-50, 61-70, 81-90

यह एक साँप और सीढ़ी बोर्ड गेम के लिए है, अगर यह मेरे प्रश्न के लिए कोई और अधिक समझ में आता है।

मैं पहली बार कल्पना करता हूं कि अगर बयान में मुझे मापांक का उपयोग करने की आवश्यकता होगी, होगा if (num == 100%10) सही ?

दूसरा मुझे कोई पता नहीं है। मैं इसे बाहर की तरह लिख सकता हूं, if (num > 10 && num is < 21 || etc)लेकिन इससे अधिक चालाक होना होगा।

Comments

आम तौर पर, अच्छे कोड की लंबाई अंग्रेजी की लंबाई के अनुपात में होती है, जो यह बताती है कि यह क्या करता है। इसलिए जब आपका "विनिर्देश" 11-20, अबूझ, 51-60, 71-80, 91-100 कहता है, तो आप अपने कोड से उन नंबरों का भी उल्लेख कर सकते हैं। यदि वे नंबर कहीं से आते हैं या किसी कारण से उत्पन्न हुए थे, तो देखें कि क्या आप संख्याओं के बजाय कारण को कोड कर सकते हैं।

— लूकी

@ user3419168: संकलक को यह परवाह नहीं है कि आपका कोड कितना पठनीय है; यह एक दूसरे के एक अंश में इसे संकलित करेगा। लेकिन आपके कोड को पढ़ने वाले मनुष्यों के लिए, आपके द्वारा चुने गए विकल्प इसे सेकंड, मिनट, घंटे या कभी नहीं समझ सकते हैं। यह एक लागत लगाता है; लोगों को कोड पढ़ने और समझने के लिए भुगतान किया जाता है, इसलिए उन पर यह आसान है। पठनीयता को अधिकतम करने के लिए हमेशा उत्पादन कोड लिखें, और याद रखें कि जरूरी नहीं कि कोड बेहतर प्रदर्शन करें।

— एरिक लिपर्ट

@AmadeusDrZaius - मेरे पास बहुत ही काम किया है, लेकिन केवल प्रदर्शन महत्वपूर्ण वर्गों के लिए। सबसे कठिन लूप जिसे 100M बार कहा जाता है, वह योग्य है - अगर सांप और सीढ़ी के खेल में बयान नहीं होता है। जहां आप उनके बीच की रेखा खींचते हैं वह एक व्यक्तिगत पसंद है।

— फ्लोरिस

मुझे यह कहने से नफरत है, लेकिन पर्याप्त कॉरपोरेट काम कर रहे हैं, शुरुआती लोगों को वास्तविक कोड लिखने के साथ, मुझे इसे मजबूर करने के लिए जानवर की सिफारिश करनी होगी। क्योंकि तब नए लोग इसे समझेंगे और इसे नहीं तोड़ेंगे। उदास लेकिन सच है - कुछ मामलों में इसका स्मार्ट गूंगा होना।

— रिचर्ड ले मेसुरियर

यह एक अच्छा सवाल है, और मैं पोस्टर से कुछ भी दूर नहीं ले जाना चाहता, लेकिन यह 500+ अंक के लायक नहीं है। इस तरह से हम कुछ ऐसे बकवास के साथ समाप्त होते हैं जो हम उन हजारों लोगों के साथ करते हैं जो यहां के अधिकारी हैं। (इस टिप्पणी को स्थानांतरित करने के लिए स्वतंत्र महसूस करें यदि यह कहीं और है।)

— GaTechThomas

Answer 1

पहले के लिए, यह जांचने के लिए कि क्या संख्या एक से अधिक उपयोग है:

if (num % 10 == 0) // It's divisible by 10

दूसरे के लिए:

if(((num - 1) / 10) % 2 == 1 && num <= 100)

लेकिन यह सघन है, और आप केवल विकल्पों को स्पष्ट रूप से सूचीबद्ध करने से बेहतर हो सकते हैं।

---

अब जब आप बेहतर विचार कर रहे हैं कि आप क्या कर रहे हैं, तो मैं दूसरा लिखूंगा:

   int getRow(int num) {
      return (num - 1) / 10;
   }

   if (getRow(num) % 2 == 0) {
   }

यह एक ही तर्क है, लेकिन फ़ंक्शन का उपयोग करके हमें स्पष्ट विचार मिलता है कि इसका क्या मतलब है।

Comments

if((num - 1) / 10) % 2 == 1 && num < 100)- अगर मैंने देखा कि मैं रोऊँगा।

— डैनियल कामिल कोजार

@DanielKamilKozar, जैसा आपको चाहिए।

— विंस्टन इवर्ट

@ user3419168, सिर्फ अपने आप से एक आश्चर्य छोड़ देता है कि दुनिया में इसका क्या मतलब है। यह दुनिया में क्या करने की कोशिश कर रहा है के रूप में कोई संकेत नहीं देता है। इसलिए संपादन में मैंने एक ऐसा संस्करण दिखाया जो एक फ़ंक्शन में तर्क को विभाजित करता है जो यह स्पष्ट करता है कि गणना वास्तव में क्या कर रही है।

— विंस्टन इवर्ट

यह भी माना जा सकता है num >= 11कि (1) इस बात पर जोर दिया जाता है कि निचली सीमा पर मुकदमा चलाया जाता है, और (2) %एक ऋणात्मक संख्या पर एक ऋणात्मक संख्या भी आती है। (मैं & 1यहाँ "सुरक्षित" का उपयोग करना चाहिए, लेकिन यह भी अतिरिक्त ज्ञान मानता है।)

— usr2564301

संपादित करें के लिए +1, यह श्रेणियों की सूची में शामिल हो जाता है और इसे पठनीय तरीके से प्रस्तुत करता है। आईएमओ, एक कदम getRow(num) % 2 == 0एक फ़ंक्शन में लपेटने के साथ-साथ यह स्पष्ट करने के लिए कि यह क्या है क्रिस्टल को स्पष्ट करने के लिए होगा। bool inEvenRow(int num){ return getRow(num) % 2 ==0;}

— मि। मिंडोर

Answer 2

यदि (संख्या 10 का गुणक है) {यह करें}

if (num % 10 == 0) {
  // Do something
}

अगर (संख्या ११-२०, भीतर, ५१-६०, 91१- 91०, ९९ -१००) {{यह करें} है

यहाँ की चाल श्रेणियों के बीच किसी प्रकार की समानता देखने के लिए है। बेशक, आप हमेशा "जानवर बल" विधि का उपयोग कर सकते हैं:

if ((num > 10 && num <= 20) ||
    (num > 30 && num <= 40) ||
    (num > 50 && num <= 60) ||
    (num > 70 && num <= 80) ||
    (num > 90 && num <= 100)) {
  // Do something
}

लेकिन आप देख सकते हैं कि, यदि आप से घटाते 1हैं num, तो आपके पास सीमाएँ होंगी:

10-19, 30-39, 50-59, 70-79, 90-99

दूसरे शब्दों में, सभी दो-अंकीय संख्याएँ जिनका पहला अंक विषम है। अगला, आपको एक सूत्र के साथ आने की आवश्यकता है जो इसे व्यक्त करता है। आप 10 से विभाजित करके पहला अंक प्राप्त कर सकते हैं, और आप परीक्षण कर सकते हैं कि यह 1 के शेष के लिए जाँच करके विषम है जब आप 2 से विभाजित करते हैं। सभी को एक साथ रखकर:

if ((num > 0) && (num <= 100) && (((num - 1) / 10) % 2 == 1)) {
  // Do something
}

लंबे समय तक लेकिन बनाए रखने योग्य कोड और छोटे "चतुर" कोड के बीच व्यापार-बंद को देखते हुए, मैं हर बार लंबा और स्पष्ट करूंगा। बहुत कम से कम, यदि आप चालाक बनने की कोशिश करते हैं, तो कृपया, एक टिप्पणी शामिल करें जो बताती है कि आप क्या हासिल करना चाहते हैं।

यह कोड पर काम करने के लिए अगले डेवलपर को संभालने में मदद करता है जो सशस्त्र है और जानता है कि आप कहां रहते हैं। :-)

Comments

मैं अभी भी चतुर कोड के लिए जाऊंगा, लेकिन फ़ंक्शन को निकालकर इसे बनाए रखने योग्य कोड में बदल दूंगा। यह उतना ही पठनीय होगा, अगर वह अंतिम बिट कहे && isTensDigitOdd(num), शायद फ़ंक्शन परिभाषा से पहले एक टिप्पणी के साथ यह बताए कि वह क्या करता है। यदि ऐसा कोई पैटर्न मौजूद है, तो पैटर्न के लिए तर्क की व्याख्या करने वाली एक टिप्पणी, स्थिरता बनाए रखने के लिए ज्ञानवर्धक है।

— क्रिस

क्रिस, यह एक बड़ी रणनीति है जब "चतुरता" का स्पष्ट लाभ होता है: बहुत कम कोड (जिसका अर्थ है कि टाइपो की संभावना कम है, खासकर अगर यह बदल जाता है), या दक्षता में एक बड़ा सुधार। संक्षिप्तता, स्पष्टता और दक्षता के बीच लगभग हमेशा एक व्यापार होता है, और एक अच्छा समझौता खोजना एक महान कौशल विकसित करना है। ( एक छींटे के लिए stackoverflow.com/a/2151844/29157 देखें ।)

— एडम लिस

यह काफी बेहतर तरीका है। To चतुर कोड ’की तुलना में समझने में इतना आसान और प्रदर्शन अंतर शायद नगण्य है।

— user1477388

@AdamLiss, हाँ, मेरी राय कम मूल्य की है क्योंकि मुझे इन निर्णयों के नतीजों को देखने के लिए पर्याप्त अनुभव नहीं है। मुझे यकीन है कि मैं जल्द ही पर्याप्त होऊंगा, और यदि आवश्यक हो तो मुझे एक दूसरी राय प्राप्त करना सुनिश्चित होगा।

— क्रिस

अपने आप को कम मत बेचो। आपकी प्रवृत्ति बहुत समझदार है, और आप सीखने को उत्सुक रहते हैं। हर राय मूल्यवान है अगर इसके पीछे एक अच्छा कारण है ... और कभी-कभी यहां तक ​​कि अगर नहीं है। मुझे यकीन है कि आप बहुत दूर जाना चाहते हैं।

— एडम लाइस

Answer 3

यदि आप GCC या किसी भी कंपाइलर का उपयोग कर रहे हैं जो केस रेंज का समर्थन करता है तो आप ऐसा कर सकते हैं, लेकिन आपका कोड पोर्टेबल नहीं होगा ।

switch(num)
{
case 11 ... 20:
case 31 ... 40:
case 51 ... 60:
case 71 ... 80:
case 91 ... 100:
    // Do something
    break;
default:
    // Do something else
    break;
}

Comments

क्या आप मुझे बता सकते हैं कि यह कोड पोर्टेबल क्यों नहीं है?

— एम शरथ हेगड़े

@ शारथ हेजडे क्योंकि इसे जीसीसी विस्तार की आवश्यकता है, जो मानक का हिस्सा नहीं है और कुछ संकलक इसका समर्थन नहीं करेंगे

— ब्रायन चेन

यह सही उत्तर है, क्योंकि यह तुरंत स्पष्ट है कि इरादा क्या है। मॉडुलो के साथ उन सभी 'चतुर' उत्तर एक रखरखाव दुःस्वप्न हैं, यहां तक ​​कि टिप्पणियों के साथ भी।

— स्मिरकिंगमैन

@smirkingman वास्तव में मैंने मुख्य प्रश्न के लिए अपनी टिप्पणी में यही कहा है। कॉरपोरेट जॉब में नए कोडर्स के अनुभव को समझने में कुछ समय लगता है कि स्मार्ट-निंजा की तुलना में स्पष्ट तरीका अक्सर बेहतर होता है।

— रिचर्ड ले मेसुरियर

Answer 4

यह भविष्य के आगंतुकों के लिए एक शुरुआत से अधिक है। अधिक सामान्य, एल्गोरिथ्म जैसे समाधान के लिए, आप मूल्यों को शुरू करने और समाप्त करने की एक सूची ले सकते हैं और जांच सकते हैं कि क्या पारित मूल्य उनमें से एक के भीतर है:

template<typename It, typename Elem>
bool in_any_interval(It first, It last, const Elem &val) {
    return std::any_of(first, last, [&val](const auto &p) {
        return p.first <= val && val <= p.second;
    });
}

सरलता के लिए, मैंने एक स्पष्ट pairतर्क के बजाय एक बहुरूपी लैम्ब्डा (C ++ 14) का उपयोग किया । यह भी शायद का उपयोग कर से चिपके चाहिए <और ==मानक एल्गोरिदम के अनुरूप होना करने के लिए है, लेकिन यह इस रूप में लंबे समय के रूप में की तरह काम करता Elemहै <=इसके लिए परिभाषित किया। वैसे भी, यह इस तरह से इस्तेमाल किया जा सकता है:

std::pair<int, int> intervals[]{
    {11, 20}, {31, 40}, {51, 60}, {71, 80}, {91, 100}
};

const int num = 15;
std::cout << in_any_interval(std::begin(intervals), std::end(intervals), num);

यहाँ एक जीवंत उदाहरण है ।

Comments

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

— केविन लैम

@ हंटरगुय 2, बहुत अच्छी बात। मैं वास्तव में इसे जोड़ों पर संचालित करने के लिए बदलने जा रहा हूं क्योंकि मैं केवल किसी कारण से ज़िप पुनरावृत्तियों के बारे में सोच रहा था।

— क्रिस

वास्तव में अच्छा stl दृष्टिकोण! इसे प्यार करना!

— हिगुरो

Answer 5

पहला आसान है। आपको बस अपने संख्यात्मक मूल्य के लिए modulo ऑपरेटर को लागू करने की आवश्यकता है:

if ( ( num % 10 ) == 0)

चूँकि C ++ प्रत्येक संख्या का मूल्यांकन कर रही है जो 0 के रूप में सत्य नहीं है, आप यह भी लिख सकते हैं:

if ( ! ( num % 10 ) )  // Does not have a residue when divided by 10

दूसरे के लिए, मुझे लगता है कि यह समझने के लिए क्लीनर है:

पैटर्न हर 20 को दोहराता है, इसलिए आप modulo 20 की गणना कर सकते हैं। आपके इच्छित सभी तत्व एक पंक्ति में होंगे जो कि 20 से विभाजित करने योग्य हैं।

उन लोगों को भी प्राप्त करने के लिए, ऋणात्मक संख्याओं से निपटने से बचने के लिए बस संख्या -1 या बेहतर संख्या + 19 का उपयोग करें।

if ( ( ( num + 19 ) % 20 ) > 9 )

यह मान रहा है कि पैटर्न हमेशा के लिए दोहराता है, इसलिए 111-120 के लिए यह फिर से लागू होगा, और इसी तरह। अन्यथा आपको संख्याओं को 100 तक सीमित करने की आवश्यकता है:

if ( ( ( ( num + 19 ) % 20 ) > 9 ) && ( num <= 100 ) )

Answer 6

कोड में कुछ अच्छी टिप्पणियों के साथ, इसे काफी संक्षिप्त और आसानी से लिखा जा सकता है।

// Check if it's a multiple of 10
if (num % 10 == 0) { ... }

// Check for whether tens digit is zero or even (1-10, 21-30, ...)
if ((num / 10) % 2 == 0) { ... }
else { ... }

Comments

पहली टिप्पणी अनावश्यक है। किसी भी प्रोग्रामर को थोड़े से अनुभव से पता चलेगा कि num % 10 == 0यह वही है numजो 10. से अधिक है।

— जस्टिन

हाँ, लेकिन शुरुआती इस साइट को भी पढ़ते हैं। मैं अपने कोड में सामान्य रूप से उस टिप्पणी का उपयोग नहीं करूंगा, लेकिन यह उन शुरुआती लोगों को उत्तर स्पष्ट कर देता है जो इस शुरुआती प्रश्न से लाभान्वित होंगे।

— ला-कोमाद्रेजा

कृपया ऐसा कभी न करें। यह वास्तव में पठनीयता को कम करता है, पाठक को धीमा करके और उन्हें दो बार सब कुछ पढ़ने के लिए मजबूर करता है। कोई भी प्रोग्रामर जो यह नहीं समझता है कि आपके कोड को बनाए रखने if (num % 10 == 0)के समान // Check if it's a multiple of 10नहीं होना चाहिए । यह एक प्रसिद्ध विरोधी पैटर्न है।

— दाऊद इब्न करीम

@DavidWallace ऊपर टिप्पणी देखें। हम इस बात की गारंटी नहीं दे सकते हैं कि इस पोस्ट के पाठक इस प्रतिमान को जान पाएंगे।

— ला-कोमाडरेजा

नहीं, मेरा मतलब है कि यह कहने के लिए प्रत्येक पंक्ति को टिप्पणी करना कि यह एक विरोधी पैटर्न है। मेरा मतलब यह नहीं है कि उपयोग %एक विरोधी पैटर्न है; जाहिर है ऐसा नहीं है। वास्तव में, यह मानते हुए कि इस पोस्ट के कई पाठक शुरुआती होंगे, उन्हें टिप्पणी लिखने की इस शैली को सिखाना प्रोग्रामर के रूप में उनके विकास में नकारात्मक योगदान दे रहा है।

— दाऊद इब्न करीम

Answer 7

आपने मूल रूप से स्वयं को उत्तर समझाया, लेकिन यहां कोड केवल मामले में है।

if((x % 10) == 0) {
  // Do this
}
if((x > 10 && x < 21) || (x > 30 && x < 41) || (x > 50 && x < 61) || (x > 70 && x < 81) || (x > 90 && x < 101)) {
  // Do this
}

Comments

सही x < 41 x > 50और कोष्ठक डाल दिया।

— 101010

@ 40two, तकनीकी रूप से, operator&&की तुलना में एक उच्च मिसाल है operator||, इसलिए यह ठीक है, लेकिन मुझे पूरा यकीन है कि जीसीसी वैसे भी इसके बारे में चेतावनी देता है।

— क्रिस

असमानता का प्रतिनिधित्व करने पर विचार 10 < x < 21के रूप में 10 < x && x < 21के बजाय x > 10 && x < 21। असमानता को पढ़ना तब आसान होता है जब यह उसी क्रम में हो जैसा कि आप इसे गणितीय रूप से लिखते हैं।

— एरिक लिपर्ट

यह कोड काफी अपठनीय है और वास्तविक तर्क के बारे में बहुत कम कहता है। मुझे यह जवाब पसंद नहीं है।

— दारेज़ज़

मैं इसे गलत ठहरा रहा हूं क्योंकि आपने जवाब दिया कि ओपी ने क्या किया।

— ब्रूनो फेरेरा

Answer 8

आप इसे उखाड़ फेंक सकते हैं।

if (x % 10)
{
   .. code for 1..9 ..
} else
{
   .. code for 0, 10, 20 etc.
}

पहली पंक्ति if (x % 10)इसलिए काम करती है क्योंकि (ए) एक मान जो 10 का गुणक है, उसे '0' के रूप में परिकलित किया जाता है, अन्य संख्याओं का परिणाम उनके बने रहने वाले के रूप में होता है, (बी) में मान 0 में मान लिया ifजाता है false, कोई भी अन्य मान है true।

संपादित करें:

बिसवां दशा में आगे और पीछे टॉगल करने के लिए, उसी चाल का उपयोग करें। इस समय, निर्णायक संख्या है 10:

if (((x-1)/10) & 1)
{
  .. code for 10, 30, ..
} else
{
   .. code for 20, 40, etc.
}

x/10किसी भी संख्या को 0 से 9 के रूप में 0, 10 से 19 के रूप में 1और इसी तरह से लौटाता है । सम या विषम पर परीक्षण & 1- आपको बताता है कि क्या यह सम या विषम है। चूंकि आपकी सीमाएं वास्तव में "11 से 20" हैं, इसलिए परीक्षण से पहले 1 घटाएं।

Answer 9

पठनीयता के लिए एक दलील

जब आपके पास पहले से ही कुछ अच्छे उत्तर हैं, तो मैं एक प्रोग्रामिंग तकनीक की सिफारिश करना चाहूंगा, जो आपके कोड को कुछ भविष्य के पाठक के लिए अधिक पठनीय बना देगा - जो कि आपको छह महीने में हो सकता है, एक सहकर्मी ने एक कोड समीक्षा, आपके उत्तराधिकारी, को करने के लिए कहा। ।

यह किसी भी "चतुर" बयान को एक फ़ंक्शन में लपेटने के लिए है जो वास्तव में (इसके नाम के साथ) दिखाता है कि यह क्या कर रहा है। जबकि प्रदर्शन ("फ़ंक्शन कॉलिंग ओवरहेड" से) पर एक न्यूनतम प्रभाव होता है, यह वास्तव में इस तरह की गेम स्थिति में नगण्य है।

जिस तरह से आप अपने इनपुट्स को सैनिटाइज कर सकते हैं - उदाहरण के लिए, "अवैध" मूल्यों के लिए परीक्षण करें। इस प्रकार आप इस तरह कोड के साथ समाप्त हो सकते हैं - देखें कि यह कितना अधिक पठनीय है? "हेल्पर फ़ंक्शंस" को कहीं दूर छिपाया जा सकता है (मुख्य मॉड्यूल में रहने की आवश्यकता नहीं है: यह उनके नाम से स्पष्ट है कि वे क्या करते हैं:)

#include <stdio.h>

enum {NO, YES, WINNER};
enum {OUT_OF_RANGE=-1, ODD, EVEN};

int notInRange(int square) {
  return(square < 1 || square > 100)?YES:NO;
}

int isEndOfRow(int square) {
  if (notInRange(square)) return OUT_OF_RANGE;
  if (square == 100) return WINNER; // I am making this up...
  return (square % 10 == 0)? YES:NO;
}

int rowType(unsigned int square) {
  // return 1 if square is in odd row (going to the right)
  // and 0 if square is in even row (going to the left)
  if (notInRange(square)) return OUT_OF_RANGE; // trap this error
  int rowNum = (square - 1) / 10;
  return (rowNum % 2 == 0) ? ODD:EVEN; // return 0 (ODD) for 1-10, 21-30 etc.
                                       // and 1 (EVEN) for 11-20, 31-40, ...
}

int main(void) {
  int a = 12;
  int rt;
  rt = rowType(a); // this replaces your obscure if statement

  // and here is how you handle the possible return values:
  switch(rt) {
  case ODD:
    printf("It is an odd row\n");
    break;
  case EVEN:
    printf("It is an even row\n");
    break;
  case OUT_OF_RANGE:
    printf("It is out of range\n");
    break;
  default:
    printf("Unexpected return value from rowType!\n");
  }

  if(isEndOfRow(10)==YES) printf("10 is at the end of a row\n");
  if(isEndOfRow(100)==WINNER) printf("We have a winner!\n");
}

Comments

यह यह बहुत दूर पुश करने के लिए के साथ कोशिश नहीं कर रहा है YESऔर NO?

— rmobis

@ राफेल_ - यह अच्छी तरह से हो सकता है: मैं सिर्फ एक "उदाहरण के लिए" दिखा रहा था। बहुत से लोग सच / गलत का उपयोग करते हैं, जाहिर है। लेकिन मुझे याद है कभी नहीं कर सकते हैं (क्योंकि अलग अलग भाषाओं अलग परंपराओं का उपयोग): है TRUE, Trueया true? और क्या, यदि कोई हो, हेडर फ़ाइलों को मुझे साधारण सी में शामिल करने की आवश्यकता होगी? इसलिए मैंने अपना रोल किया। आश्चर्य है कि अगर यह क्या घट गया ...

— फ्लोरिस

Answer 10

पहले एक के लिए:

if (x % 10 == 0)

इस पर लागू होगा:

10, 20, 30, .. 100 .. 1000 ...

दूसरे के लिए:

if (((x-1) / 10) % 2 == 1)

के लिए आवेदन करेंगे:

11-20, 31-40, 51-60, ..

हम मूल रूप से सबसे पहले करते x-1हैं:

10-19, 30-39, 50-59, ..

फिर हम उन्हें 10पाने के लिए विभाजित करते हैं:

1, 3, 5, ..

इसलिए हम जाँचते हैं कि क्या यह परिणाम विषम है।

Answer 11

आप निम्नलिखित की कोशिश कर सकते हैं:

        // multiple of 10
        if ((num % 10) == 0)
        {
           // Do something
        }
        else if (((num / 10) % 2) != 0)
        {
            //11-20, 31-40, 51-60, 71-80, 91-100
        }
         else
        {
            //other case
        }

Comments

ओपी प्रश्न में 10 के कई के लिए चेक रेंज रेंज से संबंधित नहीं है, और रेंज चेक में 20 को 11 के समान रेंज में होना चाहिए, आपके कोड के साथ ((20/10)% 2) -> ( 2% 2) -> 0

— सर्पिटन

Answer 12

मुझे पता है कि इस सवाल के बहुत सारे जवाब हैं, लेकिन मैं वैसे भी यहाँ फेंक दूंगा ...

स्टीव मैककॉनेल के कोड कम्प्लीट , 2 एडिशन से लिया गया : "सीढ़ी-स्टेप एक्सेस टेबल्स:

फिर भी एक अन्य प्रकार की तालिका का उपयोग सीढ़ी-चरण विधि है। यह पहुंच विधि एक इंडेक्स संरचना के रूप में प्रत्यक्ष नहीं है, लेकिन यह उतना डेटा स्थान बर्बाद नहीं करता है। चित्र 18-5 में चित्रित सीढ़ी-चरण संरचनाओं का सामान्य विचार यह है कि एक तालिका में प्रविष्टियां अलग-अलग डेटा बिंदुओं के बजाय डेटा की श्रेणियों के लिए मान्य हैं।

चित्रा 18-5 सीढ़ी-चरण दृष्टिकोण प्रत्येक प्रविष्टि को उस स्तर को निर्धारित करके वर्गीकृत करता है जिस पर वह "सीढ़ी" मारता है। "कदम" यह हिट अपनी श्रेणी निर्धारित करता है।

उदाहरण के लिए, यदि आप ग्रेडिंग प्रोग्राम लिख रहे हैं, तो "B" प्रविष्टि सीमा 75 प्रतिशत से 90 प्रतिशत तक हो सकती है। यहाँ आपको किसी दिन कार्यक्रम करने के लिए कई ग्रेड देने होंगे:

सीढ़ी-चरण विधि का उपयोग करने के लिए, आप प्रत्येक श्रेणी के ऊपरी छोर को एक तालिका में रखते हैं और फिर प्रत्येक सीमा के ऊपरी छोर के खिलाफ स्कोर की जांच करने के लिए एक लूप लिखते हैं। जब आप उस बिंदु को खोजते हैं जिस पर स्कोर पहली बार किसी श्रेणी के शीर्ष से अधिक है, तो आप जानते हैं कि ग्रेड क्या है। सीढ़ी-चरण तकनीक के साथ, आपको श्रेणियों के समापन बिंदुओं को ठीक से संभालने के लिए सावधान रहना होगा। विजुअल बेसिक में यह कोड है जो इस उदाहरण के आधार पर छात्रों के एक समूह को ग्रेड प्रदान करता है:

हालांकि यह एक सरल उदाहरण है, आप इसे आसानी से कई छात्रों, कई ग्रेडिंग योजनाओं (उदाहरण के लिए, अलग-अलग बिंदुओं के लिए अलग-अलग बिंदुओं पर अलग-अलग असाइनमेंट्स) और ग्रेडिंग स्कीम में बदलाव को संभालने के लिए सामान्यीकृत कर सकते हैं। "

कोड पूरा , दूसरा संस्करण, पृष्ठ 426 - 428 (अध्याय 18)।

Comments

आपको क्यों लगता है कि यह गलत सवाल है? सिर्फ इसलिए कि मैंने ओपी मामले पर एक उदाहरण नहीं दिया है, इसका मतलब यह नहीं है कि मैंने गलत सवाल का जवाब दिया ...

— lauCosma

Answer 13

जैसा कि दूसरों ने बताया है, शर्तों को अधिक संक्षिप्त बनाने से संकलन या निष्पादन में तेजी नहीं आएगी, और यह पठनीयता के साथ जरूरी नहीं है।

यह आपके कार्यक्रम को और अधिक लचीला बनाने में मदद कर सकता है, यदि आप बाद में निर्णय लेते हैं कि आप एक गेमर के संस्करण को 6 x 6 बोर्ड पर चाहते हैं, या 40 x 50 बोर्ड पर एक उन्नत संस्करण (जो आप रात भर खेल सकते हैं) ।

तो मैं इसे निम्नानुसार कोडित करूंगा:

// What is the size of the game board?
#define ROWS            10
#define COLUMNS         10

// The numbers of the squares go from 1 (bottom-left) to (ROWS * COLUMNS)
// (top-left if ROWS is even, or top-right if ROWS is odd)
#define firstSquare     1
#define lastSquare      (ROWS * COLUMNS)
// We haven't started until we roll the die and move onto the first square,
// so there is an imaginary 'square zero'
#define notStarted(num) (num == 0)
// and we only win when we land exactly on the last square
#define finished(num)   (num == lastSquare)
#define overShot(num)   (num > lastSquare)

// We will number our rows from 1 to ROWS, and our columns from 1 to COLUMNS
// (apologies to C fanatics who believe the world should be zero-based, which would
//  have simplified these expressions)
#define getRow(num)   (((num - 1) / COLUMNS) + 1)
#define getCol(num)   (((num - 1) % COLUMNS) + 1)

// What direction are we moving in?
// On rows 1, 3, 5, etc. we go from left to right
#define isLeftToRightRow(num)    ((getRow(num) % 2) == 1)
// On rows 2, 4, 6, etc. we go from right to left
#define isRightToLeftRow(num)    ((getRow(num) % 2) == 0)

// Are we on the last square in the row?
#define isLastInRow(num)    (getCol(num) == COLUMNS)

// And finally we can get onto the code

if (notStarted(mySquare))
{
  // Some code for when we haven't got our piece on the board yet
}
else
{
  if (isLastInRow(mySquare))
  {
    // Some code for when we're on the last square in a row
  }


  if (isRightToLeftRow(mySquare))
  {
    // Some code for when we're travelling from right to left
  }
  else
  {
    // Some code for when we're travelling from left to right
  }
}

हां, यह क्रिया है, लेकिन यह स्पष्ट करता है कि गेम बोर्ड पर क्या हो रहा है।

यदि मैं फोन या टैबलेट पर प्रदर्शित करने के लिए इस गेम को विकसित कर रहा था, तो मैं स्थिरांक के बजाय ROWS और COLUMNS चर बनाऊंगा, ताकि स्क्रीन के आकार और अभिविन्यास के मिलान के लिए उन्हें गतिशील रूप से (गेम की शुरुआत में) सेट किया जा सके।

मैं स्क्रीन ओरिएंटेशन को किसी भी समय, मध्य-गेम में बदलने की अनुमति दूंगा - आपको बस इतना करना है कि ROWS और COLUMNS के मूल्यों को स्विच करना है, जबकि बाकी सब को छोड़कर (वर्तमान वर्ग संख्या जो प्रत्येक खिलाड़ी चालू है, और सभी सांप और सीढ़ी के आरंभ / अंत वर्ग अपरिवर्तित)। फिर आपको 'सिर्फ' बोर्ड को अच्छी तरह से खींचना होगा, और अपने एनिमेशन के लिए कोड लिखना होगा (मुझे लगता है कि आपके ifबयानों का उद्देश्य था ...)

Comments

मैंने फ्लोरिस का जवाब भी दिया है - एक समान परिणाम प्राप्त करने की एक अलग शैली, जिसे मैंने अपना जवाब लिखने से पहले नहीं देखा था

— लारेंस रेनशॉ

आप के बजाय इनलाइन समारोह का उपयोग करना चाहिए#define

— ब्रायन चेन

यह अच्छा अभ्यास है जब आप फ़ंक्शन-जैसे #defineनिर्देशों का उपयोग करते हैं, तर्कों के चारों ओर कोष्ठक लगाने के लिए, जहां वे विस्तार में दिखाई देते हैं। इसलिए इसके बजाय #define finished(num) (num == lastSquare)आपको लिखना चाहिए #define finished(num) ((num) == lastSquare)। कारण यह है कि यदि आप एक ऐसे निर्देश का उपयोग करते हैं जिसमें एक ऑपरेटर है जिसमें कम पर्याप्त पूर्वता वाला ऑपरेटर है, तो आपको वह उत्तर नहीं मिलेगा जिसकी आप अपेक्षा करते हैं। इस मामले में, यदि आप अतिरिक्त कोष्ठक का उपयोग नहीं करते हैं, तो finished(a & b)विस्तार में (a & b == lastSquare)लगभग निश्चित रूप से नहीं है कि आप क्या चाहते हैं।

— दाऊद इब्न करीम