
๋ฌธ์ ์ฝ๋: def solution(answers): cnt = [] cnt1 = 0 cnt2=0 cnt3=0 tmp = [] arr1 = [1,2,3,4,5] arr2 = [2,1,2,3,2,4,2,5] arr3 = [3,3,1,1,2,2,4,4,5,5] for i in range(len(answers)): if answers[i] == arr1[i%5]: cnt1 += 1 if answers[i] == arr2[i%8]: cnt2 += 1 if answers[i] == arr3[i%10]: cnt3 += 1 cnt.append(cnt1), cnt.append(cnt2), cnt.append(cnt3) c = max(cnt) m = cnt.index(c) + 1 for j in range(len(cnt..

์ฝ๋: def solution(progresses, speeds): answer = [] time = 0 count = 0 while len(progresses) > 0: if (progresses[0] + time*speeds[0]) >= 100: progresses.pop(0) speeds.pop(0) count+=1 else: if count > 0: answer.append(count) count = 0 time += 1 answer.append(count) return answer ํ์ด: ์ ์ถ๋ ฅ ์์์ ๋ํ ์ธ๊ธ์ด ์๋ค? -> ์คํ or ํ๋ฅผ ์ฌ์ฉํ๋ ๋ฌธ์ ๋ผ๊ณ ์๊ฐํ๊ณ pop์ฌ์ฉํด๋ณด๊ธฐ! ์ฒซ๋ฒ์งธ ๋ฐ๋ณต๋ฌธ์์ ๋จผ์ ์ ค ์์์๋ progress๊ฐ 100์ด ์ด์์ด ๋ ๋๊น์ง time +=1 ํด์ฃผ๊ธฐ ์ฒซ๋ฒ์งธ๊ฐ..

์ฝ๋: def solution(arr): ans = [arr[0]] for i in range(1, len(arr)): if arr[i] != arr[i-1]: ans.append(arr[i]) return ans ํ์ด: arr ๋ฐฐ์ด์ ์ ๊ฐ์ด๋๋ง ๋ค๋ฅด๋ฉด ๊ฒฐ๊ณผ๋ฐฐ์ด์ ๋ฃ์ด๋ ๋จ. ๊ทธ๋์ ์ ๊ฐ์ด๋๋ง ๋น๊ตํ๋ฉด ๋๋ค.

Alec Radford & Luke Metz DCGAN : UNSUPERVISED REPRESENTATION LEARNINGWITH DEEP CONVOLUTIONALGENERATIVE ADVERSARIAL NETWORKS INTRODUCTION GANs have been known to be unstable to train, often resulting in generators that produce nonsensical outputs. CNN์ ํ์ฉํ ๋น์ง๋ํ์ต์ผ๋ก ์ง๋ํ์ต๊ณผ ๋น์ง๋ํ์ต์ ์ฐจ์ด๋ฅผ ์ค์ธ๋ค. CNN์ ํ์ฉํ์ฌ ์์ ์ ์ธ train์ ๊ฐ๋ฅํ๊ฒ ํ์ผ๋ฉฐ ์ด๋ฅผ DCGAN์ด๋ผ๊ณ ํ๋ค. ํ๋ณ๊ธฐ๋ฅผ ์ด๋ฏธ์ง ๋ถ๋ฅ๊ธฐ ์์ ์ผ๋ก ์ฌ์ฉํ์๊ณ , ๋ค๋ฅธ ๋น์ง๋ํ์ต ์๊ณ ๋ฆฌ์ฆ๋ค์ ๊ฒฝ์์ ์ธ ์ฑ๋ฅ์ ๋ณด์ฌ์ค๋ค. DCGAN์ ์ํด..

Ian Goodfellow$(.et al)$ Abstract ์ ๋์ ํ๋ก์ธ์ค๋ฅผ ํตํด ์์ฑ๋ชจ๋ธ์ ์ถ์ ํ๋ ์๋ก์ด ํ๋ ์์ํฌ๋ฅผ ์ ์ํ๋ค. ์์ฑ๋ชจ๋ธ G์ ํ๋ณ๋ชจ๋ธ D ๋๊ฐ์ง ๋ชจ๋ธ์ ๋์์ ํ๋ จํ๋ค. GAN? GAN์ ๋ ๊ฐ์ ๋ค๋ฅธ ์ ๊ฒฝ๋ง ๊ฐ์ ์ ๋์ ์ธ ๊ด๊ณ๋ก ๋๋ฆฝ(Adversarial)ํ๋ฉฐ ์๋ก์ ์ฑ๋ฅ์ ์ ์ฐจ ๊ฐ์ ํด ๋๊ฐ๋ ๊ฒ ์์ฑ ๋ชจ๋ธ G : ๋ฐ์ดํฐ์ ๋ถํฌ๋ฅผ ํ์ตํ๋ ๋ชจ๋ธ ํ๋ณ ๋ชจ๋ธ D : ์ด๋ฏธ์ง๋ฅผ ์ค์ (training data) ๋๋ ๊ฐ์ง(generated data)์ธ์ง ๋ถ๋ฅํ๋ ๋ชจ๋ธ Generator๋ ํ๋ จ ๋ฐ์ดํฐ์ ๋ถํฌ๋ฅผ ํ์ตํ์ฌ, ์์์ ๋ ธ์ด์ฆ๋ฅผ ์ ๋ ฅ์ผ๋ก ๋ฐ์ ์ ๊ฒฝ๋ง์ ์ฌ์ฉํ์ฌ ์ด๋ฏธ์ง๋ฅผ ์์ฑํจ. Introduction ๋ฅ๋ฌ๋์ ๊ฐ์ฅ ๋๋๋ฌ์ง ์ฑ๊ณต์ high-dimensional, rich sensor..

๋ฐฑ์ค 2869๋ฒ ํ์ด: ์๊ฐ ์ ํ์ด 0.25์ด์ -> ๋ฐ๋ณต๋ฌธ์ผ๋ก ํ๋ฉด ์๋๋ค๋ ๊ฒ ๋๋ฌํ๋ ๋ ์ x์ผ์ด๋ผ๊ณ ํ์ ๋, ์ด ์ฌ๋ผ๊ฐ๋ ํ์๋ x๋ฒ, ๋ด๋ ค์ค๋ ํ์๋ (x-1)๋ฒ์ด ๋ ๊ฒ์ด๋ค. ์ด๋ฅผ ๋ฐํ์ผ๋ก ์์ ์ธ์๋ณด๋ฉด Ax - B(x-1) = V ๊ฐ ๋ ๊ฒ์ด๊ณ , ์ด๋ฅผ x์ ๋ํ ์์ผ๋ก ์ ๋ฆฌํ๋ค๋ฉด x = (V-B)/(A-B) ๊ฐ ๋ ๊ฒ์ด๋ค. ์ด x๊ฐ x์ ์ ์ํ๊ณผ ๊ฐ๋ค๋ฉด, (์ฆ, x๊ฐ ๋๋์ด ๋จ์ด์ง๋ค๋ฉด) ๋ฌํฝ์ด๋ x์ผ์ ๋ค ์ฌ๋ผ๊ฐ ๊ฒ์ด๋ค. ๊ทธ๋ ์ง ์๋ค๋ฉด, ๋ฌํฝ์ด๋ ํ๋ฃจ ๋ ์ง๋์ ๋๋ฌด๋ง๋์ ๋ค ์ฌ๋ผ๊ฐ ๊ฒ์ด๋ค. ์ด์ ๋ฅผ ๋ค์ด๋ณด์๋ฉด, (V-B)/(A-B)๊ฐ 7.0์ด๋ฉด ๋ฌํฝ์ด๋ 7์ผ๋ง์ ์ฌ๋ผ๊ฐ๋ ๊ฒ์ด์ง๋ง, (V-B)/(A-B)๊ฐ 7.4๋ผ๋ฉด, 7.4์ผ์ด๋ผ๋ ์ผ์ ์์ผ๋ฏ๋ก, ๋ฌํฝ์ด๋ 8์ผ๋ง์ ์ฌ๋ผ๊ฐ๊ฒ ๋๊ธฐ ๋๋ฌธ์ด๋ค. ..

๋ฐฑ์ค 2501๋ฒ ํ์ด : ์ฝ์ ๊ตฌํ๋ ํจ์๋ฅผ ๋จผ์ ๋ง๋ค๊ธฐ ์ ๊ณฑ๊ทผ์ ์ฝ์๊น์ง๋ง ๊ตฌํ๋ฉด ๋๋ ๋น ๋ฅธ ๋ฐฉ๋ฒ ์ด์ฉ ์ฝ๋: import sys input = sys.stdin.readline def yaksu(n): div = [] for i in range(1, int(n**(1/2))+1): if (n % i == 0): div.append(i) if ((i**2) != n): div.append(n//i) div.sort() return div n, k = map(int, input().rstrip().split()) div = yaksu(n) if (len(div) < k): print(0) else: print(div[k-1]) ** ์ฝ์ ๊ตฌํ๋ ๋ถ๋ถ ์๋ณด๊ธฐ
ใ ๊ต์ : ์์ธ๋ํ๊ต ์ด์ํ ๊ต์ ใ ํ์ต๋ชฉํ ๋ณธ ๋ชจ๋์ ์ธ๊ณผ์ฑ์ ๋ํด ์ถ๋ก ํ๊ณ ๊ฒฝํ์ ๋ฐ์ดํฐ๋ฅผ ์ฌ์ฉํ์ฌ ์ธ๊ณผ ๊ด๊ณ๋ฅผ ๊ฒฐ์ ํ๋ ๋ฐฉ๋ฒ์ ์ตํ์ผ๋ก์จ ๋ฐ์ดํฐ๋ฅผ ์์ฑํ ํ๋ก์ธ์ค์ ๋ํด ๋ง๋ค์ด์ผ ํ๋ ํ์ ๊ฐ์ ๊ณผ ์ด๋ฌํ ๊ฐ์ ์ด ํฉ๋ฆฌ์ ์ธ์ง ํ๊ฐํ๋ ๋ฐฉ๋ฒ, ๋ง์ง๋ง์ผ๋ก ์ถ์ ๋๋ ์์ ํด์ํ๋ ๋ฐฉ๋ฒ์ ๋ํด ํ์ตํ๊ณ ์ ํฉ๋๋ค. Part 1. ์ธ๊ณผ์ฑ์ ๋ํ ์๊ฐ ๋ฐ ์ธ๊ณผ์ ์ถ๋ก ์ ์ํ ๊ธฐ๋ณธ ๊ฐ๋ - causal discovery : ๋ฐ์ดํฐ๋ก๋ถํฐ ์ธ๊ณผํจ๊ณผ์ ์ธ๊ณผ๊ด๊ณ๋ฅผ ๊ณ์ฐ - ๋ฐ์ดํฐ๋ ์๊ด์ฑ๋ง ๊ฐ์ง๊ณ ์๋๋ฐ, ์ฐ๋ฆฌ๊ฐ ์๊ณ ์ ํ๋ ๊ฒ์ ์ธ๊ณผํจ๊ณผ์ด๋ค. - ์ด๋ฒ ๊ฐ์๋ ์ธ๊ณผํจ๊ณผ๋ฅผ ๊ณ์ฐํ๊ธฐ ์ํ ๊ธฐ๋ณธ์ ํ๋ ์์ํฌ, ์ธ๊ณผํจ๊ณผ๋ฅผ ๊ณ์ฐํ๋ ๋ฐฉ๋ฒ๋ก , ์ธ๊ณผ์ ๊ด์ ์ผ๋ก ๋ฌธ์ ๋ฅผ ๋ฐ๋ผ๋ณด๋ ๋ฐฉ๋ฒ์ ๋ํด ์ ์ ์๋ค. - ๋ฒ ์ด์ง์ ๋คํธ์ํฌ์ ๋ํ ..
ใ ๊ต์ : ์ดํ์ฌ์๋ํ๊ต ๊ฐ์ ์ ๊ต์ ใ ํ์ต๋ชฉํ Machine Learning์ ํ ๋ถ๋ฅ์ธ ์ง๋ํ์ต(Supervised Learning)์ ๋ํ ๊ธฐ๋ณธ ๊ฐ๋ ๊ณผ regression/classification์ ๋ชฉ์ ๋ฐ ์ฐจ์ด์ ์ ๋ํด ์ดํดํ๊ณ , ๋ค์ํ ๋ชจ๋ธ ๋ฐ ๋ฐฉ๋ฒ๋ก (linear and nonlinear regression, classification, ensemble methods, kernel methods ๋ฑ)์ ํตํด ์ธ์ ์ด๋ค ๋ชจ๋ธ์ ์ฌ์ฉํด์ผ ํ๋์ง, ์ ์ฌ์ฉํ๋์ง, ๋ชจ๋ธ ์ฑ๋ฅ์ ํฅ์์ํค๋ ๋ฐฉ๋ฒ์ ํ์ตํ๊ฒ ๋ฉ๋๋ค. Part 1. SL Foundation - ์ง๋ํ์ต : ๋ถ๋ฅ / ํ๊ท ๊ฐ ์์ - error๋ฅผ ๊ณ์ฐํด์ ์์คํจ์ loss function cost function์ผ๋ก ๋ถ๋ฆ - square..
์ ๋ ฅ ์ฒซ์งธ ์ค์ N (1 ≤ N ≤ 100)๊ณผ M (1 ≤ M ≤ 100)์ด ์ฃผ์ด์ง๋ค. ๋์งธ ์ค๋ถํฐ M๊ฐ์ ์ค์ ๊ฑธ์ณ์ ๊ณต์ ๋ฃ๋ ๋ฐฉ๋ฒ์ด ์ฃผ์ด์ง๋ค. ๊ฐ ๋ฐฉ๋ฒ์ ์ธ ์ ์ i j k๋ก ์ด๋ฃจ์ด์ ธ ์์ผ๋ฉฐ, i๋ฒ ๋ฐ๊ตฌ๋๋ถํฐ j๋ฒ ๋ฐ๊ตฌ๋๊น์ง์ k๋ฒ ๋ฒํธ๊ฐ ์ ํ์ ธ ์๋ ๊ณต์ ๋ฃ๋๋ค๋ ๋ป์ด๋ค. ์๋ฅผ ๋ค์ด, 2 5 6์ 2๋ฒ ๋ฐ๊ตฌ๋๋ถํฐ 5๋ฒ ๋ฐ๊ตฌ๋๊น์ง์ 6๋ฒ ๊ณต์ ๋ฃ๋๋ค๋ ๋ป์ด๋ค. (1 ≤ i ≤ j ≤ N, 1 ≤ k ≤ N) ๋ํ์ด๋ ์ ๋ ฅ์ผ๋ก ์ฃผ์ด์ง ์์๋๋ก ๊ณต์ ๋ฃ๋๋ค. ์ถ๋ ฅ 1๋ฒ ๋ฐ๊ตฌ๋๋ถํฐ N๋ฒ ๋ฐ๊ตฌ๋์ ๋ค์ด์๋ ๊ณต์ ๋ฒํธ๋ฅผ ๊ณต๋ฐฑ์ผ๋ก ๊ตฌ๋ถํด ์ถ๋ ฅํ๋ค. ๊ณต์ด ๋ค์ด์์ง ์์ ๋ฐ๊ตฌ๋๋ 0์ ์ถ๋ ฅํ๋ค. ์ฝ๋ import sys input = sys.stdin.readline n, m = map(int, input().r..
- Total
- Today
- Yesterday
- gan
- lgaimers
- ์ฝ๋ฉ์๋ฌ
- SKTECHSUMMIT
- dreambooth
- CLOVAX
- ๋ ผ๋ฌธ๋ฆฌ๋ทฐ
- ํ ํฌ์๋ฐ
- AIRUSH
- ์ปดํจํฐ๋น์
- ํ๋ก๊ทธ๋๋จธ์ค
- Gaussian Splatting
- Aimers
- ์ฝํ ์ค๋น
- AIRUSH2023
- ๋๋ฆผ๋ถ์ค
- ์ฝ๋ฉ๊ณต๋ถ
- ํ์ด์ฌ์ฝํ
- 2d-gs
- gs๋ ผ๋ฌธ
- AI์ปจํผ๋ฐ์ค
- 3d-gs
- ๋ ผ๋ฌธ์ฝ๊ธฐ
- SQL
- MYSQL
- Paper review
- C์ธ์ด
- ๋ ผ๋ฌธ
- ํ์ด์ฌ
- ์คํ ์ด๋ธ๋ํจ์
์ผ | ์ | ํ | ์ | ๋ชฉ | ๊ธ | ํ |
---|---|---|---|---|---|---|
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 |