์ค๋๋ง์ ์๊ณ ๋ฆฌ์ฆ ํฌ์คํ
..! LeetCode์ Top Interview Questions๋ฅผ ํ๊ณ ์๋ค. LeetCode๋ vscode์ ํ์ฅํฉ์ด ์์ด์ ํํ์ด์ง์ ์๋ค์ด๊ฐ๊ณ vscode์์ ๋ฌธ์ ์ฝ๊ธฐ, ์ฝ๋ ์์ฑ, ํ
์คํธ ๋ฐ ์์ฑ๊น์ง ํ ๋ฒ์ ํ ์ ์๋ค. ์ด๊ฒ ์ง์ง ํธํด์ LeetCode๋ฅผ ํฌ๊ธฐํ ์ ์๋๋ฐ solved.ac ๋ฑ์ง๊ฐ ํ๋์ ๋ฐฑ์ค๋ ํ๊น ์๊ฐ ์ค์ด๋ค. ์ฐ์ ๋น๋ถ๊ฐ์ Top Interview Questions์ ๊ณ์ํด์ ํ ๊ฒ ๊ฐ๋ค.
๐ ๋ฌธ์
https://leetcode.com/problems/add-two-numbers/
๐ ํ์ด
๋งํฌ๋ ๋ฆฌ์คํธ ๋ฌธ์ ๋ ๋ฆฟ์ฝ๋๋ฅผ ๊ธฐ์ค์ผ๋ก ๋ช ๋ฌธ์ ํ์ด๋ณด๋๊น ์ ํ์ด ์๋์ ๊ฐ์ด ๋๋๋ ๊ฒ ๊ฐ๋ค.
1. ๊ธฐ์กด์ ๋ฆฌ์คํธ๋ฅผ ์กฐ์ํด์ผํ๋ ๊ฒฝ์ฐ
๋ฆฌํด์ ์๊ตฌํ์ง ์๊ณ ๊ธฐ์กด์ ๋งํฌ๋ ๋ฆฌ์คํธ๋ฅผ ์กฐ์ํ๋ผ๊ณ ํ๋ค. ์ปค์๋ฅผ ์๋ฆฌ์กฐ๋ฆฌ ์ ์ฎ๊ฒจ์ ํ๋ฉด ๋จโฆ
2. ์๋ก์ด ๋ฆฌ์คํธ๋ฅผ ๋ง๋ค์ด์ผ ํ๋ ๊ฒฝ์ฐ
๋ ๊ฐ์ ๋งํฌ๋ ๋ฆฌ์คํธ๊ฐ ์ฃผ์ด์ง๊ณ ํฉ์น๋ผ๋์ง, ๊ต์งํฉ์ ๊ตฌํ๋ผ๊ณ ํ๋ฏ๋ก ์๋ก์ด ๋งํฌ๋ ๋ฆฌ์คํธ๋ฅผ ๋ง๋ค์ด์ผ ํ๋ค. ๋ณธ ๋ฌธ์ ๋ ์ด ์ ํ์ ํด๋นํ๋ค. ์๋ก์ด ๋งํฌ๋ ๋ฆฌ์คํธ๋ ์๋์ ๊ฐ์ด ๋ง๋ค๋ฉด ๋๋ค. ์ฝ๋๋ 206.reverse-linked-list.py, 21.merge two sorted lists.py ์ฐธ๊ณ
newHead = ListNode(0)
cur = newHead
while ์กฐ๊ฑด๋ฌธ:
# ...
cur.next = ListNode(val)
cur = cur.next
return newHead.next # headNode์ ๊ฐ์ 0์ด๊ณ next๋ถํฐ ๊ฐ์ ๋ฃ์์ผ๋ฏ๋ก next ๋ฐํ
3. ๋ฆฌ์คํธ๋ฅผ ๋น ๋ฅด๊ฒ ํ์ํด์ผ ํ๋ ๊ฒฝ์ฐ
๊ธธ์ด, ์ค๊ฐ ์์น, ๋ณํฉ ์ง์ ์ ๊ตฌํด์ผ ํ๋ ๊ฒฝ์ฐ์ด๋ค. ๋ ๊ฐ์ ํฌ์ธํฐ๋ฅผ ์ฌ์ฉํด์ผ ํ๋ค. slow
์ fast
๋ผ๋ ๋ ๊ฐ์ ๋ฌ๋ ํฌ์ธํฐ๋ฅผ ๋ง๋ค์ด์ fast
๋ ๋ ์นธ์ฉ, slow
๋ ํ ์นธ์ฉ ์ด๋ํ์ฌ fast
๋ฅผ ๊ธฐ์ค์ผ๋ก ํ์์ด ๋๋ฌ์ ๋ slow
๋ ๋งํฌ๋ ๋ฆฌ์คํธ์ ๊ฐ์ด๋ฐ์ ์์ผ๋ฉฐ, fast
๋ฅผ ํตํด ๊ธธ์ด๋ฅผ ๊ตฌํ ์ ์๋ค. ์ฝ๋๋ 234.Palindrome-linked-list ์ฐธ๊ณ
์ด ๋ฌธ์ ๋ 2๋ฒ์งธ ์ ํ์ ํด๋นํ๋ค. ๋ ๊ฐ์ ๋งํฌ๋ ๋ฆฌ์คํธ๋ฅผ ๋์์ ํ์์ ์์ํ๋ค. divmod
๋ฅผ ์ฌ์ฉํด์ carry๋ฅผ ์ ์ฅํ์๋ค. ์ด ๋ ํ ๊ฐ์ ๋ฆฌ์คํธ๊ฐ ๋๊น์ง ๋๋ฌํ๋ฉด ์ฒซ ๋ฒ์งธ while๋ฌธ์ ๋๋ธ๋ค. ๊ทธ๋ฆฌ๊ณ ์ผํญ์ฐ์ฐ์๋ฅผ ์ด์ฉํด์ ๊ธธ์ด๊ฐ ๊ธด ๋ฆฌ์คํธ๋ฅผ l4
๊ฐ ๊ฐ๋ฅดํค๊ฒ ํด์ ํ์์ ๊ณ์ํ๋ค. ๋ง์ง๋ง์ผ๋ก carry๊ฐ ๋จ์์๋ ๊ฒฝ์ฐ ์๋ก์ด ์๋ฆฟ์๊ฐ ์ถ๊ฐ๋ ๊ฒ์ด๊ธฐ ๋๋ฌธ์ next์ 1์ ๊ฐ์ง ๋
ธ๋๋ฅผ ๋ถ์ฌ์ค๋ค. ์๊ฐ๋ณต์ก๋๋ O(max(m,n))
Top voted Solution์ ๋ณด๋๊น ํ๋์ while๋ฌธ์์ l1, l2์ val์ ๊ณ์ 0์ผ๋ก ์ด๊ธฐํํ๊ณ not l1, l2์ธ ๊ฒฝ์ฐ val์ ๋ฃ์ด์ฃผ์ด์ ์ฒ๋ฆฌํด์ฃผ๋ ์ฝ๋๋ฅผ ๋ดค๋ค. ํ๋์ while๋ฌธ์์ ํด๊ฒฐํ ์ ์์ด์ ๋ ๊น๋ํ ๊ฒ ๊ฐ๋ค.
Python ์ฝ๋
class Solution(object):
def addTwoNumbers(self, l1, l2):
"""
:type l1: ListNode
:type l2: ListNode
:rtype: ListNode
"""
l3 = ListNode()
cur = l3
carry = 0
while l1 and l2: # ๋ ์ค์ ํ๋ ๋๊น์ง ๊ฐ์ผ๋ฉด
carry, val = divmod(l1.val+l2.val+carry, 10)
l1 = l1.next
l2 = l2.next
cur.next = ListNode(val)
cur = cur.next
l4 = l1 if l1 else l2 # ๋จ์์๋ ๋
ธ๋ ๊ณ์ ๋ํจ
while l4:
carry, val = divmod(l4.val+carry, 10)
l4 = l4.next
cur.next = ListNode(val)
cur = cur.next
if carry == 1:
cur.next = ListNode(1)
return l3.next