Programming Fundamentals

• using complex if statements to control program execution
• using while loops for repetition
• building up combinations of loops
• defining and using enums and structs

In this week's lab, your tutors will go around the class and give you one on one feedback on some code you have written in a previous week.

Take this as an opportunity to ask any questions you might have about the course content so far!

So, if you would like, have a think about if there is any particular exercise you would like to receive feedback for, or any particular content you would like to ask about.

When you are finished with the exercises for this week, take a look at the 1511 Cheatsheet. This page has useful linux commands and VSCode keyboard shortcuts that you may find helpful when programming!

Help sessions are running this week!

These are one of the best ways for you to get one on one help with a tutor for any course content (including Lab Exercises and Assignments).

For the dates and times of the help sessions, see the Help Session Timetable.

To join a help session, or for more information, see the COMP(1511|1911) Help Session Microsoft Teams.

For face-to-face help sessions, the lab map can be found here. If help sessions are running in other buildings you can use Lost on Campus to help you find them.

The following is a list of all the activities available to complete this week...

Worth 1 mark(s) in total:

• count_up_down
• vector_sum
• debug_factorial
• print_grid

Worth 1 mark(s) in total:

• custom_cake
• letters_between
• street_fighter

Worth 0.5 mark(s) in total:

• xtreme
• abc_grid

For your interest, but not for marks:

• spiral
• decimal_spiral

Problem sets are capped at 15 marks (there are 4 possible bonus marks from the three-dot exercises that can bring you up to a total of 15 if you missed out on any other marks in the one- or two-dot exercises).

Completing just the one and two-dot exercises every week can give you the full 15 marks needed in this component.

For more details, see the course outline.

Before the lab you should re-read the relevant lecture slides and their accompanying examples.

When attempting the following exercises, make sure to read the whole exercise, including any hints and assumptions that may make the exercise easier.

Write a C program count_up_down.c that reads one integer n and prints all integers from 0 to n inclusive one per line.

Note that if n is positive, we are counting up and if n is negative, we are counting down.

Examples

dcc count_up_down.c -o count_up_down
./count_up_down
Enter number: 5
0
1
2
3
4
5
./count_up_down
Enter number: -3
0
-1
-2
-3

Assumptions/Restrictions/Clarifications

• You may assume 0 will never be given as input.
• You are not permitted to use arrays.
• You do not have to do any error checking.
• You do not have to check the return value from scanf.

1511 style count_up_down.c

When you think your program is working, you can use autotest to run some simple automated tests:

1511 autotest count_up_down

When you are finished working on this exercise, you must submit your work by running give:

give cs1511 lab03_count_up_down count_up_down.c

You must run give before Monday 30 September 20:00 to obtain the marks for this lab exercise. Note that this is an individual exercise, the work you submit with give must be entirely your own.

// 
// Written 23rd September 2021
// By Clarissa Tatang
//
// Program which takes in a number n and
// counts up from 0 till n if n is greater than 0 or
// counts down from 0 till n if n is less than 0.
// 

#include <stdio.h>

int main(void) {
    int n;
    printf("Enter number: ");
    scanf("%d", &n);

    int i = 0;
    if (n > 0) {
        while (i <= n) {
            printf("%d\n", i);
            i++;
        } 
    } 

    if (n < 0) {
        while (i >= n) {
            printf("%d\n", i);
            i--;
        }
    }

}

Download vector_sum.c here

Or, copy these file(s) to your CSE account using the following command:

1511 fetch-activity vector_sum

Complete the C program vector_sum.c which reads in two vectors with 3 integer components each and stores the sum of these components in a new vector to be printed.

Your job for this exercise is to complete the middle section (bolded above). There is a given struct vector called sum_vector, which needs to store the sum of the two scanned-in vectors, everything else has already been completed.

Complete the C program vector_sum.c which takes in two 3D vectors, each with an x, y and z integer component as input, and then calculates the sum to be printed.

Your job for this exercise is to use the values stored in first_vector and second_vector which have already been scanned in for you to calculate the sum of the vectors and store the result in the given struct vector called sum_vector.

Examples

dcc vector_sum.c -o vector_sum
./vector_sum
Please enter the values of the first vector (x, y, z): 1 2 3
Please enter the values of the second vector (x, y, z): 4 5 6
The resulting sum vector is:
x: 5
y: 7
z: 9
./vector_sum
Please enter the values of the first vector (x, y, z): 1 2 3
Please enter the values of the second vector (x, y, z): 1 2 3
The resulting sum vector is:
x: 2
y: 4
z: 6
./vector_sum
Please enter the values of the first vector (x, y, z): -5 30 -12
Please enter the values of the second vector (x, y, z): 15 -31 -30
The resulting sum vector is:
x: 10
y: -1
z: -42

Assumptions/Restrictions/Clarifications

• You may assume that you will be given only integers as input.
• You may assume that all input is valid.
• You may notice that the starter code does not pass 1511 style. Defining a vector with x, y and z is perfectly fine in this case, even though they are 1 letter variables. Context is important here! Since x, y and z are common for dimensions in math, it is okay here. However, a vector with h, v, q would not be good style.

1511 style vector_sum.c

When you think your program is working, you can use autotest to run some simple automated tests:

1511 autotest vector_sum

When you are finished working on this exercise, you must submit your work by running give:

give cs1511 lab03_vector_sum vector_sum.c

You must run give before Monday 30 September 20:00 to obtain the marks for this lab exercise. Note that this is an individual exercise, the work you submit with give must be entirely your own.

#include <stdio.h>

struct vector {
    int x;
    int y;
    int z;
};

int main(void) {

    //////////////// DO NOT CHANGE ANY OF THE CODE BELOW HERE //////////////////
    struct vector first_vector;
    struct vector second_vector;

    // Scans in vector values from user
    // Carefully read how these scanf's work ~ Try to understand it
    printf("Please enter the values of the first vector (x, y, z): ");
    scanf("%d %d %d", &first_vector.x, &first_vector.y, &first_vector.z);

    printf("Please enter the values of the second vector (x, y, z): ");
    scanf("%d %d %d", &second_vector.x, &second_vector.y, &second_vector.z);

    struct vector sum_vector;
    //////////////// DO NOT CHANGE ANY OF THE CODE ABOVE HERE //////////////////


    ///////////////////// ONLY WRITE CODE BELOW HERE ///////////////////////////
    // TODO: Fill in `sum_vector` by adding each component of `first_vector`
    // and `second_vector`
    sum_vector.x = first_vector.x + second_vector.x;
    sum_vector.y = first_vector.y + second_vector.y;
    sum_vector.z = first_vector.z + second_vector.z;

    ///////////////////// ONLY WRITE CODE ABOVE HERE ///////////////////////////


    printf("The resulting sum vector is:\n");
    printf("x: %d\n", sum_vector.x);
    printf("y: %d\n", sum_vector.y);
    printf("z: %d\n", sum_vector.z);
    return 0;
}

