This recurring algorithm needs to be rewritten. In this case, O(n) is complex and memory will have to be constant (about the number increases).Here's an example of how to count and take it out.#include <iostream> #include <gmp.h> #include <gmpxx.h> #include <chrono> using namespace std; mpz_class pp(int n) { if (n < 1 || n >= 10000000) return 0; if (n < 3) return 1; mpz_class a = 1; mpz_class b = 1; mpz_class c = 1; for (int i = 3; i < n; i++) { mpz_class t = a + b + c; c = b; b = a; a = t; } return a; } int main() { auto t1 = std::chrono::steady_clock::now(); cout &lt;&lt; pp(1000000) &lt;&lt; endl; auto t2 = std::chrono::steady_clock::now(); auto d_milli = std::chrono::duration_cast&lt;std::chrono::milliseconds&gt;( t2 - t1 ).count(); cout &lt;&lt; d_milli &lt;&lt; endl; return 0; } The question is, how fast is that? For a millionth element in my car, it took 22 seconds. For 100,000 elements, about 145ms. For 10,000 units, it's 2-4 ms.And after. How do you compromise?g++ -std=c++11 ff.cpp -lgmpxx -lgmp P.S. must not forget to place the library gmp.updI decided to rewrite with a handful of large numbers. The stowage code is not the best, but gmp only loses six to eight times. If you rewrite sse, I think you can pull more. But even for such a simple exercise, I don't think it's bad.#include <iostream> #include <vector> #include <string> #include <iomanip> #include <gmp.h> #include <gmpxx.h> #include <chrono> #define CLEN 8 #define BASE 100000000 class bi { public: bi() { } bi(std::string data) { for (int i = 0; i < data.length(); i+= CLEN) { int r = std::stoi(data.substr(i, CLEN)); m_digits.push_back(r); } } bi(const bi& data) { m_digits = data.m_digits; } bi(int data) { while (data &gt; 0) { m_digits.push_back(data % BASE); data = data / BASE; } } bi&amp; operator=(bi data) { if (this != &amp;data) { m_digits = data.m_digits; } return *this; } friend std::ostream&amp; operator&lt;&lt; (std::ostream&amp; stream, const bi&amp; b); friend bi operator+( const bi&amp; lhs, const bi&amp; rhs ); private: std::vector&lt;int&gt; m_digits; }; std::ostream& operator<< (std::ostream& stream, const bi& b) { for (int i = b.m_digits.size() - 1; i >= 0; i--) { if (i != b.m_digits.size() - 1) { stream << std::setfill('0') << std::setw(CLEN); } stream << b.m_digits[i]; } return stream; } bi operator+( const bi& lhs, const bi& rhs ) { bi result; size_t ls = lhs.m_digits.size(); size_t rs = rhs.m_digits.size(); size_t lm = std::min(ls, rs); result.m_digits.reserve(std::max(ls, rs) + 1); int p = 0; for (size_t i = 0; i &lt; lm; i++) { int c = lhs.m_digits[i] + rhs.m_digits[i] + p; result.m_digits.push_back(c % BASE); p = c / BASE; } if (ls &gt; rs) { for (size_t i = lm; i &lt; ls; i++) { int c = lhs.m_digits[i] + p; result.m_digits.push_back(c % BASE); p = c / BASE; } } if (rs &gt; ls) { for (size_t i = lm; i &lt; rs; i++) { int c = rhs.m_digits[i] + p; result.m_digits.push_back(c % BASE); p = c / BASE; } } if (p &gt; 0) { result.m_digits.push_back(p); } return result; } template <typename T> T pp(int n) { if (n < 1 || n >= 10000000) return 0; if (n < 3) return 1; T a = 1; T b = 1; T c = 1; for (int i = 3; i < n; i++) { T t = a + b + c; c = b; b = a; a = t; } return a; } template<typename T> int test(int n) { auto t1 = std::chrono::steady_clock::now(); std::cout &lt;&lt; pp&lt;T&gt;(n) &lt;&lt; std::endl; auto t2 = std::chrono::steady_clock::now(); auto d_milli = std::chrono::duration_cast&lt;std::chrono::milliseconds&gt;( t2 - t1 ).count(); std::cout &lt;&lt; d_milli &lt;&lt; std::endl; return d_milli; } int main() { int n = 10000; int gmp = test<mpz_class>(n); int my = test<bi>(n); std::cout << "gmp = " << gmp << " my = " << my << std::endl; std::cout << "my/gmp = " << my/gmp << std::endl; return 0; }

