DEV Community: David

Solving the HackerRank"Grading Students" Problem in TypeScript

David — Fri, 04 Oct 2024 22:58:59 +0000

I recently encountered a simple but interesting problem, the "Grading Students" challenge, and wanted to share how I solved it using JavaScript. The goal of this problem is to apply specific rounding rules to students' grades based on certain conditions.

Problem Breakdown
The task is to round student grades according to the following rules:

Any grade less than 38 remains unchanged because it’s a failing grade.
If the difference between a grade and the next multiple of 5 is less than 3, the grade should be rounded up to the nearest multiple of 5.
If the difference is 3 or greater, the grade remains unchanged.

Example
Let's take a quick example to see how this works:

A grade of 84 will round to 85 (because the next multiple of 5 is 85, and the difference is less than 3).
A grade of 29 will remain the same (because it’s below 38 and considered a failing grade).
A grade of 57 will remain 57 (because the next multiple of 5 is 60, and the difference is greater than 3).

Approach to Solve the Problem
To solve this problem, the steps are as follows:

Loop through each grade: Iterate over the list of grades.
Check if the grade is less than 38: If so, skip to the next grade because no rounding is required for failing grades.
Find the next multiple of 5: For each grade, calculate the next multiple of 5.
Check the difference: If the difference between the next multiple of 5 and the current grade is less than 3, round the grade up to that multiple of 5.
Return the modified list of grades: After processing all the grades, return the updated list.

Code Implementation
Here’s the code I wrote to solve this:

function gradingStudents(grades) {
  // Loop through all the grades
  for (let i = 0; i < grades.length; i++) {
    // Calculate the next multiple of 5
    let nextMultipleOfFive = Math.ceil(grades[i] / 5) * 5;

    // Skip grades less than 38 (failing grades)
    if (grades[i] < 38) {
      continue;
    }

    // Round the grade if the difference is less than 3
    if (nextMultipleOfFive - grades[i] < 3) {
      grades[i] = nextMultipleOfFive;
    }
  }

  return grades;
}

Step-by-Step Walkthrough

Loop through the grades:
The first step is to loop through the list of grades using a simple for loop.
Calculate the next multiple of 5:
For each grade, I used the formula Math.ceil(grade / 5) * 5 to find the next multiple of 5. For example:

For a grade of 84, the next multiple of 5 is 85.
For a grade of 73, the next multiple of 5 is 75.

Check if the grade is less than 38:
Grades below 38 are considered failing, so they do not get rounded. If the grade is less than 38, we simply continueto the next grade.
Compare the grade with the next multiple of 5:
If the difference between the grade and the next multiple of 5 is less than 3, we update the grade to that multiple. For instance:

If the grade is 84, and the next multiple is 85, the difference is 1, so we round 84 to 85.
If the grade is 73, and the next multiple is 75, the difference is 2, so we round 73 to 75.

Return the modified grades: After processing all the grades, we return the updated array of grades.

How I Solved the HackerRank "Picking Numbers" Problem in TypeScript

David — Thu, 03 Oct 2024 21:49:21 +0000

I recently tackled the "Picking Numbers" problem, a fun challenge where we need to find the longest subarray where the absolute difference between any two elements is less than or equal to 1. Here's how I solved this problem using TypeScript.

Problem Breakdown
Given an array of integers, the task is to:

Find the subarray where the absolute difference between any two elements is less than or equal to 1.
Return the length of the longest such subarray.

Approach
The problem boils down to finding subarrays that only contain two adjacent values, like numbers x and x + 1. For instance, if you have an array [1, 2, 2, 3], both [1, 2, 2] and [2, 2, 3] are valid subarrays since the difference between any two elements in these subarrays is at most 1.

To solve this, I took the following steps:

Count the frequency of each number in the array.
Check consecutive pairs of numbers and calculate their total frequency, which represents the length of the longest subarray for those two numbers.
Track the maximum length of the valid subarrays across all possible pairs of consecutive numbers.

TypeScript Solution
Here’s the solution I came up with:

function pickingNumbers(a: number[]): number {
    let frequency = new Array(100).fill(0);

    // Step 1: Count the frequency of each element in the array
    for (let i = 0; i < a.length; i++) {
        frequency[a[i]]++;
    }

    let maxLength = 0;

    // Step 2: Check pairs of consecutive numbers (x and x+1)
    for (let i = 1; i < frequency.length; i++) {
        maxLength = Math.max(maxLength, frequency[i] + frequency[i - 1]);
    }

    return maxLength;
}

Step-by-Step Explanation

Initialize Frequency Array:
I used an array frequencywith 100 elements, initialized to zero. Since the problem guarantees that the integers in the array are between 1 and 100, this array allows us to count the occurrences of each number efficiently.
Count Frequencies:
For each element in the input array a, we increment the corresponding index in the frequencyarray. For example, if a[i] = 5, we increase frequency[5] by 1. This will give us the number of occurrences of each number in the array.
Check Consecutive Numbers:
Once we have the frequency counts, we need to find the longest subarray where the absolute difference between any two numbers is less than or equal to 1. This can be done by adding the frequency of each number i and the frequency of its neighbor i-1 (i.e., frequency[i] + frequency[i-1]).
Track the Maximum Length:
As we loop through the frequency array, we keep updating the maxLength with the largest value found for consecutive numbers. This gives us the length of the longest valid subarray.

How I Solved the CodeWars "Cat and Dog Years to Human Years" Problem in JS

David — Wed, 02 Oct 2024 19:39:50 +0000

I recently tackled a fun challenge that involves converting cat and dog years into human years. The problem is simple but presents a unique way of handling calculations with conditions based on age ranges.

Here’s the breakdown of how I approached and solved this challenge.

Problem Breakdown
We are provided with two numbers:

catYears: Represents the age of a cat in cat years.
dogYears: Represents the age of a dog in dog years.
Our task is to convert these years into "human years" based on the following rules:

The first two years of a cat's or dog's life are special:

The first year counts as 15 human years.
The second year counts as 9 human years.

After the first two years, each additional year counts as:

4 human years for cats.
5 human years for dogs.

Solution Approach
I used a combination of if and else if statements to handle the different cases:

If the animal's age is below 15 years, it translates to 0 human years.
If it is between 15 and 24, that means the animal has lived one human year.
If the animal has surpassed 24 years, we calculate how many years are left after those first 24 years and then convert those remaining years into human years (4 per year for cats and 5 per year for dogs).

JavaScript Code
Here’s the solution I came up with:

var ownedCatAndDog = function(catYears, dogYears) {
  let humanCatYears;

  // Converting cat years to human years
  if (catYears < 15) {
    humanCatYears = 0;
  } else if (catYears < 24) {
    humanCatYears = 1;
  } else {
    humanCatYears = 2 + Math.floor((catYears - 24) / 4);
  }

  let humanDogYears;

  // Converting dog years to human years
  if (dogYears < 15) {
    humanDogYears = 0;
  } else if (dogYears < 24) {
    humanDogYears = 1;
  } else {
    humanDogYears = 2 + Math.floor((dogYears - 24) / 5);
  }

  return [humanCatYears, humanDogYears];
}

Step-by-Step Walkthrough

Initialize Variables:
I started by creating two variables: humanCatYears and humanDogYears. These will hold the equivalent human ages for the cat and dog.
Handle Cat Years:
For the cat:

If its age is less than 15 years (the equivalent of the first human year), it’s considered to be 0 human years.
If its age is between 15 and 24 (representing the second human year), it’s considered 1 human year.
If its age is more than 24, then it’s calculated as 2 + (remaining years) / 4, where the 2 accounts for the first two years, and each additional year counts as 4 human years.

Handle Dog Years: Similarly for the dog:

If the dog's age is below 15 years, it’s 0 human years.
If it is between 15 and 24, that’s 1 human year.
If it’s above 24, we compute 2 + (remaining years) / 5, where the 2 is for the first two years, and each additional year is 5 human years.

Return the Result: Finally, I returned an array containing the human equivalents for both the cat and the dog.

