프로그래밍 언어로 푸는 입방체 부피 문제

프로그래밍의 세계는 종종 추상적인 논리를 현실의 문제에 적용하는 과정입니다. 게임 개발에서 오브젝트의 충돌을 감지하거나, 건축 소프트웨어에서 구조물의 용적을 계산하거나, 물류 시스템에서 패키지의 최적 적재 공간을 찾는 등, 기하학적 계산은 생각보다 우리 가까이에 있습니다. 오늘 우리는 이러한 문제의 가장 기본적인 형태 중 하나인 '두 입방체의 부피 차이 계산하기'를 깊이 있게 파고들어 보겠습니다.

이 문제는 간단해 보이지만, 어떤 프로그래밍 언어를 사용하는지, 어떤 코딩 스타일을 선호하는지, 그리고 코드의 확장성과 안정성을 얼마나 고려하는지에 따라 수많은 해결책이 존재합니다. 이 글을 통해 단순히 정답을 찾는 것을 넘어, '좋은 코드'란 무엇인지 함께 고민하고 다양한 접근법의 장단점을 비교 분석하여 여러분의 프로그래밍 시야를 한 단계 넓혀드리겠습니다.

문제 정의: 명확한 목표 설정하기

먼저 우리가 해결해야 할 문제를 명확하게 정의해 보겠습니다. 이 단계는 모든 코딩의 출발점이며, 목표가 명확할수록 코드는 엉뚱한 길로 빠지지 않습니다.

주어진 조건:

• 두 개의 입력값 a와 b가 주어집니다.
• a와 b는 각각 3개의 양의 정수를 담고 있는 배열(또는 리스트)입니다. 이 세 숫자는 각각 입방체의 가로, 세로, 높이를 의미합니다.
• 우리가 작성할 함수는 이 두 입방체의 부피(Volume) 차이를 계산하여 반환해야 합니다.

핵심 요구사항:

• 부피 계산: 입방체의 부피는 가로 × 세로 × 높이로 계산합니다.
• 절댓값 반환: 어느 입방체의 부피가 더 큰지는 중요하지 않습니다. 두 부피의 차이는 항상 양수, 즉 절댓값(Absolute Value)으로 반환되어야 합니다.

예시:
입력으로 a = [2, 2, 3]과 b = [5, 4, 1]이 주어졌다고 가정해 봅시다.

1. 입방체 'a'의 부피: 2 × 2 × 3 = 12
2. 입방체 'b'의 부피: 5 × 4 × 1 = 20
3. 두 부피의 차이: 12 - 20 = -8
4. 결과의 절댓값: |-8| = 8

따라서 함수는 최종적으로 8을 반환해야 합니다. 이처럼 명확한 논리적 절차를 바탕으로, 이제 코드를 작성할 준비가 되었습니다. 다양한 언어와 기법을 통해 이 문제를 요리해 봅시다.

---

접근법 1: 가장 직관적인 해결책 - 직접 인덱싱

가장 먼저 떠올릴 수 있는 방법은 배열의 각 요소에 직접 접근하여 계산하는 것입니다. 입력 배열의 크기가 3으로 고정되어 있기 때문에 이 방법은 매우 간단하고 효과적입니다. 컴퓨터에게 지시할 내용을 순서대로 코드로 옮긴다고 생각하면 쉽습니다.

JavaScript: 웹의 지배자

웹 프론트엔드와 백엔드(Node.js)를 아우르는 JavaScript에서는 배열 인덱스를 활용하여 다음과 같이 명료하게 코드를 작성할 수 있습니다.

/**
 * 두 입방체의 부피 차이를 계산합니다.
 * @param {number[]} a - 첫 번째 입방체의 치수 [가로, 세로, 높이]
 * @param {number[]} b - 두 번째 입방체의 치수 [가로, 세로, 높이]
 * @returns {number} 두 부피의 절댓값 차이
 */
function findVolumeDifference(a, b) {
  // 1. 첫 번째 입방체의 부피 계산
  const volumeA = a[0] * a[1] * a[2];

  // 2. 두 번째 입방체의 부피 계산
  const volumeB = b[0] * b[1] * b[2];

  // 3. 두 부피의 차이를 구한 후, Math.abs()로 절댓값 반환
  return Math.abs(volumeA - volumeB);
}

// --- 테스트 케이스 ---
const cuboidA = [2, 2, 3]; // 부피: 12
const cuboidB = [5, 4, 1]; // 부피: 20
console.log(`[${cuboidA}]와 [${cuboidB}]의 부피 차이:`, findVolumeDifference(cuboidA, cuboidB)); // 출력: 8

