python somme de nombres premiers

Je suis attachant à faire un programme en python qui permettra de générer de la somme des nombres premiers pour un certain nombre, mais le programme ne donne pas le résultat correct,s'il vous plaît dites-moi pourquoi.

b=1
#generates a list of numbers.
while b<100:
    b=b+1
    x = 0.0
    a = 0
    d = 0
    #generates a list of numbers less than b. 
    while x<b:
        x=x+1
        #this will check for divisors. 
        if (b/x)-int(b/x) == 0.0:
            a=a+1
        if a==2:
            #if it finds a prime it will add it.
            d=d+b
print d

Je l'ai fait à générer une liste de nombres premiers avec succès, mais je ne pouvais pas obtenir les premiers à ajouter.

C'est le code que j'ai utilisé pour générer une liste de nombres premiers.

b=1
while b<1000:
    b=b+1
    n = b
    x = 0.0
    a = 0
    while x<n:
        x=x+1
        if (n/x)-int(n/x) == 0.0:
            a=a+1
    if a==2:
        print b

Avez-vous le code que vous avez écrit?
que voulez-vous dire? le code est ci-dessus, ou voulez-vous dire le code qui a généré une liste de nombres premiers.
Je voulais dire, avez-vous le code pour la somme de la liste, mais j'ai ajouté que faire ci-dessous.
Pouvez-vous être plus précis sur votre objectif kyle? Somme des nombres premiers pour un certain nombre = foo(15) = 3+5 = 8?
Ne pas le vérifier a==2 aller à l'extérieur de l'intérieur alors?
Vos commentaires dire que vous êtes la génération d'une liste, mais toutes tes variables sont des nombres. Êtes-vous sûr de savoir ce qu'est un liste c'est?
Je pense que quand @kylek dit "générer une liste de nombres premiers" e n'a sans doute pas dire "liste" comme en Python type de données. Comme vous le dites, il n'y a pas de liste dans le code, donc j'attends e ne voulais pas dire de cette façon.

InformationsquelleAutor kyle k | 2013-06-20

Votre d variable est en cours de réinitialisation lors de chaque itération de ta boucle externe. Déplacer l'initialisation de sortir de cette boucle.

En outre, la a == 2 case ne doit avoir lieu qu'une fois par itération de la boucle externe. La faire sortir de la boucle interne.

b=1
d = 0
#generates a list of numbers.
while b<100:
    b=b+1
    x = 0.0
    a = 0
    #generates a list of numbers less than b. 
    while x<b:
        x=x+1
        #this will check for divisors. 
        if (b/x)-int(b/x) == 0.0:
            a=a+1
    if a==2:
        #if it finds a prime it will add it.
        d=d+b
print d

Résultat:

Pendant que nous y sommes, nous allons essayer de nettoyer le code de sorte qu'il est plus compréhensible. Vous pouvez déplacer la boucle interne dans sa propre fonction, afin que les lecteurs puissent mieux comprendre son but:

def is_prime(b):
    x = 0.0
    a = 0
    while x<b:
        x=x+1
        #this will check for divisors. 
        if (b/x)-int(b/x) == 0.0:
            a=a+1
    if a==2:
        return True
    else:
        return False

b=1
d=0
#generates a list of numbers.
while b<100:
    b=b+1
    if is_prime(b):
        d=d+b
print d

Il est également utile d'utiliser des noms de variables qui décrivent ce qu'ils représentent:

def is_prime(number):
    candidate_factor = 0
    amount_of_factors = 0
    while candidate_factor<number:
        #A += B is equivalent to A = A + B
        candidate_factor += 1
        #A little easier way of testing whether one number divides another evenly
        if number % candidate_factor == 0:
            amount_of_factors += 1
    if amount_of_factors == 2:
        return True
    else:
        return False

number=1
prime_total=0
#generates a list of numbers.
while number<100:
    number += 1
    if is_prime(number):
        prime_total += number
print prime_total

for boucles sont plus idomatic que while boucle qui incrémente un compteur:

