Bibm@th

Forum de mathématiques - Bibm@th.net

Bienvenue dans les forums du site BibM@th, des forums où on dit Bonjour (Bonsoir), Merci, S'il vous plaît...

Vous n'êtes pas identifié(e).

#26 25-08-2010 21:54:30

karlun
Membre
Inscription : 05-05-2010
Messages : 216

Re : [python] chiffre par chiffre, nombre d'or phi illimité.

'soir,

Voici:

>>>
[10, 20, 40, 40, 70, 100, 120, 200, 220, 260, 300, 380, 430, 540, 550, 600, 690, 760, 710, 20]
[1, 6, 1, 8, 0, 3, 3, 9, 8, 8, 7, 4, 9, 8, 9, 4, 8, 4, 9]
nbre de cycles internes:    33
0.0 s
>>>

Mais c'est du vite fait, tirés du programme; j'espère qu'ils sont  bons (je crois qu'ils correspondent à ce que j'ai en mémoire.)

Mon expérience en matière de rebours m'a appris qu'il fallait parfois attendre plusieurs cycles avant d'obtenir la correction (à tâtons il est vrai mais logique) d'où le nombre de cycles intérieurs; un 9 au départ, pouvait devenir un zéro et encore réclamer un rebours à la dizaine inférieure (voire à plusieurs dizaines parfois).
Ton 8, après un cycle intérieur ou deux ou trois pourrais être ramené au 7 logiquement attendu...

Suite à ton post précédent j'ai été vérifier le résultat que donne mon programme avec celui de ta version 3; tu pourras constater que les derniers 3 ou 4 termes sont différents. Normal. Il faudra attendre encore une trentaine (?) d'opérations internes afin de corriger ces éphémères suspensions de chiffres.

