Java
69

[JAVA] ArrayList<Integer>์์ ์ํ๋ ์ซ์ Value ์ง์ฐ๊ธฐ
0. ๋ค์ด๊ฐ๋ฉฐ...ํด๋น ๊ธ์ ArrayList์์ ์ํ๋ ์ซ์๋ฅผ ์ง์ฐ๋ ๋ฐฉ๋ฒ์ ๋ํ ๊ธ์ด๋ค. ArrayList.remove() ํจ์๋ก ์ง์ฐ๋ฉด ๋์ง ์๊ฒ ๋ ์๊ฐํ ์ ์์ง๋ง .remove(int i)๋ฅผ ๋ฃ์ผ๋ฉด, remove์ ์ค๋ฒ๋ก๋ฉ๋ ํจ์ ์ค ArrayList.remove(int index)๊ฐ ํธ์ถ๋์ด, i๋ฅผ index๋ก ๊ฐ์ง๋ Value๋ฅผ ArrayList์์ ์ญ์ ํ๋ค. ๋ฐ๋ผ์ ์๋ ์๋ํ 'i๋ผ๋ Value ์ง์ฐ๊ธฐ'๋ ์คํจํ๋ค.1. ArrayList.remove(int index)์์์ ์ค๋ช
ํ๋ฏ์ด remove์ ์์ ์๋ฃํ int๋ฅผ ๋ฃ์ผ๋ฉด ํด๋น ์ธ์๋ฅผ index๋ก ๊ฐ์ง๋ Value๋ฅผ ArrayList์์ ์ญ์ ํ๋ค.2. ArrayList.remove(Object o)์ฐ๋ฆฌ๊ฐ ์ค์ i๋ผ๋ Value๋ฅผ ์ญ..
2025.01.25
Language/Java

[JAVA] Long๋ณด๋ค ํฐ ์๋ฅผ ๋ค๋ฃจ๋ ๋ฒ
0. ๋ค์ด๊ฐ๋ฉฐ๊ฐ๋ฐ์ ํ๊ฑฐ๋, ์ฝ๋ฉํ
์คํธ์์ ์ ์๋ก ๊ด๋ จ ๋ฌธ์ ๋ฅผ ๋ง๋๋ฉด ํ ๋ฒ์ฉ ์ฃผ์ด์ง๋ ์
๋ ฅ์ ํฌ๊ธฐ๊ฐ Longํ์ ์ด์ํ ์ ์์ ๋๊ฐ ๊ฐํน ์๋ค. ๋จผ์ ์ฝํ
์์ ์์ฃผ ์ฐ์ด๋ ์๋ฃํ์ธ int์ Longํ์ ์ต๋, ์ต์๊ฐ์ ์์๋ณด์.์ ์ํ ํ์
๋ฐ์ดํฐ ํํ ๋ฒ์int-2,147,483,648 ~ 2,147,483,647 ($10^{10}$)long-9,223,372,036,854,775,808 ~ 9,223,372,036,854,775,807 ($10^{18}$)long์ด ์ ๋ง ๋ง์ ์์ ๋ฒ์๋ฅผ ์ปค๋ฒํ ์ ์์์๋ ๋ถ๊ตฌํ๊ณ ๋ฐฑ์ค์ ๊ฑฐ์ ์์๊ฐ์ ๋ฌธ์ ๋ ์ด๋ฌํ ์๋ฃํ์ ๋ฐ์ด๋๋๋ค. ์ด๋์ ๋์ฒ๋ฒ 2๊ฐ์ง๋ฅผ ์ค๋ช
ํ๊ฒ ๋ค.1. ์ค์ ์๋ฃํ์ธ Double ์ฌ์ฉ Double์ 64bit ๋ถ๋ ์์์ ์ผ๋ก ํํ๋ ์๋ฃํ์ผ๋ก..
2025.01.24
Language/Java

[JAVA] For ๋ฌธ ์๋ ์์
0. ์ ๋ฆฌํ๋ ์ด์ ์ฝํ
๋ฌธ์ ๋ฅผ ํ๋ค๊ฐ ๊ฐ์๊ธฐ ์์๊ฐ ํท๊ฐ๋ ธ๋ค. ๊ทธ๋์ ์ ๋ฆฌํด๋์ผ ๊ฒ ๋ค1. For ๋ฌธ ์๋ ์์1๏ธโฃ: ์ง์ญ ๋ณ์ ์ ์ธ ๋ฐ ์ด๊ธฐํ (ํด๋น ๋ถ๋ถ์ด For๋ฌธ ๋ฐ์ ์์ด๋ ๋๋ค. ๋ค๋ง ๊ทธ๋ ๊ฒ ํ๋ฉด, for ๋ฌธ์ด ๋๋ ๋ค์๋ i ๊ฐ์ด ์ ์ง๋๋ค.)2๏ธโฃ: ์ค์์ ์กฐ๊ฑด ์ฒดํฌ (์ฌ๊ธฐ์ ๊ฑธ๋ฆฌ๋ฉด for๋ฌธ ๋ด์ฉ๋ฌผ์ ๋ค์ด๊ฐ์ง ์๊ณ ๋ฐ๋ก for ๋ฌธ์ด ๋๋๋ค.)3๏ธโฃ: ๋ด์ฉ๋ฌผ ์ฒ๋ฆฌ4๏ธโฃ: i ํฌ๊ธฐ ์ฌ๋ฆฌ๊ธฐ5๏ธโฃ: ๋ค์ ํ ๋ฒ ๋ ์กฐ๊ฑด ์ฒดํฌ
2025.01.24
Language/Java

