क्या एक एकल ऑपरेशन में (x == 0 || x == 1) को सरल बनाना संभव है?

Question

इसलिए मैं फिबोनाची अनुक्रम में n वें नंबर को यथासंभव एक फ़ंक्शन के रूप में लिखने की कोशिश कर रहा था :

public uint fibn ( uint N ) 
{
   return (N == 0 || N == 1) ? 1 : fibn(N-1) + fibn(N-2);
}

लेकिन मैं सोच रहा हूं कि क्या मैं इसे और अधिक कॉम्पैक्ट और कुशल बना सकता हूं

(N == 0 || N == 1)

एक ही तुलना में। क्या कुछ फैंसी बिट शिफ्ट ऑपरेशन है जो यह कर सकता है?

Comments

क्यों? यह पठनीय है, आशय बहुत स्पष्ट है, और यह महंगा नहीं है। इसे कुछ "चतुर" बिट पैटर्न से क्यों बदलें जो समझने में कठिन है और इरादे को स्पष्ट रूप से पहचान नहीं पाता है?

— D स्टेनली

यह वास्तव में सही नहीं है?

— n8wrl

फाइबोनैसी दो पिछले मूल्यों को जोड़ता है। क्या आपका मतलब fibn(N-1) + fibn(N-2) इसके बजाय था N * fibn(N-1)?

— जुहार

मैं सभी नैनोसेकेंड्स को शेव करने के लिए हूं, लेकिन अगर आपको एक विधि में सरल तुलना मिल गई है जो पुनरावृत्ति का उपयोग करता है, तो तुलना की दक्षता पर प्रयास क्यों खर्च करें, और पुनरावृत्ति को छोड़ दें?

— जॉन हैना

आप फैबोनैचि संख्या की गणना के लिए एक पुनरावर्ती तरीके का उपयोग करते हैं, फिर आप प्रदर्शन में सुधार करना चाहते हैं? इसे लूप में क्यों नहीं बदलते? या तेज बिजली का उपयोग करें?

— notbad

Answer 1

यह भी एक काम है

Math.Sqrt(N) == N 

0 और 1 का वर्गमूल क्रमशः 0 और 1 वापस आएगा।

Comments

Math.Sqrtएक जटिल फ़्लोटिंग-पॉइंट फ़ंक्शन है। यह पूर्णांक-केवल विकल्पों की तुलना में धीरे-धीरे चलता है !!

— नायुकी

यह साफ दिखता है, लेकिन इससे बेहतर तरीके हैं यदि आप अन्य उत्तरों की जांच करें।

— माफिया

अगर मैं किसी भी कोड पर काम कर रहा था, तो मुझे लगता है कि मैं कम से कम, उस व्यक्ति के डेस्क पर चलूंगा और उनसे पूछूंगा कि वे उस समय कौन सा पदार्थ खा रहे थे।

— सीवीएन

उनके सही दिमाग में कौन है, इसका जवाब देने के लिए इसे चिह्नित करें? बोली बंद होना।

— squashed.bugaboo

Answer 2

बिटवाइज़ अंकगणित का उपयोग करके अपने अंकगणितीय परीक्षण को लागू करने के कई तरीके हैं। आपकी अभिव्यक्ति:

• x == 0 || x == 1

तार्किक रूप से इनमें से हर एक के बराबर है:

• (x & 1) == x
• (x & ~1) == 0
• (x | 1) == 1
• (~x | 1) == (uint)-1
• x >> 1 == 0

बक्शीश:

• x * x == x (प्रमाण थोड़ा प्रयास लेता है)

लेकिन व्यावहारिक रूप से, ये रूप सबसे पठनीय हैं, और प्रदर्शन में थोड़ा अंतर वास्तव में बिटवाइज़ अंकगणित का उपयोग करने के लायक नहीं है:

• x == 0 || x == 1
• x <= 1(क्योंकि xएक अहस्ताक्षरित पूर्णांक है)
• x < 2(क्योंकि xएक अहस्ताक्षरित पूर्णांक है)

Comments

मत भूलना(x & ~1) == 0

— ली डैनियल क्रॉकर

लेकिन उनमें से किसी एक पर "अधिक कुशल" होने का दांव न लगाएं। gcc वास्तव में या x == 0 || x == 1से कम के लिए कोड उत्पन्न करता है । पहले एक के लिए यह स्मार्ट है जो इसे समान के रूप में पहचानता है और एक सरल आउटपुट देता है । दूसरे इसे भ्रमित करते हैं और इसे बदतर कोड बनाते हैं। (x & ~1) == 0(x | 1) == 1x <= 1cmpl; setbe

