Q1. Ecrire un générateur en R générant T,le nombre total de vignettes Panini achetées pour avoir toute la collectionn en fonction de M, le nombre total de vignettes différentes.

Dans un premier temps, on génère une collection de M cartes, le collectioneur les achetant une à une, et l’éditeur étant supposé honnête, toutes les vignettes sont imprimés dans la même proportion et suivent donc une loi uniforme. On vérifie ensuite dans ce jeu de vignette minimal si on a toute la collection. Si ce n’est pas le cas, on “retourne en acheter”, jusqu’à toute les avoir. Une fois qu’on a toute la collection, on fait un bilan, et on regarde combien de cartes ont été nécessaires pour rassembler cette collection.

set.seed(42)# on fixe la seed pour avoir les mêmes valeurs en réinterprétant.

gen<-function(M=300){
  all<-FALSE
  vignettes <-c()
  i<-1
  
  #on "achète déjà M vignettes"
  while(i<=M){
  vignettes[i] <- round(runif(1,min=1,max=M),0)
  i<-i+1
  }
  
  # on regarde si on a toute la collection
  k<-1
  while(!all){
    if(is.na(match(k,vignettes))){ # il nous manque une vignette !
      vignettes[i]<-round(runif(1,min=1,max=M),0)
      i<-i+1
    }else{
       if(k==M){
        all<-TRUE # on les a toutes :)
        }else{
        k<-k+1
        }
    }
  }
  
  length(vignettes) # nombre total de vignettes achetées
}
gen(300)
## [1] 1439

Q2. Etudier expérimentalement la valeur moyenne de T en fonction de M . On prendra des échantillons de l’ordre de 100 ou 1000 et une dizaine de valeurs M entre 10 et 200.

i<-1
tab<-c()
v<- round(runif(1,min=10,max=200),0) #tirage aléatoire de la taille de M
while(i<=10){ # on effectue 10 exp independantes.
  tab[i]<-gen(v)
  i<-i+1
}
#Observations graphiques
par(mfrow=c(1,2))
hist(tab)
plot(tab[1:length(tab)-1],tab[2:length(tab)])

plot of chunk unnamed-chunk-2

Les points semblent uniformément répartis. On possède plusieurs doublons d’une même carte avant de réunir toute la collection de façon générale, comme le laissait penser la première question.

Q3. Quelles sont les hypothèses statistiques sur la suite des variables Xn que l’éenoncé suggère ?

n sera supérieur ou égal à M. On prend comme hypothèse que Xn est une Variable aléatoire discrète qui suit une loi uniforme, tout les Xn sont équiprobables.

Q4. Lorsque la collection comporte déjà i − 1 vignettes, on note Y i le nombre de vignettes à acheter pour avoir une vignette qui n’est pas dans la collection. Donner, en la justifiant, la loi de Y i (vous pourrez calculer la probabilité P (Y i = k) et vous en déduirez l’espérance et la variance de Y i ). Les variables Y i sont-elles indépendantes ? En déduire E(T ) et Var(T ) ainsi que des équivalents quant M est grand.

Tout d’abord, on a : P(Yi) = (M - ( i-1 )) / M , la probabilité d’obtenir une nouvelle vignette.

Donc : P(Yi=k) = probabilité qu’on a déjà ^ ( k - 1 ) * proba qu’on aie une nouvelle = (( i - 1) / M)^(k-1) * ( (M - ( i-1 )) / M) )

Espérance(Yi) = Somme ( Yi * P(Yi=k)) ( pour k de 1 à 300)

Espérance(Yi) = Pi * Somme ( Xi ) ( de 1 à 300)

L’espérance représente le nombre à acheter x (pour en avoir une nouvelle ) avec x * Pi >= 1

Q6. Au fait, combien votre petit cousin devra-t-il dépenser en moyenne sachant que chaque paquet de 2 euros contient 10 vignettes et que l’album comporte 300 places ?