Bon repos ou bon boulot (c'est selon).

A+-*/

PS: Les restes sont bien les bons; j'ai vérifier sur mon calepin de montagne...


Qui trouve, cherche.

Hors ligne

#27 26-08-2010 11:38:03

yoshi
Modo Ferox
Inscription : 20-11-2005
Messages : 16 943

Re : [python] chiffre par chiffre, nombre d'or phi illimité.

Salut karlun...

Ok ! Mais ce qui est bizarre, c'est que ma version Claes avec la boucle while ne souffre pas de ce problème...
Je vais mettre en pratique une idée...
Bon, en attendant, tu as bien voulu qualifier ma version 3 de bijou, c'est gentil, mais il manquait l'écrin pour aller avec :
Voilà donc une version 3.1 :

#!/usr/bin/env python
# -*- coding: cp1252 -*-

# version 3.1

from __future__ import division
from time import time

def rac5(prc):
    reste,md,finbcl,L=5,0,prc+1,[]
    for j in xrange(finbcl):
        md=10*md
        i=9-5*((md*5+25)>reste)
        while (md+i)*i>reste:
            i-=1
        md+=i
        L.append(str(i))
        reste=(reste-md*i)*100
        md+=i
    return '3'+"".join(L)[1:]


tp_d=time()
prc=20000
nb= str(int(rac5(prc))//2)
phi=nb[0]+'.'+nb[1:]
tp_a= time()
print "phi =",phi
print tp_a-tp_d,'s'

prc =20000
temps version 3     : 3.422 s
temps version 3.1  : 2.766 s

J'ai gratté 19,2 %  ;-)

Méthode : join()
Travaille sur une liste d'éléments chaînes et retourne une chaîne :

>>> a=['1','2','3']
>>> '*_*'.join(a)
'1*_*2*_*3'
>>>

De même :

>>> " [ Ah ! ] ".join(a)
'1 [ Ah ! ] 2 [ Ah ! ] 3'
>>>

Il te ne t'étonnera donc pas que :

>>> "".join(a)
'123'
>>>

La marche arrière :

>>> from textwrap import wrap
>>> wrap('123',1)
['1', '2', '3']
>>>

Python, c'est fou...
@+

Dernière modification par yoshi (26-08-2010 15:05:02)


Arx Tarpeia Capitoli proxima...

Hors ligne

#28 28-08-2010 12:37:40

karlun
Membre
Inscription : 05-05-2010
Messages : 216

Re : [python] chiffre par chiffre, nombre d'or phi illimité.

+-*/  ...  Bonjour,

J'ai cherché un peu... dans la simplicité.
Je me suis heurté au type" float" qui va pas loin (il m'a fallu un peu de temps pour m'en apercevoir vu qu'aucun message d'erreur ne vient indiquer qu'il est bloqué comme infini).

Comme toi, je me suis tourné vers les entiers.

Ça tourne mais c'est pas rapide: 5000 décimales en 33,08 s.

Au moins il reste limpide et apte à servir de programme "martyre" des fois qu'on voudrait, touche par touche, en accélérer le fonctionnement.


def v2 (nbd=5000):
    tp_d=time()
    n,ra=1,20
    while n<nbd:
        while ((ra**2)<5*10**(2*n)):
            ra=ra+1
        ra=(ra-1)*10    
        n+=1
    ra=(ra+1*10**n)/2
    tp_a=time()
    print ra
    print tp_a-tp_d,'s'

Programme à lancer comme une def (  def v2()  ) après les "from import" d'usages.

Peut-on penser "pas de nouvelle, bonne nouvelle", Yoshi, pour ce qui est de ton "huit" récalcitrant?



A+-*/


Qui trouve, cherche.

Hors ligne

#29 28-08-2010 13:03:08

yoshi
Modo Ferox
Inscription : 20-11-2005
Messages : 16 943

Re : [python] chiffre par chiffre, nombre d'or phi illimité.

Re,

Non.
Pas de bonnes nouvelles, hélas...
Il est en sommeil, en attendant une idée et le test qui permettrait de savoir
1. Quand remonter au delà de la 1ere décimale antérieure,
2. Quel test d'arrêt utiliser.
x < 0 ?

Je pense d'autre part qu'il est impossible de faire plus vite que ma version 3.1 : moins de 2,7 s pour 20000 décimales, je n'y arrive pas depuis 48 h que je triture la formule dans tous les sens.
Je sais pourtant ce que je dois faire pour y arriver, mais chacune des astuces se sont révélées plus coûteuses en temps (pas des masses quand même : entre les v. 3 et 3.1...)à cause des calculs supplémentaires que ça.
implique.

Pour la méthode Claes, je n'ai pas dit non plus mon dernier mot, mais je crains que quoi que je fasse elle reste coûteuse en temps...

Là, je vais me changer les idées avec mon programme de conjugaison.
Quand il tournera complètement en mode texte pour voix active et voix passive, forme pronominale et module autocorrectif avec messages d'erreur et règle(s) à la clé quand on décide de conjuguer soi-même, alors je penserai à un habillage graphique : plusieurs semaines de boulot...

@+

PS

Ta machine est plus rapide que la mienne...
Ton prog pour nbd=5000 me donne une réponse en 37,5 s...
Au passage j'ai remplacé ta division / qui génère une erreur à cause de la limitation des float, par // en ayant ajouté :
from __future__ import division au début...
Cela dit mon ami, je descends à 10 s : j'ai donc divisé ton temps par 3,75, soit un gain de 73,5 % par rapport à ce que tu me présentes.
Et même 9,82 s si je prends le temps immédiatement après le calcul de la racine...
Si tu examines ta version et celle que je t'ai proposée déjà dans le post #8, tu verras que c'est la même idée :
on calcule a² en augmentant de 1 tant que a² < 5*10**2n...
Il m'est venu à l'esprit en plus (idée utilisée en v. 3) qu'au lieu de partir de 0, d'augmenter et de re-soustraire 1 à l'arrivée, on pouvait partir de 9, diminuer de 1 jusqu'à ce que a² devienne inférieur à 5*10**2n...
De plus dans le post #8, je t'ai signalé que pour gagner du temps, au lieu de recalculer à chaque fois 5*10**2n, il était préférable en partant de 5, de multiplier par 100 à chaque tour...
Mieux, je définis comme début des tests soit deb = 9, soit deb = 4...

En outre, je reprends ton intégration de l'affichage dans la fonction, qui ne renvoyant rien (devient alors une procédure) et gagne un petit quelque chose sur le temps de transmission du résultat...

#!/usr/bin/env python
# -*- coding: cp1252 -*-

from __future__ import division
from time import time

def phi(prc):
    tp_d=time()
    n,rac=5,2
    for j in xrange(1,prc):
        n*=100
        rac*=10
        deb=9-5*((rac+5)*(rac+5)>n)
        while (rac+deb)*(rac+deb)>n:
            deb-=1
        rac+=deb
    racpl=(rac+10**(prc-1))//2
    phi=str(racpl)[0]+'.'+str(racpl)[-prc:]
    tp_a=time()
    print "\nphi =",phi
    print "\nCalculs effectués en :",tp_a-tp_d,'s'


print '   **************************************************'
print '   *                                                *'
print "   *             Calcul du nombre d'or              *"
print '   *                   v. 2                         *'
print '   **************************************************'
print '\n\n'
print '          Détermination du nombre de chiffres décimaux\n'

prc=5000
phi(prc)

Dernière modification par yoshi (28-08-2010 14:49:21)


Arx Tarpeia Capitoli proxima...

Hors ligne

#30 28-08-2010 14:26:04

karlun
Membre
Inscription : 05-05-2010
Messages : 216

Re : [python] chiffre par chiffre, nombre d'or phi illimité.

'lut,

Je pensais:

Et si pour gagner du temps on choisissait le bon côté d'attaque?
Aussi j'ai calculé la moyenne des 5000 iers chiffres de phi:  4.44   .
Donc, je pense qu'on arrive à boucler un cycle plus rapidement en descendant de 5 plutôt qu'en montant...
Peut-être ne seront-ce que des fifrelins de secondes...

A+-*/


Qui trouve, cherche.

Hors ligne

#31 28-08-2010 14:55:55

yoshi
Modo Ferox
Inscription : 20-11-2005
Messages : 16 943

Re : [python] chiffre par chiffre, nombre d'or phi illimité.

Re,

Je t'ai répondu en ajoutant un codicille à ma réponse précédente pendant le temps que tu rédigeais la tienne de réponse...
Non, ce n'est pas des fifrelins :
1. "En montant", tu es obligé de soustraire 1 en sortie de "boucle", en descendant non : une opération de gagnée à chaque tour ,
2. De plus, "en descendant", tu n'es pas obligé d'aller trop loin : tu gagnes en moyenne aussi une opération pour les 3 à 4 tours...
   Mais pas n'importe quelle opération : une opération qui multiplie 1000 chiffres par 1000 chiffres prend un certain temps...
3. En plus je choisis de partir de 9 ou de 4, soit de faire potentiellement 5 opérations de moins (au prix de 2 supplémentaires).
  Et pas n'importe quelles opérations, voir ci dessus...
4. Et, bizarrement, 1000000 * 1000000 est plus rapide que 1000000²...

@+


Arx Tarpeia Capitoli proxima...

Hors ligne

#32 28-08-2010 18:20:45

yoshi
Modo Ferox
Inscription : 20-11-2005
Messages : 16 943

Re : [python] chiffre par chiffre, nombre d'or phi illimité.

Ave,

J'ai encore "gratté" 9%... Je tourne en 2,531 s par excès  au lieu de : 2.766 s

#!/usr/bin/env python
# -*- coding: cp1252 -*-

# version 3.2

from __future__ import division
from time import time

def phi(prc):
    tp_d=time()
    reste,md,finbcl,L=5,0,prc+1,[]
    for j in xrange(finbcl):
        md=md*10
        i=9-(md*5>reste)*5
        while (md+i)*i>reste:
            i-=1
        md+=i
        L.append(str(i))
        reste=(reste-md*i)*100
        md+=i
    L[0]='3'
    nb=str(int(''.join(L))//2)
    phi=nb[0]+'.'+nb[1:]
    tp_a= time()
    print "phi =",phi
    print 'Durée du calcul :',tp_a-tp_d,'s'

prc=20000
phi(prc)

Je me suis notamment avisé que pour mon test : md*5+25>reste, qui détermine si je commence à 4 ou à 9,
si md*5>reste alors md*5+25>md*5>reste...
Donc mon test devient : i = 9-(md*5>reste)*5...
Sur 20000 décimales, j'économise 20000 sommes de md*5 et de 25...

@+


Arx Tarpeia Capitoli proxima...

Hors ligne

#33 04-09-2010 19:09:51

karlun
Membre
Inscription : 05-05-2010
Messages : 216

Re : [python] chiffre par chiffre, nombre d'or phi illimité.

Bon-jour-soir
...selon,

Programmation:

Encore dans l'idée d'user Python j'essaye des trucs.

A partir d'une de mes versions (pas rapides) « calcul de Phi » je me suis lancé dans l'analyse des décimales de racine de 5.

J'ai déjà indiqué que la moyenne était inférieure à 0,5.
La parité, ou non, est aussi intéressante. (Plus paire qu'impaire)

La répartition des décimales me semblait à poursuivre permettant, ainsi, d'optimiser le choix des dixièmes pour le calcul de la racine de cinq. (0,3 n'a pas fort la quotte)
Voici les résultats:

[ la série des décimales]
Nbre de décimales:   [Classement (du 1er, au dernier) des rangs]
si [5,.... => le plus grands = 6/10 (6° position)

[95, 89, 111, 98, 110, 118, 95, 98, 90, 95]
1000     [5, 2, 4, 3, 7, 0, 6, 9, 8, 1]

[195, 203, 207, 184, 215, 203, 187, 201, 209, 195]
2000     [4, 8, 2, 1, 5, 7, 0, 9, 6, 3]

[282, 308, 330, 262, 317, 311, 305, 286, 301, 297]
3000     [2, 4, 5, 1, 6, 8, 9, 7, 0, 3]

[383, 401, 429, 352, 423, 419, 417, 389, 399, 387]
4000     [2, 4, 5, 6, 1, 8, 7, 9, 0, 3]

[493, 511, 513, 464, 526, 497, 523, 494, 495, 483]
5000     [4, 6, 2, 1, 5, 8, 7, 0, 9, 3]

[594, 616, 618, 548, 628, 599, 624, 594, 606, 572]
6000     [4, 6, 2, 1, 8, 5, 0, 7, 9, 3]

[683, 711, 725, 653, 732, 698, 737, 685, 713, 662]
7000     [6, 4, 2, 8, 1, 5, 7, 0, 9, 3]

[807, 807, 825, 740, 835, 782, 833, 778, 819, 773]
8000     [4, 6, 2, 8, 0, 1, 5, 7, 9, 3]

[896, 912, 929, 841, 931, 888, 937, 886, 911, 868]
9000     [6, 4, 2, 1, 8, 0, 5, 7, 9, 3]

[997, 1011, 1025, 955, 1020, 999, 1039, 986, 1010, 957]
10000     [6, 2, 4, 1, 8, 5, 0, 7, 9, 3]

[1109, 1110, 1122, 1054, 1108, 1093, 1147, 1090, 1102, 1064]
11000     [6, 2, 1, 0, 4, 8, 5, 7, 9, 3]

[1213, 1213, 1221, 1171, 1203, 1199, 1240, 1178, 1177, 1184]
12000     [6, 2, 0, 1, 4, 5, 9, 7, 8, 3]

[1313, 1316, 1316, 1282, 1312, 1278, 1346, 1266, 1283, 1287]
13000     [6, 1, 2, 0, 4, 9, 8, 3, 5, 7]

[1430, 1408, 1406, 1370, 1408, 1386, 1427, 1359, 1395, 1410]
14000     [0, 6, 9, 1, 4, 2, 8, 5, 3, 7]

Et voila que ça change beaucoup... bigre! Que d'illusions!
Merci l'informatique.

14000 décimales au regard de l'infini... broutilles.

Y aurait-il déjà eu des études de ce genre poussées plus avant ?

Voici le programme que je souhaite voir dûment corrigé ( c'est aussi le but de ce post; j'ai tant à apprendre...)

L'idée était de classer la fréquence de chacune des décimales dans un ordre décroissant à partir de leur position dans la chaîne.


def v2 (ndc=15000):
    #tp_d=time()
    for e in xrange(1000,ndc,1000):
        a0,a1,a2,a3,a4,a5,a6,a7,a8,a9=0,0,0,0,0,0,0,0,0,0
        p,i,n,ra,L,F=0,0,1,29,[2],[]
        while n<e:
            while ((ra**2)>5*10**(2*n)):
                ra=ra-1
            re=ra%10
            L.append(int(re))
            #if re%2==0:
                #p+=1
            #else:
                #i+=1
            a0=a0+(re==0)
            a1=a1+(re==1)
            a2=a2+(re==2)
            a3=a3+(re==3)
            a4=a4+(re==4)
            a5=a5+(re==5)
            a6=a6+(re==6)
            a7=a7+(re==7)
            a8=a8+(re==8)
            a9=a9+(re==9)
            ra=(ra*10)+9   
            n+=1
        ra=(ra+1*10**n)/2
        F=[]
        F.append(a0)
        F.append(a1)
        F.append(a2)
        F.append(a3)
        F.append(a4)
        F.append(a5)
        F.append(a6)
        F.append(a7)
        F.append(a8)
        F.append(a9)
        #tp_a=time()
        Ay,C=0,[]
        print F
        for y in xrange(10):
            Ay=F.index(max(F))
            C.append(Ay)
            F[Ay]=0
        print e,"   ",C
    #w,x=float(sum(L)),len(L)
    #print "moyenne= ",w/x,"   paires=",p,"  impaires=",i
    #print tp_a-tp_d,'s'


Qui se lance comme une def avec les import d'usages


A, mes gesticulations et +-*/       :-)


Qui trouve, cherche.

Hors ligne

#34 04-09-2010 21:09:25

yoshi
Modo Ferox
Inscription : 20-11-2005
Messages : 16 943

Re : [python] chiffre par chiffre, nombre d'or phi illimité.

Re,

Tiens camarade, voilà de quoi cogiter :

#!/usr/bin/env python
# -*- coding: cp1252 -*-

# Version 1.0

from __future__ import division
from operator import itemgetter
from time import time

def rac(prc):
    tp_d=time()
    reste,md,finbcl,L=5,0,prc+1,[]
    for j in xrange(finbcl):
        md=md*10
        i=9-(md*5>reste)*5
        while (md+i)*i>reste:
            i-=1
        md+=i
        L.append(str(i))
        reste=(reste-md*i)*100
        md+=i
    return L

prc=20000
tp_d=time()
L=rac(prc)
N=list(set([(x,L.count(x)) for x in L]))
N_tri=sorted(N,key=itemgetter(1),reverse=True)
tp_a= time()
print '\n               Classement des décimales'
print '\n',N_tri
print tp_a-tp_d,'s'

Résultats pour 14000 et 20000 décimales :

               Classement des décimales

[('0', 1430), ('6', 1427), ('9', 1410), ('4', 1409), ('1', 1408), ('2', 1407), ('8', 1395), ('5', 1386), ('3', 1370), ('7', 1359)]
5.79699993134 s
>>> ================================ RESTART ================================
>>>

               Classement des décimales

[('6', 2041), ('9', 2027), ('4', 2015), ('2', 2011), ('1', 2008), ('5', 2005), ('8', 1993), ('3', 1987), ('0', 1960), ('7', 1954)]
11.7960000038 s
>>>

J'expliquerai demain...

@+


Arx Tarpeia Capitoli proxima...

Hors ligne

#35 04-09-2010 21:33:19

karlun
Membre
Inscription : 05-05-2010
Messages : 216

Re : [python] chiffre par chiffre, nombre d'or phi illimité.

'Soir,

Un coin bouché!    ....un  !

Merci Maître.
j'm'en vais l' méditer.

A+-*/


Qui trouve, cherche.

Hors ligne

#36 05-09-2010 09:01:18

yoshi
Modo Ferox
Inscription : 20-11-2005
Messages : 16 943

Re : [python] chiffre par chiffre, nombre d'or phi illimité.

Re,

Bon, il y a un os dans le potage, mais je ne l'ai pas encore trouvé...

Ton résultat pour 1000 :
[('0', 118), ('4', 111), ('7', 110), ('3', 98), ('9', 98), ('5', 95), ('6', 95), ('1', 95), ('8', 90), ('2', 89)]
Mon résultat :
[('5', 118), ('2', 112), ('4', 110), ('7', 98), ('3', 98), ('6', 95), ('0', 95), ('9', 95), ('8', 90), ('1', 89)]

Quand tu dis 1000, c'est 1000 chiffres au total ou 1000 décimales ?
Mais le problème ne vient pas de là :
j'ai teste ta racine de 5 reconstituée à partir de ton post #3.
Je n'ai pris que 900 décimales : elle coïncide avec la mienne.
Il faut donc maintenant que je teste ton prog et le mien sur 900 décimales puisque les décimales coïncident.
Il y a peu de chances que ma méthode soit fausse : je n'ai utilisé que des fonctions pythonesques et méthodes existantes.

Wait and see...

@+


Arx Tarpeia Capitoli proxima...

Hors ligne

#37 05-09-2010 11:15:17

yoshi
Modo Ferox
Inscription : 20-11-2005
Messages : 16 943

Re : [python] chiffre par chiffre, nombre d'or phi illimité.

Re Re,

Ce que donne ta méthode avec 901 chiffres (900 décimales) avec ma méthode de comptage :
[('5', 102), ('2', 101), ('4', 101), ('6', 89), ('3', 87), ('9', 86), ('0', 85), ('7', 85), ('1', 83), ('8', 82)]
Ce que j'obtiens avec 900 chiffres avec mon prog :
[('5', 102), ('2', 101), ('4', 101), ('6', 89), ('3', 87), ('9', 86), ('0', 85), ('7', 85), ('1', 83), ('8', 82)]

Donc, là, on est d'accord, que ce soit mon comptage sur ta racine, ou mon comptage sur ma racine, ça colle...

Mais, pour 1000 décimales, mon comptage sur ta racine :
[('5', 118), ('2', 112), ('4', 110), ('7', 98), ('3', 98), ('9', 96), ('6', 95), ('0', 95), ('8', 90), ('1', 89)]
ton comptage :
[('0', 118), ('4', 111), ('7', 110), ('3', 98), ('9', 98), ('5', 95), ('6', 95), ('1', 95), ('8', 90), ('2', 89)]

Y a comme un blème... !!!
Je continue mes investigations...

Qq explications de texte...
1. Notion de "list comprehension"
Il y a bien longtemps, on enseignait les "maths modernes" et en particulier le vocabulaire ensembliste.
On disait qu'il y avait deux façons de définir un ensemble :
- En extension, par exemple I={1,3,5,7,9,11,13,15,17,19}
- En compréhension : I est l'ensemble des 10 premiers nombres impairs, compréhension = au moyen d'une propriété caractéristique commune), soit :
   [tex]I=\{x,\; x=2k+1,\; k\; in\; \mathbb{N}\; et\; k<10\}[/tex]

Transposons à Python.
* I = [1,3,5,7,9,11,13,15,17,19] liste des premiers nombres impairs.
* Construction de la liste :

I=[]
for i in xrange(10}:
    I.append(2*i+1)

Mais il y une façon plus "ramassée" d'écrire ça, au moyen d'une "list comprehension", une liste définie en compréhension :
   I=[2*i+1 for i in xrange(10)]

2. Elimination des doublons dans une liste

>>> h=['2', '2', '3', '6', '0', '6', '7', '9', '7', '7', '4', '9', '9', '7', '8', '9', '6', '9', '6']
>>> set(h)
set(['0', '3', '2', '4', '7', '6', '9', '8'])
>>> list(set(h))
['0', '3', '2', '4', '7', '6', '9', '8']

set() élimine les doublons mais ne te retourne pas une liste, pour la récupérer on fait list(set(h))

3. Comptage des éléments identiques.
    via count() : 

>>> h.count('2')
2
>>> h.count('6')
4
>>>

4. Comptage et élimination des doublons
   Je vais décomposer ça en plusieurs étapes :
   a) Création de la liste de couples (élément, nombre de présences):
   

>>> [(x,h.count(x)) for x in h]
[('2', 2), ('2', 2), ('3', 1), ('6', 4), ('0', 1), ('6', 4), ('7', 4), ('9', 5), ('7', 4), ('7', 4), ('4', 1), ('9', 5), ('9', 5), ('7', 4), ('8', 1), ('9', 5), ('6', 4), ('9', 5), ('6', 4)]
>>>

b) Maintenant j'élimine les doublons et je récupère une liste :
   

>>> list(set([(x,h.count(x)) for x in h]))
[('6', 4), ('4', 1), ('9', 5), ('0', 1), ('7', 4), ('2', 2), ('8', 1), ('3', 1)]
>>>

5. Tri de la liste selon le nombre de présences décroissante du 2e élément de chaque couple
   *  tri --> sorted()
   *  2e élément  --> itemgetter = 1
   *  Décroissance --> reverse = True. Par défaut, c'est False, et le tri est croissant.
   Donc :

>>> sorted([('6', 4), ('4', 1), ('9', 5), ('0', 1), ('7', 4), ('2', 2), ('8', 1), ('3', 1)],key=itemgetter(1),reverse=True)
[('9', 5), ('6', 4), ('7', 4), ('2', 2), ('4', 1), ('0', 1), ('8', 1), ('3', 1)]
>>>

Voilà, tu sais tout...

@+


Arx Tarpeia Capitoli proxima...

Hors ligne

#38 06-09-2010 18:06:49

yoshi
Modo Ferox
Inscription : 20-11-2005
Messages : 16 943

Re : [python] chiffre par chiffre, nombre d'or phi illimité.

Ave,

classer la fréquence de chacune des décimales dans un ordre décroissant à partir de leur position dans la chaîne.

L'idée vient de m"effleurer que j'ai dû me méprendre sur le sens de cette phrase...
Et pourtant avec 900 décimales (en principe), on est d'accord...
Quelque chose doit donc m'échapper...
Moi j'ai calculé les nombres d'apparition de chaque décimale dans la racine de 5.

@+


Arx Tarpeia Capitoli proxima...

Hors ligne

#39 06-09-2010 19:19:53

karlun
Membre
Inscription : 05-05-2010
Messages : 216

Re : [python] chiffre par chiffre, nombre d'or phi illimité.

Salut,

Je regarde les résultats de ma version (dernière et rameuse) et  ça me semble coller; il y a la liste et il y a le classement en dessous.

Tes remarques m'incite à reprendre et vérifier.

"classer la fréquence de chacune des décimales dans un ordre décroissant à partir de leur position dans la chaîne."

avait pour but de percevoir, en un regard, les changements de classement des décimales restées ordonnées (de 0 à 9)


A+-*/

Dernière modification par karlun (06-09-2010 19:31:29)


Qui trouve, cherche.

Hors ligne

#40 06-09-2010 20:11:22

yoshi
Modo Ferox
Inscription : 20-11-2005
Messages : 16 943

Re : [python] chiffre par chiffre, nombre d'or phi illimité.

Re,

Ok...
Donc c'est ça que tu veux pour 1000 décimales :
[('0', 95), ('1', 89), ('2', 112), ('3', 98), ('4', 111), ('5', 118), ('6', 95), ('7', 98), ('8', 90), ('9', 95)]

Alors, j'ai juste la ligne suivante à changer :

N_tri=sorted(N,key=itemgetter(1),reverse=True)

qui devient  :
N_tri=sorted(N,key=itemgetter(0),reverse=False)
ou encore simplement :
N_tri=sorted(N)

Et on obtient le résultat attendu...

Soit pour 2000 décimales :
[('0', 195), ('1', 204), ('2', 208), ('3', 184), ('4', 215), ('5', 203), ('6', 187), ('7', 201), ('8', 209), ('9', 195)]

Pour 14000 :
[('0', 1430), ('1', 1408), ('2', 1407), ('3', 1370), ('4', 1409), ('5', 1386), ('6', 1427), ('7', 1359), ('8', 1395), ('9', 1410)]

@+

PS
Encore raté !...
Ce n'est toujours pas ce classement là que tu veux.
D'ailleurs, je préférais le précédent.
On verra demain.


Arx Tarpeia Capitoli proxima...

Hors ligne

#41 09-09-2010 17:42:13

karlun
Membre
Inscription : 05-05-2010
Messages : 216

Re : [python] chiffre par chiffre, nombre d'or phi illimité.

Salut,

Karlun a écrit :

Je transpose en programme la méthode de résolution à la main de l'extraction de racine 5 (augmentée d'une unité) et simultanément  la division par 2.

