메뉴 리뉴얼

첫 번째 코드

orders = ["ABCFG", "AC", "CDE", "ACDE", "BCFG", "ACDEH"]
course = [2,3,4]

from collections import deque
from itertools import combinations

def solution(orders, course):
    answer = []
    alpha = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I' ,'J', 'K', 'L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z']

    for cnt in course:
        combiList = deque(combinations(alpha, cnt))
        
        for combi in combiList:
            input()
            print("combi = ", combi)
            # combi = ('A', 'B')

            for i in range(len(orders)):
                order = orders[i]
                print("order = ", order)
                # order = "ABCFG"

                for j in range(len(combi)):
                    if combi[j] not in order:
                        break
                    else:
                        continue
        
        # answerCnt = 0
        # for order in orders:
        #     # order = "ABCFG"

            # 만약 뽑은 조합이 이 order 안에 없으면? continue

    # print(combi)

    return answer

print(solution(orders, course))

# A = 'ABCDE'
# if 'AC' in A:
#     print(1)
# else:
#     print(2)

A 부터 Z 까지 가능한 모든 조합을 다 구한 다음 여기서 안되는거 하나씩 없애주려고 했다. 짜면서 도중에 가능한 조합을 출력해보게 되었고, 문득 이게 말이 되나? 라는 생각이 들었다. => 백퍼 시간 초과라고 판단

orders 배열의 크기는 2 이상 20 이하입니다.
course 배열의 크기는 1 이상 10 이하입니다.

근데 뭔가 될 것 같기도 하다. 시간 초과 날꺼 같긴 한데 끝까지 안해봐서 모른다.

두 번째 코드

orders = ["ABCFG", "AC", "CDE", "ACDE", "BCFG", "ACDEH"]
course = [2,3,4]
# result = ["AC", "ACDE", "BCFG", "CDE"]

# orders = ["ABCDE", "AB", "CD", "ADE", "XYZ", "XYZ", "ACD"]
# course = [2,3,5]
# result = ["ACD", "AD", "ADE", "CD", "XYZ"]

# orders = ["XYZ", "XWY", "WXA"]
# course = [2,3,4]
# result = ["WX", "XY"]

from itertools import combinations

def solution(orders, course):
    answer = []
    # dictOrder2 = dict()
    # dictOrder3 = dict()
    # dictOrder4 = dict()
    

    for cnt in course:
        # print("cnt = ", cnt)
        dictOrder = dict()
        for order in orders:
            # print(order)
            A = list(order)

            # ABCFG 에 대해서 가능한 조합 만들어
            combiList = list(combinations(A, cnt))
            for combi in combiList:
                XX = list(combi)
                XX.sort()
                X = ''.join(XX)

                # if cnt == 2:
                if X in dictOrder.keys():
                    nowCnt = int(dictOrder[X])
                    nowCnt += 1
                    dictOrder[X] = nowCnt
                else:
                    dictOrder[X] = 1
        # print("dictOrder = ", dictOrder)
        
        # input()
        sortedDict = sorted(dictOrder.items(), key=lambda x: x[1], reverse=True)
        # print("sortedDict = ", sortedDict)
        if len(sortedDict) >= 1:
            maxInt = sortedDict[0][1]
            for dictOne in sortedDict:
                if dictOne[1] == maxInt and dictOne[1] >= 2:
                    answer.append(dictOne[0])
                else:
                    break
        # print("answer = ", answer)
        # print(answer)
                # if cnt == 3:
                #     if X in dictOrder3.keys():
                #         nowCnt = int(dictOrder3[X])
                #         nowCnt += 1
                #         dictOrder3[X] = nowCnt
                #     else:
                #         dictOrder3[X] = 1
                # if cnt == 4:
                #     if X in dictOrder4.keys():
                #         nowCnt = int(dictOrder4[X])
                #         nowCnt += 1
                #         dictOrder4[X] = nowCnt
                #     else:
                #         dictOrder4[X] = 1

    # sortedDict2 = sorted(dictOrder2.items(), key=lambda x: x[1], reverse=True)
    # sortedDict3 = sorted(dictOrder3.items(), key=lambda x: x[1], reverse=True)
    # sortedDict4 = sorted(dictOrder4.items(), key=lambda x: x[1], reverse=True)
    answer.sort()
    return answer

print(solution(orders, course))

orders 에서 하나 가져와서 그걸로 인해 만들 수 있는 조합을 뽑고 개수를 카운팅 해준다. => 딕셔너리 이용, 가능한 모든 경우를 구한 다음 정렬, 이때 첫 번째 원소(=최대 개수)를 기억해두고 같은 수인걸 다 찾아서 answer에 넣는다.

정답.

깔끔한 코드(주석 제거)

from itertools import combinations

def solution(orders, course):
    answer = []

    for cnt in course:
        dictOrder = dict()
        for order in orders:
            A = list(order)
            combiList = list(combinations(A, cnt))
            
            for combi in combiList:
                XX = list(combi)
                XX.sort()
                X = ''.join(XX)

                if X in dictOrder.keys():
                    nowCnt = int(dictOrder[X])
                    nowCnt += 1
                    dictOrder[X] = nowCnt
                else:
                    dictOrder[X] = 1
        
        sortedDict = sorted(dictOrder.items(), key=lambda x: x[1], reverse=True)
        if len(sortedDict) >= 1:
            maxInt = sortedDict[0][1]
            for dictOne in sortedDict:
                if dictOne[1] == maxInt and dictOne[1] >= 2:
                    answer.append(dictOne[0])
                else:
                    break
        
    answer.sort()
    return answer

print(solution(orders, course))

이것도 마찬가지로 풀어서 다행이긴한데 시간이 너무 오래 걸렸다. 하나하나 프린트 찍어가면서 과정을 지켜보다보니 그런듯 하다.

간단한 로직은 머리속으로 따라라락해서 이렇게 이렇게 하면 이렇게 이렇게 되겠지? 해야 시간이 훨씬 줄어들텐데 아직까진.. 안된다. print 찍어보고 눈으로 확인해봐야 직성이 풀리는 성격이라 그런가