Go: package main

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

var scanner = bufio.NewScanner(os.Stdin)

func main() {
	dp := make([]int , 30)
	dp[0] = 1 // 1段の階段の登り方
	dp[1] = 2 // 2段の階段の登り方
	dp[2] = 4 // 3段の階段の登り方
	for i := 3; i < 30; i++ {
		// n段の階段の登り方は
		// n-1段の階段の登り方+n-2段の階段の登り方+n-3段の階段の登り方
		dp[i] = dp[i-1]+dp[i-2]+dp[i-3] 
	}
	for scanner.Scan() {
		n, _ := strconv.Atoi(scanner.Text())
		if n == 0 {
			break
		}
		fmt.Println(((dp[n-1]+9)/10+364)/365)
	}
}

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

int num(int n);

int main(){
  int n;
  cin>>n;
  cout << num(n)/3650 <<endl;
}

int num(int n){
  if(n<1)return 0;
  return num(n-1)+num(n-2)+num(n-3);
}

C++: void main()
{
	int n,i,ans[64];
	
	ans[0]=ans[1]=1;
	ans[2]=2;
	
	for(i=3;i<31;i++)
		ans[i]=ans[i-1]+ans[i-2]+ans[i-3];
	
	for(;;)
	{
		scanf("%d",&n);
		if(n==0)
			break;
		printf("%d\n",ans[n]/3650+1);
	}
}

C++: #include <bits/stdc++.h>

using namespace std;
typedef long long ll;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<ll> VL;
typedef vector<VL> VVL;
typedef pair<int, int> PII;

#define FOR(i, a, n) for (ll i = (ll)a; i < (ll)n; ++i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(x) x.begin(), x.end()
#define MOD 1000000007
#define INF (1LL<<30)
#define LLINF (1LL<<60)
#define PI 3.14159265359
#define EPS 1e-12
//#define int ll

ll dp[31];
signed main(void)
{
  dp[1] = 1; dp[2] = 2; dp[3] = 4;
  FOR(i, 4, 31) {
    dp[i] = dp[i-1] + dp[i-2] + dp[i-3];
  }

  int n;
  while(1) {
    cin >> n;
    if(!n) break;
    //cout << dp[n] << endl;
    cout << dp[n]/3650 + !!(dp[n]%3650) << endl;
  }

  return 0;
}

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

#define int long long

int n;
int dp[55];

int rec(int stage) {
  // 終了条件
  if (stage == 0) {
    return dp[stage] = 1;
  }
  
  // 一度求めた値の場合、メモしたやつを返す
  if (dp[stage] != -1) {
    return dp[stage];
  }

  int ans = 0;

  for (int i = 1; i <= 3; i++) {
    if (stage - i < 0) continue;
    ans += rec(stage - i);
  }

  // 値を求めたらメモる
  return dp[stage] = ans;
}

signed main() {
  // 前処理
  fill(dp, dp+33, -1);
  rec(30);

  while (1) {
    cin >> n;
    if (n == 0) break;
    int ans = (dp[n] + 3650 - 1) / 3650;
    cout << ans << endl;
  }

  return 0;
}

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

int main() {
    vector<ll> dp(40);
    dp[0] = dp[1] = 1;
    dp[2] = 2;
    for(int i = 3; i<=35; i++){
        dp[i] = dp[i-1]+dp[i-2]+dp[i-3];
    }
    int k;
    while(cin >> k, k){
        cout << (dp[k]-1)/3650+1 << endl;
    }
    return 0;
}

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

int main(){
        int n, m = 2, a[35] = {1, 1, 2};
        while(cin >> n && n){
                if(n > m){
                        for(int i = m+1; i <= n; i++){
                                    a[i] = a[i-3] + a[i-2] + a[i-1];
                        }
                        m = n;
                }
                cout << (a[n] + 3649) / 3650 << endl;
        }
        return 0;
}

C++: #include<cstdio>
#include<cstring>
#include<cstdlib>
#include<cmath>

int compare_int(const void* a, const void* b) { return *(int*) a - *(int*) b; }

int n, dp[30];

int func(int p) {
	if (p == n) {
		return 1;
	}
	int cnt = 0;
	for (int i = p + 1; n >= i && 3 + p >= i; i++) {
		if (dp[i] == -1) dp[i] = func(i);
		cnt += dp[i];
	}
	return cnt;
}

int main() {
	while (scanf("%d", &n) != EOF) {
		if (n == 0) return 0;
		memset(dp, -1, sizeof(dp));
		printf("%d\n", (func(0) / 10 + 364) / 365);
	}
}

C++: #include <iostream>
using namespace std;
int n;
int saiki(int ima)
{
	if(ima == n)
		return 1;
	if(ima > n)
		return 0;

	int res = 0;
	res += saiki(ima + 1) + saiki(ima + 2) + saiki(ima + 3);
	return res;
}

int main() {
	while (true){
		cin >> n;
		if (n == 0)
		{
			break;
		}
		
		int ans,a;
		ans = saiki(0);
		a = ans;
		ans /= 3650;
		a %= 3650;
		if( a == 0 )
		{
			cout << ans << endl;
		}
		else if( a != 0 )
		{
			ans++;
			cout << ans << endl;
			
		}
	}
}