[JAVA] ์ฝ๋ฉํ
์คํธ ์ค ์ค์ํ๊ธฐ ์ฌ์ด StringBuilder์ ์์ฑ์
0. ๋ฌด์์ ์ ๋ฆฌํ๋์ํ์๋ ๋ฌธ์์ด์ ๋ค์ง๋ ๊ธฐ์ ์ด ํ์ํ ๋, StringBuilderํด๋์ค์ reverse()๋ฅผ ์์ฃผ ํ์ฉํ๋ค. ๊ทผ๋ฐ, ํ ๋ฆฐ๋๋กฌ ์๋ฅผ ๋น ๋ฅด๊ฒ ๊ตฌํ๊ธฐ ์ํด, ๋ค์๊ณผ ๊ฐ์ด ๋ฌธ์ ๋ฅผ ํธ๋ ํ๋ฆฌ๋ ๊ฒ ์๋๊ฐ! StringBuilder straight = new StringBuilder(num);StringBuilder reverse = new StringBuilder(num).reverse();์ฝ์์ ์ฐ์ด๋ณด๋ ๋ ๊ฐ์ฒด ๋ชจ๋์ ์ด๋ ํ ์
๋ ฅ๊ฐ๋ ๋ค์ด๊ฐ์ง ์์๋ค! ์ฝํ
์์ ์ด๋ฌํ ์๋ฌ๋ฅผ ๊ฒช์์ผ๋ฉด ์ ์์ด ๋นํฉํ์ ๊ฒ ๊ฐ๋ค. ์ค๋์ ํ์์ ๊ฐ์ด ๋นํฉํ ์ฌ๋๋ค์ ์ํด, StringBuilder์ ์์ฑ์์ int i๋ฅผ ๋ฃ๋ ๊ฒ๊ณผ String str์ ๋ฃ๋ ๊ฒ์ ์ฐจ์ด๋ฅผ ์์๋ณด๋ ค ํ๋ค.1. ne..
2025.01.24
Language/Java

ํญํด 99 ์ฝํ
์คํฐ๋ 5๊ธฐ 8์ผ์ฐจ + [ํ๋ก๊ทธ๋๋จธ์ค] Lv3 ์๊ณผ ๋๋ java ํ์ด
1. ๋ฌธ์ ์ค๋ช
๐(1) ๋งํฌ๐ ํ๋ก๊ทธ๋๋จธ์คSW๊ฐ๋ฐ์๋ฅผ ์ํ ํ๊ฐ, ๊ต์ก, ์ฑ์ฉ๊น์ง Total Solution์ ์ ๊ณตํ๋ ๊ฐ๋ฐ์ ์ฑ์ฅ์ ์ํ ๋ฒ ์ด์ค์บ ํprogrammers.co.kr (2) ์ฃผ๋ชฉ ํฌ์ธํธ ๐ต1๏ธโฃ ๋๋ >= ์ ์ด๋ฉด ๋ชจ์๋ ์์ ๊ฐ์๊ฐ 0์ด ๋๋ค!2๏ธโฃ ํ์ฌ ํน์ ํ ์๋ธ ํธ๋ฆฌ๋ฅผ ๋ฐฉ๋ฌธ ์ค์ด๋ผ ๊ฐ์ ํ ๋, ํด๋น ํธ๋ฆฌ์์ ์ต๋ ์ด์ต์ ์ด๋ฏธ ๋๋ค๊ณ ํ์ ํ๋ค๋ฉด, ์กฐ์ ๋
ธ๋๋ฅผ ๊ฑฐ์ฌ๋ฌ ์ฌ๋ผ๊ฐ ๋ค๋ฅธ ์๋ธ ํธ๋ฆฌ๋ฅผ ํ๊ณ ๋๋ ๊ฒ์ด ๊ฐ๋ฅํ๋ค.2. ์๊ฐ์ ํ๋ฆ: ์ฝ๋๊ฐ ๋์ค๊ธฐ๊น์ง ๐๏ธ(1) IDEA ๋์ถ๐กKEY WORD: BACK-TRACKING, DFSํด์ค์์ ์ค๋ช
ํ 2๏ธโฃ๋ฒ์งธ ํฌ์ธํธ ๋๋ฌธ์, ์ด๋ฒ ๋ฌธ์ ๋ BACK-TRACKING์ ๊ฐ๊น๊ฒ ๋ณํ๋ DFS๋ฅผ ์ฌ์ฉํด์ผ ํ๋ค. ๊น์ด ์ฐ์ ํ์์ ํ๋ ์ฑ์ง์..
2025.01.22
CodingTest/์๊ณ ๋ฆฌ์ฆ-ํ์ด

[๋ฐฑ์ค] 1114 ํต๋๋ฌด ์๋ฅด๊ธฐ java ํ์ด
1. ๋ฌธ์ ์ค๋ช
๐๋ฌธ์ ๋งํฌ์ผ๋ฐ์ ์ธ ๋งค๊ฐ๋ณ์ ํ์์ด๋ ์ด๋ถ ํ์ ๋ฌธ์ ๋ณด๋ค ๊น๋ค๋ก์ ๋ ์ ์,1๏ธโฃ ํต๋๋ฌด์ ์๋ฅผ ์ ์๋ ์์น๊ฐ ์ ํด์ ธ ์๋ค.2๏ธโฃ ํต๋๋ฌด์ ๊ฐ์ฅ ๊ธด ์กฐ๊ฐ์ ์๊ฒ ๋ง๋ค์์ ๋, ์ ์ผ ์ฒ์ ์๋ฅธ ์์น๋ ๊ฐ์ด ์ถ๋ ฅ ํด๋ผ.์๋ค. ์ด๊ฑธ ์ ๋
ํ๋ฉฐ ๋ฌธ์ ๋ฅผ ํ์ด์ผ ํ๋ค.2. ๊ตฌํ ๋ฐฉ๋ฒ ๐๏ธKEY WORD: Parametric Search, Binary Search, Greedy Algorithm0๏ธโฃ ํต๋๋ฌด๋ฅผ ์๋ฅผ ์ ์๋ ์์น๋ฅผ ๋ฐ์์ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํ๋ค.1๏ธโฃ ์ด๋ถํ์์ผ๋ก ํต๋๋ฌด์ ๊ฐ์ฅ ๊ธด ์กฐ๊ฐ์ ์ต์๊ฐ์ ๊ตฌํ๋ค. ๊ตฌํ๋ ๋ฐฉ๋ฒ์ ๋ค์๊ณผ ๊ฐ๋ค.1๏ธโฃ-1) f(w) = ๋ชจ๋ ์กฐ๊ฐ๋ ํต๋๋ฌด์ ๊ธธ์ด๊ฐ w ์ดํ์ธ๊ฐ? ๋ผ๋ ๊ฒฐ์ ๋ฌธ์ ํจ์๋ฅผ ๋ง๋ ๋ค. ์ด๋ฅผ ๋ง์กฑํ๋ f(w) ์ค ๊ฐ์ฅ ์ค๋ฅธ์ชฝ์ ์๋ f(w)์..
2025.01.21
CodingTest/์๊ณ ๋ฆฌ์ฆ-ํ์ด

