Faça um programa que:
ofereça uma função que troque os valores contido no vetor pela seguinte política: cada elemento i dentro do vetor será substituído pela soma de todos os (i-1) elementos mais o elemento i. Por exemplo, dado um vetor [1 ; 2 ; 3 ; 4 ; 5] após a aplicação da função teríamos esse vetor preenchido com os seguintes valores [1; 3 ; 6; 10; 15]. Para esta tarefa utilize um vetor auxiliar.

Passo 1

Beleza, então o enunciado pede um programa que, dado um vetor de números, transforme cada elemento na soma de todos os anteriores mais ele mesmo. Em outras palavras, se o vetor é [1, 2, 3, 4, 5], o resultado deve ser [1, 1+2, 1+2+3, 1+2+3+4, 1+2+3+4+5], ou seja [1, 3, 6, 10, 15].
Conteúdo: vetores, laços de repetição e prefix sum (soma acumulada).
O que vamos precisar:
  • Um vetor auxiliar do mesmo tamanho.
  • Um laço para calcular cada posição com base nas anteriores.
  • Copiar o resultado de volta para o vetor original.

Passo 2

Teoria da Prefix Sum (Soma Acumulada)
A ideia é definir um novo vetor auxiliar aux em que cada elemento aux[i] vale
aux[i] ;=; sumk=0^i v[k]
Ou seja, aux[0] = v[0] e, para i ≥ 1,
aux[i] = aux[i-1] + v[i]
Isso garante que aux[i] é exatamente a soma de todos os elementos de v desde o índice 0 até i.

Passo 3

Descrevendo o algoritmo passo a passo:
  1. Cria um vetor aux do mesmo tamanho de v.
  2. Se i == 0, faz aux[0] = v[0].
  3. Se i > 0, faz aux[i] = aux[i-1] + v[i].
  4. Depois de preencher todo aux, copia cada aux[i] de volta em v[i].
Assim a gente usa o auxiliar para não sobrescrever valores que ainda precisamos somar.

Resposta

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

void somaAcumulada(int *v, int n) {
    int *aux = malloc(n * sizeof(int));
    if (!aux) return; // proteção básica

    // 1) Preenche o vetor auxiliar com as somas
    aux[0] = v[0];
    for (int i = 1; i < n; i++) {
        // aux[i] = aux[i-1] + v[i], conforme a fórmula
        aux[i] = aux[i-1] + v[i];
    }

    // 2) Copia de volta para o vetor original
    for (int i = 0; i < n; i++) {
        v[i] = aux[i];
    }

    free(aux);
}

int main() {
    int v[] = {1, 2, 3, 4, 5};
    int n = sizeof(v)/sizeof(v[0]);

    somaAcumulada(v, n);

    // Imprime o resultado
    for (int i = 0; i < n; i++) {
        printf("%d ", v[i]);
    }
    // Saída esperada: 1 3 6 10 15
    return 0;
}

Exercícios relacionados