Discussion :

[forum]

Bonjour,

Je vous propose un nouvel élément à utiliser : Jeu des Parenthèses

Jeu des parenthèses

A un simple traité, puisqu’occupé de ces trois caractères : « 1 = ( », « 2 = 0 », « 3 = ) ».

Son rôle consiste à corriger les éventuelles erreurs relatives aux parenthèses, les formes volontairement erronées ont étés d’un grand recours à son évolution. Et de tracer leurs différentes priorités, afin de calculer justement les numéros dans le même ordre.

Apparemment, le jeu est assez compliqué dans cet exercice. Pendant tous les efforts de reconstitution de l’évènement, pour une juste mesure visiblement codée…/

Une entre parenthèses a une opération à effectuer, et elle est une unité formée de deux opérandes et un opérateur. La définition des priorités dépend de l’équilibre du nombre des ouvertures, se doit être égal en fermeture. C’est en écrivant ce programme, en ayant volontairement glissé des erreurs. Que le jeu à lequel les parenthèses s’amusent est fortement compliqué, aussi que cette maitrise offre une capacité de fabrique mathématique.

La détection de l’erreur établit un dialogue, dans un message mesurable permettant le diagnostique. La production d’un défaut arrive lorsqu’une plage de parenthèses rencontre un deuxième numéro, car en règle générale la plage ne doit comporter qu’une seule opération ou numéro. Dialogue aidant, ainsi que bien entendu l’ensemble algorithmique nécessaire. Le point sur les petites erreurs commises entre parenthèses, le tout équilibré tant dans la quantité que dans la tenue de la priorité.



Qu'en pensez-vous ?

[Invité]

Au niveau réel de la production de ce programme, il y a celui de l'erreur qu'il est censé corriger. Pourquoi travailler dans l'erreur quand il y a plus simple ! - Quand alors le plus simple devient le plus compliqué ?. En se satisfaisant d'un message d'erreur, il n'y a plus qu'à trouver une autre solution espérée sans casse. Ce que le simple n'a pas, c'est la gestion des erreurs. Sans avoir jamais vu leurs mécanismes... Les erreurs des parenthèses sont structurées, elles ont chacune une coordination qui permet leur détection. L'erreur a donc un algorithme bien précis, et plus l'erreur évolue mieux elle sera comprise. Selon que l'acharnement à la découverte des fameuses erreurs repérables, ainsi qu'assimilées par le milieu du vrai. Le vrai milieu des parenthèses inutiles sans ces numéros calculateurs, ou encore celles qui ont deux évènements calculateurs "(1-2 4*8)", ce qui est une autre source d'erreur.

Le jeu de parenthèses est minimaliste et c'est ce qui fait une bonne raison de s'y intéresser. Un algorithme presqu'inutile tant il se déroule la plupart du temps mentalement, ce qui rend le calcul mental des parenthèses facile vient du sujet traité. Les opérations numériques sont bien connues, il est donc aisé de restituer un vrai résultat. Mais j'insiste sur le jeu de parenthèses par lui-même, sa technique d'assemblage est remarquable du fait du résultat effectué sur les calculs. IL en pourrait être de même avec d'autres sujets élémentaires tels les micro-organismes, qui pullulent à nos yeux sans trop savoir quoi que ce soit de plus. En mettant les éléments entre parenthèses, on distingue un ordre au niveau des priorités et ainsi nos yeux les voient autrement (micros machins).

La parenthèse serait alors une prothèse intelligente aidant notre esprit à discerner le sujet de notre recherche, ce qu'il faut également savoir :

Les parenthèses forment un outillage basique qui a été créé de façon logique, elles expriment idem les œillères du bourricot

[Invité]

Au niveau réel de la production de ce programme, il y a celui de l'erreur qu'il est censé corriger. Pourquoi travailler dans l'erreur .../... En mettant les éléments entre parenthèses, on distingue un ordre au niveau des priorités et ainsi nos yeux les voient autrement (micros machins).

