๐ ์ฝ๋ฉํ
์คํธ ์ฝ๋ฉํ
์คํธ ๋ฌธ์ ํ์ด โ๐ป Github ๋ฌธ์ ํ์ด github ๋งํฌ ๋ฌธ์ ์ค๋ช
์ด๋ ํ๊ต์ ํ์ธํธ๊ฐ ์น ํด์ง ๊ธธ์ด๊ฐ n๋ฏธํฐ์ธ ๋ฒฝ์ด ์์ต๋๋ค. ๋ฒฝ์ ๋์๋ฆฌ · ํํ ํ๋ณด๋ ํ์ฌ ์ฑ์ฉ ๊ณต๊ณ ํฌ์คํฐ ๋ฑ์ ๊ฒ์ํ๊ธฐ ์ํด ํ
์ดํ๋ก ๋ถ์๋ค๊ฐ ์ฒ ๊ฑฐํ ๋ ๋ผ๋ ์ผ์ด ๋ง๊ณ ๊ทธ ๊ณผ์ ์์ ํ์ธํธ๊ฐ ๋ฒ๊ฒจ์ง๊ณค ํฉ๋๋ค. ํ์ธํธ๊ฐ ๋ฒ๊ฒจ์ง ๋ฒฝ์ด ๋ณด๊ธฐ ํํด์ ธ ํ๊ต๋ ๋ฒฝ์ ํ์ธํธ๋ฅผ ๋ง์น ํ๊ธฐ๋ก ํ์ต๋๋ค. ๋์ ๋ฒฝ ์ ์ฒด์ ํ์ธํธ๋ฅผ ์๋ก ์น ํ๋ ๋์ , ๊ตฌ์ญ์ ๋๋์ด ์ผ๋ถ๋ง ํ์ธํธ๋ฅผ ์๋ก ์น ํจ์ผ๋ก์จ ์์ฐ์ ์๋ผ๋ ค ํฉ๋๋ค. ์ด๋ฅผ ์ํด ๋ฒฝ์ 1๋ฏธํฐ ๊ธธ์ด์ ๊ตฌ์ญ n๊ฐ๋ก ๋๋๊ณ , ๊ฐ ๊ตฌ์ญ์ ์ผ์ชฝ๋ถํฐ ์์๋๋ก 1๋ฒ๋ถํฐ n๋ฒ๊น์ง ๋ฒํธ๋ฅผ ๋ถ์์ต๋๋ค. ๊ทธ๋ฆฌ๊ณ ํ์ธํธ๋ฅผ ๋ค์ ์น ํด์ผ ํ ๊ตฌ์ญ๋ค์ ์ ํ์ต๋๋ค. ๋ฒฝ์ ํ์ธํธ๋ฅผ ์น ํ๋ ๋กค๋ฌ์ ๊ธธ์ด๋ m..
1. ์กฐ๊ฑด๋ฌธ 1) if ๋ฌธ : ์กฐ๊ฑด์ ๋ฐ๋ฅธ ์ฐธ์ ๊ฐ๋ง ์คํํ๊ฒ ํ ์ ์๋ ๋ฌธ์ฅ if ์ฐธ๊ณผ ๊ฑฐ์ง์ ํ๋จํ ์ ์๋ ๋ฌธ์ฅ { //code } โ๏ธ์กฐ๊ฑด์ ์๋ฆฌ์๋ ํญ์ ์ฐธ๊ณผ ๊ฑฐ์ง์ ํ๋จํ ์ ์๋ ๋ฌธ์ฅ์ด ์์ผ ํ๋ค. var number = 3 if number
1. ์ผํญ์ฐ์ฐ์ 1) ์ผํญ์ฐ์ฐ์ (Ternary Conditional Operator) : ๊ธฐ๋ณธ ํํ / if๋ฌธ๋ณด๋ค ์กฐ๊ธ์ ํ์ ์ ์ธ ํํ๋ก ์ฌ์ฉ ์กฐ๊ฑด์ ๋ฐ๋ผ ์ ํ์ด ๋๊ฐ์ง์ธ ๊ฒฝ์ฐ์ ์ฌ์ฉ condition ? ์ฐธ์ผ๋์ ์คํ๋ฌธ : ๊ฑฐ์ง์ผ๋์ ์คํ๋ฌธ ์ผ์ชฝ์ condition์ด ์ฐธ / ๊ฑฐ์ง ์ ๋ฌด์ ๋ฐ๋ผ ํด๋ก ์์ ๊ฐ์ด ์คํ๋๊ฑฐ๋ ๋ค์ ๊ฐ์ด ์คํ๋๋ค. โ๏ธ ์ผํญ์ฐ์ฐ์๋ฅผ ?์ : ์ ๋ค ์ฌ์ด์ ๋์ด์ฐ๊ธฐ๋ฅผ ๊ผญ ํด์ผํจ. if - else ๋ฌธ var a = 10 if a > 0 { print("1") } else { print("2") } ์์ if - else๋ฌธ์ ์ผํญ์ฐ์ฐ์๋ก ํํ a > 0 ? print("1") : print("2") → ์ผํญ์ฐ์ฐ์๋ if-else๋ฌธ๊ณผ ๋์ผํจ. var name = a > 0 ? "์ค..
1. ๊ธฐ๋ณธ์ฐ์ฐ์ 1) ์ฐ์ฐ์์ ๊ธฐ์ด ์ฐ์ฐ์( operator ) : ๊ฐ์ ๊ฒ์ฌ, ๋ฐ๊พธ๊ฑฐ๋ ์กฐํฉํ๊ธฐ ์ํด ์ฌ์ฉํ๋ ํน์ํ ๊ธฐํธ๋ ๊ตฌ์ ํผ์ฐ์ฐ์์ ๊ฐ์์ ๋ฐ๋ฅธ ์ฐ์ฐ์์ ๊ตฌ๋ถ ๋จํญ์ฐ์ฐ์ (Unary Operator) : ๋จ์ผ ๋์์ ๋ฐ๋ก ์ ๋๋ ๋ฐ๋ก ๋ค์ ์์นํ๋ ์ฐ์ฐ์ (๊ณต๋ฐฑ ์์ด ๋ฐ๋์ ๋ถ์ฌ์ ์ฌ์ฉ) ์) +a, -a, !a, a… ์ดํญ์ฐ์ฐ์ (Binary Operator) : ๋ ๊ฐ์ ๋์์ ๊ฐ์ด๋ฐ ์์นํ๋ ์ฐ์ฐ์ ( ์ฐ์ฐ์ ์์ชฝ์ผ๋ก ๊ณต๋ฐฑ์ ๋๊ณ ์ฌ์ฉ ) ๋น๋์นญ์ ์ฌ์ฉ์ด ๋ถ๊ฐํ๋ค ์) a + b, a >= b ์ผํญ์ฐ์ฐ์ (Ternary Operator) → ๋ค์์ ๋ ์์ธํ : ์ธ ๊ฐ์ ๋์์ ์กฐํฉํ์ฌ ํน์ํ ๊ณ์ฐ์ ํจ ( ๋ชจ๋ ์ฌ์ด์ ๊ณต๋ฐฑ์ ํ์นธ์ฉ ์ถ๊ฐํด์ ์ฌ์ฉ ) var a = 3 print(a >..
์ค๋์ ์ ๋ฆฌํ ๊ฒ ๋๋ฌด๋ ๋ง์ ๋ ์ด๋ค์.. ์ ๋ฒ์ฃผ ํ๋ฃจ๋ฅผ ํต์งธ๋ก ๊ฒฐ์ํด๋ฒ๋ฆฐ ํ์ ์ ๋ฒ์ฃผ์ ๋๋์ด์ผํ ์ ๋ฆฌ๋ค์ ์์ง๋ ํ๊ณ ์์ด์.. ์ฃผ๋ง์ ํ ์ ์์์์๋ ๋
ผ ๋๋ฅผ ํํ๋ฆฌ! ๋จธ๋ฆฟ์์ ๋ค์ด์จ ๊ฐ๋
๋ค๊ณผ ๋ฒจ๋ก๊ทธ์ ์ ๋ฆฌํ๊ณ ์ถ์ ๋ด์ฉ๋ค์ ๋ง์ ๋ฐ ๋ง์ ์์ ๋ชป์ณ๋ด๊ณ ์๋ ์ค๋์
๋๋ค. ๊ฐ์๋ ๋ค์ด์ผํ๊ณ , ์๋ก์ด ๊ฐ๋
๋ค๋ ์ด์ ์ ๋ฆฌํด์ผํ ํ
๋ฐ ๋ง์ด์ฃ ! ์ฐ์ ์ค๋์ TIL์ ์ ์ด๋ด
์๋ค. Tuple์ ์ธ์คํด์ค์ ์ด๋ฆ ์ค์ ๊ฐ๋ฅ! let case = ( a: [1, 2, 3, 4, 5], b: [1, 2, 3, 5, 2, 3], c: [1, 3, 4, 2, 3, 4, 5, 6] ) ๋ค๋ฅธ ์ฌ๋์ ํ์ด ์ค์์ ์ด๋ฐ ์ฝ๋๋ฅผ ํ์ธํ๋๋ฐ ์ด๊ฒ ๋์ฒด ๋ญ์ง..? ์ถ์์ด์. ๊ตฌ๊ธ๋ง์ ๋ญ๋ผ๊ณ ํด์ผํ ์ง๋ ๊ฐ์ด ์กํ์ง ์์ ํํฐ๋๊ป ์ง๋ฌธ์ ..