classnph

Version imprimable

Voir 40 message(s) de cette discussion en une page

31/07/2016, 12h31
forum

classnph

Bonjour,

Je vous propose un nouvel élément à utiliser : classnph

, deux codes = Une solution

Typage du nombre entier :

- Réponse qualifiant le nombre ( pair, impair)

Type = Reste = nombre%6

Essayage du nombre premier :

- Réponse quantitative du nombre ( quotient)

Intervalle = Quotient = 1/nombre

Qu'en pensez-vous ?
31/07/2016, 13h55
VinsS

J'avais toujours soupçonné que toumic est un robot, maintenant j'en ai la preuve.

Code:

1
2
3
4
5
6
7
8
 
# Affiche La Multiplication
nombre = 1626
for i in range(1, nombre):
    for y in range(1, nombre):
        iy = i * y
        if iy == nombre:
            print(i, '*', y, '=', iy)

.../

Et ceci:

Code:

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
 
import time
from math import sqrt
num = 1626
sqr = int(sqrt(num)) + 1
 
def toumic(tot):
    begin = time.time()
    for i in range(tot):
        for y in range(tot):
            iy = i * y
            if iy == tot:
                print("%s * %s = %s" % (i, y, tot))
    print("Done at: %s" %(time.time() - begin))
 
def vinss(tot, max_):
    begin = time.time()
    for i in range(max_):
        for y in range(max_, tot):
            if i * y == tot:
                print("%s * %s = %s" % (i, y, tot))
    print("Done at: %s" %(time.time() - begin))
 
toumic(num)
vinss(num, sqr)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
 
2 * 813 = 1626
3 * 542 = 1626
6 * 271 = 1626
271 * 6 = 1626
542 * 3 = 1626
813 * 2 = 1626
Done at: 0.7460360527038574
2 * 813 = 1626
3 * 542 = 1626
6 * 271 = 1626
Done at: 0.017701148986816406

Ou bien :)

Code:

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
 
# !/usr/bin/env python 3.5
# -*- coding: utf-8 -*-
import time
from math import sqrt
num = 9
sqr = int(sqrt(num))
print(sqr)
 
def toumic(tot):
    begin = time.time()
    for i in range(tot):
        for y in range(tot):
            iy = i * y
            if iy == tot:
                print("toumic = %s * %s = %s" % (i, y, tot))
    print("toumic = Done at: %s" %(time.time() - begin))
 
def vinss(tot, max_):
    begin = time.time()
    for i in range(max_):
        for y in range(max_, tot):
            if i * y == tot:
                print("vinss = %s * %s = %s" % (i, y, tot))
    print("vinss = Done at: %s" %(time.time() - begin))
 
toumic(num)
vinss(num, sqr + 1)

Code:

1
2
3
4
5
 
3
toumic = 3 * 3 = 9
toumic = Done at: 0.0
vinss = Done at: 0.0

Citation:

Envoyé par toumic

Ou bien :)

Code:

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
 
# !/usr/bin/env python 3.5
# -*- coding: utf-8 -*-
import time
from math import sqrt
num = 9
sqr = int(sqrt(num))
print(sqr)
 
def toumic(tot):
    begin = time.time()
    for i in range(tot):
        for y in range(tot):
            iy = i * y
            if iy == tot:
                print("toumic = %s * %s = %s" % (i, y, tot))
    print("toumic = Done at: %s" %(time.time() - begin))
 
def vinss(tot, max_):
    begin = time.time()
    for i in range(max_):
        for y in range(max_, tot):
            if i * y == tot:
                print("vinss = %s * %s = %s" % (i, y, tot))
    print("vinss = Done at: %s" %(time.time() - begin))
 
toumic(num)
vinss(num, sqr + 1)

Code:

1
2
3
4
5
 
3
toumic = 3 * 3 = 9
toumic = Done at: 0.0
vinss = Done at: 0.0

Une toute petite correction pour un résultat pour tous :)

Code:

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
 
# !/usr/bin/env python 3.5
# -*- coding: utf-8 -*-
import time
from math import sqrt
num = 1600
sqr = int(sqrt(num))
print(sqr)
 
def toumic(tot):
    begin = time.time()
    for i in range(tot):
        for y in range(tot):
            if i * y == tot:
                print("toumic = %s * %s = %s" % (i, y, tot))
    print("toumic = Done at: %s" %(time.time() - begin))
 
def vinss(tot, max_):
    begin = time.time()
    for i in range(max_):
        for y in range(max_ - 1, tot):
            if i * y == tot:
                print("vinss = %s * %s = %s" % (i, y, tot))
    print("vinss = Done at: %s" %(time.time() - begin))
 
toumic(num)
vinss(num, sqr + 1)

labowagenph\agenph1toast2et.py ================
4
toumic = 2 * 8 = 16
toumic = 4 * 4 = 16
toumic = 8 * 2 = 16
toumic = Done at: 0.008025884628295898
vinss = 2 * 8 = 16
vinss = 4 * 4 = 16
vinss = Done at: 0.00871419906616211
>>>

Code:

1
2
 
# Raté mais c'est pas grave :)

Allez parce que ça m'amuse aussi les concours de celui qui pisse (du code) le plus loin :mrgreen:

Code:

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
import time
from math import sqrt
num = 1600
sqr = int(sqrt(num))
print(sqr)
 
def toumic(tot):
    begin = time.time()
    for i in range(tot):
        for y in range(tot):
            if i * y == tot:
                print("toumic = %s * %s = %s" % (i, y, tot))
    print("toumic = Done at: %s" %(time.time() - begin))
 
def biBistouille(num) :
    debut = time.time()
    num2 = num
    def genInfini(i, pas) :
        while i < float('inf') :
            yield(i)
            i += pas
 
    def genPrems() :
        yield 2
        for n in genInfini(2, 1) :
            if not n % 2 :
                continue
            x = 3
            p = True
            while x < n**0.5 + 1 :
                if not n % x :
                    p = False
                    break
                x += 2
            if not p :
                continue
            yield n
 
    gp = genPrems()
    liste = []
    while num2 > 1 :
        np = next(gp)
        while not num2 % np :
            liste.append(np)
            num2 /= np
 
    i = 0
    comb = set()
    while i < len(liste) :
        comb.add((liste[i], int(num / liste[i])))
        z = liste[i]
        for n in liste[:i] :
            z *= n
            res = int(num / z)
            valeur = (z, res) if z < res else (res, z)
            comb.add(valeur)
        i += 1
 
    res = ''
    for n in sorted(comb) :
        res += 'BiBistouille : {} * {} = {}\n'.format(n[0], n[1], num)
    print('{}Bibistouille Effectué en : {}'.format(res, time.time() - debut))
 
num = 1600
toumic(num)
biBistouille(num)

Code:

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
splash@splash:~$ py3 toumic_est_trop_comique.py 
40
toumic = 2 * 800 = 1600
toumic = 4 * 400 = 1600
toumic = 5 * 320 = 1600
toumic = 8 * 200 = 1600
toumic = 10 * 160 = 1600
toumic = 16 * 100 = 1600
toumic = 20 * 80 = 1600
toumic = 25 * 64 = 1600
toumic = 32 * 50 = 1600
toumic = 40 * 40 = 1600
toumic = 50 * 32 = 1600
toumic = 64 * 25 = 1600
toumic = 80 * 20 = 1600
toumic = 100 * 16 = 1600
toumic = 160 * 10 = 1600
toumic = 200 * 8 = 1600
toumic = 320 * 5 = 1600
toumic = 400 * 4 = 1600
toumic = 800 * 2 = 1600
toumic = Done at: 0.26367926597595215
BiBistouille : 1 * 1600 = 1600
BiBistouille : 2 * 800 = 1600
BiBistouille : 4 * 400 = 1600
BiBistouille : 5 * 320 = 1600
BiBistouille : 8 * 200 = 1600
BiBistouille : 10 * 160 = 1600
BiBistouille : 16 * 100 = 1600
BiBistouille : 20 * 80 = 1600
BiBistouille : 25 * 64 = 1600
BiBistouille : 32 * 50 = 1600
BiBistouille : 40 * 40 = 1600
Bibistouille Effectué en : 0.00014281272888183594

Citation:

# Raté mais c'est pas grave :pan:

Citation:

Envoyé par bistouille

Allez parce que ça m'amuse aussi les concours de celui qui pisse (du code) le plus loin :mrgreen:

.../...

Code:

1
2
splash@splash:~$ py3 toumic_est_trop_comique.py 
40

:) Et plus petite, p...

Code:

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
 
import time
from math import sqrt
num = 1600
sqr = int(sqrt(num))
 
def toumic(tot):
    begin = time.time()
    for i in range(sqr + 1):
        for y in range(sqr, int(num/2)+1):
            if i * y == tot:
                print("toumic = %s * %s = %s" % (i, y, tot))
                break
    print("toumic = Done at: %s" %(time.time() - begin))
 
def biBistouille(num) :
    debut = time.time()
    num2 = num
    def genInfini(i, pas) :
        while i < float('inf') :
            yield(i)
            i += pas
 
    def genPrems() :
        yield 2
        for n in genInfini(2, 1) :
            if not n % 2 :
                continue
            x = 3
            p = True
            while x < n**0.5 + 1 :
                if not n % x :
                    p = False
                    break
                x += 2
            if not p :
                continue
            yield n
 
    gp = genPrems()
    liste = []
    while num2 > 1 :
        np = next(gp)
        while not num2 % np :
            liste.append(np)
            num2 /= np
 
    i = 0
    comb = set()
    while i < len(liste) :
        comb.add((liste[i], int(num / liste[i])))
        z = liste[i]
        for n in liste[:i] :
            z *= n
            res = int(num / z)
            valeur = (z, res) if z < res else (res, z)
            comb.add(valeur)
        i += 1
 
    res = ''
    for n in sorted(comb) :
        res += 'BiBistouille : {} * {} = {}\n'.format(n[0], n[1], num)
    print('{}Bibistouille Effectué en : {}'.format(res, time.time() - debut))
 
# num = 1600
toumic(num)
biBistouille(num)

Hé hé hé

