개발 학습 블로그

import java.util.*;

public class Solution {
	
	// 등산코스 정하기
	
	public static int INF = 10000001;
	public static HashMap<Integer, ArrayList<Node>> nodeListMap = new HashMap<>();
	public static HashMap<Integer, Integer> maxOfMinIntensityMap = new HashMap<>();
	public static int totalNum = 0;
	public static int[] arrGates = {};
	public static int[] arrSummits = {};
	
	public static int dijkstra(int i, int j) {
		PriorityQueue<Node> pq = new PriorityQueue<>();
		Node pqNode;
		ArrayList<Node> nodeList;
		
		int summit = arrSummits[i];
		int gate = arrGates[j];
		
		boolean[] targetNode = new boolean[totalNum + 1]; // 1개의 출입구, 1개의 봉우리만 지나도록 boolean 배열
		
		Arrays.fill(targetNode, true);
		
		for (int k = 0; k < arrSummits.length; k++) {
			
			if (arrSummits[k] == summit) {
				continue;
			}
			
			targetNode[arrSummits[k]] = false;
		}
		
		for (int k = 0; k < arrGates.length; k++) {
			
			if (arrGates[k] == gate) {
				continue;
			}
			
			targetNode[arrGates[k]] = false;
		}
		
		for (int key : nodeListMap.keySet()) {
			maxOfMinIntensityMap.put(key, INF); // 최소 Intensity 코스 중 최대 Intensity 값 무한대로 초기화
		}
		
		maxOfMinIntensityMap.put(summit, 0); // 출발 봉우리의 Intensity값 0
		
		pq.add(new Node(summit, 0));
		
		while (!pq.isEmpty()) {
			pqNode = pq.poll();
			
			if (pqNode.getIntensity() > maxOfMinIntensityMap.get(pqNode.getIndex())) {
				continue;
			}
			
			nodeList = nodeListMap.get(pqNode.getIndex());
			
			for (Node node : nodeList) {
				
				if (!targetNode[node.getIndex()]) {
					continue; // 지정된 봉우리, 출입구가 아닐 경우 경유 불가
				}
				
				if (pqNode.getIntensity() + node.getIntensity() < maxOfMinIntensityMap.get(node.getIndex())) {
					maxOfMinIntensityMap.put(node.getIndex(), Math.max(pqNode.getIntensity(), node.getIntensity()));
					pq.add(new Node(node.getIndex(), Math.max(pqNode.getIntensity(), node.getIntensity())));
				}
			}
		}
		
		int minIntensity = maxOfMinIntensityMap.get(arrGates[0]);
		
		for (int n = 1; n < arrGates.length; n++) {
			
			if (maxOfMinIntensityMap.get(arrGates[n]) < minIntensity) {
				minIntensity = maxOfMinIntensityMap.get(arrGates[n]);
			}
		}
		
		return minIntensity;
	}
	
