힌트

풀이

출처

프로그래머스 - lv1 -

힌트

풀이

출처

프로그래머스 - lv1 -

힌트

풀이

출처

프로그래머스 - lv1 -

힌트

풀이

출처

프로그래머스 - lv1 -

힌트

풀이

출처

프로그래머스 - lv1 -

힌트

풀이

출처

프로그래머스 - lv1 -

힌트

풀이

출처

프로그래머스 - lv1 -

힌트

풀이

출처

프로그래머스 - lv1 -

문제설명

자연수 n이 매개변수로 주어집니다. n을 3진법 상에서 앞뒤로 뒤집은 후, 이를 다시 10진법으로 표현한 수를 return 하도록 solution 함수를 완성해주세요.

제한사항

• n은 1 이상 100,000,000 이하인 자연수입니다.

입출력 예

입출력 예 설명

입출력 예 #1

• 답을 도출하는 과정은 다음과 같습니다.

• 따라서 7을 return 해야 합니다.

입출력 예 #2

• 답을 도출하는 과정은 다음과 같습니다.

힌트

• 10진법->3진법 표현을 위하여 먼저 제시된 숫자가 3진법으로 표현될 시 가장 큰 자리가 몇번째 자리(이하 p)인지 구합니다.
• p를 구하기위하여 반복문을 통하여 3의 제곱수만큼 나누어 몫이 1미만인 수를 구하고 그것보다 1이 작은 수가 p입니다.
• p를 이용하여 3진법 숫자를 구합니다.
• 구한 3진법 수를 뒤집어 다시 10진법으로 구하여 답을 구합니다.

풀이

    public int solution(int n) {
        int biggestPlaceValue = getBiggestPlaceValue(n); // 3진법 표현시 자릿수를 구한다.
        String ternary = getTernary(biggestPlaceValue, n).toString(); // 자릿수를 이용해 3진법수를 구한다.
        return getDecimal(ternary); // 3진법을 10진법으로 구한 수를 리턴
    }

    int getDecimal(String ternary) {
        int idx = 0;
        int decimal = 0;

        for(char c : ternary.toCharArray()) { // 3진법을 뒤집어야 하므로 앞에서부터 가져온다.
            int digit = Integer.parseInt(c + ""); // 3진법 자리의 수를 구함
            decimal += (int)Math.pow(3, idx) * digit; // 10진법 처리를 위해 다시 3의 제곱수를 곱해준다. 
            idx += 1;
        }

        return decimal;
    }

    StringBuilder getTernary(int biggestPow, int n) {
        StringBuilder stb = new StringBuilder();
        for(int i = biggestPow; i >= 0; i--) { // 최대자리수부터 시작하여 감소
            int num = n / (int)Math.pow(3, i); // 해당 자리의 들어갈 수를 구함
            n = n - (int)Math.pow(3, i) * num; // 3진법 표현한만큼 n감소
            stb.append(num);
        }

        return stb;
    }

    int getBiggestPlaceValue(int n) {
        int biggestPlaceValue = 0;

        for(int i = 0; i <= n; i++) { // 3^0=1, 3^1=3, 3^2=9, ...
            if(n < Math.pow(3, i)) {  // 3의 n제곱이 주어진 수보다 클때
                biggestPlaceValue = i - 1; // n-1이 3진법 표현시 최대자릿수임
                break;
            }
        }

        return biggestPlaceValue;
    }

출처

프로그래머스 - lv1 - 3진법 뒤집기

문제설명

두 정수 left와 right가 매개변수로 주어집니다. left부터 right까지의 모든 수들 중에서, 약수의 개수가 짝수인 수는 더하고, 약수의 개수가 홀수인 수는 뺀 수를 return 하도록 solution 함수를 완성해주세요.

제한사항

• 1 ≤ left ≤ right ≤ 1,000

입출력 예

입출력 예 설명

입출력 예 #1

• 다음 표는 13부터 17까지의 수들의 약수를 모두 나타낸 것입니다.

입출력 예 #2

• 다음 표는 24부터 27까지의 수들의 약수를 모두 나타낸 것입니다.

힌트

• 1은 약수의 개수가 홀수입니다. (1)
• 2는 약수의 개수가 짝수입니다. (1, 2)
• 임의의 수 n이 가질 수 있는 가장 큰 약수는 n/2입니다.
• n이 가질 수 있는 가장 큰 약수를 c라고 할때, 2부터 c까지(1은 모든 수의 공통된 약수이므로 제외) 나머지를 구하여 나머지가 0이면 n의 약수입니다.
• 위에서 구한 나머지 개수(반복문에서 1을 제외하였으므로 1을 추가)를 2로 나눴을때 나머지가 0이면 짝수, 1이면 홀수입니다.

