function array_unique(a)
{
    return a.reduce(function(u, e)
    {
        if(!(e in u))
            u.push(e);

        return u;
    }, []);
}

00  SS Cast

01  Take   1600   SS Up (2000 left)
02  --
03  Absorb 1600   SS Up (400 left)
04  --
05  Absorb 400    SS Down
    Take   1200
06  --

07  Take   1600   SS Up (2000 left)
08  --
09  Absorb 1600   SS Up (400 Left)
10  --
11  Absorb 400    SS Down
    Take   1200  
12  --

<?php

    // Create an 'anonymous' function without specifying arguments.
    // Arguments are considered to be named $a to $z
    function λ($body)
    {
        $args = '';
        if(preg_match_all('#(\$[a-z])\b#', $body, $matches, PREG_SET_ORDER) !== 0)
        {
            $allArgs = array();
            foreach($matches as $match)
            {
                $allArgs[] = $match[1];
            }
            $allArgs = array_unique($allArgs);
            sort($allArgs);
            $args = implode(',', $allArgs);
        }

        // Make sure it's terminated (we don't care about extra trailing ';')
        return create_function($args, $body . ';');
    }


    // Creating
    $multiply = λ('return $a * $b');
    echo "23 * 65 = " . $multiply(23, 65) . "\n";

    // Only $a to $z are reserved
    $bSquaredByA = λ('$unused = "Hello"; $b_square = $b * $b; return $b_square * $a');
    echo "8 * 6^2 = " . $bSquaredByA(8, 6) . "\n";

    // Embedding in strings
    $square      = λ('return $a * $a');
    $numbers     = array(2,4,8);
    foreach($numbers as $num)
    {
      echo "$num * $num = {$square($num)}\n";
    }

    // Note you don't have to use $a for your first argument, and $b for your second.  They just
    // Need to be in the right order
    $print_two_things = λ('echo "Second: " . $y . "\n"; echo "First: " . $d . "\n";');
    $print_two_things("Hello", "World!");

    // Practical use
    $numbers     = array(1,1,1,2,2,3,3,3,4,5,5,6,7,8,9);
    $above_three = array_filter($numbers, λ('return $x > 3;'));
    echo "Numbers above three =  " . implode(", ", $above_three) . "\n";    

?>

function mapSort(array, mapFunction, sortFunction)
{
    // Store both original value, and transformed value
    var mapData = array.map(function(e)
    {
        return [e, mapFunction(e)];
    });

    // Sort the data using the second element of each array item (the mapped one)
    var sortedData = mapData.sort(function(a, b)
    {
        return sortFunction(a[1], b[1]);
    });

    // Remove the extra transformed value from the sorted array
    return sortedData.map(function(e)
    {
        return e[0];
    });
}

// Example

var data = ["a", "b", "A", "B", "C", "c"];
var cmp  = function(a, b) { return a > b; };
var map  = function(ch) { return ch.toLowerCase(); };

print("Normal:   " + data.sort(cmp));
print("Map Sort: " + mapSort(data, map, cmp));

// Normal:   A,B,C,a,b,c
// Map Sort: a,A,B,b,c,C

<?php

    error_reporting(E_ALL);

    // Return an array of all the days in a month grouped by week number
    // (Sunday is considered to be the first day of the week)
    function weeksInMonth($month, $year)
    {
        $firstDay    = mktime(0, 0, 0, $month, 1, $year);
        $daysInMonth = date('t', $firstDay);

        $week        = 1;
        $breakdown   = array();

        for($i = 1; $i <= $daysInMonth; $i++)
        {
            $date = mktime(0, 0, 0, $month, $i, $year);
            $day  = date('l', $date);

            // Sunday triggers the start of a new week, except if it's
            // also the first day of the month.
            if(($day == 'Sunday') && ($i != 1))
            {
                $week++;
            }

            $breakdown[$week][] = $date;
        }

        return $breakdown;
    }


    $results = monthToWeek(6, 2008);

    printf("There are %d weeks in June 2008\n\n", count($results));

    foreach($results as $weekNumber => $days)
    {
        printf("Week %d\n", $weekNumber);

        foreach($days as $day)
        {
            printf("%10s  %s\n", date("l", $day), date("Y-m-d", $day));
        }

        printf("\n");
    }

