How to validate a value in a two-dimensional array? - c

Question

I have a two-dimensional array of integers and i want to accept only values that are different from those that were already read. I tried to do it this way:
for (i = 0; i < 5; i++)
{
for (j = 0; j < 5; j++)
{
printf("Number: ");
scanf("%d", &d[i][j]);
for (k = 0; k < i; k++)
{
for (l = 0; l < j; l++)
{
while (d[i][j] == d[k][l])
{
printf("Number: ");
scanf("%d", &d[i][j]);
}
}
}
}
}
Turns out it doesn't work correctly. How can i make this validation work?

Answer 1

The while statement shouldn't be in the inner loop, because it is only validating against that particular k, l and not against the other indices.
Split out your test into a separate function to test for a duplicate up to i,j:
int duplicateExists(float value, int i, int j)
{
for (k = 0; k <= i; k++)
{
for (l = 0; ((k < i) && (l < 5)) || (l < j); l++)
{
if(d[k][l] == value)
return 1;
}
}
return 0;
}
Then you can validate like this:
for (i = 0; i < 5; i++)
{
for (j = 0; j < 5; j++)
{
printf ("Number: ");
scanf ("%d", &d[i][j]);
while (duplicateExists(d[i][j], i, j))
{
printf ("Number: ");
scanf ("%d", &d[i][j]);
}
}
}

Answer 2

The problem is that you are not checking every previously entered value.
So when i == 2 and j == 3, values have been inputted into d[0][0 through 4], d[1][0 through 4], and d[2][0 through 2]. However, because of your for (l = 0; l < j; l++), you are checking d[0][0 through 2], d[1][0 through 2], and d[2][0 through 2].

Answer 3

Let's say your code has reached the inner loop, with some value of i and j.
The "validation" needs to compare d[i][j] against the following sets of values
set1: for k = 0 to i-1 compare with d[k][l] for l = 0 to 5
set2: compare with d[i][l] for l = 0 to j-1
Essentially set1 is about comparing all the rows previously read, and set2 is comparing all preceding elements in the current row.
Your two nested loops are not comparing against the combination/union of those two sets.
Note: it is not a particularly good idea to name a variable l, since it looks like a 1 (numeral one) and it is easy to make typos that are hard to see, but really screw up the meaning of your code.

Answer 4

