ONE MAN GAME DEV

내 인생에서 믿을 건 오직 나 자신뿐!

The only one you can truly trust is yourself.

게임 프로그래밍/Python 프로그래밍

프로그래머스 단어 퍼즐

🎮inspirer9 2023. 2. 14. 05:27

728x90

단어 퍼즐

문제 설명

단어 퍼즐은 주어진 단어 조각들을 이용해서 주어진 문장을 완성하는 퍼즐입니다. 이때, 주어진 각 단어 조각들은 각각 무한개씩 있다고 가정합니다. 예를 들어 주어진 단어 조각이 [“ba”, “na”, “n”, “a”]인 경우 "ba", "na", "n", "a" 단어 조각이 각각 무한개씩 있습니다. 이때, 만들어야 하는 문장이 “banana”라면 “ba”, “na”, “n”, “a”의 4개를 사용하여 문장을 완성할 수 있지만, “ba”, “na”, “na”의 3개만을 사용해도 “banana”를 완성할 수 있습니다. 사용 가능한 단어 조각들을 담고 있는 배열 strs와 완성해야 하는 문자열 t가 매개변수로 주어질 때, 주어진 문장을 완성하기 위해 사용해야 하는 단어조각 개수의 최솟값을 return 하도록 solution 함수를 완성해 주세요. 만약 주어진 문장을 완성하는 것이 불가능하면 -1을 return 하세요.

제한사항

strs는 사용 가능한 단어 조각들이 들어있는 배열로, 길이는 1 이상 100 이하입니다.
strs의 각 원소는 사용 가능한 단어조각들이 중복 없이 들어있습니다.
사용 가능한 단어 조각들은 문자열 형태이며, 모든 단어 조각의 길이는 1 이상 5 이하입니다.
t는 완성해야 하는 문자열이며 길이는 1 이상 20,000 이하입니다.
모든 문자열은 알파벳 소문자로만 이루어져 있습니다.

입출력 예

strs	t	result
["ba","na","n","a"]	"banana"	3
["app","ap","p","l","e","ple","pp"]	"apple"	2
["ba","an","nan","ban","n"]	"banana"	-1

입출력 예 설명

입출력 예 #1

문제의 예시와 같습니다.

입출력 예 #2
"ap" 1개, "ple" 1개의 총 2개로 "apple"을 만들 수 있으므로 필요한 단어 개수의 최솟값은 2를 return 합니다.

입출력 예 #3
주어진 단어로는 "banana"를 만들 수 없으므로 -1을 return 합니다.

나의 푸ㄹ이

주어진 단어들로 문자를 만드는 문제.
단어를 딕셔너리로 만들어서, 문자열에서 단어들을 하나씩 지우는 방식으로 재귀호출을 썼는데 에러난다.
테스트 케이스는 다 통과했지만...
1차 시도 소스코드

def solution(strs, t):
    answer = 0
    method_count = []
    dict = {}
    
    strs.sort(key=lambda x:x) #알파벳순 사전 구성
    for s in strs:
        if s[0] in dict:
            dict[s[0]].append(s)
        else:
            dict[s[0]] = [(s)]
    #print(dict)
    
    def deletedict(tt,c):
        dct = dict[tt[0]]
        for dd in dct:
            #print(tt, "-", dd, end=" -> ")
            if len(dd) > len(tt):
                #print("실패")
                return
            elif dd == tt:
                #print("동일", c, "저장")
                method_count.append(c)
                return
            else:
                #print("계속")
                for pair in zip(tt, dd):
                    if pair[0] != pair[1]:
                        return
            ttt = tt[len(dd):]
            #print(ttt)
            deletedict(ttt,c+1)
    
    deletedict(t,0)
    if len(method_count) > 0:
        return min(method_count) + 1
    return -1

런타임에러?