풀이

    public int solution(int left, int right) {
        int answer = 0;

        for(int i = left; i <= right; i++) {
            if(isDivisorOfNumEven(i) == true) answer += i;
            else answer -= i;
        }
        return answer;
    }

    boolean isDivisorOfNumEven(int number) {
        if(number == 1) return false;
        else if(number == 2) return true;

        int criteria = number / 2;
        int cnt = 1;
        for(int i = 2; i <= criteria; i++) {
            if(number % i == 0) cnt += 1;
        }

        return (cnt + 1) % 2 == 0 ? true : false;
    }

출처

프로그래머스 - lv1 - 약수의 개수와 덧셈

문제설명

슈퍼 게임 개발자 오렐리는 큰 고민에 빠졌다. 그녀가 만든 프랜즈 오천성이 대성공을 거뒀지만, 요즘 신규 사용자의 수가 급감한 것이다. 원인은 신규 사용자와 기존 사용자 사이에 스테이지 차이가 너무 큰 것이 문제였다.

이 문제를 어떻게 할까 고민 한 그녀는 동적으로 게임 시간을 늘려서 난이도를 조절하기로 했다. 역시 슈퍼 개발자라 대부분의 로직은 쉽게 구현했지만, 실패율을 구하는 부분에서 위기에 빠지고 말았다. 오렐리를 위해 실패율을 구하는 코드를 완성하라.

• 실패율은 다음과 같이 정의한다.
  • 스테이지에 도달했으나 아직 클리어하지 못한 플레이어의 수 / 스테이지에 도달한 플레이어 수

전체 스테이지의 개수 N, 게임을 이용하는 사용자가 현재 멈춰있는 스테이지의 번호가 담긴 배열 stages가 매개변수로 주어질 때, 실패율이 높은 스테이지부터 내림차순으로 스테이지의 번호가 담겨있는 배열을 return 하도록 solution 함수를 완성하라.

제한사항

• 스테이지의 개수 N은 1 이상 500 이하의 자연수이다.
• stages의 길이는 1 이상 200,000 이하이다.
• stages에는 1 이상 N + 1 이하의 자연수가 담겨있다.
  • 각 자연수는 사용자가 현재 도전 중인 스테이지의 번호를 나타낸다.
  • 단, N + 1 은 마지막 스테이지(N 번째 스테이지) 까지 클리어 한 사용자를 나타낸다.
• 만약 실패율이 같은 스테이지가 있다면 작은 번호의 스테이지가 먼저 오도록 하면 된다.
• 스테이지에 도달한 유저가 없는 경우 해당 스테이지의 실패율은 0 으로 정의한다.

입출력 예

입출력 예 설명

입출력 예 #1
1번 스테이지에는 총 8명의 사용자가 도전했으며, 이 중 1명의 사용자가 아직 클리어하지 못했다. 따라서 1번 스테이지의 실패율은 다음과 같다.

• 1 번 스테이지 실패율 : 1/8

2번 스테이지에는 총 7명의 사용자가 도전했으며, 이 중 3명의 사용자가 아직 클리어하지 못했다. 따라서 2번 스테이지의 실패율은 다음과 같다.

• 2 번 스테이지 실패율 : 3/7

마찬가지로 나머지 스테이지의 실패율은 다음과 같다.

• 3 번 스테이지 실패율 : 2/4
• 4번 스테이지 실패율 : 1/2
• 5번 스테이지 실패율 : 0/1

각 스테이지의 번호를 실패율의 내림차순으로 정렬하면 다음과 같다.

• [3,4,2,1,5]

입출력 예 #2
모든 사용자가 마지막 스테이지에 있으므로 4번 스테이지의 실패율은 1이며 나머지 스테이지의 실패율은 0이다.

• [4,1,2,3]

힌트

• 각각 스테이지의 실패율을 구하여 저장합니다.
• 실패율을 내림차순으로 중복을 제거합니다.
• 내림차순으로 정렬된 실패율을 순회하며 해당 실패율을 가지고 있는 스테이지를 저장합니다.

  풀이

출처

프로그래머스 - lv1 - 실패율

문제설명

수포자는 수학을 포기한 사람의 준말입니다. 수포자 삼인방은 모의고사에 수학 문제를 전부 찍으려 합니다. 수포자는 1번 문제부터 마지막 문제까지 다음과 같이 찍습니다.

1번 수포자가 찍는 방식: 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, ... 2번 수포자가 찍는 방식: 2, 1, 2, 3, 2, 4, 2, 5, 2, 1, 2, 3, 2, 4, 2, 5, ... 3번 수포자가 찍는 방식: 3, 3, 1, 1, 2, 2, 4, 4, 5, 5, 3, 3, 1, 1, 2, 2, 4, 4, 5, 5, ...

