문제

시간 제한 메모리 제한 제출 정답 맞힌 사람 정답 비율

1 초 256 MB 37117 9871 6578 24.587%

문제

상근이는 빈 공간과 벽으로 이루어진 건물에 갇혀있다. 건물의 일부에는 불이 났고, 상근이는 출구를 향해 뛰고 있다.

매 초마다, 불은 동서남북 방향으로 인접한 빈 공간으로 퍼져나간다. 벽에는 불이 붙지 않는다. 상근이는 동서남북 인접한 칸으로 이동할 수 있으며, 1초가 걸린다. 상근이는 벽을 통과할 수 없고, 불이 옮겨진 칸 또는 이제 불이 붙으려는 칸으로 이동할 수 없다. 상근이가 있는 칸에 불이 옮겨옴과 동시에 다른 칸으로 이동할 수 있다.

빌딩의 지도가 주어졌을 때, 얼마나 빨리 빌딩을 탈출할 수 있는지 구하는 프로그램을 작성하시오.

입력

첫째 줄에 테스트 케이스의 개수가 주어진다. 테스트 케이스는 최대 100개이다.

각 테스트 케이스의 첫째 줄에는 빌딩 지도의 너비와 높이 w와 h가 주어진다. (1 ≤ w,h ≤ 1000)

다음 h개 줄에는 w개의 문자, 빌딩의 지도가 주어진다.

  • '.': 빈 공간
  • '#': 벽
  • '@': 상근이의 시작 위치
  • '*': 불

각 지도에 @의 개수는 하나이다.

출력

각 테스트 케이스마다 빌딩을 탈출하는데 가장 빠른 시간을 출력한다. 빌딩을 탈출할 수 없는 경우에는 "IMPOSSIBLE"을 출력한다.

풀이

BFS로 풀 수 있는 문제였다.

  1. 배열을 벽, 불, 상근이, 빈 공간 으로 나눠서 값을 업데이트 해준다.
  2. 움직일 수 있는 사람이 있는지 확인
  3. 현재 시점에 불들을 4 방향으로 불을 퍼뜨린다 (시간이 없을 경우 한번에 불 다붙이고 끝나버림)
  4. 현재 시점에 사람을 4 방향으로 이동시킨다.
  5. 만약 사람이 배열의 끝 부분에 도착했다면 가장 빨리 도착한 경우 업데이트 해준다.

푸는데 중요했던 부분은 두가지가 있었다.

불이 2개가 붙어있다면, 주기마다 2개의 불을 다 이동시켜야 하는 것

빌딩을 탈출하는데에 가장 빠른 시간을 출력하는 것

 

package com.company.baekjoon;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.LinkedList;
import java.util.Queue;

public class B5427 {
    static final int WALL = -2;
    static final int FIRE = -1;
    static final int EMPTY_SPACE = 0;
    static final int PERSON = 1;

    static int[] dx = new int[] {-1,1,0,0};
    static int[] dy = new int[] {0,0,-1,1};
    static int[][] graph;
    static Queue<int[]> fires = new LinkedList<>();
    static Queue<int[]> person = new LinkedList<>();
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringBuilder sb = new StringBuilder();
        int T = Integer.parseInt(br.readLine());

        for (int i = 0; i < T; i++) {
            String[] size = br.readLine().split(" ");
            int w = Integer.parseInt(size[0]);
            int h = Integer.parseInt(size[1]);
            graph = new int[h][w];
            fires.clear();
            person.clear();
            int answer = Integer.MAX_VALUE;
            int time = 0;
            for (int j = 0; j < h; j++) {
                char[] s = br.readLine().toCharArray();
                for (int k = 0; k < s.length; k++) {
                    if (s[k] == '#') {
                        graph[j][k] = WALL;
                    } else if (s[k] == '.') {
                        graph[j][k] = EMPTY_SPACE;
                    } else if (s[k] == '*') {
                        graph[j][k] = FIRE;
                        fires.add(new int[] {j,k,0});
                    } else {
                        graph[j][k] = PERSON;
                        person.add(new int[]{j,k,0});
                    }
                }
            }
            // 불 먼저 움직이고 사람 움직이기
            while (!person.isEmpty()) {
                while (fires.peek() != null && fires.peek()[2] == time ) {
                    int[] fire = fires.poll();
                    for (int j = 0; j < dx.length; j++) {
                        int cy = fire[0] + dy[j];
                        int cx = fire[1] + dx[j];

                        if (cx < 0 || cy < 0 || cx >= w || cy >= h) continue;
                        if (graph[cy][cx] == FIRE) continue;
                        if (graph[cy][cx] != WALL) {
                            graph[cy][cx] = FIRE;
                            fires.add(new int[]{cy, cx, fire[2] + 1});
                        }
                    }
                }

                while (person.peek() != null && person.peek()[2] == time) {
                    int[] p = person.poll();
                    for (int j = 0; j < dx.length; j++) {
                        int cy = p[0] + dy[j];
                        int cx = p[1] + dx[j];

                        if (cx < 0 || cy < 0 || cx >= w || cy >= h) {
                            answer = Math.min(answer,p[2]);
                            break;
                        }
                        if (graph[cy][cx] == EMPTY_SPACE) {
                            graph[cy][cx] = PERSON;
                            person.add(new int[]{cy, cx, p[2] + 1});
                        }
                    }
                }
                time++;
            }
            if (answer == Integer.MAX_VALUE)
                sb.append("IMPOSSIBLE").append("\n");
            else
                sb.append(answer+1).append("\n");
        }
        System.out.println(sb);
    }
}