정확성  테스트
테스트 1 〉	통과 (0.02ms, 10.1MB)
테스트 2 〉	통과 (0.27ms, 10.2MB)
테스트 3 〉	통과 (0.01ms, 10.2MB)
테스트 4 〉	통과 (1.01ms, 10.3MB)
테스트 5 〉	통과 (135.23ms, 10.5MB)
테스트 6 〉	통과 (0.01ms, 10.2MB)
테스트 7 〉	실패 (시간 초과)
테스트 8 〉	실패 (런타임 에러)
테스트 9 〉	실패 (런타임 에러)
테스트 10 〉	실패 (런타임 에러)
테스트 11 〉	실패 (런타임 에러)
테스트 12 〉	통과 (0.01ms, 10.1MB)
테스트 13 〉	통과 (0.35ms, 10.3MB)
테스트 14 〉	통과 (0.22ms, 10.3MB)
테스트 15 〉	통과 (0.06ms, 10.2MB)
테스트 16 〉	통과 (0.01ms, 10.2MB)
테스트 17 〉	통과 (0.01ms, 10.1MB)
테스트 18 〉	통과 (0.03ms, 10.3MB)
테스트 19 〉	통과 (0.03ms, 10.2MB)
효율성  테스트
테스트 1 〉	실패 (런타임 에러)
테스트 2 〉	실패 (런타임 에러)
테스트 3 〉	실패 (런타임 에러)
테스트 4 〉	실패 (런타임 에러)
테스트 5 〉	통과 (0.06ms, 10.2MB)

아무래도... 재귀호출이 너무 많아서겠지?
파이썬은 재귀 호출을 최대 1000번까지만 허락한다.
이 한계 돌파하려면... 아래 명령을 사용한다.

import sys
limit_number = 15000
sys.setrecursionlimit(limit_number)

그래도 에러난다. 재귀호출로 풀면 안되는 문제인가보다.
잘라낸 단어를 list(set()) 한번씩 해서 줄이는 방식이 있긴 하지... 그렇게 해야되나? 그럼 BFS인가...

정확성  테스트
테스트 1 〉	통과 (0.02ms, 10.2MB)
테스트 2 〉	통과 (0.27ms, 10.3MB)
테스트 3 〉	통과 (0.01ms, 10.1MB)
테스트 4 〉	통과 (0.97ms, 10.1MB)
테스트 5 〉	통과 (133.64ms, 10.4MB)
테스트 6 〉	통과 (0.01ms, 10.1MB)
테스트 7 〉	실패 (시간 초과)
테스트 8 〉	실패 (시간 초과)
테스트 9 〉	실패 (시간 초과)
테스트 10 〉	실패 (시간 초과)
테스트 11 〉	실패 (시간 초과)
테스트 12 〉	통과 (0.01ms, 10.1MB)
테스트 13 〉	통과 (0.35ms, 10.3MB)
테스트 14 〉	통과 (0.24ms, 10.2MB)
테스트 15 〉	통과 (0.06ms, 10.2MB)
테스트 16 〉	통과 (0.01ms, 10.3MB)
테스트 17 〉	통과 (0.01ms, 10.3MB)
테스트 18 〉	통과 (0.02ms, 10.3MB)
테스트 19 〉	통과 (0.02ms, 10.1MB)
효율성  테스트
테스트 1 〉	실패 (런타임 에러)
테스트 2 〉	실패 (런타임 에러)
테스트 3 〉	실패 (런타임 에러)
테스트 4 〉	실패 (런타임 에러)
테스트 5 〉	통과 (0.07ms, 10.2MB)

요번엔 빠른데 다 실패 ㅋㅋㅋ

def solution(strs, t):
    answer = 1
    dp = [0]
    dict = {}
    
    #strs.sort(key=lambda x:x) #알파벳순 사전 구성
    for s in strs:
        if s[0] in dict:
            dict[s[0]].append(s)
        else:
            dict[s[0]] = [(s)]
    
    while 0 < len(dp):
        _tmp = []
        for index in dp:
            tt = t[index:]
            dct = dict[tt[0]]
            for dd in dct:
                print(answer,":",tt, "-", dd, end=" --> ")
                if len(dd) > len(tt):
                    print("실패")
                    continue
                elif dd == tt:
                    print("정답")
                    return answer
                    break
                else:
                    print("계속")
                    for pair in zip(tt, dd):
                        if pair[0] != pair[1]:
                            continue
                _tmp.append(index + len(dd))
        answer += 1
        dp = list(set(_tmp))
    return -1
    