Download debug_factorial.c here

Or, copy these file(s) to your CSE account using the following command:

1511 fetch-activity debug_factorial

Debugging Tips!

Some debugging tips for you:

• dcc output - as you run into issues, dcc will point you to where the errors are. Remember that dcc gives you the line number the issue is on, and will give some sort of explanation. Make sure you read everything dcc gives you. Sometimes we get “errors carried forward”, so find your first error, fix that, then recompile.
• print statements - sometimes it can be handy to see if the flow of your code puts you in the spot you expect it to be (ie. inside the right if statement, or going through a loop the correct amount of times). A quick way you can check this is by putting print statements in your code for testing purposes, like "the value of x is %d and y is %d". This lets you check that you got against what you expected.
• COMP1511 debugging guide

The Task

This exercise takes in a positive integer as input, calculates the factorial of that number and prints it out. Currently it has some issues - it is your job to figure them out and fix the code.

Examples

dcc debug_factorial.c -o debug_factorial
./debug_factorial
Enter a number: 3
The factorial of 3 is 6
./debug_factorial
Enter a number: 7
The factorial of 7 is 5040
./debug_factorial
Enter a number: 1
The factorial of 1 is 1

Assumptions/Restrictions/Clarifications

• You can assume you will not be given negative numbers

1511 style debug_factorial.c

When you think your program is working, you can use autotest to run some simple automated tests:

1511 autotest debug_factorial

When you are finished working on this exercise, you must submit your work by running give:

give cs1511 lab03_debug_factorial debug_factorial.c

You must run give before Monday 30 September 20:00 to obtain the marks for this lab exercise. Note that this is an individual exercise, the work you submit with give must be entirely your own.

// debug_factorial.c
//
// Write a C program that takes a positive integer as input, calculates the
// factorial of that number and prints it out.
//
// Sofia De Bellis, 2023

#include <stdio.h>

int main (void) {
    int num = 0;
    int factorial = 1;

    printf("Enter a number: ");
    scanf("%d", &num);

    int counter = num;

    while (counter > 0) {
        factorial *= counter;
        counter--;
    }    

    printf("The factorial of %d is %d\n", num, factorial);

    return 0;
}

Write a program called print_grid.c that reads an integer n from standard input. and prints an n x n grid with all the coordinates of the grid shown.

Each of the points of the grid should be printed out in the form (row, col). This is different to your typical (x,y) coordinate grid and you should see if you can figure out why this is more convenient for us!

Examples

dcc print_grid.c -o print_grid
./print_grid 
Enter size: 4
(0, 0) (0, 1) (0, 2) (0, 3)
(1, 0) (1, 1) (1, 2) (1, 3)
(2, 0) (2, 1) (2, 2) (2, 3)
(3, 0) (3, 1) (3, 2) (3, 3)
./print_grid 
Enter size: 5
(0, 0) (0, 1) (0, 2) (0, 3) (0, 4)
(1, 0) (1, 1) (1, 2) (1, 3) (1, 4)
(2, 0) (2, 1) (2, 2) (2, 3) (2, 4)
(3, 0) (3, 1) (3, 2) (3, 3) (3, 4)
(4, 0) (4, 1) (4, 2) (4, 3) (4, 4)
./print_grid
Enter size: 8
(0, 0) (0, 1) (0, 2) (0, 3) (0, 4) (0, 5) (0, 6) (0, 7)
(1, 0) (1, 1) (1, 2) (1, 3) (1, 4) (1, 5) (1, 6) (1, 7)
(2, 0) (2, 1) (2, 2) (2, 3) (2, 4) (2, 5) (2, 6) (2, 7)
(3, 0) (3, 1) (3, 2) (3, 3) (3, 4) (3, 5) (3, 6) (3, 7)
(4, 0) (4, 1) (4, 2) (4, 3) (4, 4) (4, 5) (4, 6) (4, 7)
(5, 0) (5, 1) (5, 2) (5, 3) (5, 4) (5, 5) (5, 6) (5, 7)
(6, 0) (6, 1) (6, 2) (6, 3) (6, 4) (6, 5) (6, 6) (6, 7)
(7, 0) (7, 1) (7, 2) (7, 3) (7, 4) (7, 5) (7, 6) (7, 7)

Assumptions/Restrictions/Clarifications

• You may assume that your program will only scan in integers
• Your program only has to handle sizes in the range 0 to 10 inclusive
• Your program is not required to do any error checking
• Your program is not permitted to use arrays

1511 style print_grid.c

When you think your program is working, you can use autotest to run some simple automated tests:

1511 autotest print_grid

When you are finished working on this exercise, you and your lab partner must both submit your work by running give:

give cs1511 lab03_print_grid print_grid.c

Note, even though this is a pair exercise, you both must run give from your own account before Monday 30 September 20:00 to obtain the marks for this lab exercise.

// Written ...

// Print a grid of coordinates

#include <stdio.h>

int main(void) {

    int size;
    printf("Enter size: ");
    scanf("%d", &size);

    int row = 0;
    while (row < size) {
        int col = 0;
        while (col < size) {
            printf("(%d, %d) ", row, col);
            col = col + 1;
        }
        printf("\n");
        row = row + 1;
    }

    return 0;
}

In this activity you will create a program called custom_cake.c.

The program will first ask for the number of layers (rows) of a cake. It will then scan in an ASCII character for each layer. Finally, the program will print out a row for each layer (ASCII character), equal in width to the number of layers.

For example, if the number of layers was 3, it should print out a cake that is 3x3 characters large. If the number of layers was 5, it should print out a cake that is 5x5 characters large.

Examples

dcc custom_cake.c -o custom_cake
./custom_cake
How many layers: 5
Please enter layers: *|=~=
*****
|||||
=====
~~~~~
=====
./custom_cake
How many layers: 3
Please enter layers: =&=
===
&&&
===

Assumptions/Restrictions/Clarifications