Re-salut :)
Je relance les dés ...

Code:

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
 
import time
from math import sqrt
 
def biBistouille(num) :
    debut = time.time()
    num2 = num
    def genInfini(i, pas) :
        while i < float('inf') :
            yield(i)
            i += pas
 
    def genPrems() :
        yield 2
        for n in genInfini(2, 1) :
            if not n % 2 :
                continue
            x = 3
            p = True
            while x < n**0.5 + 1 :
                if not n % x :
                    p = False
                    break
                x += 2
            if not p :
                continue
            yield n
 
    gp = genPrems()
    liste = []
    while num2 > 1 :
        np = next(gp)
        while not num2 % np :
            liste.append(np)
            num2 /= np
 
    i = 0
    comb = set()
    while i < len(liste) :
        comb.add((liste[i], int(num / liste[i])))
        z = liste[i]
        for n in liste[:i] :
            z *= n
            res = int(num / z)
            valeur = (z, res) if z < res else (res, z)
            comb.add(valeur)
        i += 1
    res = ''
    for n in sorted(comb) :
        res += 'BiBistouille : {} * {} = {}\n'.format(n[0], n[1], num)
    print('{}Bibistouille Effectué en : {}'.format(res, time.time() - debut))
 
 
def toumtoumic(num1):
    debut2 = time.time()
    maxinum = int(num1 / 2)
    max = maxinum if maxinum else 1
    min = int(sqrt(num1))
    def gentoum():
        for chnum in range(1, min + 1):
            npnum = int(num1 / chnum)
            if not num1 % chnum:
                yield chnum, npnum
            else:
                pass
 
    goum = gentoum()
    for g in goum:
        print('alpage : {} * {} = {}'.format(g[0], g[1], num1))
    print('toumToumic Effectué en : {}'.format(time.time() - debut2))
 
num = num1 = 16758984654
biBistouille(num)
toumtoumic(num1)

Pour un résultat gratuit :)

Code:

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
 
 RESTART: C:\Users\Vincent\Documents\developpez\labowa\labowagenph\nphbistouille1.py 
BiBistouille : 1 * 16758984654 = 16758984654
BiBistouille : 2 * 8379492327 = 16758984654
BiBistouille : 3 * 5586328218 = 16758984654
BiBistouille : 6 * 2793164109 = 16758984654
BiBistouille : 18 * 931054703 = 16758984654
BiBistouille : 22159 * 756306 = 16758984654
BiBistouille : 42017 * 398862 = 16758984654
BiBistouille : 44318 * 378153 = 16758984654
BiBistouille : 66477 * 252102 = 16758984654
BiBistouille : 84034 * 199431 = 16758984654
BiBistouille : 126051 * 132954 = 16758984654
Bibistouille Effectué en : 0.27219223976135254
alpage : 1 * 16758984654 = 16758984654
alpage : 2 * 8379492327 = 16758984654
alpage : 3 * 5586328218 = 16758984654
alpage : 6 * 2793164109 = 16758984654
alpage : 9 * 1862109406 = 16758984654
alpage : 18 * 931054703 = 16758984654
alpage : 22159 * 756306 = 16758984654
alpage : 42017 * 398862 = 16758984654
alpage : 44318 * 378153 = 16758984654
alpage : 66477 * 252102 = 16758984654
alpage : 84034 * 199431 = 16758984654
alpage : 126051 * 132954 = 16758984654
toumToumic Effectué en : 0.08974242210388184
>>>

Encore une amélioration en jeu, en copiant les techniques de l'adversaire on gagne du temps :)

Code:

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
 
import time
from math import sqrt
 
def biBistouille(num) :
    debut = time.time()
    num2 = num
    def genInfini(i, pas) :
        while i < float('inf') :
            yield(i)
            i += pas
 
    def genPrems() :
        yield 2
        for n in genInfini(2, 1) :
            if not n % 2 :
                continue
            x = 3
            p = True
            while x < n**0.5 + 1 :
                if not n % x :
                    p = False
                    break
                x += 2
            if not p :
                continue
            yield n
 
    gp = genPrems()
    liste = []
    while num2 > 1 :
        np = next(gp)
        while not num2 % np :
            liste.append(np)
            num2 /= np
 
    i = 0
    comb = set()
    while i < len(liste) :
        comb.add((liste[i], int(num / liste[i])))
        z = liste[i]
        for n in liste[:i] :
            z *= n
            res = int(num / z)
            valeur = (z, res) if z < res else (res, z)
            comb.add(valeur)
        i += 1
    res = ''
    for n in sorted(comb) :
        res += 'BiBistouille : {} * {} = {}\n'.format(n[0], n[1], num)
    print('{}Bibistouille Effectué en : {}'.format(res, time.time() - debut))
 
def toumtoumic(num1):
    debut2 = time.time()
    min = int(sqrt(num1))
    def gentoum():
        for chnum in range(1, min + 1):
            npnum = int(num1 / chnum)
            if not num1 % chnum:
                yield chnum, npnum
            else:
                pass
    goum = gentoum()
    gers = ''
    for g in goum:
        gers += 'alpage : {} * {} = {}\n'.format(g[0], g[1], num1)
    print('{}toumToumic Effectué en : {}'.format(gers, time.time() - debut2))
 
num = num1 = 16758984654
biBistouille(num)
toumtoumic(num1)

Code:

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
 
>>> 
========== RESTART: C:/Users/Vincent/Documents/nphbistouille3.py ==========
BiBistouille : 1 * 16758984654 = 16758984654
BiBistouille : 2 * 8379492327 = 16758984654
BiBistouille : 3 * 5586328218 = 16758984654
BiBistouille : 6 * 2793164109 = 16758984654
BiBistouille : 18 * 931054703 = 16758984654
BiBistouille : 22159 * 756306 = 16758984654
BiBistouille : 42017 * 398862 = 16758984654
BiBistouille : 44318 * 378153 = 16758984654
BiBistouille : 66477 * 252102 = 16758984654
BiBistouille : 84034 * 199431 = 16758984654
BiBistouille : 126051 * 132954 = 16758984654
Bibistouille Effectué en : 0.27670955657958984
alpage : 1 * 16758984654 = 16758984654
alpage : 2 * 8379492327 = 16758984654
alpage : 3 * 5586328218 = 16758984654
alpage : 6 * 2793164109 = 16758984654
alpage : 9 * 1862109406 = 16758984654
alpage : 18 * 931054703 = 16758984654
alpage : 22159 * 756306 = 16758984654
alpage : 42017 * 398862 = 16758984654
alpage : 44318 * 378153 = 16758984654
alpage : 66477 * 252102 = 16758984654
alpage : 84034 * 199431 = 16758984654
alpage : 126051 * 132954 = 16758984654
toumToumic Effectué en : 0.056047677993774414
>>>

Encore plus vite

Ouille. En prenant quelques raccourcis, je me suis trouvé en plain multiple commun.
Des combines sont présentes dans ce milieu, ce code en renferme quelques-unes.

Code:

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
 
#!/usr/bin/env python3.6
# -*- coding: utf-8 -*-
import time
from math import sqrt
 
# biBistouille chez BIBI :)
 
def biBistouille(num) :
    debut = time.time()
    num2 = num
    def genInfini(i, pas) :
        while i < float('inf') :
            yield(i)
            i += pas
 
    def genPrems() :
        yield 2
        for n in genInfini(2, 1) :
            if not n % 2 :
                continue
            x = 3
            p = True
            while x < n**0.5 + 1 :
                if not n % x :
                    p = False
                    break
                x += 2
            if not p :
                continue
            yield n
 
    gp = genPrems()
    liste = []
    while num2 > 1 :
        np = next(gp)
        while not num2 % np :
            liste.append(np)
            num2 /= np
 
    i = 0
    comb = set()
    while i < len(liste) :
        comb.add((liste[i], int(num / liste[i])))
        z = liste[i]
        for n in liste[:i] :
            z *= n
            res = int(num / z)
            valeur = (z, res) if z < res else (res, z)
            comb.add(valeur)
        i += 1
    res = ''
    for n in sorted(comb) :
        res += 'BiBistouille : {} * {} = {}\n'.format(n[0], n[1], num)
    print('{}Bibistouille Effectué en : {}'.format(res, time.time() - debut))
 
# Toumic dans les alpages
 
def toumtoumic(num1):
    debut2 = time.time()
    maxinum = int(num1 / 2)
    max = maxinum if maxinum else 1
    min = int(sqrt(num1))
    def gentoum():
        for chnum in range(1, min + 1):
            npnum = int(num1 / chnum)
            if not num1 % chnum:
                yield chnum, npnum
            else:
                pass
    goum = gentoum()
    for g in goum:
        print('alpage : {} * {} = {}'.format(g[0], g[1], num1))
    print('toumToumic Effectué en : {}'.format(time.time() - debut2))
 
# Toumic à la plage
 
def nautic(nemO):
    # Le nouveau nombre est arrivé !!!
    debut4 = time.time()
    tiwp = []       # Prélèvement des multiples
    tiw6 = []       # Typage de nombre
    towop = {}      # Dictionnaire initial
    quo = nemO
    q6 = quo%6      # Typage de nombre
    tiw6.append(q6)
    sqrip = int(sqrt(quo))      # Racine carrée multiplicative
    sqsqp = int(sqrt(sqrip))
    # La principale fonction itérative
    def gennau():
        # La technique de recherche rapide
        for ip in range(sqrip+1):
            if ip%6 in (1,5) and not quo%ip and ip >1:
                dvs = int(quo/ip)
                break
            else: #(0,2,3,4)
                dvs = nemO
        # L'nitialisation des tables factorielles
        woi = dvs
        sqrwp = int(sqrt(woi))
        wp = 1
        while wp < sqrwp+1:
            if not woi%wp:              # Nombre multiple
                wyp = wp, int(woi/wp)
                tiwp.append(wyp)        # Prélèvement
                t6 = wp%6
                if t6 in tiw6:
                    pass
                else:
                    tiw6.append(t6)
                wp += 1
            else:                       # Nombre non multiple
                while wp < sqrwp+1:
                    if not woi%wp:
                        break
                    wp += 1
        # La reconstitution initiale
        z2_10 = 0
        m2_10 = 0
        for zp in tiwp:
            zop = zp                    # Prélèvement
            multinf = zop[0]            # Multiple inférieur
            multsup = zop[1]            # Multiple supérieur
            z1_10 = m1_10 = multinf
            m1 = m1_10
            if multsup > sqrip:         # Test supérieur
                m2_10 = int(quo / multsup)
            else:                       # Test inférieur
                m2_10 = multsup
            m2 = m2_10
            z2_10 = m2_10
            towop[z1_10] = m1
            towop[z2_10] = m2
        wotop = list(towop)
        wotop.sort()
        # La reconstitution terminale
        for ap in wotop:          # Avant transmission
            yield ap, int(nemO/ap)
 
        print('eleme', len(towop), 'typ', tiw6, 'sqrip', sqrip)
    # Seuil de la transmission    
    nau = gennau()
    gers = ''
    for g in nau:
        gers += 'Nautique : (n) {} * {}\n'.format(g[0], g[1])
    print('{}nphb_0e.py Effectué en : {}'.format(gers, time.time() - debut4))