문제 설명

개발자가 사용하는 언어와 언어 선호도를 입력하면 그에 맞는 직업군을 추천해주는 알고리즘을 개발하려고 합니다.

아래 표는 5개 직업군 별로 많이 사용하는 5개 언어에 직업군 언어 점수를 부여한 표입니다.

점수SI CONTENTS HARDWARE PORTAL GAME

5 JAVA JAVASCRIPT C JAVA C++
4 JAVASCRIPT JAVA C++ JAVASCRIPT C#
3 SQL PYTHON PYTHON PYTHON JAVASCRIPT
2 PYTHON SQL JAVA KOTLIN C
1 C# C++ JAVASCRIPT PHP JAVA

예를 들면, SQL의 SI 직업군 언어 점수는 3점이지만 CONTENTS 직업군 언어 점수는 2점입니다. SQL의 HARDWARE, PORTAL, GAME 직업군 언어 점수는 0점입니다.

직업군 언어 점수를 정리한 문자열 배열 table, 개발자가 사용하는 언어를 담은 문자열 배열 languages, 언어 선호도를 담은 정수 배열 preference가 매개변수로 주어집니다. 개발자가 사용하는 언어의 언어 선호도 x 직업군 언어 점수의 총합이 가장 높은 직업군을 return 하도록 solution 함수를 완성해주세요. 총합이 같은 직업군이 여러 개일 경우, 이름이 사전 순으로 가장 빠른 직업군을 return 해주세요.


제한사항

  • table의 길이 = 5
    • table의 원소는 "직업군 5점언어 4점언어 3점언어 2점언어 1점언어"형식의 문자열입니다. 직업군, 5점언어, 4언어, 3점언어, 2점언어, 1점언어는 하나의 공백으로 구분되어 있습니다.
    • table은 모든 테스트케이스에서 동일합니다.
  • 1 ≤ languages의 길이 ≤ 9
    • languages의 원소는 "JAVA", "JAVASCRIPT", "C", "C++" ,"C#" , "SQL", "PYTHON", "KOTLIN", "PHP" 중 한 개 이상으로 이루어져 있습니다.
    • languages의 원소는 중복되지 않습니다.
  • preference의 길이 = languages의 길이
    • 1 ≤ preference의 원소 ≤ 10
  • preference의 i번째 원소는 languages의 i번째 원소의 언어 선호도입니다.
  • return 할 문자열은 "SI", "CONTENTS", "HARDWARE", "PORTAL", "GAME" 중 하나입니다.

입출력 예

tablelanguagespreferenceresult

["SI JAVA JAVASCRIPT SQL PYTHON C#", "CONTENTS JAVASCRIPT JAVA PYTHON SQL C++", "HARDWARE C C++ PYTHON JAVA JAVASCRIPT", "PORTAL JAVA JAVASCRIPT PYTHON KOTLIN PHP", "GAME C++ C# JAVASCRIPT C JAVA"] ["PYTHON", "C++", "SQL"] [7, 5, 5] "HARDWARE"
["SI JAVA JAVASCRIPT SQL PYTHON C#", "CONTENTS JAVASCRIPT JAVA PYTHON SQL C++", "HARDWARE C C++ PYTHON JAVA JAVASCRIPT", "PORTAL JAVA JAVASCRIPT PYTHON KOTLIN PHP", "GAME C++ C# JAVASCRIPT C JAVA"] ["JAVA", "JAVASCRIPT"] [7, 5] "PORTAL"

입출력 예 설명

입출력 예 #1

각 직업군 별로 점수를 계산해보면 아래와 같습니다.

아래 사진은 개발자 언어 선호도 나타낸 표입니다.

아래 사진은 개발자가 선호하는 언어의 직업군 언어 점수를 나타낸 표입니다.

따라서 점수 총합이 41로 가장 높은 "HARDWARE"를 return 해야 합니다.

