## Fastest Method to calculate 2^n Mod m where n and m are Random integers - modular-arithmetic

I was wandering if there is any possible efficient way of finding the Remainder when 2^n is divided by m where n and m are random integers. Is there any equation where I sub n and m into to give me the remainder or do we have to follow recursive methods?
Do note that I am a beginner and I'm just starting out so might not understand stuff that is too complicated.
Thanks in advance.

fkdosilovic's answer is correct but not the fastest.
His algorithm runs in O(n) time, but it is possible to achieve O(log(n)).
Since all numbers 2^n can be represented as products from a set {2^1, 2^2, 2^4, 2^8 ..., 2^floor(lg(n))}, we only need to compute these values and multiply them. E.g. 2^13 = 2^1 * 2^4 * 2^8.
Here is a python code.
def fast_powmod(n, m):
pow2 = 2
result = 1
while n > 0:
if n % 2 == 1:
result = (result * pow2) % m
pow2 = (pow2 * pow2) % m
n >>= 1
return result

Modular arithmetic for multiplication works like this:
(a * b) % x = ( (a % x) * (b % x) ) % x
Here is C++ code for that:
#include <cstdio>
#include <cstdlib>
using namespace std;
int powmod(int n, int m) {
int ret = 1;
for(int i = 0; i < n; ++i)
ret = ( (ret % m) * (2 % m) ) % m; // expression from above
return ret; // returns 2 to the power n modulo m
}
int main() {
int n, m; scanf("%d%d", &n, &m);
printf("%d\n", powmod(n, m));
return 0;
}

This javascript code handles very large values of n correctly.
function fastMod(n, m){
var pow2 = 2
var result = 1
while(n > 0){
if(n&1){
result = (result * pow2) % m
}
n/=2
pow2 = (pow2 * pow2) % m
}
console.log(result)
}
fastMod(77, 100)

Fermat's little theorem can help you in the cases where m is a prime number:
If p is a prime number, then for any integer a, the number a^p − a is an integer multiple of p.
For example, if a = 2 and p = 7, 2^7 = 128, and 128 − 2 = 7 × 18 is an integer multiple of 7.

## Related

### How many numbers with length N with K digits D consecutively

Given positive numbers N, K, D (1<= N <= 10^5, 1<=K<=N, 1<=D<=9). How many numbers with N digits are there, that have K consecutive digits D? Write the answer mod (10^9 + 7). For example: N = 4, K = 3, D = 6, there are 18 numbers: 1666, 2666, 3666, 4666, 5666, 6660, 6661, 6662, 6663, 6664, 6665, 6666, 6667, 6668, 6669, 7666, 8666 and 9666. Can we calculate the answer in O(N*K) (maybe dynamic programming)? I've tried using combination. If N = 4, K = 3, D = 6. The number I have to find is abcd. +) if (a = b = c = D), I choose digit for d. There are 10 ways (6660, 6661, 6662, 6663, 6664, 6665, 6666, 6667, 6668, 6669) +) if (b = c = d = D), I choose digit for a (a > 0). There are 9 ways (1666, 2666, 3666, 4666, 5666, 6666, 7666, 8666, 9666) But in two cases, the number 6666 is counted twice. N and K is very large, how can I count all of them?