1번 문제부터 마지막 문제까지의 정답이 순서대로 들은 배열 answers가 주어졌을 때, 가장 많은 문제를 맞힌 사람이 누구인지 배열에 담아 return 하도록 solution 함수를 작성해주세요.

제한사항

• 시험은 최대 10,000 문제로 구성되어있습니다.
• 문제의 정답은 1, 2, 3, 4, 5중 하나입니다.
• 가장 높은 점수를 받은 사람이 여럿일 경우, return하는 값을 오름차순 정렬해주세요.

입출력 예

입출력 예 설명

입출력 예 #1

• 수포자 1은 모든 문제를 맞혔습니다.
• 수포자 2는 모든 문제를 틀렸습니다.
• 수포자 3은 모든 문제를 틀렸습니다.

따라서 가장 문제를 많이 맞힌 사람은 수포자 1입니다.

입출력 예 #2

• 모든 사람이 2문제씩을 맞췄습니다.

힌트

• 1번수포자의 답: {1,2,3,4,5}의 반복
• 2번수포자의 답: {2,1,2,3,2,4,2,5}의 반복
• 3번수포자의 답: {3,3,1,1,2,2,4,4,5,5}의 반복
• 각 학생별로 문제를 반복시켜 각각의 맞은 갯수를 구한 후 많이 맞은 순으로 정렬합니다.

풀이

    public int[] solution(int[] answers) {
        List<Integer> answerList = new ArrayList<>();
        int[] studentOneAnswers = {1,2,3,4,5};
        int[] studentTwoAnswers = {2,1,2,3,2,4,2,5};
        int[] studentThreeAnswers = {3,3,1,1,2,2,4,4,5,5};

        int scoreOfOne = countStudentScore(answers, studentOneAnswers);
        int scoreOfTwo = countStudentScore(answers, studentTwoAnswers);
        int scoreOfThree = countStudentScore(answers, studentThreeAnswers);

        int max = Math.max(scoreOfOne, Math.max(scoreOfTwo, scoreOfThree));
        if(max == 0) return new int[]{};

        if(max == scoreOfOne) answerList.add(1);
        if(max == scoreOfTwo) answerList.add(2);
        if(max == scoreOfThree) answerList.add(3);

        return answerList.stream().mapToInt(n->n).toArray();
    }

    int countStudentScore(int[] answers, int[] studentAnswers) {
        int count = 0;

        for(int i=0; i < answers.length; i++) {
            if(studentAnswers[i % studentAnswers.length] == answers[i])
                count += 1;
        }
        return count;
    }

출처

프로그래머스 - lv1 - 모의고사

문제설명

당신은 폰켓몬을 잡기 위한 오랜 여행 끝에, 홍 박사님의 연구실에 도착했습니다. 홍 박사님은 당신에게 자신의 연구실에 있는 총 N 마리의 폰켓몬 중에서 N/2마리를 가져가도 좋다고 했습니다. 홍 박사님 연구실의 폰켓몬은 종류에 따라 번호를 붙여 구분합니다. 따라서 같은 종류의 폰켓몬은 같은 번호를 가지고 있습니다. 예를 들어 연구실에 총 4마리의 폰켓몬이 있고, 각 폰켓몬의 종류 번호가 [3번, 1번, 2번, 3번]이라면 이는 3번 폰켓몬 두 마리, 1번 폰켓몬 한 마리, 2번 폰켓몬 한 마리가 있음을 나타냅니다. 이때, 4마리의 폰켓몬 중 2마리를 고르는 방법은 다음과 같이 6가지가 있습니다.

1. 첫 번째(3번), 두 번째(1번) 폰켓몬을 선택
2. 첫 번째(3번), 세 번째(2번) 폰켓몬을 선택
3. 첫 번째(3번), 네 번째(3번) 폰켓몬을 선택
4. 두 번째(1번), 세 번째(2번) 폰켓몬을 선택
5. 두 번째(1번), 네 번째(3번) 폰켓몬을 선택
6. 세 번째(2번), 네 번째(3번) 폰켓몬을 선택

