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).

[Invité]

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
# Python
"""_____:
Selon un dictionnaire apparenté au jeu de parenthèses suivant
    ( ((0(0))0)(0)0)(0(0))
Qui présente des signes de dégroupement des jeux,
et en donnant le sens complexe de sa définition :
    Ce jeu d'ensemble composite fait grand bruit.
    Et pour cause, il y a anomalie notable.
    Sa régularité n'est pas opérationnelle.
"""
parent_dico = {19: [19, 20, 21], 17: [17, 18, 22],
               16: [16, 23], 11: [11, 12, 13],
               5: [5, 6, 7], 3: [3, 4, 8], 2: [2, 9, 10],
               0: [0, 1, 14, 15]}
""" ( ((0(0))0)(0)0)(0(0)) Le jeu d'un ensemble donné.
Ayant trois blocs de regroupement par inclusion.
    Blocs 1, 2, 3 = ((0(0))0), (0), (0(0))
    Basic = (bloc)(bloc)(bloc)"""
# Génération parent_dico
blocages = []
blocs = {}
boc = 0
for part in parent_dico:
    maxime = [min(parent_dico[part]), max(parent_dico[part])]
    blocs[boc] = maxime  # Initiales (min, max)
    boc += 1
# Formation des blocages
examen = []
for bon in range(len(blocs) + 1):
    if bon < len(blocs) - 1:
        b0 = max(blocs[bon+1])  # Petit (grand)
        b1 = min(blocs[bon])  # Grand (petit)
        # Intervalle blocs
        if b0 < b1:
            examen.append(blocs[bon])
            blocages.append(examen)
            examen = []
        else:
            examen.append(blocs[bon])
    else:
        examen.append(blocs[bon])
        blocages.append(examen)
        break
# ...
print('parent_dico', parent_dico); print()
print('blocs', blocs, len(blocs), 'ex'); print()
print('blocages', blocages, len(blocages), 'ex')

[Invité]

Bonjour

Content de travailler objectivement au jeu des parenthèses, et qui grâce aux erreurs que j'ai moi-même provoqué. Une correction doit être portée sur un élément, sur cet élément qui est absent au tableau. Ou bien un jeu de parenthèses a deux opérations à réaliser, d'où une correction à effectuer sans "gêner" (la suite). Le dénouement bien que basé sur un jeu vrai, avec de telles erreurs pouvant désappointer le travail du correcteur. C'est dire combien la dimension apportée par les parenthèses, compose une partition hiérarchique en ordre inclusif… .

Entre parenthèses
Cet espace nous enseigne qu’à partir d’une dimension visuelle, ayant pour image la réunion de plusieurs jeux de parenthèses. Il s’avère nécessaire de concevoir un algorithme comme moyen de reproduction logique, ayant l’image des mêmes jeux. Cet entre parenthèses doit se révéler juste, autrement il y a mesure à réajustement lié aux erreurs relevées.
___
· La quantité des ouvertures est différente de celle des fermetures.

o Normalement, il y a un jeu par opération

Pareil : 1 jeu = 1 opération.
· La singularité orientée de l’image objective originale.

o La position de l’opération se révèle capitale

Dans le réajustement d’une opération dont la hiérarchie orientée, ne corresponde pas à la définition donnée par le relevé d’erreur. L’ultime correction consiste à localiser l’erreur, et déterminer du jeu voisin à lier. On remarque, que cette situation nous conduit à créer un nouveau jeu entier ‘()’, sans se soucier du nombre d’ouverture/fermeture. Qui je le rappelle, ce dernier a comme moyen de correction au niveau d’entrée principal du programme.
· La partition des jeux et des opérations n’est pas régulière.

o Lorsque le jeu comporte une rupture opérationnelle