def is_prime(number):
    amount_of_factors = 0
    for candidate_factor in range(1, number+1):
        if number % candidate_factor == 0:
            amount_of_factors += 1
    if amount_of_factors == 2:
        return True
    else:
        return False

prime_total=0
#generates a list of numbers.
for number in range(2, 101):
    if is_prime(number):
        prime_total += number
print prime_total

Si vous vous sentez audacieux, vous pouvez utiliser interprétations de la liste de réduire le nombre de boucles que vous utilisez:

def is_prime(number):
    factors = [candidate_factor for candidate_factor in range(1, number+1) if number % candidate_factor == 0]
    return len(factors) == 2

#generates a list of numbers.
primes = [number for number in range(2, 101) if is_prime(number)]
prime_total = sum(primes)
print prime_total

+1 C'est la réponse à votre question. J'ai l'impression que je me dois de mentionner si vous allez être en utilisant ce code pour un grand nombre b vous devez 1) seulement de vérifier jusqu'à la racine carrée ou 2) mieux encore, l'utilisation d'un tamis.
Est vraiment de la somme du numéro 1 sur les nombres premiers 1060? Aussi, je le sais, la somme de 20 nombres premiers est 2+2+5=9 pas 983. J'espère donc que je peux utiliser ce code mais il ne fonctionne pas comme je l'ai exception!
ce code est la somme de tous les nombres premiers inférieurs à un nombre donné, et vous semblez vouloir trouver la somme de tous les facteurs premiers d'un nombre. Ex. lorsque vous remplacez 101 avec 20 dans mon code, vous obtenez 2+3+5+7+11+13+17+19 = 77. Vous ne savez pas où vous êtes obtenir à partir de 983.
Mais comment faire pour qu'il obtenir tous les facteurs premiers du nombre et que leur somme? Mais où voulez-vous obtenir 101? Je viens de voir b = 1 et d = 0. N'est-ce pas b le nombre à remplacer?

InformationsquelleAutor Kevin

3

Kevin correctement répondu à la question que vous avez demandé. Permettez-moi de répondre à la question que vous n'a pas demander, mais devrait avoir: Quelle est la meilleure façon de calculer la somme des nombres premiers de moins de n. La réponse est d'utiliser un tamis:
```
def sumPrimes(n):
    sum = 0
    sieve = [True] * (n+1)
    for p in range(2, n):
        if sieve[p]:
            sum += p
            for i in range(p*p, n, p):
                sieve[i] = False
    return sum
```
Ce code met en œuvre le Crible d'Eratosthène, en additionnant les nombres premiers comme il va. Il travaille à plusieurs reprises par le choix de la plus petite décroise nombre (p dans le code ci-dessus, qui est sélectionné lorsque sieve[p] est True), puis en croisant l'ensemble de ses multiples (je dans le code ci-dessus, qui est incrémenté par p pour calculer les multiples de p) à partir de sa place (depuis toutes petites composites ont déjà été barré). Un exemple d'utilisation de la fonction est print sumPrimes(100), qui imprime 1060, qui est la réponse correcte.

Noter que Roland réponse ne permet pas de mettre en œuvre le Crible d'Eratosthène, même s'il affirme qu'il n'; l'utilisation de la fonction modulo est le don que Roland en réponse utilise division de première instance, pas le Crible d'Eratosthène.

Si vous êtes intéressé par la programmation par les nombres premiers, j'ai modestement recommander ce essai à mon blog.
- Merci, j'ai eu envie d'utiliser le Crible d'Eratosthène pour un certain temps maintenant, mais tous les autres exemples ont que peu de sens pour moi, cela je peux le comprendre, merci.
InformationsquelleAutor user448810
1

