* Given some set with n members, generate all subsets with k members
* Code for best combined execution speed and elegance of code
* Language of your choice (speed comparison is among same language solutions only)
* Execution time does not include any output or use of resultant combinations

#!/usr/bin/php
<?php

/**
 * Specification:
 *
 * 1: Generate all k-combinations of integers in range 0 to n-1 (inclusive) for
 *      some k and n where 0 < k <= n
 * 2: Make execution time as low as possible.
 * 3: Make code as elegant as possible.
 * 4: The choice of programming language is yours.
 * 5: Use or output of combinations not included in determining execution speed
 *
 * The number of combinations is given by the function
 *
 *             n!
 * C(n,k) = --------
 *          k!(n-k)!
 *
 * Below is my solution in PHP - JASA 10/17/15.
 */
/*** Runtime confguration ***/
$n=36;          // Numbers to use in combination (0 to $n-1 inclusive).
$k=8;           // Combination length (0 < k <= n).
/*** End Runtime confguration ***/

// Newline.
define('NL',chr(10));

function fact($n)
{
/** Returns factorial of $n (n!). */
for($f=1;$n>1;--$n)
        $f*=$n;
return $f;
}

$e=(int)(fact($n)/
        (fact($k)*fact($n-$k))); // Expected number of combinations.
$x=0;           // Counter.
$c=$m=array();  // $c=combination array. $m=max values of elements
                // ($n-$k,$n-($k-1),$n-($k-2),...)

// Set $m and $c.
for($i=0;$i<$k;++$i)
        $m[$i]=$n-($k-($c[$i]=$i));
// Last value of combination.
$v=&$c[$k-1];

// Special case where k=1 we go straight to solution set
if($k==1)
        for(;$v<$n;++$v,++$x){
                //Comment out next line to suppress output of all combinations
                //echo join(' ',$c),NL;
                }
else
        // Start combinations (k>1).
        while(1){
                // Change last number of combination.
                for(;$v<$n;++$v,++$x){
                        //Comment out next line to suppress output of all combinations
                        //echo join(' ',$c),NL;
                        }

                // Adjust earlier values.
                for($i=$k-2;++$c[$i]>$m[$i]&&--$i>-1;)
                        ;

                // At end of combinations?
                if($i<0)
                        break;

                // Adjust later values (after $i) for next loop.
                while(++$i<$k)
                        $c[$i]=$c[$i-1]+1;
        }

// For $n=36 and $k=8 this should be 30260340.
echo 'Combinations: ',$x,NL;

// Correct number of combinations?
if($x!==$e)
        echo 'Wrong number of combinations (expected ',$e,', got ',$x,')!',NL;
?>

// command line: g++ -O3 -std=c++11 main.cpp
#include <iostream>
#include <vector>
#include <ctime>
#include <chrono>

std::vector<int> range;
std::vector<int> combination;

static int count = 0;

double factorial(double number){
    return number==1 ? number : number*factorial(number - 1);
}

void print(const std::vector<int>& combo) {
    for (size_t i = 0; i < combo.size(); ++i) {
        std::cout << combo[i] << " ";
    }
    std::cout  << std::endl;
}

void permute(int offset, int k) {
    if (k == 0) {
        ++count;
        //print(combination);  // uncomment to print combinations
        return;
    }
    for (size_t i = offset; i <= range.size() - k; ++i) {
        combination.push_back(range[i]);
        permute(i+1, k-1);
        combination.pop_back();
    }
}

int main() {
    auto start_time = std::chrono::high_resolution_clock::now();
    int n = 36;
    int k = 8;

    for (auto i = 0; i < n; ++i) {
        range.push_back(i+1);
    }
    permute(0, k);
    int possible = factorial(n) / (factorial(k)*factorial(n-k));
    if(count == possible) {
        std::cout << "The number of combinations is: " << count << std::endl;
    } else {
        std::cout << "Solution incorrect\n";
    }
    auto end_time = std::chrono::high_resolution_clock::now();
    auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time);
    std::cout << "Processing time= "<< double(elapsed.count()) <<" milliseconds"<< std::endl;
    return 0;
}

* Given some set with n members, generate all subsets with k members

#include <iostream>
#include <algorithm>
#include <vector>
#include <ctime>
#include <chrono>

void print(const std::vector<bool> &v, int n) {
    for (int i = 0; i < n; ++i) {
            if (v[i]) {
                std::cout << (i+1) << " ";
            }
        }
        std::cout << "\n";
}

int main() {
    auto start_time = std::chrono::high_resolution_clock::now();
    int n = 36;
    int k = 8;
    std::vector<bool> v(n);
    std::fill(v.begin() + n - k, v.end(), true);
    int count = 0;
    do {
        //print(v, n);
        ++count;
    } while (std::next_permutation(v.begin(), v.end()));
    std::cout << count << std::endl;
    auto end_time = std::chrono::high_resolution_clock::now();
    auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time);
    std::cout << "Processing time= "<< double(elapsed.count()) <<" milliseconds"<< std::endl;
    return 0;
}

