Análisis de Arreglos Unidimensionales y Bidimensionales

Este ejemplo explora la estructura de memoria y el acceso a elementos en arreglos de C.

Arreglo Unidimensional

Se define un arreglo de enteros dataArray de tamaño ARRAY_SIZE y se inicializa con valores. Se demuestra cómo obtener el tamaño total en bytes del arreglo usando sizeof. Posteriormente, se itera a través de cada elemento, imprimiendo su dirección de memoria y su valor. Finalmente, se muestra la dirección de memoria asociada con el nombre del arreglo, que coincide con la dirección del primer elemento.

#include <stdio.h>
#define ARRAY_SIZE 4
#define ROW_COUNT 2

void display_array_info() {
   int dataArray[ARRAY_SIZE] = {1, 9, 8, 4};
   int i;

   // Mostrar el tamaño en bytes del arreglo
   printf("sizeof(dataArray) = %zu bytes\n", sizeof(dataArray));

   // Mostrar la dirección y el valor de cada elemento
   for (i = 0; i < ARRAY_SIZE; ++i) {
       printf("%p: %d\n", &dataArray[i], dataArray[i]);
   }

   // Mostrar el valor (dirección) del nombre del arreglo
   printf("dataArray = %p\n", dataArray);
}

void display_2d_array_info() {
   int matrix[ROW_COUNT][ARRAY_SIZE] = {{1, 9, 8, 4}, {2, 0, 4, 9}};
   int i, j;

   // Mostrar el tamaño en bytes del arreglo bidimensional
   printf("sizeof(matrix) = %zu bytes\n", sizeof(matrix));

   // Mostrar la dirección y el valor de cada elemento
   for (i = 0; i < ROW_COUNT; ++i) {
       for (j = 0; j < ARRAY_SIZE; ++j) {
           printf("%p: %d\n", &matrix[i][j], matrix[i][j]);
       }
   }
   printf("\n");

   // Mostrar los valores (direcciones) de los nombres de filas
   printf("matrix = %p\n", matrix);
   printf("matrix[0] = %p\n", matrix[0]);
   printf("matrix[1] = %p\n", matrix[1]);
   printf("\n");
}

int main() {
   printf("--- Demostración de Arreglo Unidimensional ---\n");
   display_array_info();

   printf("\n--- Demostración de Arreglo Bidimensional ---\n");
   display_2d_array_info();

   return 0;
}
 

Los arreglos en C se almacenan de forma contigua en memoria. El nombre del arreglo, como x o matrix, se evalúa como la dirección de su primer elemento. En arreglos bidimensionales, los elementos se almacenan fila por fila. La diferencia entre las direcciones de matrix[0] y matrix[1], por ejemplo, corresponde al tamaño total en bytes de una fila.

Procesamiento de Arreglos: Entrada, Cálculo y Salida

Cálculo de Promedio Excluyendo Extremos

Este programa implementa la lectura de n enteros en un arreglo, el cálculo de su promedio, excluyendo el valor máximo y mínimo, y la visualización del resultado. Se utilizan funciones separadas para la entrada de datos y el cálculo.

#include <stdio.h>
#define MAX_ELEMENTS 100

// Prototipo de función para entrada de datos
void read_data(int arr[], int count);
// Prototipo de función para cálculo
double calculate_average_excluding_extremes(int arr[], int count);

int main() {
   int data_buffer[MAX_ELEMENTS];
   int num_elements;
   double result_average;

   // Bucle para procesar múltiples conjuntos de datos
   while (printf("Ingrese la cantidad de elementos (n): "), scanf("%d", &num_elements) != EOF) {
       read_data(data_buffer, num_elements); // Llamada a la función de entrada
       result_average = calculate_average_excluding_extremes(data_buffer, num_elements); // Llamada a la función de cálculo
       printf("Promedio (excluyendo max/min): %.2f\n\n", result_average);
   }

   return 0;
}

// Definición de la función de entrada
void read_data(int arr[], int count) {
   int i;
   for (i = 0; i < count; ++i) {
       scanf("%d", &arr[i]);
   }
}

