Discussion :

[toumic2.0]

Bonjour,

Je vous propose un nouvel élément à utiliser : Résolution de la conjecture Collatz et problème de Syracuse

"""#python

Bonjour, c'est Bing. Je peux vous aider à trouver des informations sur les nombres pairs et impairs. 😊



Vous avez décrit une règle qui s'applique aux nombres entiers. Pour un nombre pair, on le divise par deux.

Pour un nombre impair, on le multiplie par trois et on ajoute un. Par exemple :



- Si le nombre est 4, il est pair, donc on le divise par deux : 4 / 2 = 2

- Si le nombre est 5, il est impair, donc on le multiplie par trois et on ajoute un : 5 x 3 + 1 = 16



Cette règle est connue sous le nom de **conjecture de Collatz** ou de **problème de Syracuse**.

C'est un problème mathématique qui n'a pas encore été résolu.

Il consiste à se demander si, en appliquant cette règle à n'importe quel nombre entier positif,

on finit toujours par obtenir 1.



Par exemple, si on part de 6, on obtient la suite suivante :



- 6 est pair, donc on le divise par deux : 6 / 2 = 3

- 3 est impair, donc on le multiplie par trois et on ajoute un : 3 x 3 + 1 = 10

- 10 est pair, donc on le divise par deux : 10 / 2 = 5

- 5 est impair, donc on le multiplie par trois et on ajoute un : 5 x 3 + 1 = 16

- 16 est pair, donc on le divise par deux : 16 / 2 = 8

- 8 est pair, donc on le divise par deux : 8 / 2 = 4

- 4 est pair, donc on le divise par deux : 4 / 2 = 2

- 2 est pair, donc on le divise par deux : 2 / 2 = **1**



On a obtenu **1** au bout de **8** étapes. On dit que le temps de vol de **6** est de **8**.



La conjecture de Collatz affirme que pour tout nombre entier positif,

il existe un temps de vol fini qui permet d'obtenir **1**.

Mais personne n'a réussi à le démontrer ni à le réfuter.



Trouvez-vous ce problème intéressant ?

Qu'en pensez-vous ?

[toumic2.0]

J'ai bien aimé le voyage mental parcouru lors de l'exercice

[tyrtamos]

Bonjour

Problème intéressant! Mais il vaudrait mieux parler de "vérification" plutôt que de "résolution" puisque cette conjecture n'a jamais été résolue.

Une page web pour la définition:
https://fr.wikipedia.org/wiki/Conjecture_de_Syracuse

Voilà un petit code pour cette vérification:

Code :

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

1
2
3
4
5
6
7
8
def syracuse(n):
    """ Calcule la conjecture de Syracuse pour n
    """
    suite, k = [n], n
    while k != 1:
        k = k//2 if k%2==0 else k*3+1
        suite.append(k)
    return suite

La vérification consiste à constater que la suite se termine toujours par "1", quelque soit n

Si on reprend l'exemple de wikipedia: n=15

Code :

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

1
2
3
4
n = 15
suite = syracuse(n)
print(n, suite)
15, [15, 46, 23, 70, 35, 106, 53, 160, 80, 40, 20, 10, 5, 16, 8, 4, 2, 1]

Curieusement, il y a un vocabulaire particulier à cette conjecture:

Code :

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

1
2
3
4
5
6
7
8
print("temps de vol:", len(suite)-1)
 
for i, x in enumerate(suite):
    if x<n:
        break
print("temps de vol en altitude:", i-1)
 
print("altitude maximale:", max(suite))

Ce qui affiche

Code :

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

1
2
3
temps de vol: 17
temps de vol en altitude: 10
altitude maximale: 160

Autre exemple cité par wikipedia:
n = 27. Résultat:

Code :

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

1
2
3
4
27 [27, 82, 41, 124, 62, 31, 94, 47, 142, 71, 214, 107, 322, 161, 484, 242, 121, 364, 182, 91, 274, 137, 412, 206, 103, 310, 155, 466, 233, 700, 350, 175, 526, 263, 790, 395, 1186, 593, 1780, 890, 445, 1336, 668, 334, 167, 502, 251, 754, 377, 1132, 566, 283, 850, 425, 1276, 638, 319, 958, 479, 1438, 719, 2158, 1079, 3238, 1619, 4858, 2429, 7288, 3644, 1822, 911, 2734, 1367, 4102, 2051, 6154, 3077, 9232, 4616, 2308, 1154, 577, 1732, 866, 433, 1300, 650, 325, 976, 488, 244, 122, 61, 184, 92, 46, 23, 70, 35, 106, 53, 160, 80, 40, 20, 10, 5, 16, 8, 4, 2, 1]
temps de vol: 111
temps de vol en altitude: 95
altitude maximale: 9232

Il faudrait faire ce calcul pour des millions de valeurs n pour vérifier que la suite se termine toujours avec une valeur "1", et jusqu'à présent, personne n'a trouvé le contraire. Mais cette conjecture n'aura pas été pour autant résolue mathématiquement.

[toumic2.0]

Le sujet est intéressant, et en dernière analyse pour qu'on puisse comprendre sa mécanique.

Tout tourne autour de la parité du nombre et de son utilité algorithmique :

Impair § pair ... a/2 § a*3+1

Comprendre la mécanisation par son sens logique évident.
Au total de deux entrées(pair,impair), deux opérations(/2,*3+1) et deux sorties(pair,impair).

Les flux générés pairs/impairs sont méthodiquement transformés en pairs/impairs sortants, ce processus pratiqué sur un nombre exemplaire. En stimulant chaque particule algo(a/2), algo(a*3+1), pour ce faire il nous faut un petit code Python☺

Code :

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

1
2
3
4
5
6
7
8
9
# Que fait une série de nombres pairs divisés par deux ? Multipliés par trois, puis ajouter un ?
print(' Quand b%2 = 0 = a/2 = Nombre pair.\n Si, b%2 = 1 = a/2 = Nombre impair. ☺')
for a in range(0, 33, 2):
    b = a / 2
    c = a * 3 + 1
    print('PAIRE.a:', a, '\t b = a/2=', b, ' b%2:', b%2, '\t c = a*3+1=', c, 'c%2=', c%2, '\tfin impaire.')
    ()
# Ici, la partie décimale est entière.
# PAIRES =a/2[PERMUTE(±)] et a*3+1[IMPAIR] || Départ pair phase[a*3+1].impair()|

Justement pour voir comment réagissent les algos et quelles sont leurs transformées ?
Puis un dernier pour le code, juste histoire d'avoir l'air d'avoir tout lu ☺

Code :

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

1
2
3
4
5
6
7
8
# Que fait une série de nombres impairs divisés par deux ? Multipliés par trois, plus un ?
for a in range(1, 33, 2):
    b = a / 2
    c = a * 3 + 1
    print('IMPAIRE.a:', a, '\t b = a/2=', b, ' b%2:', b%2, '\t c = a*3+1=', c, 'c%2=', c%2, '\tfin paire.')
    ()
# Ici, la partie entière est décimale.
# IMPAIRES =a/2[PERMUTE(±)] et a*3+1[PAIR] || Départ impair phase[a*3+1].pair()|

En règle général (Python)

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
# Conjœncturæs ±(/2), ±(*3+1) ☺
 
# Que fait une série de nombres pairs divisés par deux ? Multipliés par trois, puis ajouter un ?
print(' Quand b%2 = 0 = a/2 = Nombre pair.\n Si, b%2 = 1 = a/2 = Nombre impair. ☺')
for a in range(0, 33, 2):
    b = a / 2
    c = a * 3 + 1
    print('PAIRE.a:', a, '\t b = a/2=', b, ' b%2:', b%2, '\t c = a*3+1=', c, 'c%2=', c%2, '\tfin impaire.')
    ()
# Ici, la partie décimale est entière.
# PAIRES =a/2[PERMUTE(±)] et a*3+1[IMPAIR] || Départ pair phase[a*3+1].impair()|
""" Quand b%2 = 0 = a/2 = Nombre pair.
 Si, b%2 = 1 = a/2 = Nombre impair. ☺
