아찌방 하우스

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

풀이 - 나의 생각

뒤에 소수점이 붙은걸 어떻게 알지?

라는 고민만 해결하면 되는 문제입니다.

제가 선택한 방법은

Double형을 long형으로 변환해서 비교하는 방법이었습니다.

우선 주어진 정수 n의 제곱근을 Double형으로 저장한 후

이것을 long형으로 변환 후 비교하면 되는 아주 간단한 방식입니다.

그런데 이 두가지의 차이가 뭐길래 이런 결과가 날까? 생각할 것입니다.

부동 소수점과 정수 변환

1. double 타입:
   • double은 64비트 IEEE 754 부동 소수점 숫자입니다.
   • 소수 부분을 포함할 수 있으며, 매우 큰 값과 매우 작은 값을 표현할 수 있습니다.
2. long 타입:
   • long은 64비트 정수입니다.
   • 소수 부분을 포함할 수 없으며, 정수만 표현할 수 있습니다.

long 타입은 이미 정수입니다.

double 값을 long으로 캐스팅하면 소수 부분이 버려집니다. 즉, double 값에서 정수 부분만 남게 됩니다.

public class Main {
    public static void main(String[] args) {
        double value = 4.26;
        long longValue = (long) value;
        
        System.out.println("Original double value: " + value); // 4.26
        System.out.println("Converted long value: " + longValue); // 4
    }
}

이렇게 되는 겁니다.

그러니까 제곱근이 X.xxxxxxx 이렇게 나왔을때

이것을 long 타입으로 변환하면 X.0000000이렇게 되는 겁니다.

그러니까

X.xxxxxxx == X.0000000 하면 False가 나오겠죠?

ps.

추가적으로 제가 제곱을 할때

Math.pow()를 쓰지 않았는데

그 이유는 이런 간단한 계산에서는 오히려 비효율적이기 때문입니다.

Math.pow는 더 복잡한 거듭 제곱 계산을 위해 유용합니다.

코드

class Solution {
    public long solution(long n) {
        long answer = -1;
        double sqrt = Math.sqrt(n);
        if(sqrt == (long)sqrt){
            sqrt++;
            answer = (long)(sqrt * sqrt);
        }
        return answer;
    }
}

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

풀이 - 나의 생각

전형적인 다익스트라 알고리즘에다가

비교연산 한 번이 추가 된 문제입니다.

무지와 어파치가 각자의 목적지 'A' 와 'B'에

최소한의 비용으로 가는 방법을 알기 위해서는

결국에 모든 목적지에 최소한의 비용으로 가는 방법을 알아야합니다.

그렇기에

int[] distFromStart = dijkstra(graph, n, s);
int[] distFromA = dijkstra(graph, n, a);
int[] distFromB = dijkstra(graph, n, b);

우선 출발지에서 모든 지점으로의 최소 비용을 구합니다.

A와 B에서 모든 지점의 최소 비용을 구합니다.

그 후 세가지 경우의 합을 비교합니다.

그 이유는

우리가 고려해야하는 경우는

1. 일정 지점까지 동행 후, 그 지점부터 각자의 목적지를 가는 경우

2. 처음부터 각자 가는 경우

두가지 입니다.

출발지에서 시작하는 다익스트라는 일정 지점까지 동행하는 경우를,

A, B에서 출발하는 다익스타는 일정 지점에서부터 각자가 간 경우를 알 수 있게 합니다.

그렇기에 세개의 배열의 합은

목적지까지의 비용을 나타내게 되는겁니다.

코드

import java.util.*;

class Node implements Comparable<Node>{
    int index;
    int cost;
    
    public Node(int index, int cost){
        this.index = index;
        this.cost = cost;
    }
    
    @Override
    public int compareTo(Node other){
        return Integer.compare(this.cost, other.cost);
    }
}

class Solution {
    public int solution(int n, int s, int a, int b, int[][] fares) {
        int[][] graph = new int[n+1][n+1];
        //그래프 초기화 및 값 입력
        for(int i = 1; i <= n; i++){
            Arrays.fill(graph[i], Integer.MAX_VALUE);
        }
        for(int[] fare : fares){
            graph[fare[0]][fare[1]] = fare[2];
            graph[fare[1]][fare[0]] = fare[2];
        }
        
        int[] distFromStart = dijkstra(graph, n, s);
        int[] distFromA = dijkstra(graph, n, a);
        int[] distFromB = dijkstra(graph, n, b);
        
        int minCost = Integer.MAX_VALUE;
        for(int i = 1; i <= n; i++){
            if(distFromStart[i] != Integer.MAX_VALUE && distFromA[i] != Integer.MAX_VALUE && distFromB[i] != Integer.MAX_VALUE){
                minCost = Math.min(minCost, distFromStart[i] + distFromA[i] + distFromB[i]);
            }
        }
        
        return minCost;
    }
    
    private int[] dijkstra(int[][] graph, int n, int start){
        int[] dist = new int[n+1];
        Arrays.fill(dist, Integer.MAX_VALUE);
        dist[start] = 0;
        
        PriorityQueue<Node> pq = new PriorityQueue<>();
        pq.add(new Node(start, 0));
        
        while(!pq.isEmpty()){
            Node node = pq.poll();
            int current = node.index;
            int cost = node.cost;
            
            //가야할 곳의 비용이 기존의 비용보다 비싸면 pass
            if(cost > dist[current]) continue;
            
            for(int i = 1; i <= n; i++){
            	//자기 자신의 위치, 연결이 안된 곳은 pass
                if(graph[current][i] == Integer.MAX_VALUE) continue;
                
                int newDist = cost + graph[current][i];
                //새로운 최소 비용일 시 갱신
                if(newDist < dist[i]){
                    dist[i] = newDist;
                    pq.add(new Node(i, newDist));
                }
            }
        }
        
        return dist;
    }
}

