You can use 2D array to store multiple strings. For 10 strings each of length 100

char variable[10][100];

printf("Enter Strings\n");
for (int i = 0; i < 10 ;i++)  
    scanf("%100s", variable[i]); 

Better to use fgets to read string.

fgets(variable[i], sizeof(variable[i]), stdin);  

You can also use dynamic memory allocation by using an array of pointers to char.

How store multiple string or create an array of strings in C, by using 1D array?

The short answer is: You can't

A string in C is by itself a char array (with a zero termination) so there is no way to have multiple strings in a 1D array.

You can make it a 2D array like:

int main()
{
  // Make a 2D array to store
  // 4 strings with 9 as max strlen
  char str[4][10] = {"Linux", "Ubuntu", "Arch", "Void"};

  for (int i=0; i<4; ++i) printf("%s\n", str[i]);
  return 0;
}

Another approach is to use a 1D array of char pointers to string literals - like:

int main()
{
  // Make a 1D array to store
  // 4 char pointers
  char *str[4] = {"Linux", "Ubuntu", "Arch", "Void"};

  for (int i=0; i<4; ++i) printf("%s\n", str[i]);
  return 0;
}

but notice that the strings are not saved in the array. The compiler place the strings somewhere in memory and the array just holds pointers to those strings.

Also notice that in the second example you are not allowed to modify the strings later in the program. In the first example you are allowed to change the strings after the initialization, e.g. doing strcpy(str[0], "Centos");

BTW: This may be of interrest Are string literals const?

You need a 2 dimensional character array to have an array of strings:

#include <stdio.h>

int main()
{
    char strings[3][256];
    scanf("%s %s %s", strings[0], strings[1], strings[2]);
    printf("%s\n%s\n%s\n", strings[0], strings[1], strings[2]);
}

If to place the missed semicolon at the end then this statement

const char temp[] = "GET / HTTP/1.0\r\n"
                    "Host:www.google.com\r\n"
                    "\r\n";

is equivalent to

const char temp[] = "GET / HTTP/1.0\r\nHost:www.google.com\r\n\r\n";

According to the C Standard in the section where translation phases are described there is written

6. Adjacent string literal tokens are concatenated

Sometines it is convinient to split a long string literal that does not fit a line into several shorter adjacent literals.

... requests a multidimensional array where we have for every row of the array a string, and then as an array of pointers.

After getting the qualified number of strings, allocate an array of pointers to char.

if ((n >= 1) && (n <= 20)){
  char **string_list = calloc(n, sizeof *string_list);
  assert(string_list);  // or other error checking

(Notice no type in = calloc(n, sizeof *string_list);. Easier to code right, review and maintain.)

Read the strings in a working temp buffer. As "How many characters per string?" likely means the number of characters not including the null character, our str[] needs a +1 in size.

        // char str[x]; // too small
        char str[x+1];

Yet we know x <= 10 and can use a fixed buffer size and limit input length

      for(int i = 0; i < n; i++){
        char str[10+1];
        printf("Insert a string:");
        scanf("%10s", str);  // Notice the 10 - a width limit

        // TBD check if scanf() returned 1 and if str is longer than x

Now allocate a copy of the str

        string_list[j] = strdup(str);
        assert(string_list[j]);  // or other error checking
      }

Later, when done with string_list[], clean-up and free allocations.

for (int i=0; i<n; i++) {
  free(string_list[i]);
}
free(string_list);

What is weak about this:

It uses scanf() rather than fgets() and then parses, has minimal error checking, does not take in strings with spaces, does not handle over-long input, strdup() is not standard -yet, etc.

So the above is a baby step. Better code would handle the weak issues.

If you don't want to change the strings, then you could simply do

const char *a[2];
a[0] = "blah";
a[1] = "hmm";

When you do it like this you will allocate an array of two pointers to const char. These pointers will then be set to the addresses of the static strings "blah" and "hmm".

If you do want to be able to change the actual string content, the you have to do something like

char a[2][14];
strcpy(a[0], "blah");
strcpy(a[1], "hmm");

This will allocate two consecutive arrays of 14 chars each, after which the content of the static strings will be copied into them.

First: you cannot define an array size with a variable. I mean: char buf[variable]; doesn't work.

You have to do like this:

char **buf;

buf = malloc(sizeof(char) * number_of_strings);
if (buf == NULL)
    return (MALLOC_ERROR);

Or with a macro like this:

// in your header file
#define BUF_SIZE 12
// in your .c file
char *buf[BUF_SIZE];

Then you also have to malloc the 2nd dimension of your array. For example :

int i;

i = 0
while (buf[i])
{
    buf[i] = malloc(sizeof(char) * string_length);
    if (buf[i] == NULL)
        return (MALLOC_ERROR);
    i++;
}

And don't forget to free all dimensions of your array.