// output of ./demo/comb/ksubset-twoclose-list-rec-demo.cc:
// Description:
//% k-subsets (kmin<=k<=kmax) in two-close order with homogeneous moves.
//% Representation as list of elements.
//% Recursive algorithm.

arg 1: 6 == n  [Subsets of n-element set.]  default=6
arg 2: 2 == kmin  [Minimal number of elements in subsets.]  default=2
arg 3: 4 == kmax  [Maximal number of elements in subsets.]  default=4
arg 4: 0 == w  [Whether to modify ordering (bool).]  default=0
   1;    1111..    { 0, 1, 2, 3 }
   2;    111.1.    { 0, 1, 2, 4 }
   3;    111...    { 0, 1, 2 }
   4;    111..1    { 0, 1, 2, 5 }
   5;    11..11    { 0, 1, 4, 5 }
   6;    11..1.    { 0, 1, 4 }
   7;    11....    { 0, 1 }
   8;    11...1    { 0, 1, 5 }
   9;    11.1..    { 0, 1, 3 }
  10;    11.1.1    { 0, 1, 3, 5 }
  11;    11.11.    { 0, 1, 3, 4 }
  12;    1.111.    { 0, 2, 3, 4 }
  13;    1.11..    { 0, 2, 3 }
  14;    1.11.1    { 0, 2, 3, 5 }
  15;    1.1.11    { 0, 2, 4, 5 }
  16;    1.1.1.    { 0, 2, 4 }
  17;    1.1...    { 0, 2 }
  18;    1.1..1    { 0, 2, 5 }
  19;    1...11    { 0, 4, 5 }
  20;    1...1.    { 0, 4 }
  21;    1....1    { 0, 5 }
  22;    1..1..    { 0, 3 }
  23;    1..1.1    { 0, 3, 5 }
  24;    1..11.    { 0, 3, 4 }
  25;    1..111    { 0, 3, 4, 5 }
  26;    ..1111    { 2, 3, 4, 5 }
  27;    ..111.    { 2, 3, 4 }
  28;    ..11..    { 2, 3 }
  29;    ..11.1    { 2, 3, 5 }
  30;    ..1.11    { 2, 4, 5 }
  31;    ..1.1.    { 2, 4 }
  32;    ..1..1    { 2, 5 }
  33;    ....11    { 4, 5 }
  34;    ...1.1    { 3, 5 }
  35;    ...11.    { 3, 4 }
  36;    ...111    { 3, 4, 5 }
  37;    .1..11    { 1, 4, 5 }
  38;    .1..1.    { 1, 4 }
  39;    .1...1    { 1, 5 }
  40;    .1.1..    { 1, 3 }
  41;    .1.1.1    { 1, 3, 5 }
  42;    .1.11.    { 1, 3, 4 }
  43;    .1.111    { 1, 3, 4, 5 }
  44;    .11.11    { 1, 2, 4, 5 }
  45;    .11.1.    { 1, 2, 4 }
  46;    .11...    { 1, 2 }
  47;    .11..1    { 1, 2, 5 }
  48;    .111..    { 1, 2, 3 }
  49;    .111.1    { 1, 2, 3, 5 }
  50;    .1111.    { 1, 2, 3, 4 }
ct=50