/*
There are 5 weeks in June 2008

Week 1
    Sunday  2008-06-01
    Monday  2008-06-02
   Tuesday  2008-06-03
 Wednesday  2008-06-04
  Thursday  2008-06-05
    Friday  2008-06-06
  Saturday  2008-06-07

Week 2
    Sunday  2008-06-08
    Monday  2008-06-09
   Tuesday  2008-06-10
 Wednesday  2008-06-11
  Thursday  2008-06-12
    Friday  2008-06-13
  Saturday  2008-06-14

Week 3
    Sunday  2008-06-15
    Monday  2008-06-16
   Tuesday  2008-06-17
 Wednesday  2008-06-18
  Thursday  2008-06-19
    Friday  2008-06-20
  Saturday  2008-06-21

Week 4
    Sunday  2008-06-22
    Monday  2008-06-23
   Tuesday  2008-06-24
 Wednesday  2008-06-25
  Thursday  2008-06-26
    Friday  2008-06-27
  Saturday  2008-06-28

Week 5
    Sunday  2008-06-29
    Monday  2008-06-30
*/
?>

#!/usr/bin/python

import sys
import random
import time
import os
import copy

WIDTH = 32
HEIGHT = 16

class Grid:
    def __init__(self, width, height):
        self.width  = width
        self.height = height
        self.create_blank_grid()

    def create_blank_grid(self):
        self.grid = []

        for x in range(0, self.width):
            self.grid.append([0 for y in range(0, self.height)])

    def seed(self, chance = 0.4):
        for x in range(0, self.width):
            for y in range(0, self.height):
                if random.random() < chance:
                    self.grid[x][y] = 1
                else:
                    self.grid[x][y] = 0

    def add_glider(self):
        self.grid[1][0] = 1
        self.grid[2][1] = 1
        self.grid[0][2] = 1
        self.grid[1][2] = 1
        self.grid[2][2] = 1


    def __str__(self):
        buffer = ''

        for y in range(0, self.height):
            for x in range(0, self.width):
                str = ' '
                if self.grid[x][y] == 1:
                    str = '#'

                buffer += str
            buffer += '\n';
        buffer += '\n';

        return buffer

    def get_number_neighbours(self, x, y):

        def get_value(i,j):
            try:
                return self.grid[i][j]
            except:
                return 0

        number_neighbours = get_value(x-1, y-1) + get_value(x, y-1)   + get_value(x+1, y-1) +  \
                            get_value(x-1, y)   +                       get_value(x+1, y)   +  \
                            get_value(x-1, y+1) + get_value(x, y+1)   + get_value(x+1, y+1)

        return number_neighbours


    def tick(self):
        new_grid = copy.deepcopy(self.grid)

        for x in range(0, self.width):
            for y in range(0, self.height):

                number_neighbours = self.get_number_neighbours(x,y)

                if self.grid[x][y] == 1:
                    if number_neighbours < 2:
                        new_grid[x][y] = 0
                    elif number_neighbours > 3:
                        new_grid[x][y] = 0
                else:
                    if number_neighbours == 3:
                        new_grid[x][y] = 1

        self.grid = new_grid

if __name__ == "__main__":
    grid = Grid(WIDTH, HEIGHT)
    # chance for a cell to be 'alive'
    grid.seed(0.2)
    # grid.add_glider()

    # 100 generations
    for x in range(0, 100):
        os.system('clear')
        print grid
        grid.tick()
        time.sleep(1)

<?php

// Perhaps the simplest practical use of a fold?
//
// (While this is fairly consise (even in PHP) it calculates the length of a
// string 2n-2 times [which is n-2 times more than needed])
function getLongestWord($words)
{
  $fun = create_function('$a,$b', 'return (strlen($a) > strlen($b)) ? $a : $b;');

  return array_reduce($words, $fun);
}

// This looks a little better, but it loses a lot of the simplicity of the above
function getLongestWord_2($words)
{  
  $map  = create_function('$a', 'return array($a, strlen($a));');
  $fold = create_function('$a,$b', 'return ($a[1] > $b[1]) ? $a : $b;');

  $word = array_reduce(array_map($map, $words), $fold);

  return $word[0];
}

$words = array('a', 'bb', 'ccc', 'dd', 'eeee', 'fff', 'gg');

var_dump(getLongestWord($words));
// string(4) "eeee"

var_dump(getLongestWord_2($words));
// string(4) "eeee"

?>