Circular primes less than n - GeeksforGeeks

21 Apr, 2021
Find all circular primes less than given number n. A prime number is a Circular Prime Number if all of its possible rotations are itself prime numbers.
Examples : 
79 is a circular prime.
as 79 and 97 are prime numbers.

But 23 is not a circular prime.
as 23 is prime but 32 is not a prime number. 
Algorithm: 
-> Find prime numbers up to n using Sieve of Sundaram algorithm.
-> Now for every prime number from sieve method,
  one after another, we should check whether its all
  rotations are prime or not:
   -> If yes then print that prime number.
   -> If no then skip that prime number.
Below is the implementation of the above algorithm :
C++
Java
Python3
C#
PHP
Javascript
// C++ program to print primes smaller than n using// Sieve of Sundaram.#include <bits/stdc++.h>using namespace std; // Prototypes of the methods usedvoid SieveOfSundaram(bool marked[], int);int Rotate(int);int countDigits(int); // Print all circular primesvoid circularPrime(int n){    // In general Sieve of Sundaram, produces primes smaller    // than (2*x + 2) for a number given number x.    // Since we want primes smaller than n, we reduce n to half    int nNew = (n - 2) / 2;     // This array is used to separate numbers of the form i+j+2ij    // from others where 1 <= i <= j    bool marked[nNew + 1];     // Initialize all elements as not marked    memset(marked, false, sizeof(marked));     SieveOfSundaram(marked, nNew);     // if n > 2 then 2 is also a circular prime    cout << "2 ";     // According to Sieve of sundaram If marked[i] is false    // then 2*i + 1 is a prime number.     // loop to check all  prime numbers and their rotations    for (int i = 1; i <= nNew; i++) {        // Skip this number if not prime        if (marked[i] == true)            continue;         int num = 2 * i + 1;        num = Rotate(num); // function for rotation of prime         // now we check for rotations of this prime number        // if new rotation is prime check next rotation,        // till new rotation becomes the actual prime number        // and if new rotation if not prime then break        while (num != 2 * i + 1) {            if (num % 2 == 0) // check for even                break;             // if rotated number is prime then rotate            // for next            if (marked[(num - 1) / 2] == false)                num = Rotate(num);            else                break;        }         // if checked number is circular prime print it        if (num == (2 * i + 1))            cout << num << " ";    }} // Sieve of Sundaram for generating prime numbervoid SieveOfSundaram(bool marked[], int nNew){    // Main logic of Sundaram. Mark all numbers of the    // form i + j + 2ij as true where 1 <= i <= j    for (int i = 1; i <= nNew; i++)        for (int j = i; (i + j + 2 * i * j) <= nNew; j++)            marked[i + j + 2 * i * j] = true;} // Rotate function to right rotate the numberint Rotate(int n){    int rem = n % 10; // find unit place number    rem *= pow(10, countDigits(n)); // to put unit place    // number as first digit.    n /= 10; // remove unit digit    n += rem; // add first digit to rest    return n;} // Function to find total number of digitsint countDigits(int n){    int digit = 0;    while (n /= 10)        digit++;    return digit;} // Driver program to test aboveint main(void){    int n = 100;    circularPrime(n);    return 0;}
// Java program to print primes smaller// than n using Sieve of Sundaram.import java.util.Arrays;class GFG {     // Print all circular primes    static void circularPrime(int n)    {        // In general Sieve of Sundaram, produces        // primes smaller than (2*x + 2) for a        // number given number x.Since we want        // primes smaller than n, we reduce n to half        int nNew = (n - 2) / 2;         // This array is used to separate numbers of the        // form i+j+2ij from others where 1 <= i <= j        boolean marked[] = new boolean[nNew + 1];         // Initialize all elements as not marked        Arrays.fill(marked, false);         SieveOfSundaram(marked, nNew);         // if n > 2 then 2 is also a circular prime        System.out.print("2 ");         // According to Sieve of sundaram If marked[i] is false        // then 2*i + 1 is a prime number.         // loop to check all prime numbers and their rotations        for (int i = 1; i <= nNew; i++) {            // Skip this number if not prime            if (marked[i] == true)                continue;             int num = 2 * i + 1;            num = Rotate(num); // function for rotation of prime             // now we check for rotations of this prime number            // if new rotation is prime check next rotation,            // till new rotation becomes the actual prime number            // and if new rotation if not prime then break            while (num != 2 * i + 1) {                if (num % 2 == 0) // check for even                    break;                 // if rotated number is prime then rotate                // for next                if (marked[(num - 1) / 2] == false)                    num = Rotate(num);                else                    break;            }             // if checked number is circular prime print it            if (num == (2 * i + 1))                System.out.print(num + " ");        }    }     // Sieve of Sundaram for generating prime number    static void SieveOfSundaram(boolean marked[], int nNew)    {        // Main logic of Sundaram. Mark all numbers of the        // form i + j + 2ij as true where 1 <= i <= j        for (int i = 1; i <= nNew; i++)            for (int j = i; (i + j + 2 * i * j) <= nNew; j++)                marked[i + j + 2 * i * j] = true;    }     // Function to find total number of digits    static int countDigits(int n)    {        int digit = 0;        while ((n /= 10) > 0)            digit++;        return digit;    }     // Rotate function to right rotate the number    static int Rotate(int n)    {        int rem = n % 10; // find unit place number        rem *= Math.pow(10, countDigits(n)); // to put unit place        // number as first digit.        n /= 10; // remove unit digit        n += rem; // add first digit to rest        return n;    }     // Driver code    public static void main(String[] args)    {        int n = 100;        circularPrime(n);    }}// This code is contributed by Anant Agarwal.
# Python3 program to print primes smaller# than n using Sieve of Sundaram. # Print all circular primesdef circularPrime(n):     # In general Sieve of Sundaram,    # produces primes smaller than    # (2*x + 2) for a number given    # number x. Since we want primes    # smaller than n, we reduce n to half    nNew = (n - 2) // 2      # This array is used to separate numbers    # of the form i+j+2ij from others    # where 1 <= i <= j    marked = [False for i in range(nNew + 1)]         SieveOfSundaram(marked, nNew)      # If n > 2 then 2 is also a    # circular prime    print("2", end = ' ')      # According to Sieve of sundaram    # If marked[i] is false then    # 2*i + 1 is a prime number.      # Loop to check all  prime numbers    # and their rotations    for i in range(1, nNew + 1):             # Skip this number if not prime        if (marked[i] == True):            continue;          num = 2 * i + 1                 # Function for rotation of prime        num = Rotate(num)                 # Now we check for rotations of this        # prime number if new rotation is        # prime check next rotation, till        # new rotation becomes the actual        # prime number and if new rotation        # if not prime then break        while (num != 2 * i + 1):                         # Check for even            if (num % 2 == 0):                break              # If rotated number is prime            # then rotate for next            if (marked[(num - 1) // 2] == False):                num = Rotate(num);            else:                break;         # If checked number is circular        # prime print it        if (num == (2 * i + 1)):            print(num, end = ' ') # Sieve of Sundaram for generating# prime numberdef SieveOfSundaram(marked, nNew):     # Main logic of Sundaram. Mark    # all numbers of the form    # i + j + 2ij as true where 1 <= i <= j    for i in range(1, nNew + 1):        j = i        while (i + j + 2 * i * j) <= nNew:            marked[i + j + 2 * i * j] = True            j += 1             # Rotate function to right rotate# the numberdef Rotate(n):         # Find unit place number    rem = n % 10         # To put unit place    rem = rem * (10 ** (countDigits(n) - 1))         # Number as first digit.    n = n // 10 # Remove unit digit    n += rem # Add first digit to rest    return n # Function to find total number of digitsdef countDigits(n):     digit = 0         while n != 0:        n = n // 10        digit += 1             return digit # Driver codeif __name__=="__main__":         n = 100         circularPrime(n) # This code is contributed by rutvik_56
// C# program to print primes smaller// than n using Sieve of Sundaram.using System; class GFG {     // Print all circular primes    static void circularPrime(int n)    {        // In general Sieve of Sundaram, produces        // primes smaller than (2*x + 2) for a        // number given number x.Since we want        // primes smaller than n, we reduce n to half        int nNew = (n - 2) / 2;         // This array is used to separate numbers of the        // form i+j+2ij from others where 1 <= i <= j        bool[] marked = new bool[nNew + 1];         // Initialize all elements as not marked        // Arrays.fill(marked, false);         SieveOfSundaram(marked, nNew);         // if n > 2 then 2 is also a circular prime        Console.Write("2 ");         // According to Sieve of sundaram If        // marked[i] is false then 2*i + 1 is a        // prime number.         // loop to check all prime numbers        // and their rotations        for (int i = 1; i <= nNew; i++) {                         // Skip this number if not prime            if (marked[i] == true)                continue;             int num = 2 * i + 1;                         // function for rotation of prime            num = Rotate(num);             // now we check for rotations of this prime number            // if new rotation is prime check next rotation,            // till new rotation becomes the actual prime number            // and if new rotation if not prime then break            while (num != 2 * i + 1) {                if (num % 2 == 0) // check for even                    break;                 // if rotated number is prime                // then rotate for next                if (marked[(num - 1) / 2] == false)                    num = Rotate(num);                else                    break;            }             // if checked number is circular prime print it            if (num == (2 * i + 1))                Console.Write(num + " ");        }    }     // Sieve of Sundaram for generating prime number    static void SieveOfSundaram(bool[] marked, int nNew)    {        // Main logic of Sundaram. Mark all numbers of the        // form i + j + 2ij as true where 1 <= i <= j        for (int i = 1; i <= nNew; i++)            for (int j = i; (i + j + 2 * i * j) <= nNew; j++)                marked[i + j + 2 * i * j] = true;    }     // Function to find total number of digits    static int countDigits(int n)    {        int digit = 0;        while ((n /= 10) > 0)            digit++;        return digit;    }     // Rotate function to right rotate the number    static int Rotate(int n)    {        // find unit place number        int rem = n % 10;                 // to put unit place        rem *= (int)Math.Pow(10, countDigits(n));                 // number as first digit.        n /= 10; // remove unit digit        n += rem; // add first digit to rest        return n;    }     // Driver code    public static void Main()    {        int n = 100;        circularPrime(n);    }} // This code is contributed by vt_m.
<?php// PHP program to print primes smaller than// n using Sieve of Sundaram. // Print all circular primesfunction circularPrime($n){    // In general Sieve of Sundaram, produces    // primes smaller than (2*x + 2) for a number    // given number x. Since we want primes smaller    // than n, we reduce n to half    $nNew = (int)(($n - 2) / 2);     // This array is used to separate numbers of    // the form i+j+2ij from others where 1 <= i <= j    $marked = array_fill(0, $nNew + 1, false);     SieveOfSundaram($marked, $nNew);     // if n > 2 then 2 is also a circular prime    print("2 ");     // According to Sieve of sundaram If marked[i]    // is false then 2*i + 1 is a prime number.     // loop to check all prime numbers    // and their rotations    for ($i = 1; $i <= $nNew; $i++)    {        // Skip this number if not prime        if ($marked[$i] == true)            continue;         $num = 2 * $i + 1;        $num = Rotate($num); // function for rotation of prime         // now we check for rotations of this        // prime number if new rotation is prime        // check next rotation, till new rotation        // becomes the actual prime number and if        // new rotation if not prime then break        while ($num != 2 * $i + 1)        {            if ($num % 2 == 0) // check for even                break;             // if rotated number is prime then            // rotate for next            if ($marked[(int)(($num - 1) / 2)] == false)                $num = Rotate($num);            else                break;        }         // if checked number is circular        // prime print it        if ($num == (2 * $i + 1))            print($num." ");    }} // Sieve of Sundaram for generating prime numberfunction SieveOfSundaram(&$marked, $nNew){    // Main logic of Sundaram. Mark all numbers of the    // form i + j + 2ij as true where 1 <= i <= j    for ($i = 1; $i <= $nNew; $i++)        for ($j = $i;            ($i + $j + 2 * $i * $j) <= $nNew; $j++)            $marked[$i + $j + 2 * $i * $j] = true;} // Rotate function to right rotate the numberfunction Rotate($n){    $rem = $n % 10; // find unit place number    $rem *= pow(10, countDigits($n)); // to put unit place    // number as first digit.    $n = (int)($n / 10); // remove unit digit    $n += $rem; // add first digit to rest    return $n;} // Function to find total number of digitsfunction countDigits($n){    $digit = 0;    $n = (int)($n / 10);    while ($n)    {        $digit++;        $n = (int)($n / 10);    }    return $digit;} // Driver Code$n = 100;circularPrime($n); // This code is contributed by mits?>
<script> // Javascript program to print// primes smaller// than n using Sieve of Sundaram.// Print all circular primesfunction circularPrime(n){    // In general Sieve of Sundaram, produces    // primes smaller than (2*x + 2) for a    // number given number x.Since we want    // primes smaller than n, we reduce n to half    var nNew = (n - 2) / 2;         // This array is used to    // separate numbers of the    // form i+j+2ij from others    // where 1 <= i <= j    marked = Array.from({length: nNew + 1},            (_, i) => false);              SieveOfSundaram(marked, nNew);         // if n > 2 then 2 is also a circular prime    document.write("2 ");         // According to Sieve of sundaram    // If marked[i] is false    // then 2*i + 1 is a prime number.         // loop to check all prime numbers    // and their rotations    for (i = 1; i <= nNew; i++) {        // Skip this number if not prime        if (marked[i] == true)            continue;             var num = 2 * i + 1;        // function for rotation of prime        num = Rotate(num);             // now we check for rotations of        // this prime number        // if new rotation is prime check        // next rotation,        // till new rotation becomes        // the actual prime number        // and if new rotation if        // not prime then break        while (num != 2 * i + 1) {            if (num % 2 == 0) // check for even                break;                 // if rotated number is prime then rotate            // for next            if (marked[parseInt((num - 1) / 2)] == false)                num = Rotate(num);            else                break;        }             // if checked number is circular prime print it        if (num == (2 * i + 1))            document.write(num + " ");        }} // Sieve of Sundaram for generating prime numberfunction SieveOfSundaram(marked , nNew){    // Main logic of Sundaram. Mark all numbers of the// form i + j + 2ij as true where 1 <= i <= j    for (i = 1; i <= nNew; i++)        for (j = i; (i + j + 2 * i * j) <= nNew; j++)            marked[i + j + 2 * i * j] = true;} // Function to find total number of digitsfunction countDigits(n){    var digit = 0;    while ((n = parseInt(n/10)) > 0)        digit++;    return digit;} // Rotate function to right rotate the numberfunction Rotate(n){    // find unit place number    var rem = n % 10;    // to put unit place    rem *= Math.pow(10, countDigits(n));    // number as first digit.    n = parseInt(n/10) // remove unit digit    n += rem; // add first digit to rest        return n;} // Driver codevar n = 100;circularPrime(n); // This code is contributed by Amit Katiyar </script>
Output: 
2 3 5 7 11 13 17 31 37 71 73 79 97
This article is contributed by Shivam Pradhan (anuj_charm). If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above. 
vt_m
Mithun Kumar
rutvik_56
amit143katiyar
Prime Number
sieve
Mathematical
Mathematical
Prime Number
sieve
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Merge two sorted arrays
Modulo Operator (%) in C/C++ with Examples
Prime Numbers
Program to find sum of elements in a given array
Program for Decimal to Binary Conversion
Program for factorial of a number
Operators in C / C++
The Knight's tour problem | Backtracking-1
Find minimum number of coins that make a given value
Print all possible combinations of r elements in a given array of size n