Theory and reminders

Characters, strings and output functions

Even though we will deep-dive into strings in a few weeks, lets take a look at a few things

Strings is a sequence of characters. It can be a word or a sentence, but also just a sequence of symbols. Strings are between double quotes.

Examples:

• • "a"
  • "Hello!"
  • "I do wish we could chat longer, but I'm having an old friend for dinner."
  • "lFRD=)m+0FDj2"

Characters are written in between single quotes. A string is composed of such characters.

NB! Symbols starting with a backslash are called escape sequences and they are stored as a single character in the computer memory (e.g.   \n  ).

Examples:

• • 'a'
  • 'y'
  • '\n'
  • '\t'

Now to some functions for text

printf()   – print formatted. This is the most complicated output function that we’ve looked at so far. We can use it to print text, format it and also output the contents of variables. Newlines must be manually written.

Example: printf("Hello, %s!\n", name); puts()  – put string. This is a simple output function used for printing text on separate lines. It does not support formatting and printing contents of variables. It however will print a newline after the text.

Example: puts("Hello, user!"); putchar()   – put character. This is the simplest output function out of them. It allows to print a single character only. It is good to use it for printing newlines for an example.

Example: putchar('\n');

Passing arrays to functions

When passing arrays to functions, we are actually passing a reference to the location of the original data. This means we can modify arrays in any function without returning.

Most of the time, you will need to also pass the size of the array in C. This is due to the fact that it will not be possible to calculate the size after it has been passed to a function! An exception would be strings, which we’ll discuss further later.

Some more tricks and specifics

• If you want to pass the whole array, regardless of the number of dimensions, we only specify the name of the array Func(numbers);
• If you wish to pass only a single value from a 1-dimensional array int numbers[N]; , we will specify the index of that member Func(numbers[2]); . In the function we will use it as a single integer Func(int val);
• If you wish to pass the beginning of a row from a 2-dimensional array int numbers[N][M]; , we will specify the index of that row and the length of it Func(numbers[2], M); . In the function we will use it as a 1-dimensional array Func(int numbs[], int n);
• If you wish to pass only a single value from a 2-dimensional array int numbers[N][M]; , we will specify both indexes  Func(numbers[2][1]); . In the function we will use it as a single integer Func(int val);

Swapping two values in an array

To swap to values, we can use a method we learned during bubble sort. For this, we need a temporary variable.

Note: to apply this swapping for a swapping of rows or columns, you only need a single variable.

It is only beneficial to use a temporary array instead of a variable if you can apply parallel operations on a SIMD (sing-instruction-multiple-data) type of architectures such as found in GPUs (graphics processing units).

Zero-initialising an array

To zero-initialize a whole array, we put the constant in curly braces.

If it is a 2-dimensional array, need two sets of curly braces.

Tasks

In this task we’ll create a menu-program where the user can choose when they want to exit. We’ll be working with matrix manipulations in this program.

To start off, try the sample program, after which you should continue to solve the task.

Sample program

You are given a sample of the program you will create within this lab task. It is given as a compiled binary – you can run and test it to take a look at what the final product should look ike. In the end, your program should work similarly.

Both versions of the sample program are compiled for x86-64 architecture. They are guaranteed to work on the lab computers, but should also work on most of your personal computers. There can be issues with ARM processors without using x86-64 emulation.

• Sample program (Linux)
• Sample program (Windows)

NB! On Linux you must give the permission to execute it manually (safety first!). Changing the permission is a one-time task.

This will add the execute permission for the user.

• chmod – change mode
• u – user
• x – execute

After this you can run the program as usual ( ./program_name)

Task description

The lab task is separated into two separately graded parts, which can be continued by adding extra tasks.

The program should work until the user chooses to exit. This may require you to add additional checks for the state of the matrix.

The maximum size of the matrix in memory is defined using macros LIMIT_ROWS and LIMIT_COLS , which define the maximum row and column counts. Make sure to use the correct ones!

