ํ๋ก๊ทธ๋๋จธ์ค LV. 2
XX๊ฒ์์๋ ํผ๋ก๋ ์์คํ
(0 ์ด์์ ์ ์๋ก ํํํฉ๋๋ค)์ด ์์ผ๋ฉฐ,
์ผ์ ํผ๋ก๋๋ฅผ ์ฌ์ฉํด์ ๋์ ์ ํํํ ์ ์์ต๋๋ค.
์ด๋, ๊ฐ ๋์ ๋ง๋ค ํํ์ ์์ํ๊ธฐ ์ํด ํ์ํ "์ต์ ํ์ ํผ๋ก๋"์
๋์ ํํ์ ๋ง์ณค์ ๋ ์๋ชจ๋๋ "์๋ชจ ํผ๋ก๋"๊ฐ ์์ต๋๋ค.
"์ต์ ํ์ ํผ๋ก๋"๋ ํด๋น ๋์ ์ ํํํ๊ธฐ ์ํด ๊ฐ์ง๊ณ ์์ด์ผ ํ๋ ์ต์ํ์ ํผ๋ก๋๋ฅผ ๋ํ๋ด๋ฉฐ,
"์๋ชจ ํผ๋ก๋"๋ ๋์ ์ ํํํ ํ ์๋ชจ๋๋ ํผ๋ก๋๋ฅผ ๋ํ๋
๋๋ค.
์๋ฅผ ๋ค์ด "์ต์ ํ์ ํผ๋ก๋"๊ฐ 80,
"์๋ชจ ํผ๋ก๋"๊ฐ 20์ธ ๋์ ์ ํํํ๊ธฐ ์ํด์๋ ์ ์ ์ ํ์ฌ ๋จ์ ํผ๋ก๋๋ 80 ์ด์ ์ด์ด์ผ ํ๋ฉฐ,
๋์ ์ ํํํ ํ์๋ ํผ๋ก๋ 20์ด ์๋ชจ๋ฉ๋๋ค.
์ด ๊ฒ์์๋ ํ๋ฃจ์ ํ ๋ฒ์ฉ ํํํ ์ ์๋ ๋์ ์ด ์ฌ๋ฌ๊ฐ ์๋๋ฐ,
ํ ์ ์ ๊ฐ ์ค๋ ์ด ๋์ ๋ค์ ์ต๋ํ ๋ง์ด ํํํ๋ ค ํฉ๋๋ค.
์ ์ ์ ํ์ฌ ํผ๋ก๋ k์ ๊ฐ ๋์ ๋ณ "์ต์ ํ์ ํผ๋ก๋",
"์๋ชจ ํผ๋ก๋"๊ฐ ๋ด๊ธด 2์ฐจ์ ๋ฐฐ์ด dungeons ๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋,
์ ์ ๊ฐ ํํํ ์ ์๋ ์ต๋ ๋์ ์๋ฅผ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
์ ํ์ฌํญ
์ ์ถ๋ ฅ ์
k | dungeons | result |
---|---|---|
80 | [[80,20],[50,40],[30,10]] | 3 |
function solution(k, dungeons) {
const LENG = dungeons.length;
let answer = [];
var visited = Array(LENG).fill(false); // ๋ฐฉ๋ฌธ ์ฌ๋ถ ํ๋จ๋ฐฐ์ด
function DFS(depth, hp) {
answer.push(depth) // ์ต๋ ๋๋ฌํ ๊น์ด๋ฅผ ๋ฐฐ์ด์ ๋ฃ๋๋ค.
for (let i = 0; i < LENG; i++) {
if (!visited[i] & dungeons[i][0] <= hp) {
visited[i] = true
// ํ์ฌ depth๊น์ง ๋ฐฉ๋ฌธํจ์ ์ฒดํฌ
DFS (depth + 1, hp - dungeons[i][1])
// ์ง๊ธ๊น์ง์ ๋์ ํผ๋ก๋์ ๋ค์ depth ๊ฐ ํ์ธ์ ์ํ ์ฌ๊ท
visited[i] = false
// depth์ ์์๋
ธ๋์ ๋๊น์ง ๊ฐ๋ฉด ๋์ผ
// depth์ ๋ค์ ๊ฐ ํ์ธ์ ์ํด false๋ก ๋ณ๊ฒฝ
}
}
}
DFS (0, k)
return Math.max(...answer);
}
์ค๋ซ๋ง์ DFS๋ฌธ์ ๋ฅผ ํ๋ คํ๋ ์ด๋ ค์ ๋ค.. ํ์ง๋ง ๋ค์์ ๊ฐ์ ์ ํ์ ๋ฌธ์ ๊ฐ ๋์ค๋ฉด ํผ์ ํด๊ฒฐ ํ ์ ์์ ๊ฒ ๊ฐ๋ค.
์ํฌ์๋ ์ํ์ ํฌ๊ธฐํ ์ฌ๋์ ์ค๋ง์
๋๋ค.
์ํฌ์ ์ผ์ธ๋ฐฉ์ ๋ชจ์๊ณ ์ฌ์ ์ํ ๋ฌธ์ ๋ฅผ ์ ๋ถ ์ฐ์ผ๋ ค ํฉ๋๋ค.
์ํฌ์๋ 1๋ฒ ๋ฌธ์ ๋ถํฐ ๋ง์ง๋ง ๋ฌธ์ ๊น์ง ๋ค์๊ณผ ๊ฐ์ด ์ฐ์ต๋๋ค.
1๋ฒ ์ํฌ์๊ฐ ์ฐ๋ ๋ฐฉ์: 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, ...
2๋ฒ ์ํฌ์๊ฐ ์ฐ๋ ๋ฐฉ์: 2, 1, 2, 3, 2, 4, 2, 5,
2, 1, 2, 3, 2, 4, 2, 5, ...
3๋ฒ ์ํฌ์๊ฐ ์ฐ๋ ๋ฐฉ์: 3, 3, 1, 1, 2, 2, 4, 4, 5, 5,
3, 3, 1, 1, 2, 2, 4, 4, 5, 5, ...
1๋ฒ ๋ฌธ์ ๋ถํฐ ๋ง์ง๋ง ๋ฌธ์ ๊น์ง์ ์ ๋ต์ด ์์๋๋ก ๋ค์ ๋ฐฐ์ด answers๊ฐ ์ฃผ์ด์ก์ ๋,
๊ฐ์ฅ ๋ง์ ๋ฌธ์ ๋ฅผ ๋งํ ์ฌ๋์ด ๋๊ตฌ์ธ์ง ๋ฐฐ์ด์ ๋ด์ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
์ ํ ์กฐ๊ฑด
์ ์ถ๋ ฅ ์
answers | return |
---|---|
[1,2,3,4,5] | [1] |
[1,3,2,4,2] | [1,2,3] |
function solution(answers) {
const one = [1, 2, 3, 4, 5], two = [2, 1, 2, 3, 2, 4, 2, 5],
three = [3, 3, 1, 1, 2, 2, 4, 4, 5, 5] ;
let answer = [0, 0, 0] // 1,2,3์ ์ ์๋ฅผ ๋ฃ๋ ๋ฐฐ์ด
answers.forEach((a, i) => {
if (a == one[i % 5]){
answer[0] += 1
}
if (a == two[i % 8]){
answer[1] += 1
}
if (a == three[i % 10]){
answer[2] += 1
}
})
let max_answer = Math.max(...answer)
// ์ ์ผ ๋ง์ด ๋ง์ ๊ฐ์ ์์๋ด๊ธฐ
let result = []
answer.forEach((a, i) => {
if(a == max_answer){
result.push(i + 1)
}
}) // ๋ง์ด ๋ง์ ์ฌ๋์ด ๋๊ตฌ์ธ์ง ์ฐพ์ ๋ฐฐ์ด์ ๋ฃ๋๋ค.
return result
}
๋ค์์ ์ํ์ ์ ๋ณด๋ฅผ ๋ด์ FOOD_PRODUCT ํ
์ด๋ธ์
๋๋ค.
FOOD_PRODUCT ํ
์ด๋ธ์ ๋ค์๊ณผ ๊ฐ์ผ๋ฉฐ
PRODUCT_ID, PRODUCT_NAME, PRODUCT_CD, CATEGORY, PRICE๋
์ํ ID, ์ํ ์ด๋ฆ, ์ํ ์ฝ๋, ์ํ๋ถ๋ฅ, ์ํ ๊ฐ๊ฒฉ์ ์๋ฏธํฉ๋๋ค.
FOOD_PRODUCT ํ
์ด๋ธ์์ ๊ฐ๊ฒฉ์ด ์ ์ผ ๋น์ผ ์ํ์
์ํ ID, ์ํ ์ด๋ฆ, ์ํ ์ฝ๋, ์ํ๋ถ๋ฅ, ์ํ ๊ฐ๊ฒฉ์ ์กฐํํ๋
SQL๋ฌธ์ ์์ฑํด์ฃผ์ธ์.
ํ ์ด๋ธ ๊ตฌ์ฑ
Column name | Type | Nullable |
---|---|---|
PRODUCT_ID | VARCHAR(10) | FALSE |
PRODUCT_NAME | VARCHAR(50) | FALSE |
PRODUCT_CD | VARCHAR(10) | TRUE |
CATEGORY | VARCHAR(10) | TRUE |
PRICE | NUMBER | TRUE |
-- MAX() ์ฌ์ฉ
SELECT *
FROM FOOD_PRODUCT
WHERE PRICE = (
SELECT MAX(PRICE)
FROM FOOD_PRODUCT
); // ์ ์ผ ํฐ PRICE๊ฐ๊ณผ ๋์ผํ ๋ฐ์ดํฐ๋ฅผ ์ฐพ์ ์ถ๋ ฅ
-- ORDER BY์ rownum์ ์ฌ์ฉ
SELECT *
FROM (SELECT *
FROM FOODPRODUCT
ORDER BY PRICE DESC); //๋จผ์ PRICE๊ธฐ์ค์ผ๋ก ๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ๋ ฌ
WHERE ROWNUM = 1;
์ ๊ฐ ์๊ฐํด๋ดค์ ๋๋ MAX()๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ด ์ข์ ๊ฒ ๊ฐ์ต๋๋ค.
๊ฐ์ฅ ๋น์ผ PRICE์ ๊ฐ์ ๊ฐ์ง ๋ฐ์ดํฐ๊ฐ 1๊ฐ ์ด์์ผ ๋
์๋ ORDER BY๋ฅผ ์ฌ์ฉํ์ ๋์๋ ๋ฌด์กฐ๊ฑด 1๊ฐ๋ง ๋์ค๊ธฐ ๋๋ฌธ์
MAX()๋ฅผ ์ฌ์ฉํ SQL์ด ์ข๋ ๋ฌธ์ ์์ ์ํ๋ ๊ฒฐ๊ณผ๊ฐ ๋์ค์ง ์์๊น ์๊ฐ๋ญ๋๋ค.