Числа Фибоначчи: иногда выводятся отрицательные значения

#include <iostream>
 
using namespace std;
void main()
{
    int n;
    cout << "Введите номер числа :";
    do {cin>>n;} while ((n<0)&&(n>10000));
    long long fib[10000];
    fib[0]=0;
    fib[1]=1;
    for (int i=2;i<9999;i++)
    {
        fib[i] = fib[i-1]+fib[i-2];
    }
    cout<<"Число с номером "<<n<<"ето:";
    cout<<fib[n];
    system("pause");
}

#include <iostream>
#include <math.h>
using namespace std;
const int N = 220;
int ctrl = 0;
div_t t;
void add(int a[N], int b[N], int c[N]){
  memset(c, 0, sizeof(int)*N);
  int i = 0;
  for(i = N - 1; i >= 0; i--){
    if(t.quot){
      c[i]++;
      if(i < ctrl) ctrl = i;
    }
    t = div((c[i] + a[i] + b[i]),10);
    c[i] = t.rem;
  }
}
int main()
{
 int fib0[N];int fib1[N];int fib2[N];
 memset(fib0, 0, sizeof(int)*N);
 memset(fib1, 0, sizeof(int)*N);
 memset(fib2, 0, sizeof(int)*N);
 int n;
 cin>>n;
 fib0[N - 1] = 1;fib1[N - 1] = 1;
 ctrl = N - 1;
 if(n<2) fib2[N - 1] = 1;
 for (int i = 2;i <= n;i++)
 {
   add(fib0, fib1, fib2);
   memmove(fib0, fib1, sizeof(int)*N);
      memmove(fib1, fib2, sizeof(int)*N);
 }
 for(int i = ctrl; i < N; i++) cout<<fib2[i];
 return 0;
}

#include <iostream>
 
using namespace std;
 
int main()
{
    int a ,b, k;
    a=0;
    b=1;
    cin >> k;
    while (k<=0)
    {
        cout << "ERROR! Enter the number greater than zero: ";
        cin >> k;
    }
    while (k!=0)
    {
        a=a+b;
        b=a-b;
        k=k-1;
        cout << a << " ";
    }
    return 0;
}

#include <iostream>
using namespace std;
int main ()
{
 int a,c=1,i,ans;
 float b=0;
 cin >> a;
 for (i=1;i<a;i++)
 {
    ans=c+b;
    b=c;
    c=ans;
 }
 cout << b;
    return 0;
}

#include <vector>
#include <iostream>
#include <fstream>
#include <iterator>
#include <string>
#include <algorithm>
#include <exception>
#include <stdexcept>
#include <cstring>
#include <cstdio>
#include <cstdlib>
 
class BigInteger
{
public: 
    BigInteger()
    {
        _data.push_back(0);
    }
    
    BigInteger(long long x)
    {
        while(x)
        {
            _data.push_back(x % _base);
            x /= _base;
        }
        
        if(_data.empty()) _data.push_back(0);
    }
    
    BigInteger(unsigned long long x)
    {
        while(x)
        {
            _data.push_back(x % _base);
            x /= _base;
        }
        
        if(_data.empty()) _data.push_back(0);
    }
 
    BigInteger(int x) : BigInteger((long long)x) {}
    BigInteger(unsigned int x) : BigInteger((unsigned long long)x) {}
    BigInteger(short x) : BigInteger((long long)x) {}
    BigInteger(unsigned short x) : BigInteger((unsigned long long)x) {}
    BigInteger(char x) : BigInteger((long long)x) {}
    BigInteger(unsigned char x) : BigInteger((unsigned long long)x) {}
 
    BigInteger(std::string &s)
    {
        for(int i = (int)s.size(); i > 0; i -= 9)
            if(i < 9)
                _data.push_back(atoi(s.substr(0, i).data()));
            else
                _data.push_back(atoi(s.substr(i - 9, 9).data()));
        
        while(_data.size() > 1 && _data.back() == 0)
            _data.pop_back();
    }
    
    BigInteger(const char *s)  
    {
        std::string d = s;
        
        for(int i = (int)d.size(); i > 0; i -= 9)
            if(i < 9)
                _data.push_back(atoi(d.substr(0, i).data()));
            else
                _data.push_back(atoi(d.substr(i - 9, 9).data()));
        
        while(_data.size() > 1 && _data.back() == 0)
            _data.pop_back();
    }
    
    BigInteger(const BigInteger& b)
    {
        _data.resize(b._data.size());
        std::copy(b._data.begin(), b._data.end(), _data.begin());
    }
    
