ํด์
- ์ค๋ช : Key-value์์ผ๋ก ๋ฐ์ดํฐ๋ฅผ ๋น ๋ฅด๊ฒ ์ฐพ์๋ณด์ธ์.
- ์ถ์ ๋น๋ : ๋์
- ํ๊ท ์ ์ : ๋ณดํต
ํฐ์ผ๋ชฌ (Level 1, 29813๋ช ์๋ฃ)
๋ฌธ์ ์ค๋ช
๋น์ ์ ํฐ์ผ๋ชฌ์ ์ก๊ธฐ ์ํ ์ค๋ ์ฌํ ๋์, ํ ๋ฐ์ฌ๋์ ์ฐ๊ตฌ์ค์ ๋์ฐฉํ์ต๋๋ค. ํ ๋ฐ์ฌ๋์ ๋น์ ์๊ฒ ์์ ์ ์ฐ๊ตฌ์ค์ ์๋ ์ด N ๋ง๋ฆฌ์ ํฐ์ผ๋ชฌ ์ค์์ N/2๋ง๋ฆฌ๋ฅผ ๊ฐ์ ธ๊ฐ๋ ์ข๋ค๊ณ ํ์ต๋๋ค.
ํ ๋ฐ์ฌ๋ ์ฐ๊ตฌ์ค์ ํฐ์ผ๋ชฌ์ ์ข
๋ฅ์ ๋ฐ๋ผ ๋ฒํธ๋ฅผ ๋ถ์ฌ ๊ตฌ๋ถํฉ๋๋ค. ๋ฐ๋ผ์ ๊ฐ์ ์ข
๋ฅ์ ํฐ์ผ๋ชฌ์ ๊ฐ์ ๋ฒํธ๋ฅผ ๊ฐ์ง๊ณ ์์ต๋๋ค. ์๋ฅผ ๋ค์ด ์ฐ๊ตฌ์ค์ ์ด 4๋ง๋ฆฌ์ ํฐ์ผ๋ชฌ์ด ์๊ณ , ๊ฐ ํฐ์ผ๋ชฌ์ ์ข
๋ฅ ๋ฒํธ๊ฐ [3๋ฒ, 1๋ฒ, 2๋ฒ, 3๋ฒ]์ด๋ผ๋ฉด ์ด๋ 3๋ฒ ํฐ์ผ๋ชฌ ๋ ๋ง๋ฆฌ, 1๋ฒ ํฐ์ผ๋ชฌ ํ ๋ง๋ฆฌ, 2๋ฒ ํฐ์ผ๋ชฌ ํ ๋ง๋ฆฌ๊ฐ ์์์ ๋ํ๋
๋๋ค. ์ด๋, 4๋ง๋ฆฌ์ ํฐ์ผ๋ชฌ ์ค 2๋ง๋ฆฌ๋ฅผ ๊ณ ๋ฅด๋ ๋ฐฉ๋ฒ์ ๋ค์๊ณผ ๊ฐ์ด 6๊ฐ์ง๊ฐ ์์ต๋๋ค.
- ์ฒซ ๋ฒ์งธ(3๋ฒ), ๋ ๋ฒ์งธ(1๋ฒ) ํฐ์ผ๋ชฌ์ ์ ํ
- ์ฒซ ๋ฒ์งธ(3๋ฒ), ์ธ ๋ฒ์งธ(2๋ฒ) ํฐ์ผ๋ชฌ์ ์ ํ
- ์ฒซ ๋ฒ์งธ(3๋ฒ), ๋ค ๋ฒ์งธ(3๋ฒ) ํฐ์ผ๋ชฌ์ ์ ํ
- ๋ ๋ฒ์งธ(1๋ฒ), ์ธ ๋ฒ์งธ(2๋ฒ) ํฐ์ผ๋ชฌ์ ์ ํ
- ๋ ๋ฒ์งธ(1๋ฒ), ๋ค ๋ฒ์งธ(3๋ฒ) ํฐ์ผ๋ชฌ์ ์ ํ
- ์ธ ๋ฒ์งธ(2๋ฒ), ๋ค ๋ฒ์งธ(3๋ฒ) ํฐ์ผ๋ชฌ์ ์ ํ
์ด๋, ์ฒซ ๋ฒ์งธ(3๋ฒ) ํฐ์ผ๋ชฌ๊ณผ ๋ค ๋ฒ์งธ(3๋ฒ) ํฐ์ผ๋ชฌ์ ์ ํํ๋ ๋ฐฉ๋ฒ์ ํ ์ข
๋ฅ(3๋ฒ ํฐ์ผ๋ชฌ ๋ ๋ง๋ฆฌ)์ ํฐ์ผ๋ชฌ๋ง ๊ฐ์ง ์ ์์ง๋ง, ๋ค๋ฅธ ๋ฐฉ๋ฒ๋ค์ ๋ชจ๋ ๋ ์ข
๋ฅ์ ํฐ์ผ๋ชฌ์ ๊ฐ์ง ์ ์์ต๋๋ค. ๋ฐ๋ผ์ ์ ์์์์ ๊ฐ์ง ์ ์๋ ํฐ์ผ๋ชฌ ์ข
๋ฅ ์์ ์ต๋๊ฐ์ 2๊ฐ ๋ฉ๋๋ค.
๋น์ ์ ์ต๋ํ ๋ค์ํ ์ข
๋ฅ์ ํฐ์ผ๋ชฌ์ ๊ฐ์ง๊ธธ ์ํ๊ธฐ ๋๋ฌธ์, ์ต๋ํ ๋ง์ ์ข
๋ฅ์ ํฐ์ผ๋ชฌ์ ํฌํจํด์ N/2๋ง๋ฆฌ๋ฅผ ์ ํํ๋ ค ํฉ๋๋ค. N๋ง๋ฆฌ ํฐ์ผ๋ชฌ์ ์ข
๋ฅ ๋ฒํธ๊ฐ ๋ด๊ธด ๋ฐฐ์ด nums๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋, N/2๋ง๋ฆฌ์ ํฐ์ผ๋ชฌ์ ์ ํํ๋ ๋ฐฉ๋ฒ ์ค, ๊ฐ์ฅ ๋ง์ ์ข
๋ฅ์ ํฐ์ผ๋ชฌ์ ์ ํํ๋ ๋ฐฉ๋ฒ์ ์ฐพ์, ๊ทธ๋์ ํฐ์ผ๋ชฌ ์ข
๋ฅ ๋ฒํธ์ ๊ฐ์๋ฅผ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
์ ํ์ฌํญ
- nums๋ ํฐ์ผ๋ชฌ์ ์ข ๋ฅ ๋ฒํธ๊ฐ ๋ด๊ธด 1์ฐจ์ ๋ฐฐ์ด์ ๋๋ค.
- nums์ ๊ธธ์ด(N)๋ 1 ์ด์ 10,000 ์ดํ์ ์์ฐ์์ด๋ฉฐ, ํญ์ ์ง์๋ก ์ฃผ์ด์ง๋๋ค.
- ํฐ์ผ๋ชฌ์ ์ข ๋ฅ ๋ฒํธ๋ 1 ์ด์ 200,000 ์ดํ์ ์์ฐ์๋ก ๋ํ๋ ๋๋ค.
- ๊ฐ์ฅ ๋ง์ ์ข ๋ฅ์ ํฐ์ผ๋ชฌ์ ์ ํํ๋ ๋ฐฉ๋ฒ์ด ์ฌ๋ฌ ๊ฐ์ง์ธ ๊ฒฝ์ฐ์๋, ์ ํํ ์ ์๋ ํฐ์ผ๋ชฌ ์ข ๋ฅ ๊ฐ์์ ์ต๋๊ฐ ํ๋๋ง return ํ๋ฉด ๋ฉ๋๋ค.
์ ์ถ๋ ฅ ์
nums | result |
[3,1,2,3] | 2 |
[3,3,3,2,2,4] | 3 |
[3,3,3,2,2,2] | 2 |
์ ์ถ๋ ฅ ์ ์ค๋ช
์
์ถ๋ ฅ ์ #1
๋ฌธ์ ์ ์์์ ๊ฐ์ต๋๋ค.
์
์ถ๋ ฅ ์ #2
6๋ง๋ฆฌ์ ํฐ์ผ๋ชฌ์ด ์์ผ๋ฏ๋ก, 3๋ง๋ฆฌ์ ํฐ์ผ๋ชฌ์ ๊ณจ๋ผ์ผ ํฉ๋๋ค.
๊ฐ์ฅ ๋ง์ ์ข
๋ฅ์ ํฐ์ผ๋ชฌ์ ๊ณ ๋ฅด๊ธฐ ์ํด์๋ 3๋ฒ ํฐ์ผ๋ชฌ ํ ๋ง๋ฆฌ, 2๋ฒ ํฐ์ผ๋ชฌ ํ ๋ง๋ฆฌ, 4๋ฒ ํฐ์ผ๋ชฌ ํ ๋ง๋ฆฌ๋ฅผ ๊ณ ๋ฅด๋ฉด ๋๋ฉฐ, ๋ฐ๋ผ์ 3์ return ํฉ๋๋ค.
์
์ถ๋ ฅ ์ #3
6๋ง๋ฆฌ์ ํฐ์ผ๋ชฌ์ด ์์ผ๋ฏ๋ก, 3๋ง๋ฆฌ์ ํฐ์ผ๋ชฌ์ ๊ณจ๋ผ์ผ ํฉ๋๋ค.
๊ฐ์ฅ ๋ง์ ์ข
๋ฅ์ ํฐ์ผ๋ชฌ์ ๊ณ ๋ฅด๊ธฐ ์ํด์๋ 3๋ฒ ํฐ์ผ๋ชฌ ํ ๋ง๋ฆฌ์ 2๋ฒ ํฐ์ผ๋ชฌ ๋ ๋ง๋ฆฌ๋ฅผ ๊ณ ๋ฅด๊ฑฐ๋, ํน์ 3๋ฒ ํฐ์ผ๋ชฌ ๋ ๋ง๋ฆฌ์ 2๋ฒ ํฐ์ผ๋ชฌ ํ ๋ง๋ฆฌ๋ฅผ ๊ณ ๋ฅด๋ฉด ๋ฉ๋๋ค. ๋ฐ๋ผ์ ์ต๋ ๊ณ ๋ฅผ ์ ์๋ ํฐ์ผ๋ชฌ ์ข
๋ฅ์ ์๋ 2์
๋๋ค.
ํ์ด
๋์ ํ์ด...
def solution(nums):
answer = len(nums) // 2
nums.sort() #๋ถํ์
nums = list(set(nums)) #์ฌ๊ธฐ์ set์ ํ๋ฉด sortํ ํ์๊ฐ ์์.
if answer > len(nums): #min() ํจ์ ์ฌ์ฉํด์ ํ์ค๋ก ๋ฐ๊ฟ ์ ์์.
answer = len(nums)
return answer
๊ณ ์์ ์ง๋ฆฌ๋ ํ์ด...
def solution(ls):
return min(len(ls)/2, len(set(ls)))
์์ฃผํ์ง ๋ชปํ ์ ์ (Level 1, 76150๋ช ์๋ฃ)
๋ฌธ์ ์ค๋ช
์๋ง์ ๋ง๋ผํค ์ ์๋ค์ด ๋ง๋ผํค์ ์ฐธ์ฌํ์์ต๋๋ค. ๋จ ํ ๋ช ์ ์ ์๋ฅผ ์ ์ธํ๊ณ ๋ ๋ชจ๋ ์ ์๊ฐ ๋ง๋ผํค์ ์์ฃผํ์์ต๋๋ค.
๋ง๋ผํค์ ์ฐธ์ฌํ ์ ์๋ค์ ์ด๋ฆ์ด ๋ด๊ธด ๋ฐฐ์ด participant์ ์์ฃผํ ์ ์๋ค์ ์ด๋ฆ์ด ๋ด๊ธด ๋ฐฐ์ด completion์ด ์ฃผ์ด์ง ๋, ์์ฃผํ์ง ๋ชปํ ์ ์์ ์ด๋ฆ์ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
์ ํ์ฌํญ
- ๋ง๋ผํค ๊ฒฝ๊ธฐ์ ์ฐธ์ฌํ ์ ์์ ์๋ 1๋ช ์ด์ 100,000๋ช ์ดํ์ ๋๋ค.
- completion์ ๊ธธ์ด๋ participant์ ๊ธธ์ด๋ณด๋ค 1 ์์ต๋๋ค.
- ์ฐธ๊ฐ์์ ์ด๋ฆ์ 1๊ฐ ์ด์ 20๊ฐ ์ดํ์ ์ํ๋ฒณ ์๋ฌธ์๋ก ์ด๋ฃจ์ด์ ธ ์์ต๋๋ค.
- ์ฐธ๊ฐ์ ์ค์๋ ๋๋ช ์ด์ธ์ด ์์ ์ ์์ต๋๋ค.
์ ์ถ๋ ฅ ์
participant | completion | return |
["leo", "kiki", "eden"] | ["eden", "kiki"] | "leo" |
["marina", "josipa", "nikola", "vinko", "filipa"] | ["josipa", "filipa", "marina", "nikola"] | "vinko" |
["mislav", "stanko", "mislav", "ana"] | ["stanko", "ana", "mislav"] | "mislav" |
์ ์ถ๋ ฅ ์ ์ค๋ช
"leo"๋ ์ฐธ์ฌ์ ๋ช ๋จ์๋ ์์ง๋ง, ์์ฃผ์ ๋ช ๋จ์๋ ์๊ธฐ ๋๋ฌธ์ ์์ฃผํ์ง ๋ชปํ์ต๋๋ค.
์์ #2
"vinko"๋ ์ฐธ์ฌ์ ๋ช
๋จ์๋ ์์ง๋ง, ์์ฃผ์ ๋ช
๋จ์๋ ์๊ธฐ ๋๋ฌธ์ ์์ฃผํ์ง ๋ชปํ์ต๋๋ค.
์์ #3
"mislav"๋ ์ฐธ์ฌ์ ๋ช
๋จ์๋ ๋ ๋ช
์ด ์์ง๋ง, ์์ฃผ์ ๋ช
๋จ์๋ ํ ๋ช
๋ฐ์ ์๊ธฐ ๋๋ฌธ์ ํ๋ช
์ ์์ฃผํ์ง ๋ชปํ์ต๋๋ค.
ํ์ด
๋์ ํ์ด, ์ต๊ทผ์ ์๊ฒ๋ Counter๋ก ๋ค์ ํ์ด๋ณด์๋ค. ์ฝ๋ค? ใ ก.ใ ก;from collections import Counter
def solution(participant, completion):
participant_counter = Counter(participant)
completion_counter = Counter(completion)
not_completion = participant_counter - completion_counter
return list(not_completion)[0]
๊ณ ์์ ํ์ด ๋ณด๋... 1์ค ๋ณํ๋ค๋ ์๋ค;
from collections import Counter
def solution(participant, completion):
return list(Counter(participant) - Counter(completion))[0]
์ ํ๋ฒํธ ๋ชฉ๋ก (Level 2, 45861๋ช ์๋ฃ)
๋ฌธ์ ์ค๋ช
์ ํ๋ฒํธ๋ถ์ ์ ํ ์ ํ๋ฒํธ ์ค, ํ ๋ฒํธ๊ฐ ๋ค๋ฅธ ๋ฒํธ์ ์ ๋์ด์ธ ๊ฒฝ์ฐ๊ฐ ์๋์ง ํ์ธํ๋ ค ํฉ๋๋ค.
์ ํ๋ฒํธ๊ฐ ๋ค์๊ณผ ๊ฐ์ ๊ฒฝ์ฐ, ๊ตฌ์กฐ๋ ์ ํ๋ฒํธ๋ ์์์ด์ ์ ํ๋ฒํธ์ ์ ๋์ฌ์
๋๋ค.
- ๊ตฌ์กฐ๋ : 119
- ๋ฐ์ค์ : 97 674 223
- ์ง์์ : 11 9552 4421
์ ํ๋ฒํธ๋ถ์ ์ ํ ์ ํ๋ฒํธ๋ฅผ ๋ด์ ๋ฐฐ์ด phone_book ์ด solution ํจ์์ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋, ์ด๋ค ๋ฒํธ๊ฐ ๋ค๋ฅธ ๋ฒํธ์ ์ ๋์ด์ธ ๊ฒฝ์ฐ๊ฐ ์์ผ๋ฉด false๋ฅผ ๊ทธ๋ ์ง ์์ผ๋ฉด true๋ฅผ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
์ ํ ์ฌํญ
- phone_book์ ๊ธธ์ด๋ 1 ์ด์ 1,000,000 ์ดํ์
๋๋ค.
- ๊ฐ ์ ํ๋ฒํธ์ ๊ธธ์ด๋ 1 ์ด์ 20 ์ดํ์ ๋๋ค.
- ๊ฐ์ ์ ํ๋ฒํธ๊ฐ ์ค๋ณตํด์ ๋ค์ด์์ง ์์ต๋๋ค.
์ ์ถ๋ ฅ ์์
phone_book | return |
["119", "97674223", "1195524421"] | false |
["123","456","789"] | true |
["12","123","1235","567","88"] | false |
์ ์ถ๋ ฅ ์ ์ค๋ช
์
์ถ๋ ฅ ์ #1
์์์ ์ค๋ช
ํ ์์ ๊ฐ์ต๋๋ค.
์
์ถ๋ ฅ ์ #2
ํ ๋ฒํธ๊ฐ ๋ค๋ฅธ ๋ฒํธ์ ์ ๋์ฌ์ธ ๊ฒฝ์ฐ๊ฐ ์์ผ๋ฏ๋ก, ๋ต์ true์
๋๋ค.
์
์ถ๋ ฅ ์ #3
์ฒซ ๋ฒ์งธ ์ ํ๋ฒํธ, “12”๊ฐ ๋ ๋ฒ์งธ ์ ํ๋ฒํธ “123”์ ์ ๋์ฌ์
๋๋ค. ๋ฐ๋ผ์ ๋ต์ false์
๋๋ค.
์๋ฆผ
2021๋ 3์ 4์ผ, ํ ์คํธ ์ผ์ด์ค๊ฐ ๋ณ๊ฒฝ๋์์ต๋๋ค. ์ด๋ก ์ธํด ์ด์ ์ ํต๊ณผํ๋ ์ฝ๋๊ฐ ๋ ์ด์ ํต๊ณผํ์ง ์์ ์ ์์ต๋๋ค.
ํ์ด
C++๋ก๋ ์ด๋ ๊ฒ ํ์์๋๋ฐ...
#include <string>
#include <vector>
#include <iostream>
#include <set>
using namespace std;
bool solution(vector<string> phone_book) {
set<string> tmp;
for (auto& number : phone_book)
tmp.insert(number);
for (auto it1 = tmp.begin(); it1 != tmp.end(); ++it1)
{
for (auto it2 = it1; it2 != tmp.end(); ++it2)
{
if(it1!=it2)
if (it2->find(*it1) == 0)
return false;
else
break;
}
}
return true;
}
ํ์ด์ฌ์ผ๋ก๋ ์ด๋ ๊ฒ ๋ฐ๊พธ๋ฉด ๊น๋ํ๋ค.
def solution(phone_book):
phone_book.sort()
for i in range(len(phone_book)-1):
if phone_book[i+1].startswith(phone_book[i]):
return False
return True
๊ณ ์์ ์ ์ ํ์ด ใ ก.ใ ก;;;;
def solution(phone_book):
answer = True
hash_map = {}
for phone_number in phone_book:
hash_map[phone_number] = 1
for phone_number in phone_book:
temp = ""
for number in phone_number:
temp += number
if temp in hash_map and temp != phone_number:
answer = False
return answer
O(N) ํ์ด. zip์ผ๋ก ํ๋ฉด O(N)์ด๋ผ๊ณ ํ๋ค.
def solution(phoneBook):
phoneBook = sorted(phoneBook)
for p1, p2 in zip(phoneBook, phoneBook[1:]):
if p2.startswith(p1):
return False
return True
์์ฅ (Level 2, 41255๋ช ์๋ฃ)
๋ฌธ์ ์ค๋ช
์คํ์ด๋ค์ ๋งค์ผ ๋ค๋ฅธ ์ท์ ์กฐํฉํ์ฌ ์ ์ด ์์ ์ ์์ฅํฉ๋๋ค.
์๋ฅผ ๋ค์ด ์คํ์ด๊ฐ ๊ฐ์ง ์ท์ด ์๋์ ๊ฐ๊ณ ์ค๋ ์คํ์ด๊ฐ ๋๊ทธ๋ ์๊ฒฝ, ๊ธด ์ฝํธ, ํ๋์ ํฐ์ ์ธ ๋ฅผ ์ ์๋ค๋ฉด ๋ค์๋ ์ ์ฒญ๋ฐ์ง๋ฅผ ์ถ๊ฐ๋ก ์ ๊ฑฐ๋ ๋๊ทธ๋ ์๊ฒฝ ๋์ ๊ฒ์ ์ ๊ธ๋ผ์ค๋ฅผ ์ฐฉ์ฉํ๊ฑฐ๋ ํด์ผ ํฉ๋๋ค.
์ข ๋ฅ | ์ด๋ฆ |
์ผ๊ตด | ๋๊ทธ๋ ์๊ฒฝ, ๊ฒ์ ์ ๊ธ๋ผ์ค |
์์ | ํ๋์ ํฐ์ ์ธ |
ํ์ | ์ฒญ๋ฐ์ง |
๊ฒ์ท | ๊ธด ์ฝํธ |
์คํ์ด๊ฐ ๊ฐ์ง ์์๋ค์ด ๋ด๊ธด 2์ฐจ์ ๋ฐฐ์ด clothes๊ฐ ์ฃผ์ด์ง ๋ ์๋ก ๋ค๋ฅธ ์ท์ ์กฐํฉ์ ์๋ฅผ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
์ ํ์ฌํญ
- clothes์ ๊ฐ ํ์ [์์์ ์ด๋ฆ, ์์์ ์ข ๋ฅ]๋ก ์ด๋ฃจ์ด์ ธ ์์ต๋๋ค.
- ์คํ์ด๊ฐ ๊ฐ์ง ์์์ ์๋ 1๊ฐ ์ด์ 30๊ฐ ์ดํ์ ๋๋ค.
- ๊ฐ์ ์ด๋ฆ์ ๊ฐ์ง ์์์ ์กด์ฌํ์ง ์์ต๋๋ค.
- clothes์ ๋ชจ๋ ์์๋ ๋ฌธ์์ด๋ก ์ด๋ฃจ์ด์ ธ ์์ต๋๋ค.
- ๋ชจ๋ ๋ฌธ์์ด์ ๊ธธ์ด๋ 1 ์ด์ 20 ์ดํ์ธ ์์ฐ์์ด๊ณ ์ํ๋ฒณ ์๋ฌธ์ ๋๋ '_' ๋ก๋ง ์ด๋ฃจ์ด์ ธ ์์ต๋๋ค.
- ์คํ์ด๋ ํ๋ฃจ์ ์ต์ ํ ๊ฐ์ ์์์ ์ ์ต๋๋ค.
์ ์ถ๋ ฅ ์
clothes | return |
[["yellow_hat", "headgear"], ["blue_sunglasses", "eyewear"], ["green_turban", "headgear"]] | 5 |
[["crow_mask", "face"], ["blue_sunglasses", "face"], ["smoky_makeup", "face"]] | 3 |
์ ์ถ๋ ฅ ์ ์ค๋ช
์์ #1
headgear์ ํด๋นํ๋ ์์์ด yellow_hat, green_turban์ด๊ณ eyewear์ ํด๋นํ๋ ์์์ด blue_sunglasses์ด๋ฏ๋ก ์๋์ ๊ฐ์ด 5๊ฐ์ ์กฐํฉ์ด ๊ฐ๋ฅํฉ๋๋ค.
1. yellow_hat 2. blue_sunglasses 3. green_turban 4. yellow_hat + blue_sunglasses 5. green_turban + blue_sunglasses |
์์ #2
face์ ํด๋นํ๋ ์์์ด crow_mask, blue_sunglasses, smoky_makeup์ด๋ฏ๋ก ์๋์ ๊ฐ์ด 3๊ฐ์ ์กฐํฉ์ด ๊ฐ๋ฅํฉ๋๋ค.
1. crow_mask 2. blue_sunglasses 3. smoky_makeup |
ํ์ด
C++๋ก ํ ๋๋ ์ ์์ผ๋ก ํ์์ง๋ง Python์ผ๋ก ํ๋๊น ์ผ๋งค๋ก ํ๊ฒ ๋๋ ๋๋...
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <map>
using namespace std;
int solution(vector<vector<string>> clothes) {
int answer = 1;
map<string,int> hashmap;
map<string,int>::iterator iter;
for(int i=0;i<clothes.size();i++)
{
if ( hashmap.find(clothes[i][1]) == hashmap.end() ) {
hashmap[clothes[i][1]] = 1;
} else {
hashmap[clothes[i][1]]++;
}
}
for(iter=hashmap.begin();iter!=hashmap.end();iter++) {
cout << iter->first << " " << iter->second << endl;
answer *= (iter->second+1);
}
return answer - 1;
}
๊ทธ๋๋ก ์ฎ๊ฒจ๋ณด๋ฉด... ์ ์์ค์ฝ๋ ๊ธธ์ด ๋๋ฐ!
def solution(clothes):
answer = 1
hashmap = {}
for i in clothes:
if i[1] in hashmap:
hashmap[i[1]] += 1
else:
hashmap[i[1]] = 1
for i in hashmap.values():
answer *= (i + 1)
return answer - 1
๋ฒ ์คํธ์จ๋ฒ (Level 3, 25659๋ช ์๋ฃ)
๋ฌธ์ ์ค๋ช
์คํธ๋ฆฌ๋ฐ ์ฌ์ดํธ์์ ์ฅ๋ฅด ๋ณ๋ก ๊ฐ์ฅ ๋ง์ด ์ฌ์๋ ๋ ธ๋๋ฅผ ๋ ๊ฐ์ฉ ๋ชจ์ ๋ฒ ์คํธ ์จ๋ฒ์ ์ถ์ํ๋ ค ํฉ๋๋ค. ๋ ธ๋๋ ๊ณ ์ ๋ฒํธ๋ก ๊ตฌ๋ถํ๋ฉฐ, ๋ ธ๋๋ฅผ ์๋กํ๋ ๊ธฐ์ค์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
- ์ํ ๋ ธ๋๊ฐ ๋ง์ด ์ฌ์๋ ์ฅ๋ฅด๋ฅผ ๋จผ์ ์๋กํฉ๋๋ค.
- ์ฅ๋ฅด ๋ด์์ ๋ง์ด ์ฌ์๋ ๋ ธ๋๋ฅผ ๋จผ์ ์๋กํฉ๋๋ค.
- ์ฅ๋ฅด ๋ด์์ ์ฌ์ ํ์๊ฐ ๊ฐ์ ๋ ธ๋ ์ค์์๋ ๊ณ ์ ๋ฒํธ๊ฐ ๋ฎ์ ๋ ธ๋๋ฅผ ๋จผ์ ์๋กํฉ๋๋ค.
๋ ธ๋์ ์ฅ๋ฅด๋ฅผ ๋ํ๋ด๋ ๋ฌธ์์ด ๋ฐฐ์ด genres์ ๋ ธ๋๋ณ ์ฌ์ ํ์๋ฅผ ๋ํ๋ด๋ ์ ์ ๋ฐฐ์ด plays๊ฐ ์ฃผ์ด์ง ๋, ๋ฒ ์คํธ ์จ๋ฒ์ ๋ค์ด๊ฐ ๋ ธ๋์ ๊ณ ์ ๋ฒํธ๋ฅผ ์์๋๋ก return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํ์ธ์.
์ ํ์ฌํญ
- genres[i]๋ ๊ณ ์ ๋ฒํธ๊ฐ i์ธ ๋ ธ๋์ ์ฅ๋ฅด์ ๋๋ค.
- plays[i]๋ ๊ณ ์ ๋ฒํธ๊ฐ i์ธ ๋ ธ๋๊ฐ ์ฌ์๋ ํ์์ ๋๋ค.
- genres์ plays์ ๊ธธ์ด๋ ๊ฐ์ผ๋ฉฐ, ์ด๋ 1 ์ด์ 10,000 ์ดํ์ ๋๋ค.
- ์ฅ๋ฅด ์ข ๋ฅ๋ 100๊ฐ ๋ฏธ๋ง์ ๋๋ค.
- ์ฅ๋ฅด์ ์ํ ๊ณก์ด ํ๋๋ผ๋ฉด, ํ๋์ ๊ณก๋ง ์ ํํฉ๋๋ค.
- ๋ชจ๋ ์ฅ๋ฅด๋ ์ฌ์๋ ํ์๊ฐ ๋ค๋ฆ ๋๋ค.
์ ์ถ๋ ฅ ์
genres | plays | return |
["classic", "pop", "classic", "classic", "pop"] | [500, 600, 150, 800, 2500] | [4, 1, 3, 0] |
์ ์ถ๋ ฅ ์ ์ค๋ช
classic ์ฅ๋ฅด๋ 1,450ํ ์ฌ์๋์์ผ๋ฉฐ, classic ๋ ธ๋๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
- ๊ณ ์ ๋ฒํธ 3: 800ํ ์ฌ์
- ๊ณ ์ ๋ฒํธ 0: 500ํ ์ฌ์
- ๊ณ ์ ๋ฒํธ 2: 150ํ ์ฌ์
pop ์ฅ๋ฅด๋ 3,100ํ ์ฌ์๋์์ผ๋ฉฐ, pop ๋ ธ๋๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
- ๊ณ ์ ๋ฒํธ 4: 2,500ํ ์ฌ์
- ๊ณ ์ ๋ฒํธ 1: 600ํ ์ฌ์
๋ฐ๋ผ์ pop ์ฅ๋ฅด์ [4, 1]๋ฒ ๋ ธ๋๋ฅผ ๋จผ์ , classic ์ฅ๋ฅด์ [3, 0]๋ฒ ๋ ธ๋๋ฅผ ๊ทธ๋ค์์ ์๋กํฉ๋๋ค.
- ์ฅ๋ฅด ๋ณ๋ก ๊ฐ์ฅ ๋ง์ด ์ฌ์๋ ๋ ธ๋๋ฅผ ์ต๋ ๋ ๊ฐ๊น์ง ๋ชจ์ ๋ฒ ์คํธ ์จ๋ฒ์ ์ถ์ํ๋ฏ๋ก 2๋ฒ ๋ ธ๋๋ ์๋ก๋์ง ์์ต๋๋ค.
โป ๊ณต์ง - 2019๋ 2์ 28์ผ ํ ์คํธ์ผ์ด์ค๊ฐ ์ถ๊ฐ๋์์ต๋๋ค.
ํ์ด
๋์ C++ ํ์ด...
#include <string>
#include <vector>
#include <iostream>
#include <algorithm>
#include <map>
#include <tuple>
using namespace std;
#define TUP tuple<int,int,int,int,int>
vector<int> solution(vector<string> genres, vector<int> plays) {
vector<int> answer;
map<string, TUP> genres_map;
vector<pair<int, string>> v;
for(int i=0;i<genres.size();i++)
{
if(genres_map.find(genres[i]) == genres_map.end() )
{
genres_map[genres[i]] = make_tuple(plays[i],plays[i],i,-1,-1);
}
else
{
get<0>(genres_map[genres[i]]) += plays[i];
if(plays[i] > get<1>(genres_map[genres[i]]) && plays[i] > get<3>(genres_map[genres[i]]))
{
if(get<1>(genres_map[genres[i]]) < get<3>(genres_map[genres[i]]))
{
get<1>(genres_map[genres[i]]) = plays[i];
get<2>(genres_map[genres[i]]) = i;
}
else
{
get<3>(genres_map[genres[i]]) = plays[i];
get<4>(genres_map[genres[i]]) = i;
}
}
else
{
if(plays[i] > get<1>(genres_map[genres[i]]))
{
get<1>(genres_map[genres[i]]) = plays[i];
get<2>(genres_map[genres[i]]) = i;
}
if(plays[i] > get<3>(genres_map[genres[i]]))
{
get<3>(genres_map[genres[i]]) = plays[i];
get<4>(genres_map[genres[i]]) = i;
}
}
}
}
for(map<string, TUP>::iterator itr = genres_map.begin(); itr != genres_map.end(); ++itr)
{
v.push_back(make_pair(get<0>(itr->second),itr->first));
}
sort(v.begin(), v.end(), greater<>());
for(vector<pair<int, string>>::iterator iter = v.begin(); iter != v.end(); iter++)
{
if(get<1>(genres_map[iter->second]) < get<3>(genres_map[iter->second]))
{
answer.push_back( get<4>(genres_map[iter->second]) );
answer.push_back( get<2>(genres_map[iter->second]) );
}
else if(get<1>(genres_map[iter->second]) > get<3>(genres_map[iter->second]))
{
answer.push_back( get<2>(genres_map[iter->second]) );
if(get<3>(genres_map[iter->second]) != -1)
answer.push_back( get<4>(genres_map[iter->second]) );
}
else
{
if(get<2>(genres_map[iter->second]) < get<4>(genres_map[iter->second]))
{
answer.push_back( get<2>(genres_map[iter->second]) );
answer.push_back( get<4>(genres_map[iter->second]) );
}
else
{
answer.push_back( get<4>(genres_map[iter->second]) );
answer.push_back( get<2>(genres_map[iter->second]) );
}
}
}
return answer;
}
์ ๊ฑธ ํ์ด์ฌ์ผ๋ก ์ฎ๊ธด... ๋์ ํ์ด
from collections import Counter
def solution(genres, plays):
answer = []
genres_total_play = {} # ์ฅ๋ฅด ํ ํ ํ๋ ์ด์๊ฐ = ์ธ๊ธฐ ์ฅ๋ฅด ์์
genres_song_count = {} # ์ฅ๋ฅด๋ณ ๊ณก 2๊ฐ์ฉ ์ ์ฅ... ๊ทธ๋ฅ ๋ค ์ ์ฅํ๊ณ 2๊ณก์ฉ ๋ฝ์์จ์ผ...
for i in range(len(genres)):
if genres[i] in genres_total_play:
genres_total_play[genres[i]] += plays[i]
genres_song_count[genres[i]].append((i, plays[i]))
else:
genres_total_play[genres[i]] = plays[i]
genres_song_count[genres[i]] = [(i, plays[i])]
popular_genre_list = sorted(genres_total_play.items(), key=lambda x:x[1], reverse=True)
for i in popular_genre_list: # ์ด ์์๋๋ก 2๊ณก์ฉ
genre_song_list = genres_song_count[i[0]]
best_song_list = sorted(genre_song_list, key = lambda x:-x[1] )
for ii in range(len(best_song_list)):
#print(i[0], best_song_list[ii])
answer.append(best_song_list[ii][0])
if ii == 1:
break
return answer
๊ณ ์์ ํ์ด์ฌ ํ์ด
def solution(genres, plays):
answer = []
d = {e:[] for e in set(genres)}
for e in zip(genres, plays, range(len(plays))):
d[e[0]].append([e[1] , e[2]])
genreSort =sorted(list(d.keys()), key= lambda x: sum( map(lambda y: y[0],d[x])), reverse = True)
for g in genreSort:
temp = [e[1] for e in sorted(d[g],key= lambda x: (x[0], -x[1]), reverse = True)]
answer += temp[:min(len(temp),2)]
return answer
ํํ ์ค์ง๊ฒ ์จ๋ค. ใ ใ ใ
ํ์ด์ฌ ์๋ฃ ๊ตฌ์กฐ๋ฅผ ๋ ์์ ๋กญ๊ฒ ์ธ ์ ์์ด์ผ ์๊ณ ๋ฆฌ์ฆ ๋ฌธ์ ๋ฅผ ๋ ์ฝ๊ฒ ํ ์ ์์ ๊ฒ ๊ฐ์๋ฐ...
'๊ฒ์ ํ๋ก๊ทธ๋๋ฐ > Python ํ๋ก๊ทธ๋๋ฐ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
ํ๋ก๊ทธ๋๋จธ์ค ์ด๋ชจํฐ์ฝ ํ ์ธํ์ฌ (0) | 2023.02.12 |
---|---|
์ฐ์ ์์ ํ๋ฅผ ํํ, ๋ํ๋ก ๋ณ๊ฒฝ (0) | 2023.02.10 |
ํ๋ก๊ทธ๋๋จธ์ค ์ฝ๋ฉํ ์คํธ ๊ณ ๋์ Kit (1) (0) | 2023.02.08 |
ํ์ด์ฌ ์ฐ์ ์์ํ, ๊ฒ์ ๋งต ์ต๋จ๊ฑฐ๋ฆฌ, ๊ธธ์ฐพ๊ธฐ (0) | 2023.02.08 |
๊ฒ์์ผ๋ก ๋ฐฐ์ฐ๋ ํ์ด์ฌ (3) (0) | 2023.02.08 |