Foro de elhacker.net

#include <iostream>
 
using std::cout;
using std::endl;
 
int getNum(char* text)
{
    int a=0, cont=0;
    while(text[cont])
    {
        a *= 10;
        a += text[cont++] - '0';
    }
    return a;
}
 
int main(int argc, char** argv)
{
    int num;
    num = getNum(argv[1]);
    for(int i=2;i<=num/2;i++)
        if(!(num%i))
        {
            cout << "No es primo" << endl;
            return 0;
        }
    cout << "Es primo" << endl;
    return 0;
}
 

3

1 2 3
1 3 2
2 1 3
2 3 1
3 1 2
3 2 1

4

1 2 3 4
1 2 4 3
1 3 2 4
1 3 4 2
1 4 2 3
1 4 3 2
2 1 3 4
2 1 4 3
2 3 1 4
2 3 4 1
2 4 1 3
2 4 3 1
3 1 2 4
3 1 4 2
3 2 1 4
3 2 4 1
3 4 1 2
3 4 2 1
4 1 2 3
4 1 3 2
4 2 1 3
4 2 3 1
4 3 1 2
4 3 2 1

#include <iostream>
#include <string>
#include <sstream>
using namespace std;
void String(string a,string b);
int main(int argc, char *argv[]) {
    string n="";
    ostringstream stm;
    int value=0;cin>>value;
        for(int index=1;index<=value;index++){
        stm<<index;
            n=stm.str();
        }String("",n);
    return 0;
}
void String(string a, string b) {
    if(b.length() <= 1)
    cout<<a + b+"\n";
    else
    for (int i = 0; i < b.length(); i++) {
        string n = b.substr(0, i) + b.substr(i + 1);
        String(a + b.at(i), n);
	      }
	  }
 

#include <iostream>
 
using std::cin;
using std::cout;
using std::endl;
 
int main(void)
{
    int N;
    cin >> N;
    for(int i=0;i<N;i++)
    {
        for(int g=0; g<=i; g++)
            cout << g+1 << " ";
        for(int g=i; g<N; g++)
            cout << 0 << " ";
        cout << endl;
    }
    return 0;
}
 

#include <iostream>
#include <cstdlib>
 
using std::cout;
using std::endl;
 
struct cambio
{	
	int uno;
	int cinco;
	int diez;
	int veinte;
	int cincuenta;
	int cien;
	int total;
		};
 
 
int main(int argc,char *argv[])
{
int valor = atoi(argv[1]);
if (valor!=0)
{
	cambio *monedas = new cambio;
 
while(valor>=100)
	{	
		monedas->cien++;
		monedas->total++;
		valor -=100;
		}
 
while(valor>=50)
	{	
		monedas->cincuenta++;
		monedas->total++;
		valor -=50;
		}
 
while(valor>=20)
	{	
		monedas->veinte++;
		monedas->total++;
		valor -=20;
		}
 
while(valor>=10)
	{	
		monedas->diez++;
		monedas->total++;
		valor -=10;
		}
 
while(valor>=5)
	{	
		monedas->cinco++;
		monedas->total++;
		valor -=5;
		}
 
while(valor>=1)
	{	
		monedas->uno++;
		monedas->total++;
		valor -=1;
		}
 
cout<<"Total de Monedas: "<<monedas->total<<endl<<endl;
cout<<"Valores: \n"<<"Cien: "<<monedas->cien<<endl;
cout<<"Cincuenta: "<<monedas->cincuenta<<endl;
cout<<"Veinte: "<<monedas->veinte<<endl;
cout<<"Diez: "<<monedas->diez<<endl;
cout<<"Cinco: "<<monedas->cinco<<endl;
cout<<"Uno: "<<monedas->uno<<endl;							
 
}
else
{	
	cout<<"Valor no valido"<<endl;
 
	}
return 0;
}
 
 