— हॉब्स

x <= 1 या x <2 सरल है।

— gnasher729 6

@ केविन सी + + के लिए सच है, क्योंकि यह मानक वास्तव में कोशिश करता है, वास्तव में यह कठिन है कि यह असंभव कोड लिखना असंभव है। सौभाग्य से यह C # के बारे में एक प्रश्न है;)

— Voo

अधिकांश आधुनिक कंपाइलर पहले से ही इस तरह की तुलना का अनुकूलन कर सकते हैं , हालांकि मुझे नहीं पता है कि स्मार्ट सी # कंपाइलर और .NET जेट्टर कैसे हैं। असली कोड में केवल एक ही तुलना की आवश्यकता होती है

— phuclv

Answer 3

चूंकि तर्क है uint( अहस्ताक्षरित ) आप डाल सकते हैं

  return (N <= 1) ? 1 : N * fibn(N-1);

कम पठनीय (IMHO) लेकिन यदि आप प्रत्येक वर्ण ( कोड गोल्फ या एक जैसे) की गणना करते हैं

  return N < 2 ? 1 : N * fibn(N-1);

संपादित करें : अपने संपादित प्रश्न के लिए :

  return (N <= 1) ? 1 : fibn(N-1) + fibn(N-2);

या

  return N < 2 ? 1 : fibn(N-1) + fibn(N-2);

Comments

यदि यह कोड गोल्फ था, तो यह होगा return N<2?1:f(N-1)+f(n-2)। : पी

— कोनोर ओ ब्रायन

Answer 4

आप यह भी जांच सकते हैं कि अन्य सभी बिट्स 0 इस तरह हैं:

return (N & ~1) == 0 ? 1 : N * fibn(N-1);

मैट के लिए पूर्णता के लिए धन्यवाद और भी बेहतर समाधान:

return (N | 1) == 1 ? 1 : N * fibn(N-1);

दोनों ही मामलों में आपको कोष्ठक की देखभाल करने की आवश्यकता है क्योंकि बिटवाइज़ ऑपरेटरों की तुलना में कम प्राथमिकता है ==।

Comments

मुझें यह पसंद है! धन्यवाद।

— 15:60 बजे user6048670

1 कम वर्ण:(N|1)==1

— मैट

@at 3 | 1 है 3 क्योंकि b0011 | b0001 है b0011

— Ren Vogt

@ एटक यह बिटवाइज़ है या तार्किक या कोई कमी नहीं है।

— इसहाक

@ होटेन सही, लेकिन मैट ने कहा 1 कम चरित्र , 1 कम ऑपरेशन नहीं ।

— इवान स्टोव

Answer 5

यदि आप क्या करना चाहते हैं, तो फ़ंक्शन को अधिक कुशल बनाना है, तो एक लुकअप तालिका का उपयोग करें। लुकअप तालिका केवल 47 प्रविष्टियों पर आश्चर्यजनक रूप से छोटी है - अगली प्रविष्टि 32-बिट अहस्ताक्षरित पूर्णांक को ओवरफ्लो करेगी। यह भी निश्चित रूप से फ़ंक्शन को लिखने के लिए तुच्छ बनाता है।

class Sequences
{
    // Store the complete list of values that will fit in a 32-bit unsigned integer without overflow.
    private static readonly uint[] FibonacciSequence = { 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144,
        233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657, 46368, 75025, 121393, 196418,
        317811, 514229, 832040, 1346269, 2178309, 3524578, 5702887, 9227465, 14930352, 24157817, 39088169,
        63245986, 102334155, 165580141, 267914296, 433494437, 701408733, 1134903170, 1836311903, 2971215073
    };

    public uint fibn(uint N)
    {
        return FibonacciSequence[N];
    }
}

आप स्पष्ट रूप से गुटों के लिए एक ही काम कर सकते हैं।

Answer 6

इसे बिटशिफ्ट के साथ कैसे करें

यदि आप बिटशिफ्ट का उपयोग करना चाहते हैं और कोड को कुछ अस्पष्ट (लेकिन छोटा) कर सकते हैं:

public uint fibn ( uint N ) {
   return N >> 1 != 0? fibn(N-1) + finb(N-2): 1;
}