입출력 예 #2

각 직업군 별로 점수를 계산해보면 아래와 같습니다.

아래 사진은 개발자 언어 선호도 나타낸 표입니다.

아래 사진은 개발자가 선호하는 언어의 직업군 언어 점수를 나타낸 표입니다.


점수 총합이 55로 가장 높은 직업군은 "SI" 와 "PORTAL"입니다.
따라서 사전 순으로 먼저 오는 "PORTAL"을 return 해야 합니다.

 

나의 풀이

첫번째 파라미터로 오는 배열을 보면 첫번째 값에는 직업군, 그 이후에는 언어가 오게되므로 우선 하나의 문자열을 분리시켰다.

그 이후 점수 총합과 직업군을 저장하기위해 key, value로 값을 저장하는 hashMap을 사용하여 점수 총합과 직업을 저장했다.

만약 점수가 같은 직업이 있다면 정렬을 통해 사전순서가 빠른 직업군을 리턴하도록 했다.

 

코틀린 언어가 익숙하지 않아서 조금 헤매었는데 풀고나니 조타 ㅎㅅㅎ

+ 프로그래머스와 내 로컬환경의 컴파일옵션이 달라서 그런지 내 노트북에서는 잘 컴파일 되었는데 프로그래머스에서 실행하면

오류가 많이 떠서 수정하는데 시간이 좀 걸렸다. 

import kotlin.collections.HashMap

class Solution {
   fun solution(table: Array<String>, languages: Array<String>, preference: IntArray): String {

        var hashMap = HashMap<String, Int>()
        for (i in table.indices) { // 첫번째 배열 아이템 나누기
            var tableArr = table[i].split(" ")
            var sum = 0

            for (j in languages.indices) {
                var idx = tableArr.indexOf(languages[j])
                if (idx != -1) {
                    var size = tableArr.size - idx
                    sum += size * preference[j]
                }
            }
            hashMap.put(tableArr[0],sum)
        }
        var maxVal = hashMap.values.max()
        var answers = hashMap.filter { it.value == maxVal }
        return answers.keys.min()!!
    }
}

문제 설명

대학 교수인 당신은, 상호평가를 통하여 학생들이 제출한 과제물에 학점을 부여하려고 합니다. 아래는 0번부터 4번까지 번호가 매겨진 5명의 학생들이 자신과 다른 학생의 과제를 평가한 점수표입니다.

No. 0 1 2 3 4
0 100 90 98 88 65
1 50 45 99 85 77
2 47 88 95 80 67
3 61 57 100 80 65
4 24 90 94 75 65
평균 45.5 81.25 97.2 81.6 67.8
학점 F B A B D

위의 점수표에서, i행 j열의 값은 i번 학생이 평가한 j번 학생의 과제 점수입니다.

  • 0번 학생이 평가한 점수는 0번 행에담긴 [100, 90, 98, 88, 65]입니다.
    • 0번 학생은 자기 자신에게 100점, 1번 학생에게 90점, 2번 학생에게 98점, 3번 학생에게 88점, 4번 학생에게 65점을 부여했습니다.
  • 2번 학생이 평가한 점수는 2번 행에담긴 [47, 88, 95, 80, 67]입니다.
    • 2번 학생은 0번 학생에게 47점, 1번 학생에게 88점, 자기 자신에게 95점, 3번 학생에게 80점, 4번 학생에게 67점을 부여했습니다.

당신은 각 학생들이 받은 점수의 평균을 구하여, 기준에 따라 학점을 부여하려고 합니다.
만약, 학생들이 자기 자신을 평가한 점수가 유일한 최고점 또는 유일한 최저점이라면 그 점수는 제외하고 평균을 구합니다.

  • 0번 학생이 받은 점수는 0번 열에 담긴 [100, 50, 47, 61, 24]입니다. 자기 자신을 평가한 100점은 자신이 받은 점수 중에서 유일한 최고점이므로, 평균을 구할 때 제외합니다.
    • 0번 학생의 평균 점수는 (50+47+61+24) / 4 = 45.5입니다.
  • 4번 학생이 받은 점수는 4번 열에 담긴 [65, 77, 67, 65, 65]입니다. 자기 자신을 평가한 65점은 자신이 받은 점수 중에서 최저점이지만 같은 점수가 2개 더 있으므로, 유일한 최저점이 아닙니다. 따라서, 평균을 구할 때 제외하지 않습니다.
    • 4번 학생의 평균 점수는 (65+77+67+65+65) / 5 = 67.8입니다.

제외할 점수는 제외하고 평균을 구한 후, 아래 기준에 따라 학점을 부여합니다.

평균학점

