Code Monkeys

Problem Description

You are climbing a staircase. It takes n steps to reach the top.

Each time you can either climb 1 or 2 steps. In how many distinct ways can you climb to the top?

Examples

Ex 1) Input: n = 2 Output: 2

Explanation: There are two ways to climb to the top.
1. 1 step + 1 step
2. 2 steps

Ex 2) Input: n = 3 Output: 3

Explanation: There are three ways to climb to the top.
1. 1 step + 1 step + 1 step
2. 1 step + 2 steps
3. 2 steps + 1 step

Constraints

Thought Process

Let's start by diagramming the different ways we can climb the steps to see if we can find a pattern.
- When n = 3 we have:

From the diagram we can see there are 3 distinct ways to climb to the top when n = 3 since we can ignore the scenarios where we take extra steps.
To help you see a pattern try drawing out more diagrams for larger values of n or creating a generalized diagram for any value of n.
The diagram above is an example of a recursion tree.
So, one way to solve this problem is to come up with a recursive formula that represents how many distinct ways we can climb the stairs.
Let's use the diagram to help us come up with our recursive formula.
We know we can either add 1 step or 2 steps each time we climb up the stairs, and we want to hit our target of n steps.
So, we need to keep track of how many steps we have taken which we can represent with the variable , where represents the current choice when climbing the stairs.
Initially, , here means we haven't made a choice to take 1 step or 2 steps yet.
Each time we climb the stairs we make one of the following choices:

Now, we'll let denote our function for climbing the stairs.
Here's how we can represent the different scenarios for climbing the stairs:

We're passing the + and our target value of steps to our function .
Now, we need to determine how many times we need to to call .
We know from the diagram if , then we can ignore that way of climbing the stairs
We also know if , then we have found a valid way to climb the steps.
Using this knowledge we can come up with the following:

Implementation

var climbStairs = function(n) {
  return wayToClimb(0, n);
};

var wayToClimb = function(stepsTaken, n) {
  if (stepsTaken > n) {
    return 0;
  }

  if (stepsTaken === n) {
    return 1;
  }

  return wayToClimb(stepsTaken + 1, n) + wayToClimb(stepsTaken + 2, n);
};

let n = 4;
console.log(climbStairs(n));

Downsides

Our solution will work, but it's not efficient.
We'll actually get a time limit exceeded error on LeetCode if we submit this.
This is because the time complexity of our solution is O(2ⁿ).
We can look at our recursion tree above and count the number of nodes to determine the time complexity.
Now, we won't count exactly 2ⁿ nodes since our recursive formula isn't exactly 2ⁿ, but when dealing with Big-Oh we only care about the behavior as n becomes very large.
We'll be improving this in the next post by drawing out recursion trees for larger values of n which will allow us to see an interesting pattern.

Climbing Stairs Solution 2

Thu, 01 Jul 2021 15:45:32 GMT

Links

Climbing Stairs

Problem Description

You are climbing a staircase. It takes n steps to reach the top.

Each time you can either climb 1 or 2 steps. In how many distinct ways can you climb to the top?

Examples

Ex 1) Input: n = 2 Output: 2

Explanation: There are two ways to climb to the top.
1. 1 step + 1 step
2. 2 steps

Ex 2) Input: n = 3 Output: 3

Explanation: There are three ways to climb to the top.
1. 1 step + 1 step + 1 step
2. 1 step + 2 steps
3. 2 steps + 1 step

Constraints

Thought Process

We previously came up with a solution for this problem by using a recursive formula that represents how many distinct ways we can climb the stairs.
The issue with the previous solution is it has a time complexity of O(2ⁿ) which is very inefficient.
To come up with a better solution we'll be drawing out multiple recursion trees to help us see a pattern.
When n = 1 we have:

From the diagram we can see there is 1 distinct way to climb to the top when n = 1 since we can ignore the scenarios where we take extra steps.
When n = 2 we have:

So, we have 2 distinct ways to climb to the top.
When n = 3 we have:

So, we have 3 distinct ways to climb to the top.
When n = 4 we have:

So, we have 5 distinct ways to climb to the top.
Now, let's take a look at our cases from n = 1 to n = 2 and see if we can find a pattern:

Here, waysToClimb denotes our function for determining how many unique ways we can climb the stairs.
This sequence of numbers follows the Fibonacci sequence with the only difference being the value of the 1^st and 2^nd terms.
Here, the 1^st term has a value of 1 and the 2^nd term has a value of 2.
Also, notice that we know we have two ways to climb the stairs to reach the n^th step.
If we take 1 step, then we're n - 1 steps closer to n, and if we take 2 steps then we're n - 2 steps closer to n.
So, we can get the distinct number of ways to climb the steps by summing up the ways of climbing to the n - 1 step and the ways of climbing to the n - 2 step using the following formula:

The Fibonacci sequence is the following series of numbers:

The next number is found by adding up the two numbers before it.
For example, 5 is found by adding 2 and 3.
The first two terms are called seed numbers, which we'll denote as:

Here's the formula used to characterize the sequence:

The seed numbers for our problem are:

Now that we know our pattern of climbing the stairs follows a Fibonnaci sequence we can implement the sequence in our code using the waysToClimb formula and the seed numbers we came up with.
This will improve the time complexity of our solution from the O(2ⁿ) solution we previously came up with.

Implementation

var climbStairs = function(n) {
  if (n === 1) {
    return 1;
  } else if (n === 2) {
    return 2;
  } else {
    let waysToClimb1 = 1;
    let waysToClimb2 = 2;
    let waysToClimb;
    let i = 1;

    while (n - 1 > i) {
      waysToClimb = waysToClimb2 + waysToClimb1;
      waysToClimb1 = waysToClimb2;
      waysToClimb2 = waysToClimb;
      i++;
    }

    return waysToClimb;
  }
};

let n = 4;
console.log(climbStairs(n));

Analysis

Since we're looping over the length of n - 1 our time complexity is O(n) which is a much more efficient solution!
See if you can come up with an even more efficient solution using more properties of the Fibonnaci sequence!

Reverse String

Wed, 11 Aug 2021 15:35:00 GMT

Links

Reverse String

Problem Description

Write a function that reverses a string. The input string is given as an array of characters s.

Examples

Ex 1) Input: s = ["h", "e", "l", "l", "o"] Output: ["o", "l", "l", "e", "h"]

Ex 2) Input: s = ["H", "a", "n", "n", "a", "h"] Output: ["h", "a", "n", "n", "a", "H"]

Constraints

s[i] is a printable ASCII character.
Do not allocate extra space for another array. You must do this in-place with O(1) extra memory.

What is a printable ASCII Character?

ASCII stands for American Standard Code for Information Interchange and it consists of 33 non-printable and 95 printable characters.
You can check out the non-printable, printable, and extended ASCII characters hereContent not supported.
For this problem we only care about the printable ASCII characters.

What does In-Place Mean?

In-place refers to an algorithm that transforms input using no auxiliary data structure.
So, we cannot allocate extra space for another array, a hash table, or any other data structure.
Another way of saying this is we must use O(1) extra memory.

Thought Process

Let's take our two examples from earlier and find a way to model the reversing of the characters in s.
Let's start with Ex 1)
- Initially, we have
and after reversing s our output should be:
- To perform the reversal we need to swap the characters in s.
- We can start by swapping the leftmost character and the rightmost character.
- Then we'll move to the second leftmost character and the second rightmost character and swap them.
- We'll continue this process until every character has been swapped if we have an even number of characters, or until we have one unswapped character left if we have an odd number of characters.
- To perform this swapping we'll need to loop over s while there are still characters that can be swapped.
- Let's visualize this process to help us see how the swapping will occur and to better understand what we need to keep track of.
 - 1^st Iteration:
 - Current Leftmost Character: h
 - Current Rightmost Character: o
 - Now, we can swap the characters by assigning s[0] to be s[4], but if we want to assign s[4] to be s[0], then we must first store s[0] in a temp variable.
 - Storing s[0] in a temp variable will allow us to still have the original character that was stored in s[0].
 - Here's the steps for the swapping process:
 - Here's s after the 1^st swap:
 - 2^nd Iteration:
 - Current Leftmost Character: e
 - Current Rightmost Character: l
 - Now, we can swap the characters by assigning s[1] to be s[3] and by assinging s[3] to be s[1] using the swapping process from before.
 - Here's the steps for the swapping process:
 - Here's s after the 2^nd swap:
 - There are no unswapped characters left to swap with our only remaining unswapped character, s[2], so the reversal is complete.
