Selectarea elementelor dintr-un număr necunoscut de seturi

Vreau să prezint toate combinațiile posibile care rezultă din selectarea a cel puțin unu și aproape toate elementele din fiecare set dintr-un număr (necunoscut) de seturi introduse de utilizator. Un element poate fi în mai multe seturi, dar o listă de mai multe ori nu este o problemă.

De exemplu: - Dacă utilizatorul introduce 3 seturi ca

{1,3,5}
{2,4}
{1} 

producție

1,2,1
1,4,1
1,2,4,1
3,2,1
3,4,1
3,2,4,1
5,2,1
5,4,1
5,2,4,1
1,3,2,1
1,3,4,1
1,3,2,4,1
1,5,2,1
1,5,4,1
1,5,2,4,1
3,5,2,1
3,5,4,1
3,5,2,4,1
1,3,5,2,1
1,3,5,4,1
1,3,5,2,4,1

Codul C# va fi chiar mai util. Mulțumiri.

0
Mulțumesc lui Mark. Abordarea ta pare bună
adăugat autor Dynamite, sursa
Se pare că doriți produsul cartesian al seturilor de putere ale setărilor dvs. de intrare, cu ridurile care nu vă interesează să includeți setul gol, care este, în mod oficial, un membru al setului de putere al oricărui set. Am subliniat doi termeni, o căutare pe SO va produce algoritmi, probabil și codul C#, pentru aceste operații.
adăugat autor High Performance Mark, sursa
În calitate de replică, mi-am transformat comentariul într-un răspuns, astfel încât să îl poți accepta - și să-i lași pe ceilalți colegi să-mi admire înțelepciunea sau să mestece pe buruienile amare de dezamăgire și să mă coboare.
adăugat autor High Performance Mark, sursa

4 răspunsuri

de F #

let rec comb n l =
  match n, l with
  | 0, _  -> [[]]
  | _, [] -> []
  | n, x::xs -> List.map (fun l -> x ::l) (comb (n - 1) xs) @ (comb n xs)

let powersets xs = seq {
    for i = 1 to List.length xs do
      for x in comb i xs -> x
  }

let rec powerset_out xs (acc:int list list) =
  if List.isEmpty xs then
    System.String.Join(",", seq { for el in acc do yield! el })
    |> printfn "%s"
  else
    let x::xs = xs
    for el in powersets x do
      powerset_out xs (acc @ [el])

Exemplu execuție:

> powerset_out [[1;3;5];[2;4];[1]] [];;
1,2,1
1,4,1
1,2,4,1
3,2,1
3,4,1
3,2,4,1
5,2,1
5,4,1
5,2,4,1
1,3,2,1
1,3,4,1
1,3,2,4,1
1,5,2,1
1,5,4,1
1,5,2,4,1
3,5,2,1
3,5,4,1
3,5,2,4,1
1,3,5,2,1
1,3,5,4,1
1,3,5,2,4,1
0
adăugat

Se pare că doriți cartesian produs din seturile de putere din seturile dvs. de intrare, cu ridurile care nu vă interesează să includeți setul gol, care este, în mod oficial, un membru al setului de putere al oricărui set. Am subliniat doi termeni, o căutare pe SO va produce algoritmi, probabil și codul C#, pentru aceste operații.

0
adăugat

somthing ca aceasta: (un set nu conține duplicate)

def permutate(set_to_perm, perm):
    Boolean used; 

    for elemen_set_  in set_to_perm:
        used = false

        for element_perm in perm
             if element_set_ == element_perm:
                 used = true;
                 break;
        if used false:
           if lengh(set_to_perm) < lenght(perm)
               permutate(set_to_perm, append element_set_ to perm)
           else:
               print per

take input from user;
set_to_perm = make a set from user input;
permutate(set_to_perm,[]):
0
adăugat

Puteți enumera toate seturile de care aveți nevoie cu un algoritm recursiv:

 current_set = { }

 enumerate (list_of_sets):
    if (list_of_sets is empty):
       REPORT current_set
    f = list_of_sets.front()
    r = list_of_sets.tail() /* all sets except f */
    n = f.size()
    for (i = 0 .. n - 1):
       current_set.insert(f[i])
       rec (f, i + 1, r)
       current_set.remove(f[i])

 rec (set, index, remaining_sets):
    if (index == set.size()):
       enumerate(remaining_sets)
    else:
       current_set.insert(f[index])
       rec(set, index + 1, remaining_sets)
       current_set.remove(f[index])
       rec(set, index + 1, remaining_sets)
0
adăugat