La parenthèse serait alors une prothèse intelligente aidant notre esprit à discerner le sujet de notre recherche, ce qu'il faut également savoir :

Les parenthèses forment un outillage basique qui a été créé de façon logique, elles expriment idem les œillères du bourricot

C'est à petits pas que le petit poucet conduit à quoi ?

Je ne le sais pas, mais j'ai quelques miettes de code, qui forment le résultat numérique de ce qui s'affiche à l'écran en supplément.

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
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
#!/usr/bin/env python3.6
# -*- coding: utf-8 -*-
# Jeux de parenthèse << jeux2parentheses_3copie.py >>
#
dialog = [True]
numero = []  # ......... Liste des numéros
ox_ouvre = []  # ....... Liste des ouvertures
fx_ferme = []  # ....... Liste des fermetures
plage_parente = []  # .. Plage de parenthèses
parent_priori = []  # .. Plage sans numéro
plage_dialog = []  # ... Dialogue défaut
digit = {}  # .......... Dico (plage:numéro)
diagno = [0]  # ........ Zone diagnostique
 
def formation(toto):
    """ Formation de toto | Avec uniquement (0) 
        Les caractères '(,),0' forment trois signes
        distribués = :ox_ouvre,fx_ferme,numéro:."""
    o = '('
    f = ')'
    x0 = 0
    formid = []
    # Efface tous les tableaux
    if len(numero) > 0:
        numero.clear()
        ox_ouvre.clear()
        fx_ferme.clear()
        plage_parente.clear()
        parent_priori.clear()
        plage_dialog.clear()
        digit.clear()
    dialog[0] = True
    # Image du nouveau Toto)
    """Moteur yo. Toto distribution"""
    for yo in toto:
        if yo == o and x0 not in ox_ouvre:  # Ouvrante "("
            ox_ouvre.append(x0)
        elif yo == f and x0 not in fx_ferme:  # Fermante ")"
            fx_ferme.append(x0)
        elif yo == '0':  # Position numéro
            formid.append(x0)
        x0 += 1
    """Moteur mfd. Opération numéro"""
    for mfd in formid:  # Simple copie
        numero.append(mfd)
 
