백준 4796번: 캠핑

문제

https://www.acmicpc.net/problem/4796

코드

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
public static void main(String[] args) throws IOException {
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

    StringBuilder sb = new StringBuilder();
    int i = 0;

    String input = "";
    while (!"0 0 0".equals(input = br.readLine())) {
        int[] lpv = convertStringArrayToIntegerArray(input.split(" "));

        int l = lpv[0];
        int p = lpv[1];
        int v = lpv[2];

        sb.append("Case ").append(++i).append(": ").append((v/p) * l + ((v%p) > l ? l : (v%p))).append("\n");
    }

    System.out.println(sb);
}

private static int[] convertStringArrayToIntegerArray(String[] args) {
    int[] array = new int[args.length];
    int i = 0;
    for (String str : args) {
        array[i++] = Integer.parseInt(str);
    }

    return array;
}

흐름

  1. V일 중에 연속되는 P일 동안 L일 만큼 휴가를 사용 할 수 있으므로
  2. V에서 P를 나눈 값에서 L일을 곱하면 사용 가능한 휴가 일수가 구해지고
  3. L이 V일에서 P일을 나눈 값보다 작을 땐 L일 만큼 휴가를 더 갈 수 있고
  4. 큰 경우엔 V % P 일 만큼 갈 수 있으므로 구한 값을 더하면
  5. 총 휴가 일수를 구할 수 있다.

결과

댓글 공유

백준 11047번: 동전 0

문제

https://www.acmicpc.net/problem/11047

코드

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
public static void main(String[] args) throws IOException {
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    String coinAndMoney = br.readLine();

    String[] coinAndMoneyArray = coinAndMoney.split(" ");

    int coinAmount = Integer.parseInt(coinAndMoneyArray[0]);
    long money = Long.parseLong(coinAndMoneyArray[1]);

    long[] coinCategory = getCoincategory(coinAmount, br);

    long answer = solution(coinAmount, money, coinCategory);

    System.out.println(answer);
}

public static long[] getCoincategory(int coinAmount, BufferedReader br) throws IOException {
    long[] result = new long[coinAmount];
    for (int i = 0; i < coinAmount; i++) {

        result[i] = Integer.parseInt(br.readLine());
    }

    return result;
}

public static long solution(int n, long money, long[] array) {
    long answer = 0;

    for (int i = n - 1; i >= 0; i--) {
        if (array[i] > money) {
            continue;
        }

        answer += (money / array[i]);
        money %= array[i];

        if (money == 0) {
            break;
        }
    }

    return answer;
}

흐름

  1. 돈의 종류 만큼 돌면서 큰 수 부터 가지고 있는 돈을 나눔
  2. 돈의 가치가 더 큰 경우엔 나눌 수 없으므로 continue
  3. 돈으로 갖고 있는 돈을 나눈 값을 더하고 남은 값은 다시 나눠야 하므로 money에 다시 저장함
  4. momeny가 0이 되면 나눌 돈이 없는 것이므로 사용한 돈 갯수 return
  5. 끝

결과

결과

테스트 케이스

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
long[] array = new long[] {1,5,10,50,100,500,1000,5000,10000,50000};
assertEquals(6, test.solution(10, 4200, array));
assertEquals(12, test.solution(10, 4790, array));
assertEquals(1, test.solution(10, 50000, array));
assertEquals(2000, test.solution(10, 100000000, array));

array = new long[] {1};
assertEquals(2, test.solution(1, 2, array));
assertEquals(1, test.solution(1, 1, array));
assertEquals(100000000, test.solution(1, 100000000, array));

array = new long[] {1, 5};
assertEquals(1, test.solution(2, 5, array));

array = new long[] {1, 3};
assertEquals(2, test.solution(2, 4, array));

array = new long[] {1, 100};
assertEquals(1, test.solution(2, 100, array));

array = new long[] {5000};
assertEquals(1, test.solution(1, 5000, array));
  • 나머지는 입력 값 처리이고 solution 메서드가 주요 로직이므로 solution 메서드를 테스트
  • 이렇게 테스트 할 경우 입력처리 때문에 에러가 발생 할 수 있으니 꼭 java application으로 함께 테스트 해볼 것

댓글 공유

프로그래머스: 구명보트

문제

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

코드

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public int solution(int[] people, int limit) {
    Arrays.sort(people);

    int left = 0;
    int right = people.length - 1;

    int answer = 0;
    while (left <= right) {
        int sum = people[left] + people[right];

        if (sum <= limit) {
            ++left;
        }

        ++answer;
        --right;
    }

    return answer;
}