정확성  테스트
테스트 1 〉	통과 (0.02ms, 10.2MB)
테스트 2 〉	실패 (0.03ms, 10.1MB)
테스트 3 〉	통과 (0.01ms, 10.3MB)
테스트 4 〉	통과 (0.04ms, 10MB)
테스트 5 〉	실패 (0.03ms, 10.2MB)
테스트 6 〉	통과 (0.01ms, 10.4MB)
테스트 7 〉	실패 (0.03ms, 10.2MB)
테스트 8 〉	실패 (0.06ms, 10.3MB)
테스트 9 〉	실패 (0.07ms, 10.2MB)
테스트 10 〉	실패 (0.07ms, 10.1MB)
테스트 11 〉	실패 (0.08ms, 10.2MB)
테스트 12 〉	통과 (0.01ms, 10.3MB)
테스트 13 〉	통과 (0.04ms, 10.2MB)
테스트 14 〉	통과 (0.06ms, 10.2MB)
테스트 15 〉	통과 (0.03ms, 10.1MB)
테스트 16 〉	통과 (0.01ms, 10.1MB)
테스트 17 〉	실패 (0.01ms, 10.2MB)
테스트 18 〉	통과 (0.03ms, 10.2MB)
테스트 19 〉	실패 (0.02ms, 10.2MB)
효율성  테스트
테스트 1 〉	실패 (0.44ms, 10.1MB)
테스트 2 〉	실패 (0.42ms, 10.3MB)
테스트 3 〉	실패 (0.29ms, 10.3MB)
테스트 4 〉	실패 (0.67ms, 10.3MB)
테스트 5 〉	통과 (0.34ms, 10.2MB)

심기일전 했으나...
- dict가 파이썬 예약어라서 바꿈

def solution(strs, t):
    answer = 1
    len_t = len(t)
    visited = {(0, "")}
    queue = [(0, "")]
    string_dict = {}
    
    for s in strs:
        if s[0] in string_dict:
            string_dict[s[0]].append(s)
        else:
            string_dict[s[0]] = [s]
    
    while queue:
        temp = set()
        for index, str in queue:
            dct = string_dict.get(t[index], [])
            for dd in dct:
                len_dd = len(dd)
                len_tt = len_t - index
                if len_dd <= len_tt:
                    mismatch = False
                    for i in range(len_dd):
                        if t[index+i] != dd[i]:
                            mismatch = True
                            break
                    if mismatch:
                        continue
                    if len_dd == len_tt:
                        return answer
                    new_index = index + len_dd
                    if new_index > len_t:
                        continue
                    if (new_index, dd) not in visited:
                        visited.add((new_index, dd))
                        temp.add((new_index, dd))
        answer += 1
        queue = list(temp)
        
    return -1

효율성 테스트에서 시간초과 나온다.

정확성  테스트
테스트 1 〉	통과 (0.02ms, 10.2MB)
테스트 2 〉	통과 (0.08ms, 10.3MB)
테스트 3 〉	통과 (0.01ms, 10.1MB)
테스트 4 〉	통과 (0.07ms, 10.1MB)
테스트 5 〉	통과 (0.13ms, 10.1MB)
테스트 6 〉	통과 (0.01ms, 10.4MB)
테스트 7 〉	통과 (0.37ms, 10.1MB)
테스트 8 〉	통과 (4.28ms, 10.3MB)
테스트 9 〉	통과 (5.67ms, 10.3MB)
테스트 10 〉	통과 (6.55ms, 10.3MB)
테스트 11 〉	통과 (8.14ms, 10.3MB)
테스트 12 〉	통과 (0.01ms, 10MB)
테스트 13 〉	통과 (0.03ms, 10.1MB)
테스트 14 〉	통과 (0.05ms, 10.2MB)
테스트 15 〉	통과 (0.02ms, 10.1MB)
테스트 16 〉	통과 (0.01ms, 10.1MB)
테스트 17 〉	통과 (0.01ms, 10.2MB)
테스트 18 〉	통과 (0.03ms, 10.1MB)
테스트 19 〉	통과 (0.02ms, 10.1MB)
효율성  테스트
테스트 1 〉	실패 (시간 초과)
테스트 2 〉	실패 (시간 초과)
테스트 3 〉	실패 (시간 초과)
테스트 4 〉	실패 (시간 초과)
테스트 5 〉	실패 (시간 초과)

다이나믹 프로그래밍으로 고쳤는데 시간 초과