It's just that you don't use practice. f(50) Don't wait. ♪ ♪What form? f(n) = f(n-1)+f(n-2)♪ That's it. Definition Chisel. Next, f(1)==f(2)==1♪ That's it. For example, f(5) = f(4) + f(3) f(4) Call. f(3) and f(2)♪ f(3) ♪ f(2) and f(1):f(4) = f(3) + f(2); f(3) = f(2) + f(1); f(3) In the left, it. f(2) and f(1)♪ And they're not calling anyone back. Let's go back.f(3) = 1+1 = 2; f(4) = 2+1 = 3; f(5) = 3+2 = 5; Come back. f(5)♪ That's it.

Perhaps the problem is, if your implementation of the algorithm is to hand over the number 41, which, of course, should be excluded from the task, it will return 1.More likely, for the Stepic.org platform, you may be overestimated because your decision creates a storage space for all Fibonacci chips, and in fact you need only two last sequential members.Try a solution using a class, for example: function fib(n) { if(n == 1 || n == 2){ return 1; } return fib(n-1) + fib(n-2); } What if you use that decision?function fib(n){ if (n == 1 || n == 2) { return 1; } var prev = 1, current = 1; for(var i = 3; i &lt;= n; i++) { temp = current; current = prev + current; prev = temp; } return current; } Looks like it's not in algorithm, it's in Stepic.org. The Python3 algorithm was tested first:def fib(n): if n == 1 or n == 2: return 1 prev = 1 current = 1 for i in range(3, n + 1): temp = current; current = prev + current; prev = temp; return current

for(int i=0;i<x;i++) { if(m[i]<2) m[i]=1; else m[i]=m[i-1]+m[i-2]; } You're for every element of the mass, if it's less than two, you're giving equal weight. 1♪ And move to the next element.Since the mass is originally initiated by zeros, it is expected that you receive a body of units.

Components up to n - It's just F(n + 2) - 1♪ I mean, we need to find the number of Fibonacci in one of the ways. n- and count the unit.How do you find the number of Fibonacci? https://ru.stackoverflow.com/questions/73573/%D0%A1%D1%83%D0%BC%D0%BC%D0%B0-%D1%80%D1%8F%D0%B4%D0%B0-%D0%A4%D0%B8%D0%B1%D0%BE%D0%BD%D0%B0%D1%87%D1%87%D0%B8#73578 Stanislav.

Decision on Python:import sys lineIn = sys.stdin.readline().split(" ") n = int(lineIn[0]) m = int(lineIn[1]) fibPrev = 0 fib = 1 cached = [fibPrev, fib] for curr in range(1, n): fibOld = fib fib = (fib + fibPrev) % m fibPrev = fibOld if fibPrev == 0 and fib == 1: cached.pop() break else: cached.append(fib) offset = n % len(cached) sys.stdout.write(str(cached[offset])) Test 1:python ~/Work/python/learning/fibonacci.py 1000000000001 99999 63715 Process finished with exit code 0 Test 2:python ~/Work/python/learning/fibonacci.py 100000000000000000000000000001 100 1 Process finished with exit code 0