Since the user can choose to use less than the maximum matrix size, part of the matrix may be left unused. To account for this, all functions should keep track of how much of the matrix is in use. FOr this, you will see  int rows  and int cols  being used in some functions for the amount of rows and cols currently active.

Download the starter code: https://blue.pri.ee/ttu/files/iax0583/aluskoodid/10_switch_basecode.c

General requirements

These requirements apply regardless of which part of the program you are presenting.

• Your solution must mimic the sample program as close as possible
• The work must be built on the starter code
  • You are allowed to modify the starter code within reason. E.g. it might be beneficial to reorder some statements in the main function or add another parameter to the function GetIntInRange() . For any other modifications, think hard if they are necessary or useful!
  • Starter code already has 2 functions made for you. Use them as needed in the parts that you will code on your own!
  • Starter code also has the prototypes of the first two functions that you need to create during the first part of the task.
• All the numbers in the matrix must be randomly generated and from 0 – 99.
• All actions must be repeatable without exiting the program.
• All of the processing code for the menu actions must be created as functions
  • You are free to print out helping texts and prompts in the switch() itself, as well as accept returned values from functions. If necessary, you can also add some if statemens.
  • You are not allowed to add any new loops into the main() function!
• The program must be consistent and clear for the user. It must work until the user chooses to exit.

Lab task part 1

In the first part, we’ll complete the generation and displaying of the matrix.

Requirements

• Use can generate an n * m matrix.
  • Matrix will be populated with randomly generated numbers (0 – 99)
  • Values n and m are entered by the user. If necessary, create limits for user input.
  • You are only allowed to use do while()  loops in  GenerateMatrix() function.
  • Reminder! C functions are simple and only do one thing at a time (and do it well)! Function   GenerateMatrix() is not allowed to handle user input!
• User can display a matrix
  • You are only allowed to use  while()  loops in DisplayMatrix() function.
  • Matrix must be nicely aligned.
• User can exit the program

Lab task part 2

In the second part, we will create functions for swapping rows and columns.

Requirements:

• User must be able to swap two rows.
  • You are only allowed to use for()  loops in the swapping function.
• User must be able to swap two columns.

Common mistakes

• Copy-pasting, also known as repetitive code. Mostly this will happen in the input part (e.g. number of rows, columns etc)
• Off by one issues. As a reminder, first row index is 0.
• Magical numbers
• Allowing matrix operations before having a matrix. You cannot display a matrix that has not yet been generated!
• Wrong loop types (part 1 and 2 have fixed loop types that you can use!).
• Mixing up row and column counts. Try the following
  • generate a 3 x 5 matrix, swap rows 1 and 3
  • generate a 5 x 3 matrix, swap columns 1 and 3

Extra task 1: deletion

Add additional features to your program

• User can delete a row that they desire.
• User can delete a column that they desire.
• After deleting a row, all rows following it will rise higher by 1. Similarly after deleing a column, all columns following it will move the the left by 1. The size of the matrix will shrink.
• Add the required functionality to the menu.

Extra task 2: addition

Add additional features to your program

• User can add a new row to the desired location.
• User can add a new column to the desired location.
• All elements for the added row / column will be generated randomly.
• Any rows or columns after the desired location will move forward by 1. The size of the matrix increases.
• Add the required functionality to the menu.

Extra task 3: transpose

Add additional features to your program

• User can transpose the matrix.
• Add the required functionality to the menu.

After this class, you should

• Be able to create infinitely running menu-programs.
• Know a few additional functions for text output.

Additional content

• Menu-Driven program using Switch-case in C
  https://www.geeksforgeeks.org/menu-driven-program-using-switch-case-c/
• Escape sequences in C
  https://en.wikipedia.org/wiki/Escape_sequences_in_C

Lab materials

• Slides: Conditional statements 2

Tasks

This lab has two base tasks, first one simulating a cash register and the second one simulating a store food scale. The first task is extended by an extra task, adding support for bonus point management.

Task 1 [W02-1]: Cash register