const cuboidC = [9, 7, 2]; // 부피: 126
const cuboidD = [5, 2, 2]; // 부피: 20
console.log(`[${cuboidC}]와 [${cuboidD}]의 부피 차이:`, findVolumeDifference(cuboidC, cuboidD)); // 출력: 106

코드 분석:

• a[0], a[1], a[2]는 배열 a의 첫 번째, 두 번째, 세 번째 요소에 접근하는 JavaScript의 기본 문법입니다.
• const 키워드를 사용하여 계산된 부피 값이 재할당되지 않도록 하여 코드의 안정성을 높였습니다.
• Math.abs()는 JavaScript의 내장 Math 객체에 포함된 함수로, 숫자의 절댓값을 반환합니다.

이 코드는 누가 보아도 그 의도를 명확히 파악할 수 있다는 큰 장점이 있습니다.

Python: 간결함의 미학

Python은 읽기 쉽고 간결한 문법으로 유명합니다. 위 JavaScript 코드와 거의 동일한 논리를 훨씬 더 적은 상용구(boilerplate) 코드로 표현할 수 있습니다.

def find_volume_difference(a: list[int], b: list[int]) -> int:
    """
    두 입방체의 부피 차이를 계산합니다.
    :param a: 첫 번째 입방체의 치수 [가로, 세로, 높이]
    :param b: 두 번째 입방체의 치수 [가로, 세로, 높이]
    :return: 두 부피의 절댓값 차이
    """
    # 1. 첫 번째 입방체의 부피 계산 (리스트 인덱싱)
    volume_a = a[0] * a[1] * a[2]
    
    # 2. 두 번째 입방체의 부피 계산
    volume_b = b[0] * b[1] * b[2]
    
    # 3. 내장 함수 abs()를 사용하여 절댓값 차이 반환
    return abs(volume_a - volume_b)

# --- 테스트 케이스 ---
cuboid_a = [2, 2, 3]  # 부피: 12
cuboid_b = [5, 4, 1]  # 부피: 20
print(f"{cuboid_a}와 {cuboid_b}의 부피 차이: {find_volume_difference(cuboid_a, cuboid_b)}") # 출력: 8

cuboid_c = [9, 7, 2]  # 부피: 126
cuboid_d = [5, 2, 2]  # 부피: 20
print(f"{cuboid_c}와 {cuboid_d}의 부피 차이: {find_volume_difference(cuboid_c, cuboid_d)}") # 출력: 106

코드 분석:

• Python의 리스트 인덱싱은 JavaScript와 동일하게 a[0], a[1], a[2]를 사용합니다.
• 절댓값을 구하는 함수는 abs()이며, 이는 Python의 내장 함수이므로 별도의 모듈 임포트 없이 바로 사용할 수 있습니다.
• 타입 힌트(a: list[int], -> int)를 추가하여 함수가 어떤 타입을 받고 어떤 타입을 반환하는지 명시함으로써 코드의 가독성과 유지보수성을 향상시켰습니다.

Java: 견고함과 안정성

엔터프라이즈 환경에서 널리 사용되는 Java는 정적 타입 언어로서 코드의 안정성과 예측 가능성을 중시합니다. 배열을 다루는 방식은 조금 더 명시적입니다.

public class CuboidCalculator {

    /**
     * 두 입방체의 부피 차이를 계산합니다.
     * @param a 첫 번째 입방체의 치수 (int 배열)
     * @param b 두 번째 입방체의 치수 (int 배열)
     * @return 두 부피의 절댓값 차이
     */
    public static int findVolumeDifference(int[] a, int[] b) {
        // 1. 첫 번째 입방체의 부피 계산
        int volumeA = a[0] * a[1] * a[2];

        // 2. 두 번째 입방체의 부피 계산
        int volumeB = b[0] * b[1] * b[2];

        // 3. Math.abs()를 사용하여 절댓값 차이 반환
        return Math.abs(volumeA - volumeB);
    }

    public static void main(String[] args) {
        // --- 테스트 케이스 ---
        int[] cuboidA = {2, 2, 3}; // 부피: 12
        int[] cuboidB = {5, 4, 1}; // 부피: 20
        System.out.println("부피 차이 1: " + findVolumeDifference(cuboidA, cuboidB)); // 출력: 8

        int[] cuboidC = {9, 7, 2}; // 부피: 126
        int[] cuboidD = {5, 2, 2}; // 부피: 20
        System.out.println("부피 차이 2: " + findVolumeDifference(cuboidC, cuboidD)); // 출력: 106
    }
}

