์ถ์ฒ : https://www.youtube.com/watch?v=2zjoKjt97vQ&list=PLRx0vPvlEmdAghTr5mXQxGpHjWqSz0dgC&index=2
์ผ๋ฐ์ ์ธ ์ํฉ์์ ๊ทธ๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ์ ์ต์ ์ ํด๋ฅผ ๋ณด์ฅํ ์ ์์ ๋๊ฐ ๋ง๋ค. ํ์ง๋ง ์ฝ๋ฉ ํ ์คํธ์์์ ๋๋ถ๋ถ์ ๊ทธ๋ฆฌ๋ ๋ฌธ์ ๋
ํ์๋ฒ์ผ๋ก ์ป์ ํด๊ฐ ์ต์ ์ ํด๊ฐ ๋๋ ์ํฉ
์์, ์ด๋ฅผ ์ถ๋ก ํ ์ ์์ด์ผ ํ๋ฆฌ๋๋ก ์ถ์ ๋๋ค.
์ต์ ์ ํด๋ฅผ ๋น ๋ฅด๊ฒ ๊ตฌํ๊ธฐ ์ํด์๋ ๊ฐ์ฅ ํฐ ํํ ๋จ์
๋ถํฐ ๋์ ๊ฑฐ์ฌ๋ฌ ์ฃผ๋ฉด ๋ฉ๋๋ค.
โ๐ป N์์ ๊ฑฐ์ฌ๋ฌ ์ค์ผ ํ ๋, ๊ฐ์ฅ ๋จผ์ 500์์ผ๋ก ๊ฑฐ์ฌ๋ฌ ์ค ์ ์์ ๋งํผ ๊ฑฐ์ฌ๋ฌ ์ค๋๋ค.
โ๐ป ์ดํ์ 100์, 50์, 10์์ง๋ฆฌ ๋์ ์ ์ฐจ๋ก๋๋ก ๊ฑฐ์ฌ๋ฌ ์ค ์ ์์ ๋งํผ ๊ฑฐ์ฌ๋ฌ ์ฃผ๋ฉด ๋ฉ๋๋ค.
์ด๋ป๊ฒ ์ต์ ์ ํด๋ฅผ ๋ณด์ฅํ ์ ์์๊น?
โ
ํฐ ๋จ์๊ฐ ํญ์ ์์ ๋จ์์ ๋ฐฐ์
์ด๋ฏ๋ก ์์ ๋จ์์ ๋์ ๋ค์ ์ข
ํฉํด ๋ค๋ฅธ ํด๊ฐ ๋์ฌ ์ ์๊ธฐ ๋๋ฌธ
๋ง์ฝ, 800์์ ๊ฑฐ์ฌ๋ฌ ์ฃผ์ด์ผ ํ๋๋ฐ ํํ ๋จ์๊ฐ 500์, 400์, 100์์ด๋ผ๋ฉด ์ผ๋ฐ์ ์ผ๋ก๋ 500์ 1๊ฐ, 100์ 3๊ฐ๋ฅผ ๊ฑฐ์ฌ๋ฌ์ฃผ๊ฒ ์ง๋ง ๊ทธ๋ฆฌ๋๋ฅผ ์ฌ์ฉํ๋ฉด 400์์ง๋ฆฌ 2๊ฐ๋ฅผ ์ค์ผํ๋ ๊ฒ์ด๋ค. ์ด๋ฌํ ๋ฌธ์ ๋ 500์์ง๋ฆฌ๊ฐ 400์์ ๋ฐฐ์๊ฐ ์๋๊ธฐ ๋๋ฌธ์ ๋ฐ์ํ๋ค.
๐๐ป N = 1,260์ผ ๋์ ์์๋ฅผ ํ์ธํด ๋ณด์
python
n = 1260 count = 0 # ํฐ ๋จ์์ ํํ๋ถํฐ ์ฐจ๋ก๋๋ก ํ์ธํ๊ธฐ coin_types = [500, 100, 50, 10] for coin in coin_types: count += n // coin # ํด๋น ํํ๋ก ๊ฑฐ์ฌ๋ฌ ์ค ์ ์๋ ๋์ ์ ๊ฐ์ ์ธ๊ธฐ n %= coin print(count)
Java
public class Main { public static void main(String[] args) { int n = 1260; int cnt = 0; int[] coinTypes = {500, 100, 50, 10}; for (int i = 0; i < 4; i++) { int coin = coinTypes[i]; cnt += n / coin; n %= coin; } System.out.println(cnt); } }
๐คฏ ์๊ฐ ๋ณต์ก๋ ๋ถ์
โ
ํํ์ ์ข
๋ฅ๊ฐ K๋ผ๊ณ ํ ๋, ์์ค์ฝ๋์ ์๊ฐ ๋ณต์ก๋๋ O(K)
์ด๋ค.
โ
์ด ์๊ณ ๋ฆฌ์ฆ์ ์๊ฐ ๋ณต์ก๋๋ ๊ฑฐ์ฌ๋ฌ์ค์ผ ํ๋ ๊ธ์ก๊ณผ๋ ๋ฌด๊ดํ๋ฉฐ, ๋์ ์ ์ด ์ข
๋ฅ
์๋ง ์ํฅ์ ๋ฐ์ต๋๋ค.
์ฃผ์ด์ง N์ ๋ํ์ฌ ์ต๋ํ ๋ง์ด ๋๋๊ธฐ
๋ฅผ ์ํํ๋ฉด ๋ฉ๋๋ค.
N์ ๊ฐ์ ์ค์ผ ๋ 2 ์ด์์ ์๋ก ๋๋๋ ์์ ์ด 1์ ๋นผ๋ ์์ ๋ณด๋ค ์๋ฅผ ํจ์ฌ ๋ง์ด ์ค์ผ ์ ์์ต๋๋ค.
๊ฐ๋ฅํ๋ฉด ์ต๋ํ ๋ง์ด ๋๋๋ ์์
์ด ์ด๋ป๊ฒ ์ต์ ์ ํด๋ฅผ ๋ณด์ฅํ ์ ์์๊น?
โ
N์ด ์๋ฌด๋ฆฌ ํฐ ์์ฌ๋, K๋ก ๊ณ์ ๋๋๋ค๋ฉด ๊ธฐํ๊ธ์์
์ผ๋ก ๋น ๋ฅด๊ฒ ์ค์ผ ์ ์์ต๋๋ค. ๋ค์ ๋งํด K๊ฐ 2 ์ด์์ด๊ธฐ๋ง ํ๋ฉด, K๋ก ๋๋๋ ๊ฒ์ด 1์ ๋นผ๋ ๊ฒ๋ณด๋ค ํญ์ ๋น ๋ฅด๊ฒ N์ ์ค์ผ ์ ์์ต๋๋ค. ๋ํ N์ ํญ์ 1์ ๋๋ฌํ๊ฒ ๋ฉ๋๋ค. (์ต์ ์ ํด ์ฑ๋ฆฝ)
python
# N, K๊ณต๋ฐฑ์ ๊ธฐ์ค์ผ๋ก ๊ตฌ๋ถํ์ฌ ์ ๋ ฅ ๋ฐ๊ธฐ n, k = map(int, input().split()) result = 0 while True: # N์ด K๋ก ๋๋์ด ๋จ์ด์ง๋ ์๊ฐ ๋ ๋๊น์ง๋ง 1์ฉ ๋นผ๊ธฐ # ์ฆ 1์ ๋ช ๋ฒ ๋นผ์ผํ ์ง ๊ณ์ฐ target = (n // k) * k result += (n - target) n = target # N์ด K๋ณด๋ค ์์ ๋ (๋ ์ด์ ๋๋ ์ ์์ ๋) ๋ฐ๋ณต๋ฌธ ํ์ถ if n < k: break # K๋ก ๋๋๊ธฐ result += 1 n //= k # ๋ง์ง๋ง์ผ๋ก ๋จ์ ์์ ๋ํ์ฌ 1์ฉ ๋นผ๊ธฐ result += (n - 1) print(result)
Java
import java.util.*; public class Main { public static void main(String[] args) { Scanner sc = new Scanner(System.in); // N, K๋ฅผ ๊ณต๋ฐฑ์ ๊ธฐ์ค์ผ๋ก ๊ตฌ๋ถํ์ฌ ์ ๋ ฅ ๋ฐ๊ธฐ int n = sc.nextInt(); int k = sc.nextInt(); int result = 0; while (true) { // N์ด K๋ก ๋๋์ด ๋จ์ด์ง๋ ์๊ฐ ๋ ๋๊น์ง๋ง 1์ฉ ๋นผ๊ธฐ int target = (n / k) * k; result += (n - target); n = target; // N์ด K๋ณด๋ค ์์ ๋ (๋ ์ด์ ๋๋ ์ ์์ ๋) ๋ฐ๋ณต๋ฌธ ํ์ถ if (n < k) break; // K๋ก ๋๋๊ธฐ result += 1; n /= k; } // ๋ง์ง๋ง์ผ๋ก ๋จ์ ์์ ๋ํ์ฌ 1์ฉ ๋นผ๊ธฐ result += (n - 1); System.out.println(result); } }
๋ ์ ์ค์์ ํ๋๋ผ๋ 1 ์ดํ์ธ ๊ฒฝ์ฐ์๋ ๋ํ๋ฉฐ, ๋ ์๊ฐ ๋ชจ๋ 2 ์ด์์ธ ๊ฒฝ์ฐ์๋ ๊ณฑํ๋ฉด ๋ฉ๋๋ค.
๋๋ถ๋ถ์ ๊ฒฝ์ฐ +
๋ณด๋ค๋ X
๊ฐ ๋ ๊ฐ์ ํฌ๊ฒ ๋ง๋ญ๋๋ค.
์๋ฅผ ๋ค์ด 5 + 6 = 11์ด๊ณ , 5 x 6 = 30์
๋๋ค. ๋ค๋ง ๋ ์ ์ค์์ ํ๋๋ผ๋ 0 ํน์ 1
์ธ ๊ฒฝ์ฐ, ๊ณฑํ๊ธฐ๋ณด๋ค๋ ๋ํ๊ธฐ๋ฅผ ์ํํ๋ ๊ฒ์ด ํจ์จ์ ์
๋๋ค.
๊ฐ๋ฅํ๋ฉด ์ต๋ํ ๋ง์ด ๋๋๋ ์์
์ด ์ด๋ป๊ฒ ์ต์ ์ ํด๋ฅผ ๋ณด์ฅํ ์ ์์๊น?
โ
N์ด ์๋ฌด๋ฆฌ ํฐ ์์ฌ๋, K๋ก ๊ณ์ ๋๋๋ค๋ฉด ๊ธฐํ๊ธ์์
์ผ๋ก ๋น ๋ฅด๊ฒ ์ค์ผ ์ ์์ต๋๋ค. ๋ค์ ๋งํด K๊ฐ 2 ์ด์์ด๊ธฐ๋ง ํ๋ฉด, K๋ก ๋๋๋ ๊ฒ์ด 1์ ๋นผ๋ ๊ฒ๋ณด๋ค ํญ์ ๋น ๋ฅด๊ฒ N์ ์ค์ผ ์ ์์ต๋๋ค. ๋ํ N์ ํญ์ 1์ ๋๋ฌํ๊ฒ ๋ฉ๋๋ค. (์ต์ ์ ํด ์ฑ๋ฆฝ)
python
data = input() # ์ฒซ ๋ฒ์งธ ๋ฌธ์๋ฅผ ์ซ์๋ก ๋ณ๊ฒฝํ์ฌ ๋์ result = int(data[0]) for i in range(1, len(data)): # ๋ ์ ์ค์์ ํ๋๋ผ๋ '0' ํน์ '1'์ธ ๊ฒฝ์ฐ, ๊ณฑํ๊ธฐ๋ณด๋ค๋ ๋ํ๊ธฐ ์ํ num = int(data[i]) if num <= 1 or result <= 1: result += num else: result *= num print(result)
Java
import java.util.*; public class Main { public static void main(String[] args) { Scanner sc = new Scanner(System.in); String str = sc.next(); //์ฒซ ๋ฒ์งธ ๋ฌธ์๋ฅผ ์ซ์๋ก ๋ณ๊ฒฝํ ๊ฐ์ ๋์ long result = str.charAt(0) - '0'; for (int i = 1; i < str.length(); i++) { // ๋ ์ ์ค์์ ํ๋๋ผ๋ 0' ํน์ 1'์ธ ๊ฒฝ์ฐ, ๊ณฑํ๊ธฐ๋ณด๋ค๋ ๋ํ๊ธฐ ์ํ int num = str.charAt(i) - '0'; if (num <= 1 || result <= 1) { result += num; } else { result *= num; } } System.out.println(result); } }
์ค๋ฆ์ฐจ์ ์ ๋ ฌ ์ดํ์ ๊ณตํฌ๋๊ฐ ๊ฐ์ฅ ๋ฎ์ ๋ชจํ๊ฐ๋ถํฐ ํ๋์ฉ ํ์ธํ๋ฉด ๋๋ค.
python
n = int(input()) data = list(map(int, input().split())) data.sort() result = 0 # ์ด ๊ทธ๋ฃน์ ์ count = 0 # ํ์ฌ ๊ทธ๋ฃน์ ํฌํจ๋ ๋ชจํ๊ฐ์ ์ for i in data: # ๊ณตํฌ๋๋ฅผ ๋ฎ์ ๊ฒ๋ถํฐ ํ๋์ฉ ํ์ธํ๋ฉฐ count += 1 # ํ์ฌ ๊ทธ๋ฃน์ ํด๋น ๋ชจํ๊ฐ๋ฅผ ํฌํจ์ํค๊ธฐ if count >= i: # ํ์ฌ ๊ทธ๋ฃน์ ํฌํจ๋ ๋ชจํ๊ฐ์ ์๊ฐ ํ์ฌ์ ๊ณตํฌ๋ ์ด์์ด๋ผ๋ฉด, ๊ทธ๋ฃน ๊ฒฐ์ฑ result += 1 # ์ด ๊ทธ๋ฃน์ ์ ์ฆ๊ฐ์ํค๊ธฐ count = 0 # ํ์ฌ ๊ทธ๋ฃน์ ํฌํจ๋ ๋ชจํ๊ฐ์ ์ ์ด๊ธฐํ print(result) # ์ด ๊ทธ๋ฃน์ ์ ์ถ๋ ฅ
Java
import java.util.*; public class Main { public static int n; public static ArrayList<Integer> arrayList = new ArrayList<>(); public static void main(String[] args) { Scanner sc = new Scanner(System.in); n = sc.nextInt(); for (int i = 0; i < n; i++) { arrayList.add(sc.nextInt()); } Collections.sort(arrayList); int result = 0; // ์ด ๊ทธ๋ฃน์ ์ int count = 0; // ํ์ฌ ๊ทธ๋ฃน์ ํฌํจ๋ ๋ชจํ๊ฐ์ ์ for (int i = 0; i < n; i++) { // ๊ณตํฌ๋๋ฅผ ๋ฎ์ ๊ฒ๋ถํฐ ํ๋์ฉ ํ์ธํ๋ฉฐ count += 1; // ํ์ฌ ๊ทธ๋ฃน์ ํด๋น ๋ชจํ๊ฐ๋ฅผ ํฌํจ์ํค๊ธฐ if (count >= arrayList.get(i)) { // ํ์ฌ ๊ทธ๋ฃน์ ํฌํจ๋ ๋ชจํ๊ฐ์ ์๊ฐ ํ์ฌ์ ๊ณตํฌ๋ ์ด์์ด๋ผ๋ฉด, ๊ทธ๋ฃน ๊ฒฐ์ฑ result += 1; // ์ด ๊ทธ๋ฃน์ ์ ์ฆ๊ฐ์ํค๊ธฐ count = 0; // ํ์ฌ ๊ทธ๋ฃน์ ํฌํจ๋ ๋ชจํ๊ฐ์ ์ ์ด๊ธฐํ } } System.out.println(result); } }
์ผ๋ฐ์ ์ผ๋ก ์๊ณ ๋ฆฌ์ฆ
๋ฌธ์ ์์์ 2์ฐจ์ ๊ณต๊ฐ์ ํ๋ ฌ(Matrix)
์ ์๋ฏธ๋ก ์ฌ์ฉ๋๋ค.
์๋ฎฌ๋ ์ด์
๋ฐ ์์ ํ์
๋ฌธ์ ์์๋ 2์ฐจ์ ๊ณต๊ฐ์์์ ๋ฐฉํฅ ๋ฒกํฐ
๊ฐ ์์ฃผ ํ์ฉ๋๋ค. ์ฌ๊ธฐ์ x๋ ์ธ๋ก์ถ
์, y๋ ๊ฐ๋ก์ถ
์ ์๋ฏธํ๋ค.
python
# N ์ ๋ ฅ๋ฐ๊ธฐ n = int(input()) x, y = 1, 1 plans = input().split() # L, R, U, D์ ๋ฐ๋ฅธ ์ด๋ ๋ฐฉํฅ dx = [0, 0, -1, 1] dy = [-1, 1, 0, 0] move_types = ['L', 'R', 'U', 'D'] # ์ด๋ ๊ณํ์ ํ๋์ฉ ํ์ธ for plan in plans: # ์ด๋ ํ ์ขํ ๊ตฌํ๊ธฐ for i in range(len(move_types)): if plan == move_types[i]: nx = x + dx[i] ny = y + dy[i] # ๊ณต๊ฐ์ ๋ฒ์ด๋๋ ๊ฒฝ์ฐ ๋ฌด์ if nx < 1 or ny < 1 or nx > n or ny > n: continue # ์ด๋ ์ํ x, y = nx, ny print(x, y)
Java
import java.util.*; public class Main { public static void main(String[] args) { Scanner sc = new Scanner(System.in); // N์ ์ ๋ ฅ๋ฐ๊ธฐ int n = sc.nextInt(); sc.nextLine(); // ๋ฒํผ ๋น์ฐ๊ธฐ String[] plans = sc.nextLine().split(" "); int x = 1, y = 1; // L, R, U, D์ ๋ฐ๋ฅธ ์ด๋ ๋ฐฉํฅ int[] dx = {0, 0, -1, 1}; int[] dy = {-1, 1, 0, 0}; char[] moveTypes = {'L', 'R', 'U', 'D'}; // ์ด๋ ๊ณํ์ ํ๋์ฉ ํ์ธ for (int i = 0; i < plans.length; i++) { char plan = plans[i].charAt(0); // ์ด๋ ํ ์ขํ ๊ตฌํ๊ธฐ int nx = -1, ny = -1; for (int j = 0; j < 4; j++) { if (plan == moveTypes[j]) { nx = x + dx[j]; ny = y + dy[j]; } } // ๊ณต๊ฐ์ ๋ฒ์ด๋๋ ๊ฒฝ์ฐ ๋ฌด์ if (nx < 1 || ny < 1 || nx > n || ny > n) continue; // ์ด๋ ์ํ x = nx; y = ny; } System.out.println(x + " " + y); } }
์ด ๋ฌธ์ ๋ ๊ฐ๋ฅํ ๋ชจ๋ ์๊ฐ์ ๊ฒฝ์ฐ๋ฅผ ํ๋์ฉ ๋ชจ๋ ์ธ์ ํ ์ ์๋ ๋ฌธ์ ์ด๋ค.
(ํ์ด์ฌ์ 1์ด์ 2000๋ง๋ฒ ์ ๋์ ์ฐ์ฐ์ ํ ์ ์๋ค๊ณ ๊ฐ์ ํ๊ณ ํ๊ธฐ)
์ด๋ฌํ ์ ํ์ ์์ ํ์(Brute Forcing)
๋ฌธ์ ์ ํ์ด๋ผ๊ณ ๋ถ๋ฅด๋ฉฐ, ๊ฐ๋ฅํ ๊ฒฝ์ฐ์ ์๋ฅผ ๋ชจ๋ ๊ฒ์ฌํด๋ณด๋ ํ์ ๋ฐฉ๋ฒ์ ์๋ฏธํ๋ค.
python
# H๋ฅผ ์ ๋ ฅ๋ฐ๊ธฐ h = int(input()) count = 0 for i in range(h + 1): for j in range(60): for k in range(60): # ๋งค ์๊ฐ ์์ '3'์ด ํฌํจ๋์ด ์๋ค๋ฉด ์นด์ดํธ ์ฆ๊ฐ if '3' in str(i) + str(j) + str(k): count += 1 print(count)
Java
import java.util.*; public class Main { // ํน์ ํ ์๊ฐ ์์ '3'์ด ํฌํจ๋์ด ์๋์ง์ ์ฌ๋ถ public static boolean check(int h, int m, int s) { if (h % 10 == 3 || m / 10 == 3 || m % 10 == 3 || s / 10 == 3 || s % 10 == 3) return true; return false; } public static void main(String[] args) { Scanner sc = new Scanner(System.in); // H๋ฅผ ์ ๋ ฅ๋ฐ๊ธฐ int h = sc.nextInt(); int cnt = 0; for (int i = 0; i <= h; i++) { for (int j = 0; j < 60; j++) { for (int k = 0; k < 60; k++) { // ๋งค ์๊ฐ ์์ '3'์ด ํฌํจ๋์ด ์๋ค๋ฉด ์นด์ดํธ ์ฆ๊ฐ if (check(i, j, k)) cnt++; } } } System.out.println(cnt); } }
์๊ตฌ์ฌํญ๋๋ก ์ถฉ์คํ ๊ตฌํํ๋ฉด ๋๋ ๋ฌธ์
๋์ดํธ์ 8๊ฐ์ง ๊ฒฝ๋ก๋ฅผ ํ๋์ฉ ํ์ธํ๋ฉฐ ๊ฐ ์์น๋ก ์ด๋์ด ๊ฐ๋ฅํ์ง ํ์ธํ๊ณ , ๋ฆฌ์คํธ๋ฅผ ์ด์ฉํ์ฌ 8๊ฐ์ง ๋ฐฉํฅ์ ๋ํ ๋ฐฉํฅ ๋ฒกํฐ
๋ฅผ ์ ์ํฉ๋๋ค.
python
# ํ์ฌ ๋์ดํธ์ ์์น ์ ๋ ฅ๋ฐ๊ธฐ input_data = input() row = int(input_data[1]) column = int(ord(input_data[0])) - int(ord('a')) + 1 # ๋์ดํธ๊ฐ ์ด๋ํ ์ ์๋ 8๊ฐ์ง ๋ฐฉํฅ ์ ์ steps = [(-2, -1), (-1, -2), (1, -2), (2, -1), (2, 1), (1, 2), (-1, 2), (-2, 1)] # 8๊ฐ์ง ๋ฐฉํฅ์ ๋ํ์ฌ ๊ฐ ์์น๋ก ์ด๋์ด ๊ฐ๋ฅํ์ง ํ์ธ result = 0 for step in steps: # ์ด๋ํ๊ณ ์ ํ๋ ์์น ํ์ธ next_row = row + step[0] next_column = column + step[1] # ํด๋น ์์น๋ก ์ด๋์ด ๊ฐ๋ฅํ๋ค๋ฉด ์นด์ดํธ ์ฆ๊ฐ if next_row >= 1 and next_row <= 8 and next_column >= 1 and next_column <= 8: result += 1 print(result)
Java
import java.util.*; public class Main { public static void main(String[] args) { Scanner sc = new Scanner(System.in); // ํ์ฌ ๋์ดํธ์ ์์น ์ ๋ ฅ๋ฐ๊ธฐ String inputData = sc.nextLine(); int row = inputData.charAt(1) - '0'; int column = inputData.charAt(0) - 'a' + 1; // ๋์ดํธ๊ฐ ์ด๋ํ ์ ์๋ 8๊ฐ์ง ๋ฐฉํฅ ์ ์ int[] dx = {-2, -1, 1, 2, 2, 1, -1, -2}; int[] dy = {-1, -2, -2, -1, 1, 2, 2, 1}; // 8๊ฐ์ง ๋ฐฉํฅ์ ๋ํ์ฌ ๊ฐ ์์น๋ก ์ด๋์ด ๊ฐ๋ฅํ์ง ํ์ธ int result = 0; for (int i = 0; i < 8; i++) { // ์ด๋ํ๊ณ ์ ํ๋ ์์น ํ์ธ int nextRow = row + dx[i]; int nextColumn = column + dy[i]; // ํด๋น ์์น๋ก ์ด๋์ด ๊ฐ๋ฅํ๋ค๋ฉด ์นด์ดํธ ์ฆ๊ฐ if (nextRow >= 1 && nextRow <= 8 && nextColumn >= 1 && nextColumn <= 8) { result += 1; } } System.out.println(result); } }
์๊ตฌ์ฌํญ๋๋ก ์ถฉ์คํ ๊ตฌํํ๋ฉด ๋๋ ๋ฌธ์
๋ฌธ์์ด์ด ์
๋ ฅ๋์์ ๋ ๋ฌธ์๋ฅผ ํ๋์ฉ ํ์ธํฉ๋๋ค.
โ
์ซ์์ธ ๊ฒฝ์ฐ ๋ฐ๋ก ํฉ๊ณ๋ฅผ ๊ณ์ฐํฉ๋๋ค.
โ
์ํ๋ฒณ์ ๊ฒฝ์ฐ ๋ณ๋์ ๋ฆฌ์คํธ์ ์ ์ฅํฉ๋๋ค.
๊ฒฐ๊ณผ์ ์ผ๋ก ๋ฆฌ์คํธ์ ์ ์ฅ๋ ์ํ๋ฒณ์ ์ ๋ ฌํด ์ถ๋ ฅํ๊ณ , ํฉ๊ณ๋ฅผ ๋ค์ ๋ถ์ฌ ์ถ๋ ฅํ๋ฉด ์ ๋ต ๐ค
python
data = input() result = [] value = 0 # ๋ฌธ์๋ฅผ ํ๋์ฉ ํ์ธํ๋ฉฐ for x in data: # ์ํ๋ฒณ์ธ ๊ฒฝ์ฐ ๊ฒฐ๊ณผ ๋ฆฌ์คํธ์ ์ฝ์ if x.isalpha(): result.append(x) # ์ซ์๋ ๋ฐ๋ก ๋ํ๊ธฐ else: value += int(x) # ์ํ๋ฒณ์ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌ result.sort() # ์ซ์๊ฐ ํ๋๋ผ๋ ์กด์ฌํ๋ ๊ฒฝ์ฐ ๊ฐ์ฅ ๋ค์ ์ฝ์ if value != 0: result.append(str(value)) # ์ต์ข ๊ฒฐ๊ณผ ์ถ๋ ฅ(๋ฆฌ์คํธ๋ฅผ ๋ฌธ์์ด๋ก ๋ณํํ์ฌ ์ถ๋ ฅ) print(''.join(result))
Java
import java.util.*; public class Main { public static String str; public static ArrayList<Character> result = new ArrayList<Character>(); public static int value = 0; public static void main(String[] args) { Scanner sc = new Scanner(System.in); str = sc.next(); // ๋ฌธ์๋ฅผ ํ๋์ฉ ํ์ธํ๋ฉฐ for (int i = 0; i < str.length(); i++) { // ์ํ๋ฒณ์ธ ๊ฒฝ์ฐ ๊ฒฐ๊ณผ ๋ฆฌ์คํธ์ ์ฝ์ if (Character.isLetter(str.charAt(i))) { result.add(str.charAt(i)); } // ์ซ์๋ ๋ฐ๋ก ๋ํ๊ธฐ else { value += str.charAt(i) - '0'; } } // ์ํ๋ฒณ์ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌ Collections.sort(result); // ์ํ๋ฒณ์ ์ฐจ๋ก๋๋ก ์ถ๋ ฅ for (int i = 0; i < result.size(); i++) { System.out.print(result.get(i)); } // ์ซ์๊ฐ ํ๋๋ผ๋ ์กด์ฌํ๋ ๊ฒฝ์ฐ ๊ฐ์ฅ ๋ค์ ์ถ๋ ฅ if (value != 0) System.out.print(value); System.out.println(); } }