Как найти количество одинаковых элементов массива

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

#include <iostream>
#include <algorithm>
#include <vector>
 
int main()
{
    const int N=8;
    int Arr[N]={1,2,3,2,6,2,7,7};
    std::vector<int> Vec(Arr, Arr+N);
    size_t Numb=0;
    for(size_t i=0; i<Vec.size(); ++i)
    {
        Numb+=std::count(Vec.begin(), Vec.end(), Vec[i])-1;
    Vec.erase(std::remove(Vec.begin()+1, Vec.end(), Arr[i]), Vec.end());
    }   
    std::cout<<"Numb of clones: "<< Numb <<'n';
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

#include <iostream>
#include <algorithm>
using namespace std;
 
int main()
{
 
    int a[8] = {1,2,3,2,6,2,7,1};
    for(int i=0; i<8; i++)
    {
        cout << a[i] << '-' << count(a, a+8, a[i]) << endl;
    }
    system("pause");
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

#include <stdio.h>
#include <conio.h>
 
#define N 14
 
int min(int *a, int n)
{
    int m = a[0];
    int i;
 
    for (i = 0; i < n; i++)
        if (a[i] < m)
            m = a[i];
 
    return m;
}
 
int main()
{
    int a[N] = {1, 2, 3, 2, 6, 2, 5, 7, 1, 6, 3, 1, 7, 8};
    int m;
    int elem;
    int count;
    int i, j;
 
    m = min(a, N);
 
    for (i = 0; i < N; i++)
    {
        if (a[i] < m)
            continue;
 
        elem = a[i];
        a[i] = m - 1;
        count = 1;
 
        for (j = i; j < N; j++)
        {
            if (a[j] < m)
                continue;
            else
            {
                if (a[j] == elem)
                {
                    a[j] = m - 1;
                    count++;
                }
            }
        }
 
        printf("Elem %d repeats %d timesn", elem, count);
    }
 
    getch();
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

#include <stdio.h>
#include <stdlib.h>
 
typedef struct VALCNT {
    int val;
    int cnt;
    struct VALCNT * next;
} valcnt_t;
 
valcnt_t * new_val_counter(int value){
    valcnt_t * vc;
    if ( ( vc = (valcnt_t*)malloc(sizeof(valcnt_t)) ) == NULL )
        return NULL;
    vc->val = value;
    vc->cnt = 1;
    vc->next = NULL;
    return vc;
}
 
typedef struct COUNTERS {
    valcnt_t * first;
    valcnt_t * last;
} counters_t;
 
counters_t * new_counters(void){
    counters_t * cs;
    if ( ( cs = (counters_t*)malloc(sizeof(counters_t)) ) == NULL )
        return NULL;
    cs->first = NULL;
    cs->last = NULL;
    return cs;
}
 
void delete_counters(counters_t * cs){
    while ( cs->first ){
        cs->last = cs->first->next;
        free(cs->first);
        cs->first = cs->last;
    }
    free(cs);
}
 
int insert(counters_t * cs, int value){
    valcnt_t * found;
 
    if ( ! cs->first ){
        if ( ( cs->first = new_val_counter(value) ) == NULL )
            return -1;
        cs->last = cs->first;
        return 0;
    }
    for ( found = cs->first; found; found = found->next ){
        if ( found->val == value ){
            found->cnt += 1;
            return 0;
        }
    }
    if ( ( cs->last->next = new_val_counter(value) ) == NULL )
        return -1;
    cs->last = cs->last->next;
    return 0;
}
 
void print_counters(const counters_t * cs){
    const valcnt_t * cur;
    printf("ValuetCountn");
    for ( cur = cs->first; cur; cur = cur->next )
        printf("%dt%dn", cur->val, cur->cnt);
}
 
#define SIZE 10
 
int main(void){
    int arr[SIZE] = { 2, 3, 5, 5, 7, 8, 2, 5, 8, 3 };
    int i;
    counters_t * cs;
    if ( ( cs = new_counters() ) == NULL ){
        fprintf(stderr, "Error creating counters!n");
        exit(1);
    }
    printf("Array:n");
    for ( i = 0; i < SIZE; ++i ){
        printf("%d ", arr[i]);
        if ( insert(cs, arr[i]) ){
            fprintf(stderr, "Error inserting value!n");
            delete_counters(cs);
            exit(1);
        }
    }
    printf("n");
    print_counters(cs);
    delete_counters(cs);
 
    exit(0);
}

1
2
3
4
5
6
7

for ( i = 0; i < n; i++ ) {                                    //n - размерность
        for ( j = i+1; j < n; j++ ) { 
            if ( mas[i] == mas[j] ) {
                         cout << "Совпадающие элементы имеют номера " << i << " и " << j << " в массиве"  << endl;
            }
        }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h> 
 
 
typedef struct VALCNT {
    int val;
    int cnt;
    struct VALCNT * next;
} valcnt_t;
 
valcnt_t * new_val_counter(int value) {
    valcnt_t * vc;
    if ((vc = (valcnt_t*) malloc(sizeof(valcnt_t))) == NULL)
        return NULL;
    vc->val = value;
    vc->cnt = 1;
    vc->next = NULL;
    return vc;
}
 
typedef struct COUNTERS {
    valcnt_t * first;
    valcnt_t * last;
} counters_t;
 
counters_t * new_counters(void) {
    counters_t * cs;
    if ((cs = (counters_t*)malloc(sizeof(counters_t))) == NULL)
        return NULL;
    cs->first = NULL;
    cs->last = NULL;
    return cs;
}
 
void delete_counters(counters_t * cs) {
    while (cs->first) {
        cs->last = cs->first->next;
        free(cs->first);
        cs->first = cs->last;
    }
    free(cs);
}
 
int insert(counters_t * cs, int value) {
    valcnt_t * found;
 
    if (!cs->first) {
        if ((cs->first = new_val_counter(value)) == NULL)
            return -1;
        cs->last = cs->first;
        return 0;
    }
    for (found = cs->first; found; found = found->next) {
        if (found->val == value) {
            found->cnt += 1;
            return 0;
        }
    }
    if ((cs->last->next = new_val_counter(value)) == NULL)
        return -1;
    cs->last = cs->last->next;
    return 0;
}
 
void print_counters(const counters_t * cs) {
    const valcnt_t * cur;
    printf("ValuetCountn");
    for (cur = cs->first; cur; cur = cur->next)
        printf("%dt%dn", cur->val, cur->cnt);
}
 
#define SIZE 10
 
int main(void) {
    int arr[SIZE] = { 2, 3, 5, 5, 7, 8, 2, 5, 8, 3 };
    int i;
    counters_t * cs;
    if ((cs = new_counters()) == NULL) {
        fprintf(stderr, "Error creating counters!n");
        exit(1);
    }
    printf("Array:n");
    for (i = 0; i < SIZE; ++i) {
        printf("%d ", arr[i]);
        if (insert(cs, arr[i])) {
            fprintf(stderr, "Error inserting value!n");
            delete_counters(cs);
            exit(1);
        }
    }
    printf("n");
    print_counters(cs);
    delete_counters(cs);
 
    exit(0);
}