My first impression is that the code is very hard to read.

There are lots of variables all with single-letter identifiers, without even comments to help understand what each one represents. As a general rule, a variable's descriptiveness should be proportional to the size of its scope.

void main() is not a portable declaration of main() - if your compiler doesn't at least warn about this, you probably haven't enabled enough diagnostics. Portable definitions of main() all return int (though you don't explicitly need to return a value - reaching the end of main() will cause the runtime to exit with a success status value).

Variable int a is declared but never used.

If printf("ENTER OUTER NUMBER:") fails, it seems foolish to try reading input. Don't ignore function return values unless you've considered the consequences!

Even more significantly, if the scanf() call fails to convert its input to int, then we should not be continuing with uninitialised value of n.

Consider accepting the size as a command-line argument, rather than requiring it to be passed via standard input. You could use the existing logic as a fallback if the argument isn't provided.

Having said that, we should think about what range of n we're willing to accept. Consider this invocation:

./207421 <<<12

ENTER OUTER NUMBER:1212121212121212121212121212121212121212121212
1211111111111111111111111111111111111111111112
1211101010101010101010101010101010101010101112
12111099999999999999999101112
12111098888888888888889101112
12111098777777777777789101112
12111098766666666666789101112
12111098765555555556789101112
12111098765444444456789101112
12111098765433333456789101112
12111098765432223456789101112
12111098765432123456789101112
12111098765432223456789101112
12111098765433333456789101112
12111098765444444456789101112
12111098765555555556789101112
12111098766666666666789101112
12111098777777777777789101112
12111098888888888888889101112
12111099999999999999999101112
1211101010101010101010101010101010101010101112
1211111111111111111111111111111111111111111112
1212121212121212121212121212121212121212121212

If we're to assume that each number has width of 1 character, then we need to ensure 0 < n < 10.

Alternatively, we could specify a field width when we printf() each value, so that all values are printed consistently wide. We could obtain the required width for the largest value using snprintf(NULL, 0, …). Even then, we might to limit the width for usability reasons - particularly if standard output is connected to a terminal!

Splitting the output up over several loops makes it very hard to follow. I'd prefer to use a single pair of nested loops to write all the output:

    for (unsigned y = 0; y < width;  ++y) {
        for (unsigned x = 0;  x < width;  ++x) {
            printf("%u ", distance_from_centre(size, x, y));
        }
        puts("");
    }

All we have to do is write a suitable distance_from_centre function that returns the ring number for a given position.

Improved code

Applying all the suggestions above, we get:

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

/* Read a line from standard input, removing the final newline.
   Returns number of characters read, zero on failure.
 */
static size_t read_string(char *buf, size_t buf_size, char const *prompt)
{
    if (printf("%s: ", prompt) < 2) {
        return 0;
    }
    fflush(stdout);
    if (!fgets(buf, sizeof buf_size, stdin)) {
        return 0;
    }
    size_t len = strlen(buf);
    if (len = 0 || buf[len-1] != '\n') {
        return 0;
    }
    buf[len-1] = '\0';
    return len;
}

/* Find which ring is at the position (x, y) for a set of concentric
   rings where 1 is the inner point and rings is the outer ring.
 */
static unsigned distance_from_centre(unsigned rings, unsigned x, unsigned y)
{
    unsigned dx =  x >= rings  ?  x - rings + 2  :  rings - x;
    unsigned dy =  y >= rings  ?  y - rings + 2  :  rings - y;
    return dx > dy ? dx : dy;
}

/* Convert arg to number, and print that many concentric rings */
static unsigned print_rings(char const *arg)
{
    /* Convert input; allow only 1-99 rings */
    char *end;
    unsigned long const rings_l = strtoul(arg, &end, 10);
    if (*end || rings_l - 1 >= 99) {
        fprintf(stderr, "Invalid ring count %s\n\n", arg);
        return 0;
    }
    unsigned const rings = (unsigned)rings_l;

    /* Do the printing */
    int const field_width = snprintf(NULL, 0, "%u", rings);
    unsigned const width = 2 * rings - 1;

    for (unsigned y = 0; y < width;  ++y) {
        for (unsigned x = 0;  x < width;  ++x) {
            printf("%*u ", field_width,
                   distance_from_centre(rings, x, y));
        }
        puts("");
    }
    puts("");
    return rings;
}


int main(int argc, char **argv)
{
    if (argc < 2) {
        /* No arguments: fall back to reading from input */
        char buf[10]; /* plenty for valid sizes, including newline and null */
        if (!read_string(buf, sizeof buf, "Enter number of rings")) {
            fprintf(stderr, "Failed to read input\n");
            return EXIT_FAILURE;
        }
        print_rings(buf);
    } else {
        while (*++argv) {
            print_rings(*argv);
        }
    }
}

You'll notice that much of this code is for robust input and other error-checking; the actual printing code is relatively small. That tends often to be the case when writing C programs.