PAIRE.a: 0      b = a/2= 0.0  b%2: 0.0      c = a*3+1= 1 c%2= 1     fin impaire.
PAIRE.a: 2      b = a/2= 1.0  b%2: 1.0      c = a*3+1= 7 c%2= 1     fin impaire.
PAIRE.a: 4      b = a/2= 2.0  b%2: 0.0      c = a*3+1= 13 c%2= 1     fin impaire.
PAIRE.a: 6      b = a/2= 3.0  b%2: 1.0      c = a*3+1= 19 c%2= 1     fin impaire.
PAIRE.a: 8      b = a/2= 4.0  b%2: 0.0      c = a*3+1= 25 c%2= 1     fin impaire.
PAIRE.a: 10      b = a/2= 5.0  b%2: 1.0      c = a*3+1= 31 c%2= 1     fin impaire.
PAIRE.a: 12      b = a/2= 6.0  b%2: 0.0      c = a*3+1= 37 c%2= 1     fin impaire.
PAIRE.a: 14      b = a/2= 7.0  b%2: 1.0      c = a*3+1= 43 c%2= 1     fin impaire.
PAIRE.a: 16      b = a/2= 8.0  b%2: 0.0      c = a*3+1= 49 c%2= 1     fin impaire.
PAIRE.a: 18      b = a/2= 9.0  b%2: 1.0      c = a*3+1= 55 c%2= 1     fin impaire.
PAIRE.a: 20      b = a/2= 10.0  b%2: 0.0      c = a*3+1= 61 c%2= 1     fin impaire.
PAIRE.a: 22      b = a/2= 11.0  b%2: 1.0      c = a*3+1= 67 c%2= 1     fin impaire.
PAIRE.a: 24      b = a/2= 12.0  b%2: 0.0      c = a*3+1= 73 c%2= 1     fin impaire.
PAIRE.a: 26      b = a/2= 13.0  b%2: 1.0      c = a*3+1= 79 c%2= 1     fin impaire.
PAIRE.a: 28      b = a/2= 14.0  b%2: 0.0      c = a*3+1= 85 c%2= 1     fin impaire.
PAIRE.a: 30      b = a/2= 15.0  b%2: 1.0      c = a*3+1= 91 c%2= 1     fin impaire.
PAIRE.a: 32      b = a/2= 16.0  b%2: 0.0      c = a*3+1= 97 c%2= 1     fin impaire."""
print()
# Que fait une série de nombres impairs divisés par deux ? Multipliés par trois, plus un ?
for a in range(1, 33, 2):
    b = a / 2
    c = a * 3 + 1
    print('IMPAIRE.a:', a, '\t b = a/2=', b, ' b%2:', b%2, '\t c = a*3+1=', c, 'c%2=', c%2, '\tfin paire.')
    ()
# Ici, la partie entière est décimale.
# IMPAIRES =a/2[PERMUTE(±)] et a*3+1[PAIR] || Départ impair phase[a*3+1].pair()|
""" Quand b%2 = 0 = a/2 = Nombre pair.
 Si, b%2 = 1 = a/2 = Nombre impair. ☺