def jeuparentheses(yoyo):
    """ En français dans la définition."""
    yoyo = '(' + yoyo + ')'
    print('= ==|== = intro', yoyo)
    formation(yoyo)
    """Moteur yoyo. Connection dialog"""
    if len(ox_ouvre) != len(fx_ferme):
        dialog[0] = False
        diagno[0] = 1
    # Montage(entre parenthèse)
    ox_ouvre.reverse()  # Inversion montage
    plage_famille = []  # Plages union
    """Moteur oo. Ouvrant décroissant"""
    for ouv in ox_ouvre:
        plage_enfant = []  # Plage collection
        oo = ouv
        """Service max. Limite supérieure"""
        while oo <= max(fx_ferme):
            if oo not in plage_famille:
                plage_famille.append(oo)
                plage_enfant.append(oo)
                if oo in numero:
                    """Numéro oo. Condition dialog"""
                    if ouv not in digit.keys():
                        digit[ouv] = oo
                    else:  # Connection dialog
                        dialog[0] = False
                        ouvoo = ouv, oo
                        plage_dialog.append(ouvoo)
                if oo in fx_ferme:
                    """Plage fin. Moteur oo.Plage()"""
                    plage_parente.append(plage_enfant)
                    break
            oo += 1
    parent_dico = {}  # Diction :plage_parente:
    parent_list = []  # Liste :plage_parente:
    """Dictionnaire. Plages parentes"""
    for rent in plage_parente:
        parent_dico[rent[0]] = rent
        for rt in rent:
            parent_list.append(rt)
    print('  dico parent_list', sorted(parent_list))
    print('  parent_dico', len(parent_dico), 'digit', len(digit))
    parent_sauf = []  # Tableau absence
    """Moteur pac. Pac fantôme"""
    for pac in range(max(fx_ferme) + 1):
        if pac not in plage_famille:
            dialog[0] = False
            parent_sauf.append(pac)
        if pac not in parent_list:
            dialog[0] = False
            parent_sauf.append(pac)
    def surfer(p_sf, s_av):
        for ps in p_sf:
            surf = 0
            if ps in numero:
                surf = ps, '0'
            elif ps in ox_ouvre:
                surf = ps, 'o'
            elif ps in fx_ferme:
                surf = ps, 'f'
            if surf != 0 and list(surf) not in s_av:
                s_av.append(list(surf))
    sauver = []
    """Sauveur ps. Moteur pac.Type"""
    if parent_sauf:
        surfer(parent_sauf, sauver)
    # Parent priori
    """Moteur plage. Plage fantôme"""
    for plage in plage_parente:
        if plage[0] not in digit.keys():
            dialog[0] = False
            parent_priori.append(plage)  # .. Plage sans numéro
    priori = []
    if parent_priori:
        surfer(parent_priori[0], priori)
    """Nomenclature motrice"""
    print(""" ° Rapport état
    ox_ouvre = {} \n    fx_ferme = {} \n    numero = {}
    digit = {}
    parent_dico = {}
        . Parent range.type(parent_sauf)
    sauver = {}
        . Moteur type.digit(False)
    parent_priori = {}
        . Union plage.yoyo(False)_|_digit(False)
    plage_dialog = {}
    """.format(sorted(ox_ouvre), fx_ferme, numero, sorted(digit.items()),
               parent_dico, sauver, priori, plage_dialog))
    if dialog[0] is False:
        unouv = len(ox_ouvre)
        unfer = len(fx_ferme)
        print('IF dialog | plage_dialog', plage_dialog)
        print('||| ox', ox_ouvre, unouv, 'ex\n||| fx', fx_ferme, unfer, 'ex')
        if sauver:
            print('sauver')
        if priori:
            print('priori')
        if plage_dialog:
            print('plage_dialog')
        print('._. OUV!=FER... yoyo', yoyo)
        print('============= final')
        # jeuparentheses(gogo[0])
 
if __name__ == '__main__':
    jeu = {0: '(e (a(0)0(0)a) 0 (d (b0(0)b)0(c(0)0c) d) e)',
           1: '(d (a(0)0(0)a) 0 (c 0(b(0)0b) c) d)',
           2: '(0((0)0)) 0 (0((0) 0 ))',
           3: '(0 ((0>0) ) 0 (0 ((0)0)>',
           4: '0( ((0)0o0)) 0 )',
           5: '0o ((0)0(0)) 0)',
           6: '( (0(0) ))))))))0)',
           7: 'o0(0(0))) 0 (0(0))',
           8: '((((( (0(0) )0))0)'}
    go = 4
    gogo = [jeu[go]]
    print('==== Numéro en jeu ====', go)
    jeuparentheses(gogo[0])

Et la "photo synthèse"

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
\nphumier12x\jeux2parentheses_3mcopie.py 
==== Numéro en jeu ==== 4
= ==|== = intro (0( ((0)0o0)) 0 ))
  dico parent_list [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]
  parent_dico 4 digit 3
 ° Rapport état
    ox_ouvre = [0, 2, 4, 5] 
    fx_ferme = [7, 11, 12, 16, 17] 
    numero = [1, 6, 8, 10, 14]
    digit = [(0, 1), (4, 8), (5, 6)]
    parent_dico = {5: [5, 6, 7], 4: [4, 8, 9, 10, 11], 2: [2, 3, 12], 0: [0, 1, 13, 14, 15, 16]}
        . Parent range.type(parent_sauf)
    sauver = [[17, 'f']]
        . Moteur type.digit(False)
    parent_priori = [[2, 'o'], [12, 'f']]
        . Union plage.yoyo(False)_|_digit(False)
    plage_dialog = [(4, 10), (0, 14)]
 
IF dialog | plage_dialog [(4, 10), (0, 14)]
||| ox [5, 4, 2, 0] 4 ex
||| fx [7, 11, 12, 16, 17] 5 ex
sauver
priori
plage_dialog
._. OUV!=FER... yoyo (0( ((0)0o0)) 0 ))
============= final
>>>

