web-dev-qa-db-fra.com

Comment générer un ensemble de puissance d'un ensemble donné?

J'étudie pour une entrevue et je suis tombé sur cette question en ligne dans la catégorie "Math".

Générer un ensemble de puissance d'un ensemble donné:

int A[] = {1,2,3,4,5};  
int N = 5; 
int Total = 1 << N;
for ( int i = 0; i < Total; i++ ) { 
 for ( int j = 0; j < N; j++) {
  if ( (i >> j) & 1 ) 
      cout << A[j]; 
   } 
 cout <<endl;

 }

S'il vous plaît, je ne veux pas de réponse explicite. Je veux juste des éclaircissements et des conseils sur la façon d'aborder ce problème.

J'ai vérifié l'algorithme de réglage de l'alimentation sur google et je ne comprends toujours pas comment résoudre ce problème.

Aussi, quelqu'un pourrait-il répéter ce que la question demande.

Je vous remercie.

algorithmmathpowerset
12
Ralph

Power set of a set A is the set of all of the subsets of A. 

Ce n'est pas la définition la plus conviviale au monde, mais un exemple aidera:

Par exemple. pour {1, 2}, les sous-ensembles sont les suivants: {}, {1}, {2}, {1, 2}

Ainsi, le jeu de puissance est {{}, {1}, {2}, {1, 2}}

Pour générer le jeu de puissance, observez comment vous créez un sous-ensemble: vous accédez à chaque élément un par un, puis vous le conservez ou vous l'ignorez.

Laissez cette décision être indiquée par un peu (1/0).

Ainsi, pour générer {1}, vous allez choisir 1 et abandonner 2 (10).

Sur des lignes similaires, vous pouvez écrire un vecteur de bits pour tous les sous-ensembles: 

  • {} -> 00
    {1} -> 10
    {2} -> 01
    {1,2} -> 11

Pour réitérer: Un sous-ensemble s'il est formé en incluant tout ou partie des éléments de l'ensemble d'origine. Ainsi, pour créer un sous-ensemble, accédez à chaque élément, puis décidez de le conserver ou de le supprimer. Cela signifie que pour chaque élément, vous avez 2 décisions. Ainsi, pour un ensemble, vous pouvez vous retrouver avec 2^N décisions différentes, correspondant à 2^N sous-ensembles différents.

Voyez si vous pouvez aller le chercher d'ici.

18
axiom

L'ensemble de puissance est juste l'ensemble de tous les sous-ensembles pour l'ensemble donné. Il comprend tous les sous-ensembles (avec ensemble vide). Il est bien connu qu'il y a 2N éléments de cet ensemble, où N est le nombre d'éléments de l'ensemble d'origine.

Pour construire un ensemble de puissance, on peut utiliser ce qui suit:

  • Créer une boucle, qui itère tous les nombres entiers de 0 à 2N-1
  • Passer à la représentation binaire pour chaque entier
  • Chaque représentation binaire est un ensemble de N bits (pour les nombres plus petits, ajoutez des zéros non significatifs). Chaque bit correspond, si le membre de certains ensembles est inclus dans le sous-ensemble actuel.

Exemple, 3 nombres: a, b, c

number binary  subset
0      000      {}
1      001      {c}
2      010      {b}
3      011      {b,c}
4      100      {a}
5      101      {a,c}
6      110      {a,b}
7      111      {a,b,c}
9
Alma Do

Créez un ensemble de puissance de: {"A", "B", "C"}.

Pseudo-code: 

val set = {"A", "B", "C"}

val sets = {}

for item in set:
  for set in sets:
    sets.add(set + item)
  sets.add({item})
sets.add({})

Explication de l'algorithme:

1) Initialisez sets dans un ensemble vide: {}.

2) Itérer sur chaque élément dans {"A", "B", "C"}

3) Parcourez chaque set de votre sets.

3.1) Créez un nouvel ensemble qui est une copie de set.

3.2) Ajoutez la item au new set.

3.3) Ajoutez le new set à sets.

4) Ajoutez la item à votre sets.

4) L'itération est terminée. Ajoutez le jeu vide à votre resultSets.

Procédure pas à pas:

Regardons le contenu de sets après chaque itération:

Itération 1, item = "A":

sets = {{"A"}}

Itération 2, item = "B":

sets = {{"A"}, {"A", "B"}, {"B"}}

Itération 3, item = "C":

sets = {{"A"}, {"A", "B"}, {"B"}, {"A", "C"}, {"A", "B", "C"}, {"B", "C"}, {"C"}}

Itération terminée, ajouter un ensemble vide:

sets = {{"A"}, {"A", "B"}, {"B"}, {"A", "C"}, {"A", "B", "C"}, {"B", "C"}, {"C"}, {}}

La taille des ensembles est de 2 ^ | set | = 2 ^ 3 = 8 ce qui est correct.

Exemple d'implémentation en Java: 

public static <T> List<List<T>> powerSet(List<T> input) {
  List<List<T>> sets = new ArrayList<>();
  for (T element : input) {
    for (ListIterator<List<T>> setsIterator = sets.listIterator(); setsIterator.hasNext(); ) {
      List<T> newSet = new ArrayList<>(setsIterator.next());
      newSet.add(element);
      setsIterator.add(newSet);
    }
    sets.add(new ArrayList<>(Arrays.asList(element)));
  }
  sets.add(new ArrayList<>());
  return sets;
}

Entrée: [A, B, C]

Sortie: [[A], [A, C], [A, B], [A, B, C], [B], [B, C], [C], []]

7
Cristian

Eh bien, vous devez générer tous les sous-ensembles. Pour un ensemble de taille n, il y a 2n sous-ensembles.

Une solution serait de parcourir les nombres de 0 à 2n - 1 Et convertissez-les chacun en une liste de chiffres binaires, où 0 signifie exclure Cet élément et 1 signifie l'inclure.

Une autre façon serait avec récursion, diviser et conquérir.

4
Tom Zych

Générer toutes les combinaisons d'un ensemble (en incluant ou non un article). expliquer par l'exemple: 3 éléments dans un ensemble (ou une liste). Le sous-ensemble possible sera:

000   
100   
010   
001
110
101
011
111

Le résultat est 2 ^ (nombre d'éléments dans l'ensemble).

En tant que tel, nous pouvons générer toutes les combinaisons de N éléments (avec python) comme suit:

def powerSet(items):

    N = len(items)

    for i in range(2**N):

        comb=[]
        for j in range(N):
            if (i >> j) % 2 == 1:
                comb.append(items[j])
        yield comb

for x in powerSet([1,2,3]):
    print (x)
3
Amjad

Vous obtenez quelque chose comme ça en mettant en œuvre la réponse la mieux notée. 

def printPowerSet(set,set_size):

    # set_size of power set of a set
    # with set_size n is (2**n -1)
    pow_set_size = (int) (math.pow(2, set_size));
    counter = 0;
    j = 0;

    # Run from counter 000..0 to 111..1
    for counter in range(0, pow_set_size):
        for j in range(0, set_size):

            # Check if jth bit in the 
            # counter is set If set then 
            # pront jth element from set 
            if((counter & (1 << j)) > 0):
                print(set[j], end = "");
        print("");
0
Carlson Bimbuh