archive 46 239

239_sliding-window-maximum.c

@@ -0,0 +1,146 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   239_sliding-window-maximum.c                       :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: kjikuhar <kjikuhar@student.42tokyo.jp>     +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2025/05/31 00:46:17 by kei2003730        #+#    #+#             */
+/*   Updated: 2025/06/04 17:59:05 by kjikuhar         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include <stdbool.h>
+
+/**
+ * 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);
+}

46_permutations.c

@@ -0,0 +1,187 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   46_permutations.c                                  :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: kei2003730 <kei2003730@student.42.fr>      +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2025/06/01 14:36:14 by kei2003730        #+#    #+#             */
+/*   Updated: 2025/06/01 15:15:32 by kei2003730       ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+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);
+// }