wholes = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
function filter(predicateFn, array) {
if (length(array) === 0) return [];
const firstItem = head(array);
const filteredFirst = predicateFn(firstItem) ? [firstItem] : [];
return concat(filteredFirst, filter(predicateFn, tail(array)));
}
function isEven(n) {
return n % 2 == 0
}
evens = filter(isEven, wholes)
odds = filter(
(n) => { return n % 2 !== 0 },
wholes
)
greaterThanFour = filter(
(n) => { return n > 4}, // TODO replace this line
wholes
)
function isPrime(num) { // rewrite to be more functional (focus on function, not object )
if (num < 2) return false;
// We are going to create a list of possible factors. We will see if we can divide our input by any of these factors.
// This is not optimal, for now we are just filtering out obvious factors (i.e. even values, values more than half of value)
// ideally would want to look at removing all multiples (this way we create a list of all prime numbers under a certain value )
const allFactors = Array.from({length: num - 1 }, (_, i) => i + 2) // create array going from 2 to n
const factorsUneven = filter( n => n == 2 || n % 2 !== 0, allFactors) // filter out uneven numbers larger than 2
const biggest_possible_factor = Math.floor(num / 2);
const factorsReduced = filter(n => n <= biggest_possible_factor, factorsUneven) //filter out anything bigger than half
const factors = filter(n => (num % n == 0 ), factorsReduced)
return factors.length == 0
}
function map(fn, array) {
if (length(array) === 0 ) return [];
return concat([fn(head(array))], map(fn, tail(array)))
}
doubled = map(n => n * 2, wholes)
halved = map(n => n / 2, wholes)
fizzBuzz = map(n => {
const fizz = (n % 3 == 0 ) ? "fizz" : "";
const buzz = (n % 5 == 0 ) ? "buzz" : "";
return fizz + buzz || n
}, wholes)
fizzBuzz
function reduce(reducerFn, initialValue, array) {
if (length(array) === 0) return initialValue;
const newInitialValue = reducerFn(initialValue, head(array));
return reduce(reducerFn, newInitialValue, tail(array));
}
sum = reduce(
(accumulator, value) => {
return accumulator + value
},
0,
wholes
)
max = reduce(
(acc, value) => {
return Math.max(acc,value)
}, // TODO replace this reducerFn
0, // I don't like this, what if list only has negative values?
[7, 1, 3, 5, 6, 2, 8, 10, 0, 4, 9]
)
// Concatenate two arrays into a new single array
function concat(array1, array2) {
return array1.concat(array2);
}
// Return the number of items in an array
function length(array) {
return array.length;
}
// Return the first item in an array
function head(array) {
return array[0];
}
// Return the rest of an array after the first item
function tail(array) {
return array.slice(1);
}
Purpose-built for displays of data
Observable is your go-to platform for exploring data and creating expressive data visualizations. Use reactive JavaScript notebooks for prototyping and a collaborative canvas for visual data exploration and dashboard creation.
