generateur de combinaison - Page 1

donner un programme en c capable de determiner toute les combinaisons possibles a partir d'un ensemble de 4 valeur entieres donnees
exp 1.5.3 135 153 351 315 513 531
etendre pour traiter 5,6,7,8,9 valeurs distincts
peut on envisager une solution generique pour N valeurs?.?????

oui y a une formule de maths c'est c n p. c 3 10, ensuite c de la cuisine mathematique.

Alors.

1) non, les Cnp n'ont rien à voir là dedans, ils servent à calculer les combinaisons de n parmi p objets (ou l'inverse je me souviens jamais) alors que là chaque élément peut être différent.
2) on n'en cherche pas le nombre, mais la liste, donc de toutes façons même si c'était ça ça servirait à rien.

raja> déjà il faut que tu saches si toutes tes valeurs seront distinctes ou non (si elles le sont ça simplifie pas mal).
Après tu peux faire une simple récursion du type :
"toutes les combinaisons pour N valeurs c'est l'ensemble de toutes les combinaisons pour les N-1 valeurs, en mettant chaque valeur en premier".

genre là=>
"toutes les combinaisons pour 1 3 5" c'est :
- "toutes les combinaisons pour 3 5" avec un 1 devant
- "toutes les combinaisons pour 1 5" avec un 3 devant
- "toutes les combinaisons pour 1 3" avec un 5 devant

je pense qu'elles sont distinctes, il veut juste parler de la factorielle ^^
(et puis c un peu exagéré de dire que ça a rien à voir avec les Cnp, c'est très proche à ceci près qu'on fait attention à l'ordre des lettres : en l'occurrence c'est les Anp, avec p=n si on a autant de lettres possibles que de lettres dans le mot)

Comme je m'emmerdais j'ai réfléchi à une implémentation du problème de l'énumération

void permutations(int objects[], unsigned n)
{
	if (n == 1) {
		do_something();
		return;
	}

	for (unsigned i = 0; i < n; ++i)
	{
		swap(objects[0], objects[i]);
		permutations(&objects[1], n-1);
		swap(objects[0], objects[i]);
	}
}

(note : voir swap comme une fonction ou macro qui fait ce que le nom indique, j'ai pas détaillé pour plus de lisibilité)

presque

void swap(int *a, int *b)
{
	int temp=*b;
	*b=*a;
	*a=temp;
}

donc je corrige

void permutations(int objects[], unsigned n)
{
	if (n == 1) {
		do_something();
		return;
	}

	for (unsigned i = 0; i < n; ++i)
	{
		swap(&objects[0], &objects[i]);
		permutations(&objects[1], n-1);
		swap(&objects[0], &objects[i]);
	}
}

sinon tu swappes pas gd chose

pardon pour l'up #shy#

qui te dit que spectras ne sous-entendait pas que swap() était une macro, ou encore que c'était le swap() standard de la STL ? (qui échange deux T&, et pas le contenu de deux T*)

oui, bon , ça va hein pas la peine de sla peter hein

squalyl^2 :
pas la peine de sla peter hein

euh, c'est un peu le monde à l'envers là, c'est toi qui te la pétais en disant à spectras "ha ha tu t'es trompé, voilà la correction", alors que ce qu'il avait écrit était tout à fait correct

et je vois pas bien en quoi je me la pète en expliquant ce que spectras pouvait avoir en tête

tu sais très bien que je débarque en c++ (que je découvre tout seul de plus) alors pas la peine de me sortir des détails de la STL ou autre que je ne connais pas encore (ou alors que de nom)

au moins tu pourrais présenter 'tu sais il existe autre chose' plutot que 't'es nul tu connais même po la stl'

pffou, la remarque sur la STL n'était pas destinée particulièrement à toi... (et la parenthèse encore moins, c'est juste un rappel au cas où, perso je me souvenais plus vraiment de ce que faisait swap() donc j'ai dû vérifier que ça prenait bien des T& et pas des T*, d'où ma parenthèse qui aurait pu être utile à qqun dans le même cas que moi)

ok

d'ailleurs pour continuer dans le constructif, T& ça fait quoi par rapport à T*? quand j'ai vu ça j'ai eu peur (y'a quelques mois)

T& est la référence sur l'objet T,
T* en est son pointeur

la principale différence est que T& implique que T existe et qu'il n'y a pas d'indirection, tu travailles sur les références comme tu ferais sur les objets

ha

je vois pas trop

v trouver un exemple

quand tu écris "T& x;" en fait c'est juste un "T* const y;" déguisé...

par exemple

T& x = ma_variable;
x++;
x = x.plop();

est strictement équivalent à

T* const y = &ma_variable;
(*y)++;
*y = (*y).plop(); // ou y->plop(), c'est pareil

ou encore à

ma_variable++;
ma_variable = ma_variable.plop();

