ಪ್ಯಾಸ್ಕಲ್‌ನ ತ್ರಿಕೋನ II ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರ


ತೊಂದರೆ ಮಟ್ಟ ಸುಲಭ
ಆಗಾಗ್ಗೆ ಕೇಳಲಾಗುತ್ತದೆ ಅಮೆಜಾನ್ ಮೈಕ್ರೋಸಾಫ್ಟ್
ಅರೇ ಡೈನಾಮಿಕ್ ಪ್ರೊಗ್ರಾಮಿಂಗ್ ಮಠ

ಪರಿವಿಡಿ

ಸಮಸ್ಯೆ ಹೇಳಿಕೆ

ಈ ಸಮಸ್ಯೆಯಲ್ಲಿ ನಮಗೆ ಪ್ಯಾಸ್ಕಲ್ ತ್ರಿಕೋನದ ಸಾಲು ಸೂಚ್ಯಂಕ (i) ನೀಡಲಾಗಿದೆ. ನಾವು ith ಸಾಲಿನ ಮೌಲ್ಯಗಳನ್ನು ಹೊಂದಿರುವ ರೇಖೀಯ ಶ್ರೇಣಿಯನ್ನು ರಚಿಸಬೇಕು ಮತ್ತು ಅದನ್ನು ಹಿಂತಿರುಗಿಸಬೇಕು. ಸಾಲು ಸೂಚ್ಯಂಕ 0 ರಿಂದ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ.
ಪ್ಯಾಸ್ಕಲ್‌ನ ತ್ರಿಕೋನವು ಒಂದು ತ್ರಿಕೋನವಾಗಿದೆ ಎಂದು ನಮಗೆ ತಿಳಿದಿದೆ, ಅಲ್ಲಿ ಪ್ರತಿ ಸಂಖ್ಯೆಯು ಅದರ ಮೇಲಿನ ಎರಡು ಸಂಖ್ಯೆಗಳ ಮೊತ್ತವಾಗಿರುತ್ತದೆ.

ಪ್ಯಾಸ್ಕಲ್‌ನ ತ್ರಿಕೋನ II ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರ

ಉದಾಹರಣೆ

rowIndex = 3
[1,3,3,1]
rowIndex = 0
[1]

ಪ್ಯಾಸ್ಕಲ್‌ನ ತ್ರಿಕೋನದ ಪ್ರತಿಯೊಂದು ಮೌಲ್ಯವು ದ್ವಿಪದ ಗುಣಾಂಕ (ಎನ್‌ಸಿಆರ್) ಎಂದು ನಮಗೆ ತಿಳಿದಿರುವಂತೆ, ಅಲ್ಲಿ n ಸಾಲು ಮತ್ತು r ಎಂಬುದು ಆ ಮೌಲ್ಯದ ಕಾಲಮ್ ಸೂಚ್ಯಂಕವಾಗಿದೆ.

ನಾವು ಇದೇ ರೀತಿಯ ಸಮಸ್ಯೆಯನ್ನು ಚರ್ಚಿಸಿದ್ದೇವೆ, ಅಲ್ಲಿ ನಾವು ಎಲ್ಲಾ ಸಾಲುಗಳನ್ನು ಸಾಲು ಸೂಚ್ಯಂಕ 0 ರಿಂದ ಪ್ಯಾಸ್ಕಲ್‌ನ ತ್ರಿಕೋನದ ಕೊಟ್ಟಿರುವ ಸಾಲು ಸೂಚ್ಯಂಕಕ್ಕೆ ಹಿಂದಿರುಗಿಸಬೇಕು - ಪ್ಯಾಸ್ಕಲ್ ತ್ರಿಕೋನ ಲೀಟ್‌ಕೋಡ್

ಆದರೆ ಈ ಸಮಸ್ಯೆಯಲ್ಲಿ ನಾವು ಸೂಚ್ಯಂಕವನ್ನು ನೀಡಿದ ಒಂದೇ ಸಾಲನ್ನು ಮಾತ್ರ ಹಿಂತಿರುಗಿಸಬೇಕಾಗಿದೆ.
ಈ ಸಮಸ್ಯೆಯ ಪರಿಹಾರಕ್ಕಾಗಿ ನಾವು ಮೂರು ವಿಧಾನಗಳನ್ನು ಇಲ್ಲಿ ಚರ್ಚಿಸುತ್ತೇವೆ:

