All posts by risto

Labs, Pr1_en

PR1EN6: Arrays continued

Lab content

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.

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

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

  1. Arrays were passed as the reference to the location of the array.
  2. We can manipulate arrays in functions. Modifications are persistent.
  3. Array length needs to be passed to the function alongside the array
  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. 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).

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

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: 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

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.

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.
Labs, Pr1_en

PR1EN5: Arrays

Lab content

Tasks

The task for this week is separated into two parts. First finish the first part and present your solution. Then improve your existing solution by solving the second part and present the solution again. The base task can be extended by two extra task.

Task 1 part 1

Part 1 will be solved as a UML activity diagram in the class. You will have to implement the algorithm as a program based on the starter code presented. In part 1, you will have 4 functions besides main() !

Download the starter code here: https://blue.pri.ee/ttu/files/iax0583/aluskoodid/5_minmax_template.c

Requirements
  • Part 1 must match the logic described in the UML activity diagram.
  • You have to complete all 4 functions that are described in the starter code as comments and use them in your solution. You will need to also add missing parts like macros, variable declarations, function prototypes and function calls.
  • User will enter 6 numbers from the keyboard, which will be stored in an array.
  • The process of entering the numbers must be clear to the user. You must show which number they are entering out of how many at all times (e.g. 3/6 would be 3rd number from 6 in total).
  • You need to find and print the smallest number in the array. The smallest value needs to be found in a separate function, returned and printed in main().
  • You need to find and print the greatest number in the array. The smallest value needs to be found in a separate function, returned and printed in main().
  • You need to print out the original array. This must be done in a separate function.
Workflow guide

NB! For every function, first read the function comment to understand what the function does, which inputs are provided as parameters and what the result (return) has to be. Each function must be implemented below the comment.

  1. Start by completing ReadIntArray()  function given in the starter code. This is the first function after main() .
    You will need to write a loop that on each iteration, prints the prompt and then reads the value, storing it into the array.  There will be a very similar example done in the lab as live code.
  2. To test this, we need to call it out. For this, we need to declare the array in the main function and then call the function, passing it the array and its length.
    Assuming you have a macro called NUM_CNT  and an array called numbers , the function call will look like  ReadIntArray(numbers, NUM_CNT); Test and see if your reading code works.
  3. To validate our results, we should print what we got.  Complete the function PrintArray()  and call it from main() .  Note that this time you have to set the parameters and return value yourself.
  4. Now you have two more functions to complete. Both are specified as function comments in the starter code. Finish the functions, call them out and print the results.
    NB! you are not allowed to print the results in the functions that find min and max values. Printing statement must be in the main() function!
Testing

Test 1: min first, max last

Test 2: min last, max first

Test 3: Min value is negative. Both min and max are in the middle of the array.

Task 1 part 2

In part 1 you found the extreme values from the array. In part 2, you need to find the positions of those values and how many times they occurred.

Requirements
  • Print all positions of the greatest value in the array. Printing must be done in a separate function, outside of main() .
  • Print all positions of the smallest value in the array. Printing must be done in a separate function, outside of main() .
  • Print how many occurrences the min and max value had. Results must be found in a separate function and printed out in main() .
  • Positions printed must match the way you asked the user for input!
  • Implement the two functions specified under Workflow Guide. Reuse the created functions for both min and max values.
Workflow guide

To solve this part of the task, you need to create 2 functions. Both functions are given to you as function comments. You will need to implement the functions based on the comment.

First function will be to print out all the positions of the array. To do this, you need to loop through the array and every time you find the  number you are searching for (i.e. min value), you need to print out the position you are currently at in the loop! So in total, the function will consist of a loop, a conditional statement and a print statement – that’s it!

You need to reuse this function for both min and max! Note that the text describing the results should be printed in main (i.e. “Min value position(s): “)

After implementing this function, check that the code works before proceeding to the next function!

The second function will be very similar to the first one. In this one, you need to count instead of print. Once finished, just return the result you counted and print it in main() .  There is no printing of the result in the function itself!

Testing

Test 1: only 1 occurrence of min and max

Test 2: Multiple occurrences of min and max

Extra task 1:Statistics

In this extra task, we will calculate 3 more results from the data in the array.

Requirements

  • Implement 3 functions, that will find the sum, product and arithmetic.
  • Calculating arithmetic mean should reuse the function to calculate sum so you wouldn’t copy-paste code.
  • All 3 functions must use the array and the length of the array as their parameters.
  • All functions must calculate the result and return the answer. Result must be printed out in main() .
  • Display the arithmetic mean with 3 places after the comma.
