Given a positive integer n, generate an n x n matrix filled with elements from 1 to n^2 in spiral order.

Example 1

Input: n = 3
Output: [[1,2,3],[8,9,4],[7,6,5]]

Example 2

Input: n = 1
Output: [[1]]

Constraints

• 1 <= n <= 20.

Solution

1. Starting from the top left of the matrix.

2. Going along the spiral direction.

3. Put the value to the matrix, starting from 1.

Code

#include <vector>
#include <iostream>
using namespace std;
enum Direction {RIGHT, DOWN, LEFT, UP};
vector<vector<int>> generateMatrix(int n) {
    vector<vector<int>> m(n, vector<int>(n));
    int bottom = n - 1;
    int right = n - 1;
    int top = 0;
    int left = 0;
    int row = 0;
    int col = 0;
    Direction d = RIGHT;
    int a = 1;
    while (top <= bottom && left <= right) {
        m[row][col] = a++;
        switch (d) {
            case RIGHT: if (col == right) {
                            top++;
                            d = DOWN;
                            row++;
                        } else {
                            col++;
                        }
                        break;
            case DOWN:  if (row == bottom) {
                            right--;
                            d = LEFT;
                            col--;
                        } else {
                            row++;
                        }
                        break;
            case LEFT:  if (col == left) {
                            bottom--;
                            d = UP;
                            row--;
                        } else {
                            col--;
                        }
                        break;
            case UP:    if (row == top) {
                            left++;
                            d = RIGHT;
                            col++;
                        } else {
                            row--;
                        }
                        break;
        }
    }
    return m;
}
void printResult(vector<vector<int>>& m) {
    cout << "[";
    for (auto& r : m) {
        cout << "[";
        for (int a : r) {
            cout << a << ",";
        }
        cout << "]";
    }
    cout << "]\n";
}
int main() {
    auto m = generateMatrix(3);
    printResult(m);
    m = generateMatrix(1);
    printResult(m);
}

Output:
[[1,2,3,][8,9,4,][7,6,5,]]
[[1,]]

This solution uses a Direction enum and boundary variables to iteratively fill the matrix in a spiral pattern. Updating the direction of movement based on the current position and boundaries efficiently populates the matrix with sequential values, traversing in a clockwise direction from the outer layer to the inner layer.

Complexity

• Runtime: O(n^2), where n x n is the size of the matrix.
• Extra space: O(1).

Key Takeaway

Enumerating directions with an enum (like Direction) can enhance code readability and maintainability, especially in algorithms involving traversal or movement. It aids in clearly defining and referencing the possible directions within the problem domain.

Exercise

• Spiral Matrix.

You're provided with a triangle array. Your goal is to find the smallest possible sum of a path from the top of the triangle to the bottom.

You can move to an adjacent number in the row below at each step. Specifically, if you're at index i in the current row, you can move to either index i or index i + 1 in the next row.

Example 1

Input: triangle = [[2],[3,4],[6,5,7],[4,1,8,3]]
Output: 11
Explanation: The triangle looks like:
   2
  3 4
 6 5 7
4 1 8 3
The minimum path sum from top to bottom is 2 + 3 + 5 + 1 = 11 (underlined above).

Example 2

Input: triangle = [[-10]]
Output: -10

Constraints

• 1 <= triangle.length <= 200.
• triangle[0].length == 1.
• triangle[i].length == triangle[i - 1].length + 1.
• -10^4 <= triangle[i][j] <= 10^4.

Follow up

• Could you use only O(n) extra space, where n is the total number of rows in the triangle?

Solution 1: Store all minimum paths

You can store all minimum paths at every positions (i,j) to compute the next ones with this relationship.

minPath[i][j] = triangle[i][j] + min(minPath[i - 1][j - 1], minPath[i - 1][j]);

Code

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int minimumTotal(const vector<vector<int>>& triangle) {
    const int n = triangle.size(); // triangle's height
    vector<vector<int>> minPath(n);
    minPath[0] = triangle[0];
    for (int i = 1; i < n; i++) {
        const int N = triangle[i].size();
        minPath[i].resize(N);
        // left most number
        minPath[i][0] = triangle[i][0] + minPath[i-1][0];
        for (int j = 1; j < N - 1; j++) {
            minPath[i][j] = triangle[i][j] + min(minPath[i-1][j-1], minPath[i-1][j]);
        }
        // right most number
        minPath[i][N-1] = triangle[i][N-1] + minPath[i-1][N-2];

    }
    // pick the min path among the ones (begin -> end)
    // go to the bottom (n-1)
    return *min_element(minPath[n-1].begin(), minPath[n-1].end());
}
int main() {
    vector<vector<int>> triangle{{2},{3,4},{6,5,7},{4,1,8,3}};
    cout << minimumTotal(triangle) << endl;
    triangle = {{-10}};
    cout << minimumTotal(triangle) << endl;
}

Output:
11
-10

This solution finds the minimum path sum from the top to the bottom of a triangle, represented as a vector of vectors. It uses dynamic programming to calculate the minimum path sum.

The algorithm initializes a minPath vector of vectors to store the minimum path sum for each element in the triangle. It starts by setting the first row of minPath to be the same as the first row of the triangle.

Then, it iterates through the rows of the triangle starting from the second row. For each element in the current row, the minimum path sum is calculated by considering the two paths from the previous row leading to that element. It takes the minimum of the two paths and adds the current element's value. This way, it accumulates the minimum path sum efficiently.

The algorithm continues this process until it reaches the last row of the triangle. Finally, it returns the minimum element from the last row of minPath, representing the minimum path sum from top to bottom.

Complexity

• Runtime: O(n^2), where n is the number of rows in the triangle.
• Extra space: O(n^2).

Solution 2: Store only the minimum paths of each row

You do not need to store all paths for all rows. The computation of the next row only depends on its previous one.

Code

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int minimumTotal(const vector<vector<int>>& triangle) {
    const int n = triangle.size();
    // store only min path for each row
    vector<int> minPath(n);
    minPath[0] = triangle[0][0];
    for (int i = 1; i < n; i++) {
        // right most number
        minPath[i] = triangle[i][i] + minPath[i - 1];
        for (int j = i - 1; j > 0; j--) {
            minPath[j] = triangle[i][j] + min(minPath[j - 1], minPath[j]);
        }
        // left most number
        minPath[0] = triangle[i][0] + minPath[0];
    }
    return *min_element(minPath.begin(), minPath.end());
}
int main() {
    vector<vector<int>> triangle{{2},{3,4},{6,5,7},{4,1,8,3}};
    cout << minimumTotal(triangle) << endl;
    triangle = {{-10}};
    cout << minimumTotal(triangle) << endl;
}

Output:
11
-10

Complexity

• Runtime: O(n^2), where n is the number of rows in the triangle.
• Extra space: O(n).

Given a string s, find the length of the longest substring without repeating characters.

Example 1

Input: s = "abcabcbb"
Output: 3
Explanation: The answer is "abc", with a length of 3.

Example 2

Input: s = "bbbbb"
Output: 1
Explanation: The answer is "b", with the length of 1.

Example 3

Input: s = "pwwkew"
Output: 3
Explanation: The answer is "wke", with a length of 3.
Notice that the answer must be a substring, "pwke" is a subsequence and not a substring.

Constraints

• 0 <= s.length <= 5 * 10^4.

• s consists of English letters, digits, symbols and spaces.

Solution: Store the position of the visited characters

One way of checking the repetition of the characters is by using a map to store their indices. For example:

last_visit[s[i]] = i

You might want to find every substring of nonrepeating characters in the string s, then identify the longest one among them.

1. The character you are checking its repetition and computing the length should be done within its substring;

2. The map should always update the latest visited index of a character; and

3. The starting index of a substring is also updated when repetition happens.

Example 1

For the string s = "abcabcbb":

• When you visit the second letter 'a', the first substring is formed "abc", the next substring starts from the second letter 'a': start = 3 , last_visit['a'] is updated to be 3.

• When you visit the second letter 'b', its last_visit['b'] is updated to be 4.

• Repetition is found when you visit the third letter 'b', the second substring "abc" is formed. The next start = 6; last_visit['b'] = 6.

• The fourth letter 'b' causes a repetition and forms a one-letter substring "b".

• The string s ends and form another one-letter substring "b".

Code

#include <iostream>
#include <unordered_map>
#include <algorithm>
using namespace std;
int lengthOfLongestSubstring(string s) {
    unordered_map<char, int> last_visit;
    int maxLen = 0;
    int start = -1;
    for (int i = 0; i < s.length(); i++) {
        auto it = last_visit.find(s.at(i));
        if (it != last_visit.end()) {
            start = max(start, it->second);
            it->second = i;
        } else {
            last_visit.insert({s.at(i), i});
        }
        maxLen = max(maxLen, i - start);
    }
    return maxLen;

}
int main() {
    cout << lengthOfLongestSubstring("abcabcbb") << endl;
    cout << lengthOfLongestSubstring("bbbbb") << endl;
    cout << lengthOfLongestSubstring("pwwkew") << endl;
}

Output:
3
1
3

Complexity

• Runtime: O(N), where N = s.length.

• Extra space: O(N).

Implementation notes

• You can initialize the start index of the substrings with -1 to deal with the boundary cases.

• As a best practice, when you check if a map contains a key and retrieve its value, use an iterator and find() like the above solution. DO NOT implement as follow

if (last_visit.find(s.at(i)) != last_visit.end()) {
    start = max(start, last_visit[s.at(i)]);
}

Because the operator [] might perform an additional find().

Thanks for reading. Feel free to share your thought about my content and check out my book10 Classic Coding Challenges for FREE:

