循环运行所花费的时间

Question

I am new to programming. I was trying a program to print the nth prime number. The code is as given below:

##program to print the nth prime number
nreq=input("Enter a number ")  
pctr=0 ##counter of the prime numbers
num=2

while pctr!=nreq:
    ctr=0 ##counter
    i=2
    while i<=num:
        if num%i==0:
            ctr=ctr+1
        i=i+1
    if ctr==1:
        pctr=pctr+1
    if pctr==nreq:
        break
    num=num+1


print 'the {}th prime number is {}'.format(nreq,num)  

I tried the same algorithm in both python and C. For larger numbers the time taken in python was much greater for the output as compared to C. Why did this occur? Can someone please explain the difference in which both of them execute?

My code in C was the following:

#include<stdio.h>


void main()
{

int num=2,nreq,ctr=0,pctr=0,i;

printf("enter the number of prime required");
scanf("%d",&nreq);

    while(pctr!=nreq)
{

    ctr=0;
    for(i=2;i<=num;i++)
        if(num%i==0)
            ctr++;

    if(ctr==1)
        pctr++;

    if(pctr==nreq) 
        break;
    num++;
}

printf("the %dth prime number is %d",nreq,num);
}

Answer 1

C is often faster than Python as it is compiled, and is less abstract. What that means is that C generates machine code, which is then executed by the computer. On the other hand, Python's interpreter is actually a C programs that goes through the syntax tree at runtime and executes it, which in many cases is slower. If you want your Python code to run faster, then you can try another Python implementation .

That being said, your algorithm is rather inefficient, O(n^2) (although I'm not sure if there is any less complex algorithm for this problem). In other words, as the input gets larger, the worst case complexity scales much faster. For more information on complexity, see here .

Edit: Thanks to @laindir for providing an explanation of how to make this code less complex:

An easy optimization is to store the primes so far discovered, so that only they are checked in the inner loop. That brings it down from O(n^2) to O(n * p) where p is the number of primes less than n. The next simplest is doing something in the outer loop to skip over numbers guaranteed not to be prime--a technique known as sieving--eg, skipping even numbers. A very simple sieve is Eratosthenes--that's the one used by the unix utility primes.