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 <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
constexpr int di[] = { 0, 1, 0, -1 }, dj[] = { 1, 0, -1, 0 };
#define rep(i, n) for (int i = 0; i < n; i++)
#define repr(i, n) for (int i = n; i >= 0; i--)
#define SORT(v) sort((v).begin(), (v).end())
#define SORTR(v) sort((v).rbegin(), (v).rend())
#define all(v) (v).begin(), (v).end()
#define vmax 10000
constexpr ll inf = 100000000000000;
/*cout<<fixed<<setprecision(20);cin.tie(0);ios::sync_with_stdio(false);*/

static const int N=30;
static const int W=10010;
int dp[N+1];

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

C++: #include<iostream>
#include<cstdio>
#include<cstring>
#include<vector>
#include<algorithm>
#include<utility>
#include<cmath>
using namespace std;
#define all(a) a.begin(),a.end()


int main()
{
	long long a[40]={0,1,1,1};
	for(int i=0;i<=30;i++)
	{
		for(int j=1;j<=3;j++)
		{
			a[i+j]+=a[i];
		}
	}
	
	int n;
	while(cin>>n&&n)
	{
		int ans=a[n];
		ans=ans/10+(ans%10?1:0);
		ans=ans/365+(ans%365?1:0);
		cout<<ans<<endl;
	}
	
}

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

using namespace std;

int main()
{
	int n;
	vector<int> num;
	do
	{
		cin >> n;
		num.push_back(n);
	}while (n != 0);
	num.pop_back();

	int dp[30];
	dp[0] = 1;
	dp[1] = 2;
	dp[2] = 4;

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

	for (auto it = num.begin(); it != num.end(); it++)
	{
		cout << dp[*it - 1]/3650 + 1 << endl;
	}

	return 0;
}

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

#define ll long long
#define vvi vector<vector<int>>
#define vec vector
#define pq priority_queue
#define all(v) (v).begin(), (v).end()
#define uniqueV(x) sort(x.begin(), x.end()); x.erase(unique(x.begin(), x.end()), x.end());
#define rep(i, n) for (int (i) = (0); (i) < (n); ++(i))
#define repp(i, m, n) for (int (i) = (m); (i) < (n); ++(i))
#define debug(x) cerr << #x << ": " << x << endl;
#define debug2(x, y) cerr<<"("<<#x<<", "<<#y<<") = "<<"("<<x<<", "<<y<<")"<<endl;
#define debug3(x, y, z) cerr<<"("<<#x<<", "<<#y<<", "<<#z<<") = "<<"("<<x<<", "<<y<<", "<<z<<")"<<endl;
#define debugB(value, size) cerr<<#value<<": "<<bitset<size>(value) << endl;
#define line() cerr << "---------------" << endl;

const int dx[] = {1, -1, 0, 0};
const int dy[] = {0, 0, -1, 1};
const double PI = 3.14159265358979323846;

template<typename T>
void printA(vector<T> &printArray, char between = ' ') {
   int paSize = printArray.size();
   for (int i = 0; i < paSize; i++) { cerr << printArray[i] << between;}
   if (between != '\n') {cerr << endl;}
}

// ------------------------------------------------------------------------------------------

ll dp[50];

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

int main() {
   init();
   while (1) {
      int n;
      cin >> n;
      if (!n) break;
      cout << dp[n] / 10 / 365 + (dp[n]%365 != 0) << endl;
   }

   return 0;
}

C++: #include <cstdio>
int dp[31]={1,1,2};
int main() {
	for(int i=3;i<=30;i++) {
		dp[i]=dp[i-1]+dp[i-2]+dp[i-3];
	}
	int n;
	while(scanf("%d",&n),n) {
		int days=(dp[n]/10)+((dp[n]%10)?1:0);
		int years=(days/365)+((days%365)?1:0);
		printf("%d\n",years);
	}
}

C++: #include <iostream>
#include <cstdio>
#include <algorithm>
#include <cassert>
#include <vector>
#include <string>
#include <cmath>
#include <map> 
#include <sstream>
#include <cstdio>
#include <complex>
#include <cstring>
using namespace std;
 