If one is looking for a mathematical solution (vs. necessarily an algorithmic one) it's good to look at it in terms of the base cases and some formulas. They might turn out to be something you can do some kind of refactoring and get a tidy formula for. So just for the heck of it...here's a take on it that doesn't deal with the special treatment of zeros. Because that throws some wrenches in. Let's look at a couple of base cases, and call our answer F(N,K) (not considering D, as it isn't relevant to account for; but taking it as a parameter anyway.): when N = 0 You'll never find any length sequences of digits when there's no digit. F(0, K) = 0 for any K. when N = 1 Fairly obvious. If you're looking for K sequential digits in a single digit, the options are limited. Looking for more than one? No dice. F(1, K) = 0 for any K > 1 Looking for exactly one? Okay, there's one. F(1, 1) = 1 Sequences of zero sequential digits allowed? Then all ten digits are fine. F(1, 0) = 10 for N > 1 when K = 0 Basically, all N-digit numbers will qualify. So the number of possibilities meeting the bar is 10^N. (e.g. when N is 3 then 000, 001, 002, ... 999 for any D) F(N, 0) = 10^N for any N > 1 when K = 1 Possibilities meeting the condition is any number with at least one D in it. How many N-digit numbers are there which contain at least one digit D? Well, it's going to be 10^N minus all the numbers that have no instances of the digit D. 10^N - 9^N F(N, 1) = 10^N - 9^N for any N > 1 when N < K No way to get K sequential digits if N is less than K F(N, K) = 0 when N < K when N = K Only one possible way to get K sequential digits in N digits. F(N, K) = 1 when N = K when N > K Okay, we already know that N > 1 and K > 1. So this is going to be the workhorse where we hope to use subexpressions for things we've already solved. Let's start by considering popping off the digit at the head, leaving N-1 digits on the tail. If that N-1 series could achieve a series of K digits all by itself, then adding another digit will not change anything about that. That gives us a term 10 * F(N-1, K) But if our head digit is a D, that is special. Our cases will be: It might be the missing key for a series that started with K-1 instances of D, creating a full range of K. It might complete a range of K-1 instances of D, but on a case that already had a K series of adjacent D (that we thus accounted for in the above term) It might not help at all. So let's consider two separate categories of tail series: those that start with K-1 instances of D and those that do not. Let's say we have N=7 shown as D:DDDXYZ and with K=4. We subtract one from N and from K to get 6 and 3, and if we subtract them we get how many trailing any-digits (XYZ here) are allowed to vary. Our term for the union of (1) and (2) to add in is 10^((N-1)-(K-1)). Now it's time for some subtraction for our double-counts. We haven't double counted any cases that didn't start with K-1 instances of D, so we keep our attention on that (DDDXYZ). If the value in the X slot is a D then it was definitely double counted. We can subtract out the term for that as 10^(((N - 1) - 1) - (K - 1)); in this case giving us all the pairings of YZ digits you can get with X as D. (100). The last thing to get rid of are the cases where X is not a D, but in whatever that leftover after the X position there was still a K length series of D. Again we reuse our function, and subtract a term 9 * F(N - K, K, D). Paste it all together and simplify a couple of terms you get: F(N, K) = 10 * F(N-1,K,D) + 10^(N-K) - 10^(10,N-K-1) - 9 * F(N-K-1,K,D) Now we have a nice functional definition suitable for Haskelling or whatever. But I'm still awkward with that, and it's easy enough to test in C++. So here it is (assuming availability of a long integer power function): long F(int N, int K, int D) { if (N == 0) return 0; if (K > N) return 0; if (K == N) return 1; if (N == 1) { if (K == 0) return 10; if (K == 1) return 1; return 0; } if (K == 0) return power(10, N); if (K == 1) return power(10, N) - power(9, N); return ( 10 * F(N - 1, K, D) + power(10, N - K) - power(10, N - K - 1) - 9 * F(N - K - 1, K, D) ); } To double-check this against an exhaustive generator, here's a little C++ test program that builds the list of vectors that it scans using std::search_n. It checks the slow way against the fast way for N and K. I ran it from 0 to 9 for each: #include <iostream> #include <algorithm> #include <vector> using namespace std; // http://stackoverflow.com/a/1505791/211160 long power(int x, int p) { if (p == 0) return 1; if (p == 1) return x; long tmp = power(x, p/2); if (p%2 == 0) return tmp * tmp; else return x * tmp * tmp; } long F(int N, int K, int D) { if (N == 0) return 0; if (K > N) return 0; if (K == N) return 1; if (N == 1) { if (K == 0) return 10; if (K == 1) return 1; return 0; } if (K == 0) return power(10, N); if (K == 1) return power(10, N) - power(9, N); return ( 10 * F(N - 1, K, D) + power(10, N - K) - power(10, N - K - 1) - 9 * F(N - K - 1, K, D) ); } long FSlowCore(int N, int K, int D, vector<int> & digits) { if (N == 0) { if (search_n(digits.begin(), digits.end(), K, D) != end(digits)) { return 1; } else return 0; } long total = 0; digits.push_back(0); for (int curDigit = 0; curDigit <= 9; curDigit++) { total += FSlowCore(N - 1, K, D, digits); digits.back()++; } digits.pop_back(); return total; } long FSlow(int N, int K, int D) { vector<int> digits; return FSlowCore(N, K, D, digits); } bool TestF(int N, int K, int D) { long slow = FSlow(N, K, D); long fast = F(N, K, D); cout << "when N = " << N << " and K = " << K << " and D = " << D << ":\n"; cout << "Fast way gives " << fast << "\n"; cout << "Slow way gives " << slow << "\n"; cout << "\n"; return slow == fast; } int main() { for (int N = 0; N < 10; N++) { for (int K = 0; K < 10; K++) { if (!TestF(N, K, 6)) { exit(1); } } } } Of course, since it counts leading zeros it will be different from the answers you got. See the test output here in this gist. Modifying to account for the special-case zero handling is left as an exercise for the reader (as is modular arithmetic). Eliminating the zeros make it messier. Either way, this may be an avenue of attack for reducing the number of math operations even further with some transformations...perhaps.

Miquel is almost correct, but he missed a lot of cases. So, with N = 8, K = 5, and D = 6, we will need to look for those numbers that has the form: 66666xxx y66666xx xy66666x xxy66666 with additional condition that y cannot be D. So we can have our formula for this example: 66666xxx = 10^3 y66666xx = 8*10^2 // As 0 can also not be the first number xy66666x = 9*9*10 xxy66666 = 9*10*9 So, the result is 3420. For case N = 4, K = 3 and D = 6, we have 666x = 10 y666 = 8//Again, 0 is not counted! So, we have 18 cases! Note: We need to be careful that the first number cannot be 0! And we need to handle the case when D is zero too! Update Java working code, Time complexity O(N-K) static long cal(int n, int k, int d) { long Mod = 1000000007; long result = 0; for (int i = 0; i <= n - k; i++) {//For all starting positions if (i != 0 || d != 0) { int left = n - k; int upper_half = i;//Amount of digit that preceding DDD int lower_half = n - k - i;//Amount of digit following DDD long tmp = 1; if (upper_half == 1) { if (d == 0) { tmp = 9; } else { tmp = 8; } }else if(upper_half >= 2){ //The pattern is x..yDDD... tmp = (long) (9 * 9 * Math.pow(10, upper_half - 2)); } tmp *= Math.pow(10, lower_half); //System.out.println(tmp + " " + upper_half + " " + lower_half); result += tmp; result %= Mod; } } return result; } Sample Tests: N = 8, K = 5, D = 6 Output 3420 N = 4, K = 3, D = 6 Output 18 N = 4, K = 3, D = 0 Output 9

### Given an integer z<=10^100, find the smallest row of Pascal's triangle that contains z [closed]

Closed. This question does not meet Stack Overflow guidelines. It is not currently accepting answers. This question does not appear to be about programming within the scope defined in the help center. Closed 8 years ago. Improve this question How can I find an algorithm to solve this problem using C++: given an integer z<=10^100, find the smallest row of Pascal's triangle that contains the number z. 1 1 1 1 2 1 1 3 3 1 1 4 6 4 1 For example if z=6 => result is on the 4th row. Another way to describe the problem: given integer z<=10^100, find the smallest integer n: exist integer k so that C(k,n) = z. C(k,n) is combination of n things taken k at a time without repetition

EDIT This solution needs Logarithmic time, it's O(Log z). Or maybe O( (Log z)^2 ). Say you are looking for n,k where Binomial(n,k)==z for a given z. Each row has its largest value in the middle, so starting from n=0 you increase the row number, n, as long as the middle value is smaller than the given number. Actually, 10^100 isn't that big, so before row 340 you find a position n0,k0=n0/2 where the value from the triangle is larger than or equal to z: Binomial(n0,k0)>=z You walk to the left, i.e. you decrease the column number k, until eventually you find a value smaller than z. If there was a matching value in that row you would have hit it by now. k is not very large, less than 170, so this step won't be executed more often than that and does not present a performance problem. From here you walk down, increasing n. Here you will find a steadily increasing value of Binomial[n,k]. Continue with 3 until the value gets bigger than or equal to z, then goto 2. EDIT: This step 3 can loop for a very long time when the row number n is large, so instead of checking each n linearly you can do a binary search for n with Binomial(n,k) >= z > Binomial(n-1,k), then it only needs Log(n) time. A Python implementation looks like this, C++ is similar but somewhat more cumbersome because you need to use an additional library for arbitrary precision integers: # Calculate (n-k+1)* ... *n def getnk( n, k ): a = n for u in range( n-k+1, n ): a = a * u return a # Find n such that Binomial(n,k) >= z and Binomial(n-1,k) < z def find_n( z, k, n0 ): kfactorial = k for u in range(2, k): kfactorial *= u xk = z * kfactorial nk0 = getnk( n0, k ) n1=n0*2 nk1 = getnk( n1, k ) # duplicate n while the value is too small while nk1 < xk: nk0=nk1 n0=n1 n1*=2 nk1 = getnk( n1, k ) # do a binary search while n1 > n0 + 1: n2 = (n0+n1) // 2 nk2 = getnk( n2, k ) if nk2 < xk: n0 = n2 nk0 = nk2 else: n1 = n2 nk1 = nk2 return n1, nk1 // kfactorial def find_pos( z ): n=0 k=0 nk=1 # start by finding a row where the middle value is bigger than z while nk < z: # increase n n = n + 1 nk = nk * n // (n-k) if nk >= z: break # increase both n and k n = n + 1 k = k + 1 nk = nk * n // k # check all subsequent rows for a matching value while nk != z: if nk > z: # decrease k k = k - 1 nk = nk * (k+1) // (n-k) else: # increase n # either linearly # n = n + 1 # nk = nk * n // (n-k) # or using binary search: n, nk = find_n( z, k, n ) return n, k z = 56476362530291763837811509925185051642180136064700011445902684545741089307844616509330834616 print( find_pos(z) ) It should print (5864079763474581, 6)

Stirling estimation for n! can be used to find first row in triangle with binomial coefficient bigger or equal to a given x. Using this estimation we can derive lower and upper bound for and then by observation that this is the maximum coefficient in row that expands 2n: P( 2n, 0), P( 2n, 1), P( 2n, 2), ..., P( 2n, 2n -1), P( 2n, 2n) we can find first row with maximum binomial coefficient bigger or equal to a given x. This is the first row in which x can be looking for, this is not possible that x can be found in the row smaller than this. Note: this may be right hint and give an answer immediately in some cases. At the moment I cannot see other way than to start a brute force search from this row. template <class T> T binomial_coefficient(unsigned long n, unsigned long k) { unsigned long i; T b; if (0 == k || n == k) { return 1; } if (k > n) { return 0; } if (k > (n - k)) { k = n - k; } if (1 == k) { return n; } b = 1; for (i = 1; i <= k; ++i) { b *= (n - (k - i)); if (b < 0) return -1; /* Overflow */ b /= i; } return b; } Stirling: double stirling_lower_bound( int n) { double n_ = n / 2.0; double res = pow( 2.0, 2 * n_); res /= sqrt( n_ * M_PI); return res * exp( ( -1.0) / ( 6 * n_)); } double stirling_upper_bound( int n) { double n_ = n / 2.0; double res = pow( 2.0, 2 * n_) ; res /= sqrt( n_ * M_PI); return res * exp( 1.0 / ( 24 * n_)); } int stirling_estimate( double x) { int n = 1; while ( stirling_lower_bound( n) <= x) { if ( stirling_upper_bound( n) > x) return n; ++n; } return n; } usage: long int search_coefficient( unsigned long int &n, unsigned long int x) { unsigned long int k = n / 2; long long middle_coefficient = binomial_coefficient<long long>( n, k); if( middle_coefficient == x) return k; unsigned long int right = binomial_coefficient<unsigned long>( n, ++k); while ( x != right) { while( x < right || x < ( right * ( n + 1) / ( k + 1))) { right = right * ( n + 1) / ( ++k) - right; } if ( right == x) return k; right = right * ( ++n) / ( ++k); if( right > x) return -1; } return k; } /* * */ int main(int argc, char** argv) { long long x2 = 1365; unsigned long int n = stirling_estimate( x2); long int k = search_coefficient( n, x2); std::cout << "row:" << n <<", column: " << k; return 0; } output: row:15, column: 11

### Is there any quick way to determine first k digits on n^n

I am writing a program where I need to know only the first k (k can be anywhere between 1-5) numbers of another big number which can be represented as n^n where n is a very large number. Currently I am actually calculating n^n and then parsing it as a string. I wonder if there is a better more fast method exists.

There are two possibilities. If you want the first k leading digits (as in: the leading digit of 12345 is 1), then you can use the fact that n^n = 10^(n*Log10(n)) so you compute the fractional part f of n*Log10(n), and then the first k digits of 10^f will be your result. This works for numbers up to about 10^10 before round-off errors start kicking in if you use double precision. For example, for n = 2^20, f = 0.57466709..., 10^f = 3.755494... so your first 5 digits are 37554. For n = 4, f = 0.4082..., 10^f = 2.56 so your first digit is 2. If you want the first k trailing digits (as in: the trailing digit of 12345 is 5), then you can use modular arithmetic. I would use the squaring trick: factor = n mod 10^k result = 1 while (n != 0) if (n is odd) then result = (result * factor) mod 10^k factor = (factor * factor) mod 10^k n >>= 1 Taking n=2^20 as an example again, we find that result = 88576. For n=4, we have factor = 1, 4, 6 and result = 1, 1, 6 so the answer is 6.

if you mean the least significant or rightmost digits, this can be done with modular multiplication. It's O(N) complexity and doesn't require any special bignum data types. #include <cmath> #include <cstdio> //returns ((base ^ exponent) % mod) int modularExponentiation(int base, int exponent, int mod){ int result = 1; for(int i = 0; i < exponent; i++){ result = (result * base) % mod; } return result; } int firstKDigitsOfNToThePowerOfN(int k, int n){ return modularExponentiation(n, n, pow(10, k)); } int main(){ int n = 11; int result = firstKDigitsOfNToThePowerOfN(3, n); printf("%d", result); } This will print 611, the first three digits of 11^11 = 285311670611. This implementation is suitable for values of N less than sqrt(INT_MAX), which will vary but on my machine and language it's over 46,000. Furthermore, if it so happens that your INT_MAX is less than (10^k)^2, you can change modularExponentiation to handle any N that can fit in an int: int modularExponentiation(int base, int exponent, int mod){ int result = 1; for(int i = 0; i < exponent; i++){ result = (result * (base % mod)) % mod; //doesn't overflow as long as mod * mod < INT_MAX } return result; } if O(n) time is insufficient for you, we can take advantage of the property of exponentiation that A^(2*C) = (A^C)^2, and get logarithmic efficiency. //returns ((base ^ exponent) % mod) int modularExponentiation(int base, int exponent, int mod){ if (exponent == 0){return 1;} if (exponent == 1){return base % mod;} if (exponent % 2 == 1){ return ((base % mod) * modularExponentiation(base, exponent-1, mod)) % mod; } else{ int newBase = modularExponentiation(base, exponent / 2, mod); return (newBase * newBase) % mod; } }

### Sum of series: 1^1 + 2^2 + 3^3 + ... + n^n (mod m)

Can someone give me an idea of an efficient algorithm for large n (say 10^10) to find the sum of above series? Mycode is getting klilled for n= 100000 and m=200000 #include<stdio.h> int main() { int n,m,i,j,sum,t; scanf("%d%d",&n,&m); sum=0; for(i=1;i<=n;i++) { t=1; for(j=1;j<=i;j++) t=((long long)t*i)%m; sum=(sum+t)%m; } printf("%d\n",sum); }

Two notes: (a + b + c) % m is equivalent to (a % m + b % m + c % m) % m and (a * b * c) % m is equivalent to ((a % m) * (b % m) * (c % m)) % m As a result, you can calculate each term using a recursive function in O(log p): int expmod(int n, int p, int m) { if (p == 0) return 1; int nm = n % m; long long r = expmod(nm, p / 2, m); r = (r * r) % m; if (p % 2 == 0) return r; return (r * nm) % m; } And sum elements using a for loop: long long r = 0; for (int i = 1; i <= n; ++i) r = (r + expmod(i, i, m)) % m; This algorithm is O(n log n).

I think you can use Euler's theorem to avoid some exponentation, as phi(200000)=80000. Chinese remainder theorem might also help as it reduces the modulo.

You may have a look at my answer to this post. The implementation there is slightly buggy, but the idea is there. The key strategy is to find x such that n^(x-1)<m and n^x>m and repeatedly reduce n^n%m to (n^x%m)^(n/x)*n^(n%x)%m. I am sure this strategy works.

I encountered similar question recently: my 'n' is 1435, 'm' is 10^10. Here is my solution (C#): ulong n = 1435, s = 0, mod = 0; mod = ulong.Parse(Math.Pow(10, 10).ToString()); for (ulong i = 1; i <= n; { ulong summand = i; for (ulong j = 2; j <= i; j++) { summand *= i; summand = summand % mod; } s += summand; s = s % mod; } At the end 's' is equal to required number.

Are you getting killed here: for(j=1;j<=i;j++) t=((long long)t*i)%m; Exponentials mod m could be implemented using the sum of squares method. n = 10000; m = 20000; sqr = n; bit = n; sum = 0; while(bit > 0) { if(bit % 2 == 1) { sum += sqr; } sqr = (sqr * sqr) % m; bit >>= 2; }

I can't add comment, but for the Chinese remainder theorem, see http://mathworld.wolfram.com/ChineseRemainderTheorem.html formulas (4)-(6).

### Algorithm to find Largest prime factor of a number

What is the best approach to calculating the largest prime factor of a number? I'm thinking the most efficient would be the following: Find lowest prime number that divides cleanly Check if result of division is prime If not, find next lowest Go to 2. I'm basing this assumption on it being easier to calculate the small prime factors. Is this about right? What other approaches should I look into? Edit: I've now realised that my approach is futile if there are more than 2 prime factors in play, since step 2 fails when the result is a product of two other primes, therefore a recursive algorithm is needed. Edit again: And now I've realised that this does still work, because the last found prime number has to be the highest one, therefore any further testing of the non-prime result from step 2 would result in a smaller prime.

Here's the best algorithm I know of (in Python) def prime_factors(n): """Returns all the prime factors of a positive integer""" factors = [] d = 2 while n > 1: while n % d == 0: factors.append(d) n /= d d = d + 1 return factors pfs = prime_factors(1000) largest_prime_factor = max(pfs) # The largest element in the prime factor list The above method runs in O(n) in the worst case (when the input is a prime number). EDIT: Below is the O(sqrt(n)) version, as suggested in the comment. Here is the code, once more. def prime_factors(n): """Returns all the prime factors of a positive integer""" factors = [] d = 2 while n > 1: while n % d == 0: factors.append(d) n /= d d = d + 1 if d*d > n: if n > 1: factors.append(n) break return factors pfs = prime_factors(1000) largest_prime_factor = max(pfs) # The largest element in the prime factor list

Actually there are several more efficient ways to find factors of big numbers (for smaller ones trial division works reasonably well). One method which is very fast if the input number has two factors very close to its square root is known as Fermat factorisation. It makes use of the identity N = (a + b)(a - b) = a^2 - b^2 and is easy to understand and implement. Unfortunately it's not very fast in general. The best known method for factoring numbers up to 100 digits long is the Quadratic sieve. As a bonus, part of the algorithm is easily done with parallel processing. Yet another algorithm I've heard of is Pollard's Rho algorithm. It's not as efficient as the Quadratic Sieve in general but seems to be easier to implement. Once you've decided on how to split a number into two factors, here is the fastest algorithm I can think of to find the largest prime factor of a number: Create a priority queue which initially stores the number itself. Each iteration, you remove the highest number from the queue, and attempt to split it into two factors (not allowing 1 to be one of those factors, of course). If this step fails, the number is prime and you have your answer! Otherwise you add the two factors into the queue and repeat.

My answer is based on Triptych's, but improves a lot on it. It is based on the fact that beyond 2 and 3, all the prime numbers are of the form 6n-1 or 6n+1. var largestPrimeFactor; if(n mod 2 == 0) { largestPrimeFactor = 2; n = n / 2 while(n mod 2 == 0); } if(n mod 3 == 0) { largestPrimeFactor = 3; n = n / 3 while(n mod 3 == 0); } multOfSix = 6; while(multOfSix - 1 <= n) { if(n mod (multOfSix - 1) == 0) { largestPrimeFactor = multOfSix - 1; n = n / largestPrimeFactor while(n mod largestPrimeFactor == 0); } if(n mod (multOfSix + 1) == 0) { largestPrimeFactor = multOfSix + 1; n = n / largestPrimeFactor while(n mod largestPrimeFactor == 0); } multOfSix += 6; } I recently wrote a blog article explaining how this algorithm works. I would venture that a method in which there is no need for a test for primality (and no sieve construction) would run faster than one which does use those. If that is the case, this is probably the fastest algorithm here.

JavaScript code: 'option strict'; function largestPrimeFactor(val, divisor = 2) { let square = (val) => Math.pow(val, 2); while ((val % divisor) != 0 && square(divisor) <= val) { divisor++; } return square(divisor) <= val ? largestPrimeFactor(val / divisor, divisor) : val; } Usage Example: let result = largestPrimeFactor(600851475143); Here is an example of the code:

Similar to #Triptych answer but also different. In this example list or dictionary is not used. Code is written in Ruby def largest_prime_factor(number) i = 2 while number > 1 if number % i == 0 number /= i; else i += 1 end end return i end largest_prime_factor(600851475143) # => 6857

All numbers can be expressed as the product of primes, eg: 102 = 2 x 3 x 17 712 = 2 x 2 x 2 x 89 You can find these by simply starting at 2 and simply continuing to divide until the result isn't a multiple of your number: 712 / 2 = 356 .. 356 / 2 = 178 .. 178 / 2 = 89 .. 89 / 89 = 1 using this method you don't have to actually calculate any primes: they'll all be primes, based on the fact that you've already factorised the number as much as possible with all preceding numbers. number = 712; currNum = number; // the value we'll actually be working with for (currFactor in 2 .. number) { while (currNum % currFactor == 0) { // keep on dividing by this number until we can divide no more! currNum = currNum / currFactor // reduce the currNum } if (currNum == 1) return currFactor; // once it hits 1, we're done. }

//this method skips unnecessary trial divisions and makes //trial division more feasible for finding large primes public static void main(String[] args) { long n= 1000000000039L; //this is a large prime number long i = 2L; int test = 0; while (n > 1) { while (n % i == 0) { n /= i; } i++; if(i*i > n && n > 1) { System.out.println(n); //prints n if it's prime test = 1; break; } } if (test == 0) System.out.println(i-1); //prints n if it's the largest prime factor }

The simplest solution is a pair of mutually recursive functions. The first function generates all the prime numbers: Start with a list of all natural numbers greater than 1. Remove all numbers that are not prime. That is, numbers that have no prime factors (other than themselves). See below. The second function returns the prime factors of a given number n in increasing order. Take a list of all the primes (see above). Remove all the numbers that are not factors of n. The largest prime factor of n is the last number given by the second function. This algorithm requires a lazy list or a language (or data structure) with call-by-need semantics. For clarification, here is one (inefficient) implementation of the above in Haskell: import Control.Monad -- All the primes primes = 2 : filter (ap (<=) (head . primeFactors)) [3,5..] -- Gives the prime factors of its argument primeFactors = factor primes where factor [] n = [] factor xs#(p:ps) n = if p*p > n then [n] else let (d,r) = divMod n p in if r == 0 then p : factor xs d else factor ps n -- Gives the largest prime factor of its argument largestFactor = last . primeFactors Making this faster is just a matter of being more clever about detecting which numbers are prime and/or factors of n, but the algorithm stays the same.

n = abs(number); result = 1; if (n mod 2 == 0) { result = 2; while (n mod 2 = 0) n /= 2; } for(i=3; i<sqrt(n); i+=2) { if (n mod i == 0) { result = i; while (n mod i = 0) n /= i; } } return max(n,result) There are some modulo tests that are superflous, as n can never be divided by 6 if all factors 2 and 3 have been removed. You could only allow primes for i, which is shown in several other answers here. You could actually intertwine the sieve of Eratosthenes here: First create the list of integers up to sqrt(n). In the for loop mark all multiples of i up to the new sqrt(n) as not prime, and use a while loop instead. set i to the next prime number in the list. Also see this question.

I'm aware this is not a fast solution. Posting as hopefully easier to understand slow solution. public static long largestPrimeFactor(long n) { // largest composite factor must be smaller than sqrt long sqrt = (long)Math.ceil(Math.sqrt((double)n)); long largest = -1; for(long i = 2; i <= sqrt; i++) { if(n % i == 0) { long test = largestPrimeFactor(n/i); if(test > largest) { largest = test; } } } if(largest != -1) { return largest; } // number is prime return n; }

Python Iterative approach by removing all prime factors from the number def primef(n): if n <= 3: return n if n % 2 == 0: return primef(n/2) elif n % 3 ==0: return primef(n/3) else: for i in range(5, int((n)**0.5) + 1, 6): #print i if n % i == 0: return primef(n/i) if n % (i + 2) == 0: return primef(n/(i+2)) return n

I am using algorithm which continues dividing the number by it's current Prime Factor. My Solution in python 3 : def PrimeFactor(n): m = n while n%2==0: n = n//2 if n == 1: # check if only 2 is largest Prime Factor return 2 i = 3 sqrt = int(m**(0.5)) # loop till square root of number last = 0 # to store last prime Factor i.e. Largest Prime Factor while i <= sqrt : while n%i == 0: n = n//i # reduce the number by dividing it by it's Prime Factor last = i i+=2 if n> last: # the remaining number(n) is also Factor of number return n else: return last print(PrimeFactor(int(input()))) Input : 10 Output : 5 Input : 600851475143 Output : 6857

Inspired by your question I decided to implement my own version of factorization (and finding largest prime factor) in Python. Probably the simplest to implement, yet quite efficient, factoring algorithm that I know is Pollard's Rho algorithm. It has a running time of O(N^(1/4)) at most which is much more faster than time of O(N^(1/2)) for trial division algorithm. Both algos have these running times only in case of composite (non-prime) number, that's why primality test should be used to filter out prime (non-factorable) numbers. I used following algorithms in my code: Fermat Primality Test ..., Pollard's Rho Algorithm ..., Trial Division Algorithm. Fermat primality test is used before running Pollard's Rho in order to filter out prime numbers. Trial Division is used as a fallback because Pollard's Rho in very rare cases may fail to find a factor, especially for some small numbers. Obviously after fully factorizing a number into sorted list of prime factors the largest prime factor will be the last element in this list. In general case (for any random number) I don't know of any other ways to find out largest prime factor besides fully factorizing a number. As an example in my code I'm factoring first 190 fractional digits of Pi, code factorizes this number within 1 second, and shows largest prime factor which is 165 digits (545 bits) in size! Try it online! def is_fermat_probable_prime(n, *, trials = 32): # https://en.wikipedia.org/wiki/Fermat_primality_test import random if n <= 16: return n in (2, 3, 5, 7, 11, 13) for i in range(trials): if pow(random.randint(2, n - 2), n - 1, n) != 1: return False return True def pollard_rho_factor(N, *, trials = 16): # https://en.wikipedia.org/wiki/Pollard%27s_rho_algorithm import random, math for j in range(trials): i, stage, y, x = 0, 2, 1, random.randint(1, N - 2) while True: r = math.gcd(N, x - y) if r != 1: break if i == stage: y = x stage <<= 1 x = (x * x + 1) % N i += 1 if r != N: return [r, N // r] return [N] # Pollard-Rho failed def trial_division_factor(n, *, limit = None): # https://en.wikipedia.org/wiki/Trial_division fs = [] while n & 1 == 0: fs.append(2) n >>= 1 d = 3 while d * d <= n and limit is None or d <= limit: q, r = divmod(n, d) if r == 0: fs.append(d) n = q else: d += 2 if n > 1: fs.append(n) return fs def factor(n): if n <= 1: return [] if is_fermat_probable_prime(n): return [n] fs = trial_division_factor(n, limit = 1 << 12) if len(fs) >= 2: return sorted(fs[:-1] + factor(fs[-1])) fs = pollard_rho_factor(n) if len(fs) >= 2: return sorted([e1 for e0 in fs for e1 in factor(e0)]) return trial_division_factor(n) def demo(): import time, math # http://www.math.com/tables/constants/pi.htm # pi = 3. # 1415926535 8979323846 2643383279 5028841971 6939937510 5820974944 5923078164 0628620899 8628034825 3421170679 # 8214808651 3282306647 0938446095 5058223172 5359408128 4811174502 8410270193 8521105559 6446229489 5493038196 # n = first 190 fractional digits of Pi n = 1415926535_8979323846_2643383279_5028841971_6939937510_5820974944_5923078164_0628620899_8628034825_3421170679_8214808651_3282306647_0938446095_5058223172_5359408128_4811174502_8410270193_8521105559_6446229489 print('Number:', n) tb = time.time() fs = factor(n) print('All Prime Factors:', fs) print('Largest Prime Factor:', f'({math.log2(fs[-1]):.02f} bits, {len(str(fs[-1]))} digits)', fs[-1]) print('Time Elapsed:', round(time.time() - tb, 3), 'sec') if __name__ == '__main__': demo() Output: Number: 1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679821480865132823066470938446095505822317253594081284811174502841027019385211055596446229489 All Prime Factors: [3, 71, 1063541, 153422959, 332958319, 122356390229851897378935483485536580757336676443481705501726535578690975860555141829117483263572548187951860901335596150415443615382488933330968669408906073630300473] Largest Prime Factor: (545.09 bits, 165 digits) 122356390229851897378935483485536580757336676443481705501726535578690975860555141829117483263572548187951860901335596150415443615382488933330968669408906073630300473 Time Elapsed: 0.593 sec

Here is my attempt in c#. The last print out is the largest prime factor of the number. I checked and it works. namespace Problem_Prime { class Program { static void Main(string[] args) { /* The prime factors of 13195 are 5, 7, 13 and 29. What is the largest prime factor of the number 600851475143 ? */ long x = 600851475143; long y = 2; while (y < x) { if (x % y == 0) { // y is a factor of x, but is it prime if (IsPrime(y)) { Console.WriteLine(y); } x /= y; } y++; } Console.WriteLine(y); Console.ReadLine(); } static bool IsPrime(long number) { //check for evenness if (number % 2 == 0) { if (number == 2) { return true; } return false; } //don't need to check past the square root long max = (long)Math.Sqrt(number); for (int i = 3; i <= max; i += 2) { if ((number % i) == 0) { return false; } } return true; } } }

#python implementation import math n = 600851475143 i = 2 factors=set([]) while i<math.sqrt(n): while n%i==0: n=n/i factors.add(i) i+=1 factors.add(n) largest=max(factors) print factors print largest

Calculates the largest prime factor of a number using recursion in C++. The working of the code is explained below: int getLargestPrime(int number) { int factor = number; // assumes that the largest prime factor is the number itself for (int i = 2; (i*i) <= number; i++) { // iterates to the square root of the number till it finds the first(smallest) factor if (number % i == 0) { // checks if the current number(i) is a factor factor = max(i, number / i); // stores the larger number among the factors break; // breaks the loop on when a factor is found } } if (factor == number) // base case of recursion return number; return getLargestPrime(factor); // recursively calls itself }

Here is my approach to quickly calculate the largest prime factor. It is based on fact that modified x does not contain non-prime factors. To achieve that, we divide x as soon as a factor is found. Then, the only thing left is to return the largest factor. It would be already prime. The code (Haskell): f max' x i | i > x = max' | x `rem` i == 0 = f i (x `div` i) i -- Divide x by its factor | otherwise = f max' x (i + 1) -- Check for the next possible factor g x = f 2 x 2

The following C++ algorithm is not the best one, but it works for numbers under a billion and its pretty fast #include <iostream> using namespace std; // ------ is_prime ------ // Determines if the integer accepted is prime or not bool is_prime(int n){ int i,count=0; if(n==1 || n==2) return true; if(n%2==0) return false; for(i=1;i<=n;i++){ if(n%i==0) count++; } if(count==2) return true; else return false; } // ------ nextPrime ------- // Finds and returns the next prime number int nextPrime(int prime){ bool a = false; while (a == false){ prime++; if (is_prime(prime)) a = true; } return prime; } // ----- M A I N ------ int main(){ int value = 13195; int prime = 2; bool done = false; while (done == false){ if (value%prime == 0){ value = value/prime; if (is_prime(value)){ done = true; } } else { prime = nextPrime(prime); } } cout << "Largest prime factor: " << value << endl; }

Found this solution on the web by "James Wang" public static int getLargestPrime( int number) { if (number <= 1) return -1; for (int i = number - 1; i > 1; i--) { if (number % i == 0) { number = i; } } return number; }

Prime factor using sieve : #include <bits/stdc++.h> using namespace std; #define N 10001 typedef long long ll; bool visit[N]; vector<int> prime; void sieve() { memset( visit , 0 , sizeof(visit)); for( int i=2;i<N;i++ ) { if( visit[i] == 0) { prime.push_back(i); for( int j=i*2; j<N; j=j+i ) { visit[j] = 1; } } } } void sol(long long n, vector<int>&prime) { ll ans = n; for(int i=0; i<prime.size() || prime[i]>n; i++) { while(n%prime[i]==0) { n=n/prime[i]; ans = prime[i]; } } ans = max(ans, n); cout<<ans<<endl; } int main() { ll tc, n; sieve(); cin>>n; sol(n, prime); return 0; }

Guess, there is no immediate way but performing a factorization, as examples above have done, i.e. in a iteration you identify a "small" factor f of a number N, then continue with the reduced problem "find largest prime factor of N':=N/f with factor candidates >=f ". From certain size of f the expected search time is less, if you do a primality test on reduced N', which in case confirms, that your N' is already the largest prime factor of initial N.

Here is my attempt in Clojure. Only walking the odds for prime? and the primes for prime factors ie. sieve. Using lazy sequences help producing the values just before they are needed. (defn prime? ([n] (let [oddNums (iterate #(+ % 2) 3)] (prime? n (cons 2 oddNums)))) ([n [i & is]] (let [q (quot n i) r (mod n i)] (cond (< n 2) false (zero? r) false (> (* i i) n) true :else (recur n is))))) (def primes (let [oddNums (iterate #(+ % 2) 3)] (lazy-seq (cons 2 (filter prime? oddNums))))) ;; Sieve of Eratosthenes (defn sieve ([n] (sieve primes n)) ([[i & is :as ps] n] (let [q (quot n i) r (mod n i)] (cond (< n 2) nil (zero? r) (lazy-seq (cons i (sieve ps q))) (> (* i i) n) (when (> n 1) (lazy-seq [n])) :else (recur is n))))) (defn max-prime-factor [n] (last (sieve n)))

Recursion in C Algorithm could be Check if n is a factor or t Check if n is prime. If so, remember n Increment n Repeat until n > sqrt(t) Here's an example of a (tail)recursive solution to the problem in C: #include <stdio.h> #include <stdbool.h> bool is_factor(long int t, long int n){ return ( t%n == 0); } bool is_prime(long int n0, long int n1, bool acc){ if ( n1 * n1 > n0 || acc < 1 ) return acc; else return is_prime(n0, n1+2, acc && (n0%n1 != 0)); } int gpf(long int t, long int n, long int acc){ if (n * n > t) return acc; if (is_factor(t, n)){ if (is_prime(n, 3, true)) return gpf(t, n+2, n); else return gpf(t, n+2, acc); } else return gpf(t, n+2, acc); } int main(int argc, char ** argv){ printf("%d\n", gpf(600851475143, 3, 0)); return 0; } The solution is composed of three functions. One to test if the candidate is a factor, another to test if that factor is prime, and finally one to compose those two together. Some key ideas here are: 1- Stopping the recursion at sqrt(600851475143) 2- Only test odd numbers for factorness 3- Only testing candidate factors for primeness with odd numbers

It seems to me that step #2 of the algorithm given isn't going to be all that efficient an approach. You have no reasonable expectation that it is prime. Also, the previous answer suggesting the Sieve of Eratosthenes is utterly wrong. I just wrote two programs to factor 123456789. One was based on the Sieve, one was based on the following: 1) Test = 2 2) Current = Number to test 3) If Current Mod Test = 0 then 3a) Current = Current Div Test 3b) Largest = Test 3c) Goto 3. 4) Inc(Test) 5) If Current < Test goto 4 6) Return Largest This version was 90x faster than the Sieve. The thing is, on modern processors the type of operation matters far less than the number of operations, not to mention that the algorithm above can run in cache, the Sieve can't. The Sieve uses a lot of operations striking out all the composite numbers. Note, also, that my dividing out factors as they are identified reduces the space that must be tested.

Compute a list storing prime numbers first, e.g. 2 3 5 7 11 13 ... Every time you prime factorize a number, use implementation by Triptych but iterating this list of prime numbers rather than natural integers.

With Java: For int values: public static int[] primeFactors(int value) { int[] a = new int[31]; int i = 0, j; int num = value; while (num % 2 == 0) { a[i++] = 2; num /= 2; } j = 3; while (j <= Math.sqrt(num) + 1) { if (num % j == 0) { a[i++] = j; num /= j; } else { j += 2; } } if (num > 1) { a[i++] = num; } int[] b = Arrays.copyOf(a, i); return b; } For long values: static long[] getFactors(long value) { long[] a = new long[63]; int i = 0; long num = value; while (num % 2 == 0) { a[i++] = 2; num /= 2; } long j = 3; while (j <= Math.sqrt(num) + 1) { if (num % j == 0) { a[i++] = j; num /= j; } else { j += 2; } } if (num > 1) { a[i++] = num; } long[] b = Arrays.copyOf(a, i); return b; }

This is probably not always faster but more optimistic about that you find a big prime divisor: N is your number If it is prime then return(N) Calculate primes up until Sqrt(N) Go through the primes in descending order (largest first) If N is divisible by Prime then Return(Prime) Edit: In step 3 you can use the Sieve of Eratosthenes or Sieve of Atkins or whatever you like, but by itself the sieve won't find you the biggest prime factor. (Thats why I wouldn't choose SQLMenace's post as an official answer...)

Here is the same function#Triptych provided as a generator, which has also been simplified slightly. def primes(n): d = 2 while (n > 1): while (n%d==0): yield d n /= d d += 1 the max prime can then be found using: n= 373764623 max(primes(n)) and a list of factors found using: list(primes(n))

I think it would be good to store somewhere all possible primes smaller then n and just iterate through them to find the biggest divisior. You can get primes from prime-numbers.org. Of course I assume that your number isn't too big :)

#include<stdio.h> #include<conio.h> #include<math.h> #include <time.h> factor(long int n) { long int i,j; while(n>=4) { if(n%2==0) { n=n/2; i=2; } else { i=3; j=0; while(j==0) { if(n%i==0) {j=1; n=n/i; } i=i+2; } i-=2; } } return i; } void main() { clock_t start = clock(); long int n,sp; clrscr(); printf("enter value of n"); scanf("%ld",&n); sp=factor(n); printf("largest prime factor is %ld",sp); printf("Time elapsed: %f\n", ((double)clock() - start) / CLOCKS_PER_SEC); getch(); }