아찌방 하우스

풀이 - 나의 생각

JOIN은 관련된 두 개 이상의 테이블을 결합하여 하나의 결과 집합으로 만드는 데 사용됩니다.

보통 두 테이블 사이에 공통 열(또는 키)이 있어야 합니다.

INNER JOIN: 두 테이블 사이에 일치하는 행만 결합합니다.

(INNER 생략 가능)

SELECT *
FROM table1
INNER JOIN table2 ON table1.column = table2.column;

LEFT JOIN: 왼쪽 테이블의 모든 행을 포함하고

오른쪽 테이블에서 일치하는 행이있는 경우 오른쪽 테이블의 행을 포함합니다.

SELECT *
FROM table1
LEFT JOIN table2 ON table1.column = table2.column;

RIGHT JOIN: 오른쪽 테이블의 모든 행을 포함하고

왼쪽 테이블에서 일치하는 행이있는 경우 왼쪽 테이블의 행을 포함합니다.

SELECT *
FROM table1
RIGHT JOIN table2 ON table1.column = table2.column;

FULL OUTER JOIN: 양쪽 테이블의 모든 행을 포함합니다.

일치하는 행이없는 경우 NULL 값을 사용합니다.

SELECT *
FROM table1
FULL OUTER JOIN table2 ON table1.column = table2.column;

https://school.programmers.co.kr/learn/courses/30/lessons/133027

풀이 - 나의 생각

SELECT FLAVOR, SUM(TOTAL_ORDER) TOTAL_ORDER
FROM JULY
GROUP BY FLAVOR

두 테이블을 조인을 하기전에 JULY 테이블에서

아이스크림 맛이 겹치는 경우를 GROUP BY로 합치면서 SUM으로 주문량을 구합니다.

-> JULY는 두개의 공장에서 출하하기 때문입니다.

그 다음에 조인한 걸 GROUP BY로 아이스크림 맛을 합치고

SUM으로 두 테이블의 합을 구합니다.

그리고 ORDER BY로 내림차순(DESC)하고

LIMIT 3로 상위 3개만 구합니다.

코드

SELECT a.FLAVOR
FROM (SELECT f.FLAVOR, SUM(f.TOTAL_ORDER+j.TOTAL_ORDER) TOTAL_ORDER
FROM FIRST_HALF f JOIN (
    SELECT FLAVOR, SUM(TOTAL_ORDER) TOTAL_ORDER
    FROM JULY
    GROUP BY FLAVOR
) j
ON f.FLAVOR = j.FLAVOR
GROUP BY f.FLAVOR
ORDER BY TOTAL_ORDER DESC) a
LIMIT 3;

https://school.programmers.co.kr/learn/courses/30/lessons/118667

풀이 - 나의 생각

코드

import java.util.*;
class Solution {
    public int solution(int[] queue1, int[] queue2) {
        int answer = 0;
        long sum1 = 0, sum2 = 0;
        Queue<Integer> q1 = new LinkedList<>();
        Queue<Integer> q2 = new LinkedList<>();
        
        for(int i = 0; i < queue1.length; i++){
            sum1 += queue1[i];
            sum2 += queue2[i];
            q1.offer(queue1[i]);
            q2.offer(queue2[i]);
        }
        
        int tmp = 0;
        while(answer < queue1.length*3){
            if(sum1 > sum2){
                tmp = q1.poll();
                q2.offer(tmp);
                sum1 -= tmp;
                sum2 += tmp;
            }else if(sum1 < sum2){
                tmp = q2.poll();
                q1.offer(tmp);
                sum2 -= tmp;
                sum1 += tmp;
            }else{
                return answer;
            }
            answer++;
        }
        return -1;
    }
}

https://school.programmers.co.kr/learn/courses/30/lessons/42883

풀이 - 나의 생각

처음에는

조합을 사용해야 하나 했지만

주어지는 number의 길이가 2자리 이상, 1,000,000자리 이하이기 때문에

다른 방법을 생각해야 했습니다.

코드

Stack 활용 ver