def solution(strs, t):
    len_t = len(t)
    dp = [-1] * (len_t + 1)
    dp[0] = 0
    string_dict = {}
    
    for s in strs:
        if s[0] in string_dict:
            string_dict[s[0]].append(s)
        else:
            string_dict[s[0]] = [s]
    
    for i in range(len_t):
        if dp[i] == -1:
            continue
        for dd in string_dict.get(t[i], []):
            len_dd = len(dd)
            len_tt = len_t - i
            if len_dd > len_tt:
                continue
            mismatch = False
            for j in range(len_dd):
                if t[i + j] != dd[j]:
                    mismatch = True
                    break
            if mismatch:
                continue
            if dp[i + len_dd] == -1 or dp[i + len_dd] > dp[i] + 1:
                dp[i + len_dd] = dp[i] + 1
                
    return dp[len_t]
    
정확성  테스트
테스트 1 〉	통과 (0.01ms, 10.2MB)
테스트 2 〉	통과 (0.04ms, 10.2MB)
테스트 3 〉	통과 (0.01ms, 10.4MB)
테스트 4 〉	통과 (0.03ms, 10.1MB)
테스트 5 〉	통과 (0.13ms, 10.2MB)
테스트 6 〉	통과 (0.01ms, 10.4MB)
테스트 7 〉	통과 (0.15ms, 10.2MB)
테스트 8 〉	통과 (2.27ms, 10.3MB)
테스트 9 〉	통과 (2.40ms, 10.4MB)
테스트 10 〉	통과 (2.72ms, 10.2MB)
테스트 11 〉	통과 (3.33ms, 10.3MB)
테스트 12 〉	통과 (0.01ms, 10.3MB)
테스트 13 〉	통과 (0.03ms, 10.2MB)
테스트 14 〉	통과 (0.03ms, 10.2MB)
테스트 15 〉	통과 (0.02ms, 10.2MB)
테스트 16 〉	통과 (0.01ms, 10.3MB)
테스트 17 〉	통과 (0.01ms, 10.1MB)
테스트 18 〉	통과 (0.02ms, 10.2MB)
테스트 19 〉	통과 (0.02ms, 10.4MB)
효율성  테스트
테스트 1 〉	통과 (206.62ms, 10.7MB)
테스트 2 〉	통과 (203.37ms, 10.7MB)
테스트 3 〉	실패 (시간 초과)
테스트 4 〉	통과 (211.06ms, 10.8MB)
테스트 5 〉	실패 (시간 초과)

for문 하나 고쳤다고 빨라지는거 좀 이상하다. ㅡ.ㅡ 운빨인가?

def solution(strs, t):
    len_t = len(t)
    dp = [-1] * (len_t + 1)
    dp[0] = 0
    string_dict = {}
    
    for s in strs:
        if s[0] in string_dict:
            string_dict[s[0]].append(s)
        else:
            string_dict[s[0]] = [s]
    
    for i in range(len_t):
        if dp[i] == -1:
            continue
        for dd in string_dict.get(t[i], []):
            len_dd = len(dd)
            len_tt = len_t - i
            if len_dd > len_tt:
                continue
            j = 0
            while j < len_dd and t[i + j] == dd[j]:
                j += 1
            if j < len_dd:
                continue
            if dp[i + len_dd] == -1 or dp[i + len_dd] > dp[i] + 1:
                dp[i + len_dd] = dp[i] + 1
                
    return dp[len_t]
    
정확성  테스트
테스트 1 〉	통과 (0.01ms, 10.2MB)
테스트 2 〉	통과 (0.04ms, 10.2MB)
테스트 3 〉	통과 (0.01ms, 10.3MB)
테스트 4 〉	통과 (0.03ms, 10.3MB)
테스트 5 〉	통과 (0.06ms, 10.2MB)
테스트 6 〉	통과 (0.01ms, 10.3MB)
테스트 7 〉	통과 (0.12ms, 10.2MB)
테스트 8 〉	통과 (1.61ms, 10.3MB)
테스트 9 〉	통과 (1.82ms, 10.1MB)
테스트 10 〉	통과 (2.07ms, 10.2MB)
테스트 11 〉	통과 (2.36ms, 10.1MB)
테스트 12 〉	통과 (0.01ms, 10.1MB)
테스트 13 〉	통과 (0.04ms, 10.2MB)
테스트 14 〉	통과 (0.02ms, 10.2MB)
테스트 15 〉	통과 (0.02ms, 10.2MB)
테스트 16 〉	통과 (0.01ms, 10.2MB)
테스트 17 〉	통과 (0.01ms, 10.1MB)
테스트 18 〉	통과 (0.01ms, 10.3MB)
테스트 19 〉	통과 (0.01ms, 10.2MB)
효율성  테스트
테스트 1 〉	통과 (171.62ms, 10.7MB)
테스트 2 〉	통과 (174.13ms, 10.9MB)
테스트 3 〉	통과 (166.47ms, 10.5MB)
테스트 4 〉	통과 (157.20ms, 10.8MB)
테스트 5 〉	통과 (114.42ms, 10.5MB)

