1์ฃผ์ฐจ ์ต๊ณ ๋์ด๋...๋ฐํ๐ญ
<๋ฌธ์ >
String ํ์ธ str ์ธ์์์ ์ค๋ณต๋์ง ์์ ์ํ๋ฒณ์ผ๋ก ์ด๋ฃจ์ด์ง ์ ์ผ ๊ธด ๋จ์ด์ ๊ธธ์ด๋ฅผ ๋ฐํํด์ฃผ์ธ์.
str: ํ ์คํธ
return: ์ค๋ณต๋์ง ์์ ์ํ๋ฒณ ๊ธธ์ด (์ซ์ ๋ฐํ)์๋ฅผ ๋ค์ด
- str = "abcabcabc"(return์ 3)ใ=> 'abc' ๊ฐ ์ ์ผ ๊ธธ๊ธฐ ๋๋ฌธ
- str = "aaaaa"(return์ 1)ใ=> 'a' ๊ฐ ์ ์ผ ๊ธธ๊ธฐ ๋๋ฌธ
- str = "sttrg"(return์ 3)ใ=> 'trg' ๊ฐ ์ ์ผ ๊ธธ๊ธฐ ๋๋ฌธ
์ ๊ทผ์ด๊ณ ๋ญ๊ณ ์ฝ๋์นดํ 1์๊ฐ์ค ๋ฌธ์ ๋ฅผ ์ดํดํ๋๋ฐ 40๋ถ์ ์ผ๋ค ๐ญ๐ญ ๋๋ ๋ฐ๋ณด์ธ๊ฐ...
๋ฌธ์ ๋ฅผ ์ดํดํ๊ณ ๋จผ์ ๋ ์๊ฐ์ ์ค๋ณต๋๋ ๋จ์ด๋ฅผ ๊ธฐ์ค์ผ๋ก ๋จ์ด๋ค์ ์ฌ๋ผ์ด์ฑํด์ผ๊ฒ ๋ค๋ ์๊ฐ์ด์๋ค.
๋น ๋ฆฌ์คํธ๋ฅผ ํ๋ ๋ง๋ค๊ณ , ์ฌ๋ผ์ด์ฑ์ ํ๋ค ๊ฐ ๋จ์ด์ค์์ ๊ฐ์ฅ ๊ธด๊ฑธ ๊ณ ๋ฅด๋ฉด ๋์ง ์์๊น? ๋ผ๊ณ ์ ๊ทผํด ๋ณด์๋ค
def get_len_of_str(s):
a = []
for i in s:
์ฒ์ฐธํ๊ฒ ๋จ๊ฒจ์ง ๋ด์ฝ๋...
์ฌ๋ผ์ด์ฑํ ๋จ์ด๋ฅผ ๊ฐ๊ฐ ๊ฒฐ๊ณผ๊ฐ์ผ๋ก ์ถ์ถํ๋๋ฒ์ ์์ง๋ง.. ์ด๊ฑธ ๋ฐ๋ก ๋ฐ๋ก ๋ฆฌ์คํธ์ ๋ฃ์์ค ๋ชฐ๋ผ ํ์ฐธ์ ํค๋งค๋ค ์ฝ๋์นดํ๊ฐ ๋์ด๋ฌ๋ค...ใ
ใ
def get_len_of_str(s):
word = ''
word_list = []
if s == '':
return 0
for i in s:
if i not in word:
word += i
if i == s[-1]:
print(word)
word_list.append(word)
else:
word_list.append(word)
answer = len((max(word_list, key=len)))
return answer
๋น์ทํ ๋
ผ๋ฆฌ๋ก ์ ๊ทผํ์ ๋๊ธฐ๋ถ์ ์ฝ๋๋ฅผ ๋ณด๊ณ ๋จธ๋ฆฌ๋ฅผ ํ์ณค๋๋ฐ ใ
ใ
!
๋ฐ๋ก word = ''
๋ผ๋ ๊ฑฐ์๋ค..
๋๋ ์ง๊ธ๊น์ง ๋น ๋ฌธ์์ด์ด๋ผ๋ ์๊ฐ์ ๋จ ํ๋ฒ๋ ํด๋ณธ์ ์ด ์์๋๋ฐ ํด๋ต์ด ์ฌ๊ธฐ์์ด์ ใ
ใ
๋ต๋ตํ๋ ์์ด ๋ปฅ ๋ซ๋ฆฐ๊ธฐ๋ถ์ด์๋ค(๋ฉ์ง ์ํฌ๋..๐)
def get_len_of_str(s):
dct = {}
max_so_far = curr_max = start = 0
for index, i in enumerate(s):
if i in dct and dct[i] >= start:
max_so_far = max(max_so_far, curr_max)
curr_max = index - dct[i]
start = dct[i] + 1
else:
curr_max += 1
dct[i] = index
return max(max_so_far, curr_max)
์์ ๋ชจ๋ฅด๋ ๋งค์๋๊ฐ ๋์์ ์ฐพ์๋ณด์๋ค
Enumerate๋?
์ด ํจ์๋ ์์๊ฐ ์๋ ์๋ฃํ(๋ฆฌ์คํธ, ํํ, ๋ฌธ์์ด)์ ์ ๋ ฅ์ผ๋ก ๋ฐ์ ์ธ๋ฑ์ค ๊ฐ์ ํฌํจํ๋ enumerate ๊ฐ์ฒด๋ฅผ ๋๋ ค์ค๋ค.for i, name in enumerate(['body', 'foo', 'bar']): ... print(i, name) ... 0 body 1 foo 2 bar
์ ์์ ์ ๊ฐ์ด enumerate๋ฅผ for๋ฌธ๊ณผ ํจ๊ป ์ฌ์ฉํ๋ฉด ์๋ฃํ์ ํ์ฌ ์์(index)์ ๊ทธ ๊ฐ์ ์ฝ๊ฒ ์ ์ ์๋ค. for๋ฌธ์ฒ๋ผ ๋ฐ๋ณต๋๋ ๊ตฌ๊ฐ์์ ๊ฐ์ฒด๊ฐ ํ์ฌ ์ด๋ ์์น์ ์๋์ง ์๋ ค ์ฃผ๋ ์ธ๋ฑ์ค ๊ฐ์ด ํ์ํ ๋ enumerate ํจ์๋ฅผ ์ฌ์ฉํ๋ฉด ๋งค์ฐ ์ ์ฉ
max_so_far = curr_max = start = 0๋ผ๊ณ ๋์์ ๋ณ์๋ฅผ ์ง์ ํด์ค๋ค ๋์
๋๋ฆฌ์ enumerate๋ฅผ ์ด์ฉํด ๊ฐ์ ๋ด๋ ๋ฐฉ๋ฒ์ด๋์๋๋ฐ
100ํผ์ผํธ ๋ฑ ์๋ฟ๋๊ฑด ์๋๊ณ ์๋นํ ๋ณต์กํ๋ฐ?๋ผ๊ณ ์๊ฐํ์ง๋ง ์๊ณ ๋ฆฌ์ฆ์ ์๊ฐํ๋ ์๊ฐ์ด๋ผ ๋๋ฌด ๋ฉ์๊ฒ ์ฝ๋๋ฅผ ์งฐ๋ค๊ณ ๊ฐํํ๊ธฐ ๋ฐ๋นด๋ค..๐๐
๋๋ ๊ผญ...!! ์ธ์ ๊ฐ๋!!!๐ฅ
์ซ์์ธ num์ ์ธ์๋ก ๋๊ฒจ์ฃผ๋ฉด, ๋ค์ง์ ๋ชจ์์ด num๊ณผ ๋๊ฐ์์ง ์ฌ๋ถ๋ฅผ ๋ฐํํด์ฃผ์ธ์.
num: ์ซ์
return: true or false (๋ค์ง์ ๋ชจ์์ด num์ ๋๊ฐ์์ง ์ฌ๋ถ)์๋ฅผ ๋ค์ด,
- num = 123
return false => ๋ค์ง์ ๋ชจ์์ด 321 ์ด๊ธฐ ๋๋ฌธ- num = 1221
return true => ๋ค์ง์ ๋ชจ์์ด 1221 ์ด๊ธฐ ๋๋ฌธ- num = -121
return false => ๋ค์ง์ ๋ชจ์์ด 121- ์ด๊ธฐ ๋๋ฌธ- num = 10
return false => ๋ค์ง์ ๋ชจ์์ด 01 ์ด๊ธฐ ๋๋ฌธ
๋จผ์ ์๊ฐ๋ณด๋ค ์ข ๊ฐ๋จํ๋ฐ? ๋ผ๊ณ ์๊ฐ์ ํ๋ค(๊ฐใ
..)
DAY2์์ ๋ง๋ ๋ฌธ์ ๊ฐ ๋จธ๋ฆฟ์์์ ์~โญ๏ธ๋ ์ฌ๋๊ธฐ ๋๋ฌธ! [::-1]
๋ฅผ ์ด์ฉํ๋ ๋ฐฉ๋ฒ์ด์๋๋ฐ ์ด๊ฑธ ์ด๋ฒ์๋ ์ฌ์ฉํด๋ณด๊ธฐ๋ก ํ๋ค
def same_reverse(num):
re = str(num)[::-1]
if re == str(num):
return True
else:
return False
์ ๋ ์๊ฐ๋ชปํ๋ ์น ํผ์ด....
def same_reverse(num):
num =str(num)
is_palindrome = True
for i in range(len(num) // 2):
if num[i] != num[-1 - i]:
is_palindrome = False
return is_palindrome
range๋ฅผ ์ด์ฉํ๊ณ ์ธ๋ฑ์ค๋ฅผ ์๊ณผ, ์ ์ผ ๋ง์ง๋ง์ ๋น๊ตํ๋ ๋ฐฉ์์ผ๋ก ํ์ดํ๋ค.
์ด๋ฐ์๊ฐ์ด ์๋ค๋..?
์๊ณ ๋ฆฌ์ฆ์ด๋๊ฒ ์ง์ง ๊น๊ฒ ์๊ฐํด์ผํ๋๊ตฌ๋ ์ถ๋ค..ใ
..
์ฝ๋ฉ๋์ฅ์๋ ๋์ผํ ๋ฌธ์ ํ์ด๋ฒ์ด ์์ผ๋ ๋์ค์ ๋ค์๋ณด๊ณ ๊ผญ ์ฒด๋ํ์!
๋ด๊ธฐ์ค ์ด๋ฒ์ฃผ ์ต์ต์ต์ต์ต๊ณ ๋๋์๋ค๐๐๐
strs์ ๋จ์ด๊ฐ ๋ด๊ธด ๋ฐฐ์ด์ ๋๋ค.
๊ณตํต๋ ์์ ๋จ์ด(prefix)๋ฅผ ๋ฐํํด์ฃผ์ธ์.์๋ฅผ ๋ค์ด
- strs = ['start', 'stair', 'step']
return์ 'st'- strs = ['start', 'wework', 'today']
return์ ''
def get_prefx(strs):
if strs ==[]:
return โโ
else:
prefix = โโ
strs = sorted(strs)
for i in (strs[0]):
if strs[-1].startswith(prefix+i):
prefix += i
else:
break
return prefix
์ฝ๋์นดํ ๊ฐ์ดํ ๋๊ธฐ๋ถ์ด ๊ฒ์ํด์ ์ฐพ์๋ธ๊ฒ startswith()
๋ผ๋ ๋ฉ์๋์๋๋ฐ
์์ง๋ ์ดํด๋ฅผ ์ ๋ชปํด์ ์ ๋ฆฌํด๋ณด์๋ค
str(or tuple).startswith(์์ํ๋๋ฌธ์, ์์์ง์ )
startswith๋ ๋ฌธ์์ด์ด ํน์ ๋ฌธ์๋ก ์์ํ๋์ง ์ฌ๋ถ๋ฅผ ์๋ ค์ฃผ๋ ๋ฉ์๋์ด๋ค. ๋์๋ฌธ์๋ฅผ ๊ตฌ๋ถํ๋ฉฐ ๊ฒฐ๊ณผ๊ฐ์ True/False๋ก ๋ฐํ๋๋ค.
๊ทธ๋ฆฌ๊ณ ์ธ์๊ฐ์๋ tuple ๋ฐ์ ๋ค์ด๊ฐ์ง ์๋๋ฐ list๋ dict์ ๋ฃ๋๋ค๋ฉด ์ค๋ฅ๊ฐ ๋๋ค.(tuple์ ์ฌ์ฉํ ๋์๋ string์์ ์์ํ๋ ๋ฌธ์์ด์ด tuple ์์ผ๋ฉด true๊ฐ ๋ฐํ๋๋ค. )string = "hello startswith" print(string.startswith("hello")) # >>True string = "hello startswith" print(string.startswith("Hello")) # >>False
ํน์ ๋ฌธ์์ด๋ก ๋๋๋์ง ์์๋ณด๋ endswith(๋๋๋๋ฌธ์, ๋ฌธ์์ด์์์, ๋ฌธ์์ด์๋)๋งค์๋๋ ์๋ค
def get_prefix(strs):
sorted_strs = sorted(strs)
if strs == []:
return ''
if sorted_strs[0][0] != sorted_strs[-1][0]:
return ''
if len(sorted_strs[0]) > len(sorted_strs[-1]):
shortest = len(sorted_strs[-1])
elif len(sorted_strs[0]) <= len(sorted_strs[-1]):
shortest = len(sorted_strs[0])
answer = []
for i in range(shortest):
if sorted_strs[0][i] == sorted_strs[-1][i]:
answer.append(sorted_strs[0][i])
print(answer)
return ''.join(answer)
์ด๊ฒ๋ ๋๋ฌด ์ ๊ธฐํ๋ค!
sorted_strs[0][0]
๋ผ๋๊ฒ๋ ์ฒ์ ๋ณด๊ณ !!
sorted๋ก ๋จผ์ ์ํ๋ฒณ์์ผ๋ก ๋ถ๋ฆฌํ๋ค if๋ฌธ์ผ๋ก ์ฒซ๋ฒ์งธ ๋จ์ด์ ์ ์ผ ๋ง์ง๋ง ๋จ์ด์ ์ฒซ๊ธ์๊ฐ ๋์ผํ์ง๋ถํฐ ๋ฐ์ง๋ ์์ผ๋ก ๋ฐ์ง๊ณ ๋ค์ด๊ฐ๋ค.
if๋ฌธ์ด ๋ง๊ณ ๊ธธ๋ค๊ณ ํ์
จ์ง๋ง ๋ด๊ฐ ๋ณด๊ธฐ์๋ ์ ๋ง ์ ์ง์ ๊ฑฐ ๊ฐ์์!! ๊ณต๋ถํ๊ฒ ๋ฌ๋ผ๊ณ ํ๋ค
def get_prefix(strs):
if len(strs) == 0:
return ''
res = ''
strs = sorted(strs)
for i in strs[0]:
if strs[-1].startswith(res+i):
res += i
else:
break
return res
๊ฐ์ด ์ฝ๋์นดํํ ๋๊ธฐ๋ถ์ ๋ต๊ณผ 100ํผ์ผํธ ์ผ์น! (์์ฐ)
์ ๊ทผ๋ฐฉ๋ฒ์ ์ดํด๋ฅผ ํ๋๋ฐ ์์ง ๋ด๊ฐ ์ฝ๋ 100%๋ง๋ค์ด๋ด์ง๋ ๋ชปํ ๊ฒ ๊ฐ์์ ๋ค์์ฃผ์ ๋ ๋ค์ ๋ณต์ตํ๊ธฐ๋ก!
ํ์ด๋ง~~~!!