nums๋ ์ซ์๋ก ์ด๋ฃจ์ด์ง ๋ฐฐ์ด์ ๋๋ค.
๊ฐ์ฅ ์์ฃผ ๋ฑ์ฅํ ์ซ์๋ฅผ k ๊ฐ์๋งํผ return ํด์ฃผ์ธ์.nums = [1,1,1,2,2,3], k = 2 - return [1,2] - nums = [1] k = 1 - return [1]
๊ทธ์ ๊ป ํ์๋ #7 ๋ฆฌ์คํธ ๋ด ๊ณผ๋ฐ์ ๋๋ ์ซ์ ๋ฐํํ๊ธฐ
๋ฌธ์ ๋ ๋น์ทํ๋ค.
๊ทธ ๋ฌธ์ ๋ ๋งค๊ฐ๋ณ์๋ก ์ซ์๋ฆฌ์คํธ๋ฅผ ๋ฐ์ ๊ณผ๋ฐ์๊ฐ ๋๋ ์ซ์๋ฅผ ๋ฐ๋ก ๋ฐํํ๋ฉด ๋์์ง๋ง,
์ด๋ฒ ๋ฌธ์ ๋ ๋งค๊ฐ๋ณ์๋ก ์ซ์๋ฆฌ์คํธ, k๋ผ๋ ๋งค๊ฐ๋ณ์ ๋๊ฐ๋ฅผ ๋ฐ์์ k์ ๊ฐฏ์๋งํผ์ ์ซ์๋ฅผ ๋ฐํํด์ผ ํ๋ค.
#7๋ฒ ๋ฌธ์ ๋ ๋น์ทํ๊ฒ ํ๊ณ ๋์ k์ ๊ฐ์๋งํผ์ ๋ฐํํ๋๋ก ํ๋ ค ํ๋ค!
def top_k(nums, k):
count = set(nums)
check_nums = {}
final_nums = []
for i in count:
check_nums[i] = nums.count(i)
for j in range(k):
max_key = max(check_nums, key=check_nums.get)
final_nums.append(max_key)
del(check_nums[max_key])
return final_nums
์ฐ์ ๋งค๊ฐ๋ณ์๋ก ๋ค์ด์จ ๋ฆฌ์คํธ๋ฅผ set
์๋ฃ๊ตฌ์กฐํ์ผ๋ก ๋ฐ๊ฟ์ ์ ์ผํ ์ซ์๋ค์ ์ถ์ถํ ๋ค
ํด๋น ์ซ์๋งํผ for loop
์ ๋๋ฆฌ๋ฉด์ check_nums๋ผ๋ dictionary
๋ด๋ถ์
๊ฐ ์ซ์, ๊ทธ ์ซ์์ ๊ฐ์๋ฅผ key, value
๊ตฌ์กฐ๋ก ๋ฃ์ด์ค๋ค.
๋งค๊ฐ๋ณ์๋ก ๋ฐ์ k ๋งํผ์ ์ซ์๋ค์ ๋ฆฌํดํด์ผ ํ๊ธฐ๋๋ฌธ์
check_nums
๋ผ๋ dictionary
๋ด์ ์กด์ฌํ๋ value
๋ค ์ค ๊ฐ์ฅ ํฐ key
๊ฐ์ ๊ตฌํ๋ค,max_key
๊ฐ์ final_nums
๋ผ๋ list
๋ด์ ๋ฃ๊ณ check_nums
๋ผ๋ dictionary
๋ด์์ ํด๋น key
๋ฅผ ์ญ์ ํ๋ค.๋ ์กฐ๊ฑด์ผ๋ก k๋งํผ ๋ฐ๋ณตํ๋ for loop
์ ๋๋ฆฐ๋ค.
์ดํ ๋ฆฌํดํด์ฃผ๊ธฐ!
์ด๊ฒ๋ณด๋ค ํจ์จ์ ์ธ ๋ฐฉ๋ฒ์ด ๋ถ๋ช
ํ ์์ํ
๋ฐ....
๋ค ํ์ด๋ธ ๋ค ๋ชจ๋ธ ์๋ฃจ์
์ ๋ณด๊ธฐ๋ก ํ๋ค.
def top_k(nums, k):
count = {}
for n in nums:
count[n] = count.get(n, 0) + 1
bucket = [[] for _ in range(len(nums)+1)] <- ์ฌ๊ธฐ!!
for n, freq in count.items():
bucket[freq].append(n)
ret = []
for n_list in bucket[::-1]:
if n_list:
ret.extend(n_list)
if len(ret) == k:
return ret
์ญ์๋ ์ค๋์ ๋ชจ๋ธ ์๋ฃจ์
๋ ์ ๋ง์ด์ง ์ฝ์ง ์๋ค.. ํํ
๊ทธ๋๋ ๋์ฑ ๊ฐ๊ฒฐํ, ์์ค๋์ ์ฝ๋์ ๋ํ ์ดํด๋๋ฅผ ์ฌ๋ฆฌ๊ณ ์ถ์ผ๋๊น..! ๋ถ์ํด๋ณด๊ธฐ๐คฏ ๐คฏ
but ๋ถ์ํ๋ ค๊ณ ํ๋๋ ๋น์ฅ 5๋ฒ์งธ ์ฝ๋๋ถํฐ ๋งํ๋ ๊ฒ์ด ์๋๊ฐใ
ใ
๋น์ฅ ๊ฒ์์ ๋ญ๋ผ๊ณ ํด์ผํ ์ง.. ๊ฒ์ ํค์๋๋ ๋ชจ๋ฅด๊ฒ ๊ณ ..!(์ด๋ด๋๋ ์ง๋ฌธ.. )
list comprehension
์ด๋ผ๋ ์ ์ธ ๋ฐฉ์์ด๋ผ๊ณ ํ๋ค.
Advanced Python์ ์์ ์๋ค์ด๊ฐ๋ณผ์ค ์์๋๋, ์ด๋ ๊ฒ ๋ณด๊ฒ ๋๋ค..
๋ Python์ด๋ ์ธ์ฐ์ด์๋ค..
์ํผ ๊ทธ๋์ list Comprehension์ด ๋ฌด์์ธ๊ฐ?
[ ]
๋๊ดํธ๋ฅผ ์ฌ์ฉํ์ฌ ์์ฑ
- ์ฐ๋ฆฌ๊ฐ ๋ง๋ค๋ ค๋ ์์๋ฅผ ํํํ๋ ํํ์์ผ๋ก ์์ํ์ฌ
for loop
์ด ๋ค๋ฐ๋ผ์ค๋ ํ์for loop
๋ค์if
๋ฌธ์ ์ถ๊ฐํ์ฌ ์กฐ๊ฑด๋ฌธ์ ํฌํจํ ํ์๋ ๊ฐ๋ฅ![ ํํ์ for ์์ in ๋ฐ๋ณต ๊ฐ๋ฅํ ๊ฐ์ฒด ] [ ํํ์ for ์์ in ๋ฐ๋ณต ๊ฐ๋ฅํ ๊ฐ์ฒด if๋ฌธ ]
๐ฉ๐ปโ๐ฆฐ (๊ณผ๊ฑฐ์ ํ๋) : ๊ตณ์ด list comprehension
์ด๋ผ๋ ๊ฐ๋
์ ์์์ผํด? ๊ทธ๋ฅ for loop
๋๋ ค์ ๋ฃ์ผ๋ฉด ์๋ผ?
๐ฉโ๐ป (ํ์ฌ์ ๋) : ์ ์๋ผ ํจ์ฌ ๊ฐ๊ฒฐํ๊ฒ ์ฝ๋๋ฅผ ์งค ์ ์์ผ๋๊น ๊ผญ ์์๋ฌ์ผํด
1~10๊น์ง์ ๋ฆฌ์คํธ ์์ฑํ๊ณ ์ถ์ ๋, ์ง๊ธ๊น์ง๋ ๋น ๋ฐฐ์ด์ ์ ์ธํ๊ณ , for loop
์ ์ ์ธํด์, ๋น ๋ฐฐ์ด ์์ ์์๋ค์ด ์ถ๊ฐ๋๋๋ก ํ๊ณ .. ๊ทธ๊ฑธ 10๋ฒ ๋ฐ๋ณต์ ํ๊ณ ..
์๋ฌด๋ฆฌ ๊ฐ๋จํ๊ฒ ์๊ฐํด๋ด๋ 3?4์ค ์ ๋์ ์ฝ๋๊ฐ ๋์ค๋๋ฐ list comprehension
์ ์ฌ์ฉํ๋ฉด?
new_list = [ x for x in range(1, 11) ]
print(new_list)
์๋ก์ผ ํ ์ค๋ก ๋๋ผ ์ ์๋ค. ๐คฉ
list
๋ด ์ซ์๋ค ์ค ํ์๋ง ์ถ์ถํด์ for loop
๋ฐ๊นฅ์ odd_numbers
๋ผ๋ ๋ฆฌ์คํธ์ append
ํ๋ ์ฝ๋์ ๊ฒฝ์ฐ,
odd_numbers = [ ]
for element in range(1,11):
if (element % 2) == 1:
odd_numbers.append(element)
์ง๊ธ๊น์ง๋ ์ด๋ฐ ์์ผ๋ก ์์ฑํ์๋ค!
if
๋ฅผ ํฌํจํ๋ list comprehension
์ผ๋ก ์์ ํด์ฃผ๋ฉด?
list_comprehension = [ element for element in range(1,11) if (element % 2) == 1 ]
print(list_comprehension)
ํ์ค๋ก ์์ฑํ ์ ์๊ฒ, ํจ์ฌ ๊ฐ๊ฒฐํด์ง๋ค!
list comprehension์ ์ฅ์ ์?
- ์ฝ๋๊ฐ ๊ฐ๊ฒฐํ๋ค & ์์ ์ํ ์๋๊ฐ ํจ์ฌ ๋น ๋ฅด๋ค
- ๋ฐ์ดํฐ๋ฒ ์ด์ค๋ฅผ ์กฐํํ์ฌ ๋ฆฌ์คํธ๋ก ๋ง๋ค ๋ ๋ง์ด ์ฌ์ฉ๋๋ค
: ์๋ก์ด ๋ฐฐ์ด์ ๋ง๋ค๋ ์ ์ฉ
๐๐ป DB์์ ๊ฒ์๋ฌผ ๋ฆฌ์คํธ๋ฅผ ๊ฐ์ ธ์ฌ ๋ ์๋๋ฅผ ํจ์ฌ ๋น ๋ฅด๊ฒ ์งํํ ์ ์๋ค!
- ๋ํ ์ฑ๋ฅ๊ฐ์ ์ ํ๊ธฐ ์ํด์ ๋ฆฌ์คํธ ์ปดํ๋ฆฌํจ์ ์ ์ฌ์ฉํ๊ธฐ๋ ํ์ง๋ง ๋ชจ๋ ์ํฉ์์ ๋ฆฌ์คํธ ์ปดํ๋ฆฌํจ์ ์ด ๋ง๋ฅ์ ์๋๋๋ค.
์๋ฅผ ๋ค์ด ์ฝ๋์ ๊ฐ๋ ์ฑ์ ์ํด์๋ ์ฌ๋ฌ ์ค์ ํํ์๊ณผ ์กฐ๊ฑด๋ฌธ์ผ๋ก ํํํ๋ ๊ฒ์ด ์ด์ค for๋ฌธ์ ๋ณต์กํ ๋ฆฌ์คํธ ์ปดํ๋ฆฌํจ์ ํ์ค๋ก ์ฝ๋ฉํ๋ ๊ฒ๋ณด๋ค ๋์ ๊ฒฝ์ฐ๋ ์์ต๋๋ค.
๐๐ป ๊ตฌ๊ธ์ ํ์ด์ฌ ์คํ์ผ ๊ฐ์ด๋์์ list comprehension์ ์ฅ์ ๊ณผ ๋จ์ ์ ํ์ธ ํ ์ ์๋ค!