CS 341 - Principles of Programming Languages Homework #1

Note: This work is to be done in assigned groups.  Each group will submit one assignment.  Although you may divide the work, each team member should be able to independently present/describe all submitted work upon request. 

NOTE: For each assignment, you should submit not only the requested program files, but also a simple text file called README.  README files are often used by programmers to comment on the contents of a directory or give vital information.  Please make sure this plain text file is named "README", not "README.txt", "readme", "ReadMe.txt", "Read me.doc", etc.  For each assignment, your README file will contain:

• The Honor Pledge: "I affirm that I have upheld the highest principles of honesty and integrity in my academic work and have not witnessed a violation of the Honor Code."
• Your names
• Your Gettysburg ID numbers (For department assignment purposes, your name and Gettysburg ID number in combination constitute a digital signature of the Honor Pledge.)

Submission: I will have each group come to office hours and receive a new set of test input files (different from those below).  You will generate the output with your HW1 assigned language during my office hours, and email me the following output files using these filenames from each of your programs as attachments:

• README
• max1000-out.txt (output of maximum given intList1000.txt)
• factorial10-out.txt (output of factorial given factorial10.txt)
• unique1000-out.txt (output of unique given intList1000.txt)
• quicksort1000-out.txt (output of quicksort given intList1000.txt)
• bst1000-out.txt (output of binary search tree given bst1000.txt)
• bfs1000-out.txt (output of breadth-first search given bfs1000.txt)

Learning Programming Language Basics

For our 4th hour project this semester, you will be creating your own interpreted programming language.  Before you create your language grammar, an important precursor step is to gain exposure to a variety of languages in order to inform you design.  For this assignment, you will:

• Implement 6 algorithms in a programming language assigned to your group.
• Schedule and hold an evening class meeting to informally present and discuss your solutions, most least/favorite language features, etc.

The 6 algorithms you will implement will be strictly and simply defined in a programming-contest-style input/output specification where input and output will consist of only one integer per line.  These exercises range in difficulty from the level of a first introductory programming course to the level of a data structures course.  For each exercise, you'll be provided with a single test input and solution output set of text files.  You should create and use additional tests.  Knowledge of Unix standard input/output redirection ("<" / ">") and "diff" and "wc" commands will be helpful in your testing.  It is also worth your while to create script files to somewhat automate your testing.  Good testing is key.  All test files below may be downloaded in a single .zip file here.

Example testing done with Scheme from the terminal window:

$ plt-r5rs unique.scm < int-list-in.txt > my-unique-out.txt
$ diff unique-out.txt my-unique-out.txt
$ wc unique-out.txt my-unique-out.txt
 60  60 198 unique-out.txt
 60  60 198 my-unique-out.txt

Maximum

Input: a positive integer n, followed by n integers a₁, ..., a_n  (E.g. int-list-in.txt)
Output: the maximum of the n integers a₁, ..., a_n  (E.g. maximum-out.txt)

Factorial

Input: a non-negative integer n  (E.g. factorial-in.txt)
Output: n factorial, computed recursively  (E.g. factorial-out.txt)

Unique

Input: a positive integer n, followed by n integers a₁, ..., a_n  (E.g. int-list-in.txt)
Output: the unique integers of a₁, ..., a_n ordered by first occurrence  (E.g. unique-out.txt)

Note: If the language has a standard representation of a set, use that. However, for the other 5 exercises beyond Unique, it is the implementation of the algorithms that aids in learning the language.

Quicksort

Input: a positive integer n, followed by n integers a₁, ..., a_n  (E.g. int-list-in.txt)
Output: the integers of a₁, ..., a_n, sorted with the quicksort algorithm of Introduction to Algorithms 3^rd ed., by Cormen et al.  (E.g. quicksort-out.txt)

Binary Search Tree

Input: a sequence of integer pairs, one integer per line. The first integer of each pair will encode a binary tree operation (0=delete, 1=insert, 2=contains). The second integer of each pair will be the integer key for the operation. After all pairs, a single value of -1 will indicate the end of input.  (E.g. binary-search-tree-in.txt)
Output: For each delete and contains operation, output 0/1 if the given value is not/is currently contained within the binary tree, respectively.  (E.g. binary-search-tree-out.txt)
Note: The binary search tree implementation will be according to the binary search tree algorithms of Introduction to Algorithms 3^rd ed., by Cormen et al.

Breadth-First Search

