Scan the user input and then work with these letters
You just wrote this program and it's perfectly clear in your mind, imagine to come back after 1 year: you will need to re-read everything to understand what it is doing because everything is in one big function (which is also hard to test, something you will definitely love to have when writing production code).

First of all let's split the logic into smaller functions, do it in small steps:

#define MAX_INPUT_LENGTH 10

int main()
{
    char input[MAX_INPUT_LENGTH + 1] = {0};
    if (!read_input_text(input, MAX_INPUT_LENGTH))
        return EXIT_FAILURE;

    while (1)
    {
        print_menu();

        switch (read_menu_option())
        {
            case 0:
                puts("KONEC PROGRAMU, SEE YOU SOON :) ");
                return EXIT_SUCCESS;
            case 1:
                print_input(input);
                break;
            case 2:
                print_count_lowercase_letters(input);
                break;
            case 3:
                print_digits(input);
                break;
            case 4:
                print_input_toggled(input);
                break;
            default:
                puts("Invalid option.");
        }
    }

    return EXIT_SUCCESS;
}


You can further split this code and menu may be well handled with a dictionary of functions to call (it will be easier to extend) but I think you understand the point. Few things to note:


I initialized input to zero, now you do not need to last_index because you simply can use strlen(). Also to print the string is as simple as puts(input) because you  have a valid null terminated C string (note the extra array item added to hold the string terminator).
Variable-length arrays are a subtle thing, you may avoid them unless they're absolutely required.
I'm using EXIT_SUCCESS instead of 0, it's a small thing but I think it helps to make the intent clear (and it's easier to search...)
I'm using puts() instead of printf() when I simply need to print a string to stdout: it's faster, easier and better communicate the intent (compiler may also detect what you're doing and use puts() for you, BTW).


Now let's examine the core logic. As you can already imagine the input function might be simplified:

bool read_input_text(char* input, size_t maximumLength)
{
    for (size_t i=0; i &lt; maximumnLength; ++i)
    {
        int c = getchar();

        if (c == EOF)
            return false;

        if (c == '.')
            return true;

        input[i] = (char)c;
    }

    return true;
}


Few notes:


I'm using a for loop to read needed characters, I think it's shorter and easier to understand than the equivalent while.
I check for EOF, user may press CTRL+D/CTRL+Z or stdin may be redirected and input file may be too short. As Chux noted you may consider EOF when string is still empty as a valid input (returning true).
When user type . I do not write it to input and because it's already zeroed then I simply can exit.
I'm using bool and other macros defined in stdbool.h.
I'm not allocating memory in this function, you may also change it to be char* read_input_text() but it's less error-prone (in bigger programs) to have a clear ownership for dynamically allocated memory.
read_input_text() is assuming that input is already zeroed. In true production code this should not be the case (less function interface requirements mean less bugs...) You may try to change it to append a trailing 0 where appropriate (tnx Chux, again, to point this out.)


How to count for lowercase letters? You're doing that manually but it's little bit hard to read because you're using magic numbers, let's try to write a small function:

int count_lowercase_characters(char* text)
{
    int count = 0;

    for (size_t i=0; i &lt; strlen(text); ++i)
    {
        if (text[i] &gt;= 'a' &amp;&amp; text[i] &lt;= 'z')
            ++count;
    }

    return count;
}


Using 'a' and 'z' instead of their ASCII values makes code easier to understand (I personally do not remember ASCII codes...) and less error-prone. But, hey...isn't it a very common task? There is a standard function for that, let's use it:

int count_lowercase_characters(const char* text)
{
    int count = 0;

    for (size_t i=0; i &lt; strlen(text); ++i)
    {
        if (islower((unsigned char)text[i])
            ++count;
    }

    return count;
}


Note:


I'm directly using strlen() and loop variable is size_t. Note that it's not mandatory for size_t to be equivalent to int!
I'm using int even if unsigned (or even better size_t) might be more appropriate, don't go into academic discussions about this...
I declare text as const char*, I'm not going to modify the pointed value. Later you may want to declare it as const char* const but no need to go that far, now (also consider to declare it as char const *, it may be easier to pick when beginning).
I'm casting text[i] to unsigned char, if your compiler is aliasing char to unsigned char then you do not need it. See also Do I need to cast to unsigned char before calling toupper?


To write print_count_lowercase_letters() should now be trivial. As you can imagine there is also a similar function isdigit() to determine if a char is a digit (0..9) to use in print_digits(). 

The last function we have to go through is the one to toggle the case:

if (islower(text[i]))
    text[i] = toupper(text[i]);
else if (isupper(text[i]))
    text[i] = tolower(text[i]);


In this case I'm toggling the original string but you may simply write it to stdout. Note that you're using printf() to print a single character, there is an easier way:

if (islower((unsigned char)text[i]))
    putchar(toupper(text[i]));
else if (isupper((unsigned char)text[i]))
    putchar(tolower(text[i]));
else
    putchar(text[i]);


Notes:


I'm using putchar() to print a single character to stdout. Easier and faster.
I'm using islower() and isupper() to determine the case of the character. If you can't use these library functions then write your own function to reuse.
I'm using tolower() and toupper() to perform case conversion. Again if you can't use them then write your own, you will gain in legibility.
Last else has been greatly simplified, string is user input then it already contains printable characters, everything else which is not a letter should simply go untouched.
I didn't write it but the loop is similar to the previous function for (size_t i=0; i &lt; strlen(text); ++i). See very last paragraph for more info.




In this examples I didn't consider any optimization, you will soon learn that strlen(text) as condition in a for loop is relatively terrible from a performance point of view (because outside very simple cases compiler isn't able to determine that it can be optimized and evaluated just once). The same loop may then be rewritten (few solutions ordered for complexity+speed).

To evaluate strlen(text) just once:

for (size_t i=0, n = strlen(text); i &lt; n; ++i)


To manually stop when encountering string terminator:

for (size_t i=0; text[i] != 0; ++i)


To fully use pointers arithmetic:

for (char *p = text; *p; ++p)