[Invité]

Il est certain que le traité élémentaire du jeu des parenthèses, ici. Est clairement sobre, puisque les articles du jeu sont fort peu nombreux. Mais l'exploit en vaut la peine, car pour le novice ce travail représente une part de gestion non négligeable. L'ordre des parenthèses est réglé du moins égal au dictionnaire des jeux présentés à l'essai. Tout comme le programme des nombres, il a fallut traiter les tables de repérages à l'aise dans la condition. Et aussi démystifier les différents cas qui se présentaient, ceux qui ne sont visibles que de façon logique (3^ème oeil). Ces données erronées régularisées, en la finalité d'un jeu sans erreur. Le parcours des différents cycles d'assemblage et l'exemple de ce qu'il faut faire, afin d'obtenir le même résultat juste. C'est peut-être tout ce que je réfléchis, lorsque je construit une équation simple dotée de parenthèses.

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
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
 
#!/usr/bin/env python3.6
# -*- coding: utf-8 -*-
# Jeux de parenthèse << jeux2parentheses_4m.py >>
#
dialog = [True]
numero = []  # ......... Liste des numéros
ox_ouvre = []  # ....... Liste des ouvertures
fx_ferme = []  # ....... Liste des fermetures
plage_parente = []  # .. Plage de parenthèses
parent_priori = []  # .. Plage sans numéro
plage_dialog = []  # ... Dialogue défaut
digit = {}  # .......... Dico (plage:numéro)
diagno = [0]  # ........ Zone diagnostique
introo = [0]  # ........ Rapport d'entrée
 
def formation(toto):
    """ Formation de toto | Avec uniquement (0) 
        Les caractères '(,),0' forment trois signes
        distribués = :ox_ouvre,fx_ferme,numéro:.
            Un numéro par défaut = 0
            0 est une opération imaginaire:
                0 = ( 3 + 8 )
                0 = ( (0) + 4 )
                0 = ( (0) + (0) )
                0 = ( 3+4/2 )"""
    o = '('
    f = ')'
    x0 = 0
    formid = []
    # Efface tous les tableaux
    if len(numero) > 0:
        numero.clear()
        ox_ouvre.clear()
        fx_ferme.clear()
        plage_parente.clear()
        parent_priori.clear()
        plage_dialog.clear()
        digit.clear()
    dialog[0] = True
    # Image du nouveau Toto)
    """Moteur yo. Toto distribution"""
    for yo in toto:
        if yo == o and x0 not in ox_ouvre:  # Ouvrante "("
            ox_ouvre.append(x0)
        elif yo == f and x0 not in fx_ferme:  # Fermante ")"
            fx_ferme.append(x0)
        elif yo == '0':  # Position numéro
            formid.append(x0)
        x0 += 1
    """Moteur mfd. Opération numéro"""
    for mfd in formid:  # Simple copie
        numero.append(mfd)
 
