์๊ณ ๋ฆฌ์ฆ ๋ฌธ์ ๋ฅผ ํ๋ค๊ฐ ์ฒ์์ผ๋ก ์ ํ๋ ์ ํ์ ๋ดค๋ค. ์ฐ์ prefix๋ฅผ ๊ทธ๋๋ก ๋ฒ์ญํ๋ฉด ์ ๋์ฌ์ธ๋ฐ, ๋ฌธ์์ด์ ์ฌ๋ฌ๊ฐ ์ฃผ๊ณ , ๊ฐ ์์์ ์ ๋ถ๋ถ๋ถํฐ ๋๊ฐ์ ๋ฌธ์๋ฅผ ๋ฐํํ๋ ๋ฌธ์ ์๋ค. ์์ผ๋ฉด ๊ทธ๋ฅ ๋น ๋ฌธ์์ด์ returnํ๋ค.
strs์ ๋จ์ด๊ฐ ๋ด๊ธด ๋ฐฐ์ด์ ๋๋ค. ๊ณตํต๋ ์์ ๋จ์ด(prefix)๋ฅผ ๋ฐํํด์ฃผ์ธ์.
์๋ฅผ ๋ค์ด strs = ['start', 'stair', 'step'] # ourput = 'st' strs = ['start', 'wework', 'today'] # output = ''
๋ด๊ฐ ์๊ฐํ๋ ๋ฐฉ๋ฒ์ ์ฐ์ ์๋์ ๊ฐ์๋ค.
๊ทธ๋ฐ๋ฐ ์์์ ๊ฐ์๋, ๊ฐ ์์๋ค์ ๊ธธ์ด๋ ์ ํด์ง์ง ์์ ์ํ์์ ๋น๊ตํ๋ ๋ก์ง์ ์ง๋๊ฒ ๋๋ฌด ์ด๋ ค์ ๋ค. nested for loop๋ฅผ ์จ๋ ์ด๋ค ๋ฌธ์์ด์ ์ ๋ต์ด ๋์์ง๋ง ์ด๋ค ๋ฌธ์์ด์ ๋ ๋์ค์ง ์์๋ค ๐คฏ๐คฏ๐คฏ๐คฏ๐คฏ๐คฏ๐คฏ
์ต์ 4-5์๊ฐ ๊ณ ๋ฏผํ๋๋ฐ ๋ต์ด ์ ๋์์ ๊ตฌ๊ธ ์ฑ์ค๋ฅผ ์ด ๊ฒฐ๊ณผ ๐... ๊ฒฐ๊ตญ ์ ๋ ฌ์ ํ๊ณ ๋ง์ง๋ง ์์์ ๊ธธ์ด๊ฐ ๊ฐ์ฅ ์งง์ ์์๋ง ๋น๊ตํด์ฃผ๋ฉด ๋๋ ๊ฑฐ์๋ค.
์ฒ์์๋ ๋ง์ง๋ง ์์๋ ๋น๊ตํ๋ฉด ๋๋จธ์ง๋..? ๋ค๋ฅธ ์์๋ ๊ณ ๋ คํ์ง ์์ผ๋ฉด ์ด๋กํด? ์ถ์๋๋ฐ
์ฌ์ค sort๋ก ์ ๋ ฌ์ ํ๊ฒ ๋๋ฉด ์คํ ๋ง์ ์์๋๋ก ์ ๋ ฌํด์ฃผ๊ธฐ ๋๋ฌธ์ ๋ง์ฝ ๋ค๋ฅธ ๊ฒ์ด ํ๋๋ผ๋ ์๋ค๋ฉด, ๋ง์ง๋ง ์์๋ง ๋น๊ตํด์ฃผ๋ฉด ๋๋ ๊ฒ
์ด์๋ค. ๋ค๋ฅธ ์์๊ฐ ๋ ๋ง์๋ ์ด์ฐจํผ ๋ง์ง๋ง๊บผ๋ง ๋น๊ตํด์ฃผ๋ฉด ๋๋๊ฑฐ๋ค...!
์์งํ ํ ์๋ฟ์ง๋ ์๋๋ฐ ์ด๋ ์ ๋๋ก ์ดํด๋ ๊ฐ๋ค. sort method์ ๋ ๊ฐ๊น์์ ธ์ผ ๊ฒ ๋ค๋ ์๊ฐ์ด ๋ ๋ค.
def get_prefix(string):
if len(string) == 0:
return ''
string.sort() # ์ ๋ ฌํด์ฃผ๊ธฐ
shortest = string[0] #๋น๊ต ๊ธฐ์ค์ด ๋๋ ๋ฌธ์์ด ๋ฝ๊ธฐ
prefix = '' # ์ฌ๊ธฐ๋ค๊ฐ ๋ฃ์ด์ค๊ฑฐ์ผ
for i in range(len(shortest)):
if string[len(string)-1][i] == shortest[i]:
prefix += string[len(string)-1][i]
else:
break
return prefix
์ค๋ฆ์ฐจ์, ๋ด๋ฆผ์ฐจ์์ ์ํด ์ฌ์ฉํ๋ list method์ด๋ค. ์ซ์๋ ์์ ์ซ์๋ถํฐ, ๋ฌธ์์ด์ a๋ถํฐ ์์๋๋ก ๋ฐํํ๋ค.
์ฃผ์ํ ์ ์ sort์ ๋ฐ๋๋ฅผ reverse ํจ์๋ก ์๊ฐํ๋ฉด ์ ๋๋ค. reverse ํจ์๋ ๊ทธ๋ฅ ๋ฆฌ์คํธ๋ฅผ ๊ฑฐ๊พธ๋ก ๋ฐํํ๋๊ฑฐ๋ค. ๋ด๋ฆผ์ฐจ์์ ์ํด์๋ reverse๋ฅผ sort์ ์ต์
๊ฐ
์ผ๋ก ๋ฃ์ด์ผ ํ๋ค.
a = [ 100, 4, 80, 11, 40 ]
# sort ํจ์: ๊ธฐ๋ณธ ๊ฐ์ด ์ค๋ฆ์ฐจ์ ์ ๋ ฌ
a.sort()
print(a) # output = [4, 11, 40, 80, 100]
# sort ํจ์์ reverse ์ ์ฉ: ํด๋น ์ต์
์ผ๋ก ๋ด๋ฆผ์ฐจ์์ผ๋ก ํ์ธ ๊ฐ๋ฅ
a.sort(reverse=True)
print(a) # output = [100, 80, 40, 11, 4]
# reverse ํจ์: ์ธ๋ฑ์ค๋ฅผ ๋ฐ๋๋ก ์ ์ฉํด ๋ฐํํ๋ค.
a.reverse()
print(a) # output = [40, 11, 80, 4, 100]
์ซ์๋ก ์ดํดํ๋ฉด ์ฌ์ด๋ฐ, ๋ฌธ์์ด์ ๋ญ๊ฐ ๋ด๋ฆผ, ์ค๋ฆ์ฐจ์์ ๋ํด์ ์ง๊ด์ ์ผ๋ก ์๊ฐํ๊ธฐ ํ๋ค๋ค. ์ฐธ๊ณ ๋ฅผ ์ํด ๋ฌธ์์ด๋ ์๋ก ๋ฃ์ด๋ดค๋ค.
strs = ['start', 'stair', 'step']
strs.sort()
print(strs) # output = ['stair', 'start', 'step']
'''st๊น์ง๋ ๋๊ฐ๊ณ , ์ธ ๋ฒ์งธ ๊ธ์๋ถํฐ a,e๋ก ๋ฌ๋ผ์ง๋ค.
์ค๋ฆ์ฐจ์์ด๊ธฐ ๋๋ฌธ์ a๊ฐ ์ค๋ ๋ฌธ์์ด๋ถํฐ ์์ผ๋ก ์์ผ๋ฉฐ, ๋ง์ง๋ง ๋ฌธ์๊ฐ e์ด๋ฏ๋ก
์ฒซ ๊ธ์์ ๋ง์ง๋ง ๊ธ์๋ง ๋น๊ตํด์ฃผ๋ฉด ๋๋ค.'''
sort๊ฐ list์ method๋ผ๋ฉด, sorted๋ ๋ฆฌ์คํธ๋ฅผ ์ธ์๋ก ๋ฃ๋ ํจ์
๋ค. ๋ง์ฐฌ๊ฐ์ง๋ก ๋ฆฌ์คํธ๋ฅผ ์์๋๋ก ์ ๋ ฌํด์ค ๋ค ๊ฒฐ๊ณผ๊ฐ์ ๋ฐํํ๊ณ , itertableํ ๊ฐ์ฒด์ ๋ชจ๋ ์ ์ฉ ๊ฐ๋ฅํ๋ค.
๊ทธ๋์ ๋ฐฐ์ ๋ ์๋ฃ๊ตฌ์กฐ๋ค๋ก ๋ชจ๋ ์ ์ฉ์ ํด๋ดค๋ค. ํน์ง์ ์ธ ๋ถ๋ถ์ ๋ค์๊ณผ ๊ฐ๋ค.
# list ์ค๋ฆ ์ฐจ์์ผ๋ก ๋ฐ๊ฟ์ ๋ค๋ฅธ ๋ณ์์ assign ํ๊ธฐ
a = [ 100, 4, 80, 11, 40 ]
b = sorted(a)
print(b) # output = [4, 11, 40, 80, 100]
# tuple
a = ('abc', 'bdkf', 'aaccc')
b = sorted(a)
print(b) # output = ['aaccc', 'abc', 'bdkf']
# set
a = {'abc', 'bdkf', 'aaccc'}
b = sorted(a)
print(b) # output = ['aaccc', 'abc', 'bdkf']
# dictionary
a = {5:'abc', 3:'fsdb', 1:'aaacc'}
# ๊ธฐ๋ณธ return์ key๊ฐ
b = sorted(a)
print(b) # output = [1, 3, 5]
# values method๋ก value๊ฐ ์ ๋ ฌํด์ ๋ฆฌํด ๊ฐ๋ฅ
b = sorted(a.values())
print(b) # output = ['aaacc', 'abc', 'fsdb']
์๋ ๋งํฌ๊ฐ prefix, ๊ทธ๋ฆฌ๊ณ ๋ฆฌ์คํธ ์ ๋ ฌ ๊ด๋ จํด์ ๋งค์ฐ ์ ์ ๋ฆฌํด๋์๋ค. ์ฌ์ค ๋ฆฌ์คํธ์์ ์์๋ฅผ ๋ฝ์์ ๋ฃ์ ์๊ฐ๋ง ํ์ง, ๋ฆฌ์คํธ๋ฅผ ์ ์ ๋ ฌํด์ ์ฝ๊ฒ ํด๊ฒฐํ ๋ฐฉ๋ฒ์ ๋ชปํ๋ ๊ฒ ๊ฐ๋ค.
์์ผ๋ก ์ ์ฌํ ๋ฌธ์ ๊ฐ ๋์ค๋ฉด ์ฐธ๊ณ ํ ๊ฒ โ๏ธ