Lets see, what about factorial in constant memory? Exponentiation (a to the power of b, where they are positive integers) in logarithmic time (not using built-in exponentiation functions/syntax)? Anonymously add a constant to a number and return it (in a way that can be passed to a function like 'map' or some such)?
def Factorial(x):
output = 1
for i in xrange(x):
output *= (i + 1)
return output
def Factorial2(x):
return reduce(operator.mul, xrange(1, x + 1), 1)
I provided two versions, both with constant memory, to show how it'd look with explicit iteration and without it.
First one (not 100% sure it's constant memory, I think perl optimises the for to avoid instantiating the (1..$n) list:
#!/usr/bin/perl
use Modern::Perl;
use bigint;
say fact(5000);
sub fact {
my ($n) = @_;
my $output = 1;
for my $i (1..$n) {
$output *= $i;
}
return $output;
}
(Took the value up to 5000 to get something which ran long enough to get a measurement, on my laptop it runs (including startup time) in ~1.2s. (Can we compare runtime too? I know we're discussing readability, but I'm interested).
The reduce version (again, I'm unsure of const mem req). Comes in at ~1.4s:
#!/usr/bin/perl
use Modern::Perl;
use List::Util qw(reduce);
use bigint;
say fact(5000);
sub fact {
my ($n) = @_;
return reduce(sub { $a * $b; }, 1, (1..$n));
}
The add a constant (true lambda, closing over lexicals in scope, etc etc) is 'sub':
sub { my ($x) = @_; $x + 7; }
(doesn't have the python lambda limitations). (Be aware that perl GC is refcounted though, so ref cycles are possible).
Edit: I think the languages are comparable in terms of features and also readability. People may dislike leading sigils and that's fair, but I dislike python's "no need to declare your vars, just hope you don't typo an assignment" approach to lexicals.
I don't program in perl now a days. But when I did, I generally used perl's shortcuts a lot.
For example:
return reduce(sub { $a * $b; }, 1, (1..$n));
would be:
reduce { $a * $b } 1..$n;
This
my $output = 1;
for my $i (1..$n) {
$output *= $i;
}
would be:
$output *= $_ for (1..$n)
So, I have a question for you(assuming you write perl for a living). Is this your preferred style, or you do this to appease readability police which demands programming languages be readable by non programmers? Because really, what kind of programmer programs in perl and is averse to $_?
and you're right to call me on it. If I am writing a multi-line for loop, I do like to name the loop var though.
I think this is an interesting point (in a discussion about readability), do non-perl coders think the one-liner (with 'for' suffix) is more or less readable?
(I also prefer explicit return for maintenance reasons, except possibly in one-line subs)
It's really not that different; you just end up declaring your input arguments one line lower than in most other languages. Not a big deal in practice.
And with @_, you're free to use positional arguments, named arguments, variable arity, etc. without penalty. Some languages only give you some of that.
The overhead is only really the 'my = @_;' chars, but it is annoying. On the other hand, it does allow you to do things like partially unpack args and pass the rest as a bundle to a super class.
use bignum;
use v5.10;
=cut
def Factorial(x):
output = 1
for i in xrange(x):
output *= (i + 1)
return output
=cut
# Direct translation
sub factorial {
my $x = shift;
my $output = 1;
for my $i (1 .. $x) {
$output *= $i;
}
return $output;
}
say factorial(200);
=cut
def Factorial2(x):
return reduce(operator.mul, xrange(1, x + 1), 1)
=cut
use List::Util "reduce";
sub factorial2 {
my $x = shift;
reduce { $a * $b } (1 .. $x);
}
say factorial(200);
=cut
def Power(a, b):
if not b:
return 1
if b % 2:
return Power(a, b - 1) * a
x = Power(a, b/2)
return x * x
=cut
sub power {
my $a = shift;
my $b = shift // return 1;
if ($b % 2) {
return power($a, $b - 1) * $a
}
my $x = power($a, $b/2);
return $x * $x;
}
# lambda x: x + 7
my $plus7 = sub { $_[0] + 7 };
# Or:
my $plus7 = sub { my $x = shift; $x + 7 };
say $plus7->(14);
=cut
def TweakValue(x):
return x + 7
=cut
sub plus7 { $_[0] + 7 }
say plus7(14);
> def Factorial(x): output = 1 for i in xrange(x): output = (i + 1) return output
Umm, did you mean:
def factorial(x):
output = 1
for i in xrange(2, x):
output *= i
return output
Here are the perl versions. Such trivial examples are going to look the same in languages which share the same paradigms.
use List::Util qw(reduce);
# This is how I would write it.
sub fact1 {
my $num = shift;
my $output = 1;
$output *= $_ for (2 .. $num);
return $output;
}
# Most people don't prefer inline loops and $_ variable, though
# I don't see why not.
sub fact2 {
my $num = shift;
my $output = 1;
for my $i (2 .. $num) {
$output *= $i;
}
return $output;
}
sub fact3 {
my $num = shift;
return reduce { $a * $b } 2..$num
}
Based on the examples, I presume xrange(x) is every integer up to but not including x. ie 1..^$x in Perl 6, don't recall if that's the Perl 5 syntax or not.
With this, I get:
Exponentiation: Add a constant: Or, if you want to name it globally: How do they look in Perl?