ಅಪ್ರೋಚ್ 1 (ವಿವೇಚನಾರಹಿತ ಶಕ್ತಿ ಪುನರಾವರ್ತನೆ)

ಈ ತ್ರಿಕೋನದ ಪ್ರತಿಯೊಂದು ಸಂಖ್ಯೆಯು ಅದರ ಮೇಲಿರುವ ಎರಡು ಸಂಖ್ಯೆಗಳ ಮೊತ್ತ ಎಂದು ನಮಗೆ ತಿಳಿದಿದೆ. ಅಂದರೆ
ಸಂಖ್ಯೆ (ಸಾಲು, ಕೋಲ್) = ಸಂಖ್ಯೆ (ಸಾಲು -1, ಕೋಲ್) + ಸಂಖ್ಯೆ (ಸಾಲು -1, ಕೋಲ್ -1).
ಆದ್ದರಿಂದ ನಾವು ಆ ಸಾಲಿನ ಪ್ರತಿ ಕಾಲಮ್ ಸೂಚ್ಯಂಕಕ್ಕೆ ನಮ್ (ರೋಇಂಡೆಕ್ಸ್, ಜೆ) ಕಾರ್ಯವನ್ನು ಪದೇ ಪದೇ ಕರೆಯಬಹುದು ಮತ್ತು ರೂಪುಗೊಂಡ ಪಟ್ಟಿಯನ್ನು ಹಿಂತಿರುಗಿಸಬಹುದು.

ನಾವು ನೋಡುವಂತೆ ನಾವು ಸಂಖ್ಯೆ (i, j) ಅನ್ನು ಕಂಡುಹಿಡಿಯಲು ಪುನರಾವರ್ತಿತ ವಿಧಾನವನ್ನು ರೂಪಿಸಿದ್ದೇವೆ. ಅದಕ್ಕಾಗಿ ಈಗ ಕೆಲವು ಮೂಲ ಪ್ರಕರಣಗಳಿವೆ:

  • ಮೊದಲ ಸಾಲಿನಲ್ಲಿನ ಮೌಲ್ಯ 1 ಆಗಿರುತ್ತದೆ. ಆದ್ದರಿಂದ ಸಾಲು = 0, ಸಂಖ್ಯೆ (ಸಾಲು,…) = 0 ಗೆ.
  • ಮೊದಲ ಕಾಲಂನಲ್ಲಿನ ಮೌಲ್ಯವು 1 ಆಗಿರುತ್ತದೆ. ಆದ್ದರಿಂದ ಕೋಲ್ = 0, ಸಂಖ್ಯೆ (…, ಕೋಲ್) = 0 ಗೆ.
  • ಪ್ರತಿ ಸಾಲಿನ ಕೊನೆಯ ಮೌಲ್ಯವು 1 ಕ್ಕೆ ಸಮನಾಗಿರುತ್ತದೆ. ಆದ್ದರಿಂದ col = row = k, Num (k, k) = 0 ಗೆ.

ಪ್ಯಾಸ್ಕಲ್‌ನ ತ್ರಿಕೋನ II ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರಕ್ಕಾಗಿ ಅನುಷ್ಠಾನ

ಸಿ ++ ಪ್ರೋಗ್ರಾಂ

#include <bits/stdc++.h>
using namespace std;

int nCr(int n,int r)
{
    if(n==0 || r==0 || r==n)
        return 1;

    return nCr(n-1,r-1)+ nCr(n-1,r);
}


vector<int> getRow(int rowIndex) 
{
    vector<int> res(rowIndex+1);

    for(int i=0;i<=rowIndex;i++)
        res[i]= nCr(rowIndex,i);

    return res;

}

int main() 
{
    int rowIndex=3;
    vector<int> ans= getRow(rowIndex);
    for(auto val:ans) cout<<val<<" ";
    
    cout<<endl;
    return 0; 
}
1 3 3 1

ಜಾವಾ ಪ್ರೋಗ್ರಾಂ

import java.util.*;

class Rextester{
    
