Ejercicio resuelto: matriz con órdenes de giro y desplazamiento en C

La solución usa un tipo Matriz que agrupa las dimensiones en uso (f, c) y un array fijo v[10][10]. Todas las funciones reciben un puntero a ese struct. Así, las que modifican la matriz lo hacen sobre el original y no sobre una copia, como se explica en paso por valor y por referencia en C.

El programa tiene cuatro fases: leer, ejecutar órdenes, calcular el ancho de columna e imprimir con productos. Cada fase está en su propia función.

#include <stdio.h>

#define MAXD 10

typedef struct {
    int f;
    int c;
    int v[MAXD][MAXD];
} Matriz;

static int leer_matriz(Matriz *m)
{
    if (scanf("%d %d", &m->f, &m->c) != 2) return 0;
    if (m->f < 1 || m->f > MAXD || m->c < 1 || m->c > MAXD) return 0;
    for (int i = 0; i < m->f; i++)
        for (int j = 0; j < m->c; j++)
            if (scanf("%d", &m->v[i][j]) != 1) return 0;
    return 1;
}

/* Desplazamiento circular de columnas k posiciones a la derecha (k < 0: izquierda). */
static void desplazar(Matriz *m, int k)
{
    int d = ((k % m->c) + m->c) % m->c;
    if (d == 0) return;
    int fila[MAXD];
    for (int i = 0; i < m->f; i++) {
        for (int j = 0; j < m->c; j++)
            fila[(j + d) % m->c] = m->v[i][j];
        for (int j = 0; j < m->c; j++)
            m->v[i][j] = fila[j];
    }
}

/* Giro de 90 grados en sentido horario: (i, j) pasa a (j, f-1-i). */
static void girar(Matriz *m)
{
    Matriz r = {0};
    r.f = m->c;
    r.c = m->f;
    for (int i = 0; i < m->f; i++)
        for (int j = 0; j < m->c; j++)
            r.v[j][m->f - 1 - i] = m->v[i][j];
    *m = r;
}

static int ancho(int x)
{
    int n = (x <= 0) ? 1 : 0;
    while (x != 0) {
        n++;
        x /= 10;
    }
    return n;
}

static void imprimir(const Matriz *m)
{
    int w = 1;
    for (int i = 0; i < m->f; i++)
        for (int j = 0; j < m->c; j++) {
            int a = ancho(m->v[i][j]);
            if (a > w) w = a;
        }

    printf("Matriz %dx%d:\n", m->f, m->c);
    for (int i = 0; i < m->f; i++) {
        for (int j = 0; j < m->c; j++) {
            if (j > 0) putchar(' ');
            printf("%*d", w, m->v[i][j]);
        }
        putchar('\n');
    }

    printf("Filas:");
    for (int i = 0; i < m->f; i++) {
        long long p = 1;
        for (int j = 0; j < m->c; j++)
            p *= m->v[i][j];
        printf(" %lld", p);
    }
    putchar('\n');

    printf("Columnas:");
    for (int j = 0; j < m->c; j++) {
        long long p = 1;
        for (int i = 0; i < m->f; i++)
            p *= m->v[i][j];
        printf(" %lld", p);
    }
    putchar('\n');
}

int main(void)
{
    Matriz m = {0};
    int q;

    if (!leer_matriz(&m) || scanf("%d", &q) != 1 || q < 0) {
        printf("Entrada no valida\n");
        return 0;
    }

    for (int t = 0; t < q; t++) {
        char op;
        if (scanf(" %c", &op) != 1) break;
        if (op == 'D') {
            int k;
            if (scanf("%d", &k) != 1) break;
            desplazar(&m, k);
        } else if (op == 'G') {
            girar(&m);
        }
    }

    imprimir(&m);
    return 0;
}

Lectura. leer_matriz comprueba que scanf devuelve el número de datos esperado y que las dimensiones están en [1, 10]. Si algo falla devuelve 0, y main imprime el mensaje de error. Comprobar el valor de retorno de scanf no es un adorno: con las opciones de compilación habituales, ignorarlo puede producir avisos, y sin esa comprobación una entrada truncada dejaría casillas con basura.

Lectura de órdenes. En main, el formato " %c" lleva un espacio delante. Ese espacio consume el salto de línea anterior. Sin él, op recibiría '\n' y la orden se perdería, uno de los fallos más frecuentes en examen.

Desplazamiento. En desplazar, la expresión ((k % m->c) + m->c) % m->c normaliza cualquier k al rango [0, c-1]. Por ejemplo, con 3 columnas, -998 % 3 vale -2 en C, al sumar 3 queda 1 y el último módulo lo mantiene en 1. El elemento de la columna j va a la columna (j + d) % c de un vector auxiliar fila, que después se copia sobre la fila original. El auxiliar es necesario porque, al escribir directamente en la matriz, se pisarían valores que aún no se han movido.

El test desplazamientos grandes comprueba la normalización. D 1000 y D -998 equivalen cada uno a un desplazamiento de una posición a la derecha, así que la fila 1 2 3 termina como 2 3 1. El test tres por dos girada incluye D 3 sobre tres columnas: d vale 0 y la función sale sin hacer nada.

Giro. girar construye una matriz nueva r con las dimensiones intercambiadas y coloca cada v[i][j] en r.v[j][f-1-i]. La fórmula se comprueba con una matriz de 2×3 cuyas filas son 1 2 3 y 4 5 6: el 1, en (0,0), pasa a (0,1), y la nueva primera fila es 4 1. Al final, *m = r copia el struct completo, con array incluido, porque C sí permite asignar estructuras. El test cuatro giros verifica que cuatro giros devuelven la matriz original.

Salida formateada. ancho cuenta los caracteres de un entero: arranca en 1 si el valor es negativo (por el signo) o cero (por el dígito 0), y suma uno por cada división entre 10. imprimir obtiene el máximo w y usa %*d, que toma el ancho de un argumento. En el ejemplo, el elemento más largo ocupa dos caracteres (10, -3, -6), y por eso el 1 aparece precedido de un espacio. En el test cuatro giros el ancho es 3, por el -10.

Productos. Se acumulan en long long. Una fila de diez valores de módulo 50 da 5010, casi 1017, muy por encima de INT_MAX. El test límite de diez columnas produce exactamente 97656250000000000, y un int habría desbordado, lo que en C es comportamiento indefinido.