You are given an array of positive integers nums and want to erase a subarray containing unique elements. The score you get by erasing the subarray is equal to the sum of its elements.

Return the maximum score you can get by erasing exactly one subarray.

An array b is called to be a subarray of a if it forms a contiguous subsequence of a, that is, if it is equal to a[l],a[l+1],...,a[r] for some (l,r).

Example 1

Input: nums = [4,2,4,5,6]
Output: 17
Explanation: The optimal subarray here is [2,4,5,6].

Example 2

Input: nums = [5,2,1,2,5,2,1,2,5]
Output: 8
Explanation: The optimal subarray here is [5,2,1] or [1,2,5].

Constraints

• 1 <= nums.length <= 10^5.

• 1 <= nums[i] <= 10^4.

Solution: Store the position of the visited elements

You can use a map to store the position of the elements of nums. Then when iterating nums you can identify if an element has been visited before. That helps you to decide if a subarray contains unique elements.

Code

#include <iostream>
#include <unordered_map>
#include <vector>
using namespace std;
int maximumUniqueSubarray(vector<int>& nums) {
    vector<int> sum(nums.size(), 0);
    sum[0] = nums[0];    
    int maxSum = sum[0];
    unordered_map<int, int> position;
    position[nums[0]] = 0;
    int start = -1;
    for (int i = 1; i < nums.size(); i++) {
        sum[i] = sum[i - 1] + nums[i];
        if (position.find(nums[i]) != position.end()) {
            start = max(start, position[nums[i]]);
        }
        position[nums[i]] = i;
        maxSum = (start == -1) ? sum[i] : max(maxSum, sum[i] - sum[start]);
    }
    return maxSum;
}
int main() {
    vector<int> nums{4,2,4,5,6};
    cout << maximumUniqueSubarray(nums) << endl;
    nums = {5,2,1,2,5,2,1,2,5};
    cout << maximumUniqueSubarray(nums) << endl;
}

Output:
17
8

This C++ code defines a function maximumUniqueSubarray that finds the maximum sum of a subarray in the given vector nums with the constraint that all elements must be unique. It uses two key techniques: prefix sums and a sliding window approach.

Complexity

• Runtime: O(N), where N = nums.length.

• Extra space: O(N).

Thanks for reading. Get my book "10 Classic Coding Challenges" for FREE.

While coding interviews can be challenging, even for experienced candidates, avoiding common mistakes is crucial to success. This comprehensive guide will explore the most common mistakes in coding interviews and provide strategies to avoid them, helping you excel in your next technical interview.

Why Coding Interviews Matter

Coding interviews assess candidates' technical skills, problem-solving ability, and coding proficiency. Companies use them to determine if a candidate can handle the job demands.

For the interviewee, performing well in these interviews is often a gateway to exciting job opportunities and career advancement. However, making mistakes during coding interviews can be a significant obstacle. Let's dive into some of the most common pitfalls and how to avoid them.

Common Mistakes in Coding Interviews

1. Lack of Preparation

Mistake: A lack of preparation is one of the most common and detrimental mistakes. Some candidates underestimate the importance of thorough preparation, assuming their experience or knowledge is sufficient to carry them through the interview.

Avoidance: To prepare effectively, review the fundamentals of data structures, algorithms, and problem-solving techniques. Invest time practicing coding challenges on platforms like LeetCode, HackerRank, or CodeSignal. Consider conducting mock interviews with peers or mentors to simulate the interview experience.

2. Poor Time Management

Mistake: Time management can be a significant challenge in coding interviews. Candidates may spend too much time on a single problem, leaving insufficient time for other questions.

Avoidance: Practice time management by setting time limits when solving practice problems. In real interviews, it's essential to maintain a steady pace. If you are stuck on a particular problem, consider moving on to other questions and returning to the challenging one later. Prioritize questions based on your strengths and tackle the low-hanging fruit first.

3. Lack of Communication

Mistake: Some candidates remain silent during interviews, failing to communicate their thoughts to the interviewer. This can lead to misunderstandings and missed opportunities to showcase their problem-solving skills.

Avoidance: Communicate your thought process. Explain your approach before starting to code. Discuss your assumptions and strategies with the interviewer. Effective communication demonstrates your problem-solving abilities and allows you to receive valuable feedback. Please don't assume the interviewer can read your mind; they appreciate clear, structured communication.

4. Ignoring Edge Cases

Mistake: Neglecting edge cases or failing to consider all possible scenarios can lead to incomplete or incorrect solutions.

Avoidance: Always consider edge cases and test your code against them. Discuss potential edge cases with the interviewer to demonstrate your thorough problem-solving approach. Address boundary conditions and exceptional scenarios explicitly in your code.

5. Over-Complicated Solutions

Mistake: Some candidates tend to overcomplicate their solutions. This can lead to more complex and error-prone code, which is challenging for the interviewer to understand.

Avoidance: Strive for simplicity in your solutions. Break the problem down into smaller, manageable steps. Write code that is clean, easy to understand, and efficient. Remember that the goal is to find a working solution, not necessarily the most elegant one. Prioritize clarity over complexity.

6. Focusing Only on Syntax

Mistake: Candidates may become overly concerned with perfect syntax during interviews, leading to slow progress and stress.

Avoidance: While correct syntax is essential, prioritize problem-solving and algorithmic thinking. If you make a minor syntax error, the interviewer will often overlook it if your approach is sound. Concentrate on conveying your understanding of the problem and how you intend to solve it. Focus on your problem-solving abilities rather than syntax perfection.

7. Giving Up Too Soon

Mistake: Some candidates give up too quickly when encountering difficulties in a problem. This can prevent them from reaching a solution and showcasing their problem-solving skills.

Avoidance: Persistence is key. Don't give up at the first sign of difficulty. Approach the problem methodically, break it into smaller subproblems, and tackle each. If you get stuck, communicate your thought process and discuss potential approaches with the interviewer. Interviewers often appreciate your determination and problem-solving resilience.

8. Not Asking Clarifying Questions

Mistake: Candidates often make assumptions about the problem without seeking clarification from the interviewer. This can lead to misunderstandings and incorrect solutions.

Avoidance: Ask questions to clarify any ambiguities or uncertainties in the problem statement. Don't hesitate to seek additional information or constraints to guide your solution. Interviewers appreciate candidates who ask thoughtful questions and validate their understanding of the problem.

9. Lack of Testing

Mistake: Failing to test your solution thoroughly can result in uncaught bugs or errors.

Avoidance: After writing your code, test it with various inputs, including common and edge cases. Verify that your solution produces the expected output and handles all possible scenarios. Demonstrating the effectiveness of your code through testing can enhance your credibility and reassure the interviewer that your solution is robust.

10. Not Learning from Rejections

Mistake: Rejections in coding interviews can be disheartening, but not learning from them can hinder your progress.

Avoidance: Treat rejections as opportunities to learn and improve. Request feedback from interviewers or mentors to understand your weaknesses and areas for growth. Adjust your preparation based on the feedback received to increase your chances of success in future interviews. Continuous improvement is essential in the competitive field of software engineering.

11. Not Seeking Help

Mistake: Some candidates feel they must solve problems independently, leading to frustration and wasted time.

Avoidance: Don't hesitate to seek help or hints from the interviewer if you're stuck. They may provide valuable guidance or nudges to help you find the correct solution. It's better to seek help than to remain stuck and fail to solve the problem. Interviewers are often interested in your problem-solving approach and how you adapt to new information.

12. Not Tailoring Preparation

Mistake: Failing to tailor your interview preparation to the specific company or role can result in suboptimal performance.

Avoidance: Research the company's interview process and expectations. Understand the technologies and languages they use. Tailor your preparation to align with the company's requirements and industry trends. If a company strongly focuses on a particular programming language, ensure your skills in that language are up to par.

Conclusion

Mastering coding interviews is valuable for any aspiring software engineer or developer. Avoiding common mistakes and following best practices can significantly increase your chances of success. Remember to focus on problem-solving, communicate effectively, and continuously improve your skills. With dedication and a structured approach to interview preparation, you can excel in coding interviews and secure the job you desire.

Coding interviews are not just about technical knowledge; they also showcase your problem-solving, communication, and adaptability skills. You'll perform better in interviews and grow as a well-rounded software professional by learning from mistakes and consistently improving.

Given an integer n, return true if it is a power of four. Otherwise, return false.

An integer n is a power of four if there exists an integer x such that n == 4^x.

Example 1

Input: n = 16
Output: true

Example 2

Input: n = 5
Output: false

Example 3

Input: n = 1
Output: true

Constraints

• -2^31 <= n <= 2^31 - 1.

Follow up: Could you solve it without loops/recursion?

Solution 1: Division by four

Code

#include <iostream>
using namespace std;
bool isPowerOfFour(int n) {
    while (n % 4 == 0 && n > 0) {
        n /= 4;
    }
    return n == 1;
}
int main() {
    cout << isPowerOfFour(16) << endl;
    cout << isPowerOfFour(5) << endl;
    cout << isPowerOfFour(1) << endl;
}

Output:
1
0
1

Complexity

• Runtime: O(logn).

• Extra space: O(1).

Solution 2: Binary representation

You can write down the binary representation of the powers of four to find the pattern.

1   : 1
4   : 100
16  : 10000
64  : 1000000
256 : 100000000
...

You might notice the patterns are n is a positive integer having only one bit1 in its binary representation and it is located at the odd positions (starting from the right).

How can you formulate those conditions?

If n has only one bit 1 in its binary representation 10...0, then n - 1 has the complete opposite binary representation 01...1.

You can use the bit operator AND to formulate this condition

n & (n - 1) == 0