Tels, le jeu de parenthèses sans opération à réaliser, ou d’un relevé décrivant un jeu composé de deux opérations irrégulières. La partition est le jeu des parenthèses dont le niveau d’inclusion donné par l’équation, ainsi que de sa formulation hiérarchique. Qui généralement, produisent des ensembles de jeux inclus.
Le point de rupture met en scène une opération à réaliser entre deux ensembles concrets, pour le cas d’un bloc A à multiplier avec un bloc B, sujet de recherche dans le relevé des positions opérationnelles. À cet intervalle intermédiaire étant un vide d’opération, rompant aussi l’évolution par ce manque absolu. Ne pouvant inventer l’opération, tout en donnant les termes de sa correction.
· La priorité donnée aux traitements de correction.

o Selon une demande complexe de dénouement

Résumé de la justesse parentale affiliée à l’équation, au jeu régulier tant objectif que formel. Étroitement globalisée dans sa réelle expression, ainsi que déterminée à être utile au moment de la correction. La question est de reconnaitre que les éléments perturbateurs s’enchainent, d’un jeu erroné traité via un relevé algorithmique. Ce relevé effectué automatiquement, peut comporter autant d’erreurs. C’est aussi la raison qui a poussé le programme à reformuler un appel de fonction de réinitialisation générale.
Le programme est à cet instant en cours de finalisation, le cheminement tente de suivre le cours du vrai. Tant développé que sa finalité se devine à la précision de son algorithme. Étant en cours de développement le code d’accompagnement n’est pas propre. Mais idéal pour y travailler J

Code Python généralement

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
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
 
