์ ์ฒด ๊ธ
-
์ํ๋ฅผ ์ต์ํํ ์๊ณ ๋ฆฌ์ฆ (2)Algorithm 2021. 8. 1. 10:53
์๋ ๋ฌธ์ ๋ ์ฝ๋๋ฆฌํฐ์์ ์ ๊ณตํ๋ MissingInteger์ ๋ฌธ์ ์ ๋๋ค๐ง๐ป๐ป ๋ฌธ์ ์ ์ This is a demo task. Write a function: public func solution(_ A : inout [Int]) -> Int that, given an array A of N integers, returns the smallest positive integer (greater than 0) that does not occur in A. For example, given A = [1, 3, 6, 4, 1, 2], the function should return 5. Given A = [1, 2, 3], the function should return 4. Given A = [−1, −3]..
-
์ํ๋ฅผ ์ต์ํํ ์๊ณ ๋ฆฌ์ฆAlgorithm 2021. 7. 24. 11:29
์๋ ๋ฌธ์ ๋ ์ฝ๋๋ฆฌํฐ์์ ์ ๊ณตํ๋ MaxCounters์ ๋ฌธ์ ์ ๋๋ค๐ง๐ป๐ป ๋ฌธ์ ์ ์ You are given N counters, initially set to 0, and you have two possible operations on them: increase(X) − counter X is increased by 1, max counter − all counters are set to the maximum value of any counter. A non-empty array A of M integers is given. This array represents consecutive operations: if A[K] = X, such that 1 ≤ X ≤ N, then operation K is..
-
Safe ArraySwift 2021. 7. 24. 09:19
์๋ ํ์ธ์. ๊ทธ๋ฆฐ์ ๋๋ค๐ข ์ด๋ฒ ํฌ์คํ ์์๋ ๋ฐฐ์ด์ ๋ํด ์์ ํ๊ฒ ์กฐํํ๊ณ ์ธ๋ฑ์ค๋ฅผ ์ ๊ทผํ๋ ๋ฐฉ๋ฒ์ ๋ํด ๊ฐ๋ตํ ์์๋ณด๊ฒ ์ต๋๋ค๐๐ป ๋ฐฐ์ด์ ๋ํด ์์ ํ๊ฒ ์ ๊ทผํ์ง ๋ชปํ ๋ ์๋์ ๊ฐ์ ์๋ฌ๋ฅผ ๋ฐํ์์์ ๋ง์ด ๊ฒช์ด๋ณด์ จ์๊ฒ๋๋ค. fatal error: Array index out of range ๋ฐ๋ก ์ ๊ทผํ ๋ฐฐ์ด์ ์ธ๋ฑ์ค๊ฐ ๋ฒ์ ๋ฐ, ์ฆ ์๋ค๋ ์๋ฌ ๋ฉ์์ง์ ๋๋ค. if let๋ฑ ์๋์ ๊ฐ์ด ์ต์ ๋๋ฐ์ธ๋ฉ์ ์์ ํ๊ฒ ํด์คฌ๋ค๊ณ ์๊ฐํ๋๋ฐ ์ ์ด๋ฐ ๋ฌธ์ ๊ฐ ๋ํ๋๊ฑธ๊น์? struct Person { let name = "bob" let age = 10 ... } let onePerson = Person() let twoPerson = Person() let people: [Person] = [onePerson, twoPe..
-
Test Doubles - fake, stub, mockiOS 2021. 7. 22. 08:19
์๋ ํ์ธ์. ๊ทธ๋ฆฐ์ ๋๋ค๐ข ์ด๋ฒ ํฌ์คํ ์์๋ Test Double์ 3๊ฐ์ง ์ข ๋ฅ์ ๋ํด ์์๋ณด๊ณ ๊ตฌ๋ถํด๋ณด๊ฒ ์ต๋๋ค๐ง๐ป๐ป ์ฐ์ ํ ์คํธ ๋๋ธ?? ํ ์คํธ ๋๋ธ์ ์๋ํ ํ ์คํธ์์ ์ค์ ์ ์ ์ฌํ๊ฒ ๋์ํ๋ฉด์ ๋จ์ํ ๊ฐ์ฒด๋ฅผ ์ฌ์ฉํ์ฌ ๋์์์ผ๋ณด๊ฑฐ๋ ํ๋ ํ ์คํธ ๊ณผ์ ์์ ๋ณต์ก์ฑ์ ๋ฎ์ถ๊ณ ๋ ๋ฆฝ๋ ์ฝ๋๋ฅผ ํ ์คํธ ๊ฒ์ฆํ ์ ์๋ ํ ์คํธ ํ๊ฒฝ์์ ์ด๋ฌํ ํ ์คํธ ๊ฐ์ฒด๊ฐ ์ฌ์ฉ๋๋๊ฒ ์ ๋๋ค. ํ ์คํธ ๋๋ธ์ ์ข ๋ฅ 1) fake - ์์ฉ๋๋ ์ฑ ๋ก์ง ๊ตฌํ๊ณผ ๋์ผํ๊ฒ ๊ฐ์ง๋ก ์ฑ ๋ก์ง ๊ตฌํ์ ๋ง๋ค๊ณ ์๋ฒ DB๋์ ์ธ๋ฉ๋ชจ๋ฆฌ DB๋ฅผ ์ ์ํ์ฌ ํด๋น ์ ๋ณด๋ก ํ ์คํธ (ํ๋ก๋์ ๊ตฌํ๋ณด๋ค ์ข ๋ ๋จ์ํ๊ฒ ๋ง๋ค ์ ์์) - ์๋ฅผ๋ค์ด ๋คํธ์ํฌ ํต์ ์ ํ์ฌ ์๋ฒ DB๋ฅผ ๋ฐ์ ๋ฐ์ดํฐ๋ฅผ ๋ฟ๋ ค์ฃผ๋ ๋ก์ง์ fake๋ก๋ ๋คํธ์ํฌ ํต์ ์ ํ์ง ์๊ณ ํ ์คํธ ๊ฐ์ฒด๋ฅผ ..
-
๋์ผ์ฑ๊ณผ ๋๋ฑ์ฑCS(ComputerScience) 2021. 7. 21. 19:42
์๋ ํ์ธ์. ๊ทธ๋ฆฐ์ ๋๋ค๐ข ์ด๋ฒ ํฌ์คํ ์์๋ ๋์ผ์ฑ๊ณผ ๋๋ฑ์ฑ์ ๋ํด ์์๋ณด๊ฒ ์ต๋๋ค๐๐ป ๋์ผ์ฑ๊ณผ ๋๋ฑ์ฑ ๊ทธ๋ฅ ์์๋ณด๊ธฐ์ ๋ปํ์ด๋ถํฐ ๋๋ฆ๋๋ก ์ถ์ธกํด๋ณผ๊น์? ๋์ผ์ฑ์ A์ B๊ฐ ์ ๋ถ ๊ฐ์ ์ฆ ๋์ผํ ๋ ์ฐ์ธ๋ค๊ณ ๋ณด์ด๊ณ , ๋๋ฑ์ฑ์ A์ B๊ฐ ์์ ํ ๊ฐ์ง ์์ง๋ง ๊ฐ์ ๋ถ๋ถ๋ค์ด ์์ด ๋๋ฑํ๊ฒ ๋ณผ ์ ์๋ค? ๋ผ๊ณ ๋๊ปด์ง๋๋ค. ๊ทธ๋ผ ์กฐ๊ธ ๋ ์์ธํ ๊ฐ์ฒด์งํฅ์ ์๊ฐํ๋ฉฐ ์์๋ณด๊ฒ ์ต๋๋ค. ๊ฐ์ฒด์งํฅ์์๋ ๋๊ฐ์ A์ B ๊ฐ์ฒด๊ฐ ์๋ค๊ณ ๊ฐ์ ํฉ์๋ค! ๊ทธ๋ผ A์ B์ ๊ฐ์ฒด๋ ์๋ก ๋ค๋ฅธ ์ฃผ์๊ฐ์ ๊ฐ์ต๋๋ค. ์ด ๊ฒฝ์ฐ์๋ A์ B๊ฐ ๊ฐ์ ์ฃผ์๊ฐ์ ๊ฐ๋ฅดํค๊ธฐ ์๊ธฐ์ ์์ ํ ๊ฐ๋ค๊ณ ํ ์ ์์ต๋๋ค. ์ฆ ์์ ๊ฐ๋ ์ผ๋ก ๋์ผ์ฑ๊ณผ ๋๋ฑ์ฑ์ ๊ฐ๋ตํ ์ ๋ฆฌํด๋ณด๊ฒ ์ต๋๋ค. - ๋์ผ์ฑ: A์ B์ ๊ฐ์ฒด๊ฐ ์์ ํ ๊ฐ์ ๊ฒฝ์ฐ๋ฅผ ์๋ฏธ - ๋๋ฑ์ฑ: A์ B์ ๊ฐ์ฒด๊ฐ ..
-
FlogRiverOne ์๊ณ ๋ฆฌ์ฆAlgorithm 2021. 7. 18. 10:45
์๋ ๋ฌธ์ ๋ ์ฝ๋๋ฆฌํฐ์์ ์ ๊ณตํ๋ FlogRiverOne์ ๋ฌธ์ ์ ๋๋ค๐ง๐ป๐ป ๋ฌธ์ ์ ์ A small frog wants to get to the other side of a river. The frog is initially located on one bank of the river (position 0) and wants to get to the opposite bank (position X+1). Leaves fall from a tree onto the surface of the river. You are given an array A consisting of N integers representing the falling leaves. A[K] represents the position wher..
-
Composable Architecture๋ก ๋๋ค ํต์ ๊ตฌํํ๊ธฐTCA 2021. 7. 17. 15:32
์๋ ํ์ธ์. ๊ทธ๋ฆฐ์ ๋๋ค๐ข ์ด๋ฒ ํฌ์คํ ์์๋ Composable Architecture์ผ๋ก ๋๋คํ ํต์ ์ ๊ตฌํํด๋ณด๊ฒ ์ต๋๋ค๐ง๐ป๐ป ๋ทฐ๋ SwiftUI๋ฅผ ํตํด ๊ฐ๋จํ ๊ตฌํํ์์ต๋๋ค. ์ฐ์ ๊ฐ๋ตํ ๊ธฐ๋ฅ์ ์ค๋ช ๋๋ฆฌ๊ฒ ์ต๋๋ค. Composable Architecture๋ฅผ ์ด์ฉํ์ฌ ๋ทฐ์ ์ํ๋ฅผ ์ด๋ฒคํธ ํ๋ฆ์ ๋ฐ๋ผ ๋ค๋ฃฐ ์ ์๋ ์์ฃผ ๊ฐ๋จํ ์์ ๋ก ํต์ ์ GET์ ID ์ธ๋ฑ์ค๋ฅผ ๋๊ฒจ ํต์ ํ ๋ ํด๋น ์ธ๋ฑ์ค๋ฅผ ๋๋คํ๊ฒ ๋ฝ๊ณ ํต์ ๋ฐ ํ์ฑํ ํ ID์ ํ์ดํ์ UI์ 3์ด๋ง๋ค ์๋ ๊ฐฑ์ ๋๋๋ก ๋ทฐ๋ฅผ ์ ๋ฐ์ดํธ ํ๋ ๊ธฐ๋ฅ์ ๊ฐ์ง๋๋ค๐ง๐ป๐ป ๋ํ ์๋/์๋ ๋ณ๊ฒฝ ๋ฒํผ์ ๋์ด ํด๋น ์กฐ๊ฑด์ ๋ฐ๋ผ ํต์ ๋๋๋ก ๊ตฌํํฉ๋๋ค. (์ด์ ์ ReactorKit์ผ๋ก ๋๋ค ํต์ ์ ๊ตฌํํ ์คํ๊ณผ ๋์ผํฉ๋๋ค.) ์ฌ๊ธฐ ํฌ์คํ ์์๋ ํ์ ํ์ผ์ ๋ํ ๊ตฌํ๋ค๋ง..
-
์๊ฐ๋ณต์ก๋๋ฅผ ๊ณ ๋ คํ ์๊ณ ๋ฆฌ์ฆ (3)Algorithm 2021. 7. 11. 13:50
์๋ ๋ฌธ์ ๋ ์ฝ๋๋ฆฌํฐ์์ ์ ๊ณตํ๋ TapeEquilibrium์ ๋ฌธ์ ์ ๋๋ค๐ง๐ป๐ป ๋ฌธ์ ์ ์ A non-empty array A consisting of N integers is given. Array A represents numbers on a tape. Any integer P, such that 0 < P < N, splits this tape into two non-empty parts: A[0], A[1], ..., A[P − 1] and A[P], A[P + 1], ..., A[N − 1]. The difference between the two parts is the value of: |(A[0] + A[1] + ... + A[P − 1]) − (A[P] + A[P + 1] + ... + ..