ਫਿਬੋਨਾਚੀ ਨੰਬਰ ਉਲਟਾ ਕ੍ਰਮ ਵਿੱਚ ਪ੍ਰਿੰਟ ਕਰੋ


ਮੁਸ਼ਕਲ ਪੱਧਰ ਸੌਖੀ
ਅਕਸਰ ਪੁੱਛਿਆ ਜਾਂਦਾ ਹੈ Accenture ਮੈਕ o9 ਹੱਲ UHG ਆਪਟਮ
ਡਾਇਨਾਮਿਕ ਪ੍ਰੋਗਰਾਮਿੰਗ ਕ੍ਰਮ

ਸਮੱਸਿਆ ਦਾ ਬਿਆਨ

ਇੱਕ ਨੰਬਰ n ਦਿੱਤਾ ਗਿਆ, ਫਾਈਬੋਨੈਕਸੀ ਨੰਬਰ ਨੂੰ ਉਲਟਾ ਕ੍ਰਮ ਵਿੱਚ ਪ੍ਰਿੰਟ ਕਰੋ.

ਉਦਾਹਰਨ

n = 5
3 2 1 1 0

ਸਪਸ਼ਟੀਕਰਨ: ਫਿਬੋਨਾਚੀ ਨੰਬਰ ਉਨ੍ਹਾਂ ਦੇ ਕ੍ਰਮ ਅਨੁਸਾਰ 0, 1, 1, 2, 3 ਹਨ. ਪਰ ਕਿਉਂਕਿ ਸਾਨੂੰ ਉਲਟਾ ਕ੍ਰਮ ਵਿੱਚ ਪ੍ਰਿੰਟ ਕਰਨ ਦੀ ਲੋੜ ਸੀ.

n = 7
8 5 3 2 1 1 0

ਫਿਬੋਨਾਚੀ ਨੰਬਰ ਉਲਟਾ ਕ੍ਰਮ ਵਿੱਚ ਪ੍ਰਿੰਟ ਕਰੋ

ਚਿੱਤਰ ਇਹ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ ਕਿਵੇਂ ਫਿਬੋਨਾਚੀ ਨੰਬਰ ਆਖਰੀ 2 ਫਿਬੋਨਾਚੀ ਨੰਬਰ ਦੇ ਨਤੀਜੇ ਤੇ ਨਿਰਭਰ ਹਨ.

ਐਲਗੋਰਿਥਮ

  1. ਇੰਪੁੱਟ ਲਓ, ਪ੍ਰਿੰਟ ਕੀਤੇ ਜਾਣ ਵਾਲੇ ਤੱਤਾਂ ਦੀ ਗਿਣਤੀ.
  2. ਦਿੱਤੇ ਇੰਪੁੱਟ ਦੇ ਅਕਾਰ ਦੇ ਅਰੇ ਦਾ ਐਲਾਨ ਕਰੋ.
  3. 0 ਅਤੇ 1 ਨਾਲ 0 ਵੇਂ ਅਤੇ 1 ਵੇਂ ਐਰੇ ਇੰਡੈਕਸ ਨੂੰ ਅਰੰਭ ਕਰੋ.
  4. ਅਸੀਂ i = 2 ਤੋਂ ਇੱਕ ਲੂਪ ਚਲਾਉਣਾ ਅਰੰਭ ਕਰਦੇ ਹਾਂ, ਜਦ ਤੱਕ i ਦਾ ਮੁੱਲ n ਤੋਂ ਘੱਟ ਨਹੀਂ ਹੁੰਦਾ ਜਦੋਂ ਕਿ i ਦੇ ਮੁੱਲ ਨੂੰ ਇੱਕ ਇੱਕ ਕਰਕੇ ਵਧਾਉਂਦੇ ਹੋਏ.
    1. ਅੰਤਮ ਤਤਕਰਾ ਦੇ ਤੱਤ ਅਤੇ ਪਿਛਲੇ ਤੋਂ ਪਿਛਲੇ ਅੰਤਿਮ ਤੱਤ ਦੇ ਜੋੜ ਨੂੰ ਸਟੋਰ ਕਰਦੇ ਰਹੋ.
  5. ਹੁਣ ਇਸ ਐਰੇ ਨੂੰ ਉਲਟਾ ਕ੍ਰਮ ਵਿੱਚ ਪ੍ਰਿੰਟ ਕਰੋ.

ਪਹੁੰਚ

