โค๏ธ Problem
- ๋ฌธ์
๋ช ํจ ์ง๊ฐ์ ๋ง๋๋ ํ์ฌ์์ ์ง๊ฐ์ ํฌ๊ธฐ๋ฅผ ์ ํ๋ ค๊ณ ํฉ๋๋ค. ๋ค์ํ ๋ชจ์๊ณผ ํฌ๊ธฐ์ ๋ช ํจ๋ค์ ๋ชจ๋ ์๋ฉํ ์ ์์ผ๋ฉด์, ์์์ ๋ค๊ณ ๋ค๋๊ธฐ ํธํ ์ง๊ฐ์ ๋ง๋ค์ด์ผ ํฉ๋๋ค. ์ด๋ฌํ ์๊ฑด์ ๋ง์กฑํ๋ ์ง๊ฐ์ ๋ง๋ค๊ธฐ ์ํด ๋์์ธํ์ ๋ชจ๋ ๋ช ํจ์ ๊ฐ๋ก ๊ธธ์ด์ ์ธ๋ก ๊ธธ์ด๋ฅผ ์กฐ์ฌํ์ต๋๋ค.
์๋ ํ๋ 4๊ฐ์ง ๋ช ํจ์ ๊ฐ๋ก ๊ธธ์ด์ ์ธ๋ก ๊ธธ์ด๋ฅผ ๋ํ๋ ๋๋ค.
๋ช ํจ ๋ฒํธ ๊ฐ๋ก ๊ธธ์ด ์ธ๋ก ๊ธธ์ด
1 60 50
2 30 70
3 60 30
4 80 40
๊ฐ์ฅ ๊ธด ๊ฐ๋ก ๊ธธ์ด์ ์ธ๋ก ๊ธธ์ด๊ฐ ๊ฐ๊ฐ 80, 70์ด๊ธฐ ๋๋ฌธ์ 80(๊ฐ๋ก) x 70(์ธ๋ก) ํฌ๊ธฐ์ ์ง๊ฐ์ ๋ง๋ค๋ฉด ๋ชจ๋ ๋ช ํจ๋ค์ ์๋ฉํ ์ ์์ต๋๋ค. ํ์ง๋ง 2๋ฒ ๋ช ํจ์ ๊ฐ๋ก๋ก ๋ํ ์๋ฉํ๋ค๋ฉด 80(๊ฐ๋ก) x 50(์ธ๋ก) ํฌ๊ธฐ์ ์ง๊ฐ์ผ๋ก ๋ชจ๋ ๋ช ํจ๋ค์ ์๋ฉํ ์ ์์ต๋๋ค. ์ด๋์ ์ง๊ฐ ํฌ๊ธฐ๋ 4000(=80 x 50)์ ๋๋ค.
๋ชจ๋ ๋ช ํจ์ ๊ฐ๋ก ๊ธธ์ด์ ์ธ๋ก ๊ธธ์ด๋ฅผ ๋ํ๋ด๋ 2์ฐจ์ ๋ฐฐ์ด sizes๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง๋๋ค. ๋ชจ๋ ๋ช ํจ์ ์๋ฉํ ์ ์๋ ๊ฐ์ฅ ์์ ์ง๊ฐ์ ๋ง๋ค ๋, ์ง๊ฐ์ ํฌ๊ธฐ๋ฅผ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
- ์ ํ ์ฌํญ
- sizes์ ๊ธธ์ด๋ 1 ์ด์ 10,000 ์ดํ์ ๋๋ค.
- sizes์ ์์๋ [w, h] ํ์์ ๋๋ค.
- w๋ ๋ช ํจ์ ๊ฐ๋ก ๊ธธ์ด๋ฅผ ๋ํ๋ ๋๋ค.
- h๋ ๋ช ํจ์ ์ธ๋ก ๊ธธ์ด๋ฅผ ๋ํ๋ ๋๋ค.
- w์ h๋ 1 ์ด์ 1,000 ์ดํ์ธ ์์ฐ์์ ๋๋ค.
- ์ ์ถ๋ ฅ ์ & ์ค๋ช
no | sizes | result |
1 | [[60, 50], [30, 70], [60, 30], [80, 40]] | 4000 |
2 | [[10, 7], [12, 3], [8, 15], [14, 7], [5, 15]] | 120 |
3 | [[14, 4], [19, 6], [6, 16], [18, 7], [7, 11]] | 133 |
๐ Solution
ํ์ด 1
class Solution {
public int solution(int[][] sizes) {
int[] width = new int[sizes.length];
int[] vert = new int[sizes.length];
for(int i=0; i<sizes.length; i++) {
width[i] = Math.max(sizes[i][0], sizes[i][1]);
vert[i] = Math.min(sizes[i][0], sizes[i][1]);
}
int maxWidth = width[0];
int maxVert = vert[0];
for(int i=1; i<sizes.length; i++) {
maxWidth = Math.max(maxWidth, width[i]);
maxVert = Math.max(maxVert, vert[i]);
}
return maxWidth*maxVert;
}
}
์ฒ๋ฆฌ์๋ VERY GOOD
ํ์ด 2
class Solution {
public int solution(int[][] sizes) {
int maxWidth = 0;
int maxVert = 0;
for(int i=0; i<sizes.length; i++) {
maxWidth = Math.max(maxWidth, Math.max(sizes[i][0], sizes[i][1]));
maxVert = Math.max(maxVert, Math.min(sizes[i][0], sizes[i][1]));
}
return maxWidth*maxVert;
}
}
์ฒ๋ฆฌ์๋ VERY GOOD
๐ Comment
์ด ๋ฌธ์ ์ ํจ์ ์ ๋ช ํจ์ ๊ฐ๋ก๊ธธ์ด์ ์ธ๋ก๊ธธ์ด๋ฅผ ๋ช ์ํ ์ ์ด๋ค. ๋ฌธ์ ์ค๋ช ์๋ ๋์์๋ฏ์ด 2๋ฒ ๋ช ํจ์ ๊ฐ๋ก๋ก ๋ํ ์๋ฉํ๋ ๊ฒฝ์ฐ ๊ฐ๋ก์ ์ธ๋ก๊ฐ ๋ฐ๋๊ธฐ ๋๋ฌธ์, ๋ฌธ์ ์์ ์ ์ํ ๊ฐ๋ก๊ธธ์ด์ ์ธ๋ก๊ธธ์ด๋ฅผ ์ ๊ฒฝ์ธ ํ์๊ฐ ์๋ค.
ํ์ด 1์์๋ ํ๋ํ๋ ํ์ด์ ์์ฑํ ์ ์ด๊ณ , ํ์ด 2๋ ํด๋น ๊ณผ์ ์ ํฉ์ณ์ ๊ตฌํํ ๊ฒ์ด๋ค. ๊ทธ๋์ ๊ทธ๋ฐ์ง ์ฒ๋ฆฌ ์๋์ ์ ์๋ฏธํ ์ฐจ์ด๊ฐ ์์๋ค. ๋๋ค VERY GOOD ๐
[ํ์ด 1]
ํธ์์ ๊ฐ๋ก ๋ฐฐ์ด(int[] width)์๋ ๊ธด ๊ธธ์ด๋ฅผ, ์ธ๋ก ๋ฐฐ์ด(int[] vert)๋ฅผ ์งง์ ๊ธธ์ด๋ฅผ ๋ฃ๋๋ก ๊ฐ์ ํ๋ค.
for ๋ฐ๋ณต๋ฌธ์ ํตํด ๋ฐฐ์ด์์ sizes[i][0]์ sizes[i][0]๋ฅผ Math.max()์ Math.min()์ผ๋ก ๋น๊ตํ์ฌ ๊ธด ๊ธธ์ด๋ width[i]์, ์งง์ ๊ธธ์ด๋ vert[i]์ ๋ฃ์๋ค.
๊ทธ ๋ค์ ๊ฐ ๋ฐฐ์ด width[]์ vert[]์ ๋ค์ด์๋ ๊ธธ์ด ์ค ๊ฐ์ฅ ๊ธด ๋ณ์ int maxWidth์ int maxVert๋ณ์์ ๊ฐ๊ฐ ๋ฃ์ ๋ค ๋์ด๋ฅผ ๊ตฌํ๊ธฐ ์ํด ์ด ๋ ๋ณ์๋ฅผ ๊ณฑํด์ return ํ์๋ค.
[ํ์ด 2]
ํ์ด 1๊ณผ ๋ฌ๋ฆฌ ๋ฐฐ์ด์ ์ฌ์ฉํ์ง ์๊ณ , ๋ฐ๋ก int maxWidth์ int maxVert๋ฅผ ์ ์ธํ์๋ค. ๋ฐฐ์ด์ ๋ฃ๊ณ ๋น๊ตํ๋ ๊ณผ์ ์ ํ๋ฒ์ ํฉ์น๋๋ก ๊ตฌํํ๋ค.
maxWidth = Math.max(maxWidth, Math.max(sizes[i][0], sizes[i][1]));๋ sizes[i][0]์ sizes[i][1] ์ค์ ํฐ ๊ฐ์ ์ถ์ถํ ๋ค, maxWidth์ ๋น๊ตํ์ฌ ๊ฐ์ฅ ํฐ ๊ฐ์ด maxWidth์ ๋ค์ ๋์ ๋๋๋ก ๊ตฌํํ๋ค.
maxVert = Math.max(maxVert, Math.min(sizes[i][0], sizes[i][1])); ์ญ์ sizes[i][0]์ sizes[i][1] ์ค์ ์์ ๊ฐ์ ์ถ์ถํ ๋ค, maxVert์ ๋น๊ตํ์ฌ ๊ฐ์ฅ ํฐ ๊ฐ์ด maxWidth์ ๋ค์ ๋์ ๋๋๋ก ๊ตฌํํ๋ค.
๋ง์ง๋ง์ผ๋ก ๋์ด๋ฅผ ๊ตฌํ๊ธฐ ์ํด maxWidth์ maxVert๋ฅผ ๊ณฑํด์ returnํ์๋ค.
'Programmers lv-1' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
์ผ์ด์ฌ - Java [์ฝ๋ฉํ ์คํธ ์ฐ์ต] (0) | 2022.12.13 |
---|---|
K๋ฒ์งธ์ - Java [์ฝ๋ฉํ ์คํธ ์ฐ์ต] (0) | 2022.12.13 |
๋ฌธ์์ด ๋ด ๋ง์๋๋ก ์ ๋ ฌํ๊ธฐ - Java [์ฝ๋ฉํ ์คํธ ์ฐ์ต] (1) | 2022.12.12 |
์์ ์ํธ - Java [์ฝ๋ฉํ ์คํธ ์ฐ์ต] (1) | 2022.12.08 |
์์ฐ - Java [์ฝ๋ฉํ ์คํธ ์ฐ์ต] (0) | 2022.12.07 |
3์ง๋ฒ ๋ค์ง๊ธฐ - Java [์ฝ๋ฉํ ์คํธ ์ฐ์ต] (0) | 2022.12.06 |
๋๊ธ