자릿수의 합: 동률이면 더 큰 수 고르기

function solution(n, arr) {
    let answer = 0;
    let bestSum = -1;

    for (let i = 0; i < n; i++) {
        const x = arr[i];
        let tmp = x;
        let sum = 0;

        while (tmp > 0) {
            sum += tmp % 10;
            tmp = Math.floor(tmp / 10);
        }

        if (sum > bestSum) {
            bestSum = sum;
            answer = x;
        } else if (sum === bestSum && x > answer) {
            answer = x;
        }
    }

    return answer;
}

호출: solution(n, arr) → number. n은 정수, arr는 number[]이다. 전제: 3 ≤ n ≤ 100, n == arr의 길이, 모든 원소는 1 이상 10,000,000 이하의 정수이다. 반환값은 자릿수의 합이 최대인 원래 수이며, 합이 같으면 원래 수가 더 큰 쪽이다. arr를 변경하지 않고, 표준 입력·출력은 처리하지 않는다.

풀이: 각 원래 수 x를 tmp에 복사한다. tmp가 0보다 큰 동안 tmp % 10을 sum에 더하고, tmp를 10으로 나눈 정수 몫으로 바꾼다. 이 순서는 일의 자리부터 한 자리씩 제거하며 모든 자릿수를 정확히 한 번씩 더한다. x는 끝까지 원래 값으로 유지한다.

선택 기준: bestSum은 지금까지 확인한 최대 자릿수 합, answer는 그 합을 가진 수 중 가장 큰 원래 수다. 처음에는 bestSum = -1, answer = 0으로 둔다. sum > bestSum이면 두 값을 갱신한다. sum == bestSum이면 x > answer일 때만 answer를 갱신한다. 따라서 반복이 끝나면 조건을 만족하는 원래 수가 answer에 남는다.

예제 추적: [128, 460, 603, 40, 521, 137, 123]의 자릿수 합은 차례로 [11, 10, 9, 4, 8, 11, 6]이다. 128과 137이 합 11로 같으므로 더 큰 원래 수 137을 반환한다. 반환값은 자릿수 합 11이 아니다.

경계 확인: 최소 개수 입력 [1, 2, 3]은 3이다. [235, 1234, 22]와 순서를 바꾼 [1234, 235, 22]는 모두 1234이다. 최댓값이 포함된 [10,000,000, 9,999,999, 1]은 자릿수 합이 63인 9,999,999를 고른다. [10,000,000, 1,000,000, 1]은 합이 모두 1이므로 10,000,000을 고른다. 100개 입력과 중복 원소도 같은 비교 규칙으로 처리한다. 빈 배열, 0, 음수는 원문 입력 범위 밖이다.

복잡도: N은 입력 개수, D는 가장 긴 수의 십진 자릿수이다. 시간은 O(ND), 입력 배열을 제외한 추가 공간은 O(1)이다. 이 문제에서는 D ≤ 8이므로 입력 상한을 고정하면 시간은 O(N)으로도 표현할 수 있다. 별도의 자릿수 배열이나 정렬은 필요하지 않다.

JavaScript 주의점: / 연산만 하면 소수가 남으므로 Math.floor(tmp / 10)으로 정수 몫을 구한다. 입력 상한 10,000,000은 Number의 안전한 정수 범위 안이다. 합 비교에는 ===를 사용한다. 원본 배열을 정렬하거나 원소를 직접 나누지 않는다.

def solution(n: int, arr: list[int]) -> int:
    answer = 0
    best_sum = -1

    for i in range(n):
        x = arr[i]
        tmp = x
        digit_sum = 0

        while tmp > 0:
            digit_sum += tmp % 10
            tmp //= 10

        if digit_sum > best_sum:
            best_sum = digit_sum
            answer = x
        elif digit_sum == best_sum and x > answer:
            answer = x

    return answer

호출: solution(n: int, arr: list[int]) -> int. Python 3.9 이상 문법을 사용한다. 전제: 3 ≤ n ≤ 100, n == arr의 길이, 모든 원소는 1 이상 10,000,000 이하의 정수이다. 반환값은 자릿수의 합이 최대인 원래 수이며, 합이 같으면 원래 수가 더 큰 쪽이다. arr를 변경하지 않고, 표준 입력·출력은 처리하지 않는다.

