Il m’arrive parfois, dans de grand moments de solitude, de me trouver béat à l’adresse www.google.fr, perdu et sans trop savoir ce que je fais là. Je m’étonne alors de voir comment mon esprit pense à la manière de trouver une réponse avant même que je n’ai formulé ma question. Mais c’est une évolution de mon comportement qui est somme toute assez logique puisque quelque soit la question, 9 fois sur 10 c’est bien par google que j’obtiens la réponse.

C’est comme ça que j’explique que je puisse échouer sur google sans avoir rien à lui demander. Et parfois face au curseur qui clignote j’ai ce réflexe (simiesque ?) de taper des touches au hasard.

Même si quand on y réfléchit on est surement assez loin du hasard, je suis toujours impressionné par la capacité du moteur à renvoyer des résultats. Par exemple la recherche sdbxce renvoie 612000 résultats (65 si on recherche le terme exact). On constate néanmoins et c’est d’ailleurs assez évident, que le nombre de résultat diminue à chaque nouvelle lettre ajoutée.

La petite expérience du jour consiste donc à sonder un peu la monstruosité de l’index de Google en déterminant jusqu’à combien de lettre frappées au hasard le bestiau nous renvoie des résultats.
On peut bien sur faire ça à la main mais R a quelques avantages décisifs :

• Il est plus fort que nous pour simuler le hasard
• Il peut faire les recherches Google à notre place ce qui n’est pas sans intérêt sachant qu’on en a plusieurs centaines au programme…

Commençons donc par générer nos termes de recherche. Une matrice 100×15 : 100 réplications de mots de 1 à 15 caractères tirés au hasard.

nb.letters <- 15
nb.samp <- 100

req <- data.frame()
for (i in 1:nb.letters){
  for(j in 1:nb.samp){
    samp <- sample(letters, i, replace=T)
    req[j, i] <- paste(samp, collapse="")
  }
}

Maintenant voici une fonction qui lance une recherche Google à partir d’une chaîne de caractères et retourne le nombre de résultats renvoyés par le moteur. J’ai choisi de rechercher les termes exacts (recherche entre guillemets) car je trouvais ça plus parlant.

library (XML)
library(RCurl)

goonum <- function(q){
  Sys.sleep(runif(1))
  url <- paste("http://www.google.fr/search?aq=f&gcx=w&sourceid=chrome&ie=UTF-8&q=\"", q, "\"", sep="")
  gpage <- getURL(url)
  gpage <- htmlParse(gpage)
  nbres <- xpathApply(gpage, "//div[@id='resultStats']", xmlValue)
  nbres.num <- unlist(gregexpr("[0-9]", nbres))
  nbres.val <- vector()
  for(i in 1:length(nbres.num)) 
    {nbres.val[i] <- substr(nbres, nbres.num[i], nbres.num[i])}
  nbres.val <- as.numeric(paste(nbres.val, collapse=""))
  nbres.val <- ifelse(is.na(nbres.val), 0, nbres.val)
  return(nbres.val)
}

Il ne reste qu’à faire tourner la fonction en boucle sur notre matrice de requêtes. Et faire deux petit graphiques qui sont assez parlant.

g.ans <- apply(req, FUN=goonum, MARGIN=c(1,2))
plot(apply(log(g.ans+1), 2,mean), type="b", ylab="Nombre de résultats (log+1)", xlab="Nombre de lettres")
plot(apply(g.ans==0, 2, sum), type="b", ylab="% de résultats nuls", xlab="Nombre de lettres")

Hum, ça pour être parlant… Quand on vient du monde de la biologie (et pire encore, de l’écologie) on hallucine toujours un peu face à ce genre de données ! C’est doux comme de la soie !

Comme on pouvait s’y attendre, le nombre de réponses décroit de manière exponentielle avec l’augmentation du nombre de lettre… jusqu’à 7 lettres. A 8 lettres 90% des requêtes ne renvoient plus aucun résultat. A partir de 9, plus rien, en tout cas dans cet échantillon. M’enfin 7 lettres c’est déjà pas mal, des combinaisons à 7 lettres il y en a 26^7 soit plus de 8 milliards…