Let A be the number whose binary representation has only bits 1 at all odd positions, then n & A is never 0.

In this problem, A < 2^31. You can chooseA = 0x55555555, the hexadecimal of 0101 0101 0101 0101 0101 0101 0101 0101.

Code

#include <iostream>
using namespace std;
bool isPowerOfFour(int n) {
    return n > 0 && (n & (n - 1)) == 0 && (n & 0x55555555) != 0;
}
int main() {
    cout << isPowerOfFour(16) << endl;
    cout << isPowerOfFour(5) << endl;
    cout << isPowerOfFour(1) << endl;
}

Output:
1
0
1

Complexity

• Runtime: O(1).

• Extra space: O(1).

Thanks for reading. Get my book "10 Classic Coding Challenges" for FREE:

The problem involves the International Morse Code, which defines a standard way to encode letters with dots and dashes. Each English letter corresponds to a specific sequence in Morse Code, and a full table mapping each letter is provided.

For instance, 'a' is encoded as ".-", 'b' as "-...", and so on.

The full table for the 26 letters of the English alphabet is given below:

[".-", "-...", "-.-.", "-..", ".", "..-.", "--.",
"....", "..", ".---", "-.-", ".-..", "--", "-.",
"---", ".--.", "--.-", ".-.", "...", "-", "..-",
"...-", ".--", "-..-", "-.--", "--.."]

You are given an array of strings named words, where each word can be represented as a concatenation of the Morse code for each of its letters. For example, the word "cab" can be represented as "-.-..--...", which is the concatenation of "-.-.", ".-", and "-...". This concatenated Morse code representation is referred to as the "transformation" of a word.

Your task is to count the number of different transformations that can be obtained from all the words in the given array.

Example 1

Input: words = ["gin","zen","gig","msg"]
Output: 2
Explanation: The transformation of each word is:
"gin" -> "--...-."
"zen" -> "--...-."
"gig" -> "--...--."
"msg" -> "--...--."
There are 2 different transformations: "--...-." and "--...--.".

Example 2

Input: words = ["a"]
Output: 1

Constraints

• 1 <= words.length <= 100.

• 1 <= words[i].length <= 12.

• words[i] consists of lowercase English letters.

Solution: Store the transformations in a set

Code

#include <iostream>
#include <vector>
#include <unordered_set>
using namespace std;
int uniqueMorseRepresentations(vector<string>& words) 
{
    vector<string> morse{
        ".-", "-...", "-.-.", "-..", ".", "..-.", "--.",
        "....", "..", ".---", "-.-", ".-..", "--", "-.",
        "---", ".--.", "--.-", ".-.", "...", "-", "..-",
        "...-", ".--", "-..-", "-.--", "--.."
    };
    unordered_set<string> transformations;
    for (string& w : words) 
    {
        string s{""};
        for (char& c : w) 
        {
            s += morse[c - 'a'];
        }
        transformations.insert(s);
    }
    return transformations.size();
}
int main() 
{
    vector<string> words{"gin","zen","gig","msg"};
    cout << uniqueMorseRepresentations(words) << endl;
    words = {"a"};
    cout << uniqueMorseRepresentations(words) << endl;
}

Output:
2
1

Code explanation

1. The solution begins with a predefined mapping of lowercase English letters to their corresponding Morse code representations. The Morse code representations are stored in a vector called morse.

2. An unordered_set<string> transformations is used to store the unique Morse code representations generated from the input words. This set will automatically ensure that only unique representations are stored.

3. The code iterates through each word in the words vector. For each word, it initializes an empty string s to store the Morse code representation of that word.

4. It then iterates through each character in the word. For each character c in the word, it appends the corresponding Morse code representation (retrieved from the morse vector) for that character to the s string. The mapping is accessed using morse[c - 'a'].

5. After constructing the Morse code representation for the current word, it inserts the s string into the transformations set. If s is already present in the set, it will not be added again since sets only allow unique elements.

6. After processing all the words, the size of the transformations set is returned as the result. The size of the set corresponds to the number of unique Morse code representations generated from the input words.

Complexity

This solution converts each word into Morse code based on a predefined mapping and uses an unordered set to keep track of unique representations. By inserting each representation into the set, it automatically filters out duplicates. The final result is the size of the set, which represents the number of unique Morse code representations among the input words.

• Runtime: O(N*M), where N = words.length and M = words[i].length.

• Extra space: O(N).

Thanks for reading! Get my book "10 Classic Coding Challenges" for FREE.

You are given two non-empty linked lists representing two non-negative integers. The digits are stored in reverse order, and each of their nodes contains a single digit. Add the two numbers and return the sum as a linked list.

You may assume the two numbers do not contain any leading zero, except the number 0 itself.

Example 1

Input: l1 = [2,4,3], l2 = [5,6,4]
Output: [7,0,8]
Explanation: 342 + 465 = 807.

Example 2

Input: l1 = [0], l2 = [0]
Output: [0]

Example 3

Input: l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
Output: [8,9,9,9,0,0,0,1]

Constraints

• The number of nodes in each linked list is in the range [1, 100].

• 0 <= Node.val <= 9.

• It is guaranteed that the list represents a number that does not have leading zeros.

Solution: Addition With Remember

Perform the school addition calculation and store the result in one of the lists.

Without loss of generality, let us store the result in l1. Then you might need to extend it when l2 is longer than l1 and when the result requires one additional node (Example 3).

Code

#include <iostream>
struct ListNode {
    int val;
    ListNode *next;
    ListNode() : val(0), next(nullptr) {}
    ListNode(int x) : val(x), next(nullptr) {}
    ListNode(int x, ListNode *next) : val(x), next(next) {}
};

ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
    ListNode prehead;               // dummy node to hook the head of the list
    ListNode* node = l1;            // store result on l1
    prehead.next = node;
    int sum = 0;
    while (node) {
        if (l1) {
            sum += l1->val;
            l1 = l1->next;
        }
        if (l2) {
            sum += l2->val;
            l2 = l2->next;
        }
        node->val = sum % 10;
        sum /= 10;
        if (!l1) {        // l1 ends
            if (l2) {               // l1 is shorter than l2
                node->next = l2;
            } else if (sum == 1) {  // both l1 and l2 end but the remember is not zero 
                ListNode* newNode = new ListNode(sum);
                node->next = newNode;
            }
        }
        node = node->next;
    }
    return prehead.next;
}
void printResult(ListNode* l) {
    std::cout << "[";
    while (l) {
        std::cout << l->val << ",";
        l = l->next;
    }
    std::cout << "]\n";
}
int main() {
    {
        ListNode three(3);
        ListNode four1(4, &three);
        ListNode two(2, &four1);
        ListNode four2(4);
        ListNode six(6, &four2);
        ListNode five(5, &six);
        printResult(addTwoNumbers(&two, &five));
    }
    {
        ListNode zero1(0);
        ListNode zero2(0);
        printResult(addTwoNumbers(&zero1, &zero2));
    }
    {
        ListNode nine0(9);
        ListNode nine1(9, &nine0);
        ListNode nine2(9, &nine1);
        ListNode nine3(9, &nine2);
        ListNode nine4(9, &nine3);
        ListNode nine5(9, &nine4);
        ListNode nine6(9, &nine5);
        ListNode nine7(9);
        ListNode nine8(9, &nine7);
        ListNode nine9(9, &nine8);
        ListNode nine10(9, &nine9);
        printResult(addTwoNumbers(&nine6, &nine10));
    }
}

Output:
[7,0,8,]
[0,]
[8,9,9,9,0,0,0,1,]

This solution efficiently adds two numbers represented as linked lists by iterating through both linked lists, digit by digit, and calculating the sum and carry. It also handles different scenarios for the lengths of the input lists and any remaining carry values.

Complexity

• Runtime: O(N), where N = max(l1.length, l2.length).

• Extra space: O(1).

Thanks for reading! Get my book "10 Classic Coding Challenges" for FREE.

This comprehensive guide will walk you through a step-by-step approach to solving coding challenges. It helped me prepare for the coding interviews and land several jobs in my dev career.

1. Understand the Problem

The first and most crucial step in solving any coding challenge is thoroughly understanding the problem statement. To do this:

• Read Carefully: Begin by reading the problem statement carefully. Pay attention to all the details, requirements, and constraints.

• Sample Inputs and Outputs: Review the sample inputs and outputs provided in the problem statement. This will help you understand the expected behavior of your solution.

• Clarify Ambiguities: If you encounter any ambiguities or uncertainties in the problem statement, don't hesitate to seek clarification. Contact the challenge provider or your instructor to ensure you clearly understand the problem.

2. Plan Your Approach

Before you start writing code, it's essential to plan your approach. Consider the following strategies:

• Break It Down: If the problem seems complex, break it down into smaller, more manageable subproblems. Solving each subproblem individually can make the overall task more achievable.

• Data Structures and Algorithms: Think about the data structures and algorithms you might use. Choose the most suitable ones based on the problem's requirements. This step is crucial for optimizing your solution.

• Edge Cases: Identify potential edge cases and corner cases for the problem. Consider how your code should handle these situations. It's often a good idea to address these cases later in your solution.

3. Pseudocode

I always write down my ideas before typing code.

Before diving into coding, creating a pseudocode or an outline of the steps you plan to take is helpful. Pseudocode helps you structure your thoughts and provides a roadmap for your coding journey. While writing pseudocode:

• Use plain language to describe the steps concisely.

• Avoid detailed syntax; focus on the algorithm's logic.

• Make sure your pseudocode captures the essential elements of your solution.

4. Write Code

With a clear plan and pseudocode, it's time to start writing the actual code. Follow these guidelines:

• Use a Familiar Language: Stick to a programming language you're comfortable with. You'll be more efficient and effective when working with a language you know well.

• Follow Your Plan: Translate your pseudocode or plan into actual code. Try to maintain a one-to-one correspondence between your plan and your code. This can help you stay organized and reduce the chances of making mistakes.

• Clean Code: Write clean and well-organized code. Use meaningful variable names and include comments to explain your code's purpose and any complex logic.

5. Test Your Code

Testing is a critical part of the coding challenge process. Thoroughly test your code to ensure it behaves correctly under various conditions. Here's how to approach testing:

• Test with Sample Inputs: Test your code with the sample inputs and outputs in the problem statement. This helps you verify that your code meets the basic requirements.

• Edge Cases: Test your code with edge cases, such as empty inputs, minimum and maximum possible values, or any other unusual situations. This ensures your code handles exceptional scenarios gracefully.

• Debugging: If you encounter errors or unexpected behavior during testing, use tools and techniques to identify and resolve issues. Pay attention to error messages and use print statements or debugging tools to trace the code's execution.

6. Optimize and Refactor

Once your code passes the initial tests, consider optimizing it for efficiency. Optimization involves improving the code's runtime performance and memory usage. Here are some optimization techniques:

• Algorithmic Optimization: Revisit the algorithms and data structures you chose. Can more efficient alternatives achieve the same results with fewer resources?

• Time and Space Complexity: Analyze your code's time and space complexity. Aim to reduce these complexities by optimizing loops, reducing redundant computations, and minimizing memory usage.

• Benchmarking: Compare the performance of your code with various inputs. Benchmarking can help you identify bottlenecks and areas for improvement.

Remember that optimization should come after your code is correct. Don't sacrifice correctness for premature optimization.

7. Documentation

Documentation is often overlooked but plays a crucial role in code quality and readability. When documenting your code:

• Add comments to explain the purpose of functions, classes, and complex code segments.

• Include comments for any non-trivial logic or algorithmic steps.

• Write clear and concise docstrings for functions, describing their inputs, outputs, and usage.

Adequate documentation makes it easier for others to understand and maintain your code. It's also helpful for future reference when you revisit your code.

8. Review and Proofread

Before your coding challenge is complete, take some time to review and proofread your code. Here's what to look for:

• Errors and Bugs: Carefully review your code for syntax errors, logical issues, or runtime exceptions.

• Compliance with Requirements: Double-check that your solution meets all the requirements in the problem description.

• Code Style: Ensure your code adheres to a consistent code style, such as using proper indentation, following naming conventions and using consistent formatting.

9. Submit or Share

The final step in solving a coding challenge depends on the context:

• Technical Interviews: If you're solving a coding challenge as part of a technical interview, be prepared to discuss your code and approach with the interviewer. Provide clear explanations of your thought process.

• Programming Competitions: You should submit your code as instructed in competitive programming or coding competitions. Make sure to follow the submission guidelines carefully.

• Personal Projects or Learning: If you're solving coding challenges for personal development or learning, consider sharing your solution with others through coding platforms or personal portfolios. Share instructions on how to run and test your code.

10. Reflect and Learn

After completing a coding challenge, take some time to reflect on your solution:

• Consider how you approached the problem. Were there any aha moments or insights during the process?

• Think about how you could have solved the problem differently or more efficiently.

• Identify areas where you encountered challenges or your knowledge is lacking, and use this as an opportunity to learn and grow.

11. Practice Regularly

The more you practice solving coding challenges, the more proficient you become. Regular practice is essential for honing your problem-solving skills and coding abilities. Consider these tips for effective practice:

• Variety of Challenges: Work on various coding challenges, including those related to data structures, algorithms, and specific domains (e.g., dynamic programming, graph theory, string manipulation).

• Online Platforms: Participate in online coding platforms like LeetCode, HackerRank, CodeSignal, or Project Euler. These platforms offer a wide range of challenges and a supportive community.

• Keep a Portfolio: To showcase your solutions and progress, consider maintaining a coding challenge portfolio. This can be beneficial for job applications and personal development.

• Competitions: If you're interested in competitive programming, participate in coding competitions like ACM ICPC or TopCoder's Single Round Matches.

I chose Leetcode for its extensive collection of diverse and well-crafted problems.

Remember that solving coding challenges is a skill that improves with practice. Don't be discouraged by complex challenges; each is an opportunity to learn and grow.

Conclusion

Solving coding challenges is an essential skill for programmers, whether you're preparing for a technical interview, honing your coding abilities, or participating in programming competitions. Following a structured approach, understanding the problem, planning your solution, writing clean code, testing rigorously, optimizing when necessary, and practicing regularly can enhance your problem-solving skills and help you become a more proficient coder.

Coding challenges provide a platform for continuous learning and self-improvement. Through regular practice and thoughtful reflection on your solutions, you can tackle increasingly complex challenges and gain confidence in your coding abilities.

So, embrace coding challenges as a valuable opportunity to learn, grow, and demonstrate your programming skills. Happy coding!

You're given an m x n grid represented as an integer array called grid. In this grid, there is a robot initially located at the top-left corner (i.e., grid[0][0]). The robot's goal is to move to the bottom-right corner (i.e., grid[m-1][n-1]). The robot can only move downwards or to the right at any given point.

The grid contains obstacles and empty spaces, which are marked as 1 or 0 respectively. The robot cannot pass through squares marked as obstacles.

Your task is determining the number of unique paths the robot can take to reach the bottom-right corner while avoiding obstacles.

It's important to note that the test cases are designed in such a way that the answer will always be less than or equal to 2 * 10^9.

Example 1

Input: obstacleGrid = [[0,0,0],[0,1,0],[0,0,0]]
Output: 2
Explanation: There is one obstacle in the middle of the 3x3 grid above.
There are two ways to reach the bottom-right corner:
1. Right -> Right -> Down -> Down
2. Down -> Down -> Right -> Right

Example 2

Input: obstacleGrid = [[0,1],[0,0]]
Output: 1

Constraints

• m == obstacleGrid.length.

• n == obstacleGrid[i].length.

• 1 <= m, n <= 100.

• obstacleGrid[i][j] is 0 or 1.

Solution: Dynamic programming in place

Let us find the relationship between the positions.

If there is no obstacle at the position (row = i, col = j), the number of paths np[i][j] that the robot can take to reach this position is:

np[i][j] = np[i - 1][j] + np[i][j - 1]

• As long as there is no obstacle in the first row, np[0][j] = 1. Otherwise, np[0][k] = 0 for all k >= j0, where (0, j0) is the position of the first obstacle in the first row.

• Similarly, as long as there is no obstacle in the first column, np[i][0] = 1. Otherwise, np[k][0] = 0 for all k >= i0, where (i0, 0) is the position of the first obstacle in the first column.

Code

#include <vector>
#include <iostream>
using namespace std;
int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) 
{
    const int row = obstacleGrid.size();
    const int col = obstacleGrid[0].size();
    vector<vector<int>> np(row, vector<int>(col, 0));    
    for (int i = 0; i < row && obstacleGrid[i][0] == 0; i++) 
    {
        np[i][0] = 1;
    }    
    for (int j = 0; j < col && obstacleGrid[0][j] == 0; j++) 
    {
        np[0][j] = 1;
    }
    for (int i = 1; i < row; i++) 
    {
        for (int j = 1; j < col; j++) 
        {
            if (obstacleGrid[i][j] == 0) 
            {
                np[i][j] = np[i - 1][j] + np[i][j - 1];
            }
        }
    }
    return np[row - 1][col - 1]; 
}
int main() 
{
    vector<vector<int>> obstacleGrid = {{0,0,0},{0,1,0},{0,0,0}};
    cout << uniquePathsWithObstacles(obstacleGrid) << endl;
    obstacleGrid = {{0,1},{0,0}};
    cout << uniquePathsWithObstacles(obstacleGrid) << endl;
}

Output:
2
1

Code explanation

This solution computes the number of unique paths in an m x n grid with obstacles using dynamic programming. It initializes a 2D vector np of the same size as obstacleGrid to store the number of unique paths for each cell.

First, it initializes the top row and left column of np. If there are no obstacles in the top row or left column of obstacleGrid, it sets the corresponding cells in np to 1 because there's only one way to reach any cell in the top row or left column.

Then, it iterates through the grid starting from the second row and second column (i.e., indices (1, 1)). For each cell, if there's no obstacle (obstacleGrid[i][j] == 0), it updates the value in np by summing up the values from the cell directly above it and the cell to the left of it. This step efficiently accumulates the number of unique paths while avoiding obstacles.

Finally, the value at np[row-1][col-1] contains the total number of unique paths to reach the bottom-right corner of the grid, which is returned as the result.

Complexity

The time complexity of this solution is O(m*n), where m and n are the grid dimensions, as it iterates through all grid cells once to compute the unique paths efficiently. Dynamic programming avoids redundant calculations and makes this solution efficient even for large grids.

• Runtime: O(m*n).

• Extra space: O(m*n).

Thanks for reading! Get my book "10 Classic Coding Challenges" for FREE.

You have a string called s. Your objective is to locate the index of the first character in the string that does not repeat anywhere else in the string. If such a character doesn't exist, return -1.

Example 1

Input: s = "leetcode"
Output: 0

Example 2

Input: s = "loveleetcode"
Output: 2

Example 3

Input: s = "aabb"
Output: -1

Constraints

• 1 <= s.length <= 10^5.

• s consists of only lowercase English letters.

Solution 1: Using a map to store the appearances

Code

