DEV Community: Riches

Range Extraction "Codewars"

Riches — Tue, 26 Sep 2023 13:53:08 +0000

A format for expressing an ordered list of integers is to use a comma separated list of either

individual integers
or a range of integers denoted by the starting integer separated from the end integer in the range by a dash, '-'. The range includes all integers in the interval including both endpoints. It is not considered a range unless it spans at least 3 numbers. For example "12,13,15-17"
Complete the solution so that it takes a list of integers in increasing order and returns a correctly formatted string in the range format.

Example:

solution([-10, -9, -8, -6, -3, -2, -1, 0, 1, 3, 4, 5, 7, 8, 9, 10, 11, 14, 15, 17, 18, 19, 20]);
// returns "-10--8,-6,-3-1,3-5,7-11,14,15,17-20"

Steps:

So we will start by creating four variables. the first one will be our result array. the second one will hold our starting range, the third one will hold our ending range. and the last one will hold a counter. This counter will be used to check if the range is more than 2 numbers. the initial number will be 1.
let create a loop that will start from index 1 instead of 0. the starting range we created in step 1 will have a value of the index 0 of the array.
Now inside the loop we do some checks to get our range if any. firstly we create a variable for the current value and a variable for the previous value.
if the current value - previous value is == 1.endRange is now current value, we also increase the counter value by 1.
if it is not.
1. we check if the startRange == endRange. then we push the startRange to the result array.
2. else.
  1. we also check if the counter value is greater than two. if yes we format the range with the '-' and push it to the result array.
  2. if not we move the startRange and the endRange to the result array. finally we set the counter to 1.

after the Loop we have to repeat the option 5 to the end.

finally we return the joined version of the result array.

Algorithm.

function solution(list) {
    let rangeArray = [];
    let startRange = list[0]; // Initialize startRange with the first element of the list
    let endRange = startRange; // Initialize endRange with the same value as startRange
    let counter = 1
    for (let index = 1; index < list.length; index++) {
        const currentNumber = list[index];
        const prevNumber = list[index - 1];
        if (currentNumber - prevNumber === 1) {
            endRange = currentNumber; // Extend the current range
            counter++; //
        } else {
            // Check if it's a single number or a range
            if (startRange === endRange) {
                rangeArray.push(startRange.toString());
            } else {
                if(counter > 2){
                    rangeArray.push(startRange + '-' + endRange);
                }else{
                    rangeArray.push(startRange.toString());
                    rangeArray.push(endRange.toString());
                }
                counter = 1
            }
            startRange = currentNumber; // Start a new range
            endRange = currentNumber;
        }
    }
    // Handle the last range or single number
    if (startRange === endRange) {
        rangeArray.push(startRange.toString());
    } else {
        if(counter > 2){
            rangeArray.push(startRange + '-' + endRange);
        }else{
            rangeArray.push(startRange.toString());
            rangeArray.push(endRange.toString());
        }
    }
    return rangeArray.join(",");
}

console.log(solution([-10, -9, -8, -6, -3, -2, -1, 0, 1, 3, 4, 5, 7, 8, 9, 10, 11, 14, 15, 17, 18, 19, 20]));

Most frequently used words in a text "Codewars"

Riches — Tue, 26 Sep 2023 12:43:29 +0000

Write a function that, given a string of text (possibly with punctuation and line-breaks), returns an array of the top-3 most occurring words, in descending order of the number of occurrences.

