public static void subset_by_size_next(int n, ref int[] a, ref int subsize, ref bool more, ref bool more2, ref int m, ref int m2) //****************************************************************************80 // // Purpose: // // SUBSET_BY_SIZE_NEXT returns all subsets of an N set, in order of size. // // Example: // // N = 4: // // 1 2 3 4 // 1 2 3 // 1 2 4 // 1 3 4 // 1 3 // 1 4 // 2 3 // 1 // 2 // 3 // (the empty set) // // Discussion: // // The subsets are returned in decreasing order of size, with the // empty set last. // // For a given size K, the K subsets are returned in lexicographic order. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 09 June 2015 // // Author: // // John Burkardt // // Parameters: // // Input, int N, the size of the set. // // Input/output, int A[N]. The entries A(1:SUBSIZE) contain // the elements of the subset. The elements are given in ascending // order. // // Output, int &SUBSIZE, the number of elements in the subset. // // Input/output, bool &MORE. Set MORE = FALSE before first call // for a new sequence of subsets. It then is set and remains // TRUE as long as the subset computed on this call is not the // final one. When the final subset is computed, MORE is set to // FALSE as a signal that the computation is done. // // Input/output, bool &MORE2, a variable for bookkeeping. // The user should declare this variable, but need not initialize it. // The output value from one call must be the input value for the next. // // Input/output, int &M, &M2, variables for bookkeeping. // The user should declare this variable, but need not initialize it. // The output value from one call must be the input value for the next. // { switch (more) { case false: subsize = n; more = true; more2 = false; m = 0; m2 = 0; break; default: { switch (more2) { case false: subsize -= 1; break; } break; } } switch (subsize) { // // Compute the next subset of size SUBSIZE. // case > 0: Ksub.ksub_next(n, subsize, ref a, ref more2, ref m, ref m2); break; case 0: more = false; break; } }
public static void ksub_next_test() //****************************************************************************80 // // Purpose: // // KSUB_NEXT_TEST tests KSUB_NEXT. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 28 May 2015 // // Author: // // John Burkardt // { int[] a = new int[3]; int i; Console.WriteLine(""); Console.WriteLine("KSUB_NEXT_TEST"); Console.WriteLine(" KSUB_NEXT generates all K subsets of an N set"); Console.WriteLine(" in lexicographic order."); Console.WriteLine(""); int rank = 0; const int n = 5; const int k = 3; for (i = 0; i < k; i++) { a[i] = 0; } bool more = false; int m = 0; int m2 = 0; for (;;) { Ksub.ksub_next(n, k, ref a, ref more, ref m, ref m2); rank += 1; string cout = rank.ToString().PadLeft(4) + " "; for (i = 0; i < k; i++) { cout += a[i].ToString().PadLeft(4); } Console.WriteLine(cout); if (!more) { break; } } }