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>
#include <string>
#include <vector>
#include <algorithm>
#include <climits>

using namespace std;

int main() {
	int n;

	while( true ) {
		cin >> n;

		if(n == 0) {
			break;
		}

		vector< int > dp(n + 1, 0);

		dp[0] = 1;

		for(int i = 1; i <= n; i++) {
			for(int j = -1; j >= -3; j--) {
				if(i + j < 0) {
					continue;
				}
				dp[i] += dp[i + j];
			}
		}

		int count = dp[n] / 10;
		if(dp[n] % 10 != 0) {
			count++;
		}

		int year = count / 365;
		if(count % 365 != 0) {
			year++;
		}

		cout << year << endl;
	}
}

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

int memo[31];

int main(){
	int n,ans;
	
	memo[0]=1;
	memo[1]=1;
	memo[2]=2;
	
	for(int i=3;i<31;i++){
		memo[i]=memo[i-1]+memo[i-2]+memo[i-3];
	}
	
	while(cin>>n){
		if(n==0)break;
		if(memo[n]%365!=0)ans=memo[n]/(365*10)+1;
		cout<<ans<<endl;
	}
	
	return 0;
}

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

using ll = long long;

int main() {
    ll n;
    while(cin >> n, n) {
        vector<ll> dp(n+1, 0);
        dp[0] = 1;
        for(int i=0; i<n; ++i) {
            dp[i+1] += dp[i];
            if(i+2 < n+1) {
                dp[i+2] += dp[i];
            }
            if(i+3 < n+1) {
                dp[i+3] += dp[i];
            }
        }
        ll day = (dp[n] + 9) / 10;
        ll year = (day + 364) / 365;
        cout << year << endl;
    }
}

C++: #include <bits/stdc++.h>
using namespace std;
int const MOD = 1000000007;

int main(){
    cin.tie(0); ios::sync_with_stdio(false);
   
    int n;
    while(cin>>n){
        if(n==0)break;
        int dp[n+1]={}; dp[0]=1;
        for (int i = 0; i < n; i++){
            for (int j = 1; (j <= 3)&&(i+j <= n); j++){
                dp[i+j]+=dp[i];
            }
        }
    cout<<dp[n]/3650+1<<'\n';
    }
}

C++: #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for(int i = 0; i < (int)(n); i++)

int solve(int n) {
    vector<int> dp = {1, 1, 2};
    for(int i = 3; i <= n; i++) {
        dp.push_back(dp[i - 3] + dp[i - 2] + dp[i - 1]);
    }
    int day = (dp[n] + 9) / 10;
    return (day + 364) / 365;
}

int main() {
    vector<int> n;
    int tmp = 100000;
    while(true) {
        cin >> tmp;
        if(tmp == 0) break;
        n.push_back(tmp);
    }
    REP(i, n.size()) cout << solve(n[i]) << endl;
}

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

typedef long long int ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<pair<int, int> > vii;
#define rrep(i, m, n) for(int (i)=(m); (i)<(n);  (i)++)
#define erep(i, m, n) for(int (i)=(m); (i)<=(n); (i)++)
#define  rep(i, n)    for(int (i)=0; (i)<(n);  (i)++)
#define  rev(i, n)    for(int (i)=(n)-1; (i)>=0; (i)--)
#define vrep(i, c)    for(__typeof((c).begin())i=(c).begin(); i!=(c).end(); i++)
#define  ALL(v)       (v).begin(), (v).end()
#define mp            make_pair
#define pb            push_back
template<class T1, class T2> inline void minup(T1& m, T2 x){ if(m>x) m=static_cast<T2>(x); }
template<class T1, class T2> inline void maxup(T1& m, T2 x){ if(m<x) m=static_cast<T2>(x); }

#define INF 1000000000
#define MOD 1000000007
#define EPS 1E-12

const int MAX_N = 30;
int n;
int dp[MAX_N+1];

int main()
{
  dp[1]=1;  dp[2]=2;  dp[3]=4;
  rrep(i, 4, MAX_N) dp[i] = dp[i-3] + dp[i-2] + dp[i-1];

  while((cin >> n) && n){
    cout << dp[n] / 3650 + 1 << endl;
  }

  return 0;
}