90점 이상 A
80점 이상 90점 미만 B
70점 이상 80점 미만 C
50점 이상 70점 미만 D
50점 미만 F

학생들의 점수가 담긴 정수형 2차원 배열 scores가 매개변수로 주어집니다. 이때, 학생들의 학점을 구하여 하나의 문자열로 만들어서 return 하도록 solution 함수를 완성해주세요.


제한사항

  • 2 ≤ scores의 행의 길이(학생 수) ≤ 10
  • scores의 열의 길이 = scores의 행의 길이
    • 즉, scores는 행과 열의 길이가 같은 2차원 배열입니다.
  • 0 ≤ scores의 원소 ≤ 100
  • return 값 형식
    • 0번 학생의 학점부터 차례대로 이어 붙인 하나의 문자열을 return 합니다.

입출력 예

scoresresult

[[100,90,98,88,65],[50,45,99,85,77],[47,88,95,80,67],[61,57,100,80,65],[24,90,94,75,65]] "FBABD"
[[50,90],[50,87]] "DA"
[[70,49,90],[68,50,38],[73,31,100]] "CFD"

입출력 예 설명

입출력 예 #1

문제 예시와 같습니다.

입출력 예 #2

No. 0 1
0 50 90
1 50 87
평균 50 90
학점 D A
  • 1번 학생이 자기 자신을 평가한 87점은 [90, 87]에서 유일한 최저점이므로, 평균을 구할 때 제외합니다.

입출력 예 #3

No. 0 1 2
0 70 49 90
1 68 50 38
2 73 31 100
평균 70.33… 40 64
학점 C F D
  • 1번 학생이 자기 자신을 평가한 50점은 [49, 50, 31]에서 유일한 최고점이므로, 평균을 구할 때 제외합니다.
  • 2번 학생이 자기 자신을 평가한 100점은 [90, 38, 100]에서 유일한 최고점이므로, 평균을 구할 때 제외합니다.

 

나의 풀이

 

1. 2차원 배열의 행 열을 변경하기 -> 코틀린 배열에서 제공하는 max, min 함수 사용을 위해

2. 자기 자신에게 평가 한 경우 max 또는 min 값인지 확인 후에 유일한 최저점, 최고점 확인 

 

class Solution {
     fun solution(scores: Array<IntArray>): String {
        var answer: String = ""
        var rotatedScores : Array<IntArray> = Array(scores.size) { IntArray(scores.size)}

        for ( i in scores.indices)
            for (j in scores[i].indices)
                rotatedScores[i][j] = scores[j][i]

        for (i in scores.indices)
        {
            var sum = 0.0F
            var cnt = rotatedScores[i].size

            for ( j in rotatedScores[i].indices)
            {
                if (i == j)
                {
                    if (rotatedScores[i][j] == rotatedScores[j].min() ||
                            rotatedScores[i][j] == rotatedScores[j].max())
                    {
                        var countOfSameVal = rotatedScores[i].filter { it.equals(rotatedScores[i][j])}
                        if (countOfSameVal.size < 2) {
                            cnt -= 1
                            continue
                        }
                    }
                }
                sum += rotatedScores[i][j]
            }
            sum /= cnt

            when (sum) {
                in 90F..100F -> answer = answer.plus("A")
                in 80F..90F -> answer = answer.plus("B")
                in 70F..80F -> answer = answer.plus("C")
                in 50F..70F -> answer = answer.plus("D")
                in  0F..50F -> answer = answer.plus("F")
            }
        }
        return answer
    }
}

코드는 생각보다 길어졌지만 코틀린에 익숙해지는 것을 목표로 해본다 ㅠ

  • 부족한 금액 계산하기

문제 설명

새로 생긴 놀이기구는 인기가 매우 많아 줄이 끊이질 않습니다. 이 놀이기구의 원래 이용료는 price원 인데, 놀이기구를 N 번 째 이용한다면 원래 이용료의 N배를 받기로 하였습니다. 즉, 처음 이용료가 100이었다면 2번째에는 200, 3번째에는 300으로 요금이 인상됩니다.
놀이기구를 count번 타게 되면 현재 자신이 가지고 있는 금액에서 얼마가 모자라는지를 return 하도록 solution 함수를 완성하세요.
단, 금액이 부족하지 않으면 0을 return 하세요.

제한사항

  • 놀이기구의 이용료 price : 1 ≤ price ≤ 2,500, price는 자연수
  • 처음 가지고 있던 금액 money : 1 ≤ money ≤ 1,000,000,000, money는 자연수
  • 놀이기구의 이용 횟수 count : 1 ≤ count ≤ 2,500, count는 자연수

입출력 예

pricemoneycountresult

3 20 4 10

입출력 예 설명