• The number of layers will always be a non-zero positive integer.
• The number of characters input will always match the number of layers.
• The width of each layer will always be the same as the total number of layers.
• You may assume that a whitesapce ' ', will never be the character for a layer.

1511 style custom_cake.c

When you think your program is working, you can use autotest to run some simple automated tests:

1511 autotest custom_cake

When you are finished working on this exercise, you must submit your work by running give:

give cs1511 lab03_custom_cake custom_cake.c

You must run give before Monday 30 September 20:00 to obtain the marks for this lab exercise. Note that this is an individual exercise, the work you submit with give must be entirely your own.

// Custom Cake
// custom_cake.c
//
// This program was written by Morgan Swaak (z5476300)
// on 15/01/24
//
// A program which prints out a layered cake.

#include <stdio.h>

int main(void) {
    printf("How many layers: ");
    int num_layers;
    scanf("%d", &num_layers);

    printf("Please enter layers: ");

    int i = 0;
    char layer;
    while (i < num_layers) {
        scanf(" %c", &layer);
        int j = 0;
        while (j < num_layers) {
            printf("%c", layer);
            j++;
        }
        printf("\n");
        i++;
    }
    return 0;
}

Design a program named letters_between.c that accepts a starting letter and target letter as input. The program should calculate the shortest path between the two given letters by either moving forwards or backwards through the alphabet. The program then prints out all the letters from the starting letter to the target letter along the shortest path.

For example, if 'c' and 'k' were entered as the starting and target letters respectivley, the program would calculate the path moving forwards through the alphabet to be cdefghijk, which takes 9 letters and the
the path moving backwards through the alphabet to be cbazyxwvutsrqponmlk, which takes 19 letters.

Hence the program will print cdefghijk as 9 letters is less than 19.

Note In the case where the number of letters are equal, the program will print the letters moving forwards through the alphabet.

Examples

dcc letters_between.c -o letters_between
./letters_between
Please enter starting letter: H
Please enter target letter: K
HIJK
./letters_between
Please enter starting letter: b
Please enter target letter: w
bazyxw
./letters_between
Please enter starting letter: Q
Please enter target letter: D
QRSTUVWXYZABCD
./letters_between
Please enter starting letter: m
Please enter target letter: m
m

Assumptions/Restrictions/Clarifications

• The starting and target letters will either be both uppercase or both lowercase.
• The result should be printed in the same case as the input.
• Letters will be from the english alphabet (a,b,c ... x,y,z).
• If the starting letter and target letter are the same the program should only print one character.
• If the number of letters are the same moving forwards and backwards, choose forwards.

1511 style letters_between.c

When you think your program is working, you can use autotest to run some simple automated tests:

1511 autotest letters_between

When you are finished working on this exercise, you and your lab partner must both submit your work by running give:

give cs1511 lab03_letters_between letters_between.c

Note, even though this is a pair exercise, you both must run give from your own account before Monday 30 September 20:00 to obtain the marks for this lab exercise.

// Letters Between
// letters_between.c
//
// This program was written by Morgan Swaak (z5476300)
// on 31/01/24
//
// A program that prints the shortest length of characters 
// between two letters.

#include <stdio.h>

#define NUM_LETTERS 26
#define REVERSE NUM_LETTERS - 1
#define SEQUENTIAL 1

int main(void) {
    // get input
    printf("Please enter starting letter: ");
    char start_letter;
    scanf(" %c", &start_letter);
    printf("Please enter target letter: ");
    char target_letter;
    scanf(" %c", &target_letter);

    int distance_sequential = target_letter - start_letter;

    int distance_reverse = start_letter - target_letter;

    // make sure numbers are positive
    if (distance_sequential < 0) {
        distance_sequential += NUM_LETTERS;
    } else {
        distance_reverse += NUM_LETTERS;
    }

    // we also check capitalisation
    int offset;
    if ('a' <= start_letter && start_letter <= 'z') {
        offset = 'a';
    } else {
        offset = 'A';
    }

    int direction;
    if (distance_sequential <= distance_reverse) {
        direction = SEQUENTIAL;
    } else {
        direction = REVERSE;
    }

    // generalising so printing works for upper and lower case.
    int start = start_letter - offset;
    int target = target_letter - offset;

    // print out result
    int current = start;
    while (current != target) {
        printf("%c", current + offset);
        current = (current + direction) % NUM_LETTERS;
    }
    printf("%c\n", target + offset);
    return 0;
}

Download street_fighter.c here

Or, copy these file(s) to your CSE account using the following command:

1511 fetch-activity street_fighter

Each round, the program should prompt each fighter to attack.

When a fighter attacks, their opponent's health should immediately be reduced by the attacking fighter's attack power. A fighter that is below 50% of their maximum health deals 50% more damage. If during a round a fighter is brought below 50% of their maximum health, they should immediately start dealing 50% more damage to their opponent from that point onwards.

If fighter 2 has no health remaining after fighter 1 attacks, fighter 2 still has the opportunity to attack before the fight is over.

At the end of each round, the program should print out the current health of each fighter. If either fighter has no health remaining at the end of a round, the fight is over and the program should print which fighter won.

If both fighters have no health remaining at the end of the fight your program should print It's a draw! instead.

Finally the program should then print GAME OVER and exit.

You are provided with struct fighter which contains the following fields:

1. int attack: The attack power of the fighter. A fighter's attack power will come from the user and will be between 1 and 10.
2. double health: The current health of the fighter. Fighter's begin with a maximum health of 50.
3. char attack_command: The key binding for the attack command.

Examples

dcc street_fighter.c -o street_fighter
./street_fighter
Welcome to Street Fighter!

Enter Fighter 1's attack power (1-10): 7
Enter an ascii character for Fighter 1's attack command: a

Enter Fighter 2's attack power (1-10): 10
Enter an ascii character for Fighter 2's attack command: b

FIGHT!

Fighter 1, press a to attack: a
Fighter 1 attacks!
Fighter 2, press b to attack: b
Fighter 2 attacks!

Fighter 1's health: 40.0
Fighter 2's health: 43.0
Fighter 1, press a to attack: a
Fighter 1 attacks!
Fighter 2, press b to attack: b
Fighter 2 attacks!

Fighter 1's health: 30.0
Fighter 2's health: 36.0
Fighter 1, press a to attack: a
Fighter 1 attacks!
Fighter 2, press b to attack: b
Fighter 2 attacks!