	public static int[] solution(int n, int[][] paths, int[] gates, int[] summits) {
		int[] answer = {};
		int MinSummit = 0;
		int MinIntensity = INF;
        
		totalNum = n;
		arrGates = Arrays.copyOf(gates, gates.length);
		arrSummits = Arrays.copyOf(summits, summits.length);
        		
		for (int i = 0; i < n + 1; i++) {
			nodeListMap.put(i, new ArrayList<Node>());
		}
        
		for (int i = 0; i < paths.length; i++) {
			nodeListMap.get(paths[i][0]).add(new Node(paths[i][1], paths[i][2]));
			nodeListMap.get(paths[i][1]).add(new Node(paths[i][0], paths[i][2]));
		}
        
		Arrays.sort(arrSummits); // intensity값 같을 경우 봉우리 번호 작은 것이 대상이 되도록 정렬 & 답 구할 때 더 작은 intensity값이 있을 경우에만 갱신되도록
        
		int tempIntensity = 0;
        
		for (int i = 0; i < arrSummits.length; i++) {
        	
			for (int j = 0; j < arrGates.length; j++) {
        		
				tempIntensity = dijkstra(i, j);
        		
				if (tempIntensity < MinIntensity) {
					MinIntensity = tempIntensity;
					MinSummit = arrSummits[i];
				}
			}
		}
        
		answer = new int[2];
        
		answer[0] = MinSummit;
		answer[1] = MinIntensity;
        
		System.out.println(MinSummit + " " + MinIntensity);
        
		return answer;
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int n = 7;
		int[][] paths = {{1, 2, 5}, {1, 4, 1}, {2, 3, 1}, {2, 6, 7}, {4, 5, 1}, {5, 6, 1}, {6, 7, 1}};
		int[] gates = {3, 7};
		int[] summits = {1, 5};
		
		// gates 중 하나의 번호만 선택 가능하며, 제일 처음과 마지막이어야 함 => 3 - ... - 3
		// summits 중 하나만 선택 가능하며, intensity를 최소로 만들 수 있는 번호 => 1과 5중 하나만 들어가야 함
		// ex) 출입구 7, 봉우리 5를 선택했다면 : 7 - (1) - 6 - (1) - 5 - (1) - 6 - (1) - 7 (intensity는 1)
		// 거쳤던 길의 크기 중 최대 값이 intensity가 된다. 우리는 그 intensity가 최소가 되는 출입구와 봉우리를 찾아야 한다.
		// 7 - (1) - 6 - (7) - 2 - (7) - 6 - (1) - 5 - (1) - 6 - (1) - 7
		// 다른 루트를 거친다고 해서 필수로 거치는 출입구 ~ 봉우리까지의 intensity를 낮출 수는 없다.
		// 즉, 출입구(A) - 길(B) - 봉우리(C) - 길(B) - 출입구(A)와 같이, 갔던 길로 되돌아오는 루트만 생각하면 된다는 의미이다.
		// 예를 들면
		// 출입구 3, 봉우리 1 : 3-2-1-2-3 => 3-2-1 또는 1-2-3만 봐도 됨
		// 출입구 3, 봉우리 5 : 3-2-6-5-6-2-3 => 3-2-6-5 또는 5-6-2-3만 봐도 됨
		// 출입구 7, 봉우리 1 : 7-6-2-1-2-6-7 => 7-6-2-1 또는 1-2-6-7만 봐도 됨
		// 출입구 7, 봉우리 5 : 7-6-5-6-7 => 7-6-5 또는 5-6-7만 봐도 됨
		// 이 문제에서는 봉우리 번호와 intensity 최소값을 원하므로, 봉우리에서 출발 -> 출입구 도착 루트로 문제를 풀겠다.
		
		System.out.println(solution(n, paths, gates, summits)); // {5, 1} // {봉우리 번호, intensity 최소값}
	}
}

public class Node implements Comparable<Node> {
	
	private int index = 0; // 등산코스 번호
	private int intensity = 0; // 등산코스 시간
	
	public Node(int index, int intensity) {
		this.index = index;
		this.intensity = intensity;
	}
	
	public int getIndex() {
		return this.index;
	}
	
	public int getIntensity() {
		return this.intensity;
	}

	@Override
	public int compareTo(Node otherNode) {
		// TODO Auto-generated method stub
		return this.intensity - otherNode.intensity; // intensity 기준 오름차순 정렬
	}
}

우선순위 큐를 활용하여 다익스트라 알고리즘으로 문제를 해결하고자 했으나

아직 시간 초과 존재

프로그래머스 등산코스 정하기 문제 풀이 Java 소스 코드

import java.util.ArrayDeque;
import java.util.Deque;

public class Solution {
	
	// 행렬과 연산
	// Deque 자료구조에서
	// add(A) + peek(B) or remove(B)가 있을 때 // (A)와 (B)는 First 또는 Last
	// (A)와 (B)가 같다면 스택(Stack)처럼 동작
	// (A)와 (B)가 다르다면 큐(Queue)처럼 동작
	// addFirst로 쌓고 있는 구조에서 제일 앞에 원소를 추가하고 싶다면 addLast로 추가
	// addLast로 쌓고 있는 구조에서 제일 앞에 원소를 추가하고 싶다면 addFirst로 추가
	
	static int r = 0; // rc의 행 수
	static int c = 0; // rc의 열 수
	static Deque<Integer> firstCol; // rc의 1열
	static Deque<Integer> lastCol; // rc의 마지막열
	static Deque<Deque<Integer>> restRows; // rc의 1열, 마지막열을 제외한 나머지 행들
	
