알고리즘 - [1차] 다트 게임

 

 

 

생각한건... 앞에서부터 세번째 문자가 isNaN(Not of Number)인지에 따라서 0,3 또는 0,2개로 나눠주는 거였다.

그렇게 해서 배열에 하나씩 푸쉬해서, 세트끼리 묶여있는 것까진 됐는데... 스타상과 아차상이 도저히 어떻게 적용해야할지를 모르겠다,,, reduce로 돌렸을 때 각각의 cur안에서만 영향을 미치는 게 아니라 인덱스가 다른 애한테도 영향을 미치니까 어떻게 해야할지 모르겠음 ㅠㅠ 

function solution(dartResult) {
  let arrays =[];
  // console.log(dartResult.split("").map((el)=> {
  //   console.log(el)
  // }))
  let array = dartResult.split("");
   for(let i = 0; i<array.length; ++i) {
     if(isNaN(array[2])) {
       arrays.push(array.splice(0,3));
     } else arrays.push(array.splice(0,2));
   }
  arrays.push(array)
  
  
  console.log(arrays)
  
  return arrays.reduce((acc,cur,i)=> {
    return acc+(cur[0]**(cur[1]==="S" ? 1 : cur[1]==="D" ? 2 : 3)*(cur[2]==="*" ? 2 : -1));
    

  },0)
}

solution("1S*2T*3S") //23

