
์ ํด๋ฆฌ๋ ํธ์ ๋ฒ์ ํฐ ์๋ฅผ ์์ ์๋ก ๋๋๊ณ , ๊ทธ ๋๋จธ์ง๋ฅผ ๊ณ์ ๋๋์ด ๋๊ฐ๋ฉด์
๋๋จธ์ง๊ฐ 0์ด ๋ ๋์ ์๊ฐ ์ต๋๊ณต์ฝ์๊ฐ ๋๋ ๋ฐฉ๋ฒ์ด๋ค.
์ด๊ฑธ ๋ฐ๋ณตํด์ ๊ณ์ฐํ๋ฉด ์ต๋๊ณต์ฝ์๋ฅผ ๋น ๋ฅด๊ฒ ๊ตฌํ ์ ์๋ค.
์ ํด๋ฆฌ๋ ํธ์ ๋ฒ์ ๋ ์์ ์ต๋๊ณต์ฝ์(GCD) ๋ฅผ ๋น ๋ฅด๊ฒ ๊ตฌํ๋ ๋ฐฉ๋ฒ์ด๋ค.
์ด ๋ฐฉ๋ฒ์ ๋๋์ ์ ๋ฐ๋ณตํด์ ์ฌ์ฉํ๋ ๊ฐ๋จํ ์๋ฆฌ๋ก ๋์ํ๋ค.
์ ์ ํด๋ฆฌ๋ ํธ์ ๋ฒ์ด ํ์ํ๊ฐ?
๋ ์์ ์ต๋๊ณต์ฝ์๋ฅผ ๊ตฌํ๋ ค๋ฉด ์ฒ์๋ถํฐ ์ฝ์๋ฅผ ๋ค ์ฐพ์ ๋น๊ตํ๋ฉด ๋๋ฌด ์๊ฐ์ด ์ค๋ ๊ฑธ๋ฆฐ๋ค.
๊ทธ๋์ ๋ ํจ์จ์ ์ผ๋ก ์ต๋๊ณต์ฝ์๋ฅผ ๊ตฌํ๊ธฐ ์ํด ์ ํด๋ฆฌ๋ ํธ์ ๋ฒ์ด ๋ง๋ค์ด์ก๋ค.
์ ํด๋ฆฌ๋ ํธ์ ๋ฒ์ ์๋ฆฌ
๋ ์ a์ b๊ฐ ์์ ๋ (๋จ, a > b๋ผ๊ณ ๊ฐ์ ):
1. a๋ฅผ b๋ก ๋๋ ๋๋จธ์ง๋ฅผ ๊ตฌํ๋ค.
์ด ๋๋จธ์ง๋ฅผ r์ด๋ผ๊ณ ํ์.
2. a๋ฅผ b๋ก ๋ฐ๊พธ๊ณ , b๋ฅผ r๋ก ๋ฐ๊ฟ.
๋ค์ ๋งํด, ๋ ์์ ์์ ๋๋จธ์ง์ ๊ด๊ณ๋ก ๋ฐ๊พธ๋ ๊ฒ์ด๋ค.
3. ๋๋จธ์ง๊ฐ 0์ด ๋ ๋๊น์ง ์ด ๊ณผ์ ์ ๋ฐ๋ณตํ๋ค.
๋๋จธ์ง๊ฐ 0์ด ๋๋ ์๊ฐ, ๊ทธ๋์ b๊ฐ ์ต๋๊ณต์ฝ์(GCD)๊ฐ ๋๋ค.
์์๋ก ์ดํดํ๊ธฐ
12์ 18์ ์ต๋๊ณต์ฝ์๋ฅผ ๊ตฌํด ๋ณด์.
1. ํฐ ์ 18์ ์์ ์ 12๋ก ๋๋ ๋๋จธ์ง๋ฅผ ๊ตฌํ๋ค.
๊ทธ๋์ ๋๋จธ์ง 6์ด๋ค.
2. ์ด์ 18์ 12๋ก ๋ฐ๊พธ๊ณ , 12๋ฅผ ๋๋จธ์ง 6์ผ๋ก ๋ฐ๊พผ๋ค.
๋ค์ ๋๋๋ค:
3. ๋๋จธ์ง๊ฐ 0์ด ๋์๋ค!
์ด๋์ ๊ฐ 6์ด ๋ฐ๋ก ์ต๋๊ณต์ฝ์(GCD)์ด๋ค.
์ฝ๋๋ก ๋ณด๋ฉด ์ด๋ ๊ฒ ๋๋ค.
public int gcd(int a, int b) {
if (b == 0) return a; // ๋๋จธ์ง๊ฐ 0์ด๋ฉด a๊ฐ GCD
return gcd(b, a % b); // b์ ๋๋จธ์ง(a % b)๋ก ๋ค์ GCD ํจ์ ํธ์ถ
}
์ ํด๋ฆฌ๋ ํธ์ ๋ฒ์ ์ฌ๊ท ๊ฐ๋
์ ํด๋ฆฌ๋ ํธ์ ๋ฒ์ ์ฌ๊ท ํจ์์ ๊ตฌ์กฐ๋ฅผ ํ์ฉํด์ ์ต๋๊ณต์ฝ์๋ฅผ ๊ตฌํ๋ค
์ฌ๊ท ํจ์๋ ์๊ธฐ ์์ ์ ํธ์ถํ๋ ํจ์๋ฅผ ๋งํ๋ค.
์ ํด๋ฆฌ๋ ํธ์ ๋ฒ์ ์๋ฆฌ
๋ ์ a์ b(a > b)๊ฐ ์์ ๋:
• GCD(a, b)๋ GCD(b, a % b)์ ๊ฐ๋ค.
• a % b๋ a๋ฅผ b๋ก ๋๋ ๋๋จธ์ง๋ค.
• ๋๋จธ์ง๊ฐ 0์ด ๋๋ฉด, ๊ทธ๋์ b๊ฐ ์ต๋๊ณต์ฝ์(GCD)๋ค.
์ฌ๊ท ํจ์ ์คํ ๊ณผ์ ์์
์๋ฅผ ๋ค์ด, gcd(12, 18)๋ฅผ ๊ตฌํด ๋ณด์:
1. ์ฒซ ํธ์ถ:
gcd(12, 18) → ๋๋จธ์ง 12 % 18 = 12
๋ค์ ํธ์ถ: gcd(18, 12)
2. ๋ ๋ฒ์งธ ํธ์ถ:
gcd(18, 12) → ๋๋จธ์ง 18 % 12 = 6
๋ค์ ํธ์ถ: gcd(12, 6)
3. ์ธ ๋ฒ์งธ ํธ์ถ:
gcd(12, 6) → ๋๋จธ์ง 12 % 6 = 0
๋๋จธ์ง๊ฐ 0์ด๋ฏ๋ก 6์ ๋ฐํ.
์ต์ข ๊ฒฐ๊ณผ: GCD(12, 18) = 6
1. ๊ธฐ๋ณธ ์ ํ - ์ต๋๊ณต์ฝ์ ๊ตฌํ๊ธฐ
๋ฌธ์
๋ ์ ์ a์ b๊ฐ ์ฃผ์ด์ก์ ๋, ์ด ๋์ ์ต๋๊ณต์ฝ์(GCD) ๋ฅผ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
ํ์ด ๊ณผ์
1. ๋ ์๋ฅผ ์ ๋ ฅ๋ฐ๋๋ค.
2. ์ ํด๋ฆฌ๋ ํธ์ ๋ฒ์ ์ฌ์ฉํด ์ต๋๊ณต์ฝ์๋ฅผ ๊ตฌํ๋ค:
• ํฐ ์๋ฅผ ์์ ์๋ก ๋๋ ๋๋จธ์ง๋ฅผ ๊ณ์ ๊ณ์ฐํ๋ค.
• ๋๋จธ์ง๊ฐ 0์ด ๋๋ ์๊ฐ, ์์ ์๊ฐ ์ต๋๊ณต์ฝ์๋ค.
import java.util.Scanner;
public class Main {
// ์ ํด๋ฆฌ๋ ํธ์ ๋ฒ์ผ๋ก ์ต๋๊ณต์ฝ์ ๊ตฌํ๊ธฐ
public static int gcd(int a, int b) {
if (b == 0) return a; //๋๋จธ์ง๊ฐ 0์ด๋ฉด a๊ฐ ์ต๋๊ณต์ฝ์
return gcd(b, a % b); // ์ฌ๊ท์ ์ผ๋ก ํธ์ถ
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int a = sc.nextInt();
int b = sc.nextInt();
System.out.println("์ต๋๊ณต์ฝ์: " + gcd(a, b));
}
}

