We know we can use the Benchmark module to compare Perl code. There are equivalent tools for C also, but how are we going to use two different tools and keep the comparison fair? Since Perl is a glue language in addition to its own merits, we can glue the C code into Perl and then use the Benchmark module to run the benchmark.

To simplify the task, we are going to demonstrate only the fact that C is more suitable than Perl for mathematical and memory-manipulation tasks. The purpose is to show how to use the best of both worlds.

We will use a very simple task that we will implement in Perl and C: the factorial function written both recursivly and iteratively. If you have ever taken a basic programming course you will be familiar with this example.

In mathematical language, we define the factorial function as follows:

```1! = 1
N! = N * (N-1)!```

So if we start from 1 and go up, we get these numbers:

```1! =                1
2! = (2)(1)       = 2
3! = (3)(2)(1)    = 6
4! = (4)(3)(2)(1) = 24
... and so on.```

The factorial grows very fast—e.g., 10! = 3,628,800 and 12! = 4.790016e+08 (479 million)—so you can imagine that the calculation of the factorial of large numbers is a memory-intensive operation.

Now since we have a recursive definition of the solution:

```fact(1) = 1;
fact(N) = N * fact(N-1)```

the easiest way to implement it is to write a recursive function. In Perl we just reproduce the definition:

```sub factorial_recursive_perl {
return 1 if \$_[0] < 2;
return \$_[0] * factorial_recursive_perl(\$_[0] - 1);
}```

Computer science teaches us that while recursive functions are often easy to write they are usually slower to run than their iterative equivalents. The iterative implementation is as easy as the recursive one in our example, and it should run much faster, since there is no function-call overhead. This is the iterative algorithm to calculate fact(N):

```result = 1
for (i = 2; i <= N; i++) {
result *= i;
}```

By adjusting it to use idiomatic Perl, we get the following function:

```sub factorial_iterative_perl {
my \$return = 1;
\$return *= \$_ for 2..\$_[0];
return \$return;
}```

The implementations in C are again similar to the algorithm itself:

```double factorial_recursive_c(int x) {
if (x < 2)  return 1;
return x * factorial_recursive_c(x - 1);
}

double factorial_iterative_c(int x) {
int i;
double result = 1;
for (i = 2; i <= x; i++)
result *= i;
return result;
}```

To jump ahead, when we run the final benchmark we get the following results:

```Benchmark: timing 300000 iterations of iterative_c, iterative_perl,
recursive_c, recursive_perl...
iterative_c:  0 wallclock secs ( 0.47 usr +  0.00 sys =  0.47 CPU)
recursive_c:  2 wallclock secs ( 1.15 usr +  0.00 sys =  1.15 CPU)
iterative_perl: 28 wallclock secs (26.34 usr +  0.00 sys = 26.34 CPU)
recursive_perl: 75 wallclock secs (74.64 usr +  0.11 sys = 74.75 CPU)```

All functions under test were executing 100!, which is 9.33262154439441e+157 using scientific notation.

The iterative implementation is about two and a half times as fast in C and three times as fast in Perl, where function calls are more expensive. Comparing C to Perl, the iterative implementation in C is about 56 times faster than the same algorithm implemented in Perl, and in the case of the recursive algorithm, C is 65 times faster.