Proper divisors: Difference between revisions
→JS ES6: Updated code and output.
(→{{header|Haskell}}: Corrected the reduced definition in terms of primeFactors) |
(→JS ES6: Updated code and output.) |
||
Line 2,328:
<lang JavaScript>(() => {
'use strict';
// properDivisors :: Int -> [Int]
// The integer divisors
const
intRoot = Math.floor(rRoot),
blnPerfectSquare = rRoot === intRoot,
lows = enumFromTo(1)(intRoot)
.filter(x => 0 === (n % x));
// For perfect squares, we can drop
// the head of the 'highs' list
return lows.concat(lows
.map(x => n / x)
.reverse()
.slice(blnPerfectSquare | 0)
)
.slice(0, -1); // except n itself
};
// ------------------------TESTS-----------------------
const main = () =>
fTable('Proper divisors of
)(properDivisors)(
enumFromTo(1)(10)
),
'',
'Example of maximum divisor count in the range [1..20000]:',
' ' + maximumBy(comparing(snd))(
enumFromTo(1)(20000).map(
n => [n, properDivisors(n).length]
)
// -----------------GENERIC FUNCTIONS------------------
// comparing :: (a -> b) -> (a -> a -> Ordering)
const comparing = f =>
x => y => {
const
a = f(x),
b = f(y);
return a < b ? -1 : (a > b ? 1 : 0);
};
// enumFromTo :: Int -> Int -> [Int]
const enumFromTo = m => n =>
Array.from({
length: 1 + n - m
}, (_, i) => m + i);
// fTable :: String -> (a -> String) -> (b -> String)
// -> (a -> b) -> [a] -> String
const fTable = s => xShow => fxShow => f => xs => {
// Heading -> x display function ->
// fx display function ->
// f -> values -> tabular string
const
ys = xs.map(xShow),
w = Math.max(...ys.map(x => x.length));
return s + '\n' + zipWith(
a => b => a.padStart(w, ' ') + ' -> ' + b
)(ys)(
xs.map(x => fxShow(f(x)))
).join('\n');
};
// maximumBy :: (a -> a -> Ordering) -> [a] -> a
const maximumBy = f => xs =>
0 < xs.length ? (
xs.slice(1)
.reduce((a, x) => 0 < f(x)(a) ? x : a, xs[0])
) : undefined;
// snd :: (a, b) -> b
const snd = tpl => tpl[1];
// str :: a -> String
const str = x =>
// until :: (a -> Bool) -> (a -> a)
const until = p => f => x =>
let v =
while (!p(v)) v =
return v;
};
// zipWith :: (a -> b -> c)
const zipWith = f => xs => ys =>
as = xs.slice(0, lng),
bs = ys.slice(0, lng);
return Array.from({
length: lng
}, (_, i) => f(as[i])(
bs[i]
));
};
// MAIN ---
return main();
})();</lang>
{{Out}}
<pre>Proper divisors of [1..10]:
1 -> []
2 -> [1]
3 -> [1]
4 ->
5 -> [1]
6 -> [1,2,3]
7 -> [1]
8 -> [1,2,4]
9 -> [1,3]
10 -> [1,2,5]
Example of maximum divisor count in the range [1..20000]:
15120 has 79 proper divisors.</pre>
=={{header|jq}}==
| |||