J'ai bien trouvé une réponse qui valide le calcul de la probabilité (0.5) et le nombre de boules total supérieur à 10 milliards mais celle-ci n'est pas validée.
Voici le code (d'après les deux exemples donnés dans l'énoncé, j'ai estimé le nombre de boules bleues de départ à la racine carrée de 0.5 multipliée par le nombre total de boules) :
def proba(nb_total, nb_bleues):
return (nb_bleues / nb_total) * ((nb_bleues - 1) / (nb_total - 1))
nb_total = int(10 * 10**9)
nb_bleues = int(round(nb_total * 0.5 ** (1 / 2)))
P = proba(nb_total, nb_bleues)
while not P == 0.5:
if P < 0.5:
nb_bleues += 1
else:
nb_total += 1
nb_bleues = int(round(nb_total * 0.5 ** (1 / 2)))
P = proba(nb_total, nb_bleues)
print(f"La réponse est {nb_bleues} (Total = {nb_total}).")
En sortie, j'ai la réponse suivante :
La réponse est 7073354024 (Total = 10003233192).
Je dois dire que je sèche sur le truc qui cloche dans mon raisonnement. je m'en remets donc à vous pour m'aiguiller vers le bon chemin !!!
Je vois déjà un problème qu'il faudra régler et c'est la précision des calculs et la manière dont vous comparez P à la valeur 0,5
Il faudrait appliquer une tolérance
while not abs(P - 0.5) < tolerance:
sinon la condition de la boucle while peut ne jamais être satisfaite en raison des approximations avec les flottants.
Celui qui trouve sans chercher est celui qui a longtemps cherché sans trouver.(Bachelard) La connaissance s'acquiert par l'expérience, tout le reste n'est que de l'information.(Einstein)
pour diminuer la probabilité, mais comme je suis une bille dans ce genre d'exercices, je préfère pas m'avancer.
Celui qui trouve sans chercher est celui qui a longtemps cherché sans trouver.(Bachelard) La connaissance s'acquiert par l'expérience, tout le reste n'est que de l'information.(Einstein)
Qu'est-ce que ça donnerait si tu ramenait tout à une fraction simple.
Dans l'exemple, on donne 15/21 * 14 / 20 = 210 / 420.
Il faut que le dénominateur soit le double du numérateur.
Bien sûr, les nombres sont très grands dans ce cas.
- Si on a (bleu * (bleu-1)) / (total * (total-1)) = 1 / 2 2 * bleu * (bleu-1) = total * (total-1) 2 * bleu*bleu - 2 * bleu - total * (total-1) = 0 Équation du second degré: Il faut trouver total tel que 2*total*total-1) + 1 soit un carré. J'en suis là ...
- Edité par PierrotLeFou 19 juin 2024 à 1:25:39
Le Tout est souvent plus grand que la somme de ses parties.
je pense que la condition voulue est 0.5 exactement, on peut réécrire cette condition comme b*(b-1)*2=t*(t-1) (b étant le nombre de boules bleues et t le nombre de totale de boules)
En comparant ces 2 termes, on s'affranchirait des problèmes liés aux flottants résultant de la division.
L'expression n*(n-1) est le double de la somme des nombres de 1 à n-1.
Je pense néanmoins que ce n'est pas la bonne approche. Voici ce que j'ai fait:
-
from time import perf_counter begin = perf_counter() t = 10**10 b = int(((2*t*(t-1))**0.5-1)/2) st = t*(t+1) // 2 sb = b*(b+1) // 2 while True: ds = 2*sb - st if abs(ds) < 5: break elif ds < 0: b += 1 sb += b else: t += 1 st += t print(round(perf_counter() - begin, 3), "secondes") print(b) print(t) print(2*sb-st) """ Ce qui donne: 962.326 secondes 8301239105 11739724927 2 """
Le Tout est souvent plus grand que la somme de ses parties.
from math import sqrt
x, total = 0.99, 10**10
while(x-int(x) != 0):
total += 1
a, b, c = 1, -1, -0.5*total*(total-1)
delta = b**2 - 4*a*c
if delta >=0:
x = (-b+sqrt(delta))/(2*a)
if 2*x*(x-1)==total*(total-1):
break
print('{} boules bleues {} boules rouges {} total'.format(int(x), int(total)-int(x),total))
j'obtiens 7071072880 boules bleues 2928934288 boules rouges 10000007168 total Edit: je dois être passer à côté d'un truc en fait, ce n'est pas bon non plus
parce que ça ne tombe pas juste, il y a 10 d'écarts entre les 2 termes, et donc la proba vaut 0.49999999999999994
En réadaptant le code de Phil
from math import sqrt
x, total = 0.99, 10**10
while( not x.is_integer() or not(2*x*(x-1)==total*(total-1))):
total += 1
a, b, c = 1, -1, -0.5*total*(total-1)
delta = b**2 - 4*a*c
if delta >=0:
x = (-b+sqrt(delta))/(2*a)
print('{} boules bleues {} boules rouges {} total'.format(int(x), int(total)-int(x),total))
j'obtiens le résultat 14297851353 boules bleues 5922363943 boules rouges 20220215296 total qui lui semble juste
Ouh là, je vois que ma problématique a déchainé la foule depuis mardi !!!
Punaise, au final, à un moment donné je suis parti sur la résolution de l'équation du second degré mais je n'avais pas poursuivi !!! La cause, une erreur de calcul toute bête. Pour éviter le 0.5 de la probabilité, j'ai tout multiplié par 10 sauf que les coefficients de l'équation, je les ai multiplié par 5 !!! Pourquoi, mystère !!!
Je vais actualisé mon code avec les bons coeffs et vous tiens au courant de la validation de la réponse.
Merci à tous.
Edit : Malheureusement, le nombre de boules bleues trouvé (14 297 851 353) n'est pas validé comme solution à ce problème.
Je vais simplifier un peu l'expression: Est-ce que vous êtes d'accord avec ceci? 2 * b * (b-1) = t * (t-1) 2*b*(b-1) = 2 * b**2 - 2*b Le delta vaut 4 + 4*2*t*(t-1) Si on extrait le 4 pour donner 2 à l'extérieur de la racine: delta = 1 + 2*t*(t-1)
Le Tout est souvent plus grand que la somme de ses parties.
Je vais simplifier un peu l'expression: Est-ce que vous êtes d'accord avec ceci? 2 * b * (b-1) = t * (t-1) 2*b*(b-1) = 2 * b**2 - 2*b Le delta vaut 4 + 4*2*t*(t-1) Si on extrait le 4 pour donner 2 à l'extérieur de la racine: delta = 1 + 2*t*(t-1)
Oui, oui, PierrotLeFou, je suis d'accord avec la valeur de delta.
Ma version de code avec la solution de la résolution de l'équation du second degré est devenue la suivante :
from math import sqrt
nb_total = 20.22 * 10**9
nb_bleues = 0.99
while not nb_bleues.is_integer() or not (2 * nb_bleues * (nb_bleues - 1) == nb_total * (nb_total - 1)):
nb_total += 1
"""
Recherche de la solution positive de l'équation :
(nb_bleues / nb_total) * ((nb_bleues -1 )/ (nb_total - 1)) = 0.5
soit
nb_bleues ** 2 - nb_bleues + 0.5 * (nb_total - nb_total **2) = 0
"""
delta = 1 + 2 * nb_total * (nb_total - 1)
if delta >= 0:
nb_bleues = (1 + sqrt(delta)) / 2
print(f"La réponse est {int(nb_bleues)} (Total = {int(nb_total)}).")
Cependant, comme je l'ai précisé dans le edit de mon message précédent, la solution trouvée n'est pas validée.
edit: Remarque sur l'égalité 2 * b * (b-1) = t * (t-1) On a déjà un 2 à gauche et un des nombres b ou b-1 qui est divisible par 2. Un des nombres à droite est impair et l'autre sera forcément un multiple de 4. On aura ou bien 4x, 4x-1 ou bien 4x+1, 4x - On cherche une solution pour t > 10**10, mais on peut se demander s'il existe plusieurs solutions inférieures à 10**10 J'ai écrit un petit programme (pas vraiment optimisé) pour les chercher. Python semble assez lent pour gérer les grands nombres. Les deux dernières lignes ont pris un temps vraiment abonimable( non calculé). Si quelqu'un a une idée de génie pour trouver le terme suivant ... Remarquons que toutes les valeurs de b sont impaires et que celles de t alternent entre les deux formes citées ci-haut. En fait: 4, 20, 21, 60, 61, 97 (non cyclique) - b = 2 t = 4 while t < 10**10: d = 2*b*(b-1) - t*(t-1) if d == 0: print(b, t, sep=", ") t += 1 elif d < 0: b += 1 else: t += 1 - 3, 4 15, 21 85, 120 493, 697 2871, 4060 16731, 23661 97513, 137904 568345, 803761 3312555, 4684660 19306983, 27304197 112529341, 159140520 655869061, 927538921 3822685023, 5406093004
- Edité par PierrotLeFou 23 juin 2024 à 2:36:48
Le Tout est souvent plus grand que la somme de ses parties.
Je n'ai pas été assez génial pour trouver la relation entre les valeurs de B (bleu). Je l'ai donc fait avec force brûte, mais en C car Python est trop lent. J'ai écrit ma propre version de l'arithmétique quadruple précision (4 x 32 bits). Voici ma réponse, qui est acceptée par le site: 22280241075, 31509019101 Voici la solution qui est très simple (quand on le sait ...): b(0) = 1 b(1) = 3 ... b(n) = b(n-1) * 6 - b(n-2) - 2 Chercher b(15)
Le Tout est souvent plus grand que la somme de ses parties.
Je n'ai pas été assez génial pour trouver la relation entre les valeurs de B (bleu). Je l'ai donc fait avec force brûte, mais en C car Python est trop lent. J'ai écrit ma propre version de l'arithmétique quadruple précision (4 x 32 bits). Voici ma réponse, qui est acceptée par le site: 22280241075, 31509019101 Voici la solution qui est très simple (quand on le sait ...): b(0) = 1 b(1) = 3 ... b(n) = b(n-1) * 6 - b(n-2) - 2 Chercher b(15)
Félicitations, PierrotLeFou.
Oui, effectivement, avec la solution sous les yeux, la réponse se trouve toute seule.
Maintenant, mon challenge est de tenter de retrouver cette suite !!!
Un gros rafraichissement des notions de proba en perspective !!!
Après avoir disposé les valeurs sous forme de tableau, c'est venu assez rapidement (explication dans le code) :
"""
Résultat de mon observation :
Le nombre de boules rouges du tirage suivant est égal à :
Nombre de boules total du tirage précédent + ( Nombre de boules bleues du tirage précédent - 1)
Le nombre de boules bleues du tirage suivant est égal à :
Nombre de boules bleues du tirage précédent + 2 x nombre de boules rouges du tirage en cours
"""
# BRT [Bleu, Rouge, Total]
BRT = [[15, 6, 21], [85, 35, 120]]
while not BRT[-1][2] > 10**10:
R = BRT[-1][2] + (BRT[-1][0] - 1)
B = BRT[-1][0] + 2 * R
BRT.append([B, R, B + R])
print(f"La réponse est {BRT[-1][0]} (Total = {BRT[-1][2]}).")
PB68
Celui qui trouve sans chercher est celui qui a longtemps cherché sans trouver.(Bachelard)
La connaissance s'acquiert par l'expérience, tout le reste n'est que de l'information.(Einstein)
PB68
Celui qui trouve sans chercher est celui qui a longtemps cherché sans trouver.(Bachelard)
La connaissance s'acquiert par l'expérience, tout le reste n'est que de l'information.(Einstein)
Le Tout est souvent plus grand que la somme de ses parties.
Le Tout est souvent plus grand que la somme de ses parties.
Le Tout est souvent plus grand que la somme de ses parties.
PB68
Le Tout est souvent plus grand que la somme de ses parties.
PB68
Le Tout est souvent plus grand que la somme de ses parties.
Le Tout est souvent plus grand que la somme de ses parties.
PB68
PB68
PB68