// Definición de la función de cálculo
double calculate_average_excluding_extremes(int arr[], int count) {
   int current_max, current_min;
   double sum = 0.0;
   int i;

   // Inicializar máximo y mínimo con el primer elemento
   current_max = current_min = arr[0];
   
   // Calcular la suma y encontrar los extremos
   for (i = 0; i < count; ++i) {
       sum += arr[i];

       if (arr[i] > current_max) {
           current_max = arr[i];
       } else if (arr[i] < current_min) {
           current_min = arr[i];
       }
   }

   // Calcular el promedio excluyendo los extremos
   sum = sum - current_max - current_min;
   return sum / (count - 2);
}
 

La función read_data(arr, n) y su llamada read_data(x, n) se encargan de leer n enteros del estándar de entrada y almacenarlos en el arreglo x. La función calculate_average_excluding_extremes(arr, n) calcula el promedio de los n elementos del arreglo x, omitiendo el valor más alto y el más bajo.

Manipulación de Matrices: Inicialización y Visualización

Inicialización y Salida de Matrices

Este ejemplo demuestra la inicialización y la visualización de matrices bidimensionales en C. Las funciones init_matrix y print_matrix se utilizan para rellenar la matriz con un valor especificado y luego imprimirla en un formato tabular.

#include <stdio.h>
#define MAX_DIMENSION 100

// Prototipo de función para imprimir la matriz
void print_matrix(int matrix[][MAX_DIMENSION], int dimension);
// Prototipo de función para inicializar la matriz
void init_matrix(int matrix[][MAX_DIMENSION], int dimension, int fill_value);

int main() {
   int square_matrix[MAX_DIMENSION][MAX_DIMENSION];
   int dimension_size, initial_value;

   // Bucle para procesar múltiples matrices
   while (printf("Ingrese el tamaño de la matriz (n) y el valor de inicialización: "), 
          scanf("%d%d", &dimension_size, &initial_value) != EOF) {
       init_matrix(square_matrix, dimension_size, initial_value);  // Llamada a la función de inicialización
       print_matrix(square_matrix, dimension_size);       // Llamada a la función de impresión
       printf("\n");
   }

   return 0;
}

// Definición de la función de impresión
void print_matrix(int matrix[][MAX_DIMENSION], int dimension) {
   int i, j;

   for (i = 0; i < dimension; ++i) {
       for (j = 0; j < dimension; ++j) {
           printf("%d ", matrix[i][j]);
       }
       printf("\n");
   }
}

// Definición de la función de inicialización
void init_matrix(int matrix[][MAX_DIMENSION], int dimension, int fill_value) {
   int i, j;

   for (i = 0; i < dimension; ++i) {
       for (j = 0; j < dimension; ++j) {
           matrix[i][j] = fill_value;
       }
   }
}
 

La función print_matrix(matrix, rows) y su llamada print_matrix(matrix, M) muestran los elementos de la matriz bidimensional matrix. Al pasar arreglos multidimensionales a funciones, es obligatorio especificar todas las dimensiones excepto la primera. La función init_matrix se utiliza para llenar la matriz bidimensional con valores numéricos que se incrementan secuencialmente.

Cálculo de Mediana y Ordenamiento

Cálculo de la Mediana de un Arreglo

Este programa calcula la mediana de un conjunto de números ingresadso por el usuario. Primero, los números se leen en un arreglo, luego se ordenan utilizando el algoritmo de burbuja, y finalmente se calcula la mediana.

#include <stdio.h>
#define MAX_NUMBERS 100

// Prototipo de función para leer números
void get_numbers(int arr[], int count);
// Prototipo de función para calcular la mediana
double calculate_median(int arr[], int count);
// Prototipo de función para ordenar mediante burbuja
void bubble_sort(int arr[], int count);

