Discussion :

[pythonprog]

en gros si ma chaine =[()()()] il maffiche True si nn comme [[]]]]]])))) il m'affiche false
ma solution est la voici

Code :

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

1
2
3
4
5
6
7
8
9
10
11
import sys
def par(chaine):
	vec=[]
	for i in chaine:
		if i=='(' or i=='[' :
			vec.append(i)		
		elif i==')' and vec[-1]=='(':
			vec.pop()
		elif  i==']' and vec[-1]=='[':
			vec.pop() 
	return len(vec)==0

j 'ai utilisé une pile,lorsque elle est bien parenthésé il m affiche True et quand j ai des parenthèses ouvrantes plus que parenthèse fermente il affiche False
le problème le programma bug quand j ai mis une chaine de caractère comme ceci [[]]))))))
cet a dire des patenthese ouvrantes ou des crochés ferments plus que des parenthèse ouvrante ou croché ferments aussi

merci pour votre aide

[Clodion]

Bonjour,
Je ne comprends pas vraiment le problème. (La réponse est déjà indiquée dans votre texte)!
C'est une pile, donc s'il y a des risques que la pile soit vide il faut un test vérifiant qu'elle n'est pas vide avant de poper!! Et dans ce test il faut régler le cas problématique.

Non?

PS: si vous chercher à vérifier que les parenthèses sont bien équilibrées, alors arriver à une pile vide avec un parenthèse fermante (comme dans votre exemple) est une preuve que les parenthèses ne sont pas équilibrées.
PS2: Votre erreur provient du test "vec[-1]=='('" effectué sur une pile vide…

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
import sys
def par(chaine):
	vec=[]
	for i in chaine:
		if i=='(' or i=='[' :
			vec.append(i)		
		elif (i == ")" or i == "]") and len(vec) == 0:
			return False
		elif i==')' and vec[-1]=='(':
			vec.pop()
		elif  i==']' and vec[-1]=='[':
			vec.pop() 
	return len(vec)==0

print(par("[[]]]]]]))))"))

Clodion

[VinsS]

Salut,

Evitons les successions de elif, Python est plus direct que cela.

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
 
# -*- encoding: utf-8 -*-
 
TOKENS = ('(', '[', '{', ')', ']', '}')
 
def count_tokens(st):
    tkn = {'(': 0, '[': 0, '{': 0, ')': 0, ']': 0, '}': 0}
    for ch in st:
        if ch in TOKENS:
            tkn[ch] += 1
 
    par = tkn['('] - tkn[')']
    br = tkn['{'] - tkn['}']
    cr = tkn['['] - tkn[']']
 
    return par, br, cr
 
# On teste ça
strs = ['[[{aa[[aa(}]]aa())', '{(ee[ee){(]}}', '[(dd[[d((]d{(()}))))]', '[[]]))))))']
 
for st in strs:
    p, b, c = count_tokens(st)
 
    print('\n%s' % st)
    print('Parenthèses appariées: %s' % (not p))
    print('crochets appariés: %s' % (not c))         
    print('Accolades appariées: %s' % (not b))

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
 
[[{aa[[aa(}]]aa())
Parenthèses appariées: True
crochets appariés: False
Accolades appariées: True
 
{(ee[ee){(]}}
Parenthèses appariées: False
crochets appariés: True
Accolades appariées: True
 
[(dd[[d((]d{(()}))))]
Parenthèses appariées: True
crochets appariés: False
Accolades appariées: True
 
[[]]))))))
Parenthèses appariées: False
crochets appariés: True
Accolades appariées: True

[fred1599]

On peut utiliser la classe Counter du module collections

Code :

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

1
2
3
4
>>> from collections import Counter
>>> my_count = Counter("[[{aa[[aa(}]]aa())")
>>> my_count
Counter({'a': 6, '[': 4, ']': 2, ')': 2, '(': 2, '}': 1, '{': 1})

Bon amusement,

[Clodion]

Bonsoir,
@VinsS: Tout à fait, c'est nettement plus "propre".

