๋ฌธ์ ์ ๋ชฉ | ์ ๋ต๋ฅ | ๋์ด๋ |
์ฐ์๋ ๋ถ๋ถ ์์ด์ ํฉ | 49% | Lv.2 |
ํ๋ก๊ทธ๋๋จธ์ค
์ฝ๋ ์ค์ฌ์ ๊ฐ๋ฐ์ ์ฑ์ฉ. ์คํ ๊ธฐ๋ฐ์ ํฌ์ง์ ๋งค์นญ. ํ๋ก๊ทธ๋๋จธ์ค์ ๊ฐ๋ฐ์ ๋ง์ถคํ ํ๋กํ์ ๋ฑ๋กํ๊ณ , ๋์ ๊ธฐ์ ๊ถํฉ์ด ์ ๋ง๋ ๊ธฐ์ ๋ค์ ๋งค์นญ ๋ฐ์ผ์ธ์.
programmers.co.kr
๋ฌธ์ ์์ฝ
์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌ๋ ์์ด๊ณผ ๋ถ๋ถ์์ด์ ํฉ์ด ์ฃผ์ด์ง ๋, ๋ค์ ์กฐ๊ฑด์ ๋ง์กฑํ๋ ๋ถ๋ถ์์ด์ ์กด์ฌํ๋ค. ์ด๋, ์ต์ ๊ธธ์ด๋ฅผ ๊ฐ์ง๋ ๋ถ๋ถ์์ด์ ์ธ๋ฑ์ค๋ฅผ ๋ฐํํ์ฌ๋ผ.
์กฐ๊ฑด 1) ๋ถ๋ถ์์ด์ ๋ ์ธ๋ฑ์ค์ ์์์ ๊ทธ ์ฌ์ด์ ์์๋ฅผ ๋ชจ๋ ํฌํจํ๋ค.
์กฐ๊ฑด 2) ๋ถ๋ถ์์ด์ด ์ฌ๋ฌ ๊ฐ์ธ ๊ฒฝ์ฐ ๊ธธ์ด๊ฐ ์งง์ ์์ด์ ๋ฐํํ๋ค.
์กฐ๊ฑด 3) ๊ธธ์ด๊ฐ ์งง์ ์์ด์ด ์ฌ๋ฌ ๊ฐ์ธ ๊ฒฝ์ฐ ์์ชฝ ์ธ๋ฑ์ค์ ๋ถ๋ถ์์ด์ด ์ต์ ๋ถ๋ถ์์ด์ด๋ค.
์๊ฐํ ๊ฒ
์ฐ์ , '์ฐ์๋'๊ณผ ๋ถ๋ถ์์ด ๋จ์ด๋ฅผ ๋ณด๊ณ ํฌ ํฌ์ธํฐ๋ฅผ ๋ ์ฌ๋ ค์ผ ํ๋ค.
์ฒ์ ์์์ ๋งจ ์์ผ๋ก ํ๋ฉด ๋ ํฌ์ธํฐ๋ ์ฆ๊ฐํด์ผ ํ๋ค.
์์ด์ ํฉ์ ๋๋ฆฌ๋ ค๋ฉด, ์ธ๋ฑ์ค ๋ฒ์๋ฅผ ์ฆ๊ฐ์์ผ์ผ ํ๊ณ , ํฉ์ ์ค์ด๋ ค๋ฉด ์ธ๋ฑ์ค ๋ฒ์๋ฅผ ๊ฐ์์์ผ์ผ ํ๋ค.
- ์์ด์ ํฉ ์ฆ๊ฐ(์ธ๋ฑ์ค ๋ฒ์ ์ฆ๊ฐ)
- startidx ๊ฐ์, ํน์ endidx ์ฆ๊ฐ
- ์์ด์ ํฉ ๊ฐ์(์ธ๋ฑ์ค ๋ฒ์ ๊ฐ์)
- startidx ์ฆ๊ฐ, ํน์ endidx ๊ฐ์
ํ์ด
Step1. ํฉ์ด k๋ณด๋ค ํฐ ๊ฒฝ์ฐ
- ๋ฒ์ ๊ฐ์(startidx ์ฆ๊ฐ)
Step2. ํฉ์ด k๋ณด๋ค ์์ ๊ฒฝ์ฐ
- ๋ฒ์ ์ฆ๊ฐ(endidx ์ฆ๊ฐ)
Step3. ํฉ์ด k์ ๊ฐ์ ๊ฒฝ์ฐ
- ๊ธฐ์กด์ ๋ต์ ๋ฒ์์ ๋น๊ตํ์ฌ, ๊ธฐ์กด ๋ฒ์๋ณด๋ค ์์ ๊ฒฝ์ฐ ์ ๋ฐ์ดํธ(ํฌ๊ฑฐ๋ ๊ฐ์ผ๋ฉด ํ์์ ์ง)
- startidx ์ฆ๊ฐ์์ผ ์๋ก์ด ๋ต ํ์
์ฝ๋
class Solution {
public int[] solution(int[] sequence, int k) {
int[] answer = new int[2];
// ๊ธธ์ด ์์๋ก ํ์
int startidx=0;
int endidx=0;
int sum=0;
int min_range=sequence.length;
while(startidx<=endidx){
if(sum<k){
if (endidx>=sequence.length){
break;
}
sum+=sequence[endidx++];
}else{//sum>k
sum-=sequence[startidx++];
}
if (sum==k){ //์ต์์ ๋น๊ตํ์ฌ ์
๋ฐ์ดํธ
if (min_range>endidx-startidx-1){
answer[0] = startidx;
answer[1] = endidx-1;
min_range=answer[1]-answer[0];
}
}
}
return answer;
}
}
'์๊ณ ๋ฆฌ์ฆ๐ฅ > ๋ฌธ์ ํ์ด (Java)' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Programmers] ๋ฉ๋ด ๋ฆฌ๋ด์ผ (Lv.2) 2023/7/12 (0) | 2023.07.12 |
---|---|
[Programmers] ๋ ์ ์ฌ์ด์ ์ ์ ์ (Lv.2) 2023/6/11 (0) | 2023.06.11 |
[Programmers] ์๊ฒฉ์์คํ (Lv.2) 2023/6/3 (0) | 2023.06.03 |