prime-factoring

So the problem is: Write a program to find the nth super ugly number. Super ugly numbers are positive numbers whose all prime factors are in the given prime list primes of size k. For example, [1, 2, 4, 7, 8, 13, 14, 16, 19, 26, 28, 32] is the sequence of the first 12 super ugly numbers given primes = [2, 7, 13, 19] of size 4. So my algorithm basically finds all possible factors using the pattern they follow, pushes them to an array, sorts that array and then returns the nth value in the array. It accurately calculates all of them, however, is too slow with high nth values. My question is what

I found some Python code that claims checking primality based on Fermat's little theorem : def CheckIfProbablyPrime(x): return (2 << x - 2) % x == 1 My questions: How does it work? What's its relation to Fermat's little theorem? How accurate is this method? If it's not accurate, what's the advantage of using it? I found it here . Dan 1. How does it work? Fermat's little theorem says that if a number x is prime, then for any integer a : If we divide both sides by a , then we can re-write the equation as follows: I'm going to punt on proving how this works (your first question) because there are

The prime factors of 13195 are 5, 7, 13 and 29. What is the largest prime factor of the number 600851475143? I solved this problem on Project Euler my own way, which was slow, and then I found this solution on someone's github account. I can't figure out why it works. Why are a number of factors removed, equal to an index? Any insight? def Euler3(n=600851475143): for i in range(2,100000): while n % i == 0: n //= i if n == 1 or n == i: return i This function works by finding successive factors of its input. The first factor it finds will necessarily be prime. After a prime factor is found, it

This question already has answers here : Closed 6 years ago . Possible Duplicate: A number as it’s prime number parts I have this homework assignment of mine, hard as hell, where I have to get all the distinct prime partitions of a given number. For example, number 7 has five different prime partitions (or five different ways of representing the 2 prime partitions it has): 5 + 2 2 + 5 3 + 2 + 2 2 + 3 + 2 2 + 2 + 3 As you can see, the number itself is excluded in the case it's a prime. I don't have to print all the distinct partitions, only the number of them. So I'm a bit lost with this. I've

In explanations I've read about public key cryptography, it is said that some large number is come up with by multiplying together 2 extremely large primes. Since factoring the product of large primes is almost impossibly time-consuming, you have security. This seems like a problem that could be trivially solved with rainbow tables. If you know the approximate size of primes used and know there are 2 of them, you could quickly construct a rainbow table. It'd be a mighty large table, but it could be done and the task could be parallelized across hardware. Why are rainbow tables not an effective

I am trying to build a program in JAVA which uses Unique factorization theorem. I mean, get a number>1 from user and print all the unique factorization with a counter. for ex, for 100 the output should be 2 2 5 2 since 100=2*2*5*5 and for 23 the output should be 23 if the input is 6, the output will be 2 3 and last example, for 8112, output should be 2 4 3 13 2 so far, I implement a code which gives the first column and correct for prime numbers. however I did not succeed to count when counter >1 to print the second column. My code is below: int n = scanner.nextInt(); int num = 2; while (num <