Separating a long string into individual words in C

What I'm trying to do is, given a string (say "This is a string") write a code that could take it and put each word in a separate element of an array ("This", "is", "a", "string"). I scribbled something like that:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main()
{
  char bigString[1000];
  scanf("%s", bigString);
  char wordCollection[10][100];
  int bigIndex=0;
  int smallIndex=0;
  for (int i = 0; i<10; i++)
  {
      while (bigString[bigIndex]!=' ' && bigString[bigIndex]!='
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main()
{
char bigString[1000];
scanf("%s", bigString);
char wordCollection[10][100];
int bigIndex=0;
int smallIndex=0;
for (int i = 0; i<10; i++)
{
while (bigString[bigIndex]!=' ' && bigString[bigIndex]!='\0')
{
wordCollection[i][smallIndex] = bigString[bigIndex];
bigIndex++;
smallIndex++;
}
if (bigString[bigIndex]=='\0') i=10;
bigIndex++;
smallIndex=0;
printf("%s", wordCollection[i]);
}
}
')
      {
          wordCollection[i][smallIndex] = bigString[bigIndex];
          bigIndex++;
          smallIndex++;
      }
      if (bigString[bigIndex]=='
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main()
{
char bigString[1000];
scanf("%s", bigString);
char wordCollection[10][100];
int bigIndex=0;
int smallIndex=0;
for (int i = 0; i<10; i++)
{
while (bigString[bigIndex]!=' ' && bigString[bigIndex]!='\0')
{
wordCollection[i][smallIndex] = bigString[bigIndex];
bigIndex++;
smallIndex++;
}
if (bigString[bigIndex]=='\0') i=10;
bigIndex++;
smallIndex=0;
printf("%s", wordCollection[i]);
}
}
') i=10;
      bigIndex++;
      smallIndex=0;
      printf("%s", wordCollection[i]);
  }
}

Unfortunately, it doesn't act as needed (printing out some gibberish). I tried debugging it but I still don't understand why it wouldn't function properly. Guidance would be very helpful
Also - if you have a more efficient idea, say one involving pointers, I would be more than thrilled to see it.

You are not null terminating the words in wordCollection

Add a wordCollection[i][smallIndex] = '\0 after the while, e.g.:

      while (bigString[bigIndex]!=' ' && bigString[bigIndex]!='\0')
      {
          wordCollection[i][smallIndex] = bigString[bigIndex];
          bigIndex++;
          smallIndex++;
      }
      wordCollection[i][smallIndex] = '\0';

You should also check sizes, remember that a null terminated string occupies one more char than the string length.

Also, setting i=10 before the printf will make the last printf print gibberish, because you didn't put anything there if there were less than 10 words. Even worst, it could give a segmentation fault, because the last index of the wordCollection array is 9.

For starters this call of scanf

scanf("%s", bigString);

is unsafe and can read only one word.

Instead you can use standard function fgets.

If a space character is encountered then this while loop

while (bigString[bigIndex]!=' ' && bigString[bigIndex]!='
while (bigString[bigIndex]!=' ' && bigString[bigIndex]!='
while (bigString[bigIndex]!=' ' && bigString[bigIndex]!='\0')
')
')

is skipped. In this case an element with the index i of the two-dimensional character array will not be filled by a string. As a result this call of printf

printf("%s", wordCollection[i]);

invokes undefined behavior. And moreover if there are several adjacent spaces in the record and the number of words in the string is even less than 10 it can occur such a way that neither word will be outputted.

Also you need to append each element of the array wordCollection that was filled with the terminating zero character '\0' to make a string.

And this pair of statements

  if (bigString[bigIndex]=='
  if (bigString[bigIndex]=='
  if (bigString[bigIndex]=='\0') i=10;
//...
printf("%s", wordCollection[i]);
') i=10;
  //...
  printf("%s", wordCollection[i]);
') i=10;
  //...
  printf("%s", wordCollection[i]);

again invokes undefined behavior because 10 is an invalid index.

Instead of the manually written while loop you could use standard C string functions.

And pay attention to that in general words can be separated by several adjacent spaces of tab characters.

Here is a demonstration program.

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

int main( void )
{
	enum { MAX_STRING_LEN = 1000, WORD_COUNT = 10, MAX_WORD_LEN = 100 };

	char bigString[MAX_STRING_LEN];
	char wordCollection[WORD_COUNT][MAX_WORD_LEN];

	size_t count = 0;

	if (fgets( bigString, MAX_STRING_LEN, stdin ) != NULL)
	{
		bigString[strcspn( bigString, "\n" )] = '
#include <stdio.h>
#include <string.h>

int main( void )
{
	enum { MAX_STRING_LEN = 1000, WORD_COUNT = 10, MAX_WORD_LEN = 100 };

	char bigString[MAX_STRING_LEN];
	char wordCollection[WORD_COUNT][MAX_WORD_LEN];

	size_t count = 0;

	if (fgets( bigString, MAX_STRING_LEN, stdin ) != NULL)
	{
		bigString[strcspn( bigString, "\n" )] = '
#include <stdio.h>
#include <string.h>
int main( void )
{
enum { MAX_STRING_LEN = 1000, WORD_COUNT = 10, MAX_WORD_LEN = 100 };
char bigString[MAX_STRING_LEN];
char wordCollection[WORD_COUNT][MAX_WORD_LEN];
size_t count = 0;
if (fgets( bigString, MAX_STRING_LEN, stdin ) != NULL)
{
bigString[strcspn( bigString, "\n" )] = '\0';
const char *delim = " \t";
for (const char *p = bigString; *p != '\0' && count < WORD_COUNT; )
{
p += strspn( p, delim );
if (*p != '\0')
{
size_t n = strcspn( p, delim );
size_t len = n < MAX_WORD_LEN ? n : MAX_WORD_LEN - 1;
memcpy( wordCollection[count], p, len );
wordCollection[count][len] = '\0';
++count;
p += n;
}
}
for (size_t i = 0; i < count; i++)
{
puts( wordCollection[i] );
}
}
}
';

		const char *delim = " \t";

		for (const char *p = bigString; *p != '
#include <stdio.h>
#include <string.h>
int main( void )
{
enum { MAX_STRING_LEN = 1000, WORD_COUNT = 10, MAX_WORD_LEN = 100 };
char bigString[MAX_STRING_LEN];
char wordCollection[WORD_COUNT][MAX_WORD_LEN];
size_t count = 0;
if (fgets( bigString, MAX_STRING_LEN, stdin ) != NULL)
{
bigString[strcspn( bigString, "\n" )] = '\0';
const char *delim = " \t";
for (const char *p = bigString; *p != '\0' && count < WORD_COUNT; )
{
p += strspn( p, delim );
if (*p != '\0')
{
size_t n = strcspn( p, delim );
size_t len = n < MAX_WORD_LEN ? n : MAX_WORD_LEN - 1;
memcpy( wordCollection[count], p, len );
wordCollection[count][len] = '\0';
++count;
p += n;
}
}
for (size_t i = 0; i < count; i++)
{
puts( wordCollection[i] );
}
}
}
' && count < WORD_COUNT; )
		{
			p += strspn( p, delim );


			if (*p != '
#include <stdio.h>
#include <string.h>
int main( void )
{
enum { MAX_STRING_LEN = 1000, WORD_COUNT = 10, MAX_WORD_LEN = 100 };
char bigString[MAX_STRING_LEN];
char wordCollection[WORD_COUNT][MAX_WORD_LEN];
size_t count = 0;
if (fgets( bigString, MAX_STRING_LEN, stdin ) != NULL)
{
bigString[strcspn( bigString, "\n" )] = '\0';
const char *delim = " \t";
for (const char *p = bigString; *p != '\0' && count < WORD_COUNT; )
{
p += strspn( p, delim );
if (*p != '\0')
{
size_t n = strcspn( p, delim );
size_t len = n < MAX_WORD_LEN ? n : MAX_WORD_LEN - 1;
memcpy( wordCollection[count], p, len );
wordCollection[count][len] = '\0';
++count;
p += n;
}
}
for (size_t i = 0; i < count; i++)
{
puts( wordCollection[i] );
}
}
}
')
			{
				size_t n = strcspn( p, delim );

				size_t len = n < MAX_WORD_LEN ? n : MAX_WORD_LEN - 1;

				memcpy( wordCollection[count], p, len );
				wordCollection[count][len] = '
#include <stdio.h>
#include <string.h>
int main( void )
{
enum { MAX_STRING_LEN = 1000, WORD_COUNT = 10, MAX_WORD_LEN = 100 };
char bigString[MAX_STRING_LEN];
char wordCollection[WORD_COUNT][MAX_WORD_LEN];
size_t count = 0;
if (fgets( bigString, MAX_STRING_LEN, stdin ) != NULL)
{
bigString[strcspn( bigString, "\n" )] = '\0';
const char *delim = " \t";
for (const char *p = bigString; *p != '\0' && count < WORD_COUNT; )
{
p += strspn( p, delim );
if (*p != '\0')
{
size_t n = strcspn( p, delim );
size_t len = n < MAX_WORD_LEN ? n : MAX_WORD_LEN - 1;
memcpy( wordCollection[count], p, len );
wordCollection[count][len] = '\0';
++count;
p += n;
}
}
for (size_t i = 0; i < count; i++)
{
puts( wordCollection[i] );
}
}
}
';
				
				++count;

				p += n;
			}
		}

		for (size_t i = 0; i < count; i++)
		{
			puts( wordCollection[i] );
		}
	}
}
';

		const char *delim = " \t";

		for (const char *p = bigString; *p != '
#include <stdio.h>
#include <string.h>

int main( void )
{
	enum { MAX_STRING_LEN = 1000, WORD_COUNT = 10, MAX_WORD_LEN = 100 };

	char bigString[MAX_STRING_LEN];
	char wordCollection[WORD_COUNT][MAX_WORD_LEN];

	size_t count = 0;

	if (fgets( bigString, MAX_STRING_LEN, stdin ) != NULL)
	{
		bigString[strcspn( bigString, "\n" )] = '
#include <stdio.h>
#include <string.h>
int main( void )
{
enum { MAX_STRING_LEN = 1000, WORD_COUNT = 10, MAX_WORD_LEN = 100 };
char bigString[MAX_STRING_LEN];
char wordCollection[WORD_COUNT][MAX_WORD_LEN];
size_t count = 0;
if (fgets( bigString, MAX_STRING_LEN, stdin ) != NULL)
{
bigString[strcspn( bigString, "\n" )] = '\0';
const char *delim = " \t";
for (const char *p = bigString; *p != '\0' && count < WORD_COUNT; )
{
p += strspn( p, delim );
if (*p != '\0')
{
size_t n = strcspn( p, delim );
size_t len = n < MAX_WORD_LEN ? n : MAX_WORD_LEN - 1;
memcpy( wordCollection[count], p, len );
wordCollection[count][len] = '\0';
++count;
p += n;
}
}
for (size_t i = 0; i < count; i++)
{
puts( wordCollection[i] );
}
}
}
';

		const char *delim = " \t";

		for (const char *p = bigString; *p != '
#include <stdio.h>
#include <string.h>
int main( void )
{
enum { MAX_STRING_LEN = 1000, WORD_COUNT = 10, MAX_WORD_LEN = 100 };
char bigString[MAX_STRING_LEN];
char wordCollection[WORD_COUNT][MAX_WORD_LEN];
size_t count = 0;
if (fgets( bigString, MAX_STRING_LEN, stdin ) != NULL)
{
bigString[strcspn( bigString, "\n" )] = '\0';
const char *delim = " \t";
for (const char *p = bigString; *p != '\0' && count < WORD_COUNT; )
{
p += strspn( p, delim );
if (*p != '\0')
{
size_t n = strcspn( p, delim );
size_t len = n < MAX_WORD_LEN ? n : MAX_WORD_LEN - 1;
memcpy( wordCollection[count], p, len );
wordCollection[count][len] = '\0';
++count;
p += n;
}
}
for (size_t i = 0; i < count; i++)
{
puts( wordCollection[i] );
}
}
}
' && count < WORD_COUNT; )
		{
			p += strspn( p, delim );


			if (*p != '
#include <stdio.h>
#include <string.h>
int main( void )
{
enum { MAX_STRING_LEN = 1000, WORD_COUNT = 10, MAX_WORD_LEN = 100 };
char bigString[MAX_STRING_LEN];
char wordCollection[WORD_COUNT][MAX_WORD_LEN];
size_t count = 0;
if (fgets( bigString, MAX_STRING_LEN, stdin ) != NULL)
{
bigString[strcspn( bigString, "\n" )] = '\0';
const char *delim = " \t";
for (const char *p = bigString; *p != '\0' && count < WORD_COUNT; )
{
p += strspn( p, delim );
if (*p != '\0')
{
size_t n = strcspn( p, delim );
size_t len = n < MAX_WORD_LEN ? n : MAX_WORD_LEN - 1;
memcpy( wordCollection[count], p, len );
wordCollection[count][len] = '\0';
++count;
p += n;
}
}
for (size_t i = 0; i < count; i++)
{
puts( wordCollection[i] );
}
}
}
')
			{
				size_t n = strcspn( p, delim );

				size_t len = n < MAX_WORD_LEN ? n : MAX_WORD_LEN - 1;

				memcpy( wordCollection[count], p, len );
				wordCollection[count][len] = '
#include <stdio.h>
#include <string.h>
int main( void )
{
enum { MAX_STRING_LEN = 1000, WORD_COUNT = 10, MAX_WORD_LEN = 100 };
char bigString[MAX_STRING_LEN];
char wordCollection[WORD_COUNT][MAX_WORD_LEN];
size_t count = 0;
if (fgets( bigString, MAX_STRING_LEN, stdin ) != NULL)
{
bigString[strcspn( bigString, "\n" )] = '\0';
const char *delim = " \t";
for (const char *p = bigString; *p != '\0' && count < WORD_COUNT; )
{
p += strspn( p, delim );
if (*p != '\0')
{
size_t n = strcspn( p, delim );
size_t len = n < MAX_WORD_LEN ? n : MAX_WORD_LEN - 1;
memcpy( wordCollection[count], p, len );
wordCollection[count][len] = '\0';
++count;
p += n;
}
}
for (size_t i = 0; i < count; i++)
{
puts( wordCollection[i] );
}
}
}
';
				
				++count;

				p += n;
			}
		}

		for (size_t i = 0; i < count; i++)
		{
			puts( wordCollection[i] );
		}
	}
}
' && count < WORD_COUNT; )
		{
			p += strspn( p, delim );


			if (*p != '
#include <stdio.h>
#include <string.h>

int main( void )
{
	enum { MAX_STRING_LEN = 1000, WORD_COUNT = 10, MAX_WORD_LEN = 100 };

	char bigString[MAX_STRING_LEN];
	char wordCollection[WORD_COUNT][MAX_WORD_LEN];

	size_t count = 0;

	if (fgets( bigString, MAX_STRING_LEN, stdin ) != NULL)
	{
		bigString[strcspn( bigString, "\n" )] = '
#include <stdio.h>
#include <string.h>
int main( void )
{
enum { MAX_STRING_LEN = 1000, WORD_COUNT = 10, MAX_WORD_LEN = 100 };
char bigString[MAX_STRING_LEN];
char wordCollection[WORD_COUNT][MAX_WORD_LEN];
size_t count = 0;
if (fgets( bigString, MAX_STRING_LEN, stdin ) != NULL)
{
bigString[strcspn( bigString, "\n" )] = '\0';
const char *delim = " \t";
for (const char *p = bigString; *p != '\0' && count < WORD_COUNT; )
{
p += strspn( p, delim );
if (*p != '\0')
{
size_t n = strcspn( p, delim );
size_t len = n < MAX_WORD_LEN ? n : MAX_WORD_LEN - 1;
memcpy( wordCollection[count], p, len );
wordCollection[count][len] = '\0';
++count;
p += n;
}
}
for (size_t i = 0; i < count; i++)
{
puts( wordCollection[i] );
}
}
}
';

		const char *delim = " \t";

		for (const char *p = bigString; *p != '
#include <stdio.h>
#include <string.h>
int main( void )
{
enum { MAX_STRING_LEN = 1000, WORD_COUNT = 10, MAX_WORD_LEN = 100 };
char bigString[MAX_STRING_LEN];
char wordCollection[WORD_COUNT][MAX_WORD_LEN];
size_t count = 0;
if (fgets( bigString, MAX_STRING_LEN, stdin ) != NULL)
{
bigString[strcspn( bigString, "\n" )] = '\0';
const char *delim = " \t";
for (const char *p = bigString; *p != '\0' && count < WORD_COUNT; )
{
p += strspn( p, delim );
if (*p != '\0')
{
size_t n = strcspn( p, delim );
size_t len = n < MAX_WORD_LEN ? n : MAX_WORD_LEN - 1;
memcpy( wordCollection[count], p, len );
wordCollection[count][len] = '\0';
++count;
p += n;
}
}
for (size_t i = 0; i < count; i++)
{
puts( wordCollection[i] );
}
}
}
' && count < WORD_COUNT; )
		{
			p += strspn( p, delim );


			if (*p != '
#include <stdio.h>
#include <string.h>
int main( void )
{
enum { MAX_STRING_LEN = 1000, WORD_COUNT = 10, MAX_WORD_LEN = 100 };
char bigString[MAX_STRING_LEN];
char wordCollection[WORD_COUNT][MAX_WORD_LEN];
size_t count = 0;
if (fgets( bigString, MAX_STRING_LEN, stdin ) != NULL)
{
bigString[strcspn( bigString, "\n" )] = '\0';
const char *delim = " \t";
for (const char *p = bigString; *p != '\0' && count < WORD_COUNT; )
{
p += strspn( p, delim );
if (*p != '\0')
{
size_t n = strcspn( p, delim );
size_t len = n < MAX_WORD_LEN ? n : MAX_WORD_LEN - 1;
memcpy( wordCollection[count], p, len );
wordCollection[count][len] = '\0';
++count;
p += n;
}
}
for (size_t i = 0; i < count; i++)
{
puts( wordCollection[i] );
}
}
}
')
			{
				size_t n = strcspn( p, delim );

				size_t len = n < MAX_WORD_LEN ? n : MAX_WORD_LEN - 1;

				memcpy( wordCollection[count], p, len );
				wordCollection[count][len] = '
#include <stdio.h>
#include <string.h>
int main( void )
{
enum { MAX_STRING_LEN = 1000, WORD_COUNT = 10, MAX_WORD_LEN = 100 };
char bigString[MAX_STRING_LEN];
char wordCollection[WORD_COUNT][MAX_WORD_LEN];
size_t count = 0;
if (fgets( bigString, MAX_STRING_LEN, stdin ) != NULL)
{
bigString[strcspn( bigString, "\n" )] = '\0';
const char *delim = " \t";
for (const char *p = bigString; *p != '\0' && count < WORD_COUNT; )
{
p += strspn( p, delim );
if (*p != '\0')
{
size_t n = strcspn( p, delim );
size_t len = n < MAX_WORD_LEN ? n : MAX_WORD_LEN - 1;
memcpy( wordCollection[count], p, len );
wordCollection[count][len] = '\0';
++count;
p += n;
}
}
for (size_t i = 0; i < count; i++)
{
puts( wordCollection[i] );
}
}
}
';
				
				++count;

				p += n;
			}
		}

		for (size_t i = 0; i < count; i++)
		{
			puts( wordCollection[i] );
		}
	}
}
')
			{
				size_t n = strcspn( p, delim );

				size_t len = n < MAX_WORD_LEN ? n : MAX_WORD_LEN - 1;

				memcpy( wordCollection[count], p, len );
				wordCollection[count][len] = '
#include <stdio.h>
#include <string.h>

int main( void )
{
	enum { MAX_STRING_LEN = 1000, WORD_COUNT = 10, MAX_WORD_LEN = 100 };

	char bigString[MAX_STRING_LEN];
	char wordCollection[WORD_COUNT][MAX_WORD_LEN];

	size_t count = 0;

	if (fgets( bigString, MAX_STRING_LEN, stdin ) != NULL)
	{
		bigString[strcspn( bigString, "\n" )] = '
#include <stdio.h>
#include <string.h>
int main( void )
{
enum { MAX_STRING_LEN = 1000, WORD_COUNT = 10, MAX_WORD_LEN = 100 };
char bigString[MAX_STRING_LEN];
char wordCollection[WORD_COUNT][MAX_WORD_LEN];
size_t count = 0;
if (fgets( bigString, MAX_STRING_LEN, stdin ) != NULL)
{
bigString[strcspn( bigString, "\n" )] = '\0';
const char *delim = " \t";
for (const char *p = bigString; *p != '\0' && count < WORD_COUNT; )
{
p += strspn( p, delim );
if (*p != '\0')
{
size_t n = strcspn( p, delim );
size_t len = n < MAX_WORD_LEN ? n : MAX_WORD_LEN - 1;
memcpy( wordCollection[count], p, len );
wordCollection[count][len] = '\0';
++count;
p += n;
}
}
for (size_t i = 0; i < count; i++)
{
puts( wordCollection[i] );
}
}
}
';

		const char *delim = " \t";

		for (const char *p = bigString; *p != '
#include <stdio.h>
#include <string.h>
int main( void )
{
enum { MAX_STRING_LEN = 1000, WORD_COUNT = 10, MAX_WORD_LEN = 100 };
char bigString[MAX_STRING_LEN];
char wordCollection[WORD_COUNT][MAX_WORD_LEN];
size_t count = 0;
if (fgets( bigString, MAX_STRING_LEN, stdin ) != NULL)
{
bigString[strcspn( bigString, "\n" )] = '\0';
const char *delim = " \t";
for (const char *p = bigString; *p != '\0' && count < WORD_COUNT; )
{
p += strspn( p, delim );
if (*p != '\0')
{
size_t n = strcspn( p, delim );
size_t len = n < MAX_WORD_LEN ? n : MAX_WORD_LEN - 1;
memcpy( wordCollection[count], p, len );
wordCollection[count][len] = '\0';
++count;
p += n;
}
}
for (size_t i = 0; i < count; i++)
{
puts( wordCollection[i] );
}
}
}
' && count < WORD_COUNT; )
		{
			p += strspn( p, delim );


			if (*p != '
#include <stdio.h>
#include <string.h>
int main( void )
{
enum { MAX_STRING_LEN = 1000, WORD_COUNT = 10, MAX_WORD_LEN = 100 };
char bigString[MAX_STRING_LEN];
char wordCollection[WORD_COUNT][MAX_WORD_LEN];
size_t count = 0;
if (fgets( bigString, MAX_STRING_LEN, stdin ) != NULL)
{
bigString[strcspn( bigString, "\n" )] = '\0';
const char *delim = " \t";
for (const char *p = bigString; *p != '\0' && count < WORD_COUNT; )
{
p += strspn( p, delim );
if (*p != '\0')
{
size_t n = strcspn( p, delim );
size_t len = n < MAX_WORD_LEN ? n : MAX_WORD_LEN - 1;
memcpy( wordCollection[count], p, len );
wordCollection[count][len] = '\0';
++count;
p += n;
}
}
for (size_t i = 0; i < count; i++)
{
puts( wordCollection[i] );
}
}
}
')
			{
				size_t n = strcspn( p, delim );

				size_t len = n < MAX_WORD_LEN ? n : MAX_WORD_LEN - 1;

				memcpy( wordCollection[count], p, len );
				wordCollection[count][len] = '
#include <stdio.h>
#include <string.h>
int main( void )
{
enum { MAX_STRING_LEN = 1000, WORD_COUNT = 10, MAX_WORD_LEN = 100 };
char bigString[MAX_STRING_LEN];
char wordCollection[WORD_COUNT][MAX_WORD_LEN];
size_t count = 0;
if (fgets( bigString, MAX_STRING_LEN, stdin ) != NULL)
{
bigString[strcspn( bigString, "\n" )] = '\0';
const char *delim = " \t";
for (const char *p = bigString; *p != '\0' && count < WORD_COUNT; )
{
p += strspn( p, delim );
if (*p != '\0')
{
size_t n = strcspn( p, delim );
size_t len = n < MAX_WORD_LEN ? n : MAX_WORD_LEN - 1;
memcpy( wordCollection[count], p, len );
wordCollection[count][len] = '\0';
++count;
p += n;
}
}
for (size_t i = 0; i < count; i++)
{
puts( wordCollection[i] );
}
}
}
';
				
				++count;

				p += n;
			}
		}

		for (size_t i = 0; i < count; i++)
		{
			puts( wordCollection[i] );
		}
	}
}
';
				
				++count;

				p += n;
			}
		}

		for (size_t i = 0; i < count; i++)
		{
			puts( wordCollection[i] );
		}
	}
}

The program output is

This is a string
This
is
a
string

1. Use symbolic constants instead of magic values.
2. scanf("%s", ...) reads white space separated words so bigString will never contain more than 1 word. You can use a "%[^\n]" the format string to read lines (but see next).
3. Always use a maximum field width when reading strings with scanf().
4. Check the return value from scanf() otherwise you might be operating on uninitialized data.
5. I suggest you use fgets() instead of scanf().
6. I suggest you use a single loop instead of the double loop. This means you only have to do boundary checks in one place.
7. (Not fixed) Consider separating print from processing; if you do then the terminating '\0' of bigString is just the normal case, and the break can move to the bottom of the loop.
8. You need to '\0' terminate words; otherwise printf() will be undefined behavior.
9. i=10; followed by wordCollection[i] is out of bounds which means undefined behavior.

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

#define STRING_LEN 1000
#define WORDS 10
#define WORD_LEN 100

int main(void) {
	char bigString[STRING_LEN];
	if(!fgets(bigString, STRING_LEN, stdin)) {
         printf("fgets() failed\n");
         return 1;
    }
	bigString[strcspn(bigString, "\n")] = '
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define STRING_LEN 1000
#define WORDS 10
#define WORD_LEN 100
int main(void) {
char bigString[STRING_LEN];
if(!fgets(bigString, STRING_LEN, stdin)) {
printf("fgets() failed\n");
return 1;
}
bigString[strcspn(bigString, "\n")] = '\0';
char wordCollection[WORDS][WORD_LEN];
int word = 0;
int word_i = 0;
for(int i = 0;; i++) {
if(word_i == WORD_LEN) {
printf("word too big\n");
return 1;
}
if(word == WORDS) {
printf("too many words\n");
return 1;
}
if(bigString[i] == ' ' || !bigString[i]) {
wordCollection[word][word_i] = '\0';
printf("%s\n", wordCollection[word]);
word++;
word_i = 0;
if(!bigString[i])
break;
continue;
}
wordCollection[word][word_i++] = bigString[i];
}
}
';

	char wordCollection[WORDS][WORD_LEN];
	int word = 0;
	int word_i = 0;
	for(int i = 0;; i++) {
		if(word_i == WORD_LEN) {
			printf("word too big\n");
			return 1;
		}
		if(word == WORDS) {
			printf("too many words\n");
			return 1;
		}
		if(bigString[i] == ' ' || !bigString[i]) {
			wordCollection[word][word_i] = '
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define STRING_LEN 1000
#define WORDS 10
#define WORD_LEN 100
int main(void) {
char bigString[STRING_LEN];
if(!fgets(bigString, STRING_LEN, stdin)) {
printf("fgets() failed\n");
return 1;
}
bigString[strcspn(bigString, "\n")] = '\0';
char wordCollection[WORDS][WORD_LEN];
int word = 0;
int word_i = 0;
for(int i = 0;; i++) {
if(word_i == WORD_LEN) {
printf("word too big\n");
return 1;
}
if(word == WORDS) {
printf("too many words\n");
return 1;
}
if(bigString[i] == ' ' || !bigString[i]) {
wordCollection[word][word_i] = '\0';
printf("%s\n", wordCollection[word]);
word++;
word_i = 0;
if(!bigString[i])
break;
continue;
}
wordCollection[word][word_i++] = bigString[i];
}
}
';
			printf("%s\n", wordCollection[word]);
			word++;
			word_i = 0;
			if(!bigString[i])
				break;
			continue;
		}
		wordCollection[word][word_i++] = bigString[i];
	}
}

example run:

hello world
hello
world

1 2 3 4 5 6 7 8 9 10 11
1
2
3
4
5
6
7
8
9
10
too many words

and with WORD_LEN reduced to 10 (not enough space to write the terminating '\0'):

1234567890
word too big