Jieunny์ ๋ธ๋ก๊ทธ
S4) Unit 11. [์๋ฃ๊ตฌ์กฐ/์๊ณ ๋ฆฌ์ฆ] Algorithm with Math & ์ ๊ทํํ์ ๋ณธ๋ฌธ
S4) Unit 11. [์๋ฃ๊ตฌ์กฐ/์๊ณ ๋ฆฌ์ฆ] Algorithm with Math & ์ ๊ทํํ์
Jieunny 2023. 4. 6. 15:02๐ฃ ์์ด๊ณผ ์กฐํฉ
๐ญ. ์์ด
โ๏ธ ์๋ก ๋ค๋ฅธ n๊ฐ์ ์์๋ฅผ ๊ฐ์ง๋ ์งํฉ์์ ์ด๋ค ์ค๋ณต ์์ด ์์์ ์๊ด์๊ฒ r๊ฐ์ ์์๋ฅผ ์ ํํ๊ฑฐ๋ ๋์ดํ๋ ๊ฒ
โฐ ์กฐํฉ๊ณผ ๋ฌ๋ฆฌ ์์๋ ๋ฐ์ ธ์ ๋ถ๋ถ์งํฉ์ ๋ง๋ ๋ค.
โฐ nPr = n! / (n-r)!
โฐ 3P2 = 3 * 2 = 6
๐ฎ. ์กฐํฉ
โ๏ธ ์๋ก ๋ค๋ฅธ n๊ฐ์ ์์๋ฅผ ๊ฐ์ง๋ ์ด๋ค ์งํฉ์์ ์ค๋ณต ์์ด ์์์ ์๊ด์๊ฒ r๊ฐ์ ์์๋ฅผ ์ ํํ๋ ๊ฒ
โฐ ์์๋ ๋ฐ์ง์ง ์๋๋ค.
โฐ nCr = nPr / r!
โฐ 3C2 = 3 * 2 / 2 * 1 = 3
๐จ ์์ด๊ณผ ์กฐํฉ ๋ชจ๋ N์ด ์์์ ์ด๊ฐ์์ด๊ณ R์ด ๋ฝ๋ ๊ฐ์๋ผ๊ณ ํ ๋, ์์ด๊ณผ ์กฐํฉ์ ๋ฐ๋์ R <= N์ ๋ง์กฑํด์ผ ํ๋ค.
๐ฃ GCD์ LCM(์ต๋๊ณต์ฝ์์ ์ต์๊ณต๋ฐฐ์)
๐ญ. GCD(Greatest Common Divisor)
โ๏ธ ์ต๋๊ณต์ฝ์ : ๋ ์ ์ด์์ ์ฌ๋ฌ ๊ณต์ฝ์ ์ค ์ต๋์ธ ์
โ๏ธ ๊ณต์ฝ์ : ๋ ์ ์ด์์ ์ฌ๋ฌ ์ ์ค ๊ณตํต๋ ์ฝ์
๐ฎ. LCM(Lowest Common Multiple)
โ๏ธ ์ต์๊ณต๋ฐฐ์ : ์ฌ๋ฌ ๊ณต๋ฐฐ์ ์ค ์ต์์ธ ์
โ๏ธ ๊ณต๋ฐฐ์ : ๋ ์ ์ด์์ ์ฌ๋ฌ ์ ์ค ๊ณตํต๋ ๋ฐฐ์
๐ฏ. ์ต๋๊ณต์ฝ์์ ์ต์๊ณต๋ฐฐ์๋ฅผ ๊ตฌํ๋ ๋ฐฉ์
โ๏ธ ๊ฐ์ฅ ์์ ์๋ค์ ๊ณฑ์ผ๋ก ๋ํ๋ด๋ฉฐ ๊ตฌํ๋ ๋ฒ
Q. 12์ 18์ ์ต๋๊ณต์ฝ์์ ์ต์๊ณต๋ฐฐ์
A. 12 = 2 * 2 * 3
18 = 2 * 3 * 3
๊ฒน์น๋ ๋ถ๋ถ์ธ 2 * 3 = 6์ด ์ต๋๊ณต์ฝ์, 2 * 3์ ์ค์ฌ์ผ๋ก ๋จ์ 2์ 3์ ๊ณฑํด ๋์ค๋ ์์ธ 36์ด ์ต์๊ณต๋ฐฐ์
โ๏ธ ๊ณต์ฝ์๋ก ๋๋์ด๋ณด๋ฉฐ ๊ตฌํ๋ ๋ฒ
โฐ 2์ 3์ด 12์ 18์ ๊ณต์ฝ์์์ ์๊ณ ์์ผ๋ฏ๋ก, 2์ 3์ผ๋ก 12์ 18์ด ๋๋์ด์ง์ง ์์ ๋๊น์ง ๋๋๊ณ , ๋จ์ ๊ฐ์ ๊ณฑํด์ฃผ๋ฉด ๋๋ค.
โ๏ธ ์ ํด๋ฆฌ๋ ํธ์ ๋ฒ : ์ต๋๊ณต์ฝ์์ ๊ด๋ จ์ด ๊น์ ๊ณต์์ผ๋ก, a์ b(a > b)๊ฐ ์์ ๋ a๋ฅผ b๋ก ๋๋ ๋๋จธ์ง๋ฅผ r์ด๋ผ๊ณ ํ๋ฉด a์ b์ ์ต๋๊ณต์ฝ์๋ b์r์ ์ต๋๊ณต์ฝ์์ ๊ฐ๋ค๋ ์ด๋ก => b๋ฅผ r๋ก ๋๋ r'์ ๊ตฌํ๊ณ , ๋ค์ r์ r'๋ก ๋๋๋ ๊ณผ์ ์ ๋ฐ๋ณตํด์, ๋๋จธ์ง๊ฐ 0์ด ๋ ๋ ๋๋๋ ์๊ฐ a์ b์ ์ต๋๊ณต์ฝ์์ด๋ค.
Q. 81๊ณผ 15์ ์ต๋๊ณต์ฝ์๋?
A. 81 / 15 = 5 + 6
15 / 6 = 2 + 3
6 / 3 = 2 + 0
๋๋จธ์ง๊ฐ 0์ด ๋์จ 3์ด ์ต๋๊ณต์ฝ์์ด๋ค.
๐ฃ ๋ฉฑ์งํฉ
๐ญ. ๋ฉฑ์งํฉ
โ๏ธ ์ด๋ค ์งํฉ์ด ์์ ๋, ์ด ์งํฉ์ ๋ชจ๋ ๋ถ๋ถ์งํฉ
โฐ ์์๊ฐ ์๋์ง, ์๋์ง์ 2๊ฐ์ง์ ๊ฒฝ์ฐ๋ฅผ ๊ณ ๋ คํ๊ธฐ ๋๋ฌธ์ ์งํฉ์ ์์๊ฐ n๊ฐ์ผ ๋ ๋ชจ๋ ๋ถ๋ถ์งํฉ์ ๊ฐ์๋ 2^n๊ฐ์ด๋ค.
๐ฎ. ๋ฉฑ์งํฉ์ ๊ตฌํ๋ ๋ฐฉ๋ฒ
Q. ์งํฉ {1, 2, 3}์ ๋ฉฑ์งํฉ์ ๊ตฌํด๋ผ
A.
1๏ธโฃ 1์ ์ ์ธํ {2, 3}์ ๋ถ๋ถ์งํฉ์ ๋์ดํ๋ค.
2๏ธโฃ 2๋ฅผ ์ ์ธํ {3}์ ๋ถ๋ถ์งํฉ์ ๋์ดํ๋ค.
3๏ธโฃ 3์ ์ ์ธํ {}์ ๋ถ๋ถ์งํฉ์ ๋์ดํ๋ค => {}
3๏ธโฃ {}์ ๋ชจ๋ ๋ถ๋ถ์งํฉ์ {3}์ ์ถ๊ฐํ ์งํฉ๋ค์ ๋์ดํ๋ค => {3}
2๏ธโฃ {3}์ ๋ชจ๋ ๋ถ๋ถ์งํฉ์ {2}๋ฅผ ์ถ๊ฐํ ์งํฉ๋ค์ ๋์ดํ๋ค.
3๏ธโฃ {3}์ ๋ชจ๋ ๋ถ๋ถ์งํฉ์ {2}๋ฅผ ์ถ๊ฐํ ์งํฉ๋ค์ ๋์ดํ๋ ค๋ฉด, {}์ ๋ชจ๋ ๋ถ๋ถ์งํฉ์ {2}๋ฅผ ์ถ๊ฐํ ์งํฉ๋ค์ ๋์ดํ ๋ค์ {}์ ๋ชจ๋ ๋ถ๋ถ์งํฉ์ {2, 3}์ ์ถ๊ฐํ ์งํฉ๋ค์ ๋์ดํ๋ค. => {2}, {2, 3}
1๏ธโฃ {2, 3}์ ๋ชจ๋ ๋ถ๋ถ์งํฉ์ {1}์ ์ถ๊ฐํ ์งํฉ๋ค์ ๋์ดํ๋ค.
2๏ธโฃ {2, 3}์ ๋ชจ๋ ๋ถ๋ถ์งํฉ์ {1}์ ์ถ๊ฐํ ์งํฉ๋ค์ ๋์ดํ๋ ค๋ฉด, {3}์ ๋ชจ๋ ๋ถ๋ถ์งํฉ์ {1}์ ์ถ๊ฐํ ์งํฉ๋ค์ ๋์ดํ ๋ค์ {3}์ ๋ชจ๋ ๋ถ๋ถ์งํฉ์ {1, 2}๋ฅผ ์ถ๊ฐํ ์งํฉ๋ค์ ๋์ดํ๋ค.
3๏ธโฃ {3}์ ๋ชจ๋ ๋ถ๋ถ์งํฉ์ {1}์ ์ถ๊ฐํ ์งํฉ์ ๋์ดํ๋ ค๋ฉด, {}์ ๋ชจ๋ ๋ถ๋ถ์งํฉ์ {1}์ ์ถ๊ฐํ ์งํฉ๋ค์ ๋์ดํ ๋ค์ {}์ ๋ชจ๋ ๋ถ๋ถ์งํฉ์ {1, 3}์ ์ถ๊ฐํ ์งํฉ๋ค์ ๋์ดํ๋ค. => {1}, {1, 3}
3๏ธโฃ {3}์ ๋ชจ๋ ๋ถ๋ถ์งํฉ์ {1, 2}๋ฅผ ์ถ๊ฐํ ์งํฉ์ ๋์ดํ๋ ค๋ฉด, {}์ ๋ชจ๋ ๋ถ๋ถ์งํฉ์ {1, 2}๋ฅผ ์ถ๊ฐํ ์งํฉ๋ค์ ๋์ดํ ๋ค์ {}์ ๋ชจ๋ ๋ถ๋ถ์งํฉ์ {1, 2, 3}์ ์ถ๊ฐํ ์งํฉ๋ค์ ๋์ดํ๋ค. => {1, 2}, {1, 2, 3}
๐ฃ Algorithm with Math ์์
๐ญ. ์์ด๊ณผ ์กฐํฉ : ์นด๋ ๋ฌธ์
Q. [A, B, C, D, E]๋ก ์ด๋ค์ง 5์ฅ์ ์นด๋๊ฐ ์๊ณ , ์ด 5์ฅ์ ์นด๋ ์ค 3์ฅ์ ์ ํํ์ฌ ๋์ดํ๋ ค๊ณ ํ๋ค.
์ด๋, ๋ค์์ ์กฐ๊ฑด์ ๊ฐ๊ฐ ๋ง์กฑํ๋ ๊ฒฝ์ฐ๋ฅผ ์ฐพ์์ผ ํ๋ค.
1. ์์๋ฅผ ์๊ฐํ๋ฉฐ 3์ฅ์ ์ ํํ๋ค.
2. ์์๋ฅผ ์๊ฐํ์ง ์๊ณ 3์ฅ์ ์ ํํ๋ค.
A. 1์ ์์ด, 2๋ ์กฐํฉ ๋ฌธ์ ์ด๋ค.
1๏ธโฃ ์์ด์ ๊ฒฝ์ฐ
โฐ ๋ชจ๋ ์นด๋๋ฅผ 1์ฅ์ฉ ๋์ดํ๋ฉด์, ๋์ด๋ ์นด๋๊ฐ 3์ฅ์ ๋๋ฌํ๋ฉด ๋์ด์ ์ค์งํ๋ค.
โฐ ์ฒซ๋ฒ์งธ ์นด๋๋ฅผ ์ ํํ๋ ๋ฐฉ๋ฒ 5๊ฐ์ง, ๋๋ฒ์งธ ์นด๋๋ฅผ ์ ํํ๋ ๋ฐฉ๋ฒ 4๊ฐ์ง, ์ธ๋ฒ์งธ ์นด๋๋ฅผ ์ ํํ๋ ๋ฐฉ๋ฒ 3๊ฐ์ง => 5 * 4 * 3 = 60๊ฐ์ง
function permutationLoop() {
// ์์ด ์์๊ฐ ์ธ์๋ก ์ฃผ์ด์ง ๊ฒฝ์ฐ, ์ธ์ ๊ทธ๋๋ก ์ฌ์ฉํ๋ฉด ๋์ง๋ง, ์ธ์๊ฐ ์ฃผ์ด์ง์ง ์๊ณ
// ๋ฌธ์ ์์ ํฌํจ๋์ด ์์ ๊ฒฝ์ฐ ์ด๋ฐ ์์ผ๋ก ์ง์ ์ ์ด์ ์ฌ์ฉํฉ๋๋ค.
let lookup = ['A', 'B', 'C', 'D', 'E'];
let result = [];
for (let i = 0; i < lookup.length; i++) {
for (let j = 0; j < lookup.length; j++) {
for (let k = 0; k < lookup.length; k++) {
if(i === j || j === k || k === i) continue;
// ๊ฐ์ ์ธ๋ฑ์ค๋ฅผ ์ ํํ๋ ๊ฒ์ ์ค๋ณต๋ ์์๋ฅผ ์ ํํ๋ ๊ฒ๊ณผ ๊ฐ์ผ๋ฏ๋ก ๊ทธ๋ฅ ๋ค์์ผ๋ก ๋์ด๊ฐ๊ฒ ๊ตฌํํ๋ค.
result.push([lookup[i], lookup[j], lookup[k]])
}
}
}
return result;
}
permutationLoop();
2๏ธโฃ ์กฐํฉ์ ๊ฒฝ์ฐ
โฐ 3์ฅ์ ํ๋์ ๊ทธ๋ฃน์ผ๋ก ์ ํํด์ผ ํ๋ค => ์์๋ฅผ ๊ณ ๋ คํ์ง ์๊ธฐ ๋๋ฌธ์ [A, B, C], [A, C, B], [B, A, C], [B, C, A], [C, A, B], [C, B, A] ๋ ๋ชจ๋ ํ๊ฐ์ง ๊ฒฝ์ฐ๋ก ์ทจ๊ธํ๋ฏ๋ก [A, B, C] ์์ฒด๋ฅผ ํ๋์ ๊ทธ๋ฃน์ผ๋ก ์๊ฐํด์ ํ๊ฐ์ง ๊ฒฝ์ฐ๋ผ๊ณ ์๊ฐํด์ผํ๋ค.
โฐ ์์ด์ ๊ฒฐ๊ณผ๋ฅผ ํ ๊ทธ๋ฃน์์ ๋์ฌ ์ ์๋ 6๊ฐ์ง ๊ฒฝ์ฐ๋ก ๋๋ ๊ฒ์ด ์กฐํฉ์ ๊ฒฐ๊ณผ์ด๋ค.
โฐ 60 / 6 = 10
function combinationLoop() {
// ์กฐํฉ ์์๊ฐ ์ธ์๋ก ์ฃผ์ด์ง ๊ฒฝ์ฐ, ์ธ์ ๊ทธ๋๋ก ์ฌ์ฉํ๋ฉด ๋์ง๋ง, ์ธ์๊ฐ ์ฃผ์ด์ง์ง ์๊ณ
// ๋ฌธ์ ์์ ํฌํจ๋์ด ์์ ๊ฒฝ์ฐ ์ด๋ฐ ์์ผ๋ก ์ง์ ์ ์ด์ ์ฌ์ฉํฉ๋๋ค.
let lookup = ['A', 'B', 'C', 'D', 'E'];
let result = [];
console.log(lookup);
for (let i = 0; i < lookup.length; i++) {
for (let j = i + 1; j < lookup.length; j++) {
for (let k = j + 1; k < lookup.length; k++) {
// ํ๋ฒ ์กฐํฉํ ์์๋ ๋ค์ ํฌํจ์ํค์ง ์์ผ๋ฏ๋ก ๊ทธ ์์ ๋ค์ ์์๋ถํฐ ๋ฐ๋ณตํ๋ค.
result.push([lookup[i], lookup[j], lookup[k]]);
}
}
}
return result;
}
combinationLoop();
๐จ ์์ด๊ณผ ์กฐํฉ์ ๋ฐ๋ณต๋ฌธ์ด ์๋ '์ฌ๊ท'๋ฅผ ์ฌ์ฉํ๋ ๊ฒฝ์ฐ๊ฐ ๋ง๋ค.
๐ฎ. GCD์ LCM : ์ ํด๋ฆฌ๋ ํธ์ ๋ฒ์ ์ด์ฉํด ์ต๋๊ณต์ฝ์์ ์ต์๊ณต๋ฐฐ์ ๊ตฌํ๊ธฐ
1๏ธโฃ ์ต๋๊ณต์ฝ์
function gcd(a, b){
while(b !== 0){
// ๋๋จธ์ง๊ฐ 0์ด ๋ ๋๊น์ง ๋ฐ๋ณต
let r = a % b;
// r ์ ์ฒซ๋ฒ์งธ ์์ ๋๋ฒ์งธ ์๋ฅผ ๋๋ ๋๋จธ์ง
a = b;
// ์ฒซ๋ฒ์งธ ๋๋ ์ง ์๋ ๋๋ฒ์งธ ์๊ฐ ๋๊ณ
b = r;
// ๋๋ฒ์งธ ์๋ ๋ ์๋ฅผ ๋๋ ๋๋จธ์ง๊ฐ ๋๋ค.
}
return a;
}
2๏ธโฃ ์ต์๊ณต๋ฐฐ์
function lcm(a, b){
return a * (b / gcd(a, b));
// ์ ํด๋ฆฌ๋ ํธ์ ๋ฒ์ ์ด์ฉํด์ ์ต๋๊ณต์ฝ์๋ฅผ ๊ตฌํ๊ณ ,
// ์ต๋๊ณต์ฝ์๋ฅผ ์ด์ฉํด์ ์ต์๊ณต๋ฐฐ์๋ฅผ ๊ตฌํ๋ค.
}
๐ฏ. ๋ฉฑ์งํฉ - Power Set
let inputSet = ['a', 'b', 'c'];
function powerSet (arr) {
const result = [];
function recursion (subset, start) {
result.push(subset);
for(let i = start; i < arr.length; i++){
recursion([...subset, arr[i]], i+1);
//์ด๋ ๊ฒ๋ ๊ตฌํํ ์ ์์ต๋๋ค.
recursion(subset.concat(arr[i]), i+1);
}
}
recursion([], 0);
return result;
}
poserSet(inputSet);
๐ฃ ์ ๊ทํํ์
๐ญ. ์ ๊ท ํํ์
โ๏ธ ๋ฌธ์์ด์์ ํน์ ํ ๊ท์น์ ๋ฐ๋ฅธ ๋ฌธ์์ด ์งํฉ์ ํํํ๊ธฐ ์ํด ์ฌ์ฉ๋๋ ํ์์ธ์ด
โฐ ํน์ ํ ๊ท์น์ ๊ฐ๋ ๋ฌธ์์ด๋ก ์ด๋ฃจ์ด์ง ํํ์์ผ๋ก, ํน์ ๋ฌธ์๋ ๊ฐ๊ฐ์ ๊ณ ์ ๊ท์น์ ๊ฐ๊ณ ์๋ค.
๐ฎ. ์ ๊ท ํํ์ ์์
โ๏ธ ์ด๋ฉ์ผ ์ ํจ์ฑ ๊ฒ์ฌ
const email = 'kimcoding@codestates.com';
let result = '์ฌ๋ฐ๋ฆ
๋๋ค.';
// 1. ์ ๊ทํํ์ ์ฌ์ฉ
let regExp = /^[0-9a-zA-Z]([-_.]?[0-9a-zA-Z])*@[0-9a-zA-Z]([-_.]?[0-9a-zA-Z])*.[a-zA-Z]{2,3}$/i;
if(regExp.test(email) === false) result = '์ฌ๋ฐ๋ฅด์ง ์์ต๋๋ค.';
result; // '์ฌ๋ฐ๋ฅด์ง ์์ต๋๋ค.'
-----------------------------------------------------------------------------
// 2. ์ ๊ทํํ์์ด ์๋ ๊ฒฝ์ฐ, ์ด๋ฉ์ผ ์์ด๋๊ฐ ์๋ฌธ ์๋ฌธ์์ธ์ง ํ์ธํ๋ ์ฝ๋
let idx = email.indexOf('@');
if(idx === -1) result = '์๋ฌธ ์๋ฌธ์๊ฐ ์๋๋๋ค.';
let ID = email.slice(0,idx);
ID.split('').forEach(e => {
e = e.charCodeAt(0);
if(e < 97 || e > 122){
result = '์๋ฌธ ์๋ฌธ์๊ฐ ์๋๋๋ค.';
}
});
result; // '์ฌ๋ฐ๋ฆ
๋๋ค.'
๐ฏ. ์ ๊ท ํํ์ ํจํด
^ | ์ค(Line)์ ์์์์ ์ผ์น /^abc/ |
$ | ์ค(Line)์ ๋์์ ์ผ์น /xyz$/ |
. | (ํน์๊ธฐํธ, ๋์ด์ฐ๊ธฐ๋ฅผ ํฌํจํ) ์์์ ํ ๋ฌธ์ |
a|b | a or b ์ ์ผ์น, ์ธ๋ฑ์ค๊ฐ ์์ ๊ฒ์ ์ฐ์ ๋ฐํ |
* | 0ํ ์ด์ ์ฐ์์ผ๋ก ๋ฐ๋ณต๋๋ ๋ฌธ์์ ๊ฐ๋ฅํ ๋ง์ด ์ผ์น. {0,} ์ ๋์ผ |
*? | 0ํ ์ด์ ์ฐ์์ผ๋ก ๋ฐ๋ณต๋๋ ๋ฌธ์์ ๊ฐ๋ฅํ ์ ๊ฒ ์ผ์น. {0} ์ ๋์ผ |
+ | 1ํ ์ด์ ์ฐ์์ผ๋ก ๋ฐ๋ณต๋๋ ๋ฌธ์์ ๊ฐ๋ฅํ ๋ง์ด ์ผ์น. {1,} ์ ๋์ผ |
+? | 1ํ ์ด์ ์ฐ์์ผ๋ก ๋ฐ๋ณต๋๋ ๋ฌธ์์ ๊ฐ๋ฅํ ์ ๊ฒ ์ผ์น. {1} ์ ๋์ผ |
{3} | ์ซ์ 3๊ฐ ์ฐ์ ์ผ์น |
{3, } | 3๊ฐ ์ด์ ์ฐ์ ์ผ์น |
{3, 5} | 3๊ฐ ์ด์ 5๊ฐ ์ดํ ์ฐ์ ์ผ์น |
() | ์บก์ณ(capture)ํ ๊ทธ๋ฃน |
[a-z] | a๋ถํฐ z ์ฌ์ด์ ๋ฌธ์ ๊ตฌ๊ฐ์ ์ผ์น(์์ด ์๋ฌธ์) |
[A-Z] | A๋ถํฐ Z ์ฌ์ด์ ๋ฌธ์ ๊ตฌ๊ฐ์ ์ผ์น(์์ด ๋๋ฌธ์) |
[0-9] | 0๋ถํฐ 9 ์ฌ์ด์ ๋ฌธ์ ๊ตฌ๊ฐ์ ์ผ์น(์ซ์) |
\ | escape ๋ฌธ์. ํน์ ๊ธฐํธ ์์ \๋ฅผ ๋ถ์ด๋ฉด ์ ๊ท์ ํจํด์ด ์๋, ๊ธฐํธ ์์ฒด๋ก ์ธ์ |
\d | ์ซ์๋ฅผ ๊ฒ์ํจ. /[0-9]/์ ๋์ผ |
\D | ์ซ์๊ฐ ์๋ ๋ฌธ์๋ฅผ ๊ฒ์ํจ. /[^0-9]/์ ๋์ผ |
\w | ์์ด๋์๋ฌธ์, ์ซ์, (underscore)๋ฅผ ๊ฒ์ํจ. /[A-Za-z0-9]/ ์ ๋์ผ |
\W | ์์ด๋์๋ฌธ์, ์ซ์, (underscore)๊ฐ ์๋ ๋ฌธ์๋ฅผ ๊ฒ์ํจ. /[^A-Za-z0-9]/ ์ ๋์ผ |
[^] | []์์ ๋ฌธ์์ด ์์ ^์ด ์ฐ์ด๋ฉด, []์์ ์๋ ๋ฌธ์๋ฅผ ๊ฒ์ํจ |
๐ฐ. ์ ๊ท ํํ์ ์ฌ์ฉํ๊ธฐ
Q. ๋ฌธ์์ด str ์ด ์ฃผ์ด์ง ๋, str์ ๊ธธ์ด๊ฐ 5 ๋๋ 7์ด๋ฉด์ ์ซ์(0~9)๋ก๋ง ๊ตฌ์ฑ๋์ด ์๋์ง๋ฅผ ํ์ธํด ์ฃผ๋ ํจ์๋ฅผ ์์ฑํด๋ผ.
๊ฒฐ๊ณผ๋ Boolean์ผ๋ก ๋ฆฌํด๋๋ค. ์๋ฅผ ๋ค์ด str๊ฐ c2021์ด๋ฉด false, 20212์ด๋ฉด true๋ฅผ ๋ฆฌํดํ๋ค.
// ์ ๊ทํํ์ ์ฌ์ฉ
function solution(str) {
return /^\d{5}$|^\d{7}$/.test(str);
}
๐ฑ. ์ ๊ท ํํ์์ ์ค๋ก
โ๏ธ JS์์ ์ ๊ทํํ์์ ๊ฐ์ฒด๋ก, ๋ด์ฅ ๋ฉ์๋๋ฅผ ๊ฐ์ง๊ณ ์๋ค.
1๏ธโฃ RegExp ๊ฐ์ฒด์ ๋ฉ์๋
โ๏ธ exec() : ์ํ๋ ์ ๋ณด๋ฅผ ๋ฝ์๋ด๊ณ ์ ํ ๋ ์ฌ์ฉํ๋ค.
โฐ ๊ฒ์์ ๋์์ด ์ฐพ๊ณ ์ ํ๋ ๋ฌธ์์ด์ ๋ํ ์ ๋ณด๋ฅผ ๊ฐ์ง๊ณ ์๋ค๋ฉด ์ด๋ฅผ ๋ฐฐ์ด๋ก ๋ฐํํ๋ฉฐ, ์ฐพ๋ ๋ฌธ์์ด์ด ์๋ค๋ฉด null์ ๋ฐํํ๋ค.
โ๏ธ test() : ์ฐพ๊ณ ์ ํ๋ ๋ฌธ์์ด์ด ๋์ ์์ ์๋์ง์ ์ฌ๋ถ๋ฅผ boolean ์ผ๋ก ๋ฆฌํดํ๋ค.
2๏ธโฃ String ๊ฐ์ฒด์ ๋ฉ์๋
โ๏ธ match() : RegExp.exec() ์ ๋น์ทํ ๊ธฐ๋ฅ์ ํ๋ฉฐ, ์ ๊ท ํํ์์ ์ธ์๋ก ๋ฐ์ ์ฃผ์ด์ง ๋ฌธ์์ด๊ณผ ์ผ์น๋ ๊ฒฐ๊ณผ๋ฅผ ๋ฐฐ์ด๋ก ๋ฐํํ๋ค.
โฐ ์ผ์น๋๋ ๊ฒฐ๊ณผ๊ฐ ์์ผ๋ฉด null์ ๋ฆฌํดํ๋ค.
โ๏ธ replace() : '๊ฒ์ ํ ๋ฐ๊พธ๊ธฐ'๋ฅผ ์ํํ๋ค.
โฐ ์ฒซ ๋ฒ์งธ ์ธ์๋ก๋ ์ ๊ทํํ์์ ๋ฐ๊ณ , ๋ ๋ฒ์งธ ์ธ์๋ก๋ ์นํํ๋ ค๋ ๋ฌธ์์ด์ ๋ฐ๋๋ค.
โฐ ์์ด์์ ์ฐพ๊ณ ์ ํ๋ ๋์์ ๊ฒ์ํด์ ์ด๋ฅผ ์นํํ๋ ค๋ ๋ฌธ์์ด๋ก ๋ณ๊ฒฝ ํ ๋ณ๊ฒฝ๋ ๊ฐ์ ๋ฆฌํดํ๋ค.
โ๏ธ split() : ์ฃผ์ด์ง ์ธ์๋ฅผ ๊ตฌ๋ถ์๋ก ์ผ์, ๋ฌธ์์ด์ ๋ถ๋ถ ๋ฌธ์์ด๋ก ๋๋์ด ๊ทธ ๊ฒฐ๊ณผ๋ฅผ ๋ฐฐ์ด๋ก ๋ฐํํ๋ค.
โ๏ธ search() : ์ ๊ทํํ์์ ์ธ์๋ก ๋ฐ์ ๊ฐ์ฅ ์ฒ์ ๋งค์นญ๋๋ ๋ถ๋ถ ๋ฌธ์์ด์ ์์น๋ฅผ ๋ฐํํ๋ค.
โฐ ๋งค์นญ๋๋ ๋ฌธ์์ด์ด ์์ผ๋ฉด -1์ ๋ฐํํ๋ค.
3๏ธโฃ flag
โ๏ธ ์ ๊ทํํ์์ ํ๋๊ทธ๋ฅผ ์ค์ ํด ์ค ์ ์์ผ๋ฉฐ, ํ๋๊ทธ๋ ์ถ๊ฐ์ ์ธ ๊ฒ์ ์ต์ ์ ์ญํ ์ ํ๋ค.
โฐ ํ๋๊ทธ๋ค์ ๊ฐ์ ํน์ ํจ๊ป ์ฌ์ฉํ๋ ๊ฒ์ด ๋ชจ๋ ๊ฐ๋ฅํ๋ฉฐ, ์์์ ๊ตฌ๋ถ์ด ์๋ค.
โ๏ธ i๋ฅผ ๋ถ์ด๋ฉด ๋์๋ฌธ์๋ฅผ ๊ตฌ๋ถํ์ง ์๋๋ค.
โ๏ธ g๋ฅผ ๋ถ์ด๋ฉด ๊ฒ์๋ ๋ชจ๋ ๊ฒฐ๊ณผ๋ฅผ ๋ฆฌํดํ๋ค.
โ๏ธ m์ ๋ถ์ด๋ฉด ๋ค์คํ์ ๊ฒ์ํ๋ค.
4๏ธโฃ ์ ๊ท์ ํจํด(ํํ์)
โ๏ธ ์ ๊ทํํ์์ ๋ค์ํ ํน์๊ธฐํธ๋ฅผ ํจ๊ป ์ฌ์ฉํ๋ฉด ๋ฌธ์์ด์ ๋ค๋ฃฐ ๋์ ๋ ๋ง์ ์ต์ ์ ์ค์ ํ ์ ์๋ค.
โ๏ธ Anchors: ^ and $
โฐ ^ : ๋ฌธ์์ด์ ์ฒ์์ ์๋ฏธํ๋ฉฐ, ๋ฌธ์์ด์์ ^๋ค์ ๋ถ์ ๋จ์ด๋ก ์์ํ๋ ๋ถ๋ถ์ ์ฐพ๋๋ค.
ใด ์ผ์นํ๋ ๋ถ๋ถ์ด ์๋๋ผ๋, ๊ทธ ๋ถ๋ถ์ด ๋ฌธ์์ด์ ์์ ๋ถ๋ถ์ด ์๋๋ฉด null์ ๋ฆฌํดํ๋ค.
โฐ $ : ๋ฌธ์์ด์ ๋์ ์๋ฏธํ๋ฉฐ, ๋ฌธ์์ด์์ $์์ ํํ์์ผ๋ก ๋๋๋ ๋ถ๋ถ์ ์ฐพ๋๋ค.
ใด ์ผ์นํ๋ ๋ถ๋ถ์ด ์๋๋ผ๋, ๊ทธ ๋ถ๋ถ์ด ๋ฌธ์์ด์ ๋๋ถ๋ถ์ด ์๋๋ฉด null์ ๋ฆฌํดํ๋ค.
โ๏ธ Quantifiers: *, +, ? and {}
โฐ * : ๋ฐ๋ก ์์ ๋ฌธ์๊ฐ 0๋ฒ ์ด์ ๋ํ๋๋ ๊ฒฝ์ฐ๋ฅผ ๊ฒ์ํ๋ค.
ใด /ode*/g ์ ์ฌ์ฉํ๊ฒ ๋๋ฉด "od" ๊ฐ ๋ค์ด๊ฐ๋ฉด์ ๊ทธ ๋ค์ "e"๊ฐ 0๋ฒ ์ด์ ํฌํจ๋ ๋ชจ๋ ๋ฌธ์์ด์ ๋ฆฌํดํ๋ค.
โฐ + : + ๋ฐ๋ก ์์ ๋ฌธ์๊ฐ 1๋ฒ ์ด์ ๋ํ๋๋ ๊ฒฝ์ฐ๋ฅผ ๊ฒ์ํ๋ค.
โฐ ? : ? ์์ ๋ฌธ์๊ฐ 0๋ฒ ํน์ 1๋ฒ ๋ํ๋๋ ๊ฒฝ์ฐ๋ง ๊ฒ์ํ๋ค.
ใด ?๋ * ํน์ + ์ ํจ๊ป ์ฐ๋ ๊ฒ๋ ๊ฐ๋ฅํ๋ฉฐ, ํจ๊ป ์ฌ์ฉํ์์ ๊ฒฝ์ฐ *?๋ 0๋ฒ, +?๋ 1๋ฒ์ธ ๋ฌธ์์ด๋ง ๋ฆฌํดํ๋ค.
โฐ {} : ์ง์ ์ซ์๋ฅผ ๋ฃ์ด์ ์ฐ์๋๋ ๊ฐ์๋ฅผ ์ค์ ํ ์ ์๋ค.
ใด {2}๋ 2๊ฐ, {2, }๋ 2๊ฐ ์ด์, {2, 5}๋ 2๊ฐ ์ด์ 5๊ฐ ์ดํ๋ฅผ ์๋ฏธํ๋ค.
โ๏ธ OR operator
โฐ | ๋ or ์กฐ๊ฑด์ผ๋ก ๊ฒ์ํ์ฌ | ์ ์ผ์ชฝ ๋๋ ์ค๋ฅธ์ชฝ์ ๊ฒ์ ๊ฒฐ๊ณผ๋ฅผ ๋ฐํํ๋ค.
โ๏ธ Bracket Operator : []
โฐ ๋๊ดํธ [] ์์ ๋ช ์๋ ๊ฐ์ ๊ฒ์ํ๋ค.
โ๏ธ Character classes
โฐ \d : d ๋ digit ์ ์๋ฏธํ๋ฉฐ 0 ~ 9 ์ฌ์ด์ ์ซ์ ํ๋๋ฅผ ๊ฒ์ํ๋ค. [0-9] ์ ๋์ผ
โฐ \D : not Digit ์ ์๋ฏธํ๋ฉฐ, ์ซ์๊ฐ ์๋ ๋ฌธ์ ํ๋๋ฅผ ๊ฒ์ํ๋ค. [^0-9] ์ ๋์ผ
โฐ \w : ์ํ๋ฒณ ๋์๋ฌธ์, ์ซ์, _(underbar) ์ค ํ๋๋ฅผ ๊ฒ์ํ๋ค. [a-zA-Z0-9_]์ ๋์ผ
โฐ \W : ์ํ๋ฒณ ๋์๋ฌธ์, ์ซ์, _ (underbar)๊ฐ ์๋ ๋ฌธ์ ํ๋๋ฅผ ๊ฒ์ํ๋ค. [^a-zA-Z0-9_]์ ๋์ผ
โ๏ธ Grouping and capturing
โฐ ๊ทธ๋ฃนํ : ํํ์์ ์ผ๋ถ๋ฅผ ()๋ก ๋ฌถ์ด์ฃผ๋ฉด ๊ทธ ์์ ๋ด์ฉ์ ํ๋๋ก ๊ทธ๋ฃนํํ ์ ์๋ค.
โฐ ์บก์ณ : () ๋ก ๊ทธ๋ฃนํํ๋ค๊ณ ํ์๊ณ , ์ด๋ฅผ ์บก์ฒํ๋ค ๋ผ๊ณ ํ๋ค.
co.match(/(co)+/); // ["coco", "co", index: 0, input: "coco", groups: undefined]
ใด () ๋ก "co"๋ฅผ ์บก์ฒ
ใด ์บก์ฒํ "co" ๋ ์ผ๋จ ๋น์ฅ ์ฌ์ฉํ์ง ์๊ณ , + ๊ฐ "co"์ 1ํ ์ด์ ์ฐ์ ๋ฐ๋ณต์ ๊ฒ์
ใด ์ด๋ ๊ฒ ์บก์ฒ ์ด์ธ ํํ์์ด ๋ชจ๋ ์๋ํ๊ณ ๋๋ฉด, ์บก์ฒํด ๋์๋ "co"๋ฅผ ๊ฒ์
โ๏ธ non-capturing
โฐ (?:)๋ก ์ฌ์ฉํ๋ฉด ๊ทธ๋ฃน์ ๋ง๋ค์ง๋ง ์บก์ฒ๋ ํ์ง ์๋๋ค.
โ๏ธ lookahead
โฐ ๊ฒ์ํ๋ ค๋ ๋ฌธ์์ด์ (?=์ฌ๊ธฐ) ์ ์ผ์นํ๋ ๋ฌธ์๊ฐ ์์ด์ผ (?=์ฌ๊ธฐ) ์์ ๋ฌธ์์ด์ ๋ฐํํ๋ค.
โ๏ธ negated lookahead
โฐ (?!) ๋ (?=) ์ ๋ถ์
'CodeStates > learning contents' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
Section 4. [๊ธฐ์ ๋ฉด์ ] (0) | 2023.04.10 |
---|---|
S4) Unit 11. [์๋ฃ๊ตฌ์กฐ/์๊ณ ๋ฆฌ์ฆ] Algorithm ์ ํ (0) | 2023.04.05 |
S4) Unit 11. [์๋ฃ๊ตฌ์กฐ/์๊ณ ๋ฆฌ์ฆ] ์๊ณ ๋ฆฌ์ฆ & ์๊ฐ ๋ณต์ก๋ & ๊ณต๊ฐ ๋ณต์ก๋ (0) | 2023.04.05 |
S4) Unit 10. [Deploy]Github Action & Proxy (0) | 2023.04.04 |
S4) Unit 10. [Deploy]๊ฐ๋ฐ ํ๋ก์ธ์ค (0) | 2023.04.03 |