코드 분석:

• Java는 변수와 함수의 타입을 명확히 선언해야 합니다 (int[] a, public static int...).
• 배열 요소 접근 방식은 다른 언어들과 동일하게 a[0], a[1], a[2]를 사용합니다.
• 절댓값 함수는 JavaScript와 마찬가지로 Math.abs()를 사용합니다.

장점과 한계: 직접 인덱싱 접근법은 명확하고, 빠르며, 군더더기가 없습니다. 문제의 조건(크기 3인 배열)이 변하지 않는 한, 이 방법은 거의 완벽에 가깝습니다. 하지만 만약 문제가 'n차원 공간에서의 초입방체 부피 계산'으로 확장된다면 어떨까요? 이 코드는 유연성이 부족하여 확장에 취약하다는 단점을 가집니다. 바로 이 지점에서 다음 접근법이 빛을 발합니다.

---

접근법 2: 함수형 프로그래밍의 우아함 - `reduce` 활용

함수형 프로그래밍은 코드를 값(value)들의 흐름과 변환으로 보는 패러다임입니다. 이 접근법의 핵심 도구 중 하나가 바로 `reduce` (또는 `fold`, `aggregate`) 함수입니다. `reduce`는 배열의 모든 요소를 순회하며 지정된 함수를 적용하여 단 하나의 결과값으로 축약(reduce)하는 강력한 기능을 제공합니다.

배열의 모든 요소를 곱하는 것은 `reduce`의 전형적인 활용 사례입니다. 이 방법을 사용하면 코드가 더 선언적(declarative)이 되고, 배열의 길이에 상관없이 동작하는 유연한 코드를 작성할 수 있습니다.

JavaScript: `reduce`의 정석

JavaScript의 `Array.prototype.reduce()` 메서드는 함수형 프로그래밍을 JS에서 구현하는 핵심적인 방법입니다.

function findVolumeDifferenceWithReduce(a, b) {
  // 배열의 모든 요소를 곱하여 부피를 계산하는 헬퍼(helper) 함수
  const calculateVolume = (dimensions) => {
    // reduce(accumulator, currentValue) => accumulator * currentValue
    // accumulator: 누적값, currentValue: 현재 처리 중인 배열 요소
    // 초기값 1부터 시작하여 모든 요소를 차례로 곱해나갑니다.
    return dimensions.reduce((acc, val) => acc * val, 1);
  };

  const volumeA = calculateVolume(a);
  const volumeB = calculateVolume(b);

  return Math.abs(volumeA - volumeB);
}

// 한 줄로 표현하기 (Code Golfing)
// 가독성은 떨어질 수 있지만, 간결함을 추구하는 경우 사용 가능
const findVolumeDifferenceOneLiner = (a, b) => Math.abs(
  a.reduce((acc, val) => acc * val, 1) - b.reduce((acc, val) => acc * val, 1)
);

// --- 테스트 케이스 ---
const cuboidA = [2, 2, 3];
const cuboidB = [5, 4, 1];
console.log("Reduce 방식 결과:", findVolumeDifferenceWithReduce(cuboidA, cuboidB)); // 출력: 8
console.log("한 줄 코드 결과:", findVolumeDifferenceOneLiner(cuboidA, cuboidB)); // 출력: 8

`reduce` 동작 원리:

[2, 2, 3].reduce((acc, val) => acc * val, 1) 의 내부 동작은 다음과 같습니다.

1. 초기값: `acc`는 초기값 1로 설정됩니다.
2. 1단계: `acc`(1) * `val`(2) = 2. `acc`는 이제 2가 됩니다.
3. 2단계: `acc`(2) * `val`(2) = 4. `acc`는 이제 4가 됩니다.
4. 3단계: `acc`(4) * `val`(3) = 12. `acc`는 이제 12가 됩니다.
5. 모든 요소를 순회했으므로 최종 `acc` 값인 12를 반환합니다.

이 방식은 배열의 길이가 3이든 10이든 상관없이 동일한 코드로 동작하므로, 문제의 조건이 변경되었을 때 코드 수정이 필요 없는 높은 재사용성을 자랑합니다.

Python: `functools.reduce`와 `numpy.prod`

Python에서는 `reduce`가 내장 함수가 아니라 `functools` 모듈에 포함되어 있습니다. 이는 `for` 루프가 더 파이썬스러운(Pythonic) 방식으로 여겨지기 때문이지만, 여전히 `reduce`는 강력한 도구입니다.

from functools import reduce
import operator