입출력 예 #1
이용금액이 3인 놀이기구를 4번 타고 싶은 고객이 현재 가진 금액이 20이라면, 총 필요한 놀이기구의 이용 금액은 30 (= 3+6+9+12) 이 되어 10만큼 부족하므로 10을 return 합니다.

참고 사항

  • 미션 언어는 Java, JavaScript, Python3, C++ 만 해당 됩니다.
  • 같은 코드를 제출한 사람이 여럿이라면 코드를 가장 먼저 제출한 분께 상품을 드립니다.
  • 좋아요 수가 동일할 경우 코드를 가장 먼저 제출한 분께 상품을 드립니다.

 

나의 풀이

 

문제는 간단했는데, 네가지 테스트가 계속 실패하는 바람에.. 도무지 모르겠어서 구글링 했더니 money값을 받을 때 

int형이 아닌 long형으로 받아야 한다고 해서 매개변수 타입을 long으로 변경하니 성공했다.. 문제를 보면 알 수 있는 부분인데 좀더 문제를 정확히 읽고 풀어야겠다 ㅠ-ㅠ

    public long solution(int price, long money, int count) {
        for(int i = 1; i <= count; i++)  
            money = money - price * i;
        return  money > 0 ? 0 : money*-1;
    }

문제 설명

당신은 폰켓몬을 잡기 위한 오랜 여행 끝에, 홍 박사님의 연구실에 도착했습니다. 홍 박사님은 당신에게 자신의 연구실에 있는 총 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 하면 됩니다.

입출력 예

numsresult

[3,1,2,3] 2
[3,3,3,2,2,4] 3
[3,3,3,2,2,2] 2

입출력 예 설명

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

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

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

 

1. 최대한 많은 수의 포켓몬을 골라야 하기 때문에, 중복을 제거해준다.
2. 가질 수 있는 최댓값은 N/2 마리 이므로, 배열의 길이 / 2 가 최대값이다.
3. 중복을 제거한 포켓몬 수 보다 최댓값이 크면 중복을 제거한 포켓몬 수가 최대값이 된다.

 

풀이 코드

  public int solution(int[] nums) {
        int answer = nums.length / 2;

        Set<Integer> set = new HashSet<>();

        for (int i = 0; i < nums.length; i++) {
            set.add(nums[i]);
        }
        if(answer > set.size())
            answer = set.size();
        return answer;
    }

 

문제 설명

0과 1로 이루어진 어떤 문자열 x에 대한 이진 변환을 다음과 같이 정의합니다.

  1. x의 모든 0을 제거합니다.
  2. x의 길이를 c라고 하면, x를 "c를 2진법으로 표현한 문자열"로 바꿉니다.

예를 들어, x = "0111010"이라면, x에 이진 변환을 가하면 x = "0111010" -> "1111" -> "100" 이 됩니다.

0과 1로 이루어진 문자열 s가 매개변수로 주어집니다. s가 "1"이 될 때까지 계속해서 s에 이진 변환을 가했을 때, 이진 변환의 횟수와 변환 과정에서 제거된 모든 0의 개수를 각각 배열에 담아 return 하도록 solution 함수를 완성해주세요.


제한사항

  • s의 길이는 1 이상 150,000 이하입니다.
  • s에는 '1'이 최소 하나 이상 포함되어 있습니다.

입출력 예

sresult

"110010101001" [3,8]
"01110" [3,3]
"1111111" [4,1]

입출력 예 설명

입출력 예 #1

  • "110010101001"이 "1"이 될 때까지 이진 변환을 가하는 과정은 다음과 같습니다.

회차이진 변환 이전제거할 0의 개수0 제거 후 길이이진 변환 결과

1 "110010101001" 6 6 "110"
2 "110" 1 2 "10"
3 "10" 1 1 "1"
  • 3번의 이진 변환을 하는 동안 8개의 0을 제거했으므로, [3,8]을 return 해야 합니다.

입출력 예 #2

  • "01110"이 "1"이 될 때까지 이진 변환을 가하는 과정은 다음과 같습니다.

회차이진 변환 이전제거할 0의 개수0 제거 후 길이이진 변환 결과

1 "01110" 2 3 "11"
2 "11" 0 2 "10"
3 "10" 1 1 "1"
  • 3번의 이진 변환을 하는 동안 3개의 0을 제거했으므로, [3,3]을 return 해야 합니다.

입출력 예 #3

  • "1111111"이 "1"이 될 때까지 이진 변환을 가하는 과정은 다음과 같습니다.

회차이진 변환 이전제거할 0의 개수0 제거 후 길이이진 변환 결과