#include <iostream>
#include <vector>
#include <stdio.h>

int comb(unsigned n, unsigned k) {
	// check arguments
        if (n < k || k < 1) return -1;

	// create data
	std::vector <unsigned> items;
	items.reserve(k);
	for (unsigned i = 0; i < k; i++) { items.push_back(i); }
	
	// start with the last of the k items
	unsigned which = k - 1;

	// get combinations
	for(;;) {
		// print current
		//for (unsigned i = 0; i < k; i++) { std::cout << items[i] << " "; }
		//std::cout << std::endl;

		// final state
		if (items[0] == n - k) { break; }

		
		while( (items[which] == n - 1 
			|| (which != k - 1 
				&& items[which + 1] == items[which] + 1))
		) { which--; }
	       	items[which]++;
		for (unsigned i = which + 1; i < k; i++) 
		{ items[i] = items[which]+i-which; }
		which=k-1;

	}

	return 0;
}

int main(int argc, char *argv[]) {
	unsigned n=36,k=8;
	comb(n,k);
	return 0;
}

#include <cmath>
...
int possible = ceil(factorial(n) / (factorial(k)*factorial(n-k)));

long int comb(unsigned n, unsigned k) {
	// check arguments
        long int count = 0;

	for(;;) {
                count++;
                ...
	}
	return count;
}

int main(int argc, char *argv[]) {
        ...
        std::cout << "Items: " << comb(n,k) << std::endl;
        ...
}

Given a set B with cardinality n
   and a constant k, 0 < k <= n

Find all sets A {A is proper subset of B, |A| = k}

Save SQL below to a file, mkset.sql then from mysql client with database seleted:
\. mkset.sql
............................................................
/* Create and populate universal set (table)
   Set the number of rows (cardinality of B) in the line...
    CALL mkset(rows);
*/
DELIMITER //
DROP TABLE IF EXISTS combo;
CREATE TABLE combo(id int primary key auto_increment);
DROP PROCEDURE IF EXISTS mkset;
CREATE PROCEDURE mkset(members INT)
BEGIN
SET @membs=members;
        REPEAT
                INSERT INTO combo SET id=NULL;
                SET @membs=@membs - 1;
        UNTIL @membs<=0 END REPEAT;
END
//
CALL mkset(36);
SELECT COUNT(*) as members FROM combo;

A = B X B X B X B X B X B X B X B
Where X represents restricted product operator

Save SQL below to a file, combo.sql then from mysql client with database seleted:
\. combo.sql
............................................................
SELECT
COUNT(*) as Combinations
-- OR uncomment 'k' columns below to see result rows
-- a.id, b.id, c.id, d.id, e.id, f.id, g.id, h.id
-- 'k' is the number of products, or JOINS
FROM combo a
JOIN combo b ON(b.id>a.id)
JOIN combo c ON(c.id>b.id)
JOIN combo d ON(d.id>c.id)
JOIN combo e ON(e.id>d.id)
JOIN combo f ON(f.id>e.id)
JOIN combo g ON(g.id>f.id)
JOIN combo h ON(h.id>g.id)
;

MariaDB [test]> \. combo.sql
+--------------+
| Combinations |
+--------------+
|     30260340 |
+--------------+
1 row in set (4 min 7.89 sec)

mysql> \. combo.sql
+--------------+
| Combinations |
+--------------+
|     30260340 |
+--------------+
1 row in set (1 min 36.27 sec)

#!/usr/bin/env perl

use strict; use warnings;
use Algorithm::Combinatorics qw(combinations);

my $start = time();

my @n = (1 .. 36);
my $k = 8;
my $iter = combinations(\@n, $k);
my $count = 0;
while (my $c = $iter->next) {
#        print "@$c\n";
    $count = $count +1;
}

my $end = time();
my $exec_time = $end - $start;
print "$count combinations in $exec_time seconds\n";

#!/usr/bin/python
import itertools 
import time

start = time.time()

iterable = range(1,37)
r = 8
y = 0;

for combo in itertools.combinations(iterable, r):
    #print combo
    y=y+1

print y," combinations in ",(time.time() - start)," seconds\n";

CREATE TABLE combo(id SERIAL);
INSERT INTO combo (id) VALUES(nextval('combo_id_seq')),... 36 times...;
...
# time psql testdb <combo.sql
 combinations
--------------
     30260340
(1 row)

real    1m19.934s
user    0m0.011s
sys     0m0.006s

sqlite3 dc-sqlite.db
CREATE TABLE combo(id INTEGER PRIMARY KEY AUTOINCREMENT);
INSERT INTO combo (id) VALUES(NULL),... 36 times ...;
...
# time sqlite3 -header dc-sqlite.db <combo.sql
Combinations
30260340

real    0m7.344s
user    0m7.255s
sys     0m0.007s