이때, 첫 번째(3번) 폰켓몬과 네 번째(3번) 폰켓몬을 선택하는 방법은 한 종류(3번 폰켓몬 두 마리)의 폰켓몬만 가질 수 있지만, 다른 방법들은 모두 두 종류의 폰켓몬을 가질 수 있습니다. 따라서 위 예시에서 가질 수 있는 폰켓몬 종류 수의 최댓값은 2가 됩니다. 당신은 최대한 다양한 종류의 폰켓몬을 가지길 원하기 때문에, 최대한 많은 종류의 폰켓몬을 포함해서 N/2마리를 선택하려 합니다. N마리 폰켓몬의 종류 번호가 담긴 배열 nums가 매개변수로 주어질 때, N/2마리의 폰켓몬을 선택하는 방법 중, 가장 많은 종류의 폰켓몬을 선택하는 방법을 찾아, 그때의 폰켓몬 종류 번호의 개수를 return 하도록 solution 함수를 완성해주세요.

제한사항

• nums는 폰켓몬의 종류 번호가 담긴 1차원 배열입니다.
• nums의 길이(N)는 1 이상 10,000 이하의 자연수이며, 항상 짝수로 주어집니다.
• 폰켓몬의 종류 번호는 1 이상 200,000 이하의 자연수로 나타냅니다.
• 가장 많은 종류의 폰켓몬을 선택하는 방법이 여러 가지인 경우에도, 선택할 수 있는 폰켓몬 종류 개수의 최댓값 하나만 return 하면 됩니다.

입출력 예

입출력 예 설명

입출력 예 #1
문제의 예시와 같습니다.

입출력 예 #2
6마리의 폰켓몬이 있으므로, 3마리의 폰켓몬을 골라야 합니다.
가장 많은 종류의 폰켓몬을 고르기 위해서는 3번 폰켓몬 한 마리, 2번 폰켓몬 한 마리, 4번 폰켓몬 한 마리를 고르면 되며, 따라서 3을 return 합니다.

입출력 예 #3
6마리의 폰켓몬이 있으므로, 3마리의 폰켓몬을 골라야 합니다.
가장 많은 종류의 폰켓몬을 고르기 위해서는 3번 폰켓몬 한 마리와 2번 폰켓몬 두 마리를 고르거나, 혹은 3번 폰켓몬 두 마리와 2번 폰켓몬 한 마리를 고르면 됩니다. 따라서 최대 고를 수 있는 폰켓몬 종류의 수는 2입니다.

힌트

• 주어진 배열에서 서로 다른 폰켓몬을 많이 가져가야하므로 배열내의 중복된 값(중복된 포켓몬 종류)은 의미없습니다.
• 중복을 제거하기 위하여 Stream의 .distinct()를 사용하였습니다.
• 위에서 중복을 제거한 배열의 원소 갯수는 폰켓몬의 종류의 갯수와 같습니다.
• 리스트를 생성하여 중복되지 않고, 가져갈 수 있는 최대 갯수를 넘지 않을때까지 추가합니다.

풀이

public int solution(int[] nums) {
        int numOfChoices = nums.length / 2;
        return getAnswer(numOfChoices, nums);
    }

    int getAnswer(int numOfChoices, int[] nums) {
        long max = Arrays.stream(nums).distinct().count();
        List<Integer> numberList = new LinkedList<>();

        for(int num : nums) {
            if(numberList.contains(num)) continue;

            numberList.add(num);
            if(numberList.size() == max) break;
            if(numberList.size() == numOfChoices) break;
        }

        if(numberList.size() == max) return (int)max;
        else return numberList.size();
    }

출처

프로그래머스 - lv1 - 폰켓몬

문제설명

점심시간에 도둑이 들어, 일부 학생이 체육복을 도난당했습니다. 다행히 여벌 체육복이 있는 학생이 이들에게 체육복을 빌려주려 합니다. 학생들의 번호는 체격 순으로 매겨져 있어, 바로 앞번호의 학생이나 바로 뒷번호의 학생에게만 체육복을 빌려줄 수 있습니다. 예를 들어, 4번 학생은 3번 학생이나 5번 학생에게만 체육복을 빌려줄 수 있습니다. 체육복이 없으면 수업을 들을 수 없기 때문에 체육복을 적절히 빌려 최대한 많은 학생이 체육수업을 들어야 합니다.

전체 학생의 수 n, 체육복을 도난당한 학생들의 번호가 담긴 배열 lost, 여벌의 체육복을 가져온 학생들의 번호가 담긴 배열 reserve가 매개변수로 주어질 때, 체육수업을 들을 수 있는 학생의 최댓값을 return 하도록 solution 함수를 작성해주세요.

제한사항

• 전체 학생의 수는 2명 이상 30명 이하입니다.
• 체육복을 도난당한 학생의 수는 1명 이상 n명 이하이고 중복되는 번호는 없습니다.
• 여벌의 체육복을 가져온 학생의 수는 1명 이상 n명 이하이고 중복되는 번호는 없습니다.
• 여벌 체육복이 있는 학생만 다른 학생에게 체육복을 빌려줄 수 있습니다.
• 여벌 체육복을 가져온 학생이 체육복을 도난당했을 수 있습니다. 이때 이 학생은 체육복을 하나만 도난당했다고 가정하며, 남은 체육복이 하나이기에 다른 학생에게는 체육복을 빌려줄 수 없습니다.

