Discussion :

[pitchu]

Bonjour,
On considère un lancer de deux dés nommés : a, b. Calculer la probabilités de p(a=b)

J'ai utilisé dice(rolls = 2 ,ndice=2).
Je sais qu'il faut utiliser une loi uniforme discrète, punif.
Après, je ne sais pas comment faire en sorte de n'avoir que les probabilités de a=b.

[skeud]

On te demande de calculer les probabilités que a=b.

Donc si on prend deux dés à 6 facettes, on a 6 valeurs possibles pour chacun des dés.

Il suffit ensuite de générer tous les couple possibles, éliminer les doublons, puis voir pour combien de cas on a a=b.
Ensuite, tu fais une proportionalité sur le nombre de cas (a=b) / nombre total de cas. Et tu as ta réponse .

[skeud]

J'étais motivé et m'ennuyais un peu donc j'ai fait un petit programme qui calcule cette probabilité .
Bien sur ce programme ne devrait pas trop compiler lorsque tu le lances, c'est pour que tu aies une idée de ce qu'il faut faire.
De plus, j'utilise des concepts avancés de prog que tu n'as pas vus normalement, donc évite de le recopier tel quel pour le rendre à ton prof, tu te feras griller directement .

test2.cpp

Code c++ :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
struct coupleValeur
{
	int a;
	int b;
	struct coupleValeur* next;
	struct coupleValeur* prev;
};
 
void supprimeDoublon(struct coupleValeur* first)
{
	struct coupleValeur *liste = first;
	while (liste)
	{
		struct coupleValeur* it = liste->next;
		while (it)
		{
			if (it->a == liste->b && it->b == liste->a && it->a != it->b)
			{
				if (it->prev)
				{
					it->prev->next = it->next;
					it->next->prev = it->prev;
				}
			}
			it = it->next;
		}
		liste = liste->next;
	}
}
 
void afficherListe(struct coupleValeur* liste)
{
	while (liste)
	{
		std::cout << liste->a << "/" << liste->b << std::endl;
		liste = liste->next;
	}
}
 
int countEgal(struct coupleValeur* liste)
{
	int ret = 0;
	while (liste)
	{
		if (liste->a == liste->b)
			ret++;
		liste = liste->next;
	}
	return ret;
}
 
int count(struct coupleValeur* liste)
{
	int ret = 0;
	while (liste)
	{
		ret++;
		liste = liste->next;
	}
	return ret;
}
 
int main(int argc, char* argv[])
{
	int valMax = 1;
	int* valeur;
	valeur = new int[valMax];
	int i = 0;
	while (i < valMax)
	{
		valeur[i]=++i;
	}
	struct coupleValeur *listeValeur = 0;
	struct coupleValeur* current = 0;
	int ia = 0;
	int ib = 0;
	while (ia < valMax)
	{
		ib = 0;
		while (ib < valMax)
		{
			struct coupleValeur *elem = new coupleValeur;
			elem->next = 0;
			elem->prev = current;
			elem->a = valeur[ia];
			elem->b = valeur[ib];
			if (current == 0)
			{
				listeValeur = elem;
				current = elem;
			}
			else
			{
				current->next = elem;
				current = current->next;
			}
			ib++;
		}
		ia++;
	}
	supprimeDoublon(listeValeur);
	//afficherListe(listeValeur);
	int nbEgal = countEgal(listeValeur);
	int nb = count(listeValeur);
	std::cout << "probabilite que a == b est de " << (nbEgal*100)/nb << "%" << std::endl;
	system("PAUSE");
	return 0;
}

Par contre, tu peux utiliser ce programme pour vérifier que tu obtiens bien le même résultat et comparer ta suppression de doublon à la mienne afin de comprendre les principes de programmation que ton prof veut te faire apprendre au travers de cet exercice.

PS: J'étais curieux de voir les résultat sur les stats, je pensais que plus le dé pouvait prendre de valeurs, plus on avait de chances de faire un double. Et bah non Oo en fait c'est l'inverse .

EDIT: oups, je pensais que c'était dans la section C, me suis complètement planté sur ce coup là ^^. Tout étant que tu peux quand même utiliser ce programme pour vérifier les données ou comprendre le mécanisme ^^.

[pitchu]

Comment puis-je générer tous les cas possibles ?

[pitchu]

Pour générer tous les cas possibles, j'ai utilisé ça : plot.dice ( expand.grid(1:6,1:6),layout=c(6,6) )Pour les cas :
- a=b : ce sont tous les cas qui sont sur la diagonale p(a=b) = 6/36
- a<b : tous les cas en-dessous de la diagonale p(a<b) = 15/36
- a>b : tous les cas au-dessus de la diagonale p(a>b) = 15/36
Mais après, je ne sais pas comment retrouver ces résultats avec une commande.

[Theta]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
d=expand.grid(1:6,1:6)
sum(d[1]-d[2] == 0) / length(d[1])

Avec la fonction sum j'utilise le fait que R convertisse automatiquement les booléens en nombres (TRUE = 1, FALSE = 0).