코테 패턴 스니펫 (Java)

1. 배열 순회 + 조건 체크 + 결과 담기
   사용 조건 : ~를 만족하는 원소만 찾아서 반환해라. 몇개인지 세라

public int[] solution(int[] arr) {
	List<Integer> result = new ArrayList<>();
    
    for(int i = 0; i < arr.length; i++) {
    if (arr[i] % 2 == 0) { //조건은 문제마다 변경
    	result.add(arr[i]);
        }
    }
    
    //List<Integer> -> int[] 변환
    int[] answer = new int[result.size()];
    for (int i = 0; i < result.size(); i++) {
    answer[i] = result.get(i);
}
return answer;
}

2. HashMap으로 빈도수 세기 / 중복 체크
   사용 조건 : 가장 많이 / 적게 나온 값, 중복 제거, 이미 나온 적 있는지 확인

public String solution(String[] arr) {
	Map<String, Integer> count = new HashMap<>();
    
    for (String s : arr) {
    count.put(s, count.getOrDefault(s, 0) + 1);
    }
    
    //가장 많이 나온 것 찾기
    String answer = "";
    int max = 0;
    for (String key : count.keySet()) {
    	if (count.get(key) > max) {
        max = count.get(key);
        answer = key;
        }
    }
    return answer;
}

중복 체크만 할 땐 HashMap이 더 간단

Set<Integer> seen = new HashMap<>();
for (int n : arr) {
	if (!seen.add(n)) {
    //이미 있던 값 -> 중복
    }
}

3.문자열 자르기·뒤집기·비교
사용 조건 : 팰린드롬, 아나그램, 단어개수 세기, 문자열 뒤집기/변형

public boolean solution(String s) {
	//뒤집기
    String reversed = new StringBuilder(s).reverse().toString();
    
    //자르기(공백, 특정 문자 기준)
    String[] words = s.split(" ");
    
    //한 글자씩 순회
    for (int i = 0; i < s.length(); i++) {
    	char c = s.charAt(i);
        }
        
     //문자 이어붙이기
     StringBuilder sb = new StringBuilder();
     for (char c : s.toCharArray()) {
     	sb.append(c);
    }
    return s.equals(reversed);
}

4. 정렬 후 처리
   사용 조건 : 가장 작은/큰 N개, 순서대로 나열, 그리디 문제 대부분

public int[] solution(int[] arr) {
 //기본 오름차순(Integer[]로 바꿔야 Comparator 사용 가능)
	Integer[] boxed = Arrays.stream(arr).boxed().toArray(Integer[]::new);
    Arrays.sort(boxed, (a, b) -> b - a); //내림차순
    
    //문자열 배열 정렬
    String[] strArr = {"banana", "apple"};
    Arrays.sort(strArr); //사전순
    
    //커스텀 기준 정렬
    Arrays.sort(strArr, (a,b) -> {
    	if(a.length() != b.length()) return a.length() - b.length();
        return a.compareTo(b);
    });
    return arr;
}

기본 내림차순 정렬
기존의 (a, b) -> b - a 대신 Comparator.reverseOrder()를 활용

//기존 방식
Arrays.sort(boxed, (a, b) -> b - a);

//Comparator 활용 방식
Arrays.sort(boxed, Comparator.reverseOrder());

커스텀 조건 정렬(길이순 -> 사전순)
기존에 if문으로 길이 비교 후 compareTo를 호출했던 긴 로직을 thenComparing으로 체이닝(연결)하면 깔끔해짐

//기존 방식
Arrays.sort(strArr, (a, b) -> {
	if (a.length() != b.length()) return a.length() - b.length();
    return a.compareTo(b);
});

//Comparator.comparing + thenComparing 활용
Arrays.sort(strArr, Comparator
	.comparing(String::length) //1순위 : 문자열 길이 기준 오름차순
    .thenComparing(Comparator.naturalOrder()) //2순위 : 길이가 같으면 사전순
    );

5. 투 포인터 / 슬라이딩 윈도우
   사용조건 : 연속된 구간 중, 두 수의 합이 target, 최대/최소 부분 배열

//투 포인터 : 정렬된 배열에서 두 수의 합 찾기
public boolean solution(int[] arr, int target) {
	Arrays.sort(arr);
    int left = 0, right = arr.length -1;
    
    while (left < right) {
    	int sum = arr[left] + arr[rigth];
        if (sum == target) return true;
        else if (sum < target) left++;
        else right--;
    }
    return false;
}

//슬라이딩 윈도우 : 연속 부분합의 최댓값
public int solution(int[] arr, int k) {
	int windowSum = 0;
    for (int i = 0; i < k; i++) windowSum += arr[i];
    
    int maxSum = windowSum;
    for (int i = k; i < arr.length; i++) {
    	windowSum += arr[i] - arr[i - k]; //뒤에 더하고 앞에 빼기
        maxSum = Math.max(maxSum, windowSum);
    }
    return maxSum;
}