CITS2002 Systems Programming

Lecture & Workshop
recordings on LMS

Schedule

FAQ

Unit outline

C textbooks

OS textbooks

Information resources

Look after yourself!

Labsheet 2 - for the week commencing 5th August 2024

Many tasks will require you to write functions that take one or more arguments and perform operation on them. Typically, these arguments will be read from the command-line of the program. The name of your program may be obtained from the variable (array element) argv[0]. The first "true" command-line argument to your program may be obtained from the variable (array element) argv[1]. Subsequent command-line arguments may be obtained with the code argv[2], argv[3], and so on. Note that all command-line arguments are strings.

Some of this week's tasks require your programs to accept command-line arguments and convert them to integers. The following code will do this conversion for you:

#include <stdlib.h> ..... // Determine the numerical value of the program's 1st command-line argument int value = atoi( argv[1] );

The sample program square.c demonstates this concept - after checking that the program is given the correct number of command-line arguments, the program converts each argument to an integer, and passes each integer value to a function. The standard C function atoi(), pronounced a-to-i, converts an alphanumeric character string to an integer.

When displaying output to the screen, note that the last line of all output must end with a newline character, otherwise the line will be over-written by the shell's next command prompt. A newline character is represented by the 2-character sequence \n, and requests that the output device (e.g. your screen) "go to the next line".

Tasks

A year is a leap year if it is divisible by 400, or if it is divisible by 4 and not divisible by 100. For example - 1996, 2000, and 2012 were leap years, while 1899, 1900, and 2013 were not. Write a program that prints whether a year, supplied as a command-line argument, is a leap year or not.
Incorporate your support for leap years from the previous task, into your solution to the calendar printing program from Workshop-2.
Write a program which accepts exactly 3 command-line arguments (other than the program's name in argv[0]), converts each to an integer value, and prints the maximum of the 3 values.
Rewrite your solution to the previous task so that it now prints the maximum of an arbitrary number of command-line arguments, perhaps 3, or 10, or 20....
The Luhn algorithm was developed by German computer scientist Hans Peter Luhn in 1954, and is used by many credit card companies to distinguish valid credit card numbers from random sequences of digits. To determine if a given credit card number passes the Luhn test:
1. Consider the card's digits from right-to-left.
2. Taking the first, third, ... and every odd digit (from right-to-left), sum them to form the sum s1
3. Taking the second, fourth ... and every even digit (from right-to-left):
  - Multiply each even digit by two, sum that product's digits, and add together all those sums to form the sum s2
4. If (s1 + s2) ends in zero, then the original number was a valid credit card number!
Encourage everyone in the Lab to give you their credit card number (so you can test your code, of course).
Write a program that prints out the ordinal description of the (assumed numerical) arguments supplied to the program. For example:

prompt> ./ordinal 1 6 11 12 21 22 23 1st 6th 11th 12th 21st 22nd 23rd

Write programs to print each of the following shapes. Use C's for loops to control your printing, rather than just 'fixed' calls to printf (imagine if a command-line argument indicated how big the Christmas tree should be!):

a. *       
   **      
   ***     
   ****    
   *****

b.     *   
      **   
     ***   
    ****   
   *****

c. *****   
   ****    
   ***     
   **      
   *

d.     *
      ***
     *****
    *******
   *********

Ackermann's function is a function that's simple to implement, but very difficult to understand. Ackermann's function is noted for its need for deep recursion to calculate values for even small parameter values. While it was once used to benchmark processor speeds, today it only keeps Mathematicians awake at night.
- Trivially implement Ackermann's function.
- Extend your implementation to count the number of recursive calls and the maximum recursive depth required for, say, A(1, 2) and A(3, 3).
- 🌶 🌶 Redesign your implementation so that it doesn't require any global variables to maintain the counts of recursive calls and maximum recursive depth.
🌶 Write a program that prints out the "byte size" description of the (assumed numerical) arguments supplied to the program. For example:

prompt> ./bytesize 1 1200 2444555 5666777888 1Byte 1KByte 2MByte 5GByte (this one may be a challenge!)
🌶 🌶 Write a program that prints out all "Roman numeral" equivalents of the numbers between 1 and the single argument supplied to the program. Use the rules for writing Roman numerals, and the online calculator, from: Calculator Soup (just for the numerals I, V, X, L, C, D, and M).
🌶 🌶 🌶
Pursue impossible (?), or don't waste your time
Consider the following self describing sentence (which may or not be a correct solution to this problem):

This sentence has forty three As, sixty eight Bs, ..... and seventeen Zs.

Apparently, these things are named pangrammatic autograms. Write a program to print out an autogram (alphabetic case is ignored when counting the letters).