Nभाषा c में एक अहस्ताक्षरित पूर्णांक के लिए, N>>1निम्न क्रम बिट बंद हो जाता है। यदि वह परिणाम गैर-शून्य है, तो इसका मतलब है कि एन 1 से अधिक है।

नोट: यह एल्गोरिथ्म बहुत ही अयोग्य है क्योंकि यह पहले से ही गणना किए गए अनुक्रम में मूल्यों की पुनरावृत्ति करता है।

कुछ तेजी से होगा

गणना करें कि एक पास के बजाय एक फाइबोनैसी (एन) आकार के पेड़ का निर्माण करें:

uint faster_fibn(uint N) { //requires N > 1 to work
  uint a = 1, b = 1, c = 1;
  while(--N != 0) {
    c = b + a;
    a = b;
    b = c;
  }
  return c;
}

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

Comments

न केवल घातीय बढ़ते पेड़ से बचें, बल्कि आप टर्नरी ऑपरेटर की संभावित शाखा से भी बच सकते हैं जो आधुनिक सीपीयू पाइपलाइनों को रोक सकता है।

— मैथ्रेडलर

आपका '' अधिक तेज़ '' कोड C # में काम नहीं करेगा क्योंकि uintअंतर्निहित रूप से यह करने योग्य नहीं है bool, और प्रश्न को विशेष रूप से C # के रूप में चिह्नित किया गया है।

— फराप

इसके बाद @pharap करें --N != 0। मुद्दा यह है कि कुछ O (n) O (रेशेदार (n)) के लिए बेहतर है।

— मैथ्यू गन

@ MatthewGunn के दृष्टिकोण, हे (मिथ्या (एन)) पर विस्तार करने के लिए हे है (फ़ाई ^ n) (इस व्युत्पत्ति को देखने stackoverflow.com/a/360773/2788187 )

— कॉनर क्लार्क

@ RenéVogt मैं एसी # डेवलपर नहीं हूं। मैं ज्यादातर O (फाइबर्न (N)) एल्गोरिदम की पूरी बेतुकी टिप्पणी करने की कोशिश कर रहा था। क्या यह अब संकलन करता है? (मैंने कहा! = 0 चूंकि c # गैर-शून्य परिणामों को सही नहीं मानता है।) यह सीधे काम करता है (और काम करता है) यदि आप uint को कुछ मानक जैसे uint64_t से बदलते हैं।

— मैथ्यू गन

Answer 7

जैसा कि आप एक यूंट का उपयोग करते हैं, जो नकारात्मक नहीं हो सकता है, आप जांच कर सकते हैं कि क्या n < 2

संपादित करें

या उस विशेष फ़ंक्शन केस के लिए आप इसे इस प्रकार लिख सकते हैं:

public uint fibn(uint N)
    return (N == 0) ? 1 : N * fibn(N-1);
}

जो एक ही परिणाम की ओर ले जाएगा, बेशक एक अतिरिक्त पुनरावृत्ति कदम की कीमत पर।

Comments

@ कैथलएमएफ: लेकिन परिणाम एक ही है, क्योंकि1 * fibn(0) = 1 * 1 = 1

— डेरपश्चर

क्या आपका फ़ंक्शन फैक्टरियल की गणना नहीं कर रहा है, न कि रिट्रेसमेंट?

— बरमार

@ बरमार हाँ, वास्तव में यह तथ्यात्मक है, क्योंकि यह मूल प्रश्न था

— derpirscher

इसे कहते हैं नहीं हो सकता है सबसे अच्छा हो fibnतो

— pie3636

@ pie3636 मैंने इसे फाइबर्न कहा क्योंकि यह मूल प्रश्न में कहा गया था और मैंने बाद में उत्तर को अपडेट नहीं किया

— derpirscher

Answer 8

बस यह देखने के लिए जांचें कि Nक्या <= 1 है क्योंकि आप जानते हैं कि एन अहस्ताक्षरित है केवल 2 स्थितियां हो सकती हैं : N <= 1जिसके परिणामस्वरूप TRUE: 0 और 1

public uint fibn ( uint N ) 
{
   return (N <= 1) ? 1 : fibn(N-1) + finb(N-2);
}

Comments

क्या इससे कोई फर्क नहीं पड़ता कि यह हस्ताक्षरित है या अहस्ताक्षरित है? एल्गोरिथ्म नकारात्मक इनपुट के साथ अनंत पुनरावृत्ति पैदा करता है, इसलिए उन्हें 0 या 1 के बराबर इलाज में कोई नुकसान नहीं है

— बरमार

