How to count sequence of numbers in array-CodePudding

I want to count sequence of numbers together, by always adding the next number to the sum of numbers before. Then do it all again but start one number up. Like this. Then find duplicated sums.

1 5 2 4 2 2 2(sequence) 

0..1:  1 5               sum=6
0..2:  1 5 2             sum=8
0..3:  1 5 2 4           sum=12
0..4:  1 5 2 4 2         sum=14
0..5:  1 5 2 4 2 2       sum=16
0..6:  1 5 2 4 2 2 2     sum=18
1..2:  5 2               sum=7
1..3:  5 2 4             sum=11
1..4:  5 2 4 2           sum=13
1..5:  5 2 4 2 2         sum=15
1..6:  5 2 4 2 2 2       sum=17
2..3:  2 4               sum=6
2..4:  2 4 2             sum=8
2..5:  2 4 2 2           sum=10
2..6:  2 4 2 2 2         sum=12

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

int main(void)
{
    int count = 0;
    char temp;
    int sekvence[10000];
    int countedsequence[10000];
    int duplication = 0;
//save user input
    do
    {
        scanf("%d%c", &sekvence[count], &temp);
        count  ;
    } while (temp != '\n');
    sekvence[count];
//somehow count it and save to countedsequence
    countedsequence[0] = sekvence[0];
    countedsequence[0] = countedsequence[0]   sekvence[0   1];
    for (int i = 1; i < count - 1; i  )
    {
        countedsequence[i] = countedsequence[i - 1]   sekvence[i   1];
    }
//find duplicated numbers in countedsequence
    for (int i = 0; i < count - 1; i  )
    {
        for (int j = i   1; j < count - 1; j  )
        {
            if (countedsequence[i] == countedsequence[j])
            {
                duplication  ;
                break;
            }
        }
    }
//idk some printing for testing
    for (int i = 0; i < count - 1; i  )
    {
        printf("%d ", countedsequence[i]);
    }
    printf("%d\n", duplication);

    return 0;
}

I only managed to count from start to end how do I start counting again with one up to the end?

CodePudding user response：

I usually revise op's code into an solution but the use of non-English variable mean that require unnecessary extra effort. The only working functionality is the interactive input handling but that gets in way during development.

To generate each range of the sequence using two loops (for start and end) and at third to generate the sum of said range (sequence_sum()).

With an unordered array of numbers we can find duplicates by a tweaked partition algorithm that that swap elements into 3 sections: one instance of each duplicates [0; i[, todo [i; sum_len - i[ and processed [ sum_len; [. This is an O(n^2) algorithm. A more efficient O(n) solution would use a hash map from sum to count at the cost of additional code.

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

void swap(int *a, int *b) {
    int tmp = *a;
    *a = *b;
    *b = tmp;
}

size_t duplicate_sum(size_t sum_len, const int sum[sum_len], int duplicate[sum_len]) {
    size_t i = 0;
    memcpy(duplicate, sum, sum_len * sizeof(*sum));
    for(; i < sum_len;) {
        int found = 0;
        for(size_t j = i   1; j < sum_len; j  ) {
            if(duplicate[i] == duplicate[j]) {
                found = 1;
                swap(duplicate   j, duplicate   sum_len - 1);
                sum_len--;
            }
        }
        if(found) {
            i  ;
        } else {
            swap(duplicate   i, duplicate   sum_len - 1);
            sum_len--;
        }
    }
    return i;
}

void sequence_sum(size_t len, const int sequence[len], int sum[len * (len - 1) / 2]) {
    for(size_t i = 0, s = 0; i < len - 1; i  ) {
        for(size_t j = i   1; j < len; j  , s  ) {
            sum[s] = 0;
            printf("%zu..%zu: ", i, j);
            for(size_t k = i; k <= j; k  ) {
                printf(" %d", sequence[k]);
                sum[s]  = sequence[k];
            }
            printf("%*.0ssum=%d\n", (int) (2 * len - 2 * (j - i)), "", sum[s]);
        }
    }
}

int main(void) {
    int sequence[] = { 1,5,2,4,2,2,2 };
    size_t sequence_len = sizeof sequence / sizeof *sequence;
    size_t sum_len = sequence_len * (sequence_len - 1) / 2;
    int sum[sum_len];
    sequence_sum(sequence_len, sequence, sum);

    int duplicate[sum_len];
    printf("duplicates: ");
    size_t duplicate_len = duplicate_sum(sum_len, sum, duplicate);
    for(size_t i = 0; i < duplicate_len; i  ) {
        printf(" %d", duplicate[i]);
    }
    printf("\n");

and the output:

0..1:  1 5            sum=6
0..2:  1 5 2          sum=8
0..3:  1 5 2 4        sum=12
0..4:  1 5 2 4 2      sum=14
0..5:  1 5 2 4 2 2    sum=16
0..6:  1 5 2 4 2 2 2  sum=18
1..2:  5 2            sum=7
1..3:  5 2 4          sum=11
1..4:  5 2 4 2        sum=13
1..5:  5 2 4 2 2      sum=15
1..6:  5 2 4 2 2 2    sum=17
2..3:  2 4            sum=6
2..4:  2 4 2          sum=8
2..5:  2 4 2 2        sum=10
2..6:  2 4 2 2 2      sum=12
3..4:  4 2            sum=6
3..5:  4 2 2          sum=8
3..6:  4 2 2 2        sum=10
4..5:  2 2            sum=4
4..6:  2 2 2          sum=6
5..6:  2 2            sum=4
duplicates:  6 8 12 10 4