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).

[Sengar]

Hello,

Déjà le résultat c'est 1 sur le nombre de faces du dé, ça parait logique ^^"

Ensuite pour le retrouver empiriquement avec R :

Methode 1- Tu fais comme propose Theta en dénombrant tous les cas possibles.
Par contre attention il y a une petite erreur dans le script

Code :

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

1
2
3
4
<div class="cms_table"><table class="cms_table"><tr valign="top" class="cms_table_tr"><TD class="cms_table_td">d=expand.grid(1:6,1:6)
sum(d[,1]-d[,2] == 0) / length(d[,1])</TD>
</tr>
</table></div>

Méthode 2- En simulant la réalisation des lancers de dé : tu veux utiliser la loi uniforme si j'ai bien compris

Code :

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

1
2
3
4
5
6
7
8
 
<div class="cms_table"><table class="cms_table"><tr valign="top" class="cms_table_tr"><TD class="cms_table_td">#je simule 100 000 lancers de paires de dés (la j'ai transformé la loi uniforme pour qu'elle prenne des valeurs discretes de 1 à 6 avec floor). 
#puis je dénombre dans combien de cas le dé 1 = le dé 2 grace au table
 
table(floor(runif(100000,1,6.99999))==floor(runif(100000,1,6.99999)))/100000
#je retombe bien sur un sixième</TD>
</tr>
</table></div>

[pitchu]

Bonjour,
Quelle est la différence entre d[1] et d[,1] ?
Quand je tape d[1], àa m'affiche les résultats en colonne et d[,1] en ligne. Mais ça ne change rien au calcul quand j’enlève la virgule.

[Theta]

d[1] renvoie la première colonne de d sous forme de dataframe, d[[1]] ou d[,1] renvoient la première colonne sous forme d'un vecteur (d'integer ici).

Dans pas mal de cas ça ne change rien, car R convertit automatiquement les variables dans le type le mieux adapté.
Mais dans d'autres cas, ne pas avoir le bon type de variable entraine des erreurs ou des résultats inattendus. Par exemple length, appliqué à un dataframe renvoie le nombre de colonnes (soit 1 pour d[1]), alors qu'appliquée à un vecteur, elle renvoie le nombre de valeurs (soit 36 pour d[,1]).

Tu veux voir la classe d'un objet avec la fonction "class", c'est souvent utile pour déboguer un code, surtout vu que R n'est pas toujours hyper logique :

Code :

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

1
2
3
4
5
6
7
 
> class(d[,1])
[1] "integer"
> class(d[,c(1,2)])
[1] "data.frame"
> class(d[,NULL])
[1] "data.frame"

[pitchu]

ok, merci de vos aides