#!/usr/bin/env python3.6
# -*- coding: utf-8 -*-
# Jeux de parenthèse ( jeux2parentheses_6mx.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)
intro = [0]  # ........ Rapport d'entrée
gogo = []  # ........... Retour go
 
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 exemplaire:
                0 = ( 3 + 8 )       ou (0)
                0 = ( (0) + 4 )     ou ((0)0)
                0 = ( (0) + (0) )   ou ((0)0(0))
                0 = ( 3+4/2 )       ou (0)  """
    o = '('
    f = ')'
    x0 = 0
    formidable = []
    # 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
            formidable.append(x0)
        x0 += 1
    """Moteur mfd. Opération numéro"""
    for mfd in formidable:  # Simple copie
        numero.append(mfd)
 
def jeuparentheses(yoyo):
    """ En français dans la définition."""
    global gogo
    if intro[0] == 0:
        # Surcharge entrée
        yoyo = '(' + yoyo + ')'
        gogo = [yoyo]
    print('= ==|== = intro', yoyo, 'intro[0]', intro[0])
    formation(yoyo)
    """Moteur yoyo. Connection dialog"""
    if len(ox_ouvre) != len(fx_ferme):
        dialog[0] = False
    # 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
        ert = ouv
        """Service max. Limite supérieure"""
        while ert <= max(fx_ferme):
            if ert not in plage_famille:
                plage_famille.append(ert)
                plage_enfant.append(ert)
                if ert in numero:
                    """Numéro ert. Condition dialog"""
                    if ouv not in digit.keys():
                        digit[ouv] = ert
                    else:  # Connection dialog
                        dialog[0] = False
                        ouvert = ouv, ert
                        plage_dialog.append(ouvert)
                elif ert in fx_ferme:
                    """Plage fin. Moteur ert.Plage()"""
                    plage_parente.append(plage_enfant)
                    break
            ert += 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:
            ofsig = '('
        elif unouv != unfer:
            ofsig = ')'
        else:
            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:
                yo0 = digit[dial[0]] + 1
                print('****  yo0', yo0, dial)
                if ofsig is not True:
                    if ofsig == '(':
                        unouv += 1
                    else:
                        unfer += 1
                    gogo[0] = yoyo[:yo0] + ofsig + yoyo[yo0:]
                    print('._. yoyo1', yoyo[:yo0], '\n._. yoyo2', yoyo[yo0:])
                else:  # :unouv == unfer:
                    unouv += 1
                    unfer += 1
                    y1 = yoyo[dial[1]:max(parent_dico[dial[0]])]
                    y2 = yoyo[max(parent_dico[dial[0]]) + 1:]
                    print('    ELSE YO0', yoyo[:yo0], '||', yo0,
                          '\n    ELSE Y1', y1, '||', dial[1], max(parent_dico[dial[0]]),
                          '\n    ELSE Y2', y2, '||', max(parent_dico[dial[0]]))
                    gogo[0] = yoyo[:yo0] + '(' + y1 + ')' + y2
                print('dial in dialog _ _ _ _ _', dial)
                print('._. .plage_dialog', gogo[0])
                if unfer == unouv:
                    print('break dialog')
                    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
                yo0 = max(priori)[0]
                y2 = songe
                del serie[yo0:y2]
                yoyo = ''.join(h for h in serie)
                gogo[0] = yoyo
                print('._. ... songe', 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('._. ... priori', gogo[0])
            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('._. ... 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
            yo0 = max(fx_ferme) + 1
            if savane[0] == max(fx_ferme):
                gogo[0] = ofsig + yoyo[:yo0]  # Jeu7(ofsig:gauche)
            else:
                gogo[0] = yoyo[:yo0] + ofsig  # Jeu3(ofsig:droite)
            print('._. ... sauver', gogo[0])
        intro[0] += 1
        if intro[0] < 10:
            jeuparentheses(gogo[0])
    else:
        """Contrôle structure.bloc """
        blocages = []
        blocs = {}
        boc = 0
        for part in parent_dico:
            maxime = min(parent_dico[part]), max(parent_dico[part])
            blocs[boc] = maxime
            boc += 1
        # Formation des blocages
        examen = []
        for bon in range(len(blocs)):
            if bon < len(blocs) - 1:
                b0 = max(blocs[bon+1])  # Petit (grand)
                b1 = min(blocs[bon])  # Grand (petit)
                # Intervalle blocs
                if b0 < b1:
                    examen.append(blocs[bon])
                    blocages.append(examen)
                    examen = []
                else:
                    examen.append(blocs[bon])
            else:
                examen.append(blocs[bon])
                blocages.append(examen)
        # Examinateur de choc
        examine = []
        bug = []
        bal = clef = -1
        # tableau = yoyo
        print(' blocages', blocages)
        for bb in blocages:
            bal += 1
            bong = len(bb) - 1
            # print('    BB bb', bb[-1][0])
            if len(blocages) > 1 and bal != 0:
                clef = bb[-1][0]
                print('  clé', clef)
                minimum = max(bb[bong])
                maximum = min(blocages[bal - 1][-1])
                alumine = min(bb[bong])
                print('min', minimum, 'max', maximum)
                alu = 1
                if minimum > maximum:
                    alu = -1
                fin = 0
                for manie in range(minimum, maximum + alu, alu):
                    bug.append(manie)
                    # print('manie bb', manie)
                    for mix in digit.values():
                        if manie == mix:
                            examine.append(bb[bong])
                            fin = 1
                            print('mix_manie_bong', bb[bong], 'bug', bug[-1])
                            print('')
                            break
                    if fin == 1:
                        break
                else:
                    rab = list(blocages[-1][-1])
                    if digit[alumine] not in bug:
                        ping = bb[bong - 1]
                        print('.bug_local_digit', digit[alumine], 'Non opérationnel',
                              '\n.big_local_bug', bug, 'Sans opération',
                              '\n.rip_local_rab', rab, 'Contradictoire')
                    else:
                        ping = bb[bong]
                    examine.append(ping)
                #print('..minimum', minimum, '..maximum', maximum, '..alumine', alumine)
            if clef == 0 and bb[bong][1] < max(fx_ferme):
                print('e()e', examine, bb[bong])
                examine.append(bb[bong])
        # print('Bb0', bb[0], 'bbmax', bb[bong])
        print('examine', examine)
        # ...
        # print('blocs =', blocs, '; ex1 =', len(blocs))
        print('blocages =', blocages, '; ex2 =', len(blocages))
        print('============= final', gogo[0])
 
if __name__ == '__main__':
    # Ne pas utiliser les crochets ( [jeux] )
    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)', 9: '(0 ( (( ((0(0))0) )0)',
           10: '(0(((0( (0(0)) 0)) 0)', 11: ' ((00))0(0)0)((00))',
           12: '( (0(0)) 0 (0(0)0) )', 13: '0(o)(0(0)) (0(0(0)o',
           14: '( ((0)0(0)) 0 (0(0)) )', 15: '0)(0',
           20: 'Le juste 0 a tout faux'}
    go = 11
    gogo = [jeu[go]]
    print('==== Numéro en jeu ====', go)
    jeuparentheses(gogo[0])

[Invité]

0Oo°
Ce traité : # Jeux de parenthèse ( jeux2parentheses_7m.py )
Résumé : «"" Formation de toto | Avec uniquement (0)
Les caractères '(‘, ‘)’, ‘0' forment trois signes distribués
= ouvre, ferme, numéro

Un numéro par défaut = 0 est une opération exemplaire:

0 = ( 3 + 8 ) ou (0)
0 = ( (0) + 4 ) ou ((0)0)
0 = ( (0) + (0) ) ou ((0)0(0))
0 = ( 3+4/2 ) ou (0)

Le zéro est avantageusement impersonnel

Morphologies: Voir ci-dessus
Impersonnel: Association indéfinie
Problématique: Association incomplète """