# Début                      Poiteur V
 
 
 
nemO = num = num1 = 125648754697
biBistouille(num)
toumtoumic(num1)
nautic(nemO)

Affichage résultat chrono en main

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
>>> 
 RESTART: C:/Users/Vincent/Documents/developpez/labowa/labownphpn/nphbistouille3.py 
BiBistouille : 1 * 125648754697 = 125648754697
BiBistouille : 263 * 477751919 = 125648754697
BiBistouille : 1301 * 96578597 = 125648754697
BiBistouille : 342163 * 367219 = 125648754697
BiBistouille : 367219 * 342163 = 125648754697
Bibistouille Effectué en : 4.572049617767334
alpage : 1 * 125648754697 = 125648754697
alpage : 263 * 477751919 = 125648754697
alpage : 1301 * 96578597 = 125648754697
alpage : 342163 * 367219 = 125648754697
toumToumic Effectué en : 0.1726069450378418
eleme 4 typ [1, 5] sqrip 354469
Nautique : (n) 1 * 125648754697
Nautique : (n) 263 * 477751919
Nautique : (n) 1301 * 96578597
Nautique : (n) 342163 * 367219
nphb_0e.py Effectué en : 0.0190126895904541
>>>

C'est très vivant de penser intelligemment, même si ce n'est pas parfait :)

1 pièce(s) jointe(s)

Sans blabla. Qu'avec logique

[Bonjour]

Code:

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
 
#!/usr/bin/env python3.6
# -*- coding: utf-8 -*-
# nphbasic_1a.py
import time
from math import sqrt
 
def cosmic(un_o):
    """
    La multiplication est associative,
    elle est conditionnelle au typage.
    """
    debut4 = time.time()
    tiwp = []  # Prélèvement des primeures
    towop = {}  # Dictionnaire principal
    quo = un_o
    sqrip = int(sqrt(quo))  # Racine première
    # La principale fonction itérative
    def gennau():
        """
        Lors d'une conduction de type premier multiple. (:genneau:)
        S'intialise une référence diminuée de moitié, (:tiwp:)
        en finalité des multiples communs au nombre. (:quo:)
        """
        # La technique de recherche primeure
        dvs = quo
        for ip in range(2, sqrip + 1):
            if ip % 6 in (1, 5) and not quo % ip:
                dvs = int(quo / ip)  # dvs = Second niveau
                break
        """
        dvs = multiplicateur du nombre premier(ip).
        dvs += première profondeur comme élément
        """
        # L'initialisation des tables factorielles
        sqrwp = int(sqrt(dvs))  # Racine secondaire
        wp = 1
        while wp < sqrwp + 1:
            if not dvs % wp:  # Nombre multiple
                wyp = wp, int(dvs / wp)
                tiwp.append(wyp)  # Prélèvement
                wp += 1
            else:  # Nombre non multiple
                while wp < sqrwp + 1:
                    if not dvs % wp:
                        break
                    wp += 1
        """
        tiwp = <class 'list'> : Liste du niveau -1.
        "while wp" lecture des multiples en 2.
        "if not" est directement enregistré et 1.
        "else" lecture de l'intervalle en plus.
        """
        print('tiwp ', len(tiwp), tiwp)
        # La reconstitution initiale
        # z2_10 = m2_10 = 0
        for zp in tiwp:
            zop = zp  # Prélèvement
            multinf = zop[0]  # Multiple inférieur
            multsup = zop[1]  # Multiple supérieur
            z1_10 = multinf  # Primeure absente
            m1 = int(quo / multinf)
            if multsup > sqrip:  # Test supérieur
                m2_10 = int(quo / multsup)
            else:  # Test inférieur
                m2_10 = multsup
            z2_10 = m2_10
            m2 = int(quo / z2_10)
            towop[z2_10] = m2
            towop[z1_10] = m1
        # La reconstitution terminale
        for ap, op in sorted(towop.items()):  # Avant transmission
            yield ap, op
        print('eleme', len(towop), 'typ', un_o % 6, 'sqrip', sqrip)
    # Seuil de la transmission
    nau = gennau()
    gers = ''
    for g in nau:
        gers += ': (n) {} * {}\n'.format(g[0], g[1])
    print('{}nphb_1a.py En : {}'.format(gers, time.time() - debut4))
 
# Début
unO = 123456789
print('Cosmic')
cosmic(unO)
# Mémo 123456789

Python 3.6.0 Shell

Code:

1
2
3
4
5
6
7
8
9
10
11
12
 RESTART: C:\Users\Vincent\Documents\developpez\labowa\labownph0\nphbasic_1a.py 
Cosmic
tiwp  3 [(1, 34227), (3, 11409), (9, 3803)]
eleme 6 typ 3 sqrip 11111
: (n) 1 * 123456789
: (n) 3 * 41152263
: (n) 9 * 13717421
: (n) 3607 * 34227
: (n) 3803 * 32463
: (n) 10821 * 11409
nphb_1a.py En : 0.01380610466003418
>>>

Schéma contextuel

Citation:

#!/usr/bin/env python3.6
# -*- coding: utf-8 -*-
# nphbasic_1a.py
'''
A
Cosmic
tiwp 4 [(1, 1122334454), (2, 561167227), (149, 7532446), (298, 3766223)]
eleme 8 typ 4 sqrip 111111
: (n) 1 * 12345678994 typ 1
: (n) 2 * 6172839497 typ 2
: (n) 11 * 1122334454 typ 5
: (n) 22 * 561167227 typ 4
: (n) 149 * 82856906 typ 5
: (n) 298 * 41428453 typ 4
: (n) 1639 * 7532446 typ 1
: (n) 3278 * 3766223 typ 2
nphb_1a.py En : 0.039537668228149414
Cosmic
tiwp 2 [(1, 7532446), (2, 3766223)]
eleme 4 typ 2 sqrip 33501
: (n) 1 * 1122334454 typ 1
: (n) 2 * 561167227 typ 2
: (n) 149 * 7532446 typ 5
: (n) 298 * 3766223 typ 4
nphb_1a.py En : 0.019628524780273438
Cosmic
tiwp 2 [(1, 7532446), (2, 3766223)]
eleme 4 typ 2 sqrip 9102
: (n) 1 * 82856906 typ 1
: (n) 2 * 41428453 typ 2
: (n) 11 * 7532446 typ 5
: (n) 22 * 3766223 typ 4
nphb_1a.py En : 0.028172731399536133
Cosmic
tiwp 2 [(1, 7532446), (2, 3766223)]
eleme 2 typ 4 sqrip 2744
: (n) 1 * 7532446 typ 1
: (n) 2 * 3766223 typ 2
nphb_1a.py En : 0.025005102157592773
Z
'''

[\Bonjour]

1 pièce(s) jointe(s)

Assurance douceur

Encore du temps de gagné, en un seul changement de point du démarrage de la recherche en boucle des nombres de types 1 et 5. Qui sont impliqués dans la lignée des possibles premiers multiples, ainsi qu'élément du couple lié à un multiple commun. Mais ceci est un tout autre développement...

On sait que les couples associés au nombre original, sont en ordre croissant et qu'à terme on a peut être la chance de tomber sur une racine carré. Comme par exemple 12345678987654321. Puis quand on dévore des yeux les sous multiples, on comprend qu'ils ne sont pas tous égaux en quantité (même si le contenu est exact). En prenant comme début le code suivant :
Code:

1 2 3 quo = un_o sqrip = int(sqrt(quo)) # Racine première sq3 = int(sqrt(sqrip))
On a la racine carrée de la racine carrée originale "sq3", et un départ.
Code:

1 2 3 4 5 6 dvs = quo for ip in range(sq3, sqrip + 1): if ip % 6 in (1, 5) and not quo % ip: dvs = int(quo / ip) # dvs = Second niveau print('ip', ip) break
Relançant le jeu de poursuite de l'information autour du multiple :)

AVANT

Citation:

Cosmic
ip 37
eleme 23 typ 3 sqrip 111111111
: (n) 1 * 12345678987654320 typ 1*2
: (n) 3 * 4115226329218107 typ 3*3
: (n) 9 * 1371742109739369 typ 3*3
: (n) 27 * 457247369913123 typ 3*3
: (n) 37 * 333666999666333 typ 1*3
: (n) 81 * 152415789971041 typ 3*1
: (n) 111 * 111222333222111 typ 3*3
: (n) 333 * 37074111074037 typ 3*3
: (n) 999 * 12358037024679 typ 3*3
: (n) 1369 * 9018027018009 typ 1*3
: (n) 2997 * 4119345674893 typ 3*1
: (n) 4107 * 3006009006003 typ 3*3
: (n) 12321 * 1002003002001 typ 3*3
: (n) 36963 * 334001000667 typ 3*3
: (n) 110889 * 111333666889 typ 3*1
: (n) 333667 * 36999999963 typ 1*3
: (n) 1001001 * 12333333321 typ 3*3
: (n) 3003003 * 4111111107 typ 3*3
: (n) 9009009 * 1370370369 typ 3*3
: (n) 12345679 * 999999999 typ 1*3
: (n) 27027027 * 456790123 typ 3*1
: (n) 37037037 * 333333333 typ 3*3
: (n) 111111111 * 111111111 typ 3*3
nphb_2.py En : 6.324310302734375