2. ์์ฉ ์ ํ - ์ต์๊ณต๋ฐฐ์ ๊ตฌํ๊ธฐ
๋ฌธ์
๋ ์ a์ b์ ์ต์๊ณต๋ฐฐ์(LCM) ๋ฅผ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
ํ์ด ๊ณผ์
1. ์ต์๊ณต๋ฐฐ์๋ ์ต๋๊ณต์ฝ์๋ฅผ ์ฌ์ฉํด ๊ตฌํ ์ ์๋ค:

2. ์ ํด๋ฆฌ๋ ํธ์ ๋ฒ์ผ๋ก ๋จผ์ ์ต๋๊ณต์ฝ์๋ฅผ ๊ตฌํ ํ, ์์ ์์ ํตํด ์ต์๊ณต๋ฐฐ์๋ฅผ ๊ณ์ฐํ๋ค.
import java.util.Scanner;
public class Main {
// ์ต๋๊ณต์ฝ์ ๊ตฌํ๊ธฐ
public static int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
// ์ต์๊ณต๋ฐฐ์ ๊ตฌํ๊ธฐ
public static int lcm(int a, int b) {
return (a * b) / gcd(a, b); //LCM๊ณต์
}
public staic void main(String[] args) {
Scanner sc = new Scanner(System.in);
int a = sc.nextInt();
int b = sc.nextInt();
System.out.println("์ต์๊ณต๋ฐฐ์: " + lcm(a, b));
}
}