C++: #include<iostream>
#include<vector>
#include<algorithm>
#include<queue>
#include<map>
#include<cmath>
#include<iomanip>
#include<set>
#include<numeric>
#include<random>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < n; ++i)
#define rrep(i, st, n) for (int i = st; i < n; ++i)
using pii = pair<int, int>;
//const int inf = 1e9 + 7;
//int dy[] = {0, 0, -1, 1};
//int dx[] = {1, -1, 0, 0};

int main() {
    int numstages;
    while (cin >> numstages && numstages) {
        int dp[numstages]; rep(i, numstages + 1) dp[i] = 0;
        dp[1] = 1;
        dp[2] = 2;
        dp[3] = 4;
        rrep(i, 4, numstages + 1) {
            dp[i] = dp[i - 1] + dp[i - 2] + dp[i - 3];
        }
        cout << dp[numstages] / 365 / 10 + 1 << endl;
    }
}

C++: #include<bits/stdc++.h>

using namespace std;

struct Matrix
{
  vector< vector< long long > > a;

  Matrix(int N)
  {
    a.resize(N, vector< long long >(N));
  }

  Matrix operator+(const Matrix &kj)
  {
    Matrix ret(a.size());
    for(int i = 0; i < a.size(); i++) {
      for(int j = 0; j < a.size(); j++) {
        ret.a[i][j] = a[i][j] + kj.a[i][j];
      }
    }
    return (ret);
  }

  Matrix operator*(const Matrix &kj)
  {
    Matrix ret = Matrix::Zero(a.size());
    for(int i = 0; i < a.size(); i++) {
      for(int j = 0; j < a.size(); j++) {
        for(int k = 0; k < a.size(); k++) {
          ret.a[i][j] = (ret.a[i][j] + 1LL * a[i][k] * kj.a[k][j]);
        }
      }
    }
    return (ret);
  }

  Matrix operator^(long long n)
  {
    Matrix ret = Matrix::I(a.size());
    Matrix x = *this;
    while(n > 0) {
      if(n & 1) (ret = ret * x);
      x = x * x;
      n >>= 1;
    }
    return (ret);
  }

  static Matrix Zero(int N)
  {
    Matrix ret(N);
    for(int i = 0; i < N; i++) {
      for(int j = 0; j < N; j++) ret.a[i][j] = 0;
    }
    return (ret);
  }

  static Matrix I(int N)
  {
    Matrix ret(N);
    for(int i = 0; i < N; i++) {
      for(int j = 0; j < N; j++) ret.a[i][j] = i == j;
    }
    return (ret);
  }
};

int main()
{
  int n;
  while(cin >> n, n) {
    Matrix tt(3);
    tt.a = {{1, 1, 1},
            {1, 0, 0},
            {0, 1, 0}};
    tt = tt ^ n;
    cout << (tt.a[2][0] * 2 + tt.a[2][1] + tt.a[2][2] + 3649) / 3650 << endl;
  }
}

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


const long long INF = 1LL << 60;
#define MOD 1000000007;

typedef long long ll;

#define writeln(n) cout<<n<<endl;

typedef pair<int, int> P;

ll dp[100];

int main() {


	int n;

	int dp[50] ={0};
	dp[0] =1;
	dp[1] =2;
	dp[2] =4;

	for(int i=3; i<31; i++){
		dp[i] = dp[i-1]+dp[i-2]+dp[i-3];

	}

	while(1){
		cin>>n;
		if(n ==0){
			break;
		}


		int ans = dp[n-1]/3650;

		if(dp[n-1]%3650 >0 )ans++;

		writeln(ans);


	}




}

C++: #include <cstdio>
#include <cstring>
#include <algorithm>
#include <string>
#include <cmath>
#include <stack>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <list>
#include <iostream>
#include <sstream>
#include <climits>
#include <cfloat>
#include <complex>

using namespace std;


int main()
{
	int t[31 + 3];
	t[0] = t[1] = 0;
	t[2] = 1;
	for (int i = 3; i < 31 + 3; ++i)
		t[i] = t[i-1] + t[i-2] + t[i-3];

	int n;
	while (scanf("%d", &n), n)
		printf("%d\n", (t[n+2]/10+365) / 365);

	return 0;
}

C++: #include <iostream>
#include <vector>
using namespace std;
typedef long long ll;

#define MAX_N 30

ll memo[MAX_N];
ll res(int n) {
  if(n < 0) return 0;
  if(n == 0) return memo[n] = 1;
  if(n > 0) {
    if(memo[n] != 0) {
      return memo[n];
    }
    else {
      return memo[n] = res(n-3) + res(n-2) + res(n-1);
    }
  }
  return -1;
}

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

  int n;
  while(cin >> n) {
    if( n == 0 ) break;
    ll combo = res(n);
    ll year = (combo / 10) / 365 + 1;
    cout << year << endl;
  }
}