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 <stdio.h>
#include <cmath>
#include <algorithm>
#include <stack>
 
using namespace std;

int main(){
    
    long long data[31];
    
    data[1]=1;
    data[2]=2;
    data[3]=4;
    
    for(int i=4; i < 31; i++){
        data[i] = data[i-1] + data[i-2] + data[i-3];
    }
    
    int n,y;
    
    while(true){
        scanf("%d",&n);
        if(n == 0)break;
 
        y = 0;
 
        y += data[n]/3650;
        
        if(data[n]%3650 > 0){
            y = y + 1;
        }
        
        printf("%d\n",y);
    }
 
    return 0;
}

C++: #include <bits/stdc++.h>
#define rep(i, n) for (ll i = 0; i < n; i++)
#define FOR(i, m, n) for(ll i = m;i < n;i++)
#define VSORT(v) sort(v.begin(), v.end());
#define VREV(v) reverse(v.begin(), v.end());
using namespace std;
using ll = long long;
using pll = pair<ll,ll>;
using vll = vector<ll>;
using vdouble = vector<double>;
using vstr = vector<string>;
typedef pair<int,int> P;
int dx[4] = {1, 0, -1, 0},dy[4] = {0, 1, 0, -1};
ll gcd(ll a, ll b) { return b?gcd(b,a%b):a;}
ll lcm(ll a, ll b) { return a/gcd(a,b)*b;}
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 ll INF = 1LL << 60;
const ll mod = 1000000007;

int main(){
    ll n;
    while(cin >> n, n){
    if(n<=0) return 0;
	ll dp[n+1];
	dp[0]=1;
	dp[1]=1;
	dp[2]=2;
	if(n>=3)rep(i,n-2) dp[i+3]=dp[i+2]+dp[i+1]+dp[i];
	
	ll N=dp[n];
	N+=10;
	N/=10;
	N+=364;
	N/=365;
	cout<<N<<endl;
    }
}

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

typedef long long ll;

int dp[31];
ll f(int n){
    int & ans = dp[n];
    if(ans!=0) return ans;
    else {
        if(n==1) ans = 1;
        else if(n==2) ans = 1 + f(n-1);
        else if(n==3) ans = 1 + f(n-1) + f(n-2);
        else ans = f(n-1) + f(n-2) + f(n-3);

        return ans;
    }
}

int main(){
    memset(dp,0,sizeof(dp));
    int n;
    while(cin>>n,n){
        cout << f(n)/10/365 + 1 << endl;
    }
}

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

int main() {
    vector<int> dp(31, 0);
    dp[0] = 1;
    for (int i = 1; i <= 30; i++) {
        dp[i] = dp[i - 1];
        if (i >= 2) dp[i] += dp[i - 2];
        if (i >= 3) dp[i] += dp[i - 3];
    }
    int N;
    while (cin >> N, N) {
        cout << ((dp[N] + 10 - 1) / 10 + 365 - 1) / 365 << endl;
    }
    return 0;
}

C++: #include<iostream>
#include<algorithm>
#include<string>

using namespace std;

int main(){
	int n;
	int ary[31] = { 1, 1, 2 };

	for (int i = 3; i <= 30; i++){
		ary[i] = ary[i - 1] + ary[i - 2] + ary[i - 3];
	}

	while (cin >> n, n != 0){
		int cnt = 0;
		if (ary[n] % 3650 == 0){
			cout << ary[n] / 3650 << endl;
		}
		else cout << ary[n] / 3650 + 1 << endl;
	}

	return 0;
}

C++: #include <iostream>

using namespace std;

typedef long long ll;
ll memo[31];

ll f(int n) {
  if (n == 1) return 1;
  if (n == 2) return 2;
  if (n == 3) return 4;
  if (memo[n]) {
    return memo[n];
  }
  return memo[n] = f(n-1) + f(n-2) + f(n-3);
}



int main() {
  while (true) {
    int n;
    cin >> n;

    if (n == 0) {
      break;
    }

    cout << f(n) / 10 /365  + 1<< endl;


  }

  return 0;
}