On reprend l’algorithme de génération de la Q1, que l’on modifie légèrement pour ajouter la contrainte suivante : les cartes sont achetées par paquet de 10.

gen<-function(M=300,pas=10){
  all<-FALSE
  vignettes <-c()
  i<-1
  if(M%%pas==0){ # taille collection multiple du nb de vignettes/paquet
    mt <- M/pas
  }else{
    mt <-floor(M/pas)+1 #arrondi int inf , puis on ajoute un paquet pour completer.
  }
  
  # on génère les T cartes minimales pour espérer avoir une collection complète.
  while(i<=mt*pas){
  vignettes[i] <- round(runif(1,min=1,max=M),0)
  i<-i+1
  }
  
  # On regarde si on a toute la collection
  k<-1
  while(!all){
    if(is.na(match(k,vignettes))){ # il nous manque une vignette !
      n=1;
      while(n<=pas){ # on rachète un paquet
      vignettes[i]<-round(runif(1,min=1,max=M),0)
      i<-i+1
      n<-n+1
      }
    }else{
       if(k==M){
        all<-TRUE # on les a toutes :)
        }else{
        k<-k+1
        }
    }
  }
  
  length(vignettes) # nombre de vignettes totales achetées
}

# Prix moyen d'une collection de 300 vignettes, avec des paquets de 10 vignettes
moyenne_gen<-function(M=300,paquet=10,nb_try=25){
  i<-1
  s<-c()
  while(i<=nb_try){
    s[i]<-(gen(M,paquet)/(paquet))*2
    i<-i+1
  }
  mean(s)
}

le collectonneur devra dépenser en moyenne :

moyenne_gen(300,10,25)
## [1] 377.5

A raison de 2 € le paquet de 10 cartes.

Q7. On modifie l’algorithme de génération afin d’être dans un cas non uniforme. La probabilité pi d’obtenir la carte i est 1 / (alpha * i)

gen_mod1 <- function(M=300){
alpha<-0
k<-1
while(k<=M){
  alpha<-alpha+1/k
  k<-k+1
}
#à peu près 6,28
#On part sur une précision à 6 chiffres après la virgule
#proba(1) = 0.159168
#proba(2) = 0.079584
#tabproba(1) = proba(1) = 0.159168
#tabproba(2) = proba(1) + proba(2) = 0.238752
#Pour calculer plus facilement, on va multiplier ces probas par 1.000.000 (je sais pas à quel point le runif est précis après la virgule) et on fera un round à 0. Si on obtient un chiffre entre 1 et 159168, on a une vignette 1, entre 159168 et 238752 on a une vignette 2, et ainsi de suite.

tabproba<-c()
probactu<-0
j<-1
while(j<=M){
  probactu<-probactu+1/(alpha*j)
  tabproba[j]<-probactu*1000000
  j<-j+1
}

tmp<-0
all<-FALSE
trouve<-FALSE
vignettes <-c()
i<-1

while(i<=M){
  tmp <- round(runif(1,min=1,max=1000000),0)
  j<-0
  while(!trouve && !is.na(probactu[j+1])){
    j<-j+1
    if(tmp<=probactu[j]){
      trouve<-TRUE
    }
  }
  vignettes[i]<-j
  trouve<-FALSE
  i<-i+1
}
  
  k<-1
  while(!all){
    if(is.na(match(k,vignettes))){
      vignettes[i]<-round(runif(1,min=1,max=M),0)
      i<-i+1
    }else{
       if(k==M){
        all<-TRUE
        }else{
        k<-k+1
        }
    }
  }
  
  length(vignettes)
}

gen_mod1(300)
## [1] 2272

Q7. bis La probabilité pi d’obtenir la carte i vaut maintenant 1 / (alpha * i²)