    void ToString(char *s) const
    {
        sprintf(s, "%d", _data.empty() ? 0 : _data.back());
        for(int i = (int)_data.size() - 2; i >= 0; i--)
            sprintf(s, "%s%09d", s, _data[i]);
    }
    
    std::string ToString() const
    {
        char *buff = (char*)malloc(20);
        
        sprintf(buff, "%d", _data.empty() ? 0 : _data.back());
        std::string res = buff;
        
        for(int i = (int)_data.size() - 2; i >= 0; i--)
        {
            sprintf(buff, "%09d", _data[i]);
            res += buff;
        }
            
        free(buff);
        
        return res;
    }
    
    friend const BigInteger operator+(BigInteger &i);
    friend const BigInteger& operator++(BigInteger &i);
    friend const BigInteger& operator--(BigInteger &i);
    friend const BigInteger operator++(BigInteger &i, int);
    friend const BigInteger operator--(BigInteger &i, int);
    
    friend const BigInteger operator+(const BigInteger &c, const BigInteger &b);
    friend const BigInteger operator-(const BigInteger &c, const BigInteger &b);
    friend const BigInteger operator*(const BigInteger &a, const BigInteger &b);
    friend const BigInteger operator/(const BigInteger &a, const BigInteger &b);
    friend const BigInteger operator%(const BigInteger &a, const BigInteger &b);
    
    friend BigInteger& operator+=(BigInteger &a, const BigInteger &b);
    friend BigInteger& operator-=(BigInteger &a, const BigInteger &b);
    friend BigInteger& operator*=(BigInteger &a, const BigInteger &b);
    friend BigInteger& operator/=(BigInteger &a, const BigInteger &b);
    friend BigInteger& operator%=(BigInteger &a, const BigInteger &b);
    
    friend bool operator==(const BigInteger &a, const BigInteger &b);
    friend bool operator<=(const BigInteger &a, const BigInteger &b);
    friend bool operator>=(const BigInteger &a, const BigInteger &b);
    friend bool operator<(const BigInteger &a, const BigInteger &b);
    friend bool operator>(const BigInteger &a, const BigInteger &b);
    friend bool operator!=(const BigInteger &a, const BigInteger &b);
    
    /*operator long long() const
    {
        long long res = 0, b = 1;
        for(size_t i = 0; i < _data.size(); i++)
        {
            res += b * _data[i];
            b *= BigInteger::_base;
        }
        return res;
    }
    
    operator unsigned long long()
    {
        unsigned long long res = 0, b = 1;
        for(size_t i = 0; i < _data.size(); i++)
        {
            res += b * _data[i];
            b *= BigInteger::_base;
        }
        return res;
    }*/
    
    friend std::istream& operator>>(std::istream &is, BigInteger &i)
    {
        std::string s;
        is >> s;
        i = BigInteger(s);
        return is;
    }
    
    friend std::ostream& operator<<(std::ostream &os, const BigInteger &i)
    {
        os << i.ToString();
        return os;
    }
    
private:
    static const int _base = 1000 * 1000 * 1000;
    std::vector<int> _data;
    
    int _cmp(const BigInteger &a, const BigInteger &b) const //a - b, 1 if a > b
    {
        if(a._data.size() > b._data.size()) return 1;
        if(a._data.size() < b._data.size()) return -1;
        
        for(int i = (int)a._data.size() - 1; i >= 0; i--)
        {
            if(a._data[i] > b._data[i]) return 1;
            if(a._data[i] < b._data[i]) return -1;
        }
        
        return 0;
    }
    
    BigInteger _div_short(const BigInteger &c, int b, int &mod) const
    {
        mod = 0;
        BigInteger a = c;
        for(int i = (int)a._data.size() - 1; i >= 0; i--) 
        {
            long long cur = a._data[i] + mod * 1ll * BigInteger::_base;
            a._data[i] = int(cur / b);
            mod = int(cur % b);
        }
        
        while (a._data.size() > 1 && a._data.back() == 0)
            a._data.pop_back();
        
        return a;
    }
    
    bool _is_zero() const
    {
        return _data.size() == 1 && _data[0] == 0;
    }
};
 
const BigInteger operator+(const BigInteger &i) 
{
    return BigInteger(i);
}
 
const BigInteger& operator++(BigInteger &i) 
{
    int j = 0;
    i._data[0]++;
    
    while(i._data[j] >= BigInteger::_base)
    {
        if(j == (int)i._data.size() - 1) i._data.push_back(1); else i._data[j + 1]++;
        i._data[j] -= BigInteger::_base;
        j++;
    }
    
    return i;
}
 