	// 2차원 배열을 2개의 열과 나머지 행 구조로 나누기
	public static void rcSetting(int[][] rc) {
		r = rc.length; // 행
		c = rc[0].length; // 열
		firstCol = new ArrayDeque<Integer>(); // 1열
		lastCol = new ArrayDeque<Integer>(); // 마지막열
		restRows = new ArrayDeque<Deque<Integer>>(); // 나머지 행
		
//		1 2 3
//		4 5 6
//		7 8 9
		
//		2차원 배열이 위와 같다면
//		r = 3, c = 3
//		firstCol = {1, 4, 7}
//		lastCol = {3, 6, 9}
//		restRows = {2, 5, 8}
		
		// 상단, 좌측부터 addFirst로 넣을 거야
		// 모두 addFirst로 넣는다는 것을 기억
		for (int i = 0; i < r; i++) {
			firstCol.addFirst(rc[i][0]); // 1열 담기
			lastCol.addFirst(rc[i][c - 1]); // 마지막열 담기
			
			 Deque<Integer> tempRow = new ArrayDeque<Integer>(); // restRows에 담을 tempRow 생성
			 
			 for (int j = 1; j < c - 1; j++) { // 1열과 마지막열을 제외한 모든 열의 원소 담기
				 tempRow.addFirst(rc[i][j]);
			 }
			 
			 restRows.addFirst(tempRow); // tempRow 담기
		}
	}
	
	// 테두리 한 칸씩 시계방향 회전
	public static void rotate() {
		
		if (c == 2) { // firstCol, lastCol만으로 이루어진 2차원 배열
			lastCol.addLast(firstCol.removeLast());
			// firstCol의 제일 처음에 들어왔던 원소가 빠져나가야 함 => addFirst에서 Queue 구조로 빠져나가려면 removeLast로 빼내야 한다.
			// 빼낸 값을 lastCol의 addFirst로 제일 처음 들어왔던 원소보다 앞에 넣어야 하므로 addLast로 넣어준다.
			
			firstCol.addFirst(lastCol.removeFirst());
			// lastCol의 제일 마지막에 들어왔던 원소가 빠져나가야 함 => addFirst에서 Stack 구조로 빠져나가려면 removeFirst로 빼내야 한다.
			// 빼낸 값을 firstCol의 addFirst로 가장 마지막에 들어왔던 원소의 뒤에 넣어야 하므로 똑같이 addFirst로 넣어준다.
			
			return;
		}
		
		// 테두리에 원소 추가할 순서는 상, 우, 하, 좌 순서로 하겠다.
		restRows.peekLast().addLast(firstCol.removeLast()); // 1열(firstCol)의 처음 들어온 원소를 빼냄(addFirst에서 Queue 구조로 쓰기 위해 removeLast) => restRows의 처음 들어온 행을 기준으로 잡아야 함(Queue 구조로 쓰기 위해 peekLast) => 행의 원소 중 처음에 들어왔던 원소보다 앞에 넣어줘야 하므로 addLast
		lastCol.addLast(restRows.peekLast().removeFirst()); // restRows의 처음 들어온 행 중 마지막 원소를 빼내어 마지막 열 제일 앞에 끼어들기해서 추가
		restRows.peekFirst().addFirst(lastCol.removeFirst()); // 마지막 열의 제일 마지막에 들어온 원소를 빼내어 restRows의 가장 마지막에 들어온 행 중 가장 마지막에 들어온 원소 뒤에 추가
		firstCol.addFirst(restRows.peekFirst().removeLast()); // restRows의 가장 마지막에 들어온 행 중 처음 들어온 원소를 빼내어 1열 제일 마지막에 들어온 원소 뒤에 추가
	}
	
	// 행 한 칸씩 아래로 이동
	public static void shiftRow() {
		// 가장 마지막에 들어온 행 또는 원소를 가장 처음 위치에 넣어줘야 한다. addFirst 추가 구조이므로 스택 구조로 빼내기 위해 removeFirst, 제일 앞에 추가해줘야 하므로 addLast를 써준다.
		restRows.addLast(restRows.removeFirst()); // 행
		firstCol.addLast(firstCol.removeFirst()); // 1열
		lastCol.addLast(lastCol.removeFirst()); // 마지막열
	}
	