#include <iostream>
#include <cstdlib>
using std::cin;
using std::cout;
using std::endl;
bool isperfect(const unsigned int& n)
{
    unsigned int suma = 0;
    for(register unsigned int i = 1; i < n; i++)
    if(!(n % i))
    suma += i;
    return(suma == n);
}
int main(int argc, char **argv)
{
    if(argc != 2)
        exit(EXIT_FAILURE);
    for(register unsigned int i = 1; i <= atoi(*(argv + 1)); i++)
    if(isperfect(i) && (i < atoi(*(argv + 1))))
    cout << i << endl;
    return 0;
}

#include <iostream>
 
using namespace std;
 
int main(void)
{
    int mat[5][5];
    for(int i=0; i<5; i++)
        for(int g=0; g<5;g++)
            mat[i][g] = i*g;
    int* a = mat[0];
    for(int i=0;i<25;i++)
    {
        if(!(i%5))
            cout << endl;
        cout << *a++ << " ";
    }
}

#include <iostream>
#include <vector>
using namespace std;
 
const int INF = 1000000000;
 
int dp(int p, vector<int>& M, vector<int>& v) {
    if (p < 0) return INF;
    if (p == 0) return 0; //Caso base
    if (M[p] == -1) {
        M[p] = INF;
        for (int i = 0; i < v.size(); ++i) 
            M[p] = min(M[p], 1 + dp(p - v[i], M, v));
    }
    return M[p];
}
 
int main() {
    int n, p;
    cin >> n;
    vector<int> v(n);
    for (int i = 0; i < n; ++i) cin >> v[i]; //Lectura de las monedas
    cin >> p;
    vector<int> M(p + 1, -1); //Tabla para la dinamica
    cout << dp(p, M, v) << endl;
}

#include <iostream>
using namespace std;
 
long long ceros(long long x) {
    long long res = 0, pot = 5;
    while (x/pot > 0) {
        res += x/pot;
        pot *= 5;
    }
    return res;
}
 
int main() {
    long long n;
    cin >> n;
    long long ini = 1, fin = 5*n;
    while (ini <= fin) {
        long long m = (ini+fin)/2;
        if (ceros(m) >= n) fin = m - 1;
        else ini = m + 1;
    }
    cout << fin + 1 << endl;
}
 

#include "stdafx.h"
#include <iostream>
using namespace std;
 
 
int _tmain(int argc, _TCHAR* argv[])
{
	int n, fac;
	cin >> n;
	cout << "HUHU: " << n *5 << endl;
	return 0;
}
 

#include <iostream>
 
using std::cout;
using std::cin;
using std::endl;
 
int consistencia(int v1[],int v2[],int lenght)
{
	int temp;
for(int i=0;i<lenght;i++)
	{	int k=0;
		do{
			if(v2[k]==v1[i])
			{
			temp=v1[k];
			v1[k]=v2[k];
			v2[k]=temp;
				}
			k++;
			}while(k<temp);
	}
 
for(int i=0;i<lenght;i++)
{	int k=0;
	do{
		if(v2[k]==v1[i])return 1;
		k++;
		}while(k<lenght);
	}
return 0;
}
 
int main()
{
int Regs, *gen1, *gen2, i;
 
cout<<"Cantidad de Registros: ";
cin>>Regs;
gen1 = new int[Regs];
gen2 = new int[Regs];
 
for(i;i<Regs;i++)
	{
	gen1[i]=-1;
	gen2[i]=-1;
		}
 
for(i=0;i<Regs;i++)
	{
	cout<<"1er Valor del registro "<<i+1<<" :";
	cin>>gen1[i];
	cout<<"2do Valor del registro "<<i+1<<" :";
	cin>>gen2[i];
		}
 
if(consistencia(gen1,gen2,Regs))cout<<"No son consistentes"<<endl;
else{cout<<"Son Consistentes"<<endl;}		
 
}
 

#include <stdio.h>
#include <stdlib.h>
 
int noFuck (int **corral, int g1, int g2, int n);
int addChicken (int **corral, int g1, int g2);
 