흐름

  1. 배열을 정렬

  2. 배열 내에서 제일 작은 값이랑 제일 큰 값을 더해서 limit이 넘어가는 지 확인

  3. 넘어가면 제일 작은 값을 증가

  4. 안 넘어가면 제일 큰 값 혼자 빠져야하므로 answer을 증가시키고 right를 감소 시켜서 인덱스를 한칸 땡김

  5. right가 left 보다 작아질 때 까지 반복
    ex) [50,50,70,80] 인 경우 left = 0, right = 4 인데 위 코드르 반복하면 right가 점점 줄어들어 left와 만날 때 끝

  6. 끝

결과

정확성 테스트

번호 속도
테스트 1 통과 (1.92ms, 52.7MB)
테스트 2 통과 (1.56ms, 51.4MB)
테스트 3 통과 (1.66ms, 51MB)
테스트 4 통과 (2.02ms, 50.7MB)
테스트 5 통과 (1.42ms, 53MB)
테스트 6 통과 (1.37ms, 50.9MB)
테스트 7 통과 (1.46ms, 53.1MB)
테스트 8 통과 (0.95ms, 52.6MB)
테스트 9 통과 (1.15ms, 52.5MB)
테스트 10 통과 (2.01ms, 52.4MB)
테스트 11 통과 (1.68ms, 52.7MB)
테스트 12 통과 (1.78ms, 52.7MB)
테스트 13 통과 (2.07ms, 52.5MB)
테스트 14 통과 (1.46ms, 50.5MB)
테스트 15 통과 (1.22ms, 50.1MB)

효율성 테스트

번호 속도
테스트 1 통과 (11.43ms, 56.1MB)
테스트 2 통과 (11.63ms, 55.7MB)
테스트 3 통과 (11.88ms, 53.7MB)
테스트 4 통과 (8.84ms, 56.3MB)
테스트 5 통과 (11.08ms, 55.7MB)

테스트 케이스

1
2
3
4
5
6
assertEquals(3, test.solution(new int[] {70, 50, 80, 50}, 100));
assertEquals(3, test.solution(new int[] {70, 80, 50}, 100));
assertEquals(2, test.solution(new int[] {40, 40, 80}, 160));
assertEquals(2, test.solution(new int[] {20, 50, 50, 80}, 100));
assertEquals(5, test.solution(new int[] {40,50,60,70,80,90}, 100));
assertEquals(2, test.solution(new int[] {40,40,40}, 100));

댓글 공유

프로그래머스: 큰 수 만들기

문제

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

코드

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public String solution(String number, int k) {
    char[] toCharArray = number.toCharArray();

    StringBuilder answer = new StringBuilder();

    int idx = 0;
    for(int i = 0; i < number.length() - k; i++) {
        int max = 0;

        for(int j = idx; j <= k + i; j++) {
            int ch = toCharArray[j] - '0';
            if(max < ch) {
                max = ch;
                idx = j + 1;
            }
        }

        answer.append(max);
    }

    return answer.toString();
}

흐름

  1. 문자열에서 k 만큼 빼야하니 당연히 문자열 length - k 만큼 반복
  2. 가장 큰 수의 인덱스를 구해서 그 인덱스부터 한 칸씩 밀려야 하니 k + i 한 값 까지 반복
  3. 가장 큰 수의 인덱스부터 반복해야하니 범위 내에서 가장 큰 수를 구해서 그 수의 인덱스를 저장하고 여기서 구한 인덱스를 2번에서 사용
  4. 가장 큰 수를 저장하고 반복이 끝나면 리턴
  5. 끝

테스트 케이스

1
2
3
4
5
6
7
assertEquals("23", test.solution("123", 2));
assertEquals("34", test.solution("1234", 2));
assertEquals("94", test.solution("1924", 2));
assertEquals("3234", test.solution("1231234", 3));
assertEquals("775841", test.solution("4177252841", 4));
assertEquals("9", test.solution("9999999999", 9));
assertEquals("93231357719", test.solution("9312131357719", 5));

참고 사이트

댓글 공유

백준 11399번: ATM

https://www.acmicpc.net/problem/11399

소스

1
2
3
4
5
6
7
8
9
10
11
12

public static int solution(int n, int[] times) {
    Arrays.sort(times);
    
    int answer = 0;
    for (int i = 0; i < times.length; i++) {
        answer += times[i] * (n-i);
    }
    
    return answer;
}

흐름

  1. 시간이 짧게 걸리는 사람이 앞에 올수록 전체 수행 시간이 짧아지므로 sorting부터 실행

  2. 앞에 사람이 걸리는 시간은 그 뒤 사람들도 그만큼 시간이 + 되는 것이므로 n-i 한 값을 곱함

    ex) 첫 번째 사람이 1분 걸리면 2, 3, 4, 5 번째 사람도 1분씩 더 걸리게 됨

  3. 다 더한 값을 출력하면 끝

댓글 공유

  • page 1 of 1

Junggu Ji

author.bio


author.job