Go: package main

import "fmt"

var count int

func main() {
	var inputNum, inputCount int
	var resultArr [50]int
	for {
		fmt.Scanf("%d", &inputNum)
		if inputCount == 50 {
			break
		}
		resultArr[inputCount] = calcA(inputNum)
		inputCount++
		count = 0
	}
	for _, v := range resultArr {
		fmt.Printf("%d\n", v)
	}
}

func calcA(input int) int {
	for i := 0; i <= 9; i++ {
		calcB(input, i)
	}
	return count
}

func calcB(input, a int) {
	for i := 0; i <= 9; i++ {
		calcC(input, a, i)
	}
}

func calcC(input, a, b int) {
	for i := 0; i <= 9; i++ {
		calcD(input, a, b, i)
	}
}

func calcD(input, a, b, c int) {
	for i := 0; i <= 9; i++ {
		if a+b+c+i == input {
			count++
		}
	}
}

C++: //#define _GRIBCXX_DEBUG
#include <algorithm>
#include <cctype>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iostream>
#include <iomanip>
#include <list>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;


// ?????¬???????????¬??????
#pragma region MACRO
#define P(x) cout << (x) << endl
#define p(x) cout << (x)
#define PED cout << "\n"
#define rep(i,n) for(int i=0; i<(int)n; ++i)
#define REP(i,x,n) for(int i=x; i<(int)n; ++i)
#define repi(i,n) for(int i=0; i<=(int)n; ++i)
#define REPI(i,x,n) for(int i=x; i<=(int)n; ++i)
#define ILP while(true)
#define FOR(i,c) for(__typeof((c).begin())!=(c).begin(); i!=(c).end(); ++i)
#define ALL(c) (c).begin(), (c).end()
#define mp make_pair
#pragma endregion

#pragma region TYPE_DEF
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<string, string> pss;
typedef pair<string, int> psi;
typedef pair<int, string> pis;
typedef vector<int> vi;
typedef vector<double> vd;
typedef vector<long> vl;
typedef vector<long long> vll;
typedef vector<string> vs;
#pragma endregion


// Effective std
#pragma region ESTD
template<typename C, typename T>
constexpr int count(C& c, T t) { return count(ALL(c), t); }
template<typename C, typename F>
constexpr int count_if(C& c, F f) { return count_if(ALL(c), f); }
template<typename C, typename T, typename U>
constexpr void replace(C& c, T t, U u) { replace(ALL(c), t, u); }
template<typename C, typename F, typename U>
constexpr void replace_if(C& c, F f, U u) { (ALL(c), f, u); }
template<typename C>
constexpr void sort(C& c) { sort(ALL(c)); }
template<typename C, typename Pred>
constexpr void sort(C& c, Pred p) { sort(ALL(c), p); }
template<typename C>
constexpr void reverse(C& c) { reverse(ALL(c)); }
#pragma endregion


// ?´???°
#pragma region PRIME
bool is_prime(unsigned n) {
  switch(n) {
    case 0:
    case 1: return false;
    case 2: return true;
  }
  if (n%2==0) return false;
  for (unsigned i=3; i*i<=n; i+=2)
    if (n%i==0) return false;
  return true;
}
#pragma endregion


// ??§??????/?°?????????????
#pragma region TRANSFORM
void mutal_tr(string &s) {
  for(int i=s.size(); i--;) {
    if(islower(s[i])) s[i] = toupper(s[i]);
    else if (isupper(s[i])) s[i] = tolower(s[i]);
  }
}
void to_upper(string &s) { for(int i=s.size(); i--;) s[i] = toupper(s[i]); }
void to_lower(string &s) { for(int i=s.size(); i--;) s[i] = tolower(s[i]); }
#pragma endregion


// ??????
#pragma region SET
template<class T>
set<T> intersection(const set<T>& sa, const set<T>& sb) {
  set<T> ret;
  for(T a : sa) if(sb.find(a) != sb.end()) ret.insert(a);
  return ret;
}
#pragma endregion

// Union Find
#pragma region UF
struct UnionFind {
  vector<int> data;
  UnionFind(int size) : data(size, -1) {}
  bool union_set(int x, int y) {
    x = root(x); y = root(y);
    if(x!=y) {
      if(data[y] < data[x]) swap(x, y);
      data[x] += data[y]; data[y] = x;
    }
    return x != y;
  }
  bool find_set(int x, int y) { return root(x) == root(y); }
  int root(int x) { return data[x] < 0 ? x : data[x] = root(data[x]); }
  int size(int x) { return -data[root(x)]; }
};
#pragma endregion


// ?????°
#pragma region CONST_VAL
#define PI (2*acos(0.0))
#define EPS (1e-9)
#define MOD (int)(1e9+7)
#pragma endregion