Fighter 1's health: 20.0
Fighter 2's health: 29.0
Fighter 1, press a to attack: a
Fighter 1 attacks!
Fighter 2, press b to attack: b
Fighter 2 attacks!

Fighter 1's health: 5.0
Fighter 2's health: 18.5
Fighter 1, press a to attack: a
Fighter 1 attacks!
Fighter 2, press b to attack: b
Fighter 2 attacks!

Fighter 1's health: -10.0
Fighter 2's health: 8.0

Fighter 2 wins!
GAME OVER
./street_fighter
Welcome to Street Fighter!

Enter Fighter 1's attack power (1-10): 10
Enter an ascii character for Fighter 1's attack command: a

Enter Fighter 2's attack power (1-10): 9
Enter an ascii character for Fighter 2's attack command: s

FIGHT!

Fighter 1, press a to attack: a
Fighter 1 attacks!
Fighter 2, press s to attack: s
Fighter 2 attacks!

Fighter 1's health: 41.0
Fighter 2's health: 40.0
Fighter 1, press a to attack: a
Fighter 1 attacks!
Fighter 2, press s to attack: s
Fighter 2 attacks!

Fighter 1's health: 32.0
Fighter 2's health: 30.0
Fighter 1, press a to attack: a
Fighter 1 attacks!
Fighter 2, press s to attack: s
Fighter 2 attacks!

Fighter 1's health: 18.5
Fighter 2's health: 20.0
Fighter 1, press a to attack: a
Fighter 1 attacks!
Fighter 2, press s to attack: s
Fighter 2 attacks!

Fighter 1's health: 5.0
Fighter 2's health: 5.0
Fighter 1, press a to attack: a
Fighter 1 attacks!
Fighter 2, press s to attack: s
Fighter 2 attacks!

Fighter 1's health: -8.5
Fighter 2's health: -10.0

It's a draw!
GAME OVER

Assumptions/Restrictions/Clarifications

• You may find %0.1lf useful for formatting the health of each fighter.
• Assume you will only be given valid inputs for the attack power and attack command.

1511 style street_fighter.c

When you think your program is working, you can use autotest to run some simple automated tests:

1511 autotest street_fighter

When you are finished working on this exercise, you must submit your work by running give:

give cs1511 lab03_street_fighter street_fighter.c

You must run give before Monday 30 September 20:00 to obtain the marks for this lab exercise. Note that this is an individual exercise, the work you submit with give must be entirely your own.

// Street Fighter
// street_fighter.c
//
// This program was written by Ibrahim Ghoneim (z5470570)
// on 14/01/2024
//
// Let's play Street Fighter!
// 3..2..1.. FIGHT!

#include <stdio.h>

#define MAX_HEALTH 50.0
#define MAX_ATTACK 10

// Provided fighter struct
struct fighter {
    int attack;
    double health;
    char attack_command;
};

int main(void) {
    printf("Welcome to Street Fighter!\n");
    ////////////////////////////////////////////////////////////////////////////
    ///////////////////////// Fighter 1 Creation ///////////////////////////////
    ////////////////////////////////////////////////////////////////////////////
    struct fighter fighter1;

    printf("\nEnter Fighter 1's attack power (1-10): ");
    scanf("%d", &fighter1.attack);

    fighter1.health = MAX_HEALTH;

    printf("Enter an ascii character for Fighter 1's attack command: ");
    scanf(" %c", &fighter1.attack_command);
    ////////////////////////////////////////////////////////////////////////////
    /////////////////////////// REPEAT FOR FIGHTER 2 ///////////////////////////
    ////////////////////////////////////////////////////////////////////////////
    struct fighter fighter2;

    printf("\nEnter Fighter 2's attack power (1-10): ");
    scanf("%d", &fighter2.attack);

    fighter2.health = MAX_HEALTH;

    printf("Enter an ascii character for Fighter 2's attack command: ");
    scanf(" %c", &fighter2.attack_command);
    ////////////////////////////////////////////////////////////////////////////
    //////////////////////////////// Fight Loop ////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////
    printf("\nFIGHT!\n\n");
    char action;
    while (fighter1.health > 0 && fighter2.health > 0) {
        printf("Fighter 1, press %c to attack: ", fighter1.attack_command);
        scanf(" %c", &action);
        if (action == fighter1.attack_command) {
            printf("Fighter 1 attacks!\n");
            if (fighter1.health < MAX_HEALTH/2) {
                fighter2.health -= fighter1.attack * 1.5;
            } else {
                fighter2.health -= fighter1.attack;
            }
        }
    ////////////////////////////////////////////////////////////////////////////
    /////////////////////////// REPEAT FOR FIGHTER 2 ///////////////////////////
    ////////////////////////////////////////////////////////////////////////////
        printf("Fighter 2, press %c to attack: ", fighter2.attack_command);
        scanf(" %c", &action);
        if (action == fighter2.attack_command) {
            if (fighter2.health < MAX_HEALTH/2) {
                fighter1.health -= fighter2.attack * 1.5;
            } else {
                fighter1.health -= fighter2.attack;
            }
            printf("Fighter 2 attacks!\n");
        }
        printf("\n");
        printf("Fighter 1's health: %.01lf\n", fighter1.health);
        printf("Fighter 2's health: %.01lf\n", fighter2.health);
    }

    ////////////////////////////////////////////////////////////////////////////
    ////////////////////////////// Fight Results ///////////////////////////////
    ////////////////////////////////////////////////////////////////////////////
    printf("\n");
    if (fighter1.health <= 0 && fighter2.health <= 0) {
        printf("It's a draw!\n");
    } else if (fighter1.health > 0) {
        printf("Fighter 1 wins!\n");
    } else {
        printf("Fighter 2 wins!\n");
    }
    
    printf("GAME OVER\n");
    return 0;
}

Write a program called xtreme.c that reads an (odd) integer n from standard input, and prints an n x n a square of asterisks and dashes in the following pattern:

Enter size: 9
*---*---*
-*-----*-
--*---*--
---*-*---
*---*---*
---*-*---
--*---*--
-*-----*-
*---*---*

Enter size: 15
*---*-----*---*
-*---*---*---*-
--*---*-*---*--
---*---*---*---
*---*-----*---*
-*---*---*---*-
--*---*-*---*--
---*---*---*---
--*---*-*---*--
-*---*---*---*-
*---*-----*---*
---*---*---*---
--*---*-*---*--
-*---*---*---*-
*---*-----*---*