입출력 예

입출력 예 설명

입출력 예 #1
1번 학생이 2번 학생에게 체육복을 빌려주고, 3번 학생이나 5번 학생이 4번 학생에게 체육복을 빌려주면 학생 5명이 체육수업을 들을 수 있습니다.

입출력 예 #2
3번 학생이 2번 학생이나 4번 학생에게 체육복을 빌려주면 학생 4명이 체육수업을 들을 수 있습니다.

힌트

• Hashmap을 사용하여 해결하였습니다.
• 체육복을 잃어버린 학생의 배열 lost와 여별의 체육복을 가지고 있는 학생의 배열 reserve를 정렬합니다.
• HashMap에 학생의 번호를 key로 체육복의 갯수 기본 1개씩을 value로 넣어줍니다.
• reserve에 해당 학생의 번호가 존재할 경우 HashMap에 2개를 value로 넣어줍니다.
• lost 배열을 순회하며, 해당 번호의 학생을 찾아 가진 갯수가 1개 이상일 시에는 가진 갯수의 1을 제외합니다.
• lost 배열을 순회하며, 해당 번호의 학생을 찾아 가진 갯수가 1개일 경우에는 해당 key를 제거합니다.
• lost 배열을 순회하며, 이전 번호가 있고 이전 번호의 학생이 체육복의 여분을 가지고 있을 경우, 그 학생의 체육복의 소지수를 1 줄이고, 잃어버린 학생의 번호를 key로 하여 1개의 value를 입력해줍니다. 그 후 반복문의 다음 순회로 넘어갑니다.
• 위의 순회에서 값을 구하지 못했을 경우, 다음 번호가 있고 다음 번호의 학생이 체육복의 여분을 가지고 있을 경우, 그 학생의 체육복의 소지수를 1 줄이고, 잃어버린 학생의 번호를 key로 하여 1개의 value를 입력해줍니다.

풀이

    public int solution(int n, int[] lost, int[] reserve) {
        Arrays.sort(lost);
        Arrays.sort(reserve);

        Map<Integer, Integer> uniformMap = getUniformMap(n, lost, reserve);
        return uniformMap.keySet().size();
    }

    Map<Integer, Integer> getUniformMap(int n, int[] lost, int[] reserve) {
        Map<Integer, Integer> uniformMap = new HashMap<>();

        for(int i = 0; i < n; i++) {
            uniformMap.put(i + 1, 1);
        }

        for(int num : reserve) {
            uniformMap.put(num, 2);
        }
        stolen(uniformMap, lost);
        borrow(uniformMap, lost);

        return uniformMap;
    }

    private void borrow(Map<Integer, Integer> uniformMap, int[] lost) {
        for(int number : lost) {
            if( number > 1) {
                int prevNumber = number - 1;
                int uniformPrev = uniformMap.getOrDefault(prevNumber, 0);
                if(uniformPrev == 2) {
                    borrowFrom(number, prevNumber, uniformMap);
                    continue;
                }
            }
            if( number <= uniformMap.size()) {
                int nextNumber = number + 1;
                int uniformNext = uniformMap.getOrDefault(nextNumber, 0);
                if(uniformNext == 2) {
                    borrowFrom(number, nextNumber, uniformMap);
                    continue;
                }
            }
        }
    }

    private void borrowFrom(int lost, int  target, Map<Integer, Integer> uniformMap) {
        uniformMap.put(lost, 1);
        uniformMap.put(target, 1);
    }

    private void stolen(Map<Integer, Integer> uniformMap, int[] lost) {
        for(int number : lost) {
            int uniform = uniformMap.get(number);

            if(uniform == 1) uniformMap.remove(number);
            else uniformMap.put(number, 1);
        }
    }

출처

프로그래머스 - lv1 - 체육복

문제설명

주어진 숫자 중 3개의 수를 더했을 때 소수가 되는 경우의 개수를 구하려고 합니다. 숫자들이 들어있는 배열 nums가 매개변수로 주어질 때, nums에 있는 숫자들 중 서로 다른 3개를 골라 더했을 때 소수가 되는 경우의 개수를 return 하도록 solution 함수를 완성해주세요.

제한사항

• nums에 들어있는 숫자의 개수는 3개 이상 50개 이하입니다.
• nums의 각 원소는 1 이상 1,000 이하의 자연수이며, 중복된 숫자가 들어있지 않습니다.

  입출력 예

  nums	result
  [1,2,3,4]	1
  [1,2,7,6,4]	4

  입출력 예 설명

