Este problema tan sólo consiste en rellenar una tabla según unas instrucciones que te dan en la salida (problema de simulación). El método de resolución se reduce a ir leyendo orden a orden e ir cumpliéndola. Lo único que se puede hacer es reducir un poco el código fuente, con un par de trucos (que no obstante hacen que el programa vaya más lento y sea un poco más complicado de leer). Estos son:

1.- La tabla del problema es de 16x16, pero es mejor hacerla de 16x17, y dar a la columna 16 el valor 0, para que así se pueda imprimir el resultado como si fueran cadenas de caracteres en vez de imprimirlas una a una.

2.- En vez de mirar qué subregión hay que coger (1, 2, 3 ó 4), y según eso cambiar los límites de la subimagen, es mejor encontrar un procedimiento general que, sea cual sea la subregión te de los nuevos límites. Esto se consigue con cuatro arrays del tipo:

FFdesde = {0,0,1,1};
FFhasta = {-1,-1,0,0};
CCdesde = {0,1,1,0};
CChasta = {-1,0,0,-1};

y con una variable i que indique la mitad del tamaño de la subimagen actual. Los nuevos límites de la subimagen (desdefilas, hastafilas, desdecolumnas y hastacolumnas), si c es el caracter que indica la orden, vienen dados por:

desdefilas += FFdesde[c-'1']*i;
hastafilas += FFhasta[c-'1']*i;
desdecolumnas += CCdesde[c-'1']*i;
hastacolumnas += CChasta[c-'1']*i;

Pero si nos damos cuenta, FFhasta = -(!FFdesde) y CChasta = -(!CCdesde), con lo que sólo se necesitarían dos arrays:

FF = {0,0,1,1};
CC = {0,1,1,0};

siendo los nuevos límites:

desdefilas += FF[c-'1']*i;
hastafilas -= (!FF[c-'1'])*i;
desdecolumnas += CC[c-'1']*i;
hastacolumnas -= (!CC[c-'1'])*i;

Esto puede complicar mucho la comprensión del código, se pueden cometer errores difícilmente localizables al implementarlo, y es más lento que haciendo caso a caso, pero el código fuente tiene muchísimas menos líneas.

Código

Código fuente en C