int main() {
   int number_storage[MAX_NUMBERS];
   int num_count;
   double median_value;

   // Bucle para procesar múltiples conjuntos de números
   while (printf("Ingrese la cantidad de números (n): "), scanf("%d", &num_count) != EOF) {
       get_numbers(number_storage, num_count);        // Llamada a la función de lectura
       median_value = calculate_median(number_storage, num_count); // Llamada a la función de cálculo de mediana
       printf("Mediana = %g\n\n", median_value);
   }

   return 0;
}

// Definición de la función: Leer n números desde el teclado
void get_numbers(int arr[], int count) {
   int i;
   for (i = 0; i < count; ++i) {
       scanf("%d", &arr[i]);
   }
}

// Definición de la función: Ordenar mediante el algoritmo de burbuja
void bubble_sort(int arr[], int count) {
   int i, j, temp_var;
   for (i = 0; i < count - 1; i++) {
       for (j = 0; j < count - 1 - i; j++) {
           if (arr[j] > arr[j + 1]) {
               // Intercambiar elementos
               temp_var = arr[j];
               arr[j] = arr[j + 1];
               arr[j + 1] = temp_var;
           }
       }
   }
}

// Definición de la función
double calculate_median(int arr[], int count) {
   bubble_sort(arr, count); // Ordenar el arreglo primero
   
   // Calcular la mediana según si la cantidad de elementos es par o impar
   if (count % 2 == 1) {
       // Si es impar, la mediana es el elemento central
       return (double)arr[count / 2];
   } else {
       // Si es par, la mediana es el promedio de los dos elementos centrales
       return (arr[count / 2 - 1] + arr[count / 2]) / 2.0;
   }
}
 

Rotación de Matrices

Rotación de Columnas Hacia la Derecha

Este programa toma una matriz cuadrada de n x n y rota sus colunmas hacia la derecha. La columna más a la derecha se mueve a la posición de la columna más a la izquierda, y las otras columnas se desplazan una posición a la derecha.

#include <stdio.h>
#include <stdlib.h> // Para system("pause") si es necesario
#define MAX_DIM 100

// Prototipo de función para entrada de matriz
void matrix_input(int matrix[][MAX_DIM], int dimension);
// Prototipo de función para salida de matriz
void matrix_output(int matrix[][MAX_DIM], int dimension);
// Prototipo de función para rotar columnas a la derecha
void rotate_columns_right(int matrix[][MAX_DIM], int dimension);

int main() {
   int data_matrix[MAX_DIM][MAX_DIM];
   int matrix_size;

   printf("Ingrese el tamaño de la matriz (n): "); 
   scanf("%d", &matrix_size);
   
   matrix_input(data_matrix, matrix_size);

   printf("Matriz Original:\n");
   matrix_output(data_matrix, matrix_size);

   // Llamada a la función de rotación de columnas
   rotate_columns_right(data_matrix, matrix_size);

   printf("Matriz con Columnas Rotadas:\n");
   matrix_output(data_matrix, matrix_size);

   // return 0; // Normalmente se termina aquí
   // system("pause"); // Descomentar si se ejecuta en un entorno que lo requiera
   return 0; 
}

// Definición de la función
// Función: Ingresar una matriz n*n llamada matrix
void matrix_input(int matrix[][MAX_DIM], int dimension) {
   int i, j;
   
   for (i = 0; i < dimension; ++i) {
       for (j = 0; j < dimension; ++j) {
           scanf("%d", &matrix[i][j]);
       }
   }
}

// Definición de la función
// Función: Mostrar una matriz n*n llamada matrix
void matrix_output(int matrix[][MAX_DIM], int dimension) {
   int i, j;

   for (i = 0; i < dimension; ++i) {
       for (j = 0; j < dimension; ++j) {
           printf("%4d", matrix[i][j]); // Formato para alinear números
       }
       printf("\n");
   }
}