IMPAIRE.a: 1      b = a/2= 0.5  b%2: 0.5      c = a*3+1= 4 c%2= 0     fin paire.
IMPAIRE.a: 3      b = a/2= 1.5  b%2: 1.5      c = a*3+1= 10 c%2= 0     fin paire.
IMPAIRE.a: 5      b = a/2= 2.5  b%2: 0.5      c = a*3+1= 16 c%2= 0     fin paire.
IMPAIRE.a: 7      b = a/2= 3.5  b%2: 1.5      c = a*3+1= 22 c%2= 0     fin paire.
IMPAIRE.a: 9      b = a/2= 4.5  b%2: 0.5      c = a*3+1= 28 c%2= 0     fin paire.
IMPAIRE.a: 11      b = a/2= 5.5  b%2: 1.5      c = a*3+1= 34 c%2= 0     fin paire.
IMPAIRE.a: 13      b = a/2= 6.5  b%2: 0.5      c = a*3+1= 40 c%2= 0     fin paire.
IMPAIRE.a: 15      b = a/2= 7.5  b%2: 1.5      c = a*3+1= 46 c%2= 0     fin paire.
IMPAIRE.a: 17      b = a/2= 8.5  b%2: 0.5      c = a*3+1= 52 c%2= 0     fin paire.
IMPAIRE.a: 19      b = a/2= 9.5  b%2: 1.5      c = a*3+1= 58 c%2= 0     fin paire.
IMPAIRE.a: 21      b = a/2= 10.5  b%2: 0.5      c = a*3+1= 64 c%2= 0     fin paire.
IMPAIRE.a: 23      b = a/2= 11.5  b%2: 1.5      c = a*3+1= 70 c%2= 0     fin paire.
IMPAIRE.a: 25      b = a/2= 12.5  b%2: 0.5      c = a*3+1= 76 c%2= 0     fin paire.
IMPAIRE.a: 27      b = a/2= 13.5  b%2: 1.5      c = a*3+1= 82 c%2= 0     fin paire.
IMPAIRE.a: 29      b = a/2= 14.5  b%2: 0.5      c = a*3+1= 88 c%2= 0     fin paire.
IMPAIRE.a: 31      b = a/2= 15.5  b%2: 1.5      c = a*3+1= 94 c%2= 0     fin paire."""

[toumic2.0]

Un peu comme, si on essayait de comprendre le fonctionnement en transformant les algos par des simples objets répondants aux mouvements.
Comme si le fait de diviser les nombres pairs une fois sur deux, comme si les nombres impairs étaient tous transformés en nombres pairs avec une multiplication par trois.

Un nombre exemplaire a une hauteur descendante en deux rangs, ralenti avec une faible remontée par trois à juste un rang de hauteur au-dessus du nombre exemplaire.
Tous les nombres sont ramenés aux nombres pairs qui divise par deux, en descendant la hauteur de deux rangs progressivement.
Ces nombres pairs peuvent correspondre à un nombre inclus dans une liste spéciale.

Code :

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

1
2
3
4
5
6
7
8
9
 
    # Création des multiples de deux
    "Cette série peut ou non chronique au nombre saisi par l'utilisateur"
    tab_deux, pro_deux = [], 2
    for d in range(2, 30, 2):
        pro_deux *= 2
        # div_deux = d // 2
        tab_deux.append(pro_deux)
    ('Table des multiples de deux =\n', tab_deux)

Il est évident qu'une fois le nombre dans cette liste(tab_deux), ce dernier sera divisé par deux jusqu'à obtenir 1.

.../...

Puis finalement même si je n'arrive pas à l'expliquer, il y a une part de découverte dans l'analyse de ce problème ♥.

[toumic2.0]

[toumic2.0]

Code :

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

1
2
3
4
5
6
7
"""Il ne reste plus qu'à expliquer pourquoi les crans descendants seront toujours en quantité supérieure."""
# La logique de cette application est par rapport à un nombre, auquel un algorithme de deux traitements
# 'n/2, n*3+1'. Ces deux équations conditionnées dévaluent le nombre original jusqu'à un.
# À savoir que la série des nombres entiers répliquent une cadence pair et impair, selon l'origine.
# Ainsi, qu'en divisant un nombre pair par deux, on a une fois sur deux un nombre impair.
# Tel qu'une fois sur deux on descend de deux crans, soit quatre crans un fois sur deux.
# Inversement en cas d'imparité, on remonte de trois crans sans au-delà de quatre du coup (au cas-par-cas).

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
 
