Algorithm
-
- [BOJ-1541][C++] ์์ด๋ฒ๋ฆฐ ๊ดํธ
๋ฌธ์ ์ธ์ค์ด๋ ์์์ +, -, ๊ทธ๋ฆฌ๊ณ ๊ดํธ๋ฅผ ๊ฐ์ง๊ณ ์์ ๋ง๋ค์๋ค. ๊ทธ๋ฆฌ๊ณ ๋์ ์ธ์ค์ด๋ ๊ดํธ๋ฅผ ๋ชจ๋ ์ง์ ๋ค. ๊ทธ๋ฆฌ๊ณ ๋์ ์ธ์ค์ด๋ ๊ดํธ๋ฅผ ์ ์ ํ ์ณ์ ์ด ์์ ๊ฐ์ ์ต์๋ก ๋ง๋ค๋ ค๊ณ ํ๋ค. ๊ดํธ๋ฅผ ์ ์ ํ ์ณ์ ์ด ์์ ๊ฐ์ ์ต์๋ก ๋ง๋๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค. ์ ๋ ฅ ์ฒซ์งธ ์ค์ ์์ด ์ฃผ์ด์ง๋ค. ์์ ‘0’~‘9’, ‘+’, ๊ทธ๋ฆฌ๊ณ ‘-’๋ง์ผ๋ก ์ด๋ฃจ์ด์ ธ ์๊ณ , ๊ฐ์ฅ ์ฒ์๊ณผ ๋ง์ง๋ง ๋ฌธ์๋ ์ซ์์ด๋ค. ๊ทธ๋ฆฌ๊ณ ์ฐ์ํด์ ๋ ๊ฐ ์ด์์ ์ฐ์ฐ์๊ฐ ๋ํ๋์ง ์๊ณ , 5์๋ฆฌ๋ณด๋ค ๋ง์ด ์ฐ์๋๋ ์ซ์๋ ์๋ค. ์๋ 0์ผ๋ก ์์ํ ์ ์๋ค. ์ ๋ ฅ์ผ๋ก ์ฃผ์ด์ง๋ ์์ ๊ธธ์ด๋ 50๋ณด๋ค ์๊ฑฐ๋ ๊ฐ๋ค. ์ถ๋ ฅ ์ฒซ์งธ ์ค์ ์ ๋ต์ ์ถ๋ ฅํ๋ค. ์์ ์ ๋ ฅ 1 55-50+40 ์์ ์ถ๋ ฅ 1 -35 ์์ ์ ๋ ฅ 2 10+20+30+40 ์์ ์ถ๋ ฅ 2..
2023.02.20 -
- [BOJ-2751][C++] ์ ์ ๋ ฌํ๊ธฐ 2
๋ฌธ์ N๊ฐ์ ์๊ฐ ์ฃผ์ด์ก์ ๋, ์ด๋ฅผ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค. ์ ๋ ฅ ์ฒซ์งธ ์ค์ ์์ ๊ฐ์ N(1 ≤ N ≤ 1,000,000)์ด ์ฃผ์ด์ง๋ค. ๋์งธ ์ค๋ถํฐ N๊ฐ์ ์ค์๋ ์๊ฐ ์ฃผ์ด์ง๋ค. ์ด ์๋ ์ ๋๊ฐ์ด 1,000,000๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ์ ์์ด๋ค. ์๋ ์ค๋ณต๋์ง ์๋๋ค. ์ถ๋ ฅ ์ฒซ์งธ ์ค๋ถํฐ N๊ฐ์ ์ค์ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํ ๊ฒฐ๊ณผ๋ฅผ ํ ์ค์ ํ๋์ฉ ์ถ๋ ฅํ๋ค. ์์ ์ ๋ ฅ 1 5 5 4 3 2 1 ์์ ์ถ๋ ฅ 1 1 2 3 4 5 ์๊ณ ๋ฆฌ์ฆ ๋ถ๋ฅ ์ ๋ ฌ ๋ฌธ์ ์ถ์ฒ https://www.acmicpc.net/problem/2751 2751๋ฒ: ์ ์ ๋ ฌํ๊ธฐ 2 ์ฒซ์งธ ์ค์ ์์ ๊ฐ์ N(1 ≤ N ≤ 1,000,000)์ด ์ฃผ์ด์ง๋ค. ๋์งธ ์ค๋ถํฐ N๊ฐ์ ์ค์๋ ์๊ฐ ์ฃผ์ด์ง๋ค. ์ด ์๋ ์ ๋๊ฐ์ด 1,000,00..
2023.02.04 -
- [BOJ-25305][C++] ์ปคํธ๋ผ์ธ
๋ฌธ์ 2022 ์ฐ์ธ๋ํ๊ต ๋ฏธ๋์บ ํผ์ค แแ ณแฏแแ ตแ แ ฉแแ ฎแซ แแ ฉแแ ตแผแแ ขแผแแ ชแฏ์ $N$๋ช ์ ํ์๋ค์ด ์์ํ๋ค. ์ด๋ค ์ค ์ ์๊ฐ ๊ฐ์ฅ ๋์ $k$๋ช ์ ์์ ๋ฐ์ ๊ฒ์ด๋ค. ์ด ๋, ์์ ๋ฐ๋ ์ปคํธ๋ผ์ธ์ด ๋ช ์ ์ธ์ง ๊ตฌํ๋ผ. ์ปคํธ๋ผ์ธ์ด๋ ์์ ๋ฐ๋ ์ฌ๋๋ค ์ค ์ ์๊ฐ ๊ฐ์ฅ ๊ฐ์ฅ ๋ฎ์ ์ฌ๋์ ์ ์๋ฅผ ๋งํ๋ค. ์ ๋ ฅ ์ฒซ์งธ ์ค์๋ ์์์์ ์ $N$๊ณผ ์์ ๋ฐ๋ ์ฌ๋์ ์ $k$๊ฐ ๊ณต๋ฐฑ์ ์ฌ์ด์ ๋๊ณ ์ฃผ์ด์ง๋ค. ๋์งธ ์ค์๋ ๊ฐ ํ์์ ์ ์ $x$๊ฐ ๊ณต๋ฐฑ์ ์ฌ์ด์ ๋๊ณ ์ฃผ์ด์ง๋ค. ์ถ๋ ฅ ์์ ๋ฐ๋ ์ปคํธ๋ผ์ธ์ ์ถ๋ ฅํ๋ผ. ์ ํ 1 ≤ N ≤ 1,000 1≤ k ≤ N 0 ≤ x ≤ 10,000 ์์ ์ ๋ ฅ 1 5 2 100 76 85 93 98 ์์ ์ถ๋ ฅ 1 98 ์ํ ์์์๋ค ๊ฐ์ด๋ฐ 1๋ฑ์ 100์ , 2๋ฑ์ 98์ , 3๋ฑ์ 93..
2023.02.04 -
- [BOJ-2587][C++] ๋ํ๊ฐ2
๋ฌธ์ ์ด๋ค ์๋ค์ด ์์ ๋, ๊ทธ ์๋ค์ ๋ํํ๋ ๊ฐ์ผ๋ก ๊ฐ์ฅ ํํ๊ฒ ์ฐ์ด๋ ๊ฒ์ ํ๊ท ์ด๋ค. ํ๊ท ์ ์ฃผ์ด์ง ๋ชจ๋ ์์ ํฉ์ ์์ ๊ฐ์๋ก ๋๋ ๊ฒ์ด๋ค. ์๋ฅผ ๋ค์ด 10, 40, 30, 60, 30์ ํ๊ท ์ (10 + 40 + 30 + 60 + 30) / 5 = 170 / 5 = 34๊ฐ ๋๋ค. ํ๊ท ์ด์ธ์ ๋ ๋ค๋ฅธ ๋ํ๊ฐ์ผ๋ก ์ค์๊ฐ์ด๋ผ๋ ๊ฒ์ด ์๋ค. ์ค์๊ฐ์ ์ฃผ์ด์ง ์๋ฅผ ํฌ๊ธฐ ์์๋๋ก ๋์ด ๋์์ ๋ ๊ฐ์ฅ ์ค์์ ๋์ธ ๊ฐ์ด๋ค. ์๋ฅผ ๋ค์ด 10, 40, 30, 60, 30์ ๊ฒฝ์ฐ, ํฌ๊ธฐ ์์๋๋ก ๋์ด ๋์ผ๋ฉด 10 30 30 40 60 ์ด ๋๊ณ ๋ฐ๋ผ์ ์ค์๊ฐ์ 30์ด ๋๋ค. ๋ค์ฏ ๊ฐ์ ์์ฐ์๊ฐ ์ฃผ์ด์ง ๋ ์ด๋ค์ ํ๊ท ๊ณผ ์ค์๊ฐ์ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค. ์ ๋ ฅ ์ฒซ์งธ ์ค๋ถํฐ ๋ค์ฏ ๋ฒ์งธ ์ค๊น์ง ํ ์ค์ ํ๋์ฉ ์์ฐ..
2023.02.04 -
- [BOJ-2750][C++] ์ ์ ๋ ฌํ๊ธฐ
๋ฌธ์ N๊ฐ์ ์๊ฐ ์ฃผ์ด์ก์ ๋, ์ด๋ฅผ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค. ์ ๋ ฅ ์ฒซ์งธ ์ค์ ์์ ๊ฐ์ N(1 ≤ N ≤ 1,000)์ด ์ฃผ์ด์ง๋ค. ๋์งธ ์ค๋ถํฐ N๊ฐ์ ์ค์๋ ์๊ฐ ์ฃผ์ด์ง๋ค. ์ด ์๋ ์ ๋๊ฐ์ด 1,000๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ์ ์์ด๋ค. ์๋ ์ค๋ณต๋์ง ์๋๋ค. ์ถ๋ ฅ ์ฒซ์งธ ์ค๋ถํฐ N๊ฐ์ ์ค์ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํ ๊ฒฐ๊ณผ๋ฅผ ํ ์ค์ ํ๋์ฉ ์ถ๋ ฅํ๋ค. ์์ ์ ๋ ฅ 1 5 5 2 3 4 1 ์์ ์ถ๋ ฅ 1 1 2 3 4 5 ์๊ณ ๋ฆฌ์ฆ ๋ถ๋ฅ ๊ตฌํ ์ ๋ ฌ ๋ฌธ์ ์ถ์ฒ https://www.acmicpc.net/problem/2750 2750๋ฒ: ์ ์ ๋ ฌํ๊ธฐ ์ฒซ์งธ ์ค์ ์์ ๊ฐ์ N(1 ≤ N ≤ 1,000)์ด ์ฃผ์ด์ง๋ค. ๋์งธ ์ค๋ถํฐ N๊ฐ์ ์ค์๋ ์๊ฐ ์ฃผ์ด์ง๋ค. ์ด ์๋ ์ ๋๊ฐ์ด 1,000๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ์ ์์ด๋ค..
2023.02.04 -
- [Algorithm] ๋ฐฑํธ๋ํน(Backtracking)
๋ฐฑํธ๋ํน(Backtracking) ๊ฐ๋ ๋ชจ๋ ๊ฒฝ์ฐ์ ์๋ฅผ ๊ณ ๋ คํ๋ ์๊ณ ๋ฆฌ์ฆ ์ํ ๊ณต๊ฐ์ ํธ๋ฆฌ(Tree)๋ก ๋ํ๋ผ ์ ์์ ๋ ์ ํฉํ ๋ฐฉ์์ด๋ค. ์ผ์ข ์ ํธ๋ฆฌ ํ์ ์๊ณ ๋ฆฌ์ฆ(Tree Search Algorithm)์ด๋ผ๊ณ ๋ด๋ ๋๋ค. ๋ฐฉ์์ ๋ฐ๋ฅธ ๋ถ๋ฅ ๊น์ด ์ฐ์ ํ์(Depth First Search, DFS) ๋๋น ์ฐ์ ํ์(Breadth First Search, BFS) ์ต์ ์ฐ์ ํ์(Best First Search / Heuristic Search) ๊ฒฝ์ฐ์ ์ ๊ตฌํ๊ธฐ๋ ์ผ๋ฐ์ ์ผ๋ก DFS๊ฐ ํธ๋ฆฌํ๋ฉฐ, ๋๋ค์์ ๋ฌธ์ ๋ค์ DFS๋ฅผ ์จ๋ ์ผ๋จ ๋ต์ ๋์จ๋ค. ํ์ง๋ง, ํธ๋ฆฌ์ ๊น์ด(Depth)๊ฐ ๋ฌดํ๋๊ฐ ๋ ๊ฒฝ์ฐ์๋ DFS๋ฅผ ์ฌ์ฉํ๋ฉด ์๋๋ค. ์) ๋ฏธ๋ก ์ฐพ๊ธฐ์์ ๋ฃจํ(ํ๋ก)๊ฐ ๋ฐ์ํ๋ ๊ฒฝ์ฐ, DFS๋ ์ด ๊ฐ์ง๋ฅผ ..
2022.11.16 -
- [Algorithm] ์ต๋ ๊ณต์ฝ์(GCD)์ ์ต์ ๊ณต๋ฐฐ์(LCM) ; ์ ํด๋ฆฌ๋ ํธ์ ๋ฒ(Euclidean Algorithm)
์ต๋ ๊ณต์ฝ์(GCD)์ ์ต์ ๊ณต๋ฐฐ์(LCM) ; ์ ํด๋ฆฌ๋ ํธ์ ๋ฒ(Euclidean Algorithm) ์ต๋ ๊ณต์ฝ์(GCD; Greatest Common Divisor(Factor)) ๋ ๊ฐ ์ด์์ ์์ฐ์๋ค์ ๊ณตํต์ธ ์ฝ์๋ค์ ๋ชจ์์ ๊ณต์ฝ์(Common Divisor)๋ผ๊ณ ํ๊ณ , ๊ณต์ฝ์ ์ค์์ ๊ฐ์ฅ ํฐ ์๋ฅผ ์ต๋ ๊ณต์ฝ์(Greatest Common Divisor)๋ผ๊ณ ํ๋ค. ์) $12$์ ์ฝ์๋ $\{1, 2, 3, 4, 6, 12\}$ ์ด๊ณ $18$์ ์ฝ์๋ $\{1, 2, 3, 6, 9, 18\}$์ผ ๋, ๋ ์ $12$์ $18$์ ๊ณต์ฝ์๋ $\{1, 2, 3, 6\}$์ด๊ณ ์ต๋ ๊ณต์ฝ์๋ $6$์ด ๋๋ค. ์ฝ๋ int gcd(int x, int y) { for (int i = (x > y ? y : x..
2022.11.13 -
- [C++] pair(ํ์ด)์ tuple(ํํ)
pair(ํ์ด)์ tuple(ํํ) pair(ํ์ด)๊ฐ๋ ์ฌ์ฉ์๊ฐ ์ง์ ํ 2๊ฐ์ ํ์ ์ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๊ธฐ ์ํด ์ฌ์ฉ๋๋ ํด๋์ค์๋ก ์ฐ๊ด๋ 2๊ฐ์ ๋ฐ์ดํฐ๋ฅผ ํ ์์ผ๋ก ๋ฌถ์ด์ ๋ค๋ฃฐ ๋ ์ฌ์ฉํ๋ฉด ํธ๋ฆฌํ๋ค.๊ตฌ์กฐ์ฒด(struct) ๋์ ํธ๋ฆฌํ๊ฒ 2๊ฐ์ ๋ฐ์ดํฐ๋ฅผ ๊ด๋ฆฌํ ์ ์๋ค. ํค๋ ํ์ผํ์ด(pair)๋ฅผ ์ฌ์ฉํ๋ ค๋ฉด ๋ค์์ ํค๋๋ฅผ ๋ถ๋ฌ์์ผ ํ๋ค.#include ํ์ง๋ง, , ํค๋๋ฅผ ์ฌ์ฉํ ๊ฒฝ์ฐ, ํค๋๊ฐ ํฌํจ๋์ด ์์ด ๋ฐ๋ก ๋ถ๋ฌ์ ์ฃผ์ง ์์๋ ๋๋ค.#include // ํค๋ ํฌํจ#include // ํค๋ ํฌํจ ํํํ์ด(pair)์ ํํ๋ ๋ค์๊ณผ ๊ฐ๋ค. template struct pair;T1์ ์ฒซ ๋ฒ์งธ ์ธ์๋ฅผ, T2์ ๋ ๋ฒ์งธ ์ธ์๋ฅผ ๋ฃ์ด์ฃผ๋ฉด ๋๋ค. ์ฌ์ฉ ๋ฐฉ๋ฒ์ด๊ธฐํ๋ค์๊ณผ ๊ฐ์ด ํ์ด(pair)๋ฅผ ์ด๊ธฐ..
2022.11.03 -
- [Algorithm] ๋ธ๋ฃจํธ ํฌ์ค(Brute Force)
๋ธ๋ฃจํธ ํฌ์ค(Brute Force) ๊ฐ๋ ๋ธ๋ฃจํธ(Brute)์ ํฌ์ค(Force)๊ฐ ๊ฒฐํฉ๋์ด ๋ง๋ค์ด์ง ๋จ์ด์ด๋ฉฐ, "๋ํญํ ํ(ํญ๋ ฅ)" ์ด๋ผ๋ ๋ป์ด๋ค. ๋ฌธ์ ํด๊ฒฐ์ ์ํด ์ค๋ ๊ฑธ๋ฆฌ๊ณ ์์์ด ๋ง์ด ๋ค์ด์ ๋ฌด์ํ๋ค๊ณ ์๊ฐ๋ ์๋ ์์ง๋ง, ํญ์ 100%์ ์ ํ์ฑ์ ๋ณด์ธ๋ค. ์ ๋ต(Solution)์ด ๋ฐ๊ฒฌ๋ ๋๊น์ง ๊ฐ๋ฅํ ๋ชจ๋ ์ ํ์ง๋ฅผ ์ฐพ๋ ๋ฐฉ๋ฒ์ด๋ค. ์) 4์๋ฆฌ ์ซ์์ ํจ์ค์๋๋ฅผ ์ฐพ๊ธฐ ์ํด 0000๋ถํฐ 9999๊น์ง ํ๋์ฉ ์ ๋ ฅํ์ฌ ์ฐพ์๋ณด๋ ๊ฒฝ์ฐ ๋ฐ๋ผ์ ๋ธ๋ฃจํธ ํฌ์ค ์๊ณ ๋ฆฌ์ฆ์ ์์ ํ์ ์๊ณ ๋ฆฌ์ฆ์ด๋ผ๊ณ ํ ์ ์๋ค. ๊ฐ๋จํ๊ณ ์ผ๊ด์ ์ด์ง๋ง, ๋งค์ฐ ๋๋ฆฌ๋ค๋ ๋จ์ ์ด ์๋ค. ๊ฑฐ์ ์๋ฒฝํ๊ฒ ๋ณ๋ ฌ ์์ ์ด ๊ฐ๋ฅํ์ฌ ๋ณ๋ ฌ ํ๋ก๊ทธ๋๋ฐ์์ ์ฌ์ฉ๋๋ค. ํจํด ๋งค์นญ(Pattern Matching) ๋ฑ์ ์์ ์ ์ฌ์ฉ๋ ์ ์๋ค. ๋๋น ์ฐ์ ํ..
2022.11.03 -
- [Algorithm] ํ๋ ธ์ด ํ(Tower of Hanoi)
ํ๋ ธ์ด ํ(Tower of Hanoi) ๊ฐ๋ ํ๋์ค์ ์ํ์ ์๋์๋ฅด ๋คผ์นด(François Édouard Anatole Lucas)๊ฐ 1883๋ ์๊ฐํ ์ ๋ช ํ ๋ฌธ์ ์ฌ๊ท(Recursion)๋ฅผ ์ฐ์ตํ๋๋ฐ ๋์์ด ๋๋ ์๊ณ ๋ฆฌ์ฆ ๋ค์๊ณผ ๊ฐ์ด 3๊ฐ์ ๋ง๋์ N๊ฐ์ ์ํ(Disk)์ด ์์ ๋, ์ํ์ ๋ค์์ ์์๋ฅผ ์งํค๋ฉด์ A์์ C๋ก ์ฎ๊ธฐ๋ ์์ ๊ฐ ์ํ์ ํฌ๊ธฐ๋ ๋ชจ๋ ๋ค๋ฅด๋ค. ์ํ์ ํฌ๊ธฐ๋ ์๋์์๋ถํฐ ์๋ก ๊ฐ์๋ก ์ ์ ์์์ง๋ค. โ ํ ๋ฒ์ ํ๋์ ์ํ๋ง ์ด๋ํ๋ค. โก ๋งจ ์์ ์๋ ์ํ๋ง ์ด๋ํ๋ค. โข ํฌ๊ธฐ๊ฐ ์์ ์ํ ์์ ํฐ ์ํ์ ์์ ์ ์๋ค. ์ด ์กฐ๊ฑด์์ ๋ค์์ ๊ตฌํ๋ ๊ฒ์ด ํ๋ ธ์ด ํ์ ๋ฌธ์ ๊ฐ ๋๋ค. โ ์ต์์ ์ด๋ ํ์๋ก ์ฎ๊ธฐ๋ ๊ฐ์ง์ ($2^{N} - 1$) โก ์ต์์ ์ด๋ ํ์๋ก ์ฎ๊ธธ ๋, ..
2022.11.03 -
- [C++] lower_bound(), upper_bound() ; ์ด์ง ํ์(Binary Search)
lower_bound(), upper_bound() ; ์ด์ง ํ์(Binary Search) ์๊ฐ์ด์ง ํ์(Binary Search)์ผ๋ก ์์๋ฅผ ํ์ํ๋ ํจ์์๊ฐ ๋ณต์ก๋๊ฐ $O(\log_{2} N)$ ์ผ๋ก, ๋น ๋ฅธ ์๋๋ก ํ์์ ์ํํ ์ ์๋ค.ํ์์ ์งํํ ์ปจํ ์ด๋๋ ๋ฐ๋์ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌ๋์ด ์์ด์ผ ํ๋ค. ํ์ํ ํค๋#include ํ์์ฐพ์ ๊ฐ(val)์ ์ฃผ์๋ฅผ Iterator ํ์ผ๋ก ๋ฐํํ๋ค.lower_bound(ForwardIterator first, ForwardIterator last, const T& val)lower_bound(ForwardIterator first, ForwardIterator last, const T& val) lower_bound()์ฐพ์ผ๋ ค๋ ํค ๊ฐ๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ์(์ด..
2022.11.01 -
- [C++] sort ํจ์๋ฅผ ์ด์ฉํ์ฌ ์ค๋ฆ์ฐจ์/๋ด๋ฆผ์ฐจ์ ์ ๋ ฌํ๋ ๋ฐฉ๋ฒ
sort ํจ์๋ฅผ ์ด์ฉํ์ฌ ์ค๋ฆ์ฐจ์/๋ด๋ฆผ์ฐจ์ ์ ๋ ฌํ๋ ๋ฐฉ๋ฒ sort() ํจ์๋ฐฐ์ด ๋ฑ ์ปจํ ์ด๋๋ค์ ์์๋ฅผ ์ ๋ ฌํ๋ ํจ์๋ณดํต array๋ vector๋ฅผ ์ ๋ ฌํ ๋ ์ฐ์ธ๋ค. ํ์ํ ํค๋ ํค๋๋ฅผ ๋ถ๋ฌ์์ผ ์ฌ์ฉํ ์ ์๋ค.#include ๊ธฐ๋ณธ ํฌ๋งทdefault (1)template void sort (RandomAccessIterator first, RandomAccessIterator last);custom (2)template void sort (RandomAccessIterator first, RandomAccessIterator last, Compare comp);๊ธฐ๋ณธ์ ์ผ๋ก ์ดํฐ๋ ์ดํฐ ๋ฒ์์ Compare ํ๋ผ๋ฏธํฐ๋ฅผ ํตํด ์ฝ๋ฐฑ ํจ์(Callback Function)๋ฅผ ์ ํ์ ์ผ๋ก ์ฒ๋ฆฌํ ์ ์..
2022.10.27 -
- [Algorithm] ์ค์บ๋ ๋ฉ์๋(Scanning Method)
์ค์บ๋ ๋ฉ์๋(Scanning Method) ์ผ๋ ฌ๋ก ๋์ด๋ ๋ฐ์ดํฐ๊ฐ ์ฃผ์ด์ง ๋, ๋ฌธ์ ์์ ์๊ตฌํ๋ ์ด๋ค ํน์ ๊ตฌ๊ฐ๊ณผ ๊ทธ ๊ตฌ๊ฐ์ ๊ธธ์ด๋ฅผ ๊ตฌํ๊ณ ์ ํ ๋๊ฐ ์๋ค. ์ ์๋์ ๊ฐ์ด ๋ฐฐ์ด a์ 0 ๋๋ 1์ ๋ฐ์ดํฐ๊ฐ ์ฃผ์ด์ง ๋, ์ฐ์์ ์ผ๋ก 1์ด ๋ฐ์๋๋ ์ต๋ ๊ตฌ๊ฐ์ ๊ธธ์ด์ ๊ทธ ๋์ ์์น๋ฅผ ๊ตฌํ๋ผ. X 1 0 1 1 0 1 1 1 1 0 a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] a[9] a[10] ๊ตฌ๊ฐ [1, 1]์๋ ์ฐ์๋ 1์ด 1๊ฐ ๋ฐ์๋์๊ณ , ๊ตฌ๊ฐ [3, 4]์๋ ์ฐ์๋ 1์ด 2๊ฐ ๋ฐ์๋์์ผ๋ฉฐ ๊ตฌ๊ฐ [6, 9]์๋ ์ฐ์๋ 1์ด 4๊ฐ ๋ฐ์๋์๋ค. ์ฌ๊ธฐ์ ์ฐ์์ ์ผ๋ก 1์ด ๋ฐ์๋๋ ์ต๋ ๊ตฌ๊ฐ์ [6, 9]์ด๊ณ , ๊ตฌ๊ฐ์ ๊ธธ์ด๋ 4๊ฐ ๋๋ค. 3์ค for ๋ฌธ์ ์ด์ฉํ์ฌ ๊ตฌํ๊ธฐ ๋ค..
2022.10.26 -
- [Algorithm] ๋ถ๋ถํฉ(Partial Sum) ; ๋์ ํฉ(Prefix Sum)
๋ถ๋ถํฉ(Partial Sum) ; ๋์ ํฉ(Prefix Sum) ์ฐ์๋ ๊ตฌ๊ฐ $start$ ๋ถํฐ $end$ ๊น์ง์ ํฉ ๊ตฌํ๊ธฐ ์ผ์ฐจ์ ๋ฐฐ์ด a๊ฐ ์๋์ ๊ฐ์ด ์ด๊ธฐํ๋์ด ์๋ค. X 10 20 30 40 50 60 70 80 90 100 a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] a[9] a[10] ๋ฐฐ์ด a์์ ์ฐ์๋ ๊ตฌ๊ฐ $start$ ๋ถํฐ $end$ ๊น์ง์ ํฉ์ $\displaystyle \sum_{k=\text{start}}^{\text{end}} a[k] = a[start] + a[start + 1] + \cdots + a[end -1] + a[end]$ ๋ก ์ ์ํ๋ค๋ฉด ($start ≤ end$), ๊ตฌ๊ฐ 5๋ถํฐ ๊ตฌ๊ฐ 9๊น์ง์ ํฉ $\displaystyle \sum_{..
2022.10.26 -
- [Algorithm] ํ์์(Figulate Number)
ํ์์(Figulate Number) ๊ณ ๋ ๊ทธ๋ฆฌ์ค ์๋์ ํผํ๊ณ ๋ผ์คํํ๋ ์ฐ์ฃผ์ ๋ง๋ฌผ์ด ์๋ก ์ด๋ฃจ์ด์ ธ ์๋ค๊ณ ๋ฏฟ์๋ค. ๊ทธ๋์ ๋ํ์ ์ด์ฉํ์ฌ ์ซ์๋ฅผ ํํํ์๊ณ , ์์ ๋ํ์ ๊ด๊ณ๋ฅผ ์ฐ๊ตฌํ์๋ค. ์ด๋ ๊ฒ ๋ํ์ผ๋ก ๋ฌ์ฌ๋ ์์ฐ์๋ฅผ ํ์์(Figulate Number)๋ผ๊ณ ํ๋ค. ์ผ๊ฐ์(Triangular Number) ๊ฐ๋ ์ผ๊ฐํ ๋ชจ์์ผ๋ก ์ด๋ค ์ ์ ๋์์ ๋, ์ผ๊ฐํ์ ์ด๋ฃจ๊ธฐ ์ํด ์ฌ์ฉ๋ ์ ์ ๊ฐ์ ์๊ณ ๋ฆฌ์ฆ ์ผ๊ฐ์๋ ์ฐ์ํ๋ ์์ฐ์์ ํฉ๊ณผ ๊ฐ์ผ๋ฉฐ, ๊ณต์์ ๋ค์๊ณผ ๊ฐ๋ค. $$1 + 2 + 3 + \cdots + n = \frac{n × (n+1)}{2}$$ ์ฝ๋๋ก ๋ํ๋ด๋ฉด ๋ค์๊ณผ ๊ฐ๋ค. #include using namespace std; int main() { int a[6]; for (int i = 1; ..
2022.10.26 -
- [Algorithm] ์๋ผํ ์คํ ๋ค์ค์ ์ฒด(Sieve of Erathosthenes)
์๋ผํ ์คํ ๋ค์ค์ ์ฒด(Sieve of Erathosthenes) ๊ฐ๋ ์ง๊ตฌ์ ๋๋ ๋ฅผ ์ฒ์์ผ๋ก ๊ณ์ฐํ ๊ณ ๋ ๊ทธ๋ฆฌ์ค ์ํ์ ์๋ผํ ์คํ ๋ค์ค(BC273 ~ BC192, Eratosthenes)๊ฐ ๊ธฐ์์ 200๋ ์ ๊ณ ์ํ ๋ฐฉ๋ฒ์ผ๋ก, ์๋์ ๊ฐ์ ๋ฐฉ๋ฒ์ ์ด์ฉํ์ฌ ์์๋ฅผ ๊ตฌํ๋ค. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 1์ ์์๊ฐ ์๋๋ผ๊ณ ํ์ผ๋ฏ๋ก ์ฐ์ ์ง์๋ฒ๋ฆฐ๋ค. ๋ค์์ผ๋ก ๋งจ ์ฒ์ ๋์ค๋ ์(= 2)๋ ๋ฌด์กฐ๊ฑด ์์์ด๋ค. ์๋ํ๋ฉด ์ฝ์๊ฐ 1๊ณผ ์๊ธฐ ์์ ๋ฐ์ ์๊ธฐ ๋๋ฌธ์ด๋ค. ๊ทธ๋ฆฌ๊ณ 2์ ๋ฐฐ์๋ ์์๊ฐ ์๋๋ฏ๋ก ๋ชจ๋ ์ง์๋ฒ๋ฆฐ๋ค. ๋ค์์ผ๋ก ์ง์์ง์ง ์์ ์๋ค ์ค์์ ๊ฐ์ฅ ์์ ์(= 3)๋ฅผ ์ฐพ๋๋ค. ์ด๋ ๊ฒ ์ง์์ง์ง ์๊ณ ๋จ์ ์๋ ์์์ด๋ค. ์๋ํ๋ฉด 1์ด ์๋๋ฉด์ 3๋ณด๋ค ..
2022.10.25 -
- [Algorithm] ์์ธ์ ๋ถํด(Prime/Integer Factorization)
์์ธ์ ๋ถํด(Prime/Integer Factorization) ๊ฐ๋ ํน์ ์์ฐ์๋ฅผ 1๋ณด๋ค ํฐ ์์ฐ์์ธ ์์ธ์(์์์ธ ์ธ์)๋ค๋ง์ ๊ณฑ์ผ๋ก ํํํ๋ ๊ฒ ํฉ์ฑ์๋ฅผ ์์์ ๊ณฑ์ผ๋ก ๋ํ๋ด๋ ๋ฐฉ๋ฒ ์์ธ์ ๋ถํด๋ฅผ ์ผ์์ ์ผ๋ก ๊ฒฐ์ ํ๋ ๊ณต์์ ์์ง ๋ฐ๊ฒฌ๋์ง ์์๋ค. ํ๋ ์ํธํ์์ ์์ธ์ ๋ถํด๋ ์ํธ ์ฒ๋ฆฌ๋ฅผ ํ๋๋ฐ ์ค์ํ๊ฒ ์ฌ์ฉ๋๋ค. ๋ชจ๋ ํฉ์ฑ์๋ ์์ธ์ ๋ถํด๋ ํํ๋ฅผ ๊ฐ์ง๊ณ ์๋ค. ์ฐ์ ์ ๊ธฐ๋ณธ ์ ๋ฆฌ(Fundamental Theorem of Arithmetic)๋ก ์ฆ๋ช ๋๋ค. ์๊ณ ๋ฆฌ์ฆ ๊ธฐ๋ณธ ์๊ณ ๋ฆฌ์ฆ ์์ธ์๋ 1์ด๋ผ๋ ๊ฐ์ด ์๋ 2๋ถํฐ ์์ํ๋ ๊ฒ์ด ํต์ฌ์ด๋ฉฐ, 2๋ก ๋๋์ง ๋ชปํ ๊ฒฝ์ฐ 2์์ ํ๋์ฉ ์ฆ๊ฐ์์ผ์ฃผ๋ฉด์ ๋๋์ด์ง๋์ง ์ฒดํฌํ๋ฉด ๋๋ค. void factorize(int n) { int factor = 2; // ์์ ..
2022.10.25 -
- [Algorithm] ํผ๋ณด๋์น ์์ด(Fibonacci Sequence)
ํผ๋ณด๋์น ์์ด(Fibonacci Sequence) ๋ ์ค๋๋ฅด๋ ํผ๋ณด๋์น(1170 ~ 1250, Leonardo Fibonacci) ๋ ์ค๋๋ฅด๋ ํผ๋ณด๋์น(1170 ~ 1250, Leonardo Fibonacci)๋ 1170๋ ์์ ๋์์ธ ์ดํ๋ฆฌ์์ ํผ์ฌ์์ ํ์ด๋ฌ๋ค. ๊ทธ์ ์๋ฒ์ง๋ ํผ์ฌ์์ ํ์ํ ์์ธ์ผ๋ก ์ง์คํด์์ ๊ฐ๋ ฅํ ๊ถ๋ ฅ์ ๊ฐ์ง ์ฌ๋ ์ค ํ ๋ช ์ด์๋ค. ๊ทธ์ ์๋ฒ์ง๊ฐ ๋ถ๋ถ ์ํ๋ฆฌ์นด์ ํต์ ๋ฌด์ญ ๋ํ๋ก ์๋ช ๋ฐ์, ๋ถ๋ถ ์ํ๋ฆฌ์นด๋ก ์๋ค์ ๋ฐ๋ ค๊ฐ ์ต์ ์ด์ฌ๋ ์ํ์ ๋ฐฐ์ธ ์ ์๋๋ก ํ์๋ค. ํผ๋ณด๋์น๋ ์ด์งํธ, ์๋ฆฌ์, ๊ทธ๋ฆฌ์ค, ์์น ๋ฆฌ์์ ํ๋ก๋ฐฉ์ค์์ ๋ค์ํ ๊ณต๋ถ๋ฅผ ํ์๊ณ , ๊ทธ๊ณณ์์ ์ธ๋์ ๊ธฐ์๋ฒ๊ณผ ์๋ผ๋น์ ์ซ์๋ฅผ ์ฌ์ฉํ์ฌ 10์ง๋ฒ์ผ๋ก ๊ณ์ฐํ๋ ๊ฒ์ ์๊ฒ ๋์๋ค. ํผ๋ณด๋์น๋ ์ด๋ฐ ๋ค์ํ ๊ฒฝํ์ ์ด๋ ค์ ํผ์ฌ๋ก ๋..
1 2022.10.06 -
- [Algorithm] ์ฝ์ ์ ๋ ฌ(Insertion Sort)
์ฝ์ ์ ๋ ฌ(Insertion Sort) ์ฝ์ ์ ๋ ฌ(Insertion Sort) ๋ฐฐ์ด์์ ํน์ key ๊ฐ์ด ์ ํด์ง๊ณ , ๊ทธ key ๊ฐ ์์ ์๋ ๋ฐฐ์ด์ ์์๋ค์ด ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌ๋์ด ์์ ๋, key ๊ฐ์ด ์ฝ์ ๋ ์์น๋ฅผ ์ฐพ์์ ๊ทธ ์์น์ key ๊ฐ์ ์ฝ์ ํ๋ฉด์ ์ ๋ ฌํด ๋๊ฐ๋ ๋ฐฉ์ ๋ ๋ฒ์งธ ์์๋ฅผ key ๊ฐ์ผ๋ก ์ ํด์ ๋ ๋ฒ์งธ ์์๊ฐ ์ฝ์ ๋ ์์น๋ฅผ ์ฐพ์์ ์ฒซ ๋ฒ์งธ ์์๋ถํฐ ๋ ๋ฒ์งธ ์์๊น์ง ์ ๋ ฌ์ํค๊ณ , ๋ค์ ์ธ ๋ฒ์งธ ์์๋ฅผ key ๊ฐ์ผ๋ก ์ ํด์ ์ธ ๋ฒ์งธ ์์๊ฐ ์ฝ์ ๋ ์์น๋ฅผ ์ฐพ์์ ์ฒซ ๋ฒ์งธ ์์๋ถํฐ ์ธ ๋ฒ์งธ ์์๊น์ง ์ ๋ ฌ์ํค๊ณ ๋ค์ ๋ค ๋ฒ์งธ ์์๋ฅผ key ๊ฐ์ผ๋ก ์ ํด์ ๋ค ๋ฒ์งธ ์์๊ฐ ์ฝ์ ๋ ์์น๋ฅผ ์ฐพ์์ ์ฒซ ๋ฒ์งธ ์์๋ถํฐ ๋ค ๋ฒ์งธ ์์๊น์ง ์ ๋ ฌ์ํค๊ณ , ๋ค์ฏ ๋ฒ์งธ ์์๋ฅผ key ๊ฐ์ผ๋ก ์ ํด์ ๋ค์ฏ ๋ฒ์งธ ์์๊ฐ..
1 2022.10.06 -
- [Algorithm] ๋ฒ๋ธ ์ ๋ ฌ(Bubble Sort)
๋ฒ๋ธ ์ ๋ ฌ(Bubble Sort) ๋ฒ๋ธ ์ ๋ ฌ(Bubble Sort) ๋ฐฐ์ด์์ ๊ฐ์ฅ ํฐ ๊ฐ์ ์ฐพ์์ ๋ง์ง๋ง์ ๋ฐฐ์น์ํค๊ณ , ๋ค์์ผ๋ก ํฐ ๊ฐ์ ์ฐพ์์ ๋์์ ๋ ๋ฒ์งธ์ ๋ฐฐ์น์ํค๊ณ , ๋ค์์ผ๋ก ํฐ ๊ฐ์ ์ฐพ์์ ๋์์ ์ธ ๋ฒ์งธ์ ๋ฐฐ์น์ํค๋ฉด์ ์ ๋ ฌํด ๋๊ฐ๋ ๋ฐฉ์ ๊ฑฐํ ๋ชจ์๊ณผ ๊ฐ์์ ๋ฒ๋ธ ์ ๋ ฌ(Bubble Sort)์ด๋ผ๊ณ ํ๋ค. ๊ตฌํ $O(n^{2})$ ์ผ๋ก ๊ตฌํํ๊ธฐ #include using namespace std; #define N 5 int main() { int a[N] = { 7, 6, 9, 5, 8 }; int tmp; for (int i = 0; i a[j + 1]) { tmp = ..
2022.10.06 -
- [Algorithm] ์ ํ ์ ๋ ฌ(Selection Sort)
์ ํ ์ ๋ ฌ(Selection Sort) ๋ฐ์ดํฐ์ ๊ตํ ์ค์(Swap) : ๋ ๋ณ์์ ๊ฐ์ ์๋ก ๊ตํํ๋ ์์ ๋ค์๊ณผ ๊ฐ์ด ์์ ๋ณ์(temp)๋ฅผ ์์ฑํ์ฌ ๋ฐ์ดํฐ ๊ตํ ์์ ์ ์ํํ ์ ์๋ค. temp = a; a = b; b = temp; ๋ค์๊ณผ ๊ฐ์ด ์ฝค๋ง ์ฐ์ฐ์(Comma Operator)๋ฅผ ์ฌ์ฉํ์ฌ ํ ์ค๋ก ์ฒ๋ฆฌํ ์๋ ์๋ค. temp = a, a = b, b = temp; ์ค๋ฆ์ฐจ์ ์ ๋ ฌ(Ascending Sort) ์์ ์์ด ๋์ด๋ ์๋ฃ๋ฅผ ์์ ์์์ ํฐ ์์ผ๋ก ๋ค์ ์ฌ๋ฐฐ์ดํ๋ ์์ ๋ด๋ฆผ์ฐจ์ ์ ๋ ฌ(Descending Sort) ์์ ์์ด ๋์ด๋ ์๋ฃ๋ฅผ ํฐ ์์์ ์์ ์์ผ๋ก ๋ค์ ์ฌ๋ฐฐ์ดํ๋ ์์ ์ ํ ์ ๋ ฌ(Selection Sort) ๋ฐฐ์ด์์ ๊ฐ์ฅ ์์ ๊ฐ์ ์ฐพ์์ ๋ฐฐ์ด์ ์ฒซ ๋ฒ์งธ์ ๋ฐฐ์น์ํค๊ณ , ๋ค..
2022.10.06 -
- [Algorithm] ์ต๋(Max), ์ต์(Min), ์ต๋น(Mode)
์ต๋(Max), ์ต์(Min), ์ต๋น(Mode) ์ต๋(Max)์ ์ต์(Min) ์ฃผ์ด์ง ๋ฐฐ์ด์์ ์ต๋๊ฐ๊ณผ ์ต์๊ฐ์ ์ฐพ๋ ์๊ณ ๋ฆฌ์ฆ์ ๋ค์๊ณผ ๊ฐ๋ค. ๋ง์ฝ ๋ฐฐ์ด์ ๊ฒ์ํด์ max/min ๋ณด๋ค ํฐ/์์ ๊ฐ์ด ์๋ค๋ฉด ์ฒ์์ ๊ฐ์ ์ผ๋ก ์ธ์ด max/min ๊ฐ์ด ์ต๋๊ฐ/์ต์๊ฐ์ด ๋๋ค. ์ต๋๊ฐ ๊ตฌํ๊ธฐ โ ๋ฐฐ์ด์ ์ฒซ ๋ฒ์งธ ๊ฐ์ ์ต๋๊ฐ(max)์ด๋ผ ๊ฐ์ ํ๋ค. โก ๋ฐฐ์ด์ ๊ฒ์ํด์ max ๋ณด๋ค ํฐ ๊ฐ(x)์ด ์์ผ๋ฉด max ๊ฐ์ x๋ก ๋ณ๊ฒฝํด์ค๋ค. (max = x) โข ๊ฒฐ๊ตญ ๋ง์ง๋ง์ ์ต๋๊ฐ์ด max ๋ณ์์ ๋จ๊ฒ ๋๋ค. ์ต์๊ฐ ๊ตฌํ๊ธฐ โ ๋ฐฐ์ด์ ์ฒซ ๋ฒ์งธ ๊ฐ์ ์ต์๊ฐ(min)์ด๋ผ ๊ฐ์ ํ๋ค. โก ๋ฐฐ์ด์ ๊ฒ์ํด์ min๋ณด๋ค ์์ ๊ฐ(y)์ด ์์ผ๋ฉด min ๊ฐ์ y๋ก ๋ณ๊ฒฝํด์ค๋ค. (min = y) โข ๊ฒฐ๊ตญ ๋ง์ง๋ง์ ์ต์๊ฐ์ด min ๋ณ์์ ๋จ๊ฒ..
2022.10.06 -
- [Algorithm] ์ฝ๋ผ์ธ ์ถ์ธก(Collatz Conjecture) ; ์ฐ๋ฐ์(Hailstone Sequence), 3N + 1 Problem
์ฝ๋ผ์ธ ์ถ์ธก(Collatz Conjecture) ๊ฐ๋ 1937๋ ์ ์ฒ์์ผ๋ก ์ด ์ถ์ธก์ ์ ๊ธฐํ ๋ ์ผ์ ์ํ์ ๋กํ๋ฅด ์ฝ๋ผ์ธ (1910 ~ 1990, Lorthar Collatz)์ ์ด๋ฆ์ ๋ด ๋ฒ์น ์ฒ์ ์์์ ์์์ ์์ ์ ์ `N` ์์ ์์ํ๋ค. ๋ง์ฝ `N` ์ด ์ง์์ด๋ฉด, `N` ์ 2๋ก ๋๋๋ค. ๋ง์ฝ `N` ์ด ํ์์ด๋ฉด, `N` ์ 3์ ๊ณฑํ ํ 1์ ๋ํ๋ค. ์์ ๊ฐ์ ๊ณผ์ ์ 1์ด ๋ ๋๊น์ง ๋ฐ๋ณตํ๋ค. ์) 8 → 4 → 2 → 1, 3 → 10 → 5 → 16 → 8 → 4 → 2 → 1 ์ด๋ฌํ ์๋ค์ ๋ง์น ์ฐ๋ฐ์ด ๊ตฌ๋ฆ ์์์ ์ค๋ฅด๋ด๋ฆฌ๋ฉฐ ์๋ผ๋ค๊ฐ ์ง์์ผ๋ก ๋จ์ด์ง๋ ๊ฒ๊ณผ ๋น์ทํ๋ค ํ์ฌ "์ฐ๋ฐ์(Hailstone Sequence)" ๋๋ "3N + 1 Problem" ์ด๋ผ๊ณ ๋ถ๋ฆฌ๊ธฐ๋ ํ๋ค. ์์ง๊น์ง ์ฆ..
2022.09.01 -
- [Algorithm] ์์(Prime Number) ; ์๋ฅ์ด ์์(Twin Primes), ๋ฉ๋ฅด์ผ ์์(Mersenne Primes), ๊ณจ๋๋ฐํ์ ์ถ์ธก(Goldbach's Conjecture)
์์(Prime Number) ์ฝ์์ ๊ฐ์๋ฅผ ์ด์ฉํ ์์์ ํ๋ณ 1๋ณด๋ค ํฐ ์์ฐ์ ์ค์์ 1๊ณผ ์๊ธฐ ์์ ์ด์ธ์๋ ์ฝ์๋ฅผ ๊ฐ์ง์ง ์๋ ์, ์ฆ ์ฝ์์ ๊ฐ์๊ฐ 2๊ฐ์ธ ์์ฐ์๋ฅผ ์์(Prime Number)๋ผ๊ณ ํ๋ค. 2์ ์ฝ์ : 1, 2 3์ ์ฝ์ : 1, 3 4์ ์ฝ์ : 1, 2, 4 5์ ์ฝ์ : 1, 5 6์ ์ฝ์ : 1, 2, 3, 6 7์ ์ฝ์ : 1, 7 2, 3, 5, 7, ... ๋ฑ์ ์ฝ์์ ๊ฐ์๊ฐ 2๊ฐ ์ด๋ฏ๋ก ์์์ด๋ค. ์์ #include using namespace std; int main() { int cnt; for (int i = 2; i
2022.09.01 -
- [Algorithm] ํฐ๋ฆฐ๋๋กฌ(Palindrome)
ํฐ๋ฆฐ๋๋กฌ(Palindrome) ํฐ๋ฆฐ๋๋กฌ(Palindrome) ๋ณดํต ๋ฑ๋ง ์ฌ์ด์ ์๋ ๋์ด์ฐ๊ธฐ๋ ๋ฌธ์ฅ ๋ถํธ๋ ๋ฌด์ํ๊ณ , ์์ผ๋ก ์ฝ์ผ๋ ๊ฑฐ๊พธ๋ก ์ฝ์ผ๋ ๊ฐ์ ๋ฌธ์ฅ ๋๋ ๋ฑ๋ง์ ํ๋ฌธ(ๅๆ) ๋๋ ํฐ๋ฆฐ๋๋กฌ(Palindrome) ์ด๋ผ๊ณ ํ๋ค. ์) "์์ฃผ ๋ง ๋ณ๋ง ์ฃผ์", "์ฌ๋ณด ์๊ฒฝ ์๋ณด์ฌ" ์ํ์์๋ 111, 12321๊ณผ ๊ฐ์ด ๋๋ฐ๋ก ์ฝ์ผ๋ ๊ฑฐ๊พธ๋ก ์ฝ์ผ๋ ๊ฐ์ ์๋ฅผ ํฐ๋ฆฐ๋๋กฌ ์(Palindrome Number) ๋๋ ๋์นญ์๋ผ๊ณ ํ๋ค. ์ซ์ ๋ค์ง๊ธฐ ์ซ์ k = 123, r = 0 ์ผ๋ก ์ด๊ธฐํ๋์ด ์๋ค๊ณ ํ ๋, ๋ค์์ ์ํ๋ฌธ์ ์๋ฃํ๋ฉด k์ ๊ฐ์ 0์ด ๋๊ณ r์ ๊ฐ์ k์ ๊ฐ์ด ๊ฑฐ๊พธ๋ก ๋ค์ง์ด์ง 321์ด ๋๋ค. int k = 123; int r = 0; ์ซ์ ๋ค์ง๊ธฐ ์๊ณ ๋ฆฌ์ฆ while (k != 0) { p = k..
2022.09.01 -
- [Algorithm] ์์ ์ ๊ณฑ์(Perfect Square Number, ์ ๊ณฑ์, ์ ์ฌ๊ฐ์)
์์ ์ ๊ณฑ์(Perfect Square Number, ์ ๊ณฑ์, ์ ์ฌ๊ฐ์) ์ ์ฌ๊ฐ์(Square Number) ์ด๋ค ์์ฐ์์ ์ ๊ณฑ์ด ๋๋ `1^{2}, 2^{2}, 3^{2}, 4^{2}`๊ณผ ๊ฐ์ ์๋ฅผ ์์ ์ ๊ณฑ์(Perfect Square Number) ๋๋ ์ ๊ณฑ์(Square Number) ๋๋ ์ ์ฌ๊ฐ์๋ผ๊ณ ํ๋ค. 1 = 1² 1 + 3 = 2² 1 + 3 + 5 = 3² 1 + 3 + 5 + 7 = 4² 1 + 3 + 5 + 7 + 9 = 5² ์์์์ ๊ฐ์ด 1๋ถํฐ ์ฐ์๋ ํ์์ ํฉ์ ์ธ์ ๋ ์์ ์ ๊ณฑ์์์ ์ ์ ์๋ค. ์์ ์ ๊ณฑ์ ํ๋ณํ๊ธฐ โ ์ฝ์์ ๊ฐ์๋ฅผ ์ด์ฉํ ์์ ์ ๊ณฑ์ ํ๋ณ ์์ ์ ๊ณฑ์๋ ์ฝ์์ ๊ฐ์๊ฐ ์ธ์ ๋ ํ์๊ฐ์ด๋ฏ๋ก ์ฝ์์ ๊ฐ์๋ฅผ ํ์ธํ์ฌ ์์ ์ ๊ณฑ์์ธ์ง ํ๋ณํ ์ ์๋ค. ์์ 1๋ถํฐ 100๊น์ง์..
2022.08.31 -
- [Algorithm] ํฉํ ๋ฆฌ์ผ(Factorial)
ํฉํ ๋ฆฌ์ผ(Factorial) ํฉํ ๋ฆฌ์ผ(Factorial) 1๋ถํฐ N๊น์ง ๋ชจ๋ ๊ณฑํ ์๋ฅผ N ํฉํ ๋ฆฌ์ผ(Factorial)์ด๋ผ ๋ถ๋ฅด๋ฉฐ, ๊ธฐํธ๋ก๋ N!๋ก ๋ํ๋ธ๋ค. N! = 1 x 2 x 3 x ... x N ๊ณฑ์ ์ฐ์ฐ์ ํ ๋์ ์ด๊น๊ฐ์ ์ธ์ ๋ 1์ด์ด์ผ ํ๋ค. ์ด๊น๊ฐ์ด 0์ผ ๊ฒฝ์ฐ, ์ด๋ค ์๋ฅผ ๊ณฑํด๋ ํญ์ 0์ด ๋๋ค. ์) 5! = 1 × 2 × 3 × 4 × 5 = 120 ์์ 5! ๊ตฌํ๊ธฐ #include using namespace std; int main() { int fact; fact = 1; // ์ด๊น๊ฐ์ ํญ์ 1์ด์ด์ผ ํ๋ค. for (int i = 1; i
2022.08.31 -
- [Algorithm] ์์ ์(Perfect Number), ๋ถ์กฑ์(Deficient Number), ๊ณผ์์(Abundant Number)
์์ ์(Perfect Number), ๋ถ์กฑ์(Deficient Number), ๊ณผ์์(Abundant Number) ์์ ์(Perfect Number) ๊ทธ ์ ์์ ์ ์ ์ธํ ๋ชจ๋ ์ฝ์์ ํฉ์ด ๊ทธ ์ ์์ ๊ณผ ๊ฐ์ ์๋ฅผ ์์ ์(Perfect Number)๋ผ๊ณ ํ๋ค. ์) 6์ ์ฝ์๋ {1, 2, 3, 6} ์ด๊ณ , ๊ทธ ์ ์์ ์ ์ ์ธํ 1 + 2 + 3์ ํฉ์ 6๊ณผ ๊ฐ์ผ๋ฏ๋ก 6์ ์์ ์์ด๋ค. ๋ถ์กฑ์(Deficient Number) ๊ทธ ์ ์์ ์ ์ ์ธํ ๋ชจ๋ ์ฝ์์ ํฉ์ด ๊ทธ ์ ์์ ๋ณด๋ค ์์ ์๋ฅผ ๋ถ์กฑ์(Deficient Number)๋ผ๊ณ ํ๋ค. ์) 8์ ์ฝ์๋ {1, 2, 4, 8} ์ด๊ณ , ๊ทธ ์ ์์ ์ ์ ์ธํ 1 + 2 + 4์ ํฉ์ 7๊ณผ ๊ฐ์ผ๋ฏ๋ก 8์ ๋ถ์กฑ์์ด๋ค. ๊ณผ์์(Abundant Number) ๊ทธ..
2022.08.31 -
- [Algorithm] ๋ฐฐ์(Multiple)์ ์ฝ์(Divisor)
๋ฐฐ์(Multiple)์ ์ฝ์(Divisor) ๋ฐฐ์(Multiple) ์ด๋ค ์์๋ค 1๋ฐฐ, 2๋ฐฐ, 3๋ฐฐ, 4๋ฐฐ, ... ํ ์๋ค์ ๊ทธ ์์ ๋ฐฐ์(Multiple)๋ผ๊ณ ํ๋ค. ์) {3, 6, 9, ...} ๋ 3์ ๋ฐฐ์์ด๋ค. ์์ 1๋ถํฐ 100 ์ฌ์ด์ 3์ ๋ฐฐ์ ์ถ๋ ฅํ๊ธฐ #include using namespace std; int main() { for (int i = 1; i
2022.08.31 -
- [Algorithm] ๊ฐ์ฐ์ค ๊ณ์ฐ๋ฒ(Gaussian Calculation)
๊ฐ์ฐ์ค ๊ณ์ฐ๋ฒ(Gaussian Calculation) ๊ฐ์ฐ์ค(1777 ~ 1885, Carl Friedrich Gauss) ๊ฐ์ฐ์ค(1777 ~ 1885, Carl Friedrich Gauss)์ ์ ์๋ ๋ทํธ๋๋ ์์ ์๊ฐ์ ์ ์ ์ด ์๊ฐ์ผ๋ก ํ์๋ค์๊ฒ 1๋ถํฐ 100๊น์ง ๋ํ๋ ๋ฌธ์ ๋ฅผ ๋๋ค. ๊ฐ์ฐ์ค๋ ์์๊ฐ์ 5050 ์ด๋ผ๋ ์ ๋ต์ ์์๋ด์๋ค. ๊ฐ์ฐ์ค์ ์ฒ์ฌ์ฑ์ ์์๋ณธ ๋ทํธ๋๋ ๊ทธ์๊ฒ ๊ณ ๋ฑํ๊ต ์ํ ๊ต๊ณผ์๋ฅผ ์ ๋ฌผํ๋ค๊ณ ํ๋ค. ๋ ์ผ์ ์ํ์ ๊ฐ์ฐ์ค๋ ์๋ฅดํค๋ฉ๋ฐ์ค, ๋ดํด๊ณผ ํจ๊ป ์ํ์ ์ญ์ฌ์ด ๊ฐ์ฅ ์๋ํ ์ธ ๋ช ์ ์ํ์ ์ค ํ ๋ช ์ด๋ค. ๊ฐ์ฐ์ค ๊ณ์ฐ๋ฒ ์ฐ์๋ ์ ๋๋ ๊ท์น์ ์ผ๋ก ๋์ด๋์ด ์๋ ์์ด ๋ฑ์ ํฉ์ ์ฝ๊ฒ ๊ณ์ฐํ๊ธฐ ์ํด์ ์ฌ์ฉํ๋ ๊ณ์ฐ๋ฒ ์ผ๋ฐํํ๋ฉด ๋ค์๊ณผ ๊ฐ๋ค. ์ฒ์ ๊ฐ๋ถํฐ ๋ง์ง๋ง ๊ฐ๊น์ง์ ํฉ = (์ฒ์..
2022.08.31