એન-થ્રી ટ્રિબોનાકી નંબર લેટકોડ સોલ્યુશન


મુશ્કેલી સ્તર સરળ
વારંવાર પૂછવામાં આવે છે ફેસબુક
ડાયનેમિક પ્રોગ્રામિંગ

સમસ્યા નિવેદન

“એન-થ્રી ટ્રિબોનાકી નંબર” સમસ્યામાં આપણને નંબર એન આપવામાં આવે છે. અમારું કાર્ય એ N-th શોધવા માટે છે ટ્રિબોનાકી નંબર

ઝીરોથ ટ્રિબોનાકી નંબર 0 છે. પ્રથમ ટ્રિબોનાકી નંબર 1. છે. બીજી ટ્રિબોનાકી નંબર 1 છે.

N-th Tribonacci નંબર (N-1- th Tribonacci નંબર), (N-2- th Tribonacci નંબર), અને (N-3- th Tribonacci નંબર) નો સરવાળો છે.

એન-થ્રી ટ્રિબોનાકી નંબર લેટકોડ સોલ્યુશન

ઉદાહરણ

n = 4
4

સમજૂતી: ઝીરોથ તરીકે, પ્રથમ અને બીજા ટ્રિબોનાકીની સંખ્યા અનુક્રમે 0,1,1 છે. તેથી ત્રીજી ટ્રિબોનાકી નંબર છે (0 + 1 + 1) 2. તેવી જ રીતે, ચોથો ટ્રિબોનાકી (1 + 1 + 2) 4 છે.

N-th ટ્રિબોનાકી નંબર લીટકોડ સોલ્યુશન માટેનો અભિગમ

N-th Tribonacci નંબર (N-1), (N-2), અને (N-3) ટ્રિબોનાકી નંબરના સારાંશ તરીકે વ્યાખ્યાયિત થયેલ છે. તેથી અમને પહેલા (N-3) -thth Tribonacci નંબર જોઈએ છે જેનો ઉપયોગ ગણતરીમાં કરવામાં આવશે (N-2), (N-1), અને (N) -th Tribonacci નંબર. તેથી હવે અમારી નવી સમસ્યા એ (એન -3) -thth ટ્રિબોનાકી નંબરની ગણતરી કરવાની છે. અહીં આપણે એક વાતનો નિષ્કર્ષ કા canી શકીએ છીએ કે એન-થ્રી ટ્રિબોનાકી નંબરની ગણતરી કરવા માટે આપણે એકની ગણતરી એન-થ્રી ટ્રિબોનાકી નંબર પર કરવાની જરૂર છે કારણ કે દરેક આગલું મૂલ્ય પાછલા ત્રણ મૂલ્યો પર આધારિત છે. અમે આ પગલાંને અનુસરીશું:

  1. આપણે ઝીરોથ, પ્રથમ અને બીજા ટ્રિબોનાકી નંબરો ની વેલ્યુ ત્રણ ક્રમાંકોમાં સંગ્રહિત કરીશું, જેમ કે એ, બી અને સી.
  2. અહીં a, b અને c છેલ્લા ત્રણ ટ્રિબોનાકી નંબરો સંગ્રહિત કરશે. આ છેલ્લા ત્રણ ટ્રિબોનાકી નંબરોનો ઉપયોગ કરીને અમે આગામી ટ્રિબોનાકી નંબરની ગણતરી કરીશું અને પછી એ, બી અને સીના મૂલ્યોને અપડેટ કરીશું.
  3. અમે પગલું -2 પુનરાવર્તન કરીશું જ્યાં સુધી અમને એન-th ટ્રિબોનાકી નંબરની કિંમત ન મળે ત્યાં સુધી અમે તેને પરત કરીશું.

અમલીકરણ

સી ++ એન-થ્રી ટ્રિબોનાકી નંબર માટેનો કોડ

#include <bits/stdc++.h> 
using namespace std; 
    int tribonacci(int n) {
        if (n < 2) return n;
        int a = 0, b = 1, c = 1, d = a + b + c;
        while (n-- > 2) {
            d = a + b + c, a = b, b = c, c = d;
        }
        return c;
    }

int main() 
{ 
int n=4;
int ans=tribonacci(n); 
 cout<<ans<<endl;
 return 0;
}
4

N-th ટ્રિબોનાકી નંબર માટે જાવા કોડ

import java.util.Arrays;
import java.util.Set ;
import java.util.HashSet;
import java.util.*; 
public class Tutorialcup {
    public static int tribonacci(int n) {
        if (n < 2) return n;
        int a = 0, b = 1, c = 1, d;
        while (n-- > 2) {
            d = a + b + c;
            a = b;
            b = c;
            c = d;
        }
        return c;
    }
  public static void main(String[] args) {
        int n=4; 
        int ans=tribonacci(n); 
        System.out.println(ans);
  }
}
4

જટિલતા વિશ્લેષણ એન-થી ટ્રિબોનાકી નંબર લિટકોડ સોલ્યુશન

સમયની જટિલતા

ઉપરોક્ત કોડની સમય જટિલતા છે ઓ (એન) કારણ કે આપણે N-th ટ્રિબોનાકી નંબર સુધી પુનરાવર્તન કરીએ છીએ. અહીં n એ આપેલ નંબર છે જેના માટે આપણે N-th ટ્રિબોનાકી નંબરની ગણતરી કરવાની જરૂર છે.

જગ્યાની જટિલતા

ઉપરોક્ત કોડની અવકાશ જટિલતા છે ઓ (1) કારણ કે આપણે જવાબ સંગ્રહવા માટે માત્ર એક વેરીએબલ વાપરી રહ્યા છીએ.

સંદર્ભ