C++: #include <iostream>
#include <math.h>
#include <stdio.h>
#include <vector>

using namespace std;

vector<int> F;
int memo(int n)
{
    int size = F.size();

    if (n < size)
    {
        return F[n];
    }

    for (int i = size; i <= n; i++)
    {
        switch (i)
        {
        case 0:
            F.push_back(1);
            break;
        case 1:
            F.push_back(F[i - 1]);
            break;
        case 2:
            F.push_back(F[i - 1] + F[i - 2]);
            break;
        default:
            F.push_back(F[i - 1] + F[i - 2] + F[i - 3]);
            break;
        }
    }

    return F[n];
}

int main()
{
    int n;
    while (cin >> n && n)
    {
        double ans = memo(n) / (10.0 * 365.0);
        cout << (int)(ceil(ans)) << endl;
    }
    return 0;
}

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

int main()
{
  int dp[40];
  fill_n(dp, 40, 0);

  dp[0] = 1;

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

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

C++: #include<iostream>
using namespace std;
int n;
int dp[31];
int main(){
  dp[0]=1;
  dp[1]=1;
  dp[2]=2;
  for(int i=3;i<=30;i++){
    dp[i]=dp[i-1]+dp[i-2]+dp[i-3];
  }
  while(cin>>n&&n){
    cout<<dp[n]/3650+(dp[n]%3650!=0)<<endl;
  }
  return 0;
}

C++: #include<stdio.h>
int main(){
    int i=2,n,dp[31];
    dp[0]=dp[1]=1;
    dp[2]=2;
    while(++i<31)
        dp[i]=dp[i-1]+dp[i-2]+dp[i-3];
    while(scanf("%d",&n),n)
        printf("%d\n",dp[n]/(10*365)+1);
}

C++: #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int INF = 1e9;
const int MOD = 1e9 + 7;

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

  return 0;
}

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

long long kannondou(int n);

int main(void){
    int n;
    while(1){
        cin>>n;
        if(n==0) return 0;
        cout<<kannondou(n)/3650 +1<<endl;
    }
}

long long kannondou(int n){
    if(n==0) return 1;
    if(n==1) return 1;
    if(n==2) return 2;
    else return (kannondou(n-1)+kannondou(n-2)+kannondou(n-3));
}

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

int main(void){
  int n;
  int dp[31];
  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(cin>>n,n){
    cout<<1+dp[n-1]/3650<<endl;
  }
}

C++: #include<iostream>
#include<algorithm>
#include<string>
#include<cstring>
#include<cstdio>
#include<cstdlib>
#include<vector>
#include<queue>
#include<stack>
#include<complex>
#include<utility>
#include<cmath>
#define loop(i,a,b) for(int i=a;i<b;i++)
#define rep(i,a) loop(i,0,a)
#define pi acos(-1)
#define all(v) v.begin(),v.end()
using namespace std;

const double eps = 1e-8;
const double INF = 1e12;

typedef pair<long,long> P;
typedef double Real;
typedef complex<Real> Point;
typedef vector<Point> G;

double cross(const Point& a,const Point& b){//calculate ad-bc(vector product)
	return imag(conj(a)*b);
}

struct L:public vector<Point>{//line data
	L(const Point &a,const Point &b){
		push_back(a);
		push_back(b);
	}
};

int n;
int dp[31];

long long func(int i){//i??????????§???????n??????????????????????????°???????????¢??°
	long long res;
	if(dp[i]!=-1)return dp[i];
	if(i==n)return 1;
	else if(i==n-1)res=func(i+1);
	else if(i==n-2)res=func(i+1)+func(i+2);
	else res=func(i+1)+func(i+2)+func(i+3);
	return dp[i]=res;
}

int main(){
	while(cin>>n){
		if(!n)break;
		memset(dp,-1,sizeof(dp));
		unsigned long long sum=func(0);
		bool check=false;
		if(sum%10)check=true;
		sum/=10;
		if(check)sum++;
		long long ans=sum/365;
		if(sum%365)ans++;
		cout<<ans<<endl;
	}
	return 0;
}