// Definición de la función rotate_columns_right
// Función: Rota cada columna de una matriz n*n llamada matrix hacia la derecha.
// La columna más a la derecha se envuelve y aparece en la columna más a la izquierda.
void rotate_columns_right(int matrix[][MAX_DIM], int dimension) {
   int last_column_backup[MAX_DIM];  
   int i, j;
   
   // 1. Guardar la última columna
   for (i = 0; i < dimension; i++) {
       last_column_backup[i] = matrix[i][dimension - 1];
   }
   
   // 2. Desplazar las columnas restantes hacia la derecha
   // Empezamos desde la penúltima columna y vamos hacia la izquierda
   for (j = dimension - 1; j > 0; j--) { // j es el índice de la columna destino
       for (i = 0; i < dimension; i++) { // i es el índice de la fila
           matrix[i][j] = matrix[i][j - 1]; // Copia el elemento de la columna anterior a la actual
       }
   }
   
   // 3. Colocar la última columna guardada en la primera columna
   for (i = 0; i < dimension; i++) {
       matrix[i][0] = last_column_backup[i];
   }
}
 

Conversión de Bases Numéricas

Conversión de Decimal a Binario, Octal y Hexadecimal

Este programa convierte un número decimal ingresado por el usuario a sus representaciones binaria, octal y hexadecimal. Utiliza una función recursiva para realizar la conversión.

#include <stdio.h>
#define BUFFER_SIZE 100

// Prototipo de función para convertir decimal a base N
void decimal_to_base_n(int decimal_num, int base); 

int main() {
   int input_decimal;

   // Bucle para procesar múltiples conversiones
   while (printf("Ingrese un número decimal entero: "), scanf("%d", &input_decimal) != EOF) {
       decimal_to_base_n(input_decimal, 2);  // Llamada a la función: Convertir input_decimal a binario
       decimal_to_base_n(input_decimal, 8);  // Llamada a la función: Convertir input_decimal a octal
       decimal_to_base_n(input_decimal, 16); // Llamada a la función: Convertir input_decimal a hexadecimal

       printf("\n");
   }

   return 0;
}

// Definición de la función
void decimal_to_base_n(int decimal_num, int base) {
   // Caracteres para representar dígitos en bases hasta 16
   char digits[] = "0123456789ABCDEF"; 
   char result_buffer[BUFFER_SIZE]; // Buffer para almacenar los dígitos convertidos
   int current_index = 0;
   int i;
   
   // Caso especial para el número 0
   if (decimal_num == 0) {
       printf("0\n");
       return;
   }
   
   // Proceso de conversión: obtener el resto y dividir por la base repetidamente
   while (decimal_num > 0) {
       result_buffer[current_index] = digits[decimal_num % base]; // Obtiene el dígito correspondiente
       decimal_num = decimal_num / base; // Actualiza el número dividiéndolo por la base
       current_index++; // Incrementa el índice del buffer
   }
   
   // Imprimir los dígitos en el orden correcto (inverso al que se almacenaron)
   for (i = current_index - 1; i >= 0; i--) {
       printf("%c", result_buffer[i]);
   }
   printf("\n"); // Nueva línea después de cada conversión
}
 

Verificación de Matrices Mágicas

Identificación de Matrices Mágicas

Este programa verifica si una matriz cuadrada dada es una matriz mágica. Una matriz mágica es una matriz cuadrada donde la suma de los números en cada fila, cada columna y ambas diagonales principales es la misma. Además, todos los números de 1 a n*n deben aparecer exactamente una vez.

#include <stdio.h>
#define MAX_SIZE 100

// Prototipo de función para leer la matriz
void read_square_matrix(int matrix[][MAX_SIZE], int dimension);
// Prototipo de función para mostrar la matriz
void display_square_matrix(int matrix[][MAX_SIZE], int dimension);
// Prototipo de función para verificar si es mágica
int check_magic_square(int matrix[][MAX_SIZE], int dimension);

int main() {
   int square[MAX_SIZE][MAX_SIZE];
   int n;

   // Bucle para procesar múltiples matrices
   while (printf("Ingrese la dimensión de la matriz (n): "), scanf("%d", &n) != EOF) {
       printf("Ingrese los elementos de la matriz:\n");  
       read_square_matrix(square, n); 

       printf("Matriz Ingresada:\n");  
       display_square_matrix(square, n);   

       // Verificar y mostrar si es una matriz mágica
       if (check_magic_square(square, n)) {
           printf("Es una matriz mágica\n\n");
       } else {
           printf("No es una matriz mágica\n\n");
       }
   }

   return 0;
}