Assumptions:
A word is a string of letters (A to Z) optionally containing one or more apostrophes (') in ASCII.
Apostrophes can appear at the start, middle or end of a word ('abc, abc', 'abc', ab'c are all valid)
Any other characters (e.g. #, \, / , . ...) are not part of a word and should be treated as whitespace.
Matches should be case-insensitive, and the words in the result should be lowercased.
Ties may be broken arbitrarily.
If a text contains fewer than three unique words, then either the top-2 or top-1 words should be returned, or an empty array if a text contains no words.
Examples:
top_3_words("In a village of La Mancha, the name of which I have no desire to call to
mind, there lived not long since one of those gentlemen that keep a lance
in the lance-rack, an old buckler, a lean hack, and a greyhound for
coursing. An olla of rather more beef than mutton, a salad on most
nights, scraps on Saturdays, lentils on Fridays, and a pigeon or so extra
on Sundays, made away with three-quarters of his income.")

=> ["a", "of", "on"]

top_3_words("e e e e DDD ddd DdD: ddd ddd aa aA Aa, bb cc cC e e e")

=> ["e", "ddd", "aa"]

top_3_words(" //wont won't won't")

=> ["won't", "wont"]

Bonus points (not really, but just for fun):
Avoid creating an array whose memory footprint is roughly as big as the input text.
Avoid sorting the entire array of unique words.

Steps:

We define a regular expression that matches the pattern of words that we want. Remember to add the contractions with apostrophes
Using the match method we try to match the given string with the regular expression. if given we return an array of all accepted string else we return an empty string.
Now lets convert to lowercase since casing is nor required in the algorithm.
Let's create a map that will hold a key value pair of each word and the corresponding times it appears in the sentence.
Let's use a loop to iterate through the words and get the number of times each appear and store them in the map.
Now lets sort the map in descending order so that we can easily select the top 3.
Using the slice let's retrieve the top 3 words then return them.

Algorithm

function topThreeWords(text) {
    // Define a regular expression to match words (including contractions with apostrophes)
    const wordRegex = /[a-zA-Z0-9']+/g;
    // Extract words from the text and convert them to lowercase
    const words = text.match(wordRegex) || [];
    const lowercaseWords = words.map((word) => word.toLowerCase());
    // Create a map to count the occurrences of each word
    const wordCount = new Map();
    lowercaseWords.forEach((word) => {
        if (wordCount !== "'") {
            if (wordCount.has(word)) {
                wordCount.set(word, wordCount.get(word) + 1);
            } else {
                wordCount.set(word, 1);
            }
        }
    });
    // Sort the word count map by frequency in descending order
    const sortedWords = [...wordCount.entries()].sort((a, b) => b[1] - a[1]);
    // Extract the top three words
    const topThreeWords = sortedWords.slice(0, 3).map((entry) => entry[0]);
    return topThreeWords;
}
console.log(topThreeWords("e e e e DDD ddd DdD: ddd ddd aa aA Aa, bb cc cC e e e"));

Pick peaks"Code Wars"

Riches — Thu, 21 Sep 2023 15:03:50 +0000

In this kata, you will write a function that returns the positions and the values of the "peaks" (or local maxima) of a numeric array.

For example, the array arr = [0, 1, 2, 5, 1, 0] has a peak at position 3 with a value of 5 (since arr[3] equals 5).

The output will be returned as an object with two properties: pos and peaks. Both of these properties should be arrays. If there is no peak in the given array, then the output should be {pos: [], peaks: []}.

Example: pickPeaks([3, 2, 3, 6, 4, 1, 2, 3, 2, 1, 2, 3]) should return {pos: [3, 7], peaks: [6, 3]} (or equivalent in other languages)

All input arrays will be valid arrays (although it could still be empty), so you won't need to validate the input.

The first and last elements of the array will not be considered as peaks (in the context of a mathematical function, we don't know what is after and before and therefore, we don't know if it is a peak or not).
Also, beware of plateaus !!! [1, 2, 2, 2, 1] has a peak while [1, 2, 2, 2, 3] and [1, 2, 2, 2, 2] do not. In case of a plateau-peak, please only return the position and value of the beginning of the plateau. For example: pickPeaks([1, 2, 2, 2, 1]) returns {pos: [1], peaks: [2]} (or equivalent in other languages)

Have fun!

Steps:

let create a response variable that will hold the structure of our response.
let create a loop which will start from 1 and end at the index before the last one. this is because of the condition given in the question.
let create a variable and initiate it to 1. this will be used to determine the value of the next index.
let us have a while loop which will be used to check if the value of current number is equal to the next. if so then no peak so move to the next value.
finally we have a loop which will enable us get the peak position once the condition are met. Once we get them we put it to the response variable.
we return the response.

Algorithm.

function pickPeaks(arr) {
    const response = { pos: [], peaks: [] };

    for (let i = 1; i < arr.length - 1; i++) {

        let next = 1;
        while (arr[i] === arr[i + next]) next++;

        if (arr[i] > arr[i - 1] && arr[i] > arr[i + next]) {
            response.pos.push(i);
            response.peaks.push(arr[i]);
        };
    };

    return response;
}

console.log(pickPeaks([1, 2, 5, 4, 3, 2, 3, 6, 4, 1, 2, 3, 3, 4, 5, 3, 2, 1, 2, 3, 5, 5, 4, 3]));

Pete, the baker"Codewars"

Riches — Wed, 20 Sep 2023 09:15:08 +0000

Pete likes to bake some cakes. He has some recipes and ingredients. Unfortunately he is not good in maths. Can you help him to find out, how many cakes he could bake considering his recipes?

Write a function cakes(), which takes the recipe (object) and the available ingredients (also an object) and returns the maximum number of cakes Pete can bake (integer). For simplicity there are no units for the amounts (e.g. 1 lb of flour or 200 g of sugar are simply 1 or 200). Ingredients that are not present in the objects, can be considered as 0.

Examples:

// must return 2
cakes({flour: 500, sugar: 200, eggs: 1}, {flour: 1200, sugar: 1200, eggs: 5, milk: 200});
// must return 0
cakes({apples: 3, flour: 300, sugar: 150, milk: 100, oil: 100}, {sugar: 500, flour: 2000, milk: 2000});

Steps:

Declare a variable and set it to infinity. so this will help us to get the min number of cakes that can be made.
using a loop lets iterate each of the recipes and use it for our comparison.
At each iteration we are checking if each recipe is present in the available object.
if yes, that is the recipe we need for making the cake is available. we will be dividing the value of the available recipe by the value of the required number.
if the dividend is less than the variable we declared in step one, that means only that number of cake can be made with that receipt we store it as the new min number of cakes that can be made.
finally we return the min number of cakes that can be made.

Algorithm

function cakes(recipe, available) {
    let numberOfCakes = Infinity;
    for (const eachRecipe in recipe) {
        if (available.hasOwnProperty(eachRecipe)) {
            const recipeRation = available[eachRecipe] / recipe[eachRecipe];
            if (recipeRation < numberOfCakes) {
                numberOfCakes = recipeRation;
            }
        } else {
            return 0;
        }
    }
    return Math.floor(numberOfCakes);
}
console.log(cakes({ flour: 500, sugar: 200, eggs: 1 }, { flour: 1200, sugar: 600, eggs: 5 }));

Product of consecutive Fib numbers "Codewars"

Riches — Tue, 12 Sep 2023 11:21:17 +0000

The Fibonacci numbers are the numbers in the following integer sequence (Fn):

0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, ...

such as

F(n) = F(n-1) + F(n-2) with F(0) = 0 and F(1) = 1.

Given a number, say prod (for product), we search two Fibonacci numbers F(n) and F(n+1) verifying

F(n) * F(n+1) = prod.

Your function productFib takes an integer (prod) and returns an array:

[F(n), F(n+1), true] or {F(n), F(n+1), 1} or (F(n), F(n+1), True)
depending on the language if F(n) * F(n+1) = prod.

If you don't find two consecutive F(n) verifying F(n) * F(n+1) = prodyou will return

[F(n), F(n+1), false] or {F(n), F(n+1), 0} or (F(n), F(n+1), False)
F(n) being the smallest one such as F(n) * F(n+1) > prod.

Some Examples of Return:
depend on the language)

productFib(714) # should return (21, 34, true),
# since F(8) = 21, F(9) = 34 and 714 = 21 * 34

productFib(800) # should return (34, 55, false),

# since F(8) = 21, F(9) = 34, F(10) = 55 and 21 * 34 < 800 < 34 * 55

productFib(714) # should return [21, 34, true],

productFib(800) # should return [34, 55, false],

productFib(714) # should return {21, 34, 1},

productFib(800) # should return {34, 55, 0},

productFib(714) # should return {21, 34, true},
productFib(800) # should return {34, 55, false},

Steps:

A fib series starts with 0 and 1, so lets create two variables that will hold 0 and 1
using a while loop. the condition is that first * last must be less than the number given to us which is prod.
so inside the loop we create a a new variable temp and we set it to the value of last.
we set the new value of last to first + last. the new value of last is the next value in the fib. series.
finally we set our first to the value of temp. e.g[0,1] where 0 is first and last is 1. now our temp will be 1, and our last will be 0+1 which is 1, then our first will be temp which is 1. so the new array will have [1,1]
finally we return an array that bears the first , last and the condition checking if first * last === prod.

Algorithm

function productFib(prod) {
    let first = 0
    let last = 1
    while (first * last < prod) {
        const temp = last;
        last = first + last;
        first = temp;
    }
    return [first, last, first * last === prod];
}
console.log(productFib(5895));

Find The Parity Outlier "Codewars"

Riches — Tue, 12 Sep 2023 09:54:19 +0000

You are given an array (which will have a length of at least 3, but could be very large) containing integers. The array is either entirely comprised of odd integers or entirely comprised of even integers except for a single integer N. Write a method that takes the array as an argument and returns this "outlier" N.

Examples
[2, 4, 0, 100, 4, 11, 2602, 36]
Should return: 11 (the only odd number)

[160, 3, 1719, 19, 11, 13, -21]
Should return: 160 (the only even number)

Steps.

I want to create two arrays that will serve as a store for the odd numbers and the even numbers.
creating a for loop that will iterate through the array given .
on each iteration i will check if the number is an even number or an odd number using the modulus operator.
if even number I will push it inside the even Number array and if odd I will push it inside the odd number array.
still inside the for loop before doing another iteration i will check if the even number array and the odd number array has an element inside it.
if yes i will check the smallest between the two of then and return the value inside that one. Note: the question said the outlier is just one so the array that is the smallest is of course the one that contains the outlier so i will return the first and only element in that array.

Algorithm.

function findOutlier(integers){
    //your code here
    let evenArr = []
    let oddArr = []
    for (let index = 0; index < integers.length; index++) {
        const element = integers[index];
        if(element % 2 == 0){
            evenArr.push(element)
        }else{
            oddArr.push(element)
        }
        if(evenArr.length > 0  && oddArr.length > 0){
            if(evenArr.length > oddArr.length){
                return oddArr[0]
            }else if(oddArr.length > evenArr.length){
                return evenArr[0]
            }
        }
    }
  }
  console.log(findOutlier([2,6,8,10,3]));

Playing with digits "Codewars"

Riches — Tue, 12 Sep 2023 09:01:58 +0000

Some numbers have funny properties. For example:

89 --> 8¹ + 9² = 89 * 1

695 --> 6² + 9³ + 5⁴= 1390 = 695 * 2

46288 --> 4³ + 6⁴+ 2⁵ + 8⁶ + 8⁷ = 2360688 = 46288 * 51

Given a positive integer n written as abcd... (a, b, c, d... being digits) and a positive integer p

we want to find a positive integer k, if it exists, such that the sum of the digits of n taken to the successive powers of p is equal to k * n.
In other words:

Is there an integer k such as : (a ^ p + b ^ (p+1) + c ^(p+2) + d ^ (p+3) + ...) = n * k

If it is the case we will return k, if not return -1.

Note: n and p will always be given as strictly positive integers.

Steps.

Lets Convert n which is a number to an Array and to to that we have to convert to a string first.
Let create a variable total which will hold the sum of all numbers in the array.
lets create our loop which will iterate over the array we created in step 1
inside the array we are going to raise each number to the power of p then add it to the variable total we created in step 2
we will increase our p by 1 because the power goes in an increasing order.
now we need to find a number which when multiplied with n will give us total. the best way to do that is to divide total by n.
now lets do our comparison. if the dividend is an integer we will return it, else we return -1 which means no number was found.

Solution.

function digPow(n, p){
    let nArr = n.toString().split("")
    let total = 0
    for (let index = 0; index < nArr.length; index++) {
        const element = nArr[index];
        total += Math.pow(parseInt(element), p)
        p++
    }
    let compare = total / n
    if(Number.isInteger(compare)){
        return compare
    }else{
        return -1
    }
}
console.log(digPow(46288, 3));

Algorithm To Create Phone Number "Codewars"

Riches — Sat, 09 Sep 2023 15:17:27 +0000

Write a function that accepts an array of 10 integers (between 0 and 9), that returns a string of those numbers in the form of a phone number.
Don't forget the space after the closing parentheses!
E.g:
Given ([1, 2, 3, 4, 5, 6, 7, 8, 9, 0])
It should return "(123) 456-7890"

Algorithm.

Step-1 - Use an if statement to ensure that the length of the array is 10 digits.

Step-2 - Using the slice() method in javascript we need to divide the array into three parts based on the format given to us. the first part will hold the first 3 digits, the second part will hold the next three numbers and the last part will hold the last four digits.

step-3 - concatenate the three parts together into a new variable. Don't forget to add the parentheses, the space after the closing parentheses and the dash.

Step-4 - return your variable

function createPhoneNumber(numbers) {
    // Check if the numbers array has exactly 10 digits.
    if (numbers.length !== 10) {
        return "Invalid input.";
    }
    // Using slice() method to get the first 3 second 3 and last 4
    let firstPart = numbers.slice(0, 3).join('');
    let secondPart = numbers.slice(3, 6).join('');
    let thirdPart = numbers.slice(6).join('');

    const phoneNumber = `(${firstPart}) ${secondPart}-${thirdPart}`;

    return phoneNumber;
}
console.log(createPhoneNumber([1, 2, 3, 4, 5, 6, 7, 8, 9, 0]));

Algorithm to Convert string to camel case "CodeWars"

Riches — Sat, 09 Sep 2023 14:26:44 +0000

The Problem
Complete the method/function so that it converts dash/underscore delimited words into camel casing. The first word within the output should be capitalized only if the original word was capitalized (known as Upper Camel Case, also often referred to as Pascal case).

should handle empty values
should remove underscores and convert first letter of word to upper case
should remove hyphens and convert first letter of word to upper case

Algorithm.

Step-1 - Create A Variable That will store our camel case words

Step-2 - Create a For loop that will loop through the str. on each iteration I will get the character of the letter using the index of that string.

Step-3 - Using an if statement to check if the a dash(-) or an underscore(_) was found in any of the iterations. if yes them we need to do some manipulations.

Step-4 - If any underscore or dash was found, we need to access the next value after the dash or underscore, this can be done by adding one to the current index.

Step-5 - Once we get the next character, we are to use the .toUpperCase() to convert to uppercase and then concatenate it with the variable created in step one.

Step-6 - After the concatenation we need to increase index or i by 1 (This is the variable declared in the for loop). This will enable our algorithm not to pick the next character after the underscore or dash because we have taken care of it already.

Step-7 - If no underscore or dash was found in the iteration. we just concatenate the string with the variable declared in step 1.

Step-8 - Finally we return our variable.

function toCamelCase(str){
    let acceptedString = ''
    for(let i = 0; i < str.length; i++){
      let eachChar = str[i]
      if(eachChar == '-' || eachChar == '_') {
        let nextChar = str[i+1]
        acceptedString += nextChar.toUpperCase()
        i++
      }else{
        acceptedString += eachChar
      }
    }
    return acceptedString
}
console.log(toCamelCase("the-stealth-warrior_is-Here"));

Check Whether a Number is a Narcissistic Number or Not in Javascript?

Riches — Sat, 09 Sep 2023 13:55:32 +0000

A number is said to be a narcissistic number, if the addition value of each digit raised to the power of numbers of digits available in the original number is equal to the original number.

For more clarification, if the original number has ‘n’ number of digits, first we have to calculate the nth power of each digit. Then add those value and check if that calculated value and original number both are same then the original number is called as narcissistic number.

Some examples of narcissistic numbers are: 153, 8208, 4210818, ... etc.

In this algorithm below, we will see how to check if a number is a narcissistic number by using Javascript programming language.

Algorithm
Step-1 - Since the input is a number i want to convert to a string first by using the.toString() method

Step-2 - Calculate the number of digits of the original number by using the .length method

Step-3 - Create A variable that will hold the sum of each of the numbers after raising them to the power of the length.

Step-4 - Initiate a loop to extract the digits and calculate the power value of it. Inside that loop add those calculated power values to the variable created above.

Step-5 - Compare both the calculated value with the original number. If the both are same, then the input number is called a narcissistic number then return true else not return false.

function narcissistic(value) {
    value = value.toString()
    let len = value.length
    let digitSum = 0;
    for(let i = 0; i <value.length; i++){
      let eachNumber = parseInt(value[i]);
      digitSum += Math.pow(eachNumber, len);
      console.log(digitSum)
    }
    return digitSum == value
}
console.log(narcissistic(7));