int main(int argc, char **argv) {
 
   int **corral, n, m, i, gays = 0;
   int g1,g2;
 
   if (argc != 3) return 1;
 
   n = atoi(argv[1]);
   m = atoi(argv[2]);
 
   if (!(corral = (int**)calloc(n,sizeof(int)))) return 1;
   for (i=0;i<n;i++) if (!(corral[i] = (int*)calloc(n/sizeof(int),sizeof(int)))) return 1;
 
   while (m-- > 0 & !gays) {
 
      scanf("%d %d",&g1,&g2);
      if (!noFuck(corral,g1,g2,n)) addChicken(corral,g1,g2);// añadimos g1 a parejas de g2 y viceversa
      else gays = 1;
 
   }
 
   if (!gays) printf("Si\n"); else printf("No\n");
 
   for (i=0;i<n;i++) free(corral[i]); free(corral);
 
   return 0;
 
}
 
int noFuck (int **corral, int g1, int g2, int n) {
 
   int i;
 
   if (g1 == g2) return 1;
   for (i=0;i<=n/sizeof(int);i++) if (corral[g1][i] & corral[g2][i]) return 1;
   return 0;
 
} 
 
int addChicken (int **corral, int g1, int g2) {
 
   corral[g1][g2/sizeof(int)] |= (g2%sizeof(int));
   corral[g2][g1/sizeof(int)] |= (g1%sizeof(int));
   return 0;
 
}

#include <iostream>
 
using std::cin;
using std::cout;
using std::endl;
 
struct pareja
{
    int h;
    int m;
};
 
pareja *relaciones;
int N, M;
short *pollos, *relacionesChk;
bool correcto;
 
bool Relaciona(int);
void entid(int num, int tp);
 
int main(void)
{
    cin >> N >> M;
    pollos = new short[N];
    relacionesChk = new short[M];
    relaciones = new pareja[M];
    for(int i=0; i<M; i++)
        relacionesChk[i] = 0;
    for(int i=0; i<M; i++)
    {
        cin >> relaciones[i].h >> relaciones[i].m;
    }
    correcto = true;
    Relaciona(0);
    if(correcto)
        cout << "SI";
    else
        cout << "NO";
    delete pollos;
    delete relacionesChk;
    delete relaciones;
}
 
bool Relaciona(int num)
{
    if(!correcto)
        return 0;
    if(num>=M)
        return true;
    for(int i=0; i<N; i++)
        pollos[i] = -1;
    relacionesChk[num] = 1;
    pollos[relaciones[num].h] = 0;
    pollos[relaciones[num].m] = 1;
    entid(relaciones[num].h, 1);
    entid(relaciones[num].m, 0);
    while(relacionesChk[++num] && num<=M);
    Relaciona(num);
}
 
void entid(int num, int tp)
{
    if(!correcto)
        return;
    for(int i=0; i<M; i++)
        if(!relacionesChk[i])
        {
            if(relaciones[i].h==num)
            {
                relacionesChk[i] = 1;
                if(pollos[relaciones[i].m] == -1)
                {
                    pollos[relaciones[i].m] = tp;
                    entid(relaciones[i].m, !tp);
                }
                else if(pollos[relaciones[i].m] == !tp)
                    correcto = false;
            } else if(relaciones[i].m==num) {
                relacionesChk[i] = 1;
                if(pollos[relaciones[i].h] == -1)
                {
                    pollos[relaciones[i].h] = tp;
                    entid(relaciones[i].h, !tp);
                }
                else if(pollos[relaciones[i].h] == !tp)
                    correcto = false;
            }
        }
    return;
}

#include <iostream>
#include <vector>
using namespace std;
 
typedef vector<int> VI;
typedef vector<VI> VVI;
 
bool bicolor(int u, int c, VVI& G, VI& color) {
    bool res = true;
    for (int i = 0; i < G[u].size(); ++i) {
        int v = G[u][i];
        if (color[v] < 0) {
            color[v] = c;
            res &= bicolor(v, 1 - c, G, color);
        }
        else if (color[v] != c) res = false;
    }
    return res;
}
 
int main() {
    int n, m;
    cin >> n >> m;
    VVI G(n);
    for (int i = 0; i < m; ++i) {
        int a, b;
        cin >> a >> b;
        G[a].push_back(b);
        G[b].push_back(a);
    }
    VI color(n, -1);
    bool res = true;
    for (int i = 0; i < n; ++i) { //Por si hay mas de un componente
        if (color[i] < 0) {
            color[i] = 0;
            res &= bicolor(i, 1, G, color);
        }
    }
    if (res) cout << "Si" << endl;
    else cout << "No" << endl;    
}