Testing

The biggest stumbling block in this task is getting the arithmetic mean correct. Let’s test it.

Extra task 2: n numbers without VLA

To make the program a bit more useful, we’ll allow the user to enter the amount of numbers the program can work with.

NB! Even though most C compilers work with VLAs (variable length array), not all versions of the C standard  define it as mandatory property of the C language. Depending on the compiler, it may completely fail to work.

In addition, there are also downsides to performance of VLAs, which make them less preferred in performance-oriented tasks. In short, VLAs translate to more complex assembly code which takes more CPU cycles to execute. In addition, if no other checks are performed, it is extremely easy to crash programs using VLAs (i.e. I want to enter 10 000 000 numbers).

Because of this, you will not be allowed to declare an array where the size is defined by another variable (e.g.  int numbers[numberCount]; , where numberCount  is a variable specified by the user during runtime). The universal solution based on the standard is by using dynamic memory allocation, but that is a topic for Programming 2.

For the purpose of this lab task, you will decide on a maximum size that the user can enter and use that as the upper bound. This means, that most likely there will be unused slots in the array. However since our program is small, this won’t cause us trouble.

Note, that in general, use of VLAs is not forbidden in this course. The limitation is for this task.

Requirements
  • Allow the user to specify how many numbers they will be entering
  • Limit the program so that the user cannot enter a number greater than the size of the array defined.
  • Asking of the size from the user must be handled by a function you create for this task. The function will only be allowed to return if the input is within the specified limits.
    • Use parameters to specify the limits
    • The function you create should be reusable in other similar situations (but with different limits).
  • You can choose the “reasonable” size of the array yourself (e.g. 50 members).
  • Create error handling for situations where the user enters the array size which is either too big or small.
  • Usage of VLA (variable length array) is forbidden in this task!
  • NB! Make sure to update your coding style – variables cannot be written in the same style as macros!
Testing

Make sure to test the following

  • Minimal allowed number count.
  • Maximum allowed number count.
  • Number count that is different from the original task.

After the class, you should

  • Look into homework 1 requirements and go through the videos
  • Know how to perform type casting
  • Know about floating point precision and problems with it
  • Know how fixed point and floating point number representation works.
  • Know about math library and how to use it, including how to set the compiler flag, if necessary
  • What an array is
  • How to declare an array
  • How to initialize arrays
  • How to index each member of the array
  • How to index through an array using loops
  • How to find the extreme values in an array
  • How to pass arrays to functions

Additional content

Labs, Pr1_en

3. lab: loops

Lab materials

Tasks

This lab has two base tasks for which you need to create 5 programs in total and 2 extra tasks that can be written into a single program.

Task 1: 5-number sum

You are tasked with creating a program that will find the sum of 5 numbers which are entered by the user. The program must be created 3 times – one for each loop type. All 3 programs must do the exact same thing.

Requirements
  • Program asks the user for 5 integers.
  • After every input, the program outputs the current sum.
  • After the last value is entered, the program outputs the final sum instead of the current sum.
  • Program must give a clear instructions for the user what is expected of them.
  • You cannot have any magical numbers in your code
  • Design your program in a way that if you would need to do the same task for 10, 20 or even 1000 numbers, you will only need to change one number in your code. Test it before submitting – change that number to be 7 and see if your program still works and the output makes sense!
  • Create the same program using a while, do while and a for loop.
Sample of expected result
Hints
  • Think carefully which variables you will need! Regardless of how many numbers you need to add up, the amount of variables should remain the same.
  • It’s recommended to start counting loops from 0. This is because many other internals also rely on that number. However you should display a number incremented by 1 to the user – users usually count from 1.
    • (i + 1) takes the value if i and uses the incremented value in that place only. The incremented value is not stored and does not affect the program elsewhere.  E.g. printf("%d", i + 1);
    • Operations such as  i++, ++i, i += 1 and i = i + 1 store the updated value after incrementation (permanent).

Task 2: cash register with loops

In this task we’ll revisit the task from last week and add a few features to it.

Download the lab task 2 base code: [ register ]

Requirements

You must add the following features to the program:

1. Input validation for loyalty card and extra discount

  • Ask the user for input until either 0 or 1 is entered
  • For invalid input, print an error message
  • Recommendation: Use an exit-controlled loop.

2. PIN code can be entered up to 3 times

  • If the PIN code has been entered incorrectly for 3 times, write an error message and close the program.
  • If a correct PIN is entered within 3 attempts, check the balance and if possible, do the transaction.
  • Recommendation: Use an entry-controlled counting loop.