def find_volume_difference_reduce(a: list[int], b: list[int]) -> int:
    """functools.reduce를 사용하여 부피 차이를 계산합니다."""
    
    # operator.mul은 곱셈 연산자(*)와 동일한 기능을 하는 함수입니다.
    # reduce(operator.mul, a)는 a 리스트의 모든 요소를 곱합니다.
    volume_a = reduce(operator.mul, a)
    volume_b = reduce(operator.mul, b)
    
    # 람다(lambda) 함수를 사용할 수도 있습니다:
    # volume_a = reduce(lambda x, y: x * y, a)
    
    return abs(volume_a - volume_b)

# --- 테스트 케이스 ---
cuboid_a = [2, 2, 3]
cuboid_b = [5, 4, 1]
print(f"functools.reduce 방식 결과: {find_volume_difference_reduce(cuboid_a, cuboid_b)}") # 출력: 8

만약 데이터 과학이나 수치 계산 분야에서 작업하고 있다면, NumPy 라이브러리를 사용하는 것이 훨씬 더 효율적이고 일반적입니다.

import numpy as np

def find_volume_difference_numpy(a: list[int], b: list[int]) -> int:
    """NumPy의 prod 함수를 사용하여 부피 차이를 계산합니다."""
    # np.prod()는 배열의 모든 요소의 곱을 계산하는 고성능 함수입니다.
    volume_a = np.prod(a)
    volume_b = np.prod(b)
    
    # NumPy는 자체적으로 숫자 타입을 가지므로, Python의 int로 변환해줄 수 있습니다.
    # 여기서는 abs()가 잘 처리해주므로 불필요합니다.
    return abs(volume_a - volume_b)

# --- 테스트 케이스 ---
cuboid_c = [9, 7, 2]
cuboid_d = [5, 2, 2]
print(f"NumPy 방식 결과: {find_volume_difference_numpy(cuboid_c, cuboid_d)}") # 출력: 106

np.prod()는 내부적으로 최적화된 C 코드로 실행되므로, 매우 큰 배열을 다룰 때 Python의 `reduce`나 `for` 루프보다 월등한 성능을 보입니다. 작은 배열에서는 그 차이가 미미하지만, NumPy 기반 프로젝트에서는 일관성을 위해 이 방법을 사용하는 것이 좋습니다.

Dart: 모던하고 간결한 문법

Google이 개발한 Dart 언어는 Flutter 프레임워크와 함께 모바일 앱 개발에서 큰 인기를 얻고 있습니다. Dart 역시 `reduce`를 리스트의 기본 메서드로 제공하여 함수형 스타일의 코딩을 지원합니다.

import 'dart:math';

// 부피를 계산하는 헬퍼 함수를 별도로 정의하거나, 익명 함수로 바로 사용할 수 있습니다.
int calculateVolume(List<int> dims) {
  return dims.reduce((value, element) => value * element);
}

int findVolumeDifference(List<int> a, List<int> b) {
  final volumeA = calculateVolume(a);
  final volumeB = calculateVolume(b);

  // Dart의 int, double 등 숫자 타입은 .abs() 메서드를 내장하고 있습니다.
  return (volumeA - volumeB).abs();
}

void main() {
  var a = [2, 2, 3];
  var b = [5, 4, 1];
  print('Dart reduce 방식 결과: ${findVolumeDifference(a, b)}'); // 출력: 8
}

Dart 코드는 JavaScript와 매우 유사한 구조를 가지면서도, 강력한 타입 시스템과 객체 지향적 특성(예: int 타입이 abs() 메서드를 가짐)이 조화롭게 어우러져 있습니다. 매우 깔끔하고 읽기 쉬운 코드를 작성할 수 있습니다.

---

접근법 3: 실전 코드를 위한 방어적 프로그래밍

지금까지의 코드는 문제가 제시한 '이상적인' 조건(입력은 항상 3개의 양의 정수를 담은 배열) 하에서는 완벽하게 동작합니다. 하지만 실제 애플리케이션에서는 사용자의 실수, 잘못된 데이터, 예기치 않은 API 응답 등 다양한 '비정상적인' 상황에 대비해야 합니다. 이를 **방어적 프로그래밍(Defensive Programming)**이라고 합니다.

만약 우리 함수에 다음과 같은 입력이 들어온다면 어떻게 될까요?

• a = [1, 2] (요소가 2개뿐인 배열)
• b = [1, 2, 'three'] (숫자가 아닌 요소 포함)
• a = [1, -5, 3] (음수 포함)
• b = null (배열이 아닌 `null` 값)

