Systems Programming - Examples and Exercises

This page contains some elemntary examples and problems for the Systems Programming course. More and a bit more challenging exercises are available in this collection of exam problems.

wordcount: Write a C program called wordcount that counts the words in the standard input. A word is a sequence of one or more characters delimited by white space. (Hint: there is a standard function to check whether a character is "white space".) The output should be the same as the command: wc -w.
Test package: wordcount_tests.tgz. Solutions: wordcount.c, wordcount2.c, wordcount3.c.
statistics: Write a C program in a source file called statistics.c that reads a sequence of numbers, and outputs, on a single line, the minimum value, the average value, and the maximum value. Every value must be printed as a floating-point number with exactly six digits after the decimal point. You may assume that the format of the input stream is correct, meaning that the input consists of a sequence of numbers separated by white space. However, the input may contain no numbers at all, in which case, the output must be empty.
Test package: statistics_tests.tgz.
diamond: Write a C program called diamond that takes a non-negative number n as a command-line argument, and prints on the standard output an n-by-n diamond made of '#' characters. For example, this should be the output for a 6-by-6 diamond:
```
     #
    ###
   #####
  #######
 #########
###########
 #########
  #######
   #####
    ###
     #
```
Test package: diamond_tests.tgz. Solution: diamond.c.
shellcomments: Write a C program called shellcomments that reads a shell script from the standard input, and prints on the standard output the comments in the input script. Recall that a comment is the text following the pound character ('#') up to the end of line, including the new-line character ('\n'). The output should be the same as the command: sed -n -e 's/^[^#]*#//p'
Solution: shellcomments.c. Test package: shellcomments_tests.tgz
flipline: Write a C program called flipline that reads a text file from the standard input, and prints each line in reverse order. For example, for an input line containing the characters ciao, the program should output oaic. Notice that the output must have exactly the same number of lines as the input. In particular, If an input line is terminated by a newline character ('\n'), then the output line should also be terminated by a newline character. Otherwise, if the input line is terminated by the end of file, then the output line should also terminate the file directly (without a newline character). You may assume that lines are at most 1000 characters long (bytes).
Solution: flipline.c. Test package: flipline_tests.tgz
revargs: Write a C program called revargs that takes a number of command-line arguments A₁, A₂, ..., and prints on the standard output every pair of arguments A_i A_j, with i<j, such that A_i is the reverse string of A_j (and vice-versa).
Solution: revargs.c. Test package:revargs_tests.tgz
linetoargs: In a source file called linetoargs.c write a function int line_to_args (char * argv[], int max_count, char * line) that takes an argument vector argv of maximal length max_count and a string line containing a sequence of zero or more arguments separated by one or more space characters. The function must parse the input line, change the line, and set the argv vector to point to all the component arguments. The return value is the total number of arguments read and set in argv, which must always be less than or equal to max_count. For example, with a line "one two three" and an argument vector of at most 10 elements, the result is 3 and the 3 arguments are "one", "two", and "three", respectively. You must nt allocate additional memory. You may not use any external library function, not even from the C standard library.
Solution: linetoargs.c. Test package:linetoargs_tests.tgz
sortstrings: In a source file called sortstrings.c write a function void sort_strings(const char * input, char * output, unsigned int n) that takes a sequence of n≤1000 contiguous C strings from a given input memory buffer, and copies in a given output buffer the same strings, also as a sequence of contiguous C strings, but sorted in non-decreasing lexicographical order. The order is defined by the numerical order of the character codes. Do not worry too much about the complexity of your sorting algorithm. You may not use any external library function, not even from the C standard library.
Solution: sortstrings.c. Test package:sortstrings_tests.tgz
twotimes: In a source file called twotimes.c write two functions, int twotimes(const char *s) and int twotimes2(const char *begin, const char *end), that return true (non zero) if the string passed as argument consists of the concatenation of two identical strings, or false (zero) otherwise. The twotimes function takes a C-string, meaning a zero-terminated string. The twotimes2 function takes any sequence of chars defined by a pointer to the first character (begin) and a pointer to first character past the end of the string (end). You may not use any external library function, not even from the C standard library.
Solution: twotimes.c. Test package:twotimes_tests.tgz
listint: In a source file called list_int.c implement a doubly-linked list with sentinel as defined by the interface in list_int.h.
Solution: list_int.c. Test package:listint_tests.tgz
volumes: Write a C program called volumes that takes an integer V as a command-line argument, and then reads from the standard input a set of triples of integers representing the width, height, and depth of a container. The program must output the number of containers whose volume is at least V.
Solution: volumes.c. Test package: volumes_tests.tgz
redact digits: Write a function int redact_digits(char *s) in a C source file called redactdigits.c that modifies the string passed as input so as to redact the appearence of every digit in the string. Redacting means replacing every digit with the hash mark ('#'). The return value must be 1 if the input string was modified, or 0 otherwise.
Solution: redactdigits.c. Test package: redactdigits_tests.tgz
delete digits: Write a function int delete_digits(char *s) in a C source file called deletedigits.c that modifies the string passed as input so as to delete every digit in the string. The return value must be 1 if the input string was modified, or 0 otherwise.
Solution: deletedigits.c. Test package: deletedigits_tests.tgz
top color: Write a program called topcolor in a source file called topcolor.c. The program must reads a text file consisting of lines each specifying the dimensions (width and height) and the color of a rectangle. The program must output the color of the largest rectangle. A color is a string that is guaranteed to be shorter than 20 characters. For example, with the following input
```
10 20 blue
15 15 green
12 8 red
```
the output must be
```
green
```
If there are two or more maximal rectangles, then the program should output the color of the first one. You may not use any external library function other than the input functions from the C standard library.
Solution: topcolor.c. Test package: topcolor_tests.tgz
contains string: In a source file called containstr.c write a function int contains_str(const char * s, const char * x) The contains_str function must return true (non zero) if and only if the string s contains the string x. You may not use any external library function, not even from the C standard library.
Solution: containstr.c. Test package: containstr_tests.tgz
concatenate string: In a source file called concatenate.c write a function: int concatenate(char * s, unsigned max_size, const char * s2) The concatenate function must concatenate the string s2 to the string s making sure that the resulting string s does not contain more than max_size characters, including the terminator character. The concatenate function must return true (non zero) if and only if it concatenated the full second string s2 without exceeding the max_size limit. You may not use any external library function, not even from the C standard library.
Solution: concatenate.c. Test package: concatenate_tests.tgz
contains double: In a source file called containsdouble.c write a function: int contains_double(const char * s) The contains_double function must return true (non zero) if and only if the string s contains two identical non-empty strings separated by a hyphen character (-). For example, contains_double("there are no hyphens in this string") should return false and also contains_double("a-b") should return false, while contains_double("012-012!") should return true. You may not use any external library function, not even from the C standard library.
Solution: containsdouble.c. Test package: containsdouble_tests.tgz
radix256 tree: Implement a radix-256 tree whose API is defined by this header file: radix256_tree.h. Also write a program to test your implementation.
Partial solution: radix256_tree.c
six degrees of Renato Pozzetto: Implement a program that reads and processes a movie/actor graph, and can answer queries about Renato Pozzetto (or any other actor, really). The graph is defined by the IMDB data files whose format is described here. You program must take the name of a central actor as a command-line parameter (default is Renato Pozzetto). The program must also take the name of the tab-separated files that define the graph (default are name.basics.tsv, title.basics.tsv, title.principals.tsv). The program must then answer queries read from the standard input. A query could be the name of an actor, in which case, the program must find a sequence of movies and other actors that "connect" that actor to the central actor.