@ बरम ज़रूर यह मायने रखता है, खासकर इस विशिष्ट मामले में। ओपी ने पूछा कि क्या वह बिल्कुल सरल बना सकता है (N == 0 || N == 1)। आप जानते हैं कि यह 0 से कम नहीं होगा (क्योंकि तब यह हस्ताक्षर किया जाएगा!), और अधिकतम 1 हो सकता है। N <= 1इसे सरल करता है। मुझे लगता है कि अहस्ताक्षरित प्रकार की गारंटी नहीं है, लेकिन इसे कहीं और संभाला जाना चाहिए, मैं कहूंगा।

— james

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

— बरमार

या हम नकारात्मक इनपुट्स के साथ कुछ भी कर सकते हैं, जिसमें उन्हें पुनरावृत्ति के आधार मामले के रूप में शामिल करना शामिल है।

— बरमार

@ सुंदर यकीन है कि अगर आप नकारात्मक सेट करने की कोशिश करेंगे तो uint को हमेशा अहस्ताक्षरित में बदल दिया जाएगा

— james

Answer 9

अस्वीकरण: मैं C # नहीं जानता, और इस कोड का परीक्षण नहीं किया:

लेकिन मैं सोच रहा हूं कि क्या मैं इसे [...] को एक ही तुलना में बदलकर और भी अधिक कॉम्पैक्ट और कुशल बना सकता हूं ...

बिटशिफ्टिंग या इस तरह की आवश्यकता नहीं है, यह सिर्फ एक तुलना का उपयोग करता है, और यह बहुत अधिक कुशल होना चाहिए (ओ (एन) बनाम ओ (2 ^ एन) मुझे लगता है?)। फ़ंक्शन का शरीर अधिक कॉम्पैक्ट है , हालांकि यह घोषणा के साथ थोड़ा लंबा होता है।

(पुनरावृत्ति से ओवरहेड निकालने के लिए, पुनरावृत्ति संस्करण है, जैसा कि मैथ्यू गन के उत्तर में है )

public uint fibn ( uint N, uint B=1, uint A=0 ) 
{
    return N == 0 ? A : fibn( N--, A+B, B );
}

                     fibn( 5 ) =
                     fibn( 5,   1,   0 ) =
return 5  == 0 ? 0 : fibn( 5--, 0+1, 1 ) =
                     fibn( 4,   1,   1 ) =
return 4  == 0 ? 1 : fibn( 4--, 1+1, 1 ) =
                     fibn( 3,   2,   1 ) =
return 3  == 0 ? 1 : fibn( 3--, 1+2, 2 ) =
                     fibn( 2,   3,   2 ) =
return 2  == 0 ? 2 : fibn( 2--, 2+3, 3 ) =
                     fibn( 1,   5,   3 ) =
return 1  == 0 ? 3 : fibn( 1--, 3+5, 5 ) =
                     fibn( 0,   8,   5 ) =
return 0  == 0 ? 5 : fibn( 0--, 5+8, 8 ) =
                 5
fibn(5)=5

पुनश्च: यह संचायक के साथ पुनरावृत्ति के लिए एक सामान्य कार्यात्मक पैटर्न है। आप की जगह तो N--साथ N-1आप को प्रभावी ढंग से कोई उत्परिवर्तन, बनाता है जो प्रयोग कर रहे हैं यह एक शुद्ध कार्यात्मक दृष्टिकोण में उपयोगी।

Answer 10

यहां मेरा समाधान है, इस सरल कार्य को अनुकूलित करने में बहुत कुछ नहीं है, दूसरी तरफ मैं जो यहां पेश कर रहा हूं वह पुनरावर्ती फ़ंक्शन की गणितीय परिभाषा के रूप में पठनीयता है।

public uint fibn(uint N) 
{
    switch(N)
    {
        case  0: return 1;

        case  1: return 1;

        default: return fibn(N-1) + fibn(N-2);
    }
}

इसी तरह से फिबोनाची संख्या की गणितीय परिभाषा ।।

लुकअप टेबल बनाने के लिए स्विच केस को मजबूर करने के लिए इसे आगे ले जाना।