풀이: 각 원래 수 x를 tmp에 복사한다. tmp가 0보다 큰 동안 tmp % 10을 sum에 더하고, tmp를 10으로 나눈 정수 몫으로 바꾼다. 이 순서는 일의 자리부터 한 자리씩 제거하며 모든 자릿수를 정확히 한 번씩 더한다. x는 끝까지 원래 값으로 유지한다.

선택 기준: bestSum은 지금까지 확인한 최대 자릿수 합, answer는 그 합을 가진 수 중 가장 큰 원래 수다. 처음에는 bestSum = -1, answer = 0으로 둔다. sum > bestSum이면 두 값을 갱신한다. sum == bestSum이면 x > answer일 때만 answer를 갱신한다. 따라서 반복이 끝나면 조건을 만족하는 원래 수가 answer에 남는다.

예제 추적: [128, 460, 603, 40, 521, 137, 123]의 자릿수 합은 차례로 [11, 10, 9, 4, 8, 11, 6]이다. 128과 137이 합 11로 같으므로 더 큰 원래 수 137을 반환한다. 반환값은 자릿수 합 11이 아니다.

경계 확인: 최소 개수 입력 [1, 2, 3]은 3이다. [235, 1234, 22]와 순서를 바꾼 [1234, 235, 22]는 모두 1234이다. 최댓값이 포함된 [10,000,000, 9,999,999, 1]은 자릿수 합이 63인 9,999,999를 고른다. [10,000,000, 1,000,000, 1]은 합이 모두 1이므로 10,000,000을 고른다. 100개 입력과 중복 원소도 같은 비교 규칙으로 처리한다. 빈 배열, 0, 음수는 원문 입력 범위 밖이다.

복잡도: N은 입력 개수, D는 가장 긴 수의 십진 자릿수이다. 시간은 O(ND), 입력 배열을 제외한 추가 공간은 O(1)이다. 이 문제에서는 D ≤ 8이므로 입력 상한을 고정하면 시간은 O(N)으로도 표현할 수 있다. 별도의 자릿수 배열이나 정렬은 필요하지 않다.

Python 주의점: 코드의 best_sum과 digit_sum은 설명의 bestSum과 sum에 해당한다. 정수 자릿수를 제거할 때 /가 아니라 //를 사용한다. /는 float를 만들지만 //는 정수 몫을 유지한다. 정수에는 이 입력 범위에서 오버플로가 없고, list[int] 형식 표기는 Python 3.9 이상에서 사용할 수 있다.

public class Solution {
    public static int solution(int n, int[] arr) {
        int answer = 0;
        int bestSum = -1;

        for (int i = 0; i < n; i++) {
            int x = arr[i];
            int tmp = x;
            int sum = 0;

            while (tmp > 0) {
                sum += tmp % 10;
                tmp /= 10;
            }

            if (sum > bestSum) {
                bestSum = sum;
                answer = x;
            } else if (sum == bestSum && x > answer) {
                answer = x;
            }
        }

        return answer;
    }
}

호출: Solution.solution(int n, int[] arr) → int. Solution.java에 두는 public class Solution의 public static 메서드이다. 전제: 3 ≤ n ≤ 100, n == arr의 길이, 모든 원소는 1 이상 10,000,000 이하의 정수이다. 반환값은 자릿수의 합이 최대인 원래 수이며, 합이 같으면 원래 수가 더 큰 쪽이다. arr를 변경하지 않고, 표준 입력·출력은 처리하지 않는다.

풀이: 각 원래 수 x를 tmp에 복사한다. tmp가 0보다 큰 동안 tmp % 10을 sum에 더하고, tmp를 10으로 나눈 정수 몫으로 바꾼다. 이 순서는 일의 자리부터 한 자리씩 제거하며 모든 자릿수를 정확히 한 번씩 더한다. x는 끝까지 원래 값으로 유지한다.

선택 기준: bestSum은 지금까지 확인한 최대 자릿수 합, answer는 그 합을 가진 수 중 가장 큰 원래 수다. 처음에는 bestSum = -1, answer = 0으로 둔다. sum > bestSum이면 두 값을 갱신한다. sum == bestSum이면 x > answer일 때만 answer를 갱신한다. 따라서 반복이 끝나면 조건을 만족하는 원래 수가 answer에 남는다.

예제 추적: [128, 460, 603, 40, 521, 137, 123]의 자릿수 합은 차례로 [11, 10, 9, 4, 8, 11, 6]이다. 128과 137이 합 11로 같으므로 더 큰 원래 수 137을 반환한다. 반환값은 자릿수 합 11이 아니다.