'# Exemple logistique ☺'
nombre_original = 0
while 1:
    # Entrée utilisateur ☺
    nombre = int(input('Entrez un nombre entier supérieur à 1 : '))
    nombre_original = nombre
    break
'# Ici, commence (le jeu[n/2, n*3+1])'
quant_pairs = quant_impairs = 0
liste_pairs, liste_impairs = [], []
while nombre != 1:
    ('***   ***   ***   Nombre = ', nombre)
    if nombre%2 == 0:
        liste_pairs.append(int(nombre))
        ind = nombre
        nombre = int(nombre / 2)
        quant_pairs += 1
        if int(nombre / 2)%2 == 0:
            (ind, nombre, '\tp     Nombre issu (n/2) devient pair après (n/2) suivant ', int(nombre/2), 'pair-pair')
        elif int(nombre / 2)%2 != 0:
            (ind, nombre, '\tp     Nombre issu (n/2) devient impair après (n/2) suivant ', int(nombre/2), 'pair-impair')
    else:
        liste_impairs.append(int(nombre))
        ind = nombre
        nombre = nombre * 3 + 1
        quant_impairs += 1
        if int(nombre / 2)%2 != 0:
            (ind, '\tii Nombre issu (n*3+1) devient impair après (n/2) suivant ', int(nombre/2), 'impair-impair')
        elif int(nombre / 2)%2 == 0:
            (ind, '\tip Nombre issu (n*3+1) devient pair après (n/2) suivant ', int(nombre/2), 'impair-pair')
print('Liste pairs =', liste_pairs, '\nListe impairs =', liste_impairs)
#
print("*\nNombre d'origine = ", nombre_original)
print('Résultat de la liste des nombres pairs = ', quant_pairs)
print('Résultat de la liste des nombres impairs = ', quant_impairs)
'# Opérations basiques sur les listes et leurs déplacements cumulatifs.'
mouvements_pairs = quant_pairs * -2  # Descend de deux crans à chaque fois.
mouvements_impairs = quant_impairs * 3  # Monte de 3 crans à chaque fois.
# Additionner les mouvements (±) somme une différence interne.
position_cran = mouvements_pairs + mouvements_impairs
if position_cran < 0:
    print("Les déplacements positifs n'ont pas rattrapés les déplacements négatifs = Négatifs gagnants ☺")
else:
    print("Les déplacements positifs ont rattrapés les déplacements négatifs = Positifs gagnants ☺")
#
print('Mouvements pairs = ', mouvements_pairs, '\tmouvements_impairs = ', mouvements_impairs)
print('Et le résultat = ', position_cran)
"""Il ne reste plus qu'à expliquer pourquoi les crans descendants seront toujours en quantité supérieure."""
# La logique de cette application est par rapport à un nombre, auquel un algorithme de deux traitements
# 'n/2, n*3+1'. Ces deux équations conditionnées dévaluent le nombre original jusqu'à un.
# À savoir que la série des nombres entiers répliquent une cadence pair et impair, selon l'origine.
# Ainsi, qu'en divisant un nombre pair par deux, on a une fois sur deux un nombre impair.
# Tel qu'une fois sur deux on descend de deux crans, soit quatre crans un fois sur deux.
# Inversement en cas d'imparité, on remonte de trois crans sans au-delà de quatre du coup (au cas-par-cas).
 
 
'''
Nombre d'origine =  9
Résultat de la liste des nombres pairs =  13
Résultat de la liste des nombres impairs =  6'''
# a13 == Le nombre de fois qu'un nombre pair est traité.
# b6 == Le nombre de fois qu'un nombre impair est traité.
'''
>>> a13 = 13
>>> b6 = 6
>>> a13*-2  § Les fois que a13 descend de deux crans.
-26
>>> b6*3    § Les fois que b6 monte de trois crans.
18'''
# 
'''
>>> aa = a13*-2  # Les fois que a13 descend de deux crans.
>>> bb = b6*3 =  # Les fois que b6 monte de trois crans.
>>> aa-bb  # ...
-44
>>> bb-aa  # ...
44
>>> aa  # Contrôle aa
-26
>>> bb  # Contrôle bb
18
>>> aa+bb  # Négatif plus Positif
-8
>>> bb+aa  # Positif plus Négatif
-8
'''
# Si le résultat de aa+bb est négatif, c'est que les déplacements positifs sont inférieurs.

Entrez un nombre entier supérieur à 1 : 25
Liste pairs = [76, 38, 58, 88, 44, 22, 34, 52, 26, 40, 20, 10, 16, 8, 4, 2]
Liste impairs = [25, 19, 29, 11, 17, 13, 5]
*
Nombre d'origine = 25
Résultat de la liste des nombres pairs = 16
Résultat de la liste des nombres impairs = 7
Les déplacements positifs n'ont pas rattrapés les déplacements négatifs = Négatifs gagnants ☺
Mouvements pairs = -32 mouvements_impairs = 21
Et le résultat = -11

