์นดํ
๊ณ ๋ฆฌ ์์
[์์ฌ์ํต๋ฅ๋ ฅ] ์์ฑ์ฃผ์ฒด - ๊ณต๋ฌธ์ : ํ์ ๊ธฐ๊ด, ๊ณต๋ฌด์ - ์๋ฌธ์ : ๊ฐ์ธ, ์ฌ์ ๋ชฉ์ ์ ํต๋์ - ๋ด๋ถ๊ฒฐ์ฌ๋ฌธ์ : ์ธ๋ถ ์ ํต X - ๋๋ด๋ฌธ์, ๋์ธ๋ฌธ์ ๋ฌธ์์ ์ฑ์ง 1. ๊ณต๋ฌธ์ ์๋ฌธ์(๊ฐ์ธ,์ฌ์ ๋ชฉ์ ) ์ ๋ถ๊ฐ ์ ๋ถ์๊ฒ, ํ์ฌ๊ฐ ์ ๋ถ์๊ฒ ์ ์ถ ์๊ฒฉํ ๊ท๊ฒฉ๊ณผ ์์ 2. ๊ธฐํ์ (์๊ฒฌ ์ค์ฌ) ์์ด๋์ด, ์ค๋ํ๋ ๋ฌธ์ 3. ๋ณด๊ณ ์ (์ฌ์ค ์ค์ฌ) ๋ณด๊ณ ํ๋ ๋ฌธ์ ์ผ์ ๊ดํ ํํฉ, ์งํ ์ํฉ, ์ฐ๊ตฌ ๊ฒฐ๊ณผ ๋ฑ 4. ๊ธฐ์์ ์ฌ๋ด ๊ณต๋ฌธ์. ์
๋ฌด์ ๋ํ ํ์กฐ, ์๊ฒฌ ์ ๋ฌ 5. ์ค๋ช
์ ์ํ ์ค๋ช
๋ชฉ์ ์ ํ๊ตฌ์
์ ๋, ์ฌ์ฉ๋ฒ ์๋ด ๋ชฉ์ 6. ๋ณด๋์๋ฃ ์ธ๋ก ์ ์๋๋ก ์์ ๋ค์ ์ ๋ณด๋ฅผ ๊ธฐ์ฌ๋ก ๋ณด๋ํ๋๋ก ํ๊ธฐ์ํด ๋ณด๋ด๋ ์๋ฃ ์ ๋ณด์ ๊ณต์ ์ํจ 1. ์ธ์ด์ ์์ฌ์ํต (๊ฒฝ์ฒญ๋ฅ๋ ฅ, ์์ฌ์ํต๋ฅ๋ ฅ) -์ ๋์ฑ : ์ํฉ์ ๋ฐ๋ผ ๋์ฒ ๊ฐ๋ฅ -๋ถ์ ํ :..
CS/์ด์์ฒด์
์ด์์ฒด์ ์ปดํจํฐ์ ์ฌ์ฉ์ ์ฌ์ด์์ ์์คํ
์ ํจ์จ์ ์ผ๋ก ์ด์ํ ์ ์๋๋ก ์ธํฐํ์ด์ค ์ญํ - ์ฌ์ฉ์๊ฐ ์์ฉ ํ๋ก๊ทธ๋จ์ ํธ๋ฆฌํ๊ฒ ์ฌ์ฉํ๋๋ก ํจ - ํ๋์จ์ด ์ฑ๋ฅ์ ์ต์ ํ - ํ๋ก์ธ์ค ๊ด๋ฆฌ , ๋ฉ๋ชจ๋ฆฌ ๊ด๋ฆฌ , ๊ธฐ์ต์ฅ์น ๊ด๋ฆฌ , ํ์ผ ๊ด๋ฆฌ , ์
์ถ๋ ฅ ๊ด๋ฆฌ , ๋ฆฌ์์ค ๊ด๋ฆฌ ์ด์์ฒด์ ๋ฐ๋ฌ ๊ณผ์ ์ผ๊ด ์ฒ๋ฆฌ ์์คํ
-> ๋ค์ค ํ๋ก๊ทธ๋๋ฐ, ๋ค์ค ์ฒ๋ฆฌ, ์๋ถํ , ์ค์๊ฐ ์ฒ๋ฆฌ ์์คํ
-> ๋ค์ค ๋ชจ๋ ์์คํ
-> ๋ถ์ฐ ์ฒ๋ฆฌ ์์คํ
์ผ๊ด ์ฒ๋ฆฌ ์์คํ
: ๋ฐ์ดํฐ๋ฅผ ์ผ์ ๋ ๋๋ ์ผ์ ๊ธฐ๊ฐ ๋ชจ์์ ํ๊บผ๋ฒ์ ์ฒ๋ฆฌํ๋ ์์คํ
์๋ถํ ์์คํ
: CPU์ ์ฒ๋ฆฌ ์๊ฐ์ ์ผ์ ํ ์๊ฐ ๋จ์๋ก ๋๋์ด์ ์ฌ๋ฌ ๊ฐ์ ์์
์ ์ฐ์์ ์ผ๋ก ์ฒ๋ฆฌํ๋ ์์คํ
๋ค์ค ์ฒ๋ฆฌ ์์คํ
: ์ฌ๋ฌ ๊ฐ์ CPU์ ํ๋์ ์ฃผ๊ธฐ์ต์ฅ์น๋ฅผ ์ด์ฉํ์ฌ ์ฌ๋ฌ ๊ฐ์ ํ๋ก๊ทธ๋จ์ ๋์์ ์ฒ..
CS/์ปดํจํฐ์ผ๋ฐ
์ง๋ฒ 3์ด๊ณผ ์ฝ๋ : 3(0011) ์ ๋ํจ ๋ฌธ์ ) 10์ง์ 3์ 3-์ด๊ณผ ์ฝ๋์์ ํํํ๊ธฐ 3 -> 0011 3์ด๊ณผ์ฝ๋ 0011 ๋ํ๊ธฐ 0011 +0011 ------- 0110 ๋ณด์ 1์ ๋ณด์ : ๊ฐ ์๋ฆฌ์ ์๋ 1์ 0์ผ๋ก, 0์ 1๋ก ๋ฐ๊พธ์ด ํํํ๋ค. 2์ ๋ณด์ : 1์ ๋ณด์๋ฅผ ๋จผ์ ๊ตฌํ ๋ค์ ๋งจ ์ค๋ฅธ์ชฝ ์๋ฆฌ์ 1์ ๋ํ์ฌ ๊ตฌํ๋ค. 9์ ๋ณด์ : 10์ง์์์ ๊ฐ ์๋ฆฟ์์ ์ซ์๋ฅผ ์ต๋๊ฐ์์ ๋บ๋ค. 10์ ๋ณด์: 9์ ๋ณด์๋ฅผ ๋จผ์ ๊ตฌํ ๋ค์ ๊ทธ ๊ฒฐ๊ณผ์ 1์ ๋ํ์ฌ ๊ตฌํ๋ค. ์์) 45์ ๋ํ 9์ ๋ณด์๋? 99-45 = 54 11101์ 1์ ๋ณด์๋? ์๋ฆฟ์ ๋ฐ๊พธ๊ธฐ -> 00010 2์ ๋ณด์๋? 1์ ๋ณด์ + 1 = 00011 BCD ์ฝ๋ 10์ง์์ ๊ฐ๊ฐ์ ์๋ฆฌ๋ฅผ 2์ง์๋ก ๋ฐ๊ฟ์ฃผ๋ฉด BCD code๊ฐ ..
CS/์ปดํจํฐ์ผ๋ฐ
๋ถ ๋์ (Boolean Algebra) ์ฐธ(1)๊ณผ ๊ฑฐ์ง(0), ๋ ๊ฐ์ง์ ๋
ผ๋ฆฌ๊ฐ๋ง ๊ฐ์ง๋ ๋์ ๋ฌธ์ ) F = (A+B) • (A+C) ๋ฅผ ๊ฐ์ํ ํ๊ธฐ ๋๋ณด๊ธฐ ๊ตํ ๋ฒ์น A+B = B+A , A•B = B•A ๋์ผ ๋ฒ์น A + A = A , A•A = A ํญ๋ฑ ๋ฒ์น A + 0 = A , A + 1 = 1 , A•1=A , A•0=0 F = A•A + A•C + B•A + B•C = A + AC + AB + BC ( ๋์ผ๋ฒ์น , ๊ตํ๋ฒ์น ) = A(1+C) + AB + BC = A + AB + BC ( ํญ๋ฑ๋ฒ์น ) = A(1+B) + BC = A + BC F = A + BC ๋
ผ๋ฆฌ ๊ฒ์ดํธ(Logic Gate) ๋ฐ๊ฐ์ฐ๊ธฐ (Half Adder) ๊ฐ์ฐ๊ธฐ๋ ๋ง์
์ฐ์ฐ์ ์ํํ๊ธฐ ์ํ ๋
ผ๋ฆฌํ๋ก์ด๋ค. ๋ฐ๊ฐ์ฐ๊ธฐ๋ ํ ์..
CS/์ปดํจํฐ์ผ๋ฐ
ํ๋์จ์ด - ์ค์ฒด๊ฐ ์๋(์๊ฐ์ ์ผ๋ก ๋ณด์ด๋ฉด์๋ ๋ง์ง ์ ์๋), ์ปดํจํฐ์ ๋ชจ๋ ๋ฌผ๋ฆฌ์ ์ธ ๋ถํ์ ํตํ์ด ์๋ฏธ โป ์๋ฅผ ๋ค์ด, Windows๋ฅผ ์ฌ์ฉํ๊ธฐ ์ํ ๋
ธํธ๋ถ ํน์ Android/iOS ์ฌ์ฉ์ ์ํ ์ค๋งํธํฐ, ๊ทธ ์ธ ๋ชจ๋ํฐ, ํค๋ณด๋ ๋ง์ฐ์ค ๋ฑ์ด ๋ชจ๋ ํ๋์จ์ด ํ๋์จ์ด๋ ๋ฉ์ธ๋ณด๋, ์ค์์ฒ๋ฆฌ์ฅ์น(CPU), ๊ธฐ์ต์ฅ์น, ์
์ถ๋ ฅ์ฅ์น ๋ฑ์ผ๋ก ๊ตฌ์ฑ๋๋ค. ์ค์์ฒ๋ฆฌ์ฅ์น(CPU, Central Processing Unit) - ์ปดํจํฐ์ ์ค์์์ ๋ชจ๋ ๋ฐ์ดํฐ๋ฅผ ์ฒ๋ฆฌํ๋ ํต์ฌ์ ์ธ ์ฅ์น. - ์ฌ์ฉ์๊ฐ ๋ช
๋ น์ ๋ณด๋ด๋ฉด, ๋ช
๋ น์ด ํด์ / ์๋ฃ ์ฒ๋ฆฌ(์ฐ์ฐ)๋ฅผ ํตํด ๊ฒฐ๊ณผ๋ฅผ ์ถ๋ ฅ์ฅ์น์๊ฒ ๋ณด๋ด์ค๋ค. - ์ ์ด์ฅ์น / ์ฐ์ฐ์ฅ์น / ๋ ์ง์คํฐ(๊ธฐ์ต์ฅ์น)๋ก ๊ตฌ์ฑ๋๋ค. ์ ์ด์ฅ์น (CUใControl Unit) ์ปดํจํฐ์ ์๋ ๋ชจ๋ ์ฅ์น๋ค์ ๋์์ ์ง..
Algorithm/BOJ
https://www.acmicpc.net/problem/1920 1920๋ฒ: ์ ์ฐพ๊ธฐ ์ฒซ์งธ ์ค์ ์์ฐ์ N(1 ≤ N ≤ 100,000)์ด ์ฃผ์ด์ง๋ค. ๋ค์ ์ค์๋ N๊ฐ์ ์ ์ A[1], A[2], …, A[N]์ด ์ฃผ์ด์ง๋ค. ๋ค์ ์ค์๋ M(1 ≤ M ≤ 100,000)์ด ์ฃผ์ด์ง๋ค. ๋ค์ ์ค์๋ M๊ฐ์ ์๋ค์ด ์ฃผ์ด์ง๋๋ฐ, ์ด ์๋ค www.acmicpc.net ์ ์ฐพ๊ธฐ ์ฑ๊ณต ์๊ฐ ์ ํ๋ฉ๋ชจ๋ฆฌ ์ ํ์ ์ถ์ ๋ต๋งํ ์ฌ๋์ ๋ต ๋น์จ 1 ์ด 128 MB 217313 66856 44340 30.018% ๋ฌธ์ N๊ฐ์ ์ ์ A[1], A[2], …, A[N]์ด ์ฃผ์ด์ ธ ์์ ๋, ์ด ์์ X๋ผ๋ ์ ์๊ฐ ์กด์ฌํ๋์ง ์์๋ด๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค. ์
๋ ฅ ์ฒซ์งธ ์ค์ ์์ฐ์ N(1 ≤ N ≤ 100,000)์ด ์ฃผ์ด์ง๋ค. ๋ค์ ์ค์๋ ..
Algorithm/BOJ
1-1. ํ์๊ณผ ์ ๋ ฌ (1) A – 1920 ์ ์ฐพ๊ธฐ https://www.acmicpc.net/problem/1920 B – 2750 ์ ์ ๋ ฌํ๊ธฐ https://www.acmicpc.net/problem/2750 C – 2751 ์ ์ ๋ ฌํ๊ธฐ 2 https://www.acmicpc.net/problem/2751 D – 10989 ์ ์ ๋ ฌํ๊ธฐ 3 https://www.acmicpc.net/problem/10989 E – 10815 ์ซ์ ์นด๋ https://www.acmicpc.net/problem/10815 1-2. ๊ธฐ์ด ์๋ฃ๊ตฌ์กฐ (1) A – 10828 ์คํ https://www.acmicpc.net/problem/10828 B – 10845 ํ https://www.acmicpc.net/problem/..
Algorithm/Softeer
# ๋ฐ์ด๋ฌ์ค 1์ด๋น P๋ฐฐ์ฉ ์ฆ๊ฐ # ์ฒ์ K๋ง๋ฆฌ n์ดํ -> ๋ช๋ง๋ฆฌ? # k:๋ฐ์ด๋ฌ์ค ์ , P:์ฆ๊ฐ์จ , N:์ด ์๊ฐ k,p,n = map(int,input().split()) result = k for _ in range(n): a = result % 1000000007 b = p % 1000000007 result = (a*b) % 1000000007 print(result) (a*b) % m = ( (a%m) * (b%m) ) % m https://sskl660.tistory.com/75 ๋ชจ๋๋ฌ ์ฐ์ (Modular Arithmetic) *๋ชจ๋๋ฌ ์ฐ์ (Modular Arithmetic) -> ๋ชจ๋๋ฌ ์ฐ์ (๋ชจ๋๋ฌ ์ฐ์ฐ)์ ์ ์์ ํฉ๊ณผ ๊ณฑ์ ์ด๋ค ์ฃผ์ด์ง ์์ ๋๋จธ์ง๋ฅผ ์ด์ฉํ์ฌ ์ ์ํ๋ ๋ฐฉ๋ฒ์ ๋งํ๋ค. ..