Discussion :

[Martin123]

Bonjour, je suis étudiant en bioingénierie et je dois créer un automate cellulaire pour mon cours d'informatique.


J'aurais besoin d'un petit peu d'aide


L'énoncé du travail se trouve en pièce jointe.


Voici le début de mon code :

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
59
60
61
62
63
64
import sys
 
n=int(raw_input('Entrez votre règle en décimal\n'))
 
def dec2bin(n) :
    if n<0 or n>255 :
        return 'Nombre non compris entre 0 et 255'
    else :
        bin1 = []
        while n!=0 :
            if (n%2) ==0 :
                n=n/2
                bin1.insert (0,0)
            else :
                n = (n-1)/2
                bin1.insert (0,1)
        while len (bin1) <8 :
            bin1.insert (0,0)
    return bin1
 
bin=dec2bin(n)
 
print bin
 
lignepapa = raw_input('Entrez une liste de chiffres\n')
 
n = raw_input ('Nombres de lignes')
 
lignepapa= str(lignepapa)
 
lignepapa= list(lignepapa)
 
u = len(lignepapa)
 
def reglesautomate () :
    lignegarcon = []
    for i in range (0,u) :
        if lignepapa[int((i-1)%u)]==1 and lignepapa [i]==1 and lignepapa [int((i+1)%u)]==1 :
            lignegarcon.append (dec2bin [0])
        elif lignepapa[int((i-1)%u)]==1 and lignepapa [i]==1 and lignepapa [int((i+1%u)]==0 :
            lignegarcon.append (dec2bin [1])
        elif lignepapa[int((i-1)%u)]==1 and lignepapa [i]==0 and lignepapa [int((i+1)%u)]==1 :
            lignegarcon.append (dec2bin [2])
        elif lignepapa[int((i-1)%u)]==0 and lignepapa [i]==1 and lignepapa [int((i+1)%u)]==0 :
            lignegarcon.append (dec2bin [3])
        elif lignepapa[int((i-1)%u)]==0 and lignepapa [i]==1 and lignepapa [int((i+1)%u]==1 :
            lignegarcon.append (dec2bin [4])
        elif lignepapa[int((i-1)%u)]==0 and lignepapa [i]==1 and lignepapa [int((i+1)%u)]==0 :
            lignegarcon.append (dec2bin [5])
        elif lignepapa[int((i-1)%u)]==0 and lignepapa [i]==0 and lignepapa [int((i+1)%u)]==1 :
            lignegarcon.append (dec2bin [6])
        else :
            lignepapa [int((i-1)%u)]==0 and lignepapa [i]==0 and lignepapa [int((i+1)%u)]==0
            lignegarcon.append (dec2bin [7])
 
    return lignegarcon
 
ligneenfant= reglesautomate ()
 
print ligneenfant
 
def repeat (n,regle, lignepapa) :
    n= int (n)
    print lignepapa

J'ai plusieurs problèmes :

1) J'ai réalisé le début en utilisant "raw_input" or, on demande de pouvoir invoquer l'automate à partir du terminal. Comment faire?

2) la fin de mon code me donne une ligne de 0 et non un réel nouvel "état". Je ne comprends pas pourquoi

3) Comment répéter la règle sur "n" ligne filles?

Merci beaucoup d'avance !

[afranck64]

Bonsoir, pour usage de la balise code (le bouton <#>) vous aurez au moins 40% de lecteurs en plus.

[fred1599]

1) Tu peux mettre ton code entre les balises code (#) prévues à cet effet.

2) Pourquoi ne pas utiliser la force python pour transformer un décimal en binaire.

Code :

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

bin(154) # retourne le nombre binaire du décimal 154

3)

3) Comment répéter la règle sur "n" ligne filles?

Code :

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

1
2
for n in xrange(5): # écris 5 fois l'affichage de la valeur n
    print n