With this task, we’ll create a simple cash register application with the goal of trying to compose different conditional statements. The task is provided with a starter code to start you off. Base your solution on the starter code, write your code statements after the comments specifying what to do!

Requirements:

• Program must be logically identical to the given algorithm
• Program must be built on the base code given. Your task is to add the missing printf , scanf , conditional statements and calculations. Use the code comments and the activity diagram as a reference.
• Don’t change the variable naming or the program structure
• Recommendation: To check that the values are correctly read and program behaves as expected, add printouts to check the variable values after mathematical operations.

Download task 1 starter code: [et] [en]

Algorithm

Testing

I’m proposing a series of tests for the program you are about to create. NB! I’ve left at least one important test case untested. Can you figure out which one?

Task 2 [W02-2]: Food scale

In this task you will create a program, that simulates the food scale in a grocery store.

The UML activity diagram to structure your program on will be created in class. Your program must match or exceed the functionality described.

Requirements

• You must have at least four products available.
• Products are represented as pairs of product codes (integer) and names (e.g. 1 – banana).
• The user inputs an integer product code and a real numbered quantity (in kilograms) from the keyboard.
• You must handle matching the product code to the price of 1 kg in the switch  statement.
• User will be displayed the total price only if a valid product code and weight are entered.
• The given price(s) must be given with 2 decimal places.
• Invalid product code and weight must trigger an error. There is no need to specify which error occurred. In case of an error, price must not be shown!

Download the starter code for task 2: 2_2_scale_base.c

Algorithm

A copy of the algorithm for those who either reach the second task more quickly during the lesson or lose their own copy of the algorithm. The algorithm will also be solved together in class with additional commentary

Testing

Test 1: Correct inputs will give us a total cost.

Test 2: Invalid product code triggers an error.

Test 3: Invalid weight triggers an error.

Extra task [W02-3]: Bonus account

The extra task is an extension of the first task. To do this, we’ll add an option for the user to use bonus points.

While solving the task, think carefully about everything that could go wrong at each stage of the transaction and how those issues are related!

Note: as a result of solving this task, you will end up with one long piece of spaghetti code — everything in a single function. We will start fighting against this from fourth week.

Requirements

• Add user’s bonus points count to the program, it should be initialized. Bonus points can only be integers (e.g., 1 bonus point, 15 bonus points).
• Before completing a transaction, the user is shown their total bonus points and the maximum number of points they are allowed to use for this purchase, according to the rules of using  bonus point.
• Then the user is asked whether they want to use bonus points. If yes, the program asks how many they wish to use.
• Bonus point rules
  • 1 bonus point equals 1 euro cent
  • A maximum of 90% of the purchase can be paid with bonus points, calculated after discounts
  • If the user enters a number of bonus points greater than what they have or greater than what is allowed for the purchase, the maximum permitted amount is used instead
• The rest of the transaction logic remains as specified by the base task
• At the end of the transaction, the user is shown the remaining balance of their bonus account

Necessary knowledge

As a reminder from the previous lesson – the quotient of two integers is always an integer. If you need a division where the result must be a floating-point number (i.e., a number with a decimal point), then at least one of the numbers involved in the division must be a floating-point number. This turns the entire operation into a fractional division.

For example, 1 / 100 gives the integer 0, but 1.0 / 100 gives the floating-point number 0.01.

When multiplying by a real number, this issue does not occur — e.g., 10 * 0.01 results in 0.1.

Testing

In the first example, the user is applied discount. Without the discount, the purchase would not be possible.

Enter purchase total: 125 Did client present loyalty card? 1 - yes 0 - no 1 Apply extra discount? 1 - yes 0 - no 0 10% discount applied Invoice total: 112.50 You currently have 10000 bonus points For this purchase, you can use up to 10000 points Do you wish to use bonus points? 1 - yes 0 - no 1 Enter the number of bonus points to use: 3500 Points used for this purchase: 3500 Amount to be paid after points: 77.50 EUR Please enter your PIN code:1234 PIN code accepted! Purchase completed! Final card balance is 22.50 EUR Final amount of bonus points left: 6500

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