Sample of expected result

Extra tasks

Extra task 1: Mario tower
  • Using nested loops, create a representation of the Mario stairs using the pound symbol. A total of 13 rows of steps.
  • Place an ASCII stick man on top of the stairs.
  • The width of the top platform must be enough for the stick man to rest his feet comfortably.
  • In the end of each row, show the number of blocks used for that row and the total number of used blocks until that moment.
  • Alignment should be as shown in the example below.
Extra task 2: Mirrored tower with specified height
  • Ask the user for the width of the platform (range 7 -20 blocks)
  • The steps must be mirrored this time as is in the Mario game when approaching the castle.
  • The bottom-most step must start from the left edge of the terminal window, no spaces allowed before it.
Hints

After the class, you should

  • Know what steps need to be gone through to get from the source code that we write to a executable program
  • Know what is a #define macro and how it works
  • Know what is a magic number and how to handle them
  • Know about problems with non-initialized variables.
  • Use a switch statement.
  • Use all 3 types of loops for a specified number of iterations.
  • Know how to create a loop that runs infinitely
  • Know the increment/decrement operators.
  • Know the difference between loops that check the conditions before or after executing the loop body.
  • Be able to nest blocks of code (e.g. conditional statement inside of a loop, loop inside of a loop, …)
  • Know about two control statements: break and continue.
  • Know, that we DO NOT use goto statements.
  • Use expressions and constants as printf arguments.
  • Be able to model loops in UML

Additional content

Labs, Pr1_en

1. Lab: Hello world

Lab materials

Tasks

In this lab, most of the tasks are done together.  Later in class, you will have one base task and one extra task to solve on your own.

Task 1: Parity check (base task)

Requirements
  • User is asked for and must be able to enter an integer.
  • Program outputs if the entered integer was odd or even.
Pseudo code

Pseudo code is one way of describing algorithms. It has a similar structure to a program, but does not adhere to language specific rules such as syntax requirements. The written “code” should be well structured, but remain human readable.

Background

Modulo division is widely used as a means of creating a checksum. E.g. it can be used to validate your id code or bank card number to be valid.

In this task we are doing modulo 2 division – e.g. parity check. Parity check is one of the simplest ways to do error checking in data transfers – e.g. if the amount of bits in a data packet with the value ‘1’ is odd or even? This can be used to check if there was a data transmission error (though as said before, this will only catch extremely simple errors).

Testing

This program has 2 possible outcomes – the number is either even or odd. To test your program, you need to run the program twice, covering both of these tests.

Test 1: even number

Test 2: odd number

If everything works as expected, make sure to present your task!

Extra task: Division by 3 and 5

First complete the base task!

Read on how to use logical operators: https://blue.pri.ee/ttu/coding-guides/conditional-statements/#Logical_operators

Requirements
  • User is asked for and must be able to enter an integer.
  • Program must output whether the number is divisible by 3, divisible by 5, divisible by both or neither of them.
  • The program will find the multiples and remainders by dividing the number by both 3 and 5. All 4 results must be printed regardless of the divisibility.
  • Calculations (e.g. divisions) can only be done once. If you need to use the result multiple times in your code, store it in a variable.
Background

The task is based on a classical interview question used for recruiting software developers. This is a modified version of the FizzBuzz task.

Testing

Based on the divisibility checks, you have 4 possible outcomes that must all be tested.

Test 1: Number is divisible by both 3 and 5

Test 2: Number is divisible by 3 only

Figure the last 2 tests out on your own and make sure it works in all cases!

After the class, you should

  • Understand the requirements for this subject, including how to get a grade
  • Be able to log into Linux on the class computer
  • Know the main software we use in this class
  • Know your way around the environments – where to find what
  • Know what is the C programming language, how does the program structure look like and how to write a basic program.
  • Know the structure of a C program and be able to write, compile and execute a simple program.
  • Understand the basics of the following programming concepts.
    •  #include statements
    • why is main() function special
    • declaring variables, data types
    • print statements for basic text, changing line, printing the contents of a single or multiple variables with text and integer data types.
    • reading a value from keyboard and storing it in a variable (scanf statement)
    • basic math operations and how they are written
    • if/else statement (conditional statement)
    • Understand integer division and modulo division
  • Understand what an algorithm is
  • Understand what is UML and why it is used. Understanding the basic elements (start, end, action statement, fork, join) in the design. Being able to create a basic diagram in UML.

Additional content