Check a number for permutable prime

Here given code implementation process.

// C program
// Check a number for permutable prime
#include <stdio.h>
#define SIZE 1000001

//Swap two elements 
void swap(int digit_num[], int i, int j)
{
	int temp = digit_num[i];
	digit_num[i] = digit_num[j];
	digit_num[j] = temp;
}
// Perform permutation of digitsnumber and 
// Check whether its is a prime or not
int permutation(int collection[], int digit_num[], int size, int n)
{
	if (n == size)
	{
        
		int num = 0;
		for (int i = 0; i < size; ++i)
		{
			num = num * 10 + digit_num[i];
		}
		if (collection[num] == 1)
		{
			return 1;
		}
		else
		{
			return 0;
		}
	}
	if (n < size)
	{
		for (int i = n; i < size; ++i)
		{
			//swap the number digit
			swap(digit_num, i, n);
			if (!permutation(collection, digit_num, size, n + 1))
			{
				return 0;
			}
			//swap the number digit
			swap(digit_num, i, n);
		}
	}
	return 1;
}
//Check whether given number is permutable prime or not
void is_permutable_prime(int collection[], int num)
{
	//indicating the status of result prime number
	int status = 0;
	//Check that given number is greater than one and number is prime
	if (num > 1 && collection[num] == 1)
	{
		//Active status
		status = 1;
		int digits = 0;
		int temp = num;
		//Count the number of digits in given number
		while (temp != 0)
		{
			digits++;
			temp /= 10;
		}
		if (digits > 1)
		{
			int digit_num[digits];
			int counter = 0;
			int single_digit = 0;
			temp = num;
			// Get digits of a number element
			// digit sequence is not important
			while (temp != 0 && status == 1)
			{
				single_digit = temp % 10;
				if (single_digit % 2 == 0)
				{
					// When digit is divisible by 2 
					// that means in permutation last digit is divisible by 2 
					// [When single digit is 0 2 4 6 8]
					status = 0;
				}
				else
				{
					digit_num[counter] = single_digit;
					temp /= 10;
					counter++;
				}
			}
			if (status == 1)
			{
				//final test
				status = permutation(collection, digit_num, digits, 0);
			}
		}
	}
	if (status == 1)
	{
		printf("\n %d Is Permutable Prime", num);
	}
	else
	{
		printf("\n %d Is Not Permutable Prime", num);
	}
}
//Find all prime numbers under 1000001 
void sieve_of_eratosthenes(int collection[])
{
	// Loop controlling variables
	int i = 0;
	int j = 1;
	// Initial two numbers are not prime (0 and 1)
	collection[i] = 0;
	collection[j] = 0;
	// Set the initial (2 to n element is prime)
	for (i = 2; i < SIZE; ++i)
	{
		collection[i] = 1;
	}
	// Initial 0 and 1 are not prime
	// We start to 2
	for (i = 2; i * i < SIZE; ++i)
	{
		if (collection[i] == 1)
		{
			//When i is prime number
			//Modify the prime status of all next multiplier of location i
			for (j = i * i; j < SIZE; j += i)
			{
				collection[j] = 0;
			}
		}
	}
}
int main()
{
	//This is used to store prime number status
	int collection[SIZE];
	//Find find prime number
	sieve_of_eratosthenes(collection);
	//Test case
	is_permutable_prime(collection, 7);
	is_permutable_prime(collection, 107);
	is_permutable_prime(collection, 13);
	is_permutable_prime(collection, 1319);
	is_permutable_prime(collection, 1531);
	is_permutable_prime(collection, 373);
	is_permutable_prime(collection, 991);
	return 0;
}

Output

 7 Is Permutable Prime
 107 Is Not Permutable Prime
 13 Is Permutable Prime
 1319 Is Not Permutable Prime
 1531 Is Not Permutable Prime
 373 Is Permutable Prime
 991 Is Permutable Prime