Enter purchase total: 125   Did client present loyalty card? 1 - yes 0 - no 1   Apply extra discount? 1 - yes 0 - no 0   10% discount applied Invoice total: 112.50   You currently have 10000 bonus points For this purchase, you can use up to 10000 points   Do you wish to use bonus points? 1 - yes 0 - no 1   Enter the number of bonus points to use: 3500   Points used for this purchase: 3500 Amount to be paid after points: 77.50 EUR   Please enter your PIN code:1234 PIN code accepted! Purchase completed!   Final card balance is 22.50 EUR Final amount of bonus points left: 6500

In the second example, the user chooses not to use their bonus points.

Enter purchase total: 9.69 Did client present loyalty card? 1 - yes 0 - no 1 Apply extra discount? 1 - yes 0 - no 1 20% discount applied Invoice total: 7.75 You currently have 7500 bonus points For this purchase, you can use up to 697 points Do you wish to use bonus points? 1 - yes 0 - no 0 Please enter your PIN code:1234 PIN code accepted! Purchase completed! Final card balance is 92.25 EUR Final amount of bonus points left: 7500

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

Enter purchase total: 9.69   Did client present loyalty card? 1 - yes 0 - no 1   Apply extra discount? 1 - yes 0 - no 1   20% discount applied Invoice total: 7.75   You currently have 7500 bonus points For this purchase, you can use up to 697 points   Do you wish to use bonus points? 1 - yes 0 - no 0     Please enter your PIN code:1234 PIN code accepted! Purchase completed!   Final card balance is 92.25 EUR Final amount of bonus points left: 7500

In this example, the user wants to use more bonus points than they have, so the amount is overwritten. The transaction does not go through because there is not enough money, and the bonus point balance remains unchanged.

Enter purchase total: 139.99 Did client present loyalty card? 1 - yes 0 - no 1 Apply extra discount? 1 - yes 0 - no 1 20% discount applied Invoice total: 111.99 You currently have 350 bonus points For this purchase, you can use up to 350 points Do you wish to use bonus points? 1 - yes 0 - no 1 Enter the number of bonus points to use: 2000 Error! This exceeds the maximum allowed! Using maximum amount of 350 points Points used for this purchase: 350 Amount to be paid after points: 108.49 EUR Please enter your PIN code:1234 PIN code accepted! Error! Not enough balance on the card! Final card balance is 100.00 EUR Final amount of bonus points left: 350

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36

Enter purchase total: 139.99   Did client present loyalty card? 1 - yes 0 - no 1   Apply extra discount? 1 - yes 0 - no 1   20% discount applied Invoice total: 111.99   You currently have 350 bonus points For this purchase, you can use up to 350 points   Do you wish to use bonus points? 1 - yes 0 - no 1   Enter the number of bonus points to use: 2000 Error! This exceeds the maximum allowed! Using maximum amount of 350 points   Points used for this purchase: 350 Amount to be paid after points: 108.49 EUR   Please enter your PIN code:1234 PIN code accepted! Error! Not enough balance on the card!   Final card balance is 100.00 EUR Final amount of bonus points left: 350

After the class, you should 

• Know what is a truth table and how to read them
• Be able to form conditional statements consisting of multiple conditions
• Know what De Morgan’s law is and how to apply it
• Know how to use inversion and short forms for conditional statements
• Be able to initialize integers and floating point values when declaring them
• Be able to write nested conditional statements
• Be able to alter the variable value relative to the old value, on the same line
• Be able to use and print floating point values while specifying number of decimal places
• Understand how switch statements work and how to use them in code
• Be able to model a switch statement in an activity diagram
• Know how to use swim lanes
• Know how to have multiple different endings in both programs and in activity diagrams

Additional content

• De Morgan’s Laws
  https://brilliant.org/wiki/de-morgans-laws/