#include <iostream>
#include <unordered_map>
using namespace std;
int firstUniqChar(string s) 
{
    unordered_map<char, int> count;
    for (char& c : s) 
    {
        count[c]++;
    }
    for (int i = 0; i < s.length(); i++) 
    {
        if (count[s[i]] == 1) 
        {
            return i;
        }
    }
    return -1;
}
int main() 
{
    cout << firstUniqChar("leetcode") << endl;
    cout << firstUniqChar("loveleetcode") << endl;
    cout << firstUniqChar("aabb") << endl;
}

Output:
0
2
-1

Code explanation

1. The code initializes an unordered map count where characters from the string are keys, and their corresponding counts (how many times they appear in the string) are values.

2. The loop then iterates through the characters of the string s. For each character c encountered, it increments its count in the count map.

3. After counting all the characters in the string, it performs a second loop, this time using an index variable i that starts from 0 and goes up to the length of the string s.

4. In this loop, it checks whether the count of the character at the current index i is equal to 1. If it is, this means that the character is unique in the string, and the function returns i, which is the index of the first occurrence of that unique character.

5. If no unique character is found during the loop, the function returns -1 to indicate that there are no unique characters in the string.

Complexity

This solution has a time complexity of O(n), where n is the length of the string s, because it iterates through the string twice: once to count the characters and once to find the first unique character.

It also has a space complexity of O(k), where k is the number of distinct characters in the string, as it stores character counts in the count unordered map. As the problem considers only lowercase English letters, k = 26, you can give it O(1) complexity.

• Runtime: O(n), where n = s.length.

• Extra space: O(k), where k is the number of distinct characters in the string. If k=26, it is O(1).

Solution 2: Using an array to store the appearances

From the constraints "s consists of only lowercase English letters", you can use an array of 26 elements to store the counts.

Code

#include <iostream>
#include <vector>
using namespace std;
int firstUniqChar(string s) 
{
    // initializes an array of 26 elements, all set to zero
    std::array<int, 26> count{};
    for (char& c : s) 
    {
        count[c - 'a']++;
    }
    for (int i = 0; i < s.length(); i++) 
    {
        if (count[s[i] - 'a'] == 1) 
        {
            return i;
        }
    }
    return -1;
}
int main() 
{
    cout << firstUniqChar("leetcode") << endl;
    cout << firstUniqChar("loveleetcode") << endl;
    cout << firstUniqChar("aabb") << endl;
}

Output:
0
2
-1

Complexity

• Runtime: O(n), where n = s.length.

• Extra space: O(1) as the array's length is fixed 26.

Thanks for reading! Get my book "10 Classic Coding Challenges" for FREE.

Roman numerals are represented by seven symbols: I, V, X, L, C, D, and M.

Symbol       Value
I             1
V             5
X             10
L             50
C             100
D             500
M             1000

For example, 2 is written as II in Roman numeral, just two ones added together. 12 is written as XII, which is simply X + II. The number 27 is written as XXVII, which is XX + V + II.

Roman numerals are usually written from largest to smallest and from left to right. However, the numeral for four is not IIII. Instead, the number four is written as IV. Because the one is before the five we subtract it making four. The same principle applies to the number nine, which is written as IX. There are six instances where subtraction is used:

• I can be placed before V (5) and X (10) to make 4 and 9.

• X can be placed before L (50) and C (100) to make 40 and 90.

• C can be placed before D (500) and M (1000) to make 400 and 900.

Given a Roman numeral, convert it to an integer.

Example 1

Input: s = "III"
Output: 3
Explanation: III = 3.

Example 2

Input: s = "LVIII"
Output: 58
Explanation: L = 50, V = 5, III = 3.

Example 3

Input: s = "MCMXCIV"
Output: 1994
Explanation: M = 1000, CM = 900, XC = 90 and IV = 4.

Constraints

• 1 <= s.length <= 15.

• s contains only the characters 'I', 'V', 'X', 'L', 'C', 'D', 'M'.

• It is guaranteed that s is a valid Roman numeral in the range [1, 3999].

Solution: Mapping and summing the values

And to treat the subtraction cases easier, you can iterate the string s backward.

Code

#include <iostream>
#include <unordered_map>
using namespace std;
int romanToInt(string s) {
    unordered_map<char, int> value = {
        {'I', 1},
        {'V', 5},
        {'X', 10},
        {'L', 50},
        {'C', 100},
        {'D', 500},
        {'M', 1000}
    };
    int i = s.length() - 1;
    int result = value[s[i--]];
    while (i >= 0) {
        if (value[s[i]] < value[s[i+1]]) {
            result -= value[s[i--]]; 
        } else {
            result += value[s[i--]];
        }
    }
    return result;
}
int main() {
    cout << romanToInt("III") << endl;
    cout << romanToInt("LVIII") << endl;
    cout << romanToInt("MCMXCIV") << endl;
}

Output:
3
58
1994

This solution efficiently converts a Roman numeral string into an integer by iterating through the string from right to left and applying the rules of Roman numerals, where subtractive combinations are subtracted and additive combinations are added to calculate the total value. The unordered map is used to look up the values of Roman numerals.

Complexity

• Runtime: O(N) where N = s.length.

• Extra space: O(1) (the map value is very small).

Conclusion

The problem is about encoding/decoding between a string and an integer, you could use an unordered_map here.

This is a very interesting problem since it is about history and mathematics. You can read more about it on Wikipedia.

Thanks for reading. Check out my book “10 Classic Coding Challenges” for FREE*.*

Given two strings s and t, return true if t is an anagram of s, and false otherwise.

An Anagram is a word or phrase formed by rearranging the letters of a different word or phrase, typically using all the original letters exactly once.

Example 1

Input: s = "anagram", t = "nagaram"
Output: true

Example 2

Input: s = "rat", t = "car"
Output: false

Constraints

• 1 <= s.length, t.length <= 5 * 10^4.

• s and t consist of lowercase English letters.

Follow up: What if the inputs contain Unicode characters? How would you adapt your solution to such a case?

Solution 1: Rearrange both s and t into a sorted string

Code

#include <iostream>
#include <algorithm>
using namespace std;
bool isAnagram(string s, string t) {
    if (s.length() != t.length()) {
        return false;
    }
    sort(s.begin(), s.end());
    sort(t.begin(), t.end());
    return s == t;
}
int main() {
    cout << isAnagram("anagram", "nagaram") << endl;
    cout << isAnagram("rat", "car") << endl;
}

Output:
1
0

Complexity

• Runtime: O(NlogN), where N = s.length.

• Extra space: O(1).

Solution 2: Count the appearances of each letter

Code

#include <iostream>
using namespace std;
bool isAnagram(string s, string t) {
    if (s.length() != t.length()) {
        return false;
    }
    int alphabet[26];
    for (int i = 0; i < 26; i++) {
        alphabet[i] = 0;
    }
    for (char& c : s) {
        alphabet[c - 'a']++;
    }
    for (char& c : t) {
        alphabet[c - 'a']--;
        if (alphabet[c - 'a'] < 0) {
            return false;
        }
    }
    return true;    
}
int main() {
    cout << isAnagram("anagram", "nagaram") << endl;
    cout << isAnagram("rat", "car") << endl;
}

Output:
1
0

Complexity

• Runtime: O(N), where N = s.length.

• Extra space: O(1).

Solution 3: If the inputs contain Unicode characters

In the solutions above, the array alphabet represents 26 letters 'a' to 'z'. You can generalize to allow it contains any character by using a map.

Code

#include <iostream>
#include <unordered_map>
using namespace std;
bool isAnagram(string s, string t) {
    if (s.length() != t.length()) {
        return false;
    }
    unordered_map<char, int> alphabet;
    for (char& c : s) {
        alphabet[c]++;
    }
    for (char& c : t) {
        alphabet[c]--;
        if (alphabet[c] < 0) {
            return false;
        }
    }
    return true;    
}
int main() {
    cout << isAnagram("anagæam", "nagaæam") << endl;
    cout << isAnagram("rat", "car") << endl;
}

Output:
1
0

Complexity

• Runtime: O(N), where N = s.length.

• Extra space: O(1).

Key takeaway

• An array of 26 integers can represent the English alphabet.

• Counting the appearances can help identify if a word is a permutation of another.

• You can use a map to count the appearances of the letters of a word.

Thanks for reading! Get my book "10 Classic Coding Challenges" for FREE.

Given an integer array nums of unique elements, return all possible subsets (the power set).

The solution set must not contain duplicate subsets. Return the solution in any order.

Example 1