const int MAX= 10000100;

#define loop(i,a,b) for(int i = a ; i < b ; i ++)
#define rep(i,a) loop(i,0,a)
#define all(a) (a).begin(),(a).end()
#define ll long long int
#define gcd(a,b) __gcd(a,b)
#define pb(a) push_back(a)
int GCD(int a, int b) {if(!b) return a; return gcd(b, a%b);}
int lcm(int a, int b) {return a*b / gcd(a, b);}

int main(void){
  int n;
  int m[31] = {1,1,2};
  loop(i,3,31)
    m[i] = m[i-1] + m[i-2] + m[i-3];
  while(cin>>n,n)
    cout<<m[n]/3650 + 1 <<endl;
}

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

int dp[30];

int main(){

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

    while(1){
        int n;
        scanf("%d",&n);
        if(n == 0)break;
        printf("%.0f\n",ceil(dp[n-1]/(365.0*10.0)));
    }

    return 0;
}

C++: #include <algorithm>
#include <vector>
#include <iostream>
using namespace std;
int main(int argc, const char * argv[]) {
    vector<int> dp(31,0);
    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];
    }
    for(;;){
        int n;
        cin >> n;
        if(n==0) break;
        int ans = dp[n]/(365*10);
        if(dp[n]%365>0) ans++;
        cout << ans << endl;
    }
    return 0;
}

C++: #include <bits/stdc++.h>
using namespace std;
#define int lint
typedef long long lint;
typedef pair<int,int> P;
const int    INF=(int)1e9;
const int    MOD=(int)1e9+7;
const double EPS=(double)1e-10;
struct Accelerate_Cin{
    Accelerate_Cin(){
        cin.tie(0); ios::sync_with_stdio(0);cout<<fixed<<setprecision(20);
    };
};



signed main(){
  int n;
  queue<int>q;
  while(cin>>n,n){
    int dp[100];
    dp[1]=1,dp[2]=2,dp[3]=4;
    for(int t=1;t<30;t++){
      dp[t+3]=dp[t+2]+dp[t+1]+dp[t];
    }
    q.push(ceil((double)dp[n]/3650));
  }

  while(!q.empty()){
    cout<<q.front()<<endl;
    q.pop();
  }
  return 0;
}

C++: #define _CRT_SECURE_NO_WARNINGS

#include<cstdio>
#include<algorithm>

#define N_MAX 30

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

		for (int i = 1; i <= n; ++i){
			for (int j = 1; j <= 3; ++j){
				if (j >= i){
					dp[i] += dp[i - j];
				}
			}
		}
		int day = (dp[n] % 10 == 0) ? dp[n] / 10 : dp[n] / 10 + 1;
		int ans = (day % 365 == 0) ? day / 365 : day / 365 + 1;
		printf("%d",ans);
	}
	return 0;
}

C++: #include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <functional>
#include <numeric>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <utility>
#include <sstream>
#include <complex>

using namespace std;

#define FOR(i,a,b) for(long long i=(a);i<(b);i++)
#define REP(i,N) for(long long i=0;i<(N);i++)
#define ALL(s) (s).begin(),(s).end()
#define fi first
#define se second

#define PI acos(-1.0)
#define INF 1000000007
#define EPS 1e-10

typedef long long ll;
typedef pair<ll, ll> P;
typedef pair<double, double> PD;
typedef pair<string, ll> PS;
typedef vector<ll> V;
typedef pair<P, char> PC;

int n;
int dp[100];

int main(){
	dp[1] = 1;
	dp[2] = 2;
	dp[3] = 4;
	for (int i = 4; i <= 30; i++){
		dp[i] = dp[i - 1] + dp[i - 2] + dp[i - 3];
	}
	while (cin >> n&&n){
		cout << dp[n] / 3650 + 1 << endl;
	}
}

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

int func(int n, int m){
	if(m==n)return 1;
	else{
		int cnt=0;
		for(int i=1;i<=3 && m+i<=n;++i){
			cnt += func(n,m+i);
		}
		return cnt;
	}
}

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