경계 확인: 최소 개수 입력 [1, 2, 3]은 3이다. [235, 1234, 22]와 순서를 바꾼 [1234, 235, 22]는 모두 1234이다. 최댓값이 포함된 [10,000,000, 9,999,999, 1]은 자릿수 합이 63인 9,999,999를 고른다. [10,000,000, 1,000,000, 1]은 합이 모두 1이므로 10,000,000을 고른다. 100개 입력과 중복 원소도 같은 비교 규칙으로 처리한다. 빈 배열, 0, 음수는 원문 입력 범위 밖이다.

복잡도: N은 입력 개수, D는 가장 긴 수의 십진 자릿수이다. 시간은 O(ND), 입력 배열을 제외한 추가 공간은 O(1)이다. 이 문제에서는 D ≤ 8이므로 입력 상한을 고정하면 시간은 O(N)으로도 표현할 수 있다. 별도의 자릿수 배열이나 정렬은 필요하지 않다.

Java 주의점: tmp와 10이 모두 int이므로 tmp /= 10은 정수 나눗셈이다. 양수 입력에서는 Math.floor에 해당하는 결과가 되어 별도 변환이 필요 없다. 원래 수의 최댓값과 자릿수 합은 int 범위 안이다. public 클래스 이름과 파일 이름은 Solution과 Solution.java로 맞추며, 입력을 읽는 main 메서드는 이 함수 계약과 별개다.

#include <vector>

int solution(int n, const std::vector<int>& arr) {
    int answer = 0;
    int bestSum = -1;

    for (int i = 0; i < n; i++) {
        const int x = arr[i];
        int tmp = x;
        int sum = 0;

        while (tmp > 0) {
            sum += tmp % 10;
            tmp /= 10;
        }

        if (sum > bestSum) {
            bestSum = sum;
            answer = x;
        } else if (sum == bestSum && x > answer) {
            answer = x;
        }
    }

    return answer;
}

호출: int solution(int n, const std::vector<int>& arr). C++17에서 사용할 수 있는 함수이며, arr는 읽기 전용 참조로 전달한다. 전제: 3 ≤ n ≤ 100, n == arr의 길이, 모든 원소는 1 이상 10,000,000 이하의 정수이다. 반환값은 자릿수의 합이 최대인 원래 수이며, 합이 같으면 원래 수가 더 큰 쪽이다. arr를 변경하지 않고, 표준 입력·출력은 처리하지 않는다.

풀이: 각 원래 수 x를 tmp에 복사한다. tmp가 0보다 큰 동안 tmp % 10을 sum에 더하고, tmp를 10으로 나눈 정수 몫으로 바꾼다. 이 순서는 일의 자리부터 한 자리씩 제거하며 모든 자릿수를 정확히 한 번씩 더한다. x는 끝까지 원래 값으로 유지한다.

선택 기준: bestSum은 지금까지 확인한 최대 자릿수 합, answer는 그 합을 가진 수 중 가장 큰 원래 수다. 처음에는 bestSum = -1, answer = 0으로 둔다. sum > bestSum이면 두 값을 갱신한다. sum == bestSum이면 x > answer일 때만 answer를 갱신한다. 따라서 반복이 끝나면 조건을 만족하는 원래 수가 answer에 남는다.

예제 추적: [128, 460, 603, 40, 521, 137, 123]의 자릿수 합은 차례로 [11, 10, 9, 4, 8, 11, 6]이다. 128과 137이 합 11로 같으므로 더 큰 원래 수 137을 반환한다. 반환값은 자릿수 합 11이 아니다.

경계 확인: 최소 개수 입력 [1, 2, 3]은 3이다. [235, 1234, 22]와 순서를 바꾼 [1234, 235, 22]는 모두 1234이다. 최댓값이 포함된 [10,000,000, 9,999,999, 1]은 자릿수 합이 63인 9,999,999를 고른다. [10,000,000, 1,000,000, 1]은 합이 모두 1이므로 10,000,000을 고른다. 100개 입력과 중복 원소도 같은 비교 규칙으로 처리한다. 빈 배열, 0, 음수는 원문 입력 범위 밖이다.