public uint fibn(uint N) 
{
    switch(N)
    {
        case  0: return 1;
        case  1: return 1;
        case  2: return 2;
        case  3: return 3;
        case  4: return 5;
        case  5: return 8;
        case  6: return 13;
        case  7: return 21;
        case  8: return 34;
        case  9: return 55;
        case 10: return 89;
        case 11: return 144;
        case 12: return 233;
        case 13: return 377;
        case 14: return 610;
        case 15: return 987;
        case 16: return 1597;
        case 17: return 2584;
        case 18: return 4181;
        case 19: return 6765;
        case 20: return 10946;
        case 21: return 17711;
        case 22: return 28657;
        case 23: return 46368;
        case 24: return 75025;
        case 25: return 121393;
        case 26: return 196418;
        case 27: return 317811;
        case 28: return 514229;
        case 29: return 832040;
        case 30: return 1346269;
        case 31: return 2178309;
        case 32: return 3524578;
        case 33: return 5702887;
        case 34: return 9227465;
        case 35: return 14930352;
        case 36: return 24157817;
        case 37: return 39088169;
        case 38: return 63245986;
        case 39: return 102334155;
        case 40: return 165580141;
        case 41: return 267914296;
        case 42: return 433494437;
        case 43: return 701408733;
        case 44: return 1134903170;
        case 45: return 1836311903;
        case 46: return 2971215073;

        default: return fibn(N-1) + fibn(N-2);
    }
}

Comments

आपके समाधान का लाभ यह है कि यह केवल गणना की जाती है जब जरूरत होती है। बेस्ट एक लुकअप टेबल होगी। वैकल्पिक बोनस: f (n-1) = someCalcOf (f (n-2)), इसलिए पूर्ण री-रन की जरूरत नहीं है।

— करस्टेन

@Karsten मैंने स्विच के लिए पर्याप्त मान जोड़ दिए हैं ताकि इसके लिए एक लुकअप तालिका बनाई जा सके। मुझे यकीन नहीं है कि वैकल्पिक बोनस कैसे काम करता है।

— खालिद.के।

यह प्रश्न का उत्तर कैसे देता है?

— क्लार्क केंट

@SaviourSelf यह एक लुकअप टेबल पर आता है, और उत्तर में समझाया गया दृश्य पहलू है। stackoverflow.com/a/395965/2128327

— खालिद.के

switchजब आप उत्तर की एक सरणी रख सकते हैं तो आप इसका उपयोग क्यों करेंगे ?

— नायुकी

Answer 11

एन के लिए यूइंट है, बस उपयोग करें

N <= 1

Comments

मैं बिल्कुल यहीं सोच रहा था; एन यूंट है! यह जवाब होना चाहिए, वास्तव में।

— squashed.bugaboo

Answer 12

दिमित्री का उत्तर सबसे अच्छा है, लेकिन अगर यह एक इंट 32 रिटर्न प्रकार था और आपके पास ऐसा करने के लिए पूर्णांकों का एक बड़ा सेट है, तो आप ऐसा कर सकते हैं।

return new List<int>() { -1, 0, 1, 2 }.Contains(N) ? 1 : N * fibn(N-1);

Comments

मूल से छोटा कैसे है?

— MCMastery

@MCMastery इसकी छोटी नहीं है। जैसा कि मैंने इसका केवल बेहतर उल्लेख किया है यदि मूल रिटर्न प्रकार एक इंट 32 है और वह वैध संख्याओं के एक बड़े सेट से चयन कर रहा है। लिखने के लिए (एन == -1) एन == 0 || एन == 1 || एन == 2)

— कैथलएफएफ

ओपी के कारण अनुकूलन से संबंधित प्रतीत होते हैं। यह कई कारणों से एक बुरा विचार है: 1) प्रत्येक पुनरावर्ती कॉल के अंदर एक नई वस्तु को तात्कालिक करना एक बहुत बुरा विचार है, 2) List.ContainsO (n) है, 3) इसके बजाय केवल दो तुलना करना ( N > -3 && N < 3) कम और अधिक पठनीय कोड देगा।

— ग्रो

@Groo और मान क्या है अगर -10, -2, 5, 7, 13

— कैथलएफएफ

ऐसा नहीं है जो ओपी ने पूछा। लेकिन वैसे भी, आप अभी भी 1) प्रत्येक कॉल में एक नया उदाहरण नहीं बनाना चाहते हैं, 2) एक विशिष्ट समस्या के लिए (3) के बजाय (एकल) हैशसेट का बेहतर उपयोग करेंगे, आप हैश फ़ंक्शन को अनुकूलित करने में भी सक्षम होंगे शुद्ध रहें, या यहां तक ​​कि चतुराई से व्यवस्थित बिटवाइज़ जैसे अन्य उत्तरों में सुझाए गए का उपयोग करें।

