I can’t seem to reproduce the problems you had while posting the Perl and Python examples, tho’

$ cat ./yu_li_yan_p126.py
#!/usr/bin/python
import re

fruits = ['apple', 'banana', 'cherry', 'orange', 'plum']
fruits_str = ‘ – ‘.join(fruits)
months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun']
days = [ 31, 28, 31, 30, 31, 30 ]
numbers = range(1, 7)
aoa = [ 'one', [ 'two', 'three' ], ‘four’, [ 'five', [ 'six', 'seven' ] ] ]

def show(label,object):
print ‘%10s: %s’ % (label, object)

# ok, recursion in python seems to suck big time,
# so here’s a fucked up iterative version ;-/
def flatten(arr):
i = 0
while i < len(arr):
while isinstance(arr[i], (list, tuple)):
if not arr[i]:
arr.pop(i)
if not len(arr):
break
else:
arr[i:i+1] = list(arr[i])
i += 1
return arr

show(‘join’, fruits_str)
show(’split’, fruits_str.split(‘ – ‘))
show(‘zip’, zip(months, days, numbers))
show(‘flatten’, flatten(aoa))
show(‘map’, map(lambda x: x**2, numbers))
show(‘reduce’, reduce(lambda x,y: x+y, numbers))
show(’select’, filter(lambda x: re.compile(“^[aeiou]“, re.I).match(x), fruits))
show(‘reject’, filter(lambda x: not re.compile(“^[aeiou]“, re.I).match(x), fruits))

$ ./yu_li_yan_p126.py
join: apple – banana – cherry – orange – plum
split: ['apple', 'banana', 'cherry', 'orange', 'plum']
zip: [('Jan', 31, 1), ('Feb', 28, 2), ('Mar', 31, 3), ('Apr', 30, 4), ('May', 31, 5), ('Jun', 30, 6)]
flatten: ['one', 'two', 'three', 'four', 'five', 'six', 'seven']
map: [1, 4, 9, 16, 25, 36]
reduce: 21
select: ['apple', 'orange']
reject: ['banana', 'cherry', 'plum']

once again, Perl only:

$ cat ./yu_li_yan_p126.pl
#!/usr/bin/perl
use warnings;
use strict;
use Data::Dumper ();
use List::Util qw(max reduce);
use vars qw($a $b);

my @fruits = qw(apple banana cherry orange plum);
my $fruits_str = join ‘ – ‘, @fruits;
my @months = qw(Jan Feb Mar Apr May Jun);
my @days = ( 31, 28, 31, 30, 31, 30);
my @numbers = ( 1 .. 6 );
my $aoa
= [ 'one', [ 'two', 'three' ], ‘four’, [ 'five', [ 'six', 'seven' ] ] ];

sub show {
printf “%10s: %s\n”,
shift,
Data::Dumper->new( [ \@_ ] )->Indent(0)->Terse(1)->Dump;
}

sub flatten { # it’s your job to flatten other kinds of refs
return map { ref $_ ? flatten(@$_) : $_ } @_;
}

sub zip {
map { my $i = $_; [ map { $_->[$i] } @_ ] } 0 .. max map { $#{$_} } @_;
}

show(‘join’, $fruits_str);
show(’split’, split / – /, $fruits_str);
show(‘zip’, zip(\@months, \@days, \@numbers));
show(‘flatten’, flatten($aoa));
show(‘map’, map { $_**2 } @numbers);
show(‘reduce’, reduce { $a + $b } @numbers);
show(’select’, grep { /^[aeiou]/i } @fruits);
show(‘reject’, grep { !/^[aeiou]/i } @fruits);

$ ./yu_li_yan_p126.pl
join: ['apple - banana - cherry - orange - plum']
split: ['apple','banana','cherry','orange','plum']
zip: [['Jan',31,1],['Feb',28,2],['Mar',31,3],['Apr',30,4],['May',31,5],['Jun',30,6]]
flatten: ['one','two','three','four','five','six','seven']
map: [1,4,9,16,25,36]
reduce: [21]
select: ['apple','orange']
reject: ['banana','cherry','plum']

(removed by Iulian, same problem occurred :-/)

++ IIRC PHP’s functions are not as flexible as everyone else’s (and looking at array_combine’s spec seems to prove it).

++ Python has a different opinion about “zipping”, truncating the list of tuples to the length of the shortest argument.

It’s a boring Sunday, so let’s give your readers some more examples (using your use cases)…

$ cat ./yu_li_yan_p126.rb
#!/usr/bin/ruby

fruits = %w(apple banana cherry orange plum);
fruits_str = fruits.join(‘ – ‘);
months = %w(Jan Feb Mar Apr May Jun);
days = [ 31, 28, 31, 30, 31, 30];
numbers = (1..6).to_a;
aoa = [ 'one', [ 'two', 'three' ], ‘four’, [ 'five', [ 'six', 'seven' ] ] ];

def show(label, object)
printf “%10s: %s\n”, label, object.inspect
end

show(‘join’, fruits_str);
show(’split’, fruits_str.split(‘ – ‘));
show(‘zip’, months.zip(days, numbers));
show(‘flatten’, aoa.flatten);
show(‘map’, numbers.map {|x| x**2});
#show(‘reduce’, numbers.reduce(:+)); # needs v1.8.7
show(‘reduce’, numbers.inject {|x,y| x+y});
#show(’select’, fruits.select {|x| x =~ /^[aeiou]/i});
show(’select’, fruits.grep(/^[aeiou]/i));
#show(‘reject’, fruits.reject {|x| x =~ /^[aeiou]/i});
show(‘reject’, fruits.grep(/^[^aeiou]/i));

$ ./yu_li_yan_p126.rb
join: “apple – banana – cherry – orange – plum”
split: ["apple", "banana", "cherry", "orange", "plum"]
zip: [["Jan", 31, 1], ["Feb", 28, 2], ["Mar", 31, 3], ["Apr", 30, 4], ["May", 31, 5], ["Jun", 30, 6]]
flatten: ["one", "two", "three", "four", "five", "six", "seven"]
map: [1, 4, 9, 16, 25, 36]
reduce: 21
select: ["apple", "orange"]
reject: ["banana", "cherry", "plum"]

$ cat ./yu_li_yan_p126.py
#!/usr/bin/python
import re

fruits = ['apple', 'banana', 'cherry', 'orange', 'plum']
fruits_str = ‘ – ‘.join(fruits)
months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun']
days = [ 31, 28, 31, 30, 31, 30 ]
numbers = range(1, 7)
aoa = [ 'one', [ 'two', 'three' ], ‘four’, [ 'five', [ 'six', 'seven' ] ] ]

def show(label,object):
print ‘%10s: %s’ % (label, object)

# ok, recursion in python seems to suck big time,
# so here’s a fucked up iterative version ;-/
def flatten(arr):
i = 0
while i new( [ \@_ ] )->Indent(0)->Terse(1)->Dump;
}