def jeuparentheses(yoyo):
    """ En français dans la définition."""
    if introo[0] == 0:
        yoyo = '(' + yoyo + ')'
    print('= ==|== = intro', yoyo)
    formation(yoyo)
    """Moteur yoyo. Connection dialog"""
    if len(ox_ouvre) != len(fx_ferme):
        dialog[0] = False
        diagno[0] = 1
    # Montage(entre parenthèse)
    ox_ouvre.reverse()  # Inversion montage
    plage_famille = []  # Plages union
    """Moteur oo. Ouvrant décroissant"""
    for ouv in ox_ouvre:
        plage_enfant = []  # Plage collection
        oo = ouv
        """Service max. Limite supérieure"""
        while oo <= max(fx_ferme):
            if oo not in plage_famille:
                plage_famille.append(oo)
                plage_enfant.append(oo)
                if oo in numero:
                    """Numéro oo. Condition dialog"""
                    if ouv not in digit.keys():
                        digit[ouv] = oo
                    else:  # Connection dialog
                        dialog[0] = False
                        ouvoo = ouv, oo
                        plage_dialog.append(ouvoo)
                if oo in fx_ferme:
                    """Plage fin. Moteur oo.Plage()"""
                    plage_parente.append(plage_enfant)
                    break
            oo += 1
    parent_dico = {}  # Diction :plage_parente:
    parent_list = []  # Liste :plage_parente:
    """Dictionnaire. Plages parentes"""
    for rent in plage_parente:
        parent_dico[rent[0]] = rent
        for rt in rent:
            parent_list.append(rt)
    parent_sauf = []  # Tableau absence
    """Moteur pac. Pac fantôme"""
    for pac in range(max(fx_ferme) + 1):
        if pac not in plage_famille:
            dialog[0] = False
            parent_sauf.append(pac)
        if pac not in parent_list:
            dialog[0] = False
            parent_sauf.append(pac)
    def surfer(p_sf, s_av):
        for ps in p_sf:
            surf = 0
            if ps in numero:
                surf = ps, '0'
            elif ps in ox_ouvre:
                surf = ps, 'o'
            elif ps in fx_ferme:
                surf = ps, 'f'
            if surf != 0 and list(surf) not in s_av:
                s_av.append(list(surf))
    sauver = []
    """Sauveur ps. Moteur pac.Type"""
    if parent_sauf:
        surfer(parent_sauf, sauver)
    # Parent priori
    """Moteur plage. Plage fantôme"""
    for plage in plage_parente:
        if plage[0] not in digit.keys():
            dialog[0] = False
            parent_priori.append(plage)  # .. Plage sans numéro
    priori = []
    if parent_priori:
        surfer(parent_priori[0], priori)
    """Nomenclature motrice"""
    print(""" ° Rapport état
    ox_ouvre = {} \n    fx_ferme = {} \n    numero = {}
    digit = {}
    parent_dico = {}
        . Parent range.type(parent_sauf)
    sauver = {}
        . Moteur type.digit(False)
    parent_priori = {}
        . Union plage.yoyo(False)_|_digit(False)
    plage_dialog = {}
    """.format(sorted(ox_ouvre), fx_ferme, numero, sorted(digit.items()),
               parent_dico, sauver, priori, plage_dialog))
    if dialog[0] is False:
        unouv = len(ox_ouvre)
        unfer = len(fx_ferme)
        if unouv < unfer:
            ofdif, ofsig = unfer - unouv, '('
        elif unouv != unfer:
            ofdif, ofsig = unouv - unfer, ')'
        else:
            ofdif = ofsig = True
        print('IF dialog | plage_dialog', plage_dialog)
        print('||| ox', ox_ouvre, unouv, 'ex\n||| fx', fx_ferme, unfer, 'ex')
        if plage_dialog:
            print('plage_dialog . . . . . . . .')
            for dial in plage_dialog:
                if ofdif is not True:
                    if ofsig == '(':
                        unouv += 1
                    else:
                        unfer += 1
                print('dial in dialog _ _ _ _ _', dial)
                if dial[0] == 0:
                    y1 = digit[0] + 1
                    y2 = y1
                    y0 = yoyo[y2:]
                else:
                    y1 = digit[dial[0]] + 1
                    y2 = dial[1]
                    y0 = yoyo[y2:]
                gogo[0] = yoyo[:y1] + ofsig + y0
                print('._. OUV!=FER... plage_dialog', gogo[0])
                if unfer == unouv:
                    break
                break
        elif priori:
            print('priori . . . . . . . . . . .')
            serie = list(yoyo)
            if sauver and len(digit) != len(numero):
                songe = 0
                for saut in sauver:
                    if saut[1] == '0':
                        songe = saut[0]
                        break
                # print('    max', max(priori))
                y1 = max(priori)[0]
                y2 = songe
                del serie[y1:y2]
                yoyo = ''.join(h for h in serie)
                gogo[0] = yoyo
                print('._. OUV!=FER... songer', gogo[0])
            elif priori[0][:1][0] == 0:
                del serie[0]
                del serie[-1]
                yoyo = ''.join(h for h in serie)
                gogo[0] = yoyo
                print('._. OUV!=FER... priori', gogo[0])
            elif len(digit) == len(numero):
                topo = []
                if sauver:
                    for p1p0 in sauver:
                        if p1p0[1] in ('o', 'f'):
                            topo.append(p1p0[0])
                for pr10 in priori:
                    if pr10[1] in ('o', 'f'):
                        topo.append(pr10[0])
                terme = []
                for t3 in range(len(yoyo)):
                    if t3 not in topo:
                        terme.append(serie[t3])
                yoyo = ''.join(h for h in terme)
                gogo[0] = yoyo
                print('._. OUV!=FER... digit', gogo[0])
        elif sauver:
            print('sauver . . . . . . . . . . .')
            savane = []
            for ane in sauver:
                if ane[1] in ('o', 'f'):
                    savane.append(ane[0])
            if ofsig is not True:
                if ofsig == '(':
                    unouv += 1
                else:
                    unfer += 1
            y1 = max(fx_ferme) + 1
            if savane[0] == max(fx_ferme):
                gogo[0] = ofsig + yoyo[:y1]  # Jeu7(ofsig:gauche)
            else:
                gogo[0] = yoyo[:y1] + ofsig  # Jeu3(ofsig:droite)
            print('y1 =', y1, '\n', yoyo[:y1])
            print('._. OUV!=FER... sauver', gogo[0])
        print('============= final', gogo[0])
        introo[0] = 1
        jeuparentheses(gogo[0])
 
