En este post te voy a explicar cómo es el código para solucionar un algoritmo en C que dice algo así:

Escribir el código necesario que a partir de dos arreglos sume el primer elemento del primer arreglo con el último elemento del segundo; el segundo elemento del primero con el penúltimo elemento del arreglo y así sucesivamente hasta sumar el último elemento del primer arreglo con el primer elemento del segundo arreglo.

Almacenar la suma de cada elemento en un tercer arreglo y al finalizar, imprimir los 3 arreglos.

Lo que haremos será recorrer los arreglos, acceder a los índices por un contador y finalmente sumar. Realmente será sencillo realizar la suma de elementos de arreglos en C.

Sumar elementos de ambos arreglos

Comenzamos declarando los 3 arreglos: el A, el B y el resultante.

int arregloA[10] = {1, 2, 3, 4, 5, 6, 7, 8, 1, 2};
int arregloB[10] = {1, 2, 3, 4, 5, 6, 7, 8, 1, 2};
int arregloC[10];//El resultante

Para que el algoritmo sea sencillo vamos a declarar dos variables que van a indicar la posición de cada arreglo. El primer contador indicará el del arreglo A, y el segundo, el del arreglo B.

// Primero necesitamos la longitud de ambos arreglos. Como tienen la misma longitud, no importa cuál usemos
int longitud = sizeof(arregloA) / sizeof(arregloA[0]);
// Ahora empezamos un ciclo desde 0 hasta 10, pero tenemos dos contadores
// uno nos ayuda a llevar posición del A, y el segundo del B (que irá decrementando)
int contadorA = 0;
int contadorB = longitud - 1;

En el ciclo for que haremos desde 0 hasta la longitud del arreglo vamos a aumentar el contador de A, y disminuir el contador de B. Además, colocaremos la suma en el resultante:

for (int x = 0; x < longitud; x++) {
    // Sumamos. Al inicio contadorA estará en 0 y contadorB en 9
    int suma = arregloA[contadorA] + arregloB[contadorB];
    arregloC[contadorA] = suma;
    // Avanzar en A y retroceder en B
    contadorA++;
    contadorB--;
}

Después de eso, basta con imprimir los arreglos.

Función que imprime los arreglos

Para reutilizar código he implementado una función que imprime el contenido de un arreglo:

void imprimir_arreglo(int arreglo[], int longitud) {
    for (int x = 0; x < longitud; x++) {
        printf("%d ", arreglo[x]);
    }
}

Poniendo todo junto

Y bien, el código completo de este ejercicio en C sobre sumar arreglos y almacenar la suma en el resultado queda así:

/*
  ____          _____               _ _           _       
 |  _ \        |  __ \             (_) |         | |      
 | |_) |_   _  | |__) |_ _ _ __ _____| |__  _   _| |_ ___ 
 |  _ <| | | | |  ___/ _` | '__|_  / | '_ \| | | | __/ _ \
 | |_) | |_| | | |  | (_| | |   / /| | |_) | |_| | ||  __/
 |____/ \__, | |_|   \__,_|_|  /___|_|_.__/ \__, |\__\___|
         __/ |                               __/ |        
        |___/                               |___/         
    
    Blog:       https://parzibyte.me/blog
    Ayuda:      https://parzibyte.me/blog/contrataciones-ayuda/
    Contacto:   https://parzibyte.me/blog/contacto/
    
    Copyright (c) 2020 Luis Cabrera Benito
    Licenciado bajo la licencia MIT
    
    El texto de arriba debe ser incluido en cualquier redistribución
*/
#include <stdio.h>

void imprimir_arreglo(int arreglo[], int longitud) {
    for (int x = 0; x < longitud; x++) {
        printf("%d ", arreglo[x]);
    }
}

int main() {
    int arregloA[10] = {1, 2, 3, 4, 5, 6, 7, 8, 1, 2};
    int arregloB[10] = {1, 2, 3, 4, 5, 6, 7, 8, 1, 2};
    int arregloC[10];//El resultante
    // Primero necesitamos la longitud de ambos arreglos. Como tienen la misma longitud, no importa cuál usemos
    int longitud = sizeof(arregloA) / sizeof(arregloA[0]);
    // Ahora empezamos un ciclo desde 0 hasta 10, pero tenemos dos contadores
    // uno nos ayuda a llevar posición del A, y el segundo del B (que irá decrementando)
    int contadorA = 0;
    int contadorB = longitud - 1;


    for (int x = 0; x < longitud; x++) {
        // Sumamos. Al inicio contadorA estará en 0 y contadorB en 9
        int suma = arregloA[contadorA] + arregloB[contadorB];
        arregloC[contadorA] = suma;
        // Avanzar en A y retroceder en B
        contadorA++;
        contadorB--;
    }
    printf("Arreglo A: ");
    imprimir_arreglo(arregloA, longitud);
    printf("\n");
    printf("Arreglo B: ");
    imprimir_arreglo(arregloB, longitud);
    printf("\n");
    printf("Arreglo C: ");
    imprimir_arreglo(arregloC, longitud);
    printf("\n");
}