• C/C++ if else if ladder with Examples
  https://www.geeksforgeeks.org/c-c-if-else-if-ladder-with-examples/
• Decision Making in C / C++ (if , if..else, Nested if, if-else-if )
  https://www.geeksforgeeks.org/decision-making-c-c-else-nested-else/
• Exit codes in C/C++ with Examples
  https://www.geeksforgeeks.org/exit-codes-in-c-c-with-examples/
• Beej’s guide: switch statement
  https://beej.us/guide/bgc/html/split/variables-and-statements.html#switch-statement
• Switch Statement in C/C++
  https://www.geeksforgeeks.org/switch-statement-cc/

Lab content

• Slides: functions
• Additional example on functions: dist_converter.c
• Basecode: warehouse.c

Lab tasks

Task 1: finding results from an array

The purpose of this task will be to create a program, that:

• Reads 5 integers from the user that will be in between -100 and 100.
• Prints the entered numbers out.
• Finds and prints the arithmetic mean with 2 places after the comma.
• Finds and prints the smallest member in the array.
• Allows the user to enter a number and checks if it exists in the array or not.

The task has the following limitations (in addition to previous practices):

• All of the functions described below will have to be implemented and used to find the results.
• Constants defined using macros must be passed as a function parameter and not directly used in the functions.
• If the function’s purpose is to find a results (e.g. arithmetic mean, smallest number, …), the result must be returned to main(). Side effects (printing the results within the functions) is not allowed.

Solve the program step-by-step. Test each function after creating it before proceeding. Avoid writing the code without functions at first! The functions given below are in the order we recommend writing them.

We have written a simple writeup on the parameters for each functions.  If you wish, you can add additional parameters to the second function (read array), but nothing else!

The writeup on the functions is simplified and allows the developer to make some decisions on their own. It is not enough to be used as a sample for homework 2!

1. function: reading an integer

Description: Reads one integer from the user, that is checked to be in the allowed range. The function must not return before the entered value is within the allowed range. If the user entered number wasn’t between the allowed minimum and maximum, the user will be warned and prompted again.

Parameters:

• integer – minimum allowed value.
• integer – maximum allowed value.

Return: integer, that is between the allowed minimum and maximum.

2. function: filling an array

Description: This functions reads n integers and stores them into the array. To use each integer, the previously completed function (reading an integer) is called. It is done repeatedly in a look for each array member that needs to be read.

Parameters:

• integer array – the array that will be filled.
• integer – array length.

Return: none.

3. function: printing an array

Description: Function prints values stored in the array.

Parameters:

• integer array – the array that will be printed.
• integer – array length.

Return: none.

4. function: arithmetic mean

Description: Function finds the arithmetic mean from the array and returns it.

Parameters:

• integer array – array, that contains the members of which the average will be calculated.
• integer – array length.

Return: float – arithmetic mean.

5. function: minimum value

Description: Function finds the smallest member of the array and returns it.

Parameters:

• integer array – values from where the minimum value will be searched for.
• integer – array length.

Return: integer – smallest number in the array.

6. function: check if value in array

Description: Function looks if the entered value is within the array or not. The result will be coded as an integer and returned.

Parameters:

• integer array – values from were the search key is being looked for.
• integer – array length.
• integer – the value that is being looked for.

Return: integer / boolean – was the entered number present in the array or not.

Advanced: multiples of n to a new array

• User enters a multiplier (positive integer)
• Create a function that will create the new array
  • Values where the absolute value is a multiple of the entered multiplier will be added to the new array. New array members must also be absolute values.
  • Function itself must not print out the new array nor call a function to do so.
• The newly created array must be printed out. Use a function that already exists.

Task 2: Converting an existing code to use functions

Take the following code and split it into functions:
https://blue.pri.ee/ttu/files/iax0583/warehouse_kontaktope.c

Create the following functions, move the code from main to those functions:

• Array print (without return, code reuse)
• Print message about how much will fit (without return)
• Sorting (without return)
• Combining in sorting facility (returns number of items moved to the third array)
  Note: This function can work with code reuse (called twice), but doesn’t have to!