if __name__ == '__main__':
    jeu = {0: '(e (a(0)0(0)a) 0 (d (b0(0)b)0(c(0)0c) d) e)',
           1: '(d (a(0)0(0)a) 0 (c 0(b(0)0b) c) d)',
           2: '(0((0)0)) 0 (0((0) 0 ))',
           3: '(0 ((0>0) ) 0 (0 ((0)0)>',
           4: '0( ((0)0o0)) 0 )',
           5: '0o ((0)0(0)) 0)',
           6: '( (0(0) ))))))))0)',
           7: 'o0(0(0))) 0 (0(0))',
           8: '((((( (0(0) )0))0)'}
    go = 1
    gogo = [jeu[go]]
    print('==== Numéro en jeu ====', go)
    jeuparentheses(gogo[0])

[Invité]

J'imagine que si je reprend le cours, c'est uniquement dans un but de résolution du problème donné par le jeu de parenthèses n°10, que voici-voilà :
10: '(0(((0( (0(0)) 0)) 0)' . Fait de manière loufoque et à la va vite, de telle sorte de confortablement perturber tous mes neurones de réconciliation. Les principaux terrains découverts ne se sont pas représentés comme prévu, soit sans erreur. Il manquait juste une logique, car parmi les éléments à sauver, il y a une opération. Alors que celle-ci est déjà répertoriée ou plutôt digitalisée, il ne fallait pas enlever ce qui à l'origine tenait sur pattes.

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
elif len(digit) == len(numero):
                topo = []
                if sauver:
                    for p1p0 in sauver:
                        if p1p0[1] in ('o', 'f') \
                                and p1p0[0] not in digit:
                            topo.append(p1p0[0])
                for pr10 in priori:
                    if pr10[1] in ('o', 'f'):
                        topo.append(pr10[0])
                terme = []
                for t3 in range(len(yoyo)):
                    if t3 not in topo:
                        terme.append(serie[t3])
                yoyo = ''.join(h for h in terme)
                gogo[0] = yoyo
                print('._. OUV!=FER... digit', gogo[0])

Et ouai

[Invité]

0A00

Propos principal
Proposition d’un fondateur incorrigible, devant répondre au jeu des parenthèses.
( ( (0(0)) 0) (0) 0) (0(0))

Premiers indices de correction

