Add elements to two arrays based on condition - c

Question

There is an array x and I want to put its elements in arrays y and z based of some if condition.
int x[10],y[5],z[5];
for(for x array)
if(some condition)
{
//put in y
}
else {
//put in z
}
What I am not able to figure out is how to keep track of indexes in array y and z while assigning the elements. Any help/suggestion is appreciated. Thnak you.

Answer 1

When dealing with any arrays, C doesn't provide any bounds checking, that responsibility is left solely to you as the C-programmer. Attempting to access an element outside the defined array bounds invokes Undefined Behavior.
To prevent straying off into undefined behavior, always keep track to the current array index (when filling) and test against a Max array index. While you can use sizeof array / sizeof *array be aware that is only valid within the scope where the array was declared. Once the array is passed as a parameter to a function, the first level of indirection is converted to a pointer and sizeof thereafter will return sizeof (a pointer) not the array size.
Don't use magic numbers in your code. If you need constants in your code, define them at the top of your code, either with, e.g. #define XMAX 10, or use an enum to declare them. That way, if you ever need to change the bounds (or whatever the constant is used for), you have a single location at the top, and you don't have to go picking though every loop or conditional you hardcoded some magic number in.
A quick example in your case separating the odd/even numbers in x into y & z could be done by:
#include <stdio.h>
enum { YZMAX = 5, XMAX = 10 };
int main (void) {
int x[XMAX] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9},
y[YZMAX] = {0},
z[YZMAX] = {0};
size_t yndx = 0, zndx = 0;
for (int i = 0; i < XMAX; i++)
if (yndx < YZMAX && (x[i] & 1) == 0) {
y[yndx++] = x[i];
}
else if (zndx < YZMAX) {
z[zndx++] = x[i];
}
for (int i = 0; i < YZMAX; i++)
printf (" y[%d] : %d z[%d] : %d\n", i, y[i], i, z[i]);
return 0;
}
Example Use/Output
$ ./bin/xyzindex
y[0] : 0 z[0] : 1
y[1] : 2 z[1] : 3
y[2] : 4 z[2] : 5
y[3] : 6 z[3] : 7
y[4] : 8 z[4] : 9
Reading a 2D Array from Command Line Arguments
Whether you are reading a 1D array or 2D array, the process is the same. The only thing that changes is keeping up with one additional index. In your comment, you provide the additional twist of having multiple integers contained within a single command-line argument string. While it may appear confusing at first, if you think about it, it is no different than reading multiple integers from a single line of text in a file.
While you suggest two arguments of "2 4" and "3 5", there is no reason to worry about how many integers are in each argument. Handling "2 4 3" and "5" would work the same (or "2 4 3 5" or 2 4 3 5 for that matter)
note: you will generally not want to provide array values as command-line arguments (you can, but...) you generally want to read values from a file (or stdin - a file as well). Command line arguments are generally used to influence code behavior (e.g., --help, etc..) or provide filenames from which values can be read rather than providing the values themselves. It's up to you. (for simple test code it is fine to use the arguments for anything you need)
The key is just to read each integer (regardless of which argument it comes from) update your row/column indexes, and take whatever additional steps are required before returning to read the next integer. For example:
#include <stdio.h>
#define ROW 2
#define COL 2
#define BASE 10
int main (int argc, char **argv) {
if (argc < 2) { /* validate at least one argument string given */
fprintf (stderr, "error: insufficient input.\n"
"usage: %s [followed by %d integers]\n",
argv[0], ROW + COL);
return 1;
}
int arr[ROW][COL] = {{0}}, /* array */
row = 0, col = 0, /* row / col indexes */
ndx = 1; /* argument index */
/* loop over each argument until array filled.
* you don't know how many integers could be
* in each argument., e.g. ("2 4" and "3 5")
*/
while (ndx < argc) {
char *p = argv[ndx]; /* pointer to current argument */
int offset = 0, tmp;
/* convert each int in argument and get offset in arg for next */
while (sscanf (p, "%d%n", &tmp, &offset) == 1)
{
arr[row][col++] = tmp; /* assign value to element */
if (col == COL) /* test if column full */
row++, col = 0; /* increment row, zero column */
if (row == ROW) /* test if array full */
goto done; /* goto required to break 2 loops */
p += offset; /* increment p by offset */
}
ndx++; /* process next argument */
}
done:;
for (int i = 0; i < ROW; i++) { /* for each row */
for (int j = 0; j < COL; j++) /* for each col */
printf (" %2d", arr[i][j]);
putchar ('\n');
}
return 0;
}
Example Use/Output
$ ./bin/array_2d_args "2 4" "3 5"
2 4
3 5
$ ./bin/array_2d_args "2 4 3" "5"
2 4
3 5
$ ./bin/array_2d_args "2 4 3 5"
2 4
3 5
$ ./bin/array_2d_args 2 4 3 5
2 4
3 5
Reading from a file would work the same way. Instead of looping over arguments, you would simply loop over lines read with fgets processing the integers in each line of text read with sscanf or handling both the read and conversion of single values with fscanf.
note: there are advantages in using strtol for the conversion to integer rather than sscanf, as it provides a great deal more error handling information, but also requires a bit of additional code to preform the error checking.
Reading values from a file or stdin
As noted above, in many cases it is actually easier to read directly from a file rather than using command-line arguments. Here is a short example. In this case rather than reading an integer then and handling the indexes, we use two loops to limit the number of integers read to the number of times the loops execute. Either way is fine:
#include <stdio.h>
#define ROW 2
#define COL 2
int main (int argc, char **argv) {
int arr[ROW][COL] = {{0}};
/* open filename given by argv[1] (or use stdin as default) */
FILE *fp = argc > 1 ? fopen (argv[1], "r") : stdin;
if (!fp) { /* validate file open for reading */
fprintf (stderr, "error: file open failed '%s'.\n", argv[1]);
return 1;
}
for (int i = 0; i < ROW; i++) /* for each row */
for (int j = 0; j < COL; j++) /* for each col */
if (fscanf (fp, "%d", &arr[i][j]) != 1) { /* read element */
/* handle error */
fprintf (stderr, "error: invalid input arr[%d][%d].\n", i, j);
return 1;
}
if (fp != stdin) fclose (fp); /* close file if not stdin */
for (int i = 0; i < ROW; i++) { /* for each row */
for (int j = 0; j < COL; j++) /* for each col */
printf (" %2d", arr[i][j]);
putchar ('\n');
}
return 0;
}
Example Input File
$ cat dat/2x2.txt
2 4
3 5
Example Use/Output
$ ./bin/array_2d_file <dat/2x2.txt
2 4
3 5
note: there is no need that the input be in rows or columns since you are reading a single integer at a time with fscanf -- and -- the "%d" format specifier will skip all leading whitespace (including the '\n') before reading the next number. So the input can be a on a single line or on 4-lines, e.g.
All on one line:
$ echo "2 4 3 5"
2 4 3 5
$ echo "2 4 3 5" | ./bin/array_2d_file
2 4
3 5
or mixed on multiple lines
$ printf "2\n4\n3\n\n5\n"
2
4
3
5
$ printf "2\n4\n3\n\n5\n" | ./bin/array_2d_file
2 4
3 5
or
$ printf "2\n4 3\n\n5\n"
2
4 3
5
$ printf "2\n4 3\n\n5\n" | ./bin/array_2d_file
2 4
3 5
Look things over in all answers and let me know if you have further questions.

Answer 2

For statically defined arrays;
int x[10],y[5],z[5];
for(for x array)
if(some condition)
{
//yindex is the index of the y array where you are going to assign the value
if(yindex < sizeof(y) / sizeof(y[0]))
{
y[yindex] = value;
}
}

Answer 3

you can give like that condition if you will initialize at least one array (y or z) with 0, maybe it will be helpful for you. Example:
#include<stdio.h>
int main()
{
//put values in x array otherwise it will take by default garbage value.
int i, j, k, x[10], y[5]={0}, z[5];
for(i=0; i<10; i++)
{
scanf("%d",&x[i]); //for console input.
}
for(i=0, j=0, k=0; i<10; i++)
{
if(y[j]==0 && j<5) //if(y[j]==0)
{
//put in y
y[j]=x[i];
printf("%d ",y[j]);
j++;
} else {
//put in z
z[k]=x[i];
printf("%d ",z[k]);
k++;
}
}
}
when you assign size only like x[10] without assigning any elements in C then it will store garbage values in array so if you want to store one array to another array then have to give condition for if() whatever you want to do.