현재 코드는 에러를 발생시키거나(TypeError, IndexError 등) 예상치 못한 결과를 반환할 것입니다. 견고한 코드는 이러한 예외 상황을 예측하고 적절하게 처리해야 합니다.

Python으로 구현한 방어적 코드

입력값 검증(Input Validation)을 추가하여 함수를 훨씬 더 견고하게 만들어 보겠습니다.

from functools import reduce
import operator

def find_volume_difference_robust(a: list, b: list) -> int:
    """
    입력값 검증을 포함하여 안정성을 높인 부피 차이 계산 함수
    """
    # 1. 입력값 검증
    # 두 입력이 모두 리스트인지, 그리고 각 리스트의 길이가 3인지 확인
    if not all(isinstance(arr, list) and len(arr) == 3 for arr in [a, b]):
        raise ValueError("입력값은 반드시 3개의 요소를 가진 리스트여야 합니다.")

    # 모든 요소들을 하나의 리스트로 합친다
    all_dimensions = a + b
    
    # 모든 요소가 정수이고 양수인지 확인
    if not all(isinstance(dim, int) and dim > 0 for dim in all_dimensions):
        raise ValueError("입방체의 모든 치수는 양의 정수여야 합니다.")

    # 2. 검증 통과 후, 부피 계산 로직 수행 (reduce 방식 사용)
    volume_a = reduce(operator.mul, a)
    volume_b = reduce(operator.mul, b)
    
    return abs(volume_a - volume_b)

# --- 테스트 케이스 ---
# 정상 케이스
print(f"정상 작동: {find_volume_difference_robust([3, 4, 5], [1, 1, 1])}")

# 비정상 케이스 테스트 (try-except로 에러 처리)
try:
    find_volume_difference_robust([1, 2], [1, 2, 3])
except ValueError as e:
    print(f"에러 발생 (길이 오류): {e}")

try:
    find_volume_difference_robust([1, 2, '3'], [1, 2, 3])
except ValueError as e:
    print(f"에러 발생 (타입 오류): {e}")

try:
    find_volume_difference_robust([1, -2, 3], [1, 2, 3])
except ValueError as e:
    print(f"에러 발생 (음수 오류): {e}")

코드 분석:

• isinstance()와 len()을 사용하여 입력의 타입과 길이를 엄격하게 검사합니다.
• 리스트 컴프리헨션과 all() 함수를 조합하여 모든 요소가 특정 조건을 만족하는지 간결하게 확인합니다.
• 조건을 만족하지 않으면, 계산을 시도하기 전에 ValueError를 발생시켜 문제가 무엇인지 명확하게 알려줍니다. 이는 디버깅을 매우 용이하게 만듭니다.

이처럼 몇 줄의 검증 코드를 추가하는 것만으로도 우리 함수는 예측 불가능한 상황에 훨씬 더 잘 대처하는 '프로페셔널'한 코드로 거듭날 수 있습니다.

결론: 어떤 코드가 '최고'의 코드인가?

하나의 간단한 문제를 통해 우리는 세 가지 다른 관점의 해결책을 살펴보았습니다.

1. 직접 인덱싱: 단순함과 속도가 중요하고, 입력 조건이 절대 변하지 않을 것이 확실할 때 최적의 선택입니다. 코딩 테스트의 시간제한이 있는 환경에서 빠르게 정답을 제출하기에 좋습니다.
2. `reduce` 활용: 유연성과 확장성을 중시할 때 빛을 발합니다. 'n차원 부피 계산'과 같이 문제가 일반화될 가능성이 있다면 이 방식이 훨씬 우아하고 유지보수하기 좋습니다. 함수형 프로그래밍의 간결함을 보여줍니다.
3. 방어적 프로그래밍: 안정성과 신뢰성이 최우선인 실제 애플리케이션 환경에서는 필수적인 접근법입니다. 예외 처리를 통해 예기치 않은 에러를 방지하고 시스템 전체의 견고함을 높입니다.

그렇다면 어떤 코드가 '최고'일까요? 정답은 없습니다. '최고'의 코드는 주어진 '상황'과 '목적'에 가장 잘 부합하는 코드입니다.

훌륭한 개발자는 단 하나의 정답만을 고집하는 사람이 아니라, 다양한 도구(접근법)의 장단점을 명확히 이해하고, 현재 해결해야 할 문제의 성격에 맞춰 가장 적절한 도구를 꺼내 쓸 수 있는 사람입니다. 오늘 살펴본 입방체 부피 계산 문제를 여러 각도에서 분석하고 코딩해 본 경험이 여러분의 '개발자 도구함'을 더욱 풍성하게 채워주었기를 바랍니다.