LeetCode-38
Count and Say : The count-and-say sequence is a sequence of digit strings defined by the recursive formula:
note : To determine how you "say" a digit string, split it into the minimal number of substrings such that each substring contains exactly one unique digit. Then for each substring, say the number of digits, then say the digit. Finally, concatenate every said digit.
Answer
:::python
class Solution:
def countAndSay(self, n: int) -> str:
# countAndSay(1) = "1"
# countAndSay(2) = say "1" = one 1 = "11"
# countAndSay(3) = say "11" = two 1's = "21"
# countAndSay(4) = say "21" = one 2 + one 1 = "12" + "11" = "1211"
if n==1:
return '1'
curr = 1
num='1'
result = ''
while curr<n:
left, right = 0, 1
whi s = num[left]
count=1
while right < len(num):
if s == num[right]:
count+=1
right+=1
else:
break
answer += f'{count}{s}'
left = right
right+=1
num = answer
curr+=1
return answer
Result : 64ms Memory: 16.4mb
๋ฌธ์ ์ค๋ช
Count and Say ๋ฌธ์ ๋ ์ฃผ์ด์ง ์ซ์ n์ ๋ํ์ฌ n๋ฒ์งธ ๋ฌธ๋งฅ์ ๋ฆฌํดํ๋ ๋ฌธ์ ์ ๋๋ค. ์ด ๋, ์ซ์ n์ 1๋ถํฐ ์์ํฉ๋๋ค. ๋ฌธ๋งฅ์ ๊ตฌ์ฑ์ ์์๋ฆฌ์ ์ซ์์ ๊ฐฏ์, ๊ทธ ๋ค์ ํด๋น ์ซ์๋ฅผ ์ด์ด๋ถ์ธ ๋ฌธ์์ด์ ๋๋ค.
์๋ฅผ ๋ค์ด, n=1์ผ ๋ ๋ฌธ๋งฅ์ "1"์ ๋๋ค. n=2์ผ ๋, countAndSay(1)์์ ๋ฆฌํด๋ "1"์ ๋ฌธ๋งฅ์ด๋ฏ๋ก "11"์ด ๋ฆฌํด๋ฉ๋๋ค. n=3์ผ ๋, countAndSay(2)์์ ๋ฆฌํด๋ "11"์ ๋ฌธ๋งฅ์ด๋ฏ๋ก "21"์ด ๋ฆฌํด๋ฉ๋๋ค. ์ด๋ฐ ์์ผ๋ก ๋ฌธ๋งฅ์ ๊ตฌํ๋ ๊ฒ์ ๋๋ค.
ํด๊ฒฐ ๋ฐฉ๋ฒ
ํด๋น ๋ฌธ์ ์์๋ ํ์ฌ๊น์ง ์งํํ ๋ฌธ๋งฅ๊ณผ n์ ํด๋นํ๋ ์๋ฅผ ๋น๊ตํ์ฌ ๋ฌธ๋งฅ์ ๊ตฌํ๋ฉด ๋ฉ๋๋ค. ์ฐ์ n=1์ผ ๊ฒฝ์ฐ์๋ "1"์ ๋ฆฌํดํฉ๋๋ค. ๊ทธ ๋ค์๋ถํฐ๋ ํ์ฌ๊น์ง ๊ตฌํ ๋ฌธ๋งฅ๊ณผ n๊ฐ์ ๋น๊ตํ์ฌ ์๋ก์ด ๋ฌธ๋งฅ์ ๊ตฌํฉ๋๋ค.
์๋ฅผ ๋ค์ด, n=2์ผ ๊ฒฝ์ฐ์๋ countAndSay(1)์์ ๋ฆฌํด๋ "1"์ ๋ํด์ ๋ฌธ๋งฅ์ ๊ตฌํฉ๋๋ค. ์ฌ๊ธฐ์๋ 1์ด ํ ๋ฒ ๋์ค๋ฏ๋ก "11"์ด ๋ฆฌํด๋ฉ๋๋ค. ๋ง์ฐฌ๊ฐ์ง๋ก n=3์ผ ๊ฒฝ์ฐ์๋ countAndSay(2)์์ ๋ฆฌํด๋ "11"์ ๋ํด์ ๋ฌธ๋งฅ์ ๊ตฌํฉ๋๋ค. ์ด ๊ฒฝ์ฐ์๋ 1์ด ๋ ๋ฒ ์ฐ์์ผ๋ก ๋์ค๋ฏ๋ก "21"์ด ๋ฆฌํด๋ฉ๋๋ค.
์ด์ฒ๋ผ, ํ์ฌ๊น์ง ๊ตฌํ ๋ฌธ๋งฅ์์ ์ฐ์ํด์ ๋์ค๋ ์ซ์๋ค์ ๊ทธ ์์ ๊ฐฏ์์ ๊ฐ์ด ์ด์ด๋ถ์ธ ๋ฌธ์์ด์ ๊ตฌํ๋ฉด ๋ฉ๋๋ค.
์ฝ๋ ํ๊ฐ
ํด๋น ์ฝ๋๋ ์ ๋๋ก ์์ฑ๋์ด ์์ต๋๋ค. n๊ฐ์ด 1์ผ ๊ฒฝ์ฐ์๋ "1"์, ๊ทธ๋ ์ง ์์ ๊ฒฝ์ฐ์๋ ํ์ฌ๊น์ง ๊ตฌํ ๋ฌธ๋งฅ์์ ์ฐ์ํด์ ๋์ค๋ ์ซ์๋ค์ ๊ฐฏ์์ ํด๋น ์ซ์๋ฅผ ์ด์ด๋ถ์ธ ๋ฌธ์์ด์ ๊ตฌํ๊ณ , n๊ฐ์ ๋๋ฌํ ๋๊น์ง ๋ฐ๋ณตํฉ๋๋ค.
ํ์ง๋ง, ์ฝ๋์ ๊ฐ๋ ์ฑ์ ๋์ด๊ธฐ ์ํด ๋ณ์ ์ด๋ฆ์ ์ข ๋ ๋ช ํํ๊ฒ ์ง์ ํ๋ ๊ฒ์ด ์ข์ต๋๋ค. ์๋ฅผ ๋ค์ด, ๋ณ์๋ช num์ ํด๋นํ๋ ๋ณ์๋ ํ์ฌ๊น์ง ๊ตฌํ ๋ฌธ๋งฅ์ ์๋ฏธํ๋ฏ๋ก, context๋ current_context์ ๊ฐ์ ์ด๋ฆ์ผ๋ก ๋ฐ๊ฟ์ฃผ๋ฉด ๋ ๋ช ํํด์ง๋๋ค.
๋ํ, while๋ฌธ์ ์กฐ๊ฑด์์์ ์ฐ์ธ left, right์ ๊ฐ์ ๋ณ์๋ค์ while๋ฌธ ์์์๋ง ์ฐ์ด๋ ์ง์ญ ๋ณ์์ด๋ฏ๋ก, ๋ฐ๋ณต๋ฌธ์ ์์ํ๊ธฐ ์ ์ ๋ฏธ๋ฆฌ ์ ์ธํด์ฃผ๋ ๊ฒ์ด ์ข์ต๋๋ค. ์ด๋ฌํ ์ต๊ด์ ๋ค์ด๋ ๊ฒ์ด ์ข์ต๋๋ค.
๋ฐ๋ผ์, ์ฝ๋์ ์์ ๋ ๋ฒ์ ์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
class Solution:
def countAndSay(self, n: int) -> str:
if n == 1:
return '1'
curr = 1
current_context = '1'
result = ''
while curr < n:
left = right = 0
answer = ''
while right < len(current_context):
s = current_context[left]
count = 0
while right < len(current_context) and current_context[right] == s:
count += 1
right += 1
answer += f'{count}{s}'
left = right
current_context = answer
curr += 1
return answer
์ด๋ ๊ฒ ์ฝ๋๋ฅผ ์์ ํ๋ฉด ๊ฐ๋ ์ฑ์ด ์ข์์ ธ ๋์ฑ ๋ณด๊ธฐ ์ฌ์์ง๋๋ค.
'๐ข One step' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
How to LeetCode effectively (0) | 2023.05.10 |
---|---|
[leetcode-706] Design HashMap (0) | 2023.05.09 |
[leetcode-48] Rotate Image (0) | 2023.04.30 |
[leetcode-347] Top K Frequent Elements (0) | 2023.04.27 |
[leetcode-43] Multiply Strings (0) | 2023.04.26 |