You should assign an array of char pointers, and then, for each pointer assign enough memory for the string:

char **orderedIds;

orderedIds = malloc(variableNumberOfElements * sizeof(char*));
for (int i = 0; i < variableNumberOfElements; i++)
    orderedIds[i] = malloc((ID_LEN+1) * sizeof(char)); // yeah, I know sizeof(char) is 1, but to make it clear...

Seems like a good way to me. Although you perform many mallocs, you clearly assign memory for a specific string, and you can free one block of memory without freeing the whole "string array"

You know from the start you will have number strings to store so you will need an array of size number to store a pointer to each string.

You can use malloc to dynamically allocate enough memory for number char pointers:

char** strings = malloc(number * sizeof(char*));

Now you can loop number times and allocate each string dynamically:

for (int i = 0; i < number; i++) {
   // Get length of string
   printf("Enter the length of string %d: ", i);
   int length = 0;
   scanf("%d", &length);

   // Clear stdin for next input
   int c = getchar(); while (c != '\n' && c != EOF) c = getchar();

   // Allocate "length" characters and read in string
   printf("Please enter string %d: ", i);
   strings[i] = malloc(length * sizeof(char));
   fgets(strings[i], length, stdin);
}

You cannot store an array of strings in C, as a string is a variable-length datastructure, not a simple type.
So, decide what you want:

1. An array of fixed-length buffers storing strings of fixed (maximum) length.

   char (*p)[MAX_LEN] = malloc(n * sizeof *p);
   // Store the strings at p[0], p[1], …, p[n - 1]
   

2. A buffer storing any number of strings consecutively.

   char* p = malloc(sum_of_string_lengths + count_of_strings);
   // Now fill in the strings one after the other, including Terminator
   

3. An array of pointers to strings.

   char** p = malloc(n * sizeof *p);
   p[0] = strdup(source[0]);
   // ...
   // p[n - 1] = ...
   

   With strdup() the common utility-function defined like:

   char* strdup(const char* s) {
       size_t n = strlen(s) + 1;
       char* r = malloc(n);
       if (r)
           memcpy(r, s, n);
       return r;
   }
   

I think you need to try and understand yourself what you are trying to achieve. You don't need the key[2] array and I think you are confusing yourself there as you don't yet understand how pointers work. The following should work (untested)

// Allow a password up to 99 characters long + room for null char
char password[100];
// pointer to malloc storage for password
char *key;   
int textlen, keylen, i, j, k, t, s = 0;

// Prompt user for password
printf("password:\n") ;   
scanf("%s",password);

// Determine the length of the users password, including null character room
keylen = strlen(password) + 1;

// Copy password into dynamically allocated storage
key = (char*)malloc(keylen * sizeof(char));
strcpy(key, password);

// Print the password
printf("The key is:\n\t %s", key);

NOTE: My examples are not checking for NULL returns from malloc()... you really should do that though; you will crash if you try to use a NULL pointer.

First you have to create an array of char pointers, one for each string (char *):

char **array = malloc(totalstrings * sizeof(char *));

Next you need to allocate space for each string:

int i;
for (i = 0; i < totalstrings; ++i) {
    array[i] = (char *)malloc(stringsize+1);
}

When you're done using the array, you must remember to free() each of the pointers you've allocated. That is, loop through the array calling free() on each of its elements, and finally free(array) as well.

You want to allocate an array of strings, in other words an array of pointers to characters, and that's exactly what you do allocate. The problem is that you assign the pointer returned by calloc to an array of characters.

You have two choices here actually: Either change your declaration of array to be an "array" pointers to character, e.g. char **array, and then dynamically allocate the individual strings as well. Something like this

// Allocate an array of pointers
char **array = calloc(N, sizeof(*array));

// Allocate and read all strings
for (size_t i = 0; i < N; ++i)
{
    // Allocate 50 characters
    array[i] = malloc(50);  // No need for `sizeof(char)`, it's always 1

    // Read up to 49 characters (to leave space for the string terminator)
    scanf("%49s", array[i]);
}

Or you can change the type of array, to be a pointer to fixed-sized "strings", like this

// Define `my_string_type` as an array of 50 characters
typedef char my_string_type[50];

// Declare a pointer to strings, and allocate it
my_string_type *array = calloc(N, sizeof(*array));

// Read all strings from the user
for (size_t i = 0; i < N; ++i)
{
    // Read up to 49 characters (to leave space for the string terminator)
    scanf("%49s", array[i]);
}

Note that I don't cast the result of calloc or malloc. You should never cast void * in C.