PR1EN6: Arrays continued

Lab content

This week is for practicing and reiterating existing knowledge.
Take a look at algorithm tasks – similar ones will be in the test.
Introduction to debugger
- Using distance converter example

Theory nugget 1: Passing text to a function

Many functions that otherwise seem generic and easily reusable, such as input functions or output functions, might have an issue that the text printed on the screen does not really work for us.

One way to handle this is what we did before – we printed the text separately and called the generic input/output function (such as read array, read number, print array etc). In general, this still remains my recommendation. This way you have less complexity that could otherwise hinder the reusability of this function.

However, as an alternative, I’ll give another idea. Let’s follow the basic principle of when to create a function – if you are copy-pasting code because you have a marginal difference between them, try to find a way to handle it using function parameters. This will now offer us a solution – we can pass the text we wish to print as a function parameter.

This works quite well if we want to give the user an input prompt on entering a value, such as an integer. It also can work reasonably well for printing an array with a label before it.

NB! Two additional important thoughts! Both of which we will talk in greater detail in the second part of this semester.

Text is an array, composed of individual character. Each character also has its own index.
As opposed to integer and float arrays, we do not need to pass the length of a text array to print it (we still need it for processing).

include <stdio.h>

#define DEFINED_STRING "Passing by using a macro"

void PrintPassedText(char text[]);

int main(void)
{
    PrintPassedText("Passing by using a constant");
    
    PrintPassedText(DEFINED_STRING);
    
    char inputString[] = "Passing by using a variable";
    PrintPassedText(inputString);
}

void PrintPassedText(char text[])
{
    /* To print double quotes, they need to be escaped first! */
    printf("Text passed to this function: \"%s\"\n", text);
}

include <stdio.h>

#define DEFINED_STRING "Passing by using a macro"

void PrintPassedText(char text[]);

int main(void)

{

PrintPassedText("Passing by using a constant");

PrintPassedText(DEFINED_STRING);

char inputString[] = "Passing by using a variable";

PrintPassedText(inputString);

}

void PrintPassedText(char text[])

{

/* To print double quotes, they need to be escaped first! */

printf("Text passed to this function: \"%s\"\n", text);

}

Theory nugget 2: Passing an array vs a member of an array

In the last lesson, we discussed how arrays behave with functions. Some key points

Arrays were passed as the reference to the location of the array.
We can manipulate arrays in functions. Modifications are persistent.
Array length needs to be passed to the function alongside the array
When passing an array to a function, we use the name of the array only, nothing else.

Additionally, as a reminder, when we put the square brackets after the name of the array in the middle of the code, we are indexing the said array.

This leads us to the following example, where we are highlighting passing an array to a function vs passing a member of the array to a function.

#include <stdio.h>

#define ARR_LEN 5

void PrintNum(int num);
void PrintIntArray(int arr[], int len);

int main(void)
{
	int nums[ARR_LEN] = {9, 24, -2, 3, 25};
	
	/* Passing an entire array */
	PrintIntArray(nums, ARR_LEN);
	
	/* Passing the second number in the array */
	PrintNum(nums[1]);
	
	/* Passing the fourth number in the array */
	PrintNum(nums[3]);
}

void PrintNum(int num)
{
	printf("Passed number: %d\n\n", num);
}