고수의 풀이. ㄱㅐ빠름

def solution(strs, t):
    n = len(t)
    memo = [float("inf")] * (n + 1)
    memo[0] = 0
    sizes = set(len(s) for s in strs)
    strs = set(strs)
    for i in range(n + 1):
        for size in sizes:
            if i + size < n + 1 and t[i:i + size] in strs:
                memo[i + size] = min(memo[i + size], memo[i] + 1)
    return memo[n] if memo[n] < float("inf") else -1
    
정확성  테스트
테스트 1 〉	통과 (0.02ms, 10.2MB)
테스트 2 〉	통과 (0.04ms, 10.3MB)
테스트 3 〉	통과 (0.01ms, 10.2MB)
테스트 4 〉	통과 (0.05ms, 10.3MB)
테스트 5 〉	통과 (0.06ms, 10.1MB)
테스트 6 〉	통과 (0.01ms, 10.3MB)
테스트 7 〉	통과 (0.12ms, 10.2MB)
테스트 8 〉	통과 (1.00ms, 10.2MB)
테스트 9 〉	통과 (1.05ms, 10.1MB)
테스트 10 〉	통과 (1.13ms, 10.3MB)
테스트 11 〉	통과 (1.13ms, 10.3MB)
테스트 12 〉	통과 (0.01ms, 10.3MB)
테스트 13 〉	통과 (0.02ms, 10.1MB)
테스트 14 〉	통과 (0.02ms, 10.1MB)
테스트 15 〉	통과 (0.02ms, 10.3MB)
테스트 16 〉	통과 (0.01ms, 10.3MB)
테스트 17 〉	통과 (0.01ms, 10.1MB)
테스트 18 〉	통과 (0.02ms, 10.3MB)
테스트 19 〉	통과 (0.01ms, 10.1MB)
효율성  테스트
테스트 1 〉	통과 (29.72ms, 10.7MB)
테스트 2 〉	통과 (26.69ms, 10.8MB)
테스트 3 〉	통과 (24.50ms, 10.8MB)
테스트 4 〉	통과 (31.82ms, 10.8MB)
테스트 5 〉	통과 (31.75ms, 10.6MB)

enumerate 사용

def solution(strs, t):
    counts = [20001] * len(t)

    for i, c in enumerate(t):
        for s in strs:
            if s[-1] == c and t[i - len(s) + 1: i + 1] == s:
                if i - len(s) == -1: #시작지점
                    counts[i] = 1
                else:
                    #nd = counts[i - len(s)] + 1
                    #pd = counts[i]
                    counts[i] = min(counts[i - len(s)] + 1, counts[i])

    return counts[-1] if counts[-1] < 20001 else -1
    
정확성  테스트
테스트 1 〉	통과 (0.01ms, 10.1MB)
테스트 2 〉	통과 (0.04ms, 10.3MB)
테스트 3 〉	통과 (0.00ms, 10.1MB)
테스트 4 〉	통과 (0.06ms, 10.1MB)
테스트 5 〉	통과 (0.12ms, 10.1MB)
테스트 6 〉	통과 (0.01ms, 10.1MB)
테스트 7 〉	통과 (0.18ms, 10.1MB)
테스트 8 〉	통과 (1.97ms, 10.1MB)
테스트 9 〉	통과 (2.26ms, 10.3MB)
테스트 10 〉	통과 (2.50ms, 10.1MB)
테스트 11 〉	통과 (2.81ms, 10.3MB)
테스트 12 〉	통과 (0.01ms, 10.2MB)
테스트 13 〉	통과 (0.02ms, 10MB)
테스트 14 〉	통과 (0.03ms, 10.3MB)
테스트 15 〉	통과 (0.02ms, 10.3MB)
테스트 16 〉	통과 (0.01ms, 10.2MB)
테스트 17 〉	통과 (0.01ms, 10.2MB)
테스트 18 〉	통과 (0.01ms, 10.1MB)
테스트 19 〉	통과 (0.01ms, 10.2MB)
효율성  테스트
테스트 1 〉	통과 (196.39ms, 10.7MB)
테스트 2 〉	통과 (196.14ms, 10.7MB)
테스트 3 〉	통과 (194.25ms, 10.8MB)
테스트 4 〉	통과 (202.01ms, 10.7MB)
테스트 5 〉	실패 (시간 초과)

