c05 - KimTaebin-ai/study_posts GitHub Wiki
์ฌ๊ทํจ์ ์ฌ์ฉ๊ณผ ์ฌ๋ฌ ์๊ณ ๋ฆฌ์ฆ ๋ฌธ์
์ฒ์ ํด๋น ์ฑํฐ์ ๋๋ฌํ์ ๋
์ฌ๊ทํจ์๊ฐ ๋ด๊ฐ ์ํ๋ ๋ก์ง์ด ๋ง๋์ง ๊ฒ์ฆํ๋ ๋ฐฉ๋ฒ์ ๋ํด ๋ง์ ๊ณ ๋ฏผ์ ํ๋ค
1์ผ์ฐจ์๋ ๊ท์น์ ์ฐพ๋๋ฐ์ ๊ธ๊ธํ๊ณ
2~3์ผ์ฐจ๋ ๊ตฌํํ ๋ฌธ์ ์์๋ ๋ด ๊ท์น์ด ์ ๋ง์๊น์ ๋ํด ์ง๋ฌธํ๋ค
๊ทธ ๋น์ ๋ค๋ฅธ ๋๋ฃ๋ถ๋ค์ ์กฐ์ธ์ ๊ทผ๊ฑฐ๋ก, ๊ฒฐ๋ก ์ ์ธ๊ฐ์ ์ฌ๊ท์ ์ธ ์ฌ๊ณ ๊ฐ ๋ถ๊ฐ๋ฅํ๋ฏ๋ก ๊ท์น์ ์ฐพ์ ๋ ์ํ์ ๊ท๋ฉ๋ฒ์ ํตํด ํ์ธํด์ผ ํ๋ค๊ณ ๋ฐฐ์ ๋ค
์ ์ถํ๊ณ ๋์ ์๊ฒ๋์์ง๋ง, ์ฌ๊ทํจ์๋ ํน์ ์กฐ๊ฑด์ด ๋๋๋ ์์ ์ธ ๊ธฐ์ ์กฐ๊ฑด์ด ์กด์ฌํ๋ค.
์ฌ๊ทํจ์๋ฅผ ์ฝ์ ๋ ๊ธฐ์ ์กฐ๊ฑด์ ์ฐพ๊ณ ๋์์ ๋ ๋ฒ์งธ ์กฐ๊ฑด์ ์ฐพ์ผ๋ฉด ์ฆ๋ช ๊ณผ ๊ท์น์ฐพ๊ธฐ๊ฐ ๊ฐ๋ฅํ๋ค
int ft_iterative_factorial(int nb)
{
int result;
int i;
i = 2;
result = 1;
if (nb < 0)
{
return (0);
}
else if (nb == 1)
{
return (1);
}
while (i <= nb)
{
result *= i++;
}
return (result);
}
int ft_recursive_factorial(int nb)
{
if (nb < 0)
{
return (0);
}
else if (nb < 2)
{
return (1);
}
return (nb * ft_recursive_factorial(nb - 1));
}
์ฌ๊ทํจ์์ ๊ธฐ์ ์กฐ๊ฑด์ ์์์ผํจ
ํด๋น ๋ฌธ์ ์ ๊ฒฝ์ฐ nb ๊ฐ 1์ ๋๋ฌํ์ ๋ ์ฌ๊ท๋ฅผ ์ข ๋ฃ์์ผ์ผ ํจ
๊ทธ๋ฌ์ง ์์ ๊ฒฝ์ฐ ์คํ์ค๋ฒํ๋ก์ฐ๊ฐ ๋ฐ์ํจ
int ft_iterative_power(int nb, int power)
{
int i;
int result;
i = 1;
result = nb;
if (nb < 0)
{
return (0);
}
else if (nb == 0 && power == 0)
{
return (1);
}
else
{
while (i <= power)
{
result += nb;
i++;
}
}
return (result);
}
int ft_recursive_power(int nb, int power)
{
if (nb < 0)
{
return (0);
}
else if (power == 0)
{
return (1);
}
else if (nb == 0)
{
return (0);
}
return (nb * ft_recursive_power(nb, power - 1));
}
int ft_fibonacci(int index)
{
if (index < 0)
return (-1);
else if (index == 0)
return (0);
else if (index == 1)
return (1);
return (ft_fibonacci(index - 1) + ft_fibonacci(index - 2));
}
#include <stdio.h>
int ft_sqrt(int nb)
{
int i;
int sqrt;
i = 0;
sqrt = 0;
if (nb < 1)
return 0;
while (1) {
sqrt = i * i;
if (sqrt == nb)
return i;
else if (sqrt > nb)
return 0;
i++;
}
}
#include <stdio.h>
int ft_is_prime(int nb) {
// 2๋ถํฐ ์คํ ~ ์๊ธฐ ์์ - 1
// nb % i == 0
int i = 2;
int is_prime = 1;
if (nb <= 2) {
return is_prime;
}
while (i < nb) {
if (nb % i == 0) {
is_prime = 0;
}
i++;
}
return is_prime;
}
int is_prime(int num)
{
long i;
long prime;
i = 2;
if (num <= 1)
return (0);
if (num == 2)
return (1);
while (1)
{
if (num % i == 0)
return (0);
prime = i * i;
if (prime > num)
break ;
i++;
}
return (1);
}
int ft_find_next_prime(int nb)
{
int num;
num = nb;
while (1)
{
if (is_prime(num))
return (num);
num++;
}
}
#include <unistd.h>
void print_arr(int *arr)
{
int i;
char c;
i = 0;
while (i < 10)
{
c = arr[i] + '0';
write(1, &c, 1);
i++;
}
write(1, "\n", 1);
}
int check(int col, int *arr)
{
int i;
i = 0;
while (i < col)
{
if (arr[i] == arr[col])
return (0);
if (arr[i] - arr[col] == i - col)
return (0);
if (arr[i] - arr[col] == col - i)
return (0);
i++;
}
return (1);
}
int check_queen(int col, int *arr)
{
int i;
int count;
i = 0;
count = 0;
if (col == 10)
{
print_arr(arr);
return (1);
}
while (i < 10)
{
arr[col] = i;
if (check(col, arr))
count += check_queen(col + 1, arr);
i++;
}
return (count);
}
int ft_ten_queens_puzzle(void)
{
int arr[10];
int i;
int result;
i = 0;
result = 0;
while (i < 10)
arr[i++] = 0;
i = 0;
while (i < 10)
{
result += check_queen(1, arr);
arr[0]++;
i++;
}
return (result);
}
์ ๋ช ํ n-queens๋ฌธ์ ์ด๋ค ์ด๋ฒ ์ฑํฐ์์๋ ์ฌ๊ทํจ์๋ฅผ ์ฃผ๋ก ๋ค๋ฃจ๋ ๊ฒ ๋งํผ ์ด ๋ฌธ์ ๋ฅผ ๋ฐฑํธ๋ํน ์๊ณ ๋ฆฌ์ฆ์ ํตํด ํ๊ฒ ๋์๋ค.
์ด ๋ฌธ์ ๋ ํธ์ ํน์ฑ (๋๊ฐ์ , ํ, ์ด ์ด๋๊ฐ๋ฅ)์ ๊ณ ๋ คํ์ฌ ๋ค์๊ณผ ๊ฐ์ ์กฐ๊ฑด์ ๋ง์กฑํด์ผ ํ๋ค.
- ํ๋์ ์ด, ๊ทธ๋ฆฌ๊ณ ํ๋์ ํ์๋ ํ๋์ ํธ๋ง ์์นํ๊ฒ.
- ๋๊ฐ์ ์ ์์นํ๋์ง ์ํ๋์ง ์ง์์ ์ธ ํ์ธ (์ขํฅ, ์ฐํฅ ๋๋ค ํ์ธ)
๋ ํจ์จ์ ์ธ ์๊ณ ๋ฆฌ์ฆ์ด ์์ ์ ์๊ฒ ์ง๋ง ํธ ํ๋์ ์์น๋ฅผ ์ฎ๊ฒจ๊ฐ๋ฉฐ ํ์๋๋ ๊ฒฝ์ฐ์ ์๋ฅผ ๋ค ํ์ธํ๊ธฐ ์ํด์ ์ฌ๊ท์ ํน์ฑ์ ํ์ฉํ ๋ฐฑํธ๋ํน ์๊ณ ๋ฆฌ์ฆ์ด ์ ํฉํ๋ค๊ณ ์๊ฐํ๋ค.
๋ฌธ์ ์์์ ์ ํ์๋ ์ซ์๋ถํฐ ์ดํด๊ฐ ๋์ง ์์๋ค. ํ์ง๋ง ์ด๋ ๊ฒ ์ดํดํ๋ฉด ๋๋ค. ๊ฐ์ซ์์ ์๋ฆฟ๊ฐ์ด x์ ์ขํ๊ณ ์ฐ์ฌ์๋ ๊ฐ๋ค์ด y๊ฐ์ด๋ค. ์๋ฅผ๋ค์ด 0123๋ผ๋ ๊ฐ์ด ์๋ค๋ฉด ์์๋๋ก 0,0 1,1 2,2 3,3์ด๋ค 4321์ด๋ฉด 0,4 1,3 2,2 3,1์ด๋ค ์ด ๊ฒฝ์ฐ์ ์๋ 724๊ฐ์ง ์ด๋ ต๊ฒ ์๊ฐํ ํ์๋ ์๋ค. ๊ทธ์ ์ฒซ๋ฒ์งธ ํ์ ๊ฐ์ด ์ ํด์ง๋ค๋ฉด ๋๋ฒ์งธ ํ์ ๊ฐ์ ์ ํ๊ณ ๊ทธ๋ค์ ํ ๊ทธ๋ค์ ๊ฐ ์๋๋ฉด ๋ฆฌํด ๋ฆฌํด ๋ฆฌํด ๋ฐ๋ณต์ด๋ค