// Java porgram 
// Check a number for permutable prime
class PermutablePrime
{
	//Swap two elements 
	public void swap(int[] digit_num, int i, int j)
	{
		int temp = digit_num[i];
		digit_num[i] = digit_num[j];
		digit_num[j] = temp;
	}
	// Perform permutation of digitsnumber and 
	// Check whether its is a prime or not
	public boolean permutation(boolean[] collection, int[] digit_num, int size, int n)
	{
		if (n == size)
		{
			int num = 0;
			for (int i = 0; i < size; ++i)
			{
				num = num *10 + digit_num[i];
			}
			if (collection[num] == true)
			{
				return true;
			}
			else
			{
				return false;
			}
		}
		if (n < size)
		{
			for (int i = n; i < size; ++i)
			{
				//swap the number digit
				swap(digit_num, i, n);
				if (!permutation(collection, digit_num, size, n + 1))
				{
					return false;
				}
				//swap the number digit
				swap(digit_num, i, n);
			}
		}
		return true;
	}
	//Check whether given number is permutable prime or not
	public void is_permutable_prime(boolean[] collection, int num)
	{
		//indicating the status of result prime number
		boolean status = false;
		//Check that given number is greater than one and number is prime
		if (num > 1 && collection[num] == true)
		{
			//Active status
			status = true;
			int digits = 0;
			int temp = num;
			//Count the number of digits in given number
			while (temp != 0)
			{
				digits++;
				temp /= 10;
			}
			if (digits > 1)
			{
				int[] digit_num = new int[digits];
				int counter = 0;
				int single_digit = 0;
				temp = num;
				// Get digits of a number element
				// digit sequence is not important
				while (temp != 0 && status == true)
				{
					single_digit = temp % 10;
					if (single_digit % 2 == 0)
					{
						// When digit is divisible by 2 
						// that means in permutation last digit is divisible by 2 
						// [When single digit is 0 2 4 6 8]
						status = false;
					}
					else
					{
						digit_num[counter] = single_digit;
						temp /= 10;
						counter++;
					}
				}
				if (status == true)
				{
					//final test
					status = permutation(collection, digit_num, digits, 0);
				}
			}
		}
		if (status == true)
		{
			System.out.print("\n " + num +" Is Permutable Prime");
		}
		else
		{
			System.out.print("\n " + num + " Is Not Permutable Prime");
		}
	}
	//Find all prime numbers under 1000001 
	public void sieve_of_eratosthenes(boolean[] collection, int size)
	{
		// Loop controlling variables
		int i = 0;
		int j = 1;
		// Initial two numbers are not prime (0 and 1)
		collection[i] = false;
		collection[j] = false;
		// Set the initial (2 to n element is prime)
		for (i = 2; i < size; ++i)
		{
			collection[i] = true;
		}
		// Initial 0 and 1 are not prime
		// We start to 2
		for (i = 2; i *i < size; ++i)
		{
			if (collection[i] == true)
			{
				//When i is prime number
				//Modify the prime status of all next multiplier of location i
				for (j = i *i; j < size; j += i)
				{
					collection[j] = false;
				}
			}
		}
	}
	public static void main(String args[])
	{
		PermutablePrime obj = new PermutablePrime();
		int size = 1000001;
		//This is used to store prime number status
		boolean[] collection = new boolean[size];
		//Find find prime number
		obj.sieve_of_eratosthenes(collection, size);
		//Test case
		obj.is_permutable_prime(collection, 7);
		obj.is_permutable_prime(collection, 107);
		obj.is_permutable_prime(collection, 13);
		obj.is_permutable_prime(collection, 1319);
		obj.is_permutable_prime(collection, 1531);
		obj.is_permutable_prime(collection, 373);
		obj.is_permutable_prime(collection, 991);
	}
}

Output

 7 Is Permutable Prime
 107 Is Not Permutable Prime
 13 Is Permutable Prime
 1319 Is Not Permutable Prime
 1531 Is Not Permutable Prime
 373 Is Permutable Prime
 991 Is Permutable Prime
//Include header file
#include <iostream>
using namespace std;

// C++ porgram 
// Check a number for permutable prime
class PermutablePrime
{
	public:
		//Swap two elements 
		void swap(int digit_num[], int i, int j)
		{
			int temp = digit_num[i];
			digit_num[i] = digit_num[j];
			digit_num[j] = temp;
		}
	// Perform permutation of digitsnumber and 
	// Check whether its is a prime or not
	bool permutation(bool collection[], int digit_num[], int size, int n)
	{
		if (n == size)
		{
			int num = 0;
			for (int i = 0; i < size; ++i)
			{
				num = num *10 + digit_num[i];
			}
			if (collection[num] == true)
			{
				return true;
			}
			else
			{
				return false;
			}
		}
		if (n < size)
		{
			for (int i = n; i < size; ++i)
			{
				//swap the number digit
				this->swap(digit_num, i, n);
				if (!this->permutation(collection, digit_num, size, n + 1))
				{
					return false;
				}
				//swap the number digit
				this->swap(digit_num, i, n);
			}
		}
		return true;
	}
	//Check whether given number is permutable prime or not
	void is_permutable_prime(bool collection[], int num)
	{
		//indicating the status of result prime number
		bool status = false;
		//Check that given number is greater than one and number is prime
		if (num > 1 && collection[num] == true)
		{
			//Active status
			status = true;
			int digits = 0;
			int temp = num;
			//Count the number of digits in given number
			while (temp != 0)
			{
				digits++;
				temp /= 10;
			}
			if (digits > 1)
			{
				int digit_num[digits] ;
				int counter = 0;
				int single_digit = 0;
				temp = num;
				// Get digits of a number element
				// digit sequence is not important
				while (temp != 0 && status == true)
				{
					single_digit = temp % 10;
					if (single_digit % 2 == 0)
					{
						// When digit is divisible by 2 
						// that means in permutation last digit is divisible by 2 
						// [When single digit is 0 2 4 6 8]
						status = false;
					}
					else
					{
						digit_num[counter] = single_digit;
						temp /= 10;
						counter++;
					}
				}
				if (status == true)
				{
					//final test
					status = this->permutation(collection, digit_num, digits, 0);
				}
			}
		}
		if (status == true)
		{
			cout << "\n " << num << " Is Permutable Prime";
		}
		else
		{
			cout << "\n " << num << " Is Not Permutable Prime";
		}
	}
	//Find all prime numbers under 1000001 
	void sieve_of_eratosthenes(bool collection[], int size)
	{
		// Loop controlling variables
		int i = 0;
		int j = 1;
		// Initial two numbers are not prime (0 and 1)
		collection[i] = false;
		collection[j] = false;
		// Set the initial (2 to n element is prime)
		for (i = 2; i < size; ++i)
		{
			collection[i] = true;
		}
		// Initial 0 and 1 are not prime
		// We start to 2
		for (i = 2; i *i < size; ++i)
		{
			if (collection[i] == true)
			{
				//When i is prime number
				//Modify the prime status of all next multiplier of location i
				for (j = i *i; j < size; j += i)
				{
					collection[j] = false;
				}
			}
		}
	}
};
int main()
{
	PermutablePrime obj = PermutablePrime();
	int size = 1000001;
	//This is used to store prime number status
	bool collection[size] ;
	//Find find prime number
	obj.sieve_of_eratosthenes(collection, size);
	//Test case
	obj.is_permutable_prime(collection, 7);
	obj.is_permutable_prime(collection, 107);
	obj.is_permutable_prime(collection, 13);
	obj.is_permutable_prime(collection, 1319);
	obj.is_permutable_prime(collection, 1531);
	obj.is_permutable_prime(collection, 373);
	obj.is_permutable_prime(collection, 991);
	return 0;
}