C++: 

#include <algorithm>
#include <iostream>
using namespace std;

int A[128], n, a; 
int main() {
	while(cin >> n && n >0){
		A[0] = 0;
		A[1] = 1;
		A[2] = 2;
		for (int i=3; i<=n+10; ++i) {
			A[i] = A[i-1]+A[i-2]+A[i-3];
		}
		a = int(((A[n]+9)/10+364)/365);
	cout << a <<endl;
	}
}

C++: #include<iostream>
#include<algorithm>
using namespace std;
int A[128],N;

int main(){
  A[0]=1;
  A[1]=1;
  A[2]=2;
  for(int i=3;i<=30;i++){
    A[i]=A[i-1]+A[i-2]+A[i-3];
  }
  while(cin >> N && N){
    cout << (A[N]+3649)/3650 << endl;
  }

}

C++: #include <iostream>

#define MAX_N 30
#define INF -1

int memo[MAX_N], ans, n;

void solve();

int dp(int a);

int answer(int in);

int main(){
    while(true){
        std::cin >> n;
        
        if(n == 0)
            break;
        
        for(int i = 0; i < MAX_N; ++i)
            memo[i] = INF;
        
        solve();
        
        std::cout << answer(ans) << std::endl;
    }
    return 0;
}

void solve(){
    ans = dp(n + 1);
    return;
}

int dp(int a){
    if(a < 1) return 0;
    if(a == 1) return 1;
    
    if(memo[a] == INF){
        memo[a] = dp(a - 1) + dp(a - 2) + dp(a - 3);
        return memo[a];
    }
    
    return memo[a];	
}

int answer(int in){
    int count = 1;
    in /= 10;
    while(true){
        if(count <= 365) break;
        count -= 365;
        ++count;
    }
}

C++: #include<iostream>
#include<string>
#include<vector>
#include<cstdio>
#include<sstream>
#include<algorithm>
#include<cmath>
#include<map>
using namespace std;
int main(){
int n, dp[50];
while(cin>>n,n!=0){
fill(dp,dp+50,0);
dp[0]=0,dp[1]=1,dp[2]=1,dp[3]=2;
for(int i=3;i<=n+1;i++)dp[i]=dp[i-1]+dp[i-2]+dp[i-3];
int ans=dp[n+1];
ans/=3650;
if(dp[n]%3650!=0)ans++;
cout<<ans<<endl;
}
return 0;
}

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]+9)/10+364) / 365);

	return 0;
}

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


int memo[32];
int N;


int rec(int n)
{
  if(memo[n] != -1) return memo[n];

  if(n == N) return 1;
  if(n >= N) return 0;

  int ret = 0;
  for(int i = 1; i <= 3; i++) {
    ret += rec(n+i);
  }

  return memo[n] = ret;
}

int main()
{
  for(; cin >> N && N; ) {
    memset(memo, -1, sizeof memo);
    cout << ceil(rec(0) / 3650.0) << endl;
  }
}

C++: #include <iostream>
using namespace std;
solve(int now){
    if(now==0) return 1;
    if(now<0)  return 0;
    long long res=solve(now-1)+solve(now-2)+solve(now-3);
    retrun res;
}
int main(void){
    int n;
    cin>>n;
    solve(n);
    cout<<solve(n)/3650+1<<endl;
    // Your code here!
    
}

C++: // ConsoleApplication7.cpp : ??????????????? ??¢????????±????????§????????¨????????? ?????????????????????????????????
//

#include "stdafx.h"
#include <iostream>
#include <cstring>
using namespace std;

int n, dp[32];

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

	while (cin >> n, n) {
		memset(dp, 0, sizeof(dp));

		dp[1] = dp[2] = dp[3] = 1;

		for (int i = 1; i < n + 1; ++i) {
			if (i + 3 < n + 1) {
				dp[i + 3] += dp[i];
			}
			if (i + 2 < n + 1) {
				dp[i + 2] += dp[i];
			}
			if (i + 1 < n + 1) {
				dp[i + 1] += dp[i];
			}
		}
		cout << dp[n] / 10 / 365 + 1<< endl;
	}

	return 0;
}