Проверьте, является ли число простым числом
Я просто хотел бы спросить, является ли это правильным способом проверки, является ли число простым или нет? потому что я прочитал, что 0 и 1 не являются простым числом.
int num1;
Console.WriteLine("Accept number:");
num1 = Convert.ToInt32(Console.ReadLine());
if (num1 == 0 || num1 == 1)
{
Console.WriteLine(num1 + " is not prime number");
Console.ReadLine();
}
else
{
for (int a = 2; a <= num1 / 2; a++)
{
if (num1 % a == 0)
{
Console.WriteLine(num1 + " is not prime number");
return;
}
}
Console.WriteLine(num1 + " is a prime number");
Console.ReadLine();
}
32 ответа
var number;
Console.WriteLine("Accept number:");
number = Convert.ToInt32(Console.ReadLine());
if(IsPrime(number))
{
Console.WriteLine("It is prime");
}
else
{
Console.WriteLine("It is not prime");
}
public static bool IsPrime(int number)
{
if (number <= 1) return false;
if (number == 2) return true;
if (number % 2 == 0) return false;
var boundary = (int)Math.Floor(Math.Sqrt(number));
for (int i = 3; i <= boundary; i+=2)
if (number % i == 0)
return false;
return true;
}
Я изменился number / 2 в Math.Sqrt(number) потому что из википедии они сказали:
Эта процедура состоит из деления n на каждое целое число m, которое больше 1 и меньше или равно квадратному корню из n. Если результатом любого из этих делений является целое число, то n не является простым числом, в противном случае это простое число. Действительно, если n = a*b является составным (с a и b ≠ 1), то один из факторов a или b обязательно должен быть не более квадратного корня из n
Используя рутину Сонера, но с небольшим изменением: мы будем работать до i равняется Math.Ceiling(Math.Sqrt(number)) это хитрость для наивного решения:
boolean isPrime(int number)
{
if (number == 1) return false;
if (number == 2) return true;
var limit = Math.Ceiling(Math.Sqrt(number)); //hoisting the loop limit
for (int i = 2; i <= limit; ++i) {
if (number % i == 0) return false;
}
return true;
}
Вот хороший способ сделать это.
static bool IsPrime(int n)
{
if (n > 1)
{
return Enumerable.Range(1, n).Where(x => n%x == 0)
.SequenceEqual(new[] {1, n});
}
return false;
}
И быстрый способ написания вашей программы будет:
for (;;)
{
Console.Write("Accept number: ");
int n = int.Parse(Console.ReadLine());
if (IsPrime(n))
{
Console.WriteLine("{0} is a prime number",n);
}
else
{
Console.WriteLine("{0} is not a prime number",n);
}
}
Это в основном реализация блестящего предложения Эрика Липперта где-то выше.
public static bool isPrime(int number)
{
if (number == 1) return false;
if (number == 2 || number == 3 || number == 5) return true;
if (number % 2 == 0 || number % 3 == 0 || number % 5 == 0) return false;
var boundary = (int)Math.Floor(Math.Sqrt(number));
// You can do less work by observing that at this point, all primes
// other than 2 and 3 leave a remainder of either 1 or 5 when divided by 6.
// The other possible remainders have been taken care of.
int i = 6; // start from 6, since others below have been handled.
while (i <= boundary)
{
if (number % (i + 1) == 0 || number % (i + 5) == 0)
return false;
i += 6;
}
return true;
}
Я реализовал другой метод для проверки простых чисел, потому что:
- Большинство из этих решений продолжают итеративно повторять одно и то же множество (например, они проверяют 5, 10, а затем 15, что будет проверять один% на 5).
- % На 2 будет обрабатывать все четные числа (все целые числа, заканчивающиеся на 0, 2, 4, 6 или 8).
- % На 5 будет обрабатывать все кратные 5 (все целые числа, заканчивающиеся на 5).
- Осталось проверить четное деление на целые числа, оканчивающиеся на 1, 3, 7 или 9. Но прелесть в том, что мы можем увеличивать на 10 за раз вместо увеличения на 2, и я продемонстрирую решение, которое с резьбой.
- Другие алгоритмы не имеют многопоточности, поэтому они не используют ваши ядра так, как я бы надеялся.
- Мне также требовалась поддержка действительно больших простых чисел, поэтому мне нужно было использовать тип данных BigInteger вместо int, long и т. Д.
Вот моя реализация:
public static BigInteger IntegerSquareRoot(BigInteger value)
{
if (value > 0)
{
int bitLength = value.ToByteArray().Length * 8;
BigInteger root = BigInteger.One << (bitLength / 2);
while (!IsSquareRoot(value, root))
{
root += value / root;
root /= 2;
}
return root;
}
else return 0;
}
private static Boolean IsSquareRoot(BigInteger n, BigInteger root)
{
BigInteger lowerBound = root * root;
BigInteger upperBound = (root + 1) * (root + 1);
return (n >= lowerBound && n < upperBound);
}
static bool IsPrime(BigInteger value)
{
Console.WriteLine("Checking if {0} is a prime number.", value);
if (value < 3)
{
if (value == 2)
{
Console.WriteLine("{0} is a prime number.", value);
return true;
}
else
{
Console.WriteLine("{0} is not a prime number because it is below 2.", value);
return false;
}
}
else
{
if (value % 2 == 0)
{
Console.WriteLine("{0} is not a prime number because it is divisible by 2.", value);
return false;
}
else if (value == 5)
{
Console.WriteLine("{0} is a prime number.", value);
return true;
}
else if (value % 5 == 0)
{
Console.WriteLine("{0} is not a prime number because it is divisible by 5.", value);
return false;
}
else
{
// The only way this number is a prime number at this point is if it is divisible by numbers ending with 1, 3, 7, and 9.
AutoResetEvent success = new AutoResetEvent(false);
AutoResetEvent failure = new AutoResetEvent(false);
AutoResetEvent onesSucceeded = new AutoResetEvent(false);
AutoResetEvent threesSucceeded = new AutoResetEvent(false);
AutoResetEvent sevensSucceeded = new AutoResetEvent(false);
AutoResetEvent ninesSucceeded = new AutoResetEvent(false);
BigInteger squareRootedValue = IntegerSquareRoot(value);
Thread ones = new Thread(() =>
{
for (BigInteger i = 11; i <= squareRootedValue; i += 10)
{
if (value % i == 0)
{
Console.WriteLine("{0} is not a prime number because it is divisible by {1}.", value, i);
failure.Set();
}
}
onesSucceeded.Set();
});
ones.Start();
Thread threes = new Thread(() =>
{
for (BigInteger i = 3; i <= squareRootedValue; i += 10)
{
if (value % i == 0)
{
Console.WriteLine("{0} is not a prime number because it is divisible by {1}.", value, i);
failure.Set();
}
}
threesSucceeded.Set();
});
threes.Start();
Thread sevens = new Thread(() =>
{
for (BigInteger i = 7; i <= squareRootedValue; i += 10)
{
if (value % i == 0)
{
Console.WriteLine("{0} is not a prime number because it is divisible by {1}.", value, i);
failure.Set();
}
}
sevensSucceeded.Set();
});
sevens.Start();
Thread nines = new Thread(() =>
{
for (BigInteger i = 9; i <= squareRootedValue; i += 10)
{
if (value % i == 0)
{
Console.WriteLine("{0} is not a prime number because it is divisible by {1}.", value, i);
failure.Set();
}
}
ninesSucceeded.Set();
});
nines.Start();
Thread successWaiter = new Thread(() =>
{
AutoResetEvent.WaitAll(new WaitHandle[] { onesSucceeded, threesSucceeded, sevensSucceeded, ninesSucceeded });
success.Set();
});
successWaiter.Start();
int result = AutoResetEvent.WaitAny(new WaitHandle[] { success, failure });
try
{
successWaiter.Abort();
}
catch { }
try
{
ones.Abort();
}
catch { }
try
{
threes.Abort();
}
catch { }
try
{
sevens.Abort();
}
catch { }
try
{
nines.Abort();
}
catch { }
if (result == 1)
{
return false;
}
else
{
Console.WriteLine("{0} is a prime number.", value);
return true;
}
}
}
}
Обновление: если вы хотите быстрее внедрить решение с пробным делением, вы можете рассмотреть возможность использования кэша простых чисел. Число является простым, только если оно не делится на другие простые числа, которые соответствуют значению его квадратного корня. Помимо этого, вы можете рассмотреть возможность использования вероятностной версии теста первичности Миллера-Рабина, чтобы проверить примитивность числа, если вы имеете дело с достаточно большими значениями (взяты из кода Розетты на случай, если сайт когда-нибудь выйдет из строя):
// Miller-Rabin primality test as an extension method on the BigInteger type.
// Based on the Ruby implementation on this page.
public static class BigIntegerExtensions
{
public static bool IsProbablePrime(this BigInteger source, int certainty)
{
if(source == 2 || source == 3)
return true;
if(source < 2 || source % 2 == 0)
return false;
BigInteger d = source - 1;
int s = 0;
while(d % 2 == 0)
{
d /= 2;
s += 1;
}
// There is no built-in method for generating random BigInteger values.
// Instead, random BigIntegers are constructed from randomly generated
// byte arrays of the same length as the source.
RandomNumberGenerator rng = RandomNumberGenerator.Create();
byte[] bytes = new byte[source.ToByteArray().LongLength];
BigInteger a;
for(int i = 0; i < certainty; i++)
{
do
{
// This may raise an exception in Mono 2.10.8 and earlier.
// http://bugzilla.xamarin.com/show_bug.cgi?id=2761
rng.GetBytes(bytes);
a = new BigInteger(bytes);
}
while(a < 2 || a >= source - 2);
BigInteger x = BigInteger.ModPow(a, d, source);
if(x == 1 || x == source - 1)
continue;
for(int r = 1; r < s; r++)
{
x = BigInteger.ModPow(x, 2, source);
if(x == 1)
return false;
if(x == source - 1)
break;
}
if(x != source - 1)
return false;
}
return true;
}
}
Вот хороший пример. Я добавляю сюда код на случай, если сайт однажды выйдет из строя.
using System;
class Program
{
static void Main()
{
//
// Write prime numbers between 0 and 100.
//
Console.WriteLine("--- Primes between 0 and 100 ---");
for (int i = 0; i < 100; i++)
{
bool prime = PrimeTool.IsPrime(i);
if (prime)
{
Console.Write("Prime: ");
Console.WriteLine(i);
}
}
//
// Write prime numbers between 10000 and 10100
//
Console.WriteLine("--- Primes between 10000 and 10100 ---");
for (int i = 10000; i < 10100; i++)
{
if (PrimeTool.IsPrime(i))
{
Console.Write("Prime: ");
Console.WriteLine(i);
}
}
}
}
Вот класс, который содержит IsPrime метод:
using System;
public static class PrimeTool
{
public static bool IsPrime(int candidate)
{
// Test whether the parameter is a prime number.
if ((candidate & 1) == 0)
{
if (candidate == 2)
{
return true;
}
else
{
return false;
}
}
// Note:
// ... This version was changed to test the square.
// ... Original version tested against the square root.
// ... Also we exclude 1 at the end.
for (int i = 3; (i * i) <= candidate; i += 2)
{
if ((candidate % i) == 0)
{
return false;
}
}
return candidate != 1;
}
}
/***
* Check a number is prime or not
* @param n the number
* @return {@code true} if {@code n} is prime
*/
public static boolean isPrime(int n) {
if (n == 2) {
return true;
}
if (n < 2 || n % 2 == 0) {
return false;
}
for (int i = 3; i <= Math.sqrt(n); i += 2) {
if (n % i == 0) {
return false;
}
}
return true;
}
Эта версия вычисляет список простых корней квадратных корней и только проверяет, находится ли список простых чисел ниже квадратного корня, и использует двоичный поиск в списке, чтобы найти известные простые числа. Я проверил первые 1000000 простых чисел, и это заняло около 7 секунд.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ConsoleApplication5
{
class Program
{
static void Main(string[] args)
{
//test();
testMax();
Console.ReadLine();
}
static void testMax()
{
List<int> CheckPrimes = Enumerable.Range(2, 1000000).ToList();
PrimeChecker pc = new PrimeChecker(1000000);
foreach (int i in CheckPrimes)
{
if (pc.isPrime(i))
{
Console.WriteLine(i);
}
}
}
}
public class PrimeChecker{
public List<int> KnownRootPrimesList;
public int HighestKnownPrime = 3;
public PrimeChecker(int Max=1000000){
KnownRootPrimesList = new List<int>();
KnownRootPrimesList.Add(2);
KnownRootPrimesList.Add(3);
isPrime(Max);
}
public bool isPrime(int value)
{
int srt = Convert.ToInt32(Math.Ceiling(Math.Sqrt(Convert.ToDouble(value))));
if(srt > HighestKnownPrime)
{
for(int i = HighestKnownPrime + 1; i <= srt; i++)
{
if (i > HighestKnownPrime)
{
if(isPrimeCalculation(i))
{
KnownRootPrimesList.Add(i);
HighestKnownPrime = i;
}
}
}
}
bool isValuePrime = isPrimeCalculation(value);
return(isValuePrime);
}
private bool isPrimeCalculation(int value)
{
if (value < HighestKnownPrime)
{
if (KnownRootPrimesList.BinarySearch(value) > -1)
{
return (true);
}
else
{
return (false);
}
}
int srt = Convert.ToInt32(Math.Ceiling(Math.Sqrt(Convert.ToDouble(value))));
bool isPrime = true;
List<int> CheckList = KnownRootPrimesList.ToList();
if (HighestKnownPrime + 1 < srt)
{
CheckList.AddRange(Enumerable.Range(HighestKnownPrime + 1, srt));
}
foreach(int i in CheckList)
{
isPrime = ((value % i) != 0);
if(!isPrime)
{
break;
}
}
return (isPrime);
}
public bool isPrimeStandard(int value)
{
int srt = Convert.ToInt32(Math.Ceiling(Math.Sqrt(Convert.ToDouble(value))));
bool isPrime = true;
List<int> CheckList = Enumerable.Range(2, srt).ToList();
foreach (int i in CheckList)
{
isPrime = ((value % i) != 0);
if (!isPrime)
{
break;
}
}
return (isPrime);
}
}
}
Вы также можете найти диапазон простых чисел до заданного числа пользователем.
КОД:
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Input a number to find Prime numbers\n");
int inp = Convert.ToInt32(Console.ReadLine());
Console.WriteLine("\n Prime Numbers are:\n------------------------------");
int count = 0;
for (int i = 1; i <= inp; i++)
{
for (int j = 2; j < i; j++) // j=2 because if we divide any number with 1 the remaider will always 0, so skip this step to minimize time duration.
{
if (i % j != 0)
{
count += 1;
}
}
if (count == (i - 2))
{
Console.Write(i + "\t");
}
count = 0;
}
Console.ReadKey();
}
}
Вот один с объяснением:
// Checks whether the provided number is a prime number.
public static bool IsPrime(int num) {
if (num <= 1)
return false; // 1 or less is never prime.
if (num==2)
return true; // 2 is always a prime number.
// Trial Division: Tries to divide number with all of the numbers in range 1-to-square-root(number).
// If the number did not divide with the numbers in this range it will not divide with any other number therefore it's prime.
int bound = (int)Math.Floor(Math.Sqrt(num));
for (int i = 2; i<=bound; i ++) {
if (num % i == 0)
return false;
}
return true;
}
Найдите этот пример в одной книге и подумайте, что это довольно элегантное решение.
static void Main(string[] args)
{
Console.Write("Enter a number: ");
int theNum = int.Parse(Console.ReadLine());
if (theNum < 3) // special case check, less than 3
{
if (theNum == 2)
{
// The only positive number that is a prime
Console.WriteLine("{0} is a prime!", theNum);
}
else
{
// All others, including 1 and all negative numbers,
// are not primes
Console.WriteLine("{0} is not a prime", theNum);
}
}
else
{
if (theNum % 2 == 0)
{
// Is the number even? If yes it cannot be a prime
Console.WriteLine("{0} is not a prime", theNum);
}
else
{
// If number is odd, it could be a prime
int div;
// This loop starts and 3 and does a modulo operation on all
// numbers. As soon as there is no remainder, the loop stops.
// This can be true under only two circumstances: The value of
// div becomes equal to theNum, or theNum is divided evenly by
// another value.
for (div = 3; theNum % div != 0; div += 2)
; // do nothing
if (div == theNum)
{
// if theNum and div are equal it must be a prime
Console.WriteLine("{0} is a prime!", theNum);
}
else
{
// some other number divided evenly into theNum, and it is not
// itself, so it is not a prime
Console.WriteLine("{0} is not a prime", theNum);
}
}
}
Console.ReadLine();
}
Основано на ответе @Micheal, но проверяет наличие отрицательных чисел и постепенно вычисляет квадрат
public static bool IsPrime( int candidate ) {
if ( candidate % 2 <= 0 ) {
return candidate == 2;
}
int power2 = 9;
for ( int divisor = 3; power2 <= candidate; divisor += 2 ) {
if ( candidate % divisor == 0 )
return false;
power2 += divisor * 4 + 4;
}
return true;
}
Я пытаюсь получить некоторую эффективность из раннего выхода при использовании Any()...
public static bool IsPrime(long n)
{
if (n == 1) return false;
if (n == 3) return true;
//Even numbers are not primes
if (n % 2 == 0) return false;
return !Enumerable.Range(2, Convert.ToInt32(Math.Ceiling(Math.Sqrt(n))))
.Any(x => n % x == 0);
}
Версия расширения будет такой:
public static bool IsPrime(this int value)
{
if (value < 2)
return false;
else if (value == 2)
return true;
var root = Math.Sqrt(value);
for (int i = 3; i < root; i += 2)
{
if (value % i == 0)
return false;
}
return true;
}
использование
12.IsPrime() //false
13.IsPrime() //true
151.IsPrime() //true
2.IsPrime() //true
Оригинальный ответ
- Простое число нечетное, кроме 2
- Простое число не отрицательное
- 1 или 0 не являются ни простыми, ни составными
Подход
- Добавьте счетчик, чтобы проверить, сколько раз входное число делится на i (и имеет 0 (ноль) остаток)
- Если счетчик = 2, то ввод простое, иначе не простое
- Если счетчик> 2 «break», чтобы избежать ненужных процессов (если вы хотите подсчитать факторы вашего входного числа, удалите «|| counter> 2» в первом операторе if)
- Добавьте эту строку кода во второй оператор if внутри цикла for, если вы хотите увидеть, сколько чисел с остатком 0 (или присутствуют факторы):
Console.WriteLine( $" {inputNumber} / {i} = { inputNumber / i} (remainder: {inputNumber % i})" );
- Добавьте строку кода под номером 4 (в конце цикла for), чтобы увидеть все числа, разделенные на ваш входной номер (на случай, если вы хотите увидеть остаток на выходе и частное).
Console.Write( "Enter a Positive Number: " );
int inputNumber = Convert.ToInt32( Console.ReadLine() );
int counter = 0;
for ( int i = 1; i <= inputNumber; i++ ) {
if ( inputNumber == 0 || inputNumber == 1 || counter > 2 ) { break; }
if ( inputNumber % i == 0 ) { counter++; }
}
if ( counter == 2 ) {
Console.WriteLine( $"{inputNumber} is a prime number." );
} else if ( inputNumber == 1 || inputNumber == 0 ) {
Console.WriteLine( $"{inputNumber} is neither prime nor composite." );
} else {
Console.WriteLine( $"{inputNumber} is not a prime number. (It is a composite number)" );
}
Моя ссылка: https://www.tutorialspoint.com/Chash-Program-to-check-if-a-number-is-prime-or-not
Упрощенная версия:
я использовал
uint здесь вместо
int избегать
negative входы.
public bool IsPrime(uint number)
{
if (number <= 1) { return false; }
int counter = 0;
for (int i = 1; i <= number; i++)
{
if (number % i == 0) { counter++; }
if (counter > 2) { return false; }
}
return true;
}
Алгоритм в функции состоит из проверки, является ли n кратным любому целому числу от 2 до sqrt (n). Если это не так, то возвращается True, что означает, что число (n) является простым числом, в противном случае возвращается False, что означает, что n делит число, которое находится между 2 и половиной целочисленной части sqrt (n).
private static bool isPrime(int n)
{
int k = 2;
while (k * k <= n)
{
if ((n % k) == 0)
return false;
else k++;
}
return true;
}
Алгоритм в функции состоит из проверки, является ли n кратным любому целому числу от 2 до sqrt (n). Если это не так, то возвращается True, что означает, что число (n) является простым числом, в противном случае возвращается False, что означает, что n делит число, которое находится между 2 и половиной целочисленной части sqrt (n).
Рекурсивная версия
// Always call it as isPrime(n,2)
private static bool isPrime(int n, int k)
{
if (k * k <= n)
{
if ((n % k) == 0)
return false;
else return isPrime(n, k + 1);
}
else
return true;
}
Простые числа - это числа, которые больше единицы и не могут быть равномерно разделены любым другим числом, кроме 1 и самого себя.
@ Эта программа покажет вам, простое число или нет, и покажет не простое число, которое делится на (число), а не на 1 или на себя?@
Console.Write("Please Enter a number: ");
int number = int.Parse(Console.ReadLine());
int count = 2;
// this is initial count number which is greater than 1
bool prime = true;
// used Boolean value to apply condition correctly
int sqrtOfNumber = (int)Math.Sqrt(number);
// square root of input number this would help to simplify the looping.
while (prime && count <= sqrtOfNumber)
{
if ( number % count == 0)
{
Console.WriteLine($"{number} isn't prime and it divisible by
number {count}"); // this will generate a number isn't prime and it is divisible by a number which is rather than 1 or itself and this line will proves why it's not a prime number.
prime = false;
}
count++;
}
if (prime && number > 1)
{
Console.WriteLine($"{number} is a prime number");
}
else if (prime == true)
// if input is 1 or less than 1 then this code will generate
{
Console.WriteLine($"{number} isn't a prime");
}
function isPrime(n) {
//the most speedly function
var res = '';
var is_composite = false;
var err = false;
var sqrt = Math.sqrt(n);
if (n <= 1){
err = true;
}
if (n == 2 || n == 3){
res = true; //"Prime"
} else if(n % 2 == 0 || n % 3 == 0) {
res = false; //'Composite'
} else{
/*here you just neet to check dividers like (6k+1) or (6k-1)
other dividers we exclude in if(n % 2 == 0 || n % 3 == 0)*/
for(let i = 5; i <= sqrt; i += 6){
if (n % i == 0){
is_composite = true;
break;
}
}
if (!is_composite){
for(let i=7; i <= sqrt; i += 6){
if (n % i == 0){
is_composite = true;
break;
}
}
}
if (is_composite){
res = false; //'Composite'
} else {
res = true; //'Prime'
}
}
if (err) {
res = 'error';
}
return res;
}
Это может быть полезно.
boolean isPrime(int n)
{
if(n==2) return true;
if(n==1 || n%2==0) return false;
int d,root;
for(d=3,root=(int)Math.sqrt(n);d<=root && n%d!=0;d+=2);
if(d>root) return true;
return false;
}
HackerRank Challenge (время выполнения и сложность): для нескольких тестов, простое число.
Формат ввода: первая строка содержит целое число T — количество тестов. Каждая из T последующих строк содержит целое число n, которое нужно проверить на простоту.
int T = Convert.ToInt32(Console.ReadLine());
int[] ar = new int[T];
for (int i = 0; i < ar.Length; ++i)
{
ar[i] = Convert.ToInt32(Console.ReadLine());
}
List<string> result = new List<string>();
bool flag = true;
for (int r = 0; r < ar.Length; ++r)
{
for (int i =2; i < (ar[r]>1000? ar[r]/4:ar[r]); ++i)
{
if (i != 1 && i != ar[r])
{
if (ar[r] % i == 0)
{
flag = false;
break;
}
}
}
if (flag && ar[r]!=1)
result.Add("Prime");
else
{
result.Add("Not prime");
flag = true;
}
}
foreach (var a in result)
{
Console.WriteLine(a);
}
Вот версия без "беспорядка" других ответов и просто делает свое дело.
static void Main(string[] args)
{
Console.WriteLine("Enter your number: ");
int num = Convert.ToInt32(Console.ReadLine());
bool isPrime = true;
for (int i = 2; i < num/2; i++)
{
if (num % i == 0)
{
isPrime = false;
break;
}
}
if (isPrime)
Console.WriteLine("It is Prime");
else
Console.WriteLine("It is not Prime");
Console.ReadLine();
}
public bool IsPrime(int num1)
{
if (n<2)
return false;
for (int a = 2; a <= Math.Sqrt(num1); a++)
{
if (num1 % a == 0)
{
Console.WriteLine(num1 + " is not prime number");
return false;
}
}
return true;
}
Я думаю, что это простой способ для начинающих:
using System;
using System.Numerics;
public class PrimeChecker
{
public static void Main()
{
// Input
Console.WriteLine("Enter number to check is it prime: ");
BigInteger n = BigInteger.Parse(Console.ReadLine());
bool prime = false;
// Logic
if ( n==0 || n==1)
{
Console.WriteLine(prime);
}
else if ( n==2 )
{
prime = true;
Console.WriteLine(prime);
}
else if (n>2)
{
IsPrime(n, prime);
}
}
// Method
public static void IsPrime(BigInteger n, bool prime)
{
bool local = false;
for (int i=2; i<=(BigInteger)Math.Sqrt((double)n); i++)
{
if (n % i == 0)
{
local = true;
break;
}
}
if (local)
{
Console.WriteLine(prime);
}
else
{
prime = true;
Console.WriteLine(prime);
}
}
}
bool flag = false;
for (int n = 1;n < 101;n++)
{
if (n == 1 || n == 2)
{
Console.WriteLine("prime");
}
else
{
for (int i = 2; i < n; i++)
{
if (n % i == 0)
{
flag = true;
break;
}
}
}
if (flag)
{
Console.WriteLine(n+" not prime");
}
else
{
Console.WriteLine(n + " prime");
}
flag = false;
}
Console.ReadLine();
Только один код строки:
private static bool primeNumberTest(int i)
{
return i > 3 ? ( (Enumerable.Range(2, (i / 2) + 1).Where(x => (i % x == 0))).Count() > 0 ? false : true ) : i == 2 || i == 3 ? true : false;
}
Вы также можете попробовать это:
bool isPrime(int number)
{
return (Enumerable.Range(1, number).Count(x => number % x == 0) == 2);
}
Попробуйте этот код.
bool isPrimeNubmer(int n)
{
if (n == 2 || n == 3) //2, 3 are prime numbers
return true;
else if (n % 2 == 0) //even numbers are not prime numbers
return false;
else
{
int j = 3;
int k = (n + 1) / 2 ;
while (j <= k)
{
if (n % j == 0)
return false;
j = j + 2;
}
return true;
}
}
Самый короткий и быстрый способ найти простое число, используя обычную технику.
public bool IsPrimeNumber(int Number)
{
if (Number <= 1)
return false;
if (Number == 2)
return true;
if (Number % 2 == 0)
return false;
int i = 2, j = Number / 2;
for (; i <= j && Number % 2 != 0; i++);
return (i - 1) == j;
}
Это самый простой способ найти простое число
for(i=2; i<num; i++)
{
if(num%i == 0)
{
count++;
break;
}
}
if(count == 0)
{
Console.WriteLine("This is a Prime Number");
}
else
{
Console.WriteLine("This is not a Prime Number");
}
Полезная ссылка: https://codescracker.com/java/program/java-program-check-prime.htm