- To perform these swaps we had to keep track of the index of our current leftmost character which we'll denote with i and the index of our current rightmost character which we'll denote with j.
- Keeping track of the current leftmost index required us to start with i = 0 and to increment i on each subsequent iteration.
- Keeping track of the current rightmost index required us to start with j = s.length - 1 and to decrement j on each subsequent iteration.
- We continued the loop while i < j.
Let's now look at Ex 2)
- Initially, we have
and after reversing s our output should be:
- We need to swap the characters in s again like in Ex) 1.
- Let's visualize this process to help us see how the swapping will occur for this example:
 - 1^st Iteration:
 - Current Leftmost Character: H
 - Current Rightmost Character: h
 - Now, we can swap the characters by assigning s[0] to be s[5] and by assinging s[5] to be s[0] using the swapping process from before.
 - Here's the steps for the swapping process:
 - Here's s after the 1^st swap:
 - 2^nd Iteration:
 - Current Leftmost Character: a
 - Current Rightmost Character: a
 - Now, we can swap the characters by assigning s[1] to be s[4] and by assinging s[4] to be s[1] using the swapping process from before.
 - Here's the steps for the swapping process:
 - Here's s after the 2^nd swap:
 - Note if you wanted to you could include a check to see if the characters are the same before swapping since the result after swapping will be the same.
 - 3^rd Iteration:
 - Current Leftmost Character: n
 - Current Rightmost Character: n
 - Now, we can swap the characters by assigning s[2] to be s[3] and by assinging s[3] to be s[2] using the swapping process from before.
 - Here's the steps for the swapping process:
 - Here's s after the 3^rd swap:
 - Every character has been swapped, so the reversal is complete.
- Notice again we continued the loop while i < j.
- Using the model we described above we can come up with the following implementation:

Implementation

var reverseString = function(s) {
  let temp;
  let i = 0;
  let j = s.length - 1;

  while (i < j) {
    temp = s[i];
    s[i] = s[j];
    s[j] = temp;
    i++;
    j--;
  }
};

// Case 1: s has an odd length
s = ['h', 'e', 'l', 'l', 'o'];
reverseString(s);
console.log(s);

// Case 2: s has an even length
s = ['H', 'a', 'n', 'n', 'a', 'h'];
reverseString(s);
console.log(s);

Contains Duplicate

Fri, 06 Aug 2021 18:24:00 GMT

Links

Contains Duplicate

Problem Description

Given an integer array nums, return true if any value appears at least twice, and return false if every element is distinct.

Examples

Ex 1) Input: nums = [1, 2, 3, 1] Output: true since 1 appears twice.

Ex 2) Input: nums = [1, 2, 3, 4] Output: false since no value appears twice.

Ex 3) Input: nums = [1, 1, 1, 3, 3, 4, 3, 2, 4, 2] Output: true since 1, 3, and 2 appear more than once.

Ex 4) Input: nums = [] Output: false since there are no values.

Constraints

Thought Process

By looking at the examples, the 1^st thought that comes to mind may be to simply take each value in nums, and compare it with every other value.
- Basically, we'll be comparing each pair of values in nums to see if a duplicate has occurred.
- To do this we'll start at the first value in nums, and compare it with each value to the right until we reach the end of nums.
- Then we'll take the second value in nums, and compare it with each value to the right until we reach the end of nums.
- We repeat this process until we reach the end of nums in the worst case or until we find a duplicate value.
- Here's a visualization for nums = [1, 2, 3] which represents a worst case scenario:
  - Let's take our 1^st value in nums, and compare it with each value to the right of it:
    - 1^st Comparison:
    - 2^nd Comparison:
  - Now, let's take our 2^nd value in nums, and compare it with each value to the right of it:
    - 3^rd Comparison:
    - The 3^rd value in nums is also the last value, so there's no more comparisons to be made.
- To achieve this we'll need to loop over each value in nums, and for each iteration of this loop we need to compare our current value which will denote as nums[i] with each value to the right of it.
- The process of comparing nums[i] with each value to the right of it means we'll need a nested for loop that loops from nums[i + 1] to the last value in nums.
- A nested for loop a time complexity of which is not efficient and will result in a Time Limit Exceeded error on LeetCode.
Before checking for duplicate values, we can realize that if we sort nums any duplicate values will be consecutive.
- Let's visualize this with an example for nums = [1, 2, 3, 1]:
  - Sorting nums gives us:
  - Now, we can loop over nums and check for duplicates values.