Advanced: weight limit

Create a limit for the cargo exiting the sorting facility.

E.g. a truck can deliver up to 1500 kg at once. Fill it with heavier items first. If some items don’t fit the limit, try if a lighter item will fit.

Print out the items that did fit on the truck and then fit separately the items that were left in the sorting facility.

After the class, you should

• Understand what a function is
• Understand that we have been using functions from the first week. Both functions that return values and those that don’t!
• Understand, that we can create functions just like those we have been using.
• Understand the following terms
  • Function prototype
  • Function return type
  • Function arguments
  • Function parameters
  • Function header
  • Function body
• Be able to create proper functions
• Be able to pass variables and arrays to functions
• Be able to store the value returned from a function
• Be able to reuse functions with different arguments
• Be able to divide your code to functions
• Have a small list of universal functions that you can reuse in future codes!

Additional content

• https://www.tutorialspoint.com/computer_programming/computer_programming_functions.htm
• https://www.studytonight.com/c/user-defined-functions-in-c.php

Download VIM configuration file
1. Go to your home directory

2. download the file

Decide on where to put your program(s) for this lab.
e.g. ~/P/IAX0583/ or something similar. Make sure that folder exist, if necessary create a new folder.
Use cd  to navigate, mkdir  to create a directory

Download the archived test program

You need to unzip the file
Use the program called unzip

You may need to manually make it executable
You use chmod  for this

Note: From this point on you can try to run the program provided. I recommend you try this out now! The program will stop when an unmet requirement is encountered.

Copy over an additional data file with the secret

Go to the M: folder (~/M/). Find your lecturer’s directory and go to it. In there you will find a hidden directory – go to it (it starts with a dot).

Inside you will find a .dat file. Copy that file over to the same folder as the test program. For this you will need to use the cp  command. Specify the file you want to copy and the path you want to copy it to.

To test if this worked, run the program and see if it finds the secret!

Next up you need to create a file with your matricula

For this, go back to the folder with your lab files. For this one, I’ll provide two possible options.

Option 1: Open up your favourable command line text editor, write a file called “matricula”

Vim guide:

• • Start by writing vim matricula  to create a file called matricula and open it in Vim.
  • Press ‘i’ to enter writing mode.
  • Now write your matricula.
  • Press ‘esc’ to exit write mode.
  • write :wq  in normal mode to write the file and exit

Option 2: This is what most people actually would do. They would use the echo command and redirect the output streamto a file, e.g. echo "text" > file

Write another program that will print out “Hello world!”

Again use a command line text editor. We recommend Vim, as it supports C code, but you can use any other editor as well.

Once done, compile the program. Use “-o hello” to specify the name of the program as “hello”

Now run the test program that you downloaded from us. If everything was successful, you get a new file with instructions.
Follow the instructions or if necessary, fix the mistakes.

Lab content

• Slides: Matrices

Lab tasks

This lab has two gradable tasks. Second task is extended by two extra tasks.

Task 1: Calculating various results from a matrix

In this task we’ll practice navigating a matrix and finding results from it.

The task is graded separately in 3 parts.  Look for “Graded parts” below.

To start, download the following files.

• Starter code: https://blue.pri.ee/ttu/files/iax0583/aluskoodid/9_1_matrix.c
• Input file for stream redirection: https://blue.pri.ee/ttu/files/iax0583/aluskoodid/9_1_matrix.txt

Note: the task must be shown with stream redirection with the provided data file in order to be accepted!

Requirements

• You have been given a starter code and an input file to use
• Program must be shown using stream redirection
• Add the printout of the matrix
• Find and print the following results
  • The sum of negative elements on the main diagonal
  • The product of positive elements above the anti-diagonal
  • The greatest value in every row