void PrintIntArray(int arr[], int len)
{
	printf("Numbers are: ");
	for (int i = 0; i < len; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n\n");
}

#include <stdio.h>

#define ARR_LEN 5

void PrintNum(int num);

void PrintIntArray(int arr[], int len);

int main(void)

{

int nums[ARR_LEN] = {9, 24, -2, 3, 25};

/* Passing an entire array */

PrintIntArray(nums, ARR_LEN);

/* Passing the second number in the array */

PrintNum(nums[1]);

/* Passing the fourth number in the array */

PrintNum(nums[3]);

}

void PrintNum(int num)

{

printf("Passed number: %d\n\n", num);

}

void PrintIntArray(int arr[], int len)

{

printf("Numbers are: ");

for (int i = 0; i < len; i++)

{

printf("%d ", arr[i]);

}

printf("\n\n");

}

Tasks

In this class, you need to solve two tasks. Additional points are available for extra tasks.

Lab task 1: neg-pos reordering

The lab task is based on an algorithm specified by: https://blue.pri.ee/ttu/programming-i/algorithm-tasks/#Algorithm_3_Reordering_negative_and_positive_numbers

The algorithm is given to you.

The task extends the algorithm with additional functionality.

Algorithm

Requirements

Program must be based on the provided algorithm and extended based on the requirements.
The user is asked for 6 numbers, which are stored in an array.
A second array is created based on the rules set in the algorithm. In the algorithm, it’s referred to as the reordered array. In the task description, we will also refer to it as the algorithmically created array.
A third array is created, which will only contain numbers greater than zero. The length of the array might end up being smaller than the initial array.
After all 3 arrays are populated, they are printed out.
The program must contain a total of four functions. One to read the numbers, one to print an array, one to compose the array made of positive numbers and one to compose the array specified by the algorithm.
All functions for creating and printing of the arrays must be called from the main() function.

Hints and recommendations

Start by completing the reading and printing of the array functions. Both of these you have done previously. Create the necessary array and reuse the functions you created last week. When copying the functions, don’t forget to copy the function comment!

Now lets create a function to make the algorithmically created array. First, create a new array that has the same length as the array where the numbers are entered in. Remember, you cannot return an array from a function. You need to declare this array in the main() function and pass it to this function. To create the new array, follow the algorithm provided. Then print out the array you created. The code should look something similar once completed (names of functions and variables can be different).

ReadIntArray(inputNumbers, NUM_CNT);
CreateRearrangedArra(inputNumbers, rearrangedNumbers, NUM_CNT);

printf("Printing the original array: ");
PrintIntArray(inputNumbers, NUM_CNT);

printf("Printing the modified array: ");
PrintIntArray(rearrangedNumbers, NUM_CNT);

ReadIntArray(inputNumbers, NUM_CNT);

CreateRearrangedArra(inputNumbers, rearrangedNumbers, NUM_CNT);

printf("Printing the original array: ");

PrintIntArray(inputNumbers, NUM_CNT);

printf("Printing the modified array: ");

PrintIntArray(rearrangedNumbers, NUM_CNT);

If you feel that your main() function is starting to be overcrowded, the printed text can be passed with the function call. Look at the first theory nugget.

Now move on to the last function, where you need to create an array with only positive numbers. Most of it will look very similar to what you just did, just shorter as you don’t need to go through the array twice. Think carefully about how to get the length of the new array back to main() function! This array will likely be shorter and have unused slots in the end. Once you have the length of this array, call the printing function from main() to print out the third array.

Testing

In the first test, we’ll run through the most typical case for this program, where we have both positive and negative numbers as well as a zero.

Enter number 1 / 6: 6
Enter number 2 / 6: -9
Enter number 3 / 6: 3
Enter number 4 / 6: -12
Enter number 5 / 6: 0
Enter number 6 / 6: 4

The original array
6 -9 3 -12 0 4

The rearranged array
-9 -12 6 3 0 4

The positive number array
6 3 4

Enter number 1 / 6: 6

Enter number 2 / 6: -9

Enter number 3 / 6: 3

Enter number 4 / 6: -12

Enter number 5 / 6: 0

Enter number 6 / 6: 4

The original array

6 -9 3 -12 0 4

The rearranged array

-9 -12 6 3 0 4

The positive number array

6 3 4

The program should should also account for the situation where no positive input values were given.

Enter number 1 / 6: -1
Enter number 2 / 6: -4
Enter number 3 / 6: -66
Enter number 4 / 6: -97
Enter number 5 / 6: -3
Enter number 6 / 6: -5

The original array
-1 -4 -66 -97 -3 -5

The rearranged array
-1 -4 -66 -97 -3 -5

The positive number array
Empty array

Enter number 1 / 6: -1

Enter number 2 / 6: -4

Enter number 3 / 6: -66

Enter number 4 / 6: -97

Enter number 5 / 6: -3

Enter number 6 / 6: -5

The original array

-1 -4 -66 -97 -3 -5

The rearranged array

-1 -4 -66 -97 -3 -5

The positive number array

Empty array

Lab task 2: Array indexing and comparisons

Read 5 integers from the keyboard
Ask user for two indexes.
- Check that they are within the array bounds before proceeding. If needed, prompt the user again!
- Numeration must be the same as when asking for input
- Recommendation: Print the values corresponding to those indexes from the array for self-check
Using those two values you found, find the following results
- Compare them, print out their relation to each other (e.g. is the first number smaller, greater or equal to the second)
- Create a division operation. The operation must be formed in a way, that the dividend is always greater than the divisor. If needed, swap them around.
- Division answer must be given as a real number. Display 1 place after the comma.
For this task, you need to create four functions. Functions are described for you in varying detail.

Functions to create

1. Reading the array. Reuse the code that you have done before. Copy it in with its comment.

2. Reading the index. For this, you need a new function. Let’s make it a generic and reusable function that you can use in the future – reading an integer in range. This way you can use it whenever you need one (i.e. from 0 to 5; from -10 to 10; etc). If you completed the extra task from last week, you will likely already have this function.

I’m proposing two ways to write this function. Pick the one that you prefer and implement it.

First version assumes that the question (what to enter) is presented to the user before this function is called.

/**
 * Description:    Asks the user for an integer in between the given limits.
 *                 Repeats until requirements are met and returns the number.
 *
 * Parameters:     min - lower bound for the user input (inclusive)
 *                 max - upper bound for the user input (inclusive)
 *
 * Return:         number within the specified limits
 */
int GetIntInRange(int min, int max)
{

}

/**

* Description: Asks the user for an integer in between the given limits.

* Repeats until requirements are met and returns the number.

* Parameters: min - lower bound for the user input (inclusive)

* max - upper bound for the user input (inclusive)

* Return: number within the specified limits

int GetIntInRange(int min, int max)

{

}

The second version will present the prompt to the user by the function itself. This requires the prompt to be passed to this function (theory nugget 1).

/**
 * Description:    Asks the user for an integer in between the given limits.
 *                 Repeats until requirements are met and returns the number.
 *
 * Parameters:     min - lower bound for the user input (inclusive)
 *                 max - upper bound for the user input (inclusive)
 *                 prompt - prompt for user input, printed before entry
 *
 * Return:         number within the specified limits
 */
int GetIntInRange(int min, int max, char prompt[])
{

}

/**

* Description: Asks the user for an integer in between the given limits.

* Repeats until requirements are met and returns the number.

* Parameters: min - lower bound for the user input (inclusive)

* max - upper bound for the user input (inclusive)

* prompt - prompt for user input, printed before entry

* Return: number within the specified limits

int GetIntInRange(int min, int max, char prompt[])

{

}

3. Comparison of values. For this function, you need to pass the two numbers you are comparing. You need to print both numbers and their relation to each other (which one is bigger or are they equal). Output should be using the format “a < b”, “a > b” or “a = b”

NB! To pass numbers to this function, look at the second nugget of information.

/**
 * Description:    Compares the given values (val1 and val2) and prints 
 *                 results of the comparison (which is greater; or equal)
 *
 * Parameters:     val1 - first value being compared
 *                 val2 - second value being compared
 *
 * Return:         -
 */
void CompareValues(int val1, int val2)
{

}

/**

* Description: Compares the given values (val1 and val2) and prints

* results of the comparison (which is greater; or equal)

* Parameters: val1 - first value being compared

* val2 - second value being compared

* Return: -

void CompareValues(int val1, int val2)

{

}

4. Division. Similarly to the last function, this one also expects two values. Again, you need to do the comparison as the last time, but this time instead of printing the results, you need to choose the operands for the division operation.

/**
 * Description:    Compares the given values (val1 and val2). Performs the
 *                 division by dividing greater number with the smaller number.
 *                 Both division operation and result are printed.
 *
 * Parameters:     val1 - first value
 *                 val2 - second value
 *
 * Return:         -
 */
void DivideValues(int val1, int val2)
{

}

/**

* Description: Compares the given values (val1 and val2). Performs the

* division by dividing greater number with the smaller number.

* Both division operation and result are printed.

* Parameters: val1 - first value

* val2 - second value

* Return: -

void DivideValues(int val1, int val2)

{

}

Sample solution

NB! The sample has a visible debugging printout (starts with DEBUG). It’s recommended that you also do this to verify that you are indexing the array correctly. Once you are sure about your indexes and your code works, comment this out.

Enter number 1 / 5: 5
Enter number 2 / 5: -5
Enter number 3 / 5: 24
Enter number 4 / 5: 9
Enter number 5 / 5: 1

Enter first index: -5
Error! Index must be within 1 and 5!
Enter first index: -7
Error! Index must be within 1 and 5!
Enter first index: 0
Error! Index must be within 1 and 5!
Enter first index: 4
Enter second index: 3

9 < 24
24 / 9 = 2.7

Enter number 1 / 5: 5

Enter number 2 / 5: -5

Enter number 3 / 5: 24

Enter number 4 / 5: 9

Enter number 5 / 5: 1

Enter first index: -5

Error! Index must be within 1 and 5!

Enter first index: -7

Error! Index must be within 1 and 5!

Enter first index: 0

Error! Index must be within 1 and 5!

Enter first index: 4

Enter second index: 3

9 < 24

24 / 9 = 2.7

Testing

This is a partial list of the suggested tests:

Try a normal scenario that shouldn’t cause any errors.
Try out of bounds indexes ( -10, 10). Test them both as the first and the second index.
Try the out of bounds indexes multiple times to make sure that the program wouldn’t continue unless the inputs are usable.
Try indexes on the edge cases. E.g.
- If you count from 0 – 6, try -1, 0, 6, 7
- If you count from 1 – 7, try 0, 1, 7, 8
Try all 3 different results for comparison (<, >, ==)
Try to divide by zero. NB! Dividing by 0 is undefined! Just doing the division by zero may crash the program or reset the entire computer (it’s common for controllers to completely reset themselves if this happens). You are not allowed to perform divisions by zero!

Extra task 1: non-recurrent numbers

This is a continuation of lab task #1.

Requirements

Task must be built on the same base as the base task. The functionality of the base task must remain the program.
Solution can include both advanced tasks.
Create a new array based on the entered numbers. The new array must be built in a way that only a single instance of each number can exist in it.
Create functions as seem suitable for solving this task.

Testing

Enter number 1 / 6: -5
Enter number 2 / 6: 3
Enter number 3 / 6: 9
Enter number 4 / 6: 3
Enter number 5 / 6: -5
Enter number 6 / 6: 5
 
The original array: 
-5 3 9 3 -5 5
 
The rearranged array: 
-5 -5 3 9 3 5
 
The positive number array: 
3 9 3 5
 
The nonrecurrent array: 
-5 3 9 5

Enter number 1 / 6: -5

Enter number 2 / 6: 3

Enter number 3 / 6: 9

Enter number 4 / 6: 3

Enter number 5 / 6: -5

Enter number 6 / 6: 5

The original array:

-5 3 9 3 -5 5

The rearranged array:

-5 -5 3 9 3 5

The positive number array:

3 9 3 5

The nonrecurrent array:

-5 3 9 5

Extra task 2: additive inverses

This is a continuation of lab task #1.

Requirements

Task must be built on the same base as the base task. The functionality of the base task must remain the program.
Solution can include both advanced tasks.
Find and display the additive inverses of the numbers in the array.
Same numbers can be used in a pair only once, regardless of their ordering or repetition count.
Create functions as seem suitable for solving this task.

Testing

Make sure that the pairs don’t repeat.

Enter number 1 / 6: 1
Enter number 2 / 6: 5
Enter number 3 / 6: -1
Enter number 4 / 6: -5
Enter number 5 / 6: 5
Enter number 6 / 6: 224

The original array
1 5 -1 -5 5 224

The rearranged array
-1 -5 1 5 5 224

The positive number array
1 5 5 224

The nonrecurrent array
1 5 -1 -5 224

Pairs: (-1, 1) (-5, 5)

Enter number 1 / 6: 1

Enter number 2 / 6: 5

Enter number 3 / 6: -1

Enter number 4 / 6: -5

Enter number 5 / 6: 5

Enter number 6 / 6: 224

The original array

1 5 -1 -5 5 224

The rearranged array

-1 -5 1 5 5 224

The positive number array

1 5 5 224

The nonrecurrent array

1 5 -1 -5 224

Pairs: (-1, 1) (-5, 5)

After the class, you should

Know how to pass text (strings) into functions.
Know how and when to pass either the entire array or just a member from an array to a function.
Know and be able to compose and use arrays where not all members from the declared array are in use.
Be more comfortable indexing an array in other ways than from first to last element.
Be able to copy values from one array to another using two different indexes in the same loop.