#include <iostream>
#include <vector>
using namespace std;
 
typedef vector<int> VI;
typedef vector<VI> VVI;
 
const int INF = 1000000000;
 
int dp(int n, int m, VVI& M) {
    if (n < m) return dp(m, n, M);
    if (m == 0) return 0;
    if (M[n][m] == -1) {
        M[n][m] = INF;
        for (int x = 0; x <= m; ++x) {
            M[n][m] = min(M[n][m], 1 + dp(x, m - x, M) + dp(n - x, m, M));
            M[n][m] = min(M[n][m], 1 + dp(n, m - x, M) + dp(n - x, x, M));
        }
    }
    return M[n][m];
}
 
int main() {
    int n, m;
    cin >> n >> m;
    if (n < m) swap(n, m);
    VVI M(n + 1, VI(m + 1, -1));
    cout << dp(n, m, M) << endl;
}
 

#include <stdio.h>
#include <stdlib.h>
 
int main(int argc, char **argv) {
 
   int n,*sec,i,j,k;
 
   if (argc != 2) return 1;
 
   n = atoi(argv[1]);
   sec = (int*)calloc(n,sizeof(int));
   for (i=0;i<n;i++) scanf("%d",&sec[i]);
 
   for (i=0;i<n;i++) {
      for (j=i;j<n;j++) {
         sum = 0; for (k=i;k<=j;k++) sum+=sec[k];
         if (sum > max) max = sum;
      }
   }
 
   printf("%d\n",max);
 
   free(sec);
   return 0;
 
}

#include <stdio.h>
#include <stdlib.h>
 
int main(int argc, char **argv) {
 
   int n, i, j, **sec, max=0;
 
   if (argc != 2) return 1;
 
   n = atoi(argv[1]);
   if (!(sec = (int**)calloc(n,sizeof(int*)))) return 1;
   for (i=0;i<n;i++) if(!(sec[i] = (int*)calloc(n,sizeof(int)))) return 1;
 
   for (i=0;i<n;i++) scanf("%d",&sec[0][i]);
 
   for (i=1;i<n;i++)
      for (j=i;j<n;j++) {
         sec[i][j] = sec[i-1][j]+sec[0][j-i];
         if (sec[i][j] > max) max = sec[i][j];
      }
 
   printf("%d\n",max);
 
   for (i=0;i<n;i++) free(sec[i]); free(sec);
 
   return 0;
 
}

#include <vector>
#include <iostream>
using namespace std;
int main() {
    int n;
    cin >> n;
    vector<int> suma(n);
    for (int i = 0; i < n; ++i) {
        cin >> suma[i];
        if (i > 0) suma[i] += suma[i - 1];
    }
    //suma[i] contiene la suma de los i + 1 primeros numeros
    int res = 0;
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < n; ++j) {
            //Calculamos la suma de cada intervalo aprovechando el vector de sumas calculadas
            //La suma de [i,j] sera suma[j] - suma[i - 1]
            int temp = suma[j];
            if (i > 0) temp -= suma[i - 1];
            res = max(res, temp);
        }
    }
    cout << res << endl;
}
 

#include <vector>
#include <iostream>
using namespace std;
int main() {
    int n;
    cin >> n;
    int a, res = 0, suma = 0;
    for (int i = 0; i < n; ++i) {
        cin >> a;
        suma += a;
        if (suma < 0) suma = 0;
        res = max(res, suma);
    }
    cout << res << endl;
}

#include <iostream>
#include <vector>
#include <cstdlib>
using namespace std;
 
int arrf[8] = {-1,-1,-1,0,1,1,1,0};
int arrc[8] = {-1,0,1,1,1,0,-1,-1};
 