3. ๋ฌธ์ ์ ํ - ๋ฐฐ์ด์ ์ต๋๊ณต์ฝ์์ ์ต์๊ณต๋ฐฐ์ ๊ตฌํ๊ธฐ
๋ฌธ์
์ฌ๋ฌ ๊ฐ์ ์๊ฐ ๋ด๊ธด ๋ฐฐ์ด์ด ์ฃผ์ด์ง ๋, ๋ฐฐ์ด์ ๋ชจ๋ ์์ ์ต๋๊ณต์ฝ์ ์ ์ต์๊ณต๋ฐฐ์ ๋ฅผ ๊ตฌํ์์ค.
ํ์ด ๊ณผ์
1. ์ต๋๊ณต์ฝ์:
๋ฐฐ์ด์ ์ฒซ ๋ฒ์งธ ๊ฐ๋ถํฐ ์์ฐจ์ ์ผ๋ก GCD๋ฅผ ๊ตฌํ๋ฉด ๋๋ค.
• ์: GCD(GCD(1๋ฒ, 2๋ฒ), 3๋ฒ) … ์ด๋ ๊ฒ ๋ฐ๋ณตํ๋ค.
2. ์ต์๊ณต๋ฐฐ์:
๋ฐฐ์ด์ ์ฒซ ๋ฒ์งธ ๊ฐ๋ถํฐ ์์ฐจ์ ์ผ๋ก LCM์ ๊ตฌํ๋ฉด ๋๋ค.
• ์: LCM(LCM(1๋ฒ, 2๋ฒ), 3๋ฒ) … ์ด๋ ๊ฒ ๋ฐ๋ณตํ๋ค.
public class Main {
// ์ต๋๊ณต์ฝ์ ๊ตฌํ๊ธฐ
public static int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
// ์ต์๊ณต๋ฐฐ์ ๊ตฌํ๊ธฐ
public static int lcm(int a, int b) {
return (a * b) / gcd(a, b);
}
public static void main(String[] args) {
int [] arr = {12, 18, 24}; // ์
๋ ฅ ๋ฐฐ์ด
// ๋ฐฐ์ด์ ์ต๋๊ณต์ฝ์ ๊ตฌํ๊ธฐ
int resutlGCD = arr[0];
for (int i = 1; i < arr.length; i++) {
resultGCD = gcd(resultGCD, arr[i]);
}
// ๋ฐฐ์ด์ ์ต์๊ณต๋ฐฐ์ ๊ตฌํ๊ธฐ
int resultLCM = arr[0];
for (int i = 1; i < arr.length; i++) {
resultLCM = lcm(resultLCM, arr[i]);
}
System.out.println("๋ฐฐ์ด์ ์ต๋๊ณต์ฝ์: " + resultGCD);
System.out.println("๋ฐฐ์ด์ ์ต์๊ณต๋ฐฐ์: " + resultLCM);
}
}