— ग्रू

Answer 13

फाइबोनैचि अनुक्रम संख्याओं की एक श्रृंखला है जहां एक संख्या को इससे पहले दो संख्याओं को जोड़कर पाया जाता है। शुरुआती बिंदु दो प्रकार के होते हैं: ( 0,1 , 1,2, ..) और ( 1,1 , 2,3)।

-----------------------------------------
Position(N)| Value type 1 | Value type 2
-----------------------------------------  
1          |  0           |   1
2          |  1           |   1
3          |  1           |   2
4          |  2           |   3
5          |  3           |   5
6          |  5           |   8
7          |  8           |   13
-----------------------------------------

Nइस मामले में स्थिति से शुरू होता है 1, यह 0-basedएक सरणी सूचकांक के रूप में नहीं है ।

C # 6 एक्सप्रेशन-बॉडी फीचर और दिमित्री के टर्नरी ऑपरेटर के बारे में सुझाव का उपयोग करके हम टाइप 1 के लिए सही गणना के साथ एक लाइन फ़ंक्शन लिख सकते हैं:

public uint fibn(uint N) => N<3? N-1: fibn(N-1)+fibn(N-2);

और टाइप 2 के लिए:

public uint fibn(uint N) => N<3? 1: fibn(N-1)+fibn(N-2);

Answer 14

पार्टी के लिए थोड़ा देर से, लेकिन आप भी कर सकते हैं (x==!!x)

!!xमान को धर्मान्तरित करता है 1यदि यह नहीं है 0, और 0यदि है तो इसे छोड़ देता है।
मैं सी थोड़े बहुत में इस थोड़े चीज का उपयोग करता हूं।

नोट: यह C है, निश्चित नहीं है कि यह C # में काम करता है

Comments

यकीन नहीं होता कि यह क्यों उखड़ गया। यहां तक कि इस प्रयास कर सरसरी के रूप में uint n = 1; if (n == !!n) { }देता है Operator '!' cannot be applied to operand of type 'uint'पर !nसी में #। सिर्फ इसलिए कि सी में कुछ काम करता है इसका मतलब यह नहीं है कि यह सी # में काम करता है; यहां तक ​​कि #include <stdio.h>सी # में भी काम नहीं करता है, क्योंकि सी # में प्रीप्रोसेसर निर्देश "शामिल" नहीं है। भाषाएं C और C ++ की तुलना में अधिक भिन्न हैं।

— बजे एक CVn

ओह। ठीक है। मुझे खेद है :(

— एक सामान्य रात

@OneNormalNight (x == !! x) यह कैसे काम करेगा। मेरे इनपुट पर विचार करें 5. (5 == !! 5)। यह सच के रूप में परिणाम देगा

— VINOTH ENERGETIC

@VinothKumar !! 5 का मूल्यांकन 1. (5 == !! 5) का मूल्यांकन करता है (5 == 1) जो असत्य का मूल्यांकन करता है।

— एक सामान्य रात

@OneNormalNight हाँ अब मुझे मिल गया। ! (5) 1 देता है फिर से लागू होता है यह 0. नहीं देता है 1.

— विनोथे मोंटेटिक

Answer 15

इसलिए मैंने Listइनमें से एक विशेष पूर्णांक बनाया और जाँच की कि क्या Nयह संबंधित है।

static List<uint> ints = new List<uint> { 0, 1 };

public uint fibn(uint N) 
{
   return ints.Contains(N) ? 1 : fibn(N-1) + fibn(N-2);
}

आप विभिन्न उद्देश्यों के लिए एक एक्सटेंशन विधि का उपयोग भी कर सकते हैं Contains, जिसे केवल एक बार कहा जाता है (उदाहरण के लिए जब आपका आवेदन शुरू हो रहा है और डेटा लोड हो रहा है)। यह एक स्पष्ट शैली प्रदान करता है और आपके मूल्य के प्राथमिक संबंध को स्पष्ट करता है ( N):

static class ObjectHelper
{
    public static bool PertainsTo<T>(this T obj, IEnumerable<T> enumerable)
    {
        return (enumerable is List<T> ? (List<T>) enumerable : enumerable.ToList()).Contains(obj);
    }
}

इसे लागाएं:

N.PertainsTo(ints)

यह ऐसा करने का सबसे तेज़ तरीका नहीं हो सकता है, लेकिन मेरे लिए, यह एक बेहतर शैली प्रतीत होती है।