Реализовать функцию, возвращающую набор элементов, которые встречаются в массиве более одного раза

сhar array[10];
array.insert('A');
array.insert('C');
array.insert('A');
array.insert('C');
array.insert('K');
array.insert('C');
array.insert('K');
array.insert('E');
array.insert('Q');
array.insert('P');
int FindDuplicates(char array)
{
for(int  index = 0; index  != 9; ++index)
{
    int  temp = 0;
    if (index  == array)
     ++temp;
}
};

#include <iostream>
#include <vector>
#include <string>
#include <iterator>
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <cctype>
#include <tuple>
#include <climits>
#include <cstdlib>
 
template<size_t size>
char* FindDuplicates(char _array[size])
{
    char *duplicates = new char[size]{0};
    size_t index = 0;
 
    for (size_t i = 0; i < size; ++i)
    {
        if (std::count(_array, size+_array, _array[i]) > 1)
            if (!std::count(duplicates, size+duplicates, _array[i]))
            duplicates[index++] = _array[i];
    }
 
 
    return duplicates;
};
 
int main(int argc, char *argv[])
{
 
    char _array[10] = {'A', 'C', 'A', 'C', 'K', 'C', 'K', 'E', 'Q', 'P'};
 
    char *duplicates =FindDuplicates<10>(_array);
 
    for (int i = 0; i < 10 && duplicates[i]; ++i)
        std::cout << duplicates[i] << std::endl;
 
    // [ANTIWARNING] unused parameters: 'argc', 'argv'
    return 0; (void)argc;(void)argv;
}

#include <iostream>
#include <algorithm>
#include <unordered_map>
using namespace std;
template<size_t N>
unordered_map<char,int> f(char (&a)[N]) {
    unordered_map<char,int>m;
    for(int i=0; i!=N; i++) {
        ++m[a[i]];
    }
 
    return m;
}
int main() {
    char a[]= {'A','C','A','C','K','C','K','E','Q','P'};
    auto ma=f(a);
    for(const auto&x:ma) {
        if(x.second>1) {
            cout<<x.first<<" "<<x.second<<endl;
        }
    }
    return 0;
}

#include "stdafx.h"
#include <iostream>
#include <vector>
 
template<size_t size>
int* FindDuplicates(int array[size])
{
    std::vector<size_t> duplicates(size);
    size_t index = 0;
 
    for (size_t i = 0; i < size; ++i)
    {
        int temp = std::count(array, size + array, array[i]);
        int temp1 = std::count(duplicates, size + duplicates, array[i]);
        if (temp > 1)
            if (!temp1)
                duplicates[index++] = array[i];
    }
    return duplicates;
};
 
int main(int argc, int *argv[])
{
    int array[10] = { 1, 4, 5, 7, 1, 8, 9, 9, 3};
    int* duplicates = FindDuplicates<10>(array);
 
    for (int i = 0; i < 10 && duplicates[i]; ++i)
        std::cout << duplicates[i] << std::endl;
    return 0; 
}

int temp1 = std::count(duplicates, size + duplicates, array[i]);

return duplicates;

#include <iostream>
#include <utility>
#include <algorithm>
 
using pair = std::pair<int, size_t>;
using pairs = std::vector< pair >;
 
pairs FindDuplicates(int *array, size_t size)
{
    pairs duplicates;
 
    for (size_t i = 0; i < size; ++i)
    {
        int temp = std::count(array, size + array, array[i]);
        int temp1 = [&](const int t){ for(const auto& dupl : duplicates) if(dupl.first == t) return true ;return false; }(array[i]);
        if (temp > 1)
            if (!temp1)
                duplicates.push_back(std::make_pair (array[i], temp));
    }
    return duplicates;
}
 
int main(/*int argc, int *argv[]*/)
{
    constexpr size_t N = 10;
    int array[N] = { 1, 4, 5, 7, 1, 8, 9, 9, 3};
    pairs duplicates = FindDuplicates(array, N);
 
    for (size_t i = 0; i < duplicates.size(); ++i)
        std::cout << duplicates[i].first << " - " << duplicates[i].second << std::endl;
    return 0;
}

#include <iostream>
#include <algorithm>
#include <windows.h> //Шрифт консоли - Lucida Console
 
using namespace std;
 
void MoreThanOne(int* X, int size) //Функция вывода элементов, встречающихся более одного раза
{
    int k, t;
    k = t = 0;
    for (int i = t; i < size; i++)
    {
        if (X[i] == X[i+1])
        {
            k++;
        }
        else
        {
            t = k;
            k = 0;
            if (t > 0)
            {
                cout << X[i] << " ";
            }
        }
    }
}
 
int main()
{
    SetConsoleCP(1251);
    SetConsoleOutputCP(1251);
    int N, k, t;
    cout << "Введите размерность массива:" << endl;
    cout << "N = ";
    cin >> N;
    int* A = new int[N];
    cout << "Введите элементы массива:" << endl;
    for (int i = 0; i < N; i++)
    {
        cin >> A[i];
    }
    sort(A, A + N); //Сортируем массив
    cout << "Искомые элементы:" << endl;
    MoreThanOne(A, N); //Выводим искомые элементы
    cout << endl;
    delete [] A;
    system("pause");
    return 0;
}