libft strlen

Makefile

@@ -6,7 +6,7 @@
 #    By: lud-adam <lud-adam@student.42.fr>          +#+  +:+       +#+         #
 #                                                 +#+#+#+#+#+   +#+            #
 #    Created: 2025/07/18 12:51:21 by lud-adam          #+#    #+#              #
-#    Updated: 2026/03/28 15:07:38 by lud-adam         ###   ########.fr        #
+#    Updated: 2026/03/29 14:43:31 by lud-adam         ###   ########.fr        #
 #                                                                              #
 # **************************************************************************** #
 
@@ -22,13 +22,15 @@ P_OBJ = .obj/
 P_INC = inc/
 P_LIBFT = libft/
 
-SRC = main.c \
+SRC =  \
+	main.c \
 	get_next_line.c \
-      fill_array.c \
+	fill_vector.c \
 	check_input.c \
 	print_board.c	\
 	ai.c \
-			game.c
+	game.c \
+	vector.c
 
 SRCS = $(addprefix $(P_SRC), $(SRC))
 OBJS = $(patsubst $(P_SRC)%.c,$(P_OBJ)%.o,$(SRCS))
@@ -50,9 +52,11 @@ $(LIBFT):
 
 clean:
 	rm -rf $(P_OBJ)
+	$(MAKE) -C $(P_LIBFT) clean
 
 fclean: clean
 	rm -f $(NAME)
+	$(MAKE) -C $(P_LIBFT) fclean
 
 re: fclean all
 

alcu.map

@@ -1,10 +0,0 @@
-2
-9
-10
-5
-9
-8
-2
-1
-8
-10

compile_commands.json

@@ -1,53 +0,0 @@
-[
- {
-  "directory": "/home/lud-adam/Documents/rush",
-  "arguments": [
-   "cc",
-   "-Wall",
-   "-Wextra",
-   "-Werror",
-   "-MMD",
-   "-I",
-   "inc/",
-   "-c",
-   "src/main.c",
-   "-o",
-   ".obj/main.o"
-  ],
-  "file": "src/main.c"
- },
- {
-  "directory": "/home/lud-adam/Documents/rush",
-  "arguments": [
-   "cc",
-   "-Wall",
-   "-Wextra",
-   "-Werror",
-   "-MMD",
-   "-I",
-   "inc/",
-   "-c",
-   "src/fill_array.c",
-   "-o",
-   ".obj/fill_array.o"
-  ],
-  "file": "src/fill_array.c"
- },
- {
-  "directory": "/home/lud-adam/Documents/rush",
-  "arguments": [
-   "cc",
-   "-Wall",
-   "-Wextra",
-   "-Werror",
-   "-MMD",
-   "-I",
-   "inc/",
-   "-c",
-   "src/check_input.c",
-   "-o",
-   ".obj/check_input.o"
-  ],
-  "file": "src/check_input.c"
- }
-]

inc/alcu.h

@@ -6,20 +6,24 @@
 /*   By: lud-adam <lud-adam@student.42.fr>          +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2026/03/28 13:27:29 by lud-adam          #+#    #+#             */