const BigInteger operator++(BigInteger &i, int) 
{
    BigInteger old = BigInteger(i);
    
    int j = 0;
    i._data[0]++;
    
    while(i._data[j] >= BigInteger::_base)
    {
        if(j == (int)i._data.size() - 1) i._data.push_back(1); else i._data[j + 1]++;
        i._data[j] -= BigInteger::_base;
        j++;
    }
    
    return old;
}
 
//TODO: Optimize
const BigInteger& operator--(BigInteger &i) 
{
    if(!i._is_zero()) i = i - 1;
    return i;
}
 
//TODO: Optimize
const BigInteger operator--(BigInteger &i, int) 
{
    BigInteger old = BigInteger(i);
    if(!i._is_zero()) i = i - 1;
    return old;
}
 
const BigInteger operator+(const BigInteger &c, const BigInteger &b)
{
    BigInteger a = c;
        
    int carry = 0;
    for(size_t i = 0; i < std::max(a._data.size(), b._data.size()) || carry; i++) 
    {
        if(i == a._data.size()) a._data.push_back(0);
        a._data[i] += carry + (i < b._data.size() ? b._data[i] : 0);
        carry = a._data[i] >= BigInteger::_base;
        if(carry) a._data[i] -= BigInteger::_base;
    }   
        
    return a;       
}
 
const BigInteger operator-(const BigInteger &c, const BigInteger &b)
{
    if(c < b) throw std::invalid_argument("a - b, a must b greater or equal zero");
    BigInteger a = c;
        
    int carry = 0;
    for(size_t i = 0; i < b._data.size() || carry; i++) 
    {
        a._data[i] -= carry + (i < b._data.size() ? b._data[i] : 0);
        carry = a._data[i] < 0;
        if(carry) a._data[i] += BigInteger::_base;
    }
        
    while(a._data.size() > 1 && a._data.back() == 0)
        a._data.pop_back();
            
    return a;       
}
 
const BigInteger operator*(const BigInteger &a, const BigInteger &b)
{
    BigInteger c;
    c._data.resize(a._data.size() + b._data.size());
        
    for(size_t i = 0; i < a._data.size(); i++)
        for(int j = 0, carry = 0; j < (int)b._data.size() || carry; j++) 
        {
            long long cur = c._data[i + j] + a._data[i] * 1ll * (j < (int)b._data.size() ? b._data[j] : 0) + carry;
            c._data[i + j] = int(cur % BigInteger::_base);
            carry = int(cur / BigInteger::_base);
        }
            
    while(c._data.size() > 1 && c._data.back() == 0)
        c._data.pop_back();
            
    return c;       
}
 
//TODO: Division by zero
const BigInteger operator/(const BigInteger &a, const BigInteger &b)
{
    if(b._is_zero()) throw std::invalid_argument("division by zero");
    BigInteger l = 0, r = a + 1, m;
    int t;
    while(r - l > 1)
    {
        //m = (r + l) / 2;
        m = a._div_short(r + l, 2, t);
        if(b * m <= a) l = m; else r = m;
    }
    return l;
}
 
//TODO: Division by zero
const BigInteger operator%(const BigInteger &a, const BigInteger &b)
{
    if(b._is_zero()) throw std::invalid_argument("division by zero");
    BigInteger l = 0, r = a + 1, m;
    int t;
    while(r - l > 1)
    {
        //m = (r + l) / 2;
        m = a._div_short(r + l, 2, t);
        if(b * m <= a) l = m; else r = m;
    }
    return a - b * l;
}
 
BigInteger& operator+=(BigInteger &a, const BigInteger &b)
{
    int carry = 0;
    for(size_t i = 0; i < std::max(a._data.size(), b._data.size()) || carry; i++) 
    {
        if(i == a._data.size()) a._data.push_back(0);
        a._data[i] += carry + (i < b._data.size() ? b._data[i] : 0);
        carry = a._data[i] >= BigInteger::_base;
        if(carry) a._data[i] -= BigInteger::_base;
    }   
    return a;
}
 
BigInteger& operator-=(BigInteger &a, const BigInteger &b)
{
    int carry = 0;
    for(size_t i = 0; i < b._data.size() || carry; i++) 
    {
        a._data[i] -= carry + (i < b._data.size() ? b._data[i] : 0);
        carry = a._data[i] < 0;
        if(carry) a._data[i] += BigInteger::_base;
    }
        
    while(a._data.size() > 1 && a._data.back() == 0)
        a._data.pop_back();
            
    return a;
}
 
BigInteger& operator*=(BigInteger &a, const BigInteger &b)
{
    a = a * b;
    return a;
}
 
BigInteger& operator/=(BigInteger &a, const BigInteger &b)
{
    a = a / b;
    return a;
}
 
