Calmo numbers: Difference between revisions
Add Scala implementation
(Added Algol W) |
(Add Scala implementation) |
||
| (4 intermediate revisions by 2 users not shown) | |||
Line 666:
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}}==
Line 680 ⟶ 716:
=={{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
Line 706 ⟶ 745:
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 ++ ){
Line 720 ⟶ 758:
// 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 )
}
}
Line 740 ⟶ 777:
[ 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}}==
Line 1,260 ⟶ 1,420:
</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}}==
| |||