et encore

Un peu présomptueux sans doute....le simultanément était mon idée mais il en est tout autre dans le prog. transmis. J'ai opéré la division après avoir calculé la racine; sans doute, tenir compte de cette remarque fera gagner du temps.

Et bien non!

L'ancienne version pour 300 chiffres: 0.25 s.
                                   3000          : 117.638
Cette nouvelle version, 300 chiffres: 0.28 s.
                                  3000           : 129.635

Voici la nouvelle version un peu nettoyée et améliorée.

# -*- coding: cp1252 -*-
from math import*
from time import time

    #=============================================
    #  extraction à la main de phi (1.618033....) à partir de ***((Racine 5) + 1)/2***
    #=============================================
def extract_phi(w=10):
    "extraction à la main de phi (x-1=nbre de chiffre)"
   
    #======================================
 # 1)extraction chiffre par chiffre, à la main de racine de 5 et division par 2 du chiffre-résultat
 #   (le premier est majoré de une unité).
    #======================================
   
    def racinePlus(v,r,t,q,rn):
        "place dans les listes ra,re,tot les résultats calculés"
        ra.append(v)
        re.append(r)
        tot.append(t)
        quot.append(q)
        resteDiv.append(rn)
        return ra,quot,resteDiv

    def racineMoins(m):
        "enlève des listes le dernier élément"
        del ra[m]
        del re[m]
        del tot[m]
        del quot[m]
        del resteDiv[m]
        return ra,quot,resteDiv

    def travRacine(ra,re,tot,z,t):
        ra[z-2]=ra[z-2]-1
        re[z-2]=re[z-2]+40
        resteDiv[z-2]=resteDiv[z-2]-1
        quot[z-2]=resteDiv[z-2]/2
        racineMoins(z-1)
        return ra,re,tot,z,quot,rn
   
    tp_d=time()
    #première étape: amorce de l'extraction de racine 5 et de la division par 2
    v=int(sqrt(5.))+1
    r,q,rn=10,1,3
    t,p,x=0,0,w
    ra,re,tot,quot,resteDiv=[],[],[],[],[]
    racinePlus(v,r,t,q,rn)
    z=len(ra)
    #Et c'est parti pour des tours.

    while(len (ra)<w):
         #calculs intérieurs => caculer t à partir des listes existantes
       
        p+=1
        a,b,t,=0,0,0,
        c=(z+1)/2
        if(((z)%2)):                # =>z+1 est paire
            while(a<(c-1)):
                t=t+2*(ra[c-1-a]*ra[c+b])
                a=a+1
                b=b+1
        else:                       #=> z+1 est impaire
            while(a<(c-1)):
                t=t+2*(ra[c-1-a]*ra[c+1+b])
                a=a+1
                b=b+1
            t=t+ra[c]**2
        #comparaison t doit être < que le reste: si non on dégraisse
       
        for i in xrange(ra[z-1],0,-1):
            if(t>re[z-1]):
                ra[z-1]=ra[z-1]-1
                re[z-1]=re[z-1]+40
                tot[z-1]= tot[z-1]
                t=t-4
                resteDiv[z-1]=resteDiv[z-1]-1
                quot[z-1]=resteDiv[z-1]/2
               
                #dégraissage accompli
                     
        if(ra[z-1]<=0):
            if(t>=re[z-1]):
                i,j=0,1
                while(i<j):
                    t=tot[z-1]-4                   #pour conserver t après travRacine
                    travRacine(ra,re,tot,z,t)
                    z=len(ra)
                    if(ra[z-1]==0):                 #cas où 1-1=0
                        if(t>re[z-1]):
                            j=j+1
                        else:
                            j=j
                    else:
                        if(ra[z-1]==-1):            #cas où 0-1=-1
                            j=j+1
                        else:
                            j=j
                    i+=1
       
        #ajout de la nouvelle racine (ra,re,tot)
        #ajout du nouveau quotient et de son reste (quot,resteDiv)
                   
        v=(re[z-1]-t)/4
        if(v>9):
            v=9
        r=(re[z-1]-(4*v+t))*10
        rn=(resteDiv[z-1]-quot[z-1]*2)*10+v
        q=rn/2
        racinePlus(v,r,t,q,rn)
        z=len(ra)
    tp_a= time()
    print tp_a-tp_d,'s'
    #print ra
    print quot  #qui est égal à phi
   
 
#=========================
    #commandes
extract_phi(300)
#=========================

Cette version jette la base du calcul de la racine carrée de phi, chiffre après chiffre, de manière illimitée.
(((1+extraction de racine de 5) division par deux) et extraction racine carrée).

Cet objectif pourrait-il être réalisé par une autre méthode?

A+-*/

Dernière modification par karlun (10-09-2010 17:29:51)


Qui trouve, cherche.

Hors ligne

Réponse rapide

Veuillez composer votre message et l'envoyer
Nom (obligatoire)

E-mail (obligatoire)

Message (obligatoire)

Programme anti-spam : Afin de lutter contre le spam, nous vous demandons de bien vouloir répondre à la question suivante. Après inscription sur le site, vous n'aurez plus à répondre à ces questions.

Quel est le résultat de l'opération suivante (donner le résultat en chiffres)?
soixante dix-sept plus soixante cinq
Système anti-bot

Faites glisser le curseur de gauche à droite pour activer le bouton de confirmation.

Attention : Vous devez activer Javascript dans votre navigateur pour utiliser le système anti-bot.

Pied de page des forums