Output

 7 Is Permutable Prime
 107 Is Not Permutable Prime
 13 Is Permutable Prime
 1319 Is Not Permutable Prime
 1531 Is Not Permutable Prime
 373 Is Permutable Prime
 991 Is Permutable Prime
//Include namespace system
using System;

// C# porgram 
// Check a number for permutable prime

class PermutablePrime
{
	//Swap two elements 
	public void swap(int[] digit_num, int i, int j)
	{
		int temp = digit_num[i];
		digit_num[i] = digit_num[j];
		digit_num[j] = temp;
	}
	// Perform permutation of digitsnumber and 
	// Check whether its is a prime or not
	public Boolean permutation(Boolean[] collection, int[] digit_num, int size, int n)
	{
		if (n == size)
		{
			int num = 0;
			for (int i = 0; i < size; ++i)
			{
				num = num * 10 + digit_num[i];
			}
			if (collection[num] == true)
			{
				return true;
			}
			else
			{
				return false;
			}
		}
		if (n < size)
		{
			for (int i = n; i < size; ++i)
			{
				//swap the number digit
				swap(digit_num, i, n);
				if (!permutation(collection, digit_num, size, n + 1))
				{
					return false;
				}
				//swap the number digit
				swap(digit_num, i, n);
			}
		}
		return true;
	}
	//Check whether given number is permutable prime or not
	public void is_permutable_prime(Boolean[] collection, int num)
	{
		//indicating the status of result prime number
		Boolean status = false;
		//Check that given number is greater than one and number is prime
		if (num > 1 && collection[num] == true)
		{
			//Active status
			status = true;
			int digits = 0;
			int temp = num;
			//Count the number of digits in given number
			while (temp != 0)
			{
				digits++;
				temp /= 10;
			}
			if (digits > 1)
			{
				int[] digit_num = new int[digits];
				int counter = 0;
				int single_digit = 0;
				temp = num;
				// Get digits of a number element
				// digit sequence is not important
				while (temp != 0 && status == true)
				{
					single_digit = temp % 10;
					if (single_digit % 2 == 0)
					{
						// When digit is divisible by 2 
						// that means in permutation last digit is divisible by 2 
						// [When single digit is 0 2 4 6 8]
						status = false;
					}
					else
					{
						digit_num[counter] = single_digit;
						temp /= 10;
						counter++;
					}
				}
				if (status == true)
				{
					//final test
					status = permutation(collection, digit_num, digits, 0);
				}
			}
		}
		if (status == true)
		{
			Console.Write("\n " + num + " Is Permutable Prime");
		}
		else
		{
			Console.Write("\n " + num + " Is Not Permutable Prime");
		}
	}
	//Find all prime numbers under 1000001 
	public void sieve_of_eratosthenes(Boolean[] collection, int size)
	{
		// Loop controlling variables
		int i = 0;
		int j = 1;
		// Initial two numbers are not prime (0 and 1)
		collection[i] = false;
		collection[j] = false;
		// Set the initial (2 to n element is prime)
		for (i = 2; i < size; ++i)
		{
			collection[i] = true;
		}
		// Initial 0 and 1 are not prime
		// We start to 2
		for (i = 2; i * i < size; ++i)
		{
			if (collection[i] == true)
			{
				//When i is prime number
				//Modify the prime status of all next multiplier of location i
				for (j = i * i; j < size; j += i)
				{
					collection[j] = false;
				}
			}
		}
	}
	public static void Main(String []args)
	{
		PermutablePrime obj = new PermutablePrime();
		int size = 1000001;
		//This is used to store prime number status
		Boolean[] collection = new Boolean[size];
		//Find find prime number
		obj.sieve_of_eratosthenes(collection, size);
		//Test case
		obj.is_permutable_prime(collection, 7);
		obj.is_permutable_prime(collection, 107);
		obj.is_permutable_prime(collection, 13);
		obj.is_permutable_prime(collection, 1319);
		obj.is_permutable_prime(collection, 1531);
		obj.is_permutable_prime(collection, 373);
		obj.is_permutable_prime(collection, 991);
	}
}