4) Je ne comprend rien du tout à ton code, déjà parce-qu'il est pas entre les balises code et surtout il y a des lignes répétitives et je pars de principe que si ton professeur te demande de coder un automate, tu dois avoir un code simple te permettant de créer tes répétitions suivant un indice par exemple

Un truc du genre

Code :

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

1
2
for i, j in enumerate(lignepapa):
    # Action

[Martin123]

Premièrement, merci pour ces réponses si rapide !

Alors voici ce que j'ai fait dans mon code (non fini)

Le professeur doit pouvoir lancer l'automate en tapant juste la ligne de départ, la règle de l'automate et le nombre de colonnes qu'il souhaite.

1) d'abord j'ai fait une fonction de conversion des décimals vers le binaire. Apparement je me suis cassé la tête pour rien .

2) Je demande au professeur d'entre la ligne de départ qu'il tapera au hasard. Par exemple : 1001001001010 . Le but est d'ensuite transformer cette ligne de départ grâce à la fonction en 3) et que la fonction donne une lignefille à chaque fois sur base de la ligne juste avant et pas de la ligne de départ.

3) Si je prends une règle de 30 ca me donne (en binaire) [0, 0, 0, 1, 1, 1, 1, 0] et je sais que j'ai 8 possibilités pour mes cellules (111,110,101,100,011,010,001,000). 0 = cellule vivante et 1= cellule morte. 111->0, 100 -> 1 , etc...
En gros, j'ai établis une fonction qui reprend chaque chiffre de mon nombre en binaire pour le transformer selon la règle choisie par le professeur. Elle est très répétitive et moche mais je vois pas vraiment comment faire autrement. (%u c'est pour rendre le tableau circulaire, je sais pas si je suis censé faire comme ca)



Merci beaucoup pour le temps accordé fred !

[fred1599]

Ok alors sache que j'ai jamais fais de bio à haut niveau, il te faudra être explicite voir expliquer les bases pour que je puisse comprendre un peu ce que tu demandes.

Pour tes combinaisons, tu peux utiliser le module itertools

Puis un dico

Code :

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

1
2
3
>>> dico = {'111':1, '000':0}
>>> print(dico['111'])
1

Vaut mieux faire les choses petits à petit, je veux bien t'aider, mais c'est toi qui travaille

[josmiley]

j'ai pas compris l'histoire des règles ... quelqu'un peut m'expliquer ?

[utopman]

Bonjour,
pour faire un automate selon ta feuille d'exercice, tu peux commencer ton programme comme il suit afin de récupérer les informations entrées par l'utilisateur

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
import sys
 
 
try:
	initState = [int(x) for x in sys.argv[1]]
	processLen = int(sys.argv[2])
	idRule = int(sys.argv[3])
except:
	print 'parameters error'
 
#affiche les parametres obtenus sur l entree du programme
print "%s\t%s\t%s" % (initState,processLen,idRule)

ces quelques lignes lancées avec

Code :

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

python script.py 001001001 10 15

permet d'avoir les variables que tu souhaite dans le bon format.

ensuite, comme le suggère ton TP, il serait judicieux de faire autant de fonction qu'il y a de règles, et une fonction qui détermine quelle règle appliquer. par exemple:

tu fais une règle bidon:

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
def rule1(etat):
#etat est la liste des etats de ton automate
#on va generer l etat t+1 a partir de l etat donne
	nouvelEtat = []
	for i in xrange(len(etat)):
		if i == 0: #cas ou on ne peut pas lire i-1
			nouvelEtat.append(1) #appliquer la regle pour i
		elif i == len(etat)-1:	
			nouvelEtat.append(1) #cas ou il n'y a pas de valeurs a i+1
		else:#exemple de regle bidon
			if etat[i-1] == 0 and etat[i+1] == 1: 
				nouvelEtat.append(1)
			else:
				nouvelEtat.append(0)
	return nouvelEtat