	public static int[][] solution(int[][] rc, String[] operations) {
		int[][] answer = {};
        
		// STEP 1. 2차원 배열 rc => 2개의 열과 나머지 행 구조로 나누기
		rcSetting(rc);
        
		// STEP 2. 메인 작업
		for (String operation : operations) { // "Rotate", "ShiftRow"
        	
			switch (operation.charAt(0)) { // 'R', 'S'
				case 'R' : rotate(); break;
				case 'S' : shiftRow(); break;
			}
		}
        
		// STEP 3. 2차원 배열 answer에 값 담기
		answer = new int[r][c];
        
		for (int i = 0; i < r; i++) {
			// addFirst 추가 구조에서 큐 구조로 빼내기 위해 removeLast 사용
			answer[i][0] = firstCol.removeLast(); // 1열
			answer[i][c - 1] = lastCol.removeLast(); // 마지막열
        	
			Deque<Integer> tempRow = new ArrayDeque<Integer>(); // restRows의 각 행을 담기 위해 tempRow 생성
        	
			// addFirst 추가 구조에서 큐 구조로 빼내기 위해 removeLast 사용
			tempRow = restRows.removeLast();
        	
			for (int j = 1; j < c - 1; j++) {
				answer[i][j] = tempRow.removeLast();
			}
		}
        
		return answer;
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[][] rc = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
		String[] operations = {"Rotate", "ShiftRow"}; // Rotate : 행렬 바깥쪽에 있는 원소를 시계 방향으로 회전, ShiftRow : 행을 한 칸씩 아래로 이동
		
//		    Rotate  ShiftRow
//		1 2 3    4 1 2    8 9 6
//		4 5 6    7 5 3    4 1 2
//		7 8 9    8 9 6    7 5 9
		
		System.out.println(solution(rc, operations)); // {{8, 9, 6}, {4, 1, 2}, {7, 5, 3}}
	}
}

Deque 자료구조에 대해 어느 정도 학습이 된 후 풀이하는 것을 추천한다.

프로그래머스 행렬과 연산 문제 풀이 Java 소스 코드

import java.util.ArrayDeque;
import java.util.Deque;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;

public class DequeSample {
	
	// Stack, Queue, Deque

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Deque<Integer> stack1 = new ArrayDeque<>(); // addFirst + removeFirst // 스택
		
		stack1.addFirst(1);
		stack1.addFirst(2);
		stack1.addFirst(3);
		
//		stack1.add(4); // add는 addLast와 같음 // addFirst로 쌓고 있었는데 그 방향과 반대 방향에 추가 4, 1, 2, 3이 됨
//		stack1.addFirst(5); // 1, 2, 3과 같은 방향으로 추가 // 4, 1, 2, 3, 5
//		stack1.addLast(6); // addFirst와 반대 방향으로 추가 // 6, 4, 1, 2, 3, 5
		
		System.out.println("stack1"); // stack1
		
		System.out.println(stack1.peekFirst()); // 3
		System.out.println(stack1.removeFirst()); // 3
		System.out.println(stack1.removeFirst()); // 2
		System.out.println(stack1.removeFirst()); // 1
		
		Deque<Integer> queue1 = new ArrayDeque<>(); // addFirst + removeLast // 큐
		
		queue1.addFirst(1);
		queue1.addFirst(2);
		queue1.addFirst(3);
		
		System.out.println("queue1"); // queue1
		
		System.out.println(queue1.peekLast()); // 1
		System.out.println(queue1.removeLast()); // 1
		System.out.println(queue1.removeLast()); // 2
		System.out.println(queue1.removeLast()); // 3
		
		Deque<Integer> queue2 = new ArrayDeque<>(); // addLast + removeFirst // 큐
		
		queue2.addLast(1);
		queue2.addLast(2);
		queue2.addLast(3);
		
		System.out.println("queue2"); // queue2
		
		System.out.println(queue2.peekFirst()); // 1
		System.out.println(queue2.removeFirst()); // 1
		System.out.println(queue2.removeFirst()); // 2
		System.out.println(queue2.removeFirst()); // 3
		
		Deque<Integer> stack2 = new ArrayDeque<>(); // addLast + removeLast // 스택
		
		stack2.addLast(1);
		stack2.addLast(2);
		stack2.addLast(3);
		
		System.out.println("stack2"); // stack2
		
		System.out.println(stack2.peekLast()); // 3
		System.out.println(stack2.removeLast()); // 3
		System.out.println(stack2.removeLast()); // 2
		System.out.println(stack2.removeLast()); // 1
		
		// Deque 자료구조에서 확인할 수 있는 사실
		// add(A) + peek(B) or remove(B)가 있을 때 // (A)와 (B)는 First 또는 Last
		// (A)와 (B)가 같다면 스택(Stack)처럼 동작
		// (A)와 (B)가 다르다면 큐(Queue)처럼 동작
		// First + First, Last + Last => 스택(Stack)
		// First + Last, Last + First => 큐(Queue)
		// addFirst로 쌓고 있는 구조에서 제일 앞에 원소를 추가하고 싶다면 addLast로 추가
		// addLast로 쌓고 있는 구조에서 제일 앞에 원소를 추가하고 싶다면 addFirst로 추가
		
