144 lines
3.9 KiB
JavaScript
144 lines
3.9 KiB
JavaScript
(() => {
|
|
'use strict';
|
|
|
|
// main :: IO ()
|
|
const main = () =>
|
|
console.log(
|
|
fTable(
|
|
'Narcissistic decimal numbers of lengths [1..7]:\n'
|
|
)(show)(show)(
|
|
narcissiOfLength
|
|
)(enumFromTo(1)(7))
|
|
);
|
|
|
|
// narcissiOfLength :: Int -> [Int]
|
|
const narcissiOfLength = n =>
|
|
0 < n ? filter(isDaffodil(n))(
|
|
digitPowerSums(n)
|
|
) : [0];
|
|
|
|
|
|
// powerSum :: Int -> [Int] -> Int
|
|
const powerSum = n =>
|
|
xs => xs.reduce(
|
|
(a, x) => a + pow(x, n), 0
|
|
);
|
|
|
|
|
|
// isDaffodil :: Int -> Int -> Bool
|
|
const isDaffodil = e => n => {
|
|
// True if the decimal digits of N,
|
|
// each raised to the power E, sum to N.
|
|
const ds = digitList(n);
|
|
return e === ds.length && n === powerSum(e)(ds);
|
|
};
|
|
|
|
// The subset of integers of n digits that actually need daffodil checking:
|
|
|
|
// (Flattened leaves of a tree of unique digit combinations, in which
|
|
// order is not significant. Digit sequence doesn't affect power summing)
|
|
|
|
// digitPowerSums :: Int -> [Int]
|
|
const digitPowerSums = nDigits => {
|
|
const
|
|
digitPowers = map(x => [x, pow(x, nDigits)])(
|
|
enumFromTo(0)(9)
|
|
),
|
|
treeGrowth = (n, parentPairs) => 0 < n ? (
|
|
treeGrowth(n - 1,
|
|
isNull(parentPairs) ? (
|
|
digitPowers
|
|
) : concatMap(
|
|
([parentDigit, parentSum]) =>
|
|
map(([leafDigit, leafSum]) => //
|
|
[leafDigit, parentSum + leafSum])(
|
|
take(parentDigit + 1)(digitPowers)
|
|
)
|
|
)(parentPairs)
|
|
)
|
|
) : parentPairs;
|
|
return map(snd)(treeGrowth(nDigits, []));
|
|
};
|
|
|
|
|
|
// ---------------------GENERIC FUNCTIONS---------------------
|
|
|
|
// enumFromTo :: Int -> Int -> [Int]
|
|
const enumFromTo = m => n =>
|
|
Array.from({
|
|
length: 1 + n - m
|
|
}, (_, i) => m + i);
|
|
|
|
// concatMap :: (a -> [b]) -> [a] -> [b]
|
|
const concatMap = f =>
|
|
xs => xs.flatMap(f);
|
|
|
|
// cons :: a -> [a] -> [a]
|
|
const cons = x =>
|
|
xs => [x].concat(xs);
|
|
|
|
// digitList :: Int -> [Int]
|
|
const digitList = n => {
|
|
const go = x => 0 < x ? (
|
|
cons(x % 10)(
|
|
go(Math.floor(x / 10))
|
|
)
|
|
) : [];
|
|
return 0 < n ? go(n) : [0];
|
|
}
|
|
|
|
// filter :: (a -> Bool) -> [a] -> [a]
|
|
const filter = f => xs => xs.filter(f);
|
|
|
|
// map :: (a -> b) -> [a] -> [b]
|
|
const map = f =>
|
|
xs => xs.map(f);
|
|
|
|
// isNull :: [a] -> Bool
|
|
// isNull :: String -> Bool
|
|
const isNull = xs =>
|
|
1 > xs.length;
|
|
|
|
// length :: [a] -> Int
|
|
const length = xs => xs.length;
|
|
|
|
// pow :: Int -> Int -> Int
|
|
const pow = Math.pow;
|
|
|
|
// take :: Int -> [a] -> [a]
|
|
const take = n =>
|
|
xs => xs.slice(0, n);
|
|
|
|
// snd :: (a, b) -> b
|
|
const snd = tpl => tpl[1];
|
|
|
|
// show :: a -> String
|
|
const show = x => JSON.stringify(x)
|
|
|
|
// zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
|
|
const zipWith = f => xs => ys =>
|
|
xs.slice(
|
|
0, Math.min(xs.length, ys.length)
|
|
).map((x, i) => f(x)(ys[i]));
|
|
|
|
// ------------------------FORMATTING-------------------------
|
|
|
|
// 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(length));
|
|
return s + '\n' + zipWith(
|
|
a => b => a.padStart(w, ' ') + ' -> ' + b
|
|
)(ys)(
|
|
xs.map(x => fxShow(f(x)))
|
|
).join('\n');
|
|
};
|
|
|
|
// MAIN ---
|
|
return main();
|
|
})();
|