Let's break it down, albeit my C skills are somewhat rusty. Edits are welcome :)

void    *ft_memset(void *b, int c, size_t len)
{
    size_t i;

    i = 0;
    while (i < len)
    {
        ((unsigned char *)b)[i] = c;
        i++;
    }
    return (b);
}

First, you have declared a function called ft_memset which returns void *.

void * means a pointer to any object. It's just a number, pointing to a memory address. But we do not know what's in it because it's not properly annotated.

Your function takes three arguments: b which is a pointer to anything (or void pointer if you will) c which is an int 32-bit signed integer number. len which is a size_t which is usually an alias to an unsigned integer. Read more about size_t over here

Your function iterates through the first len bytes and sets the c's value to those.

We're basically overwriting b's contents for the first len bytes.

Now, what does ((unsigned char*)b) mean. This statement is casting your void * to an unsigned char* (byte pointer), this is just telling the compiler that we're gonna deal with the contents pointed by b as if they were just a unsigned char.

Later we're just indexing on the i-th position and setting the value c in it.

There's a good chance that you're doing this to a string that you have obtained with fgets or a similar input function. In that case, it may well have the newline at the end still.

If you change your code temporarily to:

void xyz (char *number) {
    int i = 0, length = strlen (number);
    while (i < length)
        printf ("Number[%d]: %c (%d)", i, number[i], number[i]);
        i++;
    }
}

that should also show the numeric codes for all characters.

The problem with encoding something like that - 2 in your function is that it will not work with:

xyz ("123");

since it will stop early, printing out only 12. The caller should be calling with valid data, meaning that it should adjust the value to be a numeric string before calling.

You can see this happening in the following program:

#include <stdio.h>
#include <string.h>

void xyz (char *number) {
    int i = 0, length = strlen(number) - 2;
    while(i <= length)
    {
        printf("Number[%d]: %c (%d)\n",i, number[i], number[i]);
        i++;
    }
    puts ("===");
}

void xyz2 (char *number) {
    int i = 0, length = strlen(number);
    while(i < length)
    {
        printf("Number[%d]: %c (%d)\n",i, number[i], number[i]);
        i++;
    }
    puts ("===");
}

int main (void) {
    char buff[100];
    printf ("Enter number: ");
    fgets (buff, sizeof (buff), stdin);
    xyz (buff);
    xyz ("12345");
    xyz2 (buff);
    xyz2 ("12345");
    return 0;
}

The (annoted) output of this, if you enter 98765, is:

Enter number: 98765
Number[0]: 9 (57)
Number[1]: 8 (56)
Number[2]: 7 (55)  # Your adjustment works here because of the newline.
Number[3]: 6 (54)
Number[4]: 5 (53)
===
Number[0]: 1 (49)
Number[1]: 2 (50)
Number[2]: 3 (51)  # But not here, since it skips last character.
Number[3]: 4 (52)
===
Number[0]: 9 (57)
Number[1]: 8 (56)
Number[2]: 7 (55)  # Here you can see the newline (code 10).
Number[3]: 6 (54)
Number[4]: 5 (53)
Number[5]:
 (10)
===
Number[0]: 1 (49)
Number[1]: 2 (50)
Number[2]: 3 (51)  # And proper numeric strings work okay.
Number[3]: 4 (52)
Number[4]: 5 (53)
===

If you're looking for a robust user input function that gets around this problem (and avoids dangerous things like unbounded scanf("%s") and gets), I have one elsewhere on SO (right HERE, in fact) drawn from my arsenal.

This is called "loop unrolling" and is done purely for performance reasons. Modern compilers are perfectly good at doing their own loop unrolling, so doing it manually is likely going to hurt performance relative to the compiler's generated code.

char test_string[5];

test_string is an array of 5 uninitialized char objects.

for (init = 0; init < strlen(test_string); init++)

Kaboom. strlen scans for the first '\0' null character. Since the contents of test_string are garbage, the behavior is undefined. It might return a small value if there happens to be a null character, or a large value or program crash if there don't happen to be any zero bytes in test_string.

Even if that weren't the case, evaluating strlen() in the header of a for loop is inefficient. Each strlen() call has to re-scan the entire string (assuming you've given it a valid string), so if your loop worked it would be O(N²).

If you want test_string to contain just zero bytes, you can initialize it that way:

char test_string[5] = "";

or, since you initialize the first 4 bytes later:

char test_string[5] = "TEST";

or just:

char test_string[] = "TEST";

(The latter lets the compiler figure out that it needs 5 bytes.)

Going back to your declarations:

char test_string2[] = { 'G', 'O', '_', 'T', 'E', 'S', 'T'};

This causes test_string2 to be 7 bytes long, without a trailing '\0' character. That means that passing test_string2 to any function that expects a pointer to a string will cause undefined behavior. You probably want something like:

char test_string2[] = "GO_TEST";

It doesn't use the preprocessor, but sizeof is resolved at compile time. If your string is in an array, you can use that to determine its length at compile time:

static const char string[] = "bob";
#define STRLEN(s) (sizeof(s)/sizeof(s[0]))

Keep in mind the fact that STRLEN above will include the null terminator, unlike strlen().

For starters you should not name your user-defined functions the same ways as standard C functions.

There is already standard C function with the name atoi declared in header <stdlib.h>. Using the same name can result in compiler or linker errors.

Your function atoi declared like

int atoi(const char *s[]){

that is the same as

int atoi(const char **s){

due to adjusting by the compiler a parameter having an array type to pointer to the array element type accepts a "double" pointer. So using the function strlen with the double pointer invokes undefined behavior

printf(" The length is  %d",strlen(s));

The function strlen expects an argument of the type char * or const char * but not an argument of the type const char **.

Moreover the return value of the function strlen has the type size_t. And using the conversion specifier %d in a call of printf with a corresponding argument expression of the type size_t again invokes undefined behavior. You have to use the conversion specifier %zu instead of %d.

This for loop

for(int i = 0; i< length; ++i){
    printf("This is %s",*(s+i));
}

does not make sense because the variable length actually does not contain the number of elements in the passed array.

You need either explicitly to pass the number of elements in the array or the array should have a sentinel value.

And the return type of the function int also does not make sense because the returned value 0 reports nothing useful to the caller of the function.

If the function is designed only to traverse a string in a for loop then it should be declared like for example

char * func( const char *s )
{
    for ( const char *p = s; *p != '\0'; ++p )
    {
        putchar( *p );
    }

    return ( char * )s;
}

If you want to pass to the function an array of strings then the function can be implemented for example the following way as shown in the demonstration program below provided that the array contains a sentinel value

#include <stdio.h>

void func( const char **s )
{
    for ( ; *s != NULL; ++s )
    {
        printf( "%s ", *s );
    }
}

int main( void )
{
    const char * s[] = { "Hello", "World!", NULL );        

    func( s );
    putchar( '\n' );
}

The program output is

Hello World!

Why is there an empty while loop? The loop increments eos until it points to the location directly after the null terminator. The expression *eos++ is very compact way of telling your computer to get the char value eos is currently pointing to, and then increment eos so it points at the next char. There is no need for a body in this while loop.

Why does it use a local variable? Since we are incrementing a pointer (i.e. eos), and we also need a pointer to the beginning of the string in the final computation (i.e. str), we can't simply use str for everything. We need at least one other variable to get the job done.

How does the last line work? The expression eos - str does pointer subtraction, so it calculates the distance between those two pointers and returns that as an integer. Then we subtract 1 to make the answer correct.