int main()
{
    int n;
    while(cin>>n) {
        int ans = 0;
        rep(i,10) rep(j,10) rep(k,10) rep(l,10) if(i+j+k+l==n) ++ans;
        P(ans);
    }
    return 0;
}

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

int num ;
int count = 0 ;

int main()
{
	while( cin >> num )
	{
		if( num <= 36 )
		{
			for( int a = 0 ; a <= 9 ; a ++ )
			{
				for( int b = 0 ; b <= 9 ; b ++ )
				{
					for( int c = 0 ; c <= 9 ; c ++ )
					{
						for( int d = 0 ; d <= 9 ; d ++ )
						{
							if( (a+b+c+d) == num )
							{
								count ++ ;
							}
						}
					}
				}
			}
		}
		cout << count << endl ;

		count = 0 ;
	}

	return 0 ;
}

C++: #include<iostream>

#define     MIN_NUMBER       (0)
#define     MAX_NUMBER       (9)
#define     MIN_N_NUMBER     (1)
#define     MAX_N_NUMBER     (50)

using namespace std;

int main(){
	int n,cnt = 0;
	int a,b,c,d;

	while(cin >> n){
		// 入力値のチェック
		if((n < ((int)(MIN_N_NUMBER))) || (n > ((int)(MAX_N_NUMBER)))){
			cerr << "Error!!" << endl;
			return -1;
		}

		// 4重ループ
		for(a=((int)MIN_NUMBER);a<=((int)MAX_NUMBER);a++){
			for(b=((int)MIN_NUMBER);b<=((int)MAX_NUMBER);b++){
				for(c=((int)MIN_NUMBER);c<=((int)MAX_NUMBER);c++){
					for(d=((int)MIN_NUMBER);d<=((int)MAX_NUMBER);d++){
						if((a + b + c + d) == n){
							cnt++;
						}
					}
				}
			}
		}

		// 出力
		cout << cnt << endl;

		// cntのクリア
		cnt = 0;
	}

	return 0;
}

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

int main() {
    int n;
    int a[2010];
    memset(a, 0, sizeof(a));
    rep(i,0,1001) rep(j,0,1001) a[i+j]++;
    while(cin >> n) {
        int ans = 0;
        rep(i,0,2001) {
            if(0 <= n-i && n-i <= 2000) ans = ans + a[i] * a[n - i];
        }
        cout << ans << endl;
    }
    return 0;
}

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

main(){
	int n;
	while(cin>>n){
		int ans = 0;
		for(int i=0; i<=9; ++i){
			for(int j=0; j<=9; ++j){
				for(int k=0; k<=9; ++k){
					for(int l=0; l<=9; ++l){
						if(i+j+k+l == n){
							ans++;
						}
					}
				}
			}
		}
		cout << ans << endl;
	}
}

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

using namespace std;

int main(){
  int i;
  int count = 0;
  vector<int> ans;
  int a, b, c, d;
  
  while(cin >> i){
    count = 0;
    if(cin.eof()){
      break;
    }
    for(a = 0; a < 10; a++){
      for(b = 0; b < 10; b++){
	for(c = 0; c < 10; c++){
	  for(d = 0; d < 10; d++){
	    if(a + b + c + d == i){
	      count++;
	    }
	  }
	}
      }
    }
    ans.push_back(count);
  }
  for(int& d : ans){
    cout << d << endl;
  }
}

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

int main() {
  int n;
  while(cin >> n) {
    int cnt = 0;
    for(int a = 0; a < 10; a++) {
      for(int b = 0; b < 10; b++) {
        for(int c = 0; c < 10; c++) {
          for(int d = 0; d < 10; d++) {
            if(a+b+c+d == n) cnt++;
          }
        }
      }
    }

    cout << cnt << endl;
  }
}

C++: #include <stdio.h>

int main(void)
{
  int n,i,a,b,c,d;
  int ans = 0;

  i = 0;
  while(i < 50){
    scanf("%d", &n);
    if(!(n > 0 && n <= 50)){
      break;
    }
    if(n <= 36){
      for(a = 0;a <= 9;a++){
	for(b = 0;b <= 9;b++){
	  for(c = 0;c <= 9;c++){
	    for(d = 0;d <= 9;d++){
	      if((a+b+c+d) == n){
		ans++;
	      }
	    }
	  }
	}
      }
    }
    printf("%d\n", ans);
    i++;
  }
  return 0;
}

C++: #include <iostream>
using namespace std;
int ary[60],res[40];
int main(){
	int N;
	for(int i=1;i<=51;i++){
		cin>>ary[i];
		if(cin.eof()){
			N=i-1;
			break;
		}
	}
	for(int i=0;i<10;i++){
		for(int j=0;j<10;j++){
			for(int k=0;k<10;k++){
				for(int l=0;l<10;l++){
					res[i+j+k+l]++;
				}
			}
		}
	}
	for(int i=1;i<=N;i++){
		cout<<res[ary[i]]<<endl;
	}
	return 0;
}