int main() {
    int n, m;
    cin >> n >> m;
    vector<vector<char> > S(n, vector<char>(m));
    srand(time(NULL));
    for (int i = 0; i < n; ++i) 
        for (int j = 0; j < m; ++j) 
            S[i][j] = 'a' + rand()%26;
    string s;
    cin >> s;
    bool busca = true;
    for (int i = 0; i < n and busca; ++i)
        for (int j = 0; j < m and busca; ++j)
            for (int d = 0; d < 8 and busca; ++d) {
                bool ok = true;
                for (int k = 0; k < s.size() and ok; ++k) {
                    int f = i + arrf[d]*k, c = j + arrc[d]*k;
                    if (f < 0 or f >= n or c < 0 or c >= m or S[f][c] != s[k]) ok = false;
                }
                if (ok) {
                    busca = false;
                    for (int k = 0; k < s.size(); ++k) {
                        int f = i + arrf[d]*k, c = j + arrc[d]*k;
                        S[f][c] ^= 32;
                    }
                }
            }
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < m; ++j) {
            if (j > 0) cout << " ";
            cout << S[i][j];
        }
        cout << endl;
    }
    cout << endl << (busca?"No":"Si") << endl;
}
 

#include <iostream>
#include <vector>
#include <algorithm>
#include <map>
using namespace std;
 
typedef pair<int, int> PII;
 
bool comp(PII a, PII b) {
    return (a.second < b.second) or (a.second == b.second and a.first < b.first);
}
 
int main() {
    int n;
    cin >> n;
    vector<PII> v(n);
    for (int i = 0; i < n; ++i) cin >> v[i].first >> v[i].second;
    sort(v.begin(), v.end(), comp);
    int cnt = 0, ant = -1;
    for (int i = 0; i < n ; ++i) {
        if (v[i].first >= ant) {
            ++cnt;
            ant = v[i].second;
        }
    }
    cout << cnt << endl;
}
 

#include <iostream>
#include <vector>
#include <algorithm>
#include <map>
using namespace std;
 
typedef pair<int, int> PII;
 
int main() {
    int n;
    cin >> n;
    vector<PII> v(n);
    for (int i = 0; i < n; ++i) cin >> v[i].first >> v[i].second;
    sort(v.begin(), v.end());
    vector<int> M(n);
    int res = 0;
    for (int i = 0; i < n ; ++i) {
        M[i] = 1;
        for (int j = 0; j < i; ++j) 
            if (v[j].second <= v[i].first) M[i] = max(M[i], M[j] + 1);
        res = max(res, M[i]);
    }
    cout << res << endl;
}
 

open System
 
//forma 1 dos ciclos no usa funcion externa
let r i j= 
    let mutable t = 0
    for i in i .. j do
        let mutable n = i
        let mutable x = 2
        while n <> 1 do
            if n % 2 = 1 then n <- 3*n+1 else n <-n/2
            if x > t then t <- x
            x <- x + 1
    t
 
//funcion para la forma 2 y 3        
let rec gcd n y =
    if n = 1 then y
    else match n % 2 with
        | 1 -> gcd (3*n+1) y + 1
        | _ -> gcd ( n/2) y + 1
 
 
//forma 2
let r2 i j = 
    let mutable m = 0
    let mutable o = 0
    for i in i .. j do 
        o <- gcd i 1
        if o > m then m <- o
    m
 
//forma 3
let rec r3 i j n= 
    if i = j then n
    else let e = gcd i 1
        r3 (i+1) j (match e > n with |true -> e |_ -> n)
 
let a  = Console.ReadLine() |> int
let b  = Console.ReadLine() |> int
 
printfn "r  %A" (r a b)
printfn "r2 %A" (r2 a b)
printfn "r3 %A" (r3 a b 1)
 
Console.ReadKey(true);
 

#include <iostream>
#include <vector>
using namespace std;
 
typedef long long ll;
 
ll f(ll n, vector<ll>& v) {
    if (n == 1) return 1;
    if (n >= v.size()) return 1 + ((n%2 == 1)?f(3*n + 1, v):f(n/2, v));
    if (v[n] == -1) v[n] = 1 + ((n%2 == 1)?f(3*n + 1, v):f(n/2, v));
    return v[n];
}
 
int main() {
    vector<ll> v(1000000, -1);
    ll a, b;
    while (cin >> a >> b) {
        ll res = 0;
        for (ll i = min(a,b); i <= max(a,b); ++i) res = max(res, f(i, v));
        cout << a << " " << b << " " << res << endl;
    }
}