Enter size: 25
*---*---*---*---*---*---*
-*---*---*-----*---*---*-
--*---*---*---*---*---*--
---*---*---*-*---*---*---
*---*---*---*---*---*---*
-*---*---*-----*---*---*-
--*---*---*---*---*---*--
---*---*---*-*---*---*---
*---*---*---*---*---*---*
-*---*---*-----*---*---*-
--*---*---*---*---*---*--
---*---*---*-*---*---*---
*---*---*---*---*---*---*
---*---*---*-*---*---*---
--*---*---*---*---*---*--
-*---*---*-----*---*---*-
*---*---*---*---*---*---*
---*---*---*-*---*---*---
--*---*---*---*---*---*--
-*---*---*-----*---*---*-
*---*---*---*---*---*---*
---*---*---*-*---*---*---
--*---*---*---*---*---*--
-*---*---*-----*---*---*-
*---*---*---*---*---*---*

For more examples of this pattern, see the example program output at the end of this question

This exercise is designed to give you practice with while loops, if statements and some mathematical operators.

As the course has not taught arrays yet, you are not permitted to use an array in this exercise.

Examples

dcc xtreme.c -o xtreme
./xtreme
Enter size: 5
*---*
-*-*-
--*--
-*-*-
*---*
./xtreme
Enter size: 7
*-----*
-*---*-
--*-*--
---*---
--*-*--
-*---*-
*-----*
./xtreme
Enter size: 11
*---*-*---*
-*---*---*-
--*-----*--
---*---*---
*---*-*---*
-*---*---*-
*---*-*---*
---*---*---
--*-----*--
-*---*---*-
*---*-*---*
./xtreme
Enter size: 13
*---*---*---*
-*---*-*---*-
--*---*---*--
---*-----*---
*---*---*---*
-*---*-*---*-
--*---*---*--
-*---*-*---*-
*---*---*---*
---*-----*---
--*---*---*--
-*---*-*---*-
*---*---*---*
./xtreme
Enter size: 17
*---*---*---*---*
-*---*-----*---*-
--*---*---*---*--
---*---*-*---*---
*---*---*---*---*
-*---*-----*---*-
--*---*---*---*--
---*---*-*---*---
*---*---*---*---*
---*---*-*---*---
--*---*---*---*--
-*---*-----*---*-
*---*---*---*---*
---*---*-*---*---
--*---*---*---*--
-*---*-----*---*-
*---*---*---*---*

Assumptions/Restrictions/Hints

• You can assume n is odd and n >= 5.
• You may assume that you will be given only integers as input
• You may assume that all input is valid

1511 style xtreme.c

When you think your program is working, you can use autotest to run some simple automated tests:

1511 autotest xtreme

When you are finished working on this exercise, you must submit your work by running give:

give cs1511 lab03_xtreme xtreme.c

You must run give before Monday 30 September 20:00 to obtain the marks for this lab exercise. Note that this is an individual exercise, the work you submit with give must be entirely your own.

#include <stdio.h>

#define GAP 4


int main(void) {

    printf("Enter size: ");
    int size;
    scanf("%d", &size);

    int half_size = size/2;

    int row = 0;
    while (row < size) {
        int column = 0;
        while (column < size) {
            // Top left/bottom right quadrant
            if ((row <= half_size) == (column < half_size)) {
                if (row % GAP == column % GAP) {
                    printf("*");
                } else {
                    printf("-");
                }

            // bottom right/ top left quadrant
            } else {
                if (row % GAP == (size - 1 - column) % GAP) {
                    printf("*");
                } else {
                    printf("-");
                }
            }
            column = column + 1;
        }
        printf("\n");
        row = row + 1;
    }

    return 0;
}

// A program that prints an n x n square of dashes in a certain pattern
// By Nathan Colyer on the 28/02/2023

#include <stdio.h>

int abs(int x);

int main(void) {
    int len;
    // Note that 'size' (len) is odd and greater than 5
    printf("Enter size: ");
    scanf(" %d", &len);

    for (int row = 0; row < len; row++) {
        for (int col = 0; col < len; col++) {
            int col_mirror = abs(col - len / 2);
            int row_mirror = abs(row - len / 2);
            if ((row_mirror - col_mirror) % 4 == 0) {
                putchar('*');
            } else {
                putchar('-');
            }
        }
        putchar('\n');
    }
    return 0;
}

// Takes the absolute value of a number
int abs(int x) {
    if (x < 0) x = -x;
    return x;
};

For this activity you will create the program abc_grid.c.

The program will create a cascading pattern in the form of a grid of letters. First the program will ask the user to choose a grid size by entering the number of rows and then the number of columns. The program will then ask for a starting letter and the starting coordinates for this letter. This is where the pattern will start from.

In the example below the starting letter is Y. Lets say it's starting position was [x][y] where x and y are some starting co-ordinates. The letter following Y in the alphabet is Z and hence the immediate surrounding positions ([x + 1][y], [x - 1][y], [x][y + 1], [x][y - 1]) are Z. This pattern now continues from Z where the next letter is A and so on to B. This pattern will continue until the grid has been filled!

   B
  BAB
 BAZAB
BAZYZAB
 BAZAB
  BAB
   B

Examples

dcc abc_grid.c -o abc_grid
./abc_grid
How many rows: 3
How many columns: 2
Please choose starting letter: a
Please enter starting coordinates: 2 1
dc
cb
ba
./abc_grid
How many rows: 6
How many columns: 7
Please choose starting letter: W
Please enter starting coordinates: 2 3
BAZYZAB
AZYXYZA
ZYXWXYZ
AZYXYZA
BAZYZAB
CBAZABC

Assumptions/Restrictions/Clarifications

• Starting indexing for rows and columns starts at 0 (i.e. first row = 0).
• The ouput should be in the same case as the starting letter.
• You will always be given a letter from the alphabet.
• When reaching the letter 'z' it wraps around to 'a'.
• Letter starting coordinates will always be within the given row and column range.
• The number of rows and columns will always be integers greater than 0.

1511 style abc_grid.c

When you think your program is working, you can use autotest to run some simple automated tests:

1511 autotest abc_grid

When you are finished working on this exercise, you must submit your work by running give:

give cs1511 lab03_abc_grid abc_grid.c

You must run give before Monday 30 September 20:00 to obtain the marks for this lab exercise. Note that this is an individual exercise, the work you submit with give must be entirely your own.

// ABC Grid
// abc_grid.c
//
// This program was written by Morgan Swaak (z5476300)
// on 31/01/24
//
// A program which prints out an abc grid cascading from a starting letter.

