3 ms·
For me it's a function that calculates factorial using iterators in Rust: fn factorial(i: u64) -> u64 { (1..=i).product() } In almost every other la
by Jarqwiz 7y ago
For me it's a function that calculates factorial using iterators in Rust:
fn factorial(i: u64) -> u64 {
(1..=i).product()
}
In almost every other language this code would look messy or use some terrible recursion.
For example in C it would look something like this:
long factorial(int n)
{
int c;
long result = 1;
for (c = 1; c <= n; c++)
result = result * c;
return result;
}
Or with recursion:
long factorial(int n)
{
if (n == 0)
return 1;
else
return(n * factorial(n-1));
}
In any case, I thin Rust looks better in every way with its cleaner syntax.
- cakoose 7y ago> In almost every other language this code would look messy or use some terrible recursion. Nah, lots of other languages can do this. Python: def factorial(i): return reduce(operator.mul, range(2, i+1), 1) Ruby: def factorial(i) (2..i).reduce(1, :*) end Haskell: factorial n = foldl (*) 1 [2..n]
- rnhmjoj 7y agoIn haskell you can also use the `product` function: factorial n = product [1..n]
- estomagordo 7y agoFor Python, we don't need to supply the optional initializer 1. And reduce resides in the functools namespace (much like mul is in operator). I assume we're not talking about that peculiar dialect of Python that is no longer supported a few months from now.
- messe 7y agoNot only that but in python 3.8, it can be written: def factorial(n): return math.prod(range(1,n+1))
- estomagordo 7y agoNice!
- cakoose 7y ago> For Python, we don't need to supply the optional initializer 1. Without the initializer, factorial(0) doesn't work.
- emmelaich 7y agoThat Rust is very nice. But a more idiomatic C version would be long factorial(int n) { long result = 1; for (int c = 1; c <= n; c++) result *= c; return result; }
- sanatgersappa 7y agoClojure: (defn factorial [n] (reduce *' (range 1 (inc n))))
- enriquto 7y agothe first C version looks the best to me, it is extremely clear and concise. For a slight improvement, declare the variable c inside the loop. Yet, since 20! is the last factorial representable in a u64, there is not much a point for these functions, and you should definitely check for n<21. It would be more elegant to store a lookup table with the 21 possible results. In practice you would want the logarithm of the factorial, that is computed by the "lgamma" function from the C standard math.h. Is such a thing available in rust? Edit: if you use doubles (which is more reasonable for that use case), you can also do that: double factorial(double n) { return tgamma(1+n); }
- ansis- 7y agoC can be quite elegant: long factorial(int n) { return n == 0 ? 1 : n * factorial(n - 1); }