JJJ

class Solution {
    public boolean validMountainArray(int[] arr) {
						
		boolean result = true;
		
		int peak = 0;
		int peakIndex = 0;
		
		// 길이가 3보다 작으면X
		if(arr.length < 3)
			result = false;
		
		// peak
		for (int i = 0; i < arr.length; i++) {
			if(peak < arr[i]) {
				peak = arr[i];
				peakIndex = i;
			}
		}
		
        	// peak가 맨 처음/마지막에 있으면 X
		if(peakIndex == 0 || peakIndex == arr.length - 1)
			result = false;
		
		// 상승 검사
		for (int i = peakIndex; i >= 1 ; i--) {
			if(arr[i-1] >= arr[i]) {
				result = false;
			}
		}
		
		// 하강 검사
		for (int i = peakIndex; i < arr.length - 1; i++) {
			if(arr[i] <= arr[i+1]) {
				result = false;
			}
		}
		return result;
    }
}

배열을 탐색할 때에는 index 바운더리를 항상 주의

class Solution {
    public boolean checkIfExist(int[] arr) {
        
        boolean result = false;
        
        for(int i = 0; i < arr.length; i++) {          
            for(int j = 0; j < arr.length; j++) {
                if(j == i) 
                    continue;
                
                if(arr[i] * 2 == arr[j]){
                    result = true;
                    break;
                }
            }
        }
        return result;
    }
}

Two Pointer로 구현

class Solution {
    public int removeDuplicates(int[] nums) {
        int i = 0;
		if(nums.length == 0) return 0;
		
		for (int j = i+1; j < nums.length; j++) {
			if(nums[i] != nums[j]) {
				i++;
				nums[i] = nums[j];
				
			}
		}		
		return i+1;
    }
}

O(N^2)

class Solution {
    public int removeDuplicates(int[] nums) {
        
        // The initial length is simply the capacity.
        int length = nums.length;
        
        // Assume the last element is always unique.
        // Then for each element, delete it iff it is
        // the same as the one after it. Use our deletion
        // algorithm for deleting from any index.
        for (int i = length - 2; i >= 0; i--) {
            if (nums[i] == nums[i + 1]) {
                // Delete the element at index i, using our standard
                // deletion algorithm we learned.
                for (int j = i + 1; j < length; j++) {
                    nums[j - 1] = nums[j];
                }
                // Reduce the length by 1.
                length--;
            }
        }
        // Return the new length.
        return length;
    }
}

class Solution {
    public int removeElement(int[] nums, int val) {
        int k = 0;
		int valCnt = 0;
		
		for (int i = 0; i < nums.length; i++) {
			if(nums[i] == val) valCnt++;
		}		
		for (int i = 1; i <= valCnt; i++) {			
			for (int j = 0; j < nums.length; j++) {				
				if(nums[j] == val) {										
					for (int x = j+1; x < nums.length; x++) {
						nums[x-1] = nums[x];
					}				
				}
			}
		}
		k = nums.length-valCnt;
		return k;
    }
}

- In-place로 처리를 할 때는 Two Pointer로 해결할 수 있는 경우가 많음

- j를 옮겨가면서 val과 같은지 확인하고, 다르면 j의 값은 i에 넣고 i위치를 하나 올림

class Solution {
    public int removeElement(int[] nums, int val) {
        int i = 0;                
        
        for (int j = 0; j < nums.length; j++) {
			if(nums[j] != val) {
				nums[i] = nums[j];
				i++;
			}
		}        
		return i;
    }
}

class Solution {
    public void merge(int[] nums1, int m, int[] nums2, int n) {
        for (int i = 0; i < nums2.length; i++) {
			nums1[i+m] = nums2[i];
		}                
        Arrays.sort(nums1);  
    }
}

class Solution {
    public void duplicateZeros(int[] arr) {
        int zeroCnt = 0;
		int len = arr.length;
		
		for (int i = 0; i < arr.length; i++) {
			if(arr[i] == 0) {
				zeroCnt++;
			}
		}
		
		for(int i = len-1 ; i >= 0; i--) {
			int j = i + zeroCnt;
			
			if(arr[i] == 0) {
				if(j < len) {
					arr[j] = 0;
				}
				j--;
				zeroCnt--;
			}
			
			if(j < len) {
				arr[j] = arr[i];
			}
		}  
    }
}

Two Pointer를 사용하여 해결할 수 있음 (i에 있는 값을 j로 복사)

새로운 배열 없이 arr배열에서 만 해결해야함

앞에서부터 하면은 데이터가 유실되서 불가능

https://leetcode.com/problems/duplicate-zeros/solution/

class Solution {
    public int[] sortedSquares(int[] nums) {
        for(int i = 0; i < nums.length; i++) {
            nums[i]*= nums[i];
        }
        Arrays.sort(nums);
        return nums;
    }
}

숫자의 자리수가 짝수인 것들의 개수

class Solution {
    public int findNumbers(int[] nums) {
        int evenCnt = 0;        
        for(int i = 0; i < nums.length; i++){
            String str = String.valueOf(nums[i]);
            if(str.length() % 2 == 0){
                evenCnt++;
            }
        }
        return evenCnt;
    }
}

1이 나타나면 개수를 새고, 0이 나오면 연속이 끊긴 것이므로, 다시 카운팅

class Solution {
    public int findMaxConsecutiveOnes(int[] nums) {
        int max = 0;
        int cnt = 0;
        
        for(int i = 0; i < nums.length; i++){
            if(nums[i] == 1){
                cnt++;
                if(max < cnt){
                    max = cnt;
                }
            } else{                
                cnt = 0;                
            }
        }        
        return max;
    }
}

import java.util.*;

public class Main {
	
	static Stack<Character> stk = new Stack<Character>();
	
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);		
		int T = sc.nextInt();	
		
		for (int i = 0; i < T; i++) {
			String str = sc.next();
			if(VPC(str)) {
				System.out.println("YES");
			}else {
				System.out.println("NO");
			}
			stk.clear();	// 다음 VPC검사를 위해 clear
		}
	}
	
	public static boolean VPC(String str) {
		char[] arr = str.toCharArray();
		
		for (int i = 0; i < arr.length; i++) {
			if(arr[i] == '(') {
				stk.push(arr[i]);
			}
			else if (arr[i] == ')') {
				if(stk.empty()) {	// 비어있으면
					return false;
				}else {	// 비어있지 않으면
					char tmp = stk.peek();
					if(tmp == ')') {
						return false;
					}else {
						stk.pop();						
					}
				}
			}
		}
		
		if(stk.empty()) {
			return true;
		}else {
			return false;
		}
	}
}