MAINTENANT

Citation:

Cosmic
ip 333667
eleme 23 typ 3 sqrip 111111111
: (n) 1 * 12345678987654320 typ 1*2
: (n) 3 * 4115226329218107 typ 3*3
: (n) 9 * 1371742109739369 typ 3*3
: (n) 27 * 457247369913123 typ 3*3
: (n) 37 * 333666999666333 typ 1*3
: (n) 81 * 152415789971041 typ 3*1
: (n) 111 * 111222333222111 typ 3*3
: (n) 333 * 37074111074037 typ 3*3
: (n) 999 * 12358037024679 typ 3*3
: (n) 1369 * 9018027018009 typ 1*3
: (n) 2997 * 4119345674893 typ 3*1
: (n) 4107 * 3006009006003 typ 3*3
: (n) 12321 * 1002003002001 typ 3*3
: (n) 36963 * 334001000667 typ 3*3
: (n) 110889 * 111333666889 typ 3*1
: (n) 333667 * 36999999963 typ 1*3
: (n) 1001001 * 12333333321 typ 3*3
: (n) 3003003 * 4111111107 typ 3*3
: (n) 9009009 * 1370370369 typ 3*3
: (n) 12345679 * 999999999 typ 1*3
: (n) 27027027 * 456790123 typ 3*1
: (n) 37037037 * 333333333 typ 3*3
: (n) 111111111 * 111111111 typ 3*3
nphb_3.py En : 0.27335596084594727

Image 333667
Pièce jointe 248414

CODE
Code:

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 #!/usr/bin/env python3.6 # -*- coding: utf-8 -*- # Série nphbasic_1a.py import time from math import sqrt def cosmic(un_o): """ La multiplication est associative, elle est conditionnelle au typage. """ debut4 = time.time() tiwp = [] # Prélèvement des primeures towop = {} # Dictionnaire principal quo = un_o sqrip = int(sqrt(quo)) # Racine première sq3 = int(sqrt(sqrip)) # La principale fonction itérative def gennau(): """ Lors d'une conduction de type premier multiple. (:genneau:) S'intialise une référence diminuée de moitié, (:tiwp:) en finalité des multiples communs au nombre. (:quo:) """ # La technique de recherche primeure dvs = quo for ip in range(sq3, sqrip + 1): if ip % 6 in (1, 5) and not quo % ip: dvs = int(quo / ip) # dvs = Second niveau print('ip', ip) break """ dvs = multiplicateur du nombre premier(ip). dvs += première profondeur comme élément """ # L'initialisation des tables factorielles sqrwp = int(sqrt(dvs)) # Racine secondaire wp = 1 while wp < sqrwp + 1: if not dvs % wp: # Nombre multiple wyp = wp, int(dvs / wp) tiwp.append(wyp) # Prélèvement wp += 1 else: # Nombre non multiple while wp < sqrwp + 1: if not dvs % wp: break wp += 1 # print('tiwp ', len(tiwp), 'sqrwp', sqrwp) """ tiwp = <class 'list'> : Liste du niveau -1. "while wp" lecture des multiples en 2. "if not" est directement enregistré et 1. "else" lecture de l'intervalle en plus. """ # La reconstitution initiale for zp in tiwp: zop = zp # Prélèvement multinf = zop[0] # Multiple inférieur multsup = zop[1] # Multiple supérieur z1_10 = multinf # Primeure absente m1 = int(quo / multinf) if multsup > sqrip: # Test supérieur m2_10 = int(quo / multsup) else: # Test inférieur m2_10 = multsup z2_10 = m2_10 m2 = int(quo / z2_10) towop[z2_10] = m2 towop[z1_10] = m1 # La reconstitution terminale for ap, op in sorted(towop.items()): # Avant transmission yield ap, op, ap % 6, op % 6 print('eleme', len(towop), 'typ', un_o % 6, 'sqrip', sqrip) # Seuil de la transmission nau = gennau() gers = '' for g in nau: gers += ': (n) {} * {} typ {}*{}\n'.format(g[0], g[1], g[2], g[3]) print('{}nphb_3.py En : {}'.format(gers, time.time() - debut4)) # Début unO = 12345678987654321 print('Cosmic') cosmic(unO) """ Cosmic """ # Mémo 12345678987654321 # Fin

Encore plus ???

Eh oui :)

En ajoutant un signe de reconnaissance mnémonique : ip0
Ici

Code:

1
2
3
4
5
6
7
8
9
# La technique de recherche primeure
        dvs = quo
        ip0 = 0
        for ip in range(sq3, sqrip + 1):
            if ip % 6 in (1, 5) and not quo % ip:
                dvs = int(quo / ip)  # dvs = Second niveau
                ip0 = 1
                print('ip', ip)
                break

Corrigé 28/02/17 Ici : Car le sous-multiple sélectionné ne suffisait pas à l'original

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
# La technique de recherche primeure
        dvs = quo
        ipo = int(dvs % 6)
        for ip in range(2, sq3):
            if ip % 6 in (1, 5) and not quo % ip:
                dvs = int(quo / ip)  # dvs = Second niveau
                break
        else:   # Recherche plan minimal
            for ip in range(2, sq4):
                ouq = int(quo/ip)
                if ouq % 6 in (5, ipo) and not quo % ip:
                    dvs = ouq
                    break

Et là

Code:

1
2
3
4
# L'initialisation des tables factorielles
        sqrwp = int(sqrt(dvs))  # Racine secondaire
        if ip0 == 0:
            sqrwp = sq3

Corrigé 28/02/17 Ici : Inutile avec la correction, donc enlevé

Tout çà pour ça

Code:

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
#!/usr/bin/env python3.6
# -*- coding: utf-8 -*-
# Série nphbasic_1a.Général Python
# Version nohb_30.py
import time
from math import sqrt
 
def cosmic(un_o):
    """
    La multiplication est associative,
    elle est conditionnelle au typage.
    """
    debut4 = time.time()
    tiwp = []  # Prélèvement des primeures
    towop = {}  # Dictionnaire principal
    quo = un_o
    sqrip = int(sqrt(quo))  # Racine première
    sq3 = int(sqrt(sqrip))
 
    # La principale fonction itérative
    def gennau():
        """
        Lors d'une conduction de type premier multiple. (:genneau:)
        S'intialise une référence diminuée de moitié, (:tiwp:)
        en finalité des multiples communs au nombre. (:quo:)
        """
        # La technique de recherche primeure
        dvs = quo
        ip0 = 0
        for ip in range(sq3, sqrip + 1):
            if ip % 6 in (1, 5) and not quo % ip:
                dvs = int(quo / ip)  # dvs = Second niveau
                ip0 = 1
                print('ip', ip)
                break
        """
        dvs = multiplicateur du nombre premier(ip).
        dvs += première profondeur comme élément
        """
        # L'initialisation des tables factorielles
        sqrwp = int(sqrt(dvs))  # Racine secondaire
        if ip0 == 0:
            sqrwp = sq3
        print('sq3', sq3, 'sqrwp', sqrwp)
        wp = 1
        while wp < sqrwp + 1:
            if not dvs % wp:  # Nombre multiple
                wyp = wp, int(dvs / wp)
                tiwp.append(wyp)  # Prélèvement
                wp += 1
            else:  # Nombre non multiple
                while wp < sqrwp + 1:
                    if not dvs % wp:
                        break
                    wp += 1
        # print('tiwp ', len(tiwp), 'sqrwp', sqrwp)
        """
        tiwp = <class 'list'> : Liste du niveau -1.
        "while wp" lecture des multiples en 2.
        "if not" est directement enregistré et 1.
        "else" lecture de l'intervalle en plus.
        """
        # La reconstitution initiale
        for zp in tiwp:
            zop = zp  # Prélèvement
            multinf = zop[0]  # Multiple inférieur
            multsup = zop[1]  # Multiple supérieur
            z1_10 = multinf  # Primeure absente
            m1 = int(quo / multinf)
            if multsup > sqrip:  # Test supérieur
                m2_10 = int(quo / multsup)
            else:  # Test inférieur
                m2_10 = multsup
            z2_10 = m2_10
            m2 = int(quo / z2_10)
            towop[z2_10] = m2
            towop[z1_10] = m1
        # La reconstitution terminale
        for ap, op in sorted(towop.items()):  # Avant transmission
            yield ap, op, ap % 6, op % 6
        print('eleme', len(towop), 'typ', un_o % 6, 'sqrip', sqrip)
    # Seuil de la transmission
    nau = gennau()
    gers = ''
    for g in nau:
        gers += ': (n) {} * {} typ {}*{}\n'.format(g[0], g[1], g[2], g[3])
    print('{}nphb_30.py En : {}'.format(gers, time.time() - debut4))
 
# Début
unO = 12345678987654
print('Cosmic')
cosmic(unO)
"""
Cosmic
"""
# Mémo 12345678987654321
# Mémo 123456789876543
# Fin

Corrigé 28/02/17 en mieux

Code:

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
 
#!/usr/bin/env python3.6
# -*- coding: utf-8 -*-
# Série nphbasic_1a.Général Python
# Version nphb_5.py
import time
from math import sqrt
 