#include <stdio.h>

#define NUM_LETTERS 26

int main (void) {
    printf("How many rows: ");
    int num_rows;
    scanf("%d", &num_rows);
    printf("How many columns: ");
    int num_cols;
    scanf("%d", &num_cols);

    printf("Please choose starting letter: ");
    char start_letter;
    scanf(" %c", &start_letter);

    printf("Please enter starting coordinates: ");
    int start_row;
    int start_col;
    scanf("%d %d", &start_row, &start_col);

    int offset;
    if ('a' <= start_letter && start_letter <= 'z') {
        offset = 'a';
    } else if ('A' <=  start_letter && start_letter <= 'Z') {
        offset = 'A';
    }

    // first we need to calculate what char to print first
    // abc_index eg if 'a' = 0, 'b' = 1, 'z' = 25
    int abc_index = start_letter - offset;
    char row_start = (abc_index + start_row + start_col) % NUM_LETTERS + offset;
    
    // 2D loop will print out the abc_grid
    int i = 0;
    while (i < num_rows) {
        // creating a current variable which will be used for printing along 
        // the row
        char current = row_start;
        int j = 0;
        while (j < num_cols) {
            printf("%c", current);
            // abc_index eg if 'a' = 0, 'b' = 1, 'z' = 25
            abc_index = current - offset;
            // checks if column is before starting letter (count backwards 
            // through alphabet) or after (count forwards through alphabet)
            if (j < start_col) {
                current = (abc_index + NUM_LETTERS - 1) % NUM_LETTERS + offset;
            } else {
                current = (abc_index + 1) % NUM_LETTERS + offset;  
            }
            j++;
        }
        printf("\n");

        // increment row counter
        abc_index = row_start - offset;
        if (i < start_row) {
            row_start = (abc_index + NUM_LETTERS - 1) % NUM_LETTERS + offset;
        } else {
            row_start = (abc_index + 1) % NUM_LETTERS + offset;
        }
        i++;
    }
    return 0;
}

Write a program called spiral.c that reads an integer n from standard input. and prints an n x n pattern of asterisks and dashes in the shape of a spiral.

Examples

dcc spiral.c -o spiral
./spiral
Enter size: 5
*****
----*
***-*
*---*
*****
./spiral
Enter size: 7
*******
------*
*****-*
*---*-*
*-***-*
*-----*
*******
./spiral
Enter size: 9
*********
--------*
*******-*
*-----*-*
*-***-*-*
*-*---*-*
*-*****-*
*-------*
*********
./spiral
Enter size: 17
*****************
----------------*
***************-*
*-------------*-*
*-***********-*-*
*-*---------*-*-*
*-*-*******-*-*-*
*-*-*-----*-*-*-*
*-*-*-***-*-*-*-*
*-*-*-*---*-*-*-*
*-*-*-*****-*-*-*
*-*-*-------*-*-*
*-*-*********-*-*
*-*-----------*-*
*-*************-*
*---------------*
*****************

Assumptions/Restrictions/Clarifications

• You can assume n is odd and n >= 5.

1511 style spiral.c

When you think your program is working, you can use autotest to run some simple automated tests:

1511 autotest spiral

//spiral.c
//By Alex Rowell z5116848
//Written 20th/21st March 2017
//A program to print a spiral of stars

#include <stdio.h>
#include <stdlib.h>


//A key part of this implementation is splitting the numbers into lines
//These are the straight lines of numbers, with the first number coming from the line before
//There are 4 cases to deal with each line based on which direction it would go when spiraling inwards
//(For the example below 'r' is for lines going right, 'd' for lines going down, 'u' for lines going up and 'l' for lines going left)
//eg.
// rrrrr
// ----d
// urr-d
// u---d
// lllld

int main(void) {
    int num;

    printf("Enter size: ");
    if (!scanf("%d", &num) || num % 2 == 0) {
        //Did not get a number or the number is even, exit
        return 1;
    }

    int row = 0;
    int col = 0;

    while (row < num) {
        col = 0;

        while (col < num) {
            if (row <= num/2 && row % 2 == 0 && col >= row - 1 && col <= num-row - 1) { //Line going to the right

                printf("*");

            } else if (row > num/2 && row % 2 == 0 && col <= row && col >= num - row - 1) { //Line going to the left

                printf("*");

            } else if (col <= num/2 && col % 2 == 0 && row >= col + 2 && row < num - col - 1) { //Line going upwards

                printf("*");

            } else if (col > num/2 && col % 2 == 0 && row <= col && row >= num - col) { //Line going downwards

                printf("*");

            } else { // Not part of any line

                printf("-");

            }

            col = col + 1;
        }
        printf("\n");
        row = row + 1;
    }

    return 0;
}

Write a program called decimal_spiral.c that reads an integer n from standard input. and prints an n x n pattern of decimal digits and dashes in the shape of a spiral.

Examples

dcc decimal_spiral.c -o decimal_spiral
./decimal_spiral
Enter size: 5
65432
----1
210-0
3---9
45678
./decimal_spiral
Enter size: 7
0987654
------3
87654-2
9---3-1
0-012-0
1-----9
2345678
./decimal_spiral
Enter size: 9
876543210
--------9
8765432-8
9-----1-7
0-210-0-6
1-3---9-5
2-45678-4
3-------3
456789012
./decimal_spiral
Enter size: 15
654321098765432
--------------1
2109876543210-0
3-----------9-9
4-210987654-8-8
5-3-------3-7-7
6-4-87654-2-6-6
7-5-9---3-1-5-5
8-6-0-012-0-4-4
9-7-1-----9-3-3
0-8-2345678-2-2
1-9---------1-1
2-01234567890-0
3-------------9
456789012345678

Assumptions/Restrictions/Clarifications

• You can assume n is odd and n >= 5.

1511 style decimal_spiral.c

When you think your program is working, you can use autotest to run some simple automated tests:

1511 autotest decimal_spiral

//decimal_spiral.c
//By Alex Rowell z5116848
//Written 20th March 2017
//A program to print a spiral of numbers, with the numbers increasing as it spirals outwards

#include <stdio.h>
#include <stdlib.h>


//These are for the direction of the current line being printed (to be explained below)
#define DIR_NONE 0
#define DIR_LEFT 1
#define DIR_RIGHT 2
#define DIR_UP 3
#define DIR_DOWN 4


