[Java] 피자 나눠먹기(3)_올림 계산

Problem 💻

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

프로그래머스

 

문제 설명

머쓱이네 피자가게는 피자를 두 조각에서 열 조각까지 원하는 조각 수로 잘라줍니다. 피자 조각 수 slice와 피자를 먹는 사람의 수 n이 매개변수로 주어질 때, n명의 사람이 최소 한 조각 이상 피자를 먹으려면 최소 몇 판의 피자를 시켜야 하는지를 return 하도록 solution 함수를 완성해보세요.

---

제한사항

• 2 ≤ slice ≤ 10
• 1 ≤ n ≤ 100

---

입출력 예slicenresult

7	10	2
4	12	3

---

Approach 1 ❌ - 나의 초기 접근법

class Solution {
    public int solution(int slice, int n) {
        // slice와 n과의 최소공배수 구하기
        // slice를 2에서 10까지 제한을 어떻게 둬야 하지?
        int gcd = gcd(slice, n);
        int lcd = slice * n / gcd;
        
        return lcd/slice;
    }
    pulbic static int gcd (int a, int b) {
        if (b == 0){return a};
        return gcd(b, a%b);
    }
}

---

Approach 2 ⭕ - 나의 접근법에 대한 교정

문제점 1: 문제의 요구 사항을 파악하지 못함.

• 문제는 최소 공배수(LCD)를 찾는 것이 아니라, n명의 사람이 최소 한 조각 이상 먹기 위해 몇 판의 피자를 시켜야 하는지를 계산해야 한다.

• 그러나 코드에서는 slice와 n의 최소공배수를 계산한 뒤, 이를 다시 slice로 나누는 방식을 사용하고 있다. 

 

문제점 2: gcd 메서드 구현 오류

• 코드에서 gcd 메서드 선언이 잘못되었다.

   오타로 pulbic이라고 적었다. 

---

Solution 💡

개선 방안: 올바른 접근법으로 문제 해결

 

문제의 본질은 다음과 같다:

1. 한 판의 피자에서 slice 만큼 조각을 제공.

2. n명이 최소 한 조각씩 먹으려면 필요한 총 조각 수는 n이다.

3. 피자를 몇 판 시켜야 하는지를 구하려면, 총 필요한 조각 수 n을 한 판에서 제공할 수 있는 조각 수 slice로 나누고, 나머지가 있으면 한 판을 더 추가해야 한다.

 

이를 코드로 구현하면 다음과 같이 작성할 수 있다:

class Solution {
   public int solution(int slice, int n) {
       // 한 사람당 최소 한 조각을 먹기 위해 필요한 피자 판 수 계산
       return (n + slice -1) / slice; // 올림 처리
   }
   public static void main(String[] args) {
      Solution solution = new Solution();
      
      System.out.println(solution.solution(7, 10)); //출력: 2
      System.out.println(solution.solution(4, 12)); //출력: 3
   }
}

코드 설명

1. (n + slice - 1) / slice는 올림(ceiling)을 구현하는 간단한 방법이다.

   • 예: n=10, slice=7인 경우:

        • n / slice는 10 / 7 = 1.428로 1이지만, 올림 처리로 2가 되어야 한다.  

        • (n + slice - 1) / slice는 (10 + 7 - 1) / 7 = 16 / 7 = 2가 된다.

  • 이 방법은 나머지가 있는 경우 한 판을 추가하는 효과를 준다.

 

2. 별도로 최소공배수나 최대공약수를 계산할 필요가 없다. 문제에서 요구하는 것은 단순히 나눗셈과 올림 처리이다.

 

왜  문제에서는 slice를 2~10으로 제한을 두었는데 코드에서는 이 제한을 두는 코드가 없는걸까?

실제 코드에 검증 로직이 빠져있어서 그렇다.

* 왜 제한을 명시해야 하는가? *
1. 입력값 검증
문제에서 slice의 범위를 2 ~ 10으로 제한했으므로, 입력값이 이 범위를 벗어날 경우 이를 처리하지 않으면 의도하지 않은 결과를 초래할 수 있다.
2. 안전한 코드 작성
실제 운영 환경에서는 입력값이 예상 범위를 벗어날 가능성이 있기 때문에, 항상 입력값을 검증하여 코드의 안전성을 보장하는 것이 중요하다.

