classnph

Invité · 30/04/2017, 13h55

Envoyé par toumic

Bonjour

Code corrigé

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
 
#!/usr/bin/env python3.6
# -*- coding: utf-8 -*-
# Série communs. En Général Python
# Version : Tierse facture
"""MusicAToumic En"""
# Programmes Nphony_0a : 18 avril 2017
# Programme  Nphony_1a : 30 avril 2017
"""
Découvrir les multiples liés à un NOMBRE
"""
import time
from math import sqrt
d0 = time.time()
nivbas = []
subips = []
subdvs = []
nivorg = []
sq1 = [0]
bi0 = [0]
def nombre(n_):
    norg = n_
    if n_ < 3:
        sq2 = sq3 = 1
    else:
        sq2 = int(sqrt(sqrt(norg)))
        sq3 = int(sqrt(sqrt(sqrt(norg))))
    bi0[0] = 0
    def cobas(c_):
        corg = c_
        w10 = 0
        if c_ < 1:
            # Si :c_: égale zéro
            c_ = 1
        if c_ < 4:
            # Si :c_: inférieur à 4
            # Petit NOMBRE solution
            # Essayer sans condition
            nivbas.append(c_)
            nivbas.append(c_ // c_)
            nivbas.sort()
        else:
            # NOMBRE apte à recherche
            csq1 = int(sqrt(corg))
            if corg == norg:
                sq1[0] = csq1
            cs10 = csq1+1 # :csq1: Racine Carrée NOMBRE
            if sq2 == 1:
                cs20 = cs21 = sq2 # :sq2: R C de :csq1:
            else:
                cs20 = cs21 = sq2-1
            cs30 = sq2*3
            w1 = w2 = w3 = 0
            while 1:
                if csq1 < 4:
                    w10 = 1
                if not corg % cs10:
                    # Décrément de :cs10: à :cs21:
                    nivbas.append(cs10)
                    nivbas.append(corg // cs10)
                    break
                elif not corg % cs20\
                     and sq2 > 1:
                    # Décrément :cs20:
                    nivbas.append(cs20)
                    nivbas.append(corg // cs20)
                    break
                elif not corg % cs21\
                     and cs21 > 1:
                    # Incrément de :cs21: à :cs10:
                    nivbas.append(cs21)
                    nivbas.append(corg // cs21)
                    break
                if w10 == 1:
                    cs10 -= 1
                else:
                    if cs10 > cs30:
                        cs10 -= 1
                    else:
                        w1 = 1
                    if cs21 < cs30: 
                        cs21 += 1
                    else:
                        w2 = 1
                    if len(nivbas) == 0\
                       and w2 == 1:
                        cs20 -= 1
            if nivbas[0] == nivbas[1]:
                bi0[0] = 1
    def socom():
        so2 = 0
        for so in nivbas:
            # :nivbas: niveau à démultiplier
            so2 += 1
            nivsub = []
            sub = so
            ssq1 = int(sqrt(sub))
            for sn in range(ssq1, 0, -1):
                if not sub % sn:
                    if so2 < 2:
                        sndv = sub // sn
                        subips.append(sn)
                        subips.append(sndv)
                        if bi0[0] == 1:
                            subdvs.append(sn)
                            subdvs.append(sndv)
                    elif bi0[0] != 1:
                        sndv = sub // sn
                        subdvs.append(sn)
                        subdvs.append(sndv)
            # Un peu d'ordre
            if nivbas[0] > nivbas[1]:
                nv0, nv1 = nivbas[1], nivbas[0]
            else:
                nv0, nv1 = nivbas[0], nivbas[1]
        print('ip %s  dv %s' % (nv0, nv1))
    def multis():
        for mn in subips:
            # Table :subips: multiplicateurs
            for mo in subdvs:
                # Table :subdvs: multiplicandes
                mon = mn * mo
                if not norg % mon and mon < sq1[0] + 1\
                   and mon not in nivorg:
                    nivorg.append(mon)
            # Liste ordonnée des multiplicateurs
            nivorg.sort()
    def communs(o_):
        con = o_
        for yn in con:
            ip = yn
            dv = norg // yn
            print('%s * %s  typ %s*%s' % (ip,dv,ip%6,dv%6))
    cobas(norg)
    if nivbas[0] == 1:
        # Et NOMBRE premier
        nivorg.append(nivbas[0])
    else:
        socom()
        multis()
    communs(nivorg)
    print('Ed',len(nivorg),'typ',norg % 6,'sq1',int(sq1[0]),sq2,sq3)
    print('Nphony_11a.py En {}'.format(time.time() - d0))
uno = 987654319
print('Cosmic', uno)
nombre(uno)
"""
Exemple long premier 326579102297565526099
Erreur 20021957 (absence multiple 191)
"""

Dernier multi ultime

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
 
#!/usr/bin/env python3.6
# -*- coding: utf-8 -*-
# Série communs. En Général Python
# Version : Tierse facture
import time
from math import sqrt
"""MusicAToumic En"""
# Programmes Nphony_0a : 18 avril 2017
# Suite  à   Nphony_11 : 30 avril 2017
# Programme Nphonic_0a : 1 mai 2017
"""Découvrir les multiples d'un NOMBRE
"""
d0 = time.time()
nivbas = []
subips = []
subdvs = []
nivorg = []
sq1 = [0]
bi0 = [0]
def nombre(n_):
    '''Introduction du NOMBRE'''
    norg = n_
    if n_ < 3:
        sq2 = sq3 = 1
    else:
        sq2 = int(sqrt(sqrt(norg)))
        sq3 = int(sqrt(sqrt(sqrt(norg))))
    bi0[0] = 0
    def cobas(c_):
        corg = c_
        w10 = 0
        if c_ < 1:
            # Si :c_: égale zéro
            c_ = 1
        if c_ < 4:
            # Si :c_: inférieur à 4
            # Petit NOMBRE solution
            nivbas.append(c_)
            nivbas.append(c_ // c_)
            nivbas.sort()
        else:
            # NOMBRE apte à recherche
            csq1 = int(sqrt(corg))
            if corg == norg:
                sq1[0] = csq1
            cs10 = csq1+1 # :csq1: Racine Carrée NOMBRE
            if sq2 == 1:
                cs20 = cs21 = sq2 # :sq2: R C de :csq1:
            else:
                cs20 = cs21 = sq2-1
            cs30 = int(sq2+(sq3**2.5))
            cs40 = int(csq1+(sq3**2.5))
            w2 = 0
            while 1:
                if csq1 < 4:
                    w10 = 1
                if not corg % cs10:
                    # Décrément de :cs10: à :cs21:
                    nivbas.append(cs10)
                    nivbas.append(corg // cs10)
                    break
                elif not corg % cs20\
                     and sq2 > 1:
                    # Décrément :cs20:
                    nivbas.append(cs20)
                    nivbas.append(corg // cs20)
                    break
                elif not corg % cs21\
                     and cs21 > 1:
                    # Incrément de :cs21: à :cs10:
                    nivbas.append(cs21)
                    nivbas.append(corg // cs21)
                    break
                if w10 == 1:
                    cs10 -= 1
                else:
                    if cs10 > cs40:
                        cs10 -= 1
                    if cs21 < cs30: 
                        cs21 += 1
                    else:
                        w2 = 1
                    if len(nivbas) == 0\
                       and w2 == 1:
                        cs20 -= 1
            if nivbas[0] == nivbas[1]:
                bi0[0] = 1
    def socom():
        so2 = 0
        for so in nivbas:
            # :nivbas: niveau à démultiplier
            so2 += 1
            sub = so
            ssq1 = int(sqrt(sub))
            for sn in range(ssq1, 0, -1):
                if not sub % sn:
                    if so2 < 2:
                        sndv = sub // sn
                        subips.append(sn)
                        subips.append(sndv)
                        if bi0[0] == 1:
                            subdvs.append(sn)
                            subdvs.append(sndv)
                    elif bi0[0] != 1:
                        sndv = sub // sn
                        subdvs.append(sn)
                        subdvs.append(sndv)
            # Un peu d'ordre
            if nivbas[0] > nivbas[1]:
                nv0, nv1 = nivbas[1], nivbas[0]
            else:
                nv0, nv1 = nivbas[0], nivbas[1]
        print('ip %s  dv %s' % (nv0, nv1))
    def multis():
        for mn in subips:
            # Table :subips: multiplicateurs
            for mo in subdvs:
                # Table :subdvs: multiplicandes
                mon = mn * mo
                if not norg % mon and mon < sq1[0] + 1\
                   and mon not in nivorg:
                    nivorg.append(mon)
            # Liste ordonnée des multiplicateurs
            nivorg.sort()
    def communs(o_):
        con = o_
        for yn in con:
            ip = yn
            dv = norg // yn
            print('%s * %s  typ %s*%s' % (ip,dv,ip%6,dv%6))
    cobas(norg)
    if nivbas[0] == 1:
        # Et NOMBRE premier
        nivorg.append(nivbas[0])
    else:
        socom()
        multis()
    communs(nivorg)
    print('Ed',len(nivorg),'typ',norg % 6,'sq1',int(sq1[0]),sq2,sq3)
    print('Nphonic_0a.py En {}'.format(time.time() - d0))
uno = 621354658784521325689
print('Cosmic', uno)
nombre(uno)

Invité · 08/05/2017, 08h06

Bonjour, j'ai revisité le moyen de recherche en boucle d'un multiple dont le voisinage est estimé à

Code :

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

cs40 = int(csq1 - (sq3 ** 2.5))

Ce qui est valable pour les nombres à petite quantité de chiffres, ne l'est pas pour les grands nombres. Il faut penser que la boucle de recherche prend un certain temps à trouver, mais aussi lorsqu'elle ne trouve pas. Car dans le code il y a une condition donnée par :cs40:, et en calculant ce qu'il reste à chercher on produit un nombre de comptages très conséquent. L'idée de créer un moteur de recherche qui tiendrait la mesure du nombre premier, ceci est l'étape suivante. Pour le moment je vous propose de voir les premiers pas qui je l'espère sont sans faux - pas

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
#!/usr/bin/env python3.6
# -*- coding: utf-8 -*-
# Série communs. En Général Python
# Version : Tierse facture
import time
from math import sqrt
"""MusicAToumic En"""
# Programmes Nphony_0a : 18 avril 2017
# Suite  à   Nphony_11 : 30 avril 2017
# Programme Nphonic_0a : 1 mai 2017
'''Mise à jour au      : 8 mai 2017'''
"""Découvrir les multiples d'un NOMBRE
"""
d0 = time.time()
nivbas = []
subips = []
subdvs = []
nivorg = []
sq1 = [0]
bi0 = [0]
 
def nombre(n_):
    """Introduction du NOMBRE"""
    norg = n_
    if n_ < 3:
        sq2 = sq3 = 1
    else:
        sq2 = int(sqrt(sqrt(norg)))
        sq3 = int(sqrt(sqrt(sqrt(norg))))
    bi0[0] = 0
    def cobas(c_):
        """Recherche d'un élément lié"""
        corg = c_
        w10 = 0
        if c_ < 1:
            # Si :c_: égale zéro
            c_ = 1
        if c_ < 4:
            # Si :c_: inférieur à 4
            # Petit NOMBRE solution
            nivbas.append(c_)
            nivbas.append(c_ // c_)
            nivbas.sort()
        else:
            # NOMBRE apte à recherche
            csq1 = int(sqrt(corg))
            if corg == norg:
                sq1[0] = csq1
            cs10 = csq1 + 1  # :csq1: Racine Carrée NOMBRE
            if sq2 < 3:
                cs20 = cs21 = sq2  # :sq2: R C de :csq1:
                cs30 = cs10
                cs40 = cs20
            else:
                cs20 = cs21 = sq2 - 1
                cs30 = int(sq2 + (sq3 ** 2.5))
                cs40 = int(csq1 - (sq3 ** 2.5))
            w2 = 0
            while 1:
                if csq1 < 4:
                    w10 = 1
                if not corg % cs10:
                    # Décrément de :cs10: à :cs40:
                    nivbas.append(cs10)
                    nivbas.append(corg // cs10)
                    break
                elif not corg % cs20 \
                        and sq2 > 1:
                    # Décrément :cs20:
                    nivbas.append(cs20)
                    nivbas.append(corg // cs20)
                    break
                elif not corg % cs21 \
                        and cs21 > 1:
                    # Incrément de :cs21: à :cs30:
                    nivbas.append(cs21)
                    nivbas.append(corg // cs21)
                    break
                if w10 == 1:
                    cs10 -= 1
                else:
                    if cs10 > cs40:
                        cs10 -= 1
                    if cs21 < cs30:
                        cs21 += 1
                    else:
                        w2 = 1
                    if len(nivbas) == 0 \
                            and w2 == 1:
                        cs20 -= 1
            if nivbas[0] == nivbas[1]:
                bi0[0] = 1
    def socom():
        """Alignement des multiplicateurs"""
        so2 = nv0 = nv1 = 0
        for so in nivbas:
            # :nivbas: niveau à démultiplier
            so2 += 1
            sub = so
            ssq1 = int(sqrt(sub))
            for sn in range(ssq1, 0, -1):
                if not sub % sn:
                    if so2 < 2:
                        sndv = sub // sn
                        subips.append(sn)
                        subips.append(sndv)
                        if bi0[0] == 1:
                            subdvs.append(sn)
                            subdvs.append(sndv)
                    elif bi0[0] != 1:
                        sndv = sub // sn
                        subdvs.append(sn)
                        subdvs.append(sndv)
            # Un peu d'ordre
            if nivbas[0] > nivbas[1]:
                nv0, nv1 = nivbas[1], nivbas[0]
            else:
                nv0, nv1 = nivbas[0], nivbas[1]
        print('ip %s  dv %s' % (nv0, nv1))
    def multis():
        """Multiplication élémentaire"""
        for mn in subips:
            # Table :subips: multiplicateurs
            for mo in subdvs:
                # Table :subdvs: multiplicandes
                mon = mn * mo
                if not norg % mon and mon < sq1[0] + 1 \
                        and mon not in nivorg:
                    nivorg.append(mon)
            # Liste ordonnée des multiplicateurs
            nivorg.sort()
    def communs(o_):
        """Production des multiplicandes"""
        con = o_
        for yn in con:
            ip = yn
            dv = norg // yn
            print('%s * %s  typ %s*%s' % (ip, dv, ip % 6, dv % 6))
    cobas(norg)
    if nivbas[0] == 1:
        # Et NOMBRE premier
        nivorg.append(nivbas[0])
    else:
        socom()
        multis()
    communs(nivorg)
    print('Ed', len(nivorg), 'typ', norg % 6, 'sq1', int(sq1[0]), sq2, sq3)
    print('Nphonic_0a.py En {}'.format(time.time() - d0))
 
uno = 12345678987654321
print('Cosmic', uno)
nombre(uno)

Invité · 13/05/2017, 10h47

Où plusieurs compteurs/cueilleurs sont étalés à plein vent, la prochaine étape serait de mettre en dictionnaire tous ces gadgets.
Malheureusement pour les plus grands nombres, le comptage est lent à cause des éléments à traiter.
Une fois ce compteur achevé, les types vont être utilisés à des fins de filtrage des actions à mener au niveau de la cueillette

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
 
#!/usr/bin/env python3.6
# -*- coding: utf-8 -*-
# Série communs. En Général Python
# Version : Tierse facture
import time
"""MusicAToumic En"""
# Programmes  Nphony_0a : 18 avril 2017
# Suite  à    Nphony_11 : 30 avril 2017
# Programmes Nphonic_0a : 1 mai 2017
# Programme Nphonic_11a : 13 mai 2017
"""Découvrir les multiples d'un NOMBRE
"""
d0 = time.time()
nivbas = []
nivrec = []
subips = []
subdvs = []
nivorg = []
sq1 = [0]
bi0 = [0]
 
def nombre(n_):
    """Introduction du NOMBRE"""
    norg = n_
    if n_ < 3:
        sq2 = sq3 = 1
    else:
        sq2 = int(norg**(1/4))
        sq3 = int(norg**(1/8))
    bi0[0] = 0
    def cobas(c_):
        """Recherche d'un élément lié"""
        corg = c_
        w10 = 0
        if c_ < 1:
            # Si :c_: égale zéro
            c_ = 1
        if c_ < 4:
            # Si :c_: inférieur à 4
            # Petit NOMBRE solution
            nivbas.append(c_ // c_)
            nivbas.append(c_)
        else:
            # NOMBRE apte à recherche
            csq1 = corg**(1/2)
            if corg == norg:
                sq1[0] = int(csq1)
            cs10 = sq1[0] + 1  # :csq1: Racine Carrée NOMBRE
            if sq2 < 3:
                cs20 = cs21 = sq2  # :sq2: R C de :csq1:
                cs51 = cs30 = cs10
                cs50 = cs40 = cs20
            else:
                cs20 = cs21 = sq2 - 1
                cs51 = cs30 = int(sq2 + (sq3 ** 3))
                cs50 = cs40 = int(csq1 - (sq3 ** 3))
            cs60 = cs61 = cs00 = int((int((csq1 - sq2)//2))**(1/2))
            c1 = c2 = c3 = c4 = c5 = c6 = c7 = 0 # Commun
            s1 = s2 = s3 = s4 = s5 = s6 = s7 = 0 # Absent
            w1 = 0
            while 1:
                w1 += 1
                if csq1 < 4: # Commence Racine :csq1:
                    w10 = 1
                # Section des cueilleurs
                if not corg % cs10 and s1 == 0\
                   and cs10 not in nivrec:
                    # Décrément de :cs10: à :cs40:
                    nivrec.append(cs10)
                    c1 = 1
                if not corg % cs50 and s2 == 0\
                   and cs50 not in nivrec:
                    # Décrément de :cs50: à :cs00:
                    nivrec.append(cs50)
                    c2 = 1
                if not corg % cs51 and s3 == 0\
                   and cs51 not in nivrec:
                    # Incrément de :cs51: à :cs00:
                    nivrec.append(cs51)
                    c3 = 1
                if not corg % cs60 and s4 == 0\
                   and cs60 not in nivrec:
                    # Décrément de :cs60: à :cs30:
                    nivrec.append(cs60)
                    c4 = 1
                if not corg % cs61 and s5 == 0\
                   and cs61 not in nivrec:
                    # Incrément de :cs61: à :cs40:
                    nivrec.append(cs61)
                    c5 = 1
                if not corg % cs21 and cs21 > 1\
                    and s6 == 0 and cs21 not in nivrec:
                    # Incrément de :cs21: à :cs30:
                    nivrec.append(cs21)
                    c6 = 1
                if not corg % cs20 and sq2 > 1\
                    and cs20 not in nivrec:
                    # Décrément de :cs20: à 0
                    nivrec.append(cs20)
                    c7 = 1
                # Section des compteurs
                if w10 == 1: # Clause :csq1<4:
                    cs10 -= 1
                else:
                    cgen = c1+c2+c3+c4+c5+c6+c7
                    sgen = s1+s2+s3+s4+s5+s6+s7
                    if cs10 > cs40 and c1 == 0:
                            cs10 -= 1
                    else: s1 = 1
                    if cs50 > cs00 and c2 == 0:
                        cs50 -=1
                    else: s2 = 1
                    if cs51 < cs00 and c3 == 0:
                        cs51 +=1
                    else: s3 = 1
                    if cs60 > cs30 and c4 == 0:
                        cs60 -=1
                    else: s4 = 1
                    if cs61 < cs40 and c5 == 0:
                        cs61 +=1
                    else: s5 = 1
                    if cs21 < cs30 and c6 == 0:
                        cs21 += 1
                    else: s6 = 1
                    if cs20 > 0 and sgen > 0 \
                       and cgen == 0:
                        cs20 -= 1
                    if cgen > 0 and sgen > 2:
                        nvmx = max(nivrec)
                        nivbas.append(nvmx)
                        nivbas.append(corg // nvmx)
                        break
            if nivbas[0] == nivbas[1]:
                bi0[0] = 1
    def socom():
        """Alignement des multiplicateurs"""
        so2 = nv0 = nv1 = 0
        for so in nivbas:
            # :nivbas: niveau à démultiplier
            so2 += 1
            sub = so
            ssq1 = int(sub**(1/2))
            for sn in range(ssq1, 0, -1):
                if not sub % sn:
                    if so2 < 2:
                        sndv = sub // sn
                        subips.append(sn)
                        subips.append(sndv)
                        if bi0[0] == 1:
                            subdvs.append(sn)
                            subdvs.append(sndv)
                    elif bi0[0] != 1:
                        sndv = sub // sn
                        subdvs.append(sn)
                        subdvs.append(sndv)
            # Un peu d'ordre
            if nivbas[0] > nivbas[1]:
                nv0, nv1 = nivbas[1], nivbas[0]
            else:
                nv0, nv1 = nivbas[0], nivbas[1]
        print('ip %s  dv %s' % (nv0, nv1))
    def multis():
        """Multiplication élémentaire"""
        for mn in subips:
            # Table :subips: multiplicateurs
            for mo in subdvs:
                # Table :subdvs: multiplicandes
                mon = mn * mo
                if not norg % mon and mon < sq1[0] + 1 \
                        and mon not in nivorg:
                    nivorg.append(mon)
            # Liste ordonnée des multiplicateurs
            nivorg.sort()
    def communs(o_):
        """Production des multiplicandes"""
        con = o_
        for yn in con:
            ip = yn
            dv = norg // yn
            print('%s * %s  typ %s*%s' % (ip, dv, ip % 6, dv % 6))
    cobas(norg)
    if nivbas[0] == 1:
        # Et NOMBRE premier
        nivorg.append(nivbas[0])
    else:
        socom()
        multis()
    communs(nivorg)
    print('Ed', len(nivorg), 'typ', norg % 6, 'sq1', sq1[0], sq2, sq3)
    print('Nphonic_11a.py En {}'.format(time.time() - d0))
 
uno = 3652123456737365212
print('Cosmic', uno)
nombre(uno)
# a**(1./b) racine ou a**.5
# Nombre avec un seul couple commun 365212345677

Invité · 13/05/2017, 13h22

Bonjour

Pour avancer, ont étés incorporés des compteurs/cueilleurs. Différenciés en étalage en pleine Racine Carrée

Tout un suivit des états trouvés et non trouvés, qui avant de se retrouver sous la forme d'un dictionnaire

Vont venir se présenter ici

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
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
 
#!/usr/bin/env python3.6
# -*- coding: utf-8 -*-
# Série communs. En Général Python
# Version : Tierse facture
import time
"""MusicAToumic En"""
# Programmes  Nphony_0a : 18 avril 2017
# Suite  à    Nphony_11 : 30 avril 2017
# Programmes Nphonic_0a : 1 mai 2017
# Programme Nphonic_11a : 13 mai 2017
"""Découvrir les multiples d'un NOMBRE
"""
d0 = time.time()
nivbas = []
nivrec = []
subips = []
subdvs = []
nivorg = []
sq1 = [0]
bi0 = [0]
 
def nombre(n_):
    """Introduction du NOMBRE"""
    norg = n_
    if n_ < 3:
        sq2 = sq3 = 1
    else:
        sq2 = int(norg**(1/4))
        sq3 = int(norg**(1/8))
    bi0[0] = 0
    def cobas(c_):
        """Recherche d'un élément lié"""
        corg = c_
        w10 = 0
        if c_ < 1:
            # Si :c_: égale zéro
            c_ = 1
        if c_ < 4:
            # Si :c_: inférieur à 4
            # Petit NOMBRE solution
            nivbas.append(c_ // c_)
            nivbas.append(c_)
        else:
            # NOMBRE apte à recherche
            csq1 = corg**(1/2)
            if corg == norg:
                sq1[0] = int(csq1)
            cs10 = sq1[0] + 1  # :csq1: Racine Carrée NOMBRE
            if sq2 < 3:
                cs20 = cs21 = sq2  # :sq2: R C de :csq1:
                cs51 = cs30 = cs10
                cs50 = cs40 = cs20
            else:
                cs20 = cs21 = sq2 - 1
                cs51 = cs30 = int(sq2 + (sq3 ** 3))
                cs50 = cs40 = int(csq1 - (sq3 ** 3))
            cs60 = cs61 = cs00 = int((int((csq1 - sq2)//2))**(1/2))
            c1 = c2 = c3 = c4 = c5 = c6 = c7 = 0 # Commun
            s1 = s2 = s3 = s4 = s5 = s6 = s7 = 0 # Absent
            w1 = 0
            while 1:
                w1 += 1
                if csq1 < 4: # Commence Racine :csq1:
                    w10 = 1
                # Section des cueilleurs
                if not corg % cs10 and s1 == 0\
                   and cs10 not in nivrec:
                    # Décrément de :cs10: à :cs40:
                    nivrec.append(cs10)
                    c1 = 1
                if not corg % cs50 and s2 == 0\
                   and cs50 not in nivrec:
                    # Décrément de :cs50: à :cs00:
                    nivrec.append(cs50)
                    c2 = 1
                if not corg % cs51 and s3 == 0\
                   and cs51 not in nivrec:
                    # Incrément de :cs51: à :cs00:
                    nivrec.append(cs51)
                    c3 = 1
                if not corg % cs60 and s4 == 0\
                   and cs60 not in nivrec:
                    # Décrément de :cs60: à :cs30:
                    nivrec.append(cs60)
                    c4 = 1
                if not corg % cs61 and s5 == 0\
                   and cs61 not in nivrec:
                    # Incrément de :cs61: à :cs40:
                    nivrec.append(cs61)
                    c5 = 1
                if not corg % cs21 and cs21 > 1\
                    and s6 == 0 and cs21 not in nivrec:
                    # Incrément de :cs21: à :cs30:
                    nivrec.append(cs21)
                    c6 = 1
                if not corg % cs20 and sq2 > 1\
                    and cs20 not in nivrec:
                    # Décrément de :cs20: à 0
                    nivrec.append(cs20)
                    c7 = 1
                # Section des compteurs
                if w10 == 1: # Clause :csq1<4:
                    cs10 -= 1
                else:
                    cgen = c1+c2+c3+c4+c5+c6+c7
                    sgen = s1+s2+s3+s4+s5+s6+s7
                    if cs10 > cs40 and c1 == 0:
                            cs10 -= 1
                    else: s1 = 1
                    if cs50 > cs00 and c2 == 0:
                        cs50 -=1
                    else: s2 = 1
                    if cs51 < cs00 and c3 == 0:
                        cs51 +=1
                    else: s3 = 1
                    if cs60 > cs30 and c4 == 0:
                        cs60 -=1
                    else: s4 = 1
                    if cs61 < cs40 and c5 == 0:
                        cs61 +=1
                    else: s5 = 1
                    if cs21 < cs30 and c6 == 0:
                        cs21 += 1
                    else: s6 = 1
                    if cs20 > 0 and sgen > 0 \
                       and cgen == 0:
                        cs20 -= 1
                    if cgen > 0 and sgen > 2:
                        nvmx = max(nivrec)
                        nivbas.append(nvmx)
                        nivbas.append(corg // nvmx)
                        break
            if nivbas[0] == nivbas[1]:
                bi0[0] = 1
    def socom():
        """Alignement des multiplicateurs"""
        so2 = nv0 = nv1 = 0
        for so in nivbas:
            # :nivbas: niveau à démultiplier
            so2 += 1
            sub = so
            ssq1 = int(sub**(1/2))
            for sn in range(ssq1, 0, -1):
                if not sub % sn:
                    if so2 < 2:
                        sndv = sub // sn
                        subips.append(sn)
                        subips.append(sndv)
                        if bi0[0] == 1:
                            subdvs.append(sn)
                            subdvs.append(sndv)
                    elif bi0[0] != 1:
                        sndv = sub // sn
                        subdvs.append(sn)
                        subdvs.append(sndv)
            # Un peu d'ordre
            if nivbas[0] > nivbas[1]:
                nv0, nv1 = nivbas[1], nivbas[0]
            else:
                nv0, nv1 = nivbas[0], nivbas[1]
        print('ip %s  dv %s' % (nv0, nv1))
    def multis():
        """Multiplication élémentaire"""
        for mn in subips:
            # Table :subips: multiplicateurs
            for mo in subdvs:
                # Table :subdvs: multiplicandes
                mon = mn * mo
                if not norg % mon and mon < sq1[0] + 1 \
                        and mon not in nivorg:
                    nivorg.append(mon)
            # Liste ordonnée des multiplicateurs
            nivorg.sort()
    def communs(o_):
        """Production des multiplicandes"""
        con = o_
        for yn in con:
            ip = yn
            dv = norg // yn
            print('%s * %s  typ %s*%s' % (ip, dv, ip % 6, dv % 6))
    cobas(norg)
    if nivbas[0] == 1:
        # Et NOMBRE premier
        nivorg.append(nivbas[0])
    else:
        socom()
        multis()
    communs(nivorg)
    print('Ed', len(nivorg), 'typ', norg % 6, 'sq1', sq1[0], sq2, sq3)
    print('Nphonic_11a.py En {}'.format(time.time() - d0))
 
uno = 9130308641843413
print('Cosmic', uno)
nombre(uno)
# a**(1./b) racine ou a**.5
# Nombre avec un seul couple commun 365212345677

Suite auquel va s'appliquer à filtrer la cueillette, en omettant certains compteurs...

Invité · 27/05/2017, 10h59

Après quelques versions évolutives, pour enfin parvenir à itérer par comparaison à un commun possible le moins "longtemps" possible. Précédemment, une série de points d'itérations mis en place à l'aide des racines carrées. Cette structure de lecteurs / cueilleurs finalisée, et selon quelques paramétrages du code. A plusieurs fonctionnements :

La sélection du premier commun rencontré. Moins important et plus rapide à itérer
Le cumul d'un unique commun par section. Permet un plus large choix de multiplicandes
Le cumul des communs aux préalables premiers. Intègre les tempéraments multiplicateurs

Le cumul des préalables premiers est facile, à condition que le sujet commun ait un de ces types (1, 5)

L'univers composé de la multiplication des tempéraments, est sûrement à matérialiser...

# Programme Nphonic_7cosica : 25 mai 2017 Causant comme une recherche instrumentalisée par le 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
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
 
#!/usr/bin/env python3.6
# -*- coding: utf-8 -*-
# Série communs. En Général Python
# Version : Tierse facture
import time
import copy
"""MusicAToumic En"""
# Programme   Nphonic_2cosic : 14 mai 2017
# Programme   Nphonic_5cosic : 24 mai 2017
# Programme  Nphonic_7cosica : 25 mai 2017
"""Découvrir les multiples d'un NOMBRE
1- Tableau(imem) des :ip;dv: de type (1, 5)
2- Copie (imem) sur tableau(itab)
3- Boucle (imem) sur (itab)
4- :ion1;ion2: Motif de progression
5- Modélisation :ip:
6- :print: Points d'analyses
Typogramme nucloïde
uo5 60432 u25 245 iut 60310
imem typ: 1 ou 5 long 5
itab long 14
1 * 3652123456  typ 1*4
2 * 1826061728  typ 2*2
4 * 913030864  typ 4*4
8 * 456515432  typ 2*2
16 * 228257716  typ 4*4
19 * 192217024  typ 1*4
32 * 114128858  typ 2*2
38 * 96108512  typ 2*2
64 * 57064429  typ 4*1
76 * 48054256  typ 4*4
152 * 24027128  typ 2*2
304 * 12013564  typ 4*4
608 * 6006782  typ 2*2
1216 * 3003391  typ 4*1
Cosmic 3652123456 typ 4 long 14
Nphonic_5cosic.py En 0.19465422630310059
"""
dod0 = time.time()
uno = 9
uo5 = int(uno**.5)
uo6 = uno % 6
u25 = int(uno**.25)
iut = (uo5 - u25)//2
#print('uo5', uo5,'u25', u25, 'iut', iut)
imem = []
itab = []
v = uo5 #:uo5: Racine(uno)
w = x = u25 #:u25: Racine(uo5)
u = 1
y = z = iut
#print('P0: u%sw%s x%sz%s y%sv%s'%(u,w,x,z,y,v))
while 1:
    #print('P1: u%sw%s x%sz%s y%sv%s'%(u,w,x,z,y,v))
    if not uno%u and u%6 in (2, 3) \
       and u < 6 and u not in imem:
        imem.append(u)
    if not uno%u and u%6 in (1, 5) \
       and u not in imem: #u = u(+1)
        imem.append(u)
    if (uno//u) % 6 in (1, 5) \
       and u not in imem \
       and not uno%(uno//u):
        imem.append(u)
    #print('u', imem)
    if v > y:
        if not uno%v and v not in imem:
            if v%6 in (1, 5):
                imem.append(v)
            elif v == uo5:
                imem.append(v)
        if (uno//v) % 6 in (1, 5) \
           and v not in imem \
           and not uno%(uno//v):
            imem.append(v)
        #print('v', imem)
    if not uno%x and x%6 in (1, 5) \
       and x not in imem: #x = u25(+1)
        imem.append(x)
    if (uno//x) % 6 in (1, 5) \
       and x not in imem \
       and not uno%(uno//x):
        imem.append(x)
    #print('x', imem)
    if w > u:
        if not uno%w \
           and w%6 in (1, 5) \
           and w not in imem: #w = u25(-1)
            imem.append(w)
        if (uno//w) % 6 in (1, 5) \
           and w not in imem \
           and not uno%(uno//w):
            imem.append(w)
        #print('w', imem)
    if not uno%y \
       and y%6 in (1, 5) \
       and y not in imem: #y = iut(+1)
        imem.append(y)
    if (uno//y) % 6 in (1, 5) \
       and y not in imem \
       and not uno%(uno//y):
        imem.append(y)
    #print('y', imem)
    if z > x:
        if not uno%z \
           and z%6 in (1, 5) \
           and z not in imem: #z = iut(-1)
            imem.append(z)
        if (uno//z) % 6 in (1, 5) \
           and z not in imem \
           and not uno%(uno//z):
            imem.append(z)
        #print('z', imem)
    z -= 1
    v -= 1
    w -= 1
    u += 1
    x += 1
    y += 1
    if u > w and x > z and y > v:
        print('P: u%sw%s x%sz%s y%sv%s'%(u,w,x,z,y,v))
        break
imem.sort()
itab = copy.copy(imem)
#print('imem typ: 1 ou 5', 'long', len(imem))
print('imem', imem)
ion1 = ion2 = 0
#print('itab1', itab)
while 1:
    ion1 = len(itab)
    for i in imem:
        for y in itab:
            i1 = y*i
            if i1 < uo5 and i1 not in itab \
               and not uno % i1:
                itab.append(i1)
    itab.sort()
    #print('it1', itab)
    ion2 = len(itab)
    if ion1 == ion2:
        break
#print('itab', 'long', len(itab))
d = 0
for i in itab:
    d = uno // i
    ip, dv = i, d
    if ip > dv:
        break
    else:
        print('%s * %s  typ %s*%s' % (ip, dv, ip % 6, dv % 6))
 
print('Cosmic', uno, 'typ', uo6, 'long', len(itab))
print('Nphonic_7cosica.py En {}'.format(time.time() - dod0))
 
 
 
 
#nombre(uno)

Invité · 04/06/2017, 08h05

Les nombres associés donnent du relief à en découdre les mailles de la multiplication

Car si on ne peut pas arrêter le poisson dans le filet (puisqu'étant piégé)
Au contraire, il y a des arêtes dans le filet du poisson (en prévision)

C'est en pleine marinade de la mer que nageraient les multiples, tout comme les nombres les poissons ont plusieurs types de pêche. Bien sûr il faut avoir plongé plusieurs fois dans les profondeurs océanes, pour vivre cette expérience commune au grand public. Enfin que d'entreprendre une réécriture, je propose une excuse

Un jour, une dictée codée, pour que l'expression soit un mode opératoire dans le domaine de la programmation en Python (dans le texte)

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
 
#!/usr/bin/env python3.6
# -*- coding: utf-8 -*-
# Série communs. En Général Python
# Version : Tierse facture
import time
import copy
"""MusicAToumic En"""
# Programme  Nphonic_9cosica : 3 juin 2017
# Programme       nphysic_0a : 3 juin 2017
# Programme        nphysic_1 : 3 juin 2017
"""Découvrir les multiples d'un NOMBRE
1- Tableau(imem) des :ip;dv: de type (1, 5)
2- Copie (imem) sur tableau(itab)
3- Boucle (imem) sur (itab)
4- :ion1::ion2: Motif de progression
5- Modélisation :ip:
6- :print: Points d'analyses
Typogramme nucloïde
P = Points d'itérations 'u15171w-14925...'
NP = Nombre Pemier: Signe '°'
NpP = Nombre préalable Premier: Types '1&5'
NpPip = Tableau :imem[ip(NpP)]: Résultat "ip"
NpPdv = Tableau :imem[dv(NpP)]: Résultat "ip"
NC = Nombre Commun :itab[NC]: Résultat "ip"
Les premiers tempéraments préalables NpP
Les démultiplications NpP produisent NC
Mes premiers pas sur sur cette échelle
P: u15171w-14925 x15415z14923 y45263v45262
imem [1, 2, 19, 64, 1216]
1° * 3652123456  typ 1*4 a | NpPip
2° * 1826061728  typ 2*2 a | NpPip
4 * 913030864  typ 4*4 a
8 * 456515432  typ 2*2 a
16 * 228257716  typ 4*4 a
19° * 192217024  typ 1*4 a | NpPip
32 * 114128858  typ 2*2 a_
38 * 96108512  typ 2*2 a_
64 * 57064429  typ 4*1 a | NpPdv
76 * 48054256  typ 4*4 a
152 * 24027128  typ 2*2 a
304 * 12013564  typ 4*4 a
608 * 6006782  typ 2*2 a
1216 * 3003391°  typ 4*1 A*B° | NpPdv
Cosmic 3652123456 typ 4 long 14
Nphonic_7cosica.py En 0.17653870582580566
"""
dod0 = d_d1 = time.time()
# Nombre original :onu:
onu = 456213879
# Copie circonstancielle
uno = onu
u1 = 0
if uno == 0: #:uno=0: Zéro issue
    uno = 1
    u1 = 1
uo5 = int(uno**.5)
uo6 = uno % 6
u25 = int(uno**.25)
iut = ((uo5 - u25)//2)
print('uo5(v):', uo5,'u25(w,x):', u25, 'iut(y,z):', iut)
imem = []
itab = []
v = uo5 #:uo5: Racine(uno)
w = x = u25 #:u25: Racine(uo5)
u = 1
y = z = iut
v_ = w_ = z_ = 0
print('P0: u%sw%s x%sz%s y%sv%s'%(u,w,x,z,y,v))
if u1 == 0: #Zéro issue
    while 1:
        #print('P1: u%sw%s x%sz%s y%sv%s'%(u,w,x,z,y,v))
        if not uno%u and u%6 in (2, 3) \
           and u < 6 and u not in imem:
            imem.append(u)
        if v > y - 1 and v_ == 0:
            if not uno%v and v not in imem:
                if v%6 in (1, 5):
                    imem.append(v)
                elif v == uo5:
                    imem.append(v)
            if y%6 in (1, 5) \
               and not uno%y \
               and y not in imem: #y = iut(+1)
                imem.append(y)
            if uo6 in (1, 5) and iut != 0:
                if (uno//v) % 6 in (1, 5) \
                   and v not in imem \
                   and not uno%(uno//v):
                    imem.append(v)
                if (uno//y) % 6 in (1, 5) \
                   and y not in imem \
                   and not uno%(uno//y):
                    imem.append(y)
        else:
            v_ = 1
        if w > u - 1 and w_ == 0:
            if not uno%w \
               and w%6 in (1, 5) \
               and w not in imem: #w = u25(-1)
                imem.append(w)
            if not uno%u and u%6 in (1, 5) \
               and u not in imem: #u = u(+1)
                imem.append(u)
            if uo6 in (1, 5) and iut != 0:
                if (uno//w) % 6 in (1, 5) \
                   and w not in imem \
                   and not uno%(uno//w):
                    imem.append(w)
                if (uno//u) % 6 in (1, 5) \
                   and u not in imem \
                   and not uno%(uno//u):
                    imem.append(u)
        else:
            w_ = 1
        if z > x - 1 and z_ == 0:
            if not uno%z \
               and z%6 in (1, 5) \
               and z not in imem: #z = iut(-1)
                imem.append(z)
            if not uno%x and x%6 in (1, 5) \
               and x not in imem: #x = u25(+1)
                imem.append(x)
            if uo6 in (1, 5) and iut != 0:
                if (uno//z) % 6 in (1, 5) \
                   and z not in imem \
                   and not uno%(uno//z):
                    imem.append(z)
                if (uno//x) % 6 in (1, 5) \
                   and x not in imem \
                   and not uno%(uno//x):
                    imem.append(x)
        else:
            z_ = 1
 
        if v_ == 0:
            v -= 1
            y += 1
        if w_ == 0:
            w -= 1
            u += 1
        if z_ == 0:
            z -= 1
            x += 1
        vwz = v_+ w_ + z_
        if vwz > 2:
            #print('P: u:%sw:%s x:%sz:%s y:%sv:%s'%(u,w,x,z,y,v))
            break
imem.sort()
itab = copy.copy(imem)
print(u1,'imem0', imem)
print('Partime En {}'.format(time.time() - d_d1))
ion1 = ion2 = 0
#print('itab1', itab)
if u1 == 0: #Zéro issue
    while 1:
        ion1 = len(itab)
        for i in imem:
            for y in itab:
                i1 = y*i
                if i1 < uo5 and i1 not in itab \
                   and not uno % i1:
                    itab.append(i1)
        itab.sort()
        #print('it1', itab)
        ion2 = len(itab)
        if ion1 == ion2:
            print('ion1',ion2)
            break
    #print('itab', itab,'long', len(itab))
    d = 0
    for i in itab:
        d = uno // i
        ip, dv = i, d
        if ip < dv or ip == dv: # Déblocage :uno = 2 ou 4:
            print('%s * %s  typ %s*%s' % (ip, dv, ip % 6, dv % 6))
else:
    # Zéro issue :uno;onu:
    print('%s * %s  typ %s*%s' % (uno, onu, uno % 6, onu % 6))
 
print('Cosmic', uno, 'typ', uo6, 'long', len(itab))
print('nphysic_1.py En {}'.format(time.time() - dod0))
 
 
 
 
#nombre(onu): Charge zéro
#nombre(uno): Charge unité

Invité · 29/06/2017, 19h17

Envoyé par toumic

Les nombres associés donnent du relief à en découdre les mailles de la multiplication

Pour parvenir à détecter les erreurs d'interprétation du programme "nphysic_1", il a fallut démultiplier le nombre "21"
En essayant avec "nphysic_1", il a pour résultat 1 * 21. Autant dire que pour lui le nombre "21" est un nombre premier

Mais non, une erreur était glissée, à cause du non conditionnement de la variable "iut", qui dans ce cas était inférieure à "u25"
Puis ça m'a permis de visiter le code en suivant une ligne d'analyse bien précise, et parfaire ce complexe qui reste à mes yeux

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
 
#!/usr/bin/env python3.6
# -*- coding: utf-8 -*-
# Série communs. En Général Python
# Version : Tierse facture
import time
import copy
"""MusicAToumic En"""
# Programme  Nphonic_9cosica : 3 juin 2017
# Programme       nphysic_0a : 3 juin 2017
# Programme       nphysic_2a : 28 juin 2017
"""Découvrir les multiples d'un NOMBRE
1- Tableau(imem) des :ip;dv: de type (1, 5)
2- Copie (imem) sur tableau(itab)
3- Boucle (imem) sur (itab)
4- :ion1::ion2: Motif de progression
5- Modélisation :ip:
6- :print: Points d'analyses
Typogramme nucloïde
P = Points d'itérations 'u15171w-14925...'
NP = Nombre Pemier: Signe '°'
NpP = Nombre préalable Premier: Types '1&5'
NpPip = Tableau :imem[ip(NpP)]: Résultat "ip"
NpPdv = Tableau :imem[dv(NpP)]: Résultat "ip"
NC = Nombre Commun :itab[NC]: Résultat "ip"
Les premiers tempéraments préalables NpP
Les démultiplications NpP produisent NC
Mes premiers pas sur sur cette échelle
"""
# Fonction :imemap: Nombres Premiers (NP)
"""
uo5(v): 60432 u25(w,x): 245 iut(y,z): 30093
P0: u1w245 x245z30093 y30093v60432
0 imem0 [1, 2, 19]
Partime 1 En 0.06004047393798828
ion1 14
1° * 3652123456  typ 1*4
2° * 1826061728  typ 2*2
4 * 913030864  typ 4*4
8 * 456515432  typ 2*2
16 * 228257716  typ 4*4
19° * 192217024  typ 1*4
32 * 114128858  typ 2*2
38 * 96108512  typ 2*2
64 * 57064429  typ 4*1
76 * 48054256  typ 4*4
152 * 24027128  typ 2*2
"""
# Carré² w = x = 245
"""
304 * 12013564  typ 4*4
608 * 6006782  typ 2*2
1216 * 3003391°  typ 4*1
"""
# Centre y = z = 30093
# Carré v = 60432
"""
Partime 2 En 0.045113325119018555
Cosmic 3652123456 typ 4 long 14
nphysic_1.py En 0.1216895580291748
"""
dod0 = d_d1 = time.time()
def onuno(uno):
    u1 = 0
    if uno == 0: #:uno=0: Zéro issue
        uno = 1
        u1 = 1
    uo5 = int(uno**.5)
    uo6 = uno % 6
    u25 = int(uno**.25)
    iut = ((uo5 - u25)//2)
    print('uo5(v):', uo5,'u25(w,x):', u25, 'iut(y,z):', iut)
    imem = []
    uzem = [0]
    v = uo5 #:uo5: Racine(uno)
    w = x = u25 #:u25: Racine(uo5)
    if iut > u25:
        u = 1
    else:
        u = 2
    y = z = iut
    v_ = w_ = z_ = 0
    # print('P0: u%sw%s x%sz%s y%sv%s'%(u,w,x,z,y,v))
    if u1 == 0: #Zéro issue
        # print('P1: u%sw%s x%sz%s y%sv%s'%(u,w,x,z,y,v))
        def imemap(uz):
            """ Les nombres premiers
            Des préalables premiers"""
            if not uno%uz and uz%6 in (1, 3, 5) \
               and uz < 8:
                imem.append(uz)
            i5 = sq5 = int(uz**.5)
            i2 = sq2 = int(uz**.25)
            i0 = (i5 - i2) // 2
            for i in range(i5, i0, -1):
                if not uz%i \
                   and i%6 in (1, 5):
                    break
            else:
                for i in range(i2, i0):
                    if not uz%i \
                   and i%6 in (1, 5):
                        break
                else:
                    for i in range(i2, 0, -1):
                        if not uz%i \
                           and i%6 in (1, 5):
                            if i > 1:
                                break
                            elif uz%6 in (1, 5):
                                imem.append(uz)
        while 1:
            if not uno%u and u%6 in (1, 2, 3) \
               and u < 6 and u not in imem:
                imem.append(u)
            if v > y - 1 and v_ == 0:
                if not uno%v and v not in imem:
                    if v%6 in (1, 5):
                        imemap(v)
                    elif v == uo5:
                        imemap(v)
                if y%6 in (1, 5) \
                   and not uno%y \
                   and y not in imem: #y = iut(+1)
                    imemap(y)
                if uo6 in (1, 5) and iut != 0:
                    if (uno//v) % 6 in (1, 5) \
                       and v not in imem \
                       and not uno%(uno//v):
                        imemap(v)
                    if (uno//y) % 6 in (1, 5) \
                       and y not in imem \
                       and not uno%(uno//y):
                        imemap(y)
            else:
                v_ = 1
            if w > u - 1 and w_ == 0:
                if not uno%w \
                   and w%6 in (1, 5) \
                   and w not in imem: #w = u25(-1)
                    imemap(w)
                if not uno%u and u%6 in (1, 5) \
                   and u not in imem \
                   and u > 1: #u = u(+1)
                    imemap(u)
                if uo6 in (1, 5) and iut != 0:
                    if (uno//w) % 6 in (1, 5) \
                       and w not in imem \
                       and not uno%(uno//w):
                        imemap(w)
                    if (uno//u) % 6 in (1, 5) \
                       and u not in imem \
                       and not uno%(uno//u):
                        imemap(u)
            else:
                w_ = 1
            if z > x - 1 and z_ == 0:
                if not uno%z \
                   and z%6 in (1, 5) \
                   and z not in imem: #z = iut(-1)
                    imemap(z)
                if not uno%x and x%6 in (1, 5) \
                   and x not in imem: #x = u25(+1)
                    imemap(x)
                if uo6 in (1, 5) and iut != 0:
                    if (uno//z) % 6 in (1, 5) \
                       and z not in imem \
                       and not uno%(uno//z):
                        imemap(z)
                    if (uno//x) % 6 in (1, 5) \
                       and x not in imem \
                       and not uno%(uno//x):
                        imemap(x)
            else:
                z_ = 1
            # Blanc
            if v_ == 0:
                v -= 1
                y += 1
            if w_ == 0:
                w -= 1
                u += 1
            if z_ == 0:
                z -= 1
                x += 1
            vwz = v_+ w_ + z_
            if vwz > 2:
                break
    # print('P2: u%sw%s x%sz%s y%sv%s'%(u,w,x,z,y,v))
    imem.sort()
    itab = copy.copy(imem)
    print('Nombres Premiers :ip:', imem)
    # d_d2 = time.time()
    ion1 = ion2 = 0
    if u1 == 0: #Zéro issue
        while 1:
            ion1 = len(itab)
            for i in imem:
                for y in itab:
                    i1 = y*i
                    if i1 not in itab \
                       and not uno % i1:
                        itab.append(i1)
            itab.sort()
            ion2 = len(itab)
            if ion1 == ion2:
                break
        # print('Partime 2 En {}'.format(time.time() - d_d2))
        # d_d3 = time.time()
        d = u = n = m = 0
        for i in itab:
            d = uno // i
            ip, dv = i, d
            if ip < dv or ip == dv: # Déblocage :uno = 2 ou 4:
                print('%s * %s  typ %s*%s' \
                      % (ip, dv, ip % 6, dv % 6))
        #print('Partime 3 En {}'.format(time.time() - d_d3))
    else:
        # Zéro issue :uno;onu:
        print('%s * %s  typ %s*%s' % \
              (uno, onu, uno % 6, onu % 6))
        uno = 0
 
    # print('Partime 2 En {}'.format(time.time() - d_d2))
    print('Cosmic', uno, 'typ', uo6, 'long', len(itab))
    print('nphysic_2a.py En {}'.format(time.time() - dod0))
# Nombre original :onu:
onu = 21
onuno(onu)
#nombre(onu): Charge zéro
#nombre(uno): Charge unité

Invité · 22/07/2017, 21h07

Le script précédent a de nombreuses lignes de code afin de fluidifier la recherche des nombres premiers sous-multiples d'un nombre entier.
Ce programme a un tableau qui réunit les nombres premiers allant de 2 à 227, ce qui signifie que la recherche des sous-multiples est limitée.
Et son avantage est qu'il fait gagner du temps, notamment celui de la recherche des nombres premiers, ce qui est intéressant pour les grands nombres.

L'avantage offert par cette démonstration est évident, lorsqu'on parle de l'organisation des nombres multiples communs.
Pour moi c'est une découverte essentielle, et une preuve du sérieux de mes recherches en gammologie numérique (dans le sens du nombre).

Voici le script qui prouve tout ce que j'avance :

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
 
#!/usr/bin/env python3.6
# -*- coding: utf-8 -*-
""" Ce script démontre l'utilisation des nombres premiers,
afin de produire les nombres communs du 'nombre_entier'.
Ceci n'est pas un résultat exhaustif, car il se limite à l'ensemble
du tableau 'premiers', dont le maximum étant 227.
"""
import time
import copy
t = time.time()
premiers = [
    2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59,
    61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127,
    131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191,
    193, 197, 199, 211, 223, 227
    ]   # Liste incomplète des nombres premiers
premiers_communs = []
nombre_entier = 123456
racine_carree = int(nombre_entier **.5)
for p in premiers:  # Les éléments du tableau
    if p <= racine_carree:  # La limite de la recherche
        if (nombre_entier / p).is_integer():
            premiers_communs.append(p)
    else : break
copie_ip = []
copie_ip = copy.copy(premiers_communs)
copie_ip.append(1)     # Utilisé pour les premiers termes
while 1:    # Production des multiples communs
    longueur1 = len(copie_ip)
    for c in premiers_communs:
        for o in copie_ip:
            co = int(c * o)
            if co <= racine_carree \
               and not nombre_entier % co and co not in copie_ip:
                copie_ip.append(co)
    longueur2 = len(copie_ip)
    if longueur1 == longueur2: break
copie_ip.sort()
print('ip', copie_ip)
print('nphermier1. En:{}'.format(time.time()-t))

Et si vous manquez de nombres premiers, complétez le tableau avec ce que ceci produira :

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
 
#!/usr/bin/env python3.6
# -*- coding: utf-8 -*-
# Série première. En Général Python
import time
t = time.time()
p0 = [2, 3, 5]
n0 = 9999999999
sq = int(n0**.5)
print('sq', sq)
for p1 in range(7, sq + 1, 6):
    p5 = p1 + 4
    pp1 = pp5 = 0
    for p in p0:
        if not p1 % p:
            pp1 = 1
        if not p5 % p:
            pp5 = 1
    if pp1 == 0:
        p0.append(p1)
    if pp5 == 0:
        p0.append(p5)
 
print(p0)
print(time.time()-t)

Invité · 30/07/2017, 17h46

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
336
337
338
339
 
#!/usr/bin/env python3.6
# -*- coding: utf-8 -*-
# Série communs. En Général Python
import time
import copy
"""MusicAToumic En"""
# Programme       nphysic_4a : 3 juillet 2017
# Programme        nphysic_5 : 16 juillet 2017
# Programme       nphysic_7a : 30 juillet 2017
"""Découvrir les multiples d'un NOMBRE
1- Tableau(imem[NP]) des :ip;dv: de type (1, 5)
2- Copie (imem) sur tableau(itab)
3- Boucle (imem) sur (itab)
4- :ion1::ion2: Motif de progression
5- Modélisation :ip:
6- :print: Points d'analyses
Typogramme nucloïde
P = Points d'itérations 'u15171w-14925...'
NP = Nombre Pemier: Signé '°'
NpP = Nombre préalable Premier: Types '1&5'
NpPip = Tableau :imem[ip(NP)]: Résultat "ip"
NpPdv = Tableau :imem[dv(NP)]: Résultat "ip"
NC = Nombre Commun :itab[NC]: Résultat "ip"
Les premiers tempéraments préalables NpP '1&5'
Fonction :imemap: Nombres Premiers NP
Les multiplications NP produisent NC
Mes premiers pas sur sur cette échelle
"""
dod0 = dod1 = time.time()
 
def onuno(uno):
    """ Pour un nombre :uno:
    À la recherche des sous-multiples
    """
    u1 = 0
    if uno == 0:  # :uno=0: Zéro issue
        uno = 1
        u1 = 1
    uo5 = so5 = int(uno ** .5)
    uo6 = uno % 6
    u25 = s25 = int(uno ** .25)
    iut = sut = ((uo5 - u25) // 2)
    # print('uo5(v):', uo5, 'u25(w,x):', u25, 'iut(y,z):', iut)
    """
    La partie suivante fabrique trois groupes liés (sut,so5,s25)
    Chaque groupe a un "[0]Type(1&5)". Sert au tri (1&5).
    "[1]Type(1)|[2]Type(5)". À raison des compteurs incrémentés :6:
    Et, en incrémentant de six chaque lignée (1&5), on ne rate pas
    le nombre préalable se trouvant sur la lignée(1), (occasionnel
    lorsqu'on incrémente uniquement la lignée (5)).
    """
    # Initialisations des tableaux-types
    s00 = []  # Goupe :sut:
    s01 = []  # Goupe :so5:
    s02 = []  # Goupe :s25:
    if int(sut % 6) in (1, 5):
        s00.append(int(sut % 6))
        if int(sut % 6) == 1:
            s00.append(sut)
            s00.append(sut + 4)
        else:
            s00.append(sut + 2)
            s00.append(sut)
    else:
        while 1:
            sut += 1
            if int(sut % 6) in (1, 5):
                s00.append(int(sut % 6))
                s00[0] = int(sut % 6)
                # :s00[0]: = nombre type état
                if int(sut % 6) == 1:
                    s00.append(sut)
                    s00.append(sut + 4)
                    # :s00[0]: = type 1
                    # :s00[1]: = nombre type 1
                    # :s00[2]: = nombre type 5
                else:
                    s00.append(sut + 2)
                    s00.append(sut)
                    # :s00[0]: = type 5
                    # :s00[1]: = nombre type 1
                    # :s00[2]: = nombre type 5
                break
 
    if int(so5 % 6) in (1, 5):
        s01.append(int(so5 % 6))
        # :s01[0]: = nombre type état
        if int(so5 % 6) == 1:
            s01.append(so5)
            s01.append(so5 + 4)
            # :s01[0]: = type 1
            # :s01[1]: = nombre type 1
            # :s01[2]: = nombre type 5
        else:
            s01.append(so5 + 2)
            s01.append(so5)
            # :s01[0]: = type 5
            # :s01[1]: = nombre type 1
            # :s01[2]: = nombre type 5
    else:
        while 1:
            so5 += 1
            if int(so5 % 6) in (1, 5):
                s01.append(int(so5 % 6))
                if int(so5 % 6) == 1:
                    s01.append(so5)
                    s01.append(so5 + 4)
                else:
                    s01.append(so5 + 2)
                    s01.append(so5)
                break
 
    if int(s25 % 6) in (1, 5):
        s02.append(int(s25 % 6))
        # :s02[0]: = nombre type état s25
        if int(s25 % 6) == 1:
            s02.append(s25)
            s02.append(s25 + 4)
            # :s02[0]: = type 1
            # :s02[1]: = nombre type 1
            # :s02[2]: = nombre type 5
        else:
            s02.append(s25 + 2)
            s02.append(s25)
            # :s02[0]: = type 5
            # :s02[1]: = nombre type 1
    else:
        while 1:
            s25 -= 1
            if int(s25 % 6) in (1, 5):
                s02.append(int(s25 % 6))
                if int(s25 % 6) == 1:
                    s02.append(s25)
                    s02.append(s25 + 4)
                else:
                    s02.append(s25 + 2)
                    s02.append(s25)
                break
    # Affectations des compteurs-types
    """v = s01[1)  # :so5: Racine(uno). Type 1
    w = x = s02[1]  # :s25: Racine(so5). Type 1
    :v5,y5,w5,z5,x5: Sont de type 5
    """
    # Section :v >= y:
    v = s01[1]  # Nombre type 1
    v5 = s01[2]  # Nombre type 5
    y = s00[1]  # Nombre type 1
    y5 = s00[2]  # ...
    # Section :w >= u:
    """:u: est incrémenté de 1"""
    w = s02[1]
    w5 = s02[2]
    # Section :z >= x:
    z = s00[1]
    z5 = s00[2]
    x = s02[1]
    x5 = s02[2]
    # print('s01:%s s00:%s s02:%s' % (s01, s00, s02))
    # Tableau :imem[ip(NP)]:
    imem = []
    if iut > u25:  # Si oui: Commence à 1
        u = 1
    else:  # Si non: Commence à 2. Sinon ERREUR
        u = 2
    v_ = w_ = z_ = 0  # Indices des fins (v_ pour v...)
    if u1 == 0:  # Zéro issue
        # Fonction d'appel à condition NP
        def imemap(uz):
            """ Les nombres premiers NP
            Des préalables premiers :uz: déjà '1&5' """
            # Condition du niveau bas (1, 2, 3, 4, 5, 6, 7)
            if not uno % uz and uz % 6 in (1, 3, 5) \
               and uz < 8:
                imem.append(uz)  # Tableau :imem[ip(NP)]:
            else:
                # print(uz, 'mim2', imem)
                # :rim: Reconstruction à chaque tour
                rim = [mm for mm in imem if mm > 1]
                for rr in rim:
                    if not uz % rr:
                        r0 = 1
                        break
                else:
                    # Rapports des racines carrées :uz:
                    sq5 = int(uz ** .5)
                    sq2 = int(uz ** .25)
                    i0 = (sq5 - sq2) // 2  # Entre :sq2: et :sq5:
                    # :iep: Ordonnée de carré à carré²
                    # print('sq5:%s sq2:%s i0:%s' % (sq5, sq2, i0))
                    q = 0
                    for iep in range(sq5, i0, -1):
                        if not uz % iep \
                           and iep % 6 in (1, 5):
                            r0 = 1
                            break
                        if not uz % (uz // iep) \
                           and (uz // iep) % 6 in (1, 5):
                            r0 = 1
                            break
                        o = sq2 + q  # Ordonnée de carré² incrémenté
                        if o > 1:
                            if not uz % o \
                               and o % 6 in (1, 5):
                                r0 = 1
                                break
                            if not uz % (uz // o) \
                               and (uz // o) % 6 in (1, 5):
                                r0 = 1
                                break
                        p = sq2 - q  # Ordonnée de carré² décrémenté
                        if p > 1:
                            if not uz % p \
                               and p % 6 in (1, 5):
                                r0 = 1
                                break
                            if not uz % (uz // p) \
                               and (uz // p) % 6 in (1, 5):
                                r0 = 1
                                break
                        q += 1
                    else:
                        r0 = 0
                if r0 == 0:  # :for: Condition vide, donc.
                    imem.append(uz)
                    # Nombre premier NP
        # À la recherche des sous-multiples
        while 1:
            # Ordonnée conditionnée aux sous-multiples
            # Condition du niveau bas (1, 2, 3, 4, 5)
            if not uno % u and u % 6 in (1, 2, 3, 5) \
               and u < 6 and u not in imem:
                imem.append(u)  # Tableau :imem[ip(NP)]:
            # :v >= y::sq5|sut:
            if v >= y and v_ == 0:  # Si oui: Faire
                if not uno % v and v not in imem:
                    imemap(v)  # Appel :imemap: Sortant :v: NpP
                    if v == uo5:  # Le carré est rencontré
                        imemap(v)
                if not uno % v5 and v5 not in imem:
                    imemap(v5)  # Appel :imemap: Sortant :v5: NpP
                    if v5 == uo5:  # Le carré est rencontré
                        imemap(v5)
                if not uno % y \
                   and y not in imem:  # y = iut(+1)
                    imemap(y)
                if not uno % y5 \
                   and y5 not in imem:  # y5 = iut(+1)
                    imemap(y5)
            else:  # Si non: Indice terminal
                v_ = 1
 
            # :w >= u::s25|u:
            if w >= u - 6 and w_ == 0:  # Si oui: Faire
                if not uno % w \
                   and w not in imem:  # w = u25(-1)
                    imemap(w)  # Appel :imemap: Sortant :w: NpP
                if not uno % u and u not in imem \
                   and u % 6 in (1, 5) \
                   and u > 1:  # u = u(+1)
                    imemap(u)
                if not uno % w5 \
                   and w5 not in imem:  # w5 = u25(-1)
                    imemap(w5)  # Appel :imemap: Sortant :w5: NpP
            else:  # Si non: Indice terminal
                w_ = 1
 
            # :z >= x::sut|s25:
            if z >= x and z_ == 0:  # Si oui: Faire z_
                if not uno % z \
                   and z not in imem:  # z = iut(-1)
                    imemap(z)
                if not uno % x \
                   and x not in imem:  # x = u25(+1)
                    imemap(x)
                if not uno % z5 \
                   and z5 not in imem:  # z5 = iut(-1)
                    imemap(z5)
                if not uno % x5 \
                   and x5 not in imem:  # x5 = u25(+1)
                    imemap(x5)
            else:  # Si non: Indice terminal z_
                z_ = 1
            # Ordonnées positives et négatives
            if v_ == 0:
                v -= 6  # sq5 typ1
                y += 6  # sut typ1
                v5 -= 6  # sq5 typ5
                y5 += 6  # sut typ5
            if w_ == 0:
                w -= 6  # s25 typ1
                u += 1  # u
                w5 -= 6  # s25 typ5
            if z_ == 0:
                z -= 6  # sut typ1
                x += 6  # s25 typ1
                z5 -= 6  # sut typ5
                x5 += 6  # s25 typ5
            vwz = v_ + w_ + z_  # :vwz: Cumul des terminaux
            if vwz > 2:  # :vwz=3: Le tour est fait !
                break
    # Tableau :imem[ip(NP)]: Trier
    imem.sort()
    # 2- Copie (imem) sur tableau(itab)
    itab = copy.copy(imem)
    print('Nombres Premiers :ip:', imem)  # Affiche (les) NP
    # print('En {}'.format(time.time() - dod1))
    if u1 == 0:  # Zéro issue
        # Les multiplications NP produisent NC
        while 1:
            ion1 = len(itab)
            for i in imem:
                for y in itab:
                    i1 = y * i
                    if i1 not in itab \
                       and not uno % i1:
                        itab.append(i1)
                        # NC = Nombre Commun :itab[NC]: Résultat "ip"
            itab.sort()
            ion2 = len(itab)
            if ion1 == ion2:  # 4- :ion1::ion2: Motif de progression
                break
        for i in itab:  # Démultiplier :i: produire :d:
            d = uno // i
            ip, dv = i, d
            if ip < dv or ip == dv:  # Déblocage :uno = 2 ou 4:
                print('%s * %s  typ %s*%s' % (ip, dv, ip % 6, dv % 6))
    else:
        # Zéro issue :uno;onu:
        print('%s * %s  typ %s*%s' % (uno, onu, uno % 6, onu % 6))
        uno = 0
    print('Cosmic', uno, 'typ', uo6, 'long', len(itab))
    print('nphysic_7a.py En {}'.format(time.time() - dod0))
 
# Nombre original :onu:
onu = 2468135790
onuno(onu)
# nombre(onu): Charge zéro
# nombre(uno): Charge unité

Invité · 15/08/2017, 20h02

Bonjour, voici la dernière d'autant plus véloce qu'intéressante

Choisissez nphysic_8a.py, bien sûr

Erreurs avec les petits nombres, en voie de correction

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
336
337
338
339
340
341
342
343
344
345
346
 
#!/usr/bin/env python3.6
# -*- coding: utf-8 -*-
# Série communs. En Général Python
import time
import copy
"""MusicAToumic En"""
# Programme        nphysic_5 : 16 juillet 2017
# Programme       nphysic_7a : 30 juillet 2017
# Programme        nphysic_8 : 31 juillet 2017
# Programme       nphysic_8a : 15 août 2017
"""Découvrir les multiples d'un NOMBRE
1- Tableau(imem[NP]) des :ip;dv: de type (1, 5)
2- Copie (imem) sur tableau(itab)
3- Boucle (imem) sur (itab)
4- :ion1::ion2: Motif de progression
5- Modélisation :ip:
6- :print: Points d'analyses
Typogramme nucloïde
P = Points de récupération 'u15171w-14925...'
NP = Nombre Pemier: Signé '°'
NpP = Nombre préalable Premier: Types '1&5'
NpPip = Tableau :imem[ip(NP)]: Résultat "ip"
NpPdv = Tableau :imem[dv(NP)]: Résultat "ip"
NC = Nombre Commun :itab[NC]: Résultat "ip"
Les premiers tempéraments préalables NpP '1&5'
Fonction :imemap: Nombres Premiers NP
Les multiplications NP produisent NC
Mes premiers pas sur sur cette échelle
"""
dod0 = dod1 = time.time()
 
def onuno(uno):
    """ Pour un nombre :uno:
    À la recherche des sous-multiples
    """
    u1 = 0
    if uno == 0:  # :uno=0: Zéro issue
        uno = 1
        u1 = 1
    uo5 = so5 = int(uno ** .5)
    uo6 = uno % 6
    u25 = s25 = int(uno ** .25)
    iut = sut = ((uo5 - u25) // 2)  # print('uo5(v):', uo5, 'iut(y,z):', iut, 'u25(w,x):', u25)
    """
    La partie suivante fabrique trois groupes liés (sut,so5,s25)
    Chaque groupe a un "[0]Type(1&5)". Sert au tri (1&5).
    "[1]Type(1)|[2]Type(5)". À raison des compteurs incrémentés :6:
    Et, en incrémentant de six chaque lignée (1&5), on ne rate pas
    le nombre préalable se trouvant sur la lignée(1), (occasionnel
    lorsqu'on incrémente uniquement la lignée (5)).
    """
    # Initialisations des tableaux-types
    s00 = []  # Goupe :sut:
    s01 = []  # Goupe :so5:
    s02 = []  # Goupe :s25:
    if int(sut % 6) in (1, 5):
        s00.append(int(sut % 6))
        if s00[0] == 1:
            s00.append(sut)
            s00.append(sut + 4)
            # :s00[0]: = type état 1
            # :s00[1]: = nombre type 1
            # :s00[2]: = nombre type 5
        else:
            s00.append(sut + 2)
            s00.append(sut)
            # :s00[0]: = type état 5
            # :s00[1]: = nombre type 1
            # :s00[2]: = nombre type 5
    else:
        while 1:
            sut += 1
            if int(sut % 6) in (1, 5):
                s00.append(int(sut % 6))
                s00[0] = int(sut % 6)
                # :s00[0]: = nombre type état
                if s00[0] == 1:
                    s00.append(sut)
                    s00.append(sut + 4)
                else:
                    s00.append(sut + 2)
                    s00.append(sut)
                break
    if int(so5 % 6) in (1, 5):
        s01.append(int(so5 % 6))
        # :s01[0]: = nombre type état
        if s01[0] == 1:
            s01.append(so5)
            s01.append(so5 + 4)
        else:
            s01.append(so5 + 2)
            s01.append(so5)
    else:
        while 1:
            so5 -= 1
            if int(so5 % 6) in (1, 5):
                s01.append(int(so5 % 6))
                if s01[0] == 1:
                    s01.append(so5)
                    s01.append(so5 + 4)
                else:
                    s01.append(so5 - 4)
                    s01.append(so5)
                break
    if int(s25 % 6) in (1, 5):
        s02.append(int(s25 % 6))
        # :s02[0]: = nombre type état s25
        if s02[0] == 1:
            s02.append(s25)
            s02.append(s25 + 4)
        else:
            s02.append(s25 + 2)
            s02.append(s25)
    else:
        while 1:
            s25 += 1
            if int(s25 % 6) in (1, 5):
                s02.append(int(s25 % 6))
                if s02[0] == 1:
                    s02.append(s25)
                    s02.append(s25 + 4)
                else:
                    s02.append(s25 + 2)
                    s02.append(s25)
                break
    # Affectations des compteurs-types
    """v = s01[1)  # :so5: Racine(uno). Type 1
    w = x = s02[1]  # :s25: Racine(so5). Type 1
    :v5,y5,w5,z5,x5: Sont de type 5
    """
    # Section :v >= y:
    v = s01[1]  # Nombre type 1
    v5 = s01[2]  # Nombre type 5
    y = s00[1]  # Nombre type 1
    y5 = s00[2]  # ...
    # Section :w >= u:
    """:u: est incrémenté de 1"""
    w = s02[1]
    w5 = s02[2]
    # Section :z >= x:
    z = s00[1]
    z5 = s00[2]
    x = s02[1]
    x5 = s02[2]  #
    print('s01:%s s00:%s s02:%s' % (s01, s00, s02))
    # Généralités repèrées
    v1 = s01[1] - int(s02[1] ** 1.5)
    z1 = s00[1] - int(s02[1] ** 1.5)
    if v1 % 6 != 1:
        if v1 % 6 == 0:
            v1 += 1
        else:
            v2 = v1 % 6 - 1
            v1 -= v2
    if z1 % 6 != 1:
        if z1 % 6 == 0:
            z1 += 1
        else:
            v2 = v1 % 6 - 1
            z1 -= v2
    # Tableau :imem[ip(NP)]:
    imem = []
    if iut > u25:  # Si oui: Commence à 1
        u = 1
    else:  # Si non: Commence à 2. Sinon ERREUR
        u = 2
    v_ = w_ = z_ = 0  # Indices des terminaux (v_ pour v...)
    # Fonction d'appel à condition NP
    def imemap(uz):
        # print('uz', uz)
        """ Les nombres premiers NP
        Des préalables premiers :uz: déjà '1&5' """
        # Condition du niveau bas (1, 2, 3, 4, 5, 6, 7)
        if not uno % uz and uz % 6 in (1, 3, 5) \
                and uz < 8:
            imem.append(uz)  # Tableau :imem[ip(NP)]:
        else:
            # :rim: Reconstruction à chaque tour
            rim = [mm for mm in imem if mm > 1]
            for rr in rim:
                if not uz % rr:
                    r0 = 1
                    break
            else:
                # Rapports des racines carrées :uz:
                sq5 = int(uz ** .5)
                sq2 = int(uz ** .25)
                ind0 = (sq5 - sq2) // 2  # Entre :sq2: et :sq5:
                # :iep: Ordonnée de carré à carré²
                # print('sq5:%s sq2:%s i0:%s' % (sq5, sq2, i0))
                q = 0
                for iep in range(sq5, ind0, -1):
                    if not uz % iep \
                            and iep % 6 in (1, 5):
                        r0 = 1
                        break
                    if not uz % (uz // iep) \
                            and (uz // iep) % 6 in (1, 5):
                        r0 = 1
                        break
                    o = sq2 + q  # Ordonnée de carré² incrémenté
                    if o > 1:
                        if not uz % o \
                                and o % 6 in (1, 5):
                            r0 = 1
                            break
                        if not uz % (uz // o) \
                                and (uz // o) % 6 in (1, 5):
                            r0 = 1
                            break
                    p = sq2 - q  # Ordonnée de carré² décrémenté
                    if p > 1:
                        if not uz % p \
                                and p % 6 in (1, 5):
                            r0 = 1
                            break
                        if not uz % (uz // p) \
                                and (uz // p) % 6 in (1, 5):
                            r0 = 1
                            break
                    q += 1
                else:
                    r0 = 0
            if r0 == 0:  # :for: Condition vide, donc.
                imem.append(uz)
                # Nombre premier NP
    if u1 == 0:  # Zéro issue
        # À la recherche des sous-multiples
        while 1:
            # Ordonnée conditionnée aux sous-multiples
            # Condition du niveau bas (1, 2, 3, 4, 5)
            if not uno % u and u % 6 in (1, 2, 3, 5) \
                    and u < 6 and u not in imem:
                imem.append(u)  # Tableau :imem[ip(NP)]:
            # :v >= y: :sq5|sut: Environnement
            if v > v1 and v_ == 0:  # Si oui: Faire
                if not uno % v and v not in imem:
                    imemap(v)  # Envoi :imemap: Sortant :v: NpP
                    if v == uo5:  # Carré rencontré Type 1
                        imemap(v)
                if not uno % v5 and v5 not in imem \
                        and v5 > 1:
                    imemap(v5)  # Envoi :imemap: Sortant :v5: NpP
                    if v5 == uo5:  # Carré rencontré Type 5
                        imemap(v5)
                if not uno % y \
                        and y not in imem:  # y = iut(+6)
                    imemap(y)
                if not uno % y5 \
                        and y5 not in imem:  # y5 = iut(+6)
                    imemap(y5)
            else:  # Si non: Indice terminal
                v_ = 1
            # :w >= u: :s25|u: Environnement
            if w >= u - 6 and w_ == 0:  # Si oui: Faire
                if not uno % w \
                        and w not in imem:  # w = u25(-6)
                    imemap(w)
                if not uno % u and u not in imem \
                        and u % 6 in (1, 5) \
                        and u > 1:  # u = u(+1)
                    imemap(u)
                if not uno % w5 and w5 > 1 \
                        and w5 not in imem:  # w5 = u25(-6)
                    imemap(w5)
            else:  # Si non: Indice terminal
                w_ = 1
            # :z >= x: :sut|s25: Environnement
            if z > z1 and z_ == 0:  # Si oui: Faire z_
                if not uno % z \
                        and z not in imem:  # z = iut(-6)
                    imemap(z)
                if not uno % x \
                        and x not in imem:  # x = u25(+6)
                    imemap(x)
                if not uno % z5 \
                        and z5 not in imem:  # z5 = iut(-6)
                    imemap(z5)
                if not uno % x5 \
                        and x5 not in imem:  # x5 = u25(+6)
                    imemap(x5)
            else:  # Si non: Indice terminal z_
                z_ = 1
            # Ordonnées positives et négatives
            if v_ == 0:
                v -= 6  # sq5 typ1
                y += 6  # sut typ1
                v5 -= 6  # sq5 typ5
                y5 += 6  # sut typ5
            if w_ == 0:
                w -= 6  # s25 typ1
                u += 1  # u
                w5 -= 6  # s25 typ5
            if z_ == 0:
                z -= 6  # sut typ1
                x += 6  # s25 typ1
                z5 -= 6  # sut typ5
                x5 += 6  # s25 typ5
            vwz = v_ + w_ + z_  # :vwz: Cumul des terminaux
            if vwz > 2:  # :vwz=3: Le tour est fait !
                break
    # Tableau :imem[ip(NP)]: Trier
    imem.sort()
    # 2- Copie (imem) sur tableau(itab)
    itab = copy.copy(imem)
    # print('En {}'.format(time.time() - dod1))
    if u1 == 0:  # Zéro issue
        # Les multiplications NP produisent NC
        while 1:
            ion1 = len(itab)
            for i in imem:
                for y in itab:
                    i0 = y * i
                    if i0 > s01[1]:
                        i1 = uno // i0
                        if i1 not in imem:
                            imemap(i1)
                    else:
                        i1 = i0
                    if i1 not in itab \
                            and not uno % i1:
                        itab.append(i1)
                        # NC = Nombre Commun :itab[NC]: Résultat "ip"
            itab.sort()
            ion2 = len(itab)
            if ion1 == ion2:  # 4- :ion1::ion2: Motif de progression
                imem = copy.copy(itab)
                print('Nombres Premiers :ip:', imem)  # Affiche (les) NP
                break
        for i in itab:  # Démultiplier :i: produire :d:
            d = uno // i
            ip, dv = i, d
            if ip < dv or ip == dv:  # Déblocage :uno = 2 ou 4:
                print('%s * %s  typ %s*%s' % (ip, dv, ip % 6, dv % 6))
    else:
        # Zéro issue :uno;onu:
        print('%s * %s  typ %s*%s' % (uno, onu, uno % 6, onu % 6))
        uno = 0
        uo6 = uno % 6
    print('Cosmic', uno, 'typ', uo6, 'long', len(itab))
    print('nphysic_8a.py En {}'.format(time.time() - dod0))
 
# Nombre original :onu:
onu = 98
onuno(onu)

Invité · 16/08/2017, 19h13

Envoyé par toumic

Bonjour, voici la dernière d'autant plus véloce qu'intéressante

Choisissez nphysic_8a.py, bien sûr

Erreurs avec les petits nombres, en voie de correction

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
336
337
338
339
340
341
342
343
344
345
346
 
#!/usr/bin/env python3.6
# -*- coding: utf-8 -*-
# Série communs. En Général Python
import time
import copy
"""MusicAToumic En"""
# Programme        nphysic_5 : 16 juillet 2017
# Programme       nphysic_7a : 30 juillet 2017
# Programme        nphysic_8 : 31 juillet 2017
# Programme       nphysic_8a : 15 août 2017
"""Découvrir les multiples d'un NOMBRE
1- Tableau(imem[NP]) des :ip;dv: de type (1, 5)
2- Copie (imem) sur tableau(itab)
3- Boucle (imem) sur (itab)
4- :ion1::ion2: Motif de progression
5- Modélisation :ip:
6- :print: Points d'analyses
Typogramme nucloïde
P = Points de récupération 'u15171w-14925...'
NP = Nombre Pemier: Signé '°'
NpP = Nombre préalable Premier: Types '1&5'
NpPip = Tableau :imem[ip(NP)]: Résultat "ip"
NpPdv = Tableau :imem[dv(NP)]: Résultat "ip"
NC = Nombre Commun :itab[NC]: Résultat "ip"
Les premiers tempéraments préalables NpP '1&5'
Fonction :imemap: Nombres Premiers NP
Les multiplications NP produisent NC
Mes premiers pas sur sur cette échelle
"""
dod0 = dod1 = time.time()
 
def onuno(uno):
    """ Pour un nombre :uno:
    À la recherche des sous-multiples
    """
    u1 = 0
    if uno == 0:  # :uno=0: Zéro issue
        uno = 1
        u1 = 1
    uo5 = so5 = int(uno ** .5)
    uo6 = uno % 6
    u25 = s25 = int(uno ** .25)
    iut = sut = ((uo5 - u25) // 2)  # print('uo5(v):', uo5, 'iut(y,z):', iut, 'u25(w,x):', u25)
    """
    La partie suivante fabrique trois groupes liés (sut,so5,s25)
    Chaque groupe a un "[0]Type(1&5)". Sert au tri (1&5).
    "[1]Type(1)|[2]Type(5)". À raison des compteurs incrémentés :6:
    Et, en incrémentant de six chaque lignée (1&5), on ne rate pas
    le nombre préalable se trouvant sur la lignée(1), (occasionnel
    lorsqu'on incrémente uniquement la lignée (5)).
    """
    # Initialisations des tableaux-types
    s00 = []  # Goupe :sut:
    s01 = []  # Goupe :so5:
    s02 = []  # Goupe :s25:
    if int(sut % 6) in (1, 5):
        s00.append(int(sut % 6))
        if s00[0] == 1:
            s00.append(sut)
            s00.append(sut + 4)
            # :s00[0]: = type état 1
            # :s00[1]: = nombre type 1
            # :s00[2]: = nombre type 5
        else:
            s00.append(sut + 2)
            s00.append(sut)
            # :s00[0]: = type état 5
            # :s00[1]: = nombre type 1
            # :s00[2]: = nombre type 5
    else:
        while 1:
            sut += 1
            if int(sut % 6) in (1, 5):
                s00.append(int(sut % 6))
                s00[0] = int(sut % 6)
                # :s00[0]: = nombre type état
                if s00[0] == 1:
                    s00.append(sut)
                    s00.append(sut + 4)
                else:
                    s00.append(sut + 2)
                    s00.append(sut)
                break
    if int(so5 % 6) in (1, 5):
        s01.append(int(so5 % 6))
        # :s01[0]: = nombre type état
        if s01[0] == 1:
            s01.append(so5)
            s01.append(so5 + 4)
        else:
            s01.append(so5 + 2)
            s01.append(so5)
    else:
        while 1:
            so5 -= 1
            if int(so5 % 6) in (1, 5):
                s01.append(int(so5 % 6))
                if s01[0] == 1:
                    s01.append(so5)
                    s01.append(so5 + 4)
                else:
                    s01.append(so5 - 4)
                    s01.append(so5)
                break
    if int(s25 % 6) in (1, 5):
        s02.append(int(s25 % 6))
        # :s02[0]: = nombre type état s25
        if s02[0] == 1:
            s02.append(s25)
            s02.append(s25 + 4)
        else:
            s02.append(s25 + 2)
            s02.append(s25)
    else:
        while 1:
            s25 += 1
            if int(s25 % 6) in (1, 5):
                s02.append(int(s25 % 6))
                if s02[0] == 1:
                    s02.append(s25)
                    s02.append(s25 + 4)
                else:
                    s02.append(s25 + 2)
                    s02.append(s25)
                break
    # Affectations des compteurs-types
    """v = s01[1)  # :so5: Racine(uno). Type 1
    w = x = s02[1]  # :s25: Racine(so5). Type 1
    :v5,y5,w5,z5,x5: Sont de type 5
    """
    # Section :v >= y:
    v = s01[1]  # Nombre type 1
    v5 = s01[2]  # Nombre type 5
    y = s00[1]  # Nombre type 1
    y5 = s00[2]  # ...
    # Section :w >= u:
    """:u: est incrémenté de 1"""
    w = s02[1]
    w5 = s02[2]
    # Section :z >= x:
    z = s00[1]
    z5 = s00[2]
    x = s02[1]
    x5 = s02[2]  #
    print('s01:%s s00:%s s02:%s' % (s01, s00, s02))
    # Généralités repèrées
    v1 = s01[1] - int(s02[1] ** 1.5)
    z1 = s00[1] - int(s02[1] ** 1.5)
    if v1 % 6 != 1:
        if v1 % 6 == 0:
            v1 += 1
        else:
            v2 = v1 % 6 - 1
            v1 -= v2
    if z1 % 6 != 1:
        if z1 % 6 == 0:
            z1 += 1
        else:
            v2 = v1 % 6 - 1
            z1 -= v2
    # Tableau :imem[ip(NP)]:
    imem = []
    if iut > u25:  # Si oui: Commence à 1
        u = 1
    else:  # Si non: Commence à 2. Sinon ERREUR
        u = 2
    v_ = w_ = z_ = 0  # Indices des terminaux (v_ pour v...)
    # Fonction d'appel à condition NP
    def imemap(uz):
        # print('uz', uz)
        """ Les nombres premiers NP
        Des préalables premiers :uz: déjà '1&5' """
        # Condition du niveau bas (1, 2, 3, 4, 5, 6, 7)
        if not uno % uz and uz % 6 in (1, 3, 5) \
                and uz < 8:
            imem.append(uz)  # Tableau :imem[ip(NP)]:
        else:
            # :rim: Reconstruction à chaque tour
            rim = [mm for mm in imem if mm > 1]
            for rr in rim:
                if not uz % rr:
                    r0 = 1
                    break
            else:
                # Rapports des racines carrées :uz:
                sq5 = int(uz ** .5)
                sq2 = int(uz ** .25)
                ind0 = (sq5 - sq2) // 2  # Entre :sq2: et :sq5:
                # :iep: Ordonnée de carré à carré²
                # print('sq5:%s sq2:%s i0:%s' % (sq5, sq2, i0))
                q = 0
                for iep in range(sq5, ind0, -1):
                    if not uz % iep \
                            and iep % 6 in (1, 5):
                        r0 = 1
                        break
                    if not uz % (uz // iep) \
                            and (uz // iep) % 6 in (1, 5):
                        r0 = 1
                        break
                    o = sq2 + q  # Ordonnée de carré² incrémenté
                    if o > 1:
                        if not uz % o \
                                and o % 6 in (1, 5):
                            r0 = 1
                            break
                        if not uz % (uz // o) \
                                and (uz // o) % 6 in (1, 5):
                            r0 = 1
                            break
                    p = sq2 - q  # Ordonnée de carré² décrémenté
                    if p > 1:
                        if not uz % p \
                                and p % 6 in (1, 5):
                            r0 = 1
                            break
                        if not uz % (uz // p) \
                                and (uz // p) % 6 in (1, 5):
                            r0 = 1
                            break
                    q += 1
                else:
                    r0 = 0
            if r0 == 0:  # :for: Condition vide, donc.
                imem.append(uz)
                # Nombre premier NP
    if u1 == 0:  # Zéro issue
        # À la recherche des sous-multiples
        while 1:
            # Ordonnée conditionnée aux sous-multiples
            # Condition du niveau bas (1, 2, 3, 4, 5)
            if not uno % u and u % 6 in (1, 2, 3, 5) \
                    and u < 6 and u not in imem:
                imem.append(u)  # Tableau :imem[ip(NP)]:
            # :v >= y: :sq5|sut: Environnement
            if v > v1 and v_ == 0:  # Si oui: Faire
                if not uno % v and v not in imem:
                    imemap(v)  # Envoi :imemap: Sortant :v: NpP
                    if v == uo5:  # Carré rencontré Type 1
                        imemap(v)
                if not uno % v5 and v5 not in imem \
                        and v5 > 1:
                    imemap(v5)  # Envoi :imemap: Sortant :v5: NpP
                    if v5 == uo5:  # Carré rencontré Type 5
                        imemap(v5)
                if not uno % y \
                        and y not in imem:  # y = iut(+6)
                    imemap(y)
                if not uno % y5 \
                        and y5 not in imem:  # y5 = iut(+6)
                    imemap(y5)
            else:  # Si non: Indice terminal
                v_ = 1
            # :w >= u: :s25|u: Environnement
            if w >= u - 6 and w_ == 0:  # Si oui: Faire
                if not uno % w \
                        and w not in imem:  # w = u25(-6)
                    imemap(w)
                if not uno % u and u not in imem \
                        and u % 6 in (1, 5) \
                        and u > 1:  # u = u(+1)
                    imemap(u)
                if not uno % w5 and w5 > 1 \
                        and w5 not in imem:  # w5 = u25(-6)
                    imemap(w5)
            else:  # Si non: Indice terminal
                w_ = 1
            # :z >= x: :sut|s25: Environnement
            if z > z1 and z_ == 0:  # Si oui: Faire z_
                if not uno % z \
                        and z not in imem:  # z = iut(-6)
                    imemap(z)
                if not uno % x \
                        and x not in imem:  # x = u25(+6)
                    imemap(x)
                if not uno % z5 \
                        and z5 not in imem:  # z5 = iut(-6)
                    imemap(z5)
                if not uno % x5 \
                        and x5 not in imem:  # x5 = u25(+6)
                    imemap(x5)
            else:  # Si non: Indice terminal z_
                z_ = 1
            # Ordonnées positives et négatives
            if v_ == 0:
                v -= 6  # sq5 typ1
                y += 6  # sut typ1
                v5 -= 6  # sq5 typ5
                y5 += 6  # sut typ5
            if w_ == 0:
                w -= 6  # s25 typ1
                u += 1  # u
                w5 -= 6  # s25 typ5
            if z_ == 0:
                z -= 6  # sut typ1
                x += 6  # s25 typ1
                z5 -= 6  # sut typ5
                x5 += 6  # s25 typ5
            vwz = v_ + w_ + z_  # :vwz: Cumul des terminaux
            if vwz > 2:  # :vwz=3: Le tour est fait !
                break
    # Tableau :imem[ip(NP)]: Trier
    imem.sort()
    # 2- Copie (imem) sur tableau(itab)
    itab = copy.copy(imem)
    # print('En {}'.format(time.time() - dod1))
    if u1 == 0:  # Zéro issue
        # Les multiplications NP produisent NC
        while 1:
            ion1 = len(itab)
            for i in imem:
                for y in itab:
                    i0 = y * i
                    if i0 > s01[1]:
                        i1 = uno // i0
                        if i1 not in imem:
                            imemap(i1)
                    else:
                        i1 = i0
                    if i1 not in itab \
                            and not uno % i1:
                        itab.append(i1)
                        # NC = Nombre Commun :itab[NC]: Résultat "ip"
            itab.sort()
            ion2 = len(itab)
            if ion1 == ion2:  # 4- :ion1::ion2: Motif de progression
                imem = copy.copy(itab)
                print('Nombres Premiers :ip:', imem)  # Affiche (les) NP
                break
        for i in itab:  # Démultiplier :i: produire :d:
            d = uno // i
            ip, dv = i, d
            if ip < dv or ip == dv:  # Déblocage :uno = 2 ou 4:
                print('%s * %s  typ %s*%s' % (ip, dv, ip % 6, dv % 6))
    else:
        # Zéro issue :uno;onu:
        print('%s * %s  typ %s*%s' % (uno, onu, uno % 6, onu % 6))
        uno = 0
        uo6 = uno % 6
    print('Cosmic', uno, 'typ', uo6, 'long', len(itab))
    print('nphysic_8a.py En {}'.format(time.time() - dod0))
 
# Nombre original :onu:
onu = 98
onuno(onu)

Au juste, il n' a eu qu'à adapter cette petite logique

Code :

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

1
2
3
4
5
6
7
# Généralités repèrées
    if s01[1] < int(s02[1] ** 1.5):
        v1 = y
        z1 = x
    else:
        v1 = s01[1] - int(s02[1] ** 1.5)
        z1 = s00[1] - int(s02[1] ** 1.5)

Pour la totale

nphysic_8a.py

Ce qu'il y a à la suite de cette expérience la multiplication des deux tables (imem et itab), il y a une recherche basée sur les multiples, et non pas à l'aide des itérations (+6, -6).
Cet élément donne un indice visant à réduire le taux des itérations à l'aide de la multiplication (pour un gain de temps), et un autre point de vue

Que des promesses .... Qu'elle erreur !

Invité · 09/09/2017, 11h43

Il y a des raisons de croire que le développement engendre la connaissance, en raison d'une conséquence liée au vecteur numéral. D'un côté, le nombre peut-être grand et donner lieu à une importante série de traitements gourmands en temps d'exécution. D'autre part, les qualités relatives à la multiplication des nombres entre eux et leurs effets visibles sur les produits. Alors on ne peut pas éviter de penser que les nombres sont finalement organisés, et que les relations peuvent être profondes. Il est important de savoir que la profondeur est distinguée, qu'elle est composée d'éléments distinctifs.

Le programme précédent (nphysic_11a.py) a de nombreux traitements ne gênant pas le développement de l'idée originale, et grâce à sa logique heureusement simplifiable. Son enseignement donne l'occasion d'écrire un code plus simple, en ne gardant que la principale ligne de conduite de son algorithme. Résolu avec les nombres premiers aux production des communs, et de la science qui en découle. La relation avec les différents niveaux de profondeur estimée en grandeur numérale du nombre à traiter, pour que finalement on puisse interpréter le langage numéral après avoir compris sa systématique.

Je voudrais remercier dans ce texte la communauté Pycharm de Jet Brain, qui fort compétant de disposer d'un éditeur de code agréable

Code quantum d'un débutant non autonome et de ses deux amis Python et Pycharm

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
 
#!/usr/bin/env python3.6
# -*- coding: utf-8 -*-
# Série première. En Général Python
# MusicAtoumic nphermier_1 Le 9 septembre 2017
import time
import copy
t = time.time()
nombre = 9854632157861
carre = carre1 = int(nombre ** .5)
hautniveau = []
"""Pontage niveau haut:
Définir le carré en deux lignes (1&5)
Lié au reste de la division :carre % 6:"""
if carre % 6 == 1:
    carre1 = carre
    carre5 = carre1 + 4
else:
    differe = (carre % 6) - 1
    carre1 -= differe
    carre5 = carre1 + 4
"""Bas niveau des premiers:
Création du haut niveau des nombres premiers
Lié au bas niveau des nombres premiers"""
basniveau = [2, 3, 5]
for i in range(7):
    if i in basniveau and not nombre % i:
        hautniveau.append(i)
"""Hauts niveaux premiers:
Chercher dans l'alignement des nombres premiers"""
for p1 in range(7, carre, 6):
    p5 = p1 + 4
    # Lorsque le haut niveau n'a pas d'élément bas
    if not hautniveau:
        if not nombre % p1:
            hautniveau.append(p1)
        if not nombre % p5:
            hautniveau.append(p5)
        # Partie inverse   
        if not nombre % carre1:
            hautniveau.append(carre1)
        if not nombre % carre5:
            hautniveau.append(carre5)
    # Lorsque le haut niveau a un élément bas
    else:
        if not nombre % p1 and p1 not in hautniveau:
            for i in hautniveau:
                if not p1 % i:
                    break
            else:
                hautniveau.append(p1)
        if not nombre % p5 and p5 not in hautniveau:
            for i in hautniveau:
                if not p5 % i:
                    break
            else:
                hautniveau.append(p5)
        # Partie inverse
        if not nombre % carre1 and carre1 not in hautniveau:
            for i in hautniveau:
                if not carre1 % i:
                    break
            else:
                hautniveau.append(carre1)
        if not nombre % carre5 and carre5 not in hautniveau:
            for i in hautniveau:
                if not carre5 % i:
                    break
            else:
                hautniveau.append(carre5)
    carre1 -= 6
    carre5 -= 6
    # Contrôle jonction (+/-)
    if p1 >= carre1:
        break
print('Hautniveau En:', time.time() - t)
"""Désigne la communauté:
Les nombres premiers associés :hautniveau:
Produisent la communauté des multiples communs"""
hautniveau.append(1)
hautniveau.sort()
print('Premiers', hautniveau)
communs = copy.copy(hautniveau)
for com1 in hautniveau:
    for com2 in communs:
        produit = com1 * com2
        # Condition de recherche
        if produit > carre:
            break
        elif produit not in communs and not nombre % produit:
            communs.append(produit)
            communs.sort()
            # Ordonnance des communs
for i in communs:
    print('{} * {} typ {}*{}'.format(i, nombre // i, i % 6, (nombre // i) % 6))
print('nphermier_0a.py En:', time.time() - t)
print('', )

Invité · 18/09/2017, 18h16

Envoyé par toumic

Il y a des raisons de croire que le développement engendre la connaissance,,,

Je voudrais remercier dans ce texte la communauté Pycharm de Jet Brain, qui fort compétant de disposer d'un éditeur de code agréable

Code quantum d'un débutant non autonome et de ses deux amis Python et Pycharm

Pas facile de s'y retrouver parmi les communautés des multiples, car chaque nombre comporte une communauté différente. Et comme le code évolue en fonction des communs rencontrés, il est toujours probable qu'il ne soit pas totalement estimable comme son titre de réussite le demande

L'algorithme relatif aux nombres a encore évolué, visiblement :

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
 
#!/usr/bin/env python3.6
# -*- coding: utf-8 -*-
# Série première. En Général Python
# MusicAtoumic nphermier_5a Le 17 septembre 2017
import time
import copy
t = time.time()
nombre = 7999178931971
typ6 = nombre % 6
carre = int(nombre ** .5)
hautniveau = []
horscourse = []
palier = int(nombre ** .46)
if typ6 in (1, 5):
    cartyp6 = int(nombre ** .473)
    borne = int(nombre ** .4)
else:
    cartyp6 = int(nombre ** .437)
    borne = int(nombre ** .36)
"""Pontage niveau haut:
Définir le carré en deux lignes (1&5)
Lié au reste de la division :carre % 6:"""
carre1 = carre
if carre % 6 == 1:
    carre5 = carre1 + 4
else:
    differe = (carre % 6) - 1
    carre1 -= differe
    carre5 = carre1 + 4
"""Bas niveau des premiers:
Création du haut niveau des nombres premiers
Lié au bas niveau des nombres premiers"""
basniveau = [2, 3, 5]
for i in range(7):
    if i in basniveau and not nombre % i:
        hautniveau.append(i)
 
def compare(c):
    if not nombre % c and c <= carre:
        if c not in horscourse:
            horscourse.append(c)
        for haut in hautniveau:
            if not c % haut:
                break
        else:
            if c <= carre and c not in hautniveau:
                hautniveau.append(c)
 
"""Hauts niveaux premiers:
Chercher dans l'alignement des nombres premiers"""
for p1 in range(7, cartyp6, 6):
    p5 = p1 + 4
    # Lorsque le haut niveau n'a pas d'élément bas
    if not hautniveau:
        if not nombre % p1:
            hautniveau.append(p1)
        if not nombre % p5:
            hautniveau.append(p5)
        # Partie inverse
        if not nombre % carre1:
            hautniveau.append(carre1)
        if not nombre % carre5:
            hautniveau.append(carre5)
    # Lorsque le haut niveau a un élément bas
    else:
        if not nombre % p1 and p1 not in hautniveau:
            compare(p1)
        if not nombre % p5 and p5 not in hautniveau:
            compare(p5)
        # Partie inverse
        if not nombre % carre1 and carre1 not in hautniveau:
            compare(carre1)
        if not nombre % carre5 and carre5 not in hautniveau:
            compare(carre5)
    carre1 -= 6
    carre5 -= 6
    """Condition du palier:
        Nombres démunis en communs"""
    if p1 > palier and 2 > len(hautniveau):
        break
    """Condition de la borne:
    Nombres premiers complémentaires"""
    if p1 > borne and 1 < len(hautniveau):
        produit = 1
        hautniveau.sort()
        hautniveau.reverse()
        for unit in hautniveau:
            produit *= unit
            result = nombre // produit
            if result > 1 and not nombre % result:
                if produit > carre and result not in horscourse:
                    compare(result)
                elif nombre > produit < carre:
                    compare(produit)
        else:
            horscourse.sort()
            h = hh = 0
            while not hh:
                h -= 1
                fx_ip = nombre // horscourse[-1]
                fx_mu = fx_ip * min(hautniveau)
                if fx_mu < carre:
                    ho_dv = horscourse[h] // min(hautniveau)
                    if not nombre % ho_dv:
                        if ho_dv % 6 in (1, 5):
                            compare(ho_dv)
                    if not nombre % fx_mu:
                        if fx_mu > carre:
                            if (nombre // fx_mu) % 6 in (1, 5):
                                compare(nombre // fx_mu)
                                hh = 1
                        else:
                            if fx_mu % 6 in (1, 5):
                                compare(fx_mu)
                else:
                    hh = 1
            break
 
"""Désigne la communauté:
Les nombres premiers associés :hautniveau:
Produisent la communauté des multiples communs"""
hautniveau.append(1)
hautniveau.sort()
print('Premiers', hautniveau)
communs = copy.copy(hautniveau)
for com1 in hautniveau:
    for com2 in communs:
        produit = com1 * com2
        # Condition de recherche
        if produit > carre:
            break
        elif produit not in communs and not nombre % produit:
            communs.append(produit)
            communs.sort()
            # Ordonnance des communs
for i in communs:
    print('{} * {} typ {}*{}'.format(i, nombre // i, i % 6, (nombre // i) % 6))
print('nphermier_5a.py En:', time.time() - t)
print('', )

Pour cause cet exemple :

Code :

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

1
2
3
4
5
 
Premiers [1, 758339]
1 * 7999178931971 typ 1*5
758339 * 10548289 typ 5*1
nphermier_5a.py En: 0.2581496238708496

Invité · 08/11/2017, 11h12

Ainsi:

Code :

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

1
2
3
4
5
6
7
8
"""Bas niveau des premiers:
Création du haut niveau des nombres premiers
Lié au bas niveau des nombres premiers"""
basniveau = [2, 3, 5]
for i in range(7):
    if i in basniveau and not nombre % i:
        hautniveau.append(i)
        horscourse.append(i)

Dans le report bas niveau ne sont pas traités (4, 6)
Noter qu'ensuite, les points (p1&p5) sont à (7, 11)
Si quatre est un sous-multiple, ici il est absent

Pour y remédier, une simple mofification suffit:

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
"""Bas niveau des premiers:
Création du haut niveau des nombres premiers
Lié au bas niveau des nombres premiers"""
basniveau = [2, 3, 5]
for i in range(2, 7):
    if not nombre % i:
        def rang(ti, i_):
            if ti == 1:
                hautniveau.append(i_)
                horscourse.append(i_)
            else:
                horscourse.append(i_)
        if i in basniveau:
            rang(1, i)
        else:
            rang(2, i)

Invité · 15/11/2017, 21h14

J'avoue, je fais des erreurs, ce n'est pas encore ça. Mais le sujet est compliqué, je débute en ayant vu des choses, et en oubliant de les appliquer. C'est alors, qu'il faut poser un topique. Tout en ayant pas peur de tout devoir reprendre, sauf qu'en cours de route on code tout ce qu'il faut pour interpréter la vaste communauté des nombres. Tout en notant quelques notions basiques et répétitives ou communes à certains nombres. Je vous propose un outillage intellectuel basé sur des incantations de l'homme qui a vu...

# PyCosmic 4: Dossier typic
"""
typ 0_________________________________________________
Cosmic = 357951258456 typ 0
square = 598290
PL [1, 2, 3, 11, 11587, 117017](*) = 89487814614
(ip*dv(axe)) = 4 * 89487814614 typ 4*0
(ip(sup)*dv(inf)) = 509828 * 702102 typ 2*0
# F break maxFermiers(Cosmic): 357951258456

Cosmic = 765432198765432 typ 0
square = 27666445
PL [1, 2, 3, 11](*) = 66
(ip(axe)*dv) = 66 * 11597457557052 typ 0*0
(ip(sup)*dv(inf)) = 7128 * 107383866269 typ 0*5
CoMulti maxFermiers = 7128
C break CaxeP 8341747
typ 1_________________________________________________
Cosmic = 428622468822709 typ 1
square = 20703199
PL [1, 7, 953](*) = 6671
(ip(sup)*dv(inf)) = 6671 * 64251606779 typ 5*5
CoMulti maxFermiers = 6671
C break CaxeP 670642

Cosmic = 84269713568423971 typ 1
square = 290292462
PL [1, 7, 23, 151](*) = 24311
(ip(axe)*dv) = 24311 * 3466320331061 typ 5*5
(ip(sup)*dv(inf)) = 170177 * 495188618723° typ 5*5
CoMulti maxFermiers = 170177
C break CaxeP 23623665
typ 2_________________________________________________
Cosmic = 23521654248938 typ 2
square = 4849912
PL [1, 2, 83, 9949](*) = 1651534
(ip(sup)*dv(inf)) = 1651534 * 14242307 typ 4*5
CoMulti maxFermiers = 1651534
C break CaxeP 48623

Cosmic 26846125345688 typ 2
cartyp6 5181324
PL [1, 2, 11, 17](*) = 374
(ip(axe)*dv) = 374 * 71781083812 typ 2*4
(ip(sup)*dv(inf)) = 1496 * 17945270953 typ 2*1
C len(haut) horscourse 1496
W break cartyp6 5181313
typ 3_________________________________________________
Cosmic = 987654321987654321 typ 3
square = 993807990
PL [1, 3, 7, 11, 13, 17, 19, 52579, 379721](*) = 19365771019365771
(ip*dv(axe)) = 51 * 19365771019365771 typ 3*3
(ip(sup)*dv(inf)) = 987654321 * 1000000001 typ 3*5
# F break maxFermiers(Cosmic): 987654321987654321

Cosmic 645231875461353 typ 3
cartyp6 25401414
[1, 3, 17](*) = 51
(ip(axe)*dv) = 51 * 12651605401203 typ 3*3
(ip(sup)*dv(inf)) = 459 * 1405733933467° typ 3*1
C len(haut) horscourse 459
W break cartyp6 25401403
typ 4_________________________________________________
Cosmic = 846465432165442 typ 4
square = 29094078
PL [1, 2, 17, 53, 6067](*) = 10932734
(ip(sup)*dv(inf)) = 10932734 * 77424863 typ 2*5
CoMulti maxFermiers = 10932734
C break CaxeP 373523

Cosmic 65315487956524 typ 4
cartyp6 8081799
[1, 2, 13, 31](*) = 806
(ip(axe)*dv) = 806 * 81036585554 typ 2*2
(ip(sup)*dv(inf)) = 1612 * 40518292777 typ 4*1
C len(haut) horscourse 1612
W break cartyp6 8081791
typ 5_________________________________________________
Cosmic = 465321564589739 typ 5
square = 21571313
PL [1, 11, 13, 429797, 7571009](*) = 465321564589739
(ip(min)*dv(sup)) = 1 * 465321564589739 typ 1*5
(ip(sup)*dv(inf)) = 7571009 * 61460971 typ 5*1
# F break maxFermiers(Cosmic): 465321564589739

Cosmic 546897512558795 typ 5
cartyp6 23385840
[1, 5, 47, 1709](*) = 401615
(ip(sup)*dv(inf)) = 401615 * 1361745733 typ 5*1
C len(haut) horscourse 401615
W break cartyp6 23385829

(ip*dv) =
(ip*dv) =
(ip*dv) =
(ip*dv) =
(ip*dv) =

Cosmic = 357951258456 typ 0
square = 598290
PL [1, 2, 3, 11, 11587, 117017](*) = 89487814614
(ip*dv(axe)) = 4 * 89487814614 typ 4*0
(ip(sup)*dv(inf)) = 509828 * 702102 typ 2*0
# F break maxFermiers(Cosmic): 357951258456
1287187 1355875979 14914635769
Premiers ( 32 )ex
[1, 2, 3, 11, 11587, 117017]
1 * 357951258456 typ 1*0
2 * 178975629228 typ 2*0
3 * 119317086152 typ 3*2
4 * 89487814614 typ 4*0
6 * 59658543076 typ 0*4
8 * 44743907307 typ 2*3
11 * 32541023496 typ 5*0 1287187(11) 14914635769(11)
12 * 29829271538 typ 0*2
22 * 16270511748 typ 4*0
24 * 14914635769 typ 0*1 1 * 14914635769 typ 1*1
33 * 10847007832 typ 3*4
44 * 8135255874 typ 2*0
66 * 5423503916 typ 0*2
88 * 4067627937 typ 4*3
132 * 2711751958 typ 0*4
264 * 1355875979 typ 0*5 1 * 1355875979 typ 1*5
11587 * 30892488 typ 1*0 1355875979(11587)
23174 * 15446244 typ 2*0
34761 * 10297496 typ 3*2
46348 * 7723122 typ 4*0
69522 * 5148748 typ 0*4
92696 * 3861561 typ 2*3
117017 * 3058968 typ 5*0 1287187(117017) 1355875979(117017)
127457 * 2808408 typ 5*0
139044 * 2574374 typ 0*2
234034 * 1529484 typ 4*0
254914 * 1404204 typ 4*0
278088 * 1287187 typ 0*1 1 * 1287187 typ 1*1
351051 * 1019656 typ 3*4
382371 * 936136 typ 3*4
468068 * 764742 typ 2*0
509828 * 702102 typ 2*0
nphullmen_4.py En:
0.39316320419311523
_______________________________PUIS____________________________________
Ce corps de texte rassemble les cas rencontrés avec les multiples communs.
Ils sont assez nombreux pour les noter sur cette page.
Analyses sur les termes communs: Le couplage voisin de la racine carrée.
Services rendus par des reports importants et formels.
Exemple type d'analyse:

CAS FERMIER = COSMIC
typ 0_________________________________________________
Cosmic = 357951258456 typ 0
square = 598290
PL [1, 2, 3, 11, 11587, 117017](*) = 89487814614
(ip*dv(axe)) = 4 * 89487814614 typ 4*0
(ip(sup)*dv(inf)) = 509828 * 702102 typ 2*0
# F break maxFermiers(Cosmic): 357951258456

La table des nombres premiers et multiples communs du nombre entier.
Les premiers se multiplient pour donner un produit :hautmulti:.
_1*2*3*11*11587*117017=89487814614_
Selon le tempérament des communs variant de nombre en nombre.
H :hautmulti: = Nombre Entier.
H :hautmulti: = Niveau bas du couple voisin à la racine carrée (n**.5).
H :hautmulti: = Niveau moyen des éléments de couple, comme ci-dessus.

L'utilisation des lecteurs typés itératifs dédiés aux communs.
Les communs des lecteurs sont préalablement premiers, d'où un tri.
Les nombres premiers produisent aussi une liste de communs.

C :premiers

Ces trois tables évoluent à chaque nouveau premier.
F :fermiers

Elles produisent les nombres communs relatifs.
R :ramieres

Les limites relatives sont significatives.
C :premiers

*) = H :hautmulti: (89487814614).

Cosmic > H :hautmulti

Le haut multiple est à moyen niveau de couple.
_(ip*dv(axe)) = 4 * 89487814614 typ 4*0_

F :fermiers: = Cosmic (357951258456)| Nombre égale le max(communs).
_# F break maxFermiers(Cosmic): 357951258456_

F :fermiers

Au centre des communs, le couple voisin de la racine carrée.
_(ip(sup)*dv(inf)) = 509828 * 702102 typ 2*0_

CAS FERMIER != COSMIC
typ 1_________________________________________________
Cosmic = 84269713568423971 typ 1
square = 290292462
PL [1, 7, 23, 151](*) = 24311
(ip(axe)*dv) = 24311 * 3466320331061 typ 5*5
(ip(sup)*dv(inf)) = 170177 * 495188618723° typ 5*5
CoMulti maxFermiers = 170177
C break CaxeP 23623665

H :hautmulti

Objet inférieur de couple (24311)
_(ip(axe)*dv) = 24311 * 3466320331061 typ 5*5_

F :fermiers

Objet inférieur de couple voisin :square: (170177)
_(ip(sup)*dv(inf)) = 170177 * 495188618723° typ 5*5_

Ici les communs ne sont pas parvenus à la valeur du nombre :Cosmic:
Aidé par l'objet supérieur de couple et informateur d'état (ip(sup)*dv(inf)).
Terminant la liste des communs, par un objet supérieur premier (495188618723).

"""

Invité · 17/11/2017, 21h15

Ce qui m'étonne c'est que dans une confusion quasi insoutenable, le phénomène du déjà codé m'aide à me sortir des mauvais pas. Certes après une mûre maturité visionnaire, ou pas. Ainsi que de toutes les zizanies écrites à la va vite, pour obtenir Le Résultat même si le mélange ne fait pas la mayonnaise, il se pourrait bien avoir sauvé la situation numérale en cherchant Les Résultats. Et que la mélasse encore visuelle dans le code et à savoir si certaines portions ne seront jamais utilisées. Car pour comprendre les nombres, il faut presque les écouter un par un. Chacun a son histoire, même s'ils sont communs.
Sauf qu'en général, il vaut mieux lire entre les lignes. Pour moi cet évènement est nouveau, pour vous je ne sais pas. Puis à terme il présente une définition des liens entre les nombres (fréquences, ondes, unités...). Certainement pas du hasard, et combien d'utilisation virtuelle

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
 
#!/usr/bin/env python3.6
# -*- coding: utf-8 -*-
# Série première. En Général Python
# MusicAtoumic nphullmen_4a Ce 17 novembre 2017
"""Version public"""
import time
time_ = time.time()
nombre = 987654321010123456789
# :breakComm: printage communs
breakComm = 1
carre = int(nombre ** .5)
hautniveau = []
horscourse = []
hautmulti_ = [1]
p1 = 7
p5 = 11
"""Borne & cartyp6
Borne : Limite en pleine forêt
Cartyp6 : Limite en plein ciel"""
cartyp6 = [carre]
 
def compare(c):
    hautmulti_[0] = 1
    if c not in horscourse:
        if c > 1:
            horscourse.append(c)
        for haut in hautniveau[1:]:
            if not c % haut:
                break
        else:
            hautniveau.append(c)
            for h in hautniveau:
                hautmulti_[0] *= h
            if len(hautniveau):
                for c1 in sorted(hautniveau):
                    for c2 in horscourse:
                        c12 = c1 * c2
                        if not nombre % c12 \
                                and c12 not in horscourse:
                            if c12 <= carre:
                                horscourse.append(c12)
                                horscourse.sort()
                cartyp6[0] = int((nombre//max(horscourse))**.5)
                # Terme commun     
                if max(horscourse) <= carre:
                    if hautmulti_[0]:
                        hdv = hautmulti_[0] * hautniveau[1]
                        how = nombre // hautmulti_[0]
                        if hdv >= carre and not nombre % hdv:
                            hip = nombre // hdv
                            if hip not in hautniveau:
                                compare(hip)
                        if how not in hautniveau \
                           and 1 < how <= carre:
                            compare(how)
                # Terme racine        
                if hautmulti_[0] == nombre:
                    hautmulti_[0] = 0
                elif max(horscourse) == nombre:
                    hautmulti_[0] = 0
                elif hautmulti_[0] > (nombre // hautniveau[1]):
                    hautmulti_[0] = 0
 
"""Bas niveau des premiers:
Création du haut niveau des nombres premiers
Lié au bas niveau des nombres premiers"""
basniveau = [1, 2, 3, 5]
for i in range(1, 7):
    if not nombre % i:
        def rang(ti, i_):
            if ti == 1:  # Nombre Premier(basniveau)
                hautniveau.append(i_)
                horscourse.append(i_)
            else:  # Nombre Commun(basniveau)
                horscourse.append(i_)
 
        if i in basniveau:
            rang(1, i)
        else:
            rang(2, i)
"""Hauts niveaux premiers: cartyp6
Chercher dans l'alignement des nombres premiers"""
while p1 <= cartyp6[0]:
    if hautmulti_[0] == 0:
        break
    # Lorsque le haut niveau n'a pas d'élément bas
    if not hautniveau:
        if not nombre % p1:
            hautniveau.append(p1)
            horscourse.append(p1)
        if not nombre % p5:
            hautniveau.append(p5)
            horscourse.append(p5)
    # Lorsque le haut niveau a un élément bas
    else:
        if not nombre % p1 and p1 not in hautniveau:
            compare(p1)
        if not nombre % p5 and p5 not in hautniveau:
            compare(p5)
    p1 += 6
    p5 += 6
"""Désigne la communauté:
Les nombres premiers associés :hautniveau:
Produisent la communauté des multiples communs"""
if max(horscourse) > carre:
    hi = len(horscourse) // 2
else:
    hi = len(horscourse)
hautniveau.sort()
print('Premiers (', hi, ')ex\n', hautniveau)
for i in sorted(horscourse):
    print('{} * {} typ {}*{}'
          .format(i, nombre // i, i % 6, (nombre // i) % 6))
    if breakComm == 0:
        break
print('nphullmen_4a.py En: \n', time.time() - time_)
print('', )

Bien qu'à mi-chemin conduisant à un autre genre de développement, concrétisant le traitement plus sobrement. Ce qui au départ est difficile, facilite l'évolution qui se voue à la perfection personnelle de l'auteur.

Invité · 26/11/2017, 14h04

Bonjour je viens juste de terminer une partie de restructuration se situant au niveau de la compréhension des lectures.
À savoir, quels sont les signes distinctifs liés aux nombres, ce phénomène est visible lorsqu'on poursuit les différents "break" d'arrêts.

Ce résultat n'est en aucun cas la mouture finale, selon que le sujet soit traité plus simplement. Il faut prendre conscience que le niveau d'effort face à l'erreur est important, signifiant une parfaite concentration sur la solution codée. Les divergences suivantes aux diverses cohérences relatives à l'état de la communauté des premiers multiples communs, m'ont aidées à établir plusieurs points logiques. Et qui dit plusieurs, dit nombreux de manière à former un groupe de traitements logiques. De pas à pas la situation s'éclaircit, jusqu'à voir un certain ciel dégagé de tous ces moches nuages.

Le code de nphullmen_5a.py

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
#!/usr/bin/env python3.6
# -*- coding: utf-8 -*-
# Série première. En Général Python
# Origine : nphermier_9a Du 8 octobre 2017
# MusicAtoumic nphullmen_5a Ce 26 novembre 2017
"""Version public"""
import time
time_ = time.time()
nombre = 1234567890987654321
# :breakComm: printage communs
breakComm = 1
carre = int(nombre ** .5)
hautniveau = []
horscourse = []
topsmutli_ = []
hautmulti_ = [1]
c12tableau = []
p1 = 7
p5 = 11
print('Nombre =', nombre, 'typ', nombre % 6)
"""Borne & cartyp6
Borne : Limite en pleine forêt
Cartyp6 : Limite en plein ciel"""
cartyp6 = [carre]
borne = int(carre ** .9)
print('cartyp6 %s borne %s' % (cartyp6, borne))
 
def compare(c):
    hautmulti_[0] = 1
    if c not in horscourse:
        if c > 1:
            horscourse.append(c)
            horscourse.sort()
        for haut in hautniveau[1:]:
            if not c % haut:
                break
        else:
            hautniveau.append(c)
            for h in hautniveau:
                hautmulti_[0] *= h
            if len(hautniveau):
                for c1 in sorted(hautniveau):
                    for c2 in horscourse:
                        c12 = c1 * c2
                        if not nombre % c12 \
                                and c12 not in horscourse:
                            if c12 <= carre:
                                horscourse.append(c12)
                                horscourse.sort()
                            elif c12 not in c12tableau:
                                c12tableau.append(c12)
                                c12tableau.sort()
                if c12tableau:
                    for ctab in c12tableau:
                        iptab = nombre // ctab
                        if iptab not in horscourse:
                            compare(iptab)
                cartyp6[0] = int((nombre // max(hautniveau)) ** .5)
                # Terme commun     
                if max(horscourse) <= carre:
                    if hautmulti_[0]:
                        hdv = hautmulti_[0] * hautniveau[1]
                        if hdv >= carre and not nombre % hdv:
                            hip = nombre // hdv
                            if hip not in hautniveau:
                                compare(hip)
                if hautmulti_[0] != 0:
                    # Terme racine
                    if hautmulti_[0] == nombre:
                        hautmulti_[0] = 0
                    elif hautmulti_[0] * hautniveau[1] >= carre \
                            and hautmulti_[0] == max(hautniveau):
                        hautmulti_[0] = 0
                    elif hautmulti_[0] * hautniveau[1] >= nombre:
                        hautmulti_[0] = 0
                    elif max(horscourse) == nombre:
                        hautmulti_[0] = 0
                    else:
                        if len(hautniveau) > 2:
                            dvinf = nombre // max(horscourse)
                            ipant = horscourse[-2] * dvinf
                            ipsup = nombre // hautniveau[1]
                            for ii in range(max(hautniveau),
                                            int(borne ** .5)):
                                if not dvinf % ii:
                                    if ii not in horscourse:
                                        compare(ii)
                                    break
                            else:
                                if ipant == ipsup:
                                    hautmulti_[0] = 0
 
"""Bas niveau des premiers:
Création du haut niveau des nombres premiers
Lié au bas niveau des nombres premiers"""
basniveau = [1, 2, 3, 5]
for i in range(1, 7):
    if not nombre % i and i <= carre:
        def rang(ti, i_):
            if ti == 1:  # Nombre Premier(basniveau)
                hautniveau.append(i_)
                horscourse.append(i_)
            else:  # Nombre Commun(basniveau)
                horscourse.append(i_)
 
        if i in basniveau:
            rang(1, i)
        else:
            rang(2, i)
"""Hauts niveaux premiers: cartyp6
Itérer dans l'alignement des nombres premiers"""
while p1 <= cartyp6[0]:
    if hautmulti_[0] == 0:
        break
    elif p1 >= cartyp6[0]:
        break
    elif len(hautniveau) < 2 and p1 >= int(borne**.7):
        break
    # Lecteurs en action
    if not nombre % p1 and p1 not in hautniveau \
            and p1 not in horscourse:
        compare(p1)
    if not nombre % p5 and p5 not in hautniveau \
            and p5 not in horscourse:
        compare(p5)
    p1 += 6
    p5 += 6
"""Désigne la communauté:
Les nombres premiers associés :hautniveau:
Produisent la communauté des multiples communs"""
if max(horscourse) > carre:
    hi = len(horscourse) // 2
else:
    hi = len(horscourse)
hautniveau.sort()
print('Premiers (', hi, ')ex\n', hautniveau)
for i in sorted(horscourse):
    if breakComm == 0:
        ha = horscourse[hi - 1]
        hu = horscourse[0]
        print('Duos (inf)*(sup)|(sup)*(inf) \n{} * {} Types {}&{}'
              .format(hu, nombre // hu, hu % 6, (nombre // hu) % 6))
        print('    {} * {} Types {}&{}'
              .format(ha, nombre // ha, ha % 6, (nombre // ha) % 6))
        break
    else:
        print('{} * {} Types {}&{}'
              .format(i, nombre // i, i % 6, (nombre // i) % 6))
print('nphullmen_5a.py En: \n', time.time() - time_)
print('', )

L'affichage des communs et un temps d'exécution rassurant

Nombre = 1234567890987654321 typ 3
cartyp6 [1111111106] borne 138414548
Premiers ( 24 )ex
[1, 3, 7, 19, 928163]
1 * 1234567890987654321 Types 1&3
3 * 411522630329218107 Types 3&3
7 * 176366841569664903 Types 1&3
9 * 137174210109739369 Types 3&1
19 * 64977257420402859 Types 1&3
21 * 58788947189888301 Types 3&3
57 * 21659085806800953 Types 3&3
63 * 19596315729962767 Types 3&1
133 * 9282465345771837 Types 1&3
171 * 7219695268933651 Types 3&1
399 * 3094155115257279 Types 3&3
1197 * 1031385038419093 Types 3&1
928163 * 1330119699867 Types 5&3
2784489 * 443373233289 Types 3&3
6497141 * 190017099981 Types 5&3
8353467 * 147791077763 Types 3&5
17635097 * 70006299993 Types 5&3
19491423 * 63339033327 Types 3&3
52905291 * 23335433331 Types 3&3
58474269 * 21113011109 Types 3&5
123445679 * 10000899999 Types 5&3
158715873 * 7778477777 Types 3&5
370337037 * 3333633333 Types 3&3
1111011111 * 1111211111 Types 3&5
nphullmen_5a.py En:
3.5613858699798584

Bye

Invité · 05/12/2017, 19h04

Envoyé par toumic

Bonjour je viens juste de terminer une partie de restructuration se situant au niveau de la compréhension des lectures.
À savoir, quels sont les signes distinctifs liés aux nombres, ce phénomène est visible lorsqu'on poursuit les différents "break" d'arrêts.

Ce résultat n'est en aucun cas la mouture finale, selon que le sujet soit traité plus simplement. Il faut prendre conscience que le niveau d'effort face à l'erreur est important, signifiant une parfaite concentration sur la solution codée. Les divergences suivantes aux diverses cohérences relatives à l'état de la communauté des premiers multiples communs, m'ont aidées à établir plusieurs points logiques. Et qui dit plusieurs, dit nombreux de manière à former un groupe de traitements logiques. De pas à pas la situation s'éclaircit, jusqu'à voir un certain ciel dégagé de tous ces moches nuages.

Le code de nphullmen_5a.py
Bye

Le zéro n'est pas encore géré, et bien ?

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
#!/usr/bin/env python3.6
# -*- coding: utf-8 -*-
# Série première. En Général Python
# Origine : nphermier_9a Du 8 octobre 2017
# MusicAtoumic nphullmen_6 Ce 5 décembre 2017
"""Version public"""
import time
time_ = time.time()
nombre = 2564
# :breakComm: printage communs
breakComm = 1
carre = int(nombre ** .5)
hautniveau = []
if nombre == 0:
    horscourse = [0]
else:
    horscourse = []
hautmulti_ = [1]
horspluri_ = [0]
c12tableau = []  # Liste communs dv
p1 = [7]
p5 = [11]
q1 = [0]
q5 = [0]
"""Borne & cartyp6
Borne : Limite en pleine forêt
Cartyp6 : Limite en plein ciel"""
cartyp6 = [carre]
borne = int(carre ** .9933)
 
def forme15(r1_, rng_, r6_):
    if r6_ == 1:
        if r1_ > 0:
            p1[0] = rng_
        else:
            q1[0] = rng_
    else:
        dfo_ = r6_ - 1
        if r1_ > 0:
            p1[0] = rng_ - dfo_
        else:
            q1[0] = rng_ - dfo_
    if r1_ > 0:
        p5[0] = p1[0] - 2
    else:
        q5[0] = q1[0] - 2
 
forme15(0, borne, borne % 6)
 
def compare(c):
    hautmulti_[0] = 1
    didi = [c]
    if c not in horscourse:
        if c > 1:
            horscourse.append(c)
            horscourse.sort()
        sqc = int(c ** .5)
        for dd in range(2, sqc):
            if not c % dd:
                didi.append(dd)
                dddv = c // dd
                didi.append(dddv)
                didi.sort()
                break
        for di in didi:
            c = di
            for haut in hautniveau[1:]:
                if not c % haut:
                    break
            else:
                hautniveau.append(c)
        for h in hautniveau:
            hautmulti_[0] *= h
        if hautmulti_[0] != 0:
            for c1 in sorted(hautniveau):
                for c2 in horscourse:
                    c12 = c1 * c2
                    if not nombre % c12 \
                            and c12 not in horscourse:
                        if c12 <= carre:
                            horscourse.append(c12)
                            horscourse.sort()
                        elif c12 not in c12tableau:
                            c12tableau.append(c12)
                            c12tableau.sort()
            if c12tableau:
                for ctab in c12tableau:
                    iptab = nombre // ctab
                    if iptab not in horscourse:
                        for hh in hautniveau[1:]:
                            if not iptab % hh:
                                break
                        else:
                            compare(iptab)
                if hautmulti_[0]:
                    c12ip = nombre // max(hautniveau)
                    if max(c12tableau) > c12ip:
                        hautmulti_[0] = 0
            for h in horscourse:
                if horspluri_[0] <= nombre:
                    horspluri_[0] += h
            cartyp6[0] = int((nombre // max(hautniveau)) ** .5)
            # Terme commun     
            if max(horscourse) <= carre:
                if hautmulti_[0]:
                    hdv = hautmulti_[0] * hautniveau[1]
                    if hdv >= carre and not nombre % hdv:
                        hip = nombre // hdv
                        if hip not in hautniveau:
                            compare(hip)
            if hautmulti_[0]:
                # Terme racine
                if hautmulti_[0] == nombre:
                    hautmulti_[0] = 0
                elif hautmulti_[0] * hautniveau[1] >= carre \
                        and hautmulti_[0] == max(hautniveau):
                    hautmulti_[0] = 0
                elif hautmulti_[0] * hautniveau[1] >= nombre:
                    hautmulti_[0] = 0
                elif max(horscourse) == nombre:
                    hautmulti_[0] = 0
                else:
                    ppp = 0
                    png = nombre // max(hautniveau)
                    dvinf = nombre // max(horscourse)
                    ipsup = dvinf // max(horscourse)
                    if len(hautniveau) > 2:
                        if ipsup >= carre:
                            rng = int(max(horscourse) ** 1.613)
                            for ii in range(rng, int(dvinf ** .5)):
                                if not dvinf % ii:
                                    if ii not in horscourse:
                                        compare(ii)
                                        break
                                    if ii > horspluri_[0]:
                                        ppp = dvinf
                                        wu[0] = 0
                                        forme15(1, ppp, ppp % 6)
                                        break
                                for iii in horscourse[1:]:
                                    if not ppp % iii:
                                        break
                                else:
                                    hautmulti_[0] = 0
                                    break
                        else:
                            hautmulti_[0] = 0
                    wu[0] = 0
                    if hautmulti_[0]:
                        if max(hautniveau) > int(borne ** .3):
                            rng = int(png ** .4958)
                            r6 = rng % 6
                            forme15(1, rng, r6)
                            wu[0] = 0
 
"""Bas niveau des premiers:
Création du haut niveau des nombres premiers
Lié au bas niveau des nombres premiers"""
basniveau = [1, 2, 3, 5]
for i in range(1, 7):
    if not nombre % i and i <= carre:
        def rang(ti, i_):
            if ti == 1:  # Nombre Premier(basniveau)
                hautniveau.append(i_)
                horscourse.append(i_)
            else:  # Nombre Commun(basniveau)
                horscourse.append(i_)
        if i in basniveau:
            rang(1, i)
        else:
            rang(2, i)
"""Hauts niveaux premiers: cartyp6
Itérer dans l'alignement des nombres premiers"""
wu = [0]
while p1[0] <= cartyp6[0]:
    while wu[0] < 1:  # Simple effet de boucle
        cartyp6[0] = int((nombre // max(hautniveau)) ** .5)
        wu[0] += 1
    if hautmulti_[0] == 0:
        break
    elif p1[0] >= q1[0]:
        break
    elif p1[0] >= cartyp6[0]:
        break
    elif len(hautniveau) < 2 and p1[0] >= borne:
        break
    # Lectures
    if not nombre % p1[0] and p1[0] not in hautniveau \
            and p1[0] not in horscourse:
        compare(p1[0])
    if not nombre % p5[0] and p5[0] not in hautniveau \
            and p5[0] not in horscourse:
        compare(p5[0])
    if not nombre % q1[0] and q1[0] not in hautniveau \
            and q1[0] not in horscourse:
        compare(q1[0])
    if not nombre % q5[0] and q5[0] not in hautniveau \
            and q5[0] not in horscourse:
        compare(q5[0])
    p1[0] += 6
    p5[0] += 6
    q1[0] -= 6
    q5[0] -= 6
"""Désigne la communauté:
Les nombres premiers associés :hautniveau:
Produisent la communauté des multiples communs"""
if max(horscourse) > carre:
    hi = len(horscourse) // 2
else:
    hi = len(horscourse)
hautniveau.sort()
print('Premiers (', hi, ')ex\n', hautniveau)
for i in sorted(horscourse):
    if breakComm == 0:
        ha = horscourse[hi - 1]
        hu = horscourse[0]
        print('Duos (inf)*(sup)|(sup)*(inf) \n{} * {} Types {}&{}'
              .format(hu, nombre // hu, hu % 6, (nombre // hu) % 6))
        print('    {} * {} Types {}&{}'
              .format(ha, nombre // ha, ha % 6, (nombre // ha) % 6))
        break
    else:
        print('{} * {} Types {}&{}'
              .format(i, nombre // i, i % 6, (nombre // i) % 6))
print('nphullmen_6.py En: \n', time.time() - time_)
print('', )

* * * Erreur rencontrée (conseil = travailler avec 2 calculatrices)

Invité · 10/12/2017, 08h39

Il est toujours agréable d'affiner le code, et je sais qu'il germe un traitement visant à raccourcir le temps des itérations des lecteurs. Aidé par la consistence même des nombres premiers multiples communs, et de part la position occupée des ces derniers. Nous avons l'image des briques et de leurs architecture, les racines carrées aidant à positionner les lectures forment une sorte d'entonnoir et justement éloigné des racines "réelles". Où la racine réelle est n**.5, et l'entonnoir n**.4.

Dans ce contexte commun, les associations symbolisent des structures propres à la nature de la composition des nombres entiers. Je vous en ai déjà assez dit pour le moment, le moment du code est là

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
#!/usr/bin/env python3.6
# -*- coding: utf-8 -*-
# Série première. En Général Python
# MusicAtoumic nphullmen_6a Ce 10 décembre 2017
"""Python Compulsion Commune"""
import time
time_ = time.time()
 
def zero(z):
    if z == 1:
        z = 0
        print('Premiers (', z, ')ex\n', '[0]')
        print('{} * {} Types {}&{}'
              .format(z, z, z % 6, z % 6))
        print('nphullmen_6x.py En: \n', time.time() - time_)
    else:
        print('nphullmen_6x.py En: \n', time.time() - time_)
 
# _____________________
# :nombre: objet unique
nombre = 654321547654321547
# :breakComm: printage communs
breakComm = 1
# :zero: instruction zéro
if nombre == 0:
    zero(breakComm)
# :carre: service axial
carre = int(nombre ** .5)
hautniveau = []  # Liste premiers
horscourse = []  # Liste communs ip&dv
hautmulti_ = [1]  # Mul.hautniveau
horsmulti_ = [1]  # Mul.horscourse
c12tableau = []  # Liste communs dv
# Lecteurs initiaux
p1 = [7]
p5 = [11]
q1 = [0]
q5 = [0]
"""Borne & cartyp6
Borne : Limite en pleine forêt
Cartyp6 : Limite en plein ciel"""
cartyp6 = [carre]
borne = int(cartyp6[0] ** .999)
borne = [borne]
 
def forme15(r1_, rng_, r6_):
    """Positionnement des Lecteurs (bas/hauts)
        P1: Point (+6) Type (1)
            Position inférieure :ip: Inf.carre
        Q1: Point (-6) Type (5)
            Position supérieure :dv: Sup.carre"""
    if r6_ == 1:
        if r1_ > 0:
            p1[0] = rng_
        else:
            q1[0] = rng_
    else:
        dfo_ = r6_ - 1
        if r1_ > 0:
            p1[0] = rng_ - dfo_
        else:
            q1[0] = rng_ - dfo_
    if r1_ > 0:
        p5[0] = p1[0] - 2
    else:
        q5[0] = q1[0] - 2
 
if nombre != 0:
    forme15(0, borne[0], borne[0] % 6)
 
def compare(c):
    """Réception et traitement (c)"""
    hautmulti_[0] = 1
    didi = [c]
    if c not in horscourse:
        if c > 1:
            horscourse.append(c)
            horscourse.sort()
        sqc = int(c ** .5)
        for dd in range(2, sqc):
            if not c % dd:
                didi.append(dd)
                dddv = c // dd
                didi.append(dddv)
                didi.sort()
                break
        for di in didi:
            c = di
            for haut in hautniveau[1:]:
                if not c % haut:
                    break
            else:
                hautniveau.append(c)
        # Production haut niveau
        for hha in hautniveau:
            hautmulti_[0] *= hha
        if hautmulti_[0] != 0:
            for c1 in sorted(hautniveau):
                for c2 in horscourse:
                    c12 = c1 * c2
                    # Séparation :carre:
                    if not nombre % c12 \
                            and c12 not in horscourse:
                        if c12 <= carre:
                            horscourse.append(c12)
                            horscourse.sort()
                        elif c12 not in c12tableau:
                            c12tableau.append(c12)
                            c12tableau.sort()
            if c12tableau:
                for ctab in c12tableau:
                    iptab = nombre // ctab
                    # :ctab: Occurence :c12:
                    if iptab not in horscourse:
                        for hh in hautniveau[1:]:
                            if not iptab % hh:
                                break
                        else:
                            compare(iptab)
                if hautmulti_[0]:
                    c12ip = nombre // max(hautniveau)
                    # :c12ip: Sup.carre(dv) de Max.premier(ip)
                    if max(c12tableau) > c12ip:
                        hautmulti_[0] = 0
            if hautmulti_[0]:
                horsmulti_[0] = 1
                # Production hors course
                for hha in horscourse:
                    if horsmulti_[0] <= nombre:
                        horsmulti_[0] *= hha
                cartyp6[0] = int((nombre // max(hautniveau)) ** .499)
                brn = int(cartyp6[0] ** .5)
                borne[0] = brn
            # Terme commun     
            if max(horscourse) <= carre:
                if hautmulti_[0]:
                    hdv = hautmulti_[0] * hautniveau[1]
                    # :hdv: Son.carre(dv) par Min.hautniveau
                    if hdv >= carre and not nombre % hdv:
                        hip = nombre // hdv
                        # :hip: Son(ip) du Son.carre(dv)
                        if hip not in horscourse:
                            compare(hip)
            if hautmulti_[0]:
                # Termes racine
                if hautmulti_[0] == nombre:
                    hautmulti_[0] = 0
                elif hautmulti_[0] * hautniveau[1] >= carre \
                        and hautmulti_[0] == max(hautniveau):
                    hautmulti_[0] = 0
                elif hautmulti_[0] * hautniveau[1] >= nombre:
                    hautmulti_[0] = 0
                elif max(horscourse) == nombre:
                    hautmulti_[0] = 0
                else:
                    # Différentiel comparatif
                    dvinf = nombre // max(horscourse)
                    ipsup = dvinf // max(horscourse)
                    if len(hautniveau) > 2:
                        if ipsup >= carre:
                            rng = int(
                                (nombre // max(hautniveau)) ** .4534)
                            r6 = rng % 6
                            forme15(0, rng, r6)
                        else:
                            sqinf = int(dvinf ** .5) + 1
                            for e in range(max(hautniveau), sqinf):
                                if not dvinf % e:
                                    if e % 6 in (1, 5) \
                                            and e not in horscourse:
                                        compare(e)
                                        break
                            else:
                                hautmulti_[0] = 0
 
"""Bas niveau des premiers:
Création du haut niveau des nombres premiers
Lié au bas niveau des nombres premiers
Composition des hors course"""
basniveau = [1, 2, 3, 5]
for i in range(1, 7):
    if not nombre % i and i <= carre:
        def rang(ti, i_):
            if ti == 1:  # Nombre Premier(basniveau)
                hautniveau.append(i_)
                horscourse.append(i_)
            else:  # Nombre Commun(basniveau)
                horscourse.append(i_)
 
        if i in basniveau:
            rang(1, i)
        else:
            rang(2, i)
if horscourse:
    for h in horscourse:
        for o in horscourse:
            oh = h * o
            if not nombre % oh and oh not in horscourse:
                compare(oh)
"""Hauts niveaux premiers: cartyp6
Itérer dans l'alignement des nombres premiers
Condition évolutive des lecteurs"""
while p1[0] <= cartyp6[0]:
    if hautmulti_[0] == 0:
        break
    elif p1[0] > q1[0]:
        break
    elif p1[0] >= cartyp6[0]:
        break
    elif len(hautniveau) < 3 and p1[0] >= int(borne[0] ** .5):
        if hautmulti_[0] == 0:
            dvhors = nombre // max(horscourse)
            sqhors = int(dvhors ** .5) + 1
            for ds in range(max(hautniveau), int(sqhors ** .6)):
                if not dvhors % ds and ds not in horscourse:
                    compare(ds)
            else:
                break
    # Lectures
    if not nombre % p1[0] and p1[0] not in hautniveau \
            and p1[0] not in horscourse:
        compare(p1[0])
    if not nombre % p5[0] and p5[0] not in hautniveau \
            and p5[0] not in horscourse:
        compare(p5[0])
    if not nombre % q1[0] and q1[0] not in hautniveau \
            and q1[0] not in horscourse:
        compare(q1[0])
    if not nombre % q5[0] and q5[0] not in hautniveau \
            and q5[0] not in horscourse:
        compare(q5[0])
    p1[0] += 6
    p5[0] += 6
    q1[0] -= 6
    q5[0] -= 6
if nombre != 0:
    """Désigne la communauté:
    Les nombres premiers associés :hautniveau:
    Produisent la communauté des multiples communs"""
    if max(horscourse) > carre:
        hi = len(horscourse) // 2
    else:
        hi = len(horscourse)
    hautniveau.sort()
    print('Premiers (', hi, ')ex\n', hautniveau)
    for i in sorted(horscourse):
        if breakComm == 0:
            ha = horscourse[hi - 1]
            hu = horscourse[0]
            print('Duos (inf)*(sup)|(sup)*(inf) \n  {} * {} Types {}&{}'
                  .format(hu, nombre // hu, hu % 6, (nombre // hu) % 6))
            print('  {} * {} Types {}&{}'
                  .format(ha, nombre // ha, ha % 6, (nombre // ha) % 6))
            break
        else:
            print('{} * {} Types {}&{}'
                  .format(i, nombre // i, i % 6, (nombre // i) % 6))
    print('nphullmen_6a.py En: \n', time.time() - time_)
    print('', )

Et de son résultat, où une grande échelle est entamée, autant pour la technique relationnelle

\nphermier\nphumier\nphullmen_6a.py
W break hautmulti_ [0]
Premiers ( 32 )ex
[1, 11, 23, 5387, 120157, 246107909, 909090909090909091]
1 * 36639493274782624133663949327478262413 Types 1&1
11 * 3330863024980238557605813575225296583 Types 5&5
23 * 1593021446729679310159302144672967931 Types 5&5
253 * 144820131520879937287209285879360721 Types 1&1
5387 * 6801465244993990000680146524499399 Types 5&5
59257 * 618315022272180909152740593136309 Types 1&1
120157 * 304930160330090000030493016033009 Types 1&1
123901 * 295715880217130000029571588021713 Types 1&1
1321727 * 27720923666371818184590274184819 Types 5&5
1362911 * 26883261837920909093597417092883 Types 5&5
2763611 * 13257833057830000001325783305783 Types 5&5
30399721 * 1205257550711818181938707573253 Types 1&1
246107909 * 148875724570000000014887572457 Types 5&5
647285759 * 56604819070000000005660481907 Types 5&5
2707186999 * 13534156779090909092262506587 Types 1&1
5660481907 * 6472857590000000000647285759 Types 1&1
7120143349 * 5145892642727272727787316537 Types 1&1
14887572457 * 2461079090000000000246107909 Types 1&1
62265300977 * 588441599090909090967935069 Types 5&5
163763297027 * 223734462727272727295100719 Types 5&5
1325783305783 * 27636110000000000002763611 Types 1&1
14583616363613 * 2512373636363636363887601 Types 5&5
29571588021713 * 1239010000000000000123901 Types 5&5
30493016033009 * 1201570000000000000120157 Types 5&5
325287468238843 * 112637272727272727283991 Types 1&1
335423176363099 * 109233636363636363647287 Types 1&1
680146524499399 * 53870000000000000005387 Types 1&1
7481611769493389 * 4897272727272727273217 Types 5&5
159302144672967931 * 230000000000000000023 Types 1&1
909090909090909091 * 40303442602260886543 Types 1&1
1752323591402647241 * 20909090909090909093 Types 5&5
3663949327478262413 * 10000000000000000001 Types 5&5
nphullmen_6a.py En:
284.5729763507843

Invité · 12/12/2017, 18h55

Bonjour
Quand on ne me connaît pas, on se demande toujours : Mais qu'est-ce qu'il raconte ?

Heureusement pour nous, nous n'avons pas besoin de nous comprendre entièrement, et pour le cas qui me concerne ce sera partiellement. Tout définir est un travail de longue haleine, et puisque je passe mon temps à coder ce simple petit programme qui m'accapare. Jusqu'à aujourd'hui, et encore une fois, j'exclame mon plaisir commun à chacun d'entre nous, puisse profiter de ce code si tel n'est pas le cas

Comme dit, les nombres forment un rassemblement invraisemblable. Ils sont difficiles à cerner, et toutes ces avancées amènent à des bonnes compréhensions.
Bonne continuation à tous ceux qui cheminent parmi l'univers des nombres...

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
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
 
#!/usr/bin/env python3.6
# -*- coding: utf-8 -*-
# Série première. En Général Python
# Objet : Apprendre par la pratique
# MusicAtoumic nphullmen_8x Ce 14 décembre 2017
"""Pyhton Compulsion Commune"""
import time
time_ = time.time()
 
def zero(z):
    if z == 1:
        z = 0
        print('Premiers (', z, ')ex\n', '[0]')
        print('{} * {} Types {}&{}'
              .format(z, z, z % 6, z % 6))
        print('nphullmen_6x.py En: \n', time.time() - time_)
    else:
        print('nphullmen_6x.py En: \n', time.time() - time_)
 
# 999888777666555000111222333444555 1304562926286024619985807821
# 1234567898765432112345678987654321
# 999888777666555666777888999 987898765456543212321
# 999888777666555444333222111 222557130146747222557130146747
# _____________________ 111222333222111000111222333222111
# :nombre: objet unique
nombre = 222557130146747222557130146747
print('Nombre =', nombre, '; typ =', nombre % 6)
# :breakComm: printage communs
breakComm = 0
# :zero: instruction zéro
if nombre == 0:
    zero(breakComm)
elif nombre < 0:
    nombre = abs(nombre)
# :carre: service axial
carre = int(nombre ** .5)
hautniveau = []  # Liste premiers
horscourse = []  # Liste communs ip&dv
hautmulti_ = [1]  # Mul.hautniveau
horsmulti_ = [1]  # Mul.horscourse
c12tableau = []  # Liste communs dv
# Lecteurs initiaux
p1 = [7]
p5 = [11]
m1 = [0]
m5 = [0]
d1 = [0]
d5 = [0]
q1 = [0]
q5 = [0]
"""Borne & cartyp6
Borne : Limite en pleine forêt
Cartyp6 : Limite en plein ciel"""
cartyp6 = [carre]
borne = int(cartyp6[0] ** .992)
borne = [borne]
print('cartyp6 = %s ; borne = %s' % (cartyp6, borne))
 
def forme15(rng_, r6_,mng_, m6_):
    """Positionnement des Lecteurs (bas/hauts)
        P1: Point (+6) Type (1)
            Position inférieure :ip: Inf.carre
        Q1: Point (-6) Type (5)
            Position supérieure :dv: Sup.carre"""
    if r6_ == 1:
        q1[0] = rng_
    else:
        dfo_ = r6_ - 1
        q1[0] = rng_ - dfo_
 
    if m6_ == 1:
        m1[0] = mng_
        d1[0] = mng_
    else:
        dfo_ = m6_ - 1
        m1[0] = mng_ - dfo_
        d1[0] = mng_ - dfo_
 
 
    # Position P5
    p5[0] = p1[0] - 2
    # Position Q5
    q5[0] = q1[0] - 2
    # Position M5
    m5[0] = m1[0] - 2
    d5[0] = d1[0] - 2
    print(' f15 p1, typ', p1[0], p1[0] % 6)
    print(' f15 d1, typ', d1[0], d1[0] % 6)
 
if nombre != 0:
    mib0 = borne[0] // 2
    forme15(borne[0], borne[0] % 6, mib0, mib0 % 6)
 
def compare(c):
    """Réception et traitement (c)"""
    hautmulti_[0] = 1
    didi = [c]
    if c not in horscourse:
        if c > 1:
            horscourse.append(c)
            horscourse.sort()
        sqc = int(c ** .5)
        for dd in range(2, sqc):
            if not c % dd:
                didi.append(dd)
                dddv = c // dd
                didi.append(dddv)
                didi.sort()
                break            
        # Priorité :didi:
        print('C didi', didi)
        for di in didi:
            c = di
            for haut in hautniveau[1:]:
                if not c % haut:
                    break
            else:
                hautniveau.append(c)
        # Production haut niveau
        for hha in hautniveau:
            hautmulti_[0] *= hha
        if hautmulti_[0] != 0:
            print('Oniveau =', sorted(hautniveau))
            print('Omulti_ =', hautmulti_)
            for c1 in sorted(hautniveau):
                for c2 in horscourse:
                    c12 = c1 * c2
                    # Séparation :carre:
                    if not nombre % c12 \
                            and c12 not in horscourse:
                        if c12 <= carre:
                            horscourse.append(c12)
                            horscourse.sort()
                        elif c12 not in c12tableau:
                            c12tableau.append(c12)
                            c12tableau.sort()
            if c12tableau:
                print('C max: c12 =', max(c12tableau))
                for ctab in c12tableau:
                    iptab = nombre // ctab
                    # :ctab: Occurence :c12:
                    if iptab not in horscourse:
                        for hh in hautniveau[1:]:
                            if not iptab % hh:
                                break
                        else:
                            print('C c12 compare: iptab =', iptab)
                            compare(iptab)
                if hautmulti_[0]:
                    c12ip = nombre // max(hautniveau)
                    # :c12ip: Sup.carre(dv) de Max.premier(ip)
                    print('C c12ip, max(c12)', c12ip, max(c12tableau))
                    if max(c12tableau) > c12ip:
                        hautmulti_[0] = 0
                        print('C BREAK max(c12)', max(c12tableau))
            if hautmulti_[0]:
                horsmulti_[0] = 1
                # Production hors course
                for hho in horscourse:
                    if horsmulti_[0] <= nombre:
                        horsmulti_[0] *= hho
                print('C coms(', len(horscourse), ')ex HORS(',
                      max(horscourse), ')')
                print('C  ****HORSmulti_', horsmulti_)
                cartyp6[0] = int((nombre // max(hautniveau)) ** .499)
                brn = int(cartyp6[0] ** .5)
                borne[0] = brn
                print('C cartyp6 =', cartyp6, 'borne =', borne)
            # Terme commun     
            if max(horscourse) <= carre:
                if hautmulti_[0]:
                    print('Cm if hautmulti', hautmulti_[0])
                    hdv = hautmulti_[0] * hautniveau[1]
                    # :hdv: Son.carre(dv) par Min.hautniveau
                    if hdv >= carre and not nombre % hdv:
                        hip = nombre // hdv
                        # :hip: Son(ip) du Son.carre(dv)
                        if hip not in horscourse:
                            print('Cm compare: hip =', hip)
                            compare(hip)
            print('C')
            if hautmulti_[0]:
                # Termes racine
                if hautmulti_[0] == nombre:
                    hautmulti_[0] = 0
                    print('E BREAK multi_==', nombre)
                elif hautmulti_[0] * hautniveau[1] >= carre \
                        and hautmulti_[0] == max(hautniveau):
                    hautmulti_[0] = 0
                    print('E BREAK multi*min(c)', hautmulti_)
                elif hautmulti_[0] * hautniveau[1] >= nombre:
                    hautmulti_[0] = 0
                    print('E BREAK multi*min(n)', hautmulti_)
                elif (nombre // hautmulti_[0]) <= max(hautniveau):
                    hautmulti_[0] = 0
                    print('E BREAK n/multi <= max(haut)', hautmulti_)
                elif max(horscourse) == nombre:
                    hautmulti_[0] = 0
                    print('E BREAK hors(nombre)', nombre)
                else:
                    # Différentiel comparatif
                    dvinf = nombre // max(horscourse)
                    ipsup = dvinf // max(horscourse)
                    sqinf = int(dvinf ** .5)
                    print('E (,sqinf)', sqinf)
                    print('E nombre//max(hors) dvinf =', dvinf)
                    print('E dvinf//max(hors) ipsup =', ipsup)
                    if len(hautniveau) > 2:
                        typ = 0
                        if ipsup >= carre:
                            if borne[0] == int(carre ** .992):
                                bord = int(borne[0] ** .7)
                            else:
                                bord = int(carre ** .5)
                            rng = bord
                            r6 = rng % 6
                            print('E rng', rng,
                                  'dv*.5', int(dvinf ** .499))
                            mib1 = borne[0] // 2
                            forme15(rng, r6, mib1, mib1 % 6)
                        else:
                            print('E else(dvinf,sqinf)', dvinf, sqinf)
                            if not nombre % sqinf \
                               and sqinf % 6 in(1, 5):
                                print('E if(compare): sqinf =', sqinf)
                                compare(sqinf)
                            if ipsup > 1:
                                sqinf = int(dvinf ** .5)
                                print('E sqinf', sqinf)
                                for e in range(2, sqinf):
                                    if not dvinf % e:
                                        typ = 1
                                        if e % 6 in (1, 5) \
                                                and e not in horscourse:
                                            print('E for(compare): e =', e)
                                            compare(e)
                                            break
                                else:
                                    typ = 0
                        print('  E sqinf', sqinf)
                        print('  E else dvinf', dvinf)
                        for hoip in horscourse[1:]:
                            if not dvinf % hoip:
                                hodv = dvinf // hoip
                                ho6 = hodv % 6
                                if ho6 in (1, 5) \
                                   and hodv not in horscourse:
                                    print(
                                        '  E for(compare): hodv =',
                                        hodv)
                                    compare(hodv)
                                    break
                            if hoip > sqinf:
                                break
    wu[0] = 0
 
"""Bas niveau des premiers:
Création du haut niveau des nombres premiers
Lié au bas niveau des nombres premiers
Composition des hors course"""
wu = [0]  # Indice d'écriture des lecteurs(1&5)
basniveau = [1, 2, 3, 5]
for i in range(1, 7):
    if not nombre % i and i <= carre:
        def rang(ti, i_):
            if ti == 1:  # Nombre Premier(basniveau)
                hautniveau.append(i_)
                horscourse.append(i_)
            else:  # Nombre Commun(basniveau)
                horscourse.append(i_)
 
        if i in basniveau:
            rang(1, i)
        else:
            rang(2, i)
if horscourse:
    # Traitement basique
    for h in horscourse:
        for o in horscourse:
            oh = h * o
            if not nombre % oh and oh not in horscourse:
                if oh > carre and not nombre % (nombre // oh):
                    if (nombre // oh) not in horscourse:
                        print('Basic compare: n>carre =', oh)
                        compare(nombre // oh)
                        break
                elif oh <= carre:
                    print('Basic compare: n<carre =', oh)
                    compare(oh)
                    break
"""Hauts niveaux premiers: cartyp6
Itérer dans l'alignement des nombres premiers
Condition évolutive des lecteurs"""
while p1[0] <= cartyp6[0]:
    while wu[0] < 1:  # Effet de boucle visu
        print('    while P1', p1,'Q1', q1)
        print('    while cartyp6', cartyp6,'borne', borne)
        print('W')
        break
    if hautmulti_[0] == 0:
        print('    W break hautmulti_', hautmulti_)
        break
    elif p1[0] > d1[0]:
        print('    W break p1>d1', p1[0], d1[0])
        break
    elif len(hautniveau) < 3 and p1[0] > int(borne[0]**.9163):
        print('    W break p1>borne', p1[0], int(borne[0]**.9163))
        break
    # Lectures
    if p1[0] == 0:  # Révision nombre
        print('    W P1', p1[0])
        print('    W n%P1', nombre % p1[0])
    if not nombre % p1[0] and p1[0] not in hautniveau \
            and p1[0] not in horscourse:
        print('  W p1', p1[0])
        compare(p1[0])
    if not nombre % p5[0] and p5[0] not in hautniveau \
            and p5[0] not in horscourse:
        print('  W p5', p5[0])
        compare(p5[0])
    if not nombre % q1[0] and q1[0] not in hautniveau \
            and q1[0] not in horscourse:
        print('  W q1', q1[0])
        compare(q1[0])
    if not nombre % q5[0] and q5[0] not in hautniveau \
            and q5[0] not in horscourse:
        print('  W q5', q5[0])
        compare(q5[0])
    if not nombre % m1[0] and m1[0] not in hautniveau \
            and m1[0] not in horscourse:
        print('  W m1', m1[0])
        compare(m1[0])
    if not nombre % m5[0] and m5[0] not in hautniveau \
            and m5[0] not in horscourse:
        print('  W m5', m5[0])
        compare(m5[0])
    if not nombre % d1[0] and d1[0] not in hautniveau \
            and d1[0] not in horscourse:
        print('  W d1', d1[0])
        compare(d1[0])
    if not nombre % d5[0] and d5[0] not in hautniveau \
            and d5[0] not in horscourse:
        print('  W d5', d5[0])
        compare(d5[0])
    p1[0] += 6
    p5[0] += 6
    q1[0] -= 6
    q5[0] -= 6
    m1[0] += 6
    m5[0] += 6
    d1[0] -= 6
    d5[0] -= 6
    wu[0] += 1
if nombre != 0:
    """Désigne la communauté:
    Les nombres premiers associés :hautniveau:
    Produisent la communauté des multiples communs"""
    hi = [u for u in horscourse if u <= carre]
    hi = len(hi)
    hautniveau.sort()
    print('carre %s cartyp6 %s borne %s' % (carre, cartyp6, borne))
    print('Premiers (', hi, ')ex\n', hautniveau)
    for i in horscourse[:hi]:
        if breakComm == 0:
            iii = -1
            while horscourse[iii] >= carre:
                iii -= 1
                pass
            else:
                ha = horscourse[iii]
            hu = horscourse[0]
            print('Duos (inf)*(sup)|(sup)*(inf) \n  {} * {} Types {}&{}'
                  .format(hu, nombre // hu, hu % 6, (nombre // hu) % 6))
            print('  {} * {} Types {}&{}'
                  .format(ha, nombre // ha, ha % 6, (nombre // ha) % 6))
            break
        else:
            print('{} * {} Types {}&{}'
                  .format(i, nombre // i, i % 6, (nombre // i) % 6))
    print('nphullmen_8x.py En: \n', time.time() - time_)
    print('', )

Ces débuts enchevêtrent plusieurs traitements, ils demandent à être résumés selon des motifs bien précis. Puis en gardant ce qui est "vraiment" nécessaire, il y a des chances de trouver les nombres communs sans utiliser les itérations. Ce qui manque à ce tableau ce sont les éléments de couplages supérieurs à la racine carrée, quotients de contenant inférieur du tableau hors course. Ainsi en croisant les inférieurs avec les supérieurs, on augmente d'un traitement par rapport à l'existant.

C'est à dire que ce n'est pas terminé, même si l'existant démontre le contraire du point de vue algorithmique

classnph

Téléchargez Python

Vue hybride

Partager

Partager