[취업준비일지] - 137

1.소프트웨어의 생명 주기는 소프트웨어 개발 방법론의 바탕이 되는 것으로
소프트웨어 생명 주기 모형에는 폭포수 모형, 프로토타입 모형, 나선형 모형, 에자일 모형 등이 있다.

폭포수 모형은 고전적 생명 주기 모형이라도 불리며
한번 지나간 과정을 다시 수행하지 않기 때문에
각 과정을 철저하게 수행하는 것을 중요시한다.

프로토타입 모형은 시제품을 만들어 중간 평가를 통해 오류를 개선할 수 있는
폭포수 모형의 단점을 보완할 수 있는 모형이다.

나선형 모형은 이름처럼 빙글빙글 돌며 순환하는 개발 과정으로 진행되는데
각각의 과정을 반복하며 점진적으로 완벽한 산출물을 만들기 위한 방식이기 때문에
점진적 모형이라고 불린다.

애자일 모형은 요즘 개발의 트렌드로 볼 수 있는데
특정 방법에 집중하지 않고 빠르고 효율적으로 소통을 통해 만들어나가려는 방법론이다.

애자일 모형을 바탕으로 발전된 개발 모형에는
스크럼, 칸반, 린, 크리스탈, 기능 중심 개발(FDD), DSDM, DAD 등이 있다.


2.스크럼 기법은 애자일에서 언급되었던 방법론 중 하나로
팀 중심으로 개발 효율성을 높이려는 기법이다.

개발팀에는 제품 책임자, 스크럼 마스터, 개발팀으로 구성되며
제품 책임자에는 주로 의뢰자 또는 사용자 등에서 맡으며
우선순위, 일정, 요구사항 등을 정리한다.

스크럼 마스터는 스크럼 회의를 주관하며 진행사항 점검 및 장애 요소 공론화 등을 담당하며
팀원 각각을 통제하지는 않지만 조언하는 역할을 맡고 있다.

마지막으로 개발팀에는 개발자, 디자이너, 테스터 등 개발 관련자들이 포함된다.

 

 

 

 

 

(1).백준 2667번 단지번호붙이기는 
기존에 진행된 지렁이 문제와 유사한 느낌이지만
각각 처리 횟수를 추가적으로 요구하고 정렬까지 추가된 문제였다.

일단 matrix를 구성하기 위해 문자열 처리를 진행한 다음
dfs와 bfs 중 dfs 탐색을 골랐는데
bfs도 가능하지만 queue보다는 stack이 빠르기 때문에 
둘 다 가능할 경우 dfs가 더 빠르게 처리가 될 것 같다고 생각했다.

인접한 덩어리들은 dfs 또는 bfs로 처리할 경우 다 사라지기 때문에
for문에서 전체 배열을 순회하며 dfs를 실행하고
dfs에서는 내부 stack의 처리 횟수를 보며 몇개의 건물이 인접해있는지를 count로 확인했다.

또한 이 count들을 result에 모아서 몇개의 단지가 있는지를 result.length로 구분했으며
count는 오름차순으로 출력해줬다.

const input = `7
0110100
0110101
1110101
0000111
0100000
0111110
0111000`.split('\n')

const length = Number(input[0])
const matrix = input.slice(1).map(el => el.split('').map(Number))
const result = []

const dfs = (x,y) => {
    let count = 1
    const stack = [[x,y]]
    matrix[x][y] = 0
    while (stack.length) {
        const [xNow, yNow] = stack.pop()
        if(matrix[xNow+1] && matrix[xNow+1][yNow]){
            count++
            matrix[xNow+1][yNow] = 0
            stack.push([xNow+1,yNow])
        }
        if(matrix[xNow-1] && matrix[xNow-1][yNow]){
            count++
            matrix[xNow-1][yNow] = 0
            stack.push([xNow-1,yNow])
        }
        if(matrix[xNow][yNow+1]){
            count++
            matrix[xNow][yNow+1] = 0
            stack.push([xNow,yNow+1])
        }
        if(matrix[xNow][yNow-1]){
            count++
            matrix[xNow][yNow-1] = 0
            stack.push([xNow,yNow-1])
        }
        
    }
    
    return count
}