		Stack<Integer> stack = new Stack<>();
		
		stack.push(1);
		stack.push(2);
		stack.push(3);
		
		System.out.println("Original Stack"); // Original Stack
		System.out.println(stack.peek()); // 3
		System.out.println(stack.pop()); // 3
		System.out.println(stack.pop()); // 2
		System.out.println(stack.pop()); // 1
		
		Queue<Integer> queue = new LinkedList<>();
		
		queue.offer(1);
		queue.offer(2);
		queue.offer(3);
		
		System.out.println("Original Queue"); // Original Queue
		System.out.println(queue.peek()); // 1
		System.out.println(queue.poll()); // 1
		System.out.println(queue.poll()); // 2
		System.out.println(queue.poll()); // 3
	}
}

<Deque 자료구조>
add(A) + peek(B) or remove(B)가 있을 때 // (A)와 (B)는 First 또는 Last
(A)와 (B)가 같다면 스택(Stack)처럼 동작
(A)와 (B)가 다르다면 큐(Queue)처럼 동작
First + First, Last + Last => 스택(Stack)
First + Last, Last + First => 큐(Queue)
addFirst로 쌓고 있는 구조에서 제일 앞에 원소를 추가하고 싶다면 addLast로 추가
addLast로 쌓고 있는 구조에서 제일 앞에 원소를 추가하고 싶다면 addFirst로 추가

import java.util.Arrays;
import java.util.LinkedList;
import java.util.Queue;

public class Solution {
	
	// 두 큐 합 같게 만들기
	
	public static int solution(int[] queue1, int[] queue2) {
		int answer = 0;
		int length = queue1.length;
		long queue1Sum = 0; // queue1의 합계만을 사용할 것
		long totalSum = 0;
		long targetSum = 0;
		
		Queue<Integer> q1 = new LinkedList<>();
		Queue<Integer> q2 = new LinkedList<>();
        
		queue1Sum = Arrays.stream(queue1).sum(); // 6
        
		totalSum = queue1Sum + Arrays.stream(queue2).sum(); // 20

		if (totalSum % 2 == 1) return -1; // 똑같이 나눌 수 없다면 -1 리턴
        
		targetSum = totalSum / 2; // 10 // 하나의 큐만 절반 값을 맞춘다면 okay, 절반 값을 이용
        
		for (int i = 0; i < length; i++) {
			q1.offer(queue1[i]); // 1, 2, 1, 2
			q2.offer(queue2[i]); // 1, 10, 1, 2
		}
        
		int tempNum = 0;
        
		while (queue1Sum != targetSum) {
        	
			if (queue1Sum < targetSum) {
				tempNum = q2.poll();
				q1.offer(tempNum);
				queue1Sum += tempNum;
			} else {
				tempNum = q1.poll();
				q2.offer(tempNum);
				queue1Sum -= tempNum;
			}
        	
			answer++;
        	
			// queue1, queue2의 모든 원소가 자리바꿈하여 다시 원래의 위치로 오기 위한 횟수 (queue1.length + queue2.length) * 2 = 16
			// 즉 16이 된다는 것은 다시 처음의 경우와 같아졌음을 의미하고, 더이상 반복할 필요가 없음을 뜻한다.
			if (answer > length * 4 - 1) return -1;
		}
		
		return answer;
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[] queue1 = {1, 2, 1, 2};
		int[] queue2 = {1, 10, 1, 2};
		
		System.out.println(solution(queue1, queue2)); // 7
	}
}

프로그래머스 두 큐 합 같게 만들기 문제 풀이 Java 소스 코드

import java.util.*;

public class Solution {
	
	//	성격 유형 검사하기
	
	static String[] typeArr = {"RT", "CF", "JM", "AN"};
	
	public static String typeCheck(HashMap<Character, Integer> hm) {
		
		StringBuilder sb = new StringBuilder();
		
		char firstChar;
		char secondChar;
		char typeChar;
		
		for (String s : typeArr) { // "RT", "CF", "JM", "AN"
			
			firstChar = s.charAt(0); // 'R', 'C', 'J', 'A'
			secondChar = s.charAt(1);// 'T', 'F', 'M', 'N'
			
			typeChar = hm.get(firstChar) >= hm.get(secondChar) ? firstChar : secondChar;
			
			sb.append(typeChar); // 'T' + 'C' + 'M' + 'A'
		}
		
		return sb.toString(); // "TCMA"
	}
	
