์ผ | ์ | ํ | ์ | ๋ชฉ | ๊ธ | ํ |
---|---|---|---|---|---|---|
1 | 2 | 3 | 4 | 5 | 6 | 7 |
8 | 9 | 10 | 11 | 12 | 13 | 14 |
15 | 16 | 17 | 18 | 19 | 20 | 21 |
22 | 23 | 24 | 25 | 26 | 27 | 28 |
29 | 30 | 31 |
- DataFrame Hint
- Spark Partitioning
- Spark SQL
- redshift
- Kubernetes
- aws
- Dag
- KDT_TIL
- ๋น ๋ฐ์ดํฐ
- k8s
- Spark ์ค์ต
- Airflow
- Spark
- Docker
- SQL
- off heap memory
- colab
- topic
- mysql
- AQE
- Salting
- etl
- disk spill
- Speculative Execution
- spark executor memory
- ๋ฐ์ดํฐ ํ์ดํ๋ผ์ธ
- Kafka
- Spark Caching
- CI/CD
- backfill
- Today
- Total
JUST DO IT!
[TIL] KDT_20230413 ๋ณธ๋ฌธ
๐ KDT WEEK 2 DAY 4 TIL
์ฝ๋ฉํ ์คํธ ํ์ด์ ์๊ณ ๋ฆฌ์ฆ ํ์ต
- ํด์(Hash)
- ํ์๋ฒ(Greedy)
- ์ ๋ ฌ(Sort)
ํด์(Hash) ์๊ณ ๋ฆฌ์ฆ
- Set, Dictionary๋ฅผ ํ์ฉํ์ฌ ํ์ ์๊ฐ ๋ณต์ก๋๋ฅผ O(1)๋ก ํจ์จ์ ์ด์ฉ
- ์ ํ ๋ฐฐ์ด์์๋ ์ซ์๋ก ํ์ํ๋ ๊ฒฝ์ฐ์ O(1)๋ก ํจ์จ์ ์ผ ์ ์์
์์ ๋ฌธ์ : ์์ฃผํ์ง ๋ชปํ ์ ์
def solution(participant, completion):
dic = {}
for i in participant:
dic[i] = dic.get(i,0) + 1
for j in completion:
dic[j] = dic.get(j,0) - 1
result = [x for x,y in dic.items() if y > 0]
return result[0]
๊ฐ๋จํ ์๊ณ ๋ฆฌ์ฆ์ด์๋ค.
Dictionary ๊ตฌ์กฐ์์ .get(x,y) ํจ์๋ 'x' ํค ๊ฐ์ด ์กด์ฌํ์ง ์์ผ๋ฉด 0 ์ ๋ฐํํ๋ค.
ํ์๋ฒ(Greedy) ์๊ณ ๋ฆฌ์ฆ
- ์๊ณ ๋ฆฌ์ฆ์ ๊ฐ ๋จ๊ณ์์ ๊ทธ ์๊ฐ์ ์ต์ ์ด๋ผ๊ณ ์๊ฐ๋๋ ๊ฒ์ ์ ํ!
- ๋จ, ํ์ฌ์ ์ ํ์ด ๋ง์ง๋ง ํด๋ต์ ์ต์ ์ฑ์ ํด์น์ง ์์์ผ ํ๋ค
- ๋ชจ๋ ๊ฒฝ์ฐ์ ์๋ฅผ ๋ฐ์ง์ง ์์๋ ๊ทธ ์๊ฐ๋ง๋ค ์ต์ ์ ์ ํ์ ํ๋ค.
์์๋ฌธ์ : ์ฒด์ก๋ณต
def solution(n, lost, reserve):
l = [1] * (n + 2) # ๊ตฌํ์ ํธ๋ฆฌ์ฑ์ ์ํด ๊ฐ์ฅ ์๊ณผ ๋ค์ ๊ฐ์์ ์ธ๋ฌผ ์ถ๊ฐ
for i in reserve:
l[i] += 1
for i in lost:
l[i] -= 1
for i in range(1, n+1):
if l[i] == 2 and l[i-1] == 0:
l[i], l[i-1] = 1,1
if l[i] == 2 and l[i+1] == 0:
l[i], l[i+1] = 1,1
return len([x for x in l[1:-1] if x > 0]) # ๊ฐ์์ ์ธ๋ฌผ์ ์ ์ธํ๊ณ ์ถ๋ ฅ
์ ์ฒด ํ์์ ์ n, ์ฒด์ก๋ณต์ ๋๋๋นํ ํ์๋ค์ ๋ฒํธ ๋ฐฐ์ด lost, ์ฌ๋ฒ ์ฒด์ก๋ณต์ ๊ฐ์ ธ์จ ํ์ ๋ฒํธ ๋ฐฐ์ด reserve ์ด๋ค.
์์ ์ ๋ฒํธ ๋ฐ๋ก ์ ๋ค๋ก๋ง ์ฒด์ก๋ณต์ ๋น๋ ค์ค ์ ์๋ค๊ณ ํ ๋ ์ต๋ํ ๋ง์ ํ์์ด ์ฒด์ก ์์ ์ ๋ฃ๊ฒ ํด์ผํ๋ค.
์ฌ๊ธฐ๊น์ง ๊ด์ฐฎ์๋ฐ, ์ฌ๋ฒ ์ฒด์ก๋ณต์ ๊ฐ์ ธ์จ ํ์์ด ์ฒด์ก๋ณต์ ๋๋๋นํ์ ์๋ ์๋ค๊ณ ํ๋ค.
๊ทธ๋์ ์ฌ์ฉํ ์๊ณ ๋ฆฌ์ฆ์.. ๋ชจ๋ ํ์๋ค์๊ฒ ์ฒด์ก๋ณต์ด ์๋ค๊ณ ๊ฐ์ ํ๊ณ ( ๋ฐฐ์ด์ ์ฒด์ก๋ณต ๊ฐ์์ธ 1 ๋ถ์ฌ )
์ ๋ ฅ๋ฐ์ ์ธ์์ for๋ฌธ์ผ๋ก ๊ฐ ๋ฒํธ๋ง๋ค ์ฒด์ก๋ณต์ ๊ฐ์๋ฅผ ๊ตฌํ ์ ์๋ค!
๊ทธ ๋ค๋ก๋ ๊ทธ๋ฆฌ๋๋ก ๊ทธ๋๊ทธ๋ ์ต์ ์ ์ ํ(์ผ์ชฝ, ์ค๋ฅธ์ชฝ์ ์ฒด์ก๋ณต์ ๋น์ฅ ๋น๋ ค์ค์ผ ํ๋์ง)์ ํตํด ๊ตฌํํ๋ค.
์ ๋ ฌ(Sort) ์๊ณ ๋ฆฌ์ฆ
- ์ซ์์ ๋น๊ต๊ฐ ํ์ํ ์๊ณ ๋ฆฌ์ฆ์ ์ ํฉํ๋ค
- ์ ๋ ฌ ํ ๋ค์์ ๊ตฌํํ๋ ๋ฐฉ๋ฒ์ด ์๊ฐ ๋ณต์ก๋์ ๋์์ ์ค ์๋ ์๋ค.
์์ ๋ฌธ์ : ๊ฐ์ฅ ํฐ ์
def solution(numbers):
li = [str(x) for x in numbers]
li.sort(key=lambda x : (x * 4)[:4], reverse = True)
if li[0] == "0": # ์ฃ์ง ์ผ์ด์ค ์ฒ๋ฆฌ
return "0"
else:
return "".join(li)
์ฃผ์ด์ง ๋ฐฐ์ด์ ์ซ์ ์กฐํฉ์ ํตํด ๊ฐ์ฅ ํฐ ์๋ฅผ ๋ง๋ค์ด๋ด๋ ๋ฌธ์ .
ex) ์ฃผ์ด์ง ์ ์๊ฐ [6, 10, 2]๋ผ๋ฉด [6102, 6210, 1062, 1026, 2610, 2106]๋ฅผ ๋ง๋ค ์ ์๊ณ , ์ด์ค ๊ฐ์ฅ ํฐ ์๋ 6210
์ฒ์ ๋ดค์ ๋๋ ๊ตฌํํ๊ธฐ ์ด๋ ค์ธ ๊ฒ ๊ฐ์๋๋ฐ.. ์ฝ๋๋ ๋ง์ด ๊ฐ๋จํ๋ค.
numbers์ ์์๊ฐ 0 ์ด์ 1,000์ดํ๋ผ๋ ์ ์ ํ์ฉํด์
๊ฐ ์ซ์๋ก๋ง ๋ง๋ค์ด์ง ๋ค์๋ฆฟ์( (x*4)[:4] )๋ฅผ ํตํด ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํ๊ณ ๋ฌธ์์ด๋ก ๋ฐํํ๋ฉด ๋..
๋ฐฉ๋ฒ์ ๊ฐ๋จํ๋ ์ ๊ฑธ ๋ ์ฌ๋ฆฌ๋ ๊ฒ์ด ์ด๋ ต๊ฒ ๋ค..๐
๐ค ๊ณต๋ถํ๋ฉด์ ์ด๋ ค์ ๋ ๋ด์ฉ
์ฌ๋ฌ ์ฝ๋ฉํ ์คํธ ์์๋ฌธ์ ๋ฅผ ํตํด ์ ํฉํ ์๊ณ ๋ฆฌ์ฆ์ ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ์ ๋ฐฐ์ ๋ค.
๋ณดํต ์ฒ์ ๋ด๊ฐ ๋ฌธ์ ๋ฅผ ๋ณด๊ณ ์๊ฐํ๋ ์๊ณ ๋ฆฌ์ฆ๋ณด๋ค ํจ์ฌ ๊ฐ๋จํ๊ณ ํจ์จ์ ์ผ๋ก ํธ๋ ๋ฐฉ๋ฒ์ ๋๋๋ค..
์์ง ํ์ฐธ ๋ถ์กฑํ๋ค๊ณ ์๊ฐํ๊ณ .. ๊ฐ์ฌ๋ ๋ง๋๋ก ๋ง์ ๋ฌธ์ ๋ฅผ ํ์ด๋ณด๋๊ฒ ์ง๊ธ ๋์๊ฒ ๊ฐ์ฅ ํ์ํ ๋ถ๋ถ์ธ ๋ฏ ํ๋ค ๐ญ
'TIL' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[TIL]KDT_20230417 (0) | 2023.04.17 |
---|---|
[TIL] KDT_20230414 (0) | 2023.04.14 |
[TIL] KDT_20230412 (0) | 2023.04.12 |
[TIL] KDT_20230411 (0) | 2023.04.11 |
[TIL] KDT_20230410 (0) | 2023.04.10 |