• 입출력 예 #1*
  [1,2,4]를 이용해서 7을 만들 수 있습니다.

• 입출력 예 #2*
  [1,2,4]를 이용해서 7을 만들 수 있습니다.
  [1,4,6]을 이용해서 11을 만들 수 있습니다.
  [2,4,7]을 이용해서 13을 만들 수 있습니다.
  [4,6,7]을 이용해서 17을 만들 수 있습니다.

힌트

• 반복문을 2번 만들어 수를 더합니다.
• i = 0부터 j = i + 1부터
• 소수판별은 아직까지 밝혀진 공식이 없으므로, 에라토스테네스의 체를 활용합니다.

풀이

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

        for(int i = 0; i < nums.length; i++) {
            if(i + 2 > nums.length) continue;
            int firstNumber = nums[i];
            for(int p = i + 1; p < nums.length; p++) {
                int secondNumber = nums[p];
                for(int j = p + 1; j < nums.length; j++) {
                    int thirdNumber = nums[j];
                    int sum = firstNumber + secondNumber + thirdNumber;

                    if(isPrime(sum)) answer++;
                }
            }
        }

        return answer;
    }

    boolean isPrime(int num) {
        if(num == 1) return false;
        else if(num == 2) return true;
        else if(num % 2 == 0) return false;

        int count = 0;
        for(int i = 3; i <= Math.sqrt(num); i+=2) {
            if(num % i == 0) count++;
        }

        return count == 0;
    }

출처

프로그래머스 - lv1 - 소수만들기

힌트

• absolutes와 signs 배열의 같은 번지의 데이터를 꺼냅니다.
• signs의 데이터가 false이면 -1을 곱하여 음수를 만들어줍니다.

풀이

class Solution {
    public int solution(int[] absolutes, boolean[] signs) {
        int answer = 0;
        int[] integerArr = new int[absolutes.length];

        for (int i = 0; i < absolutes.length; i++) {
            int number = 0;
            if(signs[i] == true) number = absolutes[i] * 1;
            else number = absolutes[i] * -1;

            integerArr[i] = number;
        }

        for(int number : integerArr) {
            answer += number;
        }
        return answer;
    }
}

출처

프로그래머스 - lv1 - 음양더하기

게임개발자인 "죠르디"는 크레인 인형뽑기 기계를 모바일 게임으로 만들려고 합니다. "죠르디"는 게임의 재미를 높이기 위해 화면 구성과 규칙을 다음과 같이 게임 로직에 반영하려고 합니다. 게임 화면은 "1 x 1" 크기의 칸들로 이루어진 "N x N" 크기의 정사각 격자이며 위쪽에는 크레인이 있고 오른쪽에는 바구니가 있습니다. (위 그림은 "5 x 5" 크기의 예시입니다). 각 격자 칸에는 다양한 인형이 들어 있으며 인형이 없는 칸은 빈칸입니다. 모든 인형은 "1 x 1" 크기의 격자 한 칸을 차지하며 격자의 가장 아래 칸부터 차곡차곡 쌓여 있습니다. 게임 사용자는 크레인을 좌우로 움직여서 멈춘 위치에서 가장 위에 있는 인형을 집어 올릴 수 있습니다. 집어 올린 인형은 바구니에 쌓이게 되는 데, 이때 바구니의 가장 아래 칸부터 인형이 순서대로 쌓이게 됩니다. 다음 그림은 [1번, 5번, 3번] 위치에서 순서대로 인형을 집어 올려 바구니에 담은 모습입니다. 만약 같은 모양의 인형 두 개가 바구니에 연속해서 쌓이게 되면 두 인형은 터뜨려지면서 바구니에서 사라지게 됩니다. 위 상태에서 이어서 [5번] 위치에서 인형을 집어 바구니에 쌓으면 같은 모양 인형 두 개가 없어집니다.

힌트

• 게임의 관점에서 바라보면 원래는 뽑은 인형이 담겨있는 stack에 인형이 연속되는 순간 처리를 해야하지만 연속되는 순간 처리하나, 일괄적으로 처리하나 결과는 같습니다.
• 인형이 쌓여있는 게임판의 세로 한 줄을 column이라고 할때 moves에서 가져온 위치의 0이 아닌 숫자를 가져와 list에 담습니다.
• 해당 위치의 숫자는 배열에서 0으로 처리해줍니다.
• list의 연속된 내용을 제거합니다.

풀이

import java.util.ArrayList;
import java.util.List;

class Solution {
    private int answer = 0;

