ํ๋ก๊ทธ๋๋จธ์ค 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์ด ์ข๋ ๋ฌธ์ ์์ ์ํ๋ ๊ฒฐ๊ณผ๊ฐ ๋์ค์ง ์์๊น ์๊ฐ๋ญ๋๋ค.