#include <iostream>
 
using namespace std;
 
struct locas
{
    int b,c,d,e;
	};
 
int main()
{
	int a,i=0,j=0,t=0,k;
	cin>>a;
	locas b[a];
	for(i;i<a;i++){cin>>b[i].b>>b[i].e>>b[i].c; b[i].d=0;}
 
	for(i=0;i<a;i++)
	{
		for(j=0;j<a;j++)
		{
			if(b[i].b>b[j].b && b[i].e>b[j].e && b[i].c>b[j].c)
			{
			    if(b[j].d==1)continue;
			    else
			    {
                                    t++;
                                    b[j].d=1;
                                    break;
				    }
			    }
                         }
		}
	cout<<t<<endl;
	}
 

#include <iostream>
#include <cmath>
using namespace std;
 
inline void limpiar()
{
	while(getchar() != '\n');
}
 
int main()
{
	//aceleracion causada por la gravedad
	const float g = 9.81;
	//Datos
	float M,F,D,N;
	//Datos intermedios:
	//fuerza causada por friccion, Fuerza neta sobre la masa, aceleracion
	float Ff, Fn, a;
	//Respuesta:
	float v;
 
	cout << "Introduzca la masa" << endl;
	cin >> M;
	limpiar();
	cout << "Introduzca la fuerza" << endl;
	cin >> F;
	limpiar();
	cout << "Introduzca la distancia" << endl;
	cin >> D;
	limpiar();
	cout << "Introduzca el coeficiente de friccion" << endl;
	cin >> N;
	limpiar();
 
	Ff = N*M*g;
	Fn = F - Ff;
	if(Fn < 0)
	{
		//No hay movimiento, la friccion es mas grande que la fuerza
		cout << "Velocidad final del bloque 0 m/s." << endl;
		exit(0);
	}
	a = Fn/M;
	v = sqrt(2.0*a*D);
	cout.precision(1);
	cout << "Velocidad final del bloque ";
	cout << fixed << v;
	cout << " m/s." << endl;
	cin.get();
}
 

#include <iostream>
 
using namespace std;
 
int fact(int val)
{
   if(val==0)
      return 1;
   else
      return val*fact(val-1);
}
 
int main(void)
{
    int N;
    cin >> N;
    cout << fact(N) << endl;
    return 0;
}
 

3
1
2 1
1 0 1

4

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
 
typedef vector<long long> VL;
 
VL mult(VL& a, int i1, int f1, VL& b, int i2, int f2) {
    if (i1 > f1 or i2 > f2) return VL(1,0);
    if (f1 >= a.size()) return mult(a, i1, a.size() - 1, b, i2, f2);
    if (f2 >= b.size()) return mult(a, i1, f1, b, i2, b.size() - 1);
    if (i1 >= a.size() or i2 >= b.size()) return VL(1,0);
    int n = f1 - i1 + 1, m = f2 - i2 + 1;
    VL c(max(n,m)*2 + 1, 0);
    for (int i = i1; i <= f1; ++i) {
        for (int j = i2; j <= f2; ++j) {
            c[i - i1 + j - i2] += (a[i]*b[j]);
            c[i - i1 + j - i2 + 1] += (c[i - i1 + j - i2]/1000000000);
            c[i - i1 + j - i2] %= 1000000000;
        }
    }
    int pos = c.size() - 1;
    while (pos > 0 and c[pos--] == 0) c.pop_back();
    return c;
}
 