// Definición de la función
void read_square_matrix(int matrix[][MAX_SIZE], int dimension) {
   int i, j;
   
   for (i = 0; i < dimension; ++i) {
       for (j = 0; j < dimension; ++j) {
           scanf("%d", &matrix[i][j]);
       }
   }
}

// Definición de la función
void display_square_matrix(int matrix[][MAX_SIZE], int dimension) {
   int i, j;

   for (i = 0; i < dimension; ++i) {
       for (j = 0; j < dimension; ++j) {
           printf("%4d", matrix[i][j]); // Formato para alinear
       }
       printf("\n");
   }
}

// Definición de la función para verificar si es una matriz mágica
int check_magic_square(int matrix[][MAX_SIZE], int dimension) {
   int target_sum;  // La suma esperada para cada fila, columna y diagonal
   int current_sum; // Suma temporal para filas, columnas o diagonales
   int i, j;
   
   // Las matrices mágicas tradicionalmente son de tamaño impar.
   // Si se requiere soportar matrices pares, esta condición debería modificarse o eliminarse.
   if (dimension % 2 == 0) { 
       return 0; // No es una matriz mágica si la dimensión es par (según esta implementación)
   }
   
   // Calcular la suma mágica esperada para una matriz de tamaño n*n
   // Fórmula: n * (n^2 + 1) / 2
   target_sum = dimension * (dimension * dimension + 1) / 2;
   
   // 1. Verificar la suma de cada fila
   for (i = 0; i < dimension; i++) {
       current_sum = 0;
       for (j = 0; j < dimension; j++) {
           current_sum += matrix[i][j];
       }
       if (current_sum != target_sum) {
           return 0; // Si alguna fila no suma lo esperado, no es mágica
       }
   }
   
   // 2. Verificar la suma de cada columna
   for (j = 0; j < dimension; j++) {
       current_sum = 0;
       for (i = 0; i < dimension; i++) {
           current_sum += matrix[i][j];
       }
       if (current_sum != target_sum) {
           return 0; // Si alguna columna no suma lo esperado, no es mágica
       }
   }
   
   // 3. Verificar la suma de la diagonal principal (izquierda a derecha)
   current_sum = 0;
   for (i = 0; i < dimension; i++) {
       current_sum += matrix[i][i];
   }
   if (current_sum != target_sum) {
       return 0; // Si la diagonal principal no suma lo esperado, no es mágica
   }
 
   // 4. Verificar la suma de la diagonal secundaria (derecha a izquierda)
   current_sum = 0;
   for (i = 0; i < dimension; i++) {
       current_sum += matrix[i][dimension - 1 - i]; // Índice de columna: n-1-i
   }
   if (current_sum != target_sum) {
       return 0; // Si la diagonal secundaria no suma lo esperado, no es mágica
   }
   
   // 5. Verificar si todos los números de 1 a n*n están presentes exactamente una vez
   // Usamos un arreglo auxiliar 'used' para marcar los números encontrados.
   int used[MAX_SIZE * MAX_SIZE + 1] = {0};  // Inicializado a 0s
   for (i = 0; i < dimension; i++) {
       for (j = 0; j < dimension; j++) {
           // Verificar rango de valores
           if (matrix[i][j] < 1 || matrix[i][j] > dimension * dimension) { 
               return 0;  // Si un número está fuera del rango, no es mágica
           }
           // Verificar si el número ya ha sido visto
           if (used[matrix[i][j]]) {
               return 0;  // Si el número se repite, no es mágica
           }
           used[matrix[i][j]] = 1;  // Marcar el número como visto
       }
   }
   
   // Si todas las comprobaciones pasaron, la matriz es mágica
   return 1;
}