Counting how many times a number appears in a random array - arrays

Question

C function.
Heres my working code. It shows this output when given a random array size;
Enter the size of the array: 20
What's in the array:
3 6 17 15 13 15 6 12 9 1 2 7 10 19 3 6 0 6 12 16
3 occurs 2 times.
6 occurs 4 times.
15 occurs 2 times.
6 occurs 3 times.
12 occurs 2 times.
6 occurs 2 times.
However I was wondering how you would go about implementing once a certain number has been searched for how to not repeat the loop?
#include <stdio.h>
#include <stdlib.h>
/* shows duplicate numbers in randomly generated array*/
void display_repeats(int *a, int n){
int i, j;
int count = 0;
for(i = 0; i < n; i++){
for(j = i; j < n; j++){
if(a[i] == a[j]){
count++;
}
}
if(count > 1){
printf("%3d occurs %3d times.", a[i], count);
printf("\n");
}
count = 0;
}
}
int main(void){
int array_size = 0;
int *my_array;
int i = 0;
printf("Enter the size of the array: ");
scanf("%d", &array_size);
/*initialises the array to the appropriate size */
my_array = malloc(array_size * sizeof my_array[0]);
if(NULL == my_array){
fprintf(stderr, "memory allocation failed!\n");
return EXIT_FAILURE;
}
for(i = 0; i < array_size; i++){
my_array[i] = rand() % array_size;
}
printf("What's in the array:\n");
for(i = 0; i < array_size; i++){
printf("%d ", my_array[I]);
}
printf("\n");
display_repeats(my_array, array_size);
/* release the memory associated with the array */
free(my_array);
return EXIT_SUCCESS;
}

Answer 1

You can sort the array and count runs of each number. Time complexity is O(n log(n)) but without a clean hashing solution, it should be reasonable and is the easiest approach.
As an aside, it's a good idea to separate printing (a side effect) from logic. Return results as a data structure and let the caller decide what to do with it. Keeping logic and printing tightly coupled harms reusability and prevents you from programmatically operating on the data after applying a function.
Here's a quick proof of concept. Plenty of room for improvement based on the above tips--and consider making a copy of the int array before sorting to keep the function idempotent if you do move this out of main.
#include <stdio.h>
#include <stdlib.h>
int cmp_ints(const void *a, const void *b) {
return *((const int *)a) - *((const int *)b);
}
int main(void) {
int nums[] = {1, 1, 5, 6, 1, 6, 2, 4, 6, 8};
int len = sizeof nums / sizeof nums[0];
qsort(nums, len, sizeof *nums, cmp_ints);
for (int i = 0; i < len;) {
int count = 1;
int num = nums[i++];
for (; i < len && nums[i] == num; i++, count++);
printf("%d => %d\n", num, count);
}
return 0;
}
Output:
1 => 3
2 => 1
4 => 1
5 => 1
6 => 3
8 => 1

Answer 2

The following proposed code:
cleanly compiles
properly initializes the rand() function via a call to srand()
properly checks for success/failure of the call to scanf() and properly handles any failure by informing the user via stderr and exiting the code
makes use of the Variable Length Array feature of C, so no need for dynamic memory
limits the scope of local variables when ever possible
does not repeat the examination for a value more than once
makes use of appropriate horizontal and vertical spacing for readability
outputs the values in the array in ascending order
Performs the desired functionality
and now, the proposed code:
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
/* shows duplicate numbers in randomly generated array*/
/* note: order of parameters in function
* so can clearly indicate the array sizing
*/
void display_repeats(int arraySize, int Array[ arraySize ] )
{
int minValue = 0;
int maxValue = 0;
for( int i = 0; i < arraySize; i++ )
{
if( Array[i] > maxValue )
{
maxValue = Array[i];
}
}
for( int j = minValue; j <= maxValue; j++ )
{
int count = 0;
for( int i = 0; i < arraySize; i++)
{
if( Array[i] == j )
{
count++;
}
}
if(count > 1 )
{
printf( "%d occurs %d times.\n", j, count );
}
}
}
int main( void )
{
int array_size = 0;
printf( "Enter the size of the array: " );
if( scanf( "%d", &array_size ) != 1 )
{
fprintf( stderr, "scanf for array size failed\n" );
exit( EXIT_FAILURE );
}
/* use VLA feature of C to declare array */
int my_array[ array_size ];
srand( (unsigned)time(NULL) );
for( int i = 0; i < array_size; i++ )
{
my_array[i] = rand() % array_size;
}
printf( "What's in the array:\n" );
for( int i = 0; i < array_size; i++ )
{
printf( "%d ", my_array[i] );
}
printf( "\n" );
display_repeats( array_size, my_array );
}
A typical run of the proposed code results in:
Enter the size of the array: 100
What's in the array:
19 69 68 90 25 8 44 64 33 3 28 4 4 43 22 6 19 93 70 63 34 96 42 31 74 9 72 49 34 12 12 53 33 80 95 10 40 39 74 26 94 55 82 98 98 56 56 69 49 78 33 35 75 75 19 1 36 91 50 70 55 63 76 40 95 71 51 88 63 25 14 9 80 48 8 30 4 16 0 5 95 33 93 22 60 12 23 96 3 74 19 58 89 95 50 84 18 1 24 33
1 occurs 2 times.
3 occurs 2 times.
4 occurs 3 times.
8 occurs 2 times.
9 occurs 2 times.
12 occurs 3 times.
19 occurs 4 times.
22 occurs 2 times.
25 occurs 2 times.
33 occurs 5 times.
34 occurs 2 times.
40 occurs 2 times.
49 occurs 2 times.
50 occurs 2 times.
55 occurs 2 times.
56 occurs 2 times.
63 occurs 3 times.
69 occurs 2 times.
70 occurs 2 times.
74 occurs 3 times.
75 occurs 2 times.
80 occurs 2 times.
93 occurs 2 times.
95 occurs 4 times.
96 occurs 2 times.
98 occurs 2 times.

Answer 3

An implementation of the first suggestion by ggorlen, creating an array that stores whether the number at each index has already been seen.
void display_repeats(int *a, int n){
int i, j;
int count = 0;
int seen[n]; //stores 1 if the number at this index has already been seen, 0 if not
for (int i = 0; i<n; i++) seen[i] = 0; //initializes values to 0
for(i = 0; i < n; i++){
if (seen[i]) continue; //skips this iteration of the for loop if this number has already been seen
for(j = i; j < n; j++){
if(a[i] == a[j]){
count++;
seen[j] = 1; //notes that we already seen the number at this index
}
}
if(count > 1){
printf("%3d occurs %3d times.", a[i], count);
printf("\n");
}
count = 0;
}
}