
Problem ๐ป
์ค์๊ฐ์ ์ด๋ค ์ฃผ์ด์ง ๊ฐ๋ค์ ํฌ๊ธฐ์ ์์๋๋ก ์ ๋ ฌํ์ ๋ ๊ฐ์ฅ ์ค์์ ์์นํ๋ ๊ฐ์ ์๋ฏธํฉ๋๋ค. ์๋ฅผ ๋ค์ด 1, 2, 7, 10, 11์ ์ค์๊ฐ์ 7์ ๋๋ค. ์ ์ ๋ฐฐ์ด array๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋, ์ค์๊ฐ์ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด๋ณด์ธ์.
Approach 1 โ
์ด ๋ฌธ์ ๋ฅผ ์ฝ๊ณ ๋ฌธ์ ์ ํฌ์ธํธ๋
1) '์ฃผ์ด์ง ๊ฐ๋ค์ ํฌ๊ธฐ์ ์์๋๋ก ์ ๋ ฌ'
2) '์ ๋ ฌํ์๋ ๊ฐ์ฅ ์ค์์ ์์นํ๋ ๊ฐ'
์ ๊ตฌํ๋ ๊ฒ์ด๋ค.
์ผ๋จ ๋๋ ๋ฐฐ์ด๋ ์์๋ค์ ํฌ๊ธฐ ์์๋๋ก ์ ๋ ฌํ๋ ์ฝ๋๋ฅผ ๋ชจ๋ฅธ๋ค.
๊ทธ๋ฆฌ๊ณ ์์๋ค์ ์ค์๊ฐ์ ์์๋ค์ ํฌ๊ธฐ/2๋ฅผ ํ์ฌ int๋ก ์ถ๋ ฅํ๋ฉด ๋๋ค๋ ํํธ๋ฅผ ์ป์๋ค.
Approach 2 โญ
1. ์ค์๊ฐ์ ์ ์ ํ์ :
- ์ค์๊ฐ์ ๋ฐ์ดํฐ๋ฅผ ํฌ๊ธฐ ์์๋๋ก ์ ๋ ฌํ์ ๋ ๊ฐ์ฅ ๊ฐ์ด๋ฐ์ ์๋ ๊ฐ์ด๋ค.
- ๋ฐฐ์ด์ ๊ธธ์ด๊ฐ ํ์์ผ ๊ฒฝ์ฐ, ๊ฐ์ด๋ฐ ๊ฐ์ด ์ ์ผํ๊ฒ ์กด์ฌํ๋ค.
2. ๋ฌธ์ ๋ฅผ ๋จ๊ณ์ ์ผ๋ก ํด๊ฒฐํ๊ธฐ:
- ๋ฐฐ์ด์ ์ ๋ ฌํ๋ค.
- ์ ๋ ฌ๋ ๋ฐฐ์ด์์ ์ค์์ ์์นํ ๊ฐ์ ์ฐพ์ ๋ฐํํ๋ค.
- ๋ฐฐ์ด์ ๊ธธ์ด๊ฐ ํ์์์ด ๋ณด์ฅ๋๋ค๋ ๋ฌธ์ ์กฐ๊ฑด์ ํ์ฉํ๋ค.
3. ๊ตฌํ ์ธ๋ถ์ฌํญ:
- ๋ฐฐ์ด์ ์ ๋ ฌํ๊ธฐ ์ํด JAVA์ Arrays.sort() ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ค.
- ์ค์๊ฐ์ ์ธ๋ฑ์ค๋ (๋ฐฐ์ด ๊ธธ์ด / 2)๋ก ๊ณ์ฐํ ์ ์๋ค.
Solution ๐ก
java
import java.util.Arrays;
public class MedianFinder {
public static int solution(int[] array) {
// Step 1 : ๋ฐฐ์ด์ ์ ๋ ฌํ๋ค.
Arrays.sort(array);
// step 2 : ๋ฐฐ์ด์ ์ค์๊ฐ์ ๋ฐํํ๋ค.
int medianIndex = array.length / 2; // ๋ฐฐ์ด ๊ธธ์ด๊ฐ ํ์์ผ ๊ฒฝ์ฐ
return array[medianIndex];
}
public static void main(String[] args) {
// ํ
์คํธ ์์
int[] exampleArray = {1, 2, 7, 10, 11};
System.out.println("์ค์๊ฐ: " + solution(exampleArray)); //์ถ๋ ฅ: ์ค์๊ฐ:7
}
}
๋ ผ๋ฆฌ์ ํ์ด ๊ณผ์
1. ๋ฐฐ์ด ์ ๋ ฌ:
- Arrays.sort(array)๋ฅผ ์ฌ์ฉํด์ ๋ฐฐ์ด์ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํ๋ค.
- ์ ๋ ฌ ํ, ์๋ฅผ ๋ค์ด ์ ๋ ฅ ๋ฐฐ์ด์ด {1,2,7,10,11}์ด๋ผ๋ฉด ์ ๋ ฌ๋ ์ํ๋ ๋์ผํ๊ฒ ์ ์ง๋๋ค.
2. ์ค์๊ฐ ์์น ์ฐพ๊ธฐ :
- ์ค์๊ฐ์ ๋ฐฐ์ด ๊ธธ์ด๊ฐ n์ผ ๋, ์ค์ ์ธ๋ฑ์ค๋ n / 2 ๊ฐ ๋๋ค.
- ์๋ฅผ ๋ค์ด, ๋ฐฐ์ด์ ๊ธธ์ด๊ฐ 5๋ผ๋ฉด 5/2 = 2์ด๊ณ , ๋ฐฐ์ด์ 2๋ฒ ์ธ๋ฑ์ค ๊ฐ์ด ์ค์๊ฐ์ด๋ค.
3. ์ค์๊ฐ ๋ฐํ :
๋ฐฐ์ด์์ ํด๋น ์ธ๋ฑ์ค์ ์์นํ ๊ฐ์ ๋ฐํํ๋ค.
์์ผ๋ก ์๊ฐํด๋ณผ ๋ฌธ์ .[์๊ฐ์ ํ์ฅ]
๋ฐฐ์ด์ ๊ธธ์ด๊ฐ ์ง์์ผ ๊ฒฝ์ฐ์๋ ์ด๋ป๊ฒ ํ์ง?
๋ฐฐ์ด์ ๊ธธ์ด๊ฐ ์ง์์ธ ๊ฒฝ์ฐ, ์ค์๊ฐ์ ๋ ์ค์๊ฐ ํ๋ณด์ ํ๊ท ๊ฐ์ ๊ณ์ฐํด์ผ ํ๋ค.
์๋ฅผ ๋ค์ด, ์ ๋ ฌ๋ ๋ฐฐ์ด์ด {1, 2, 3, 4}๋ผ๋ฉด ์ค์๊ฐ ํ๋ณด๋ 2์ 3์ด๊ณ ,
์ค์๊ฐ์ (2+3) / 2 = 2.5๊ฐ ๋๋ค.
ํ์ง๋ง, ๋ฌธ์ ์์ ์ค์๊ฐ์ด ์ ์ํ์ด์ด์ผ ํ๋ค๋ฉด ํ๊ท ๊ฐ์ ๊ณ์ฐํ ๋ ์์์ ์ ๋ฒ๋ ค์ผ ํ๋ค.
java
import java.util.Arrays;
class Solution {
public int solution(int[] array) {
// Step 1 : ๋ฐฐ์ด ์ ๋ ฌ
Arrays.sort(array);
// Step 2 : ๋ฐฐ์ด ๊ธธ์ด์ ๋ฐ๋ผ ์ค์๊ฐ ๊ณ์ฐ
int length = array.length;
if (length % == 1) {
// ๋ฐฐ์ด ๊ธธ์ด๊ฐ ํ์์ธ ๊ฒฝ์ฐ, ์ค์๊ฐ์ ์ค๊ฐ ์ธ๋ฑ์ค์ ๊ฐ
return array[length / 2];
} else {
// ๋ฐฐ์ด ๊ธธ์ด๊ฐ ์ง์์ธ ๊ฒฝ์ฐ, ๋ ์ค์๊ฐ์ ํ๊ท ๊ฐ
int mid1 = array[length / 2 - 1];
int mid2 = array[length /2];
return (mid1 + mid2) / 2 ; // ์ ์ํ ๊ณ์ฐ์ผ๋ก ํ๊ท ๊ฐ ๋ฐํ
}
}
}