Pairs with common factors: Difference between revisions
m
Minor reformatting.
(Added C) |
m (Minor reformatting.) |
||
| (17 intermediate revisions by 9 users not shown) | |||
Line 1:
{{
Generate the sequence where each term '''n''' is the count of the pairs '''(x,y)''' with '''1 < x < y <= n''', that have at least one common prime factor.
Line 119:
a(100000): 1960299247
a(1000000): 196035947609
</pre>
=={{header|ALGOL W}}==
As Algol W is limited to 32 bit integers, shows a(100000) but not a(1000000).
<syntaxhighlight lang="algolw">
begin % finds integers of the sequence a(n) where a(n) is number of pairs %
% (x,y) where 1 < x < y <= n that have at least one common prime %
% factor. The sequence integers can be calculated by: %
% a(n) = n(n-1)/2 + 1 - sum i = 1..n of phi(i) where phi is Euler's %
% totient function %
% returns the number of integers k where 1 <= k <= n that are mutually %
% prime to n %
integer procedure totient ( integer value n ) ; % algorithm from the %
if n < 3 then 1 % 2nd Go Sample in the Totient function task %
else if n = 3 then 2
else begin
integer t, v, i;
t := n;
v := n;
i := 2;
while i * i <= v do begin
if v rem i = 0 then begin
while v rem i = 0 do v := v div i;
t := t - t div i
end if_v_ren_i_eq_0 ;
if i = 2 then i := 1;
i := i + 2
end while_ii_le_v ;
if v > 1 then t - t div v else t
end totient ;
integer maxNumber, totientSum, nextToShow;
maxNumber := 100000; % maximum number of terms required %
totientSum := 0; % sum of the totients 1..n %
nextToShow := 1000; % next power of 10 integer to show %
for n := 1 until maxNumber do begin
integer an;
totientSum := totientSum + totient( n );
an := ( ( ( n * ( n - 1 ) ) div 2 ) + 1 ) - totientSum;
if n <= 100 then begin
writeon( i_w := 4, s_w := 0, " ", an );
if n rem 10 = 0 then write()
end
else if n = nextToShow then begin
write( i_w := 1, s_w := 0, "a(", n, "): ", an );
nextToShow := nextToShow * 10
end if_n_le_100__n_eq_nextToShow
end for_n
end.
</syntaxhighlight>
{{out}}
<pre>
0 0 0 1 1 4 4 7 9 14
14 21 21 28 34 41 41 52 52 63
71 82 82 97 101 114 122 137 137 158
158 173 185 202 212 235 235 254 268 291
291 320 320 343 363 386 386 417 423 452
470 497 497 532 546 577 597 626 626 669
669 700 726 757 773 818 818 853 877 922
922 969 969 1006 1040 1079 1095 1148 1148 1195
1221 1262 1262 1321 1341 1384 1414 1461 1461 1526
1544 1591 1623 1670 1692 1755 1755 1810 1848 1907
a(1000): 195309
a(10000): 19597515
a(100000): 1960299247
</pre>
Line 215 ⟶ 283:
The 1,000,000th term: 196,035,947,609
</pre>
=={{header|C++}}==
<syntaxhighlight lang="c++">
#include <algorithm>
#include <cstdint>
#include <iomanip>
#include <iostream>
#include <numeric>
#include <vector>
std::vector<uint32_t> totients;
std::vector<uint32_t> primes;
void listTotients(const uint32_t& maximum) {
totients.resize(maximum + 1);
std::iota(totients.begin(), totients.end(), 0);
for ( uint32_t i = 2; i <= maximum; ++i ) {
if ( totients[i] == i ) {
totients[i] = i - 1;
for ( uint32_t j = i * 2; j <= maximum; j += i ) {
totients[j] = ( totients[j] / i ) * ( i - 1 );
}
}
}
}
void listPrimeNumbers(const uint32_t& maximum) {
const uint32_t halfMaximum = ( maximum + 1 ) / 2;
std::vector<bool> composite(halfMaximum, false);
for ( uint32_t i = 1, p = 3; i < halfMaximum; p += 2, ++i ) {
if ( ! composite[i] ) {
for ( uint32_t j = i + p; j < halfMaximum; j += p ) {
composite[j] = true;
}
}
}
primes.push_back(2);
for ( uint32_t i = 1, p = 3; i < halfMaximum; p += 2, ++i ) {
if ( ! composite[i] ) {
primes.push_back(p);
}
}
}
int main() {
const uint32_t maximum = 1'000'000;
listPrimeNumbers(maximum);
listTotients(maximum);
std::vector<uint64_t> pairsCount(maximum + 1, 0);
uint64_t totientSum = 0;
for ( uint64_t number = 1; number <= maximum; ++number ) {
totientSum += totients[number];
if ( std::binary_search(primes.begin(), primes.end(), number) ) {
pairsCount[number] = pairsCount[number - 1];
} else {
pairsCount[number] = ( number * ( number - 1 ) >> 1 ) - totientSum + 1;
}
}
std::cout << "The first one hundred terms of the number of pairs with common factors:" << std::endl;
for ( uint32_t number = 1; number <= 100; ++number ) {
std::cout << std::setw(4) << pairsCount[number] << ( ( number % 10 == 0 ) ? "\n" : " " );
}
std::cout << std::endl;
uint32_t term = 1;
while ( term <= maximum ) {
std::cout << std::left << std::setw(14)
<< "Term " + std::to_string(term) + ": " << pairsCount[term] << std::endl;
term *= 10;
}
}
</syntaxhighlight>
{{ out }}
<pre>
The first one hundred terms of the number of pairs with common factors:
0 0 0 1 1 4 4 7 9 14
14 21 21 28 34 41 41 52 52 63
71 82 82 97 101 114 122 137 137 158
158 173 185 202 212 235 235 254 268 291
291 320 320 343 363 386 386 417 423 452
470 497 497 532 546 577 597 626 626 669
669 700 726 757 773 818 818 853 877 922
922 969 969 1006 1040 1079 1095 1148 1148 1195
1221 1262 1262 1321 1341 1384 1414 1461 1461 1526
1544 1591 1623 1670 1692 1755 1755 1810 1848 1907
Term 1: 0
Term 10: 14
Term 100: 1907
Term 1000: 195309
Term 10000: 19597515
Term 100000: 1960299247
Term 1000000: 196035947609
</pre>
=={{header|EasyLang}}==
{{trans|C}}
<syntaxhighlight>
func isprim num .
if i < 2
return 0
.
i = 2
while i <= sqrt num
if num mod i = 0
return 0
.
i += 1
.
return 1
.
func totient n .
tot = n
i = 2
while i * i <= n
if n mod i = 0
repeat
n /= i
until n mod i <> 0
.
tot -= tot / i
.
if i = 2
i = 1
.
i += 2
.
if n > 1
tot -= tot / n
.
return tot
.
write "1-100:"
for n = 1 to 1000
sumPhi += totient n
if isprim n = 1
a = ap
else
a = n * (n - 1) / 2 + 1 - sumPhi
.
if n <= 100
write " " & a
.
ap = a
.
print ""
print "1000: " & a
</syntaxhighlight>
=={{header|Factor}}==
Line 323 ⟶ 544:
The 1,000,000th term: 196035947609</pre>
=={{header|Go}}==
{{trans|Wren}}
{{libheader|Go-rcu}}
<syntaxhighlight lang="go">package main
import (
"fmt"
"rcu"
)
func totient(n uint64) uint64 {
tot := n
i := uint64(2)
for i*i <= n {
if n%i == 0 {
for n%i == 0 {
n /= i
}
tot -= tot / i
}
if i == 2 {
i = 1
}
i += 2
}
if n > 1 {
tot -= tot / n
}
return tot
}
func ord(c int) string {
m := c % 100
if m >= 4 && m <= 20 {
return "th"
}
m %= 10
switch m {
case 1:
return "st"
case 2:
return "md"
case 3:
return "rd"
default:
return "th"
}
}
func main() {
const max = 1_000_000
a := make([]uint64, max)
sumPhi := uint64(0)
for n := uint64(1); n <= uint64(max); n++ {
sumPhi += totient(n)
if rcu.IsPrime(n) {
a[n-1] = a[n-2]
} else {
a[n-1] = n*(n-1)/2 + 1 - sumPhi
}
}
fmt.Println("Number of pairs with common factors - first one hundred terms:")
rcu.PrintTable(a[:100], 10, 6, true)
fmt.Println()
for limit := 1; limit <= max; limit *= 10 {
fmt.Printf("The %s%s term: %s\n", rcu.Commatize(limit), ord(limit), rcu.Commatize(a[limit-1]))
}
}</syntaxhighlight>
{{out}}
<pre>
Number of pairs with common factors - first one hundred terms:
0 0 0 1 1 4 4 7 9 14
14 21 21 28 34 41 41 52 52 63
71 82 82 97 101 114 122 137 137 158
158 173 185 202 212 235 235 254 268 291
291 320 320 343 363 386 386 417 423 452
470 497 497 532 546 577 597 626 626 669
669 700 726 757 773 818 818 853 877 922
922 969 969 1,006 1,040 1,079 1,095 1,148 1,148 1,195
1,221 1,262 1,262 1,321 1,341 1,384 1,414 1,461 1,461 1,526
1,544 1,591 1,623 1,670 1,692 1,755 1,755 1,810 1,848 1,907
The 1st term: 0
The 10th term: 14
The 100th term: 1,907
The 1,000th term: 195,309
The 10,000th term: 19,597,515
The 100,000th term: 1,960,299,247
The 1,000,000th term: 196,035,947,609
</pre>
=={{header|J}}==
Line 337 ⟶ 650:
Here, <code>p.</code> calculates a polynomial (1 + (-x)/2 + (x^2)/2 in this example), <code>5&p:</code> is euler's totient function, <code>@{:</code> modifies the polynomial to only operate on the final element of a sequence, <code>+/</code> is sum and <code>+/\</code> is running sum, and <code>1+i.n</code> is the sequence of numbers 1 through n.
=={{header|Java}}==
<syntaxhighlight lang="java">
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public final class PairsWithCommonFactors {
public static void main(String[] args) {
final int maximum = 1_000_000;
listPrimeNumbers(maximum);
listTotients(maximum);
long[] pairsCount = new long[maximum + 1];
long totientSum = 0;
for ( int number = 1; number <= maximum; number++ ) {
totientSum += totients[number];
if ( Collections.binarySearch(primes, number) > 0 ) {
pairsCount[number] = pairsCount[number - 1];
} else {
pairsCount[number] = ( (long) number * ( number - 1 ) >> 1 ) - totientSum + 1;
}
}
System.out.println("The first one hundred terms of the number of pairs with common factors:");
for ( int number = 1; number <= 100; number++ ) {
System.out.print(String.format("%4d%s", pairsCount[number], ( ( number % 10 == 0 ) ? "\n" : " " )));
}
System.out.println();
int term = 1;
while ( term <= maximum ) {
System.out.println(String.format("%-14s%s", "Term " + term + ": ", pairsCount[term]));
term *= 10;
}
}
private static void listTotients(int maximum) {
totients = new int[maximum + 1];
for ( int i = 0; i <= maximum; i++ ) {
totients[i] = i;
}
for ( int i = 2; i <= maximum; i++ ) {
if ( totients[i] == i ) {
totients[i] = i - 1;
for ( int j = i * 2; j <= maximum; j += i ) {
totients[j] = ( totients[j] / i ) * ( i - 1 );
}
}
}
}
private static void listPrimeNumbers(int maximum) {
final int halfMaximum = ( maximum + 1 ) / 2;
boolean[] composite = new boolean[halfMaximum];
for ( int i = 1, p = 3; i < halfMaximum; p += 2, i++ ) {
if ( ! composite[i] ) {
for ( int j = i + p; j < halfMaximum; j += p ) {
composite[j] = true;
}
}
}
primes = new ArrayList<Integer>(List.of( 2 ));
for ( int i = 1, p = 3; i < halfMaximum; p += 2, i++ ) {
if ( ! composite[i] ) {
primes.add(p);
}
}
}
private static int[] totients;
private static List<Integer> primes;
}
</syntaxhighlight>
{{ out }}
<pre>
The first one hundred terms of the number of pairs with common factors:
0 0 0 1 1 4 4 7 9 14
14 21 21 28 34 41 41 52 52 63
71 82 82 97 101 114 122 137 137 158
158 173 185 202 212 235 235 254 268 291
291 320 320 343 363 386 386 417 423 452
470 497 497 532 546 577 597 626 626 669
669 700 726 757 773 818 818 853 877 922
922 969 969 1006 1040 1079 1095 1148 1148 1195
1221 1262 1262 1321 1341 1384 1414 1461 1461 1526
1544 1591 1623 1670 1692 1755 1755 1810 1848 1907
Term 1: 0
Term 10: 14
Term 100: 1907
Term 1000: 195309
Term 10000: 19597515
Term 100000: 1960299247
Term 1000000: 196035947609
</pre>
=={{header|jq}}==
Line 445 ⟶ 858:
The 1,000,000th pair with common factors count is 196,035,947,609
</pre>
=={{header|Mathematica}} / {{header|Wolfram Language}}==
{{trans|Julia}}
<syntaxhighlight lang="mathematica">(* Define the prime counting function (pcf) *)
pcf[n_] := n (n - 1)/2 + 1 - Total[EulerPhi /@ Range[n]]
(* Print pairs of (n, pcf(n)) for n from 1 to 100 *)
Do[
Module[{pair = pcf[n], pairString},
pairString = ToString[StringPadRight[ToString[pair], 5]];
If[Mod[n, 20] == 0,
WriteString["stdout", pairString <> "\n"],
WriteString["stdout", pairString, " "]
]
],
{n, 1, 100}
]
(* Print the 10^expo-th pair with common factors count *)
Do[
Print["The ", ToString[NumberForm[10^expo, DigitBlock -> 3]],
"th pair with common factors count is ",
ToString[NumberForm[pcf[10^expo], DigitBlock -> 3]]],
{expo, 1, 6}
]</syntaxhighlight>
{{out}}
<pre>
0 0 0 1 1 4 4 7 9 14 14 21 21 28 34 41 41 52 52 63
71 82 82 97 101 114 122 137 137 158 158 173 185 202 212 235 235 254 268 291
291 320 320 343 363 386 386 417 423 452 470 497 497 532 546 577 597 626 626 669
669 700 726 757 773 818 818 853 877 922 922 969 969 1006 1040 1079 1095 1148 1148 1195
1221 1262 1262 1321 1341 1384 1414 1461 1461 1526 1544 1591 1623 1670 1692 1755 1755 1810 1848 1907
The 10th pair with common factors count is 14
The 100th pair with common factors count is 1,907
The 1,000th pair with common factors count is 195,309
The 10,000th pair with common factors count is 19,597,515
The 100,000th pair with common factors count is 1,960,299,247
The 1,000,000th pair with common factors count is 196,035,947,609
</pre>
=={{header|Maxima}}==
{{trans|Mathematica_/_Wolfram_Language}}
<syntaxhighlight lang="Maxima">/* Define the prime counting function (pcf) */
pcf(n) := n*(n - 1)/2 + 1 - sum(totient(i), i, 1, n);
/* Print pairs of (n, pcf(n)) for n from 1 to 100 */
for n:1 thru 100 do (
pcf_n : ev(pcf(n), numer),
if mod(n, 20) = 0 then (
printf(true, "~4d~%", pcf_n)
) else (
printf(true, "~4d ", pcf_n)
)
);
/* Print the 10^expo-th pair with common factors count */
for expo:1 thru 6 do (
pcf_10expo : ev(pcf(10^expo), numer),
printf(true, "The ~a-th pair with common factors count is ~a~%", 10^expo, pcf_10expo)
);</syntaxhighlight>
{{out}}
<pre>
0 0 0 1 1 4 4 7 9 14 14 21 21 28 34 41 41 52 52 63
71 82 82 97 101 114 122 137 137 158 158 173 185 202 212 235 235 254 268 291
291 320 320 343 363 386 386 417 423 452 470 497 497 532 546 577 597 626 626 669
669 700 726 757 773 818 818 853 877 922 922 969 969 1006 1040 1079 1095 1148 1148 1195
1221 1262 1262 1321 1341 1384 1414 1461 1461 1526 1544 1591 1623 1670 1692 1755 1755 1810 1848 1907
The 10-th pair with common factors count is 14
The 100-th pair with common factors count is 1907
The 1000-th pair with common factors count is 195309
The 10000-th pair with common factors count is 19597515
The 100000-th pair with common factors count is 1960299247
The 1000000-th pair with common factors count is 196035947609
</pre>
=={{header|Nim}}==
Line 755 ⟶ 1,245:
<!--<syntaxhighlight lang="phix">(phixonline)-->
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #008080;">constant</span> <span style="color: #000000;">limit</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">1e6</span>
<span style="color: #004080;">sequence</span> <span style="color: #000000;">a</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span><span style="color: #000000;">limit</span><span style="color: #0000FF;">)</span>
<span style="color: #004080;">atom</span> <span style="color: #000000;">sumPhi</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">limit</span> <span style="color: #008080;">do</span>
<span style="color: #000000;">sumPhi</span> <span style="color: #0000FF;">+=</span> <span style="color: #
<span style="color: #008080;">if</span> <span style="color: #7060A8;">is_prime</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">then</span>
<span style="color: #000000;">a</span><span style="color: #0000FF;">[</span><span style="color: #000000;">n</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">a</span><span style="color: #0000FF;">[</span><span style="color: #000000;">n</span><span style="color: #0000FF;">-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">]</span>
Line 814 ⟶ 1,286:
</pre>
=={{header|Quackery}}==
<code>totient</code> is defined at [[Totient function#Quackery]].
<syntaxhighlight lang="Quackery"> [] 0
1000 times
[ i^ 1+ totient +
i^ 1+ dup 1 - * 2 / 1+
over -
swap dip join ]
drop
dup -1 peek swap
100 split drop
say "First 100 terms:"
[] swap witheach
[ number$ nested join ]
60 wrap$
cr cr say "1000th term: " echo</syntaxhighlight>
{{out}}
<pre>First 100 terms:
0 0 0 1 1 4 4 7 9 14 14 21 21 28 34 41 41 52 52 63 71 82 82
97 101 114 122 137 137 158 158 173 185 202 212 235 235 254
268 291 291 320 320 343 363 386 386 417 423 452 470 497 497
532 546 577 597 626 626 669 669 700 726 757 773 818 818 853
877 922 922 969 969 1006 1040 1079 1095 1148 1148 1195 1221
1262 1262 1321 1341 1384 1414 1461 1461 1526 1544 1591 1623
1670 1692 1755 1755 1810 1848 1907
1000th term: 195309</pre>
=={{header|Raku}}==
Line 848 ⟶ 1,351:
One millionth term: 196,035,947,609</pre>
=={{header|RPL}}==
The <code>PHI</code> function
To save time, Σφ(j) are stored in a global variable named <code>ΣPHI</code>, which must be initialized at <code>{ 1 }</code> once.
{{trans|C}}
{{works with|Halcyon Calc|4.2.8}}
{| class="wikitable"
Line 856 ⟶ 1,360:
|-
|
≪ <span style="color:green">∑PHI</span> SIZE
'''IF''' DUP2 ≤ '''THEN''' DROP
'''ELSE'''
'
SWAP j
'
'
≫ '
≪ DUP DUP 1 - * 2 / 1 + SWAP
|
'
if n...
...is not already in ∑PHI
Line 898 ⟶ 1,380:
'
|}
≪ { } 1 100 FOR j j <span style="color:blue">A185670</span> + NEXT ≫ EVAL
1000 <span style="color:blue">A185670</span>
{{works with|HP|49}}
« DUP DUP 1 - 2 * / 1 +
'j' 4 ROLL 'EULER(j)' ∑ - R→I
» '<span style="color:blue">A185670</span>' STO
« « n <span style="color:blue">A185670</span> » 1 100 1 SEQ
1000 <span style="color:blue">A185670</span>
» '<span style="color:blue">TASK</span>' STO
{{out}}
<pre>
Line 935 ⟶ 1,422:
{{libheader|Wren-math}}
{{libheader|Wren-fmt}}
<syntaxhighlight lang="
import "./fmt" for Fmt
| |||