    static int nCr(int n,int r)
    {
        if(n==0 || r==0 || r==n)
            return 1;

        return nCr(n-1,r-1)+ nCr(n-1,r);
    }

    public static List<Integer> getRow(int rowIndex) 
    {
       List<Integer> res=new ArrayList<Integer>();
        for(int i=0;i<=rowIndex;i++)
            res.add(nCr(rowIndex,i));

        return res;
    }

  public static void main(String args[])
    {
       	int rowIndex=3;
        List<Integer> ans= getRow(rowIndex);
        for(int val:ans)  System.out.print(val+" ");
    }
}
1 3 3 1

ಪ್ಯಾಸ್ಕಲ್‌ನ ತ್ರಿಕೋನ II ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರಕ್ಕಾಗಿ ಸಂಕೀರ್ಣತೆ ವಿಶ್ಲೇಷಣೆ

ಸಮಯ ಸಂಕೀರ್ಣತೆ

ಒ (2 ^ ಕೆ): ಇಲ್ಲಿ k ಎಂಬುದು ಕೊಟ್ಟಿರುವ ಸಾಲು ಸೂಚ್ಯಂಕವಾಗಿದೆ.
ನಾವು ಸಂಖ್ಯಾ (i, j) ಗಾಗಿ ಪುನರಾವರ್ತನೆಯನ್ನು Num (i-1, j) + Num (i-1, j-1) ಎಂದು ಕರೆಯುತ್ತಿದ್ದೇವೆ. ಆದ್ದರಿಂದ ಸಂಖ್ಯೆ (n, r) ಅನ್ನು ಕಂಡುಹಿಡಿಯುವ ಸಮಯ nCr ಆಗಿರುತ್ತದೆ.
ಕೊಟ್ಟಿರುವ ಸಾಲು (ಕೆ) ನ ಎಲ್ಲಾ ಕಾಲಮ್ ಸೂಚ್ಯಂಕಕ್ಕಾಗಿ ನಾವು ಈ ಪುನರಾವರ್ತಿತ ಕಾರ್ಯವನ್ನು ಕರೆಯುತ್ತಿದ್ದೇವೆ .ಇದು
kC0 + kC1 + kC2 +…. + kCk = 2 ^ k.
ಆದ್ದರಿಂದ ಒಟ್ಟು ಸಮಯದ ಸಂಕೀರ್ಣತೆಯು O (2 ^ k) ಆಗಿರುತ್ತದೆ.

ಬಾಹ್ಯಾಕಾಶ ಸಂಕೀರ್ಣತೆ 

ಸರಿ): ಕೊಟ್ಟಿರುವ ಸಾಲಿನ ಎಲ್ಲಾ ಮೌಲ್ಯಗಳನ್ನು ಪಟ್ಟಿಯಲ್ಲಿ ಸಂಗ್ರಹಿಸಲು ನಮಗೆ ಒ (ಕೆ) ಸ್ಥಳ ಬೇಕು. ಕೆಟ್ಟ ಸಂದರ್ಭದಲ್ಲಿ ನಮ್ಮ ಪುನರಾವರ್ತನೆಗೆ ಪುನರಾವರ್ತಿತ ಕರೆಗಾಗಿ ಒ (ಕೆ) ಸ್ಟಾಕ್ ಸ್ಥಳ ಬೇಕಾಗುತ್ತದೆ. ಆದ್ದರಿಂದ O (k) + O (k) = ~ O (k).

ಅಪ್ರೋಚ್ 2 (ಡೈನಾಮಿಕ್ ಪ್ರೊಗ್ರಾಮಿಂಗ್)

ಮೇಲಿನ ಪುನರಾವರ್ತನೆಯಲ್ಲಿ ನಾವು ಒಂದೇ (i, j) ಕಾರ್ಯಕ್ಕಾಗಿ ಪುನರಾವರ್ತಿತವಾಗಿ Num (i, j) ಕಾರ್ಯವನ್ನು ಕರೆಯುತ್ತಿದ್ದೇವೆ ಎಂದು ನೋಡಬಹುದು.