Avec le plaisir de créer ma première matrice, qui j'espère visible ♥

[toumic2.0]

Code :

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

1
2
3
"""Il ne reste plus qu'à expliquer pourquoi les crans descendants seront toujours en quantité supérieure."""
 
# Si le résultat de aa+bb est négatif, c'est que les déplacements positifs sont inférieurs.

Ce code ci-dessous utilise des boucles, il montre le pourquoi de mes dires.

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
 
# Conjœncturæs ±(/2), ±(*3+1) ☺
 
 
# Que fait une série de nombres pairs divisés par deux ? Multipliés par trois, puis ajouter un ?
print(' Quand b%2 = 0 = a/2 = Nombre pair.\n Si, b%2 = 1 = a/2 = Nombre impair. ☺')
for a in range(0, 33, 2):
    b = a / 2
    c = a * 3 + 1
    ('PAIRE.a:', a, '\t b = a/2=', b, ' b%2:', b%2, '\t c = a*3+1=', c, 'c%2=', c%2, '\tfin impaire.')
    ()
# Ici, la partie décimale est entière.
# PAIRES =a/2[PERMUTE(±)] et a*3+1[IMPAIR] || Départ pair phase[a*3+1].impair()|
""" Quand b%2 = 0 = a/2 = Nombre pair.
 Si, b%2 = 1 = a/2 = Nombre impair. ☺
PAIRE.a: 0      b = a/2= 0.0  b%2: 0.0      c = a*3+1= 1 c%2= 1     fin impaire.
PAIRE.a: 2      b = a/2= 1.0  b%2: 1.0      c = a*3+1= 7 c%2= 1     fin impaire.
PAIRE.a: 4      b = a/2= 2.0  b%2: 0.0      c = a*3+1= 13 c%2= 1     fin impaire.
PAIRE.a: 6      b = a/2= 3.0  b%2: 1.0      c = a*3+1= 19 c%2= 1     fin impaire.
PAIRE.a: 8      b = a/2= 4.0  b%2: 0.0      c = a*3+1= 25 c%2= 1     fin impaire.
PAIRE.a: 10      b = a/2= 5.0  b%2: 1.0      c = a*3+1= 31 c%2= 1     fin impaire.
PAIRE.a: 12      b = a/2= 6.0  b%2: 0.0      c = a*3+1= 37 c%2= 1     fin impaire.
PAIRE.a: 14      b = a/2= 7.0  b%2: 1.0      c = a*3+1= 43 c%2= 1     fin impaire.
PAIRE.a: 16      b = a/2= 8.0  b%2: 0.0      c = a*3+1= 49 c%2= 1     fin impaire.
PAIRE.a: 18      b = a/2= 9.0  b%2: 1.0      c = a*3+1= 55 c%2= 1     fin impaire.
PAIRE.a: 20      b = a/2= 10.0  b%2: 0.0      c = a*3+1= 61 c%2= 1     fin impaire.
PAIRE.a: 22      b = a/2= 11.0  b%2: 1.0      c = a*3+1= 67 c%2= 1     fin impaire.
PAIRE.a: 24      b = a/2= 12.0  b%2: 0.0      c = a*3+1= 73 c%2= 1     fin impaire.
PAIRE.a: 26      b = a/2= 13.0  b%2: 1.0      c = a*3+1= 79 c%2= 1     fin impaire.
PAIRE.a: 28      b = a/2= 14.0  b%2: 0.0      c = a*3+1= 85 c%2= 1     fin impaire.
PAIRE.a: 30      b = a/2= 15.0  b%2: 1.0      c = a*3+1= 91 c%2= 1     fin impaire.
PAIRE.a: 32      b = a/2= 16.0  b%2: 0.0      c = a*3+1= 97 c%2= 1     fin impaire."""
print()
# Que fait une série de nombres impairs divisés par deux ? Multipliés par trois, plus un ?
for a in range(1, 33, 2):
    b = a / 2
    c = a * 3 + 1
    ('IMPAIRE.a:', a, '\t b = a/2=', b, ' b%2:', b%2, '\t c = a*3+1=', c, 'c%2=', c%2, '\tfin paire.')
    ()
