[라피신 공부 일지] C05

Exercise 00 : ft_iterative_factorial

• 문제

• 풀이
  팩토리알 함수를 반복 함수로 구현하기
  인자가 유효하지 않으면 0 반환 = 음수일때는 0반환
  오버플로우는 처리하면 안됨.(한/영 오역 주의)
   cf) 0! = 1
• 코드

int	ft_iterative_factorial(int nb)
{
	int	factorial;
	int	index;

	if (nb < 0)
		return (0);
	index = 1;
	factorial = 1;
	while (index < nb + 1)
		factorial = factorial * index++;
	return (factorial);
}

 

 

Exercise 01 : ft_recursive_factorial

• 문제

• 풀이
  → 팩토리얼 함수를 재귀함수로 구현하기
  인자가 유효하지 않으면 0 반환.
  오버플로우는 처리하지 말기.
  cf) 0! = 1
• 코드

int	ft_recursive_factorial_recursive(int factorial, int number)
{
	factorial *= number--;
	if (number > 0)
		return (ft_recursive_factorial_recursive(factorial, number));
	return (factorial);
}

int	ft_recursive_factorial(int nb)
{
	if (nb < 0)
		return (0);
	if (nb == 0)
		return (1);
	return (ft_recursive_factorial_recursive(1, nb));
}

 

 

Exercise 02 : ft_iterative_power

• 문제
• 풀이
  → 거듭제곱을 반환하는 반복함수 작성
  n이 0보다 작으면 0 반환,
  0^0 = 1 (모든 수의 0제곱 = 1)
  오버플로우 처리하지 말기
• 코드

int	ft_iterative_power(int nb, int power)
{
	int result;

	if (power < 0)
		return (0);
	result = 1;
	while (power-- > 0)
		result *= nb;
	return (result);
}

 

Exercise 03 : ft_recursive_power

• 문제
• 풀이
  → 거듭제곱 반환하는 재귀함수 작성.
  n이 0보다 작으면 0 반환,
  0^0 = 1 (모든 수의 0제곱 = 1)
  오버플로우 처리하지 말기
• 코드

int	ft_recursive_power_recursive(int number, int power, int result)
{
	if (power-- > 0)
		return (ft_recursive_power_recursive(number, power, result *= number));
	return (result);
}

int	ft_recursive_power(int nb, int power)
{
	if (power < 0)
		return (0);
	return (ft_recursive_power_recursive(nb, power, 1));
}

 

Exercise 04 : ft_fibonacci

• 문제
• 풀이
  → 피보나치 수열 재귀함수로 작성하기.
  인덱스가 0보다 작으면 -1반환하기
  index 0 = 0, index 1 = 1으로 정의하기.
  피보나치 수열 : n항 = n-1항 + n-2항
  오버플로우 처리하지 말기.
• 코드

int	ft_fibonacci(int index)
{
	if (index < 0)
		return (-1);
	if (index < 2)
		return (index);
	return (ft_fibonacci(index - 2) + ft_fibonacci(index - 1));
}

 

Exercise 05 : ft_sqrt

• 문제
• 풀이
  → 제곱근이 존재하면 제곱근 반환, 제곱근이 무리수면(=정수가 아니면) 0 반환.
• 코드

int 	ft_sqrt(int nb)
{
	long long i;

	if(nb <= 0)
		return (0);
	i=1;
	while(i*i < (long long) nb)
		++i;
	if(i*i==(long long) nb)
		return(i);
	return (0);
}

cf) int 와 long long int 는 호환이 된다.
long long int = long long
i * i 일때 오버플로우 방지 위해서 롱롱씀

 

Exercise 06 : ft_is_prime

• 문제
• 풀이
  → 매개변수로 주어진 수가 소수면 1반환,
  그렇지 않으면 0 반환 0과 1은 소수가 아님.
• 코드

#include <unistd.h>

int	ft_is_prime(int nb)
{
	int	i;

	i = 2;
	if (nb <= 1)
		return (0);

	while (i * i <= nb)
	{
		if (nb % i == 0)
			return (0);
		i++;
	}
	return (1);
}

Exercise 07 : ft_find_next_prime

• 문제
• 풀이
  → 인자로 주어진 수보다 크거나 같은 다음 소수를 반환하기.
• 코드

int	ft_is_prime(int nb)
{
	int	i;

	i = 2;
	if (nb <= 1)
		return (0);
	while (i * i <= nb)
	{
		if (nb % i == 0)
			return (0);
		i++;
	}
	return (1);
}

int	ft_find_next_prime(int nb)
{
	int	i;

	if (nb < 2)
		nb = 2;
	i = nb;
	while (####범위설정#####)   //i < 2 * nb
		{
			if (ft_is_prime(i))
				return (i);
			i++;
		}
	return (0);
}

 

int	ft_recursive_factorial(int nb)
{
	if (nb<0)
		return (0);
	if (nb == 0)
		return (1);
	if (nb == 1)
		return (1);
	return (nb * ft_recursive_factorial(nb-1));
}

Exercise 07 : The Ten Queens

#include <stdio.h>
#include <unistd.h>

void	ft_putstr(char *str)
{
	while (*str)
		write(1, str++, 1);
}

void	build(int grid[10][10])
{
	int	x;
	int	y;

	y = 0;
	while (y < 10)
	{
		x = 0;
		while (x < 10)
		{
			grid[x][y] = 0;
			x++;
		}
		y++;
	}
}

void	print(int grid[10][10])
{
	int	x;
	int	y;

	y = 0;
	while (y < 10)
	{
		x = 0;
		while (x < 10)
		{
			printf("%d, ", grid[x][y]);
			x++;
		}
		printf("\\n");
		y++;
	}
}

int		find_in_y(int grid[10][10], int x)
{
	int	i;

	i = 0;
	while (i < 10)
	{
		if (grid[x][i])
		{
			return (i);
			break ;
		}
		i++;
	}
	return (-1);
}

int		possible(int grid[10][10], int x, int y)
{
	int	i;
	int	found;

	i = 0;
	while (i < 10)
	{
		found = find_in_y(grid, i);

		int	ytemp = x - i;
		int xtemp = y - found;
		if (xtemp < 0)
			xtemp = -xtemp;
		if (ytemp < 0)
			ytemp = -ytemp;

		if (y == found || ytemp == xtemp)
			return (0);
		i++;
	}
	return (1);
}

void	solve(int grid[10][10], int x, int *solutions)
{
	int	i;

	if (x < 10)
	{
		i = 0;
		while (i < 10)
		{
			if (possible(grid, x, i))
			{
				grid[x][i] = 1;
				solve(grid, x + 1, solutions);
				grid[x][i] = 0;
			}
			i++;
		}
	}
	else
		(*solutions)++;
		print(grid);
}

int	ft_ten_queens_puzzle(void)
{
	int		grid[10][10];
	int		solutions;

	solutions = 0;
	build(grid);
	solve(grid, 0, &solutions);
	return (solutions);
}

int	main(void)
{
	printf("\\n%d\\n", ft_ten_queens_puzzle());
	return (0);
}

작은 도움이 되셨길 바라며, 좋아요나 댓글은 큰 힘이 됩니다:)