ಆದ್ದರಿಂದ ನಾವು ಏನು ಮಾಡಬಹುದೆಂದರೆ, ನಾವು ಪ್ರತಿಯೊಂದಕ್ಕೂ (ಐ, ಜೆ) ಉತ್ತರಗಳನ್ನು ಜ್ಞಾಪಕದಲ್ಲಿಟ್ಟುಕೊಳ್ಳಬಹುದು, ಇದರಿಂದಾಗಿ ಆ ಕಾರ್ಯವನ್ನು ಮತ್ತೆ ಕರೆಯುವ ಅಗತ್ಯವಿರುವಾಗಲೆಲ್ಲಾ ನಾವು ಮತ್ತೆ ಲೆಕ್ಕ ಹಾಕದೆ ಸಂಗ್ರಹಿಸಿದ ಉತ್ತರವನ್ನು ಮೆಮೊರಿಯಿಂದ ನೇರವಾಗಿ ಹಿಂದಿರುಗಿಸುತ್ತೇವೆ. ಹೀಗಾಗಿ ಸಾಕಷ್ಟು ಸಮಯವನ್ನು ಉಳಿಸುತ್ತದೆ.
ನಾವು ಬಳಸಬಹುದಾದ ಉತ್ತರಗಳನ್ನು ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ಸಂಗ್ರಹಿಸಲು ಹ್ಯಾಶ್ ನಕ್ಷೆ ಕೀಲಿಯು ಸಾಲು ಸೂಚ್ಯಂಕ ಮತ್ತು ಕಾಲಮ್ ಸೂಚ್ಯಂಕದ ಸಂಯೋಜನೆಯಾಗಿರುತ್ತದೆ.

ನಾವು ಇಲ್ಲಿ ನೋಡಬಹುದಾದ ಇನ್ನೊಂದು ವಿಷಯವೆಂದರೆ ಪ್ರಸ್ತುತ ಸಾಲಿನ ಮೌಲ್ಯಗಳನ್ನು ಕಂಡುಹಿಡಿಯಲು ನಮಗೆ ಹಿಂದಿನ ಸಾಲು ಮೌಲ್ಯಗಳು ಮಾತ್ರ ಬೇಕಾಗುತ್ತವೆ. ಆದ್ದರಿಂದ ನಾವು ಒಂದು ಸಮಯದಲ್ಲಿ ಒಂದು ಸಾಲು ಮೌಲ್ಯಗಳನ್ನು ಮಾತ್ರ ಸಂಗ್ರಹಿಸಬಹುದು ಮತ್ತು ಮುಂದಿನ ಸಾಲಿನ ಮೌಲ್ಯಗಳನ್ನು ಕಂಡುಹಿಡಿಯಲು ಅದನ್ನು ಬಳಸಬಹುದು. ಆದ್ದರಿಂದ ನಾವು ಇಲ್ಲಿ ಒ (ಕೆ) ಗೆ ಜಾಗದ ಸಂಕೀರ್ಣತೆಯನ್ನು ಕಡಿಮೆ ಮಾಡಬಹುದು.