sub flatten { # it’s your job to flatten other kinds of refs
return map { ref $_ ? flatten(@$_) : $_ } @_;
}

sub zip {
map { my $i = $_; [ map { $_->[$i] } @_ ] } 0 .. max map { $#{$_} } @_;
}

show(‘join’, $fruits_str);
show(’split’, split / – /, $fruits_str);
show(‘zip’, zip(\@months, \@days, \@numbers));
show(‘flatten’, flatten($aoa));
show(‘map’, map { $_**2 } @numbers);
show(‘reduce’, reduce { $a + $b } @numbers);
show(’select’, grep { /^[aeiou]/i } @fruits);
show(‘reject’, grep { !/^[aeiou]/i } @fruits);

$ ./yu_li_yan_p126.pl
join: ['apple - banana - cherry - orange - plum']
split: ['apple','banana','cherry','orange','plum']
zip: [['Jan',31,1],['Feb',28,2],['Mar',31,3],['Apr',30,4],['May',31,5],['Jun',30,6]]
flatten: ['one','two','three','four','five','six','seven']
map: [1,4,9,16,25,36]
reduce: [21]
select: ['apple','orange']
reject: ['banana','cherry','plum']

$ cat ./yu_li_yan_p126.js
// use JS v1.8 please, I’m too lazy
fruits = ['apple', 'banana', 'cherry', 'orange', 'plum']
fruits_str = fruits.join(‘ – ‘)
months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun']
days = [ 31, 28, 31, 30, 31, 30]
numbers = [ 1, 2, 3, 4, 5, 6]
aoa = [ 'one', [ 'two', 'three' ], ‘four’, [ 'five', [ 'six', 'seven' ] ] ]

function inspect(object) {
if(typeof object == “undefined”) return ‘undefined’;
if(object === null) return ‘null’;
if(typeof object == “number”) return object
if(object instanceof Array)
return ‘[' + object.map(inspect).join(', ') + ']‘;
return “‘” + object + “‘”;
}

function show(label, object) {
label = new Array(11 – label.length).join(‘ ‘) + label + ‘:’;
print(label, inspect(object));
}

function flatten(x) {
var ret = [];
x.forEach( function(i) {
ret = ret.concat(i instanceof Array ? flatten(i) : [i]);
});
return ret;
}

function zip() {
var arrays = Array.prototype.slice.apply(arguments, [0]);
var max = Math.max.apply( null, arrays.map(function(x) x.length) );
var ret = [];
for(var i=0; i < max; i++)
ret.push(arrays.map(function(x) x[i]));
return ret;
}

show(‘join’, fruits_str)
show(’split’, fruits_str.split(‘ – ‘))
show(‘zip’, zip(months, days, numbers));
show(‘flatten’, flatten(aoa))
show(‘map’, numbers.map(function(x) x*x))
show(‘reduce’, numbers.reduce(function(x,y) x+y))
show(’select’, fruits.filter(function(x) x.match(/^[aeiou]/i)))
show(‘reject’, fruits.filter(function(x) !x.match(/^[aeiou]/i)))

$ js ./yu_li_yan_p126.js
join: ‘apple – banana – cherry – orange – plum’
split: ['apple', 'banana', 'cherry', 'orange', 'plum']
zip: [['Jan', 31, 1], ['Feb', 28, 2], ['Mar', 31, 3], ['Apr', 30, 4], ['May', 31, 5], ['Jun', 30, 6]]
flatten: ['one', 'two', 'three', 'four', 'five', 'six', 'seven']
map: [1, 4, 9, 16, 25, 36]
reduce: 21
select: ['apple', 'orange']
reject: ['banana', 'cherry', 'plum']

Hopefully, your blogging software won’t funk up the above code too much

Ah, and my apologies to the other languages, I’m too lazy

cheers

More explanations from Iulian: This computes the sum of all the numbers in the array. The thing between curly braces is a “block”, which for all practical purposes is a function. The function has two arguments and gets called for each item of the array. The first param, called “sum”, is the value accumulated so far. That’s why they call it “accumulator” in general. The second param is the current item in the array.

using join :

the same thing with uppercase characters, using map {}