99ํด๋ฝ ์ฝํ
์คํฐ๋ 5๊ธฐ 5์ผ์ฐจ + [๋ฐฑ์ค] 17270 ์ฐ์์ธ์ ํ๋ค์ด java ํ์ด
1. ๋ฌธ์ ์ค๋ช
๐๋ฌธ์ ๋งํฌ์งํ๊ณผ ์ฑํ์ ์๋ก์ด ์ฝ์ ์ฅ์๋ฅผ ์ฐพ์์ฃผ๋ ๋ฌธ์ ๋ก์, ๋ค์ต์คํธ๋ผ๋ฅผ ํตํด ๊ฐ์์ ์ถ๋ฐ์ ์์ ๋ชจ๋ ์ ์ ๊น์ง์ ์ต์ ๋๋ฌ ๋น์ฉ์ ๊ตฌํ๊ณ , ์ด๋ฅผ ํตํด 4๊ฐ์ง ์กฐ๊ฑด์ ๋ง์กฑํ๋ ์ฝ์ ์ฅ์๋ฅผ ์ฐพ์ผ๋ฉด ๋๋ค.ํ์ง๋ง, ์ถ์ ์๊ฐ ์ง๋ฌธ์ ๋๊ฒ ๋ชจํธํ๊ฒ ์ ์ด์, ์กฐ๊ฑด์ ์ง์๊ฐ ํท๊ฐ๋ฆฐ๋ค.์ฝ์ ์ฅ์์ ์กฐ๊ฑด์ ๋ค์๊ณผ ๊ฐ๋ค.1๏ธโฃ ๊ฐ์์ ์ถ๋ฐ์ ์ ์ฝ์ ์ฅ์๊ฐ ๋ ์ ์๋ค.2๏ธโฃ ๋ ๋ค ์ต์ ๋น์ฉ์ผ๋ก ๋ฟ์ ์ ์๋ ์ฅ์์ฌ์ผ ํ๋ค.3๏ธโฃ ์งํ์ด๊ฐ ์ฑํ๋ณด๋ค ๋จผ์ ๋์ฐฉํ๋ ์ฅ์์ฌ์ผ ํ๋ค.4๏ธโฃ ์์ ์กฐ๊ฑด์ ๋ชจ๋ ๋ง์กฑํ๋ ์ฅ์๊ฐ ๋ณต์๋ผ๋ฉด, ๊ทธ ์ค ์งํ์ด๊ฐ ๋นจ๋ฆฌ ๋์ฐฉํ๋ ์ฅ์๋ฅผ ๊ณ ๋ฅธ๋ค. (์ด ๋ง์ ๋ ๋ณต์์ด๋ฉด, ์ ์ ๋ฒํธ๊ฐ ๋น ๋ฅธ ๊ฒ์ ๊ณ ๋ฅธ๋ค.)์ด ์กฐ๊ฑด์ ๋ณด๋ฉด,๊ฐ์์ ์ถ๋ฐ์ ์ด ์๋๋ฉด์, ์งํ์ด๊ฐ ์ฑํ๋ณด๋ค ๋จผ์ ๋์ฐฉํ๋ฉด์..
2025.01.17
CodingTest/์๊ณ ๋ฆฌ์ฆ-ํ์ด

๊ธฐ์ ์ ๋ ฌ(radix sort), ๊ทธ๋ฆผ์ผ๋ก ์ฝ๊ฒ ์ดํดํ๊ธฐ
1. ๊ธฐ์ ์ ๋ ฌ์ด๋?์๋ค์ ์๋ฆฟ๊ฐ์ ํ์ฉํด, ๋ฐ์ดํฐ๋ฅผ ์ ๋ ฌํ๋ ์ ๋ ฌ๋ฐฉ๋ฒ(์ง๊ธ๊น์ง ๋ฐฐ์ด ์ ๋ ฌ๋ค์ ์ ๋ค๊ฐ์ ๋์ ๊ด๊ณ๋ฅผ ๋น๊ตํ๋ ๋น๊ต ์ ๋ ฌ์ด์์ง๋ง, ๊ธฐ์ ์ ๋ ฌ์ ๋ฐ์ดํฐ ๊ฐ์ ๋์ ๊ด๊ณ๋ฅผ ๋น๊ตํ์ง ์์.)์๊ฐ ๋ณต์ก๋๋ O(kn)์ด๋ค. ์ฌ๊ธฐ์ K๋ ์
๋ ฅ์ผ๋ก ์ฃผ์ด์ง ๋ฐ์ดํฐ ์ค ๊ฐ์ฅ ํฐ ์๋ฆฟ๊ฐ์ ๋งํ๋ค. ์ฝ๋ฉํ
์คํธ์์๋ ์ต๋๊ฐ์ด 10์ต์ ๋์ด๊ฐ๋ ๊ฒฝ์ฐ๊ฐ ๋๋ฌผ๊ธฐ ๋๋ฌธ์ ์ค์ง์ ์ผ๋ก O(N)์ ์๊ฐ์์ ์ ๋ ฌ์ด ๊ฐ๋ฅํ๋ค๋ ์๋ฆฌ์ด๋ค.ํ์ง๋ง ๊ฐ์ฒ ์ ์ฐ๊ธ์ ์ฌ์ฒ๋ผ ๋ฑ๊ฐ๊ตํ์ ์์น์ด๋ค. ํด๋น ์ ๋ ฌ์ ๊ตฌํํ๊ธฐ ์ํด์ ์๋๋ Queue๊ฐ 10๊ฐ๊ฐ ํ์ํด์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๋ง์ด ์ก์๋จน๋๋ค. ์ด๋ฌํ ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋์ ์ค์ด๊ธฐ ์ํด ๋ณธ ํฌ์คํ
์์๋ ๋์ ํฉ ๋ฐฐ์ด์ ์ด์ฉํ ๊ตฌํ ๋ฐฉ๋ฒ์ ์๊ฐํ๊ฒ ๋ค.2. ์๋ฆฌ0. ์ธํ
ํ์ฌ ํ์ธ ์ค์ธ ์๋ฆฟ๊ฐ์ ๊ฐ์ง ์ซ์๊ฐ ..
2024.12.31
CodingTest/์๊ณ ๋ฆฌ์ฆ-์ด๋ก