ಸ್ಪೇಸ್ ಆಪ್ಟಿಮೈಸ್ಡ್ ಅಲ್ಗಾರಿದಮ್:
1. ಹಿಂದಿನ ಸಾಲು ಮತ್ತು ಪ್ರಸ್ತುತ ಸಾಲಿಗೆ ಕ್ರಮವಾಗಿ ಎರಡು ಸರಣಿಗಳನ್ನು ರಚಿಸಿ.
2. ಪ್ರಾರಂಭಿಸಿ ಕೊನೆಯ ಸಾಲು {1 as.
3. i = 1 ರಿಂದ i = ಗೆ ith ಸಾಲುಗಾಗಿ ಲೂಪ್ ಅನ್ನು ಚಲಾಯಿಸಿrowIndex. ಮತ್ತು ಹಿಂದಿನ ಸಾಲಿನಿಂದ ಹೊಸ ಸಾಲು ಮೌಲ್ಯಗಳನ್ನು ರಚಿಸಿ ಮತ್ತು ಅದನ್ನು ಸಂಗ್ರಹಿಸಿ ಕರ್ ರಚನೆ.
4. ಈಗ ನವೀಕರಿಸಿ ಕೊನೆಯ ನಿಯೋಜಿಸುವ ಮೂಲಕ ಸಾಲು ಹೃದಯ ಗೆ ಸಾಲು ಕೊನೆಯ ಈ ಲೂಪ್ನಲ್ಲಿ ಅದೇ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಸಾಲು ಮಾಡಿ ಮತ್ತು ಪುನರಾವರ್ತಿಸಿ.
5. ಸಂಗ್ರಹಿಸಲಾದ ಕೊನೆಯ ಸಾಲನ್ನು ಹಿಂತಿರುಗಿ ಕೊನೆಯ ರಚನೆ.

ಪ್ಯಾಸ್ಕಲ್‌ನ ತ್ರಿಕೋನ II ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರಕ್ಕಾಗಿ ಅನುಷ್ಠಾನ

ಮೆಮೋಯೈಸೇಶನ್ ಬಳಸುವ ಸಿ ++ ಪ್ರೋಗ್ರಾಂ

#include <bits/stdc++.h>
using namespace std;

unordered_map<string,int> cache;

int nCr(int n,int r)
{
    string key= to_string(n)+to_string(r);
    if(cache.count(key)) return cache[key]; 

    if(n==0 || r==0 || r==n)
        return 1;

    return ( cache[key]= nCr(n-1,r-1)+ nCr(n-1,r) );
}


vector<int> getRow(int rowIndex) 
{
    vector<int> res(rowIndex+1);

    for(int i=0;i<=rowIndex;i++)
        res[i]= nCr(rowIndex,i);

    return res;

}

int main() 
{
    int rowIndex=3;
    vector<int> ans= getRow(rowIndex);
    for(auto val:ans) cout<<val<<" ";
    
    cout<<endl;
    return 0; 
}

ಸಿ ++ ಪ್ರೋಗ್ರಾಂ (ಸ್ಪೇಸ್ ಆಪ್ಟಿಮೈಸ್ಡ್ ಡಿಪಿ)

#include <bits/stdc++.h>
using namespace std;

vector<int> getRow(int rowIndex) 
{
    vector<int> prev={1},curr;
    for(int i=1;i<=rowIndex;i++)
    {
        curr.clear();
        curr.resize(i+1,1);

        for(int j=1;j<i;j++)
            curr[j]=prev[j]+prev[j-1];

        prev=curr;
    }

    return prev;
}

int main() 
{
    int rowIndex=3;
    vector<int> ans= getRow(rowIndex);
    for(auto val:ans) cout<<val<<" ";
    
    cout<<endl;
    return 0; 
}
1 3 3 1

ಜ್ಞಾಪಕವನ್ನು ಬಳಸುವ ಜಾವಾ ಪ್ರೋಗ್ರಾಂ

import java.util.*;

class Rextester{
    
    static Map<String,Integer> cache=new HashMap<String,Integer>();
    
    static int nCr(int n,int r)
    {
        String key= "" + n + r;
        if(cache.containsKey(key)) return cache.get(key); 
        
        if(n==0 || r==0 || r==n)
            return 1;
        
        int ans= nCr(n-1,r-1)+ nCr(n-1,r);
        cache.put(key,ans);
        return ans;
    }

    public static List<Integer> getRow(int rowIndex) 
    {
       List<Integer> res=new ArrayList<Integer>();
        for(int i=0;i<=rowIndex;i++)
            res.add(nCr(rowIndex,i));

        return res;
    }

  public static void main(String args[])
    {
       	int rowIndex=3;
        List<Integer> ans= getRow(rowIndex);
        for(int val:ans)  System.out.print(val+" ");
    }
}

ಜಾವಾ ಪ್ರೋಗ್ರಾಂ (ಸ್ಪೇಸ್ ಆಪ್ಟಿಮೈಸ್ಡ್ ಡಿಪಿ)

#include <bits/stdc++.h>
using namespace std;

vector<int> getRow(int rowIndex) 
{
    vector<int> prev={1},curr;
    for(int i=1;i<=rowIndex;i++)
    {
        curr.clear();
        curr.resize(i+1,1);

        for(int j=1;j<i;j++)
            curr[j]=prev[j]+prev[j-1];

        prev=curr;
    }

    return prev;
}

int main() 
{
    int rowIndex=3;
    vector<int> ans= getRow(rowIndex);
    for(auto val:ans) cout<<val<<" ";
    
    cout<<endl;
    return 0; 
}
1 3 3 1

ಪ್ಯಾಸ್ಕಲ್‌ನ ತ್ರಿಕೋನ II ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರಕ್ಕಾಗಿ ಸಂಕೀರ್ಣತೆ ವಿಶ್ಲೇಷಣೆ

ಸಮಯ ಸಂಕೀರ್ಣತೆ

ಒ (ಕೆ ^ 2):  ಜ್ಞಾಪಕೀಕರಣವು ಒಂದು ನಿರ್ದಿಷ್ಟ ಅಂಶವನ್ನು ಒಮ್ಮೆ ಮಾತ್ರ ಲೆಕ್ಕಹಾಕುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ. ಮತ್ತು ಹ್ಯಾಶ್ ನಕ್ಷೆಯಿಂದ ಉತ್ತರಗಳನ್ನು ಪಡೆಯಲು ನಿರಂತರ ಸಮಯ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಎಂದು uming ಹಿಸಿದರೆ ಪ್ಯಾಸ್ಕಲ್‌ನ ತ್ರಿಕೋನದ ಪ್ರತಿಯೊಂದು ಮೌಲ್ಯವನ್ನು ಲೆಕ್ಕಹಾಕಲು ನಿರಂತರ ಸಮಯ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.
ಈಗ ನಾವು 1 + 2 + 3 +… + (ಕೆ + 1) = (ಕೆ + 1) (ಕೆ + 2) / 2 ಮೌಲ್ಯಗಳನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುವುದನ್ನು ಕೊನೆಗೊಳಿಸುತ್ತೇವೆ ಅದು = ~ ಒ (ಕೆ ^ 2).

ಬಾಹ್ಯಾಕಾಶ ಸಂಕೀರ್ಣತೆ 

1. ಸರಳ ಜ್ಞಾಪಕೀಕರಣವು ಎಲ್ಲಾ 1 + 2 + 3 +… + (ಕೆ + 1) = (ಕೆ + 1) (ಕೆ + 2) / 2 ಅಂಶಗಳನ್ನು ಕೆಟ್ಟ ಸಂದರ್ಭದಲ್ಲಿ ಹಿಡಿದಿಟ್ಟುಕೊಳ್ಳುತ್ತದೆ. ಅದು ಅಗತ್ಯವಾಗಿರುತ್ತದೆ ಒ (ಕೆ ^ 2) ಸ್ಥಳ.
2. ಬಾಹ್ಯಾಕಾಶ ಆಪ್ಟಿಮೈಸ್ಡ್ ಡಿಪಿಯಲ್ಲಿ ನಮಗೆ ಅಗತ್ಯವಿದೆ ಸರಿ) ಇತ್ತೀಚಿನ ರಚಿಸಿದ ಸಾಲನ್ನು ಸಂಗ್ರಹಿಸಲು ಮಾತ್ರ ಸ್ಥಳಾವಕಾಶ.

