Mensajes

En verdad C es de por sí inseguro y solo le interesa la velocidad y la libertad del programador. A parte del ensamblador es, seguramente, el lenguaje más libre_de_hacer_lo_que_quieras que haya circulando por el mundo.
Es como un gran muscle car sin control de derrape, ni abs, ni de tracción activa: o eres un buen piloto o no le sacas todo el partido al coche o, peor aún, te estrellas.

Lástima que el trabajo sea en C++, porqué sé muy poco de ese lenguaje, pero aquí te enseño un código en C el cuál tienes los datos separados de la lógica, una función menú genérica y un main limpio.

Código (c) [Seleccionar] Expandir


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

/* Estas tablas facilitan los posteriores cambios en las opciones */
/* En las opciones de menú poner siempre al final un NULL, ya que
* es lo que espera la función para trabajar con estos argumentos.
*/
const char *fabricantes[] = {"Microsoft", "Apple", "Linux", NULL};
const char *productos[] = {"Sistema operativo", "Lenguaje de programación", NULL};
const char *dispositivo[] = {"Celulares", "Tablas", "Otros", NULL};

const int precios_microsoft[] = {
            /* Sistema operativo */ 1500,
            /* Lenguaje de Programación */
            /*    Celulares */      1800,
            /*    Tablas    */      1200,
            /*    Otros     */       900};

const int precios_apple[] = {
            /* Sistema operativo */ 2500,
            /* Lenguaje de Programación */
            /*    Celulares */      1900,
            /*    Tablas    */      1800,
            /*    Otros     */      1600};

const int precios_linux[] = {
            /* Sistema operativo */ 1000,
            /* Lenguaje de Programación */
            /*    Celulares */       100,
            /*    Tablas    */       150,
            /*    Otros     */        50};

int menu(const char *titulo, const char *empresa, const char **opciones) {
    int i = 0;
    int respuesta;
   
    do {
        /* Imprimiendo el título del menú */
        printf("%s ", titulo);
        if(empresa)
            printf("%s", empresa);
        printf(":\n\n");
        /* Imprimiendo opciones del menú */
        while(opciones[i] != NULL) {
            printf("    %2i. %s\n", i + 1, opciones[i]);
            ++i;
        }
        --i;
        /* Adquiriendo la opción deseada */
        printf("\n    Opcion >> ");
        respuesta = getchar();
        /* Control de errores de la entrada por teclado */
        while(getchar() != '\n');
        if(isdigit(respuesta))
            respuesta -= '0' + 1;
        else
            respuesta = -1;
        if(respuesta > i)
            respuesta = -1;
        if(respuesta == -1) {
            i = 0;
            printf("*** OPCION INCORRECTA ***\n");
            while(getchar() != '\n');
        }
    } while(respuesta == -1);
   
    /* Un poco bonito, que también puede formar parte del menú... */
    putchar('\n');
   
    /* Devuelvo la opción elegida */
    return respuesta;
}

int main() {
    int respuesta;
    const char *fabricante;
    const int *lista_de_precios;

    respuesta = menu("Elija fabricante", NULL, fabricantes);
    fabricante = fabricantes[respuesta];
    switch(respuesta) {
        case 0:
            lista_de_precios = precios_microsoft;
            break;
        case 1:
            lista_de_precios = precios_apple;
            break;
        case 2:
            lista_de_precios = precios_linux;
            break;
    }
   
    respuesta = menu("Elija el producto de", fabricante, productos);
   
    if(respuesta == 1)
        respuesta = menu("Elija el dispositivo de", fabricante, dispositivo) + 1;
   
    printf("El precio del producto es: %i", lista_de_precios[respuesta]);
   
    return 0;
}

C++ y C a partir del estándar del 99 sí se puede declarar el array con variables.

El enunciado es muy vago en su descripción. No sé que hay que hacer.

De entrada se me plantea una duda:
Si la matriz ordenada no puede repetir ningún número puede que sea de menor tamaño que la matriz original. Siendo así:
¿La matriz ordenada debe ser la misma matriz original? Si la matriz original es estática, eso es definida del tipo T[dimY][dimX], no se puede reducir su tamaño. ¿Cómo se marcan las casillas vacías? ¿Cómo se distribuye la información en la matriz?
Si la matriz original es dinámica se pueden reducir sus dimensiones pero de nuevo aparece el problema de como se distribuye el sistema si no se pueden cuadrar las dimensiones (número impar de elementos).

Jaja, sí, pero creo que la idea de NOB2014 no iba por ahí 

A ver, esto es porqué no me gusta lo de C/C++, la gente tiende a mezclarlos.
C estándar, sin extensiones de compiladores ni otras historias, no tiene sobrecargas; sus archivos de cabecera son los terminados en .h; no necesita castings en los punteros a void. Mientras C++ es todo lo contrario en estos puntos.

Yo he hecho el siguiente código que, a diferencia del tuyo, destruye la variable original.

Código (c) [Seleccionar] Expandir


#include <stdio.h>
#include <math.h>

int main() {
    unsigned num = -12345;
    unsigned resultado;
    int d = 1;
   
    while(num) {
        resultado ^= d * (num & 1);
        num >>= 1;
        d <<= 1;
    }
    printf("El número buscado es %i", resultado);
   
    return 0;
}

Ah, pues lo primero que debes hacer es avisar al usuario si se excede en las dimensiones, o son muy pequeñas (imagínate que pone 0 o menor a 0).

Después con bucles anidados haces (te lo voy a dejar en seudocódigo porqué es muy fácil.

Código [Seleccionar] Expandir


por i = 1 hasta num_filas
    cuenta = 0
    por j = 1 hasta num_columnas
        si elemento(i,j) es 0
            cuenta = cuenta + 1
    imprimir "El número de 0s en fila " i " es " cuenta

Similar para conseguir el número de 0s para las columnas.
Para toda la tabla es

Código [Seleccionar] Expandir


cuenta = 0
por i = 1 hasta num_filas
    por j = 1 hasta num_columnas
        si elemento(i,j) es 0
            cuenta = cuenta + 1
imprimir "El número de 0s en la tabla es " cuenta

Te recomiendo te pases por aquí:
https://www.youtube.com/watch?v=kjYKBEUB0y0