gen_mod2 <- function(M=300){
alpha<-0

k<-1
while(k<=M){
  alpha<-alpha+1/(k*k)
  k<-k+1
}
#à peu près 6,28
#On part sur une précision à 6 chiffres après la virgule
#proba(1) = 0.159168
#proba(2) = 0.079584
#tabproba(1) = proba(1) = 0.159168
#tabproba(2) = proba(1) + proba(2) = 0.238752
#Pour calculer plus facilement, on va multiplier ces probas par 1.000.000 (je sais pas à quel point le runif est précis après la virgule) et on fera un round à 0. Si on obtient un chiffre entre 1 et 159168, on a une vignette 1, entre 159168 et 238752 on a une vignette 2, et ainsi de suite.

tabproba<-c()
probactu<-0
j<-1
while(j<=M){
  probactu<-probactu+1/(alpha*j*j)
  tabproba[j]<-probactu*1000000
  j<-j+1
}

tmp<-0
all<-FALSE
trouve<-FALSE
vignettes <-c()
i<-1

while(i<=M){
  tmp <- round(runif(1,min=1,max=1000000),0)
  j<-0
  while(!trouve && !is.na(probactu[j+1])){
    j<-j+1
    if(tmp<=probactu[j]){
      trouve<-TRUE
    }
  }
  vignettes[i]<-j
  trouve<-FALSE
  i<-i+1
}
  
  k<-1
  while(!all){
    if(is.na(match(k,vignettes))){
      vignettes[i]<-round(runif(1,min=1,max=M),0)
      i<-i+1
    }else{
       if(k==M){
        all<-TRUE
        }else{
        k<-k+1
        }
    }
  }
  
  length(vignettes)
}

gen_mod2(300)
## [1] 1711

On observe dans le 7bis que T ( nb vignette ) est plus petit que dans le cas 7, cela s’explique par le fait que les probas semblent plus uniformément réparties.

Q8.

Cette fois ci, pi vaut 1/ ( 2^i ). On s’attends donc à devoir en moyenne avoir besoin de moins de carte que dans les 2 précédants cas. Testons !

gen_mod3 <- function(M=300){
alpha<-0

k<-1
while(k<=M){
  alpha<-alpha+1/(2^k)
  k<-k+1
}
#à peu près 6,28
#On part sur une précision à 6 chiffres après la virgule
#proba(1) = 0.159168
#proba(2) = 0.079584
#tabproba(1) = proba(1) = 0.159168
#tabproba(2) = proba(1) + proba(2) = 0.238752
#Pour calculer plus facilement, on va multiplier ces probas par 1.000.000 (je sais pas à quel point le runif est précis après la virgule) et on fera un round à 0. Si on obtient un chiffre entre 1 et 159168, on a une vignette 1, entre 159168 et 238752 on a une vignette 2, et ainsi de suite.

tabproba<-c()
probactu<-0
j<-1
while(j<=M){
  probactu<-probactu+1/(alpha*(2^j))
  tabproba[j]<-probactu*1000000
  j<-j+1
}

tmp<-0
all<-FALSE
trouve<-FALSE
vignettes <-c()
i<-1

while(i<=M){
  tmp <- round(runif(1,min=1,max=1000000),0)
  j<-0
  while(!trouve && !is.na(probactu[j+1])){
    j<-j+1
    if(tmp<=probactu[j]){
      trouve<-TRUE
    }
  }
  vignettes[i]<-j
  trouve<-FALSE
  i<-i+1
}
  
  k<-1
  while(!all){
    if(is.na(match(k,vignettes))){
      vignettes[i]<-round(runif(1,min=1,max=M),0)
      i<-i+1
    }else{
       if(k==M){
        all<-TRUE
        }else{
        k<-k+1
        }
    }
  }
  
  length(vignettes)
}

gen_mod3(300)
## [1] 1873

C’est bien le cas :)

C’est encore plus lissé, l’écart entre les Pi est encore plus faible, on obtiendra nos cartes plus facilement.