๐ฉ ์ง์ญ๋ณ์{} ์ฝ๋ ๋ธ๋ก ๋ด๋ถ์ ์ ์ธ์ฝ๋ ๋ธ๋ก ์ธ๋ถ์์๋ ์ฌ์ฉ ๋ถ๊ฐ ๐ฉ ์กฐ๊ฑด๋ฌธ(๋ถ๊ธฐ๋ฌธ)ํน์ ์กฐ๊ฑด์ ์ด์ฉํ์ฌ ์ฝ๋๋ฅผ ๋ค๋ฅธ ์น์
์ผ๋ก ๋ถ๊ธฐํ๋คif, if~else, if~else if~elseswitch (case, break, default)์ค์ฒฉ์ผ๋ก ์ฌ์ฉ๊ฐ๋ฅ ๐ฉ ๋ฐ๋ณต๋ฌธfor(์ด๊ธฐ์, ์กฐ๊ฑด์, ์ฆ๊ฐ์)while(์กฐ๊ฑด์)do ~ while(์กฐ๊ฑด์) : ๋ฌด์กฐ๊ฑด ํ ๋ฒ์ ์คํ๋๋ค.์ค์ฒฉ forforeachfor๋ฌธ๊ณผ ๋์ผํ๊ฒ ์๋์ฐจํ์ ๋ฐฐ์ด, collection์์ ์ฌ์ฉ ๐ฉ ๋ฌดํ ๋ฐ๋ณตwhile(true)for(;;) ๐ฉ ์ ํ๋ฌธ๋ฌดํ๋ฃจํ ์ ์ดbreakcontinuegoto๐ ์ซ์ ๋ฌ๋ฆฌ๊ธฐusing System;using System.Threading;namespace _002_CheckPoint01 { ..
๐ฉ๐ป ํ๋ก๊ทธ๋๋ฐ
์ฐ์ฐ์๋จํญ ์ฐ์ฐ์ : ํ ๊ฐ์ ๋ฐ์ดํฐ๋ก ์ฒ๋ฆฌint a = 18;์ดํญ ์ฐ์ฐ์ : ๋ ๊ฐ์ ๋ฐ์ดํฐ๋ก ์ฒ๋ฆฌint c = a / b;์ผํญ ์ฐ์ฐ์ : ์ธ ๊ฐ์ ๋ฐ์ดํฐ๋ก ์ฒ๋ฆฌ์กฐ๊ฑด ์ฐ์ฐ์ '? :'int value = (num > 0) ? 1 : 0;์ฐ์ ์ฐ์ฐ์ :+, -, *, /, %๋ชจ๋ ์์น ๋ฐ์ดํฐ ํํ์ฆ๊ฐ ์ฐ์ฐ์๋จํญ ์ฐ์ฐ์ (++, --)์ ์น ์ฐ์ฐ, ํ์น ์ฐ์ฐํ ๋น ์ฐ์ฐ์=, +=, -=, *=, /=, %=์ฐ์ฐ ํ ์ฌํ ๋น๊ด๊ณ ์ฐ์ฐ์ํผ ์ฐ์ฐ์์ ๋น๊ต(bool), =, ==, !=๋
ผ๋ฆฌ ์ฐ์ฐ์์กฐ๊ฑด๋ถ ๋
ผ๋ฆฌ : &&, ||๋
ผ๋ฆฌ ๋ถ์ ์ฐ์ฐ์ : !๋นํธ ์ฐ์ฐ์๋นํธ ๋จ์๋ก ๋ฐ์ดํฐ๋ฅผ ์ฒ๋ฆฌ๋น์ด์๋ ๋ถ๋ถ์ 0์ผ๋ก ์ฑ์ฐ๊ธฐ>> : ์ค๋ฅธ์ชฝ์ผ๋ก ๋ฐ๊ธฐ๋นํธ ๋
ผ๋ฆฌ ์ฐ์ฐ์& : ๋ ๋ค 1์ผ ๋ 1| : ํ๋๋ง 1์ด์ด๋ 1^ : XOR, ๋ ๋น..
1. ํ
ํ๋ฆฟ'ํํ'์ด๋ผ๋ ์๋ฏธ, ๋ถ์ด๋นต ํ ๊ฐ์ ๊ฑฐ์ฌ๋ฃ๋ง ๊ฐ์ง๊ณ ๋๊ฐ์ ๋ชจ์์ผ๋ก ์ฐ์ด๋ผ ์ ์์ผ๋ฉฐ, ๋ฃ๋ ์ฌ๋ฃ์ ๋ฐ๋ผ ๋ด์ฉ๋ฌผ์ ์กฐ๊ธ์ฉ ๋ฌ๋ผ์ง๋ค.๊ธฐ๋ฅ์ ์ด๋ฏธ ๊ฒฐ์ ๋์ด ์์ผ๋, ์๋ฃํ์ด ์ ํด์ง์ง ์๋๋ค๋ ํน์ง์ ๊ฐ์ง๊ณ ์๋ค.ํจ์ ํ
ํ๋ฆฟ : ํจ์๋ฅผ ์ฐ์ด๋ด๋ ํํด๋์ค ํ
ํ๋ฆฟ : ํด๋์ค๋ฅผ ์ฐ์ด๋ด๋ ํ 2. ํจ์ ํ
ํ๋ฆฟ#include using namespace std;templatevoid Swap(T& num1, T& num2){ T temp = num1; num1 = num2; num2 = temp;}int main(){ int num1=10, num2=40; cout before, num1: 10, num2: 40after, num1: 40, num2: 10before, num1: 15.6, num2: 14..
1. ํ ๋ณํ๋ฐ์ดํฐ์ ํ์์ ๋ณ๊ฒฝ์ ์ ↔ ์ค์๋ฌธ์์ด ↔ ๊ธฐ๋ณธ ๋ฐ์ดํฐํ์บ์คํธ ์ฐ์ฐ์ : '()'ToString() : ๋ฌธ์์ด๋ก ๋ณํParse() : ์คํธ๋ง ๐ ์ ์, ์ค์ ์๋ฃํ์ผ๋ก ๋ณํConvert.~ : double dNum2 = 12345678912;int num2 = (int)dNum2; // ํฐ ๋ฐ์ดํฐ ํ์ ์์ ๋ฐ์ดํฐํ์ผ๋ก ๋ณ๊ฒฝ์ ์ฃผ์string strA = "100";string strB = "2314.12";string strC = "1213.4";int parseA = int.Parse(strA); // int parseA = 100;int a = int.Parse(Console.ReadLine()); // string์ผ๋ก ์
๋ ฅ๋๋ฉด int๋ก ๋ณํ๋๋ค.int convert..
1. ๋ณ์๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๊ธฐ ์ํ ๊ณต๊ฐ๋ณ์ ์ ์ธ("๋ณ์ ๋ง๋ ๋ค")๋ก ํํ๋ฐ์ดํฐ ํ์๊ณผ ์๋ณ์(์ด๋ฆ)์ผ๋ก ๊ตฌ์ฑint num; // int(๋ฐ์ดํฐ ํ์), num(์๋ณ์)int num; //์ ์ธnum = 1000; // ์ด๊ธฐํint num2 = 100; // ์ ์ธ๊ณผ ๋์์ ์ด๊ธฐํConsole.WriteLine(num);Console.WriteLine(num2); ๐ ์ ์ํ๊ฐ์ฅ ๋น๋ฒํ๊ฒ ์ฌ์ฉ๋๋ ํํsbyte, byte, short, long, ulong, int ๋ฑ์๋ฃํ.MinValue, ์๋ฃํ.MaxValue ๊ฐ์ฅ ์์ ๊ฐ, ํฐ ๊ฐ์ ์๋ ค์ค๋ค์) int : -2147483648~2147483648int a = 0b11111111; // 2์ง์ ๋ฆฌํฐ๋ด ์ ๋์ฌ 0b(0B)int b = 0xFF; ..
๐ฉ ํ์ค string ํด๋์คํค๋ํ์ผ ์ ํฌํจํด์ผ ํ๋ค.string ํด๋์ค๋ ํ์ค ํด๋์ค๋ก์จ ๋ฌธ์์ด์ ์ฒ๋ฆฌ๋ฅผ ์ํด ์ ๊ณต๋๋ ํด๋์ค 1. ๋ฌธ์์ด์ ์ธ์๋ก ์ ๋ฌ๋ฐ๋ ์์ฑ์์ ์ ์string str1 = "I like "; ๐ string str1("I like ");string str2 = "string class"; ๐ string str2("string class"); 2. ์์ฑ์, ์๋ฉธ์, ๋ณต์ฌ ์์ฑ์, ๋์
์ฐ์ฐ์์ ์ ์์์ฑ์ ๋ด์์ ๋ฌธ์์ด ์ ์ฅ์ ์ํ ๋ฉ๋ชจ๋ฆฌ์ ๋์ ํ ๋น์ด ์ด๋ฃจ์ด์ง๋ฏ๋ก 3. ๊ฒฐํฉ๋ ๋ฌธ์์ด๋ก ์ด๊ธฐํ๋ ๊ฐ์ฒด๋ฅผ ๋ฐํํ๋ + ์ฐ์ฐ์์ ์ค๋ฒ๋ก๋ฉstring str3 = str1 + str2;str1 + str2์ ๋ฐํ๊ฐ์ผ๋ก ๋ ๊ฐ์ฒด์ ๋ฌธ์์ด์ ๋ชจ๋ ํฌํจํ๋ string ๊ฐ์ฒด๊ฐ ๋ฐํ๋๋๋ก ..
1. .NET Framework์ ์ดํดwin32 ํ๋ก๊ทธ๋จ (exe ํ์ผ ๋ฑ) ๐ ์ด์์ฒด์ : ์ด์์ฒด์ ์ ๋ฐ๋ก ์ข
์๋จ.Net ํ๋ก๊ทธ๋จ ๐ CLR(Common Language Runtime) ๐ ์ด์์ฒด์ : CLR์ด ์ด์์ฒด์ ์ ๋์์ ํด์ฃผ๊ธฐ ๋๋ฌธ์ ์ด์์ฒด์ ์ ์๊ด์๋ค. 2. C# ์ธ์ด ์ปดํ์ผ ๊ณผ์ C# ์ฝ๋ฉ ๐ ์ปดํ์ผ ๐ .NET Framework ๐ ์คํํ๋ก๊ทธ๋๋จธ๊ฐ ์ ๊ฒฝ์จ์ค์ผ ํ๋ ๋ถ๋ถ(VS) 3. C# ์ธ์ด/ํ๋ก๊ทธ๋๋ฐ- C++์์ ํ์๋ ๊ฐ์ฒด ์งํฅ ์ธ์ด- ํ์ ์์ ์ฑ- ๋ฉ๋ชจ๋ฆฌ ๊ด๋ฆฌ๊ฐ ์ฝ๋ค : ๊ฐ๋น์ง ์ปฌ๋ ํฐ(garbage collector)- ๋ค์ํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ์ง์ โจ static void Main- ๊ฐ์ฅ ์ค์ํ ๋ฉ์๋- ์ต์ด์ ์ง์
์ - ๋ฉ์ธ ๋ฉ์๋๊ฐ ๋ฐ๋์ ์กด์ฌ- Main ํจ์์ ํํ๋ ๋ค์ํ๋ค.
1. KMP ์๊ณ ๋ฆฌ์ฆํจํด์ ๋ฌธ์ฅ ์์์ ์ข์์ ์ฐ๋ก ๋น๊ตํ๋ ๊ฒ. ๋ธ๋ฃจํธ-ํฌ์ค ์๊ณ ๋ฆฌ์ฆ๊ณผ ๋ค๋ฅด๊ฒ ํจํด์ ์์น๋ฅผ ์ข๋ ํจ์จ์ ์ผ๋ก ์ด๋์ํจ๋ค. ํจํด๊ณผ ๋ฌธ์ฅ์ ๋ถ์ผ์น๊ฐ ๋ฐ์ํ์ ๋ ์ค๋ณต์ฐ์ฐ์ ์ต๋ํ ํผํ๋ฉด์ ํจํด์ ์ฐ์ธก์ผ๋ก ์ด๋์ํจ๋ค. ์ด๋ฅผ ์ํด์๋ ๋ฌธ์ฅ์ ๋ถ์ผ์น ๋ฐ์ ์, ์ผ๋ง๋งํผ ๊ฑด๋ ๋๋ ํ์ ๋น๊ต์ฐ์ฐ์ ํ ๊ฒ์ธ๊ฐ๋ฅผ ํ๋จํ์ฌ์ผ ํ๋ค. 2. ์คํจํจ์(ํ์ด ๋ฐฐ์ด)KMP ์๊ณ ๋ฆฌ์ฆ์์ ํ์ ๋ฌธ์์ด์ ์ ๋์ฌ์ ์ ๋ฏธ์ฌ์ ์ผ์น ๋ถ๋ถ์ ๊ณ์ฐํ์ฌ ๋ฐฐ์ด์ ํํ๋ก ์ ์ฅํ๋ ํจ์i๋ ์ ๋ฏธ์ฌ ๊ฐ๋ฆฌํค๋ ์ธ๋ฑ์ค, len์ ์ ๋์ฌ ๊ฐ๋ฆฌํค๋ ์ธ๋ฑ์ค7๋ฒ์งธ : 6๋ฒ์งธ์ len=2, i=5์ผ ๋, A๊ฐ ์ด๋ฏธ ์ผ์นํ๋ ์ฌ์ค์ ์๊ธฐ ๋๋ฌธ์ ์ด๋ฅผ ์ด์ฉํ๊ธฐ ์ํด len์ lps[len-1]๋ก ์ด๋ํ๋ ๊ฒ. ์ด๋ KMP ์๊ณ ๋ฆฌ์ฆ ์๋ฆฌ์ ๋์ผํ๋ค.๋
ธ..
1. ๋ผ๋น-์นดํ ์๊ณ ๋ฆฌ์ฆ๋ผ๋น-์นดํ ์๊ณ ๋ฆฌ์ฆ์ ๋ฌธ์์ด์ ํด์ฑ ๊ธฐ๋ฒ์ ์ฌ์ฉํ์ฌ ํด์ ๊ฐ์ผ๋ก ๋น๊ตํ๋ ์๊ณ ๋ฆฌ์ฆ ํด์ ๊ฐ์ด ๋ค๋ฅด๋ค๋ฉด ๋ ๋ฌธ์์ด์ด ๋ค๋ฅด๋ค๋ ๊ฒ์ ๋ณด์ฅํ๋ค. ํ์ง๋ง ๋ฌธ์์ด์ด ๋ฌ๋ผ๋ ํด์ ๊ฐ์ด ๊ฐ์ ์ ์๋ค.๐ ์ฐ๋ฆฌ๋ ์ด๊ฒ์ Spurious Hit์ด๋ผ ํ๋ค.Spurious Hit ๋๋ฌธ์ ํด์ ๊ฐ์ด ๊ฐ์ ๊ฒฝ์ฐ ์ถ๊ฐ๋ก ๋ฌธ์์ด์ด ๊ฐ์์ง ๋น๊ตํ๋ ์์
์ด ํ์ํ๋ค. ์ด ํน์ง์ ์ด์ฉํ์ฌ ๋ผ๋น-์นดํ ์๊ณ ๋ฆฌ์ฆ์ ํจํด์ ํด์๊ฐ์ ํ
์คํธ์ ๋ถ๋ถ ๋ฌธ์์ด์ ํด์๊ฐ๊ณผ ์ผ์นํ๋์ง ๋น๊ตํ๋ ์์
์ ํ๋ค. ๋ฐ๋ผ์ ๋ผ๋น-์นดํ ์๊ณ ๋ฆฌ์ฆ์ ๋ค์ ๋ฌธ์์ด์ ๋ํ ํด์ ๊ฐ์ ๊ณ์ฐํด์ผ ํ๋ค.๊ธธ์ด๊ฐ m์ธ ํจํด ์์ฒด๊ธธ์ด๊ฐ m์ธ ํ
์คํธ์ ๋ชจ๋ ๋ถ๋ถ ๋ฌธ์์ด 2. ํด์ ํจ์์ฌ์ฉ ์์๐ฉ rolling hash๊ฐ ์์น์์ ํด์ ํจ์๋ฅผ ์ฒ์๋ถํฐ ๋ค์ ..
1. ์์ ํ์ ์๊ณ ๋ฆฌ์ฆ์ฆ, ๊ฐ๋ฅํ ๋ชจ๋ ๊ฒฝ์ฐ์ ์๋ฅผ ๋ชจ๋ ํ์ํ๋ฉด์ ์๊ตฌ์กฐ๊ฑด์ ์ถฉ์กฑ๋๋ ๊ฒฐ๊ณผ๋ง์ ๊ฐ์ ธ์จ๋ค.์ด ์๊ณ ๋ฆฌ์ฆ์ ๊ฐ๋ ฅํ ์ ์ ์์ธ ์์ด 100% ํ๋ฅ ๋ก ์ ๋ต๋ง์ ์ถ๋ ฅํ๋ค. BUT ๊ทธ๋งํผ ๋์ ์๊ฐ ๋ณต์ก๋๋ฅผ ๊ฐ๋๋ค.๋๋น ์ฐ์ ํ์(BFS)์ ๊ด๋ จ์ด ๊น๋ค. ๐ ์์ ํ์ ์๊ณ ๋ฆฌ์ฆ๊ณผ์ ์ฐจ์ด์ ์์ ํ์ ์๊ณ ๋ฆฌ์ฆ : ๋ชจ๋ ๊ฒฝ์ฐ์ ์๋ฅผ ์ ๋ถ ํ์ํ๋ ์๊ณ ๋ฆฌ์ฆ, ๊ทธ ๊ฒฐ๊ณผ๋ฅผ ์ฐพ๋ ๊ฒ๋ณด๋ค ํ์ํ๋ค๋ ๊ณผ์ ์ ์ค์ ๋ธ๋ฃจํธํฌ์ค ์๊ณ ๋ฆฌ์ฆ : ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด, ๋ชจ๋ ๊ฒฝ์ฐ๋ฅผ ํ์ํ๊ณ ๋ต์ ๋์ถํ๋ ์๊ณ ๋ฆฌ์ฆ, ๊ฒฐ๊ณผ๋ฅผ ์ฐพ๋ ๊ฒ์ ์ค์ 2. ๋ฌธ์ ํด๊ฒฐ ๋ฐฉ๋ฒ์ฃผ์ด์ง ๋ฌธ์ ๋ฅผ ์ ํ ๊ตฌ์กฐ๋ก ๊ตฌ์กฐํํ๋ค.๊ตฌ์กฐํ๋ ๋ฌธ์ ๊ณต๊ฐ์ ์ ์ ํ ๋ฐฉ๋ฒ์ผ๋ก ํด๋ฅผ ๊ตฌ์ฑํ ๋๊น์ง ํ์ํ๋ค.๊ตฌ์ฑ๋ ํด๋ฅผ ์ ๋ฆฌํ๋ค. 3. ์ฌ์ฉ ์กฐ๊ฑด ๋ฐ ์์ ๋ฌธ์ ์์ ๋ฌ์ฑํ๊ณ ์ ..
๐ฉ ์ฐ์ฐ์ ์ค๋ฒ๋ก๋ฉํจ์ ์ค๋ฒ๋ก๋ฉ, ์์ฑ์ ์ค๋ฒ๋ก๋ฉ์ ํจ์๋ช
, ์์ฑ์๋ช
์ด ๊ฐ์ผ๋ ๋งค๊ฐ๋ณ์์ ์๋ฃํ์ด๋ ์๊ฐ ๋ค๋ฅธ ํจ์์ด๋ค. ์ฐ์ฐ์ ์ค๋ฒ๋ก๋ฉ์ ๊ฒฝ์ฐ ๋ค๋ฅธ ๊ธฐ๋ฅ์ ์ ๊ณตํ๋ฉด์ ์ฐ์ฐ์๋ฅผ ์ถ๊ฐํ ์ ์์๊น?#include using namespace std;class NUMBOX{private: int num1, num2;public: NUMBOX(int num1, int num2) : num1(num1), num2(num2) { } void ShowNumber() { cout ๐ท๏ธ ์๋ฌ1 IntelliSense: ์ด๋ฌํ ํผ์ฐ์ฐ์์ ์ผ์นํ๋ "+" ์ฐ์ฐ์๊ฐ ์์ต๋๋ค. ํผ์ฐ์ฐ์ ํ์์ด NUMBOX + NUMBOX์
๋๋ค. c:\Users\h4ckfory0u\Documents\Visual St..
๐ฉ LCS, ์ต์ฅ ๊ณตํต ๋ถ๋ถ ์์ด Longest Common Subsequence (cf. Longest Common Substring ์ต์ฅ ๊ณตํต ๋ฌธ์์ด) ์ต์ฅ ๊ณตํต ๋ถ๋ถ ์์ด์ ๊ฒฝ์ฐ, ๋ถ๋ถ์์ด์ด๊ธฐ ๋๋ฌธ์ ๋ฌธ์ ์ฌ์ด๋ฅผ ๊ฑด๋๋ฐ์ด ๊ณตํต๋๋ฉด์ ๊ฐ์ฅ ๊ธด ๋ถ๋ถ ๋ฌธ์์ด์ ์ฐพ์ผ๋ฉด ๋๋ค.์ต์ฅ ๊ณตํต ๋ฌธ์์ด์ ๊ฒฝ์ฐ, ๋ถ๋ถ ๋ฌธ์์ด์ด ์๋๊ธฐ ๋๋ฌธ์, ํ ๋ฒ์ ์ด์ด์ ธ ์๋ ๋ฌธ์์ด๋ง ๊ฐ๋ฅํ๋ค. ๐ฉ ์ต์ฅ ๊ณตํต ๋ฌธ์์ดif i == 0 or j == 0: # ๋ง์ง ์ค์ LCS[i][j] = 0elif string_A[i] == string_B[j]: LCS[i][j] = LCS[i - 1][j - 1] + 1else: LCS[i][j] = 0 LCS๋ผ๋ 2์ฐจ์ ๋ฐฐ์ด์ ์ด์ฉํ์ฌ ๋ ๋ฌธ์์ด์ ํ, ์ด์ ๋งค์นญํ๋ค. ํธ์์ i, j๊ฐ..