Cinq jeux correspondent aux critères de conditionnement, mais ils ne remplissent pas à eux seuls le tableau global. Il n’y a pas de solution à certains endroits de l’équation, afin de suivre un cours précis, il faut définir les éléments corrigés, et ceux qui sont erronés.

(		(	(	0	(	0	)	)	0	)	(	0	)	0	)	(	0	(	0	)	)
0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16	17	18	19	20	21
(					Résultat 0									14	)	(					)

Le jeu du résultat zéro a une parenthèse ouvrante en position zéro, et une fermante à la position quinze. Ce jeu (R0) n’a pas de résultat, à cause d’une irrégularité formée par les jeux inclus.
Les jeux inclus au résultat zéro

Le résultat classé premier, est gradué de deux à dix, et il cerne l’opérande neuf (R1)

R1 est donné en tant que résultat vrai, il a aussi deux jeux de parenthèses incluses dans son champ : _ Pose (5, 7), opère (6). _ Pose (3, 8), opère (4). _

Mise en situation réelle

((4 + (6 x 6)) / 9) = R1

Le résultat classé deuxième, est gradué de onze à treize, et il cerne l’opérande douze (R2)

R2 conduit une opération à un emplacement unique, il est résolu parce qu’il est seul, puis il est au même niveau que le résultat (R1). R2 _ pose (11, 13), opère (12). _

Conformément

(12 – 12 x 12) = R2

Qu’est-ce qui ne va pas dans cette figure : (_ (R1) _ (R2) _ R0)

Il n’y a pas d’opérateur entre R1 et R2, et la position de l’opérande contenue dans R0. La position originale fabriquée par l’auteur désigne un acte à la fin du jeu R0, ce qui signifie une requête rapportée. L’auteur étant absent, il est difficile de créer une correction, de modifier le positionnement d’un opérande (même si c’est arrangeant).

00
Manque opérande
	L'opération effectuée entre les parenthèses ne peut pas rester isolée, et son résultat est en isolation. Lorsque deux résultats n'ont pas de mode opérationnel. …
A0
Manque un jeu
	Disposé à choisir une solution : 1 = ( (R3) O² ((R2)14) )"bof" _ 2 = ( ((R3)O²(R2)) 14)"bof" _ 3 = ( (R3) 14 (R2) )"bon". Si toutefois l'opérande se prête à ce jeu.
01
Jeu associatif
	Cette union des résultats (R0, R1) attend le résultat R0, qui est la solution survenue des unions (R2, R3, 14). Qui sont deux jeux de mesure, et de l’opérande 14.
02
Jeu voisin
	Deux jeux de parenthèses voisins ont un opérande donnant un résultat, le contraire provoque une perte des résultats.

Quand on ne sait pas jouer avec les parenthèses, il faut s’attendre à un résultat erroné. Si les petites erreurs peuvent être corrigées, les autres n’ont pas cette chance. Celles qui ne sont pas corrigées à cause d’opérandes absents, ou plus généralement aux logiques qui ne sont pas jouables. La question qui se pose est de savoir ce qu’à voulu dire l’auteur dans cette mise en scène, afin de résoudre au plus juste son équation. Au cas de l’oubli d’une parenthèse fermante, il est possible grâce à ces présences d’y ajouter la bonne. Il faut noter que la correction est effectuée à partir des relevés réalisés sur la partie présente, ainsi qu’avoir découvert qu’un jeu de parenthèses « () » comporte deux opérandes. Ce qui est une erreur dans la logique du jeu de parenthèses basique, puisqu’un jeu comporte un seul rôle opérationnel. Le jeu de parenthèses a un acte inclusif, étant donné qu’il est sensé révéler un résultat en suivant des règles de priorité sur les opérations. Ces dernières ont plusieurs formes composées de nombres et d’opérateurs, aussi un jeu peut comporter une opération complexe faite de nombreux nombres et opérateurs. Pour réduire le flux des détails et ainsi mieux appréhender le sujet, puis à terme le complexe opérationnel se réduit à un zéro significatif. Le jeu de parenthèses ne peut être vide (ici).