[shell] Jeu du pendu

**Xteyse** · 12/11/2013, 19h49

Bonsoir à tous,
J'ai eu un TP en cours qui consiste à faire un jeu du pendu en shell.
N'ayant jamais pratiquer ce langage avant ce tp, je sollicite votre aide pour une erreur que je rencontre avec mon script.

Voici l'énoncé de ma première question :

Écrivez une fonction « motAuHasard » qui affiche un mot tiré au hasard dans le fichier dico.dic, ce mot devra faire 6 caractères ou plus pour être utilisable (la variable système RANDOM permet de générer des nombres aléatoires. Par exemple $(($RANDOM%nombdredelignes)) calcule un nombre au hasard compris entre 0 et nombrelignes.
Attention la variable RANDOM, donne une valeur entre 0 et 32767, le fichiers mots contenant plus de 32767 lignes, il faudra tirer 2 valeurs aux hasard et les multiplier pour obtenir une valeur assez grande et en calculer ensuite le modulo.
Voici ce que j'ai fait

Code :

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
 
#!/bin/bash
 
motAuHasard () {
while [$nbcaract < 6]
	do
#calcule des deux aléatoire
	rdm = $(($RANDOM%32767))
	rdmm = $(($RANDOM%32767))
 
#multiplication des deux aléatoire 	
        modulo = expr $rdm \* $rdmm
	echo $modulo
#calcul modulo 
	nbligne= expr $modulo % 50
	echo $nbligne
#Cherche la ligne du mot
	mot = sed -n "$nbligne" dico.dic
	echo $mot
#calcule du nombre de caractère
nbcaract = ${#mot}
echo $nbcaract
done
}

Lorsque je l’exécute j’obtiens l'erreur suivante :
line 6 : 6] : no such file or directory
Merci

**disedorgue** · 12/11/2013, 22h22

Bonjour,

Peux-tu déplacer ton post dans la section correspondante (si sous linux, il y a un forum dédier (shell et commande gnu), si sous unix en général, il y a aussi un forum shell et commande posix.

Sinon, en survolant un peu ton programme, quelques remarques:
- Le shebang (#!/bin/bash) doit-être obligatoirement sur la 1ère ligne.
- on voit à la fois une utilisation de expr et une utilisation de $((...)) qui est un peu la même chose...
- la syntaxe sur la valorisation de tes variables n'est pas je pense ce que tu veux, qui je pense est le résultats des commandes que tu passes, donc les 2 syntaxes possibles:

Code :

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

mot = sed -n "$nbligne" dico.dic

Doit s'écrire soit:

Code :

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

mot=$(sed -n "$nbligne" dico.dic)

ou

Code :

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

mot=`sed -n "$nbligne" dico.dic`

comme tu le remarquera, dans un premier temps, j'ai retiré les espaces autour du signe '=' car sinon, le shell considère ta variable comme une commande.
puis j'ai soit englobé ta commande de $(...) ou de backquote (`) qui sont les deux syntaxe pour dire au shell courant que c'est une commande à éxécuter dans un sous-shell.
Cas particulier, cette syntaxe est sous-entendu pour la forme $((...)) mais il ne faut toujours pas mettre d'espace autour du signe '=' pour signifie la valorisation d'une variable.
-Concernant l'erreur que tu rencontres, c'est l'inverse du signe '=', il faut un espace apres '[' et avant ']', donc while [ ... ] .
Après, je te conseilles d'aller dans la session tutoriel, pour compulser ceux concernant les shell...

**Xteyse** · 13/11/2013, 15h02

Merci pour cette réponse.
Cela m'a bien aidé.

Voici le code avec quelque changements notamment au niveau de la boucle while qui n' était pas bonne et du sed pour bien chercher à partir du numéro de ligne. Si je rencontre d'autre problème sur le jeu je viendrai poster ici.

Code :

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
#!/bin/bash
 
motAuHasard () {
nbcaract=0
while [ $nbcaract -le 6 ]
do
#calcule des deux aléatoire
	rdm=$(($RANDOM%32767))
	rdmm=$(($RANDOM%32767))
 echo $rdm
 echo $rdmm
#multiplication des deux aléatoire 	
    modulo=$(expr $rdm \* $rdmm)
	echo $modulo
#calcul modulo 
	nbligne=$(expr $modulo % 28)
	echo $nbligne
#Cherche la ligne du mot
	mot=$(sed -n "$nbligne"p dico.dic)
	echo $mot
#calcule du nombre de caractère
nbcaract=${#mot}
echo $nbcaract
done
}

j'ai demandé à un modo de déplacer le sujet.

**Flodelarab** · 13/11/2013, 21h31

Bonjour

Soit un dictionnaire, fichier texte ne contenant qu'un mot par ligne, que nous appelerons 'dico.txt'.

Si un pendu a besoin d'un dico ayant uniquement besoin des mots de 6 lettres ou plus, on peut utiliser l'expression régulière '......' ou '.\{6\}' dans un filtre.

Code :

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

grep '......' dico.txt

OU

Code :

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

grep '.\{6\}' dico.txt

Donc, dans le programme, le mot serait tiré aléatoirement dans cet extrait:

Code :

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

mot=$(grep '......' dico.txt | sed -n "$nbligne"p )

Les tests de longueur deviennent alors inutiles

**N_BaH** · 14/11/2013, 01h27

heu?

ce mot devra faire 6 caractères ou plus

cela suggère que le fichier contient davantage de mots.

il faudrait donc connaître le nombre de mots >=6 lettres, que l'on divisera par deux (plus un pour une partie si le nombre de mots est impair); ces deux parties serviront à calculer les modulos sur RANDOM, qui seront enfin additionnés pour obtenir la ligne qui sera sélectionnée (et donc le mot).
le modulos de Xteise est d'ailleurs inutile, puisqu'il "module" sur le nombre maximum que peut atteindre RANDOM.

Ça me paraît plus efficace que de tirer un nombre au hasard, qui pourrait être supérieur au nombre de lignes du fichiers, et, encore plus, au nombre de mots >=6 lettres

**xflr6** · 14/11/2013, 08h23

Bonjour,

Envoyé par N_BaH

il faudrait donc connaître le nombre de mots >=6 lettres, que l'on divisera par deux (plus un pour une partie si le nombre de mots est impair); ces deux parties serviront à calculer les modulos sur RANDOM, qui seront enfin additionnés pour obtenir la ligne qui sera sélectionnée (et donc le mot).

Je suis perplexe quant à ce raisonnement -- pas qu'il faille connaître (ou pouvoir obtenir facilement) le nombre de mots >=6 lettres, le reste bien sûr ;-) --.

Envoyé par N_BaH

le modulos de Xteise est d'ailleurs inutile, puisqu'il "module" sur le nombre maximum que peut atteindre RANDOM.

Agreed. Et je comprends encore moins le modulo 50 transformé en modulo 28, par ex. ici nbligne=$(expr $modulo % 28).

J'ai l'impression que pour le choix du mot, ce qu'il faut faire est clairement dit dans l'énoncé : multiplier 2 random d'entiers sur 16 bits pour simuler une distribution uniforme sur 32
j'ai de sérieux doutes sur l'uniformité de la distribution, rien que pour la densité des pairs et impairs, mais bon...

On a alors une distribution qui permet de couvrir des nombres largement au dessus de la centaine de milliers, qui doit correspondre à l'ordre de grandeur de la taille du dico (ou dico modifié par une commande similaire à celle proposées par Flodelarab (à adapter pour >=6, mais bon c'est pas grand chose)).

Reste à prendre le modulo du random vs nombre entrées dico >=6 (qui induit aussi un biais dans l'uniformité de la distribution sur le nbre d'entrées, mais bon, être bien uniformément aléatoire dans un jeu de pendu n'est peut-être pas vital non plus.

Edit: qui plus est, le requis est "au hasard", donc ça doit suffire puisque c'est l'énoncé qui suggère de faire comme ça).

Ou alors suis-je à côté de la plaque ?

**disedorgue** · 14/11/2013, 10h44

Ici, c'est juste pour apprendre le shell d'après ce que j'avais compris, je n'ai donc pas regardé la cohérence de l'algorithme.
Donc, après avoir extrait les mots qui nous interresse (post Flodelarab), on pourrait rajouter un petit sort -R et plus besoin du random (puisque le sort le fait pour nous).

**Xteyse** · 14/11/2013, 15h45

Bonjour,

Merci pour toutes ces réponses.
Effectivement mon code n'est pas très bon
Après avoir lu vos messages j'ai testé plus en profondeur le random. Et effectivement il ne marche pas très bien. Les mots qui sortent avec mon code sont souvent les mêmes. Je pense avoir mal compris le sujet. Je vais donc essayer la solution de xflr6 et je vous posterai le code après.

Pour info le dico fait plus de 300 000 lignes avec des mot de trois à beaucoup de lettres.
Si certain sont intéressé et veulent s'amuser à faire le jeu, je peut le mettre à disposition avec le tp.

**Flodelarab** · 14/11/2013, 17h14

Nous n'avons pas le choix de la technique, vu l'énoncé.
La technique du sort -R est vraiment excellente. Surtout pour un pendu. Si on veut tirer 100000 mots au hasard, c'est plus lent.

Code :

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
]$ for ((i=0;i<1000;i++));do head -n 30 dico.txt | sort -R | head -1;done |awk 'a[$0]++{} END{for (j in a) print j, a[j]}'
AA 35
ABAISSAMES 38
ABAISSAIT 38
ABAISSA 30
ABAISSASSIEZ 42
ABAISSASSES 42
ABAISSABLE 35
ABACA 25
ABAISSASSE 29
AALENIENNES 40
ABACULES 32
ABAISSANT 32
ABACULE 23
AALENIENNE 34
ABACAS 38
AAS 33
ABAISSAS 31
ABAISSANTE 41
ABAISSANTS 28
ABAISSASSIONS 40
ABAISSAIENT 31
ABAISSAI 34
ABAISSANTES 30
AALENIEN 25
ABAISSASSENT 30
AALENIENS 36
ABACOST 37
ABAISSAIS 29
ABACOSTS 27
ABAISSABLES 35

Les mots sont tirés à des fréquences équivalentes.

**xflr6** · 14/11/2013, 17h56

Envoyé par Flodelarab

La technique du sort -R est vraiment excellente. Surtout pour un pendu. Si on veut tirer 100000 mots au hasard, c'est plus lent.

Ce n'est en effet pas ce qui est demandé, mais c'est clair, l'idée est vraiment excellente.
Y compris pour 100000 pendus !
En effet : une fois le sort -R effectué, on a une suite aléatoire de mots qu'il suffit de parcourir, et on est même sûr de ne pas tirer deux fois le même. Pour certaines applications, ça peut carrément être utile.
Mais pour des applications de type tabula rasa où tout doit être remis en jeu à chaque fois, OK, s'il faut faire le sort à chaque fois, ça va devenir long.

**disedorgue** · 14/11/2013, 21h33

Si on laisse de coté le sort -R qui se prête bien au pendu car on peut très bien ne faire qu'un seul tri comme précisé par xflr6, je pense que la méthode pas trop complexe tout en étant (je pense...

) à peu près équilibré serait pour 300 000 mots environ:

Code :

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

$(((($RANDOM*($RANDOM%10))%$nblignes)+1))

Le +1 est juste là pour ne pas avoir zéro car sed compte à partir de 1

**xflr6** · 14/11/2013, 21h50

+1 pour le +1.

Après, mieux vaut laisser (($RANDOM*$RANDOM)%$nblignes)+1.

Intuitivement [...] plus c'est immensément grand devant nbligne, plus l'erreur d'uniformité due au modulo a de chance de passer petite et inaperçue lorsqu'on passe à l'échelle dans la stat.
Après, le coup de l'uniformité, c'est un peu du pinaillage compte tenu de la légèreté du sujet -le pendu-, et l'objectif initial du problème (shell et outils associés).

**disedorgue** · 14/11/2013, 22h54

@Flodelarab: Juste un détail concernant le passage par grep, le mieux serait:

Code :

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

grep -m $nblignes '......' | tail -1

ou

Code :

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

grep -m $nblignes '......' | sed -n '$p'

Mais, bon, je pinaille

**Flodelarab** · 15/11/2013, 00h59

Déjà, quit à pinailler:

Code :

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

grep -m $nblignes '......' | sed '$!d'

Après, je ne suis pas sûr de comprendre pourquoi le nombre maximum de correspondances devrait être fixée (à une valeur, d'ailleurs, qui ne sera pas atteinte, a moins que tout le dico ait des 6_lettres_ou_+). Tout le dico nous intéresse.

Bon. Résumons. Il n'y a pas besoin de script shell. Une ligne suffit:

Code :

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

1
2
$ awk -vrnd=$((RANDOM*RANDOM)) '/....../{nb_mots++;mots[nb_mots]=$0} END{print mots[rnd%nb_mots+1]}' dico.txt 
ABAISSAIT

Et la vérif'

Code :

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
for ((i=0;i<1000;i++));do awk -vrnd=$((RANDOM*RANDOM)) '/....../{nb_mots++;mots[nb_mots]=$0} END{print mots[rnd%nb_mots+1]}' dico.txt;done | awk 'a[$0]++{} END{for (j in a) print j, a[j]}'
ABAISSAIT 56
ABAISSAMES 21
ABAISSASSIEZ 23
ABAISSA 55
ABAISSASSES 46
ABAISSABLE 26
ABACULES 28
ABAISSASSE 26
AALENIENNES 22
ABACULE 24
ABAISSANT 28
AALENIENNE 25
ABACAS 27
ABAISSANTE 74
ABAISSAS 60
ABAISSANTS 28
ABAISSAI 44
ABAISSASSIONS 15
ABAISSAIENT 16
AALENIENS 58
ABAISSASSENT 18
ABAISSANTES 23
AALENIEN 123
ABACOST 32
ABAISSAIS 28
ABACOSTS 44
ABAISSABLES 30

**disedorgue** · 16/11/2013, 13h26

Envoyé par xflr6

+1 pour le +1.

Après, mieux vaut laisser (($RANDOM*$RANDOM)%$nblignes)+1.

Intuitivement [...] plus c'est immensément grand devant nbligne, plus l'erreur d'uniformité due au modulo a de chance de passer petite et inaperçue lorsqu'on passe à l'échelle dans la stat.
Après, le coup de l'uniformité, c'est un peu du pinaillage compte tenu de la légèreté du sujet -le pendu-, et l'objectif initial du problème (shell et outils associés).

J'avais forcé un RANDOM modulo 10 car 32767 * 10 est assez proche de 300 000 (qui est la contenance de son dictionnaire).
Pour que le random soit vraiment correcte, il faudrait que l'on tombe sur un facteur du nombre de mots qu'il y a dans le dico sinon, le modulo nbligne force certain mots à avoir une chance supplémentaire à être tiré au sort:

Code :

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

(32767 * 10)%300000=27670

ici on aurait donc 27670 mots avec une chance supplémentaire d'apparaitre.

Code :

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

(32767 * 32767)%300000=276289

ici on aurait donc 276289 mots avec une chance supplémentaire d'apparaitre.

On pourrait croire que mon choix est donc meilleurs car il y a moins de mots avec une chance suppléméntaire d'être tirer au sort, mais en fait ce n'est pas le cas car:

Code :

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

300000 - 276289=23711

on a donc que 23711 mots avec en fait une chance en moins d'être tiré contre 27670 mots avec une chance en plus d'être tiré et tout ça sur une répartition de 300000 mots.

Donc oui, ici $RANDOM*$RANDOM est mieux que $RANDOM*($RANDOM%10).

En fait, selon le "pseudo-raisonnement" que je viens de donner, le meilleur choix serait:

Code :

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

($RANDOM%600)*($RANDOM%500)

Et qui d'ailleurs n'est autre que le modulo du nombre de mots mais répartie sur l'ensemble des randoms...

**disedorgue** · 16/11/2013, 14h38

Et pour le fun, en builtin bash:

Code :

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
$ cat dico1.txt
DECFG
BCEEE
ABAISSAIENT
AALENIENS
DDFDF
ABAISSAIT
DEEGG
ABAISSABLES
CBFFE
CCCGE
ABAISSASSIEZ
ACCEE
ABAISSASSES
ADDDF
ACDDF
DBCGG
AEDDF
ABAISSASSIONS
ABACOSTS
DBDFH
AALENIENNES
DBCEE
ADEGE
BBDGF
BBDGF
ABAISSANTS
ABAISSAS
ABACULES
CDDDG
AALENIENNE
ABAISSAMES
CBDFH
CBDFH
DCDFF
BDEDH
ABAISSA
CCCGH
ABAISSAIS
ABAISSANTES
ABAISSABLE
CEFFH
ABACOST
DCCEF
ABAISSAI
ABACAS
CBFGE
DEFGF
ADEFE
AEEEE
AECDF
ABAISSANTE
ABAISSANT
AALENIEN
ABAISSASSENT
ABAISSASSE
CEDEE
ABACULE

Code :

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

1
2
$ unset MAPFILE ; while [ ${#MAPFILE[0]} -lt 6 ]; do mapfile -O 0 -t -s $(($RANDOM)) -n1 -c 1 <dico1.txt ; done ; echo ${MAPFILE[0]}
ABAISSAI

ou

Code :

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

1
2
$ unset MAPFILE ; while [ ${#MAPFILE[0]} -lt 6 ]; do readarray -O 0 -t -s $(($RANDOM)) -n1 -c 1 <dico1.txt ; done ; echo ${MAPFILE[0]}
ABAISSANTES

si on connait le nombre de ligne, on peut dans ce cas moduler le random pour gagner du temps, mais ici, c'est juste pour le fun

**N_BaH** · 16/11/2013, 14h56

Code bash :

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

1
2
while read -r mot; do ((${#mot} >=6)) && a+=( "$word" ); done <dico.txt
echo "${a[RANDOM]}"

les double-parenthèses sont inutiles autour de RANDOM.
le $ est facultatif entre double-parenthèses.
réitérer mapfile tant que le premier élément du tableau <6

**disedorgue** · 16/11/2013, 15h23

Pour les erreurs concernant la présence des double paranthèse, c'est juste parce qu'à l'origine je fesai un calcul modulo et que j'ai arrêté par la suite...
Après, le $ facultatif dans une double parenthèse, je le savais mais on ne peut pas lutter contre tout ces démons

Concernant le mapfile, je ne charge pas la totalité du tableau mais juste une ligne qui ici est bien positionné sur l'index 0 mais je ne lit pas d'autre ligne que la ligne spécifier par le random:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
$ unset MAPFILE
$ readarray -t -s1 -n1 -c 1 <dico1.txt
$ set | grep MAPFILE
MAPFILE=([0]="BCEEE")
$ readarray -t -s1 -n2 -c 1 <dico1.txt
$ set | grep MAPFILE
MAPFILE=([0]="BCEEE" [1]="ABAISSAIENT")
$ readarray -t -s1 -n3 -c 1 <dico1.txt
$ set | grep MAPFILE
MAPFILE=([0]="BCEEE" [1]="ABAISSAIENT" [2]="AALENIENS")
$ readarray -t -s1 -n1 -c 1 <dico1.txt
$ set | grep MAPFILE
MAPFILE=([0]="BCEEE")