//A key part of this implementation is splitting the numbers into lines
//These are the straight lines of numbers, with the first number coming from the line before
//There are 4 cases to deal with each line based on which direction it would go when spiraling inwards
//(For the example below 'r' is for lines going right, 'd' for lines going down, 'u' for lines going up and 'l' for lines going left)
//eg.
// rrrrr
// ----d
// urr-d
// u---d
// lllld

int main(void) {
    int num;

    printf("Enter size: ");
    if (!scanf("%d", &num) || num % 2 == 0) {
        //Did not get a number or the number is even, exit
        return 1;
    }


    // These are the sizes of the original lines, the right line starts
    // longer than the others since it doesn't have another direction that takes its first number
    // The up line starts shorter than the others since every time it gets to the upwards line the line
    // gets smaller
    int original_up_size = num - 3;
    int original_down_size = num - 1;
    int original_right_size = num + 1;
    int original_left_size = num - 1;



    //Determine the total number of numbers to write (so that it can count down)
    //This is done by simulating each side
    int total_stars = 0;

    int up_size = original_up_size;
    int down_size = original_down_size;
    int right_size = original_right_size;
    int left_size = original_left_size;

    while (up_size > 0) {
        total_stars = total_stars + up_size;
        up_size = up_size - 4; //Every go of the spiral, each side shrinks by 4
    }
    while (down_size > 0) {
        total_stars = total_stars + down_size;
        down_size = down_size - 4;
    }
    while (right_size > 0) {
        total_stars = total_stars + right_size;
        right_size = right_size - 4;
    }
    while (left_size > 0) {
        total_stars = total_stars + left_size;
        left_size = left_size - 4;
    }


    int row = 0;
    int col = 0;

    while (row < num) {
        col = 0;

        while (col < num) {

            int line_num = 0; // The number of line changes in the spiral before this line

            int offset = 0; // The number along the line this position is

            int line_dir = DIR_NONE; //The direction the line's going (or none if a dash should be printed)


            if (row <= num/2 && row % 2 == 0 && col >= row - 1 && col <= num-row - 1) { //Line going to the right
                line_dir = DIR_RIGHT;
                line_num = (row / 2 * 4);

                offset = col - row + 2;

            } else if (row > num/2 && row % 2 == 0 && col <= row && col >= num - row - 1) { //Line going to the left
                line_dir = DIR_LEFT;
                line_num = ((num-row-1)/2 * 4) + 2;

                offset = row - col;

            } else if (col <= num/2 && col % 2 == 0 && row >= col + 2 && row < num - col - 1) { //Line going upwards
                line_dir = DIR_UP;
                line_num = (col / 2 * 4) + 3;

                offset = num - col - 1 - row;
            } else if (col > num/2 && col % 2 == 0 && row <= col && row >= num - col) { //Line going downwards
                line_dir = DIR_DOWN;
                line_num = ((num-col-1)/2 * 4) + 1;

                offset = row - num + col + 1;
            }

            if (line_dir != DIR_NONE) {
                // Reset the number of stars in the first line of each type
                // For calculating the number to print out
                up_size = original_up_size;
                down_size = original_down_size;
                right_size = original_right_size;
                left_size = original_left_size;

                int num_so_far = 0; //The total numbers that have been printed so far in the spiral
                int i = 0;

                while (i < line_num) {
                    // Similar to calculating total number of numbers printed in the whole spiral
                    // but in this case only go up to the current line
                    if (i % 4 == 0) { // rightwards line
                        num_so_far = num_so_far + right_size;
                        right_size = right_size - 4;
                    } else if (i % 4 == 1) { // downwards line
                        num_so_far = num_so_far + down_size;
                        down_size = down_size - 4;
                    } else if (i % 4 == 2) { // leftwards line
                        num_so_far = num_so_far + left_size;
                        left_size = left_size - 4;
                    } else { // i % 4 == 3, upwards line
                        num_so_far = num_so_far + up_size;
                        up_size = up_size - 4;
                    }

                    i = i + 1;
                }

                num_so_far = num_so_far + offset; // Include the amount printed in the current line

                int to_print = total_stars - num_so_far; // Subtract num_so_far from total_stars as
                // the spiral should be counting down as it goes inwards
                printf("%d", to_print % 10); // Only take last digit of what to print

            } else {
                printf("-"); // Not part of spiral, just print a dash
            }
            col = col + 1;
        }
        printf("\n");
        row = row + 1;
    }

    return 0;
}

// Draws a decimal spiral of size defined by the user. O(n^2)
// By Sabine Lim z5242579
// For COMP1511 Lab04

// The implementation consists of 2 parts:
// 1. Loop left to right, up to down, calling an isDigit function to
// know whether to print a digit or a dash for each coordinate
// 2. If a digit should be printed, call a getDigit function to
// calculate the digit to be printed

// The isDigit function is the same the code for the regular spiral, but
// instead of printing an asterisk it returns 1 to whatever code called it

// getDigit works by splitting the spiral into triangular quadrants
//
//   *******
// *  *****  *
// **  ***  **
// ***  *  ***
// **  ***  **
// *  *****  *
//   *******
//
// For the top quadrant, observe the following digits
//
// 6**************
// --------------*
// **0**********-*
// *-----------*-*
// *-**0******-*-*
// *-*-------*-*-*
// *-*-**6**-*-*-*
// *-*-*---*-*-*-*
// *-*-*-***-*-*-*
// *-*-*-----*-*-*
// *-*-*******-*-*
// *-*---------*-*
// *-***********-*
// *-------------*
// ***************
//
// The actual numbers at the location of these digits form a quadratic sequence
// 6  30  70  126
//  24  40  56
//    16  16
// Where the differences between the differences is 16.
// Using this, you can make a quadratic sequence for the top left corners
// of each box, and subtract the current column to find the digits for
// coordinates to the right
//
// You'll need to come up with a different quadratic equation for each quadrant
// Since there are 2 types of spiral (last digit in the centre, last digit
// off-centre, that's a total of 8 different quadratic equations
// Use the current column or current row accordingly to determine how much
// to add or subtract from the corner values

#include <stdio.h>

int abs(int i);
// Returns 0 if current coordinate is a dash, 1 for a digit
int isDigit(int size, int row, int col);
// Returns the integer at a specific coordinate on a box for a given size
int getDigit(int size, int row, int col);

