Calmo numbers: Difference between revisions
Add Scala implementation
(Tidied up task description.) |
(Add Scala implementation) |
||
| (37 intermediate revisions by 20 users not shown) | |||
Line 2:
;Definition
Let '''n''' be a
Add the first three eligible divisors, then the next three, and so on until the eligible divisors are exhausted. If the resulting partial sums are prime numbers, then '''n''' is called a Calmo number.
Line 25:
{{libheader|ALGOL 68-primes}}
Note, the source of primes.incl.a68 is on Rosetta Code (see above link).
<syntaxhighlight lang="algol68">
BEGIN # find some "Calmo" numbers: numbers n such that they have 3k divisors #
Line 60 ⟶ 57:
-1
ELSE
# divisor
0
FI
Line 81 ⟶ 78:
165 273 385 399 561 595 665 715 957
</pre>
=={{header|ALGOL W}}==
{{Trans|ALGOL 68}}
<syntaxhighlight lang="algolw">
begin % find some "Calmo" numbers: numbers n such that they have 3k divisors %
% (other than 1 and n) for some k > 0 and the sum of their divisors %
% taken three at a time is a prime %
integer MAX_NUMBER, MAX_PRIME;
MAX_NUMBER := 1000; % largest number we will consider %
MAX_PRIME := MAX_NUMBER * 3; % largest prime we need to consider %
% as we are going to sum divisors in groups of three, %
% it should be (more than) large enough %
begin
logical array prime ( 1 :: MAX_PRIME );
integer array dsum, dcount ( 1 :: MAX_NUMBER );
% sieve the primes to MAX_PRIME %
for i := 1 until MAX_PRIME do prime( i ) := true;
prime( 1 ) := false;
for i := 2 until truncate( sqrt( MAX_PRIME ) ) do begin
if prime( i ) then begin
for p := i * i step i until MAX_PRIME do prime( p ) := false
end if_prime_i
end for_i ;
% construct tables of the divisor counts and divisor sums and check %
% for the numbers as we do it %
% as we are ignoring 1 and n, the initial counts and sums will be 0 %
% but we should ignore primes %
for i := 1 until MAX_NUMBER do begin
dsum( i ) := dcount( i ) := if prime( i ) then -1 else 0
end for_i ;
for i := 2 until MAX_NUMBER do begin
for j := i + i step i until MAX_NUMBER do begin
% have another proper divisor %
if dsum( j ) >= 0 then begin
% this number is still a candidate %
dsum( j ) := dsum( j ) + i;
dcount( j ) := dcount( j ) + 1;
if dcount( j ) = 3 then begin
% the divisor count is currently 3 %
% if then divisor sum isn't prime, ignore it in future %
% if the divisor sum is prime, reset the sum and count %
dsum( j ) := dcount( j ) :=
if NOT prime( dsum( j ) ) then - 1 else 0
end if_dcount_j_eq_3
end if_dsum_j_ge_0
end for_j
end for_i ;
% show the numbers %
for i := 2 until MAX_NUMBER do begin
if dcount( i ) = 0 then writeon( i_w := 1, s_w := 0, " ", i )
end for_i ;
end
end.
</syntaxhighlight>
{{out}}
<pre>
165 273 385 399 561 595 665 715 957
</pre>
=={{header|AppleScript}}==
<syntaxhighlight lang="applescript">on properDivisors(n)
set output to {}
if (n > 1) then
set sqrt to n ^ 0.5
set limit to sqrt div 1
if (limit = sqrt) then
set end of output to limit
set limit to limit - 1
end if
repeat with i from limit to 2 by -1
if (n mod i is 0) then
set beginning of output to i
set end of output to n div i
end if
end repeat
set beginning of output to 1
end if
return output
end properDivisors
(* on isCalmo(n)
set pds to properDivisors(n)
set pdCount to (count pds)
if ((pdCount - 3) mod 3 ≠ 1) then return false
repeat with i from 2 to (pdCount - 1) by 3
if (properDivisors((pds's item i) + (pds's item (i + 1)) + (pds's item (i + 2))) ≠ {1}) then ¬
return false
end repeat
return true
end isCalmo *)
-- It turns out that every Calmo number < 5,000,000 is odd
-- and has exactly 6 "eligible" (ie. 7 proper) divisors, so:
on isCalmo(n)
if (n mod 2 = 0) then return false
set pds to properDivisors(n)
return (((count pds) = 7) and ¬
(properDivisors((pds's item 2) + (pds's item 3) + (pds's item 4)) = {1}) and ¬
(properDivisors((pds's item 5) + (pds's item 6) + (pds's end)) = {1}))
end isCalmo
on calmoNumbers(limit)
set output to {}
repeat with n from 20 to limit
if (isCalmo(n)) then set end of output to n
end repeat
return output
end calmoNumbers
return calmoNumbers(999)</syntaxhighlight>
{{output}}
<syntaxhighlight lang="applescript">{165, 273, 385, 399, 561, 595, 665, 715, 957}</syntaxhighlight>
=={{header|Arturo}}==
<syntaxhighlight lang="arturo">calmo?: function [n][
f: (factors n) -- @[1 n]
unless zero? (size f) % 3 -> return false
every? f [x y z] -> prime? x+y+z
]
1..1000 | select => calmo?
| print</syntaxhighlight>
{{out}}
<pre>165 273 385 399 561 595 665 715 957</pre>
=={{header|BASIC}}==
==={{header|BASIC256}}===
<syntaxhighlight lang="vb">include "isprime.kbs"
for n = 1 to 1000-1
if isCalmo(n) then print n; " ";
next n
end
function isCalmo(n)
limite = sqr(n)
cont = 0: SumD = 0: SumQ = 0: k = 0: q = 0
d = 2
do
q = n/d
if n mod d = 0 then
cont += 1
SumD += d
SumQ += q
if cont = 3 then
k += 3
if not IsPrime(SumD) then return False
if not IsPrime(SumQ) then return False
cont = 0: SumD = 0: SumQ = 0
end if
end if
d += 1
until d >= limite
if cont <> 0 or k = 0 then return False
return True
end function</syntaxhighlight>
{{out}}
<pre>Same as FreeBASIC entry.</pre>
==={{header|FreeBASIC}}===
<syntaxhighlight lang="vb">#include "isprime.bas"
Function isCalmo(n As Integer) As Boolean
Dim As Integer limite = Sqr(n)
Dim As Integer cont = 0, SumD = 0, SumQ = 0, k = 0, q = 0, d = 2
Do
q = n/d
If (n Mod d) = 0 Then
cont += 1
SumD += d
SumQ += q
If cont = 3 Then
k += 3
If Not IsPrime(SumD) Orelse Not IsPrime(SumQ) Then Return False
cont = 0: SumD = 0: SumQ = 0
End If
End If
d += 1
Loop Until d >= limite
If cont <> 0 Or k = 0 Then Return False
Return True
End Function
For n As Integer = 1 To 1000-1
If isCalmo(n) Then Print n;
Next n
Sleep</syntaxhighlight>
{{out}}
<pre>165 273 385 399 561 595 665 715 957</pre>
==={{header|Run BASIC}}===
{{works with|Just BASIC}}
<syntaxhighlight lang="vb">for n = 1 to 1000-1
if isCalmo(n) then print n; " ";
next n
end
function isPrime(n)
if n < 2 then isPrime = 0 : goto [exit]
if n = 2 then isPrime = 1 : goto [exit]
if n mod 2 = 0 then isPrime = 0 : goto [exit]
isPrime = 1
for i = 3 to int(n^.5) step 2
if n mod i = 0 then isPrime = 0 : goto [exit]
next i
[exit]
end function
function isCalmo(n)
limite = sqr(n)
cont = 0: SumD = 0: SumQ = 0: k = 0: q = 0
d = 2
[start]
q = n/d
if n mod d = 0 then
cont = cont +1
SumD = SumD +d
SumQ = SumQ +q
if cont = 3 then
k = k + 3
if not(isPrime(SumD)) then isCalmo = 0 : goto [exit]
if not(isPrime(SumQ)) then isCalmo = 0 : goto [exit]
cont = 0: SumD = 0: SumQ = 0
end if
end if
d = d +1
if d < limite then [start]
if cont <> 0 or k = 0 then isCalmo = 0 : goto [exit]
isCalmo = 1
[exit]
end function</syntaxhighlight>
{{out}}
<pre>Same as FreeBASIC entry.</pre>
==={{header|Yabasic}}===
<syntaxhighlight lang="vb">import isprime
for n = 1 to 1000-1
if isCalmo(n) print n, " ";
next n
print
end
sub isCalmo(n)
local limite, cont, SumD, SumQ, k, d, q
limite = sqrt(n)
cont = 0: SumD = 0: SumQ = 0: k = 0: q = 0: d = 2
repeat
q = n/d
if mod(n, d) = 0 then
cont = cont+1
SumD = SumD+d
SumQ = SumQ+q
if cont = 3 then
k = k+3
if not isPrime(SumD) return False
if not isPrime(SumQ) return False
cont = 0: SumD = 0: SumQ = 0
fi
fi
d = d+1
until d >= limite
if cont <> 0 or k = 0 return False
return True
end sub</syntaxhighlight>
{{out}}
<pre>Same as FreeBASIC entry.</pre>
=={{header|C}}==
{{trans|Go}}
<syntaxhighlight lang="c">#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#define LIMIT 1000
bool isPrime(int n) {
if (n < 2) return false;
if (n%2 == 0) return n == 2;
if (n%3 == 0) return n == 3;
int d = 5;
while (d*d <= n) {
if (n%d == 0) return false;
d += 2;
if (n%d == 0) return false;
d += 4;
}
return true;
}
int compare(const void* a, const void* b) {
int arg1 = *(const int*)a;
int arg2 = *(const int*)b;
if (arg1 < arg2) return -1;
if (arg1 > arg2) return 1;
return 0;
}
void eligibleDivisors(int n, int *divs, int *length) {
if (n < 1) {
*length = 0;
return;
}
int i, j, k = 1, c = 0;
if (n%2) k = 2;
for (i = k + 1; i*i <= n; i += k) {
if (!(n%i)) {
divs[c++] = i;
j = n / i;
if (j != i) divs[c++] = j;
}
}
if (c > 1) qsort(divs, c, sizeof(int), compare);
*length = c;
}
int main() {
int i, j, sum, edc, psc, cnc = 0;
int ed[30], ps[5];
bool isCalmo;
printf("Calmo numbers under 1,000:\n");
printf("Number Eligible divisors Partial sums\n");
printf("------------------------------------------------\n");
for (i = 2; i < LIMIT; ++i) {
eligibleDivisors(i, ed, &edc);
if (edc == 0 || edc % 3 != 0 ) continue;
isCalmo = true;
psc = 0;
for (j = 0; j < edc; j += 3) {
sum = ed[j] + ed[j+1] + ed[j+2];
if (!isPrime(sum)) {
isCalmo = false;
break;
}
ps[psc++] = sum;
}
if (isCalmo) {
printf("%3d [", i);
for (j = 0; j < edc; ++j) printf("%d, ", ed[j]);
printf("\b\b] \t\b\b\b\b[");
for (j = 0; j < psc; ++j) printf("%d, ", ps[j]);
printf("\b\b]\n");
}
}
return 0;
}</syntaxhighlight>
{{out}}
<pre>
Calmo numbers under 1,000:
Number Eligible divisors Partial sums
------------------------------------------------
165 [3, 5, 11, 15, 33, 55] [19, 103]
273 [3, 7, 13, 21, 39, 91] [23, 151]
385 [5, 7, 11, 35, 55, 77] [23, 167]
399 [3, 7, 19, 21, 57, 133] [29, 211]
561 [3, 11, 17, 33, 51, 187] [31, 271]
595 [5, 7, 17, 35, 85, 119] [29, 239]
665 [5, 7, 19, 35, 95, 133] [31, 263]
715 [5, 11, 13, 55, 65, 143] [29, 263]
957 [3, 11, 29, 33, 87, 319] [43, 439]
</pre>
=={{header|Delphi}}==
{{works with|Delphi|6.0}}
{{libheader|SysUtils,StdCtrls}}
<syntaxhighlight lang="Delphi">
function GetAllProperDivisors(N: Integer;var IA: TIntegerDynArray): integer;
{Make a list of all the "proper dividers" for N}
{Proper dividers are the of numbers the divide evenly into N}
var I: integer;
begin
SetLength(IA,0);
for I:=1 to N-1 do
if (N mod I)=0 then
begin
SetLength(IA,Length(IA)+1);
IA[High(IA)]:=I;
end;
Result:=Length(IA);
end;
var Facts: TIntegerDynArray;
function IsCalmoNumber(N: integer): boolean;
{Test number to see if it a Calmo number}
var Inx,Sum: integer;
begin
Result:=False;
{Get all divisors}
GetAllProperDivisors(N,Facts);
{strip off 1 }
Facts:=Copy(Facts,1,High(Facts));
if Length(Facts)<3 then exit;
{Must be at least three}
if (Length(Facts) mod 3)<>0 then exit;
Inx:=0;
repeat
begin
{Sum three factors}
Sum:=Facts[Inx]+Facts[Inx+1]+Facts[Inx+2];
{Exit if not primve}
if not IsPrime(Sum) then exit;
{Index to next three}
Inc(Inx,3);
end
until Inx>High(Facts)-1;
Result:=True;
end;
procedure ShowCalmoNumbers(Memo: TMemo);
{Show all Calmo numbers less than 1,000}
var I,J: integer;
var S: string;
begin
for I:=1 to 1000 do
if IsCalmoNumber(I) then
begin
S:='';
for J:=0 to High(Facts) do
S:=S+Format('%4d',[Facts[J]]);
S:=Trim(S);
Memo.Lines.Add(IntToStr(I)+' ['+S+']');
end;
end;
</syntaxhighlight>
{{out}}
<pre>
165 [3 5 11 15 33 55]
273 [3 7 13 21 39 91]
385 [5 7 11 35 55 77]
399 [3 7 19 21 57 133]
561 [3 11 17 33 51 187]
595 [5 7 17 35 85 119]
665 [5 7 19 35 95 133]
715 [5 11 13 55 65 143]
957 [3 11 29 33 87 319]
Elapsed Time: 11.747 ms.
</pre>
=={{header|Factor}}==
<syntaxhighlight lang="factor">USING: combinators.short-circuit grouping.extras kernel math
math.functions math.primes math.primes.factors math.vectors
prettyprint ranges sequences sequences.extras ;
IN: calmo
: calmo? ( n -- ? )
divisors 1 -1 rot subseq* {
[ empty? not ]
[ length 3 divisor? ]
[ [ + + prime? ] 3 group-map vall? ]
} 1&& ;
MAIN: [ 2 1000 [a..b) [ calmo? ] filter . ]</syntaxhighlight>
{{out}}
<pre>
V{ 165 273 385 399 561 595 665 715 957 }
</pre>
=={{header|FutureBasic}}==
<syntaxhighlight lang="futurebasic">
local fn IsPrime( n as NSUInteger ) as BOOL
BOOL isPrime = YES
NSUInteger i
if n < 2 then exit fn = NO
if n = 2 then exit fn = YES
if n mod 2 == 0 then exit fn = NO
for i = 3 to int(n^.5) step 2
if n mod i == 0 then exit fn = NO
next
end fn = isPrime
local fn IsCalmo( n as NSUInteger ) as BOOL
BOOL isCalmo = YES
double limit = sqr(n)
NSUInteger count = 0, sumd = 0, sumq = 0, k = 0, q = 0, d = 2
while ( d < limit )
q = n/d
if ( n mod d == 0 )
count++ : sumd += d : sumq += q
if ( count == 3 )
k += 3
if fn IsPrime( sumd ) == NO then exit fn = NO
if fn IsPrime( sumq ) == NO then exit fn = NO
count = 0 : sumd = 0 : sumq = 0
end if
end if
d++
wend
if count != 0 or k == 0 then exit fn = NO
end fn = isCalmo
NSUInteger n
for n = 1 to 1000 -1
if fn IsCalmo( n ) then print n; " ";
next
HandleEvents
</syntaxhighlight>
{{output}}
<pre>
165 273 385 399 561 595 665 715 957
</pre>
=={{header|Go}}==
{{libheader|Go-rcu}}
<syntaxhighlight lang="go">package main
import (
"fmt"
"rcu"
"strconv"
"strings"
)
func main() {
const limit = 1000
fmt.Println("Calmo numbers under 1,000:\n")
fmt.Println("Number Eligible divisors Partial sums")
fmt.Println("-------------------------------------------")
for i := 2; i < limit; i++ {
ed := rcu.ProperDivisors(i)[1:]
l := len(ed)
if l == 0 || l%3 != 0 {
continue
}
isCalmo := true
var ps []int
for j := 0; j < l; j += 3 {
sum := ed[j] + ed[j+1] + ed[j+2]
if !rcu.IsPrime(sum) {
isCalmo = false
break
}
ps = append(ps, sum)
}
if isCalmo {
eds := make([]string, len(ed))
for k, e := range ed {
eds[k] = strconv.Itoa(e)
}
seds := "[" + strings.Join(eds, " ") + "]"
fmt.Printf("%3d %-21s %v\n", i, seds, ps)
}
}
}</syntaxhighlight>
{{out}}
<pre>
Calmo numbers under 1,000:
Number Eligible divisors Partial sums
-------------------------------------------
165 [3 5 11 15 33 55] [19 103]
273 [3 7 13 21 39 91] [23 151]
385 [5 7 11 35 55 77] [23 167]
399 [3 7 19 21 57 133] [29 211]
561 [3 11 17 33 51 187] [31 271]
595 [5 7 17 35 85 119] [29 239]
665 [5 7 19 35 95 133] [31 263]
715 [5 11 13 55 65 143] [29 263]
957 [3 11 29 33 87 319] [43 439]
</pre>
=={{header|Haskell}}==
<syntaxhighlight lang=Haskell>import Data.List (group, sort)
import Data.List.Split (chunksOf)
import Data.Numbers.Primes (isPrime, primeFactors)
---------------------- CALMO NUMBERS ---------------------
isCalmo :: Int -> Bool
isCalmo n =
let xs = properDivisors n
m = length xs
in m > 3
&& 0 == mod (pred m) 3
&& all (isPrime . sum) (chunksOf 3 $ tail xs)
--------------------------- TEST -------------------------
main :: IO ()
main = print $ takeWhile (< 1000) $ filter isCalmo [1 ..]
------------------------- GENERIC ------------------------
properDivisors :: Int -> [Int]
properDivisors =
init
. sort
. foldr --
(flip ((<*>) . fmap (*)) . scanl (*) 1)
[1]
. group
. primeFactors</syntaxhighlight>
{{Out}}
<pre>[165,273,385,399,561,595,665,715,957]</pre>
=={{header|J}}==
If we ignore 1 and primes (see [[Talk:Calmo_numbers#Edge_cases|talk page]]):
<syntaxhighlight lang=J> isCalmo=: {{*/((,*)+/)1 p:}:_3+/\/:~_ _ _,~.}.}:*/@>,{1 ,&.>q:y}} ::0:"0
I.isCalmo i.1000
165 273 385 399 561 595 665 715 957
</syntaxhighlight>
(This implementation relies on infinity not being specifically prime nor non-prime, and on treating the error case as "not a Calmo number").
=={{header|JavaScript}}==
{{Trans|ALGOL 68}}
Procedural, uses console.log to show the numbers.
<syntaxhighlight lang="javascript">
{ // find some "Calmo" numbers: numbers n such that they have 3k divisors
// (other than 1 and n) for some k > 0 and the sum of their divisors
// taken three at a time is a prime
'use strict'
const maxNumber = 1000 // largest number we will consider
// construct a sieve of (hopefully) enough primes - as we are going to sum
// the divisors in groups of three, it should be (more than) large enough
let isPrime = []
const maxPrime = maxNumber * 3
for( let sPos = 1; sPos <= maxPrime; sPos ++ ){ isPrime[ sPos ] = sPos % 2 == 1 }
isPrime[ 1 ] = false
isPrime[ 2 ] = true
const rootMaxPrime = Math.floor( Math.sqrt( maxPrime ) )
for( let sPos = 3; sPos <= rootMaxPrime; sPos += 2 ) {
if( isPrime[ sPos ] ){
for( let p = sPos * sPos; p <= maxPrime; p += sPos ){ isPrime[ p ] = false }
}
}
// construct tables of the divisor counts and divisor sums and check for
// the numbers as we do it
// as we are ignoring 1 and n, the initial counts and sums will be 0
// but we should ignore primes
let dsum = [], dcount = []
for( let i = 1; i <= maxNumber; i ++ ){
dsum[ i ] = dcount[ i ] = ( isPrime[ i ] ? -1 : 0 )
}
for( let i = 2; i <= maxNumber; i ++ ){
for( let j = i + i; j <= maxNumber; j += i ){
// have another proper divisor
if( dsum[ j ] >= 0 ){
// this number is still a candidate
dsum[ j ] = dsum[ j ] + i
dcount[ j ] = dcount[ j ] + 1
if( dcount[ j ] == 3 ){
// the divisor count is currently 3
// if the divisor sum isn't prime, ignore it in future
// if the divisor sum is prime, reset the sum and count
dsum[ j ] = dcount[ j ] = ( ! isPrime[ dsum[ j ] ] ? -1 : 0 )
}
}
}
}
// show the numbers, they will have 0 in the divisor count
let calmoNumbers = []
for( let i = 2; i <= maxNumber; i ++ ){
if( dcount[ i ] == 0 ){
calmoNumbers.push( i )
}
}
console.log( calmoNumbers )
}
</syntaxhighlight>
{{out}}
<pre>
[ 165, 273, 385, 399, 561, 595, 665, 715, 957 ]
</pre>
Or, by functional composition, and preferring to return a value directly (avoiding `console.log`, which is not defined in ECMAScript, and is not available to all JS interpreters):
<syntaxhighlight lang="javascript">(() => {
"use strict";
// ------------------ CALMO NUMBERS ------------------
// isCalmo :: Int -> Bool
const isCalmo = n => {
const
ds = properDivisors(n),
nd = ds.length;
return 3 < nd && (
0 === (nd - 1) % 3
) && chunksOf(3)(ds.slice(1)).every(
triple => isPrime(sum(triple))
);
};
// ---------------------- TEST -----------------------
const main = () =>
enumFromTo(1)(1000).filter(
isCalmo
);
// --------------------- GENERIC ---------------------
// chunksOf :: Int -> [a] -> [[a]]
const chunksOf = n => {
// xs split into sublists of length n.
// The last sublist will be short if n
// does not evenly divide the length of xs .
const go = xs => {
const chunk = xs.slice(0, n);
return 0 < chunk.length
? [chunk, ...go(xs.slice(n))]
: [];
};
return go;
};
// enumFromTo :: Int -> Int -> [Int]
const enumFromTo = m =>
n => Array.from({
length: 1 + n - m
}, (_, i) => m + i);
// enumFromThenTo :: Int -> Int -> Int -> [Int]
const enumFromThenTo = m =>
// Integer values enumerated from m to n
// with a step defined by (nxt - m).
nxt => n => {
const d = nxt - m;
return Array.from({
length: (Math.floor(n - nxt) / d) + 2
}, (_, i) => m + (d * i));
};
// isPrime :: Int -> Bool
const isPrime = n => {
// True if n is prime.
if (n === 2 || n === 3) {
return true;
}
if (2 > n || 0 === (n % 2)) {
return false;
}
if (9 > n) {
return true;
}
if (0 === (n % 3)) {
return false;
}
const p = x =>
0 === n % x || 0 === (n % (2 + x));
return !enumFromThenTo(5)(11)(1 + Math.sqrt(n))
.some(p);
};
// properDivisors :: Int -> [Int]
const properDivisors = n => {
const
rRoot = Math.sqrt(n),
intRoot = Math.floor(rRoot),
lows = enumFromTo(1)(intRoot)
.filter(x => 0 === (n % x));
return lows.concat(
lows.map(x => n / x)
.reverse()
.slice(
rRoot === intRoot
? 1
: 0,
-1
)
);
};
// sum :: [Num] -> Num
const sum = xs =>
// The numeric sum of all values in xs.
xs.reduce((a, x) => a + x, 0);
// MAIN ---
return JSON.stringify(main());
})();</syntaxhighlight>
{{Out}}
<pre>[165,273,385,399,561,595,665,715,957]</pre>
=={{header|Julia}}==
<syntaxhighlight lang="julia">using Primes
function divisors(n::Integer)::Vector{Int}
sort(vec(map(prod,Iterators.product((p.^(0:m) for (p,m) in eachfactor(n))...))))
end
function isCalmo(n)
divi = divisors(n)[begin+1:end-1]
ndiv = length(divi)
return ndiv > 0 && ndiv % 3 == 0 && all(isprime, sum(reshape(divi, (3, :)), dims = 1))
end
println(filter(isCalmo, 1:1000))
</syntaxhighlight>
=={{header|Lua}}==
{{Trans|ALGOL 68}}
<syntaxhighlight lang="lua">
do --[[ find some "Calmo" numbers: numbers n such that they have 3k divisors
(other than 1 and n) for some k > 0 and the sum of their divisors
taken three at a time is a prime
--]]
local maxNumber = 1000 -- largest number we will consider
-- construct a sieve of (hopefully) enough primes - as we are going to sum
-- the divisors in groups of three, it should be (more than) large enough
local isPrime, maxPrime = {}, maxNumber * 2
for sPos = 1, maxPrime do isPrime[ sPos ] = sPos % 2 == 1 end
isPrime[ 1 ] = false
isPrime[ 2 ] = true
for sPos = 3, math.sqrt( maxPrime ), 2 do
if isPrime[ sPos ] then
for p = sPos * sPos, maxPrime, sPos do isPrime[ p ] = false end
end
end
-- construct tables of the divisor counts and divisor sums and check for
-- the numbers as we do it
-- as we are ignoring 1 and n, the initial counts and sums will be 0
-- but we should ignore primes
local dsum, dcount = {}, {}
for i = 1, maxNumber do
dcount[ i ] = ( isPrime[ i ] and -1 or 0 )
dsum[ i ] = dcount[ i ]
end
for i = 2, maxNumber do
for j = i + i, maxNumber, i do
-- have another proper divisor
if dsum[ j ] >= 0 then
-- this number is still a candidate
dsum[ j ] = dsum[ j ] + i
dcount[ j ] = dcount[ j ] + 1
if dcount[ j ] == 3 then
-- the divisor count is currently 3
-- if the divisor sum isn't prime, ignore it in future
-- if the divisor sum is prime, reset the sum and count
dcount[ j ] = ( not isPrime[ dsum[ j ] ] and -1 or 0 )
dsum[ j ] = dcount[ j ]
end
end
end
end
-- show the numbers, they will have 0 in the divisor count
for i = 2, maxNumber do
if dcount[ i ] == 0 then
io.write( " ", i )
end
end
io.write( "\n" )
end
</syntaxhighlight>
{{out}}
<pre>
165 273 385 399 561 595 665 715 957
</pre>
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<syntaxhighlight lang="Mathematica">
(*Function to get the divisors of a number excluding 1 and the number itself*)
EligibleDivisors[n_Integer] :=
Select[Divisors[n], # != 1 && # != n &]
(*Function to check if the sum of every three consecutive eligible divisors is prime*)
IsCalmoNumber[n_Integer] :=
Module[{divisors, sums, divisorsLength},
divisors = EligibleDivisors[n];
divisorsLength = Length[divisors];
If[Mod[divisorsLength, 3] != 0 || divisorsLength <= 0,
Return[False]];
sums = Total /@ Partition[divisors, 3];
AllTrue[sums, PrimeQ]
]
(*Find all Calmo numbers under 1000*)
calmoNumbers = Select[Range[2, 999], IsCalmoNumber]
(*Output the Calmo numbers*)
calmoNumbers // Print
</syntaxhighlight>
{{out}}
<pre>
{165, 273, 385, 399, 561, 595, 665, 715, 957}
</pre>
=={{header|MiniScript}}==
<syntaxhighlight lang="miniscript">
isPrime = function(n)
if n < 2 then return false
if n < 4 then return true
for i in range(2,floor(n ^ 0.5))
if n % i == 0 then return false
end for
return true
end function
getFactors = function(n)
factors = {}
for i in range(1, floor(n ^ 0.5))
if n % i == 0 then
factors[i] = 1
factors[n /i ] = 1
end if
end for
return factors.indexes.sort
end function
isCalmo = function(n)
factors = getFactors(n)
if not(factors.len >= 5 and (factors.len - 2) % 3 == 0) then return false
for i in range(1, factors.len - 4, 3)
if not isPrime(factors[i] + factors[i+1] + factors[i+2]) then return false
end for
return true
end function
for i in range(1, 1000)
if isCalmo(i) then print i
end for
</syntaxhighlight>
{{out}}
<pre>165
273
385
399
561
595
665
715
957
</pre>
=={{header|Nim}}==
<syntaxhighlight lang="Nim">func isPrime(n: Natural): bool =
if n < 2: return false
if (n and 1) == 0: return n == 2
if n mod 3 == 0: return n == 3
var d = 5
var step = 2
while d * d <= n:
if n mod d == 0:
return false
inc d, step
step = 6 - step
return true
func divisors(n: Positive): seq[int] =
for d in 2..<n:
if n mod d == 0:
result.add d
func isCalmoNumber(n: Positive): bool =
let d = n.divisors
if d.len == 0 or d.len mod 3 != 0:
return false
for i in countup(0, d.high, 3):
if not isPrime(d[i] + d[i + 1] + d[i + 2]):
return false
return true
for n in 1..1000:
if n.isCalmoNumber:
stdout.write ' ', n
echo()
</syntaxhighlight>
{{out}}
<pre> 165 273 385 399 561 595 665 715 957
</pre>
=={{header|PARI/GP}}==
<syntaxhighlight lang="PARI/GP">
\\ Function to get the divisors of a number excluding 1 and the number itself
eligibleDivisors(n) = {
my(divs = divisors(n)); \\ Compute all divisors of n
if (#divs <= 2, return([])); \\ If there are no divisors other than 1 and n, return an empty list
vecextract(divs, "2..-2"); \\ Extract divisors without the first and last elements (1 and n)
};
\\ Function to check if the sum of every three consecutive eligible divisors is prime
isCalmoNumber(n) = {
my(divisors, sums, i, k);
divisors = eligibleDivisors(n); \\ Get eligible divisors
if ((#divisors % 3 != 0) || (#divisors == 0), return(0)); \\ If not divisible by 3 or no divisors, return false
sums = vector(#divisors \ 3, i, sum(k = 1, 3, divisors[3*i + k - 3])); \\ Compute sums of every three divisors
for (i = 1, #sums,
if (!isprime(sums[i]), return(0)); \\ If any sum is not prime, return false
);
return(1); \\ If all sums are prime, return true
};
{
\\ Find all Calmo numbers under 1000
calmoNumbers = [];
for (n = 1, 1000,
if (isCalmoNumber(n), calmoNumbers = concat(calmoNumbers, n)); \\ Check if n is a Calmo number and add to the list
);
print(calmoNumbers); \\ Print all Calmo numbers found under 1000
}
</syntaxhighlight>
{{out}}
<pre>
[165, 273, 385, 399, 561, 595, 665, 715, 957]
</pre>
=={{header|Perl}}==
{{libheader|ntheory}}
<syntaxhighlight lang="perl" line>
use v5.36;
use ntheory<is_prime divisors>;
use List::Util 'all';
use experimental 'for_list';
sub c_divisors ($n) { my @d = divisors $n; pop @d; shift @d; @d }
for (2..1000) {
my @d = c_divisors $_;
next unless @d and 0 == @d%3;
my @sums;
for my($a,$b,$c) (@d) { push @sums, $a+$b+$c }
print "$_ " if all { is_prime $_ } @sums;
}
say '';
</syntaxhighlight>
{{out}}
<pre>
165 273 385 399 561 595 665 715 957
</pre>
=={{header|Phix}}==
<!--<syntaxhighlight lang="phix">(phixonline)-->
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #008080;">function</span> <span style="color: #000000;">calmo</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">)</span>
<span style="color: #004080;">sequence</span> <span style="color: #000000;">f</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">factors</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">)</span>
<span style="color: #004080;">integer</span> <span style="color: #000000;">l</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">f</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">if</span> <span style="color: #000000;">l</span><span style="color: #0000FF;">=</span><span style="color: #000000;">0</span> <span style="color: #008080;">or</span> <span style="color: #7060A8;">remainder</span><span style="color: #0000FF;">(</span><span style="color: #000000;">l</span><span style="color: #0000FF;">,</span><span style="color: #000000;">3</span><span style="color: #0000FF;">)!=</span><span style="color: #000000;">0</span> <span style="color: #008080;">then</span> <span style="color: #008080;">return</span> <span style="color: #004600;">false</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">l</span> <span style="color: #008080;">by</span> <span style="color: #000000;">3</span> <span style="color: #008080;">do</span>
<span style="color: #008080;">if</span> <span style="color: #008080;">not</span> <span style="color: #7060A8;">is_prime</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">sum</span><span style="color: #0000FF;">(</span><span style="color: #000000;">f</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">..</span><span style="color: #000000;">i</span><span style="color: #0000FF;">+</span><span style="color: #000000;">2</span><span style="color: #0000FF;">]))</span> <span style="color: #008080;">then</span> <span style="color: #008080;">return</span> <span style="color: #004600;">false</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #008080;">return</span> <span style="color: #004600;">true</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
<span style="color: #0000FF;">?</span><span style="color: #7060A8;">filter</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">tagset</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1000</span><span style="color: #0000FF;">),</span><span style="color: #000000;">calmo</span><span style="color: #0000FF;">)</span>
<!--</syntaxhighlight>-->
{{out}}
<pre>
{165,273,385,399,561,595,665,715,957}
</pre>
=={{header|Python}}==
<syntaxhighlight lang="python">#!/usr/bin/python
def isPrime(n):
for i in range(2, int(n**0.5) + 1):
if n % i == 0:
return False
return True
def isCalmo(n):
limite = pow(n, 0.5)
cont = 0
SumD = 0
SumQ = 0
k = 0
q = 0
d = 2
while d < limite:
q = n/d
if n % d == 0:
cont += 1
SumD += d
SumQ += q
if cont == 3:
k += 3
if not isPrime(SumD):
return False
if not isPrime(SumQ):
return False
cont = 0
SumD = 0
SumQ = 0
d += 1
if cont != 0 or k == 0:
return False
return True
if __name__ == "__main__":
for n in range(1, 1000-1):
if isCalmo(n):
print(n, end=" ");</syntaxhighlight>
{{out}}
<pre>Same as FreeBASIC entry.</pre>
=={{header|Quackery}}==
<code>factors</code> is defined at [[Factors of an integer#Quackery]].
<syntaxhighlight lang="Quackery"> [ true swap
factors dup size 3 < iff
[ drop not ] done
1 split nip
-1 split drop
dup size 3 mod 0 != iff
[ drop not ] done
[ 3 split
0 rot witheach +
factors size 2 != iff
[ dip not ] done
dup [] = until ]
drop ] is calmo ( n --> b )
[] 1000 times [ i^ calmo if [ i^ join ] ]
echo
</syntaxhighlight>
{{out}}
<pre>[ 165 273 385 399 561 595 665 715 957 ]</pre>
=={{header|Raku}}==
<syntaxhighlight lang="raku" line>use Prime::Factor;
use List::Divvy;
my $upto = 1e3;
my @found = (2..Inf).hyper.grep({
(so my @d = .&proper-divisors(:s)) &&
(@d.elems %% 3) &&
(all @d.batch(3)».sum».is-prime)
}).&upto($upto);
put "{+@found} found before $upto using sums of proper-divisors:\n" ~
@found.batch(10)».fmt("%4d").join: "\n";
@found = (2..Inf).hyper.grep({
(so my @d = .&proper-divisors(:s).&after: 1) &&
(@d.elems %% 3) &&
(all @d.batch(3)».sum».is-prime)
}).&upto($upto);
put "\n{+@found} found before $upto using sums of some bizarre\nbespoke definition for divisors:\n" ~
@found.batch(10)».fmt("%4d").join: "\n";</syntaxhighlight>
{{out}}
<pre>85 found before 1000 using sums of proper-divisors:
8 21 27 35 39 55 57 65 77 85
111 115 125 129 155 161 185 187 201 203
205 209 221 235 237 265 291 299 305 309
319 323 327 335 341 365 371 377 381 391
413 415 437 451 485 489 493 497 505 515
517 535 579 611 623 649 655 667 669 671
687 689 697 707 731 737 755 767 779 781
785 831 835 851 865 893 899 901 917 921
939 955 965 979 989
9 found before 1000 using sums of some bizarre
bespoke definition for divisors:
165 273 385 399 561 595 665 715 957</pre>
=={{header|Ring}}==
Line 193 ⟶ 1,397:
done...
</pre>
=={{header|RPL}}==
≪ DUP FACTORS
'''IF''' DUP SIZE 3 MOD '''THEN''' DROP2 0 '''ELSE'''
{} 1 3 PICK SIZE '''FOR''' j
OVER j GET +
2 '''STEP'''
NIP SWAP OVER / + SORT
1 CF
1 OVER SIZE '''FOR''' j
DUP j DUP 2 + SUB ∑LIST
'''IF''' ISPRIME? NOT '''THEN''' 1 SF DUP SIZE 'j' STO '''END'''
3 '''STEP''' DROP
1 FC?
'''END'''
≫ '<span style="color:blue">CALMO?</span>' STO
≪ { } 2 1000 '''FOR''' j '''IF''' j <span style="color:blue">CALMO?</span> '''THEN''' j + '''END NEXT''' ≫ '<span style="color:blue">TASK</span>' STO
{{out}}
<pre>
1: { 165 273 385 399 561 595 665 715 957 }
</pre>
Runs in 2 minutes 54 seconds on a HP-50g.
=={{header|Scala}}==
{{trans|Python}}
<syntaxhighlight lang="Scala">
object Main extends App {
def isPrime(n: Int): Boolean = {
for (i <- 2 to math.sqrt(n).toInt) {
if (n % i == 0) {
return false
}
}
true
}
def isCalmo(n: Int): Boolean = {
val limite = math.sqrt(n)
var cont = 0
var sumD = 0
var sumQ = 0
var k = 0
var q = 0
var d = 2
while (d < limite) {
q = n / d
if (n % d == 0) {
cont += 1
sumD += d
sumQ += q
if (cont == 3) {
k += 3
if (!isPrime(sumD)) {
return false
}
if (!isPrime(sumQ)) {
return false
}
cont = 0
sumD = 0
sumQ = 0
}
}
d += 1
}
if (cont != 0 || k == 0) {
return false
}
true
}
for (n <- 1 until 1000) {
if (isCalmo(n)) {
print(n + " ")
}
}
}
</syntaxhighlight>
{{out}}
<pre>
165 273 385 399 561 595 665 715 957
</pre>
=={{header|Wren}}==
{{libheader|Wren-math}}
{{libheader|Wren-seq}}
{{libheader|Wren-fmt}}
<syntaxhighlight lang="wren">import "./math" for Int, Nums
import "./seq" for Lst
import "./fmt" for Fmt
var limit = 1000
var calmo = []
for (i in 2...limit) {
var ed = Int.properDivisors(i)
ed.removeAt(0)
if (ed.count == 0 || ed.count % 3 != 0) continue
var isCalmo = true
var ps = []
for (chunk in Lst.chunks(ed, 3)) {
var sum = Nums.sum(chunk)
if (!Int.isPrime(sum)) {
isCalmo = false
break
}
ps.add(sum)
}
if (isCalmo) calmo.add([i, ed, ps])
}
System.print("Calmo numbers under 1,000:\n")
System.print("Number Eligible divisors Partial sums")
System.print("----------------------------------------------")
for (e in calmo) {
Fmt.print("$3d $-24n $n", e[0], e[1], e[2])
}</syntaxhighlight>
{{out}}
<pre>
Calmo numbers under 1,000:
Number Eligible divisors Partial sums
----------------------------------------------
165 [3, 5, 11, 15, 33, 55] [19, 103]
273 [3, 7, 13, 21, 39, 91] [23, 151]
385 [5, 7, 11, 35, 55, 77] [23, 167]
399 [3, 7, 19, 21, 57, 133] [29, 211]
561 [3, 11, 17, 33, 51, 187] [31, 271]
595 [5, 7, 17, 35, 85, 119] [29, 239]
665 [5, 7, 19, 35, 95, 133] [31, 263]
715 [5, 11, 13, 55, 65, 143] [29, 263]
957 [3, 11, 29, 33, 87, 319] [43, 439]
</pre>
=={{header|XPL0}}==
<syntaxhighlight lang "XPL0">func IsPrime(N); \Return 'true' if N is prime
int N, I;
[if N <= 2 then return N = 2;
if (N&1) = 0 then \even >2\ return false;
for I:= 3 to sqrt(N) do
[if rem(N/I) = 0 then return false;
I:= I+1;
];
return true;
];
func IsCalmo(N); \Return 'true' if N is a Calmo number
int N, Limit, Count, SumD, SumQ, K, D, Q;
[Limit:= sqrt(N);
Count:= 0; SumD:= 0; SumQ:= 0; K:= 0;
D:= 2;
repeat Q:= N/D;
if rem(0) = 0 then
[Count:= Count+1;
SumD:= SumD+D;
SumQ:= SumQ+Q;
if Count = 3 then
[K:= K+3;
if not IsPrime(SumD) then return false;
if not IsPrime(SumQ) then return false;
Count:= 0; SumD:= 0; SumQ:= 0;
];
];
D:= D+1;
until D >= Limit;
if Count # 0 or K = 0 then return false;
return true;
];
int N;
[for N:= 1 to 1000-1 do
if IsCalmo(N) then
[IntOut(0, N); ChOut(0, ^ )];
]</syntaxhighlight>
{{out}}
<pre>
165 273 385 399 561 595 665 715 957 </pre>
| |||