	public static String solution(String[] survey, int[] choices) {
		String answer = "";
		int[] score = {0, 3, 2, 1, 0, -1, -2, -3}; // choices 값에 따라 점수 부여
		
		HashMap<Character, Integer> hm = new HashMap<>(); // 타입, 점수 담을 HashMap
		
		int scoreSum = 0; // 타입별 점수를 담을 변수
		
		for (String s : typeArr) { // "RT", "CF", "JM", "AN"
			hm.put(s.charAt(0), 0); // 'R' : 0, 'C' : 0, 'J' : 0 ,'A' : 0
			hm.put(s.charAt(1), 0); // 'T' : 0, 'F' : 0, 'M' : 0 ,'N' : 0
		}
		
		for (int i = 0; i < survey.length; i++) { // "AN", "CF", "MJ", "RT", "NA"
			// 'A' 스코어 // 'C' 스코어 // 'M' 스코어 // 'R' 스코어 // 'N' 스코어 업데이트
			scoreSum = hm.get(survey[i].charAt(0)) + score[choices[i]];
			hm.put(survey[i].charAt(0), scoreSum);
		}
		
		// 'R' : -3, 'C' : 1, 'J' : 0 ,'A' : -1
		// 'T' :  0, 'F' : 0, 'M' : 2 ,'N' : -1
		answer = typeCheck(hm);
		
		return answer;
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		String[] survey = {"AN", "CF", "MJ", "RT", "NA"}; // survey 원소의 첫 글자를 기준으로 점수를 부여할 것이므로 score = {0, 3, 2, 1, 0, -1, -2, -3}으로 세팅
		int[] choices = {5, 3, 2, 7, 5}; // A : += score[5] // C : += score[3] // M : += score[2] // R : += score[7] // N : += score[5]
		
		System.out.println(solution(survey, choices));
	}
}

프로그래머스 성격 유형 검사하기 문제 풀이 Java 소스 코드

<JAVA>
------------------------------------------------------------------------
문자 확인 및 변환

char ch1 = 'a';

Character.isUpperCase(ch1); // 대문자 확인 : false

Character.isLowerCase(ch1); // 소문자 확인 : true

Character.isDigit(ch1); // 숫자 확인 : false

Character.toUpperCase(ch1); // 대문자 변환 : 'A'

Character.toLowerCase(ch1); // 소문자 변환 : 'a'

Character.isAlphabetic(ch1); // 영문자 확인(한글 자음, 모음 포함) : true

Character.isLetter(ch1); // 영문자 확인(한글 자음, 모음 포함) : true
------------------------------------------------------------------------
문자열 관련

String str1 = "abcd...a";

str1.length(); // 문자열 길이 : 8

str1.charAt(1); // 문자열의 해당 인덱스 값 : 'b'

"abcd...a".equals(str1); // 문자열 같은지 비교 : true

str1.toUpperCase(); // 대문자 변환 : "ABCD...A"

str1.toLowerCase(); // 소문자 변환 : "abcd...a"

str1.indexOf("a"); // 문자열 포함 확인 & 포함한다면 첫 인덱스 반환 : 0
str1.indexOf("abc"); // : 0
str1.indexOf("bc"); // : 1
str1.indexOf("bca"); // : -1 (포함하지 않으면 -1)

str1.replace("ab", "z") // 문자열 변경  : "zcd...a"
str1.replace("..", ".") // : "abcd..a"

while (str1.indexOf("..") != -1) { // ".."이 남아있는지 체크
	str1 = str1.replace("..", ".");
} // : "abcd.a"

str1.isEmpty(); // 빈 문자열인지 체크 : false

str1.substring(1); // 인덱스로 문자열 자르기(이상) : "bcd...a"
str1.substring(1,3); // (이상~미만) : "bc"

String[] str1Arr = str1.split("bc"); // 문자열 쪼개서 배열 만들기 : "a", "d...a"

str1.startsWith("ab") // "ab"로 시작하는지 확인 : true

str1.endsWith("a") // "a"로 끝나는지 확인 : true

str1.contains("cd") // "cd"를 포함하는지 확인 : true

"A".charAt(0); // 'A'
(int)"A".charAt(0); // 65
(byte)"A".charAt(0); // 65
'A' // 'A'
(int)'A'; // 65
(byte)'A'; // 65

대문자 A ~ Z : 65 ~ 90
소문자 a ~ z : 97 ~ 122
------------------------------------------------------------------------
문자열을 숫자로

String s = "123";