# Ici, la partie entière est décimale.
# IMPAIRES =a/2[PERMUTE(±)] et a*3+1[PAIR] || Départ impair phase[a*3+1].pair()|
""" Quand b%2 = 0 = a/2 = Nombre pair.
 Si, b%2 = 1 = a/2 = Nombre impair. ☺
IMPAIRE.a: 1      b = a/2= 0.5  b%2: 0.5      c = a*3+1= 4 c%2= 0     fin paire.
IMPAIRE.a: 3      b = a/2= 1.5  b%2: 1.5      c = a*3+1= 10 c%2= 0     fin paire.
IMPAIRE.a: 5      b = a/2= 2.5  b%2: 0.5      c = a*3+1= 16 c%2= 0     fin paire.
IMPAIRE.a: 7      b = a/2= 3.5  b%2: 1.5      c = a*3+1= 22 c%2= 0     fin paire.
IMPAIRE.a: 9      b = a/2= 4.5  b%2: 0.5      c = a*3+1= 28 c%2= 0     fin paire.
IMPAIRE.a: 11      b = a/2= 5.5  b%2: 1.5      c = a*3+1= 34 c%2= 0     fin paire.
IMPAIRE.a: 13      b = a/2= 6.5  b%2: 0.5      c = a*3+1= 40 c%2= 0     fin paire.
IMPAIRE.a: 15      b = a/2= 7.5  b%2: 1.5      c = a*3+1= 46 c%2= 0     fin paire.
IMPAIRE.a: 17      b = a/2= 8.5  b%2: 0.5      c = a*3+1= 52 c%2= 0     fin paire.
IMPAIRE.a: 19      b = a/2= 9.5  b%2: 1.5      c = a*3+1= 58 c%2= 0     fin paire.
IMPAIRE.a: 21      b = a/2= 10.5  b%2: 0.5      c = a*3+1= 64 c%2= 0     fin paire.
IMPAIRE.a: 23      b = a/2= 11.5  b%2: 1.5      c = a*3+1= 70 c%2= 0     fin paire.
IMPAIRE.a: 25      b = a/2= 12.5  b%2: 0.5      c = a*3+1= 76 c%2= 0     fin paire.
IMPAIRE.a: 27      b = a/2= 13.5  b%2: 1.5      c = a*3+1= 82 c%2= 0     fin paire.
IMPAIRE.a: 29      b = a/2= 14.5  b%2: 0.5      c = a*3+1= 88 c%2= 0     fin paire.
IMPAIRE.a: 31      b = a/2= 15.5  b%2: 1.5      c = a*3+1= 94 c%2= 0     fin paire."""
print()
# Les nombres pairs à divisions(/2) successives.
dic_suc = {}
for i in range(66, 1, -1):
    k, m = 0, i
    j = m / 2
    while j % 2 == 0:
        j = m / 2
        k += 1
        m -= 1
        if k > 0 and j % 2 == 0:
            dic_suc[i] = j
            print('i:', i, 'j:', j, 'k:', k)
for i in dic_suc.keys():
    ('i:', i, 'dic_suc:', dic_suc[i])
    pass
print(dic_suc.keys())
# Il y a des nombres pairs qui une fois divisés par deux, produisent un quotient pair.
 
 
'''
Nombre entier de référence
Pair descend deux_. Une fois sur deux quand il est pair (n/2=pair)
Impair remonte trois_.'''
#
nombre_entier, un = 235, 0
nombre_parity = True  # True=pair. False=impair
while nombre_entier < 1197:
    if nombre_parity:
        nombre_entier = int(nombre_entier / 2)
        un -= 2
        if nombre_parity:
            nombre_parity = False
    else:
        nombre_entier = int(nombre_entier * 3 + 1)
        un += 3
        nombre_parity = True
    print('nombre_entier', nombre_entier)
# pied

Selon les nombres on retrouve les mêmes résultats finalement...

[toumic2.0]

Bonjour

Problème intéressant! Mais il vaudrait mieux parler de "vérification" plutôt que de "résolution" puisque cette conjecture n'a jamais été résolue.

Il faudrait faire ce calcul pour des millions de valeurs n pour vérifier que la suite se termine toujours avec une valeur "1", et jusqu'à présent, personne n'a trouvé le contraire. Mais cette conjecture n'aura pas été pour autant résolue mathématiquement.

Moi je parle de résolution.

Pour un nombre pair qui descend de quatre une fois sur deux.
Et,, d'un nombre impair qui ramène à pair systématiquement.

Ce déroulement se réalise à chaque boucle : Pair descend de quatre et Impair monte de trois. (Une fois sur deux)

Le phénomème descend plus qu'il ne grimpe, la preuve est là !

[tyrtamos]

Bonjour

Moi je parle de résolution

Ce problème n'a jamais été résolu mathématiquement et c'est pour ça qu'on l'appelle "conjecture".

[wiztricks]

Moi je parle de résolution.[/COLOR]

Votre approche est mentionnée dans l comme approche probabiliste.
Mais une approche probabiliste (çà marche dans N % des cas) n'exclut pas l'existence d'entiers pour lesquels ça ne marche pas i.e. ce n'est pas une démonstration/résolution.

- W

[toumic2.0]

Mon approche est bien détaillée et en aucun cas ne peut être contredite.