Input: nums = [1,2,3]
Output: [[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]

Example 2

Input: nums = [1]
Output: [[],[1]]

Constraints

• 1 <= nums.length <= 10.

• -10 <= nums[i] <= 10.

• All the numbers of nums are unique..

Solution

You might need to find the relationship between the result of the array nums with the result of itself without the last element.

Example 3

Input: nums = [1,2]
Output: [[],[1],[2],[1,2]]

You can see the powerset of Example 3 was obtained from the one in Example 2 with additional subsets [2], [1,2]. These new subsets were constructed from subsets [], [1] of Example 2 appended with the new element 2.

Similarly, the powerset of Example 1 was obtained from the one in Example 3 with the additional subsets [3], [1,3], [2,3], [1,2,3]. These new subsets were constructed from the ones of Example 3 appended with the new element 3.

Code

#include <vector>
#include <iostream>
using namespace std;
vector<vector<int>> subsets(vector<int>& nums) {
    vector<vector<int>> powerset = {{}};
    int i = 0;
    while (i < nums.size()) {
        vector<vector<int>> newSubsets;
        for (auto subset : powerset) {
            subset.push_back(nums[i]);  
            newSubsets.push_back(subset);
        }
        powerset.insert(powerset.end(), newSubsets.begin(), newSubsets.end());
        i++;
    }
    return powerset;
}
void print(vector<vector<int>>& powerset) {
    for (auto& set : powerset ) {
        cout << "[";
        for (auto& element : set) {
            cout << element << ",";
        }
        cout << "]";
    }
    cout << endl;
}
int main() {
    vector<int> nums{1,2,3};
    auto powerset = subsets(nums);
    print(powerset);
    nums = {1};
    powerset = subsets(nums);
    print(powerset);
}

Output:
[][1,][2,][1,2,][3,][1,3,][2,3,][1,2,3,]
[][1,]

Code explanation

1. The code initializes an empty vector of vectors called powerset to store the subsets. It starts with an initial subset containing an empty vector, representing the empty set: {{}}.

2. Within the loop, it creates a new vector of vectors called newSubsets to store subsets that include the i-th element of nums.

3. It iterates through the existing subsets in powerset. For each subset, it creates a copy of it (represented by the subset variable), adds the i-th element from nums to the copied subset, and pushes the modified subset into the newSubsets vector.

4. After processing all existing subsets, the code adds the contents of newSubsets to the powerset vector. This effectively combines the current subsets with subsets that include the i-th element of nums.

5. It repeats steps 2-4 until all elements in nums have been considered.

6. Finally, the code returns the powerset, which now contains all possible subsets of nums.

Complexity

This code essentially generates subsets by iteratively adding each element of nums to the existing subsets and accumulating the results. The time complexity of this code is O(2^N), where N is the number of elements in nums, as it generates all possible subsets. The space complexity is also O(2^N) due to the space required to store the subsets.

• Runtime: O(2^N).

• Extra space: O(2^N).

Thanks for reading. Feel free to share your thought about my content and check out my FREE book 10 Classic Coding Challenges.

Given an integer array nums already sorted in non-decreasing order, you must remove duplicates so that each unique element appears at most twice. The relative order of the elements should remain unchanged.

Since changing the array's length in some programming languages is impossible, you must place the result in the first part of the nums array. In other words, if there are k elements after removing the duplicates, the first k elements of nums should contain the final result. Anything beyond the first k elements is not important.

You should return the value of k after placing the final result in the first k slots of the nums array.

The key requirement is to accomplish this task without using extra space for another array. It must be done by modifying the input array nums in-place, using only O(1) extra memory.

Example 1

Input: nums = [1,1,1,2,2,3]
Output: 5, nums = [1,1,2,2,3,_]
Explanation: Your function should return k = 5, with the first five elements of nums being 1, 1, 2, 2, and 3, respectively.
What you leave does not matter beyond the returned k (hence, they are underscores).

Example 2

Input: nums = [0,0,1,1,1,1,2,3,3]
Output: 7, nums = [0,0,1,1,2,3,3,_,_]
Explanation: Your function should return k = 7, with the first seven elements of nums being 0, 0, 1, 1, 2, 3, and 3, respectively.
What you leave does not matter beyond the returned k (hence, they are underscores).

Constraints

• 1 <= nums.length <= 3 * 10^4.

• -10^4 <= nums[i] <= 10^4.

• nums is sorted in non-decreasing order.

Solution 1: Erasing the duplicates

In order for each unique element to appear at most twice, you have to erase the further appearances if they exist.

Since the array nums is sorted, you can determine that existence by checking if nums[i] == nums[i-2] for 2 <= i < nums.length.

Code

#include <vector>
#include <iostream>
using namespace std;
int removeDuplicates(vector<int>& nums) 
{
    int i = 2;
    while (i < nums.size()) 
    {
        if (nums[i] == nums[i-2]) 
        {
            int j = i;
            while (j < nums.size() && nums[j] == nums[i]) 
            {
                j++;
            }
            nums.erase(nums.begin() + i, nums.begin() + j);
        } 
        else 
        {
            i++;
        }
    }
    return nums.size();
}
void printResult(const int k, const vector<int>& nums) 
{
    cout << k << ", [";
    for (int i = 0; i < k ; i++) 
    {
        cout << nums[i] << ",";
    }
    cout << "]\n";
}
int main() 
{
    vector<int> nums{1,1,1,2,2,3};
    printResult(removeDuplicates(nums), nums);
    nums = {0,0,1,1,1,1,2,3,3};
    printResult(removeDuplicates(nums), nums);
}

Output:
5, [1,1,2,2,3,]
7, [0,0,1,1,2,3,3,]

Code explanation

1. Inside the loop, it checks if the element at index i is equal to the element two positions before it.

2. If the condition is met, there are more than two occurrences of the current element. We need to remove the excess duplicates while preserving two instances. To do this, a second while loop is used until the duplicate elements are no longer found. At this point, j will be the index of the first element that differs from the current element.

3. After finding the range of duplicate elements to remove (from index i to j-1, inclusive), it uses the vector's erase function to remove these elements from the nums array. This effectively keeps only two instances of the current element.

4. If the condition in step 2 is not met (i.e., there are at most two occurrences of the current element), it moves the index i to the next unique element in the array.

5. Repeat steps 2 to 4 until i has traversed the entire array. The while loop removes all duplicate elements beyond two occurrences while maintaining the order of unique elements.

6. Once the loop finishes, the nums array contains unique elements with at most two occurrences of each. Return the size of the modified array using nums.size().

This solution efficiently removes duplicates from the sorted array by checking for duplicates and erasing the excess occurrences while preserving two instances of each unique element. It then returns the length of the modified array.

Complexity

• Runtime:

  • Worst case: O(N^2/3), where N = nums.size(). The complexity of the erase() method is linear in N. The worst case is when erase() is called maximum N/3 times.

    Example of the worst case:
    nums = [1,1,1,2,2,2,3,3,3,4,4,4,5,5,5,6,6,6].

• On average: O(N) since the number of erase() calls is O(1).

• Extra space: O(1).

Solution 2: Reassigning the satisfying elements

You might need to avoid the erase() method in the solution above to reduce the complexity. Moreover, after removing the duplicates, the problem only cares about the first k elements of the array nums.

If you look at the final result after removing duplication, the expected nums satisfies

nums[i] > nums[i-2] for 2 <= i < nums.length.

You can use this invariant to reassign the array nums only the satisfied elements.

Code

#include <vector>
#include <iostream>
using namespace std;
int removeDuplicates(vector<int>& nums) 
{
    if (nums.size() <= 2) 
    {
        return nums.size(); 
    } 
    int k = 2; 
    int i = 2;
    while (i < nums.size()) 
    {
        if (nums[i] > nums[k - 2]) 
        {
            nums[k++] = nums[i];
        }
        i++;
    }
    return k;
}
void printResult(const int k, const vector<int>& nums) 
{
    cout << k << ", [";
    for (int i = 0; i < k ; i++) 
    {
        cout << nums[i] << ",";
    }
    cout << "]\n";
}
int main() 
{
    vector<int> nums{1,1,1,2,2,3};
    printResult(removeDuplicates(nums), nums);
    nums = {0,0,1,1,1,1,2,3,3};
    printResult(removeDuplicates(nums), nums);
}

Output:
Output:
5, [1,1,2,2,3,]
7, [0,0,1,1,2,3,3,]

Code explanation

1. The code checks the size of the input array nums. If it has 2 or fewer elements, there's no need to perform any removals, so the function simply returns the size of the original array.

2. It initializes two variables:

   • k: This will represent the length of the resulting array after removing duplicates (initially set to 2 since we allow up to two occurrences of each element).

   • i: This is an iterator that starts from the array's third element (index 2) and is used to traverse the array.

3. It starts a loop that iterates from the third element (i = 2) to the end of the array.

4. Inside the loop, it compares the current element at index i with the element at k - 2. This comparison checks if the current element exceeds the previous two positions. If it is, this means it's a new element. Otherwise, it is a third occurrence of the same element, which we want to skip.

5. If the current element is greater than the element at index k - 2, it updates the element at index k with the current element. Then, it increments k to indicate that a new unique element has been found.

6. Continue iterating through the array by incrementing i.

7. Once the loop finishes, the array up to index k - 1 contains the unique elements with at most two occurrences each, and the rest of the array can be ignored.

8. Finally, return the value of k, which represents the length of the resulting array.

Complexity

This solution effectively modifies the input array in-place, removing duplicates that occur more than twice while maintaining the desired order of unique elements. It does so in a single pass through the array, resulting in a time complexity of O(N), where N is the number of elements in the array.

• Runtime: O(N), where N = nums.size().

• Extra space: O(1).

Thanks for reading. Check out my book 10 Classic Coding Challenges for free here.

Given the starting nodes of two sorted linked lists, list1 and list2, your task is to combine these lists into a single sorted linked list.

This merged list should be created by connecting the nodes from both list1 and list2. Finally, you should return the starting node of the resulting merged linked list.

Example 1

Input: list1 = [1,2,4], list2 = [1,3,4]
Output: [1,1,2,3,4,4]

Example 2

Input: list1 = [], list2 = []
Output: []

Example 3

Input: list1 = [], list2 = [0]
Output: [0]

Constraints

• The number of nodes in both lists is in the range [0, 50].

• -100 <= Node.val <= 100.

• Both list1 and list2 are sorted in non-decreasing order.

Solution: Constructing a new list

For each pair of nodes between the two lists, pick the node having a smaller value to append to the new list.

Code

#include <iostream>
struct ListNode {
    int val;
    ListNode *next;
    ListNode() : val(0), next(nullptr) {}
    ListNode(int x) : val(x), next(nullptr) {}
    ListNode(int x, ListNode *next) : val(x), next(next) {}
};

ListNode* mergeTwoLists(ListNode* list1, ListNode* list2) {
    if (list1 == nullptr) {
        return list2;
    } else if (list2 == nullptr) {
        return list1;
    }
    // identify which list is head
    ListNode* head = list1;
    if (list2->val < head->val) {
        head = list2;
        list2 = list2->next;
    } else {
        list1 = list1->next;
    }
    ListNode* node = head;
    while (list1 && list2) {
        if (list1->val < list2->val) {
            node->next = list1;
            list1 = list1->next;
        } else {
            node->next = list2;
            list2 = list2->next;
        }
        node = node->next;
    }
    if (list1 == nullptr) {
        node->next = list2;
    } else {
        node->next = list1;
    }
    return head;
}
void printResult(ListNode* head) {
    std::cout << "[";
    while (head) {
        std::cout << head->val << ",";
        head = head->next;
    }
    std::cout << "]\n";
}
int main() {   
    ListNode four1(4);
    ListNode two1(2, &four1);
    ListNode one1(1, &two1);
    ListNode four2(4);
    ListNode three2(3, &four2);
    ListNode one2(1, &three2);
    auto newOne = mergeTwoLists(&one1, &one2);
    printResult(newOne);

    auto empty = mergeTwoLists(nullptr, nullptr);
    printResult(empty);

    ListNode zero(0);
    auto z = mergeTwoLists(nullptr, &zero);
    printResult(z);
}

Output:
[1,1,2,3,4,4,]
[]
[0,]

Code explanation

1. The function begins with two base cases to handle situations where one of the input lists is empty:

   • If list1 is empty (i.e., list1 is nullptr), the function simply returns list2. There is no need to merge anything because list1 is empty.

   • Similarly, if list2 is empty (i.e., list2 is nullptr), the function returns list1.

2. A head pointer will be used to keep track of the merged list. The code determines which of list1 and list2 should be the head of the merged list. It does this by comparing the values of the first nodes in list1 and list2:

   • If the value of the first node in list2 is less than the value of the first node in list1, it means that list2 should be the new head of the merged list. The code updates the head pointer to point to list2, and it advances the list2 pointer to the next node.

   • If the value of the first node in list1 is less than or equal to the value in list2, list1 should be the new head. The code advances the list1 pointer to the next node.

3. The main merging process is performed using a while loop that continues as long as both list1 and list2 are not empty:

   • Inside the loop, the code compares the values of the first nodes in list1 and list2:

     • If the value in list1 is smaller, the code connects the current node pointed to by node to the node in list1, and advances list1 to its next node.

     • If the value in list2 is smaller or equal, the code connects the current node pointed to by node to the node in list2, and advances list2 to its next node.

   • After connecting a node, the node pointer is moved to the newly connected node.

4. After the while loop completes, one of the input lists may still have remaining elements. To ensure that all elements are included in the merged list, the code appends the remaining nodes from either list1 or list2 (whichever is not empty) to the end of the merged list.

5. Finally, the function returns head, which points to the head of the merged sorted linked list.

Complexity

• Runtime: O(N), where N = list1.length + list2.length.

• Extra space: O(1).

Thanks for reading. Feel free to share your thought about my content and check out my FREE book 10 Classic Coding Challenges.

Given an integer array nums of size n, return the minimum number of moves required to make all array elements equal.

In one move, you can increment or decrement an element of the array by 1.

Example 1

Input: nums = [1,2,3]
Output: 2
Explanation:
Only two moves are needed (remember each move increments or decrements one element):
[1,2,3]  =>  [2,2,3]  =>  [2,2,2]

Example 2

Input: nums = [1,10,2,9]
Output: 16

Constraints

• n == nums.length.

• 1 <= nums.length <= 10^5.

• -10^9 <= nums[i] <= 10^9.

Solution 1: Median - The math behind the problem

You are asked to move all elements of an array to the same value M. The problem can be reduced to identifying what M is.

First, moving elements of an unsorted array and moving a sorted one are the same. So you can assume nums is sorted in some order. Let us say it is sorted in ascending order.

Second, M must be in between the minimum element and the maximum one. Apparently!

We will prove that M will be the median of nums, which is nums[n/2] of the sorted nums.

In other words, we will prove that if you choose M a value different from nums[n/2], then the number of moves will be increased.

In fact, if you choose M = nums[n/2] + x, where x > 0, then:

• Each element nums[i] that is less than M needs more x moves, while each nums[j] that is greater than M can reduce x moves.

• But the number of nums[i] is bigger than the number of nums[j].

• So the total number of moves is bigger.

The same arguments apply for x < 0.

Example 3

For nums = [0,1,2,2,10]. Its median is 2. The minimum number of moves is 2 + 1 + 0 + 0 + 8 = 11.

If you choose M = 3 (the average value, the mean), the total number of moves is 3 + 2 + 1 + 1 + 7 = 14.

Code

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int minMoves2(vector<int>& nums) {
    sort(nums.begin(), nums.end());
    const int median = nums[nums.size() / 2];
    int moves = 0;
    for (int& a: nums) {
        moves += abs(a - median);
    }
    return moves;
}
int main() {
    vector<int> nums{1,2,3};
    cout << minMoves2(nums) << endl;
    nums = {1,10,2,9};
    cout << minMoves2(nums) << endl;
}

Output:
2
16

Complexity

• Runtime: O(nlogn), where n = nums.length.

• Extra space: O(1).

Solution 2: Using std::nth_element to compute the median

What you only need in Solution 1 is the median value. Computing the total number of moves in the for loop does not require the array nums to be fully sorted.

In this case, you can use std::nth_element to reduce the runtime complexity.

Code

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int minMoves2(vector<int>& nums) {
    const int mid = nums.size() / 2;    
    std::nth_element(nums.begin(), nums.begin() + mid, nums.end());
    const int median = nums[mid];
    int moves = 0;
    for (int& a: nums) {
        moves += abs(a - median);
    }
    return moves;
}
int main() {
    vector<int> nums{1,2,3};
    cout << minMoves2(nums) << endl;
    nums = {1,10,2,9};
    cout << minMoves2(nums) << endl;
}

Output:
2
16

Complexity

• Runtime: O(n), where n = nums.length.

• Extra space: O(1).

Modern C++ notes

In the code of Solution 2, the partial sorting algorithm std::nth_element will make sure for all indices i and j that satisfy 0 <= i <= mid <= j < nums.length,

nums[i] <= nums[mid] <= nums[j].

With this property, if mid = nums.length / 2, then the value of nums[mid] is unchanged no matter how nums is sorted or not.

What is your approach? The problem was picked from leetcode.com. You can submit your solution in any programming language and check the performance.

Thanks for reading. Feel free to share your thought about my content and check out my FREE book 10 Classic Coding Challenges.

A string s is called good if there are no two different characters in s that have the same frequency.

Given a string s, return the minimum number of characters you need to delete to make s good.

The frequency of a character in a string is the number of times it appears in the string. For example, in the string "aab", the frequency of 'a' is 2, while the frequency of 'b' is 1.

Example 1

Input: s = "aab"
Output: 0
Explanation: s is already good.

Example 2

Input: s = "aaabbbcc"
Output: 2
Explanation: You can delete two 'b's resulting in the good string "aaabcc".
Another way is to delete one 'b' and one 'c' resulting in the good string "aaabbc".

Example 3

Input: s = "ceabaacb"
Output: 2
Explanation: You can delete both 'c's resulting in the good string "eabaab".
Note that we only care about characters that are still in the string at the end (i.e. frequency of 0 is ignored).

Constraints

• 1 <= s.length <= 10^5.

• s contains only lowercase English letters.

Solution: Delete the frequencies in sorted order

Your goal is to make all the frequencies different.

One way of doing that is by sorting the frequencies and performing the deletion.

Example 4

For s = "ceaacbb", the frequencies of the characters are: freq['a'] = 2, freq['b'] = 2, freq['c'] = 2 and freq['e'] = 1. They are already in sorted order.

• Let the current frequency be the first frequency freq['a'] = 2.

• The next frequency is freq['b'] = 2, equal to the current frequency. Delete one appearance to make the current frequency be 1.

• The next frequency is freq['c'] = 2, bigger than the current frequency. Delete two appearances to make the current frequency be 0.

• Because the current frequency is 0, delete all appearances of the remaining frequencies, which is freq['e'] = 1.

• In total, there are 4 deletions.

Code

#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int minDeletions(string s) {
    vector<int> freq(26, 0);
    for (char& c: s) {
        freq[c - 'a']++;
    }
    sort(freq.begin(), freq.end(), greater<int>());
    int deletion = 0;
    int currentFreq = freq[0];
    for (int i = 1; i < freq.size() && freq[i] > 0; i++) {
        if (currentFreq == 0) {
            deletion += freq[i];
        } else if (freq[i] >= currentFreq) {
            deletion += freq[i] - currentFreq + 1;
            currentFreq--;
        } else {
            currentFreq = freq[i];
        }
    }
    return deletion;
}
int main() {
    cout << minDeletions("aab") << endl;
    cout << minDeletions("aaabbbcc") << endl;
    cout << minDeletions("ceabaacb") << endl;
}

