Go: package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
)

func main() {
	sc1 := bufio.NewScanner(os.Stdin)
	sc1.Split(bufio.ScanWords)
	sc1.Scan()
	num, _ := strconv.Atoi(sc1.Text())
	cache := make([]*int, num+1)
	fmt.Println(fib(num, cache))

}

func fib(n int, cache []*int) int {
	if n <= 1 {
		return 1
	}

 	if cache[n] != nil {
		return *(cache[n])
	}

	result := fib(n -2, cache) + fib(n -1, cache)
	cache[n] = &result
	return result
}

C++: #include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cmath>
#include <cstdlib>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

#define IOS ios::sync_with_stdio(false); cin.tie(0);
#define FOR(i, s, n) for(int i = s, i##_len=(n); i < i##_len; ++i)
#define FORS(i, s, n) for(int i = s, i##_len=(n); i <= i##_len; ++i)
#define VFOR(i, s, n) for(int i = s; i < (n); ++i)
#define VFORS(i, s, n) for(int i = s; i <= (n); ++i)
#define REP(i, n) FOR(i, 0, n)
#define REPS(i, n) FORS(i, 0, n)
#define VREP(i, n) VFOR(i, 0, n)
#define VREPS(i, n) VFORS(i, 0, n)
#define RFOR(i, s, n) for(int i = s, i##_len=(n); i >= i##_len; --i)
#define RFORS(i, s, n) for(int i = s, i##_len=(n); i > i##_len; --i)
#define RREP(i, n) RFOR(i, n, 0)
#define RREPS(i, n) RFORS(i, n, 0)
#define ALL(v) (v).begin(), (v).end()
#define SORT(v) sort(ALL(v))
#define RSORT(v) sort(ALL(v), greater<decltype(v[0])>())
#define SZ(x) ((int)(x).size())
#define PB push_back
#define MP make_pair
#define MT make_tuple
#define BIT(n) (1LL<<(n))
#define UNIQUE(v) v.erase(unique(ALL(v)), v.end());

using ll = long long;
using PII = pair<int, int>;
using VI = vector<int>;
using VD = vector<double>;
using VLL = vector<ll>;
using VS = vector<string>;

const int MOD = 1000000007;
const int INF = 1000000000;

template<class T> bool chmax(T &a, const T &b){
    if(a < b){
        a = b; return true;
    }
    return false;
}
template<class T> bool chmin(T &a, const T &b){
    if(b < a){
        a = b; return true;
    }
    return false;
}



template <class T>
class Matrix{
private:
    vector<vector<T>> A;
public:
    Matrix(){}

    Matrix(size_t m, size_t n): A(m, vector<T>(n, 0)) {}

    Matrix(size_t n): A(n, vector<T>(n, 0)) {}

    Matrix(size_t m, size_t n, T a): A(m, vector<T>(n, a)) {}

    Matrix(const Matrix& mat){if(this != &mat) A = mat.A;}

    Matrix(vector<vector<T>> v){
        size_t m = v.size();
        assert(m != 0);
        size_t  n = v[0].size();
        REP(i, m) assert(v[i].size() == n);
        A = v;
    }

    ~Matrix() {}

    size_t height() const{return A.size();}

    size_t width() const{return A[0].size();}

    bool sameSize(const Matrix& mat) const{
        return height() == mat.height() && width() == mat.width();
    }

    inline const vector<T> &operator[](int idx) const{return A.at(idx);}

    inline vector<T> &operator[](int k){return (A.at(k));}

    void print2D(int w){
        size_t m = height(), n = width();
        REP(i, m){
            REP(j, n){
                if(j) cout << " ";
                cout << setw(w) << (*this)[i][j];
            }
            cout << "\n";
        }
    }

    friend ostream& operator<<(ostream &os, const Matrix &mat){
        size_t m = mat.height(), n = mat.width();
        REP(i, m){
            REP(j, n){
                if(j) os << " ";
                os << mat[i][j];
            }
            os << "\n";
        }
        return (os);
    }

    static Matrix identity(size_t n){
        Matrix ret(n);
        REP(i, n) ret[i][i] = 1;
        return ret;
    }

    Matrix operator+() const{return *this;}

    Matrix operator-() const{
        size_t m = height(), n = width();
        Matrix temp(height(), width());
        REP(i, m) REP(j, n) temp[i][j] = -(*this)[i][j];
        return temp;
    }

    Matrix& operator=(const Matrix mat){
        if(this != &mat){
            A = mat.A;
        }
        return *this;
    }