int main() {
    int size = 0;
    printf("Enter size: ");
    scanf("%d", &size);
    int row = 0;
    while (row < size) {
        int col = 0;
        while (col < size) {
            if (isDigit(size, row, col) == 1) {
                if (row <= size / 2 && col < size / 2 && row == col + 1) {
                    // Special handling for box segments modified to be spirals
                    printf("%d", getDigit(size, row - 1, col - 1) % 10);
                } else {
                    printf("%d", getDigit(size, row, col) % 10);
                }
            } else {
                printf("-");
            }
            ++col;
        }
        printf("\n");
        ++row;
    }
    return 0;
}

int abs(int i) {
    if (i < 0) {
        i = -i;
    }
    return i;
}

int isDigit(int size, int row, int col) {
    // Absolute row distance from midpoint
    int rowDist = abs(row - size / 2);
    // Absolute column distance from midpoint
    int colDist = abs(col - size / 2);
    int isDigit = 0;
    if (size % 4 == 1) {
        // Type 1 spiral (digit in centre)
        if (row <= size / 2 && col < size / 2 && row == col + 1) {
            // Special handling to turn boxes into spirals
            if (rowDist % 2 == 0) {
                isDigit = 1;
            }
        } else if (colDist >= rowDist && colDist % 2 == 0) {
            isDigit = 1;
        } else if (colDist < rowDist && rowDist % 2 == 0) {
            isDigit = 1;
        }
    } else {
        // Type 2 spiral (no digit in centre)
        if (row <= size / 2 && col < size / 2 && row == col + 1) {
            // Special handling to turn boxes into spirals
            if (rowDist % 2 == 1) {
                isDigit = 1;
            }
        } else if (colDist >= rowDist && colDist % 2 == 1) {
            isDigit = 1;
        } else if (colDist < rowDist && rowDist % 2 == 1) {
            isDigit = 1;
        }
    }
    return isDigit;
}

int getDigit(int size, int row, int col) {
    // Row displacement from midpoint
    int rowDist = row - size / 2;
    // Absolute row distance from midpoint
    int absRowDist = abs(rowDist);
    // Column displacement from midpoint
    int colDist = col - size / 2;
    // Absolute column distance from midpoint
    int absColDist = abs(colDist);
    // Size of box current coordinate is on
    int subSize = 0;
    if (absRowDist >= absColDist) {
        subSize = 2 * absRowDist + 1;
    } else {
        subSize = 2 * absColDist + 1;
    }
    row = row - (size - subSize) / 2;
    col = col - (size - subSize) / 2;
    // Layer of current box. 0 is centre
    int layer = (subSize + 1) / 4;
    if (rowDist <= 0 && absRowDist >= absColDist) {
        // Top quadrant
        if (subSize % 4 == 1) {
            // Type 1 boxes
            return 8 * layer * layer + 8 * layer - col;
        } else {
            // Type 2 boxes
            return 8 * layer * layer - 2 - col;
        }
    } else if (colDist > 0 && absColDist > absRowDist) {
        // Right quadrant
        if (subSize % 4 == 1) {
            // Type 1 boxes
            return 8 * layer * layer + 4 * layer - row;
        } else {
            // Type 2 boxes
            return 8 * layer * layer - 4 * layer - row;
        }
    } else if (rowDist > 0 && absRowDist >= absColDist) {
        // Bottom quadrant
        if (subSize % 4 == 1) {
            // Type 1 boxes
            return 8 * layer * layer - 4 * layer + col;
        } else {
            // Type 2 boxes
            return 8 * layer * layer - 12 * layer + 4 + col;
        }
    } else {
        // Left quadrant
        if (subSize % 4 == 1) {
            // Type 1 boxes
            return 8 * layer * layer - 8 * layer + row;
        } else {
            // Type 2 boxes
            return 8 * layer * layer - 16 * layer + 6 + row;
        }
    }
}

Download debug_square.c here

Or, copy these file(s) to your CSE account using the following command:

1511 fetch-activity debug_square

Note that this exercise is not marked or worth marks!

Debugging Tips!

Some debugging tips for you:

• dcc output - as you run into issues, dcc will point you to where the errors are. Remember that dcc gives you the line number the issue is on, and will give some sort of explanation. Make sure you read everything dcc gives you. Sometimes we get “errors carried forward”, so find your first error, fix that, then recompile.
• print statements - sometimes it can be handy to see if the flow of your code puts you in the spot you expect it to be (ie. inside the right if statement, or going through a loop the correct amount of times). A quick way you can check this is by putting print statements in your code for testing purposes, like "the value of x is %d and y is %d". This lets you check that you got against what you expected.
• COMP1511 debugging guide

The Task

This exercise takes in a positive integer 'n' as input, and prints the outline of a square of size 'n' by 'n' in asterisks ('x'). Currently it has some issues - it is your job to figure them out and fix the code.

Examples

dcc debug_square.c -o debug_square
./debug_square
Enter the size of the pattern: 2
**
**
./debug_square
Enter the size of the pattern: 5
*****
*   *
*   *
*   *
*****
./debug_square
Enter the size of the pattern: 1
*

Walkthrough

Below is a video walkthrough of this exercise! Make sure to attempt it before watching this video

1511 style debug_square.c

When you think your program is working, you can use autotest to run some simple automated tests:

1511 autotest debug_square

// debug_square.c
//
// Write a C program that prints the outline of a square in asterisks ('*').
// The program should take a positive integer 'n' as input and print the 
// outline of a square of size 'n' by 'n'.
//
// Sofia De Bellis, 2023

#include <stdio.h>

int main (void) {
    int size = 0;
    int rows = 0;
    int cols = 0;

    printf("Enter the size of the pattern: ");
    scanf("%d", &size);

    while (rows < size) {
        cols = 0;
        while (cols < size) {
            if (rows == 0 || cols == 0 || rows == size - 1 || cols == size - 1) {
                printf("*");
            } else {
                printf(" ");
            }
            cols++;
        }
        printf("\n");
        rows++;
    }
    return 0;
}

You can run give multiple times. Only your last submission will be marked.

Don't submit any exercises you haven't attempted.

If you are working at home, you may find it more convenient to upload your work via give's web interface.

Remember you have until Week 4 Monday 20:00 to submit your work.

You cannot obtain marks by e-mailing your code to tutors or lecturers.

You check the files you have submitted here.

Automarking will be run by the lecturer several days after the submission deadline, using test cases different to those autotest runs for you. (Hint: do your own testing as well as running autotest.)

After automarking is run by the lecturer you can view your results here. The resulting mark will also be available via give's web interface.