He reaprovechado un código que hice hace un tiempo que multiplica usando Karatsuba, por lo que el código es largo y feo. Si alguien lo prefiere dejo una versión nueva y más legible sin usar Karatsuba. De hecho, Karatsuba sólo se usa si los dos números a multiplicar son suficiente grandes (unos 100 dígitos) en mi código, pero lo dejo por si a alguien le interesa.

#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;
}
 

Ahora pasemos al reto de Og. y a ver si alguien se anima, que es una dinámica sencillita.

Bueno parece que nadie se animo a resolver el reto por lo que aqui va la solución:

Bueno.. aqui va uno un tanto sencillo.
fuente: Wikipedia.

Reto #21: Hacer un programa que imprima en pantalla todos los números perfectos hasta un número N dado como entrada.

Reto #22: Dada dos fechas, verificar cuantos dias han transcurrido... se debe de tomar en cuenta los años bisiestos.

Postealo a ver, lo vamos revisando y arreglando.

Saludos.