ಅಪ್ರೋಚ್ 3 (ಗಣಿತ)

ಪ್ಯಾಸ್ಕಲ್‌ನ ತ್ರಿಕೋನದ ಪ್ರತಿಯೊಂದು ಮೌಲ್ಯವು ದ್ವಿಪದ ಗುಣಾಂಕ (ಎನ್‌ಸಿಆರ್) ಎಂದು ನಮಗೆ ತಿಳಿದಿದೆ. ಮತ್ತು ನಾವು nCr ಅನ್ನು ಹೀಗೆ ಬರೆಯಬಹುದು:
ಪ್ಯಾಸ್ಕಲ್‌ನ ತ್ರಿಕೋನ II ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರ

ಈಗ ನಾವು ಗಮನಿಸಿದರೆ, ಸತತ ದ್ವಿಪದ ಗುಣಾಂಕಗಳಾದ ಎನ್‌ಸಿ (ಆರ್ -1) ಮತ್ತು ಎನ್‌ಸಿಆರ್ ಇವುಗಳ ಅಂಶದಿಂದ ಭಿನ್ನವಾಗಿವೆ:
ಪ್ಯಾಸ್ಕಲ್‌ನ ತ್ರಿಕೋನ II ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರ

ಹೀಗಾಗಿ, ನಾವು ಮುಂದಿನ ಪದವನ್ನು ಪ್ಯಾಸ್ಕಲ್‌ನ ತ್ರಿಕೋನದಲ್ಲಿ ಸತತವಾಗಿ ಹಿಂದಿನ ಪದದಿಂದ ಪಡೆಯಬಹುದು.

