index.js

// Practice Test: Higher Order Functions, Callbacks & Recursion


// Problem 1
// Write a function `capitalizeWords` that takes an array of strings and 
// returns a new array with each word capitalized. Use `map()`.

arrayStrings = ['elm', 'oak', 'walnut', 'pine', 'birch', 'ash'];
// function capitalizeWords(a) {
//     return a.toUpperCase();

// }
// let myArray = arrayStrings.map(capitalizeWords);

//stuff on top works, but going to try as arrow function
let newArray = arrayStrings.map((e) => {return e.toUpperCase();})

console.log(newArray);

// console.log(newArray);
// capitalizeWords(arrayStrings);




// Problem 2
// Create a function `countVowels` that uses recursion to count how 
// many vowels are in a string.
function countVowels () {
    let vowelCount = function(vowesl)
}


// Problem 3
// Implement a function `delayedGreeting` that takes a name and a callback 
// function, then executes the callback after a 1-second delay with the greeting 
// "Hello, [name]!".




// Problem 4
// Write a function `filterByLength` that takes an array of strings and a number, 
// then returns a new array with only strings longer than the given number. 
// Use `filter()`.



// Problem 5
// Create a recursive function `reverseString` that reverses any string passed to it.



// Problem 6
// Implement a function `processNumbers` that takes an array of numbers and two callbacks.
//  It should apply the first callback to even numbers and the second to odd numbers, returning 
// a new array.



// Problem 7
// Write a function `sumSquares` that uses `reduce()` to calculate the sum of squares of all
//  numbers in an array.



// Problem 8
// Create a function `countdown` that uses recursion to log numbers from a given number down to 0.



// Problem 9
// Implement a higher-order function `applyTwice` that takes a function and a value, and applies the 
// function to the value twice.



// Problem 10
// Write a function `findFirstPositive` that uses `find()` to locate the first positive number in an array.



// Problem 11
// Create a recursive function `flattenArray` that takes a nested array and returns a flattened version 
// (one level deep).




// Problem 12
// Implement a function `asyncMultiply` that takes two numbers and a callback, then uses `setTimeout` to
//  call the callback with the product after 500ms.




// Problem 13
// Write a function `allTruthy` that uses `every()` to check if all elements in an array are truthy.




// Problem 14
// Create a function `alternateCaps` that takes a string and a callback, then applies the callback to alternate 
// characters (odd-indexed characters uppercase, even-indexed lowercase).



// Problem 15  
// Write a recursive function `sumDigits` that takes a positive integer and returns the sum of its digits.



// Problem 16  
// Create a recursive function `countOccurrences` that takes an array and a target value, returning how many times the target appears in the array.



// Problem 17 
// Implement a recursive function `range` that takes two numbers (a, b) and returns an array of all integers between them, inclusive.



// Problem 18  
// Write a recursive function `deepCount` that returns the number of elements in a nested array (counting all elements at all levels).



// Problem 19  
// Create a recursive function `binarySearch` that implements the binary search algorithm on a sorted array, returning the index of the target element or -1 if not found.




// Problem 20 (Advanced, please dont stress this is just for us to get comfortable with not knowing something)
// Implement a memoized recursive Fibonacci function that uses tail call optimization principles. The function 
// should efficiently calculate Fibonacci numbers without redundant calculations or stack overflow.