- Looping over nums has a time complexity of O(n), and the sorting algorithm can have a time complexity as good as O(nlogn) if something like heapsort is used.
- So, the overall time complexity is O(nlogn) since it's the dominating factor.
Solving this problem requires the ability to efficiently search for values, and a great way to do that is to use a hash table.
- A hash table is an object that maps keys to values.
- The search and insert opertions in a hash table have a time complexity of O(1).
- Using a hash table will allow us to store each value in nums as a key, and we can map a value of let's say true to it if it's the first time we've seen the value.
- Now, to create our hash table we can loop over nums then check to see if the key is present.
- If the key is present, then we have found a duplicate, and we'll return true.
- If the key isn't present, then we'll store the current value of nums as a key in our hash table with a value of true.
- If no key appears twice, then nums has no duplicates, and we'll return false.
- Here's a visualization of creating our hash table which we'll denote as obj for nums = [1, 2, 1]:
  - 1^st Iteration:
  - So, we'll store the value of nums[0] as a key in our hash table with a value of true.
  - 2^nd Iteration:
  - So, we'll store the value of nums[1] as a key in our hash table with a value of true.
  - 3^rd Iteration:
  - Since the same key appeared in our hash table, a duplicate has been found in nums, so we'll return false.

Implementation

var containsDuplicate = function(nums) {
  const obj = {};
  for (let i = 0; i < nums.length; i++) {
    if (obj[nums[i]]) {
      return true;
    }
    obj[nums[i]] = true;
  }

  return false;
};

nums = [1, 2, 3, 1];
console.log(containsDuplicate(nums));

Single Number

Tue, 29 Jun 2021 17:23:42 GMT

Links

Single Number

Remove Duplicates from Sorted Array

Problem Description

Given a non-empty array of integers nums, every element appears twice excepet for one. Find that single one.

You must implement a solution with a linear runtime complexity and use only constant extra space.

Examples

Ex 1) Input: nums = [2, 2, 1] Output: 1 since 1 appears once.

Ex 2) Input: nums = [4, 1, 2, 1, 2] Output: 4 since 4 appears once.

Ex 3) Input: nums = [1] Output: 1 since 1 appears once.

Constraints

Each element in the array appears twice except for one element which appears only once.

What does Linear Runtime Mean?

A linear runtime means our solution must have a time complexity of O(n).
So, it's ok to use a loop in our solution but not a nested loop.

What does Using Constant Extra Space Mean?

Our given space complexity is O(n) since we're given nums which is an array of length n.
Since we want to use constant extra space, our solution must have at most O(n) space complexity.

Thought Process

We need to iterate over nums since we need to find out which element appears only once.
The iteration can be done using a for loop.
Now, to keep track of how many times an element has appeared in nums we can use a hash table.
A hash table is an object that maps keys to values.
Here, the key will represent the element in nums, and the value can be set to true if it has appeared once.
If the key appears again we can remove it since we know every element other than the unique element appears twice.
After removing the keys that appear twice, we just need to return the key of our hash table that appeared once.
Here's a visualization of creating our hash table which we'll denote as myObj for nums = [2, 2, 1]:
- 1^st Iteration:
- So, we'll store the value of nums[0] as a key in our hash table with a value of true.
- 2^nd Iteration:
- So, we'll remove the 2 key from our hash table since it has now appeared twice.
- 3^rd Iteration:
- So, we'll store the value of nums[2] as a key in our hash table with a value of true.
- Now, we have reached the end of the loop, so we'll return the value of the only key left in our hash table which in this case is 1.

Implementation

var singleNumber = function(nums) {
  const myObj = {};
  for (let i = 0; i < nums.length; i++) {
    if (myObj[nums[i]]) {
      delete myObj[nums[i]];
    } else {
      myObj[nums[i]] = true;
    }
  }

  return Object.keys(myObj)[0];
};

nums = [2, 2, 1];
console.log(singleNumber(nums));

Remove Duplicates from Sorted Array

Sat, 03 Jul 2021 17:25:34 GMT

Links

Problem Description

Given an integer array nums sorted in non-decreasing order, remove the duplicates in-place such that each unique element appears only once. The relative order of the elements should be kept the same.