Avec au dessus, une fonction qui ordonne les règles

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
def applyRule(initState,processLen,idRule):
	state = initState #on dit u'on utilise la reference state
	for time in xrange(processLen):
		if idRule == 1:
			state = rule1(state)
		if idRule == 2:
			pass
			"""
                        on transforme l etat a l instant t en l etat a l instant t+1
                        en construisant un nouveau resultat plutot que modifier l etat
                        afin de considerer que l automate evolue en parallele.
                        """
		#a chaque etape, on affiche le nouvel etat
		print state

et enfin, une fonction qui lance le tout:

Code :

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

1
2
if __name__ == "__main__":
	applyRule(initState,processLen,idRule)

Avec ca, tu as le squelette d un automate cellulaire en python, il faut surtout que tu comprennes comment ça marche, et aussi que tu ajoutes les différentes règles qui te sont demandées.

Si ce domaine te passionne, tu pourrais regarder le Master 2 MOCAD à l'université de Lille 1 ... qui sait.

[josmiley]

ensuite, comme le suggère ton TP, il serait judicieux de faire autant de fonction qu'il y a de règles, et une fonction qui détermine quelle règle appliquer.

heu oué ...
la détermination de la règle tient en une ligne
et la génération de l'état n+1 tient en une ligne aussi

max 10 lignes pour faire un truc propre.

aller, un oneline pour le respect de la PEP ^^:

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
gen = lambda etat,regle: ''.join([str(bin(regle))[2:].zfill(8)[7-int((etat[-1]+etat+etat[0])[i:i+3],2)]for i in range(len(etat))])
 
etat = '100101111010110'
for i in range(10):
    etat = gen(etat,60)
    print(etat)
 
'110111000111101'
'001100100100011'
'101010110110010'
'111111101101011'
'000000011011110'
'000000010110001'
'100000011101001'
'010000010011101'
'111000011010011'
'000100010111010'

[josmiley]

on me demande par MP d'expliquer le oneline que j'ai posté, autant en faire profiter tout le monde ...

soit la regle 30 lut de bas en haut:

Code :

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

1
2
3
4
5
6
7
8
9
10
clé   ( indice )        valeur
 
'000' (0 en binaire) --> '0'   ^
'001' (1 en binaire) --> '1'   |
'010' (2 en binaire) --> '1'   |
'011' (3 en binaire) --> '1'   | 
'100' (4 en binaire) --> '1'   | ça fait 30 en binaire
'101' (5 en binaire) --> '0'   |
'110' (6 en binaire) --> '0'   |
'111' (7 en binaire) --> '0'   |

la regle lut à l'envers tiens dans une liste ... la clé est l'indice associé à la valeur
ex:
'011' doit donner '1'
à l'indice 3 de la liste ci-dessous ('011' en décimal) on à bien un '1'

Code :

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

1
2
['0','1','1','1','1','0','0','0']
 <------------------------------  ça fait 30 en binaire

il suffit dinc d'inverser l'ordre des bits de la règle écrite en binaire pour obtenir une représentation exploitable ...




soit un motif:

'100101111010110'
pour donner l'illusion que c'est circulaire je copie le bit de la fin au début, et celui du début à la fin

Code :

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

1
2
3
           |---------------|
         0'100101111010110'1
         |_______________|

on à un nouveau motif '01001011110101101' dont on parcours les triplets ... qui servent d'indices pour la regle.

Code :

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

1
2
3
4
5
6
7
8
'01001011110101101'                                                     resultat
 
[010] -------------- 2 en binaire ['0','1','1','1','1','0','0','0'][2] --> 1
 [100] ------------- 4 en binaire ['0','1','1','1','1','0','0','0'][4] --> 1
  [001] ------------ 1 en binaire ['0','1','1','1','1','0','0','0'][1] --> 1
   [010] ----------- 2 en binaire ['0','1','1','1','1','0','0','0'][2] --> 1
    [101] ---------- 5 en binaire ['0','1','1','1','1','0','0','0'][5] --> 0
     [etc] ..........................................................     ...

et résultat, ben ... c'est le résultat ...

[forscience]

super merci beaucoup josmiley