[Coding Club] 23.07.07

일시 : 23.07.07

시간 : 07:30~08:00

문제 : 카드 뭉치,대충 만든 자판

다음 주 과제 : 덧칠하기, 다트

---

1. 카드 뭉치

 

<문제 접근법>

나 : 조건에 해당하면 인덱스 숫자를 더해서 처리하는 방식

순범 : 조건에 해당 되면 인덱스를 제거하는 방식

승호 형 : 조건에 해당 되면 인덱스를 제거하는 방식

신영 : 리스트를 활용하여 인덱스의 순서에 따라서 패널티를 부여하는 방식

 

 

인덱스의 숫자를 더하거나 제거하거나 패널티를 부여하여 푸는 방식으로 풀 수 있었다.

내 생각에는 인덱스의 숫자를 더하거나 제거하는 방식이 가장 깔끔하다고 생각한다.

하지만 그렇다고 패널티를 부여하는 방식이 잘 못 된것은 아니다.

 

정말 신선했다. 이렇게 문제를 풀 수 있을 것이라고는 상상을 하지 못했다.

항상 신영이의 코드를 보면 고민의 흔적이 코드에 고스란히 담기는 것 같다.

어떤 문제를 해결하기 위해서 고민을 한 흔적이...

신영이에게 배울 점이 많다.

(깔끔한 코드는 아니지만 다른 방식으로도 생각을 할 수 있다는 것이 배울 점)

 

# 내 코드 
def solution(cards1, cards2, goal):
    answer = 'Yes'
    card1_idx, card2_idx = 0, 0
    
    for word in goal:
        if len(cards1) > card1_idx and word == cards1[card1_idx]:
            card1_idx += 1
        elif len(cards2) > card2_idx and word == cards2[card2_idx]:
            card2_idx += 1
        else:
            answer = "No"
    
    return answer

# 순범 코드
def solution(cards1, cards2, goal):
    for i in goal:
        if (len(cards1) == 0) & (len(cards1) == 0):
            return "No"

        elif len(cards1) == 0:
            if i == cards2[0]:
                del cards2[0]
            else:
                return "No"

        elif len(cards2) == 0:
            if i == cards1[0]:
                del cards1[0]
            else:
                return "No"
        else:
            if i == cards1[0]:
                del cards1[0]
            elif i == cards2[0]:
                del cards2[0]
            else:
                return "No"

    return "Yes"

# 승호 형 코드
def solution(cards1, cards2, goal):
    cards1.append(' ')
    cards2.append(' ')
    for i in goal:
        # 리스트 두개를 한번에 비교하기 위하여 remove를 사용
        if cards1[0] == i:
            cards1.remove(cards1[0])
        elif cards2[0] == i:
            cards2.remove(cards2[0])
        else:
            return 'No'
    return 'Yes'

# 신영 코드 
# 1. cards1에서 뽑은 것들이 순서대로 있는지 확인
# 2. cards2에서 뽑은 것들이 순서대로 있는지 확인
# 3. 뽑힌것들의 개수와 goal의 개수가 같은지 -> YES else -> NO

def solution(cards1, cards2, goal):
    num1 = []
    num2 = []
    n = 0
    # cards에서 goal과 일치하면 cards의 인덱스를 각각 새로운 배열에 저장
    for i in goal:
        for j in range(0, len(cards1)):
            if i == cards1[j]:
                num1.append(j)
        for k in range(0, len(cards2)):
            if i == cards2[k]:
                num2.append(k)
    # 인덱스가 순서대로 들어있는지 확인 -> 순서대로 들어있지않으면 1점
    for i in range(0, len(num1) - 1):
        if num1[i + 1] - num1[i] != 1:
            n += 1
    for i in range(0, len(num2) - 1):
        if num2[i + 1] - num2[i] != 1:
            n += 1
    # 뽑힌 것들의 개수와 goal 안에 들어있는 개수가 일치하는지 확인
    # -> 일치하지 않으면 1점(cards에 적힌 단어들로 만들 수 없다는 것)
    if len(num1) + len(num2) != len(goal):
        n += 1
    # 0점이면 조건에 부합한다는 것 -> Yes
    if n == 0:
        return "Yes"
    else:
        return "No"

---

2. 대충 만든 자판

 

<문제 접근법>