Output

 7 Is Permutable Prime
 107 Is Not Permutable Prime
 13 Is Permutable Prime
 1319 Is Not Permutable Prime
 1531 Is Not Permutable Prime
 373 Is Permutable Prime
 991 Is Permutable Prime
<?php
// Php porgram 
// Check a number for permutable prime
class PermutablePrime
{
    //Swap two elements 
    public  function swap( & $digit_num, $i, $j)
    {
        $temp = $digit_num[$i];
        $digit_num[$i] = $digit_num[$j];
        $digit_num[$j] = $temp;
    }
    // Perform permutation of digitsnumber and 
    // Check whether its is a prime or not
    public  function permutation( & $collection, & $digit_num, $size, $n)
    {
        if ($n == $size)
        {
            $num = 0;
            for ($i = 0; $i < $size; ++$i)
            {
                $num = $num * 10 + $digit_num[$i];
            }
            if ($collection[$num] == true)
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        if ($n < $size)
        {
            for ($i = $n; $i < $size; ++$i)
            {
                //swap the number digit
                $this->swap($digit_num, $i, $n);
                if (!$this->permutation($collection, $digit_num, $size, $n + 1))
                {
                    return false;
                }
                //swap the number digit
                $this->swap($digit_num, $i, $n);
            }
        }
        return true;
    }
    //Check whether given number is permutable prime or not
    public  function is_permutable_prime( & $collection, $num)
    {
        //indicating the status of result prime number
        $status = false;
        //Check that given number is greater than one and number is prime
        if ($num > 1 && $collection[$num] == true)
        {
            //Active status
            $status = true;
            $digits = 0;
            $temp = $num;
            //Count the number of digits in given number
            while ($temp != 0)
            {
                $digits++;
                $temp = intval($temp / 10);
            }
            if ($digits > 1)
            {
                $digit_num = array_fill(0, $digits, 0);
                $counter = 0;
                $single_digit = 0;
                $temp = $num;
                // Get digits of a number element
                // digit sequence is not important
                while ($temp != 0 && $status == true)
                {
                    $single_digit = $temp % 10;
                    if ($single_digit % 2 == 0)
                    {
                        // When digit is divisible by 2 
                        // that means in permutation last digit is divisible by 2 
                        // [When single digit is 0 2 4 6 8]
                        $status = false;
                    }
                    else
                    {
                        $digit_num[$counter] = $single_digit;
                        $temp = intval($temp / 10);
                        $counter++;
                    }
                }
                if ($status == true)
                {
                    //final test
                    $status = $this->permutation($collection, $digit_num, $digits, 0);
                }
            }
        }
        if ($status == true)
        {
            echo "\n ". $num ." Is Permutable Prime";
        }
        else
        {
            echo "\n ". $num ." Is Not Permutable Prime";
        }
    }
    //Find all prime numbers under 1000001 
    public  function sieve_of_eratosthenes( & $collection, $size)
    {
        // Loop controlling variables
        $i = 0;
        $j = 1;
        // Initial two numbers are not prime (0 and 1)
        $collection[$i] = false;
        $collection[$j] = false;
        // Set the initial (2 to n element is prime)
        for ($i = 2; $i < $size; ++$i)
        {
            $collection[$i] = true;
        }
        // Initial 0 and 1 are not prime
        // We start to 2
        for ($i = 2; $i * $i < $size; ++$i)
        {
            if ($collection[$i] == true)
            {
                //When i is prime number
                //Modify the prime status of all next multiplier of location i
                for ($j = $i * $i; $j < $size; $j += $i)
                {
                    $collection[$j] = false;
                }
            }
        }
    }
}

function main()
{
    $obj = new PermutablePrime();
    $size = 1000001;
    //This is used to store prime number status
    $collection = array_fill(0, $size, false);
    //Find find prime number
    $obj->sieve_of_eratosthenes($collection, $size);
    //Test case
    $obj->is_permutable_prime($collection, 7);
    $obj->is_permutable_prime($collection, 107);
    $obj->is_permutable_prime($collection, 13);
    $obj->is_permutable_prime($collection, 1319);
    $obj->is_permutable_prime($collection, 1531);
    $obj->is_permutable_prime($collection, 373);
    $obj->is_permutable_prime($collection, 991);
}
main();

Output