Output:
0
2
2

Complexity

• Runtime: O(N), where N = s.length;

• Extra space: O(1) since 26 is not a big number.

What is your approach? The problem was picked from leetcode.com. You can submit your solution in any programming language and check the performance.

Thanks for reading. Feel free to share your thought about my content and check out my FREE book 10 Classic Coding Challenges.*

You are assigned to put some amount of boxes onto one truck. You are given a 2D array boxTypes, where boxTypes[i] = [numberOfBoxes_i, numberOfUnitsPerBox_i]:

• numberOfBoxes_i is the number of boxes of type i.

• numberOfUnitsPerBox_i is the number of units in each box of the type i.

You are also given an integer truckSize, which is the maximum number of boxes that can be put on the truck. You can choose any boxes to put on the truck as long as the number of boxes does not exceed truckSize.

Return the maximum total number of units that can be put on the truck.

Example 1

Input: boxTypes = [[1,3],[2,2],[3,1]], truckSize = 4
Output: 8
Explanation: There are:
- 1 box of the first type that contains 3 units.
- 2 boxes of the second type that contain 2 units each.
- 3 boxes of the third type that contain 1 unit each.
You can take all the boxes of the first and second types, and one box of the third type.
The total number of units will be = (1 * 3) + (2 * 2) + (1 * 1) = 8.