Integer.parseInt(s); // 123
Float.parseFloat(s); // 123.0
Double.parseDouble(s); // 123.0
------------------------------------------------------------------------
int n = 32;

String strNum3 = Integer.toString(n, 3); // 10진수를 3진수로

StringBuilder sb = new StringBuilder(strNum3); // strNum3 값을 초기값으로 가지는 sb 생성

String strNum3Reverse = sb.reverse().toString(); // 문자열 뒤집기

int answer = Integer.parseInt(strNum3Reverse, 3); // 3진수를 10진수로

sb.setLength(0); // 가장 빠른 초기화 방법

String binaryNum = Integer.toBinaryString(n); // 100000
char[] charArr = binaryNum.toCharArray(); // {'1','0','0','0','0','0'}
------------------------------------------------------------------------
String : 문자열 연산이 적고 멀티쓰레드 환경일 경우
StringBuffer : 문자열 연산이 많고 멀티쓰레드 환경일 경우
StringBuilder : 문자열 연산이 많고 단일쓰레드이거나 동기화를 고려하지 않아도 되는 경우
------------------------------------------------------------------------
절대값
int num = Math.abs(-10); // 10

제곱근값
double sqrtN = Math.sqrt(n); // 제곱근값으로 소수점이 존재하기 때문에 double
------------------------------------------------------------------------
해시맵 안에 해시셋

HashMap<String, HashSet<String>> setHashMap = new HashMap<>();

setHashMap.put("key1", new HashSet<>());
        
setHashMap.get("key1").add("value1");
setHashMap.get("key1").add("value1");
setHashMap.get("key1").add("value2");
setHashMap.get("key1").add("value3");
setHashMap.get("key1").remove("value3"); // [value2, value1]

setHashMap.containsKey("key1"); // true
------------------------------------------------------------------------
해시맵 키, 값 세팅 및 꺼내기

HashMap<String, String> strHashMap = new HashMap<>();

strHashMap.put("key1", "value1");
strHashMap.put("key1", "value2"); // value2

for (int i = 0; i < strHashMap.size(); i++) {
	String hmKey = strHashMap.keySet().toArray()[i].toString(); // put한 순서로 인덱스가 정해지진 않는다.
	String hmValue = strHashMap.values().toArray()[i].toString(); // hmKey와 순서는 일치
}
------------------------------------------------------------------------
HashMap<String, Integer> intHashMap = new HashMap<>();
        
for (int i = 0; i < genres.length; i++) {
	intHashMap.put(genres[i], intHashMap.getOrDefault(genres[i], 0) + plays[i]); // 해시맵.getOrDefault(가져올 값, 없을 경우 디폴트 값)
}
------------------------------------------------------------------------
해시셋 값 세팅 및 꺼내기

HashSet<String> hs = new HashSet<>();

hs.add("value10");
hs.add("value11");
hs.add("value12");

HashSet 출력 방법1
for (String hsValue : hs) { // 집합의 값 꺼내는 방법
	System.out.print(hsValue + ","); // value11,value10,value12,
}

HashSet 출력 방법2
Iterator it = hs.iterator();

while (it.hasNext()) {
	System.out.print(it.next() + ","); // value11,value10,value12,
}
------------------------------------------------------------------------
Hash의 특성 : 중복된 키를 허용하지 않는다.
Set의 특성 : 중복된 값을 허용하지 않는다.
------------------------------------------------------------------------
 String s = "example";
        
if (s.contains("ex")) {
	s = s.replace("ex", "xe"); // replace만 하면 안되고 담아줘야 해
}
------------------------------------------------------------------------
정렬 및 비교

String[] participant = {"leo", "kiki", "eden"};

Arrays.asList(participant); // 배열의 리스트화
Collections.frequency(리스트, 찾고자 하는 객체); // 문자열은 Object이므로 몇 개 존재하는지 찾을 수 있음

Arrays.sort(participant); // a ~ z 순서 정렬 // 숫자의 경우 1부터 정렬
Arrays.sort(participant, Collections.reverseOrder()); // z ~ a 순서 정렬 // 숫자의 경우 int[]가 아닌 Integer[]일 경우에만 가능

int[] arrA = {1, 1, 1, 6, 0};
int[] arrTempA = arrA;
Arrays.sort(arrTempA); // arrTempA 오름차순 정렬