Input:
- a positive integer n, indicating the number of graph nodes, indexed 0 through n-1
- pairs of node indices, one index per line, indicating an undirected edge between the indexed nodes
- a value of -1, indicating the end of the graph specification
- the start node index u
- the goal node index v  (E.g. breadth-first-search-in.txt)
Output:
- a sequence of node integers, beginning with u, ending with v, defining a graph path from u to v computed with breadth-first search, or the single integer -1 if no such path exists  (E.g. breadth-first-search-out.txt)
Note: The breadth-first search implementation will be according to the breadth-first search algorithms of Introduction to Algorithms 3^rd ed., by Cormen et al. and makes use of variable-length adjacency lists.

The Process of Learning Programming Language Basics

With each of these problems approached in sequence, there is a natural progression of questions to answer with each.  Here are some examples:

• Maximum:
  • How do I write to standard output?
  • How do I read from standard input?
  • How do a declare/read/set a variable?
  • How do I form basic decision (e.g. if-else) and iteration (e.g. while) control constructs?
• Factorial:
  • How do I define recursive functions (a.k.a. procedures, methods, subroutines, subprograms, callable units)?
• Unique:
  • How do I best represent sets?  How do I add set members and test set membership?
• Quicksort:
  • How do I construct/read from/write to random access lists?
• Binary Search Tree:
  • How do I construct objects or, alternatively, lists of heterogenous data that contain object fields (a.k.a attributes, members, instance variables).
  • How do I get/set fields of such objects/lists?
  • How do I assign object references, or do I need to simulate such references using another technique, e.g. object array indices?
• Breadth-First Search:
  • How do I dynamically add to variable length lists?

This is not an exhaustive list of questions, of course, but in them you can see a gradual, step-by-step formation of general-purpose programming competency.  These tasks get you started with basics, forming a sort of "pidgin" usage of the programming language but not necessarily providing understanding of important language idioms.  For this reason, it is also important to study many good examples of programming idioms and express/apply them yourself to become truly fluent in a programming langauge.  Expect each language to have strengths, specialty application areas, and stylistic merits that may not be obvious at first glance.  If you seek to program every language in the style of Java programmers, you'll not only be unsatisfied with most everything but Java, but you'll also miss the beauty of other language design decisions and programming paradigms.

In approaching different programming languages, become like an international traveller that is able to become immersed in the culture to the point that there will be something missed and appreciated from each culture.  For example, engage a functional programming language such as Scheme as Scheme programmers do, making liberal use of tail recursion and lesser use of loops, favoring thinking in terms of expression evaluation rather than statement execution, and you will grow to be a multi-paradigm programmer, able to discern the right programming approach to diverse problems.

Garbage Collection

One question to ask yourself for HW1 language learning: Does my programming language take care of garbage collection for me? That is, does it free up dynamically allocated memory for arrays and objects that I'm not using anymore?

If not, then when you are done with dynamically allocated memory (e.g. binary search tree nodes that are removed) one should free that memory explicitly.

In C, one can "free" memory allocated with "malloc". In C++, one needs to "delete" an object before you lose the last reference to it. Failure to free up unused memory is called a "memory leak" and results in program code consuming more and more memory over time such that it will eventually crash. (I'm not saying it will do so for our small examples, but freeing memory is part of language learning for non-garbage collecting languages.)

Side Note: Kattis Practice (NOT part of HW1)

If you're learning a programming language supported by Kattis, there are related problems you can make use of there:

• Maximum → Parking - For each test case, the minimum distance walked is when one parks between the minimum and maximum position stores, in which case, the distance walked in the circuit is 2 * (maximum - minimum).
• Factorial → Watch Out For Those Hailstones! - Implement recursively, remembering that you need 64 bit integers (longs) for this problem.
• Unique → I've Been Everywhere, Man. - Implement using sets of strings.
• Quicksort → Baloni - This is nothing to do with sorting, but is another exercise concerning 1D-array manipulation. Surprisingly, you'll not be storing the balloon heights in an array. Instead, pursue the following one-pass algorithm that will use an array count counting the number of arrow heights of previously popped balloons: For each balloon height h read, either count[h + 1] == 0 and you should make a new shot and increment count[h], or you should decrement count[h + 1] and increment count[h] (simulating this balloon being popped by a previously fired arrow). Finally, print the number of shots needed.
• Binary Search Tree and Breadth First Search →
  • For basic object-oriented programming practice, one can implement Hitting the Targets with the following implementation constraints. Define a Shape abstract object / interface with a boolean method contains(x, y), with Circle and Rectangle objects that extend / implement Shape. For the problem, build a list of shapes and make use of object-oriented polymorphism to interate through the list, calling contains(x, y) on each Shape.
  • For data structure practice, choose any significant dynamic data structure problem, e.g. A Walk Through The Forest - (topics: graph paths, Djikstra's algorithm, single-source shortest path, dynamic programming path counting) The challenge of this problem in Kattis is not running over the time limit. For language learning purposes, focus mainly on correctness for simple given cases.