LeetCode 30 Day Challenge | Day 7 | Counting Elements

Given an integer array arr, count element x such that x + 1 is also in arr.

If there're duplicates in arr, count them seperately.

Example 1:

Input: arr = [1,2,3]
Output: 2
Explanation: 1 and 2 are counted cause 2 and 3 are in arr.

Example 2:

Input: arr = [1,1,3,3,5,5,7,7]
Output: 0
Explanation: No numbers are counted, cause there's no 2, 4, 6, or 8 in arr.

Example 3:

Input: arr = [1,3,2,3,5,0]
Output: 3
Explanation: 0, 1 and 2 are counted cause 1, 2 and 3 are in arr.

Example 4:

Input: arr = [1,1,2,2]
Output: 2
Explanation: Two 1s are counted cause 2 is in arr.

Constraints:

• 1 <= arr.length <= 1000
• 0 <= arr[i] <= 1000

C++ Solution:

class Solution {
public:
    int countElements(vector<int>& arr) {
        unordered_map<int, int> _map;
        
        for(int a : arr){
            if(_map.find(a) != _map.end())
                _map[a]++;
            else
                _map[a] = 1;
        }
        
        int result = 0;
        for(auto n : _map){
            if(_map.find(n.first + 1) != _map.end())
                result += n.second;
        }
        
        return result;
    }
};

Detailed Explanation on Youtube:

LeedCcode 30 day Challenge #2 - Happy Numbers

LeetCode 202 - Happy Numbers

Write an algorithm to determine if a number is "happy".

A happy number is a number defined by the following process: Starting with any positive integer, replace the number by the sum of the squares of its digits, and repeat the process until the number equals 1 (where it will stay), or it loops endlessly in a cycle which does not include 1. Those numbers for which this process ends in 1 are happy numbers.

Example: 

Input: 19
Output: true
Explanation: 
12 + 92 = 82
82 + 22 = 68
62 + 82 = 100
12 + 02 + 02 = 1

Detailed Explanation with 2 different methods in following video:

Source: https://crack-coding-interviews.blogspot.com/2020/04/leedccode-30-day-challenge-2-happy.html

System Design : Load Balancing | How Load Balancers work

Features of Load Balancer:

• Distribute load/requests across multiple resources/servers.
• Keep track of status of all resources while distributing requests. If a server is down, it stops sending traffic to that server. [depending on activeness of the server]
• Ease of use in adding/removing servers in network based on demand.

Algorithms used for Load Balancing:

1. Round Robin
2. Least Connections
3. Least Response Time
4. IP Hash
5. URL Hash


Where can we use Load Balancers?

• User Requests -- [Load Balancer] -- Web Server
• Web Server --  [Load Balancer] -- Backend Server
• Internal Server -- [Load Balancer] -- Databases

Detailed explanation can be viewed on Knowledge Center's Youtube channel:

Subscribe to KnowledgeCenter 

4 Tips to crack System Design Interview

• Leverage your Existing Knowledge:
• Database Technologies
• Load Balancers
• Message Handlers
• Caching Techniques
• Scaling Techniques

• Understand the Problem very well: (Ask Questions)
• Constraints ?
• Users - Who, How large ?

• High Level Architecture Design (Abstract Design):
• Break problem into Components/Modules
• How the components are connected
• Don't go Deep

• Go Deep into Component of Interest:
• UI
• Database Side
• Caching
• Scalability
• Server

Detailed Explanation can be found on Youtube:

Subscribe toKnowledgeCenter 

Swap Nodes of Linked List without Copying

C++ Code:

void swap_nodes(Node **headPtr, int a, int b){

    if(a == b || !headPtr || !(*headPtr))

        return;

    

    Node *curr = *headPtr;

    Node *prev = nullptr;

    Node *nodeA = nullptr;

    Node *nodeB = nullptr;

    Node *prevA = nullptr;

    Node *prevB = nullptr;

    

    while (curr) {

        if(curr->data == a){

            nodeA = curr;

            prevA = prev;

        } else if(curr->data == b){

            nodeB = curr;

            prevB = prev;

        }

        prev = curr;

        curr = curr->next;

    }

    

    if(!nodeA || !nodeB)

        return;

    

    if(prevA){

        prevA->next = nodeB;

    } else { // nodeA is head

        *headPtr = nodeB;

    }

    

    if(prevB){

        prevB->next = nodeA;

    } else { // nodeB is head

        *headPtr = nodeA;

    }

    

    Node *tmp = nodeA->next;

    nodeA->next = nodeB->next;

    nodeB->next = tmp;

}

Detailed explanation is available on youtube:  

Subscribe toKnowledgeCenter 

Check if a Linked List is palindrome

Detailed explanation is available on youtube: 

Subscribe to KnowledgeCenter

Remove Loop From Linked List using Floyd's Algorithm

C++ Code:

void remove_loop(Node *head){

    Node *slow = head;

    Node *fast = head;

    if (!head || !(head->next))

        return;

    while(slow && fast && fast->next){

        slow = slow->next;

        fast = fast->next->next;

        if(slow == fast)

            break;

    }

    

    // No Loop exixts

    if (slow != fast){

        std::cout << "No Loop" << std::endl;

        return;

    }

    

    // When Loop exists

    slow = head;

    while(slow->next != fast->next){

        slow = slow->next;

        fast = fast->next;

    }

    fast->next = nullptr;

}

Detailed explanation is available on Youtube:

Subscribe to KnowledgeCenter