प्रौद्योगिकी साझेदारी

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

पुनरावृत्तेः सर्वाधिकं लोकप्रियं अवगमनं क्रमः भवति पुनरावृत्तिः अनुक्रमस्य च सम्बन्धः एल्गोरिदमस्य दत्तांशसंरचनायाः च सम्बन्धः इव भवति
यथा दत्तांशसंरचने रेखीयसूची (यत् क्रमिकसूची अथवा लिङ्क् कृतसूची भवितुम् अर्हति, प्रायः क्रमिकसूची), पुनरावृत्तिः अस्ति
एकः पाशः अथवा पुनरावर्तनीयः गणनाप्रक्रिया ।
पुनरावृत्तिः मूलतः गणितीयसमस्या अस्ति, अतः केचन छात्राः पृष्टवन्तः यत् एल्गोरिदम् इत्यस्य कृते उत्तमं गणितं आवश्यकं वा इति
एतानि गणितानि केवलं कनिष्ठ उच्चविद्यालये उच्चविद्यालये च दुर्बलतया ज्ञातानि वस्तूनि सन्ति वयं महाविद्यालयस्य प्रवेशपरीक्षां पूर्वमेव गतवन्तः, अतः एतेभ्यः विषयेभ्यः किमर्थं भयभीताः भवेयुः!?

1. फिबोनाची अनुक्रम

फिबोनाची संख्याभिः (प्रायः F(n) इत्यनेन प्रतिनिधितः) निर्मितः क्रमः फिबोनाची अनुक्रमः इति कथ्यते ।क्रमः 0 तथा 1 इत्यनेन आरभ्यते, तदनन्तरं
प्रत्येकं सङ्ख्या in इति पूर्वसङ्ख्याद्वयस्य योगः । अर्थात्:

च (0) = 0,च (1) = 1
f(n)=f(n -1)+ f(n- 2), जहाँ n>1, दी गई n(0 ≤n≤ 30), कृपया f(n) की गणना करें।

एतत् प्रश्नं प्राप्त्वा प्रथमं प्रश्नस्य परिधिं पश्यामः, यत् ३० तः अधिकं न भवेत् ।तत् यतो हि फिबोनाची संख्यानां वृद्धिः अतीव द्रुतगतिः भवति
द्रुतम्, घातीयरूपेण। अतः यदि n बृहत् अस्ति तर्हि C भाषायां 32-बिट् पूर्णाङ्कानां परिधिं अतिक्रमयिष्यति ।एतत् सर्वाधिकं मूलभूतं प्रसवम् अस्ति
अस्माभिः पूर्वमेव कटौतीप्रश्नः पुनरावृत्तिसूत्रं च कथितं यत् अस्माभिः केवलं एतत् पुनरावृत्तिः कार्यान्वितुं लूप् इत्यस्य उपयोगः करणीयः ।
अस्माकं केवलं F[31] एरे इत्यस्य उपयोगः करणीयः, F[0] तथा F[1] इत्येतयोः आरम्भः करणीयः, ततः दत्तसूत्रानुसारं लूप् मध्ये तस्य गणना करणीयम् ।

int febonacci(int n) {  
    int F[30] = {0,1};  
    for (int i = 2; i < 30; i++) {  
        F[i] = F[i - 1] + F[i - 2];  
    }  
    return F[29]  
}
1
2
3
4
5
6
7

2. तबोनाची अनुक्रम

तबोनाची क्रमः Tn इति परिभाषितः अस्ति ।
T(0) = 0, T(1) = 1,T(2)=1
तथा च n>2, T(n)=T(n-1)+T(n-2)+T(n-3) इत्यस्य शर्तेन, भवन्तं n पूर्णाङ्कं दत्त्वा, कृपया nth Tabonacci प्रत्यागच्छतु
T(n) इति संख्यायाः मूल्यम् ।
यदि भवान् पूर्वमेव Fibonacci क्रमं अवगच्छति तर्हि एषा समस्या कठिना नास्ति, परन्तु आरम्भकाले प्रथमत्रिसङ्ख्याः आरम्भं कर्तुं आवश्यकम् ।
तथा च लूप् पुनरावृत्तिगणनायाः समये वर्तमानसङ्ख्यायाः मूल्ये पूर्वत्रिसङ्ख्यानां मूल्यानां सञ्चितयोगः आवश्यकः भवति । इव : १.