for(let i = 0 ; i < length ; i++){
    for(let j = 0 ; j < length ; j++){
        if(matrix[i][j]){
            result.push(dfs(i,j))
        }
    }
}

console.log(result.length)
console.log(result.sort((a,b) => a-b).join('\n'))

(2).프로그래머스 카드 뭉치는 의외로 까다로운 문제였는데(첫 접근방식을 이상하게 해서)
cards1, cards2라는 두 개의 카드 뭉치에서 원하는 것을 사용할 수 있지만
맨 앞에서부터 꺼낼 수 있는 queue 형태로 설정되어 있기 때문에
goal에 담긴 원하는 문자열을 만들 수 있는지를 묻는 문제였다.

처음에는 간단하게 순차적으로 사용된다면 맨 앞에 불필요한 문자가 없으며
매칭된 goal의 index가 오름차순이면 가능하다고 보고 맨 아래의 주석처리된 코드를 제출했지만
중간에 쓸대없는 코드가 들어갈 경우 문제가 발생했고
그 문제를 해결하기 위해 쓸대없는 코드가 들어갈 경우 "No"를 출력했지만
두 개의 카드뭉치였기 때문에 A로만 가능해도 
B에 쓸모없는 카드가 앞에 있는 경우 "No"가 나오기 때문에 통과되지 않았다.

결국 순차적으로 자료를 확인하는 방식으로 진행해야 한다는 생각이 들었고
shift를 지속적으로 사용하는 것 보다는 
한번 reverse를 사용한 다음 pop을 사용하는 것이 더 효율적이라고 생각했다.

indexOf 또는 includes를 사용하면 시간복잡도가 증가하기 때문에
현재 조회해야 하는 goal의 index를 count에 대입했고
또한 이 count 값은 goal의 길이와 비교해 종료 시점을 정하는 키로도 사용했다.

각각의 비교를 위해 pop을 사용했기 때문에 내부가 아닌 최상단으로 끌어올렸으며
그 카드를 사용하지 않을 경우 다시 push하는 방식으로 진행했다.

요약하자면 1번, 2번 뭉치의 첫 번째 카드를 미리 꺼낸 다음
goal의 0번째 카드가 1번 뭉치에 있는 경우 2번 뭉치의 카드는 다시 집어넣고
2번 뭉치의 카드가 goal의 0번째 카드와 같은 경우 1번 뭉치의 카드를 다시 집어넣었으며
goal n번째의 카드가 1, 2번에 모두 존재하지 않는 경우 만들 수 없으니 "No"를 출력했고
while문의 순회가 끝났다는 것은 goal을 완성했다는 의미기 때문에 "Yes"가 출력된다.

function solution(cards1, cards2, goal) {
    let count = 0
    cards1 = cards1.reverse()
    cards2 = cards2.reverse()
    while(count < goal.length){
        const card1 = cards1.pop()
        const card2 = cards2.pop()
        if(goal[count] === card1){
           count++
           cards2.push(card2)
        }
        else if(goal[count] === card2){
            count++
            cards1.push(card1)
        }
        else{
            return "No"
        }
    }
    return "Yes"
}


//1~24번은 통과되고 25번은 되지 않던 코드
// function solution(cards1, cards2, goal) {
//     const indexCheck = {}
//     for(let i = 0 ; i < goal.length ; i++){
//         indexCheck[goal[i]] = i
//     }
//     for(let i = 1 ; i < cards1.length ; i++){
//         if(indexCheck[cards1[i]] < indexCheck[cards1[i-1]] || indexCheck[cards1[i-1]] === undefined) return "No"
//     }
//     for(let i = 1 ; i < cards2.length ; i++){
//         if(indexCheck[cards2[i]] < indexCheck[cards2[i-1]] || indexCheck[cards2[i-1]] === undefined) return "No"
//     }
//     return "Yes"
// }