    Matrix& operator+=(const Matrix &B){
        size_t m = height(), n = width();
        assert(m == B.height() && n == B.width());
        REP(i, m) REP(j, n) (*this)[i][j] += B[i][j];
        return *this;
    }

    Matrix& operator-=(const Matrix &B){
        size_t m = height(), n = width();
        assert(m == B.height() && n == B.width());
        REP(i, m) REP(j, n) (*this)[i][j] -= B[i][j];
        return *this;
    }

    Matrix& operator*=(const Matrix &B){
        size_t m = height(), n = width(), l = B.width();
        assert(n == B.height());
        vector<vector<T>> C(m, vector<T>(l, 0));
        REP(i, m) REP(j, l) REP(k, n)
            C[i][j] = (C[i][j] + (*this)[i][k] * B[k][j]);
        A.swap(C);
        return *this;
    }

    Matrix& operator%=(const ll &mod){
        size_t m = height(), n = width();
        REP(i, m) REP(j, n) (*this)[i][j] %= mod;
        return *this;
    }

    Matrix operator+(const Matrix& mat) const{
        Matrix temp(*this);
        return temp += mat;
    }

    Matrix operator-(const Matrix& mat) const{
        Matrix temp(*this);
        return temp -= mat;
    }

    Matrix operator*(const Matrix& mat) const{
        Matrix temp(*this);
        return temp *= mat;
    }

    Matrix operator%(const ll mod) const{
        Matrix temp(*this);
        return temp %= mod;
    }

    bool operator==(const Matrix& mat) const{
        if(!sameSize(mat)) return false;
        size_t m = height(), n = width();
        REP(i, m) REP(j, n) if((*this)[i][j] != mat[i][j]) return false;
        return true;
    }

    bool operator!=(const Matrix& mat) const{return !(*this == mat);}
    
    Matrix powWithoutMod(ll b){
        size_t n = height();
        assert(n == width());
        Matrix ret = identity(n);
        Matrix a = *this;
        while(b){
            if(b & 1) ret = ret * a;
            a = a * a;
            b /= 2;
        }
        return ret;
    }

    Matrix pow(ll b, ll mod){
        size_t n = height();
        assert(n == width());
        Matrix ret = identity(n);
        Matrix a = *this;
        while(b){
            if(b & 1) ret = (ret * a) % mod;
            a = (a * a) % mod;
            b /= 2;
        }
        return ret;
    }

    Matrix pow(ll b) {
        return pow(b, MOD);
    }
};

ll fibonacci(int n){
    if(!n) return 1;
    vector<ll> a1{1, 1}, a2{1, 0};
    vector<vector<ll>> a{a1, a2};
    Matrix<ll> mat(a);
    mat = mat.powWithoutMod(n-1);
    return mat[0][0] + mat[0][1];
}

int main(){
    int n; cin >> n;
    cout << fibonacci(n) << "\n";
    return 0;
}

C++: #include <iostream>
using namespace std;

int Fib(int n) {

	long a[50] = { 1, 1 };

	if (n > 1) {
		for (int i = 2; i <= n; i++)
			a[i] = a[i - 1] + a[i - 2];
		return a[n];
	}
	else
		return 1;
}

int main()
{
	int n = 0;

	cin >> n;

	cout << Fib(n) << endl;

	return 0;
}

C++: #include <iostream>
using namespace std;

int fib(int n){
	int ans[45] = {1,1},i;
	for(i=1;i<n;i++){
		ans[i] = ans[i-1]+ans[i-2];
	}
	return ans[i];
}

int main() {
	int n;
	cin >> n;
	cout << fib(n) << endl;
	return 0;
}

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

int main(){
    cin.tie(nullptr);
    ios::sync_with_stdio(false);

    int n;
    cin >> n;

    int dp[n + 1] = {};
    dp[0] = 1;
    dp[1] = 1;
    for(int i = 2; i <= n; i++){
        dp[i] = dp[i - 2] + dp[i - 1];
    }

    cout << dp[n] << endl;

    return 0;
}

C++: #include<iostream>

using namespace std;

int fib(int n);

int memo[1000];

int main() {
  int n;

  //入力
  cin >> n;

  //出力
  cout << fib(n) << endl;

  return 0;
}

int fib(int n){

  if(n==0 || n == 1){
    return 1;
  }else if(memo[n] != 0){
    return memo[n];
  }else{
    return memo[n] = fib(n-1) + fib(n-2);
  }
}