나는 아직 멀었구나... ㅡ.ㅡ;

def solution(strs, t) :
    dp = {i: float('inf') for i in range(len(t))}

    for j in range(len(t)-1, -1, -1):
        for k in range(1,6):
    #         print("------------------------------------------------------------------")
    #         print("j: ", j, "  k: ", k, "  t[j:j+k]", t[j:j+k])

            if j+k > len(t) :
                break

            if t[j:j+k] in strs:
    #             print("==============================================================")
    #             print("dp.get(j): ", dp.get(j), "  dp.get(j+k, 0)+1: ", dp.get(j+k, 0)+1)
                dp[j] = min(dp.get(j), dp.get(j+k, 0)+1)
    #             print("dp: ", dp)

    if dp[0] == float('inf') :
        return -1
    else :
        return dp[0]
        
정확성  테스트
테스트 1 〉	통과 (0.02ms, 10.1MB)
테스트 2 〉	통과 (0.06ms, 10.1MB)
테스트 3 〉	통과 (0.01ms, 10MB)
테스트 4 〉	통과 (0.11ms, 10.1MB)
테스트 5 〉	통과 (0.11ms, 10.2MB)
테스트 6 〉	통과 (0.02ms, 10.2MB)
테스트 7 〉	통과 (0.46ms, 10.1MB)
테스트 8 〉	통과 (2.45ms, 10.4MB)
테스트 9 〉	통과 (2.65ms, 10.2MB)
테스트 10 〉	통과 (2.72ms, 10.2MB)
테스트 11 〉	통과 (4.55ms, 10.2MB)
테스트 12 〉	통과 (0.02ms, 10.1MB)
테스트 13 〉	통과 (0.03ms, 10.1MB)
테스트 14 〉	통과 (0.03ms, 10.3MB)
테스트 15 〉	통과 (0.03ms, 10.2MB)
테스트 16 〉	통과 (0.01ms, 10.1MB)
테스트 17 〉	통과 (0.02ms, 10.1MB)
테스트 18 〉	통과 (0.02ms, 10.1MB)
테스트 19 〉	통과 (0.02ms, 10MB)
효율성  테스트
테스트 1 〉	통과 (136.99ms, 11.9MB)
테스트 2 〉	통과 (141.49ms, 12MB)
테스트 3 〉	통과 (131.01ms, 11.8MB)
테스트 4 〉	통과 (122.39ms, 11.8MB)
테스트 5 〉	통과 (128.40ms, 11.9MB)

다른 사람들 풀이를 보니까, 알파벳순으로 사전 만들어서 찾아서 끼우는 방식으로 할 필요가 없었구나.
그냥 무지성으로 DP 돌리는게 더 빠른 거였다.

728x90

저작자표시 동일조건

'게임 프로그래밍 > Python 프로그래밍' 카테고리의 다른 글

프로그래머스 디펜스 게임 (0)	2023.02.15
프로그래머스 점 찍기 (0)	2023.02.14
프로그래머스 인사고과 (0)	2023.02.14
프로그래머스 이모티콘 할인행사 (0)	2023.02.12
우선순위 큐를 힙큐, 디큐로 변경 (0)	2023.02.10

현재글프로그래머스 단어 퍼즐

ONE MAN GAME DEV

프로그래머스 단어 퍼즐

단어 퍼즐

문제 설명

제한사항

입출력 예

입출력 예 설명

나의 푸ㄹ이

고수의 풀이. ㄱㅐ빠름

'게임 프로그래밍 > Python 프로그래밍' 카테고리의 다른 글

'게임 프로그래밍/Python 프로그래밍'의 다른글

티스토리툴바

프로그래머스 단어 퍼즐

단어 퍼즐

문제 설명

제한사항

입출력 예

입출력 예 설명

나의 푸ㄹ이

고수의 풀이. ㄱㅐ빠름

'게임 프로그래밍 > Python 프로그래밍' 카테고리의 다른 글

'게임 프로그래밍/Python 프로그래밍'의 다른글

관련글

티스토리툴바