 7 Is Permutable Prime
 107 Is Not Permutable Prime
 13 Is Permutable Prime
 1319 Is Not Permutable Prime
 1531 Is Not Permutable Prime
 373 Is Permutable Prime
 991 Is Permutable Prime
// Node Js porgram 
// Check a number for permutable prime
class PermutablePrime
{
	//Swap two elements 
	swap(digit_num, i, j)
	{
		var temp = digit_num[i];
		digit_num[i] = digit_num[j];
		digit_num[j] = temp;
	}
	// Perform permutation of digitsnumber and 
	// Check whether its is a prime or not
	permutation(collection, digit_num, size, n)
	{
		if (n == size)
		{
			var num = 0;
			for (var i = 0; i < size; ++i)
			{
				num = num * 10 + digit_num[i];
			}
			if (collection[num] == true)
			{
				return true;
			}
			else
			{
				return false;
			}
		}
		if (n < size)
		{
			for (var i = n; i < size; ++i)
			{
				//swap the number digit
				this.swap(digit_num, i, n);
				if (!this.permutation(collection, digit_num, size, n + 1))
				{
					return false;
				}
				//swap the number digit
				this.swap(digit_num, i, n);
			}
		}
		return true;
	}
	//Check whether given number is permutable prime or not
	is_permutable_prime(collection, num)
	{
		//indicating the status of result prime number
		var status = false;
		//Check that given number is greater than one and number is prime
		if (num > 1 && collection[num] == true)
		{
			//Active status
			status = true;
			var digits = 0;
			var temp = num;
			//Count the number of digits in given number
			while (temp != 0)
			{
				digits++;
				temp = parseInt(temp / 10);
			}
			if (digits > 1)
			{
				var digit_num = Array(digits).fill(0);
				var counter = 0;
				var single_digit = 0;
				temp = num;
				// Get digits of a number element
				// digit sequence is not important
				while (temp != 0 && status == true)
				{
					single_digit = temp % 10;
					if (single_digit % 2 == 0)
					{
						// When digit is divisible by 2 
						// that means in permutation last digit is divisible by 2 
						// [When single digit is 0 2 4 6 8]
						status = false;
					}
					else
					{
						digit_num[counter] = single_digit;
						temp = parseInt(temp / 10);
						counter++;
					}
				}
				if (status == true)
				{
					//final test
					status = this.permutation(collection, digit_num, digits, 0);
				}
			}
		}
		if (status == true)
		{
			process.stdout.write("\n " + num + " Is Permutable Prime");
		}
		else
		{
			process.stdout.write("\n " + num + " Is Not Permutable Prime");
		}
	}
	//Find all prime numbers under 1000001 
	sieve_of_eratosthenes(collection, size)
	{
		// Loop controlling variables
		var i = 0;
		var j = 1;
		// Initial two numbers are not prime (0 and 1)
		collection[i] = false;
		collection[j] = false;
		// Set the initial (2 to n element is prime)
		for (i = 2; i < size; ++i)
		{
			collection[i] = true;
		}
		// Initial 0 and 1 are not prime
		// We start to 2
		for (i = 2; i * i < size; ++i)
		{
			if (collection[i] == true)
			{
				//When i is prime number
				//Modify the prime status of all next multiplier of location i
				for (j = i * i; j < size; j += i)
				{
					collection[j] = false;
				}
			}
		}
	}
}

function main()
{
	var obj = new PermutablePrime();
	var size = 1000001;
	//This is used to store prime number status
	var collection = Array(size).fill(false);
	//Find find prime number
	obj.sieve_of_eratosthenes(collection, size);
	//Test case
	obj.is_permutable_prime(collection, 7);
	obj.is_permutable_prime(collection, 107);
	obj.is_permutable_prime(collection, 13);
	obj.is_permutable_prime(collection, 1319);
	obj.is_permutable_prime(collection, 1531);
	obj.is_permutable_prime(collection, 373);
	obj.is_permutable_prime(collection, 991);
}
main();

Output

 7 Is Permutable Prime
 107 Is Not Permutable Prime
 13 Is Permutable Prime
 1319 Is Not Permutable Prime
 1531 Is Not Permutable Prime
 373 Is Permutable Prime
 991 Is Permutable Prime
#  Python 3 porgram 
#  Check a number for permutable prime
class PermutablePrime :
	# Swap two elements 
	def swap(self, digit_num, i, j) :
		temp = digit_num[i]
		digit_num[i] = digit_num[j]
		digit_num[j] = temp
	
	#  Perform permutation of digitsnumber and 
	#  Check whether its is a prime or not
	def permutation(self, collection, digit_num, size, n) :
		if (n == size) :
			num = 0
			i = 0
			while (i < size) :
				num = num * 10 + digit_num[i]
				i += 1
			
			if (collection[num] == True) :
				return True
			else :
				return False
			
		
		if (n < size) :
			i = n
			while (i < size) :
				# swap the number digit
				self.swap(digit_num, i, n)
				if (not self.permutation(collection, digit_num, size, n + 1)) :
					return False
				
				# swap the number digit
				self.swap(digit_num, i, n)
				i += 1
			
		
		return True
	