Quick ์ ๋ ฌ, ๊ทธ๋ฆผ์ผ๋ก ์ฝ๊ฒ ์ดํดํ๊ธฐ
1. Quick ์ ๋ ฌ์ ๋ฌด์์ธ๊ฐ?Pivot(์ค์ถ)๊ฐ ๋๋ ๊ฐ์ ํ๋ ์ ์ ํด์ ๊ทธ ๊ฐ๋ณด๋ค ์์ ๊ฐ์ ์ผ์ชฝ์ผ๋ก, ํฐ ๊ฐ์ ์ค๋ฅธ์ชฝ์ผ๋ก ๋ชจ์๋ค. ์ด์ ๋๋ ์ง ๋ ๊ทธ๋ฃน ๋ด์์ ๋ค์ Pivot์ ์ ์ ํ๊ณ ์ด ๊ณผ์ ์ ๋ฐ๋ณตํ๋ค. ๊ฐ์ ๋ ์ด์ ์ชผ๊ฐค ์ ์์ ๋๊น์ง ๋ฐ๋ณตํ๋ฉด ๋ชจ๋ ๊ฐ์ด ์ ๋ ฌ๋์ด ์๋ค.2. ์๋ฆฌ๋ณํฉ์ ๋ ฌ๊ณผ ๋ง์ฐฌ๊ฐ์ง๋ก ๋ถํ ์ ๋ณต์ ํ์ฉํ๋ ๋ ๋ค๋ฅธ ์์์ด๋ค. ๋ณํฉ ์ ๋ ฌ์์๋ ์ ๋ถํ ํ ์ ๋ณต ์ด์๋ค๋ฉด, quick ์ ๋ ฌ์ ์ ์ ๋ณต, ํ ๋ถํ ํ์์ด๋ผ ์๊ฐํ๋ฉด ๋๊ฒ ๋ค.์ ๋ณต์๋ ๋ง์ฃผ๋ณด๋ ํฌ ํฌ์ธํฐ๊ฐ ํ์ฉ๋๋ค. ์ด๋ป๊ฒ ์ฐ์ด๋์ง๋ ๋ฐ์ ์์์์ ์์ธํ ์ค๋ช
ํ๊ฒ ๋ค. (1) Pivot ์ ํ๊ธฐ (์ ํ๋ ๋ฐฉ์์ ๋์ ๋ง๊ฒ ์์ )(2) Pivot๋ณด๋ค ํฐ ๊ฐ์ ์ค๋ฅธ์ชฝ์ผ๋ก ๋ชฐ๊ธฐ, ์๊ฑฐ๋ ๊ฐ์ ๊ฐ์ ์ผ์ชฝ์ผ๋ก ๋ชฐ๊ธฐ (์ ๋ณต by ํฌ ํฌ..
2024.12.31
CodingTest/์๊ณ ๋ฆฌ์ฆ-์ด๋ก

[Java] HashMap์์ Custom Class๋ฅผ Key๋ก ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ, ๊ทธ๋ฆผ์ผ๋ก ์ฝ๊ฒ ์ดํดํ๊ธฐ
0. ์์๋ณผ ๊ฒ1. Hash Map ์ด๋? ํํ์ ๋ฐ์ดํฐ ์์ผ๋ก ์ด๋ฃจ์ด์ง ์๋ฃ๊ตฌ์กฐKEY๋ฅผ ํ์ฉํด HashMap์ VALUE์ (์ ์ฅ, ์ญ์ , ์กฐํ) ํ๋๋ฐ ํ๊ท O(1)์ ์๊ฐ์ด ๋ ๋ค. ์์ ENTRY๋ผ๊ณ ๋ถ๋ฅธ๋ค.KEY ๊ฐ์ ์ค๋ณต๋ ์ ์๊ณ , VALUE ๊ฐ์ KEY ๊ฐ์ด ๋ค๋ฅด๋ค๋ฉด ์ค๋ณต์ ์ฅ์ด ๊ฐ๋ฅํ๋ค.2. HashMap ๋ด๋ถ ๊ตฌ์กฐHashMap์ ํฌ๊ฒ HASH ํจ์์ Hash Bucket์ผ๋ก ์ด๋ฃจ์ด์ ธ ์๋ค.Hash Bucket์ ๊ฐ์ ์ ์ฅํ๋ ์ฅ์๋ก Array๋ก ๊ตฌํ๋์ด ์๋ค.Hash ํจ์๋ ์
๋ ฅ ๊ฐ ๋ง๋ค์ Hash ๊ฐ์ ๋ฐํ ํ๋๋ฐ, ํด๋น Hash ๊ฐ์ Hash Bucket์ Index์ด๋ค. ๋ฐ๋ผ์ Hash ํจ์๋ ์
๋ ฅ ๊ฐ์ด ์ ์ฅ๋ ์์น๋ฅผ ์๋ ค์ฃผ๋ ๋ค๋น๊ฒ์ดํฐ ์ญํ ์ ํ๋ค๊ณ ์๊ฐํ๋ฉด ๋๊ฒ ๋ค.์ด์ ์ค์ ์
๋ ฅ๊ฐ..
2024.12.31
Language/Java

[๋ฐฑ์ค] 1517 ๋ฒ๋ธ ์ํธ java ํ์ด (๊ทธ๋ฆผ์ผ๋ก ์ฝ๊ฒ ์ดํดํ๊ธฐ)
1. ๋ฌธ์ ์ค๋ช
๐๋ฌธ์ ๋งํฌ1์ฐจ์ ๋ฐฐ์ด์ด ์ฃผ์ด์ง๊ณ , ํด๋น ๋ฐฐ์ด์ ๋ฒ๋ธ ์ ๋ ฌ๋ก ์ ๋ ฌํ๋ค๊ณ ํ์๋, ์ ์ฒด ๊ณผ์ ์ค์์ swap์ ๋ช ๋ฒ ์ผ์ด๋ฌ๋์ง ๊ตฌํ๋ผ.2. ์ ๊ทผ ๋ฐฉ์ ๐๏ธKey Word: Merge_sort, Two Pointer๋ถํ ์ ๋ณต, ํฌ ํฌ์ธํฐ๋ฅผ ํ์ฉํด ์
๋ ฅ์ ๋ํด ๋ณํฉ ์ ๋ ฌ์ ์คํํ๋ค.๋งค ์ฌ๊ท ์๊ฐ๋ง๋ค ์ ๋ ฌ์ด ๋ ํ
๋ฐ, ์ด๋ ์๋ฆฌ ๋ฐ๊ฟ์ด ์ผ์ด๋ ํ์๋ฅผ ์ผ๋ค.์์ ๊ณผ์ ์์ ๊ตฌํ ์๋ฆฌ ๋ฐ๊ฟ ํ์๋ฅผ ๋์ ํด ์ถ๋ ฅํ๋ค.์ ์ฒด ๊ณผ์ ์ ๊ฐ๋ตํ ์ค๋ช
ํ๋ฉด ๋ค์๊ณผ ๊ฐ๋ค.(1) ์ง๊ธ๋ถํฐ ๋ณํฉ ์ ๋ ฌ์ด ๋ฌด์์ธ์ง,(2) ๋ฒ๋ธ ์ ๋ ฌ๋ก ์ ๋ ฌํ๋ผ ํ๋๋ฐ ์ ๋ณํฉ ์ ๋ ฌ์ ์ฌ์ฉํ๊ณ ๊ทธ๊ฒ์ด ํตํ๋์ง,(3) ์ด๋ป๊ฒ ๊ตฌํํ๋ฉด ๋๋์ง์ธ์ธํ๊ฒ ์ค๋ช
ํ๊ฒ ๋ค.(1) ๋ณํฉ ์ ๋ ฌ์ด ๋ฌด์์ธ์ง๋ณํฉ์ ๋ ฌ์ ๋ถํ ์ ๋ณต๊ณผ ํฌ ํฌ์ธํฐ๋ฅผ ํ์ฉํด ๊ฐ๋ค์ ์ ๋ ฌํ๋..
2024.12.28
CodingTest/์๊ณ ๋ฆฌ์ฆ-ํ์ด

[๋ฐฑ์ค] 2003 ์๋ค์ ํฉ2 ์ฌ์ด ํ์ด java ^^
1. ๋ฌธ์ ์ค๋ช
๐๋ฌธ์ ๋งํฌ2. ์ ๊ทผ ๋ฐฉ์ ๐๏ธKEY WORD: one-way Two pointer๋จ๋ฐฉํฅ ํฌ ํฌ์ธํฐ๋ฅผ ์ฌ์ฉํ๋ ์ ํ์ ์ธ ๋ฌธ์ ์ด๋ค. ์ผ์ชฝ ํฌ์ธํฐ(L)๊ณผ ์ค๋ฅธ์ชฝ ํฌ์ธํฐ(R)์ ๋๋ค. ํด๋น ๊ตฌ๊ฐ ๋ด ์๋ค์ ํฉ์ sum์ด๋ผ ํ๊ฒ ๋ค.sum : R ํฌ์ธํฐ๋ฅผ ์ ์ง์ํจ๋ค.sum >= M: L ํฌ์ธํฐ๋ฅผ ์ ์ง์ํจ๋ค. (๋ง์ฝ sum == M์ด๋ฉด ๋ต์ด ๋๋ ๊ฒฝ์ฐ์ ์๋ฅผ +1 ์ฌ๋ฆฐ๋ค.)๊ตฌ๊ฐ ๋ด์ ํฉ์ ๊ตฌ๊ฐ ๋ด์ ๊ฐ์ด ์์ ํ๋์ธ ๊ฒฝ์ฐ๋ ํฌํจํ๋ค. ๋ฐ๋ผ์ arr[0] == M ์ธ ๊ฒฝ์ฐ๋ ์์ธ ์์ด ๊ณ์ฐ์ ํฌํจ๋๋๋ก ํด์ค์ผ ํ๋ค.๋๋ 3๋ฒ์ ๊ท์น์ ์งํค๊ธฐ ์ํด ๋ฐฐ์ด์ N+1๋ก ๋ง๋ค์ด ๊ฐ๋ค์ 1๋ถํฐ ์ฑ์ฐ๊ณ , ํฌ์ธํฐ๋ค์ 0๋ถํฐ ์์ํ๋๋ก ํ์๋ค.3. ์ฝ๋ ์๊ฐ ๐import java.io.*;import java..
2024.12.23
CodingTest/์๊ณ ๋ฆฌ์ฆ-ํ์ด

[๋ฐฑ์ค] 11003 ์ต์๊ฐ ์ฐพ๊ธฐ java ํ์ด (๊ทธ๋ฆผ์ผ๋ก ์ฌ์ด ์ค๋ช
^^)
1. ๋ฌธ์ ์ค๋ช
๐๋ฌธ์ ๋งํฌ์ฌ๋ผ์ด๋ฉ ์๋์ฐ์์ ๋ ๋์๊ฐ์, ์๋์ฐ ๊ตฌ๊ฐ์์ ์ต์๊ฐ์ ๋งค๋ฒ ์ถ๋ ฅํ๋ ๋ฌธ์ ์ด๋ค.2. ์ ๊ทผ ๋ฐฉ์ ๐๏ธKEY WORD: Sliding Window, Data Structure (Deque)ํ์ด์ฌ์์๋ ์ถ๊ฐ์๊ฐ์ด ์ฃผ์ด์ค์ ์ฐ์ ์์ ํ๋ฅผ ์ด์ฉํด๋ ํ๋ฆฌ์ง๋ง, Java์์๋ ํ๋ฆฌ์ง ์๋๋ค. ์ ์ฐ์ ์์ ํ๋ก๋ ์๋๋์ง์ ๋ํด 4๋ฒ ํญ๋ชฉ์์ ์ค๋ช
ํ๊ฒ ๋ค.(1) ์ ์ฒด ์ ๊ทผ ๋ฐฉ์ArrayDeque๋ก ์ฌ๋ผ์ด๋ฉ ์๋์ฐ๋ฅผ ๊ตฌํํ๋ค.(ํด๋น deque๋ ํ์ฌ ๊ตฌ๊ฐ์ธ ๊ฐ๋ค๋ง ๊ฐ์ง๊ณ ์์ผ๋ฉฐ, ์ค๋ฆ์ฐจ์์ผ๋ก ๊ฐ์ ์์๋ฅผ ์ ์งํ๋ค. (front = ์ต์๊ฐ))์ฌ๋ผ์ด๋ฉ ์๋์ฐ๋ฅผ ์ค๋ฅธ์ชฝ์ผ๋ก ํ ์นธ์ฉ ์์ง์ธ๋ค.๊ตฌ๊ฐ์ ์ ๊ท๋ก ์ถ๊ฐ๋ ๊ฐ์ A๋ผ๊ณ ์ณค์ ๋, A์ deque์ rear(๊ผฌ๋ฆฌ)๋ฅผ ๋น๊ตํ๋คrear > A:..
2024.12.21
CodingTest/์๊ณ ๋ฆฌ์ฆ-ํ์ด

[๋ฐฑ์ค] 3020 ๊ฐ๋ฅ๋ฒ๋ java ์๋ฒฝ ํ์ด!
1. ๋ฌธ์ ์ค๋ช
๐๋ฌธ์ ๋งํฌ2. ์ ๊ทผ ๋ฐฉ์ ๐๏ธKEY WORD: ๋์ ํฉ, ์ด๋ถ ํ์๋๊ตด์ ๋์ด์ธ H์ ๊น์ด์ธ N์ด ๊ฐ๊ฐ \(10^{5}\)์ด๋ฏ๋ก, ์์ ํ์์ผ๋ก ํ๋์ ํ๋ง๋ค ๋ชจ๋ ์ด์ ์กฐํํ๋ค๋ฉด 1์ด์ \(10^{10}\)๋ฒ ์ด์์ ์ฐ์ฐ์ ํด์ผํด์ ์๊ฐ ์ด๊ณผ๊ฐ ๋ ๊ฒ์ด๋ค.ํด๋น ๋ฌธ์ ๋ *๊ฑฐ๊พธ๋ก ๋งค๋ฌ๋ ค ์๋ ์ข
์ ์์ ์ด๋ป๊ฒ ์ฒ๋ฆฌํ ๊ฒ์ธ๊ฐ?* ์ ๋ํ ๋ช
ํํ ๊ฐ์ด๋๋ผ์ธ๋ง ๊ณํํ ์ ์๋ค๋ฉด ํ ์ ์๋ ๋ฌธ์ ์ด๋ค. ์ข
์ ์ ์ฒ๋ฆฌ๋ฐฉ๋ฒ์ ๋ฐ๋ผ ๋ ๊ฐ์ง ๋ฐฉ๋ฒ์ผ๋ก ํ ์ ์๋๋ฐ, ํ๋๋ ๋์ ํฉ์ด๊ณ ๋ค๋ฅธ ํ๋๋ ์ด๋ถ ํ์์ด๋ค.(1) ๋์ ํฉa. ๊ฒฐ๋ก ๋จผ์ 1. "์์๊ณผ ์ข
์ ์ ์
๋ ฅ์ ๋ถ๋ฅํ์ฌ Y์ถ ์์น์ ๋ฐ๋ฅธ ๊ฐ ์ฐ๋ฌผ์ ์์น๋ฅผ ์ ์ฅํ๋ ๋ฐฐ์ด ๊ตฌํ"2. "๊ฐ ๋ฐฐ์ด์ ๋์ ํฉ ๊ตฌํ๊ธฐ (์์ ๋์ ํฉ ๋ฐฐ์ด์ sum_S[i], ..
2024.12.19
CodingTest/์๊ณ ๋ฆฌ์ฆ-ํ์ด

[๋ฐฑ์ค] 16139 ์ธ๊ฐ-์ปดํจํฐ ์ํธ์์ฉ java ํ์ด
1. ๋ฌธ์ ์ค๋ช
๐๋ฌธ์ ๋งํฌ2. ์ ๊ทผ ๋ฐฉ์ ๐๏ธKEY WORD: ๊ตฌ๊ฐ ํฉ๋์ ํฉ ๋ฐฐ์ด S์์ A~B ๊ตฌ๊ฐ ๋ด์ ๊ตฌ๊ฐํฉ์ ๊ตฌํ ๊ฒฝ์ฐ ์ด๋ป๊ฒ ํํํ๋๊ฐ?S[B] - S[A-1] ์ด์๋ค. A๊ฐ ๊ตฌ๊ฐ๋ด์ ํฉํด์ง๋๋ก A-1๊น์ง์ ๊ตฌ๊ฐํฉ์ ์ ๊ฑฐํ๋ค. ์ด๋ฌํ ์๋ฆฌ๋ ๊ตฌ๊ฐ ๋ด์ ์ํ๋ฒณ์ด ๋ช ๋ฒ ๋ฑ์ฅํ๋๊ฐ ์ฐพ๋ ์ด๋ฒ ๋ฌธ์ ์์๋ ์ฌ์ฉํ ์ ์๋ค.์ ๊ทธ๋ฆผ๊ณผ ๊ฐ์ด, a๊ฐ A๊ตฌ๊ฐ์์ ํ๋ฒ, B๊ตฌ๊ฐ์์ ํ๋ฒ ๋์จ๋ค๊ณ ํ์. ๊ทธ๋ฌ๋ฉด, S[A] = 1, S[B] = 2๊ฐ ๋ ๊ฒ์ด๋ค. ๊ตฌ๊ฐ์ ํ์ธํ๋ฉด ๋ฌธ์์ด์ด A์ ์์น๋ฅผ ๋์ด์์ B๊น์ง ๊ตฌ๊ฐ์ ์ ํ๋ ์๊ฐ a๋ ํ๊ฐ์ด๋ค. S[B]-S[A]๋ A+1 ~ B๊น์ง์ ๊ตฌ๊ฐํฉ์์ผ๋ก 2-1 = 1์ด ๋์จ๋ค. ๋ฐ๋ฉด S[B] - S[A-1]์ A์ ์์น๋ถํฐ B๊น์ง์ ๊ฑฐ๋ฆฌ์์ a์ ๊ฐ์์์ผ๋ก S[..
2024.12.12
CodingTest/์๊ณ ๋ฆฌ์ฆ-ํ์ด

ํ๋ก๊ทธ๋๋จธ์ค Lv1 ์งํ ์ ๊ธฐ ํ์ด java
1. ๋ฌธ์ ์ค๋ช
๐๋ฌธ์ ๋งํฌ2. ์ ๊ทผ ๋ฐฉ์ ๐๏ธKEY WORD: SIMULATION3. ์ฝ๋ ์๊ฐ ๐import java.util.*;class Solution { public int solution(int[] wallet, int[] bill) { int answer = 0; Arrays.sort(wallet); Arrays.sort(bill); while(wallet[0] 4. ๋ฐฐ์ด ๊ฒ๋ค ๐ฏ์์. ๊พธ์คํจ์ ์ํ ์ฌ๋ฌผ
2024.11.28
CodingTest/์๊ณ ๋ฆฌ์ฆ-ํ์ด

[ํ๋ก๊ทธ๋๋จธ์ค] Lv2 ์๊ฒฉ์์คํ
java ์ฌ์ด ํ์ด
1. ๋ฌธ์ ์ค๋ช
๐๋ฌธ์ ์ค๋ช
๋ฌธ์ ์ค๋ช
์๋ต2. ์ ๊ทผ ๋ฐฉ์ ๐๏ธKEY WORD: GREEDY ALGORITHMGreedy ์๊ณ ๋ฆฌ์ฆ์ ๋งค ์ ํ์ ์๊ฐ์ ๋น์ ํ ์ ์๋ ์ต์ ์ ์ ํ์ ํ๋ ๊ฒ์ด ์ ์ฒด ๋ฌธ์ ์์๋ ์ต์ ์ ํด๋ฅผ ๊ตฌํ๋ ๊ฒ์์ ๊ฐ์ ํ๋ ์๊ณ ๋ฆฌ์ฆ์ด๋ค.์ฌ๊ธฐ์๋ ๋ฏธ์ฌ์ผ์ ๋ฌถ์์ ๋์ง์ ๊ธฐ์ค ์ค๋ฆ ์ฐจ์์ผ๋ก ์ ๋ ฌํ๊ณ , ๋ฏธ์ฌ์ผ ๋ฌถ์์ ์ต๋ํ ๋์ง์ ์์ ์ฐจ๋ก๋๋ก ์๊ฒฉํด ๋๊ฐ๋ฉด ์ต์ํ์ผ๋ก ์๊ฒฉ ๋ฏธ์ฌ์ผ์ ์ฌ์ฉํ๋ ๊ฒ์ด๋ค. ํด๋น ๋ฐฉ๋ฒ์ ๋ค์๊ณผ ๊ฐ์ ์ด์ ๋ก ์ ํจํ๋ค.๋ฏธ์ฌ์ผ์ ๋ง๋๋ฉด ๋ฌด์กฐ๊ฑด ์๊ฒฉํด์ผ ํ๋ค. ์ํ๊ณ ์ง๋์น๋ ๊ฒฝ์ฐ๋ ์๋ค.๋ฐ๋ผ์ ๋ฏธ์ฌ์ผ์ ๋ง๋๋ฉด ์ต๋ํ ๊ฒน์น๊ฒ ์ญ์ ํด์ผ ํ๋ค.ํ๋์ ๋ฏธ์ฌ์ผ ๋ฌถ์ A๊ฐ ๋ค๋ฅธ ๋ฏธ์ฌ์ผ ๋ฌถ์๊ณผ ์ต๋ํ ๊ฒน์น๋ ๊ฒฝ์ฐ๋ A์ ๋์ง์ ์์๋ง ๋ฐ์ํ๋ค.์๋ฅผ ๋ค์ด๋ณด๊ฒ ๋ค.๋ค์๊ณผ ๊ฐ์ด ํญ๊ฒฉ ๋ฏธ์ฌ..
2024.11.12
CodingTest/์๊ณ ๋ฆฌ์ฆ-ํ์ด

[ํ๋ก๊ทธ๋๋จธ์ค] Lv2 ์๋ ๋ก๊ทธ ์๊ณ java ์ดํดํ๊ธฐ ์ฌ์ด ํ์ด!
1. ๋ฌธ์ ์ค๋ช
๐๋ฌธ์ ๋งํฌ์๋ ๋ก๊ทธ ์๊ณ์ ์ด์นจ์ด ์์นจ ํน์ ๋ถ์นจ๊ณผ ๊ฒน์น ๋๋ง๋ค ์๋์ ์ธ๋ฆด ๊ฑด๋ฐ, ์ฃผ์ด์ง ์์ ์๊ฐ๋ถํฐ ๋์๊ฐ ๋ด์ ์๋ฆผ์ด ๋ช ๋ฒ ์ธ๋ ธ๋์ง ํ์๋ฅผ ๋ฐํํ๋ ํจ์๋ฅผ ์์ฑํ๋ ๋ฌธ์ . ์๊ณ์ ์ด,๋ถ,์์นจ์ ์ฐ์์ ์ผ๋ก ์์ง์ธ๋ค. ๋ฐ๋ผ์ ๊ฒน์น๋ ์๊ธฐ๊ฐ 0.001์ด ๋จ์์ผ ์๋, 0.00001์ด ๋จ์์ผ์๋ ์๋ค. ์ด๋ฅผ ๋ค ์๊ฐํด์ ๊ฒน์น๋ ํ์๋ฅผ ๊ตฌํด๋ผ! (Lv2 ๋ง๋?? Lv3๋ก ๊ฒฉ์ํด์ผํ ๋ฏ...)2. ์ ๊ทผ ๋ฐฉ์ ๐๏ธKEY WORD: SIMULATION์๊ณ ์นจ๋ค์ ๊ฒน์นจ ํ์์ ์ต๋ํ ์ฝ๋๋ก ๊ตฌํํด์ผ ํ๋ค. ํ์ง๋ง ์ฐ์์ ์ผ๋ก ์ด๋ฃจ์ด์ง๋ ์์ง์ ์์์ ๊ฒน์น๋ ์๊ฐ์ ํฌ์ฐฉํ๋ค๋ ๊ฒ์ ๋ถ๊ฐ๋ฅํ ์ผ์ด๋ค. ๋ฐ๋ผ์ ๊ฒน์น๋ค์ ๊ธฐ์ค์ ๋ค์๊ณผ ๊ฐ์ด ์ ํ๋ค.(1) ๊ฒน์น๋ค์ ๊ธฐ์ค๊ฐ๋ ์ ์ด์นจ์ด ์์นจ ํน์ ๋ถ์นจ๋ณด๋ค..
2024.11.10
CodingTest/์๊ณ ๋ฆฌ์ฆ-ํ์ด

[๋ฐฑ์ค] 1931 ํ์์ค ๋ฐฐ์ ์ฌ์ด ํ์ด ^^
1. ๋ฌธ์ ์ค๋ช
๐๋ฌธ์ ๋งํฌํ์์๊ฐ์ ์์๊ณผ ๋์ด ์ฃผ์ด์ง ๋, ์ต๋ํ ๋ง์ ๊ฐ์๋ฅผ ํ์์ค์ ๋ฐฐ์ ํด๋ผ (A ๊ฐ์์ ๋์๊ฐ๊ณผ B ๊ฐ์์ ์์ ์๊ฐ์ด ๊ฐ์ผ๋ฉด ์ฐ๋ฌ์ ๋ฐฐ์ ํ ์ ์๋ ๊ฒ์ผ๋ก ๊ฐ์ฃผํ๋ค.) 2. ์ ๊ทผ ๋ฐฉ์ ๐๏ธKEY WORDS: GREEDY ALGORITHMGreedy Algorithm์ ์ ํ์ ์๊ฐ์ ์ต์ ์ ์ ํ์ง๋ฅผ ๊ณ ๋ฅด๋ ๊ฒ์ด ์ ์ฒด ๋ฌธ์ ์์ ์ต์ ์ ์ ํ์ ํ๋ ๊ฒ์ด๋ผ ๊ฐ์ ํ๋ ์๊ณ ๋ฆฌ์ฆ์ด๋ค.๋นจ๋ฆฌ ๋๋๋ ์์ผ๋ก ํ์๋ฅผ ์ ๋ ฌ์ ์ผ ๋นจ๋ฆฌ ๋๋๋ ํ์๊ฐ A๋ผ๋ฉด A ํ์ ์ดํ์ ์์ํ ์ ์์ผ๋ฉด์๋, ์ต๋ํ ๋นจ๋ฆฌ ๋๋๋ ํ์๋ฅผ ์ ํํ๋ ๊ฒ์ด ์ ์ฒด ๋ฌธ์ ์์ ๋ดค์ ๋ ์ต๋ํ ๋ง์ ๊ฐ์๋ฅผ ๊ณ ๋ฅผ ์ ์๋ ๋ฐฉ๋ฒ์.2๋ฒ์ ๋ชจ๋ ํ์๋ฅผ ๋์๋ณด๋ฉฐ ๋ ์ด์ ๊ณ ๋ฅผ ์ ์๋ ํ์๊ฐ ์์ ๋๊น์ง ๋ฐ๋ณต 3. ์ฝ๋ ์๊ฐ ๐..
2024.11.09
CodingTest/์๊ณ ๋ฆฌ์ฆ-ํ์ด

[๋ฐฑ์ค] 1744 ์ ๋ฌถ๊ธฐ java ์ฌ์ด ํ์ด^^
1. ๋ฌธ์ ์ค๋ช
๐๋ฌธ์ ๋งํฌ๋ฌธ์ ์์ ์์ด์ด ์ฃผ์ด์ง๋๋ฐ, ์์ด์ ๊ธฐ๋ณธ์ ์ผ๋ก ๋ชจ๋ ๋ํด์ง๋ค. ํ์ง๋ง ๋ง์ฝ ์ฌ์ฉ์๊ฐ ์์์ ์ 2๊ฐ๋ฅผ ๊ณจ๋ผ์ ๊ดํธ๋ฅผ ์ณค์ ๊ฒฝ์ฐ, ํด๋น ์๋ ๊ณฑํด์ง๋ค. ๋ชจ๋ ์๋ ๋จ ํ๋์ ๊ดํธ์ ํฌํจ๋๊ฑฐ๋ ์๋๋ฉด ๊ดํธ์ ์์ ํฌํจ๋์ง ์๋ 2๊ฐ์ง ์ ํ์ง๋ฐ์ ์๋ค๊ณ ํ์ ๋, ์์ด๋ก ๋ง๋ค ์ ์๋ ์ต๋๊ฐ์ ๊ตฌํ๋ผ.์๋ฅผ ๋ค์ด ์์ด์ด [0,1,2,4,3,5]๋ก ์ฃผ์ด์ก์ ๋, ๊ดํธ๊ฐ ์๋ค๋ฉด ํฉ์ 15์ด์ง๋ง, ๋ค์๊ณผ ๊ฐ์ด ๊ดํธ๋ฅผ ํ์ฉํ๋ฉด 0 + 1 + (2*3) + (4*5) ๊ฐ ๋๋ฉด ๊ฐ์ด 27๋ก ์ต๋๊ฐ ๋๋ค.2. ์ ๊ทผ ๋ฐฉ์ ๐๏ธKEYWORD: GREEDY ALGORITHM(1) ๊ฒฝ์ฐ์ ์ ์๊ฐํ๊ธฐ๋จผ์ ์ฃผ์ด์ง ๋ ๊ฐ์ ์๋ก ์ต๋๊ฐ์ ๋ง๋ค ์ ์๋ ๊ฒฝ์ฐ๋ ๋ฌด์์ด ์์๊น?๋ ์ ๋ชจ๋ 0๋ณด๋ค ํด ๋: ์ด..
2024.11.08
CodingTest/์๊ณ ๋ฆฌ์ฆ-ํ์ด

[๋ฐฑ์ค] 11047 ์ค๋ฒ4 ๋์ 0 java ํ์ด
1. ๋ฌธ์ ์ค๋ช
๐๋ฌธ์ ๋งํฌ์ค๋ช
์ด ์ง๊ด์ ์ด๋ผ ์ถ๊ฐ ์ค๋ช
์๋ต2. ์ ๊ทผ ๋ฐฉ์ ๐๏ธKEY WORD: Greedy Algorithm๋์ ์๊ฐ ๋ฌดํํ๊ธฐ ๋๋ฌธ์ Greedy ์๊ณ ๋ฆฌ์ฆ์ ์ ์ฉํ๋ฉด ๋๋ค. Greedy ์๊ณ ๋ฆฌ์ฆ์ ๋งค ์๊ฐ ์ต์ ์ ์ ํ์ ํ๋ ๊ฒ์ด๋ค. ์ฌ๊ธฐ์ ์ต์ ์ ์ ํ์ ๊ฐ๋ฅํํ ํฐ ๋จ์์ ๋์ ์ ์ฌ์ฉํ์ฌ ๋์ ๊ฐ์๋ฅผ ์ค์ด๋ ๊ฒ์ด๋ค. ๋ฐ๋ผ์ ๋ด๋ฆผ์ฐจ์์ผ๋ก ๋์ ๋จ์๋ฅผ ํ๋์ฉ ํ์ผ๋ฉฐ, K์์ ์ต๋ํ ํฐ ๋จ์์ ๋์ ์ผ๋ก ์ฐจ๊ฐํ๋ค.๋ด๋ฆผ์ฐจ์์ผ๋ก ๋์ ์กฐํ๋ง์ฝ ํ์ฌ ์กฐํ ์ค์ธ ๋์ ์ผ๋ก K์์ ๋๋ ์ ์๋ค๋ฉด? ๋๋ ๋ชซ๋งํผ ๋์ ์ ์ฌ์ฉ ๊ฐ๋ฅํ ๊ฒ์์ผ๋ก ๋ชซ์ ๋ต์ ๋์ ์ํดK์์ (ํด๋น ๋์ ์ ๋จ์ x ๋ชซ) ๋งํผ ์ฐจ๊ฐ๋์์ผ๋ฏ๋ก, ๋๋จธ์ง๋งํผ๋ง ๋จ์์๋ ๊ฒ์ด๋ค. ๋ฐ๋ผ์ K = K%๋จ์๋ก ๊ฐฑ์ ํ๋ค.1,2,3๋ฒ์ K ==..
2024.11.08
CodingTest/์๊ณ ๋ฆฌ์ฆ-ํ์ด