์์ฝ๋ ํ์ด ์ฝ๋์นดํ 2์ฃผ์ฐจ!!
๋๋๋ฆฌ ์ด๋ ต๋ค.....๐
5๋ฌธ์ ์ค์ 2๋ฌธ์ ๋ ๋ชปํ์๋ค....์ฐํํซ......
function romanToNum(s) {
let romanNum = {
I:1,
V:5,
X:10,
L:50,
C:100,
D:500,
M:1000
}
let result = 0;
let sIdx = s.split("");
for(let i = 0; i < s.length; i++) {
if(romanNum[sIdx[i]] < romanNum[sIdx[i+1]]){
result += romanNum[sIdx[i]] - (romanNum[sIdx[i]] * 2);
} else {
result += romanNum[sIdx[i]];
}
}
return result;
}
romanToNum('XXIV'); // 24
์ฝ 1์๊ฐ ๋ฐ...? ๊ฑธ๋ฆฐ ๋ฌธ์ ๐
์ผ๋จ romanNum
์ object๋ก ๋ด์๋๊ณ , result
๋ณ์๋ ์ง์ ํด ์ค๋ค.
๊ทธ๋ค์์ for ๋ฌธ ๋๋ฆฌ๊ธฐ ์ ์ s
๋ฅผ ๊ธ์๋ง๋ค split
์ผ๋ก ์ชผ๊ฐ๋๊ณ , ์ด๋ฅผ sIdx
์ ๋ฃ์ด๋๋๋ค!
๋ง์ฝ ํ์ฌ s
์ ์ธ์๋ก 'XXIV'
๊ฐ ๋ค์ด์๋ค๊ณ ๊ฐ์ ํ์ ๋๋ก ์ค๋ช
๊ธ๊ธ
if
: s์ i ๊ฐ i+1 ๋ณด๋ค ํฐ ์์ผ ๋, ์ฆ, X์ value์ธ 10์ด X์ value์ธ 10๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ์๋ โ result
์ 10์ ๋ํ๋ค!XI
๋, IV
์ ๊ฒฝ์ฐ์๋ ๋ค์ ๊ฒฝ์ฐ์ผ๋๋ else ์กฐ๊ฑด์ผ๋ก ๋์ด๊ฐ๋ค!
else if
: s์ i ๊ฐ i+1 ๋ณด๋ค ํฐ ์์ผ ๋, ์ฆ, I์ value์ธ 1์ด V์ value์ธ 5๋ณด๋ค ์์๋ โ result
์ ( 1 - ( 1 * 2) ) = -1 ๋ฅผ ๋ํ๋ค!ํ๊ตญ๋์ด ํธ์ ๋ฐฉ๋ฒ์ ๋ฃ๊ณ ์ ์ฉํ๊ฑด๋ฐ, ์ด๋ ๊ฒ ์ผ์ ์๋ฆฌ๋ -2, ์ญ์ ์๋ฆฌ๋ -20, ๋ฐฑ์ ์๋ฆฌ๋ -200์ ํด์ฃผ๋ฉด ๋๋ค!
์๋๋ฉด IV = 4, VI = 6 ์ด๋ผ ํญ์ 2์ ์ฐจ์ด๊ฐ ๋๊ณ , ์ด๊ฑด ๋ค๋ฅธ ์ญ์ ์๋ฆฌ, ๋ฐฑ์ ์๋ฆฌ์์๋ ๋ง์ฐฌ๊ฐ์ง์ด๊ธฐ ๋๋ฌธ!
๊ทธ๋์ ๋์ค์ V ๊ฐ ๋ํ ๋ +5 ๋ฅผ ํด์ฃผ๊ธฐ ๋๋ฌธ์ ๊ฒฐ๊ตญ-1 + 5 = 4
ํด์ IV๋ 4๊ฐ ๋๋ค!
else
: ์ ๊ฒฝ์ฐ๊ฐ ๋ชจ๋ ์๋๋!! ์ฆ, i ๊ฐ ์ ์ผ ๋ง์ง๋ง index์ผ๋ ์กฐ๊ฑด์ ํ๋ ๋ ๋ฃ์ด์คฌ๋ค!!์ฒซ๋ฒ์งธ ์กฐ๊ฑด์ ||
์ผ๋ก ๋ฃ์ด์ค๊น ์ถ์ด์ i === s.length[i]
?ใ
ใ
ใ
ใ
ใ
ใ
๋ญ ์ด๋ฐ์์ผ๋ก ๋ฃ์ด๋ดค๋๋ฐ ํ๋ ์์์ใ
๊ด์ค๋์ด ๋ง์ง๋ง์ else
๋ก ๋๋จธ์ง ๊ฒฝ์ฐ๋ฅผ ํ์ณ์ ๋ฃ๋๊ฒ ์ด๋ ๋๊ณ ํ์
์ ๋ฐ๋ก ํด๋ดค๋๋ ์ค1!??!? ๋๋น!!!๐
function romanToNum(s) {
let matching = {
I: 1,
V: 5,
X: 10,
L: 50,
C: 100,
D: 500,
M: 1000
}
let strArr = s.split('');
let numArr = strArr.map(el => matching[el]);
let sum = 0;
for (let i = 0; i < numArr.length; i++) {
if (numArr[i] < numArr[i+1]) {
sum += (numArr[i+1] - numArr[i]);
i++;
} else {
sum += numArr[i];
}
}
return sum;
}
model solution์ ์ฒ์ ๊ด์ค๋์ด ์๊ฐํ์ ๋ฐฉ๋ฒ์ด๋ ๋น์ทํ๋ฐ....
์กฐ๊ฑด์ ๋๋ ๊ฐ๊ณ ! ๊ฒฐ๊ณผ๊ฐ์ ๋ํ ๋ (numArr[i+1] - numArr[i])
์ ๊ฒฐ๊ณผ๊ฐ์ ๋ํด๋ฒ๋ฆฐ๋ค!
๊ทผ๋ฐ ์ด๋ ๊ฒ ํ๋ฉด ๋ฌธ์ ๊ฐ, ๋ค์ ์กฐ๊ฑด์ผ๋ก ๋์ด๊ฐ์๋ ์ด๋ฏธ ๊ณ์ฐ์ด ์๋ฃ๋ numArr[i+1]
๋ก ๋ ๊ณ์ฐํด์ (numArr[i+2] - numArr[i+1])
์ด ๋์ด๋ฒ๋ฆฐ๋ค!
๊ทธ๋์ model solution์์๋ ์กฐ๊ฑด์ ๋ง์ง ์์ผ๋ฉด ๋ค์ for
๋ฌธ์ผ๋ก ๋ฐ๋ก ๋๊ธฐ๊ณ , ๋ง์ฝ ์กฐ๊ฑด์ ๋ง์ ๊ฒฝ์ฐ์๋ i
์ ๊ฐ์ ์๋์ ์ผ๋ก ์ฌ๋ ค์, if ๋ฌธ์์ ์กฐ๊ฑด์ ๋ง์ ๊ฒฝ์ฐ 1๋ฒ + ๋ค์ for
๋ฌธ์ผ๋ก ๋์ด๊ฐ๋ ํ๋ฒ, ์ด +2
๊ฐ ๋๋ค!
let nums = [1];
function moreThanHalf(nums) {
let idx = Math.ceil(nums.length / 2);
let numArr = nums.sort();
let result = numArr[idx];
if(nums.length > idx) {
return result;
} else if(nums.length === 1) {
return parseInt(nums);
} else {
return "๊ณผ๋ฐ์๊ฐ ์๋๋๋ค!"
}
}
moreThanHalf(nums);
์ผ๋จ ๊ณผ๋ฐ์๊ฐ ์ ๋ฐ ์ด์์ธ๊ฐ ์ด๊ณผ์ธ๊ฐ๋ฅผ ๋ชจ๋ฅด๊ฒ ์ด์ ๋ค์ด๋ฒ์ ๊ฒ์ํ๋ฐ.....^p^....
๋ผ๊ณ ํ๋ค.
๊ทธ๋ ๋ค๋ฉด nums Array์ ์์๋ค์ ๋ฎ์ ์ซ์ ๋ถํฐ ๋์ ์ซ์ ์์๋ก ์ ๋ ฌํ ๋ค์์ ๊ทธ ์ค๊ฐ+1
๊ฐ์ ๋ฝ์๋ด๋ฉด ๊ทธ๊ฒ ๋ฐ๋ก ๊ณผ๋ฐ์ ์๋?
์ค์ค ๋ ์ข ์ฒ์ฌ์ธ๋ฏ. ๋ฐ๋ก ํด๋ดค๋ค!!! (์์์ ๊ด์ค๋์ด ์๊พธ count
๊ฐ ์ด์ฉ๊ตฌ ๋ญ์๊ธฐ๊ฐ ์ด์ฉ๊ตฌ๊ฑฐ๋ ธ๋ค๐ค)
๋ฉ์๋๋ ๊ตฌ๊ธ๋ง์ผ๋ก ์์๋๋๋ฐ sort
๋ผ๋ ์ซ์๋ฅผ ์ ๋ ฌํด์ฃผ๋ ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ค!
๋ฐฐ์ด์ ์ค๊ฐ+1 ์์น์ ์๋ index๋ idx
๋ผ๋ ๋ณ์์ Math.ceil(nums.length / 2)
์ด๋ผ๋ ์ฌ๋ฆผ ํจ์๋ก ์ง์ ํ๋ค.
๐คท๐ปโโ๏ธ ์?
์๋ฅผ๋ค์ด ๋ฐฐ์ด์ ๊ธธ์ด๊ฐ 10์ธ๊ฒฝ์ฐ, ์ค๊ฐ ์์น๋5
, ๊ธธ์ด๊ฐ 11์ธ ๊ฒฝ์ฐ์๋ ์ค๊ฐ ์์น5.5
๊ฐ ๋ฐํ๋๋ค.
์ฌ๊ธฐ์ ์ฌ๋ฆผ์ ํ๋ฉด ์ ์๋6
, ํ์๋6
์ด ๋๋ค.
๋ฐ๋ก ๋์ด!!! ๊ทผ๋ฐ ๋ฌธ์ ๋ ๋ฐฐ์ด์ ์์๊ฐ ํ๋์ผ๋!!
ํ๋๋ฉด, 100% ๋๊น ๊ทธ ์์ ์์ฒด๋ฅผ ๋ฐํํ๋ฉด ๋๋ค!
์ด๋ป๊ฒ ์งง๊ฒ ์ธ๊น ๊ณ ๋ฏผํ๋๋ฐ.... ๊ฒฐ๊ตญ ๊ทธ๋ฅ else if
๋ก ๋ฃ์์ใ
ใ
ใ
์งง๊ฒ ๋ฆฌํฉํ ๋ง ํ๊ณ ์ถ๋คใ ใ ์์ด๋์ด ์๋ ๋ถ wecode 9๊ธฐ ๊ฐ์๋ฏธํํ ์ค๋ช ํด์ฃผ์ธ์ฌ.........
์ํผ ๊ทธ๋์ else if
๋ก nums.length
๊ฐ 1์ผ๋๋ฅผ ์กฐ๊ฑด์ผ๋ก ๊ฑธ์ด์ nums๋ฅผ ๋ฐํ!
๊ทผ๋ฐ nums ๋ ๋ฐฐ์ด์ด๋๊น, parseInt
๋ก ์ ์๋ก ๋ณํํด์ฃผ์๋ค!
๊ทธ ์ธ์ ๊ฒฝ์ฐ๋ "๊ณผ๋ฐ์๊ฐ ์๋๋๋ค!" return!
function moreThanHalf(nums) {
let result;
for (let i = 0; i < nums.length; i++) {
let sum = 0;
for (let j = 0; j < nums.length; j++ ) {
if (nums[i] === nums[j]) {
sum += 1;
}
}
if (sum > nums.length/2) {
return nums[i];
}
}
}
function moreThanHalf(nums) {
let obj = {};
let key = '';
let count = nums.length/2;
for (let i = 0; i < nums.length; i++) {
let thisNum = nums[i];
if (obj[thisNum]) {
obj[thisNum]++;
} else {
obj[thisNum] = 1;
}
if (obj[thisNum] > count) {
key = thisNum;
break;
}
}
return Number(key);
}
์ฃผ๋ง์ ๋ด๊ฐ ํ๊ฒ ์ง......๐
()
{}
[]
์ด 3๊ฐ๋ฅผ ๋ฏธ๋ฆฌ ๋ณ์ ์ง์ ํด๋๊ณ , s ์์ ์ด 3๊ฐ์ค์ ์ผ์นํ๋์ ๊ฐ ์์ผ๋ฉด ํด๋นํ๋ ๋ถ๋ถ ์๋ฅด(๋ ค๊ณ ํ๋๋ฐ ์์์ ์ฝ๋๊ฐ ์๋์จ๋ค.)
๊ด์ค๋์ด๋ ์๊ณ ๋ฆฌ์ฆ์ ๋ค ์๊ธฐํ๋๋ฐ ์์์ ์ฝ๋๊ฐ ์๋์จ๋ค..........๐
function getMaxArea(height) {
let result = 0;
let width = 0;
let minHeight = 0;
for(let i = 0; i<height.length; i++) {
for(let j = i+1; j < height.length; j++) {
minHeight = height[i] < height[j] ? height[i] : height[j]
result = result < (minHeight * (j-i)) ? (minHeight * (j-i)) : result;
}
}
return result;
}
let nums = [1, 8, 6, 2, 5, 4, 8, 3, 7];
getMaxArea(nums); // 49
์ผ๋จ... ๋ฉด์ ์ ๋์ด * ๋๋น!!!!!
๊ทผ๋ฐ ์ด๊ฑด ๋ฌผ์ ๋ด์์ผ ํ๋๊น... ๋ฌผ์ด ๋์น์ง ์๊ธฐ ์ํด์ ?
๋์ด โ ๋ heigth ๊ฐ์ ์ต์๊ฐ
๋๋น โ index ๊ฐ์ ์ฐจ์ด
๋ฅผ ์ฐพ์์ผ ํ๋ค!
์ด์ค for ๋ฌธ์ผ๋ก ๋ ๊ฐ์ ๋์ด ์ต์๊ฐ์ ๊ตฌํ ๋ค, ๊ฐ ์ต์๊ฐ์ index๋ฅผ ์ด์ฉํด์ ๋๋น๋ฅผ ๊ตฌํ๋ค.
๋จผ์ , height์ ์ฒซ๋ฒ์งธ ๊ฐ๊ณผ ๋๋จธ์ง ๊ฐ์ ์ผํญ์ฐ์ฐ์๋ฅผ ์ด์ฉํด i
์ i+1
์ ๋น๊ตํด์ ์ต์๊ฐ์ ๊ตฌํ๊ณ , ์ด๋ฅผ minHeight
์ ์ ์ฅํ๋ค.
๋๋น๋ ๋ index์ ์ฐจ์ด๋๊น j-i
๋ก ๊ตฌํ๋ค.
๊ทธ๋ ๊ฒ ์ ์ฅํ ์ต์๊ฐ๊ณผ ๊ตฌํ ๋๋น๋ฅผ ๊ณฑํด์ ์ต์ข
๊ฐ์ธ result
์ ๋น๊ต!
๊ทธ ์ค ๋ ํฐ ๊ฐ์ result
์ ์ ์ฅํ๋ค! ์ด๋ฅผ height
์ ๋ชจ~~๋ index์ ๋ฐ๋ณต!
์๊ณ ๋ฆฌ์ฆ์ ๋นจ๋ฆฌ ์๊ฐํด ๋๋๋ฐ ์์ผ๋ก ์ฐ๋๊ฒ ํ๋ค์๋ค.....
์ฐ๊ณ ๋๋ ์๊ฐ๋ณด๋ค ๊ฐ๋จํ๋ค.
function getMaxArea(height) {
let size = 0;
for (let i = 0; i < height.length; i++) {
for (let j = i+1; j < height.length; j++) {
size = Math.max(Math.min(height[i], height[j]) * (j-i), size);
}
}
return size;
}
์ปฅ....... ๊ฐ์งง๋ค.....๐ญ ํ๋ฌด์ฐ.... ๊ทผ๋ฐ ์๊ณ ๋ฆฌ์ฆ์ ๋๋ ๊ฐ๋ค!
๋๋ ์ต์๊ฐ์ height[i] < height[j]
์ผ๋ก ๊ตฌํ๊ณ , model solution ์ Math.min
๋ฉ์๋๋ฅผ ์ด์ฉํ๋ค.
๊ทธ๋ฆฌ๊ณ ๋๋ ์ต์ข
result
์ result < (minHeight * (j-i))
์ผ๋ก ํฌ๊ธฐ๋ฅผ ๋น๊ตํ๋๋ฐ, model solution ์ Math.max
๋ฉ์๋๋ฅผ ์ด์ฉํ๋ค.
ํ์ค๋ก ๊ฐ๋จํ๊ฒ ๋๋ ์ ์์๋ค...... model solution ์ฉ๋ค....!๐ญ
ํ๊ธฐ : ์น๋ฅ 60%...............