[ํ๋ก๊ทธ๋๋จธ์ค] Lv0 : ์ง์ฌ๊ฐํ ๋์ด ๊ตฌํ๊ธฐ
๋ฌธ์ ์ค๋ช
2์ฐจ์ ์ขํ ํ๋ฉด์ ๋ณ์ด ์ถ๊ณผ ํํํ ์ง์ฌ๊ฐํ์ด ์์ต๋๋ค. ์ง์ฌ๊ฐํ ๋ค ๊ผญ์ง์ ์ ์ขํ [[x1, y1], [x2, y2], [x3, y3], [x4, y4]]๊ฐ ๋ด๊ฒจ์๋ ๋ฐฐ์ด dots๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋, ์ง์ฌ๊ฐํ์ ๋์ด๋ฅผ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด๋ณด์ธ์.
์ ํ์ฌํญ
์ ์ถ๋ ฅ ์
dots | result |
---|---|
[[1, 1], [2, 1], [2, 2], [1, 2]] | 1 |
[[-1, -1], [1, 1], [1, -1], [-1, 1]] | 4 |
์ขํ [[1, 1], [2, 1], [2, 2], [1, 2]] ๋ฅผ ๊ผญ์ง์ ์ผ๋ก ๊ฐ๋ ์ง์ฌ๊ฐํ์ ๊ฐ๋ก, ์ธ๋ก ๊ธธ์ด๋ ๊ฐ๊ฐ 1, 1์ด๋ฏ๋ก ์ง์ฌ๊ฐํ์ ๋์ด๋ 1 x 1 = 1์ ๋๋ค.
์ขํ [[-1, -1], [1, 1], [1, -1], [-1, 1]]๋ฅผ ๊ผญ์ง์ ์ผ๋ก ๊ฐ๋ ์ง์ฌ๊ฐํ์ ๊ฐ๋ก, ์ธ๋ก ๊ธธ์ด๋ ๊ฐ๊ฐ 2, 2์ด๋ฏ๋ก ์ง์ฌ๊ฐํ์ ๋์ด๋ 2 x 2 = 4์ ๋๋ค.
function solution(dots) {
let garo= 0;
let sero= 0;
for(let i=0; i < dots.length-1; i++){
const [x,y] = dots[i]
const [nx,ny] = dots[i+1]
garo = Math.max(Math.abs(nx-x), garo)
sero = Math.max(Math.abs(ny-y), sero)
}
return garo * sero
}
๐ก ์
/์ถ๋ ฅ ์ ๊ทผ
1. ์ง์ฌ๊ฐํ์ ๋์ด๋ฅผ ๊ตฌํ๋ ๊ณต์์ ๊ฐ๋ก x ์ธ๋ก
2. ๊ฐ ๋ณ์ ๊ธธ์ด๋ฅผ ์์๋ด์ผ ํจ.
3. ๋๋ค์ผ๋ก ์
๋ ฅ๋๋ ๊ฐ ๊ผญ์ง์ ์ ํฌ์ธํธ๋ค
3-1. ์
๋ ฅ ๊ฐ์ dots์ ๋ฐฐ์ด์ ์ํํ์ฌ ๊ฐ ๊ฐ์ ํฌ์ธํธ๋ฅผ ๊ตฌ์กฐ๋ถํด ํ ๋น์ผ๋ก ์ ์.
3-2. ๋ค์ ํฌ์ธํธ๊น์ง ํ๋ฒ์ ๊ตฌํด์ ๋ชจ๋๋ฅผ ํฉ์ฐํ ๊ฒฝ์ฐ์ ์ ์ค
4. ๋ณ์ ๊ธธ์ด๋ฅผ ๊ฐ์ง ๊ฐ์ฅ ํฐ ๊ฐ์ ์ถ์ถ.
4-1. for๋ฌธ ์์ ์์ ์์ฌํจ์ผ๋ก์จ ๊ณ์ํด์ max๊ฐ ๋๋ ๊ฐ์ ์ด๊ธฐํํ์ฌ ๊ฐ์ฅ ํฐ ๊ฐ์ ์ฐพ์๋.
5. return ๊ฐ๋ก x ์ธ๋ก
[ํ๋ก๊ทธ๋๋จธ์ค] Lv0 : ์บ๋ฆญํฐ์ ์ขํ
๋ฌธ์ ์ค๋ช
๋จธ์ฑ์ด๋ RPG๊ฒ์์ ํ๊ณ ์์ต๋๋ค. ๊ฒ์์๋ up, down, left, right ๋ฐฉํฅํค๊ฐ ์์ผ๋ฉฐ ๊ฐ ํค๋ฅผ ๋๋ฅด๋ฉด ์, ์๋, ์ผ์ชฝ, ์ค๋ฅธ์ชฝ์ผ๋ก ํ ์นธ์ฉ ์ด๋ํฉ๋๋ค. ์๋ฅผ ๋ค์ด [0,0]์์ up์ ๋๋ฅธ๋ค๋ฉด ์บ๋ฆญํฐ์ ์ขํ๋ [0, 1], down์ ๋๋ฅธ๋ค๋ฉด [0, -1], left๋ฅผ ๋๋ฅธ๋ค๋ฉด [-1, 0], right๋ฅผ ๋๋ฅธ๋ค๋ฉด [1, 0]์
๋๋ค. ๋จธ์ฑ์ด๊ฐ ์
๋ ฅํ ๋ฐฉํฅํค์ ๋ฐฐ์ด keyinput์ ๋งต์ ํฌ๊ธฐ board์ด ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง๋๋ค. ์บ๋ฆญํฐ๋ ํญ์ [0,0]์์ ์์ํ ๋ ํค ์
๋ ฅ์ด ๋ชจ๋ ๋๋ ๋ค์ ์บ๋ฆญํฐ์ ์ขํ [x, y]๋ฅผ returnํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
์ ํ์ฌํญ
์ ์ถ๋ ฅ ์
keyinput | board | result |
---|---|---|
["left", "right", "up", "right", "right"] | [11, 11] | [2,1] |
["down", "down", "down", "down", "down"] | [7, 9] | [0, -4] |
[0, 0]์์ ์ผ์ชฝ์ผ๋ก ํ ์นธ ์ค๋ฅธ์ชฝ์ผ๋ก ํ ์นธ ์๋ก ํ ์นธ ์ค๋ฅธ์ชฝ์ผ๋ก ๋ ์นธ ์ด๋ํ ์ขํ๋ [2, 1]์ ๋๋ค.
[0, 0]์์ ์๋๋ก ๋ค์ฏ ์นธ ์ด๋ํ ์ขํ๋ [0, -5]์ด์ง๋ง ๋งต์ ์ธ๋ก ํฌ๊ธฐ๊ฐ 9์ด๋ฏ๋ก ์๋๋ก๋ ๋ค ์นธ์ ๋์ด์ ์ด๋ํ ์ ์์ต๋๋ค. ๋ฐ๋ผ์ [0, -4]๋ฅผ returnํฉ๋๋ค.
function solution(keyinput, board) {
let x = 0;
let y = 0;
const maxXsize = Math.floor(board[0]/2)
const maxYsize = Math.floor(board[1]/2)
for(let i =0; i < keyinput.length; i++){
let item = keyinput[i]
if(item === 'left' && x > -maxXsize ) {
x--
}
if(item === 'right' && x < maxXsize){
x++
}
if(item === 'up'&& y < maxYsize){
y++
}
if(item === 'down'&& y > -maxYsize){
y--
}
}
return [x, y]
}
๐ก ์
/์ถ๋ ฅ ์ ๊ทผ
1. ์กฐ๊ฑด๋ณด๋ค๋ keyinput์ ์
๋ ฅ ๋ฐฐ์ด์ ์ํํ์ฌ ๊ฐ๊ฐ์ ํค์๋๋ฅผ ์ป์
2. if ์กฐ๊ฑด์ ํตํด ํด๋น ํค์๋์ ๋ง๊ฒ x, y ๊ฐ์ ๋ํ๊ฑฐ๋ ๋บ
3. ํ์ง๋ง board์ ์ต๋, ์ต์ ๊ฐ ๋๋ฌธ์ board ๊ฐ์ ๊ฒฝ๊ณ ์์์ ์์ง์ฌ์ผ ํ๋ ์บ๋ฆญํฐ.
4. ์ ๋ฐ์ ๋๋ ๊ฐ์ ์ต๋ ๊ฐ์ผ๋ก ์ ํ ํ && ์ฐ์ฐ์๋ฅผ ํตํด ์กฐ๊ฑด์ ์ถ๊ฐํด์ค๋ค.
5. return [x, y]
[ํ๋ก๊ทธ๋๋จธ์ค] Lv0 : ๋คํญ์ ๋ํ๊ธฐ
๋ฌธ์ ์ค๋ช
ํ ๊ฐ ์ด์์ ํญ์ ํฉ์ผ๋ก ์ด๋ฃจ์ด์ง ์์ ๋คํญ์์ด๋ผ๊ณ ํฉ๋๋ค. ๋คํญ์์ ๊ณ์ฐํ ๋๋ ๋๋ฅํญ๋ผ๋ฆฌ ๊ณ์ฐํด ์ ๋ฆฌํฉ๋๋ค. ๋ง์
์ผ๋ก ์ด๋ฃจ์ด์ง ๋คํญ์ polynomial์ด ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋, ๋๋ฅํญ๋ผ๋ฆฌ ๋ํ ๊ฒฐ๊ด๊ฐ์ ๋ฌธ์์ด๋ก return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด๋ณด์ธ์. ๊ฐ์ ์์ด๋ผ๋ฉด ๊ฐ์ฅ ์งง์ ์์์ return ํฉ๋๋ค.
์ ํ์ฌํญ
0 < polynomial์ ์๋ ์ < 100
polynomial์ ๋ณ์๋ 'x'๋ง ์กด์ฌํฉ๋๋ค.
polynomial์ ์์ ์ ์, ๊ณต๋ฐฑ, โxโ, โ+'๋ก ์ด๋ฃจ์ด์ ธ ์์ต๋๋ค.
ํญ๊ณผ ์ฐ์ฐ๊ธฐํธ ์ฌ์ด์๋ ํญ์ ๊ณต๋ฐฑ์ด ์กด์ฌํฉ๋๋ค.
๊ณต๋ฐฑ์ ์ฐ์๋์ง ์์ผ๋ฉฐ ์์์ด๋ ๋์๋ ๊ณต๋ฐฑ์ด ์์ต๋๋ค.
ํ๋์ ํญ์์ ๋ณ์๊ฐ ์ซ์ ์์ ์ค๋ ๊ฒฝ์ฐ๋ ์์ต๋๋ค.
" + 3xx + + x7 + "์ ๊ฐ์ ์๋ชป๋ ์ ๋ ฅ์ ์ฃผ์ด์ง์ง ์์ต๋๋ค.
0์ผ๋ก ์์ํ๋ ์๋ ์์ต๋๋ค.
๋ฌธ์์ ์ซ์ ์ฌ์ด์ ๊ณฑํ๊ธฐ๋ ์๋ตํฉ๋๋ค.
polynomial์๋ ์ผ์ฐจ ํญ๊ณผ ์์ํญ๋ง ์กด์ฌํฉ๋๋ค.
๊ณ์ 1์ ์๋ตํฉ๋๋ค.
๊ฒฐ๊ด๊ฐ์ ์์ํญ์ ๋ง์ง๋ง์ ๋ก๋๋ค.
0 < polynomial์ ๊ธธ์ด < 50
์ ์ถ๋ ฅ ์
keyinput | result |
---|---|
"3x + 7 + x" | "4x + 7" |
"x + x + x" | "3x" |
"3x + 7 + x"์์ ๋๋ฅํญ๋ผ๋ฆฌ ๋ํ๋ฉด "4x + 7"์ ๋๋ค.
"x + x + x"์์ ๋๋ฅํญ๋ผ๋ฆฌ ๋ํ๋ฉด "3x"์ ๋๋ค.
function solution(polynomial) {
let value = polynomial.split(' + ')
let x = 0;
let c = 0;
for(let i =0; i<value.length; i++){
let item = value[i]
if(item[item.length-1] !== 'x'){
c += Number(item)
}
else {
//x ์ผ๋
const num = item.split('x')[0]
if(num === ''){
x += 1
}else{
x += Number(num)
}
}
}
let answer = ''
if(x === 1 ) {
answer += 'x'
}
if (x>1){
answer +=`${x}x`
}
if(x===0 && c > 0){
answer += c
}
else if(c > 0){
answer +=` + ${c}`
}
return answer
}
๐ก ์
/์ถ๋ ฅ ์ ๊ทผ
1. polynomial : "3x + 7 + x" ๊ณต๋ฐฑ์ ํฌํจํ ๋ฌธ์์ด ์์ธ ํด๋น ์
๋ ฅ ๊ฐ์ split(" + ")์ ํตํด +๋ฅผ ํฌํจํ ๊ณต๋ฐฑ์ ์ ๊ฑฐํ ๋ฐฐ์ด ๋ฐํ.
=> ["3x","7","x"]
2. if ์กฐ๊ฑด์ ํตํด x๋ฅผ ํฌํจํ ํญ์ธ์ง ์๋์ง ๊ตฌ๋ณ.
2-1. x๊ฐ ์๋๋ฉด ์์ํญ์๋ค ์ถ์ถ๋ ๋ฌธ์์ด ๋๋ฒ๋ฅผ ํ๋ณํํ์ฌ ์ฌํ ๋น.
2-2. x์ด๋ฉด ๋ฌธ์'x'๋ฅผ ๋๋์ด ํ์ํ ์ซ์๋ฅผ ์ถ์ถ ๊ทธ๋ฌ๋ x์ ๊ฐ์ด ํ๋๋ง ์กด์ฌํ ๊ฒฝ์ฐ์ ์๋ ๊ฒฝ์ฐ๋ฅผ ๊ณ ๋ คํ์ฌ if์กฐ๊ฑด ์ถ๊ฐ
3. returnํ answer ์์ฒด๋ฅผ ์ ์ธํ์ฌ ๋ฐํํด์ผํ ๋ฌธ์์ด ์์ ์กฐ๊ฑด์ ํตํด ํ ๋น
3-1. x๊ฐ 1์ผ ๊ฒฝ์ฐ answer์ x ๋ถ๋ถ์ ์ซ์ ์์ด ๋ฌธ์๋ง ์กด์ฌ
3-2. x > 1์ผ ๊ฒฝ์ฐ ์ ์ฅ ๋ x์ ๊ฐ์ ํ
ํ๋ฆฟ ๋ฆฌํฐ๋ด(๋ฐฑํฑ์ผ๋ก ๊ฐ์ผ ๋ฌธ์์ด)์ ํตํด ํด๋น ๊ฐ ํธ์ถ
3-3. x===0 && c >0 ์ผ ๊ฒฝ์ฐ answer๋ c ๊ฐ๋ง ์กด์ฌ
3-4. c > 0๋ ํฌํจ์ผ ๊ฒฝ์ฐ ์ ์ฅ๋ c์ ๊ฐ์ ํธ์ถํ์ฌ ์์ ๋ง๋ฌด๋ฆฌํ์ฌ ๋ฆฌํด.
์ ๋ดค์ต๋๋ค. ์ข์ ๊ธ ๊ฐ์ฌํฉ๋๋ค.