I’ve now solved the first 15 Project Euler challenges in C. But then, I’ve hit a road block. Let me explain.

Let’s say you want to find the sum of digits for the number 3^300. Would you use C or Python?

Python

In Python, it’s easy:

sum(map(int, str(3**300)))

C

To achieve the same thing in C you would need:

1. A big decimal library
2. A big decimal to string conversion function
3. Use manual memory allocation
4. Worry about printing the result correctly

All this without ever having the chance to express on a high level:

Calculate 3^300, find the digits, convert them to integers, sum them.

Instead, C would require you to say:

Initialize my big decimal library, start the calculation. Check whether the calculation didn’t run out of memory. Then, execute a loop that uses the big decimal to string conversion routine to retrieve its string representation. Then, convert this string representation back to integers, and then finally sum the integers.

While you can always create a nice high level abstraction inside of C, the drawback is flexibility. While you crafted all this code within an hour or so, using Python lets you solve 20 similar problems in the same time. At the same time, it provides better memory safety, readability, and maintainability.

This comes with some drawbacks:

1. The Python code is much slower. It requires tons of Python object meta-data and requires garbage collection.
2. You can optimize C code using the correct compiler flags. Python doesn’t have an optimizing compiler.
3. The C code can interface with assembly instructions that might be offered on your CPU to offer further speedups.

The Compromise

A great solution that a lot of Python projects find is to have the high level API run in Python, while the low-level hot loops are written in C. One of the most famous projects that do it this way would be NumPy. It contains C code for efficient array packing, but still exposes a powerful Python interface to achieve a lot in a small amount of lines of code.