์ฃผ์๊ฐ๊ฒฉ (with.Java)
์ฃผ์๊ฐ๊ฒฉ (with.Java) ์ ๋ํ์ฌ ์์๋ณธ ๊ธ์ ๋๋ค.
์ฝ๋ฉ ํ ์คํธ ๋ฌธ์ ๋ฅผ ํ๋ฉฐ, ํ์๋ ๋ฌธ์ ์ ๋ํ ํ๊ณ ์ ๋ค๋ฅธ ํ์ด ๋ฐฉ๋ฒ์ ์์๋ณด๋ฉฐ, ์์๊ฐ๊ณ ์ ํฉ๋๋ค.
๋ฌธ์ ์ ๋ํด ๋จผ์ ์์๋ณด๊ฒ ์ต๋๋ค.
๋ฌธ์
์ด ๋จ์๋ก ๊ธฐ๋ก๋ ์ฃผ์๊ฐ๊ฒฉ์ด ๋ด๊ธด ๋ฐฐ์ด prices๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋, ๊ฐ๊ฒฉ์ด ๋จ์ด์ง์ง ์์ ๊ธฐ๊ฐ์ ๋ช ์ด์ธ์ง๋ฅผ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํ์ธ์.
์ ํ์ฌํญ
- prices์ ๊ฐ ๊ฐ๊ฒฉ์ 1 ์ด์ 10,000 ์ดํ์ธ ์์ฐ์์ ๋๋ค.
- prices์ ๊ธธ์ด๋ 2 ์ด์ 100,000 ์ดํ์ ๋๋ค.
์ ์ถ๋ ฅ ์
prices | return |
---|---|
[1, 2, 3, 2, 3] | [4, 3, 1, 1, 0] |
๋ฌธ์ ํ์ด
class Solution {
public int[] solution(int[] prices) {
int[] answer = new int[prices.length];
for(int i = 0; i < prices.length - 1; i++){
int init_0 = prices[i];
int sec = 0;
for(int j = i + 1; j < prices.length; j++){
int init_1 = prices[j];
sec++;
if(init_0 > init_1){
break;
}
}
answer[i] = sec;
}
return answer;
}
}
ํ์ด ์ค๋ช
์ด ์ฝ๋๋ ์ฃผ์ ๊ฐ๊ฒฉ์ ๋ฐฐ์ด์ ์ ๋ ฅ๋ฐ์ ๊ฐ ์ฃผ์ ๊ฐ๊ฒฉ์ด ๋ช ์ด ๋์ ๋จ์ด์ง์ง ์์๋์ง๋ฅผ ๊ณ์ฐํ์ฌ ๋ฐํํ๋ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํฉ๋๋ค.
๋จผ์ ์ฃผ์ ๊ฐ๊ฒฉ์ด ๋จ์ด์ง์ง ์์ ์๊ฐ์ ์ ์ฅํ ๋ฐฐ์ด์ ์์ฑํฉ๋๋ค.
์ด ๋ฐฐ์ด์ ๊ธธ์ด๋ ์ ๋ ฅ ๋ฐฐ์ด๊ณผ ๋์ผํฉ๋๋ค.
์ฒซ ๋ฒ์งธ ๋ฐ๋ณต๋ฌธ์ ํตํด ๊ฐ ์ฃผ์ ๊ฐ๊ฒฉ์ ํ์ธํฉ๋๋ค.
๋ง์ง๋ง ์ฃผ์ ๊ฐ๊ฒฉ์ ๋น๊ตํ ํ์๊ฐ ์์ผ๋ฏ๋ก ์ฃผ์ ๋ฐฐ์ด์ ๊ธธ์ด์์ ํ๋๋ฅผ ๋บ ๋งํผ ๋ฐ๋ณตํฉ๋๋ค.
ํ์ฌ ์ฃผ์ ๊ฐ๊ฒฉ์ ๋ณ์์ ์ ์ฅํ๊ณ ์ฃผ์ ๊ฐ๊ฒฉ์ด ๋จ์ด์ง์ง ์์ ์๊ฐ์ ์ ์ฅํ ๋ณ์๋ฅผ ์ด๊ธฐํํฉ๋๋ค.
๋ ๋ฒ์งธ ๋ฐ๋ณต๋ฌธ์ ํตํด ํ์ฌ ์ฃผ์ ๊ฐ๊ฒฉ ์ดํ์ ์ฃผ์ ๊ฐ๊ฒฉ๋ค์ ํ์ธํฉ๋๋ค.
๋น๊ตํ ์ฃผ์ ๊ฐ๊ฒฉ์ ๋ณ์์ ์ ์ฅํ๊ณ ์ฃผ์ ๊ฐ๊ฒฉ์ด ๋จ์ด์ง์ง ์์์ผ๋ฏ๋ก ์๊ฐ์ 1์ด ์ฆ๊ฐ์ํต๋๋ค.
ํ์ฌ ์ฃผ์ ๊ฐ๊ฒฉ์ด ๋น๊ตํ ์ฃผ์ ๊ฐ๊ฒฉ๋ณด๋ค ํฌ๋ค๋ฉด ์ฃผ์ ๊ฐ๊ฒฉ์ด ๋จ์ด์ง ๊ฒ์ด๋ฏ๋ก ๋ฐ๋ณต๋ฌธ์ ์ข ๋ฃํฉ๋๋ค.
ํ์ฌ ์ฃผ์ ๊ฐ๊ฒฉ์ด ๋จ์ด์ง์ง ์์ ์๊ฐ์ ๋ฐฐ์ด์ ์ ์ฅํฉ๋๋ค.
์ด ๊ณผ์ ์ ํตํด ๋ชจ๋ ์ฃผ์ ๊ฐ๊ฒฉ์ ๋ํด ๋จ์ด์ง์ง ์์ ์๊ฐ์ ๊ณ์ฐํ ํ, ๊ฒฐ๊ณผ ๋ฐฐ์ด์ ๋ฐํํฉ๋๋ค.
์๋ฅผ ๋ค์ด ์ฃผ์ ๊ฐ๊ฒฉ ๋ฐฐ์ด์ด 1, 2, 3, 2, 3์ธ ๊ฒฝ์ฐ ์ฒซ ๋ฒ์งธ ๊ฐ๊ฒฉ 1์ ๋จ์ด์ง์ง ์์ ์๊ฐ์ด 4์ด, ๋ ๋ฒ์งธ ๊ฐ๊ฒฉ 2๋ 3์ด, ์ธ ๋ฒ์งธ ๊ฐ๊ฒฉ 3์ 1์ด, ๋ค ๋ฒ์งธ ๊ฐ๊ฒฉ 2๋ 1์ด, ๋ง์ง๋ง ๊ฐ๊ฒฉ 3์ ๋น๊ตํ ํ์๊ฐ ์์ผ๋ฏ๋ก 0์ด์ ๋๋ค.
๋ฐ๋ผ์ ๊ฒฐ๊ณผ ๋ฐฐ์ด์ 4, 3, 1, 1, 0์ด ๋ฉ๋๋ค.
์ด ์ฝ๋๋ ์ฃผ์ ๊ฐ๊ฒฉ์ด ๋จ์ด์ง์ง ์์ ์๊ฐ์ ํจ์จ์ ์ผ๋ก ๊ณ์ฐํ์ฌ ๋ฐฐ์ด ํํ๋ก ๋ฐํํ๋ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํฉ๋๋ค.