class Solution {
   public int solution(int slice, int n) {
      // slice 값 검증
      if (slice < 2 || slice > 10) {
          throw new IllegalArgumentException("slice는 2 이상 10 이하의 값이어야 한다.");
      }
      
      //필요한 피자 판 수 계산
      return (n + slice -1) /slice ; // 올림 계산
   }
   public static void main(String[] args) {
    Solution solution = new Solution();

    // 정상 케이스
    System.out.println(solution.solution(7, 10)); // 출력: 2
    System.out.println(solution.solution(4, 12)); // 출력: 3

    // 예외 케이스
    try {
        System.out.println(solution.solution(1, 10)); // 예외 발생
    } catch (IllegalArgumentException e) {
        System.out.println(e.getMessage()); // 출력: slice는 2 이상 10 이하의 값이어야 합니다.
    }
}
}​

 

- 검증 로직 추가
  if (slice < 2 || slice > 10)를 통해 slice가 2 미만이거나 10 초과일 경우 예외를 발생시킨다.
   • IllegalArgumentException은 잘못된 입력값에 대해 코드가 중단되고, 적절한 에러 메시지를 출력하도록 한다.
-  문제 해결 로직 유지
  검증 로직 이후 기존의 계산 방식을 유지하므로, slice 값이 올바를 경우 문제를 정상적으로 해결한다.

---

Reference 📄

2024.12.17 - [Java Algorithm Coding Test] - [Java] 피자 나눠먹기(1)_ 몫과 나머지에 대한 근본적인 원리 사용

[Java] 피자 나눠먹기(1)_ 몫과 나머지에 대한 근본적인 원리 사용

 

위 문제와 어떤 공통점과 차이점이 있을까?

공통점

1. 기본 문제 구조

두 문제 모두 특정 조건을 만족하는 피자의 최소 개수를 계산하는 문제이다.

피자를 일정한 조각 수로 나누고, 모든 사람이 최소 한 조각 이상 먹을 수 있도록 계산하는 점에서 동일하다.

 

2. 수학적 접근 방식

두 문제 모두 필요한 조각 수를 기준으로 피자 판 수를 계산하며, 필요한 조각 수를 한 판의 조각 수로 나누고 올림(ceil) 처리를 통해 해결된다.

 

3. 제한 조건

두 문제 모두 입력값의 범위가 작아, 단순한 정수 연산으로 해결 가능하다.

---

차이점

1. 피자의 조각 수

  • 첫 번째 문제는 피자의 조각 수 slice가 변수로 제공되며, 2 ~ 10 사이의 값으로 동적으로 설정할 수 있다.

  • 두 번째 문제는 피자의 조각 수가 항상 7조각으로 고정되어 있다.

 

2. 매개변수

  • 첫 번째 문제는 solution(int slice, int n)와 같이 조각 수(slice)와 인원 수(n) 두 개의 매개변수를 받는다.

  • 두 번째 문제는 solution(int n)와 같이 인원 수(n) 하나만 매개변수로 받는다.

 

3. 문제의 일반성과 특수성

  • 첫 번째 문제는 피자 조각 수를 다양하게 설정할 수 있어 일반적인 상황을 다루는 문제이다.

  • 두 번째 문제는 피자 조각 수가 고정되어 있으므로 특정한 상황을 다루는 문제이다.

 

4. 코드의 간결함

  • 첫 번째 문제는 slice를 매개변수로 받아야 하므로 코드가 약간 더 복잡하다.

  • 두 번째 문제는 slice = 7이 고정되어 있어 코드가 더 간단하다.

 

---

두 문제의 코드 비교

 

첫 번째 문제

class Solution {
   public int solution(int slice, int n) {
      return (n + slice -1) / slice; // 올림 계산
   }
}

 

두 번째 문제

class Solution {
   public int solution(int n) {
       int slice = 7;
       return (n + slice -1) / slice; //올림 계산
   }
}