• All values must be stored as integers. Data types such as float, double and such are not allowed.
• If you want to use smaller or bigger data types than a 32-bit int, you must use it precisely (e.g. through inttypes.h ). Data types such as long  and long long  are not allowed.
• The solution must be cross-platform. Formats such as %ld  and %lld  are not allowed.
• You must complete at least the listed functions below under “required functions”.

Required functions

You need to have at least 5 user-defined functions created in your program. You are allowed to create more if it suits the purpose.

• Reading the matrix. During the function, all values were be stored into your 2-dimensional array (matrix). This has been done for you.
• Printing of the matrix. During the function, the matrix will be printed onto the screen as shown in the example below. Function has no return value. Prototype for it has been done for you.
• Finding the sum of negative numbers from the main diagonal. Function returns the sum to main() function, where it will be printed. Side effects are forbidden! Prototype for it has been done for you.
  NB! Think carefully about which values need to be summed up and watch out for excess work. Check out the indexes where your values are and make sure that you only go through those and nothing else. E.g., going through the entire 49-member array only to add up 7 values is not ok. Imagine if this was a 1000 x 1000 matrix – in that case you would visit a million numbers only to find 1000 of them. This would make the useful work to be 0.1% (reduction in efficiency is exponential if you go through the entire array).
• Finding the product of positive values that are positioned above the anti-diagonal. Function returns the product to main() function, where it will be printed. Side effects are forbidden.
• Finding the greatest values in each row. This one is entirely up to you how to design. You can have side effects and print the results inside of this function. You can add some helper functions as needed as well.

Grading

The task has 3 graded parts, marked separately.

There are 2 requirements which must be completed regardless of which part you intend to present

1. Program must be executed using stream redirection
2. Matrix must be printed on the screen

Separately graded parts

• Part 1: the sum of negative elements on the main diagonal
• Part 2: the product of positive elements above the anti-diagonal
• Part 3: the greatest value in every row

Hints

• Look at how ReadMatrix()  is written. You can write the parameter list for your other functions based on this
• Printing: Again, take inspiration from ReadMatrix()  function. This already has everything you need to go through all the positions. Now you just need to format the printout nicely. To figure out the line change, think of what is the purpose of inner and outer loops!
• Part 1: Write the indexes that you need to sum up. Take a look at those indexes and think of how many variables (and loops) you even need to go through all of them!
• Part 2: Remind yourself what happened during an integer overflow!
• Part 3: You can pass a single row of a matrix into a function. For this, we will specify the index of the row we wish to pass as well as pass the length of that row. This way you can re-use a function that you’ve created previously. E.g. FindMaxValue(matrix[rowIndex], rowLength)

Testing

This include the answers expected from the given matrix.

Task 2: Cinema hall

We have been given a layout with the current bookings for a cinema hall. It is represented as a 2-dimensional array. Your task will be to correctly interpret the values to display the hall plan.

All seats in the hall are coded with the following integers:

• 0 – the seat does not exist at this location
• 1 – the seat is free
• 2 – the seat is already booked

The array position 0, 0 corresponds with the top left seat of the movie hall.

Download the starter code with the hall plan here: https://blue.pri.ee/ttu/files/iax0583/aluskoodid/9_2_cinema_init.c

Requirements

• Print the hall plan. Program’s output must match the one given in the sample
  • Row numbers are placed on the left side
  • All rows start with the seat number 1. You must account for missing seats (and not count them – look at the example)
  • Free seats are marked as seat numbers
  • Missing seats are marked as an upper case ‘X’ character
  • Seats that don’t exist are not depicted
  • The location of the screen is shown in the plan
• Ask the user for a seat (row, seat number) and print if it is free or not.
• At minimum, you should have 2 functions besides main. One for printing the plan, another for checking the availability of the chose seat. You are free to create more as you see fit.

Workflow recommendation

