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;
    }
};

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;
    }
};

#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--;
        }
    }
};

#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;
    }
};

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;
    }
};

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;
    }
};

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;
    }
};

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]);
            }
        }
    }
};