	# Check whether given number is permutable prime or not
	def is_permutable_prime(self, collection, num) :
		# indicating the status of result prime number
		status = False
		# Check that given number is greater than one and number is prime
		if (num > 1 and collection[num] == True) :
			# Active status
			status = True
			digits = 0
			temp = num
			# Count the number of digits in given number
			while (temp != 0) :
				digits += 1
				temp = int(temp / 10)
			
			if (digits > 1) :
				digit_num = [0] * (digits)
				counter = 0
				single_digit = 0
				temp = num
				#  Get digits of a number element
				#  digit sequence is not important
				while (temp != 0 and status == True) :
					single_digit = temp % 10
					if (single_digit % 2 == 0) :
						#  When digit is divisible by 2 
						#  that means in permutation last digit is divisible by 2 
						#  [When single digit is 0 2 4 6 8]
						status = False
					else :
						digit_num[counter] = single_digit
						temp = int(temp / 10)
						counter += 1
					
				
				if (status == True) :
					# final test
					status = self.permutation(collection, digit_num, digits, 0)
				
			
		
		if (status == True) :
			print("\n ", num ," Is Permutable Prime", end = "")
		else :
			print("\n ", num ," Is Not Permutable Prime", end = "")
		
	
	# Find all prime numbers under 1000001 
	def sieve_of_eratosthenes(self, collection, size) :
		#  Loop controlling variables
		i = 0
		j = 1
		#  Initial two numbers are not prime (0 and 1)
		collection[i] = False
		collection[j] = False
		#  Initial 0 and 1 are not prime
		#  We start to 2
		i = 2
		while (i * i < size) :
			if (collection[i] == True) :
				# When i is prime number
				# Modify the prime status of all next multiplier of location i
				j = i * i
				while (j < size) :
					collection[j] = False
					j += i
				
			
			i += 1
		
	

def main() :
	obj = PermutablePrime()
	size = 1000001
	# This is used to store prime number status
	collection = [True] * (size)
	# Find find prime number
	obj.sieve_of_eratosthenes(collection, size)
	# Test case
	obj.is_permutable_prime(collection, 7)
	obj.is_permutable_prime(collection, 107)
	obj.is_permutable_prime(collection, 13)
	obj.is_permutable_prime(collection, 1319)
	obj.is_permutable_prime(collection, 1531)
	obj.is_permutable_prime(collection, 373)
	obj.is_permutable_prime(collection, 991)

if __name__ == "__main__": main()

Output

  7  Is Permutable Prime
  107  Is Not Permutable Prime
  13  Is Permutable Prime
  1319  Is Not Permutable Prime
  1531  Is Not Permutable Prime
  373  Is Permutable Prime
  991  Is Permutable Prime
#  Ruby porgram 
#  Check a number for permutable prime
class PermutablePrime 
	# Swap two elements 
	def swap(digit_num, i, j) 
		temp = digit_num[i]
		digit_num[i] = digit_num[j]
		digit_num[j] = temp
	end

	#  Perform permutation of digitsnumber and 
	#  Check whether its is a prime or not
	def permutation(collection, digit_num, size, n) 
		if (n == size) 
			num = 0
			i = 0
			while (i < size) 
				num = num * 10 + digit_num[i]
				i += 1
			end

			if (collection[num] == true) 
				return true
			else 
				return false
			end

		end

		if (n < size) 
			i = n
			while (i < size) 
				# swap the number digit
				self.swap(digit_num, i, n)
				if (!self.permutation(collection, digit_num, size, n + 1)) 
					return false
				end

				# swap the number digit
				self.swap(digit_num, i, n)
				i += 1
			end

		end

		return true
	end

	# Check whether given number is permutable prime or not
	def is_permutable_prime(collection, num) 
		# indicating the status of result prime number
		status = false
		# Check that given number is greater than one and number is prime
		if (num > 1 && collection[num] == true) 
			# Active status
			status = true
			digits = 0
			temp = num
			# Count the number of digits in given number
			while (temp != 0) 
				digits += 1
				temp /= 10
			end

			if (digits > 1) 
				digit_num = Array.new(digits) {0}
				counter = 0
				single_digit = 0
				temp = num
				#  Get digits of a number element
				#  digit sequence is not important
				while (temp != 0 && status == true) 
					single_digit = temp % 10
					if (single_digit % 2 == 0) 
						#  When digit is divisible by 2 
						#  that means in permutation last digit is divisible by 2 
						#  [When single digit is 0 2 4 6 8]
						status = false
					else 
						digit_num[counter] = single_digit
						temp /= 10
						counter += 1
					end

				end

				if (status == true) 
					# final test
					status = self.permutation(collection, digit_num, digits, 0)
				end

			end

		end

		if (status == true) 
			print("\n ", num ," Is Permutable Prime")
		else 
			print("\n ", num ," Is Not Permutable Prime")
		end

	end

