개발 학습 블로그

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로 추가

SELECT (CASE WHEN B.GRADE >= 8 THEN A.NAME ELSE NULL END) AS NAME
     , B.GRADE
     , A.MARKS
  FROM STUDENTS A, GRADES B
 WHERE A.MARKS <= B.MAX_MARK
   AND A.MARKS >= B.MIN_MARK
 ORDER BY B.GRADE DESC, NAME, A.MARKS

모든 데이터는 등급을 기준으로 내림차순 정렬되어야 하며,
GRADE가 8 이상인 것들 '이름'을 기준으로 오름차순 정렬,
GRADE가 8 미만인 것들은 '점수'를 기준으로 오름차순 정렬되어야 한다.

(CASE WHEN B.GRADE >= 8 THEN A.NAME ELSE NULL END) AS NAME에서
GRADE가 8 미만인 것들은 NAME이 NULL로 조회되기 때문에
이 경우, 같은 등급 내에서 ORDER BY NAME에 영향을 받지 않게 된다.
결과적으로, GRADE가 8 이상인 것들은 같은 등급 내에서 '이름'을 기준으로 오름차순 정렬이,
GRADE가 8 미만인 것들은 같은 등급 내에서  '점수'를 기준으로 오름차순 정렬이 된다.

해커랭크 The Report SQL

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 소스 코드

SELECT MAX(CASE WHEN A.OCCUPATION = 'Doctor' THEN NAME END) AS 'Doctor'
     , MAX(CASE WHEN A.OCCUPATION = 'Professor' THEN NAME END) AS 'Professor'
     , MAX(CASE WHEN A.OCCUPATION = 'Singer' THEN NAME END) AS 'Singer'
     , MAX(CASE WHEN A.OCCUPATION = 'Actor' THEN NAME END) AS 'Actor'
  FROM (
         SELECT NAME
              , OCCUPATION
              , ROW_NUMBER() OVER (PARTITION BY OCCUPATION ORDER BY NAME) AS RN
           FROM OCCUPATIONS
       ) A
GROUP BY A.RN

해커랭크 Occupations SQL

SELECT G.NODE
  FROM (
         SELECT CONCAT(N, ' Root') AS NODE
              , N
           FROM BST
          WHERE P IS NULL
      UNION ALL
         SELECT CONCAT(N, ' Inner') AS NODE
              , N
           FROM BST
          WHERE N IN (
                       SELECT P
                         FROM BST
                     )
            AND P IS NOT NULL
      UNION ALL       
         SELECT CONCAT(N, ' Leaf') AS NODE
              , N
           FROM BST
          WHERE N NOT IN (
                           SELECT DISTINCT P
                             FROM BST
                            WHERE P IS NOT NULL
                         )
       ) G
ORDER BY G.N

해커랭크 Binary Tree Nodes SQL 풀이

SELECT CONCAT(NAME, '(', SUBSTR(OCCUPATION, 1, 1), ')')
  FROM OCCUPATIONS
 ORDER BY NAME;

SELECT CONCAT('There are a total of ', COUNT(OCCUPATION), ' ', LOWER(OCCUPATION), 's.') 
  FROM OCCUPATIONS
 GROUP BY OCCUPATION
 ORDER BY COUNT(OCCUPATION), OCCUPATION

해커랭크 The PADS SQL

SELECT CASE WHEN A = B AND B = C THEN 'Equilateral'
            WHEN A + B <= C OR B + C <= A OR C + A <= B THEN 'Not A Triangle'
            WHEN A = B OR B = C OR C = A THEN 'Isosceles'
            ELSE 'Scalene' END
  FROM TRIANGLES

A + B <= C OR B + C <= A OR C + A <= B THEN 'Not A Triangle' 조건이

A = B OR B = C OR C = A THEN 'Isosceles' 조건보다 먼저 나와야 하는 이유

​

A = B OR B = C OR C = A THEN 'Isosceles 조건이 먼저 나오게 되면

A = B = 1이고 C = 2인 경우 삼각형 조건이 성립하지 않지만,

Isosceles(이등변 삼각형)라는 값을 RETURN하기 때문이다.

해커랭크 Type of Triangle SQL