나 : 두가지의 경우를 모두 구하고 최소인 값을 리턴하는 방식

순범 : 나와 비슷한 방식

승호 형 : 딕셔너리를 활용하여 계산을 하는 방식

신영 : 나와 비슷한 방식이지만 코드는 많이 다름

 

딕셔너리를 활용하여 문제를 푸는 방식은 신선했다.

나는 딕셔너리를 잘 사용하는 방법을 몰라서 생각도 하지 않았다.

너무 내가 아는 것만 활용하려고 하지 말고

새로운 방법도 찾으려고 노력해야 할 필요가 있다고 느꼈다.

 

# 내 코드
def solution(keymap, targets):
    answer = [0] * len(targets)
    for t in range(len(targets)):
        for i in range(len(targets[t])):
            save = []  # targets의 값을 keymap의 인덱스와 비교해서 숫자를 추가해서 비교를 하기 위해 만든 방
            for j in range(len(keymap)): 
                if targets[t][i] in keymap[j]: # keymap의 @번인덱스안에 인덱스들의 값이 있는가?
                    save.append(keymap[j].index(targets[t][i])+1) # 있다면 그 값에 해당되는 keymap의 인덱스를 저장
            if len(save) == 0:   # 저장된 값이 없다면 
                answer[t] = -1   # -1을 호출
                break
            else:
                answer[t] += min(save) # save에 내부의 값 중에서 최소값만 answer에 더하라
    return answer



# 순범 코드
def solution(keymap, targets):
    result = []
    for i in targets:
        score = []
        for j in i:
            idx = []
            cnt = 0
            for k in keymap:
                if k.find(j) != -1:
                    idx.append(k.find(j) + 1)
                else:
                    cnt += 1
            if cnt == len(keymap):
                score.append(-1)
            else:
                score.append(min(idx))
        if -1 in score:
            result.append(-1)
        else:
            result.append(sum(score))
    return result



# 승호 형 코드
def solution_v1(keymap, targets):
    # keymap에 있는 알파벳이 들어갈 딕셔너리 생성
    key_dic = {}

    for i in range(len(keymap)):
        for j in range(len(keymap[i])):
            # 딕셔너리(key_dic) 안에 이미 같은 키가 있고 안의 값이 더 작으면 pass
            if keymap[i][j] in key_dic.keys():
                if key_dic[keymap[i][j]] < j+1:
                    continue
            # 키 : 알파벳 , 값 : 인덱스 + 1
            key_dic[keymap[i][j]] = j+1

    # 결과 담을 리스트
    result = []
    for i in targets:
        a = 0
        for j in i:
            # 알파벳이 딕셔너리(key_dic)안에 있다면 키에 해당하는 값을 더해줌
            if j in key_dic.keys():
                a += key_dic[j]
            # 알파벳이 딕셔너리 안에 없다면 계산이 불가능 하므로 -1
            else:
                a = -1
                break
        result.append(a)
    return result



# 신영 코드
def solution(keymap,targets):
    answer = [0] * len(targets)                     # target개수만큼 answer 배열 요소 생성
    for i in range(len(targets)):                   # 문자열 분리(for 한글자씩 비교)
        targets[i] = list(targets[i])
    for i in range(len(keymap)):
        keymap[i] = list(keymap[i])

    for i in range(len(targets)):
        for j in range(len(targets[i])):
            arr = [101] * len(keymap)               # keymap의 배열 속 배열끼리 비교하기 위해 arr 생성
            for k in range(len(keymap)):            # keymap에서 눌러야하는 횟수(인덱스+1) 각각 arr에 저장
                if targets[i][j] in keymap[k]:
                    arr[k] = keymap[k].index(targets[i][j]) + 1
            targets[i][j] = min(arr)                # targets의 알파벳을 최솟값으로 치환

            if targets[i][j] == 101:                # 101(존재X)이면 -1로 바꿔
                targets[i][j] = -1
        if '-1' in str(targets[i]):                 # 중간에 존재하지 않는 알파벳이 포함된 경우: 나중에 횟수 더해줄때 4 + (-1) + 3 방지
            answer[i] = -1                          # -1 포함하면 answer = -1
        else:
            answer[i] = sum(targets[i])

    return answer

---

 

<문제 풀어보기>

 

프로그래머스

프로그래머스