def cosmic(un_o):
    debut4 = time.time()
    tiwp = []  # Prélèvement des primeures
    towop = {}  # Dictionnaire principal
    quo = un_o
    sqrip = int(sqrt(quo))  # Racine première
    sq3 = int(sqrt(sqrip))  # Racine médiane
    sq4 = int(sqrt(sq3))    # Racine minimale
 
    # La principale fonction itérative
    def gennau():
        # La technique de recherche primeure
        dvs = quo
        ipo = int(dvs % 6)
        for ip in range(2, sq3):
            if ip % 6 in (1, 5) and not quo % ip:
                dvs = int(quo / ip)  # dvs = Second niveau
                break
        else:   # Recherche plan minimal
            for ip in range(2, sq4):
                ouq = int(quo/ip)
                if ouq % 6 in (5, ipo) and not quo % ip:
                    dvs = ouq
                    break
        # L'initialisation des tables factorielles
        sqrwp = int(sqrt(dvs))  # Racine secondaire
        wp = 1
        while wp < sqrwp + 1:
            if not dvs % wp:  # Nombre multiple
                wyp = wp, int(dvs / wp)
                tiwp.append(wyp)  # Prélèvement
                wp += 1
            else:  # Nombre non multiple
                while wp < sqrwp + 1:
                    if not dvs % wp:
                        break
                    wp += 1
 
        # La reconstitution initiale
        for zp in tiwp:
            zop = zp  # Prélèvement
            multinf = zop[0]  # Multiple inférieur
            multsup = zop[1]  # Multiple supérieur
            z1_10 = multinf  # Primeure absente
            m1 = int(quo / multinf)
            if multsup > sqrip:  # Test supérieur
                m2_10 = int(quo / multsup)
            else:  # Test inférieur
                m2_10 = multsup
            z2_10 = m2_10
            m2 = int(quo / z2_10)
            towop[z2_10] = m2
            towop[z1_10] = m1
 
        # La reconstitution terminale
        for ap, op in sorted(towop.items()):  # Avant transmission
            yield ap, op, ap % 6, op % 6
        print('eleme', len(towop), 'typ', un_o % 6, 'sqrip', sqrip)
    # Seuil de la transmission
    nau = gennau()
    gers = ''
    for g in nau:
        gers += ': (n) {} * {} typ {}*{}\n'.format(g[0], g[1], g[2], g[3])
    print('{}nphb_51.py En : {}'.format(gers, time.time() - debut4))
 
# Début
print('Cosmic')
for x in range(1, 60):
    xip = x
    unO = xip
    cosmic(unO)
"""
Cosmic
"""
# Mémo 12345678987654321
# Mémo 123456789876543
# Fin

ATTENTION VARIANTE :)

Code:

1
2
3
4
5
6
7
 
# Début
print('Cosmic')
for x in range(1, 60):
    xip = x
    unO = xip
    cosmic(unO)

:idea:

Comme c'est bon de regarder les associations des n°

De mémoire j'en suis resté à une vitesse de calcul, en 35 secondes pour : 12345678987654321 :)

En réfléchissant un peu, et trois mois plus tard. Toumic réalise le même parcours en 6 secondes.
Je vous propose de regarder les nombres de la même façon que moi, juste pour voir tous ses artifices.

Les personnes qui ont inventées les nombres ont réalisées un travail de titan, ou c'est tombé dessus par hasard ?

Quoi qu'il en soit, je reste ravi devant toutes mes prouesses. Merci Python :)

Voici la bête :mrgreen:

Code:

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
 
#!/usr/bin/env python3.6
# -*- coding: utf-8 -*-
# Série nphbasic_1a.Général Python
# Version nphb_6a.py
import time
from math import sqrt
 
def cosmic(un_o):
    debut4 = time.time()
    towop = {}  # Dictionnaire principal
    quo = un_o
    sqrip = int(sqrt(quo))  # Racine première
    sq3 = int(sqrt(sqrip))  # Racine médiane
    sq4 = int(sqrt(sq3))    # Racine minimale
 
    # La principale fonction itérative
    def gennau():
        # La recherche du sous-multiple
        dvs = ip = quo
        ipo = dvs % 6
        for ip in range(2, sq3):
            if ip % 6 in (1, 5) and not quo % ip:
                dvs = int(quo / ip)  # dvs = Second plan
                break
        else:
            for ip in range(2, sq4):
                ouq = int(quo/ip)
                if not quo % ouq and ip % 6 in (1, 5):
                    dvs = ouq       # dvs = Plain minimal
                    break
        print('ip', ip, 'dvs',dvs,'sq3',sq3,'sq4',sq4)
        # La sélection des multiples communs originaux
        sqrwp = int(sqrt(dvs))  # Racine secondaire
        wp = 1
        while wp < sqrwp + 1:
            if not dvs % wp:  # Nombre multiple
                wyp = wp, int(dvs / wp)
                minf = wyp[0]
                msup = wyp[1]
                z1_10 = minf
                m1 = int(quo / minf)
                if msup > sqrip:  # Test supérieur
                    m2_10 = int(quo / msup)
                else:  # Test inférieur
                    m2_10 = msup
                z2_10 = m2_10
                m2 = int(quo / z2_10)
                towop[z2_10] = m2
                towop[z1_10] = m1
                wp += 1
            else:  # Nombre non multiple
                while wp < sqrwp + 1:
                    if not dvs % wp:
                        break
                    wp += 1
 
        # La reconstitution terminale
        for ap, op in sorted(towop.items()):  # Avant transmission
            yield ap, op, ap % 6, op % 6
        print('eleme', len(towop), 'typ', un_o % 6, 'sqrip', sqrip)
    # Seuil de la transmission
    nau = gennau()
    gers = ''
    for g in nau:
        gers += '{} * {} typ {}*{}\n'.format(g[0], g[1], g[2], g[3])
    print('{}nphb_6b7.py En : {}'.format(gers, time.time() - debut4))
 
# Début
unO = 12345678987654321
print('Cosmic', unO)
cosmic(unO)
"""
Cosmic
37 dvs 333666999666333 sq3 10540 sq4 102
eleme 23 typ 3 sqrip 111111111
1 * 12345678987654320 typ 1*2
3 * 4115226329218107 typ 3*3
9 * 1371742109739369 typ 3*3
27 * 457247369913123 typ 3*3
37 * 333666999666333 typ 1*3
81 * 152415789971041 typ 3*1
111 * 111222333222111 typ 3*3
333 * 37074111074037 typ 3*3
999 * 12358037024679 typ 3*3
1369 * 9018027018009 typ 1*3
2997 * 4119345674893 typ 3*1
4107 * 3006009006003 typ 3*3
12321 * 1002003002001 typ 3*3
36963 * 334001000667 typ 3*3
110889 * 111333666889 typ 3*1
333667 * 36999999963 typ 1*3
1001001 * 12333333321 typ 3*3
3003003 * 4111111107 typ 3*3
9009009 * 1370370369 typ 3*3
12345679 * 999999999 typ 1*3
27027027 * 456790123 typ 3*1
37037037 * 333333333 typ 3*3
111111111 * 111111111 typ 3*3
nphb_6b7.py En : 6.86573052406311
Cosmic
67 dvs 1474110927 sq3 560 sq4 23
eleme 16 typ 3 sqrip 314269
: (n) 1 * (98765432109) typ 1*3 uno0
: (n) 3 * 32921810703 typ 3*3
: (n) 9 * 10973936901 typ 3*3
: (n) 27 * 3657978967 typ 3*1
: (n) 67 * (1474110927) typ 1*3 dvs0 uno1
: (n) 201 * (491370309) typ 3*3 dvs1 uno2
: (n) 603 * (163790103) typ 3*3 dvs2 uno3
: (n) (1723) * 57321783 typ 1*3 dvs4
: (n) 1809 * (54596701) typ 3*1 dvs3 uno4
: (n) 5169 * 19107261 typ 3*3
: (n) 15507 * 6369087 typ 3*3
: (n) (31687) * 3116907 typ 1*3 dvs4
: (n) 46521 * 2123029 typ 3*1
: (n) 95061 * 1038969 typ 3*3
: (n) 115441 * 855549 typ 1*3
: (n) 285183 * 346323 typ 3*3
nphb_6a.py En : 0.039083003997802734
"""
# Fin
 
@+

02/04/2017, 08h26
Invité

5 pièce(s) jointe(s)

La précédente démonstration en record à la vitesse de calcul, est vue à la hausse en se servant des nombres de type premier. Ce dernier message a prit son temps avant de s'affirmer, par l'effet de recherches à tâtonnements sur une liste déjà produite. Un peu triché car la logique ne commence pas à zéro, lorsque sans la liste je n'avais pas encore compris le développement de A à Z. Ce matin je vais essayer de faire passer le message exprimé par les nombres...

On sait tous que les nombres sont typiquement liés à six sections entières d'alignement nul correspondant au zéro, où chaque nombre a une série de type chronique. Par exemple, suivant le nombre 2 et cumulons-le. On obtient cette série de types constamment (2, 4, 0), le chiffre 6 n'a qu'un seul type le zéro (0). Puis on peut aussi voir, qu'un grand nombre a des multiples communs de types différents à la liste original. C'est normal puisque les types des nombres 1 et 5 ont dans leurs séries originales tous les types réunis (1, 2, 3, 4, 5, 0), et qu'il forment un point de supplémentarité nouvellement multiple commune (puisque nombre premier)..

Sans s'évertuer à des descriptions textuelles et parfois perdues dans le texte, je propose une image et quelques mots explicatifs.
Ce tableau récapitule les cas de recherches réalisés sur chaque état de couplage, afin de déterminer quel type de bas niveau est à même de résulter à la demande de tous les multiplicateurs communs de notre premier nombre original. Et non seulement, il doit être de bas niveau pour que l'opération soit le plus rapide possible. Tout comme moi; l'écran n'aime pas attendre pendant que "monsieur" l'ordinateur travaille...
Pièce jointe 260191
Tous les couplages ne sont pas égaux, ni complets, puisque ce n'est pas la quantité de multiplicateurs communs qui lui sont appréciés. Mais plutôt les réunions de types étant des compléments incomplets, cette non finalité a l'atout de représenter plus clairement des détails non perdus dans la masse. Ainsi que de démontrer les différentes cause de cadences dans les élans des multiplications, .

Pièce jointe 260196
Rassurez-vous, tout ceci n'est qu'un avant goût. Disons à l'image d'un musée sans guide, sans artiste et des oeuvres numériques de première facture :)
Pièce jointe 260199
On ne le dira jamais assez les mots s'envolent avec les millénaires :)
Pièce jointe 260204
Les écrits restent plus longtemps s'ils sont sages comme des images.
Pièce jointe 260208

Bon voyage numérique

