Escriba un programa en C para leer una matriz de 3 * 3, encuentre el valor entero mínimo, reemplace los elementos diagonales por un entero mínimo y muéstrelo usando un puntero.

Answer 1

Gracias por la solicitud Espero que esta no sea una pregunta de tarea.
Código :

#include

int findMin (int mínimo, int currentValue)
{
retorno mínimo <currentValue? mínimo: currentValue;
}

int main ()
{
// recuento de filas y columnas
int rowCount = 3, colCount = 3;
// loop var
int i, j;
matriz de int [rowCount] [colCount];
int mínimo = 10000;
// suponiendo que el elemento max es <10000
//entrada
// y encontrar el mínimo
para (i = 0; i <rowCount; i ++)
{
para (j = 0; j <colCount; j ++)
{
scanf (“% d”, y matriz [i] [j]);
mínimo = findMin (mínimo, matriz [i] [j]);
}
}
// valores cambiantes
int * ptr = & matriz [0] [0];
para (i = 0; i <rowCount; i ++)
{
para (j = 0; j <colCount; j ++)
{
// diagonal primaria
si (i == j)
{
* ptr = mínimo;
}
// diagonal secundaria
if (j == (colCount – i – 1))
{
* ptr = mínimo;
}
ptr ++;
}
}
ptr = & matriz [0] [0];
//monitor
para (i = 0; i <rowCount; i ++)
{
para (j = 0; j <colCount; j ++)
{
printf (“% d”, * ptr);
++ ptr;
}
printf (“\ n”);
}
devuelve 0;
}

Explicación:
Supuse que el elemento máximo que puede tener la matriz es 10000. Al obtener la entrada en sí, encuentro el mínimo. Luego cambio la diagonal primaria y secundaria de la matriz con el elemento mínimo usando el puntero. Luego muestro la matriz.

Salida:

Aquí -2 es el elemento mínimo. Las primeras 3 líneas denotan la entrada y las siguientes 3, salida.

Answer 2

Sospecho que esta es una pregunta de tarea, así que en lugar de darle un archivo de código, le daré algunos algoritmos generales. Para encontrar el entero mínimo de una lista de enteros, debe comenzar con el primer número como mínimo, luego recorrer la lista reemplazando el mínimo actual por cada número que encuentre que es más pequeño.

En cuanto a mostrarlo con un puntero, no recuerdo los detalles arenosos, pero supongo que una matriz 2D C almacena valores fila por fila, por lo que [1] [0] en una matriz 3 × 3 sería [3] en la representación interna Entonces, en conjunto con location & loc, el valor en [m] [n] sería

* (& loc + sizeof (int) * m * longitud de fila + n)

Answer 3

El programa está escrito a continuación.

#include
#define max 3

int main ()
{
int matriz [max] [max], pequeño, i, j;
int * ptr;

printf (“Ingrese los valores de la matriz:”);
para (i = 0; i para (j = 0; j scanf (“% d”, y matriz [i] [j]);

// encontrar un elemento pequeño
pequeño = matriz [0] [0]; // inicializa pequeño como primer elemento

para (i = 0; i para (j = 0; j {
if (pequeño> matriz [i] [j])
pequeño = matriz [i] [j];
}

// cambio de elemento pequeño a elemento digonal

para (i = 0; i matriz [i] [i] = pequeño; // dado que los elementos digonales i y j son los mismos, por ejemplo: matrx [0] [0], matrix [1] [1];

// imprimir como matriz
printf (“\ n El resultado es \ n”);

ptr = matriz;

para (i = 0; i {
para (j = 0; j {
printf (“% d”, * ptr);
ptr = ptr + 1;
}
printf (“\ n”);
}

devuelve 0;
}