프로그래머스 알고리즘 1단계

2023년 11월 11일 TIL

II

비축해둔 알고리즘 분량을 다 써버렸다..

최소한 평일보단 여유롭게 보내더라도 알고리즘 몇문제는 풀고 넘기자

행렬의 덧셈

행렬의 덧셈

    public int[][] solution(int[][] arr1, int[][] arr2) {
        int[][] answer = arr1;

        for (int i = 0; i < arr1.length; i++) {
            for (int j = 0; j < arr1[i].length; j++) 
                answer[i][j] = arr1[i][j] + arr2[i][j];
        }

        return answer;
    }

행렬의 덧셈

배열의 길이를 따로 받아서 넣어줄까 하다가 별로 큰 차이는 없겠다 싶어
가독성으로 가기로 했다.
나만 알면 되지.

직사각형 별 찍기

직사각형 별 찍기

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt();
        int b = sc.nextInt();

        for (int i = 0; i < b; i++) {
            for (int j = 0; j < a; j++)
                System.out.print('*');
            if (i != b-1)
                System.out.println();
        }
    }

직사각형 별 찍기

이젠 1단계 문제라면 크게 어려울것 없이 그냥 그림 그려나간다는 생각으로
문제를 풀어 나갔다.

틀렸다.

코드를 노려보다 이마를 한대 때려주고
a와 b의 위치를 뒤집어주었다.

최대 공약수와 최소 공배수

최대 공약수와 최소 공배수

    public int[] solution(int n, int m) {
        int gcd = euclidean(n, m);
        int lcm = n * m / gcd;

        return new int[]{gcd, lcm};
    }

    public int euclidean (int n, int m) {
        int j = 1;

        while ( j > 0 ) {
            j = n % m;
            n = m;
            m = j;
        }

        return n;
    }

최대 공약수와 최소 공배수

최대 공약수와 최소 공배수는
"유클리드 호재법" 하나만 기억해두면 될것 같다.

공식과도 같은 유클리드 메서드를 만들어준다.

int gcd = euclidean(n, m); // 최대 공약수
int lcm = n * m / gcd;     // 최소 공배수

3진법 뒤집기

3진법 뒤집기

  // 1차 시도
    public static int solution(int n) {
        int answer = 0;

        List<Integer> ternary = new ArrayList<>();

        while (n > 0) {
            ternary.add(n % 3);
            n /= 3;
        }

        int[] arrayTernary = ternary.stream().mapToInt(i -> i).toArray();

        int base = 0;
        for (int i = arrayTernary.length  - 1; i >= 0; i--)
            answer += arrayTernary[i] * (int)Math.pow(3, base++);

        return answer;
    }

  // 2차 시도
    public static int solution(int n) {
        int answer = 0;

        List<Integer> ternary = new ArrayList<>();

        while (n > 0) {
            ternary.add(n % 3);
            n /= 3;
        }

        int base = 0;
        for (int i = ternary.size() - 1; i >= 0; i--)
            answer += ternary.get(i) * (int)(Math.pow(3, base++));

        return answer;
    }

3진법 뒤집기

2진법 변환이라면 별 생각 없이 풀었을거라 생각했는데
3진법이 나타나니 이상하게 잘 안풀렸다.

잠깐 머리를 식힐겸 일단 정답부터 만들어두고 최적화를 하자는 생각에

stream().mapToInt(i -> i).toArray();

를 사용했다.
굳이 배열을 뒤집을것 없이 뒤에서 부터 읽어오면 됐으니 진법을 뒤집는 과정은 생략했다.

이후, stream() 을 사용하지 않고 List를 뒤에서 get()해주는 방식으로
최적화를 시도했다.

확실히, 굳이 필요한게 아니라면 toStream 을 사용하지 않는 방법을 찾는게 맞다.

이상한 문자 만들기

이상한 문자 만들기

    public String solution37(String s) {
        StringBuilder answer = new StringBuilder();
        int metBlack = 0;
        char[] tmpS = s.toCharArray();

        for (int i = 0; i < tmpS.length; i++) {
            char c = tmpS[i];

            if (tmpS[i] == ' ') {                                        
                answer.append(c);
                metBlack = 0;                                        
            } else {                                        
                if (metBlack % 2 == 0)
                    answer.append(Character.toUpperCase(c));
                else
                    answer.append(Character.toLowerCase(c));
                metBlack++;                                        
            }
        }                                        
        return answer.toString();
    }

이상한 문자 만들기

출력값을 String에 더해 나가서 출력해야 한다는걸 문제를 보자마자 알았기에
StringBuilder 를 들고 시작했지만,
toUpperCase와 toLowerCase를 직접 구현하려다 포기했다.

toUpperCase 와 toLowerCase 를 메서드화 시켜서 빼내 만들어 볼까 했다.
다만, 이에 따라 해당 글자의 대소문자에 따른 조건문을 추가시켜줘야 하기 때문에
내장 메서드를 사용하는것 보다 훨씬 더 많은 시간을 필요로 할것 같은 예감이 들어
그냥 있는걸 쓰기로 했다.

삼총사

삼총사

public int solution(int[] number) {
    int answer = 0;

    for (int first = 0; first < number.length - 2; first++) {
        for (int second = first + 1; second < number.length - 1; second++) {
            for (int third = second + 1; third < number.length; third++) {
                if (number[first] + number[second] + number[third] == 0)
                    answer++;
            }
        }
    }
    return answer;
}

삼총사

문제가 더럽다

크기가 작은 부분 문자열

크기가 작은 부분 문자열

    public int solution(String t, String p) {
        int answer = 0;
        char[] tmpT = t.toCharArray();
        Long target;
        Long intP = Long.parseLong(p);

        for (int i = 0; i <= t.length() - p.length(); i++) {
            target = 0L;
            for (int j = 0; j < p.length(); j++) {
                target = target * 10 + tmpT[i + j] - 48;
            }
            if (target <= intP)
                answer++;
        }

        return answer;
    }

크기가 작은 부분 문자열

이 문제 역시 풀면서 더럽다고 느꼈다.
문자열을 반복해서 접근해야 하는 문제들은 풀면서 항상 약간의 조바심이 든다.

첫 시도에서 P 를 int 로 주고 풀었다.
무수한 런타임 에러가 쏟아졌고, import java.util.*;을 주며 맞을거라 생각했다.
p의 범위를 제대로 보지 않은 탓 이었는다.

p는 최대 18자리 숫자로 int_Max인 2147483647보다 8자리 더 큰 숫자가 들어올 수 있었다.
Long으로 변환시켜주자 속도는 생각보다 좀 안 나오지만 그냥 그런대로 풀렸다.