BigInteger& operator%=(BigInteger &a, const BigInteger &b)
{
    a = a % b;
    return a;
}
 
bool operator==(const BigInteger& a, const BigInteger& b)
{
    return a._cmp(a, b) == 0;
}
 
bool operator<=(const BigInteger& a, const BigInteger& b)
{
    return a._cmp(a, b) <= 0;
}
 
bool operator>=(const BigInteger& a, const BigInteger& b)
{
    return a._cmp(a, b) >= 0;
}
 
bool operator<(const BigInteger& a, const BigInteger& b)
{
    return a._cmp(a, b) < 0;
}
 
bool operator>(const BigInteger& a, const BigInteger& b)
{
    return a._cmp(a, b) > 0;
}
 
bool operator!=(const BigInteger& a, const BigInteger& b)
{
    return a._cmp(a, b) != 0;
}
 
int main()
{
    int n;
    std::cin >> n;
    std::vector<BigInteger> f = { BigInteger(0), BigInteger(1) };
    for(int i = 2; i <= n; i++) f.push_back(f[i - 1] + f[i - 2]);
    std::cout << f[n].ToString() << std::endl;
    return 0;
}

#include<stdio.h>
main()
{
    int a=0,b=1,c,n;
    scanf("%d",&n);
    if(n==0)printf("0");
    else if(n==1)printf("1");
    else
    {
        for(int i=2;i<=n;i++)
        {
            c=a+b;
            a=b;
            b=c;
        }
        printf("%d",c);
    }
}

#include <iostream>
#include <cstring>
using namespace::std;
    string sum(string p1, string p2)
    {
        if(p1.length()!=p2.length())
        {
            p1="00"+p1; 
        }
        else
        {
            p1="0"+p1;
        }
        p2="0"+p2;
        char* arr1=new char[p1.length()];
        strcpy(arr1, p1.c_str());
        char* arr2=new char[p2.length()];
        strcpy(arr2, p2.c_str());
        char* arr3 =new char[p2.length()];
        strcpy(arr3, p2.c_str());
        
        int it=p2.length(), opit=it-1, tmp=0, op1=0, op2=0;
        while(it!=0)
        {
            op1=(int)arr1[opit]-48;
            op2=(int)arr2[opit]-48;
            
            tmp+=(op1+op2);
            
            arr3[opit]=(tmp%10)+48;
            tmp/=10;
            
            it--;
            opit--;
            
        }
        string h;
        if(arr3[0]=='0')
        {
            for(int i=0;i<(p2.length()-1);i++)
            {
                arr3[i]=arr3[i+1];
            }
            h = string(arr3, p2.length()-1);
        }
        else
        {
            return arr3;
        }
        return h;
    }
    
int main()
{
    string a,b,c;
    int n;
    do
    {
        cin>>n;
    }while(n<1);
    if(n==1)
    {
        cout <<0;
        return 0;
    }
    else{
        if(n==2)
        {
            cout<<1;
            return 0;   
        }   
    }
    a = "1";
    b = "1";
    for(int i=2; i<n; i++)
    {
        c = sum(a, b);
        a=b;
        b=c;
                
    }
    cout <<c;
    return 0;
}

#include <iostream>
#include <cstdlib>
#include <time.h>
using namespace::std;
int flag=1;
    int* sum(int* arr1, int* arr2)
    {
        int tmp=0;
        int i=0;
        
        for(; i<flag;i++)
        {
            tmp+=(arr1[11100-i]+arr2[11100-i]);
            
            arr1[11100-i]=tmp%10;
            tmp/=10;
        }
        if(tmp)
        {
            arr1[11100-i]=tmp;
            flag++;
        }
        
        return arr1;
    }
    
int main()
{
    clock_t t;
    t=clock();
    int* arr1;
    int* arr2;
    int* arr3;
    int n;
    /*do
    {
        cin>>n;
    }while(n<1);*/
    n=10000;
    if(n==1)
    {
        cout <<0;
        return 0;
    }
    else{
        if(n==2)
        {
            cout<<1;
            return 0;   
        }   
    }
    arr1=(int*)malloc(11101*sizeof(int));
    arr2=(int*)malloc(11101*sizeof(int));
    arr3=(int*)malloc(11101*sizeof(int));
    arr1[11100]=1;
    arr2[11100]=1;
    for(int i=2; i<n; i++)
    {
        arr3 = sum(arr1, arr2);   
        arr1=arr2;
        arr2=arr3; 
    }
    cout<<(float)(clock()-t)/CLOCKS_PER_SEC<<endl;
    for(int i=(11101-flag); i<11101; i++)
    {
        cout<<arr3[i];
    }
    return 0;
}