Cependant cela dépend beaucoup de l'énoncé exact ainsi que du "chapitre" dans lequel se trouve l'exercice! :-)
D'autre part, l'avantage d'une pile est de vérifier l'appariement complet (non-seulement celui de chacun des "{[(" mais aussi la consistance de leur utilisation), non?
))((
([)]
Ce sont deux exemples pour lesquels l'égalité du nombre de parenthèses et des crochets est vérifiée, alors que l'appariement est non valide.

@fred1599: Oui, encore plus succinct. Cependant même remarque que précédemment!!

Clodion

[fred1599]

mais aussi la consistance de leur utilisation

Tout à fait ça sera la difficulté, mais on peut avoir une réponse directe True ou False si le nombre n'est pas équivalent pour chaque '(' et '['.

[VinsS]

Pour vérifier la constance de l'appariement, ça peut se faire avec un simple compteur.

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
 
TOKENS = (('(', ')'), ('[', ']'), ('{', '}'))
 
def count_tokens(st, op, cl):
    tkn = {op: 1, cl: -1}
    count = 0
    for idx, ch in enumerate(st):
        if ch in (op, cl):
            count += tkn[ch]
            if count == -1:
                raise SyntaxError("Unvalid token column %s" % idx)
 
    return count
 
# On teste ça
strs = ['[[{aa[[aa(}}]]aa())]]', '{(ee[ee){(]}}', '[(dd[[d((]d{(()}))))]', '[[]]))))))']
 
for st in strs:
    print('\n%s' % st)
    for t in TOKENS:
        try:
            c = count_tokens(st, t[0], t[1])
        except SyntaxError as why:
            print("Error with %s : %s" % (t, why))
            continue
 
        else:
            print('Conteneurs %s appariés: %s' % (t, not c))

Edit: @ pythonprog, c'est du code Python que tu analyses, ou rien à voir ?

[pythonprog]

Bonjour,
Je ne comprends pas vraiment le problème. (La réponse est déjà indiquée dans votre texte)!
C'est une pile, donc s'il y a des risques que la pile soit vide il faut un test vérifiant qu'elle n'est pas vide avant de poper!! Et dans ce test il faut régler le cas problématique.

Non?

PS: si vous chercher à vérifier que les parenthèses sont bien équilibrées, alors arriver à une pile vide avec un parenthèse fermante (comme dans votre exemple) est une preuve que les parenthèses ne sont pas équilibrées.
PS2: Votre erreur provient du test "vec[-1]=='('" effectué sur une pile vide…

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
import sys
def par(chaine):
	vec=[]
	for i in chaine:
		if i=='(' or i=='[' :
			vec.append(i)		
		elif (i == ")" or i == "]") and len(vec) == 0:
			return False
		elif i==')' and vec[-1]=='(':
			vec.pop()
		elif  i==']' and vec[-1]=='[':
			vec.pop() 
	return len(vec)==0

print(par("[[]]]]]]))))"))

Clodion

merci clodien , elle marche bien , sauf que le prof nous a recommandé d' eviter les returns

[pythonprog]

Salut,

Evitons les successions de elif, Python est plus direct que cela.

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
 
# -*- encoding: utf-8 -*-
 
TOKENS = ('(', '[', '{', ')', ']', '}')
 
def count_tokens(st):
    tkn = {'(': 0, '[': 0, '{': 0, ')': 0, ']': 0, '}': 0}
    for ch in st:
        if ch in TOKENS:
            tkn[ch] += 1
 
    par = tkn['('] - tkn[')']
    br = tkn['{'] - tkn['}']
    cr = tkn['['] - tkn[']']
 
    return par, br, cr
 
# On teste ça
strs = ['[[{aa[[aa(}]]aa())', '{(ee[ee){(]}}', '[(dd[[d((]d{(()}))))]', '[[]]))))))']
 
for st in strs:
    p, b, c = count_tokens(st)
 
    print('\n%s' % st)
    print('Parenthèses appariées: %s' % (not p))
    print('crochets appariés: %s' % (not c))         
    print('Accolades appariées: %s' % (not b))

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
 
[[{aa[[aa(}]]aa())
Parenthèses appariées: True
crochets appariés: False
Accolades appariées: True
 
{(ee[ee){(]}}
Parenthèses appariées: False
crochets appariés: True
Accolades appariées: True
 
[(dd[[d((]d{(()}))))]
Parenthèses appariées: True
crochets appariés: False
Accolades appariées: True
 
[[]]))))))
Parenthèses appariées: False
crochets appariés: True
Accolades appariées: True

sauf que vous aves oubliez la condition que la chaine doit etre bien parenthésé
votre code ne verifie pas cette chaine ])bla bla([

[fred1599]

Sauf que tu as oublié que l'exercice c'est à toi de le faire...

95% du boulot est mâché !

Bonne continuation.

[pythonprog]

MERCI

[Clodion]

Bonjour,

merci clodien , elle marche bien , sauf que le prof nous a recommandé d' eviter les returns

Heu? Ce n'était pas indiqué dans les conditions initiales…
D'autre part, c'est un exercice. Le principal est que l'erreur que vous obteniez soit détectée et comprise, non?

Maintenant, modifier votre code afin de s'affranchir de ce "return", n'est vraiment pas compliqué!! Il y a plusieurs manières d'y parvenir!
Et dans ce cas, au moins, c'est un problème que, même avec un niveau de grand débutant (je ne connais pas votre niveau en Python), vous devriez pouvoir résoudre en moins de trois minutes, chronomètre en main.

Clodion