-/*   Updated: 2026/03/28 21:41:55 by dgaillet         ###   ########lyon.fr   */
+/*   Updated: 2026/03/29 14:58:00 by lud-adam         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
 #ifndef ALCU_H
-# define ALCU_H
+#define ALCU_H
 
-# include <stddef.h>
+#include "vector.h"
+
+#include <stdbool.h>
+#include <stddef.h>
 
 char *read_file(int fd);
-int		check_input(int fd);
+bool check_input(t_vector *lines);
 void print_board(int *game_state, size_t nb_line);
-int		*fill_array(int fd, int size);
+bool fill_vector(t_vector *lines, int fd);
 int ai(int *gamestate, int nb_line);
-void	game(int *lines, int size);
+bool game(int *lines, int size);
+int *fill_array(t_vector *lines, int *size);
 
 #endif

inc/compile_commands.json

@@ -0,0 +1 @@
+[]

inc/vector.h

@@ -0,0 +1,49 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   vector.h                                           :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: lud-adam <lud-adam@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2026/03/29 14:24:01 by lud-adam          #+#    #+#             */
+/*   Updated: 2026/03/29 14:40:21 by lud-adam         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#ifndef VECTOR_H
+#define VECTOR_H
+
+#include <stdbool.h>
+#define VECTOR_INIT_CAPACITY 6
+#define UNDEFINE -1
+#define SUCCESS 0
+
+typedef struct s_vector_list {
+  void **items;
+  int capacity;
+  int total;
+} t_vector_list;
+
+typedef struct s_vector t_vector;
+
+struct s_vector {
+  t_vector_list vector_list; /**< List to store vector elements */
+  int (*pfVectorTotal)(
+      t_vector *); /**< Retrieves the total number of elements in the vector */
+  int (*pfVectorResize)(t_vector *,
+                        int); /**< Resizes the vector to a new capacity */
+  int (*pfVectorAdd)(t_vector *, void *); /**< Adds an element to the vector */
+  int (*pfVectorSet)(
+      t_vector *, int,
+      void *); /**< Sets an element at a specific index in the vector */
+  void *(*pfVectorGet)(t_vector *,
+                       int); /**< Retrieves an element from the vector */
+  int (*pfVectorDelete)(t_vector *,
+                        int); /**< Deletes an element from the vector */
+  int (*pfVectorFree)(
+      t_vector *); /**< Frees the memory allocated for the vector */
+};
+
+bool vector_init(t_vector *v);
+
+#endif

libft/ft_strlen.c

@@ -12,14 +12,11 @@
 
 #include "libft.h"
 
