diff --git a/239_sliding-window-maximum.c b/239_sliding-window-maximum.c new file mode 100644 index 0000000..60f649f --- /dev/null +++ b/239_sliding-window-maximum.c @@ -0,0 +1,146 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* 239_sliding-window-maximum.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: kjikuhar +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2025/05/31 00:46:17 by kei2003730 #+# #+# */ +/* Updated: 2025/06/04 17:59:05 by kjikuhar ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include + +/** + * Note: The returned array must be malloced, assume caller calls free(). + */ +# define DEQUE_CAPACITY 100001 +typedef struct s_Deque +{ + int top; + int bottom; + unsigned int size; + int array[DEQUE_CAPACITY]; +} t_Deque; + + void deque_init(t_Deque *deque) +{ + deque->top = 0; + deque->bottom = 0; + deque->size = 0; + // bzero(deque->array, sizeof(int) * DEQUE_CAPACITY); +} + +void deque_clear(t_Deque *deque) +{ + deque_init(deque); +} + +bool deque_is_empty(const t_Deque *deque) +{ + return (deque->size == 0); +} + +bool deque_is_full(const t_Deque *deque) +{ + return (deque->size == DEQUE_CAPACITY); +} + +int deque_peek_at_Nth(const t_Deque *deque, unsigned int index) +{ + size_t position; + + if (index >= deque->size) + return (0); + position = (deque->top + index) % DEQUE_CAPACITY; + return (deque->array[position]); +} + +bool deque_push_front(t_Deque *deque, int num) +{ + if (deque_is_full(deque)) + return (false); + deque->top = (deque->top - 1 + DEQUE_CAPACITY) % DEQUE_CAPACITY; + deque->array[deque->top] = num; + deque->size += 1; + return (true); +} + +bool deque_push_back(t_Deque *deque, int num) +{ + if (deque_is_full(deque)) + return (false); + if (deque->size == 0) + { + deque->array[deque->top] = num; + deque->bottom = (deque->top + 1) % DEQUE_CAPACITY; + } + else + { + deque->array[deque->bottom] = num; + deque->bottom = (deque->bottom + 1) % DEQUE_CAPACITY; + } + deque->size += 1; + return (true); +} + +bool deque_pop_front(t_Deque *deque, int *out) +{ + if (deque_is_empty(deque)) + return (false); + if (out) + *out = deque->array[deque->top]; + deque->top = (deque->top + 1) % DEQUE_CAPACITY; + deque->size -= 1; + return (true); +} + +bool deque_pop_back(t_Deque *deque, int *out) +{ + if (deque_is_empty(deque)) + return (false); + deque->bottom = (deque->bottom - 1 + DEQUE_CAPACITY) % DEQUE_CAPACITY; + if (out) + *out = deque->array[deque->bottom]; + deque->size -= 1; + return (true); +} + +int deque_peek_back(t_Deque *deque) +{ + int pos; + pos = (deque->bottom + DEQUE_CAPACITY - 1) % DEQUE_CAPACITY; + return (deque->array[pos]); +} + +int* maxSlidingWindow(int* nums, int numsSize, int k, int* returnSize) +{ + int i; + int *result; + t_Deque deque; + + i = 0; + *returnSize = numsSize - k + 1; + result = malloc(sizeof(int) * (*returnSize)); + if (!result) + return (NULL); + if(k == 1) + { + memcpy(result, nums, sizeof(int) * (*returnSize)); + return (result); + } + deque_init(&deque); + while (i < numsSize) + { + while (!deque_is_empty(&deque) && nums[i] >= nums[deque_peek_back(&deque)]) + deque_pop_back(&deque, NULL); + deque_push_back(&deque, i); + if (i - deque.array[deque.top] >= k) + deque_pop_front(&deque, NULL); + if (i >= k - 1) + result[i - k + 1] =nums[deque_peek_at_Nth(&deque, 0)]; + i++; + } + return (result); +} diff --git a/46_permutations.c b/46_permutations.c new file mode 100644 index 0000000..2554868 --- /dev/null +++ b/46_permutations.c @@ -0,0 +1,187 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* 46_permutations.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: kei2003730 +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2025/06/01 14:36:14 by kei2003730 #+# #+# */ +/* Updated: 2025/06/01 15:15:32 by kei2003730 ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include +#include +#include +#include + +bool set_null(int **returnColumnSizes, int *returnSize) +{ + *returnSize = 0; + *returnColumnSizes = NULL; + return (false); +} + +bool input_validation(int *nums, int numsSize, int *returnSize, + int **returnColumnSizes) +{ + int i; + int j; + + if (!(0 <= numsSize && numsSize <= 6) || !nums || !returnSize + || !returnColumnSizes) + return (set_null(returnColumnSizes, returnSize)); + i = 0; + while (i < numsSize) + { + if (!(-10 <= nums[i] && nums[i] <= 10)) + return (set_null(returnColumnSizes, returnSize)); + j = i + 1; + while (j < numsSize) + { + if (nums[i] == nums[j]) + return (set_null(returnColumnSizes, returnSize)); + j++; + } + i++; + } + return (true); +} + +int get_return_size(int numsSize) +{ + int size; + int i; + + size = 1; + i = 1; + while (i <= numsSize) + { + size *= i; + i++; + } + return (size); +} + +int **allocate_result(int numsSize, int *returnSize, int **returnColumnSizes) +{ + int **result; + int i; + + *returnSize = get_return_size(numsSize); + result = malloc(sizeof(int *) * (*returnSize)); + if (!result) + return (NULL); + *returnColumnSizes = malloc(sizeof(int) * (*returnSize)); + if (!(*returnColumnSizes)) + return (free(result), NULL); + i = 0; + while (i < *returnSize) + { + result[i] = malloc(sizeof(int) * numsSize); + if (!result[i]) + { + while (i > 0) + free(result[--i]); + free(result); + return (free(*returnColumnSizes), NULL); + } + (*returnColumnSizes)[i] = numsSize; + i++; + } + return (result); +} + +void swap(int *a, int *b) +{ + int tmp; + + tmp = *a; + *a = *b; + *b = tmp; +} + +void generate_permutations(int *nums, int numsSize, int start, int **result, + int *result_index) +{ + int i; + + if (start == numsSize) + { + memcpy(result[*result_index], nums, sizeof(int) * numsSize); + (*result_index)++; + return ; + } + i = start; + while (i < numsSize) + { + swap(&nums[start], &nums[i]); + generate_permutations(nums, numsSize, start + 1, result, result_index); + swap(&nums[start], &nums[i]); + i++; + } +} + +/** + * Return an array of arrays of size *returnSize. + * The sizes of the arrays are returned as *returnColumnSizes array. + * Note: Both returned array and *columnSizes array must be malloced, + assume caller calls free(). + */ +int **permute(int *nums, int numsSize, int *returnSize, int **returnColumnSizes) +{ + int **result; + int *nums_copy; + int result_index; + int i; + + if (!input_validation(nums, numsSize, returnSize, returnColumnSizes)) + return (*returnSize = 0, *returnColumnSizes = NULL, NULL); + result = allocate_result(numsSize, returnSize, returnColumnSizes); + if (!result) + return (*returnSize = 0, NULL); + nums_copy = malloc(sizeof(int) * numsSize); + if (!nums_copy) + { + i = 0; + while (i < *returnSize) + free(result[i++]); + return (free(result), free(*returnColumnSizes), NULL); + } + memcpy(nums_copy, nums, sizeof(int) * numsSize); + result_index = 0; + generate_permutations(nums_copy, numsSize, 0, result, &result_index); + free(nums_copy); + return (result); +} + +// int main(void) +// { +// int nums[] = {1, 2, 3, 4}; +// int numSize = 4; +// int returnSize; +// int *returnColumnSizes; +// int **result; +// int i; +// int j; + +// result = permute(nums, numSize, &returnSize, &returnColumnSizes); +// printf("順列の数: %d\n", returnSize); +// printf("すべての順列:\n"); +// i = 0; +// while (i < returnSize) +// { +// printf("%d: ", i + 1); +// j = 0; +// while (j < returnColumnSizes[i]) +// printf("%d ", result[i][j++]); +// printf("\n"); +// i++; +// } +// i = 0; +// while (i < returnSize) +// free(result[i++]); +// free(result); +// free(returnColumnSizes); +// return (0); +// } \ No newline at end of file