La morphologie du zéro a un état

Si, ci-dessus, le zéro peut prendre différents états. Soit il est l’opération d’un opérateur sur deux opérandes, ou bien il est composé d’un opérateur sur un opérande lié avec l’opérande du résultat. Ces cas de formation opérateur & opérande, sont distinctifs et ont des longues appellations. Afin d’inhiber les phrases, on réduit le poids des appels en créant des indices.

Appellation longue (3+8) Appellation courte (o0o)
· (3 + 8) = 0 : Un Opérateur (+) & deux opérandes (3, 8) . oOo
· ((0) + 4) = 0 : Un Opérateur (+) & un opérande (4) . . Oo
· ((0) + (0)) = 0 : Un Opérateur (+) . . . O
· (((3 + 8) + 4)) + (0)) . . . . (((oOo) Oo) O(o))

Le zéro a un mode opératoire ordonné à la priorité cursive de l’équation, formant une série opérante sur jeu de parenthèse. Les parenthèses (ouvertes & fermées) ou jeux des triparties arborescentes, dont la propriété est d’orienter la priorité au jeu de parenthèses le plus profond. Les jeux ont chacun un état opérationnel, suivant une séquence allant jusqu’au niveau de priorité majeur.
La détermination opérationnelle à sensation mathématique, forme son modèle d’interprétation lié au zéro à traiter. Par ce, que les états zéros du traitement ont une unique expression, en se faisant par leurs positions parmi les jeux de parenthèses. C’est un objet neutralisé par une simple assimilation, d’où le Titre - Objet Neutre Assimilé.

• ONA. L’objet neutre assimilé (ona) ©

L’élément assigné est en équation assimilative, c’est-à-dire qu’il est une articulation de membre. Qu’il est intégré à la chronologie multi-niveaux, où les objets sont disposés en strates hiérarchisées. L’objet bien que résultant, il a la capacité d’être assimilable à un même résultat. Être assimilable en étant assimilé, l’objet de part la chronique des jeux de parenthèses dans lequel il est limité. Car ce genre d’assemblage, divise des unités d’états destinées à produire un résultat. À savoir qu’un état est en fait un résultat, si bien que seul le résultat comptant fait la validité de l’objet. Aussi deux objets ne peuvent pas être assimilés à un jeu de parenthèses, s’ils ne sont pas mis en équation. Un objet de liaison entre les deux résultantes peut créer l’assimilation, celle qui aide à l’aboutissement en jeu.