๋ฌธ์
Given an array of integers arr, return true if and only if it is a valid mountain array.
Recall that arr is a mountain array if and only if
- arr.length >= 3
- There exists some i with 0 < i < arr.length - 1 such that:
- arr[0] < arr[1] < ... < arr[i - 1] < arr[i]
- arr[i] > arr[i + 1] > ... > arr[arr.length - 1]
๋ฐฐ์ด์ด ์ฐ์ฒ๋ผ ์ค๋ฆ์ฐจ์-๋ด๋ฆผ์ฐจ์์ผ๋ก ์ด๋ฃจ์ด์ ธ์๋์ง ํ์ธํ์ฌ boolean์ผ๋ก ๋ฐํํ๋ ๋ฌธ์ .
์กฐ๊ฑด์ ๋ฐฐ์ด์ ๊ธธ์ด๊ฐ 3 ์ด์์ด์ด์ผ ํ๊ณ , ์ค๋ฆ์ฐจ์๊ณผ ๋ด๋ฆผ์ฐจ์์ ๊ธฐ์ ์ด ๋๋ i์ ๊ฐ์ด ์กด์ฌํด์ผ ํ๋ค.
๋ฌธ์ ์์ ์ ๊ณตํด์ฃผ๋ ์๋ ์ฌ์ง์ ๋ณด๋ฉด ์ดํด๊ฐ ๋ ์ฝ๋ค.
ํ์ด
const validMountainArray = function(arr) {
// ๋ฐฐ์ด์ ๊ธธ์ด๊ฐ 3๋ณด๋ค ์์ผ๋ฉด ๋ฐํํ๋ค
if (arr.length < 3) return false;
// ์ข,์ฐ ํฌ์ธํฐ ํ๋์ฉ ๋๋ค.
let left = 0;
let right = arr.length - 1;
// ๋ฃจํ 1: ์ผ์ชฝ๋ถํฐ ์ค๋ฆ์ฐจ์์ธ์ง ํ์ธ
while (arr[left] < arr[left + 1]) {
left++;
}
// ๋ฃจํ 2: ์ค๋ฅธ์ชฝ๋ถํฐ ์ค๋ฆ์ฐจ์์ธ์ง ํ์ธ
while (arr[right] < arr[right - 1]) {
right--;
}
return left === right && left !== 0 && right !== arr.length - 1;
};
ํฌ์ธํฐ๋ฅผ ๋ค์ํ๊ฒ ์ธ ์ ์๋ ๊ฒ ๊ฐ์ ์ ๋ฆฌ๋ฅผ ํด๋๋ ค๊ณ ํ๋ค.
์ฐ์ ๋ฐฐ์ด์ ๊ธธ์ด๊ฐ 3๋ณด๋ค ์์ผ๋ฉด ๋์ด์ ์งํ ๋์ง ์๊ณ false๋ฅผ ๋ฐํํ๋๋ก ํ๋ค.
์ฒ์์ ์ค๊ฐ๊ฐ์ ๊ธฐ์ค์ผ๋ก ๋ฐ์ ธ๋ณด๋ ค ํ๋๋ฐ ์ ๋์ง ์์์ ์์ชฝ ๋์ ํฌ์ธํฐ๋ฅผ ๋์ด์
์ฐ์ฒ๋ผ ๋๋์ง ํ์ธํด๋ณด๊ธฐ๋ก ํ๋ค.
์ผ์ชฝ ํฌ์ธํฐ๋ ์ผ์ชฝ์์๋ถํฐ ์ค๋ฆ์ฐจ์์ธ์ง,
์ค๋ฅธ์ชฝ ํฌ์ธํฐ๋ ์ญ์์ผ๋ก ๊ฐ๋ฉฐ ์ค๋ฆ์ฐจ์์ธ์ง ํ์ธํ๋ฉฐ ๋ถํฉํ๋ค๋ฉด ์ธ๋ฑ์ค๋ฅผ ๋ํ๊ฑฐ๋ ์ฐจ๊ฐํ๋ค.
์๋ฅผ ๋ค์ด [0,3,4,2,1] ์ด๋ผ๋ ๋ฐฐ์ด์ด ์๋ค๊ณ ํ์.
์ ๋์ ํฌ์ธํฐ๋ฅผ ๋๊ณ ์ฒซ๋ฒ์งธ while๋ฌธ์ ๋ค์ด๊ฐ๋ฉด, ๋ฐฐ์ด์ ํ์ฌ ์ธ๋ฑ์ค ๊ฐ๋ณด๋ค ๋ค์ ์ธ๋ฑ์ค์ ๊ฐ์ด ํฌ๋ค๋ฉด ํฌ์ธํฐ๋ ๊ณ์ ๋ค์ ์ธ๋ฑ์ค๋ก ์ด๋ํ๋ค. ์ฌ๊ธฐ์๋ arr[0]์ธ 0๋ณด๋ค arr[1]์ธ 3์ด ํฌ๋ left๋ ์ฆ๊ฐํ ๊ฒ์ด๋ค.
๋์ด์ ๋ฐฐ์ด์ ๋ค์ ์ธ๋ฑ์ค ๊ฐ์ด ํฌ์ง ์์ ์ง์ ์์ ๋น ์ ธ๋์จ๋ค.
์ฐ์ด๋ผ๋ฉด ๊ผญ๋๊ธฐ์ ํด๋นํ๋ ๋ถ๋ถ์ด๋ค.
์ด์ด์ ๋๋ฒ์งธ while๋ฌธ์ ๋ฐฐ์ด์ ๋ง์ง๋ง ์ธ๋ฑ์ค์์๋ถํฐ ์์ํ๋ค.
๋ฐฐ์ด์ ์ด์ ์ธ๋ฑ์ค ๊ฐ์ด ๋ ํฌ๋ค๋ฉด ํฌ์ธํฐ๋ฅผ ๊ฐ์์์ผ ์ด์ ์ธ๋ฑ์ค๋ก ํฅํ๋ค.
๊ทธ๋ผ ๋ ํฌ์ธํฐ๋ ๊ฐ์ฅ ํฐ ๊ฐ์ธ ์ง์ ์์ ๋ง๋์ ๋ฉ์ถ๊ฒ ๋๋ค.
์ด ๋์ left๋ 2, right๋ 2.
์ฒ์์๋ ๋ ํฌ์ธํฐ์ ๊ฐ์ด ๊ฐ์ ๋๋ง ๋ฐํํ๋๋ก ํ๋๋ฐ,
ํฌ์ธํฐ๊ฐ ์์ง์ด์ง ์์ ๊ฒฝ์ฐ์ ํ
์คํธ์ผ์ด์ค๊ฐ ๋ฐ์ํด์ ํฌ์ธํฐ๊ฐ ์ด๊ธฐ์ํ๊ฐ ์๋ ๊ฒฝ์ฐ๋ฅผ ์กฐ๊ฑด์ ํฌํจ์์ผฐ๋ค.
ํฌํฌ์ธํฐ์ ์๊ฐ๋ณต์ก๋๋ O(n).
๋ค๋ฅธ ํ์ด
var validMountainArray = function(arr, edge = 0) {
for (let i = 1; i < arr.length-1; i++) {
if (arr[i-1] < arr[i] && arr[i] > arr[i+1]) edge++;
if (arr[i-1] >= arr[i] && arr[i] <= arr[i+1]) return false;
}
return edge == 1;
};
ํ๋์ for๋ฌธ์ ํตํด์ ํด๊ฒฐํ๋ค.
edge๋ผ๋ ์ด๊ธฐ๊ฐ์ด 0์ธ ๋ณ์๋ฅผ ์ง์ ํด์คฌ๋๋ฐ, ๊ฐ์ฅ ๊ผญ๋๊ธฐ์ ์๋ ๊ฐ์ด ์กด์ฌํ๋์ง ์ฐพ๋ ์ฝ๋์ด๋ค.
๋ฐฐ์ด์ ์ธ๋ฑ์ค ๊ฐ์ ๊ธฐ์ค์ผ๋ก 1๋ถํฐ ์์ํด์ ์ด์ ๊ฐ์ ๋ ์๊ณ , ์ดํ๊ฐ๋ ์์ ๋๋ฅผ ์ฐพ์ edge๋ฅผ ๋ํด์ค๋ค.
edge๊ฐ ์กด์ฌํ๋ค๋๊ฑด ๊ฒฐ๊ตญ ์ฐ ๋ชจ์์ด ๋๋ ๊ธฐ์ ๊ฐ์ด ์๋ค๋ ๊ฒ!
๋ฉ์ง ๋ฐ์์ธ ๊ฒ ๊ฐ๋ค.
์๋ฌธ์ ์๋์ ๋ณผ ์ ์๋ค.
'๐ Algorithm > LeetCode' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[JavaScript] leetCode : Longest Common Prefix (0) | 2022.05.09 |
---|---|
[JavaScript] leetCode : Linked List Cycle II (3) | 2022.05.03 |
[JavaScript] LeetCode : Add Binary (0) | 2022.04.22 |
[JavaScript] LeetCode : Plus One (0) | 2022.04.21 |
[JavaScript] LeetCode : Largest Number At Least Twice of Others (1) | 2022.04.20 |
Comment