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 main(){
	int n;
	double ans =0;
	int checkc = 0;
	int i = 4;
	double check[3] = { 1, 2, 4 };

	cin >> n;

	switch (n){
	case 1:
		ans = 1;
		break;
	case 2:
		ans = 2;
		break;
	case 3:
		ans = 4;
		break;
	default :
		while (n >= i){
			ans = check[0] + check[1] + check[2];
			i++;
			check[0] = check[1];
			check[1] = check[2];
			check[2] = ans;
		}
	}

	ans = ans / 3650;
	checkc = (int)(ans);

	if (ans > (double)(checkc)){
		checkc++;
	}
	if (ans != 0){
		cout << checkc << endl;
	}
	else{
		cout << endl;
	}

	return 0;
}

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

int f(int n){   //再帰関数
    if( n==1 )return 1;
    if( n==2 )return 2;
    if( n==3 )return 4;
    //f(n)=f(n-1)+f(n-2)+f(n-3)
    return f(n-1)+f(n-2)+f(n-3);
}
int main(void){
    int n;
    while(true){
    cin >> n;
    if(n==0)break;
    cout << (f(n)/3650)+1 << endl;
    }
}

C++: #include <iostream>
using namespace std;
int main()
{
    int N;
    long long A[31];
    while((cin >> N)&&(N > 0))
    {
        for(int i = 0; i <= N; i++)
        {
            if(i == 0)
            {
                A[i] = 1;
            }
            else if(i == 1)
            {
                A[i] = A[i-1];
            }
            else if(i == 2)
            {
                A[i] = A[i-1] + A[i-2];
            }
            else
            {
                A[i] = A[i-1] + A[i-2] + A[i-3];
            }
        }

        cout << (((A[N] + 9) / 10) + 364) / 365 << endl;

    }
    return 0;
}

C++: #include <iostream>
#include <vector>
#include <cstdlib>
using namespace std;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }

const int MAX_N = 30;

int main() {
    while (true) {
        // input
        int n; cin >> n;
        
        if (n == 0) break;

        // initialize DP table
        int dp[MAX_N + 1];
        for (int i = 0; i <= n; i++) dp[i] = 0;

        // initial condition
        dp[0] = 1;

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

        int year = (dp[n] + 3649) / 3650;
        cout << year << endl;
    }
    return 0;
}

C++: #include<cstdio>
#include<iostream>
#include<algorithm>
#include<string>
#include<queue>
#include<vector>
#include<functional>
#include<cmath>
#include<map>
#include<stack>
#include<set>
#include<numeric>
#include<limits>
#include<iterator>

#define all(x) (x).begin(),(x).end()
#define rall(x) (x).rbegin(),(x).rend()
#define rep(i,n) for(int i=0; i<n; i++)
#define INF (1<<20)

using namespace std;
typedef long long ll;
typedef pair<int, int> pi;
typedef pair<ll, ll> pl;
typedef pair<ll, char> plc;

int a[40], n;

int main()
{
	while (cin >> n, n) {
		a[0] = 1;
		for (int i = 1; i <= 32; i++) {
			a[i] = a[i - 1];
			if (i - 2 >= 0)a[i] += a[i - 2];
			if (i - 3 >= 0)a[i] += a[i - 3];
		}
		cout << ceil(a[n] / 10.0 / 365.0) << endl;
	}
	return	0;
}

C++: #include <cstdio>

using namespace std;

int n,dp[34];

int main(){
  while(1){
    scanf("%d",&n);
    if(n==0) break;
    for(int i=0;i<34;i++) dp[i]=0;
    dp[0]=1;

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

    //for(int i=0;i<n;i++) printf("%d_%d\n",i,dp[i]);

    int ans=(dp[n]/3650)+1;

    printf("%d\n",ans);

  }
  return 0;

}

C++: #include <iostream>
using namespace std;
int trib(int a){
    if(a==1){return 1;}
    if(a==2){return 2;}
    if(a==0){return 1;}
//  if(a==3){return }
    return trib(a-3)+trib(a-2)+trib(a-1);
}
int main() {
    // your code goes here
int a;
while(true){
    cin>>a;
    if(a==0){return 0;}
cout<<((trib(a)+1)/10+1)/365+1<<endl;
     
}
    return 0;
}

C++: #include <iostream>
using namespace std;
vector<int> memo;
int f(int n){
    if(n<0)
        return 0;
    if(n==0)
        return 1;
    if ( memo[n]!= -1 )
        return memo[n];
    return f(n-1)+f(n-2)+f(n-3);
}
 
int main(){
    int n;
    memo.resize(31,-1);
    while(1){
        cin >> n;
        if(n==0)
            break;
        int num=f(n);
        cout <<num/10/365+1<< endl;
    }
    return 0;  
}

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

using namespace std;


int StepsData[31] = { 0,1,2,4 };



int main(void) {
	int n, years;

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

	while (cin >> n, n) {
		years = StepsData[n] / 3650;

		if (StepsData[n] % 3650 != 0) {
			years++;
		}
	
		cout << years << endl;		
	}

	return 0;
}

C++: #include <iostream>
#include <cmath>
#include <cstring>

using namespace std;

int n;

int dp[35][35];

void solve() {
	memset(dp, 0, sizeof(dp));
	
	dp[0][0] = 1;
	for (int i=0; i<n; i++) {
		for (int j=0; j<=n; j++) {
			if (j>=1) dp[i+1][j] += dp[i][j-1];
			if (j>=2) dp[i+1][j] += dp[i][j-2];
			if (j>=3) dp[i+1][j] += dp[i][j-3];
		}
	}
	
	int sum = 0;
	for (int i=0; i<n; i++) {
		sum += dp[i+1][n];
	}
	sum /= 10;
	int ans = ceil((double)sum/365.0);
	if (sum > 0) cout << ans << endl;
	else cout << 1 << endl;
}

int main() {
	while (1) {
		cin >> n; if (n==0) break;
		solve();
	}
	
	return 0;
}

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

using namespace std;

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

C++: #include<iostream>
#include<cstdio>
#include<algorithm>
#include<climits>
#include<string>
#include<vector>
#include<list>
#include<map>
#include<set>
#include<cmath>
#include<queue>
#include<cstring>
#include<stack>
#include<functional>
using namespace std;

int main(){
	int N;
	while(cin>>N,N){
		int dp[31] = {}; dp[0] = 1;
		for(int i=0;i<N;i++){
			for(int j=1;j<=3;j++) if(i+j<=N) dp[i+j] += dp[i];
		}
		printf("%d\n",((dp[N]-1)/10)/365+1);
	}
	return 0;
}

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 + (dp[n]%3650 ? 1 : 0) << endl;
  }

  return 0;
}