The value of generating functions in languages that support tail call optimization (e.g. any platform language .net - C#, F#, C+CLI) is practically different from the normal cycle. And even if this optimization is not possible, the challenge of a non-virtual function is usually cheap enough.So the recurring algorithms work at the same speed as their linear ones. analogs♪ If analogs are used in a a direct sense, then a classroom is a way to organize a code.Specifically case Fib You usually do two. various different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different different algorithm:in linear, you calculate the values of the consistency members once.You're probably counting F (some specific x) several times.This discrepancy is being eliminated by the use of technology called memoization. https://ru.wikipedia.org/wiki/%D0%9C%D0%B5%D0%BC%D0%BE%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F - Cashing the results of F(x). Fib is a pure function (it depends only on its arguments), the result is easily quashed:This is the option that will calculate the Fib (x) value every time - slowlet rec fibs n = if n < 1 then 1 else (fibs (n - 1)) + (fibs (n - 2)) http://www.fssnip.net/8P which will calculate Fib (x) only once for each x:let rec fibs = memoize (fun n -> if n < 1 then 1 else (fibs (n - 1)) + (fibs (n - 2))) where memoize This is:open System.Collections.Generic /// The function creates a function that calls the argument 'f' /// only once and stores the result in a mutable dictionary (cache) /// Repeated calls to the resulting function return cached values. let memoize f = // Create (mutable) cache that is used for storing results of // for function arguments that were already calculated. let cache = new Dictionary<_, _>() (fun x -> // The returned function first performs a cache lookup let succ, v = cache.TryGetValue(x) if succ then v else // If value was not found, calculate & cache it let v = f(x) cache.Add(x, v) v) By the way, Fib is such a typical example for memoization that it is shown in the haskel wiki in the section. https://wiki.haskell.org/Memoization#Memoization_with_recursion where memoization is shorter than F#:memoized_fib :: Int -> Integer memoized_fib = (map fib [0 ..] !!) where fib 0 = 0 fib 1 = 1 fib n = memoized_fib (n-2) + memoized_fib (n-1) As WORN recalled, not all the lessons can be optimized through tail call. For example, decision fibs F# above shall not be optimised. The solution and support of such optimization is as follows:let fib n = let rec loop acc1 acc2 = function | n when n = 0I -> acc1 | n -> loop acc2 (acc1 + acc2) (n - 1I) loop 0I 1I n In fact, it's the same cycle, a function that causes itself, once, by handing over the last two sequencing members, but it's a recurring form. It's about that. https://github.com/fsharp/fsharp/blob/master/src/fsharp/FSharp.Core/seq.fs which allows for the generation of sequences in which the next element depends on the previous.

var n = 10; // Сколько элементов хотим получить var fibonacci = [0, 1]; // Первые два элемента последовательности Фибоначчи for (i = 2; i < n; i ++) { // Получаем i-й элемент последовательности как сумму предыдущих двух fibonacci[i] = fibonacci[i-1] + fibonacci[i-2]; } console.log(fibonacci.slice(0,n)); // slice отрезает от массива первые n элементов, если n < 2

Based on the google and the motto of those who have received the same task before you, the teacher hopes to get the symbols grouped into a pack of sizes from the sequence of Fibonacci. To this end, the sequence of Fibonacci should be considered, and gaps or transfers should be made in the right places. If you stick to your code style, the solution is like:#include<stdio.h> #include<conio.h> #include<ctype.h> int Fibonacci(int n) { if (n == 0) return 0; else if (n == 1) return 1; else return (Fibonacci(n - 1) + Fibonacci(n - 2)); } void main() { FILE *f1 = NULL; if (!(f1 = fopen("c:\\temp\\in.txt", "r"))) { printf("Error! Cannot open file"); getch(); return; } fseek(f1, 0, SEEK_END); int fileLength = (unsigned long)ftell(f1); fseek(f1, 0, SEEK_SET); char *all = new char[fileLength]; int total = 0; while (!feof(f1)) { char c; fscanf(f1, "%c", &amp;c); if (isalpha(c)) { all[total++] = c; } } fclose(f1); FILE *f2 = NULL; if (!(f2 = fopen("c:\\temp\\Result.txt", "w"))) { printf("Error! Cannot open file 2"); getch(); return; } printf("Kilkist liter: %d\n", total); fprintf(f2, "Kilkist liter: %d\n", total); int fibindex = 1; int currentFib = 1; for (int i = 0; i &lt; total; i++) { printf("%c", all[i]); fprintf(f2, "%c", all[i]); currentFib--; if (currentFib == 0) { currentFib = Fibonacci(++fibindex); printf("\n"); fprintf(f2, "\n"); } } fclose(f2); } Z.A., I'll guess the city by the teacher. Blackcasses?

Let's see it from a mathematical point of view. Let her n- and cycling a = x♪ b = y♪ Then in line a = a + b It'll work. a = x + y♪ Follow-up line b = a - b Got it. b = (x + y) - y = x♪ Thus, b Previous value a♪ a - The following value, calculated according to the rules for the sequence of Fibonacci.

Fibonacci sequence:1 1 2 3 5 8 ... We have a number five. So... f(5) The answer is 5, if it works right. Let's take a look at this:f(5) = f(4) + f(3) f(4) = f(3) + f(2) f(3) = f(2) + f(1) f(4) = (f(2) + f(1)) + f(2) f(5) = [(f(2) + f(1)) + f(2)] + [f(2) + f(1)] Т.к. f(2) = f(1) = 1, то f(5) = 1 + 1 + 1 + 1 + 1 = 5 It all matches!

I'd just write.System.out.print("1 1 2 3 5 8 13 21 34 55 89"); Your code is fine. I don't think the only way to write the Fibonacci sequence is to compute it.int fib(int i) { if (i == 1) return 1; if (i == 2) return 1; return fib(i - 1) + fib(i - 2); } That's a way to use a class.

It is known that, in the classic recurring algorithm, the number of Fibonacci f(n) has to be determined f(n+1) of the recurring challenges. Therefore, the total time to calculate the number of Fibonacci n is time f(n+1) * t, where t is time for one challenge. Chisla Fibonacci can be counted approximately https://ru.wikipedia.org/wiki/%D0%A7%D0%B8%D1%81%D0%BB%D0%B0_%D0%A4%D0%B8%D0%B1%D0%BE%D0%BD%D0%B0%D1%87%D1%87%D0%B8 where If you use the degree calculation through the logarithm, the numbers will be considered very fast.Now we need to determine the t coefficient. It's clear that with a lot of numbers, there's gonna be a longer recurring challenge, it's gonna be a 32-bit and 1024-bit two big differences. It should therefore depend on n, and perhaps linear.To this end, we start a code with different n values and watch time. I was testing a virtual, so time might be small.n time f(n) per request 30 - 0.0057 (832040) - 6.85 нс 35 - 0.0611 (9227465) - 6.62 нс 37 - 0.1600 (24157817) - 6.62 нс 39 - 0.4149 (63245986) - 6.56 нс I had a rough time. But that's because we're working with 32-bit numbers and the sidewalk processor. If there is BigInt, the time must be proportional to the size of the number (most likely, the time will not be linear but steps).And now we'll move on to the program. The start-up programme should cover the number of 35-37 and count the time to one challenge (only split). Then for the n-star, count the number of Fibonacci quickly and multiply on the constant. If it takes about two to three years, there's no way anyone can prove it's wrong.I don't have to write the code because it's very primitive. We need to figure out the meaning of the expression.(((1+sqrt(5)) / 2) ^ (n+1)) / sqrt(5) * 6.5e-9 By the way, for 100, it's 3.7 for 10 degrees in 12 seconds... it's 118,000 years. A little over a year for 76... It's a long time to check the result directly.

It is safe to say that for O (1), the n-number of Fibonacci cannot be calculated because, as a minimum, the length of the reply is unlimited with n.The degree of chieling with a floating point occurs at a constant time, but yields an approximate result. So the Bina formula will not give you the Fibonacci number, but the rough approxiation.

Uh, the main advantage of replacing the subtraction by 2 for subtraction i.e. in time when the abnormal excretion was more advantageous than split into 2 (especially when there was no battle shift in whole and split into 2 as a separate operation in floating)You initially have four sets of differences between which further numbers can be produced at the reference interval. And now you're just looking for an extremum of a function, depending on which subway there is and continuing to generate differences.i.e. 4 numbers a,b,c,d (increase)where (s-a)/(d-a) = (b-a)/(c-a) - and close (as close to the relationship of the neighbouring Fibonacis to the gold grid)You can see that b-a-S-S-and the remaining middle (s-b) has the next red flag. and (c-b) as much as any of the parts (b-a) or (d-c) as the same, form the next couple, for generating in the cut (a,c) (if the search needs to be continued here), the next point is b'=c-(b-a) now d'=c and c'b is the fourth point again. a,b'(this is c-(b-a)),c'(this is b of the previous iteration)d'(this is from the previous utterance)

let string_fibo = ''; const finale = 13; for(let i = 0, j = 1; i <= finale; string_fibo += i + ' ', [i,j] = [j, i + j]); console.log(string_fibo);It is possible without prior proclamation of variables and without restrictions.for(var string = '', i = 0, j = 1; i != Infinity; string += i + ' ', [i,j] = [j, i + j]); console.log(string);If you want to, you can. console.log insert the phrase.for(let string = '', i = 0, j = 1; i != Infinity ? true : console.log(string.trimEnd()); string += i + ' ', [i,j] = [j, i + j]);All may be inscribed to Section 2 (Cycle Conditions/Cycle Cycle Cycle Cycle Removal):for(let s='',i=0,j=1;(s+=i+' ')&&([i,j]=[j,i+j])[0]!=Infinity?true:console.log(s.trimEnd()););P. S. I hope it's a vicious practice. The code is written for people and a good code is understood at first sight. The assignment is therefore inherently unacceptable.

We can do about this:const fib = ( lim, res = [0, 1], next = res.slice(-2).reduce((a, b) => a + b) ) => { return lim < next ? res : fib(lim, [...res, next]); }; console.log(fib(6), fib(6)); console.log(fib(10), fib(10)); console.log(fib(20), fib(20));

Only 46 Fibonacci numbers are included in the int, and they can only be manually recorded in the body, copyed from the plate, and issued on the index.int fib(int n) { if ((n > 45) || (n < 1)) { return -1} // ошибка int fib[] = {1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657, 46368, 75025, 121393, 196418, 317811, 514229, 832040, 1346269, 2178309, 3524578, 5702887, 9227465, 14930352, 24157817, 39088169, 63245986, 102334155, 165580141, 267914296, 433494437, 701408733, 1134903170, 1836311903}; return fib[n-1]; }

You need to find the numbers of Fibonacci, which are not more than 4000000, and summarise them.About:#include<iostream> using namespace std; int main() { int sum = 0; for(int x = 1, y = 1;;) { int z = x+y; if (z > 4000000) break; sum += z; x = z + y; y = z + x; } cout << sum << endl; }

#include <iostream> using namespace std; pair<unsigned long long, unsigned long long> fib(unsigned long long N, unsigned long long A, unsigned long long B, unsigned long long C) { unsigned long long a[2][2] = {{1,1},{1,0}}; unsigned long long r[2][2] = {{1,0},{0,1}}; while(N) { unsigned long long b[2][2]; if (N&1) { b[0][0] = a[0][0]*r[0][0] + a[0][1]*r[1][0]; b[0][1] = a[0][0]*r[0][1] + a[0][1]*r[1][1]; b[1][0] = a[1][0]*r[0][0] + a[1][1]*r[1][0]; b[1][1] = a[1][0]*r[0][1] + a[1][1]*r[1][1]; r[0][0] = b[0][0]%C; r[0][1] = b[0][1]%C; r[1][0] = b[1][0]%C; r[1][1] = b[1][1]%C; } N >>= 1; b[0][0] = a[0][0]*a[0][0] + a[0][1]*a[1][0]; b[0][1] = a[0][0]*a[0][1] + a[0][1]*a[1][1]; b[1][0] = a[1][0]*a[0][0] + a[1][1]*a[1][0]; b[1][1] = a[1][0]*a[0][1] + a[1][1]*a[1][1]; a[0][0] = b[0][0]%C; a[0][1] = b[0][1]%C; a[1][0] = b[1][0]%C; a[1][1] = b[1][1]%C; } return make_pair(r[0][0]*B + r[0][1]*A,r[1][0]*B+r[1][1]*A); } int main() { unsigned long long A, B, C, K; cin >> A >> B >> C >> K; if (K == 1) cout << A << "\n"; else if (K == 2) cout << B << "\n"; else if (A == 0 && B == 0) cout << B << "\n"; else { auto p = fib(K-2,A,B,C); A = p.first%C; if (A == 0) A = C; cout << A << endl; } }