int main() {
boost::timer t;
Primes p;
int max = 20;
map<int,int> factors;
for (int i = 1; i <= max; i++) {
auto curr_factors = p.prime_factors(i);
for (map<long,int>::iterator it = curr_factors.begin(); it != curr_factors.end();
++it) {
if (factors[it->first] < it->second){
factors[it->first] = it->second;
}
}
}
long product = 1;
for (map<int,int>::iterator it = factors.begin(); it != factors.end(); ++it) {
for (int i = 0; i < it->second; i++) {
product *= it->first;
}
}
cout << product << endl;
cout << t.elapsed()*1000 << "ms" << endl;
return 0;
}
bool isOddComposite(long long n, Primes primes){
if(n%2 == 0) return false;
if(primes.find(n) != primes.end()) return false;
for(long long i = 3; i < n; i+= 2){
if(n%i == 0){
//cout << "base," << n << " divite by " << i << endl;
return true;
}
}
return false;
}
int is_amicable(int n, Primes &p) {
int fac_sum1 = p.sum_proper_divisors(n);
if ( fac_sum1 <= n ) {
return 0;
}
int fac_sum2 = p.sum_proper_divisors(fac_sum1);
if (fac_sum2 == n) {
return n + fac_sum1;
}
return 0;
}
int main() {
Primes myprimes;
int num_factors = 1;
int i = 2;
int num;
while (num_factors <= 500) {
num = nth_triangular(i);
auto factors = myprimes.prime_factors(num);
num_factors = num_factors_from_prime_factors(factors);
i++;
}
cout << num << endl;
return 0;
}
int main() {
Primes p;
for (int i = 1; i < 28123; i++ ) {
cout << i << " " << p.abundance(i) << endl;
}
int sum = 0;
for (int i = 1; i <= 28123; i++ ) {
cout << i << endl;
if (!p.is_sum_of_abundant(i)) {
sum += i;
}
}
cout << sum << endl;
}
template<typename T> const std::vector<std::pair<T, unsigned int> > PrimeFactors(const T& value)
{
Primes<T> primes;
std::vector<std::pair<T, T> > result;
T remainder = value;
while (remainder > 1) {
primes.Next();
unsigned int count = 0;
while (remainder % primes.Current() == 0) {
remainder /= primes.Current();
count++;
}
if (count > 0) {
result.push_back(std::make_pair(primes.Current(), count));
}
}
return result;
}
std::vector< std::pair<int, int> > getFactors(int n){
std::vector< std::pair<int, int> > factors;
int p = 2;
do{
int multiplicity = 0;
while( n % p == 0 ){
multiplicity++;
n /= p;
}
if( multiplicity ){
factors.push_back( std::make_pair(p, multiplicity) );
}
if( g_primes.isPrime(n) ){
factors.push_back( std::make_pair(n, 1) );
break;
}
} while( (n > 1) && (p = g_primes.nextPrime(p)) );
return factors;
}
int main() {
Primes *p = new Primes();
int a = 123;
int final_digits[] = { 1,3,7,9};
for (int i = 0; i < 3; i++) {
if (p->is_prime(a*10 + final_digits[i])) {
cout << a*10 + final_digits[i] << endl;
}
}
ulong power = power_10_ceil(a);
for (int i = 1; i < 10; i++) {
if (p->is_prime(a + power*i)) {
cout << a + (power * i) << endl;
}
}
for(vector<ulong>::iterator i = p->primes_by_len[digits_in_num(a)]->begin(); i != p->primes_by_len[digits_in_num(a)]->end(); i++) {
ulong t1 = a;
ulong t2 = *i;
if (t1 > t2) {
ulong t3 = t1;
t1 = t2;
t1 = t3;
}
ulong diff = t2 - t1;
if (diff % 10 == 0 && diff > 0) {
while (diff % 10 == 0) {
diff /= 10;
}
diff = diff - (diff % 10);
if (diff == 0) {
cout << *i << endl;
}
}
};
return(0);
}
bool test(int n){
--n;
// test that its two least significant digits are 01
if( !(n & 0x1) && ( (n>>1) & 0x1) ){
// factor
std::vector<int> divs( getDivisors(n) );
std::vector<int>::iterator it;
for(it = divs.begin(); it != divs.end(); it++){
if( !g_primes.isPrime(*it + n/(*it)) ){
return false;
}
}
return true;
}
else{
return false;
bool test_get_smallest_prime_divisor(Primes pr, llint input, llint soln) {
return pr.get_smallest_prime_divisor(input) == soln;
}
bool test_is_divisible_by(Primes pr, llint num, llint denom, bool is_divisible_by) {
return pr.is_divisible_by(num, denom) == is_divisible_by;
}
bool test_is_prime(Primes pr, llint input, bool is_prime) {
return pr.is_prime(input) == is_prime;
}