-size_t	ft_strlen(char *str, char c)
-{
+size_t ft_strlen(const char *s) {
   size_t i;
 
   i = 0;
-	if (!str)
-		return (0);
-	while (str[i] && str[i] != c)
+  while (s[i])
     i++;
   return (i);
 }

map_gen.sh

@@ -1,15 +0,0 @@
-#!/bin/bash
-
-if [ $# -lt 2 ]; then
-	echo "usage: bash map_gen.sh [size] [range]"
-	exit 1
-fi
-
-unset var
-for i in $( seq 1 $1 )
-do
-	var+="\n$(( RANDOM % $2 + 1))"
-done
-var="${var}\n";
-echo -e $var | tail -n +2
-

src/check_input.c

@@ -12,30 +12,31 @@
 
 #include "../libft/libft.h"
 #include "get_next_line.h"
+#include "vector.h"
+
 #include <fcntl.h>
 #include <stdlib.h>
 #include <unistd.h>
+#include <stdbool.h>
 
-int	check_input(int fd)
+bool	check_input(t_vector* lines)
 {
 	int		i;
 	int		j;
-	char	*line;
+	char* line;
 
-	line = NULL;
-	line = get_next_line(fd);
 	j = 0;
-	while (line != NULL)
+	line = NULL;
+	while (j < lines->pfVectorTotal(lines))
 	{
+		line = (char*)lines->pfVectorGet(lines, j);
 		i = -1;
 		while (line[++i])
-			if (!(line[i] >= '0' && line[i] <= '9') && line[i] != '\n')
-				return (free(line), -1);
+			if ((!(line[i] >= '0' && line[i] <= '9') && line[i] != '\n') || i > 5)
+				return (false);
 		if (ft_atoi(line) < 1 || ft_atoi(line) > 10000)
-			return (free(line), -1);
-		free(line);
+			return (false);
 		j++;
-		line = get_next_line(fd);
 	}
-	return (j);
+	return (true);
 }

src/fill_array.c

@@ -1,35 +0,0 @@
-/* ************************************************************************** */
-/*                                                                            */
-/*                                                        :::      ::::::::   */
-/*   fill_array.c                                       :+:      :+:    :+:   */
-/*                                                    +:+ +:+         +:+     */
-/*   By: lud-adam <lud-adam@student.42.fr>          +#+  +:+       +#+        */
-/*                                                +#+#+#+#+#+   +#+           */
-/*   Created: 2026/03/28 13:21:46 by lud-adam          #+#    #+#             */
-/*   Updated: 2026/03/28 20:53:02 by dgaillet         ###   ########lyon.fr   */
-/*                                                                            */
-/* ************************************************************************** */
-
-#include "../libft/libft.h"
-#include "get_next_line.h"
-
-int	*fill_array(int fd, int size)
-{
-	int		*res;
-	char	*line;
-	int		i;
-
-	res = malloc(sizeof(int) * size);
-	if (res == NULL)
-		return (NULL);
-	line = get_next_line(fd);
-	i = 0;
-	while (line != NULL)
-	{
-		res[i] = ft_atoi(line);
-		i++;
-		free(line);
-		line = get_next_line(fd);
-	}
-	return (res);
-}

src/fill_vector.c

@@ -0,0 +1,57 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   fill_vector.c                                      :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: lud-adam <lud-adam@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2026/03/28 13:21:46 by lud-adam          #+#    #+#             */
+/*   Updated: 2026/03/29 16:31:19 by lud-adam         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "../libft/libft.h"
+
+#include "get_next_line.h"
+
+#include "alcu.h"
+#include <stdbool.h>
+
+bool fill_vector(t_vector *lines, int fd) {
+  char *line;
+
+  line = get_next_line(fd);
+  if (!line)
+    return (false);
+  while (line != NULL) {
+    if (!ft_strncmp("\n", line, ft_strlen(line))) {
+      free(line);
+      return (true);
+    }
+    if (lines->pfVectorAdd(lines, line) == UNDEFINE) {
+      free(line);
+      return (false);
+    }
+    line = get_next_line(fd);
+  }
+  return (false);
+}
+
+int *fill_array(t_vector *lines, int *size) {
+  int *res;
+  int i;
+  char *line;
+
+  i = 0;
+  line = NULL;
+  *size = lines->pfVectorTotal(lines);
+  res = malloc(sizeof(int) * *size);
+  if (!res)
+    return (NULL);
+  while (i < *size) {
+    line = (char *)lines->pfVectorGet(lines, i);
+    res[i] = ft_atoi(line);
+    i++;
+  }
+  return (res);
+}

src/game.c

@@ -14,8 +14,7 @@
 #include "alcu.h"
 #include "get_next_line.h"
 
-static int	check_char_int(char *str)
-{
+static int check_char_int(char *str) {
   int i;
 
   i = -1;
@@ -25,66 +24,57 @@ static int	check_char_int(char *str)
   return (1);
 }
 
-static int	play_choice(int *line, int choice)
-{
-	if (choice > 0 && choice < 4)
-	{
-		if (choice > *line)
-		{
+static int play_choice(int *line, int choice) {
+  if (choice > 0 && choice < 4) {
+    if (choice > *line) {
       ft_putstr_fd("-\nInvalid choice\n", 1);
       return (0);
     }
     *line -= choice;
     return (1);
-	}
-	else
-	{
+  } else {
     ft_putstr_fd("-\nInvalid choice\n", 1);
     return (0);
   }
 }
 
-static void	player_turn(int *line)
-{
+static bool player_turn(int *line) {
   char *temp;
   int choice;
 
-	while (1)
-	{
+  while (1) {
     ft_putstr_fd("\nPlease choose between 1 and 3 items\n", 1);
     temp = get_next_line(0);
-		if (temp && ft_strlen(temp) > 0)
-		{
-			if (!check_char_int(temp))
-			{
+    if (!temp)
+      return (false);
+    if (temp && ft_strlen(temp) > 0) {
+      if (!check_char_int(temp)) {
         free(temp);
-				continue ;
+        continue;
       }
       choice = ft_atoi(temp);
       if (play_choice(line, choice))
-				break ;
-		}
-		else
+        break;
+    } else
       ft_putstr_fd("-\nInvalid choice\n", 1);
     if (temp)
       free(temp);
   }
+  if (temp)
+    free(temp);
+  return (true);
 }
 
-static void	play_turns(int *lines, int i, int *ai_turn, int size)
-{
+static bool play_turns(int *lines, int i, int *ai_turn, int size) {
   int choice;
 
-	while (lines[i] != 0)
-	{
+  while (lines[i] != 0) {
     ft_putstr_fd("\n------------------------------\n", 1);
-		if (!*ai_turn)
-		{
+    if (!*ai_turn) {
       print_board(lines, size);
-			player_turn(&lines[i]);
-		}
-		else
-		{
+      if (player_turn(&lines[i]) == false)
+        return (false);
+    } else {
       print_board(lines, size);
       ft_putstr_fd("\n", 1);
       choice = ai(lines, size);
@@ -95,22 +85,23 @@ static void	play_turns(int *lines, int i, int *ai_turn, int size)
     }
     *ai_turn = *ai_turn == 0;
   }
+  return (true);
 }
 
-void	game(int *lines, int size)
-{
+bool game(int *lines, int size) {
   int ai_turn;
   int i;
 
   ai_turn = 1;
   i = size - 1;
-	while (i >= 0)
-	{
-		play_turns(lines, i, &ai_turn, size);
+  while (i >= 0) {
+    if (play_turns(lines, i, &ai_turn, size) == false)
+      return (false);
     i--;
   }
   if (!ai_turn)
     ft_putstr_fd("AI win ! It will replace you\n", 1);
   else
     ft_putstr_fd("You win ! Well done\n", 1);
+  return (true);
 }

src/get_next_line.c

@@ -10,11 +10,10 @@
 /*                                                                            */
 /* ************************************************************************** */
 
-#include "../libft/libft.h"
 #include "get_next_line.h"
+#include "../libft/libft.h"
 
-size_t	ft_strlen_with_c(char *str, char c)
-{
+size_t ft_strlen_with_c(char *str, char c) {
   size_t i;
 
   i = 0;
@@ -25,15 +24,13 @@ size_t	ft_strlen_with_c(char *str, char c)
   return (i);
 }
 
-size_t	detect_newline(char *str)
-{
+size_t detect_newline(char *str) {
   size_t i;
 
   i = 0;
   if (!str)
     return (0);
-	while (str[i])
-	{
+  while (str[i]) {
     if (str[i] == '\n')
       return (1);
     i++;
@@ -41,20 +38,17 @@ size_t	detect_newline(char *str)
   return (0);
 }
 
-static void	fill_line(char *line, char *c_remaining, char *src, size_t *index)
-{
+static void fill_line(char *line, char *c_remaining, char *src, size_t *index) {
   size_t i;
   size_t j;
 
   i = 0;
   j = 0;
-	while (c_remaining && c_remaining[i])
-	{
+  while (c_remaining && c_remaining[i]) {
     line[i] = c_remaining[i];
     i++;
   }
-	while (src[j] && src[j] != '\n')
-	{
+  while (src[j] && src[j] != '\n') {
     line[i + j] = src[j];
     src[j] = 0;
     j++;
@@ -64,18 +58,16 @@ static void	fill_line(char *line, char *c_remaining, char *src, size_t *index)
   *index = j;
 }
 
-char	*build_line(char *src, char *c_remaining, size_t *index)
-{
+char *build_line(char *src, char *c_remaining, size_t *index) {
   char *line;
   size_t size;
   size_t is_jump;
 
   is_jump = detect_newline(src);
-	size = ft_strlen_with_c(src, '\n') + ft_strlen_with_c(c_remaining, '\0')
-		+ is_jump + 1;
+  size = ft_strlen_with_c(src, '\n') + ft_strlen_with_c(c_remaining, '\0') +
+         is_jump + 1;
   line = ft_calloc(size, sizeof(char));
-	if (!line)
-	{
+  if (!line) {
     free(c_remaining);
     return (NULL);
   }
@@ -87,16 +79,14 @@ char	*build_line(char *src, char *c_remaining, size_t *index)
   return (line);
 }
 
-static void	read_file(int fd, char *buffer, ssize_t *nb_read)
-{
+static void read_file(int fd, char *buffer, ssize_t *nb_read) {
   *nb_read = read(fd, buffer, BUFFER_SIZE);
   if (*nb_read < 0)
-		return ;
+    return;
   buffer[*nb_read] = '\0';
 }
 
-static char	*get_the_line(int fd, char *buffer)
-{
+static char *get_the_line(int fd, char *buffer) {
   char *line;
   size_t i;
   ssize_t nb_read;
@@ -104,28 +94,25 @@ static char	*get_the_line(int fd, char *buffer)
   i = 0;
   nb_read = 0;
   line = NULL;
-	if (buffer[0] != '\0')
-	{
+  if (buffer[0] != '\0') {
     line = build_line(buffer, NULL, &i);
     if (!line)
       return (NULL);
     ft_memcpy(buffer, buffer + i + 1, ft_strlen_with_c(buffer + i, '\0'));
   }
-	while (detect_newline(line) == 0)
-	{
+  while (detect_newline(line) == 0) {
     read_file(fd, buffer, &nb_read);
     if (nb_read < 0)
       return (free(line), NULL);
     if (nb_read == 0)
-			break ;
+      break;
     line = build_line(buffer, line, &i);
     ft_memcpy(buffer, buffer + i + 1, ft_strlen_with_c(buffer + i, '\0'));
   }
   return (line);
 }
 
-char	*get_next_line(int fd)
-{
+char *get_next_line(int fd) {
   static char buffer[BUFFER_SIZE + 1] = "";
   char *line;
 

src/main.c

@@ -6,53 +6,64 @@
 /*   By: lud-adam <lud-adam@student.42.fr>          +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2026/03/28 12:30:29 by lud-adam          #+#    #+#             */
-/*   Updated: 2026/03/28 21:41:29 by dgaillet         ###   ########lyon.fr   */
+/*   Updated: 2026/03/29 16:31:17 by lud-adam         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
 #include "../libft/libft.h"
 #include "alcu.h"
+
 #include <fcntl.h>
-#include <stdlib.h>
 #include <unistd.h>
 
-static int	get_fd(int argc, char **argv)
-{
-	if (argc == 2)
-	{
+static int get_fd(int argc, char **argv) {
+  if (argc == 2) {
     return (open(argv[1], O_RDONLY));
-	}
-	else if (argc == 1)
+  } else if (argc == 1)
     return (0);
   else
     return (-1);
 }
 
-int	main(int argc, char *argv[])
-{
+int main(int argc, char *argv[]) {
+
   int fd;
   int size;
-	int	*lines;
+  int *lines_int;
+  t_vector lines;
 
+  if (vector_init(&lines) == false) {
+    ft_putstr_fd("ERROR\n", 2);
+    return (1);
+  }
   fd = get_fd(argc, argv);
-	if (fd < 0)
-	{
-		ft_putstr_fd("ERROR", 2);
+  lines_int = NULL;
+  size = 0;
+  if (fd < 0 || fill_vector(&lines, fd) == false) {
+    lines.pfVectorFree(&lines);
+    ft_putstr_fd("ERROR\n", 2);
     return (1);
   }
-	size = check_input(fd);
-	if (size < 0)
-	{
-		ft_putstr_fd("ERROR", 2);
+  if (check_input(&lines) == false) {
+    lines.pfVectorFree(&lines);
+    ft_putstr_fd("ERROR\n", 2);
+    return (1);
+  }
+  lines_int = fill_array(&lines, &size);
+  lines.pfVectorFree(&lines);
+  if (!lines_int) {
+    lines.pfVectorFree(&lines);
+    ft_putstr_fd("ERROR\n", 2);
     return (1);
   }
   close(fd);
-	fd = open(argv[1], O_RDONLY);
-	lines = fill_array(fd, size);
-	if (!lines)
+  if (open("/dev/tty", O_RDONLY) < 0 || game(lines_int, size) == false) {
+    free(lines_int);
+    ft_putstr_fd("ERROR\n", 2);
     return (1);
-	game(lines, size);
+  }
+  if (fd != 0)
     close(fd);
-	free(lines);
+  free(lines_int);
   return (0);
 }

src/vector.c

@@ -0,0 +1,140 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   vector.c                                           :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: lud-adam <lud-adam@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2026/03/29 14:23:01 by lud-adam          #+#    #+#             */
+/*   Updated: 2026/03/29 14:50:19 by lud-adam         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "vector.h"
+#include "libft.h"
+#include <stdbool.h>
+#include <stdlib.h>
+#include <string.h>
+
+int vector_resize(t_vector *v, int capacity);
+int vector_push_back(t_vector *v, void *item);
+int vector_set(t_vector *v, int index, void *item);
+void *vector_get(t_vector *v, int index);
+int vector_delete(t_vector *v, int index);
+int vector_free(t_vector *v);
+int vector_total(t_vector *v);
+
+bool vector_init(t_vector *v) {
+  v->pfVectorTotal = vector_total;
+  v->pfVectorResize = vector_resize;
+  v->pfVectorAdd = vector_push_back;
+  v->pfVectorSet = vector_set;
+  v->pfVectorGet = vector_get;
+  v->pfVectorFree = vector_free;
+  v->pfVectorDelete = vector_delete;
+  v->vector_list.capacity = VECTOR_INIT_CAPACITY;
+  v->vector_list.total = 0;
+  v->vector_list.items = malloc(sizeof(void *) * v->vector_list.capacity);
+  if (!v->vector_list.items) {
+    ft_putstr_fd("Memory allocation failed in vector_init\n", 2);
+    return (false);
+  }
+  return (true);
+}
+
+int vector_total(t_vector *v) {
+  int totalCount = UNDEFINE;
+  if (v) {
+    totalCount = v->vector_list.total;
+  }
+  return totalCount;
+}
+
+int vector_resize(t_vector *v, int capacity) {
+  int status = UNDEFINE;
+  if (v) {
+    void **items_copy = malloc(sizeof(void *) * capacity);
+    if (!items_copy)
+      return (status);
+    ft_memcpy(items_copy, v->vector_list.items,
+              sizeof(void *) * v->pfVectorTotal(v));
+    if (items_copy) {
+      free(v->vector_list.items);
+      v->vector_list.items = items_copy;
+      v->vector_list.capacity = capacity;
+      status = SUCCESS;
+    }
+  }
+  return (status);
+}
+
+int vector_push_back(t_vector *v, void *item) {
+  int status = UNDEFINE;
+  if (v) {
+    if (v->vector_list.capacity == v->vector_list.total) {
+      status = vector_resize(v, v->vector_list.capacity * 2);
+      if (status != UNDEFINE) {
+        v->vector_list.items[v->vector_list.total++] = item;
+      }
+    } else {
+      v->vector_list.items[v->vector_list.total++] = item;
+      status = SUCCESS;
+    }
+  }
+  return status;
+}
+
+int vector_set(t_vector *v, int index, void *item) {
+  int status = UNDEFINE;
+  if (v) {
+    if ((index >= 0) && (index < v->vector_list.total)) {
+      v->vector_list.items[index] = item;
+      status = SUCCESS;
+    }
+  }
+  return status;
+}
+
+void *vector_get(t_vector *v, int index) {
+  void *readData = NULL;
+  if (v) {
+    if ((index >= 0) && (index < v->vector_list.total)) {
+      readData = v->vector_list.items[index];
+    }
+  }
+  return readData;
+}
+
+int vector_delete(t_vector *v, int index) {
+  int status = UNDEFINE;
+  int i = 0;
+  if (v) {
+    if ((index < 0) || (index >= v->vector_list.total))
+      return status;
+    v->vector_list.items[index] = NULL;
+    for (i = index; (i < v->vector_list.total - 1); ++i) {
+      v->vector_list.items[i] = v->vector_list.items[i + 1];
+      v->vector_list.items[i + 1] = NULL;
+    }
+    v->vector_list.total--;
+    if ((v->vector_list.total > 0) &&
+        ((v->vector_list.total) == (v->vector_list.capacity / 4))) {
+      vector_resize(v, v->vector_list.capacity / 2);
+    }
+    status = SUCCESS;
+  }
+  return status;
+}
+
+int vector_free(t_vector *v) {
+  int status = UNDEFINE;
+  int total = v->pfVectorTotal(v);
+  if (v) {
+    for (int i = 0; i < total; i++) {
+      void *temp = v->pfVectorGet(v, i);
+      free(temp);
+    }
+    free(v->vector_list.items);
+  }
+  return status;
+}