在数组中查找重复项 - 语法说明

Question

I don't have any idea about this syntax int *count = new int[sizeof(int)* (size - 2)]

What kind of array that will create.

I thought they are trying to create map like structure. But how does it work?

#include <bits/stdc++.h>
using namespace std;
 
void printRepeating(int arr[], int size)
{
    int *count = new int[sizeof(int)*(size - 2)];
    int i;
         
    cout << " Repeating elements are ";
    for(i = 0; i < size; i++)
    {
        if(count[arr[i]] == 1)
            cout << arr[i] << " ";
        else
            count[arr[i]]++;
    }
}
 
// Driver code
int main()
{
    int arr[] = {4, 2, 4, 5, 2, 3, 1};
    int arr_size = sizeof(arr)/sizeof(arr[0]);
    printRepeating(arr, arr_size);
    return 0;
}
 
// This is code is contributed by rathbhupendra

Answer 1

Finding duplications in an array is of course a solved problem. IMHO a very simple solution is:

1. sort the array use std::sort()
2. use a loop to check if an element is equal to it's successor, ie. for(int i = 1; i < num_elements; i++){ if(arr[i-1]==arr[i]){...duplicate....}}

This requires O(n) memory and O(n*log(n)) time, so it's quite ok. You can also use a hashmap, but that's pretty much the same.

---

Anyways, to your question(s):

int *count = new int[sizeof(int)* (size - 2)]; 

This is incorrect. I assume it used to be this C code:

int num_elements = size-2; // we want size-2 elements (not sure why)
int total_bytes = sizeof(int) * num_elements; 
int *count = calloc(total_bytes); // reserve space, and set to 0

Which one could translate to this C++ code:

int num_elements = size-2; 
int * count = new int[num_elements]{0}; // alloc and set to zero

So the person who did the port misunderstands fundamentals about C++.

Let's dig further.

---

For the sake of it, the problem formulation appears to be:

You are given an array of n+2 elements. All elements of the array are in range 1 to n. And all elements occur once except two numbers which occur twice. Find the two repeating numbers

I have made tiny changes to make the solution less crazy, and I've added annotations.

// #include <bits/stdc++.h> is a bad choice. 
// This includes _EVERYTHING_ in C++, 
// but it only works in GCC afaik. For this particular 
// case we just need cout, so: 
#include <iostream>

// using the std namespace like this spills function calls like crazy in the global namespace. 
// it is both, conventient and "not too bad" (imho) in cpp files, 
// but never ever do this in .h files where it affects multiple cpp files. 
using namespace std;
 
void printRepeating(int arr[], int size)
{
    // create a new array of size-2 and set to zero
    int *count = new int[(size - 2)]{0};
    int i;
         
    cout << " Repeating elements are ";

    // loop all elements
    for(i = 0; i < size; i++)
    {
        int value = arr[i]; 

        // increase the count for `value`
        // note that if value<=0 or value>size-2, 
        // then the program will crash! 
        // the problem description is contrived, but it does 
        // state that all values need to be >0 and <=size-2, 
        // so this next array access is fine! 
        count[value-1]++;
        // we still have to subtract 1, because C arrays start 
        // at index 0, but our problem description says we start at 1. 
        // we could also create an array of size-1 and 
        // "ignore" the first position in count[0] (it would never get used!)


        // if the element appears the second time... 
        if(count[value-1] == 2){
            // then print it
            cout << value << " ";
            // btw: if you check with count[value-1]==2, then only
            // the first duplicate is printed. 
            // you could compare with count[value-1]>=2 then all 
            // repeating elements are printed repeatetly. 
        }
    }

    // free up the memory. we allocated with `new[]`
    // so we also have to use `delete[]`
    delete [] count; 
}
 
// Driver code
int main()
{
    int arr[] = {4, 2, 4, 5, 2, 3, 1};
    // next line is a standard trick. 
    // a single int consumes 4bytes (typically), 
    // the array will have size 7*4=28 bytes, so sizeof(arr)=28
    // the first element is an int, so sizeof(arr[0]) = 4
    // so sizeof(arr)/sizeof(arr[0]) = 7
    // c and c++ don't have arr.length like java,etc., that's 
    // why under certain circumstances this "trick" is used. 
    int arr_size = sizeof(arr)/sizeof(arr[0]);
    // call the function
    printRepeating(arr, arr_size);
    return 0;
}
 
// This is code is contributed by rathbhupendra. 
// Maybe fixed and annotated by hansi:)

---

I hope this helps you and answers some questions. Good luck with your C++ adventures!