NON[int(a/b)] OUI[a//b]

[QUOTE=toumic;9114113]De mémoire j'en suis resté à une vitesse de calcul, en 35 secondes pour : 12345678987654321 :)

Quoi qu'il en soit, je reste ravi devant toutes mes prouesses. Merci Python :)

Voici la bête :mrgreen:

QUOTE]

La bête a été remplacée à cause d'inconvénients établis par la division en détournant certains résultats
Du coup, au lieu de coder :int(a/b):. S'est codé :a//b:. C'est tout !

Code:

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
 
#!/usr/bin/env python3.6
# -*- coding: utf-8 -*-
# Série nphbasic_1a.Général Python
# Version nphb_6a.py
import time
from math import sqrt
 
def cosmic(un_o):
    debut4 = time.time()
    towop = {}  # Dictionnaire principal
    quo = un_o
    sqrip = int(sqrt(quo))  # Racine première
    sq3 = int(sqrt(sqrip))  # Racine médiane
    sq4 = int(sqrt(sq3))    # Racine minimale
 
    # La principale fonction itérative
    def gennau():
        # La recherche du sous-multiple
        dvs = ip = quo
        ipo = dvs % 6
        for ip in range(2, sq3):
            if ip % 6 in (1, 5) and not quo % ip:
                dvs = quo // ip  # dvs = Second plan
                break
        else:
            for ip in range(2, sq4):
                ouq = quo//ip
                if not quo % ouq and ip % 6 in (1, 5):
                    dvs = ouq       # dvs = Plain minimal
                    break
        print('ip', ip, 'dvs',dvs,'sq3',sq3,'sq4',sq4)
        # La sélection des multiples communs originaux
        sqrwp = int(sqrt(dvs))  # Racine secondaire
        wp = 1
        while wp < sqrwp + 1:
            if not dvs % wp:  # Nombre multiple
                wyp = wp, dvs // wp
                minf = wyp[0]
                msup = wyp[1]
                z1_10 = minf
                m1 = quo // minf
                if msup > sqrip:  # Test supérieur
                    m2_10 = quo // msup
                else:  # Test inférieur
                    m2_10 = msup
                z2_10 = m2_10
                m2 = quo // z2_10
                towop[z2_10] = m2
                towop[z1_10] = m1
                wp += 1
            else:  # Nombre non multiple
                while wp < sqrwp + 1:
                    if not dvs % wp:
                        break
                    wp += 1
 
        # La reconstitution terminale
        for ap, op in sorted(towop.items()):  # Avant transmission
            yield ap, op, ap % 6, op % 6
        print('eleme', len(towop), 'typ', un_o % 6, 'sqrip', sqrip)
    # Seuil de la transmission
    nau = gennau()
    gers = ''
    for g in nau:
        gers += '{} * {} typ {}*{}\n'.format(g[0], g[1], g[2], g[3])
    print('{}nphb_6b7corrige.py En : {}'.format(gers, time.time() - debut4))
 
# Début
unO = 2725518515793
print('Cosmic', unO)
cosmic(unO)

Ce n'est pas terminé, à suivre :)

Pavé du nombre dans la mare des communs

Bonjour

Je n'irais pas par quatre chemins, car je suis déjà fatigué d'avoir tracé celui que je vous fait parvenir.

Vu mon élémentarisme je crains les critiques, mais ne cède pas à mon devoir que vous pouvez lire ci-bas

Salutations respectueuses

Code:

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
 
""" Vendredi 7 avril 2017 """
# Exemple de développement multiple
# Nombre original = 100010001
# Utilitaire : nphbasic_6b7corrige
# Cosmic aux liaisons typiques
"""
    Nphbasic_6b7... :ip=7: :dv=14287143:
    Ip et dv, est le couple sélectionné
    L'ip est égal au type premier et sélection
    Le dv est son binôme de type(3)
    Celui qui est traité par l'utilitaire
        La masse numérale est supérieure à 10.000.000
        Son orbite est calculée en temps Python
        Temps Python. En : 0.03057241439819336
    """
# Développé général
# En un empilement des couples croissants
# Quelques définitions:
"""
    Titre : Cosmic 100010001
    Choix : ip 7 dvs 14287143 sq3 100 sq4 10
        ip 7 dvs 14287143, définis ci-dessus
        sq3 100 : carré du carré
        sq4 10 : carré(carré du carré)
    Corps : eleme 16 typ 3 sq1 10000.500037498125
        eleme 16 : 16 couples pour 32 communs
        typ 3 : multiple commun impair
        sq1 10000.500037498125 : 1ère racine carrée
    """
# La relative dv d'origine, lorsque ip = 1
# Est continuellement mise à contribution
# L'aspect finit est typiquement original
# A droite, après :typ ip*dv: 1ers repères
"""
    La suite dv a un couple de bas niveau
        9901 * 10101 typ 1*3 A°*B *3'8 91 * 111
        A° : l'ip 9901 qui a le typage 1, est premier
        Le dv 10101 est de type 3, est capable
        B *3'8 : dv B a 8 éléments pour 16 originaux
        91 * 11 : couple du bas niveau de B
    """
# Les données présentées nous guident 
# Elles cernent les différents niveaux
# Le commun typé a ses ip et dv, communs
# Ci-bas, le dv B, et sa borne inférieure
"""
    91 * 1099011 typ 1*3 a_ *3'4 111 * 9901
        L'ip 91 : borne inférieure basse (ip)
    111 * 900991 typ 3*1 a_ *1'4 91 * 9901
        Le dv 900991 : borne inférieure haute (dv)
    Les deux ip (91, 111) ont une origine voisine
    Cet intervalle est en rapport localisé
    En étant le dv du niveau inférieur
        Il devient un supérieur d'origine inférieure
        Et, dv couplé supérieurement à l'ip 1
    """
# À cette étape : En : 0.05180621147155762
# Le temps Python ne gagne pas en vitesse moyenne
# Rappel début ip 7 : En : 0.03057241439819336
# Cette étape met plus de temps malgré le moins dv
"""
    La raison en vient de l'utilitaire nphbasic_6b7
        nphbasic_6b7 est sûr de son résultat
        nphbasic_6b7 utilise une méthode basique
    """
# Actuellement, nphbasic_6b7 reste de mise
# Il sert à comparer cet élaboré
# À ce développement
"""
Cosmic 100010001
ip 7 dvs 14287143 sq3 100 sq4 10
eleme 16 typ 3 sq1 10000.500037498125
1 * 100010001 typ 1*3
3 * 33336667 typ 3*1
7 * 14287143 typ 1*3
13 * 7693077 typ 1*3
21 * 4762381 typ 3*1
37 * 2702973 typ 1*3
39 * 2564359 typ 3*1
91 * 1099011 typ 1*3 a_ *3'4 111 * 9901
111 * 900991 typ 3*1 a_ *1'4 91 * 9901
259 * 386139 typ 1*3
273 * 366337 typ 3*1
481 * 207921 typ 1*3
777 * 128713 typ 3*1
1443 * 69307 typ 3*1
3367 * 29703 typ 1*3
9901 * 10101 typ 1*3 A°*B *3'8 91 * 111
nphb_6b7corrige.py En : 0.03057241439819336
"""
# Type 1 et nombre premier multiple
# Temps Python : En : 0.05399656295776367
# Tel que je connais cet utilitaire
# Il a fermé l'ip en boucle de 1 à sq1
# sq1 original : 10000.500037498125
# Puis il a traité à partir du dv original
# dv original : 100010001
"""
Cosmic 9901
ip 2 dvs 9901 sq3 9 sq4 3
eleme 1 typ 1 sq1 99.50376877284599
1 * 9901 typ 1*1
nphb_6b7corrige.py En : 0.05399656295776367
"""
# Plan B à cause d'un plan A carré (9901)
# A° est la signature d'un couple majeur
# Couple à l'origine, a 16 couples
# Le couple majeur a 8 couples
"""
    Ce genre de couplage a 8 éléments
    Qui s'emboitent avec complémentarité
    Produisent les 16 éléments originaux
    """
    # Cosmic 10101
"""
Cosmic 10101
ip 7 dvs 1443 sq3 10 sq4 3
eleme 8 typ 3 sq1 100.50373127401788
1 * 10101 typ 1*3
3 * 3367 typ 3*1
7 * 1443 typ 1*3
13 * 777 typ 1*3
21 * 481 typ 3*1
37 * 273 typ 1*3
39 * 259 typ 3*1
91 * 111 typ 1*3
nphb_6b7corrige.py En : 0.05180621147155762
"""
# Simples curiosités complexes:
    # Cosmic 1099011
"""
Cosmic 1099011
ip 4 dvs 1099011 sq3 32 sq4 5
eleme 4 typ 3 sq1 1048.337254894626
1 * 1099011 typ 1*3
3 * 366337 typ 3*1
37 * 29703 typ 1*3
111 * 9901 typ 3*1
nphb_6b7corrige.py En : 0.027402400970458984
"""
    # Cosmic 900991 
"""
Cosmic 900991
ip 7 dvs 128713 sq3 30 sq4 5
eleme 4 typ 1 sq1 949.2054572114512
1 * 900991 typ 1*1
7 * 128713 typ 1*1
13 * 69307 typ 1*1
91 * 9901 typ 1*1
nphb_6b7corrige.py En : 0.04903221130371094
"""
"""
Bonne continuation
"""

Encore plus vite que tout à l'heure ;)

Code:

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
 
