Расчет биномиальных коэффициентов на Си (С++) и Python

#include <iostream>
#include <type_traits>

template <char ... Chars>
struct number {};

std::ostream& operator<< (std::ostream& os, number<>){
    return os;
}

template <char C, char ... Chars>
std::ostream& operator<< (std::ostream& os, number<C, Chars...>){
    os << C << number<Chars...>{};
    return os;
}

template <class A, class B>
struct append;

template <char ... As, char ... Bs>
struct append<number<As...>, number<Bs...>> {
    using type = number<As..., Bs...>;
};

template <class Source, class Result = number<>>
struct reverse;

template <char A, char ... As, char ... Bs>
struct reverse<number<A,As...>, number<Bs...>> {
    using type = typename reverse<number<As...>,number<A,Bs...>>::type;
};

template <char ... Bs>
struct reverse<number<>,number<Bs...>> {
    using type = number<Bs...>;
};

template <class T>
struct remove_zeroes {
    using type = T;
};

template <>
struct remove_zeroes<number<'0'>> {
    using type = number<'0'>;
};

template <char ... As>
struct remove_zeroes<number<'0',As...>> {
    using type = typename remove_zeroes<number<As...>>::type;
};

template <char A, char B, char C>
struct basic_sum {
    static constexpr char H = '0' + ((A-'0') + (B-'0') + (C -'0'))/10;
    static constexpr char L = '0' + ((A-'0') + (B-'0') + (C -'0'))%10;
};

template <class A, class B, char C>
struct partial_sum;

template <char A, char ... As, char B, char ... Bs, char C>
struct partial_sum<number<A,As...>, number<B, Bs...>, C> {
    using L = number<basic_sum<A,B,C>::L>;
    using H = typename partial_sum<number<As...>,number<Bs...>,basic_sum<A,B,C>::H>::type;
    using type = typename append<L,H>::type;
};
template <char A, char ... As, char C>
struct partial_sum<number<A,As...>,number<>,C> {
    using L = number<basic_sum<A,'0',C>::L>;
    using H = typename partial_sum<number<As...>,number<>,basic_sum<A,'0',C>::H>::type;
    using type = typename append<L,H>::type;
};

template <char B, char ... Bs, char C>
struct partial_sum<number<>,number<B,Bs...>,C> {
    using L = number<basic_sum<'0',B,C>::L>;
    using H = typename partial_sum<number<>,number<Bs...>,basic_sum<B,'0',C>::H>::type;
    using type = typename append<L,H>::type;
};

template <char C>
struct partial_sum<number<>,number<>,C> {
    using L = number<C>;
    using H = number<>;
    using type = typename append<L,H>::type;
};

template <class A, class B>
using sum = typename remove_zeroes<typename reverse<typename partial_sum<typename reverse<A>::type,typename reverse<B>::type,'0'>::type>::type>::type;

template <class>
struct decrement_helper;

template <char A, char... As>
struct decrement_helper<number<A,As...>> {
    using L = number<(A=='0')?'9':(A-1)>;
    using H = typename std::conditional<A=='0',typename decrement_helper<number<As...>>::type,number<As...>>::type;
    using type = typename append<L,H>::type;
};

template <>
struct decrement_helper<number<>> {
    using type = number<>;
};

template <class T>
using decrement = typename remove_zeroes<typename reverse<typename decrement_helper<typename reverse<T>::type>::type>::type>::type;

template <class K, class N>
struct bcl_helper {
    using type = sum<typename bcl_helper<K,decrement<N>>::type,typename bcl_helper<decrement<K>,decrement<N>>::type>;
};

template <class N>
struct bcl_helper<N,N> {
    using type = number<'1'>;
};

template <class N>
struct bcl_helper<number<'0'>,N> {
    using type = number<'1'>;
};

template <typename CharT, CharT ...String> auto operator "" _n() {
    return number<String...>();
}

template <class K, class N>
auto bcl(K,N) {
    return typename bcl_helper<K,N>::type();
}

int main(int /*argc*/, char** /*argv*/)
{
    std::cout << bcl("50"_n,"100"_n) << std::endl;
}