വിപരീത ക്രമത്തിൽ ഫിബൊനാച്ചി നമ്പറുകൾ അച്ചടിക്കുക


വൈഷമ്യ നില എളുപ്പമായ
പതിവായി ചോദിക്കുന്നു ഓട്ടോമോട്ടീവ് MAQ 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 യുടെ മൂല്യം ഓരോന്നായി വർദ്ധിപ്പിക്കുമ്പോൾ i യുടെ മൂല്യം n നേക്കാൾ കുറവായിരിക്കും.
    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

സങ്കീർണ്ണത വിശകലനം

സമയ സങ്കീർണ്ണത

O (N), ഫിബൊനാച്ചി സംഖ്യകൾ കണക്കാക്കാൻ ഈ സമയം ആവശ്യമാണ്. കാരണം ഫിബൊനാച്ചി സീക്വൻസ് കണ്ടെത്താൻ ഞങ്ങൾ ഒരൊറ്റ ലൂപ്പ് പ്രവർത്തിപ്പിക്കുന്നു. സമയ സങ്കീർണ്ണത രേഖീയമാണ്.

ബഹിരാകാശ സങ്കീർണ്ണത

O (N), ഫിബൊനാച്ചി നമ്പറുകളുടെ മൂല്യങ്ങൾ സംഭരിക്കാൻ ഞങ്ങൾ ഒരു അറേ ഉപയോഗിച്ചതിനാൽ, സ്ഥല സങ്കീർണ്ണത രേഖീയമാണ്.