Example 2

Input: boxTypes = [[5,10],[2,5],[4,7],[3,9]], truckSize = 10
Output: 91
Explanation: (5 * 10) + (3 * 9) + (2 * 7) = 91.

Constraints

• 1 <= boxTypes.length <= 1000.

• 1 <= numberOfBoxes_i, numberOfUnitsPerBox_i <= 1000.

• 1 <= truckSize <= 10^6.

Solution: Greedy algorithm

Put the boxes having more units first.

Code

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int maximumUnits(vector<vector<int>>& boxTypes, int truckSize) {
    // sort for the boxes based on their number of units
    sort(boxTypes.begin(), boxTypes.end(), [](const vector<int>& a, const vector<int>& b) {
        return a[1] > b[1];
    });
    int maxUnits = 0;
    int i = 0;
    while (truckSize > 0 && i < boxTypes.size()) {
        if (boxTypes[i][0] <= truckSize) {
            maxUnits += boxTypes[i][0] * boxTypes[i][1];
            truckSize -= boxTypes[i][0];
        } else {
            maxUnits += truckSize * boxTypes[i][1];
            break;
        }
        i++;
    }
    return maxUnits;
}
int main() {
    vector<vector<int>> boxTypes{{1,3},{2,2},{3,1}};
    cout << maximumUnits(boxTypes, 4) << endl;
    boxTypes = {{5,10},{2,5},{4,7},{3,9}};
    cout << maximumUnits(boxTypes, 10) << endl;
}

Output:
8
91

Complexity

• Runtime: O(NlogN), where N = boxTypes.length.

• Extra space: O(1).

Modern C++ STL notes

Note that two vectors can be compared. That is why you can sort them.

But in this case you want to sort them based on the number of units. That is why you need to define the comparison function like the code above. Otherwise, the sort algorithm will use the dictionary order to sort them by default.

What is your approach? The problem was picked from leetcode.com. You can submit your solution in any programming language and check the performance.

Thanks for reading. Feel free to share your thought about my content and check out my FREE book 10 Classic Coding Challenges.

Given an integer n, return the least number of perfect square numbers that sum to n.

A perfect square is an integer that is the square of an integer; in other words, it is the product of some integer with itself. For example, 1, 4, 9, and 16 are perfect squares while 3 and 11 are not.

Example 1

Input: n = 9
Output: 1
Explanation: 9 is already a perfect square.

Example 2

Input: n = 13
Output: 2
Explanation: 13 = 4 + 9.

Example 3

Input: n = 7
Output: 4
Explanation: 7 = 4 + 1 + 1 + 1.

Example 4

Input: n = 12
Output: 3
Explanation: 12 = 4 + 4 + 4.

Constraints

• 1 <= n <= 10^4.

Solution 1: Dynamic Programming

Let us call the function to be computed numSquares(n), which calculates the least number of perfect squares that sum to n.

Here are the findings.

1. If n is already a perfect square then numSquares(n) = 1.

2. Otherwise, it could be written as n = 1 + (n-1), or n = 4 + (n-4), or n = 9 + (n-9), etc. which means n is a sum of a perfect square (1, 4 or 9, etc.) and another number m < n. That leads to the problems numSquares(m) of smaller values m.

3. If you have gotten the results of the smaller problems numSquares(n-1), numSquares(n-4), numSquares(n-9), etc. then numSquares(n) = 1 + the minimum of those results.

Example 4

n = 12 is not a perfect square. It can be written as n = 1 + 11 = 4 + 8 = 9 + 3.

• For m = 11, it is not a perfect square and can be written as m = 1 + 10 = 4 + 7 = 9 + 2.

• For m = 8, it is not a perfect square and can be written as m = 1 + 7 = 4 + 4 (matched). You get numSquares(8) = 2.

• For m = 3, it is not a perfect square and can be written as m = 1 + 2.

You can continue to compute numSquares(m) for other values m in this recursive process. But you can see the case of m = 8 was already the best solution. And numSquares(12) = 1 + numSquares(8) = 1 + 2 = 3, which is the case of n = 12 = 4 + 4 + 4.

To improve runtime, you can apply dynamic programming to cache the numSquares(n) that you have computed.

Code

#include <iostream>
#include <cmath>
#include <unordered_map>
using namespace std;
int nsq(int n, unordered_map<int, int>& ns) {
    auto it = ns.find(n);
    if (it != ns.end()) {
        return it->second;
    }
    const int sq = sqrt(n);
    if (sq * sq == n) {
        ns[n] = 1;
        return 1;
    }
    int result = n;
    for (int i = 1; i <= sq; i++) {
        result = min(result, nsq(n - i*i, ns));
    }
    ns[n] = result + 1;
    return ns[n];
}
int numSquares(int n) {
    unordered_map<int, int> ns;
    return nsq(n, ns);
}
int main() {
    cout << numSquares(12) << endl;
    cout << numSquares(13) << endl;
}

Output:
3
2

Complexity

• Runtime: O(n^2).

• Extra space: O(n)

Solution 2: Number Theory

The dynamic programming solution above is good enough. But for those who are interested in Algorithmic Number Theory, there is a very interesting theorem that can solve the problem directly without recursion.

It is called Lagrange's Four-Square Theorem, which states

every natural number can be represented as the sum of four integer squares.

It was proven by Lagrange in 1770.

Example 4

n = 12 = 4 + 4 + 4 + 0 or 12 = 1 + 1 + 1 + 9.

Applying to our problem, numSquares(n) can only be 1, 2, 3, or 4. Not more.

It turns into the problem of

identifying when numSquares(n) returns 1, 2, 3, or 4.

Here are the cases.

1. If n is a perfect square, numSquares(n) = 1.

2. There is another theorem, Legendre's Three-Square Theorem, which states that numSquares(n) cannot be 1, 2, or 3 if n can be expressed as

    n = 4^a(8*b + 7),
   

   where a, b are nonnegative integers. In other words, numSquares(n) = 4 if n is of this form.

Example 3

n = 7 = 4^0(8*0 + 7). It can only be written as 7 = 4 + 1 + 1 + 1.

Code

#include <iostream>
#include <cmath>
using namespace std;
bool isSquare(int n) {
    int sq = sqrt(n);
    return sq * sq == n;
}
int numSquares(int n) {
    if (isSquare(n)) {
        return 1;
    }
    // Legendre's three-square theorem
    int m = n;
    while (m % 4 == 0) {
        m /= 4;
    }
    if (m % 8 == 7) {
        return 4;
    }
    const int sq = sqrt(n);
    for (int i = 1; i <= sq; i++) {
        if (isSquare(n - i*i)) {
            return 2;
        }
    }
    return 3;
}
int main() {
    cout << numSquares(12) << endl;
    cout << numSquares(13) << endl;
}

Output:
3
2

Complexity

• Runtime: O(logn).

• Extra space: O(1).

Solution 3: Further performance improvement

Lagrange's Four-Square Theorem and Legendre's Three-Square Theorem are so powerful to solve this problem. But you can still do a little more algebra to improve further the runtime of the implementation above.

Instead of looping over sqrt(n) in the final for loop, we will prove that this loop over sqrt(m) is enough. That will improve runtime a lot since m is much less than n.

Let m be the reduced value of n after the Legendre's while loop. It satisfies

n = 4^a * m.

We will prove that numSquares(n) = numSquares(m).

In fact, if m is written as m = x^2 + y^2 + z^2, where x, y, z are nonnegative integers. Then

n = 4^a * m = (2^a)^2 * m = (2^a * x)^2 + (2^a * y)^2 + (2^a * z)^2.

In other words, numSquares(n) = numSquares(m).

Now you can change directly the value n during the Legendre's while loop without affecting the final result.

Code

#include <iostream>
#include <cmath>
using namespace std;
bool isSquare(int n) {
    int sq = sqrt(n);
    return sq * sq == n;
}
int numSquares(int n) {
    if (isSquare(n)) {
        return 1;
    }
    // Legendre's three-square theorem
    while (n % 4 == 0) {
        n /= 4;
    }
    if (n % 8 == 7) {
        return 4;
    }
    const int sq = sqrt(n);
    for (int i = 1; i <= sq; i++) {
        if (isSquare(n - i*i)) {
            return 2;
        }
    }
    return 3;
}
int main() {
    cout << numSquares(12) << endl;
    cout << numSquares(13) << endl;
}

Output:
3
2

Complexity

• Runtime: O(logn).

• Extra space: O(1).

Conclusion

• The title of this coding challenge (Perfect squares) gives you a hint it is more about mathematics than coding technique.

• It is amazing from Lagrange's Four-Square Theorem there are only four possibilities for the answer to the problem. Not many people knowing it.

• You can get an optimal solution to a coding problem when you know something about the mathematics behind it.

Hope you learn something from this code challenge.

Have fun with coding and mathematics!

Thanks for reading. Feel free to share your thought about my content and check out my FREE book 10 Classic Coding Challenges.

What is your approach? The problem was picked from leetcode.com. You can submit your solution in any programming language and check the performance.