$$config title: 문제 keywords: - IT $$ # 문제 1-1 ```java import java.util.Scanner; import java.util.stream.IntStream; public class Main { public static void main(String[] args) { AppContext.init(); // 앱에 필요한 의존성들을 생성 new App().run(); // 앱 실행 AppContext.destroy(); // 앱에 필요한 의존성들을 해제 } } class AppContext { public static Scanner sc; public static void init() { sc = new Scanner(System.in); // 의존성 생성 } public static void destroy() { sc.close(); } } class App { public void run() { // 1단계 : 숫자 5개를 입력받는다. inputNumbersAndSum(5); } private void inputNumbersAndSum(int count) { int sum = IntStream.range(1, count) .map(this::inputNumber) .sum(); System.out.printf("총합 : %d\n", sum); } protected int inputNumber(int no) { while (true) { System.out.printf("숫자 %d 입력 : ", no); try { return Integer.parseInt(AppContext.sc.nextLine()); } catch (NumberFormatException e) { System.err.println("[입력오류] : 정수만 입력가능합니다. 다시 입력해주세요."); } } } } ``` # 문제 1-3 ```java import java.util.Arrays; import java.util.List; import java.util.Scanner; import java.util.stream.Collectors; public class Main { public static void main(String[] args) { AppContext.init(); // 앱에 필요한 의존성들을 생성 new App().run(); // 앱 실행 AppContext.destroy(); // 앱에 필요한 의존성들을 해제 } } class AppContext { public static Scanner sc; public static void init() { sc = new Scanner(System.in); // 의존성 생성 } public static void destroy() { sc.close(); } } class App { public void run() { // 1단계 숫자들을 입력받는다. List numbers = inputNumbers(); // 2단계 초기 증가폭을 구한다. int initialDiff = calcInitialDiff(numbers); // 3단계 증가폭이 일정한지 검증한다. assertLinear(initialDiff, numbers); } /** * 1단계 **/ private List inputNumbers() { List numbers = null; while (true) { System.out.printf("숫자들을 띄워쓰기를 기준으로 여러개 입력 : "); String input = AppContext.sc.nextLine(); try { numbers = Arrays .stream(input.split(" ")) .map(String::trim) .mapToInt(Integer::parseInt) .boxed() .collect(Collectors.toList()); } catch (NumberFormatException e) { System.err.println("[입력오류] : 정수만 입력가능합니다. 다시 입력해주세요."); continue; } if (numbers.size() < 2) { System.err.println("[입력오류] : 숫자를 2개이상 입력해주세요."); continue; } break; } return numbers; } /** * 2단계 **/ private int calcInitialDiff(List numbers) { return numbers.get(1) - numbers.get(0); } /** * 3단계 **/ private void assertLinear(int initialDiff, List numbers) { for (int i = 2; i < numbers.size(); i++) { if (initialDiff != numbers.get(i) - numbers.get(i - 1)) { System.err.println("결과 : 증가폭이 일정하지 않습니다."); return; } } System.out.printf("증가폭 : %d\n", initialDiff); } } ``` # 하하 ```java import java.util.Arrays; import java.util.List; import java.util.Scanner; import java.util.stream.Collector; import java.util.stream.IntStream; public class Main { public static void main(String[] args) { AppContext.init(); // 앱에 필요한 의존성들을 생성 new App().run(); // 앱 실행 AppContext.destroy(); // 앱에 필요한 의존성들을 해제 } } class AppContext { public static Scanner sc; public static void init() { sc = new Scanner(System.in); // 의존성 생성 } public static void destroy() { sc.close(); } } class App { public void run() { long input = inputNumber(); String hanWon = toHanWon(input); System.out.println("금액 ￦ : " + hanWon + "(원)"); } private String toHanWon(long input) { final List inputBits = Arrays.asList(splitBy4(input)); return IntStream.range(0, inputBits.size()) .mapToObj(index -> toHanWonUnitType1(inputBits.get(index), index)) .collect(Util.stream.joiningReversed()); } private String toHanWonUnitType2(String input) { String result = IntStream.range(0, input.length()) .mapToObj(index -> toHanWonUnitType2(input.charAt(index), index)) .collect(Util.stream.joiningReversed()); return result; } private String toHanWonUnitType1(String c, int index) { String unit = ""; switch (index) { case 5: unit = "해 "; break; case 4: unit = "경 "; break; case 3: unit = "조 "; break; case 2: unit = "억 "; break; case 1: unit = "만 "; break; } return toHanWonUnitType2(c) + unit; } private String toHanWonUnitType2(char c, int index) { if (c == '0') return ""; String hanWon = ""; switch (c) { case '1': hanWon = index == 0 ? "일" : ""; break; case '2': hanWon = "이"; break; case '3': hanWon = "삼"; break; case '4': hanWon = "사"; break; case '5': hanWon = "오"; break; case '6': hanWon = "육"; break; case '7': hanWon = "칠"; break; case '8': hanWon = "팔"; break; case '9': hanWon = "구"; break; } String unit = ""; switch (index) { case 3: unit = "천"; break; case 2: unit = "백"; break; case 1: unit = "십"; break; } return hanWon + unit; } private String[] splitBy4(long input) { String inputStr = Util.str.toReverse(input + ""); String[] inputStrBits = Util.str.splitStringEveryNthChar(inputStr, 4); return inputStrBits; } protected long inputNumber() { while (true) { System.out.printf("숫자 : "); try { return Long.parseLong(AppContext.sc.nextLine()); } catch (NumberFormatException e) { System.out.println("[입력오류] : 정수만 입력가능합니다. 다시 입력해주세요."); } } } } class Util { public static class stream { public static Collector joiningReversed() { return joiningReversed("", "", ""); } public static Collector joiningReversed(CharSequence delimiter) { return joiningReversed(delimiter, "", ""); } public static Collector joiningReversed(CharSequence delimiter, CharSequence prefix, CharSequence suffix) { return Collector.of( StringBuilder::new, (sb, item) -> { if (sb.length() != 0) { sb.insert(0, delimiter); } sb.insert(0, item); }, (a, b) -> { throw new UnsupportedOperationException(); }, sb -> sb.insert(0, prefix).append(suffix).toString()); } } public static class str { public static String toReverse(String text) { return new StringBuilder(text).reverse().toString(); } public static String[] splitStringEveryNthChar(String text, long n) { return text.split("(?<=\\G.{" + n + "})"); } } } ```