leet code

오늘은 쉬운문제 8문제를 풀었습니다.

3237 - Find Numbers with Even Number of Digits

C++ time(beats 91.49%), space(39.04%)

class Solution {
public:
    int findNumbers(vector<int>& nums) {
        int len=nums.size();
        int cnt = 0;
        int rslt = 0;
        int curNum = 0;
        for(int i=0; i<len; ++i)
        {
            cnt = 0;
            curNum = nums[i];
            while(curNum)
            {
                curNum /= 10;
                cnt++;
            }
            if(cnt%2==0)
            {
                rslt++;
            }
        }
        return rslt;
    }
};

3240 - Squares of a Sorted Array

처음에는 bubble sort를 써서 했다가, TLE(Time Limit Error)가 떠서,

counting sort를 썼습니다.

C++ times(beats 54.43%), space(beats 36.34%)

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        // square and sort
        int len = nums.size();
        int tmp=0;
        int lut[10001]= {0,};
        for(int i=0; i<len; ++i)
        {
            if(nums[i] < 0)
            {
                nums[i] *= -1;
            }

            lut[nums[i]]++;
        }
        int idx = 0;
        for(int i=0;i<10001; ++i)
        {
            while(lut[i])
            {
                nums[idx] = i*i;
                idx++;
                lut[i]--;
            }

        }
        return nums;

    }
};

3245 - Duplicate Zeros

C++ time(beats 93.89%), space(beats 73.43%)

class Solution {
public:
    void duplicateZeros(vector<int>& arr) {
        int len = arr.size();
        int zeroCnt = 0;
        for(int i=0; i<len; ++i)
        {
            if(!arr[i]) zeroCnt++;
        }

        int rsltLen = len + zeroCnt;
        int idx=rsltLen-1;
        for(int i=len-1;i>=0; --i)
        {
            if(arr[i])
            {
                if(idx>=len)
                {
                    idx--;
                    continue;
                }
                arr[idx] = arr[i];
                idx--;
            }else
            {
                if(idx-1>=len)
                {
                    idx-=2;
                    continue;
                }

                if(idx<len)
                    arr[idx] = 0;
                arr[idx-1] = 0;
                idx -= 2;
            }
        }
        return;
    }
};

3253 - Merge Sorted Array

C++ time(beats 100%, 0ms), space(beats 85.94%)

class Solution {
public:
    void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {
        int idx1=m-1;
        int idx2=n-1;
        for(int i=nums1.size()-1; i>=0; --i)
        {
            if(idx1>=0&&idx2>=0)
            {
                if(nums1[idx1] > nums2[idx2])
                {
                    nums1[i] = nums1[idx1];
                    idx1--;
                }else
                {
                    nums1[i] = nums2[idx2];
                    idx2--;
                }
            }else if(idx1>=0&&idx2<0)
            {
                nums1[i] = nums1[idx1];
                idx1--;
            }else
            {
                nums1[i] = nums2[idx2];
                idx2--;
            }

        }
        return;
    }
};

3247 - Remove Element

C++

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int rsltLen = 0;
        int len = nums.size();
        int targetIdx=0;
        for(int i=0; i<len; ++i)
        {
            if(nums[i]!=val)
            {
                nums[targetIdx] = nums[i];
                rsltLen++;
                targetIdx++;
            }
        }
        return rsltLen;
    }
};

3248 - Remove Duplicates from Sorted Array

C++ time(beats 100%), space(17.70%)

#include<stdio.h>

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        int lut[20002]={0,};
        int len = nums.size();
        for(int i=0; i<len; ++i)
        {
            lut[nums[i]+10001]++;
        }

        int idx = 0;
        int rslt = 0;
        for(int i=-10001; i<10001; ++i)
        {
            if(lut[i+10001])
            {
                nums[idx] = i;
                idx++;
                rslt++;
            }
        }
        return rslt;
    }
};

3250 - Check If N and Its Double Exist

C++ times(beats 94.85%), space(beats 90.82%)

class Solution {
public:
    bool checkIfExist(vector<int>& arr) {
        int lut[4001] = { 0, };
        int len = arr.size();
        for (int i = 0; i < len; ++i)
        {
            lut[arr[i] + 2000]++;
        }
        for (int i = -1000; i < 1001; ++i)
        {
            if (lut[i + 2000])
            {
                if (i == 0)
                {
                    if (lut[2000] > 1) return true;
                }
                else
                {
                    if (lut[2000 + i * 2])
                        return true;
                }

            }
        }
        return false;
    }
};

3251 - Valid Mountain Array

C++ time(beats 55.02%), space(beats 0%)

class Solution {
public:
    bool validMountainArray(vector<int>& arr) {
        int left=0;
        int right=arr.size()-1;
        int len=arr.size();
        while(left<len-1)
        {
            if(arr[left] < arr[left+1])
            {
                left++;
            }else
            {
                break;
            }
        }
        while(right>=1)
        {
            if(arr[right] < arr[right-1])
            {
                right--;
            }else
            {
                break;
            }
        }
        if(!left || right==len-1) return false;
        if(left!=right) return false;
        else return true;
    }
};