1 "1111111" 0 7 "111"
2 "111" 0 3 "11"
3 "11" 0 2 "10"
4 "10" 1 1 "1"
  • 4번의 이진 변환을 하는 동안 1개의 0을 제거했으므로, [4,1]을 return 해야 합니다.

나의 풀이

1. 문자열에서 0 제거하기

2. 이진 변환하기

3. 문자열의 길이가 1이 될때까지 반복하기

 

public int[] solution(String s) {
        int[] answer = new int[2];
        int zeroCount = 0;
        int binaryCount = 0;
        while (true) {

            if (s.length() == 1) { // 문자열의 길이가 1일 경우 break
                break;
            }

            for (int i = 0; i < s.length(); i++) {
                if (s.charAt(i) == '0') {
                    zeroCount++; // 문자가 0일경우 count 증가
                }
            }

            s = s.replaceAll("0", ""); // 0을 모두 공백으로 변경

            int binaryStr = s.length();

            s = Integer.toBinaryString(binaryStr); // 문자열의 길이를 이진수로 변환
            binaryCount++;
        }
        
        answer[0] = binaryCount;
        answer[1] = zeroCount;

        return answer;
    }

문제 설명

한자리 숫자가 적힌 종이 조각이 흩어져있습니다. 흩어진 종이 조각을 붙여 소수를 몇 개 만들 수 있는지 알아내려 합니다.

각 종이 조각에 적힌 숫자가 적힌 문자열 numbers가 주어졌을 때, 종이 조각으로 만들 수 있는 소수가 몇 개인지 return 하도록 solution 함수를 완성해주세요.

제한사항

  • numbers는 길이 1 이상 7 이하인 문자열입니다.
  • numbers는 0~9까지 숫자만으로 이루어져 있습니다.
  • "013"은 0, 1, 3 숫자가 적힌 종이 조각이 흩어져있다는 의미입니다.

입출력 예

numbersreturn

"17" 3
"011" 2

입출력 예 설명

예제 #1
[1, 7]으로는 소수 [7, 17, 71]를 만들 수 있습니다.

예제 #2
[0, 1, 1]으로는 소수 [11, 101]를 만들 수 있습니다.

  • 11과 011은 같은 숫자로 취급합니다.

출처

 

나의 풀이

1. 만들 수 있는 모든 경우의 수 구하기 - DFS 이용

2. 중복 제거하기 및 0으로 시작하는 숫자는 지우기.

3. 소수 찾기

 

public class FindDecimal {
	// 모든 경우의 수를 담을 어레이리스트
    ArrayList<String> arrayList = new ArrayList<>();
    
    public int solution(String numbers) {
    
        int answer = 0;
        // dfs에서 방문확인
        boolean[] booleans = new boolean[numbers.length()];
        // 소수를 찾을 리스트
        ArrayList<String> answerList = new ArrayList<>();
        
        char[] chars = numbers.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            String s = "";
            dfs(i, booleans, s, chars);
        }
		
        // 0으로 시작하는 문자열은 삭제시키고 0부터 다시 시작
        for (int i = 0; i < arrayList.size(); i++) {
            if(arrayList.get(i).startsWith("0")) {
                arrayList.remove(i);
                i = -1;
            }
            else if (!answerList.contains(arrayList.get(i))) {
                answerList.add(arrayList.get(i));
            }
        }
        
        // 인덱스에 해당하는 숫자가 소수일 경우 정답 수 증가
        for (int i = 0; i < answerList.size(); i++) {
            int n = Integer.parseInt(answerList.get(i));

            for(int j = 2; j <= n; j++) {
                if(j == n) {
                    answer++;
                }
                if ( n%j == 0) {
                    break;
                }

            }
        }
        
        // System.out.println(answer);
        
        return answer;
    }
    
    // dfs 함수
    public void dfs(int i, boolean[] booleans, String s, char[] chars) {
        booleans[i] = true;
        s = s + chars[i];
        arrayList.add(s);
        for (int j = 0; j < booleans.length; j++) {
            if (!booleans[j]) {
                dfs(j, booleans, s, chars);
            }

        }
        booleans[i] = false;
    }

    public static void main(String[] args) {
        FindDecimal findDecimal = new FindDecimal();
        findDecimal.solution("17");
        // System.out.println(findDecimal.arrayList);

    }

}

 

알고리즘이 약하다는 생각에 대학생 취준 이후로 다시 알고리즘 공부를 시작하려고 한다. 더 좋은 방법이 있으면 댓글 달아주세요 ㅎㅅㅎ  dfs 알고리즘 짜는데 시간이 좀 걸려서 한시간 정도 걸렸다.... 공부하자!!

 

문제 설명

