공부하려고 만든 블로그

멍청한 나는 for문에 너무 집착한 나머지 1시간 동안 머리를 싸매다가 결국 Discuss를 보고 말았다.

while문이 무한루프를 도는 경우가 싫어서 왠만해선 for문을 써왔었는데 최근 Leetcode 문제들을 풀어보면 while이 그렇게 나쁜것도 아니고, 오히려 굉장히 실용적이라는 느낌도 들었다. 코딩문제를 풀때 while도 많이 애용해 봐야겠다고 생각했다.

class Solution(object):
    def maxArea(self, height):
        """
        :type height: List[int]
        :rtype: int
        """
        MAX = 0 
        x = len(height) - 1
        y = 0
        while x != y:
            if height[x] > height[y]:
                area = height[y] * (x - y)
                y += 1
            else:
                area = height[x] * (x - y)
                x -= 1
            MAX = max(MAX, area)
        return MAX

이걸 for문으로 하려면 아주 난리를 쳐야했는데 만들면서도 굉장히 잘못됐다고 느꼈었다ㅋㅋㅋㅋ,,, while... 애용합시다!

대부분의 사람들이 그렇겠지만, 개인적으로 굉장히 어려워하는게 Node인데 하필이면 2번부터 Node가 나왔다ㅋㅋㅋ 번호 순서대로 풀지 말아야겠다는 생각이 강력하게 들었지만 의외로 또 문제가 쉬워보여서 도전해봤다. 어렵진 않았지만 Node의 개념을 모른다면 절대 못푸는 그런 문제... return값도 node라는게 아주 키포인트임!

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next

# 내 풀이
class Solution:
    def addTwoNumbers(self, l1, l2):
        # print(l1.next.next) # ListNode{val: 3, next: None}
        # ListNode는 길이가 없다. 생각해보면 당연하지만 일단 len충인 나는 해봤다 봉변당함ㅋㅋ
        # print(len(l1)) # 'ListNode' has no len()

        result = 0
        i = 0
        
        # 우선 l1과 l2에 있는 데이터로 연산을 완료 (result)
        while l1 or l2 :
            if l1 != None :
                result += l1.val*(10**i)
                l1 = l1.next
            if l2 != None :
                result += l2.val*(10**i)
                l2 = l2.next
            i += 1
            
        # for문을 돌리기 위해 int인 result를 str로 변경한 모습 (별로 좋다고 생각은 안함)
        result = str(result)
        # 여기서 진짜 웃긴게 cur을 사용하지 않으면 node가 제대로 이어지지 않는다.
        answer = cur = ListNode(0)
		
        # answer = cur = ListNode(0)이 아니고
        # answer = ListNode(0)으로 해서 아래 for문을 cur 대신 answer쓰면 제대로 node 형성이 안됨
        for i in range(len(result)-1,-1,-1) :
            cur.next = ListNode(result[i])
            cur = cur.next
            
        # return도 제법 웃겨
        return answer.next

# Discuss에서 추천 수 많았던 코드

class Solution:
    def addTwoNumbers(self, l1, l2):
        carry = 0
        root = n = ListNode(0)
        while l1 or l2 or carry:
            v1 = v2 = 0
            if l1:
                v1 = l1.val
                l1 = l1.next
            if l2:
                v2 = l2.val
                l2 = l2.next
            # print(carry)
            # print("v1 :",v1,"v2 :",v2)
            carry, val = divmod(v1+v2+carry, 10)
            # print(carry,val)
            n.next = ListNode(val)
            n = n.next
        return root.next

위의 코드를 보면 결국에 나랑 비슷한 생각인데 나는 올림에 대해 어떻게 해야할지 모르겠어서 연산을 다 마치고 연산이 끝난 데이터를 역순으로 뽑아 node를 만들었다면, 이 사람은 한번에 node까지 만든것을 볼 수 있다. 올림을 저렇게 할 생각을 못했었는데 진짜 똑똑한것 같다.

이 부분에 대해서는 조금 더 공부한 내용을 추가하도록 하겠다! Node를 아주 부셔버리겠어...

알고리즘을 어떻게 공부해야할까 어느 사이트를 참고해야할까 엄청 고민하던 찰나에, 우연히 보게된 글에서 LeetCode로 공부하는게 좋다길래 참고하여 공부하려고 한다! Easy고 나발이고 x밥인 나는 이 사람 말대로 이것도 어려웠다ㅋㅎ,, 괜찮아.. 열심히 하면 늘겠지!

# 내 코드
class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        output = []
        for i in range(len(nums)) :
            target -= nums[i]
            if target in nums[i+1:] :
                output.append(i)
                output.append(nums[i+1:].index(target)+i+1)
                return output
            target += nums[i]
        return

메모리 사용량은 적지만 시간이 굉장히 오래걸리는 내 코드... Discussion에 올라와있는 코드들은 딕셔너리를 사용하여 효과적으로 속도를 향상시킬 수 있었다.

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        dic = {}
        for i, n in enumerate(nums):
            if n in dic:
                return [dic[n], i]
            dic[target-n] = i

근데 또 Discussion에서 나온 의견으로는 nums = [11, 2, 2, 7, 11, 15] , target = 9 일 때, 정답은 [1,3]인데 위의 코드로 하면 [2,3]이 나오는 오류가 발생한다... 근데 내코드는 잘 됨 헤헷 속도를 잃고 정확성을 얻었다 암튼 코딩 하수인 나는 리스트도 enumerate가 된다는 새로운 사실을 알았으니 그것만으로도 만족 헤헷,,, 그리고 딕셔너리 사용이 속도면에서 효과적이라는 것을 알았으니 이것도 만족 헤헷...