for(let i = 0; i < arrays.length; ++i) {
    for(let j = 0; j < arrays.length; ++j) {
      console.log(arrays[i][j]**(arrays[i][j]==="S" ? 1 : arrays[i][j]==="D" ? 2 : 3)*(arrays[i][2] && arrays[i+1][2]==="*" && arrays[i][2]==="*" ? 4 : 1 ))
    }

진짜 너무 오바같은데 .. ? ? ? ? ? 하다가 그만뒀다. 

 

그리고 점수가 두 자리일 경우 안된다.... !!!!!ㅠㅠ 이게 젤 중요... 결국 이 방법은...못 쓴다. 

 

 

 

// 멘토님 풀이 

const isBonus = [ "S", "D", "T" ]; // 보너스를 판별하기 위한 배열

function solution(dartResult) {
    var answer = [];
    let score = ""; // 점수만 뽑아서 저장하는 변수
    for (let i = 0; i< dartResult.length; ++i) {
        if(isNaN(dartResult[i]) === false) {
            // 숫자 타입으로 변환한 데이터의 결과가 NaN값이 아닌 경우 (= 숫자가 맞는 경우)
            score += dartResult[i];
        } else {
            // 숫자 타입으로 변환한 데이터의 결과가 NaN 값이 맞는 경우 (= 숫자가 아닌 경우)
            // === 보너스와 옵션이 이쪽으로 처리된다. 
            // 필수적으로 들어오는 보너스를 먼저 처리한다.
            // console.log(dartResult[i])
            
            // isBonus에 있다면 보너스가 맞군! -> "S", "D", "T"만 들어온다. 
            if(isBonus.includes(dartResult[i])) {
                score = Number(score);
                
                if(dartResult[i]==="D") {
                    // 더블이라면 2제곱 
                    score = Math.pow(score,2); // score **= 2;
                } else if(dartResult[i]==="T") {
                    score = score **3; 
                }
                answer.push(score);
                score = ""; // 다음 게임 점수를 받아오기 위해 초기화
                // console.log(dartResult[i], score)
            } else {
                // 옵션은 이곳에서 처리가 된다. ("*", "#")
                // console.log(dartResult[i], answer)
                if(dartResult[i]==="#") {
                    // 아차상일 경우 : 해당 점수를 마이너스 한다.
                    // 현재 점수는 배열의 마지막! 와우... 
                    answer[answer.length-1] *= -1;
                } else {
                    // 스타상일 경우 : 해당 점수에 2를 곱한다. 
                    answer[answer.length-1] *= 2;
                    // 지금 게임이 두번째 이상 게임인지? (배열의 길이가 2 이상일 때) 
                    if(answer.length > 1) {
                        // 앞에 있는 게임에도 2배 적용! 
                        answer[answer.length-2] *= 2;
                    }
                }
            }
        }
    }
       console.log(answer)
    return answer.reduce((acc,cur)=> {
        return acc+cur;
    })
}

숫자를 뽑는 방법이 중요하다!

0부터 10이니까,  두자리까지도 뽑아야한다. 그때 사용할 수 있는게, 문자열로 만들어서 두자릿수까지 가져오게 하는 것.

점수를 뽑아오는 방법 중요중요!!!!!

와우 그러네...

 

메서드로 푸는 법

const isBonus = [ "S", "D", "T" ]; // 보너스를 판별하기 위한 배열

function solution(dartResult) {
  let score = ""; // 문자열에 있는 점수 데이터를 저장
  let currentScore = 0; // 현재 게임(턴)의 점수를 저장
  let last = false; // 점수를 최종적으로 저장할 시점을 저장
    
    return dartResult.split("")
                .reduce((acc,cur,i)=> {
            if(isNaN(cur)===false) {
                score += cur; // 숫자가 맞다면 score에 더해준다.
                last = false; // 새로운 게임이 시작되는 시점 
            } else if(isBonus.includes(cur)) {
                // 보너스 처리
                console.log(cur)
                score = Number(score);
                const squared = isBonus.indexOf(cur) + 1; // 이 부분 잘 모르겠다. 아, 위에! 
                
                currentScore = score ** squared; 
                score = ""; // 다음 게임 받기 위해 
                console.log(cur, dartResult[i+1]) // S 2 를 가져온 경우, D *를 가져온 경우
                
                if(isNaN(dartResult[i+1])===false || dartResult[i+1]===undefined ){
                    // 그 다음거가 숫자면, 
                    // 현재 게임에 옵션이 없고, 그 다음 게임이 시작되었을 때 
                    last = true; // 이렇게 끝내면 그 다음 계~속 last는 true임
                }
            } else { // 옵션 처리
                last = true;
                // console.log(cur,last)
                if(cur === "#") {
                    // 아차상일 경우(현재 게임에 -1을 곱한다.)
                    currentScore *= -1;
                } else {
                    // 스타상일 경우(현재 게임에 2를 곱한다.)
                    currentScore *= 2;
                    if(acc.length > 0) {
                        acc[acc.length-1] *= 2; 
                    }
                }
            }
        if( last ) {
            // 턴이 종료되었을 때만 점수를 최종 저장한다. 
            acc.push(currentScore); 
        }

        return acc; // 이 위에 acc.push하면 반복문 실행될 때마다 push 됨(배열의 길이만큼)
    }, []).reduce((acc,cur)=> {
        return acc+cur;
    })
}

 지금 꼭 메서드로 풀 필요없고 for문으로 연습해도 괜찮음!!

 

이 문제 진짜 너무 어렵다. 집 가면서 생각해보다가 집에서 다시 풀어봐야겠다...!!! 

결국 혼자서는 못 푼 문제..ㅠ ㅠ ㅠ ㅠ ㅠ 

 

집에와서 탈색하며 다시 풀어본 것

const Bonus = ["S", "D", "T"];

function solution(dartResult) {
  let array =[];
  
  let score = "";
  // 1. 문자열 받아내기
  for(let i = 0; i < dartResult.length; ++i) {
    if(!isNaN(dartResult[i])) {
      score += dartResult[i];
    } else if(Bonus.includes(dartResult[i])) {
      console.log(dartResult[i])
      score = Number(score);
      if (dartResult[i]==="D"){
        score **= 2;
      } else if (dartResult[i]==="T") {
        score **= 3;
      }
      array.push(score);
      score = "";
    } else { // 옵션
       if(dartResult[i]==="#") {
         array[array.length-1] *= -1;
       } else {
         array[array.length-1] *= 2;
         if(array[array.length-2]) {
           array[array.length-2] *= 2;
         }
       }
    }
  }
  return array.reduce((acc, cur)=> acc+cur)
}

여기서 **=2, **=3 해줄 때, indexOf에 +1 한 값을 더해줘도 된다!