ಅಲ್ಗಾರಿದಮ್:

  1. ಸಾಲಿನ ಮೊದಲ ಪದವನ್ನು 1 ಎಂದು ಪ್ರಾರಂಭಿಸಿ.
  2. ಇಥ್ ಇಂಡೆಕ್ಸ್ಡ್ ಕಾಲಮ್‌ಗಾಗಿ ಲೂಪ್ ಅನ್ನು ಚಲಾಯಿಸಿ ಮತ್ತು ಮುಂದಿನ ಪದವನ್ನು (ಟರ್ಮ್ (ಐ)), ಟರ್ಮ್ (ಐ) = ಟರ್ಮ್ (ಐ -1) * (ಎನ್-ಐ + 1) / ಐ ಎಂದು ಲೆಕ್ಕಹಾಕಿ.
  3. ಲೆಕ್ಕಹಾಕಿದ ಮೌಲ್ಯಗಳನ್ನು ಪಟ್ಟಿಯಾಗಿ ಹಿಂತಿರುಗಿ.

ಪ್ಯಾಸ್ಕಲ್‌ನ ತ್ರಿಕೋನ II ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರಕ್ಕಾಗಿ ಅನುಷ್ಠಾನ

ಸಿ ++ ಪ್ರೋಗ್ರಾಂ

#include <bits/stdc++.h>
using namespace std;

vector<int> getRow(int rowIndex) 
{
    int n=rowIndex;
   vector<int> res;
   res.push_back(1);

    for(int i=1;i<=n;i++)
    {
       int x= (int) ( ((long long)res.back()*(n-i+1) ) /i);
       res.push_back(x);
    }

    return res;
}

int main() 
{
    int rowIndex=3;
    vector<int> ans= getRow(rowIndex);
    for(auto val:ans) cout<<val<<" ";
    
    cout<<endl;
    return 0; 
}
1 3 3 1

ಜಾವಾ ಪ್ರೋಗ್ರಾಂ

import java.util.*;

class Rextester{

    public static List<Integer> getRow(int rowIndex) 
    {
       int n=rowIndex;
       List<Integer> res=new ArrayList<Integer>();
       res.add(1);
        
        for(int i=1;i<=n;i++)
        {
           int x= (int) ( ((long)res.get(res.size()-1)*(n-i+1) ) /i);
           res.add(x);
        }
        
        return res;
    }

  public static void main(String args[])
    {
       	int rowIndex=3;
        List<Integer> ans= getRow(rowIndex);
        for(int val:ans)  System.out.print(val+" ");
    }
}
1 3 3 1

ಪ್ಯಾಸ್ಕಲ್‌ನ ತ್ರಿಕೋನ II ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರಕ್ಕಾಗಿ ಸಂಕೀರ್ಣತೆ ವಿಶ್ಲೇಷಣೆ

ಸಮಯ ಸಂಕೀರ್ಣತೆ

ಸರಿ): ಸಾಲಿನ ಪ್ರತಿಯೊಂದು ಮೌಲ್ಯವನ್ನು ಸ್ಥಿರ ಸಮಯದಲ್ಲಿ ಲೆಕ್ಕಹಾಕಲಾಗುತ್ತದೆ.

ಬಾಹ್ಯಾಕಾಶ ಸಂಕೀರ್ಣತೆ 

ಸರಿ): Hold ಟ್ಪುಟ್ ಅನ್ನು ಹಿಡಿದಿಟ್ಟುಕೊಳ್ಳುವುದನ್ನು ಹೊರತುಪಡಿಸಿ ಯಾವುದೇ ಹೆಚ್ಚುವರಿ ಸ್ಥಳದ ಅಗತ್ಯವಿಲ್ಲ.