	# Find all prime numbers under 1000001 
	def sieve_of_eratosthenes(collection, size) 
		#  Loop controlling variables
		i = 0
		j = 1
		#  Initial two numbers are not prime (0 and 1)
		collection[i] = false
		collection[j] = false
		#  Initial 0 and 1 are not prime
		#  We start to 2
		i = 2
		while (i * i < size) 
			if (collection[i] == true) 
				# When i is prime number
				# Modify the prime status of all next multiplier of location i
				j = i * i
				while (j < size) 
					collection[j] = false
					j += i
				end

			end

			i += 1
		end

	end

end

def main() 
	obj = PermutablePrime.new()
	size = 1000001
	# This is used to store prime number status
	collection = Array.new(size) {true}
	# Find find prime number
	obj.sieve_of_eratosthenes(collection, size)
	# Test case
	obj.is_permutable_prime(collection, 7)
	obj.is_permutable_prime(collection, 107)
	obj.is_permutable_prime(collection, 13)
	obj.is_permutable_prime(collection, 1319)
	obj.is_permutable_prime(collection, 1531)
	obj.is_permutable_prime(collection, 373)
	obj.is_permutable_prime(collection, 991)
end

main()

Output

 7 Is Permutable Prime
 107 Is Not Permutable Prime
 13 Is Permutable Prime
 1319 Is Not Permutable Prime
 1531 Is Not Permutable Prime
 373 Is Permutable Prime
 991 Is Permutable Prime
// Scala porgram 
// Check a number for permutable prime
class PermutablePrime
{
	//Swap two elements 
	def swap(digit_num: Array[Int], i: Int, j: Int): Unit = {
		var temp: Int = digit_num(i);
		digit_num(i) = digit_num(j);
		digit_num(j) = temp;
	}
	// Perform permutation of digitsnumber and 
	// Check whether its is a prime or not
	def permutation(collection: Array[Boolean], digit_num: Array[Int], size: Int, n: Int): Boolean = {
      	var i: Int = 0;
		if (n == size)
		{
			var num: Int = 0;
			while (i < size)
			{
				num = num * 10 + digit_num(i);
				i += 1;
			}
			if (collection(num) == true)
			{
				return true;
			}
			else
			{
				return false;
			}
		}
		if (n < size)
		{
			i = n;
			while (i < size)
			{
				//swap the number digit
				swap(digit_num, i, n);
				if (!permutation(collection, digit_num, size, n + 1))
				{
					return false;
				}
				//swap the number digit
				swap(digit_num, i, n);
				i += 1;
			}
		}
		return true;
	}
	//Check whether given number is permutable prime or not
	def is_permutable_prime(collection: Array[Boolean], num: Int): Unit = {
		//indicating the status of result prime number
		var status: Boolean = false;
		//Check that given number is greater than one and number is prime
		if (num > 1 && collection(num) == true)
		{
			//Active status
			status = true;
			var digits: Int = 0;
			var temp: Int = num;
			//Count the number of digits in given number
			while (temp != 0)
			{
				digits += 1;
				temp = (temp / 10).toInt;
			}
			if (digits > 1)
			{
				var digit_num: Array[Int] = Array.fill[Int](digits)(0);
				var counter: Int = 0;
				var single_digit: Int = 0;
				temp = num;
				// Get digits of a number element
				// digit sequence is not important
				while (temp != 0 && status == true)
				{
					single_digit = temp % 10;
					if (single_digit % 2 == 0)
					{
						// When digit is divisible by 2 
						// that means in permutation last digit is divisible by 2 
						// [When single digit is 0 2 4 6 8]
						status = false;
					}
					else
					{
						digit_num(counter) = single_digit;
						temp = (temp / 10).toInt;
						counter += 1;
					}
				}
				if (status == true)
				{
					//final test
					status = permutation(collection, digit_num, digits, 0);
				}
			}
		}
		if (status == true)
		{
			print("\n " + num + " Is Permutable Prime");
		}
		else
		{
			print("\n " + num + " Is Not Permutable Prime");
		}
	}
	//Find all prime numbers under 1000001 
	def sieve_of_eratosthenes(collection: Array[Boolean], size: Int): Unit = {
		// Loop controlling variables
		var i: Int = 0;
		var j: Int = 1;
		// Initial two numbers are not prime (0 and 1)
		collection(i) = false;
		collection(j) = false;
		// Initial 0 and 1 are not prime
		// We start to 2
		i = 2;
		while (i * i < size)
		{
			if (collection(i) == true)
			{
				//When i is prime number
				//Modify the prime status of all next multiplier of location i
				j = i * i;
				while (j < size)
				{
					collection(j) = false;
					j += i;
				}
			}
			i += 1;
		}
	}
}
object Main
{
	def main(args: Array[String]): Unit = {
		var obj: PermutablePrime = new PermutablePrime();
		var size: Int = 1000001;
		//This is used to store prime number status
		var collection: Array[Boolean] = Array.fill[Boolean](size)(true);
		//Find find prime number
		obj.sieve_of_eratosthenes(collection, size);
		//Test case
		obj.is_permutable_prime(collection, 7);
		obj.is_permutable_prime(collection, 107);
		obj.is_permutable_prime(collection, 13);
		obj.is_permutable_prime(collection, 1319);
		obj.is_permutable_prime(collection, 1531);
		obj.is_permutable_prime(collection, 373);
		obj.is_permutable_prime(collection, 991);
	}
}

Output