VL suma(VL& a, int i1, int f1, VL& b, int i2, int f2) {
    if (i1 > f1 or i1 >= a.size()) {
        VL cero(1,0);
        return suma(cero, 0, 0, b, i2, f2);
    }
    if (i2 > f2 or i2 >= b.size()) {
        VL cero(1, 0);
        return suma(a, i1, f1, cero, 0, 0);
    }
    if (f1 >= a.size()) return suma(a, i1, a.size() - 1, b, i2, f2);
    if (f2 >= b.size()) return suma(a, i1, f1, b, i2, b.size() - 1);
    int n = f1 - i1 + 1, m = f2 - i2 + 1;
    VL c(n + m + 2, 0);
    int i = i1, j = i2, k = 0;
    while (i <= f1 and j <= f2) {
        c[k] += (a[i] + b[j]);
        c[k + 1] += (c[k]/1000000000);
        c[k] %= 1000000000;
        ++i; ++j; ++k;
    }
    while (i <= f1) {
        c[k] += a[i];
        c[k + 1] += (c[k]/1000000000);
        c[k] %= 1000000000;
        ++i; ++k;
    }
    while (j <= f2) {
        c[k] += b[j];
        c[k + 1] += (c[k]/1000000000);
        c[k] %= 1000000000;
        ++j; ++k;
    }
    int pos = c.size() - 1;
    while (pos > 0 and c[pos--] == 0) c.pop_back();
    return c;
}
 
VL resta(VL& a, int i1, int f1, VL& b, int i2, int f2) {
    VL c;
    c = a;
    for (int i = i2; i <= f2; ++i) {
        c[i] -= b[i];
        while (c[i] < 0) {
            c[i] += 1000000000;
            c[i + 1]--;
        }
    }
    int pos = c.size() - 1;
    while (pos > 0 and c[pos--] == 0) c.pop_back();
    return c;
}
 
VL karatsuba(VL& a, int i1, int f1, VL& b, int i2, int f2) {
    if (i1 > f1 or i2 > f2) return VL(1,0);
    if (f1 >= a.size()) return karatsuba(a, i1, a.size() - 1, b, i2, f2);
    if (f2 >= b.size()) return karatsuba(a, i1, f1, b, i2, b.size() - 1);
    if (i1 >= a.size() or i2 >= b.size()) return VL(1,0);
    int p = f1 - i1 + 1, m = f2 - i2 + 1;
    if (min(p, m) <= 10) return mult(a, i1, f1, b, i2, f2);
    int n = max(p, m);
    VL c1, c2, c3, x, y;
    int mit = n/2;
    c1 = karatsuba(a, i1 + mit, f1, b, i2 + mit, f2);
    c3 = karatsuba(a, i1, i1 + mit - 1, b, i2, i2 + mit - 1);
    x = suma(a, i1, i1 + mit - 1, a, i1 + mit, f1);
    y = suma(b, i2, i2 + mit - 1, b, i2 + mit, f2);
    c2 = karatsuba(x, 0, x.size() - 1, y, 0, y.size() - 1);
    c2 = resta(c2, 0, c2.size() - 1, c1, 0, c1.size() - 1);
    c2 = resta(c2, 0, c2.size() - 1, c3, 0, c3.size() - 1);
    VL res(2*n + 3, 0);
    for (int i = 0; i < c1.size(); ++i) {
        res[i + 2*mit] += c1[i];
        res[i + 2*mit + 1] += (res[i + 2*mit]/1000000000);
        res[i + 2*mit] %= 1000000000;
    }
    for (int i = 0; i < c2.size(); ++i) {
        res[i + mit] += c2[i];
        res[i + mit + 1] += (res[i + mit]/1000000000);
        res[i + mit] %= 1000000000;
    }
    for (int i = 0; i < c3.size(); ++i) {
        res[i] += c3[i];
        res[i + 1] += (res[i]/1000000000);
        res[i] %= 1000000000;
    }
    int pos = res.size() - 1;
    while (pos > 0 and res[pos--] == 0) res.pop_back();
    return res;
}
 
string str(long long x) {
    string s;
    do {
        s += char(x%10 + '0');
        x /= 10;
    } while(x > 0);
    reverse(s.begin(), s.end());
    return s;
}
 
int main() {
    int n;
    cin >> n;
    VL res(1,1);
    for (int i = 1; i <= n; ++i) {
        VL a(1,i);
        VL c;
        c = karatsuba(a, 0, a.size() - 1, res, 0, res.size() - 1);
        res = c;
    }
    cout << res[res.size() - 1];
    for (int i = res.size() - 2; i >= 0; --i) {
        string s = str(res[i]);
        cout << string(9 - s.size(), '0') << s;
    }
    cout << endl;
}