Program: Finding maximum element from an array.

#include <iostream>
using namespace std;

int findMax(int arr[], int size) {
    int max = arr[0];
    for (int i = 1; i < size; i++) {
        if (arr[i] > max) {
            max = arr[i];
        }
    }
    return max;
}

int main() {
    int arr[] = {12, 32, 23, 11, 39};
    int size = sizeof(arr) / sizeof(arr[0]);
    int maxNumber = findMax(arr, size);
    cout << "Maximum number in array: " << maxNumber << endl;
    return 0;
}

Program: Searching in a 2D array.

#include <iostream>
using namespace std;

int* search(int arr[][3], int rows, int cols, int target) {
    static int result[2]; 
    result[0] = -1;
    result[1] = -1;

    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            if (arr[i][j] == target) {
                result[0] = i;
                result[1] = j;
                return result; 
            }
        }
    }
    return result; 
}

int main() {
    int arr[3][3] = {
        {20, 45, 10},
        {32, 26, 22},
        {47, 98, 37}
    };

    int target;
    cout << "Enter target element: ";
    cin >> target;

    int* result = search(arr, 3, 3, target);
    
    if (result[0] != -1) {
        cout << "Element found at index (" << result[0] << "," << result[1] << ")" << endl;
    } else {
        cout << "Element not found" << endl;
    }

    return 0;
}

#linearsearch

Leetcode 26:
https://leetcode.com/problems/remove-duplicates-from-sorted-array/description/

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        int lastUniqueElementIdx = 0;

        for (int i = 1; i < nums.size(); i++) {
            if (nums[lastUniqueElementIdx] != nums[i]) {
                nums[lastUniqueElementIdx + 1] = nums[i];
                lastUniqueElementIdx++;
            }
        }
        return lastUniqueElementIdx + 1;
    }
};

Leetcode 122:
https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int maxProfit = 0;
        for(int i = 0; i < prices.size() - 1; i++) {
            if(prices[i] < prices[i + 1]) {
                int diff = prices[i + 1] - prices[i];
                maxProfit += diff;
            }
        }
        return maxProfit;
    }
};

Leetcode 189:
https://leetcode.com/problems/rotate-array/

#include <vector>
#include <iostream>

class Solution {
public:
    void rotate(std::vector<int>& nums, int k) {
        k = k % nums.size();
        // Reversing the whole array
        reverseNumsArr(nums, 0, nums.size());
        // Reversing first k elements
        reverseNumsArr(nums, 0, k);
        // Reversing remaining elements
        reverseNumsArr(nums, k, nums.size());
    }

private:
    void reverseNumsArr(std::vector<int>& nums, int start, int end) {
        end--; // Adjusting end to be the last index
        while (start < end) {
            std::swap(nums[start], nums[end]);
            start++;
            end--;
        }
    }
};

Leetcode 217:
https://leetcode.com/problems/contains-duplicate/description/

#include <vector>
#include <algorithm>

class Solution {
public:
    bool containsDuplicate(std::vector<int>& nums) {
        std::sort(nums.begin(), nums.end());
        for (size_t i = 0; i < nums.size() - 1; i++) {
            if (nums[i] == nums[i + 1]) {
                return true;
            }
        }
        return false;
    }
};

Leetcode 136:
https://leetcode.com/problems/single-number/

class Solution {
public:
    int singleNumber(vector<int>& nums) {
        int finder = 0;
        for(int i = 0; i < nums.size(); i++) {
            finder = finder ^ nums[i];
        }
        return finder;
    }
};

Leetcode 350: https://leetcode.com/problems/intersection-of-two-arrays-ii/

class Solution {
public:
    std::vector<int> intersect(std::vector<int>& nums1, std::vector<int>& nums2) {
        std::unordered_map<int, int> numsMap;
        std::vector<int> intersectedNums;

        for (int num : nums1) {
            numsMap[num]++;
        }

        for (int num : nums2) {
            if (numsMap.find(num) != numsMap.end() && numsMap[num] > 0) {
                intersectedNums.push_back(num);
                numsMap[num]--;
                if (numsMap[num] == 0) {
                    numsMap.erase(num);
                }
            }
        }

        return intersectedNums;
    }
};

Leetcode 66:
https://leetcode.com/problems/plus-one/

class Solution {
public:
    std::vector<int> plusOne(std::vector<int>& digits) {
        int currentIndex = digits.size() - 1;
        
        while (digits[currentIndex] == 9) {
            if (currentIndex == 0) {
                std::vector<int> resultArr(digits.size() + 1, 0);
                resultArr[0] = 1;
                return resultArr;
            }
            digits[currentIndex] = 0;
            currentIndex--;
        }

        digits[currentIndex]++;
        return digits;
    }
};

Leetcode 283: https://leetcode.com/problems/move-zeroes/

class Solution {
public:
    void moveZeroes(vector<int>& nums) {
        if (nums.size() < 2) {
            return;
        }
        
        int leftIdx = 0, rightIdx = 1;
        
        while (rightIdx < nums.size()) {
            if (nums[leftIdx] != 0) {
                leftIdx++;
                rightIdx++;
            } 
            else if (nums[rightIdx] == 0) {
                rightIdx++;
            } 
            else {
                swap(nums[leftIdx], nums[rightIdx]);
            }
        }
    }
};

Hello everyone 👋

We’re starting the #90DaysOfLeetCode challenge from May 4.

Link: https://t.me/+-J7nBjpCGK4xMDZl

#90DaysOfLeetCode challenge started

If you're interested, Join the channel.

Link: https://t.me/+-J7nBjpCGK4xMDZl