# ft_str_split: String Splitting Project in C

## Project Overview
This project-based learning assignment challenges you to implement a function that splits a string into an array of strings based on a specified delimiter character. The project will enhance your understanding of string manipulation, memory allocation, and pointer arithmetic in C.

## Learning Objectives
- Deepen understanding of string manipulation in C
- Practice dynamic memory allocation and management
- Implement robust error handling
- Understand pointer arithmetic and array management
- Develop efficient algorithms for string processing

## Function Prototype
```c
char **ft_str_split(char const *s, char c);
```

### Parameters
- `s`: The string to be split
- `c`: The delimiter character used to identify where the string should be split

### Return Value
- An array of new strings resulting from the split
- NULL if the allocation fails

## Requirements

1. **Function Behavior:**
    - The function must split the string `s` using the character `c` as a delimiter
    - The array must end with a NULL pointer
    - The resulting strings must not contain the delimiter character

2. **Memory Management:**
    - You must allocate memory for the result array and each substring
    - All allocations must be properly handled with error checking
    - No memory leaks are allowed

3. **Edge Cases:**
    - Handle empty strings properly
    - If `c` does not appear in `s`, the result should be an array with a single element containing the entire string
    - If `s` is NULL, return NULL
    - If multiple delimiters appear consecutively, they should result in empty substrings

## Project Steps

### Step 1: Planning the Algorithm
Begin by designing your algorithm. Consider:
- How to count the number of resulting substrings
- How to allocate the right amount of memory
- How to extract each substring efficiently

### Step 2: Implementing Helper Functions
Consider implementing these helper functions:
- `count_words`: Count how many words will result from the split
- `word_length`: Calculate the length of a word until the next delimiter
- `extract_word`: Extract a single word from the source string

### Step 3: Implementing the Main Function
Implement the `ft_str_split` function using your helper functions.

### Step 4: Testing
Create a comprehensive test suite that covers:
- Normal cases with various delimiters
- Edge cases (empty strings, no delimiters, etc.)
- Error cases (memory allocation failures)

## Example Usage

```c
#include <stdio.h>
#include <stdlib.h>

char **ft_str_split(char const *s, char c);

void print_result(char **result) {
     if (!result)
          return;
     
     for (int i = 0; result[i]; i++) {
          printf("'%s'\n", result[i]);
     }
}

void free_result(char **result) {
     if (!result)
          return;
     
     for (int i = 0; result[i]; i++) {
          free(result[i]);
     }
     free(result);
}

int main() {
     char *str = "Hello,world,this,is,a,test";
     char **result = ft_str_split(str, ',');
     
     printf("Original: '%s'\n", str);
     printf("Split by ',': \n");
     print_result(result);
     
     free_result(result);
     return 0;
}
```

## Evaluation Criteria

Your implementation will be evaluated based on:
1. **Correctness**: Does it handle all required cases correctly?
2. **Memory Management**: Are there any memory leaks?
3. **Code Quality**: Is the code clean, well-organized, and properly commented?
4. **Efficiency**: Is the algorithm efficient in terms of time and space complexity?

## Advanced Challenges

Once you've completed the basic implementation, consider these extensions:
1. Modify your function to handle multiple delimiter characters
2. Implement a version that uses a string as a delimiter instead of a single character
3. Create a version that keeps empty substrings as separate entries in the result array
4. Optimize your code for maximum performance with large strings

## Resources

- C string manipulation functions (`strlen`, `strcpy`, etc.)
- Memory allocation functions (`malloc`, `free`)
- Pointer arithmetic in C
- String tokenization techniques

## Conclusion

This project will strengthen your C programming skills, particularly in the areas of string manipulation and memory management. The ability to split strings is a fundamental operation in many programming applications, making this a valuable skill to master.

Good luck with your implementation!