import java.util.Stack;
class Solution {
    public String solution(String number, int k) {
        char[] result = new char[number.length() - k];
        Stack<Character> stack = new Stack<>();

        for (int i=0; i<number.length(); i++) {
            char c = number.charAt(i);
            while (!stack.isEmpty() && stack.peek() < c && k-- > 0) {
                stack.pop();
            }
            stack.push(c);
        }
        for (int i=0; i<result.length; i++) {
            result[i] = stack.get(i);
        }
        return new String(result);
    }
}

범위 탐색 ver

class Solution {
    public String solution(String number, int k) {
        String answer = "";
        int start = 0, end = k, maxIndex = 0, max = 0, flag = 0;
        String[] nums = number.split("");
        flag = nums.length - k;
        while(answer.length() < flag){
            max = -1;
            for(int i = start; i <= end; i++){
                int num = Integer.parseInt(nums[i]);
                if(max < num){
                    max = num;
                    maxIndex = i;
                    if(num == 9) break;
                }
            }
            
            k -= (maxIndex - start);
            if(k == 0){
                answer+=number.substring(maxIndex, number.length());
                break;
            }
            start = maxIndex+1;
            answer+=nums[maxIndex];
            end++;
        }
        
        return answer;
    }
}

https://school.programmers.co.kr/learn/courses/30/lessons/42583

풀이 - 나의 생각

큐를 트럭과 다리를 담당하도록

2개를 선언했다.

1. Truck Queue

우선 Queue에 truck을 다 집어 넣는다.

2. Bridge Queue

우선 Queue에 다리 길이 만큼 0을 다 집어 넣는다.

이때 0은 truck이 올라가 있지 않다는 것을 의미한다.

3. 반복문 돌리기

while문으로 Bridge Queue가 비어 있지 않는 경우 반복문을 돌린다.

다리에 올라가 있는 트럭의 무게를 체크하면서

다음 트럭을 올려도 되는지, 안 되는지 파악한다.

코드

import java.util.*;
class Solution {
    public int solution(int bridge_length, int weight, int[] truck_weights) {
        int time = 0;
        int current_weight = 0;

        Queue<Integer> bridge = new LinkedList<>();
        Queue<Integer> trucks = new LinkedList<>();

        for(int truck : truck_weights){
            trucks.offer(truck);
        }

        for(int i = 0; i < bridge_length; i++){
            bridge.offer(0);
        }
        
        while(!bridge.isEmpty()){
            int passed_truck = bridge.poll();
            current_weight -= passed_truck;
            
            if(!trucks.isEmpty()){
                int next_truck = trucks.peek();
                
                if(current_weight + next_truck <= weight){
                    bridge.offer(trucks.poll());
                    current_weight += next_truck;
                }else{
                    bridge.offer(0);
                }
            }
            
            time++;
        }
        
        return time;
    }
}

https://school.programmers.co.kr/learn/courses/30/lessons/42839

풀이 - 나의 생각

순열을 사용해서 numbers로 만들 수 있는 모든 조합을 찾아가면서

Set에 저장(중복 제거를 위해)

그 후 소수의 갯수를 체크하면 된다.

코드

import java.util.*;
import java.util.stream.Collectors;

class Solution {
    static boolean[] visited;
    static String[] nums;
    static Set<Integer> set;
    
    public int solution(String numbers) {
        set = new HashSet<>();
        visited = new boolean[numbers.length()];
        nums = numbers.split("");
        makeNum(0, "");
        
        return set.stream()
                .filter(this::isPrime)
                .collect(Collectors.toList())
                .size();
    }
    
    public static void makeNum(int cnt, String stNum){
        if(!stNum.isEmpty()) {
            set.add(Integer.parseInt(stNum));
        }
        
        for(int i =0; i < nums.length; i++){
            if(visited[i]) continue;
            visited[i] = true;
            makeNum(cnt+1, stNum+nums[i]);
            visited[i] = false;
        }
    }
    
    public boolean isPrime(int num){
        if(num < 2) return false;
        for(int i = 2; i <= Math.sqrt(num); i++){
            if(num%i == 0) return false;
        }
        
        return true;
    }
}

https://school.programmers.co.kr/learn/courses/30/lessons/68936