https://school.programmers.co.kr/learn/courses/30/lessons/12916?language=java

풀이 - 나의 생각

String 함수 중 replaceAll을 활용하면 아주 쉽게 해결됩니다.

저 같은 경우 toLowerCase()를 사용했지만

replaceAll("[P,p,Y,y]","") 를 사용하면

P, p, Y, y가 모두 삭제되고

replaceAll("[^P,p,Y,y]","") 를 사용하면

P, p, Y, y를 제외한 문자를 모두 삭제합니다.

아무튼 저는 다 소문자로 바꾸고

p, y을 제외한 문자를 삭제했습니다.

그 후 p를 제외한 문자열 길이와 y를 제외한 문자열 길이가

짝수가 아니면 False를 반환하게 하였습니다.

하지만 이외에도

p를 제외한 문자열과 y를 제외한 문자열의 길이의 차가 0이 아니면

False를 반환하게 해도 됩니다.

코드

class Solution {
    boolean solution(String s) {
        boolean answer = true;
        
        s = s.toLowerCase();
        s = s.replaceAll("[^p,y]","");
        if(s.length() == 0) return answer;
        else if(s.length()%2!=0) return false;
        
        if(s.replaceAll("[p]","").length() == s.replaceAll("[y]","").length()) return true;
        
        return false;
    }
}

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

풀이 - 나의 생각

먼저 8~10월 총 대여 횟수가 5회 이상인 CAR_ID를 찾아낸 후

JOIN한다.

그 후에 GROUP BY로 달 별, CAR_ID 별로 묶어서

그 숫자를 센다.

코드

SELECT MONTH(START_DATE) MONTH, C.CAR_ID, COUNT(*) RECORDS
FROM CAR_RENTAL_COMPANY_RENTAL_HISTORY C
JOIN (
    SELECT CAR_ID
    FROM CAR_RENTAL_COMPANY_RENTAL_HISTORY
    WHERE MONTH(START_DATE) IN (8, 9, 10)
    GROUP BY CAR_ID
    HAVING COUNT(HISTORY_ID) >= 5) SUB ON C.CAR_ID = SUB.CAR_ID
WHERE MONTH(START_DATE) IN (8, 9, 10)
GROUP BY MONTH, C.CAR_ID
HAVING COUNT(*) >= 1
ORDER BY MONTH, C.CAR_ID DESC;

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

풀이 - 나의 생각

StringBuilder에 반절분을 저장한 후

"0" 추가 후

기존에 저장된 음식을 뒤집은 걸 append 해주면 됩니다.

String의 경우 reverse 함수가 없지만

StringBuilder에는 reverse 함수가 있기에 이를 활용해 봤습니다.

Stirng으로 하실경우

반복문으로 문자열의 뒤에서부터 하나씩 저장해가면 

reverse된 문자열을 구하실 수 있습니다.

코드

class Solution {
    public String solution(int[] food) {
        StringBuilder sb = new StringBuilder();
        int len = 0;
        for(int i = 1; i < food.length; i++){
            for(int j = 0; j < food[i]/2; j++){
                sb.append(i);
            }
        }
        
        StringBuilder reverse = new StringBuilder(sb).reverse();
        sb.append("0").append(reverse);
        
        return sb.toString();
    }
}

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

풀이 - 나의 생각

서브쿼리를 조인하여 문제를 해결했습니다.

코드

SELECT P.*
FROM PLACES P
JOIN (
    SELECT HOST_ID
    FROM PLACES
    GROUP BY HOST_ID
    HAVING COUNT(*) > 1
) Sub ON P.HOST_ID = Sub.HOST_ID
ORDER BY P.ID;

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

풀이 - 나의 생각

코드

SELECT CONCAT('/home/grep/src/',BOARD_ID,'/',FILE_ID,FILE_NAME,FILE_EXT) FILE_PATH
FROM USED_GOODS_FILE
WHERE BOARD_ID LIKE (
    SELECT BOARD_ID
    FROM USED_GOODS_BOARD
    ORDER BY VIEWS DESC
    LIMIT 1
)
ORDER BY FILE_ID DESC

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

풀이 - 나의 생각

현재 칠해야하는 위치(wall)가

현재 롤러의 위치(index)보다 크거나 같을 경우,

이 말은

새롭게 페인트를 칠해야한다는 말과 같습니다.

그렇기에 cnt를 +1 해주고

롤러의 위치(index)를 wall + m을 통해

페인트를 칠한 후의 위치로 옮겨 주면 됩니다.

그리고 롤러의 위치가 주어진 벽의 길이(n)를 넘어선다면

모든 벽을 칠한 것이기 때문에 break해주어 빠르게 끝내면 됩니다.

코드

class Solution {
    public int solution(int n, int m, int[] section) {
        int index = 0, cnt = 0;
        
        for(int wall : section){
            if(index <= wall){
                cnt++;
                index = wall + m;
            }
            if(index > n) break;
        }
        
        return cnt;
    }
}