    public int solution(int[][] board, int[] moves) {

        List<Integer> stack = getDolls(board, moves);
        removeDuplicates(stack);
        return answer;
    }

    boolean isDuplicated(List<Integer> stack) {
        boolean result = false;
        for(int i = 0; i < stack.size(); i++) {
            if(i < 1) continue;

            if(stack.get(i) == stack.get(i - 1)) {
                result = true;
            }
        }

        return result;
    }

    void removeDuplicates(List<Integer> stack) {
        for(int i = 0; i < stack.size(); i++) {
            if(i < 1) continue;

            if(stack.get(i) == stack.get(i - 1)) {
                answer += 2;
                stack.remove(i);
                stack.remove(i - 1);
            }
        }

        if(isDuplicated(stack)) removeDuplicates(stack);
        else return;
    }

    List<Integer> getDolls(int[][] board, int[] moves) {
        List<Integer> stackList = new ArrayList<Integer>();

        for(int line : moves) {
            int column = line - 1;

            for(int[] boardRow : board) {
                if(boardRow[column] != 0) {
                    stackList.add(boardRow[column]);
                    boardRow[column] = 0;
                    break;
                }
            }
        }
        return stackList;
    }
}

출처

프로그래머스 - lv1 - 크레인 인형뽑기 게임

힌트

• 왼손으로 눌러야만 하는 숫자는 1, 4, 7 최초위치는 *입니다.
• *을 만약 10로 치환한다면 왼손으로 눌러야하는 숫자는 모두 n % 3 == 1을 만족합니다.
• 오른손으로 눌러야만 하는 숫자는 3, 6, 9 최초위치는 #입니다.
• #을 만약 12로 치환한다면 오른손으로 눌러야하는 숫자는 모두 n % 3 == 0을 만족합니다.
• 같은 맥락으로 가운데 숫자들은 0을 11로 치환할 경우 모두 n % 3 == 2를 만족합니다.
• 각각의 손가락이 마지막으로 위치한 곳을 저장하고 가운데 숫자를 눌러야 할 경우 거리를 계산하여 올바른 손가락을 구합니다.
• 구하는 공식
  • x좌표 = (n-1) / 3
  • y좌표 = (n-1) % 3
  • 이동거리 = 절대값(현x좌표 - 목표값x좌표) + 절대값(현y좌표 - 목표값y좌표)

풀이

class Solution {
    private Hand leftHand = new Hand(10, "left"); // 왼손: *을 10으로 치환
    private Hand rightHand = new Hand(12, "right"); // 오른손 #을 12로 치환

    public String solution(int[] numbers, String hand) {
        StringBuilder stb = new StringBuilder();

        for(int number : numbers) { // 눌러야 할 숫자를 가져옴
            if(number % 3 == 1) { // n % 3 == 1 경우 왼손
                stb.append("L");
                leftHand.setPosition(number);
            }
            else if(number != 0 && (number % 3 == 0)) { // 0이 아니고 n % 3 == 3 경우 오른손
                stb.append("R");
                rightHand.setPosition(number);
            }
            else { // 가운데 숫자들
                String properHand = findProperHand(number, hand);
                stb.append(properHand);
            }
        }

        return stb.toString();
    }

    String findProperHand(int number, String hand) {
        int distanceFromLeft = calculateDistance(leftHand, number); // 왼손거리 계산
        int distanceFromRight = calculateDistance(rightHand, number); // 오른손거리 계산

        if(distanceFromLeft == distanceFromRight) { // 두개가 같으면
            if(hand.equals(rightHand.getRightOrLeftStr())) { // 주 사용 손이 오른손이면
                rightHand.setPosition(number); // 오른손 위치 변경
                return "R"; // 해당 숫자는 오른손으로 눌러야함
            }
            else { // 주 사용손이 왼손이면
                leftHand.setPosition(number); // 왼손 위치 변경
                return "L"; // 해당 숫자는 왼손으로 눌러야함
            }
        } else if (distanceFromLeft < distanceFromRight) { // 왼손이 가까우면
            leftHand.setPosition(number); // 왼손 위치 변경
            return "L"; // 해당 숫자는 왼손으로 눌러야함
        }
        else { // 오른손이 가까우면
            rightHand.setPosition(number); // 오른손 위치 변경
            return "R"; // 해당 숫자는 오른손으로 눌러야함
        }
    }

    int calculateDistance(Hand hand, int number) {
        int position = hand.getPosition();

        if (position  == 0) position = 11; // 0은 11로 치환한다
        if (number == 0 ) number = 11;

        int positionX = (position - 1) / 3;
        int positionY = (position - 1) % 3;

        int numX = (number - 1) / 3;
        int numY = (number - 1) % 3;

        int distance = Math.abs(positionX - numX) + Math.abs(positionY - numY);

        return distance;
    }

}
class Hand { // 자바의 객체지향성 활용하여 class 생성
    private int position;
    private String rightOrLeftStr;