#!/usr/bin/env python3.6
# -*- coding: utf-8 -*-
# Série communs. En Général Python
# Version : Première facture
# Programmes NphParty_0a : 2 avril 2017
#########################################################
"""
Ce programme a une définition harmonique basée sur un nombre
unique, il énumère en une série de couplages un ensemble
de multiples communs. C'est en voulant être plus rapide, que
les opérations se sont dirigées vers les couples. Dans le but
de trouver un nombre moins conséquent, nous donnant en un
moindre temps de calcul le résultat réel.
NphParty_4.py : 15 avril 2017
                                Music@toumic
"""
#########################################################
import time
from math import sqrt
depart = time.time()
# Tables connexées
ipba = [] # Plus petit commun
dvba = [] # Tableau primaire
ipso = [] # Transfert dico
ipho = [0] # sous-multiple
sq1 = [0]
ipdv = {}
def nombre(n_):
    """
    Cette fonction trouve le plus petit
    couple multiple de bas niveau, et
    enregistre les couplages
    """
    norg = n_
    co6 = norg % 6
    # Le plus petit nombre commun
    def cobas(c_):
        corg = c_
        csq1 = int(sqrt(corg))
        if corg == norg:
            sq1[0] = csq1
        # Couple de bas niveau
        for cu in range(csq1, 0, -1):
            if not corg % cu:
                ip = cu
                dv = corg//cu
                cipdv = ip, dv, corg
                ipba.append(cipdv)
                break
    # Communs du sous-multiple
    def souscom():
        """
        Les couples de bas niveaux :ipba:, sont
        utilisés pour être simplifiés.
        """
        ip1 = dv1 = 0
        if ipba[1][0] == 1: # Nombre premier
            ip1 = 1
        if ipba[2][0] == 1: # Nombre premier
            dv1 = 1
        if ip1 + dv1 == 2: # Nombres premiers
            scip = ipba[0][:2], ipba[0][:2]
        elif ip1 + dv1 == 1: # Un sur deux premier ?
            if ip1 - dv1 < 0: # :(ip1=0)-(dv1=1)=-1:
                scip = ipba[1], ipba[2][:2]
            else: # :(ip1=1)-(dv1=0)=1:
                scip = ipba[1][:2], ipba[2]
        else: # Nombre premier absent
            scip = ipba[1], ipba[2]
        dvba.append(1)
        for sp in scip:
            for si in sp:
                if si not in dvba:
                    dvba.append(si)
        dvba.sort()
        """
        :dvba: Conteneur élémentaire - bas niveau
        """
        for sd in dvba[1:]: # Distribution du bas niveau
            sdi6 = sd % 6
            sdd6 = (norg // sd) % 6
            if sd in ipba[0]: # :ipba[0]: Partie initiale
                if ip1 == 1: # Rappel Nombre Premier
                    snbr = sd
                    break
                elif dv1 == 1: # R N P
                    snbr = norg // sd
                    break
            elif sd not in ipba[0]: # Nombre non initial
                if sdi6 in (1, 5) and sdd6 == co6\
                   and sd > 1: # Option Type 
                    snbr = norg // sd
                    break
                elif sdi6 == co6 and sdd6 in (1,5): # O T
                    snbr = sd
                    break
        else: # Echec et méthode classique
            if ipba[0][0] == ipba[0][1]: # Correction
                sdmin = dvba[0]
            else:
                sdmin = dvba[-2]
            sdmin = dvba[1]
            for mnx in range(sdmin, 2, -1):
                sdmnx = norg // mnx
                mnx6 = mnx % 6
                if not norg % mnx and mnx6 in (1, 5):
                    snbr = sdmnx
                    break
        print('snbr', snbr)  # :snbr: Sélection
        sqnbr = int(sqrt(snbr))
        for sid in range(1, sqnbr + 1):
            if not snbr % sid and sid not in ipso:
                ipso.append(sid)
                ipso.append(snbr//sid) 
    def communs(i_):
        """
        Transmission de la composition :ipso:
        Conteneur des éléments de couplage
        """
        for ic in i_:
            if ic > sq1[0]:
                if norg//ic not in list(ipdv.keys()):
                    ipdv[norg//ic] = ic
            else:
                if ic not in list(ipdv.keys()):
                    ipdv[ic] = norg//ic
        for ip, dv in sorted(ipdv.items()):
            yield ip, dv
    # C Party
    cobas(norg)
    cobas(ipba[0][0])
    cobas(ipba[0][1])
    souscom()
    ipso.sort()
    com = communs(ipso)
    stop = topo = 0
    co = ''
    for c in com:
        if stop < 5: # Pour éviter l'écriture
            co += '{} * {} Tp {}*{}\n'.format(c[0], c[1],c[0]%6,c[1]%6)
            stop += 0 # Pour mettre à 1
            topo += 1
        else: break
    print('Ed', topo, 'typ', norg % 6, 'sq1', sq1[0])
    print('{}NphParty_4cosic.py En {}'.format(co, time.time() - depart))
 
nbr = 4356
print('Cosmic', nbr)
nombre(nbr)
"""
Le développement en cours a des zones de captation
1: La zone la plus évoluée est celle de la racine carrée
    L'espace minimum requis
2: Puis, la zone du niveau bas au premier tableau :ipba[0]:
    Lors d'une racine carrée:
        Indice de l'intégralité du couple
3: Sinon, :dvba: effectue un tri de type (%6)
    Selon un :ip: dans type (1, 5)
    Et un :dv: dans la table :co1:
        :co1: réunit les types :dvba:
"""
 
 
 
 
 
 
 
 
 
 
 
#

Malheureusement, il ne tourne pas rond. Je m'en suis aperçu en essayant le nombre 4356 qui a un couple de bas niveau composé d'une racine carrée
Heureusement, qu'il peut au moins susciter le mal de la mer ;)

Ce n'est pas fini puisque je cherche, et j'ai retrouvé une vieille solution ( Parmi les nombreuses fabuleuses ). Qui commence la main tenante sur l'expérience acquise.
La promesse de recherches :for: restreintes...

Voici la clé du succès

Code:

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
 
#!/usr/bin/env python3.6
# -*- coding: utf-8 -*-
from math import sqrt
"""
Cosmic 987654321123456789
dvba [2923, 13761, 73589, 333667, 975308641, 1012658229]
elif1 2923
snbr 337890633295743
Ed 48 typ 3 sq1 993807990
1 * 987654321123456789 Tp 1*3
3 * 329218107041152263 Tp 3*3
9 * 109739369013717421 Tp 3*1
11 * 89786756465768799 Tp 5*3
33 * 29928918821922933 Tp 3*3
99 * 9976306273974311 Tp 3*5
139 * 7105426770672351 Tp 1*3
417 * 2368475590224117 Tp 3*3
1251 * 789491863408039 Tp 3*1
1529 * 645947888242941 Tp 5*3
2923 * 337890633295743 Tp 1*3
4587 * 215315962747647 Tp 3*3
8769 * 112630211098581 Tp 3*3
13761 * 71771987582549 Tp 3*5
26307 * 37543403699527 Tp 3*1
32153 * 30717330299613 Tp 5*3
73589 * 13421222208801 Tp 5*3
96459 * 10239110099871 Tp 3*3
220767 * 4473740736267 Tp 3*3
289377 * 3413036699957 Tp 3*5
333667 * 2960000003367 Tp 1*3
406297 * 2430867865437 Tp 1*3
662301 * 1491246912089 Tp 3*5
809479 * 1220111109891 Tp 1*3
1001001 * 986666667789 Tp 3*3
1218891 * 810289288479 Tp 3*3
2428437 * 406703703297 Tp 3*3
3003003 * 328888889263 Tp 3*1
3656673 * 270096429493 Tp 3*1
3670337 * 269090909397 Tp 5*3
4469267 * 220987987767 Tp 5*3
7285311 * 135567901099 Tp 3*1
10228871 * 96555555459 Tp 5*3
11011011 * 89696969799 Tp 3*3
13407801 * 73662662589 Tp 3*3
30686613 * 32185185153 Tp 3*3
33033033 * 29898989933 Tp 3*5
40223403 * 24554220863 Tp 3*5
46379713 * 21294964053 Tp 1*3
92059839 * 10728395051 Tp 3*5
112517581 * 8777777769 Tp 1*3
139139139 * 7098321351 Tp 3*3
215100647 * 4591591587 Tp 5*3
337552743 * 2925925923 Tp 3*3
417417417 * 2366107117 Tp 3*1
510176843 * 1935905823 Tp 5*3
645301941 * 1530530529 Tp 3*3
975308641 * 1012658229 Tp 1*3
NphParty_5.py En 7.02373480796814
"""
# NphParty_5.py Témoin Erroné
"""
Cosmic 987654321123456789
ip 11 dvs 89786756465768799 sq3 31524 sq4 177
eleme 96 typ 3 sq1 993807990.0682309
1 * 987654321123456789 typ 1*3
3 * 329218107041152263 typ 3*3
9 * 109739369013717421 typ 3*1
11 * 89786756465768799 typ 5*3
33 * 29928918821922933 typ 3*3
37 * 26693360030363697 typ 1*3 a
79 * 12501953431942491 typ 1*3 a
99 * 9976306273974311 typ 3*5
111 * 8897786676787899 typ 3*3
139 * 7105426770672351 typ 1*3
237 * 4167317810647497 typ 3*3
333 * 2965928892262633 typ 3*1
407 * 2426669093669427 typ 5*3
417 * 2368475590224117 typ 3*3
711 * 1389105936882499 typ 3*1
869 * 1136541221085681 typ 5*3
1221 * 808889697889809 typ 3*3
1251 * 789491863408039 typ 3*1
1529 * 645947888242941 typ 5*3
2607 * 378847073695227 typ 3*3
2923 * 337890633295743 typ 1*3 a_'2"24
3663 * 269629899296603 typ 3*5
4587 * 215315962747647 typ 3*3
5143 * 192038561369523 typ 1*3
7821 * 126282357898409 typ 3*5
8769 * 112630211098581 typ 3*3
10981 * 89942111021169 typ 1*3
13761 * 71771987582549 typ 3*5 b_'6"8
15429 * 64012853789841 typ 3*3
26307 * 37543403699527 typ 3*1
32153 * 30717330299613 typ 5*3
32943 * 29980703673723 typ 3*3
46287 * 21337617929947 typ 3*1
56573 * 17458051033593 typ 5*3
73589 * 13421222208801 typ 5*3 b_'1"48
96459 * 10239110099871 typ 3*3
98829 * 9993567891241 typ 3*1
120791 * 8176555547379 typ 5*3
169719 * 5819350344531 typ 3*3
220767 * 4473740736267 typ 3*3
289377 * 3413036699957 typ 3*5
333667 * 2960000003367 typ 1*3 a_'1"48
362373 * 2725518515793 typ 3*3
406297 * 2430867865437 typ 1*3
509157 * 1939783448177 typ 3*5
662301 * 1491246912089 typ 3*5
809479 * 1220111109891 typ 1*3
1001001 * 986666667789 typ 3*3
1087119 * 908506171931 typ 3*5
1218891 * 810289288479 typ 3*3
2428437 * 406703703297 typ 3*3
2722793 * 362735735373 typ 5*3
3003003 * 328888889263 typ 3*1
3656673 * 270096429493 typ 3*1
3670337 * 269090909397 typ 5*3
4469267 * 220987987767 typ 5*3
5813531 * 169888888719 typ 5*3
7285311 * 135567901099 typ 3*1
8168379 * 120911911791 typ 3*3
10228871 * 96555555459 typ 5*3
11011011 * 89696969799 typ 3*3
12345679 * 80000000091 typ 1*3 a
13407801 * 73662662589 typ 3*3
17440593 * 56629629573 typ 3*3
24505137 * 40303970597 typ 3*5
26359693 * 37468354473 typ 1*3 a
29950723 * 32975975943 typ 1*3
30686613 * 32185185153 typ 3*3
33033033 * 29898989933 typ 3*5
37037037 * 26666666697 typ 3*3
40223403 * 24554220863 typ 3*5
46379713 * 21294964053 typ 1*3
52321779 * 18876543191 typ 3*5
63948841 * 15444444429 typ 1*3
79079079 * 12489451491 typ 3*3
89852169 * 10991991981 typ 3*3
92059839 * 10728395051 typ 3*5
111111111 * 8888888899 typ 3*1
112517581 * 8777777769 typ 1*3
135802469 * 7272727281 typ 5*3
139139139 * 7098321351 typ 3*3
191846523 * 5148148143 typ 3*3
215100647 * 4591591587 typ 5*3
237237237 * 4163150497 typ 3*1
269556507 * 3663997327 typ 3*1
289956623 * 3406214043 typ 5*3
337552743 * 2925925923 typ 3*3
378468227 * 2609609607 typ 5*3
407407407 * 2424242427 typ 3*3
417417417 * 2366107117 typ 3*1
510176843 * 1935905823 typ 5*3
575539569 * 1716049381 typ 3*1
645301941 * 1530530529 typ 3*3
808080809 * 1222222221 typ 5*3
869869869 * 1135404681 typ 3*3
975308641 * 1012658229 typ 1*3 A*B_'4"12
nphb_6b7corrige.py En : 107.3016836643219
"""
nbr = 987654321123456789
sq0 = int(sqrt(nbr))
tab = []
a13761 = [1,3,9,11,33,99,139,417,1251,1529,4587,13761]
b71771987582549 = [1,37,79,2923,73589,333667,2722793,
                   5813531,12345679,26359693,215100647,
                   975308641,24554220863,908506171931,
                   1939783448177,71771987582549]
for bn in b71771987582549:
    for an in a13761:
        bang = bn * an
        if not nbr%bang and bang < sq0\
           and bang not in tab:
            tab.append(bang)
tab.sort()
print('tab', tab, 'big', len(tab))
 
 
 
 
 
 
 
 
 
 
 
 
 
#

Voici le code :) Avec mises à jour des problèmes connus, en ayant sondés les phénomènes connus. Le programme ci-dessus a des problèmes, celui du dessous en a corrigé.

Code:

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
 
#!/usr/bin/env python3.6
# -*- coding: utf-8 -*-
# Série communs. En Général Python
# Version : Première facture
"""MusicAToumic"""
# Programmes NphParty_0a : 2 avril 2017
# Programme  NphParty_7a : 17 avril 2017
import time
from math import sqrt
depart = time.time()
nivbas = []
subips = []
subdvs = []
nivorg = []
sq1 = [0]
def nombre(n_):
    norg = n_
    def cobas(c_):
        corg = c_
        csq1 = int(sqrt(corg))
        if corg == norg:
            sq1[0] = csq1
        for nn in range(csq1, 0, -1):
            if not corg % nn:
                if nn == 1:
                    cn1q = 1
                else:
                    cn1q = nn
                nivbas.append(cn1q)
                break
    def socom():
        nivbas.sort()
        def sosub(s_):
            nivsub = []
            sub = s_
            ssq1 = int(sqrt(sub))
            for sn in range(ssq1, 0, -1):
                if not sub % sn:
                    if sn == 1 and len(nivsub) < 0:
                        nivsub.append(sub)
                    else:
                        sndv = sub // sn
                        nivsub.append(sn)
                        nivsub.append(sndv)
            return nivsub
        sipba = nivbas[0]       # Origine sous(ip)
        sdvba = norg // sipba   # Origine sous(dv)
        sipsub = sosub(sipba)   # Envoi :ip:
        sdvsub = sosub(sdvba)   # Envoi :dv:
        subips.append(sipsub)
        subips[0].sort()
        subdvs.append(sdvsub)
        subdvs[0].sort()
        print('ip %s  dv %s' % (sipba, sdvba))
    def multis():
        for mn in subips[0]:
            for mo in subdvs[0]:
                mon = mn * mo
                if not norg % mon and mon < sq1[0] + 1\
                   and mon not in nivorg:
                    nivorg.append(mon)
            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)
    cobas(nivbas[0])
    socom()
    multis()
    communs(nivorg)
    print('Ed', len(nivorg), 'typ', norg % 6, 'sq1', sq1[0])
    print('NphParty_7a.py En {}'.format(time.time() - depart))
uno = 147896325987412365
print('Cosmic', uno)
nombre(uno)

Bon t'es calmé, maintenant que ça marche

Citation:

Envoyé par toumic

Bonjour
Je reviens pour vous présenter le truc qui répond au précédent message
Bien que je ne le maitrise pas complètement, mais ce bidule fonctionne comme à l'identique
Enfin, chacun son champ de vision sur le sujet des multiples communs

Si cette première mouture calcule avec une légèreté déconcertante, celle qui est envisagée est prometteuse

En rapport avec le mètre du maitre charpentier...

Ce n'est pas fini puisque je cherche, et j'ai retrouvé une vieille solution ( Parmi les nombreuses fabuleuses ). Qui commence la main tenante sur l'expérience acquise.
La promesse de recherches :for: restreintes...

Voici la clé du succès

Voici le code :) Avec mises à jour des problèmes connus, en ayant sondés les phénomènes connus. Le programme ci-dessus a des problèmes, celui du dessous en a corrigé.