ok c'est un pointeur constant déja déréférencé

quelle est l'utilisation pratique?

- Ecrire du code plus lisible
- Rendre le passage d'une adresse ou de la valeur transparent au programme appelant (donc changeable sans avoir à modifier le source des programmes appelant)
- Supprimer des possibilités de bugs (une référence est toujours définie contrairement à un pointeur qui peut pointer sur n'importe quoi)

(anticipation anti-pollux : effectivement on peut arriver à faire une référence sur un truc bidon mais faut vraiment le vouloir)

Je crois que c'est pour limiter l'utilisation des pointeurs parce que les pointeurs c'est trop bas niveau pour le C++.
Malheureusement, leur utilisation reste indispensable, et puis l'utilisation des références n'est vraiment pas agréable en C++, donc au final, ce n'est pas terrible.
Je trouve que Java est bien plus joli de ce côté là...
Bref, l'utilisation pratique, c'est par exemple :

void incrementer(int& a)
{
  a++;
}

void foo()
{
  int variable = 0;
  incrementer(variable);
  // variable vaut maintenant 1 ! Et tout ça sans passer par des pointeurs. Ce serait impossible en C pur (et sans macro).
}

Sasume :
Et tout ça sans passer par des pointeurs

enfin si, mais tu caches le pointeur en écrivant "byref a as integer" (bof)

Sasume
: l'utilisation des références n'est vraiment pas agréable en C++, donc au final, ce n'est pas terrible.

gni ?
qu'est-ce que tu reproches aux références ?

allez c'est parti, fight

nEUr00 > ceci :

class A
{
  B& b;
};

Ce code n'est pas valide. Je sais que c'est par mesure de sécurité, pour ne pas avoir de référence ne désignant aucun objet, mais au final ça fait qu'on est obligé de passer par des pointeurs pour tout ce qui est allocation dynamique.
Aussi, je trouve dommage que les objets soient implicitement passés par valeur, ce qui oblige à écrire des prototypes de fonctions du genre :
void foo(const T& bar);
Qui finalement ne sont pas vraiment très agréables à lire.

En fait, j'avoue que si le C++ n'avait pas ajouté le mécanisme des références par rapport au C, ce serait pire. Donc c'est sûr que ce qui est là est mieux que rien.
Mais le must, je trouve, ce de repartir sur des bases saines plutôt que de "surcoucher" le C, et de faire du Java (ou peut-être du C#, je ne connais pas).

je trouve aussi, mais on me dit que ça sux a cause de la machine virtuelle

Ça sux surtout parce que ça reprend 90% de la syntaxe pourrie du C

L'intérêt des références, c'est entre autres que ça harmonise la syntaxe entre objet alloué localement (std::string ma_chaine) et objet déclaré et/ou alloué en dehors de la fonction, dont on prendrait une référence (par exemple un paramètre de type std::string&) ^^


Sasume>

ben si tu veux pouvoir modifier le pointeur, c'est normal que tu puisses pas en faire un T&... sinon après pour pouvoir modifier le T& en question (en le passant par exemple à ta fonction incrementer()) il faudrait que T&& soit un type valide, et là ça poserait évidemment une montagne de problèmes ^^ (est-ce qu'une affectation doit modifier ce vers quoi pointe le T& ou est-ce qu'elle doit appeler operator=() sur le T ? dans chacun des deux cas tu casserais une propriété importante des références)
C'est pour ça que T& n'est pas véritablement un type à part entière comme T*, du point de vue du typage c'est plutôt un T avec un petit qqch en plus (d'ailleurs c'est effectivement un T, tu peux l'utiliser partout où on attend un paramètre de type T) Si tu veux avoir la flexibilité d'un pointeur modifiable, il faut que les indirections soient explicites, donc il faut utiliser un pointeur type C ou une classe de type "smart pointer"... Si tu n'as pas besoin de cette flexibilité, les références sont faites pour

Sasume :
nEUr00 > ceci :

class A
{
  B& b;
};

Ce code n'est pas valide.

Non, mais celui-ci l'est :

class A
{
  B & b;
  A(B & x) : b(x) {}
};

squalyl^2 :
je trouve aussi, mais on me dit que ça sux a cause de la machine virtuelle

Bof, il y a un petit temps d'attente au lancement, puis après, ça tourne bien je trouve...
Enfin, je n'ai peut-être pas testé des applications trop gourmandes.
Bon, j'avoue que NetBeans par exemple est assez lourd à utiliser. Mais est-ce parce qu'il a été écrit en Java ? C'est vraiment un IDE très puissant...

Sally :
Ça sux surtout parce que ça reprend 90% de la syntaxe pourrie du C

Houlà, ça c'est encore un autre débat...
Perso je trouve que c'est plutôt un avantage, ça permet de passer plus facilement du C au Java.

oui, netbeans est écrit en java

T'as encore rien compris...