Integer[] tempA = Arrays.stream(arrA).boxed().toArray(Integer[]::new); // int 배열인 arrA를 Integer 배열 tempA로
Arrays.sort(tempA, Collections.reverseOrder()); // tempA 내림차순 정렬
int[] arrTempA = Arrays.stream(tempA).mapToInt(Integer::intValue).toArray(); // Integer 배열인 tempA를 int 배열 arrTempA로

int[][] arr = {{5, 4}, {5, 2}, {1, 2}, {3, 1}, {1, 3}};

Arrays.sort(arr, new Comparator<int[]>() { // 2차원 배열 정렬
	@Override
	public int compare(int[] o1, int[] o2) {
		if(o1[0] == o2[0]) {
			return o1[1] - o2[1]; // 뒤 원소 오름차순 // o2[1] - o1[1] 뒤 원소 내림차순
		}else {
			return o1[0] - o2[0]; // 앞 원소 오름차순 // o2[0] - o1[0] 앞 원소 내림차순
		}
	}
});

Arrays.sort(strNumbers, new Comparator<String>() { // 숫자로 된 문자열 배열이 있을 때, 이어서 가장 큰 숫자를 만들고자 할 때 사용
	@Override
	public int compare(String o1, String o2) {
		// TODO Auto-generated method stub
		return (o2+o1).compareTo(o1+o2); // 내림차순 정렬 // 오름차순 정렬 (o1+o2).compareTo(o1+o2);
	}
});

String answer = "YES";

if ("YES".equals(answer)) // 문자열 비교는 equals로

ArrayList<String> strArrayList = new ArrayList<>();

Collections.sort(strArrayList); // 정렬

static class Music{
        String genre;
        int play;
        int idx;
        
        public Music(String genre, int play, int idx) {
            this.genre = genre;
            this.play = play;
            this.idx = idx;
        }
}

ArrayList<Music> list = new ArrayList<>();

Collections.sort(list, (o1, o2) -> o1.play - o2.play); // 오름차순 정렬
Collections.sort(list, (o1, o2) -> o2.play - o1.play); // 내림차순 정렬

int idx = Arrays.asList(strArr).indexOf("Kim");
boolean containCheck = Arrays.asList(strArr).contains("Kim");
------------------------------------------------------------------------
코딩테스트 볼 때
import java.util.*; 쓰고 시작하자
------------------------------------------------------------------------
continue; // 아래 구문으로 내려가지 않고 다시 반복문 조건으로
break; // 반복문 종료
return; // 함수 종료
------------------------------------------------------------------------
문자 치환

String match1 = "[^a-zA-Z]";

str1 = str1.replaceAll(match1, ""); // 문자열 str1에서 영문자를 제외한 모든 문자를 ""로 치환 // ^는 제외라는 의미

"[a-zA-Z]" : 영문자
"[^0-9a-zA-Z]" : 숫자, 영문자 제외
"[^\uAC00-\uD7A3]" : 특수문자 제외
"[^\uAC00-\uD7A30-9a-zA-Z]" : 특수문자, 숫자, 영문자 제외
------------------------------------------------------------------------
int[] numArr = {9, 3, 9, 3, 9, 7, 9};

Arrays.stream(numArr).sum(); // 합계 49
------------------------------------------------------------------------
System.out.println(2f); // 2.0

int i = 100;
long l1 = 100L;
long l2 = 100l;
double d1 = 1.23;
double d2 = 1.23D;
double d3 = 1.23d;
float f1 = 1.23F;
float f2 = 1.23f;
------------------------------------------------------------------------

// you can also use imports, for example:
// import java.util.*;

// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");

class Solution {
    public int solution(int[] A) {
        // write your code in Java SE 11
        float minAvg = (A[0] + A[1]) / 2f;
        float avg = 0.0f;
        int minIndex = 0;

        for (int i = 2; i < A.length; i++) {
            
            avg = (A[i - 2] + A[i - 1] + A[i]) / 3f;
            
            if (minAvg > avg) {
                minAvg = avg;
                minIndex = i - 2;
            }

            avg = (A[i - 1] + A[i]) / 2f;

            if (minAvg > avg) {
                minAvg = avg;
                minIndex = i - 1;
            }
        }

        return minIndex;
    }
}

코딜리티 MinAvgTwoSlice 문제 풀이 Java 소스 코드

// you can also use imports, for example:
// import java.util.*;

// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");

class Solution {
    public int solution(int A, int B, int K) {
        // write your code in Java SE 11
        double a = (double) A / K;
        int b = B / K;
        int c = (int) Math.ceil(a);

        return b - c + 1;
    }
}

코딜리티 CountDiv 문제 풀이 Java 소스 코드