Les nombres pairs consécutifs quand ils sont divisés par deux entrainent dans tous les cas un coup sur deux un nombre impair, (l'autre c'est qu'il est un nombre pair.

Vous ne pouvez donc pas me contredire sans aucun exemple, ainsi vos réponses sont explicitement inappropriées et complètement négativistes, c'est votre droit.

Vous ne pouvez donc pas dire que je n'ai pas raison, ni que j'ai raison. Vos réponses ressemblent à des 49.3 ☺

[wiztricks]

Mon approche est bien détaillée et en aucun cas ne peut être contredite.

Vous ne comprenez pas le sens de ce qu'on vous dit.
Maintenant faire valider votre truc par l'académie des sciences ou faire ajouter dans l'article de wikipédia que toumic a démontré cela en Mai 2023 voilà ce qui pourrait "contredire".

- W

[tyrtamos]

Bonjour

+1 pour wiztricks

Je n'ai pas critiqué autre chose que l'utilisation du mot "résolution", et c'est votre persistance à l'utiliser qui est inappropriée.

Chez vous, vous pouvez inventer ce que vous voulez. Mais, pour prendre un exemple, si vous pensez que pour vous 2+2=5, le fait de le déclarer en public ne vous permettra pas d'échapper aux contradicteurs, et c'est très bien ainsi. Surtout dans un forum où ceux qui ont besoin d'aide sont censés ne trouver que des informations correctes.

[VinsS]

Salut,

Si je comprends bien il faut donc démontrer que l'on arrive toujours a X tel que X * 3 + 1 = une puissance de 2.

Mais peu importe, ce qui m'intéressait ici c'était de voir si on pouvait constater une différence notable de temps d'exécution en utilisant des opérations dites "atomiques".

Et c'est le cas, et pas un peu, le gain est énorme.

Avec ce 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
 
import time
 
def long_func():
    start = time.perf_counter()
    for i in range(2, 1000001):
        while 1:
            if i == 1:
                break
            if i % 2:
                i = i * 3 + 1
            else:
                i /= 2
    end = time.perf_counter()
    print("long_func done at: %s sec." %(end-start))
 
def short_func():
    start = time.perf_counter()
    for i in range(2, 1000001):
        while 1:
            if i == 1:
                break
            if i & 1:
                i = i * 3 + 1
            else:
                i >>= 1
    end = time.perf_counter()
    print("short_func done at: %s sec." %(end-start))
 
long_func()
short_func()

long_func done at: 16.280122615004075 sec.
short_func done at: 8.104949430993292481 sec.

CQFD

[toumic2.0]

Salut,

Si je comprends bien il faut donc démontrer que l'on arrive toujours a X tel que X * 3 + 1 = une puissance de 2.

Mais peu importe, ce qui m'intéressait ici c'était de voir si on pouvait constater une différence notable de temps d'exécution en utilisant des opérations dites "atomiques".

Et c'est le cas, et pas un peu, le gain est énorme.

Avec ce code:

Code :

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

1
2
 
# .../... ☺

CQFD

Joli, je sais que ce type de réponse envolerait n'importe qui, moi inclus.

Ce qui est vrai c'est que le sujet est quelque chose qu'on connait (n/2), (n*3+1).

Sauf que le fait est que cette conjecture a reçu un certain focus, par une simple vraie idée lumineuse ne faisant pas avancer le chariot pour les mules. Ce qui est ajouté c'est la présence d'un outil informatique en version code Python, il représente les traitements utiles qui calculent la conjecture. Cette dernière s'avère être une logique mathématique réelle, qui de nos jours n'a pas d'explication autre que :

{(Npair/2), (Nimpair*3+1)}. Pourquoi ça mène à 1 ?

Chercher à comprendre, c'est étendre les racines du savoir afin d'entrevoir une tolérance avec la question...

Vous envisagez l'allumage des esprits tolérés par la conjecture, les messages précédents sont des éléments tolérés car ils ne sont pas prenants "non intrusif". Seulement décoratifs, comme si le code faisait des adaptations éclairantes. Soyez certain que l'inconnu intelligent n'est pas pressé ni compétitif, mais uniquement plus curieux communicant.

Réponse à froid

[toumic2.0]

Salut,

Si je comprends bien il faut donc démontrer que l'on arrive toujours a X tel que X * 3 + 1 = une puissance de 2.

Mais peu importe, ce qui m'intéressait ici c'était de voir si on pouvait constater une différence notable de temps d'exécution en utilisant des opérations dites "atomiques".

Et c'est le cas, et pas un peu, le gain est énorme.

Avec ce 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
 
import time
 
def long_func():
    start = time.perf_counter()
    for i in range(2, 1000001):
        while 1:
            if i == 1:
                break
            if i % 2:
                i = i * 3 + 1
            else:
                i /= 2
    end = time.perf_counter()
    print("long_func done at: %s sec." %(end-start))
 
def short_func():
    start = time.perf_counter()
    for i in range(2, 1000001):
        while 1:
            if i == 1:
                break
            if i & 1:
                i = i * 3 + 1
            else:
                i >>= 1
    end = time.perf_counter()
    print("short_func done at: %s sec." %(end-start))
 
long_func()
short_func()

CQFD

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
 
import time
 
 
hyper_max = 1000001
def long_func():
    start = time.perf_counter()
    for i in range(2, hyper_max):
        while 1:
            if i == 1:
                break
            if i % 2:
                i = i * 3 + 1
            else:
                i /= 2
    end = time.perf_counter()
    print("long_func done at: %s sec." %(end-start))
 
def short_func():
    start = time.perf_counter()
    for i in range(2, hyper_max):
        while 1:
            if i == 1:
                break
            if i & 1:
                i = i * 3 + 1
            else:
                i >>= 1
    end = time.perf_counter()
    print("short_func done at: %s sec." %(end-start))
 
 
def slowh_func():
    start = time.perf_counter()
    n=hyper_max
    while n > 1:  # n réduction.
        if not (n%6)%2:
            n //= 2
        else:
            n = n*3+1
    end = time.perf_counter()
    print("slowh_func done at: %s sec." %(end-start))
 
 
long_func()
short_func()
slowh_func()

[VinsS]

Hum, ta fonction est inexacte (chatGPT ?)

Elle ne vérifie pas tous les nombres, en fait elle est même chaotique.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
def slowh_func():
    start = time.perf_counter()
    n = 100001
    while n > 1:  # n réduction.
        print(n)
        if not (n%6)%2:
            n //= 2
        else:
            n = n*3+1
    end = time.perf_counter()
    print("slowh_func done at: %s sec." %(end-start))

100001
300004
150002
75001
225004
112502
56251
168754
84377
253132
126566
63283
189850
94925
284776
142388
71194
35597
106792
.......

[toumic2.0]

Hum, ta fonction est inexacte (chatGPT ?)

Elle ne vérifie pas tous les nombres, en fait elle est même chaotique.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
def slowh_func():
    start = time.perf_counter()
    n = 100001
    while n > 1:  # n réduction.
        print(n)
        if not (n%6)%2:
            n //= 2
        else:
            n = n*3+1
    end = time.perf_counter()
    print("slowh_func done at: %s sec." %(end-start))

Inexacte pour toi mais pas pour moi ☺
Je suis resté dans le même principe d'exécution que l'original qui consiste à dévaluer jusqu'à 1.
Elle est chaotique à cause de l'alternative pair-impair rencontrée avec les nombres.
Au sujet de chatGPT, je dirais plutôt Bing IA. Mais pour ce coup, il y a une intelligence réelle.

Pour hyper_max = hyper_max = 1000001

Code :

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

1
2
3
4
5
6
7
8
9
10
 
def rap_func():
    start = time.perf_counter()
    for n in range (2, hyper_max):  # n addiction.
        if n%2:
            n = n*3+1
        else:
            n //= 2
    end = time.perf_counter()
    print("rap_func done at: %s sec." %(end-start))

Code :

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

1
2
3
4
5
 
long_func done at: 15.356375899999875 sec.
short_func done at: 7.621013599999969 sec.
slowh_func done at: 1.250000013897079e-05 sec.
rap_func done at: 0.07152290000021821 sec.

[toumic2.0]

Il y a une phrase que j'ai dû dire qui n'est pas vraie :

En divisant par deux on abouti à une alternative (nombre pair/nombre impair).

Voici pourquoi :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
# Démultiplication(/2) ☺
# Version 2
en_cas = []
for i in range(300, 1, -1):
    while i%2 == 0:
        en_cas.append(i)
        i //= 2
    if len(en_cas) > 2:
        print('Liste en_cas', en_cas)
    en_cas.clear()

Cette liste a récupéré les séries continues d'aboutissantes à un nombre pair, ce qui ne change rien à mes propos puisque ça va vers le 1.

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
 
Liste en_cas [296, 148, 74]
Liste en_cas [288, 144, 72, 36, 18]
Liste en_cas [280, 140, 70]
Liste en_cas [272, 136, 68, 34]
Liste en_cas [264, 132, 66]
Liste en_cas [256, 128, 64, 32, 16, 8, 4, 2]
Liste en_cas [248, 124, 62]
Liste en_cas [240, 120, 60, 30]
Liste en_cas [232, 116, 58]
Liste en_cas [224, 112, 56, 28, 14]
Liste en_cas [216, 108, 54]
Liste en_cas [208, 104, 52, 26]
Liste en_cas [200, 100, 50]
Liste en_cas [192, 96, 48, 24, 12, 6]
Liste en_cas [184, 92, 46]
Liste en_cas [176, 88, 44, 22]
Liste en_cas [168, 84, 42]
Liste en_cas [160, 80, 40, 20, 10]
Liste en_cas [152, 76, 38]
Liste en_cas [144, 72, 36, 18]
Liste en_cas [136, 68, 34]
Liste en_cas [128, 64, 32, 16, 8, 4, 2]
Liste en_cas [120, 60, 30]
Liste en_cas [112, 56, 28, 14]
Liste en_cas [104, 52, 26]
Liste en_cas [96, 48, 24, 12, 6]
Liste en_cas [88, 44, 22]
Liste en_cas [80, 40, 20, 10]
Liste en_cas [72, 36, 18]
Liste en_cas [64, 32, 16, 8, 4, 2]
Liste en_cas [56, 28, 14]
Liste en_cas [48, 24, 12, 6]
Liste en_cas [40, 20, 10]
Liste en_cas [32, 16, 8, 4, 2]
Liste en_cas [24, 12, 6]
Liste en_cas [16, 8, 4, 2]
Liste en_cas [8, 4, 2]