게임개발자인 죠르디는 크레인 인형뽑기 기계를 모바일 게임으로 만들려고 합니다.
죠르디는 게임의 재미를 높이기 위해 화면 구성과 규칙을 다음과 같이 게임 로직에 반영하려고 합니다.

게임 화면은 1 x 1 크기의 칸들로 이루어진 N x N 크기의 정사각 격자이며 위쪽에는 크레인이 있고 오른쪽에는 바구니가 있습니다. (위 그림은 5 x 5 크기의 예시입니다). 각 격자 칸에는 다양한 인형이 들어 있으며 인형이 없는 칸은 빈칸입니다. 모든 인형은 1 x 1 크기의 격자 한 칸을 차지하며 격자의 가장 아래 칸부터 차곡차곡 쌓여 있습니다. 게임 사용자는 크레인을 좌우로 움직여서 멈춘 위치에서 가장 위에 있는 인형을 집어 올릴 수 있습니다. 집어 올린 인형은 바구니에 쌓이게 되는 데, 이때 바구니의 가장 아래 칸부터 인형이 순서대로 쌓이게 됩니다. 다음 그림은 [1번, 5번, 3번] 위치에서 순서대로 인형을 집어 올려 바구니에 담은 모습입니다.

만약 같은 모양의 인형 두 개가 바구니에 연속해서 쌓이게 되면 두 인형은 터뜨려지면서 바구니에서 사라지게 됩니다. 위 상태에서 이어서 [5번] 위치에서 인형을 집어 바구니에 쌓으면 같은 모양 인형 두 개가 없어집니다.

크레인 작동 시 인형이 집어지지 않는 경우는 없으나 만약 인형이 없는 곳에서 크레인을 작동시키는 경우에는 아무런 일도 일어나지 않습니다. 또한 바구니는 모든 인형이 들어갈 수 있을 만큼 충분히 크다고 가정합니다. (그림에서는 화면표시 제약으로 5칸만으로 표현하였음)

게임 화면의 격자의 상태가 담긴 2차원 배열 board와 인형을 집기 위해 크레인을 작동시킨 위치가 담긴 배열 moves가 매개변수로 주어질 때, 크레인을 모두 작동시킨 후 터트려져 사라진 인형의 개수를 return 하도록 solution 함수를 완성해주세요.

[제한사항]

  • board 배열은 2차원 배열로 크기는 5 x 5 이상 30 x 30 이하입니다.
  • board의 각 칸에는 0 이상 100 이하인 정수가 담겨있습니다.
    • 0은 빈 칸을 나타냅니다.
    • 1 ~ 100의 각 숫자는 각기 다른 인형의 모양을 의미하며 같은 숫자는 같은 모양의 인형을 나타냅니다.
  • moves 배열의 크기는 1 이상 1,000 이하입니다.
  • moves 배열 각 원소들의 값은 1 이상이며 board 배열의 가로 크기 이하인 자연수입니다.

입출력 예

boardmovesresult

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

입출력 예에 대한 설명

입출력 예 #1

인형의 처음 상태는 문제에 주어진 예시와 같습니다. 크레인이 [1, 5, 3, 5, 1, 2, 1, 4] 번 위치에서 차례대로 인형을 집어서 바구니에 옮겨 담은 후, 상태는 아래 그림과 같으며 바구니에 담는 과정에서 터트려져 사라진 인형은 4개 입니다.

public int solution(int[][] board, int[] moves) {
        int answer = 0;

        Stack<Integer> answerStack = new Stack<>();
        for(int i = 0; i < moves.length; i++)
        {
            for(int j = 0; j < board.length; j++)
            {
                if(board[board.length - 1][moves[i] - 1] == 0)
                    break;
                if(board[j][moves[i] - 1] != 0)
                {
                    answerStack.add(board[j][moves[i] - 1]);
                    board[j][moves[i] - 1] = 0;
                    if(answerStack.size() >= 2 && answerStack.peek() == answerStack.get(answerStack.size() - 2))
                    {
                        answerStack.pop();
                        answerStack.pop();
                        answer += 2;
                    }
                    break;
                }
            }
        }
        return answer;
    }

스택을 사용하면 간단하게 풀수있다.

문제 설명

위와 같은 삼각형의 꼭대기에서 바닥까지 이어지는 경로 중, 거쳐간 숫자의 합이 가장 큰 경우를 찾아보려고 합니다. 아래 칸으로 이동할 때는 대각선 방향으로 한 칸 오른쪽 또는 왼쪽으로만 이동 가능합니다. 예를 들어 3에서는 그 아래칸의 8 또는 1로만 이동이 가능합니다.

삼각형의 정보가 담긴 배열 triangle이 매개변수로 주어질 때, 거쳐간 숫자의 최댓값을 return 하도록 solution 함수를 완성하세요.

