
Problem ๐ป
https://school.programmers.co.kr/learn/courses/30/lessons/12944
ํ๋ก๊ทธ๋๋จธ์ค
SW๊ฐ๋ฐ์๋ฅผ ์ํ ํ๊ฐ, ๊ต์ก, ์ฑ์ฉ๊น์ง Total Solution์ ์ ๊ณตํ๋ ๊ฐ๋ฐ์ ์ฑ์ฅ์ ์ํ ๋ฒ ์ด์ค์บ ํ
programmers.co.kr
๋ฌธ์ ์ค๋ช
์ ์๋ฅผ ๋ด๊ณ ์๋ ๋ฐฐ์ด arr์ ํ๊ท ๊ฐ์ returnํ๋ ํจ์, solution์ ์์ฑํด๋ณด์ธ์.
์ ํ์ฌํญ
- arr์ ๊ธธ์ด 1 ์ด์, 100 ์ดํ์ธ ๋ฐฐ์ด์ ๋๋ค.
- arr์ ์์๋ -10,000 ์ด์ 10,000 ์ดํ์ธ ์ ์์ ๋๋ค.
์ ์ถ๋ ฅ ์
arrreturn| [1,2,3,4] | 2.5 |
| [5,5] | 5 |
Approach 1 โ - ๋์ ์ด๊ธฐ ์ ๊ทผ ๋ฐฉ๋ฒ
1. for๋ฌธ์ ์ด์ฉํ์ฌ ๋ฐฐ์ด์ ์์๋ฅผ ํ๋์ฉ ๊บผ๋ธ๋ค.
2. ๊บผ๋ธ ์์๋ค์ ๋ณ์ sum์ ๋ชจ๋ ๋ํด์ค๋ค.
3. sum์ ๋ฐฐ์ด์ ๊ธธ์ด+1์ ๋๋ ์ค๋ค.
class Solution {
public double solution(int[] arr) {
int x = 0;
int sum = 0;
for (int i = 0; i < arr.length(); i++) {
arr[i] = x;
sum += x;
} return sum / (arr.length() +1);
}
}
Approach 2 โญ - ๋์ ์ฝ๋์ ๋ํ ๊ต์
1. ๋ฐฐ์ด ๊ธธ์ด ์ ๊ทผ ๋ฐฉ์์ ์ค๋ฅ
arr.length()๋ ์๋ชป๋ ์ ๊ทผ.
๋ฐฐ์ด์ ๊ธธ์ด๋ฅผ ๊ฐ์ ธ์ฌ ๋๋ arr.length๋ฅผ ์ฌ์ฉํด์ผ ํ๋ค.
๋ฐฐ์ด์ ๋ฉ์๋๊ฐ ์๋๋ผ ์์ฑ์ผ๋ก ๊ธธ์ด๋ฅผ ์ ๊ณตํ๋ค.
<์์ฑ๊ณผ ๋ฉ์๋์ ์ฐจ์ด>
1. ์์ฑ(Property) :
์์ฑ์ ๊ฐ์ฒด์ ๊ฐ์ ๋ํ๋ด๋ ํ๋์ด๋ค.
๋จ์ํ ๊ฐ์ฒด์ ์ํ๋ฅผ ๋ฐํํ๊ฑฐ๋ ์ค์ ํ ๋ ์ฌ์ฉํ๋ค.
- ํน์ง : ๊ดํธ()๋ฅผ ์ฌ์ฉํ์ง ์๋๋ค.
- ์์ : ๊ฐ์ฒด์ ํฌ๊ธฐ, ๊ธธ์ด, ์ด๋ฆ, ์ํ ๋ฑ๊ณผ ๊ฐ์ด ๋ฐ์ดํฐ ๊ทธ ์์ฒด๋ฅผ ํํํ ๋ ์ฌ์ฉํ๋ค.
2. ๋ฉ์๋(Method) :
๋ฉ์๋๋ ๊ฐ์ฒด์ ๋์์ด๋ ํ์๋ฅผ ์ ์ํ๋ ํจ์์ด๋ค. ํน์ ์์ ์ด๋ ๋ก์ง์ ์คํํ ๋ ์ฌ์ฉํ๋ค.
- ํน์ง : ๊ดํธ()๋ฅผ ํ์ฉํ์ฌ ํธ์ถํ๋ค.
- ์์ : ๋ฐ์ดํฐ๋ฅผ ์กฐ์ํ๊ฑฐ๋ ๊ณ์ฐํ๋ ๋์์ ์ํํ ๋ ์ฌ์ฉ๋๋ค.
<๋ฐฐ์ด์ ๊ธธ์ด : ์ ์์ฑ์ผ๊น?>
์๋ฐ์์ ๋ฐฐ์ด์ ๊ธธ์ด๋ length๋ผ๋ ์์ฑ์ ํตํด ์ ๊ณต๋๋ค.
๋ฐฐ์ด์ ํฌ๊ธฐ๊ฐ ๊ณ ์ ๋์ด ์๊ณ , ๊ทธ ๊ธธ์ด๋ ์์ฑ์ ์ ํด์ง๋ฏ๋ก ๋จ์ํ ๊ทธ ๊ฐ์ ๋ฐํํ๊ธฐ๋ง ํ๋ฉด ๋๋ค.
์ด๋ ๋ฐฐ์ด์ด ์ด๋ฏธ ๊ฐ์ฒด ๋ด๋ถ์ ์ ์ฅํ๊ณ ์๋ ์ํ ์ ๋ณด๋ฅผ ๋ ธ์ถํ๋ ๋์์ด๋ฏ๋ก ์์ฑ์ผ๋ก ๊ตฌํ๋๋ค.
int[] arr = {1,2,3,4};
System.out.println(arr.length); // ๋ฐฐ์ด์ ๊ธธ์ด : 4
์ ๋ฉ์๋๊ฐ ์๋๊น?
๋ฐฐ์ด์ ๊ธธ์ด๋ ์ฐ์ฐ์ด ํ์์๋ ๋จ์ํ ๊ฐ ๋ฐํ์ด๋ค.
๋ฉ์๋ ํธ์ถ์ ์คํ ๋ฉ๋ชจ๋ฆฌ์ ์ถ๊ฐ์ ์ธ ์์ ์ ๋ฐ์์ํค๋ฏ๋ก, ๋จ์ ๋ฐ์ดํฐ ์ ๊ทผ์ ์์ฑ์ผ๋ก ์ฒ๋ฆฌํ๋๊ฒ ๋ ํจ์จ์ ์ด๋ค.
<์์ฑ๊ณผ ๋ฉ์๋๋ฅผ ๊ตฌ๋ถํ๋ ๊ธฐ์ค์ ๋ ์์๋ณผ๊น?>
์์ฑ๊ณผ ๋ฉ์๋๋ฅผ ์ฌ์ฉํ ๋ ๋ค์ ๊ธฐ์ค์ ์ฐธ๊ณ ํ์!
1. ์์ฑ์ ๋ฐ์ดํฐ๋ฅผ ์ง์ ์ ๊ณตํ ๋ ์ฌ์ฉ๋๋ค.
- ๊ฐ์ฒด์ ์ํ๋ฅผ ๋ฐํํ๊ฑฐ๋ ๋ณด์ฌ์ค ๋ ์ฃผ๋ก ์ฌ์ฉํ๋ค.
//์์ฑ ์ฌ์ฉ
String str = "Hello";
int length = str.length(); // ๋ฌธ์์ด์ ๊ธธ์ด๋ ๋ฉ์๋๋ก ์ ๊ณต(๊ณ์ฐ ํ์)
int[] arr = {1, 2, 3};
int arrlength = arr.length; // ๋ฐฐ์ด ๊ธธ์ด๋ ์์ฑ์ผ๋ก ์ ๊ณต(๊ฐ๋ง ๋ฐํ)
2. ๋ฉ์๋๋ ๋์(๊ณ์ฐ , ์กฐ์ ๋ฑ)์ ์ํํ ๋ ์ฌ์ฉ๋๋ค.
String str = "Hello";
String upper = str.toUpperCase(); // ๋ฌธ์์ด์ ๋๋ฌธ์๋ก ๋ณํํ๋ ๋ฉ์๋
int[] arr = {1, 2, 3};
Arrays.sort(arr); // ๋ฐฐ์ด ์์๋ฅผ ์ ๋ ฌํ๋ ๋ฉ์๋
3. ์์ฑ์ ๊ฐ๋ง์ ์ฝ๊ฑฐ๋ ์ค์ ํ ๋ ์ฃผ๋ก ์ฌ์ฉ๋๋ฉฐ, ์ถ๊ฐ ์์ ์ด ํ์ ์๋ค๋ฉด ์์ฑ์ผ๋ก ์ฒ๋ฆฌํ๋ค.
4. ๋ฉ์๋๋ ์ฐ์ฐ, ๋ก์ง, ์ํ ๋ณ๊ฒฝ ๋ฑ์ ์์ ์ด ํ์ํ ๋ ์ฌ์ฉํ๋ค.
<๊ตฌ์ฒด์ ์ธ ์ : ์์ฑ๊ณผ ๋ฉ์๋ ๋น๊ต>
๋ฐฐ์ด์ ๊ธธ์ด
int[] arr = {1, 2, 3, 4};
System.out.println(arr.length); // ์์ฑ : ๋จ์ํ ๊ฐ ๋ฐํ
๋ฌธ์์ด์ ๊ธธ์ด
String str = "Hello";
System.out.println(str.length()); // ๋ฉ์๋ : ๋ฌธ์์ด์ ๊ธธ์ด๋ฅผ ๊ณ์ฐ ํ ๋ฐํ
๋ฌธ์์ด์ ๊ธธ์ด๋ ๋ฉ์๋๋ก ์ ๊ณต๋๋๋ฐ, ์ด์ ๋ ๋ฌธ์์ด์ ๋ถ๋ณ(immutable) ๊ฐ์ฒด๋ก ๋์ํ๋ฉฐ,
๋ด๋ถ์ ์ผ๋ก ๋ฌธ์์ด์ ์ ์ฅํ๋ ๋ฐฉ์์ ๋ฐ๋ผ ๊ธธ์ด๋ฅผ ๊ณ์ฐํด์ผ ํ๊ธฐ ๋๋ฌธ์ด๋ค.
๋ถ๋ณ ๊ฐ์ฒด(immutable Object)๋?
๋ถ๋ณ ๊ฐ์ฒด๋, ํ๋ฒ ์์ฑ๋๋ฉด ์ํ(๊ฐ)๋ฅผ ๋ณ๊ฒฝํ ์ ์๋ ๊ฐ์ฒด๋ฅผ ๋งํ๋ค.
์ฆ, ๊ฐ์ฒด๊ฐ ์์ฑ๋ ํ ๋ด๋ถ ๋ฐ์ดํฐ๋ฅผ ์์ ํ๊ฑฐ๋ ๋ณ๊ฒฝํ ์ ์๋ค.
์๋ฐ์์ ๋ํ์ ์ธ ๋ถ๋ณ ๊ฐ์ฒด๋ String ํด๋์ค์ด๋ค.
๋ถ๋ณ ๊ฐ์ฒด์ ํน์ง :
1. ์ํ ๋ณ๊ฒฝ ๋ถ๊ฐ :
๊ฐ์ฒด๊ฐ ํ ๋ฒ ์์ฑ๋๋ฉด ๋ด๋ถ ๊ฐ์ด๋ ์ํ๋ฅผ ๋ฐ๊ฟ์ ์๋ค.
2. ์ค๋ ๋ ์์ (Thead-safe) :
์ฌ๋ฌ ์ค๋ ๋์์ ๋์์ ๋ถ๋ณ ๊ฐ์ฒด๋ฅผ ์ฝ์ด๋ ์์ ํ๋ค.
๊ฐ์ด ๋ณ๊ฒฝ๋์ง ์์ผ๋ฏ๋ก ๋๊ธฐํ ์์ ์์ด ๊ณต์ ๊ฐ๋ฅํ๋ค.
3. ์ฌ์ฌ์ฉ ๊ฐ๋ฅ :
๊ฐ์ด ๋ณํ์ง ์์ผ๋ฏ๋ก ๋์ผํ ๊ฐ์ ๊ฐ์ง ๊ฐ์ฒด๋ฅผ ์ฌ์ฌ์ฉํ ์ ์๋ค.
์ด๋ ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ์ ํจ์จ์ ์ผ๋ก ๊ด๋ฆฌํ๋๋ฐ ๋์์ ์ค๋ค.
2. ๋ฐฐ์ด ์ด๊ธฐํ ๋ฌธ์
arr[i] = x;
์ด ์ฝ๋๋ ๋ฐฐ์ด์ ์์๋ฅผ ๋ฐ๋ณต๋ฌธ ์์์ x๋ก ๊ณ์ ๋ฎ์ด์ฐ๊ณ ์๋ค.
์ด๋ก ์ธํด ๊ธฐ์กด ๋ฐฐ์ด์ ๊ฐ์ด ๋ชจ๋ ์ฌ๋ผ์ง๊ณ , x์ ์ด๊ธฐ๊ฐ์ธ 0์ผ๋ก ์ฑ์์ง๋ค.
์ด๋ ์๋ ๋ฐฐ์ด์ ํ๊ท ๊ฐ์ ๊ณ์ฐํด์ผ ํ๋ ๋ฌธ์ ์์ ๋ ผ๋ฆฌ์ ์ค๋ฅ์ด๋ค.
3. ํ๊ท ๊ณ์ฐ์์ ์ค๋ฅ
return sum / (arr.length()+1);
๋ฐฐ์ด ๊ธธ์ด์ 1์ ๋ํ๋ ๊ฒ์ ์๋ชป๋ ๊ณ์ฐ์ด๋ค.
๋ฌธ์์์ ์๊ตฌํ ๊ฒ์ ๋ฐฐ์ด์ ์ดํฉ์ ๋ฐฐ์ด์ ๊ธธ์ด๋ก ๋๋ ํ๊ท ์ด๋ค.
๋ฐ๋ผ์ ๋จ์ํ arr.length๋ฅผ ์ฌ์ฉํด์ผ ํ๋ค.
4. ์ ์ ๋๋์ ์ผ๋ก ์ธํ ์์์ ์์ค
int / int ์ฐ์ฐ์ ๊ฒฐ๊ณผ๊ฐ ์ ์๋ก ๋ฐํ๋๋ค.
ํ๊ท ์ ์ ํํ ๊ตฌํ๋ ค๋ฉด ๋๋์ ์ ๊ฒฐ๊ณผ๋ฅผ ์ค์๋ก ๋ฐํํด์ผ ํ๋ค.
์ด๋ฅผ ์ํด sum์ด๋ arr.length๋ฅผ double๋ก ํ ๋ณํํด์ผ ํ๋ค.
Solution ๐ก
class Solutio {
public double solution(int[] arr) {
// 1. ํฉ๊ณ๋ฅผ ์ ์ฅํ ๋ณ์ ์ ์ธ
int sum = 0;
// 2. for ๋ฌธ์ ํตํด ๋ฐฐ์ด ์์๋ฅผ ๋ชจ๋ ๋ํจ.
for (int i = 0; i < arr.length; i++) {
sum += arr[i];
}
//3. ํ๊ท ๊ฐ ๊ณ์ฐ (double๋ก ํ ๋ณํ)
return (double) sum / arr.length;
}
}
1. sum ๋ณ์๋ฅผ ์ ์ธํ์ฌ 0์ผ๋ก ์ด๊ธฐํ.
2. for ๋ฃจํ๋ฅผ ์ฌ์ฉํด์ ๋ฐฐ์ด arr์ ๊ฐ ์์๋ฅผ sum์ ๋ฐ๋ก ๋ํ๋ค.
3. ์ต์ข ํฉ๊ณ๋ฅผ ๋ฐฐ์ด ๊ธธ์ด arr.length๋ก ๋๋์ด ํ๊ท ๊ฐ์ ๊ณ์ฐํ๋ค.
4. ๋๋์ ๊ฒฐ๊ณผ๊ฐ double๋ก ์ ํํ ๊ณ์ฐ๋๋๋ก (double) ํ ๋ณํ์ ์ ์ฉํ๋ค.