 7 Is Permutable Prime
 107 Is Not Permutable Prime
 13 Is Permutable Prime
 1319 Is Not Permutable Prime
 1531 Is Not Permutable Prime
 373 Is Permutable Prime
 991 Is Permutable Prime
// Swift 4 porgram 
// Check a number for permutable prime
class PermutablePrime
{
	//Swap two elements 
	func swap(_ digit_num: inout[Int], _ i: Int, _ j: Int)
	{
		let temp: Int = digit_num[i];
		digit_num[i] = digit_num[j];
		digit_num[j] = temp;
	}
	// Perform permutation of digitsnumber and 
	// Check whether its is a prime or not
	func permutation(_ collection: [Bool], _ digit_num: inout[Int], _ size: Int, _ n: Int) -> Bool
	{
      	var i: Int = 0;
		if (n == size)
		{
			var num: Int = 0;
			
			while (i < size)
			{
				num = num * 10 + digit_num[i];
				i += 1;
			}
			if (collection[num] == true)
			{
				return true;
			}
			else
			{
				return false;
			}
		}
		if (n < size)
		{
			i = n;
			while (i < size)
			{
				//swap the number digit
				self.swap(&digit_num, i, n);
				if (!self.permutation(collection, &digit_num, size, n + 1))
				{
					return false;
				}
				//swap the number digit
				self.swap(&digit_num, i, n);
				i += 1;
			}
		}
		return true;
	}
	//Check whether given number is permutable prime or not
	func is_permutable_prime(_ collection: [Bool], _ num: Int)
	{
		//indicating the status of result prime number
		var status: Bool = false;
		//Check that given number is greater than one and number is prime
		if (num > 1 && collection[num] == true)
		{
			//Active status
			status = true;
			var digits: Int = 0;
			var temp: Int = num;
			//Count the number of digits in given number
			while (temp != 0)
			{
				digits += 1;
				temp /= 10;
			}
			if (digits > 1)
			{
				var digit_num: [Int] = Array(repeating: 0, count: digits);
				var counter: Int = 0;
				var single_digit: Int = 0;
				temp = num;
				// Get digits of a number element
				// digit sequence is not important
				while (temp != 0 && status == true)
				{
			
					single_digit = temp % 10;
					if (single_digit % 2 == 0)
					{
						// When digit is divisible by 2 
						// that means in permutation last digit is divisible by 2 
						// [When single digit is 0 2 4 6 8]
						status = false;
					}
					else
					{
						digit_num[counter] = single_digit;
						temp /= 10;
						counter += 1;
					}
				}
				if (status == true)
				{
					//final test
					status = self.permutation(collection, &digit_num, digits, 0);
				}
			}
		}
		if (status == true)
		{
			print("\n ", num ," Is Permutable Prime", terminator: "");
		}
		else
		{
			print("\n ", num ," Is Not Permutable Prime", terminator: "");
		}
	}
	//Find all prime numbers under 1000001 
	func sieve_of_eratosthenes(_ collection: inout[Bool], _ size: Int)
	{
		// Loop controlling variables
		var i: Int = 0;
		var j: Int = 1;
		// Initial two numbers are not prime (0 and 1)
		collection[i] = false;
		collection[j] = false;
		// Initial 0 and 1 are not prime
		// We start to 2
		i = 2;
		while (i * i < size)
		{
			if (collection[i] == true)
			{
				//When i is prime number
				//Modify the prime status of all next multiplier of location i
				j = i * i;
				while (j < size)
				{
					collection[j] = false;
					j += i;
				}
			}
			i += 1;
		}
		
	}
}
func main()
{
	let obj: PermutablePrime = PermutablePrime();
	let size: Int = 1000001;
	//This is used to store prime number status
	var collection: [Bool] = Array(repeating: true, count: size);
	//Find find prime number
	obj.sieve_of_eratosthenes(&collection, size);
	//Test case
	obj.is_permutable_prime(collection, 7);
	obj.is_permutable_prime(collection, 107);
	obj.is_permutable_prime(collection, 13);
	obj.is_permutable_prime(collection, 1319);
	obj.is_permutable_prime(collection, 1531);
	obj.is_permutable_prime(collection, 373);
	obj.is_permutable_prime(collection, 991);
}
main();

Output

  7  Is Permutable Prime
  107  Is Not Permutable Prime
  13  Is Permutable Prime
  1319  Is Not Permutable Prime
  1531  Is Not Permutable Prime
  373  Is Permutable Prime
  991  Is Permutable Prime


Please share your knowledge to improve code and content standard. Also submit your doubts, and test case. We improve by your feedback. We will try to resolve your query as soon as possible.

New Comment







© 2021, kalkicode.com, All rights reserved