풀이 - 나의 생각

제목이 거창하지만

결국에는 분할 정복입니다.

분할 정복은

조건에 부합하지 않을 경우 탐색 범위를 줄여가면서

조건을 부합하는 경우를 찾아가는 겁니다.

그렇기 때문에

우선 위의 그림처럼

처음에 2차원 배열을 값들을 한 번 살펴봅니다.

그랬을때 모든 값이 같으면 그 값으로 압축하면 끝

하지만 다른 값이 있으면 4등분하고 다시 검색하는 겁니다.

저 같은 경우

메소드를 하나 만들어 살펴볼 범위와 좌표 값을 넘깁니다.

그러면 그 좌표의 값을 기준으로 두고

넘겨 받은 범위를 둘러봅니다.

모든 값이 같다면 끝

아니라면 분할해서 다시 분석하도록 요청합니다.

위의 그림을 보면 처음에는 배열의 크기 8만큼을(Size = 8)

arr[0][0]부터(x = 0, y = 0) 탐색을 합니다.

그런데 arr[1][0] == 0 이기에 분할 후 탐색을 해야합니다.

그렇기에 size 를 절반으로 나눈후(4를 나누는게 아닙니다.)

적절한 탐색 위치를 지정해주면 됩니다.

그 적절한 탐색 위치는

x, x + size, y, y + size를 적적히 조합하면 구할 수 있습니다

코드

import java.util.*;

class Solution {
    static int[][] map;
    static int[] answer;
    public int[] solution(int[][] arr) {
        answer = new int[2];
        map = Arrays.copyOf(arr, arr.length);
        divide(arr.length, 0, 0);
        return answer;
    }
    
    public static void divide(int size, int x, int y){
        int num = map[x][y];
        boolean flag = true;
        for(int i = x; i < x+size; i++){
            for(int j = y; j < y+size; j++){
                if(num != map[i][j]){
                    flag = false;
                    break;
                }
            }
        }
        if(flag){
            answer[num]++;
        }else{
            size/=2;
            divide(size, x, y);
            divide(size, x+size, y);
            divide(size, x, y+size);
            divide(size, x+size, y+size);
        }
    }
}

https://fall-in-dream.tistory.com/86

위의 글을 보신 분들 중

의아한?궁금한? 부분이 있으신 분들이 있을거라고 생각합니다.

그것은 바로

1. NOT 연산의 결과

2. >>연산과 >>>의 차이

라고 생각합니다.

이번에는 우선 NOT 연산의 결과를 다시 한 번 살펴 봅시다.

int a = 5(0101) 를

Not 연산 결과로

-6(1010)이 나왔습니다.

'0101'을 NOT(~) 연산했으니 0과 1이 반대가 돼서 '1010'이 나온 것까지는 OK

근데 '1010'은 12가 아닌가?

생각할 수 있습니다.

NOT연산자를 이해하기 위해서는

JAVA는 2의 보수를 사용하는 것을 알아야 합니다.

예로,

int 형의 변수는 32비트로 나타내는데

즉, int a = 5; 라고 하면

우리가 보기에는 '0101'이지만

사실은

'0000  0000  0000  0000  0000  0000   0000  0101'이라는 사실!!!!

그러면 이 것을 NOT(~) 연산한다면?

'0000  0000  0000  0000  0000  0000   0000  1010'이 아니라

'1111  1111  1111  1111  1111  1111   1111  1010'가 되는 겁니다!!!!

이진수 '1111  1111  1111  1111  1111  1111   1111  1010' 는 부호 비트가 1로 시작하므로 음수로 간주됩니다.

이진수에서 2의 보수를 취하면 해당 음수의 양수 표현이 됩니다.

따라서 '1111 1111 1111 1111 1111 1111 1111 1010'의

2의 보수는

'0000 0000 0000 0000 0000 0000 0000 0110'이 되고, 이는 10진수로 -6입니다.

(2의 보수에 대해서는 다음에 한 번 다루어 보도록 하겠습니다.)

그러면 다음에는

>>연산과 >>>연산의 차이에 대해 들고 오겠습니다!!!