아찌방 하우스

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/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/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/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;
    }
}

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

풀이 - 나의 생각

1. 먼저, 1부터 주어진 수의 제곱근까지의 범위에서 반복합니다. 이 범위를 선택하는 이유는 주어진 수의 약수는 해당 수의 제곱근보다 클 수 없기 때문입니다. 만약 제곱근보다 큰 약수가 존재한다면, 해당 약수는 이미 이전에 제곱근 이하의 약수에서 포함되었을 것입니다.
2. 주어진 수를 반복하는 동안, 해당 수를 현재 인덱스로 나누어떨어지는지 확인합니다. 나누어떨어지면 현재 인덱스는 해당 수의 약수이므로 카운트를 증가시킵니다.
3. 만약 나누어떨어진 수가 현재 인덱스와 같다면, 이는 제곱수임을 의미합니다. 예를 들어, 99의 약수 중 33은 제곱근인 √9​=3과 같으므로 제곱수입니다. 따라서 카운트를 증가시킵니다.
4. 그렇지 않은 경우에는 현재 인덱스와 나누어떨어진 수의 약수가 모두 카운트에 포함되므로, 카운트를 2 증가시킵니다.
5. 반복이 완료되면 약수의 총 개수를 반환합니다.

예를 들어,n=12인 경우

1. i=1일 때, 12를 1로 나누면 나누어떨어지므로 약수이며, 카운트는 +2 증가합니다.
2. i=2일 때, 12를 2로 나누면 나누어떨어지므로 약수이며, 카운트는 +2 증가합니다.
3. i=3일 때, 12를 3으로 나누면 나누어떨어지므로 약수이며, 카운트는 +2 증가합니다.

이렇게 하여 12의 약수의 개수는 6이 됩니다.

예를 들어,n=16인 경우

1. i=1일 때, 12를 1로 나누면 나누어떨어지므로 약수이며, 카운트는 +2 증가합니다.
2. i=2일 때, 12를 2로 나누면 나누어떨어지므로 약수이며, 카운트는 +2 증가합니다.
3. i=3일 때, 12를 3으로 나누면 나누어떨어지지 않으므로 약수가 아닙니다.
4. i=4일 때, 12를 4으로 나누면 나누어떨어지고 제곱근이므로, 카운트는 +1 증가합니다.

이렇게 하여 12의 약수의 개수는 5이 됩니다.

코드

class Solution {
    public int solution(int left, int right) {
        int answer = 0;
        for(int i = left; i <= right; i++){
            if(flag(i)%2 == 0){
                answer+=i;
            }else{
                answer-=i;
            }
        }
        return answer;
    }
    
    public int flag(int n){
        int count = 0;
        for(int i = 1; i <= Math.sqrt(n); i++){
            if (n % i == 0) {
                if (n / i == i) { // 제곱수인 경우
                    count++;
                } else { // 제곱수가 아닌 경우
                    count += 2;
                }
            }
        }
        
        return count;
    }
}

주소

풀이 - 나의 생각

효율적으로 약수를 구하는 방법을 알려드리고자 들고온 문제입니다.

보통 n의 약수를 구하기 위해서 사용하는 방법은

public int solution(int n) {
        int answer = 0;
        for(int i = 1; i <= n; i++){
            if(n%i == 0){
                answer+=i;
            } 
        }
        return answer;
}

위와 같이 1부터 n까지 반복문을 돌려

나머지가 0인 수를 찾는 것이겠죠?

그런데

약수라는 것은 숫자의 제곱근을 기준으로 대칭을 이룬다는 사실!!!!

알고 계셨나요???

요런 느낌입니다.

그러니까 반복문을 n의 제곱근까지 돌리면서

대칭하는 숫자도 같이 더하면

반복문의 횟수가 많이 줄어들겠죠?

하나 주의할 점은

약수의 개수가 홀수이면

대칭을 이루지 않는 약수가 있겠죠?

그것만 예외처리 해주면 됩니다.

코드

class Solution {
    public int solution(int n) {
        int answer = 0;
        for(int i = 1; i <= Math.sqrt(n); i++){
            if(n%i == 0){
                answer+=i;  
                if(i == n/i) continue;
                answer+=(n/i);
            } 
        }
        return answer;
    }
}

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

풀이 - 나의 생각

처음에는

String[] arr = s.split(" ");

이런 식으로 공백을 기준으로 단어를 잘라서 했는데

이럴경우

"_abc_def_"

이런 경우("_"가 공백이다)

arr = {"abc", "def"} 가 돼서 답이 나오지 않았다.

그래서

for(String s : s.split("")){}

으로 주어진 문자열을 한 글자 단위로 모두 자르고

공백일 경우 " " 

위치가 짝수, 홀수일 경우로 구분해서 문자열을 저장했다.

코드

class Solution {
    public String solution(String s) {
        StringBuilder sb = new StringBuilder();
        int index = 0;
        for(String word : s.split("")){
            if(word.equals(" ")){
                index = 0;
                sb.append(" ");
                continue;
            }else if(index%2 == 0){
                sb.append(word.toUpperCase());
            }else{
                sb.append(word.toLowerCase());
            }
            index++;
        }
        return sb.toString();
    }
}

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

풀이 - 나의 생각

소수는 1과 자기 자신으로만 나누어지는 수입니다.

이걸 판별하는 여러가지 방법이 있는데

저는 trial division(시도로 나누기) 방법을 사용했습니다.

 n이 주어질때

2부터 n의 제곱근까지만 확인하면 되는겁니다.

예를 들어서

16이 주어질 때

2분터 4(16의 제곱근)까지만 나누어 보면

소수인지 아닌지 판별이 가능한 것을 알 수 있습니다.

코드

class Solution {
    public int solution(int n) {
        int answer = 0;
        for(int i = 2; i <=n; i++){
            if(isPrimeNumber(i)) answer++;
        }
        return answer;
    }
    
    public static boolean isPrimeNumber(int num){
        if(num <= 1) return false;
        
        for(int i = 2; i <= Math.sqrt(num); i++){
            if(num%i == 0) return false;
        }
        
        return true;
    }
}