작성 코드

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.StringTokenizer;

public class decrease_number {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());

        int n = Integer.parseInt(st.nextToken());

        List<Long> nums = new ArrayList<>();

        for (int i = 1; i <= 10; i++){
            List<List<Integer>> combinations = new ArrayList<>();
            generateCombinations(combinations, new ArrayList<>(), 0, 10, i);

            for (List<Integer> combination : combinations) {
                Collections.sort(combination, Collections.reverseOrder());
                StringBuilder sb = new StringBuilder();
                for (int num : combination) {
                    sb.append(num);
                }
                nums.add(Long.parseLong(sb.toString()));
            }
        }

        Collections.sort(nums);

        try {
            System.out.println(nums.get(n));
        } catch (NumberFormatException e) {
            System.out.println(-1);
        }
    }

    public static void generateCombinations(List<List<Integer>> combinations, List<Integer> current, int start, int n, int r) {
        if (r==0) {
            combinations.add(new ArrayList<>(current));
            return;
        }

        for (int i = start; i < n; i++){
            current.add(i);
            generateCombinations(combinations, current, i+1,  n, r-1);
            current.remove(current.size()-1);
        }
    }

설명

위의 코드는 "감소하는 수"를 생성하는 로직을 구현한 것입니다. 아래는 코드의 로직을 리스트 형태로 설명한 것입니다.

1. main 메서드:

   • 입력을 받기 위해 BufferedReader와 StringTokenizer를 사용합니다.
   • 정수 n을 입력 받습니다.
   • 감소하는 수를 저장할 리스트 nums를 생성합니다.
   • 반복문을 사용하여 자릿수(i)를 1부터 10까지 순회합니다.
     - 조합을 생성하기 위한 빈 리스트 combinations를 생성합니다.
     - generateCombinations 메서드를 호출하여 감소하는 수를 생성하는 조합을 구합니다.
     - 각 조합을 내림차순으로 정렬합니다.
     - 조합을 숫자로 변환하여 nums 리스트에 추가합니다.
   • nums 리스트를 오름차순으로 정렬합니다.
   • n번째 감소하는 수를 출력합니다.
   • NumberFormatException 예외가 발생하면 -1을 출력합니다.

2. generateCombinations 메서드:

   • 재귀 호출을 사용하여 조합을 생성하는 메서드입니다.
   • combinations 리스트에 현재 조합(current)을 추가합니다.
   • 재귀 호출을 사용하여 다음 자리 숫자를 선택하고, 재귀적으로 조합을 생성합니다.
   • 재귀 호출이 끝나면 마지막에 추가한 숫자를 제거하여 이전 상태로 돌아갑니다.

자바스크립트

const readline = require("readline");

let n;

function generateCombinations(combinations, current, start, n, r) {
  if (r == 0) {
    combinations.push([...current]);
    return;
  }

  for (let i = start; i < n; i++) {
    current.push(i);
    generateCombinations(combinations, current, i + 1, n, r - 1);
    current.pop();
  }
}

readline
  .createInterface(process.stdin, process.stdout)
  .on("line", (line) => {
    n = parseInt(line);
  })
  .on("close", () => {
    let nums = [];

    for (let i = 1; i < 11; i++) {
      let combinations = [];
      generateCombinations(combinations, [], 0, 10, i);

      for (let combination of combinations) {
        const reverseCombination = combination.sort((a, b) => b - a);
        const num = parseInt(reverseCombination.join(""));
        nums.push(num);
      }
    }

    nums.sort((a, b) => a - b);

    if (n >= 0 && n < nums.length) {
      console.log(nums[n]);
    } else {
      console.log(-1);
    }
  });

파이썬

import sys
from itertools import combinations

input = sys.stdin.readline

n = int(input())

nums = []
for i in range(1, 11):
    for comb in combinations(range(0, 10), i):
        comb = list(comb)
        comb.sort(reverse=True)
        nums.append(int("".join(map(str, comb))))
        
nums.sort()

try:
    print(nums[n])
except:
    print(-1)