Sauf qu'en enlevant des lignes inutiles, que tu as mises lorsque tu étais chaud :)
Hi

Code:

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
 
#!/usr/bin/env python3.6
# -*- coding: utf-8 -*-
# Série communs. En Général Python
# Version : Première facture
# Programmes NphParty_0a : 2 avril 2017
# Programme  NphParty_8a : 18 avril 2017
import time
from math import sqrt
depart = time.time()
nivbas = []
subips = []
subdvs = []
nivorg = []
sq1 = [0]
def nombre(n_):
    norg = n_
    def cobas(c_):
        corg = c_
        csq1 = int(sqrt(corg))
        if corg == norg:
            sq1[0] = csq1
        for nn in range(csq1, 0, -1):
            if not corg % nn:
                nivbas.append(nn)
                break
    def socom():
        nivbas.sort()
        def sosub(s_):
            nivsub = []
            sub = s_
            ssq1 = int(sqrt(sub))
            for sn in range(ssq1, 0, -1):
                if not sub % sn:
                    sndv = sub // sn
                    nivsub.append(sn)
                    nivsub.append(sndv)
            return nivsub
        sipba = nivbas[0]       # Origine sous(ip)
        sdvba = norg // sipba   # Origine sous(dv)
        sipsub = sosub(sipba)   # Envoi :ip:
        sdvsub = sosub(sdvba)   # Envoi :dv:
        subips.append(sipsub)
        subips[0].sort()
        subdvs.append(sdvsub)
        subdvs[0].sort()
        print('ip %s  dv %s' % (sipba, sdvba))
    def multis():
        for mn in subips[0]:
            for mo in subdvs[0]:
                mon = mn * mo
                if not norg % mon and mon < sq1[0] + 1\
                   and mon not in nivorg:
                    nivorg.append(mon)
            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)
    cobas(nivbas[0])
    socom()
    multis()
    communs(nivorg)
    print('Ed', len(nivorg), 'typ', norg % 6, 'sq1', sq1[0])
    print('NphParty_8a.py En {}'.format(time.time() - depart))
uno = 147896325987412365
print('Cosmic', uno)
nombre(uno)

Citation:

C'est tout à fait bien une fois refroidi ton bouillon communal, en enlevant les croutons sa donne çà

Code:

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
 
#!/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
# Considérable simplifié de NphParty_8a
# Programme  Nphony_1a : 18 avril 2017
import time
from math import sqrt
depart = time.time()
nivbas = []
subips = []
subdvs = []
nivorg = []
sq1 = [0]
def nombre(n_):
    norg = n_
    def cobas(c_):
        corg = c_
        csq1 = int(sqrt(corg))
        if corg == norg:
            sq1[0] = csq1
        for nn in range(csq1, 0, -1):
            if not corg % nn:
                nivbas.append(nn)
                nivbas.append(corg // nn)
                break
    def socom():
        so2 = 0
        for so in nivbas:
            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)
                    else:
                        sndv = sub // sn
                        subdvs.append(sn)
                        subdvs.append(sndv)
        print('ip %s  dv %s' % (nivbas[0], nivbas[1]))
    def multis():
        for mn in subips:
            for mo in subdvs:
                mon = mn * mo
                if not norg % mon and mon < sq1[0] + 1\
                   and mon not in nivorg:
                    nivorg.append(mon)
            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)
    socom()
    multis()
    communs(nivorg)
    print('Ed', len(nivorg), 'typ', norg % 6, 'sq1', sq1[0])
    print('Nphony_1a.py En {}'.format(time.time() - depart))
uno = 987654321123456789
print('Cosmic', uno)
nombre(uno)

Voir 40 message(s) de cette discussion en une page