Change the occurrences of a value in a matrix

I was trying to solve the following problem:

• Count the occurrences in each row of a required input value in a 4x4 matrix

• Then, change the occurrence to the value 0 only in the lines where the value appears two or more times

For the first step I didn't have any problems, but the second is giving me a lot of trouble.

After several attempts I managed to get to this point:

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#define N 4
int main() {
int mat[N][N] = { {6, 75, 45, 6}, {30, 6, 77, 64}, {15, 35, 6, 43}, {6, 95, 47, 6} };
int val;
int i, j;
int count_occ = 0;
srand(time(NULL));
/* for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
mat[i][j] = (rand() % 99 + 1);  
}
} */
printf("Matrix original: \n");
for (i = 0; i < N; i++) {
for (j = 0; j < N; j++) {
printf("%3d", mat[i][j]);
}
printf("\n");
}
puts("");
printf("Insert a value to search for: ");
scanf("%d", &val);
puts("");
// Counting occurrencies of a value in each row
for (i = 0; i < N; i++) {
for (j = 0; j < N; j++) {
if (mat[i][j] == val) {
count_occ++;
if (count_occ >= 2) {
mat[i][j] = 0;
}
}
}
printf("There are %d occurrencies of value %d in row %d. \n", count_occ, val, i);
count_occ = 0;
}
puts("");
printf("Matrix modified: \n");
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
printf("%3d", mat[i][j]);
}
printf("\n");
}
puts("");
}

With the following output:

Matrix original: 
6 75 45  6
30  6 77 64
15 35  6 43
6 95 47  6
Insert a value to search for: 6
There are 2 occurrencies of value 6 in row 0. 
There are 1 occurrencies of value 6 in row 1. 
There are 1 occurrencies of value 6 in row 2. 
There are 2 occurrencies of value 6 in row 3. 
Matrix modified: 
6 75 45  0
30  6 77 64
15 35  6 43
6 95 47  0

As you can see, only some values ​​of the rows in question are modified, but not all the necessary ones.

Could anyone give me some advice on how to do this? I'm freaking out

Your current algorithm is the following:

> For every number in the matrix, if the number is the input value and the input value has already been encountered on that line, then set the number to 0.

This algorithm is incorrect, as it will never set the first occurrence of the input value on a line to 0.

One simple correct algorithm would be the following:

> For every line in the matrix, first determine whether the input value occurs at least twice on that line. If it does not occur at least twice, then do nothing. Otherwise, go back to the start of the line and replace all occurrences of the input value to 0.

Here is a demonstration program:

#include <stdio.h>
#define N 4
void print_matrix( int matrix[N][N] );
int main( void )
{
int mat[N][N] =
{
{  6, 75, 45, 6  },
{ 30,  6, 77, 64 },
{ 15, 35,  6, 43 },
{  6, 95, 47,  6 }
};
int val;
//print original matrix
printf( "Matrix original:\n" );
print_matrix( mat );
//add spacing
puts( "" );
//get input from user
printf( "Insert a value to search for: " );
scanf( "%d", &val );
//add spacing
puts( "" );
//process one row per loop iteration
for ( int i = 0; i < N; i++ )
{
int count_occ = 0;
//count number of occurrences in the current row
for ( int j = 0; j < N; j++ )
{
if ( mat[i][j] == val )
{
count_occ++;
}
}
//print information about number of occurrences
printf(
"There are %d occurrences of value %d in row %d.\n",
count_occ, val, i
);
//determine whether number of occurrences on the
//current line is at least two
if ( count_occ >= 2 )
{
//replace all occurrences on the current line
//with zero
for ( int j = 0; j < N; j++ )
{
if ( mat[i][j] == val )
{
mat[i][j] = 0;
}
}
}
}
//add spacing
puts( "" );
//print modified matrix
printf( "Matrix modified:\n" );
print_matrix( mat );
//add spacing
puts( "" );
}
void print_matrix( int matrix[N][N] )
{
for ( int i = 0; i < N; i++ )
{
for ( int j = 0; j < N; j++ )
{
printf( "%3d", matrix[i][j] );
}
printf( "\n" );
}
}

This program has the following behavior:

Matrix original:
6 75 45  6
30  6 77 64
15 35  6 43
6 95 47  6
Insert a value to search for: 6
There are 2 occurrences of value 6 in row 0.
There are 1 occurrences of value 6 in row 1.
There are 1 occurrences of value 6 in row 2.
There are 2 occurrences of value 6 in row 3.
Matrix modified:
0 75 45  0
30  6 77 64
15 35  6 43
0 95 47  0

This algorithm could be made more efficient by remembering the index of the first occurrence, so that you don't have to go back to the start of the line. However, this would make the algorithm also more complicated, so this optimization would only be worthwhile for larger matrixes.

The simplest (and inefficient in many ways) method is to make second pair of loops.
The first pair of loops (based on yours) is now only counting occurrences and saving it to the row_occ[N] array. The second pair of loops is only replacing values. It's inefficient, but quite simple.

int row_occ[N]; // ADDED
// This loop will only count
for (i = 0; i < N; i++)
{
for (j = 0; j < N; j++)
{
if (mat[i][j] == val)
{
count_occ++;
}
}
printf("There are %d occurrencies of value %d in row %d. \n", count_occ, val, i);
row_occ[i] = count_occ; // ADDED
count_occ = 0;
}
// This loop will only replace
for (i = 0; i < N; i++)
{
if (row_occ[i] < 2)
continue; // we will replace only if value occurs 2 or more times.
for (j = 0; j < N; j++)
{
if (mat[i][j] == val)
{
mat[i][j] = 0; //replacing
}
}
}

Better approach (and the one you are trying to implement) is to just add a single variable that will remember index of last occurrence of the value. When you have this index, you can replace not only current occurrence, but also the previous.

for (i = 0; i < N; i++)
{
int prev_occ;
for (j = 0; j < N; j++)
{
if (mat[i][j] == val)
{
count_occ++;
if (count_occ >= 2)
{
mat[i][prev_occ] = 0;
mat[i][j] = 0;
}
prev_occ = j;
}
}
printf("There are %d occurrencies of value %d in row %d. \n", count_occ, val, i);
count_occ = 0;
}

The first approach is not as nonsense as it looks like. Imagine huge array and condition of replacement "100 or more occurrences". IMHO it will be quite ok to implement it in the first method. At last as long as it is not the challenge of the most optimized code, but rather the easiest to write, understand and maintain.