    Hand(int position, String rightOrLeftStr) {
        this.position = position;
        this.rightOrLeftStr = rightOrLeftStr;
    }

    public void setPosition(int position) {
        this.position = position;
    }

    public int getPosition() {
        return position;
    }

    public String getRightOrLeftStr() {
        return rightOrLeftStr;
    }
}

출처

프로그래머스 - lv1 - 키패드누르기

힌트

• 이 문제에서 원하는 값은 각각의 배열의 같은 위치에 있는 값을 합한 후 모든 값을 더한 것입니다.
• 각각의 배열을 순회하며 곱한 후 더하면 됩니다.

풀이

class Solution {
    public int solution(int[] a, int[] b) {
         int size = a.length; // a와 b의 크기는 같으므로 둘 중 아무 배열의 크기를 기준으로 잡음
        int sum = 0;

        for(int i = 0; i < size; i++) { // 힌트의 설명과 같음
            int product = a[i] * b[i];
            sum = sum + product;
        }

        return sum;
    }
}

출처 프로그래머스 - lv1 - 내적

힌트

• String을 앞에서 부터 한글자씩 가져와서 숫자면 정답영역에 저장, 문자면  임시영역에 저장합니다.
• 임시영역에 저장된 문자열이 "zero" || "one" || ... 와 같다면 해당하는 숫자로 변환하여 정답영역에 저장합니다.
• 모든 과정이 끝나면 정답영역을 리턴합니다.

풀이

class Solution {
    private final String ZERO = "zero";
    private final String ONE = "one";
    private final String TWO = "two";
    private final String THREE = "three";
    private final String FOUR = "four";
    private final String FIVE = "five";
    private final String SIX = "six";
    private final String SEVEN = "seven";
    private final String EIGHT = "eight";
    private final String NINE = "nine";

    public int solution(String s) {
        String answerAsString = getAnswer(s); // 문자가 숫자로 변환된 String을 획득한다.
        return Integer.parseInt(answerAsString); // Integer.parseInt를 통해 문자->숫자 변환
    }

    String getAnswer(String str) {
        StringBuilder answerStrBuilder = new StringBuilder();
        StringBuilder tempStrBuilder = new StringBuilder();

        for(int i = 0; i < str.length(); i++) {
            char c = str.charAt(i); // 특정 번지에 있는 문자를 획득
            if(isNumber(c)) { // 문자가 숫자라면
                answerStrBuilder.append(c); // answer StringBuilder에 추가한다.
            } else { // 문자가 아니라면
                tempStrBuilder.append(c); // 임시 StringBuilder에 추가하고
                if(isNumber(tempStrBuilder.toString())) { // 임시 StringBuilder가 숫자가 되었는지 판단
                    int numFromStr = convertToNumFromString(tempStrBuilder.toString()); // StringBuilder의 내용을 숫자로 변환
                    answerStrBuilder.append(numFromStr);  // answer StringBuilder에 추가한다.
                    tempStrBuilder = new StringBuilder(); // 임시 StringBuilder 초기화
                }
            }
        }
        return answerStrBuilder.toString();
    }

    boolean isNumber(char c) { // 인수로 전달받은 char가 숫자인지 확인
        if(c >= '0' && c <= '9') return true; // ASCII코드 기준으로 '0'은 48 '9'는 57임 그 사이에 존재하면 숫자
        return false;
    }

    boolean isNumber(String s) { // 인수로 전달받은 String이 숫자인지 확인
        if(s.equals(ZERO) || s.equals(ONE) || s.equals(TWO) || s.equals(THREE)
                || s.equals(FOUR) || s.equals(FIVE)|| s.equals(SIX)
                || s.equals(SEVEN) || s.equals(EIGHT) || s.equals(NINE)) return true;
        else return false;
    }

    int convertToNumFromString(String s) { // 인수로 전달받은 문자를 숫자로 변환한다.
        if(s.equals(ZERO)) return 0;
        else if(s.equals(ONE)) return 1;
        else if(s.equals(TWO)) return 2;
        else if(s.equals(THREE)) return 3;
        else if(s.equals(FOUR)) return 4;
        else if(s.equals(FIVE)) return 5;
        else if(s.equals(SIX)) return 6;
        else if(s.equals(SEVEN)) return 7;
        else if(s.equals(EIGHT)) return 8;
        else if(s.equals(NINE)) return 9;

        return -1;
    }
}

출처

https://programmers.co.kr/learn/courses/30/lessons/81301