How I Solved the HackerRank "Birthday Cake Candles" Problem in JS

David — Wed, 02 Oct 2024 19:02:14 +0000

I recently encountered a fun problem called "Birthday Cake Candles" on a coding challenge platform. The goal is straightforward: given an array representing the heights of candles, I need to figure out how many tallest candles there are. Here's how I approached the problem using JavaScript.

Problem Breakdown
We are given an array, ar, where each element represents the height of a candle. The task is to:

Find the tallest candle(s).
Count how many candles have that tallest height.

Solution Approach
I took a two-step approach to solving this problem:

First, I looped through the array to find the height of the tallest candle.
Then, I looped again to count how many candles are of that tallest height.

Here’s the JavaScript solution I came up with:

function birthdayCakeCandles(ar) {
    let tallestCandle = 0;
    let tallestCandlesCount = 0;

    // Step 1: Find the height of the tallest candle
    for (let i = 0; i < ar.length; i++) {
        if (ar[i] > tallestCandle) {
            tallestCandle = ar[i];
        }
    }

    // Step 2: Count how many candles have the tallest height
    for (let j = 0; j < ar.length; j++) {
        if (ar[j] === tallestCandle) {
            tallestCandlesCount++;
        }
    }

    return tallestCandlesCount;
}

Step-by-Step Walkthrough

Initialize Variables: I started by declaring two variables:

tallestCandle: Holds the height of the tallest candle we find.
tallestCandlesCount: Keeps track of how many candles match the tallest height.

Find the Tallest Candle: I looped through the ar array with a for loop. As I iterate through each candle height:

If the current candle is taller than the value stored in tallestCandle, I update tallestCandle to reflect this new height.

Count the Tallest Candles:
After determining the height of the tallest candle, I loop through the array again. For each candle that matches the tallestCandle height, I increment the tallestCandlesCount variable.
Return the Result:
Finally, after counting all the tallest candles, I return the value of tallestCandlesCount.

HackerRank JS: Solving the Staircase Problem in JavaScript

David — Mon, 30 Sep 2024 23:07:47 +0000

Recently, I tackled a fun coding challenge: building a right-aligned staircase with a given height n, using JavaScript. I wanted to share how I approached and solved this problem, hoping it might help others tackle similar challenges.

The task: Print a staircase of height n where the # symbol represents each step. The tricky part is that the steps are right-aligned, and the rest of the row is filled with spaces.

For example, given n = 4, we need the output to look like this:

   #
  ##
 ###
####

At first glance, it might look like a simple nested loop problem, but the alignment requires careful attention to how we place spaces and # symbols.

Thought Process:
Before jumping into code, I broke the problem into smaller, manageable tasks:

Print n rows: Each row should represent a step in the staircase.
Each row has exactly n characters: Some of them are spaces, and the rest are #.
Spaces should come before #: As the row number increases, fewer spaces are needed, and more # symbols are added.

Plan:
For every row i (starting from 0):
Add spaces for the first n - i - 1 characters (to ensure right alignment).
Then, fill the rest of the row with # characters.
The logic is that as i (the row number) increases, the number of spaces decreases, and the number of # symbols increases.

The Solution Code:
Here’s the code I wrote to implement this plan:

function staircase(n) {
    // Write your code here
      var height = n;

    for (let i=0; i < height; i++) {
        let row= "";
        for (let j=0; j < height; j++) {
            if (i + j > height - 2) {
                row += "#";
            } else {
                row +=  " ";
            }
        }
        console.log(row)
    }
}

How It Works:

Initialize the height: The first thing we do is store the value of n in the height variable. This makes the code easier to read and understand.
Outer loop: This loop runs n times, representing the rows of the staircase. Each iteration corresponds to a row in the final output.
Inner loop: This loop runs n times as well, controlling how many characters will be in each row.
Condition to add # or space: The condition if (i + j > height - 2) checks whether a # should be printed. If this condition is met, we append a # to the row; otherwise, we add a space. This ensures that for each row, spaces appear first and then the # symbols.
Print the row: Once a full row is constructed (a mix of spaces and # symbols), it is printed to the console.