์ฝ๋ ํด์
• ๋ชฉํ: ๋ฐฐ์ด {12, 18, 24}์ ๊ฐ์ ์ฌ๋ฌ ์์ ์ต๋๊ณต์ฝ์๋ฅผ ๊ตฌํ๋ ๊ฒ.
• ๊ณผ์ : ๋ฐฐ์ด์ ๋ชจ๋ ์์์ ๋ํด ๋ ์์ GCD๋ฅผ ์ฐจ๋ก๋ก ๊ตฌํด๋๊ฐ๋ค.
๋จ๊ณ๋ณ ๋์
1. resultGCD๋ฅผ ๋ฐฐ์ด์ ์ฒซ ๋ฒ์งธ ์์๋ก ์ด๊ธฐํํ๋ค.
์: resultGCD = arr[0] = 12
2. for ๋ฐ๋ณต๋ฌธ์ ์ฌ์ฉํด์ ๋ฐฐ์ด์ ๋๋จธ์ง ์์๋ค์ ์ฐจ๋ก๋๋ก ์ํํ๋ค.
3. resultGCD = gcd(resultGCD, arr[i])๋ฅผ ํตํด ํ์ฌ GCD์ ๋ค์ ์์์ ์ต๋๊ณต์ฝ์๋ฅผ ๊ณ์ฐํ๊ณ , ๊ทธ ๊ฐ์ resultGCD์ ์ ์ฅํ๋ค.
์:
• ์ฒซ ๋ฒ์งธ ๋ฐ๋ณต (i = 1): gcd(12, 18) → 6
→ resultGCD = 6
• ๋ ๋ฒ์งธ ๋ฐ๋ณต (i = 2): gcd(6, 24) → 6
→ resultGCD = 6
4. ๋ฐ๋ณต์ด ๋๋๋ฉด resultGCD์ ๋ฐฐ์ด ์ ์ฒด์ ์ต๋๊ณต์ฝ์๊ฐ ์ ์ฅ๋๋ค.
์ฌ๊ท๊ฐ ๋ฐฐ์ด ์ ์ฒด์ ์ ์ฉ๋๋ ๊ณผ์
์์ ์ค๋ช ํ ๋ฐฐ์ด ์ ์ฒด ์ต๋๊ณต์ฝ์ ๊ตฌํ๊ธฐ ์ฝ๋์์๋ gcd ํจ์๋ฅผ ๊ณ์ ํธ์ถํด์ ๊ฐ ์์๋ฅผ ์์ฐจ์ ์ผ๋ก ๋น๊ตํ๋ค.
1. ์ด๊ธฐ๊ฐ: resultGCD = arr[0]
2. ์ฒซ ๋ฐ๋ณต:
• gcd(resultGCD, arr[1]) → ๋ ์์์ ์ต๋๊ณต์ฝ์๋ฅผ ๊ตฌํจ.
3. ๋ค์ ๋ฐ๋ณต:
• ์ด์ ๊น์ง์ ์ต๋๊ณต์ฝ์(resultGCD)์ ๋ค์ ์์(arr[i])๋ฅผ ๋น๊ตํด์ ๋ค์ GCD๋ฅผ ๊ตฌํจ.
4. ๋ฐ๋ณต ๋:
• ์ต์ข resultGCD๋ ๋ฐฐ์ด ์ ์ฒด์ ์ต๋๊ณต์ฝ์๋ค.
์ ํด๋ฆฌ๋ ํธ์ ๋ฒ์ ์ต๋๊ณต์ฝ์๋ฅผ ๋น ๋ฅด๊ฒ ๊ตฌํ๋ ํต์ฌ ์๊ณ ๋ฆฌ์ฆ์ด๋ค. ์ด๋ฅผ ํ์ฉํด ์ต์๊ณต๋ฐฐ์ ๋ฌธ์ ๋ ํด๊ฒฐํ ์ ์๋ค. ์ํ์์๋ ๋ ์๋ฅผ ๋ค๋ฃจ๋ ๊ธฐ๋ณธ ๋ฌธ์ ๋ถํฐ ๋ฐฐ์ด ์ ์ฒด๋ฅผ ๋ค๋ฃจ๋ ๊ณ ๊ธ ๋ฌธ์ ๊น์ง ์ถ์ ๋ ์ ์์ผ๋ ์๋ฆฌ๋ฅผ ์ดํดํ๊ณ ์ฐจ๊ทผ์ฐจ๊ทผ ์ ์ฉํ๋ฉด ๋๋ค.
'๐ฐ๐ท ํ๊ตญ์ด (Korean) > Java Algorithm Coding Test' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
| [Java] ๋ฌธ์์ด ๋ค์ง๊ธฐ (1) | 2024.12.21 |
|---|---|
| [Java] ํผ์ ๋๋ ๋จน๊ธฐ(3)_์ฌ๋ฆผ ๊ณ์ฐ (1) | 2024.12.18 |
| [Java] ํผ์ ๋๋ ๋จน๊ธฐ(2) _ ์ต์ ๊ณต๋ฐฐ์, ์ต๋ ๊ณต์ฝ์, ์ ํด๋ฆฌ๋ ํธ์ ๋ฒ์ ์๋ฆฌ ์ฌ์ฉ (1) | 2024.12.17 |
| [Java] ํผ์ ๋๋ ๋จน๊ธฐ(1)_ ์ฌ๋ฆผ ๊ณ์ฐ (1) | 2024.12.17 |
| [Java] ์ฌ๊ท ํจ์์ ์คํ(Stack)์ ๊ฐ๋ (0) | 2024.12.16 |