int tribonacci(int n) {  
    int F[30] = {0,1,1};  
    for (int i = 3; i < 30; i++) {  
        F[i] = F[i - 1] = F[i - 2] + F[i - 3];  
    }  
    return F[29];  
}
1
2
3
4
5
6
7

3. द्विविधा पुनरावृत्तिसमस्या

Fibonacci अनुक्रम इत्यादीनां समस्यानां समाधानं एकविमीयसरण्या सह कर्तुं शक्यते कदाचित् यदा एकः आयामः तस्य समाधानं कर्तुं न शक्नोति तदा I
अस्माभिः समस्यां उच्चतरपरिमाणात् अवलोकनीयम्।

दीर्घता न(१
परन्तु अन्ये वर्णाः न भवेयुः) तथा च M इत्यस्य परस्परं समीपस्थत्वं निषिद्धम् अस्ति यत् एतादृशाः ताराः कति प्रकाराः सन्ति।

दीर्घता n इति विचार्य, तत्र च 'A' इत्यनेन समाप्ताः f[n][0] प्रकाराः, 'C' इत्यनेन समाप्ताः f[n][1] प्रकाराः ताराः सन्ति, तत्र च f[n][ १] '' '' इत्यनेन समाप्ताः ताराः प्रकाराः ।
f[n][2] जातिः

4. वास्तविकं युद्धम्

४.१ ५०९ फिबोनाची संख्यानां समीपे

फिबोनाची संख्या(प्रायः प्रयुक्तःF(n)प्रतिनिधियति) निर्मितः क्रमः उच्यतेफिबोनाची अनुक्रम .अयं क्रमः युक्तः0तथा1प्रारम्भे प्रत्येकं अनन्तरसङ्ख्या पूर्वसङ्ख्याद्वयस्य योगः भवति ।

int fib(int n){
    if(n == 0){
       return 0;

    }
    else if (n == 1){
        return 1;

    }
    return fib(n - 1) + fib(n - 2);
}
1
2
3
4
5
6
7
8
9
10
11

४.२ लिकोउ ७० सोपानमारोहणम्

भवन्तः सोपानम् आरोहन्ति इति कल्पयन्तु।आवश्यकताnभवनस्य शिखरं पदानि स्वीकृत्य प्राप्तुं शक्नुवन्ति ।
प्रत्येकं समये भवन्तः आरोहणं कर्तुं शक्नुवन्ति1वा2 एकं पदम् । भवनस्य शिखरं प्रति कतिभिः प्रकारैः आरोहणं कर्तुं शक्यते ?

int climbStairs(int n) {  
    int f[46];  
    f[0] = 1;  
    f[1] = 1;  
    for(int i = 2; i <= n; i++){  
        f[i] = f[i - 1] + f[i - 2];  
    }  
    return f[n];  
}
1
2
3
4
5
6
7
8
9

४.३ लिकोउ ११९ याङ्ग हुई त्रिकोण||

अऋणात्मकं सूचकाङ्कं दत्तम्rowIndex, "याङ्ग हुई त्रिकोण" इत्यस्य तृतीयबिन्दुं प्रति प्रत्यागच्छन्तु ।rowIndexअस्तु।

int* getRow(int rowIndex, int* returnSize) {  
    int f[34][34];  
    for(int i = 0; i <= rowIndex; i++){  
        for(int j = 0; j <= i; j++){  
            if(j ==0 || j == i){  
                f[i][j] = 1;  
            }  
            else {  
                f[i][j] = f[i - 1][j] + f[i - 1][j - 1];   
            }  
        }  
    }  
    int* ret = (int *)malloc (sizeof(int) * (rowIndex + 1));  
    for(int j = 0; j <= rowIndex; j++){  
        ret[j] = f[rowIndex][j];  
    }  
    *returnSize = rowIndex + 1;  
    return ret;  
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19