제한사항

  • 삼각형의 높이는 1 이상 500 이하입니다.
  • 삼각형을 이루고 있는 숫자는 0 이상 9,999 이하의 정수입니다.

입출력 예

triangleresult

[[7], [3, 8], [8, 1, 0], [2, 7, 4, 4], [4, 5, 2, 6, 5]] 30

 

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

        for(int i = 1; i < triangle.length; i++)
        {
            for (int j = 0; j < triangle[i].length; j++)
            {
                if(j == 0)
                {
                    triangle[i][j] += triangle[i - 1][j];
                }else if ( j == triangle[i].length - 1)
                {
                    triangle[i][j] += triangle[i - 1][j - 1];
                }
                else
                {
                    triangle[i][j] += Math.max(triangle[i - 1][j - 1],triangle[i - 1][j]);
                }
            }
        }
        int max = 0;
        for(int k = 0; k < triangle[triangle.length - 1].length; k++)
        {
            if (triangle[triangle.length - 1][k] > max)
                max = triangle[triangle.length - 1][k];
        }

        answer = max;

        return answer;
    }

 

위에서 부터 배열에 값을 더해가면서 가장 아래에 있는 값 중에 가장 큰 수가 답이 된다. 처음 풀어본 레벨 3 단계 문제이다!

 

 

문제 설명

매운 것을 좋아하는 Leo는 모든 음식의 스코빌 지수를 K 이상으로 만들고 싶습니다. 모든 음식의 스코빌 지수를 K 이상으로 만들기 위해 Leo는 스코빌 지수가 가장 낮은 두 개의 음식을 아래와 같이 특별한 방법으로 섞어 새로운 음식을 만듭니다.

섞은 음식의 스코빌 지수 = 가장 맵지 않은 음식의 스코빌 지수 + (두 번째로 맵지 않은 음식의 스코빌 지수 * 2)

Leo는 모든 음식의 스코빌 지수가 K 이상이 될 때까지 반복하여 섞습니다.
Leo가 가진 음식의 스코빌 지수를 담은 배열 scoville과 원하는 스코빌 지수 K가 주어질 때, 모든 음식의 스코빌 지수를 K 이상으로 만들기 위해 섞어야 하는 최소 횟수를 return 하도록 solution 함수를 작성해주세요.

제한 사항

  • scoville의 길이는 2 이상 1,000,000 이하입니다.
  • K는 0 이상 1,000,000,000 이하입니다.
  • scoville의 원소는 각각 0 이상 1,000,000 이하입니다.
  • 모든 음식의 스코빌 지수를 K 이상으로 만들 수 없는 경우에는 -1을 return 합니다.

입출력 예

scovilleKreturn

[1, 2, 3, 9, 10, 12] 7 2

입출력 예 설명

  1. 스코빌 지수가 1인 음식과 2인 음식을 섞으면 음식의 스코빌 지수가 아래와 같이 됩니다.
    새로운 음식의 스코빌 지수 = 1 + (2 * 2) = 5
    가진 음식의 스코빌 지수 = [5, 3, 9, 10, 12]

  2. 스코빌 지수가 3인 음식과 5인 음식을 섞으면 음식의 스코빌 지수가 아래와 같이 됩니다.
    새로운 음식의 스코빌 지수 = 3 + (5 * 2) = 13
    가진 음식의 스코빌 지수 = [13, 9, 10, 12]

모든 음식의 스코빌 지수가 7 이상이 되었고 이때 섞은 횟수는 2회입니다.

 

public int solution(int[] scoville, int K) {
        int answer = 0;
        PriorityQueue<Integer> priorityQueue = new PriorityQueue<>();

        for (int num:scoville)
        { priorityQueue.add(num); }

        while(!priorityQueue.isEmpty())
        {
            try
            {
                int a = priorityQueue.poll();
                int b = priorityQueue.poll();
                priorityQueue.add(a + (b * 2));
                answer++;
                if(priorityQueue.peek() > K)
                {
                    break;
                }
            }catch (Exception e)
            {
                return -1;
            }    
        }
        
        return answer;
    }

우선순위 큐를 이용하여 가장 작은 수 두가지를 꺼낸 후 첫째 수 + 둘째 수 * 2 연산 수행 후 다시 우선순위 큐에 값을 넣는다. 만약 우선순위 큐에서 가장 작은 수를 꺼냈을 때, K 보다 클 경우 answer를 리턴하고, Exception이 발생하는 경우는 우선순위 큐에 모든 값을 꺼내서 K보다 큰 수를 못 만들었을 경우이다. 이때 Exception에 대한 처리로 return -1 을 해주면 K보다 큰 수를 만들 수 없을 경우에 대해서 처리할 수 있다.

+ Recent posts