Since it is impossible to change the length of the array in some languages, you must instead have the result be placed in the first part of the array nums. More formally, if there are k elements after removing the duplicates, then the first k elements of nums should hold the final result. It does not matter what you leave beyond the first k elements.

Return k after placing the final result in the first k slots of nums.

Do not allocate extra space for another array. You must do this by modifying the input array in-place with O(1) extra memory.

Examples

Ex 1) Input: nums = [1, 1, 2] Output: 2, nums = [1, 2, _]

Explanation: Your function should return k = 2, with the first two elements of nums being 1 and 2 respectively.
It does not matter what you leave beyond the returned k (hence they are underscores).

Ex 2) Input: nums = [0, 0, 1, 1, 1, 2, 2, 3, 3, 4] Output: 5, nums = [0, 1, 2, 3, 4, _, _, _, _, _]

Explanation: Your function should return k = 5, with the first five elements of nums being 0, 1, 2, 3, and 4 respectively.
It does not matter what you leave beyond the returned k (hence they are underscores).

Constraints

nums is sorted in non-decreasing order.

What does In-Place mean?

Let's start by defining in-place which is an algorithm that transforms input using no auxiliary data structure.
So, we cannot allocate extra space for another array, a hash table, or any other data structure.
Another way of saying this is we must use O(1) extra memory.

Removing (or Moving) Duplicates & Maintaining Relative Order

In JavaScript we can change the length of an array by adding or removing elements, but in other languages like C for example we cannot change the length of an array after it's created.
So, to get around this we're told we can place the result in the first part of nums.
Recall the formal description from earlier: if there are k elements after removing the duplicates, then the first k elements of nums should hold the final result, and it doesn't matter what is left after the first k elements.
The examples from earlier should make this clearer:
- Ex 1) Input: nums = [1, 1, 2] Output: 2, nums = [1, 2, _ ]
- Notice:
  - The output maintains the relative order for nums by keeping the elements we care about in non-decreasing order.
  - Also, recall if we're moving the duplicates it doesn't matter what we leave after the k^th element, so those elements were denoted with underscores.
- Ex 2) Input: nums = [0, 0, 1, 1, 1, 2, 2, 3, 3, 4] Output: 5, nums = [0, 1, 2, 3, 4, _, _, _, _, _]
- Notice:
  - The output maintains the relative order again for nums by keeping the elements we care about in non-decreasing order.
  - And again, recall if we're moving the duplicates it doesn't matter what we leave after the k^th element, so those elements were denoted with underscores.

How to Modify nums In-Place?

We're told we can only modify nums in-place.
Let's start with nums = [1, 1, 1, 2, 2], and see if we can come up with some way to move around the elements to get our desired output.
Let's start by taking our 1^st element in nums and compare it with the 2^nd element, then we can compare the 2^nd element with the 3^rd and so on...
1^st Iteration:

2^nd Iteration:

3^rd Iteration:

4^th Iteration:

After the 4^th iteration, there's nothing left to compare nums[4] with, so that's the last iteration we need.
During our iterations we had to keep track of our current element in nums which we'll call nums[i] and the next element in nums which will be nums[i + 1].
We also had to keep track of which element we needed to replace in nums if we ran into an element we hadn't seen before which we'll call nums[j].
So, to implement this we'll loop over nums from the beginning to the length of nums - 1 since when we get to the last element there's nothing else for us to compare it with.
On each iteration we'll compare the current element of nums which is nums[i] with the next element of nums which is nums[i + 1].
If they're not equal then we'll set nums[j] = nums[i + 1] where j gets initialized to 1, and we'll increment j every time nums[i] doesn't equal nums[i + 1].
We also need to remember the case of nums.length = 0 which means we have no elements in our array, so we'll just return 0.

Implementation

var removeDuplicates = function(nums) {
  const numsLength = nums.length;

  if (numsLength === 0) {
    return 0;
  }

  let j = 1;
  for (let i = 0; i < numsLength - 1; i++) {
    if (nums[i] !== nums[i + 1]) {
      nums[j] = nums[i + 1];
      j++;
    }
  }

  return j;
};

nums = [1, 1, 1, 2, 2];
console.log('k =', removeDuplicates(nums), 'nums =', nums);

Valid Anagram

Fri, 02 Jul 2021 18:15:23 GMT

Links

Valid Anagram