[LeetCode/Easy] 2733. Neither Minimum nor Maximum

1. Input

1) int[] nums

 

2. Output

1) nums의 요소 중 최솟값도 아니고 최댓값도 아닌 수 중 하나를 반환

2) 그런 수가 없다면 -1을 반환

 

3. Constraint

1) 1 <= nums.length <= 100

2) 1 <= nums[i] <= 100

3) nums에 중복된 수는 없다.

 

4. Example

Input: nums = [3,2,1,4] -> Output: 2

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

설명:

- 최댓값은 4, 최솟값은 1이므로 남은 2나 3중 하나를 반환한다.

- 최댓값은 2, 최솟값은 1이므로 남은 수가 없어 -1을 반환한다.

 

5. Code

1) 첫 코드

class Solution {
    public int findNonMinOrMax(int[] nums) {
        if(nums.length<=2) return -1;
        int max = Math.max(nums[0],nums[1]), min = Math.min(nums[0],nums[1]), mid = 0;
        for(int i=2 ; i<nums.length ; i++){
            if(nums[i]<min){
                mid = min; min = nums[i];
            } else if(nums[i]<max)
                mid = nums[i];
            else{
                mid = max; max = nums[i];
            }
        }
        return mid;
    }
}

- 92%, 68%

- 너무 정성스럽게 찾은 것 같은 느낌

 

2) sort랑 비교해보고 싶어 작성한 코드

class Solution {
    public int findNonMinOrMax(int[] nums) {
        if(nums.length<=2) return -1;
        Arrays.sort(nums);
        return nums[1];
    }
}

- 56%, 55%

- 역시 내장함수는 비용이 크다는 것인가..

 

3) quicksort를 이용해서 풀어본 코드

class Solution {
    public int findNonMinOrMax(int[] nums) {
        if(nums.length<=2) return -1;
        quicksort(nums, 0, nums.length-1);
        return nums[1];
    }

    static void quicksort(int[] arr, int start, int end){
        if(start>=end) return;
        int i = start+1, j = end, pivot = start;
        while(i<=j){
            while(i<=end && arr[i]<=arr[pivot]) i++;
            while(j>start && arr[j]>arr[pivot]) j--;
            if(i<j){
                int tmp = arr[i];
                arr[i] = arr[j];
                arr[j] = tmp;
            } else{
                int tmp = arr[j];
                arr[j] = arr[pivot];
                arr[pivot] = tmp;
            }
        }
        quicksort(arr, start, j-1);
        quicksort(arr, j+1, end);
    }
}

- 7%, 68%

- 첫 코드가 제일 낫다...