You should try to change your code like this. Put an 'if', so you can see if the number you wrote is the same, of course you should change my code, but this is the base of the logic.
printf("Number: ");
scanf ("%d", &numb);
for (k = 0; k < i; k++)
{
for (l = 0; l < j; l++)
{
if (numb == d[k][j])
{
printf("Same number, try again\n");
}
else
{
d[i][j] = numb;
}
}

Answer 5

You have missed some of the previous entries because you didn't check the whole of each previous row, and didn't check any of the current row.
int had;
for (i = 0; i < 5; i++)
{
for (j = 0; j < 5; j++)
{
do
{
had = 0;
printf ("Number: ");
scanf ("%d", &d[i][j]);
// check previous rows
for (k = 0; k < i; k++)
{
for (l = 0; l < 5; l++) // <--- change end condition
{
if (d[i][j] == d[k][l])
{
had = 1;
continue;
}
}
}
//check this row
for (l = 0; l < j; l++)
{
if (d[i][j] == d[i][l])
{
had = 1;
continue;
}
}
} while (had);
}
}

Answer 6

It will benefit you if you break the task down into a couple of functions as indicated by others. This does away with, at minimum, 4 independent iteration variables for the indexes in the nested loop. After you have your initial array, then your primary goal is to iterate over each value in your original and verify that the new value you are attempting to add to the second doesn't exist in the first.
Take for example an existing array and an empty second array (a and b below):
int a[][ASZ] = {{19, 1,38,51,37},
{95,74,42,23,76},
{17,24,14,22,25},
{11,50,10,84,45},
{78,44,66,46,98}};
int b[ASZ][ASZ] = {{0}};
(Note: any significantly large array, iterating over every value for every addition to the second is very inefficient. To improve the efficient, it would make sense to sort the original (even in a temp array) allowing a bisection/bracketing type search to dramatically cut down on the iterations needed to check for duplicate values)
Checking for duplicates, in its simplest sense could be an integer function taking the original array and the proposed value as arguments (along with the array size) and then comparing the values, returning 1 or 0 for unique or non-unique determinations. Something like the following:
int check_uniq (int a[][ASZ], size_t n, int v)
{
size_t i, j;
for (i = 0; i < n; i++)
for (j = 0; j < ASZ; j++)
if (a[i][j] == v)
return 0;
return 1;
}
(where: ASZ is simply a constant for the row-size of the array)
With a way to check for unique values, filling the array reduces to your basic approach:
/* fill second array with values unique to values in a[][] */
for (i = 0; i < n; i++) {
for (j = 0; j < ASZ; j++) {
for (;;) {
tmp = rand() % 100 + 1;
if (check_uniq (a, n, tmp))
break;
}
b[i][j] = tmp;
}
}
(note: you can use any type of internal loop you prefer. for, while, or do .. while. A simple continual iteration with a break after a unique value is found is as simple as anything else).
Lastly, testing. Rather than having to type proposed values over and over during testing, sometimes it makes sense to set up a simple way to fill the second array with random numbers to allow thorough validation. The following is a short example putting all the pieces together. Hopefully this will help. Let me know if you have any questions:
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define ASZ 5
int check_uniq (int a[][ASZ], size_t n, int v);
void prn_array (int a[][ASZ], size_t n);
void prn_array_1d (int a[][ASZ], size_t n);
void quick_sort (int *a, size_t n);
int main (void) {
int a[][ASZ] = {{19, 1,38,51,37},
{95,74,42,23,76},
{17,24,14,22,25},
{11,50,10,84,45},
{78,44,66,46,98}};
int b[ASZ][ASZ] = {{0}};
int tmp = 0;
size_t i, j;
const size_t n = sizeof a/sizeof *a;
srand (time (NULL));
/* fill second array with values unique to values in a[][] */
for (i = 0; i < n; i++) {
for (j = 0; j < ASZ; j++) {
for (;;) {
tmp = rand() % 100 + 1;
if (check_uniq (a, n, tmp))
break;
}
b[i][j] = tmp;
}
}
printf ("\n the original array is:\n\n");
prn_array (a, n);
printf ("\n the second array with unique values is:\n\n");
prn_array (b, n);
printf ("\n comparison in sorted 1D array format (easier to check):\n\n");
prn_array_1d (a, n);
printf ("\n");
prn_array_1d (b, n);
printf ("\n\n");
return 0;
}
int check_uniq (int a[][ASZ], size_t n, int v)
{
size_t i, j;
for (i = 0; i < n; i++)
for (j = 0; j < ASZ; j++)
if (a[i][j] == v)
return 0;
return 1;
}
void prn_array (int a[][ASZ], size_t n)
{
size_t i, j;
for (i = 0; i < n; i++) {
for (j = 0; j < ASZ; j++)
printf (" %3d", a[i][j]);
printf ("\n");
}
}
void prn_array_1d (int a[][ASZ], size_t n)
{
size_t i, j;
int tmp [n * ASZ];
for (i = 0; i < n; i++)
for (j = 0; j < ASZ; j++)
tmp [i * ASZ + j] = a[i][j];
quick_sort (tmp, n * ASZ);
for (i = 0; i < n * ASZ; i++)
printf (" %3d", tmp[i]);
}
void quick_sort (int *a, size_t n)
{
int pvt, tmp;
size_t i, j;
if (n < 2) return;
pvt = a[n / 2];
for (i = 0, j = n - 1;; i++, j--)
{
while (a[i] < pvt) i++;
while (pvt < a[j]) j--;
if (i >= j)
break;
tmp = a[i];
a[i] = a[j];
a[j] = tmp;
}
quick_sort (a, i);
quick_sort (a + i, n - i);
}
Output
$ ./bin/array_2d_fill_uniq
the original array is:
19 1 38 51 37
95 74 42 23 76
17 24 14 22 25
11 50 10 84 45
78 44 66 46 98
the second array with unique values is:
81 16 34 69 65
87 88 35 67 79
89 43 55 18 12
77 83 93 9 99
34 94 75 2 72
comparison in sorted 1D array format (easier to check):
1 10 11 14 17 19 22 23 24 25 37 38 42 44 45 46 50 51 66 74 76 78 84 95 98
2 9 12 16 18 34 34 35 43 55 65 67 69 72 75 77 79 81 83 87 88 89 93 94 99