Forum de mathématiques - Bibm@th.net
Vous n'êtes pas identifié(e).
- Contributions : Récentes | Sans réponse
#101 Re : Café mathématique » des cubes et des puissances supérieures » 18-08-2025 09:15:01
Bonjour jelobreuil,
Je pense que les solutions sont innombrables.
Au début, j’ai cherché sur une plage donnée, par exemple de -10 à 10 zéro exclu, j’ai trouvé vingt solutions. Comme elles sont symétriques autour de zéro (suffit de changer les signes) voici celles où d>0.
(-6)³ + (-8)³ + (+9)³ = (+1)³
(-4)³ + (-5)³ + (+6)³ = (+3)³
(-3)³ + (-5)³ + (+6)³ = (+4)³
(-3)³ + (-4)³ + (+6)³ = (+5)³
(-1)³ + (-8)³ + (+9)³ = (+6)³
(+3)³ + (+4)³ + (+5)³ = (+6)³
(-1)³ + (-6)³ + (+9)³ = (+8)³
(+1)³ + (+6)³ + (+8)³ = (+9)³
(-1)³ + (+9)³ + (+10)³ = (+12)³
(+6)³ + (+8)³ + (+10)³ = (+12)³
J’ai trouvé amusant les déclinaisons :
(-4)³ + (-5)³ + (+6)³ = (+3)³
(-3)³ + (-5)³ + (+6)³ = (+4)³
(-3)³ + (-4)³ + (+6)³ = (+5)³
(+3)³ + (+4)³ + (+5)³ = (+6)³
Puis je n’ai considéré que les a, b et c positifs, par exemple de 0 à 20 :
(+3)³ + (+4)³ + (+5)³ = (+6)³
(+1)³ + (+6)³ + (+8)³ = (+9)³
(+6)³ + (+8)³ + (+10)³ = (+12)³
(+2)³ + (+12)³ + (+16)³ = (+18)³
(+9)³ + (+12)³ + (+15)³ = (+18)³
(+3)³ + (+10)³ + (+18)³ = (+19)³
(+7)³ + (+14)³ + (+17)³ = (+20)³
(+12)³ + (+16)³ + (+20)³ = (+24)³
Je me suis aperçu qu’il y avait pas mal de multiples. Je me suis donc attaché uniquement aux triplets fondamentaux :
(+3)³ + (+4)³ + (+5)³ = (+6)³
(+1)³ + (+6)³ + (+8)³ = (+9)³
(+3)³ + (+10)³ + (+18)³ = (+19)³
(+7)³ + (+14)³ + (+17)³ = (+20)³
Une fois que j’en étais là, je me suis amusé à chercher s’il y avait des sommes de cubes avec a, b et c premiers. Rigolo, les premiers que j’ai trouvés sont consécutifs :
(+349)³ + (+379)³ + (+383)³ = (+535)³
Dans la foulée, je me suis demandé s’il existait des décompositions pour d premier, eh bien oui, surtout si on s’autorise les négatifs :
(+9)³ + (+15)³ + (-16)³ = (+2)³
(-4)³ + (-5)³ + (+6)³ = (+3)³
(-3)³ + (-4)³ + (+6)³ = (+5)³
(-14)³ + (-17)³ + (+20)³ = (+7)³
(-15)³ + (-27)³ + (+29)³ = (+11)³
(-51)³ + (-104)³ + (+108)³ = (+13)³
(-7)³ + (-14)³ + (+20)³ = (+17)³
(+3)³ + (+10)³ + (+18)³ = (+19)³
… etc.
J’ai même cherché a, b, c et d premiers, c’est dire :
(+193)³ + (+461)³ + (+631)³ = (+709)³
(+599)³ + (+691)³ + (+823)³ = (+1033)³
(+103)³ + (+2179)³ + (+2213)³ = (+2767)³
(+769)³ + (+1879)³ + (+2447)³ = (+2791)³
(+31)³ + (+1951)³ + (+2591)³ = (+2917)³
(+1399)³ + (+1667)³ + (+3541)³ = (+3727)³
(+11)³ + (+1783)³ + (+3631)³ = (+3769)³
… etc.
Pour explorer le truc de façon systématique, j’ai pondu une page qui permet de le faire (à condition de rester raisonnable bien sûr), vaut mieux commencer petit si on ne veut pas un temps de calcul rédhibitoire.
#102 Re : Programmation » Décomposition en facteurs premiers » 26-07-2025 14:37:21
Bonjour Rescassol,
En Python c'est nettement moins rigolo, il n'y a plus rien à faire : il existe des bibliothèques spécialisées très efficaces qu'il suffit de charger avec pip pour que le résultat soit excellent. Avec 'sympy' par exemple, 'factorint' enchaîne Miller-Rabin, force brute, Pollard-Rho et ECM sans rien demander à personne et à la vitesse max, c’est fou.
Pour dire, décomposer 466751831375951548784665726729 sur mon PC avec mon programme met environ 6 à 7 secondes en multi-threading alors qu’avec ce programme mono-thread en Python c’est dix fois plus rapide.
À noter qu’à cause des paramètres variables dans Pollard et ECM, les temps d’exécution peuvent eux aussi varier d’un facteur dix, aussi bien en JavaScript qu’en Python, normal.
import sys
import time
from sympy import isprime, factorint
def compact_factors(factor_dict):
parts = []
for base in sorted(factor_dict.keys()):
exp = factor_dict[base]
parts.append(f"{base}^{exp}" if exp > 1 else str(base))
return " × ".join(parts)
def main():
while True:
try:
input_str = input("\n> ").strip()
if input_str.lower() == 'q' or input_str == '':
print("Fin du programme.")
break
if not input_str.isdigit():
print("Erreur : veuillez entrer un entier positif composé uniquement de chiffres.")
continue
n = int(input_str)
if n <= 1:
print(f"Entrée triviale : {n}")
continue
print("Calcul en cours...")
start = time.time()
if isprime(n):
factors = {n: 1}
else:
factors = factorint(n)
end = time.time()
print(f"\nNombre initial :\n{n}")
print(f"\nDécomposition en facteurs premiers :\n{compact_factors(factors)}")
print(f"\nTemps écoulé : {round((end - start) * 1000, 3)} ms")
print(f"(Nombre de facteurs trouvés : {sum(factors.values())})")
except Exception as e:
print(f"Erreur pendant la factorisation : {str(e)}")
if __name__ == "__main__":
print("Entrez un entier (≥ 2) à factoriser. Tapez 'q' ou appuyez sur Entrée pour quitter.")
main()
#103 Re : Programmation » Décomposition en facteurs premiers » 26-07-2025 08:25:35
Bonjour,
Allez hop, code amélioré et finalisé en ligne, même URL.
Pour le test de Miller-Rabin, 64 bases sont utilisées, 32 bases fixes (les 32 premiers nombres premiers, de 2 à 131) et 32 bases aléatoires (intervalle 2, n−2). Chaque base de test réduit par au moins 75% la probabilité de faux positifs (c’est la propriété de Miller-Rabin). Ainsi, la probabilité de déclarer "premier" un nombre qui est en réalité composé est maintenant d'environ 5.4 × 10⁻³⁹. Autrement dit, le test satisfait largement les exigences des usages généraux de la cryptographie courante (RSA, Diffie-Hellman, etc.) et même des outils comme OpenSSL, GnuPG ou GMP (qui utilisent en général 25 à 64 tests).
Pollard Rho est également amélioré par la version Brent qui s’y prend autrement et mieux, ce qui en moyenne gagne ici un facteur deux.
Et enfin le calcul parallèle. Javascript permet d’implémenter des Web Workers capables de travailler indépendamment, ce qui tombe bien puisque chaque base fait une recherche autonome. On va donc lire le nombre de threads disponibles, on implémente autant de blocs qui calculeront en parallèle, et en gros pour des factorisations compliquées, sur mon PC je passe d’une quarantaine de secondes avec thread unique et Pollard simple à six secondes avec Pollard Rho Brent amélioré et web workers.
En dehors de la cryptographie qui cherche des décompositions compliquées, la plupart des nombres se décomposent maintenant super vite et super bien, et cela a été un vrai plaisir de bricoler ce genre de truc sans avoir à mettre trop les mains dans le cambouis.
#104 Programmation » Décomposition en facteurs premiers » 25-07-2025 15:54:16
- Ernst
- Réponses : 4
Bonjour,
Nous sommes ici dans la partie « programmation » dédiée aux algorithmes, aux programmes, au codage, bref au numérique dans tout ce qu’il peut avoir d’automatisé, je vais donc détailler ma démarche pour factoriser dans un temps raisonnable n’importe quel nombre même avec des dizaines de décimales.
Premier point, je vais faire le truc en html+javascript. Avantage, cela fonctionne avec un seul fichier texte capable d’être exécuté par n’importe quel navigateur. Inconvénient, je n’y connais rien ni en html (sauf que je sais qu’il y a une histoire de balises) ni en javascript (bourré d’instructions très spécifiques) ni en algorithmes de factorisation (à part la recherche brute qui consiste à diviser par 2, 3 et 6k±1 jusqu’à racine(N)).
Problème, la recherche brute jusqu’à $10^{15}$ ça va encore assez vite, mais au-delà ça devient carrément pas vite du tout. Si le nombre est composé ça passe, parce que dès qu’on a divisé on se retrouve avec des morceaux bien plus petits – donc ça va vite – mais avec un grand nombre qui est premier il faut épuiser toutes les divisions, pas top.
Je demande à l’IA s’il y a moyen d’accélérer le bousin. Il me parle d’algorithmes probabilistes, par exemple un certain Miller-Rabin (enchanté) qui permet de savoir rapidement si un nombre est premier ou non, avec une bonne marge de confiance. C’est quoi cette marge ? Eh bien on essaie avec plusieurs bases (qu’on ne me demande pas ce que c’est) et plus il y en a plus c’est fiable. Ah bon. Après essais je lui demande de m’en coller direct cinquante dans le code, avec ça le résultat est une quasi-certitude et il exécute le truc en quelques millisecondes, pourquoi se priver ? Donc où bien c’est premier et c’est immédiat, ou bien ce n’est pas premier et il n’en dit pas plus.
Ok, le nombre n’est pas premier. Sil est petit, on sait faire. S’il est grand, est-ce qu’il existe d’autres algorithmes efficaces ? Eh bien oui, l’IA me parle d’un certain Pollard rho également probabiliste qui trouve, dans la plupart des cas, des facteurs s’il y en a. Le problème, c’est que chaque facteur n’est pas obligatoirement le plus petit ni obligatoirement dans l’ordre.
Je me dis pas grave, une fois qu’il a un facteur il en a automatiquement un deuxième (le résultat de la division) et là il suffit de considérer les deux nombres comme deux autres recherches indépendantes jusqu’au moment où il ne reste plus que du facteur premier et rien d’autre. Je demande à l’IA si elle sait faire ce genre de morcellement ? Réponse, oui, c’est sans problème. Le programme en html+javascript encapsulé, le Miller-machin, le Pollard-truc et la moulinette 6k±1, le tout récursif, clé en main ? Sans problème, qu’elle répète, et sans même demander confirmation, pof elle me pond un code qui marche !
Le résultat est là :
https://sites.google.com/view/ernst01/facteurs-premiers
Bon, d’accord, faut pas lui demander de miracle non plus, mais jusqu’à $10^{30}$ c’est vraiment honnête.
(ou comment faire un truc qui aurait fait baver les auteurs des récréations mathématiques du siècle dernier sans rien connaître à la théorie mathématique, aux modulos, aux nombres premiers, aux algorithmes, à la programmation, au javascript, etc.)
#105 Re : Programmation » le prof et les nombres premiers » 21-07-2025 11:11:14
Bonjour,
Pourquoi une calculatrice ? Cela s'appelle le crible d'Érastothène, suffit de faire un tableau de 40 lignes de 50 cases (pratique, j'ai un bloc Rhodia à petits carreau, ça tient sur une feuille), puis de marquer 2 dans la première case, et partant de là de cocher une case sur 2. On met ensuite le nombre correspondant à la case libre suivante, ici 3, et on coche toutes les trois cases. Même pas besoin d'écrire, on se déplace de trois cases, on coche, on se déplace de trois cases, on coche, etc. La case libre suivante est maintenant à deux cases de ce 3, on y met 5, et on coche toutes les cinq cases. Puis 7, puis 11, etc. Un gamin sait faire ça, pas besoin d'attendre d'être au lycée. Les Grecs déjà, m'a-t-on dit...
#106 Re : Enigmes, casse-têtes, curiosités et autres bizarreries » Une farce avec le carburant » 18-07-2025 08:50:33
Hello bridgslam,
Si je raisonne en termes de distance parcourue par quantité de carburant et que je garde l’image de mon anneau, répartir le carburant en quantités variables tout le long de cet anneau revient à le couper en morceaux, chacun représentant la distance associée. Eh bien c’est simple, je peux couper un anneau en autant de morceaux différents que je veux, tant que je n’en enlève pas, ça reste un anneau.
Ok, exemple pratique. Sur l’anneau je coupe à zéro et je le coupe au premier tiers. On va dire que c’est la quantité de carburant (= distance) déposée au point de départ, un tiers de la longueur totale. Logique de penser que la quantité de carburant qui reste représente les deux tiers restants, qu’on imagine être disponible au point de coupe.
Et maintenant la ruse des camarades facétieux : après une coupe ils décident de déplacer le tronçon pour l’écarter et créer un espace (déplacement du bidon contenant le carburant restant et pof, panne sèche). Eh bien non. Quand on fait pivoter un tronçon pour l’écarter, on se rend bien compte que sa longueur fait qu’il va pousser le premier tronçon qui débute au point zéro et que celui-ci glisse d’autant et que l’ensemble reste raccord.
C’est le réservoir du véhicule qui fait office de poussoir. S’il n’existait pas, il y aurait recouvrement après déplacement et donc effectivement un trou, mais le réservoir permet de reporter la superposition et donc de déplacer d’autant le premier tronçon. Suffit bien sûr de commencer le parcours non plus à zéro mais au point de coupe après déplacement pour que cela marche.
Une fois qu’on a compris cela, on peut couper en autant de tronçons aussi petits que l’on veut et les déplacer autant qu’on veut, ça marche toujours.
(d’aucuns parleraient de récursivité ou d’induction, mais on m’a fait comprendre que ces termes étaient réservés aux mathématiciens, les vrais. :-)
#107 Re : Enigmes, casse-têtes, curiosités et autres bizarreries » Une farce avec le carburant » 17-07-2025 20:25:21
Bonsoir,
Perso je me suis imaginé sur un anneau avec un réservoir permettant d’en faire le tour complet. Ok. Que se passe-t-il si je répartis le contenu en deux moitiés et que je place le second réservoir pile poil au milieu opposé. Je le rejoins, que ce soit dans un sens ou dans l’autre, en vidant le premier. Bon, comme un anneau c’est symétrique, je ne garde qu’un seul sens, ça marche aussi.
Et maintenant, piège : je déplace le second réservoir pour l’éloigner du premier quand on respecte ce sens de rotation. Panne sèche, forcément. Sauf que. On peut partir de là où on veut, et si je pars de ce second réservoir déplacé vers la fin, quand je vais arriver à cette fin, j’aurais dans le réservoir le carburant qui me manquait pour le rejoindre à partir du premier. Et donc en ajoutant le premier, je rejoins bel et bien le second mon nouveau point de départ.
De là, même chose avec trois, quatre ou n’importe quelle répartition : choisir le point de départ permet de ‘récupérer’ l’excédent qui manquait pour l’atteindre à partir du précédent. En gros, plus on augmente les écarts, plus on concentre le carburant, et donc plus ça revient au même. :-)
Et bien sûr, une fois que j’ai compris ça, je savais que ça marchait de la même façon dans l’autre sens, forcément.
(pas très mathématique ma formulation, désolé)
#108 Re : Programmation » factorisation avec Python » 17-07-2025 14:52:58
Bonjour,
je croit que vous esquivez à ma question pour ne pas dire (rechaper)
Ah bon. Pourtant j'ai vraiment essayé de proposer et d'expliquer. Faut vraiment que j'arrête, moi...
donc j'ai factoriser seulement avec des nombres premiers comme diviseurs
Divisions effectuées : 80 (ope rations)
Bravo, surtout quand on pense qu'avec mon dernier programme il faut pas moins de 175 divisions pour la même factorisation.
si c'est le cas
pourquoi ?
Oh, tout simplement parce qu'il essaie méthodiquement sans rien négliger, et qu'entre 2 et 1033 inclus il y a exactement 174 nombres premiers.
Ceci dit, j'espère que tu trouveras des interlocuteurs plus à même de te satisfaire, alors bonne continuation.
#109 Re : Programmation » factorisation avec Python » 15-07-2025 21:59:36
Bonsoir,
En fait c'est facile à comprendre, le programme teste toutes les divisions par 2, puis 3, puis par les multiples de 6±1. Or parmi ceux-ci, environ la moitié ne sont pas des nombres premiers. Donc effectivement, le nombre de divisions ici n'est pas un minimum théorique.
Si on ne veut tester que les divisions par des nombres premiers, il faut une liste de ceux-ci jusqu'à la racine carrée du nombre dont on cherche les facteurs. Soit on charge cette liste, soit on la constitue par une méthode rapide similaire à celle utilisée dans le programme (il faut par exemple 16 664 nombres premiers pour pouvoir factoriser ton nombre 33762007291).
Allez hop, programme en Python qui constitue d'abord cette liste puis qui ne compte que les divisions par des nombres premiers :
import math
import time
from collections import defaultdict
def generer_premiers_jusqua(n):
"""Crible d'Eratosthène optimisé avec bytearray"""
if n < 2:
return []
sieve = bytearray([1]) * (n + 1)
sieve[0:2] = b'\x00\x00'
for i in range(2, int(math.isqrt(n)) + 1):
if sieve[i]:
sieve[i*i::i] = b'\x00' * len(sieve[i*i::i])
return [i for i, is_prime in enumerate(sieve) if is_prime]
def factoriser_avec_premiers(n, premiers):
"""Factorisation avec comptage précis des divisions"""
facteurs = defaultdict(int)
divisions = 0
if n == 1:
return {}, 0
for p in premiers:
if p * p > n:
break
while True:
divisions += 1
quotient, reste = divmod(n, p)
if reste != 0:
break
facteurs[p] += 1
n = quotient
if n > 1:
facteurs[n] += 1
return dict(facteurs), divisions
def main():
print("Factorisation efficace avec comptage des divisions")
print("-----------------------------------------------")
n = int(input("Entrez un nombre à factoriser : "))
start_total = time.perf_counter()
# Étape 1: Génération des premiers
start_gen = time.perf_counter()
racine = math.isqrt(n)
premiers = generer_premiers_jusqua(racine)
temps_gen = time.perf_counter() - start_gen
# Étape 2: Factorisation
start_fact = time.perf_counter()
facteurs, nb_div = factoriser_avec_premiers(n, premiers)
temps_fact = time.perf_counter() - start_fact
# Résultats
print("\n► Résultat :")
if not facteurs:
print(f"{n} est premier !")
else:
decomp = " × ".join(f"{p}^{e}" if e > 1 else str(p) for p, e in sorted(facteurs.items()))
print(f"{n} = {decomp}")
print("\n► Performance :")
print(f"- Nombres premiers générés : {len(premiers)}")
print(f"- Divisions effectuées : {nb_div}")
print(f"- Temps génération : {temps_gen:.6f}s")
print(f"- Temps factorisation : {temps_fact:.6f}s")
print(f"- TOTAL : {time.perf_counter() - start_total:.6f}s")
if __name__ == "__main__":
main()
Entrez un nombre à factoriser : 33762007291
► Résultat :
33762007291 = 182981 × 184511
► Performance :
- Nombres premiers générés : 16644
- Divisions effectuées : 16583
- Temps génération : 0.005938s
- Temps factorisation : 0.002296s
- TOTAL : 0.020397s
#110 Re : Programmation » factorisation avec Python » 14-07-2025 12:08:31
Bonjour,
Code légèrement amélioré et compacté :
def factoriser(n):
if n < 2:
print("Entier ≥ 2 requis."); return
orig, f, t = n, [], 0
deb = time.time()
while n % 2 == 0: f.append(2); n //= 2; t += 1
while n % 3 == 0: f.append(3); n //= 3; t += 1
i = 5; max_d = math.isqrt(n)
while i <= max_d:
while n % i == 0:
f.append(i); n //= i; t += 1
max_d = math.isqrt(n)
t += 1
d = i + 2
while n % d == 0:
f.append(d); n //= d; t += 1
max_d = math.isqrt(n)
t += 1
i += 6
if n > 1: f.append(n); t += 1
fin = time.time()
print(f"Facteurs de {orig} : {f}")
print(f"Divisions : {t} | Temps : {fin - deb:.6f} s")
if __name__ == "__main__":
try: factoriser(int(input("Entier à factoriser : ")))
except: print("Entrée invalide.")
Pour des nombres allant jusqu'à une quinzaine de chiffres, le temps d'obtention du résultat va être de l'ordre de la seconde sur une machine récente.
Entier à factoriser : 24960007
Facteurs de 24960007 : [4993, 4999]
Divisions : 1666 | Temps : 0.000000 s
Entier à factoriser : 14705773
Facteurs de 14705773 : [3541, 4153]
Divisions : 1182 | Temps : 0.000000 s
Entier à factoriser : 2428216771
Facteurs de 2428216771 : [48341, 50231]
Divisions : 16116 | Temps : 0.003000 s
On notera que le nombre de divisions dépend de l’algorithme utilisé, et selon bien sûr que celui-ci soit plus ou moins optimisé…
Pour que tu puisses utiliser toi-même le programme, facile : tu vas sur > cette page <, tu copies le code Python dans le cadre de gauche, en dessous tu cliques sur ‘Exécuter’, et dans la fenêtre de droite tu as le programme qui te demande de rentrer un nombre. Dès que tu en proposes un et que tu valides avec [Entrée] la réponse t’est donnée. Il suffira de cliquer à nouveau sur ‘Exécuter’ pour relancer le programme et essayer un autre nombre.
#111 Re : Programmation » factorisation avec Python » 13-07-2025 10:22:25
Bonjour,
On peut toujours écrire un programme Python qui fait le job, en utilisant une recherche un poil plus rapide que tester tous les nombres possibles :
- on teste 2 et 3
- puis tous les multiples de 6 plus ou moin 1 (donc 5, 7, 11, 13, 17, 19, etc.)
- et s'arrêter à la racine carrée
def factoriser(n):
if n < 2:
print("Veuillez entrer un entier supérieur ou égal à 2.")
return
original_n = n
facteurs = []
tentatives = 0
# Diviser par 2
while n % 2 == 0:
facteurs.append(2)
n //= 2
tentatives += 1
# Diviser par 3
while n % 3 == 0:
facteurs.append(3)
n //= 3
tentatives += 1
# Teste les diviseurs de la forme 6k ± 1
i = 5
max_diviseur = math.isqrt(n) + 1
while i <= max_diviseur:
for d in [i, i + 2]: # i = 6k - 1 et i+2 = 6k + 1
while n % d == 0:
facteurs.append(d)
n //= d
tentatives += 1
max_diviseur = math.isqrt(n) + 1 # Mise à jour après division
tentatives += 1 # On a tenté la division même si elle a échoué
i += 6
# Si il reste un nombre premier
if n > 1:
facteurs.append(n)
tentatives += 1
print(f"Facteurs de {original_n} : {facteurs}")
print(f"Nombre de tentatives de division : {tentatives}")
# Exemple d'exécution
if __name__ == "__main__":
try:
nombre = int(input("Entrez un entier à factoriser : "))
factoriser(nombre)
except ValueError:
print("Veuillez entrer un entier valide.")
La réponse est pratiquement instantanée.
Facteurs de 74747503 : [8447, 8849]
Nombre de tentatives de division : 2818
#112 Re : Enigmes, casse-têtes, curiosités et autres bizarreries » Valeurs cachées » 04-07-2025 09:51:19
Amis des probabilités et des espérances de gain, bonjour.
C'est bon, problème résolu. D'une part en pratique j'ai fait un programme qui détaille toute l'arborescence, j'ai donc l'espérance de gain exacte (pour $n=5$ c'est 20,2056) et d'autre part j'ai trouvé la formule théorique, suffit de l'appliquer aux $n^2$ pour se rapprocher de plus en plus de ces valeurs.
Tirage d’un nombre aléatoire entre [0..1], espérance de gain 0,5.
Seuil $x$ à 0,5 et deuxième tirage si inférieur, moyenne de l’espérance [0,5..1] et de l’espérance [0..1] égale à 0,625.
Ici seuil $x$ = 0,5 optimum puisque la moyenne des espérances est le polynôme $E(x) = \frac{1 - x^2 + x}{2}$ et que sa dérivée s’annule en 0,5.
Formule récursive complète :
\[ \left\{ \begin{array}{l} E_1 = \dfrac{1}{2} \\[2ex] E_n = E_{n-1}^2 + \dfrac{1}{2}(1 - E_{n-1}^2) \end{array} \right. \]
On notera que pour $n$ tirages, l'espérance est donnée par $E_n$ et le seuil par $E_{n-1}$
#113 Re : Enigmes, casse-têtes, curiosités et autres bizarreries » Valeurs cachées » 30-06-2025 22:20:28
Avec n=3 ça fait déjà pas mal de calculs si on fait à la main.
Oui, cela devient tellement touffu avec de grands $n$ que j’ai préféré estimer à partir de tirages aléatoires - une forme de sélection darwinienne si on veut - plutôt que me lancer dans le calcul.
Le problème, c’est que chaque branche de l’arborescence a des espérances de gain différentes au fil des cases découvertes. Perso j’établis des seuils pour chaque étape, à telle valeur je continue et à telle autre je conserve, mais c’est assez bourrin vu que ces seuils sont préfixés et ne tiennent pas compte de l’obtention des cases précédentes. Logique de penser qu’un 7, 3 et 2 déjà découverts laissent bien plus de valeurs hautes à la quatrième étape qu’un 13, 15 et 12 par exemple. Faudrait donc le faire en temps réel à la volée.
En fait à force d’y penser, je me rends compte que c’est un peu comme le black jack au casino, la banque applique un algorithme public qui garde un avantage sur n’importe quelle méthode pré-calculée, mais reste inférieur à des mises tenant compte des cartes restant dans le talon. Ici même chose, ma stratégie au doigt mouillé est sans doute satisfaisante comme base, mais peut très certainement être améliorée de façon dynamique.
#114 Re : Enigmes, casse-têtes, curiosités et autres bizarreries » Valeurs cachées » 30-06-2025 22:13:33
Bonjour,
Je n'ai pas fait les calculs précis mais, avec $n=5$, j'aurai envie de dire qu'après la première case, on s'arrête si celle-ci est supérieure à 20, sinon on continue. Dans ce cas, on s'arrête après la seconde case si cette dernière est supérieure à 15, puis après la troisième si elle est supérieure à 10, et enfin après la quatrième si elle est supérieure à 5.
Ainsi, je pense qu'on est proche de la valeur annoncée par Ernst :
Ernst a écrit :j’arrive à une espérance de gain de 20,192
mais je n'ai aucune idée de la question de l'optimalité...
Ma question : est ce plus ou moins ce que tu as suivi comme idée Ernst ?
Roro.
Hello,
Oui, c'est bien ça, et effectivement ta stratégie est très proche avec 19.33… Pour l’idée que je m’en fais, au début on garde l’espoir de tomber sur des valeurs hautes et donc on laisse passer les basses et les moyennes, et plus on avance plus il faut réduire ses exigences. (les seuils que j'ai retenus sont 19, 18, 17 et 14)
Pour déduire ces seuils d’une part je fais des tirages aléatoires (je mélange les n² valeurs et je prends les n premières), d’autre part je détermine une stratégie en choisissant la valeur de ces seuils au hasard. J’applique cette stratégie à un tirage précis, et le gain obtenu est ensuite attribué aux seuils s’il est plus important. Comme cela va très vite, je teste des milliers et des milliers de stratégies différentes avec ce même tirage, puis je change de tirage et je recommence, encore et encore. Avec 100 000 tirages et 10 000 stratégies par tirage, j’obtiens un milliard de simulations en moins de dix secondes, et les valeurs stabilisées restent ensuite les mêmes.
#115 Re : Enigmes, casse-têtes, curiosités et autres bizarreries » Valeurs cachées » 30-06-2025 08:31:19
Hello,
Oui, chaque fois qu’il dévoile une case il sait la valeur de celle-ci. Il peut décider de s’arrêter là et d’empocher, ou au contraire de continuer, sachant qu’à la $n$-ième il n’aura plus le choix et devra se contenter de la valeur de cette dernière.
Pour $n=2$ ce n’est pas très difficile. Au moment où il dévoile la première case, il sait. Si part exemple il tombe sur un $4$, c’est la plus grande valeur du panel (puisqu’il sait que ce sont les valeurs de $1$ à $n^{2}$ qui sont cachées) et donc il s’arrête. S’il tombe sur un $1$ il continue bien sûr, il sait qu’il fera toujours mieux. La stratégie qu’il adopte fait qu’avec un $2$ il continue puisqu’il reste $1$, $3$ et $4$ et donc qu’il a deux chances sur trois de faire mieux (espérance $\dfrac{\left( 1+3+4\right) }{3}=\dfrac{8}{3}>2$), alors qu’avec un $3$ il reste puisque cette fois son espérance est inférieure, à savoir $\dfrac{\left( 1+2+4\right) }{3}=\dfrac{7}{3}<3$.
Avec cette stratégie, l’espérance de gain du jeu $n=2$ est égale à $\dfrac{\left( \dfrac{\left( 2+3+4\right) }{3}+\dfrac{\left( 1+3+4\right) }{3}+3+4\right)}{4}=\dfrac{19}{6}$.
#116 Enigmes, casse-têtes, curiosités et autres bizarreries » Valeurs cachées » 29-06-2025 20:18:01
- Ernst
- Réponses : 7
Amis des probabilités et des espérances de gain, bonjour.
Un joueur a devant lui une grille $n\times n$ contenant des valeurs entières de 1 à $n^2$, aléatoirement disposées et toutes cachées. Il a le droit de révéler de 1 à $n$ cases, étant entendu que son gain correspondra à la valeur de la dernière case qu’il aura dévoilée. Y a-t-il des stratégies particulières et si oui, que permettent-elles en terme de gain ?
Pour $n$ = 5 (valeurs de 1 à 25 et cinq cases à ouvrir au maximum) j’arrive à une espérance de gain de 20,192 mais est-ce l’optimum ?
#117 Re : Enigmes, casse-têtes, curiosités et autres bizarreries » Une décomposition à base des premiers carrés » 24-06-2025 23:03:13
Amis des casse-têtes, bonsoir.
Merci pour ton intérêt sur le sujet, surprenant peut-être de prime abord, et ton joli crible.
Au départ c’était une curiosité à titre personnel, mais j’ai mis en ligne en me disant que cela pouvait en intéresser d’autres.
Mais quid de l'entier 0 dans ton crible?
On ajoute ou soustrait des valeurs non nulles, son cas mérite de l'attention je pense...
C'est vrai. Comme je me suis aussi amusé à faire un programme de > décomposition < pour n’importe quel entier positif (pour les négatifs suffit de changer les signes) on peut s'en servir pour explorer le zéro.
Bref, ton casse-tête hors de ma portée sur le plan théorique m’a quand même bien cassé la tête sur le plan pratique, c'est cool.
#118 Re : Enigmes, casse-têtes, curiosités et autres bizarreries » Une décomposition à base des premiers carrés » 24-06-2025 10:44:54
Bonjour,
Je suis en train de m’amuser avec ces décompositions. Pour mieux comprendre ce qui se passe j’ai fait > un crible < façon Eratosthène. L’idée est de voir quels sont les nombres accessibles à une décomposition en $m$ carrés consécutifs. Avec $m = 1$ il n’y en a qu’un seul (je néglige la symétrie histoire de rester positif ;-), avec $m = 2$ il n’y a que 3 et 5, avec $m = 3$ on obtient 4, 6, 12 et 14, etc. Le crible permet également de visualiser une plage, par exemple toutes les décompositions comprenant de un à huit termes, ce qui permet de constater que 25 n’est toujours pas atteint. Il lui faut neuf termes et on peut alors en afficher une décomposition si on le souhaite : 25 = +1² -2² +3² -4² -5² -6² -7² +8² +9².
Pour établir le crible le programme calcule les $2^{m}$ combinaisons pour un $m$ donné, ce qui devient vite monstrueux. Comme les processeurs peuvent aujourd’hui être multicœurs, j’ai ajouté le nombre de ‘workers’ souhaités, par exemple huit dans mon cas, ce qui accélère grandement les calculs quand on veut explorer $m>20$. On s’aperçoit qu’il existe toujours un premier nombre non décomposable dans la plage donnée (normal) et que celui-ci n’est finalement pas très grand...
#119 Re : Enigmes, casse-têtes, curiosités et autres bizarreries » Une décomposition à base des premiers carrés » 23-06-2025 18:41:12
Surprenant !
Ce qu’il y a de bien quand on me demande de démontrer, c’est que cela me dit que c’est possible, par conséquent je le tiens pour acquis. Donc là, c’est une propriété tout à fait étonnante, je garde. :-)
Ceci dit, comment a-t-on pu déterminer qu’une sommation des premiers carrés pouvait donner n’importe quel entier, mystère…
#120 Re : Entraide (collège-lycée) » Pangea : une question facile ? » 14-06-2025 09:01:15
Hello jelobreuil,
Merci pour ton appréciation, je ne sais jamais si c’est utile ou non de partager des avis finalement très personnels.
Je ne suis sur aucun autre forum que celui-ci, donc sens-toi libre d’utiliser cela à ta convenance, soit en reprenant les parties que tu souhaites, soit en reprenant avec tes propres formulations (pas besoin de citation), soit en mettant un lien, moi tout me convient.
J’en profite pour dire que tout ce que je mets en ligne est absolument libre d’utilisation sous n’importe quelle forme, autrement dit n’importe qui peut en faire ce qu’il souhaite sans aucune restriction. S’il fallait prendre des précautions de démineur à chaque fois qu’une idée ou qu’une formule nous plaît on n’aurait pas fini. ;-)
#121 Re : Entraide (collège-lycée) » Pangea : une question facile ? » 13-06-2025 18:31:09
Un mot sur l’assistance numérique.
Pour ceux qui ont vu se développer les tableurs et les langages de programmation après leurs études (il en reste encore m’a-t-on dit) l’avenir est au passé. Ils regrettent massivement le bon vieux temps, celui des classes prépa où on apprenait les maths comme on apprenait les lettres classiques (langues mortes faut-il le rappeler) et où l’essentiel de l’effort était finalement de démontrer encore et encore des choses parfaitement connues, la belle affaire...
Aujourd’hui c’est comme si nous avions à notre service des assistants inépuisables, ni plus ni moins. Par exemple pour Lagrange, que je n’ai pas eu l’honneur de connaître, cela a été très simple. Je lui ai demandé une formule qui, quand on fournit $a$ donne $b$, quand on fournit $c$ donne $d$ et quand on fournit $e$ donne $f$. Il me l’a donné, extrait :
$$P(x) = b \cdot \frac{(x - c)(x - e)}{(a - c)(a - e)} + d \cdot \frac{(x - a)(x - e)}{(c - a)(c - e)} + f \cdot \frac{(x - a)(x - c)}{(e - a)(e - c)}$$
Ce polynôme vérifie bien $P(a) = b$, $P(c) = d$ et $P(e) = f$
Suffit alors de remplacer $f$ par n’importe quelle valeur parmi les cinq proposées pour que le résultat soit parfait.
Soit dit en passant, ce genre d’assistance va à l’encontre de tous les principes qui régissent ce forum, à savoir que c’est au demandeur de faire un effort, qu’on lui donne uniquement des pistes, et que c’est à lui de se débrouiller en montrant de la bonne volonté. C’est très appréciable certes, et je ne remets pas cette approche en cause, je dis juste qu’aujourd’hui on dispose d’outils qui permettent d’aller bien plus vite et bien plus loin, et qu’apprendre les identités remarquables me paraît maintenant aussi utile que d’apprendre les chefs-lieux et les sous-préfectures.
#122 Re : Entraide (collège-lycée) » Pangea : une question facile ? » 13-06-2025 18:18:11
En quoi les outils numériques m’ont-ils servi ?
Si on leur demande de trouver eux-même une structure, ils essaient des dizaines de logiques différentes et choisissent souvent la valeur la plus proche de leurs résultats parmi les cinq. Ils calculent par exemple un ratio entre les cinq valeurs extérieures et la valeur centrale, observent une réduction de celui-ci entre les deux premiers pentagones, et donc choisissent la valeur pour le troisième pentagone qui prolonge cette réduction de ratio. Pas bête, mais complètement arbitraire et très approximatif.
Par contre ils vont être d’une efficacité certaine pour évaluer une théorie, et c’est là leur force. Si je leur demande d’avoir des idées à ma place, pas top. Si je leur demande d’évaluer une théorie particulière, par exemple si l’ordre en étoile est susceptible d’apporter une réponse, ils me testent le truc avec l’étoile sur chaque sommet dans les deux sens sans aucune fatigue, génial. Même chose, est-ce que la décomposition en facteurs premiers est susceptible d’être une piste ? Pof, ils décomposent immédiatement les dix-sept valeurs et cherchent une corrélation qu’ils ne trouvent pas. Et en binaire, est-ce qu’il y a un pattern de bits qui m’échapperait ? Même chose, réponse immédiate, rien d’apparent. Quand j’ai pensé à cette histoire de facteurs, j’ai demandé un programme en html+javascript encapsulé pour tester le truc, ils me pondent un programme immédiatement fonctionnel dans lequel il n’y a qu’à ajuster la plage et le pas pour tomber sur la solution – ou pas.
#123 Re : Entraide (collège-lycée) » Pangea : une question facile ? » 13-06-2025 18:15:50
Bonjour,
S’il y a une aptitude qui me semble fondamentale, c’est bien la recherche d’une structure, tout le temps, avec tout. Chercher à comprendre comment ça marche, c’est in fine toujours chercher une logique, que ce soit avec le langage, la médecine, la physique, l’agriculture ou ce que l’on voudra d’autre.
Ici même chose. On voit bien que les valeurs ne suivent pas une progression évidente, qu’il n’y a pas une question de primalité, de parité, d’alternance, les premières structures habituelles que l’on recherche dans ces cas-là. Il est facile d’inventer une structure fonctionnelle grâce aux polynômes de Lagrange mais ce n’est pas ce qu’on nous demande.
J’ai donc essayé un peu tout et n’importe quoi. Par exemple ordonner les nombres en suivant une étoile dans le pentagone (1,3,5,2,4), par exemple changer de base pour trouver une évidence masquée, par exemple décomposer en facteurs premiers pour faire émerger une similitude, etc. Et bien sûr je n’ai rien trouvé.
Je me suis dit qu’il existait peut-être une sommation avec un facteur pour chaque nombre qui donnerait le centre. En gros il s’agit d’essayer dans une plage donnée tous les facteurs possibles à appliquer indépendamment aux sommets a, b, c, d et e pour obtenir la valeur du centre. Alors hop, un petit programme et bingo, 2, -2, 2, 2 et -2 donnait la valeur centrale dans les deux premiers. Si, avec le troisième, j’obtenais une valeur parmi celles proposées, j’étais bon, sinon fallait encore chercher.
J’étais bon.
#124 Re : Entraide (collège-lycée) » Pangea : une question facile ? » 12-06-2025 22:43:55
Bonsoir,
Bon, j'ai cherché à peu près tout et n'importe quoi qui me passait par la tête. Le plus simple que j'ai trouvé :
#125 Re : Café mathématique » Un site web pour unifier les ressources mathématiques francophones ? » 09-06-2025 01:51:26
Bonjour,
J'ai demandé à Perplexity, voici sa réponse.
Je crois que même pour un autodidacte, passer par un site particulier n'a aujourd'hui plus aucun sens tant les ressources de qualité sont disponibles et faciles à trouver.
(eh oui, les temps ont bien changé, mais au moins pour cela ce n'était pas mieux avant ;-)







