КИТА unofficial

    | a | b | c |
  1 |   |   |   |
  2 |   |   |   |
  . |   |   |   |
  . |   |   |   |
  n |   |   |   |

    | a | b | c |
  1 |   | v |   |
  2 | v |   | v |
  3 |   |   | v |
  4 | v |   |   |
  5 | v |   |   |

   static class Program
    {
        static IEnumerable<string> Combinations(this IEnumerable<string> table)
        {
            foreach (var result in
                from line in table.Count() > 1 ? table.Take(table.Count() - 1).Combinations() : new string[] { string.Empty }
                from character in table.Count() > 0 ? table.Last() : string.Empty
                select line + character)
                yield return result;
        }

        static void Main(string[] args)
        {
            foreach (string s in new string[] { "B", "AC", "C", "A", "A" }.Combinations())
                Console.WriteLine(s);
        }
    }

#light
printf "%A" (["B"; "AС"; "С"; "A"; "A"] 
|> Seq.fold (fun result current -> [for c in current do for s in result -> s + (string)c]) [""])

# Produces list of permutations of elements according to a set of rules.
#
# Rules determine which elements are acceptable in each position of a single
# permutation. First rule determines which elements are acceptable in the first
# position of a permutation, second rule -- to a second position, and so on.

def permutations(rules)
  rules.inject([[]]) { |solution, rule| apply_rule(solution, rule) }
end

# extends each element of solution with each element of a rule
def apply_rule(solution, rule) 
  rule.inject([]) do |acc, possible_value|
    acc.concat(append(possible_value, solution))
  end
end
# returns an array produced by prepending a +value+ to each element of
# +permutations+.
def append(value, permutations)
  permutations.map { |p| p.dup.push(value) }
end

RULES = [[   :x,   2],
   [   :x,    ],
   [1,   :x,  2],
   [   :x,    ]];

puts permutations(RULES).map {|p| p.inspect}.join("\n")