si vous faites cela pour l'amour de l'apprentissage de python il y a plus concis (>> moins de risques d'erreurs) façons de le faire. À partir de votre question je suis en supposant que vous êtes en essayant de la somme de tous les nombres premiers ci-dessous et dont 100:
```
sum=0
limit=100
for n in range(2,limit+1):
  if all(n % i for i in range(2, n)):
    sum += n
print sum
```
imprime 1060
- Si vous voulez aider em apprendre le langage Python, il serait utile d'expliquer le plus ésotérique Python-ismes, telles que votre compréhension de liste et les fonctions que vous utilisez.
- point de prise, mais je suis sûr que mon code est assez lisible et donne suffisamment d'indices pour laisser Google faire le reste de l'enseignement, si l'apprentissage est en effet le cas des OP objectif.
InformationsquelleAutor Sébastien Dawans

Interprétations de la liste sont un puissant outil en Python. Pensez à eux comme une boucle for en stéroïdes. 🙂 Vous pouvez les utiliser pour mettre en œuvre division de première instance, ce qui est une façon simple de trouver les nombres premiers.

Il fonctionne comme ceci:

In [4]: sum(prime_list(100))
Out[4]: 1061

La prime_list fonction:

def prime_list(num):
    """Returns a list of all prime numbers up to and including num.
    Based on trial division.

    :num: highest number to test
    :returns: a list of primes up to num

    """
    if num < 3:
        raise ValueError('this function only accepts arguments > 2')
    candidates = range(3, num+1, 2) # (a)
    L = [c for c in candidates if all(c % p != 0 for p in range(3, c, 2))] #(b)
    return [1, 2] + L

Maintenant pour l'explication. À l'exception de 2, tous les nombres premiers sont impairs. Donc, tous les nombres impairs de 3 à num (100 dans ce cas) sont des candidats pour les nombres premiers. Nous allons générer une liste de ceux que fait à (a):

In [5]: num = 100

In [6]: range(3, num+1, 2)
Out[6]: [3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33, 35, 37, 39, 41, 43, 45, 47, 49, 51, 53, 55, 57, 59, 61, 63, 65, 67, 69, 71, 73, 75, 77, 79, 81, 83, 85, 87, 89, 91, 93, 95, 97, 99]

Pour un nombre impair c être le premier, on doit s'assurer que c modulo tous les précédents numéros impairs p doit être non nul. Disons c est de 25.

In [7]: c = 25

Puis p est dans:

In [8]: range(3, c, 2)
Out[8]: [3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23]

Maintenant vérifier c modulo p:

In [9]: [c % p != 0 for p in range(3, c, 2)]
Out[9]: [True, False, True, True, True, True, True, True, True, True, True]

Comme nous le savons, 25 % 5 == 0, de sorte que le deuxième élément de la liste est False. Cependant, pour un nombre premier, tous les éléments de la liste doivent être remplies:

In [10]: all(c % p != 0 for p in range(3, c, 2))
Out[10]: False

Donc 25 n'est pas un nombre premier.

Essayez encore une fois pour c est 41:

In [11]: c = 41

In [12]: range(3, c, 2)
Out[12]: [3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33, 35, 37, 39]

In [13]: [c % p != 0 for p in range(3, c, 2)]
Out[13]: [True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True]

In [14]: all(c % p != 0 for p in range(3, c, 2))
Out[14]: True

Et en effet 41 est un nombre premier.

Donc prime_list renvoie la liste des nombres premiers:

In [15]: prime_list(100)
Out[15]: [1, 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]

À la somme que nous utilisons simplement la sum() fonction:

In [16]: sum(prime_list(100))
Out[16]: 1061

Edit: sur la Base des commentaires, j'ai essayé de l'amélioration que WillNess suggéré et un véritable tamis à l'aide des ensembles:

def prime_list(num):
    if num < 3:
        raise ValueError('this function only accepts arguments > 2')
    candidates = range(3, num+1, 2)
    L = [c for c in candidates if all(c % p != 0 for p in range(3, c, 2))]
    return [1, 2] + L

def prime_list2(num):
    if num < 3:
        raise ValueError('this function only accepts arguments > 2')
    candidates = range(3, num+1, 2)
    L = [c for c in candidates if all(c % p != 0 for p in
         range(3, int(math.sqrt(c))+1, 2))]
    return [1, 2] + L

def prime_list3(num):
    candidates = set(range(3, num+1, 2))
    results = [1, 2]
    while candidates:
        t = list(candidates)[0]
        results.append(t)
        candidates -= set(range(t, num+1, t))
    return results

Certains horaires pour num=100:

In [8]: %timeit prime_list(100)
1000 loops, best of 3: 180 us per loop

In [9]: %timeit prime_list2(100)
1000 loops, best of 3: 192 us per loop

In [10]: %timeit prime_list3(100)
10000 loops, best of 3: 83.9 us per loop

Et num=1000:

In [11]: %timeit prime_list(1000)
100 loops, best of 3: 8.05 ms per loop

In [12]: %timeit prime_list2(1000)
100 loops, best of 3: 2.43 ms per loop

In [13]: %timeit prime_list3(1000)
1000 loops, best of 3: 1.26 ms per loop

num = 5000:

In [14]: %timeit prime_list(5000)
1 loops, best of 3: 166 ms per loop

In [15]: %timeit prime_list2(5000)
100 loops, best of 3: 11.1 ms per loop

In [16]: %timeit prime_list3(5000)
100 loops, best of 3: 15.3 ms per loop

Et enfin num=50000:

In [18]: %timeit prime_list3(50000)
1 loops, best of 3: 1.49 s per loop

In [19]: %timeit prime_list2(50000)
1 loops, best of 3: 170 ms per loop

faire que if all(c % p != 0 for p in range(3, sqrt(c)+1, 2)) pour grand le gain en vitesse. 🙂 Si sqrt calcul prend trop de temps, ré-écrire cela comme une simple boucle, avec le chèque p*p <= c (peut-être plus rapide).
Intéressant. Il fonctionne très bien (au moins jusqu'à 10000 🙂 ), mais je ne vois pas encore pourquoi?
mais quel est le gain de vitesse? Maintenant sur le "pourquoi": si a*b == n et a >= sqrt(n) alors sûrement b =< sqrt(n), de sorte que vous auriez rencontrés il avant le a. L'un d'eux est <= sqrt(n) pour sûr, s'il y a des a,b tels que n == a*b. Donc, si nous sommes arrivés à la sqrt et n'a toujours pas trouvé un tel nombre, - c'est un premier.
J'ai ajouté quelques timings
ce sujet de mon explication? 🙂 -- le nouveau code: si prime_list3(n) sont optimales impl n de tamis de Erat, il serait plus rapide que prime_list2(n), qui est seulement une sous-optimale division de première instance. vous pouvez arrêter la soustraction jeux quand t est au-dessus de sqrt(num). À ce moment, toutes les valeurs de gauche des candidats sont des nombres premiers. Mais ce ne sera pas l'aider: tourner un jeu dans la liste, à chaque itération (pour trouver son faible elemt, non?) gâche la complexité globale désespérément. Vous avez besoin de générer des nombres premiers ci-dessous sqrt(num) séparément, pour les soustractions. Pouvez-vous utiliser le tamis méthode pour cela??

InformationsquelleAutor Roland Smith

0

Somme juste la liste à l'aide du code que vous avez utilisé pour générer la liste:
```
d = sum(d)
print d
```
- Quelle liste parlez-vous? Il n'y a pas de listes dans le cas des OP code. d est un entier.
- "Je l'ai fait à générer une liste de nombres premiers avec succès." Le code qu'il n'a pas de poste, mais a dit qu'il a atteint.
InformationsquelleAutor debianplebian

def sum_of_prime(num):
        if num < 2:
            return 'Please enter values greater than 2'
        if num == 2:
                return 2
        sum = 0
        for j in range(2,num):
                for i in range(2,j):
                        if (j % i) == 0:
                                break
                else:
                        print j
                        sum = sum + j
        return sum
num = int(raw_input())
result = sum_of_prime(num)
print result

ne serait-ce pas votre appel sum_of_prime(3) retour 2 aussi? ce n'est pas cohérente avec le retour des 2 pour num=2 ensuite. et que dire de l'efficacité? comment faire de votre empiriques commandes de croissance comparer avec les autres réponses?

InformationsquelleAutor Yash Rastogi

Vous devez vous connecter pour publier un commentaire.