복잡도: N은 입력 개수, D는 가장 긴 수의 십진 자릿수이다. 시간은 O(ND), 입력 배열을 제외한 추가 공간은 O(1)이다. 이 문제에서는 D ≤ 8이므로 입력 상한을 고정하면 시간은 O(N)으로도 표현할 수 있다. 별도의 자릿수 배열이나 정렬은 필요하지 않다.

C++ 주의점: 양수 int의 / 10은 정수 몫을 남기므로 tmp /= 10으로 한 자리를 제거한다. 일반적인 32비트 int 환경에서 입력 상한과 합은 안전하다. const std::vector<int>&는 입력 복사와 수정을 피하므로 추가 공간 O(1)을 유지한다. 필요한 <vector>를 포함하며, main과 입출력 코드는 함수 계약에 포함하지 않는다.

public static class Solution
{
    public static int solution(int n, int[] arr)
    {
        int answer = 0;
        int bestSum = -1;

        for (int i = 0; i < n; i++)
        {
            int x = arr[i];
            int tmp = x;
            int sum = 0;

            while (tmp > 0)
            {
                sum += tmp % 10;
                tmp /= 10;
            }

            if (sum > bestSum)
            {
                bestSum = sum;
                answer = x;
            }
            else if (sum == bestSum && x > answer)
            {
                answer = x;
            }
        }

        return answer;
    }
}

호출: Solution.solution(int n, int[] arr) → int. public static class Solution의 public static 메서드이다. 전제: 3 ≤ n ≤ 100, n == arr의 길이, 모든 원소는 1 이상 10,000,000 이하의 정수이다. 반환값은 자릿수의 합이 최대인 원래 수이며, 합이 같으면 원래 수가 더 큰 쪽이다. arr를 변경하지 않고, 표준 입력·출력은 처리하지 않는다.

풀이: 각 원래 수 x를 tmp에 복사한다. tmp가 0보다 큰 동안 tmp % 10을 sum에 더하고, tmp를 10으로 나눈 정수 몫으로 바꾼다. 이 순서는 일의 자리부터 한 자리씩 제거하며 모든 자릿수를 정확히 한 번씩 더한다. x는 끝까지 원래 값으로 유지한다.

선택 기준: bestSum은 지금까지 확인한 최대 자릿수 합, answer는 그 합을 가진 수 중 가장 큰 원래 수다. 처음에는 bestSum = -1, answer = 0으로 둔다. sum > bestSum이면 두 값을 갱신한다. sum == bestSum이면 x > answer일 때만 answer를 갱신한다. 따라서 반복이 끝나면 조건을 만족하는 원래 수가 answer에 남는다.

예제 추적: [128, 460, 603, 40, 521, 137, 123]의 자릿수 합은 차례로 [11, 10, 9, 4, 8, 11, 6]이다. 128과 137이 합 11로 같으므로 더 큰 원래 수 137을 반환한다. 반환값은 자릿수 합 11이 아니다.

경계 확인: 최소 개수 입력 [1, 2, 3]은 3이다. [235, 1234, 22]와 순서를 바꾼 [1234, 235, 22]는 모두 1234이다. 최댓값이 포함된 [10,000,000, 9,999,999, 1]은 자릿수 합이 63인 9,999,999를 고른다. [10,000,000, 1,000,000, 1]은 합이 모두 1이므로 10,000,000을 고른다. 100개 입력과 중복 원소도 같은 비교 규칙으로 처리한다. 빈 배열, 0, 음수는 원문 입력 범위 밖이다.

복잡도: N은 입력 개수, D는 가장 긴 수의 십진 자릿수이다. 시간은 O(ND), 입력 배열을 제외한 추가 공간은 O(1)이다. 이 문제에서는 D ≤ 8이므로 입력 상한을 고정하면 시간은 O(N)으로도 표현할 수 있다. 별도의 자릿수 배열이나 정렬은 필요하지 않다.

C# 주의점: int끼리 나누면 정수 몫이 나오며, 양수에서 tmp /= 10은 자릿수 제거에 적합하다. 입력 상한과 자릿수 합은 32비트 int 범위 안이다. 배열은 참조형이지만 arr[i]를 대입하지 않아 원본이 보존된다. 표준 입력·출력과 Main은 별도의 실행 코드에서 담당한다. 검증 범위: 이 환경에는 C# 컴파일러·런타임이 없어 실행 검증은 하지 못했으며, 시그니처·타입·계산·동률 로직을 정적으로 검토했다.