1. Print out the floor plan just as regular matrix with all numbers. Do not try to adjust what’s printed yet.
2. Start altering the output (interpreting the coded values in the array). Create a conditional statement to print “nothing” instead of the code that represents missing seats
3. Continue to interpret the other codes.
4. Now that the floorplan is printed, print out the row numbers on the side.
5. Ask the user for their preferred seat. Don’t forget to sanity check them!
6. The row index can be calculated in one step. Column index has to be adjusted for the missing seats.
7. Print out the indexes in the array data structure to validate that you got the correct position! 
8. Now finish the program.

Hints

• The floor plan is flipped compared to the array indexes. It may help you to draw it out and write the indexes for the first and last row compared to the floorplan.
  • Row 14 has the row index of 0
  • Row 1 has the row index of 13
• To figure out the seat number, use a separate counter
• A really clean solution to handle such a coded integer is a switch()  statement.

Testing of the program and samples

NB! The sample also uses colors in code, your solution doesn’t have to (but can 🙂 )

We’ve added a small debugging line where we are showing the index of the array we are checking for seat availability. It’s recommended to add it to yours as well, as it will be easier to check for correctness of it.

Sample output after solving the base task:

Sample output after solving both extra tasks:

Extra task 1: n tickets

Lets add a feature so that the user can book multiple tickets with one purchase. Add this to the base task.

• User is asked for the number of tickets required.
• All of the seats offered must be in the same row, next to each other.
• Use the entered seat position as the starting point for your search. The other seats can booked to the left or to the right of the chosen seat, including to both sides at the same time.
• Display the offered seats

Extra task 2: confirmation

Lets add a confirmation before the seats are booked

• You must have both the base task and extra task 1 completed and in the same program for this.
• After giving the offer to book the seats, prompt the user a confirmation if the offered seats are OK.
• If the user refuses the seats you offered or there were not enough seats available at the chosen location, allow them to choose again (both seat position and number of tickets)

Hint: There are 3 coded values in the initial matrix. If you wish, you can add them. As an alternative, you may just want to make a copy of the initial matrix.

After the class, you should

• Be able to use various length integers in code, including a 64 bit integer in cross-platform compatible code.
• Understand how integer overflows happen in code
• Be able to visualize a two-dimensional array
• Understand how to declare and index a two-dimensional array
• Be able to index only a specific part out of that array (e.g. first row, last row, first three rows, second element from the third row etc.)
• Understand and be able to use matrix diagonal properties
• Be able to go through the array both row by row and column by column

Additional content

• http://www.cplusplus.com/reference/climits/
• http://www.cplusplus.com/reference/cinttypes/
• http://www.cplusplus.com/reference/cstdint/
• Adding Color to Your Output From C
  https://www.theurbanpenguin.com/4184-2/

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 and output functions, might have an issue that the printed text doesn’t work for the specific use case

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.

1. Text is an array, composed of individual character. Each character also has its own index.
2. 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). This is due to a special character that is placed right after the last symbol, that terminates the the end of the string.

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

In the last lesson, we discussed how arrays behave with functions. Let’s remind ourselves of some key points

1. Arrays were passed as the reference to the location of the array.
2. We can manipulate arrays in functions. Modifications are persistent.
3. We cannot determine the length of an array that was passed to a function, thus we must always the length of the array as well.
4. 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.

Tasks

In this class, you need to solve two tasks. The first task is extended by two extra tasks.

Lab task 1 [W6-01]: Composing new arrays

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 provided below. The task itself (as per requirements) also includes additional functionality, that is not described by the algorithm.

Algorithm

Requirements

• Program must be based on the provided algorithm and extended based on the requirements listed here.
• 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, if you wish, reuse the functions you created last week. If you choose to copy functions from previous week, 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 user entered numbers were stored to. 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 just created. The code should look something similar once completed (names of functions and variables can be different).

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.

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

Lab task 2 [W6-02]: Array indexing and comparisons

The second task is about indexing into an array to pick out specific member values and performing basic operations on it.

Requirements

• 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 to check for correctness before proceeding
• 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 (e.g. 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.

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).

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.

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.

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.

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 [W6-03]: 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.
• 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

Extra task 2 [W6-04]: 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.
• 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.

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.