Dado un arreglo n × m lleno con valores enteros aleatorios entre 1 y un numero dado, crea otro arreglo n × m en el que cada posicion (i, j) contenga la suma de los elementos vecinos (arriba, abajo, izquierda, derecha y las diagonales) de la posicion (i, j) en el arreglo original. La posicion (i, j) en sı no debe sumarse. crea este programa en C crea el programa sin usar ninguna funcion

Aquí te dejo un ejemplo de cómo podrías implementar este programa en C sin utilizar funciones:

```c
#include <stdio.h>

// Constante para el límite superior de los valores aleatorios
#define MAX_VALOR 100

// Constante para el número de filas y columnas del arreglo
#define FILAS 5
#define COLUMNAS 5

int main() {
    // Arreglo original con valores aleatorios
    int arreglo[FILAS][COLUMNAS];

    // Inicializar el arreglo con valores aleatorios
    for (int i = 0; i < FILAS; i++) {
        for (int j = 0; j < COLUMNAS; j++) {
            arreglo[i][j] = (rand() % MAX_VALOR) + 1;
        }
    }

    // Arreglo resultado con la suma de los vecinos
    int resultado[FILAS][COLUMNAS];

    // Calcular la suma de los vecinos para cada posición
    for (int i = 0; i < FILAS; i++) {
        for (int j = 0; j < COLUMNAS; j++) {
            int suma = 0;

            // Sumar los elementos arriba
            if (i > 0) {
                suma += arreglo[i - 1][j];
            }

            // Sumar los elementos abajo
            if (i < FILAS - 1) {
                suma += arreglo[i + 1][j];
            }

            // Sumar los elementos a la izquierda
            if (j > 0) {
                suma += arreglo[i][j - 1];
            }

            // Sumar los elementos a la derecha
            if (j < COLUMNAS - 1) {
                suma += arreglo[i][j + 1];
            }

            // Sumar los elementos diagonales
            if (i > 0 && j > 0) {
                suma += arreglo[i - 1][j - 1];
            }
            if (i > 0 && j < COLUMNAS - 1) {
                suma += arreglo[i - 1][j + 1];
            }
            if (i < FILAS - 1 && j > 0) {
                suma += arreglo[i + 1][j - 1];
            }
            if (i < FILAS - 1 && j < COLUMNAS - 1) {
                suma += arreglo[i + 1][j + 1];
            }

            // Guardar la suma en el arreglo resultado
            resultado[i][j] = suma;
        }
    }

    // Mostrar el arreglo original
    printf("Arreglo original:\n");
    for (int i = 0; i < FILAS; i++) {
        for (int j = 0; j < COLUMNAS; j++) {
            printf("%d ", arreglo[i][j]);
        }
        printf("\n");
    }

    // Mostrar el arreglo resultado
    printf("Arreglo resultado:\n");
    for (int i = 0; i < FILAS; i++) {
        for (int j = 0; j < COLUMNAS; j++) {
            printf("%d ", resultado[i][j]);
        }
        printf("\n");
    }

    return 0;
}
```

Este programa crea un arreglo `arreglo` con valores aleatorios entre 1 y `MAX_VALOR`, y luego crea un arreglo `resultado` donde cada posición contiene la suma de los elementos vecinos de la posición correspondiente en `arreglo`. Finalmente, muestra ambos arreglos en la consola.