ਫਿਬੋਨਾਚੀ ਨੰਬਰਾਂ ਨੂੰ ਪ੍ਰਿੰਟ ਕਰਨ ਲਈ ਇਕ ਭੋਰਾ ਜਿਹਾ ਪਹੁੰਚ ਹਮੇਸ਼ਾ ਰਿਹਾ ਹੈ ਮੁੜ. ਅਤੇ ਜਦੋਂ ਵੀ ਸਾਨੂੰ ਦੁਹਰਾਉਣ ਬਾਰੇ ਦੱਸਿਆ ਜਾਂਦਾ ਹੈ, ਸਭ ਤੋਂ ਪਹਿਲਾਂ ਜਿਸ ਬਾਰੇ ਸਾਨੂੰ ਆਮ ਤੌਰ ਤੇ ਦੱਸਿਆ ਜਾਂਦਾ ਹੈ ਉਹ ਹਨ ਫਿਬੋਨਾਚੀ ਨੰਬਰ. ਇਸ ਲਈ, ਰੀਕੋਰਜ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਦਿਆਂ ਅਸੀਂ ਫਿਬੋਨਾਚੀ ਨੰਬਰ ਲੱਭ ਸਕਦੇ ਹਾਂ. ਅਤੇ ਫਿਰ ਉਹਨਾਂ ਨੂੰ ਉਲਟਾ ਕ੍ਰਮ ਵਿੱਚ ਪ੍ਰਿੰਟ ਕਰੋ. ਪਰ ਅਜਿਹਾ ਕਰਨ ਲਈ ਭਾਰੀ ਗਣਨਾ ਦੀ ਜ਼ਰੂਰਤ ਹੈ, ਇਸ ਲਈ ਅਜਿਹਾ ਕਰਨ ਦੀ ਬਜਾਏ ਸਾਨੂੰ ਇੱਕ ਵਿਕਲਪਕ ਪਹੁੰਚ ਬਾਰੇ ਸੋਚਣ ਦੀ ਜ਼ਰੂਰਤ ਹੈ.

ਵਿਕਲਪਕ ਪਹੁੰਚ ਹੈ ਗਤੀਸ਼ੀਲ ਪ੍ਰੋਗਰਾਮਿੰਗ, ਜਿੱਥੇ ਅਸੀਂ ਉਹ ਡੇਟਾ ਸਟੋਰ ਕਰਦੇ ਹਾਂ ਜਿਸਦੀ ਸਮੱਸਿਆ ਦੇ ਹੱਲ ਲਈ ਅਕਸਰ ਲੋੜ ਹੁੰਦੀ ਹੈ. ਅਸੀਂ ਇਸਦੀ ਵਰਤੋਂ ਕਰਦਿਆਂ ਫਿਬੋਨੈਕੀ ਨੰਬਰ ਲੱਭਣ ਬਾਰੇ ਵੀ ਵਿਚਾਰ ਵਟਾਂਦਰੇ ਕੀਤੇ ਹਨ ਗਤੀਸ਼ੀਲ ਪ੍ਰੋਗਰਾਮਿੰਗ ਪਿਛਲੇ ਵਿੱਚ ਪੋਸਟ.

ਕੋਡ

ਉਲਟਾ ਕ੍ਰਮ ਵਿੱਚ ਫਿਬੋਨਾਕੀ ਨੰਬਰ ਪ੍ਰਿੰਟ ਕਰਨ ਲਈ ਸੀ ++ ਕੋਡ

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

int main()
{
    int n;cin>>n;
    int fib[n];
    if(n>=1)
    fib[0] = 0;
    if(n>=2)
    fib[1] = 1;
    for(int i=2;i<n;i++)
        fib[i] = fib[i-1] + fib[i-2];
    for(int i=n-1;i>=0;i--)
        cout<<fib[i]<<" ";
}
4
2 1 1 0

ਜਾਵਾ ਕੋਡ ਉਲਟਾ ਕ੍ਰਮ ਵਿੱਚ ਫਿਬੋਨੈਕਸੀ ਨੰਬਰ ਪ੍ਰਿੰਟ ਕਰਨ ਲਈ

import java.util.*;
class Main{
  
  public static void main(String[] args)
  {
    Scanner sc = new Scanner(System.in);
    int n = sc.nextInt();
    	int fib[] = new int[n];
    	if(n>=0)
    		fib[0] = 0;
    	if(n>=1)
    		fib[1] = 1;
    	for(int i=2;i<n;i++)
    		fib[i] = fib[i-1] + fib[i-2];
    	for(int i=n-1;i>=0;i--)
    		System.out.print(fib[i]+" ");
  	}
}
4
2 1 1 0

ਜਟਿਲਤਾ ਵਿਸ਼ਲੇਸ਼ਣ

ਟਾਈਮ ਜਟਿਲਤਾ

ਓ (ਐੱਨ), ਫਿਬੋਨੈਕਸੀ ਨੰਬਰਾਂ ਦੀ ਗਣਨਾ ਕਰਨ ਲਈ ਇਸ ਸਮੇਂ ਦੀ ਲੋੜ ਹੈ. ਕਿਉਂਕਿ ਅਸੀਂ ਫਿਬੋਨੈਕਸੀ ਲੜੀ ਨੂੰ ਲੱਭਣ ਲਈ ਸਿਰਫ ਇਕੋ ਲੂਪ ਚਲਾਉਂਦੇ ਹਾਂ. ਸਮੇਂ ਦੀ ਜਟਿਲਤਾ ਰੇਖਿਕ ਹੈ.

ਸਪੇਸ ਦੀ ਜਟਿਲਤਾ

ਓ (ਐਨ), ਕਿਉਂਕਿ ਅਸੀਂ ਫਿਬੋਨਾਚੀ ਨੰਬਰਾਂ ਦੇ ਮੁੱਲਾਂ ਨੂੰ ਸਟੋਰ ਕਰਨ ਲਈ ਇੱਕ ਐਰੇ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਹੈ, ਸਪੇਸ ਦੀ ਗੁੰਝਲਤਾ ਰੇਖਿਕ ਹੈ.