pep-material: comparison cws/cw05.tex

equal deleted inserted replaced

-:5549016ab10f
+:bebe34c975a8
 Also note that the running time of each part will be restricted to a
 maximum of 30 seconds on my laptop.
 \DISCLAIMER{}
+\subsection*{Reference Implementation}
+As usual, this Scala assignment comes with a reference implementation in form of
+two \texttt{jar}-files. You can download them from KEATS. This allows you to run any
+test cases on your own computer. For example you can call Scala on the command line with the
+option \texttt{-cp bf.jar} and then query any function from the
+\texttt{bf.scala} template file. You have to
+prefix the calls with \texttt{CW10a} and \texttt{CW10b}, respectively. For example
+\begin{lstlisting}[language={},xleftmargin=1mm,numbers=none,basicstyle=\ttfamily\small]
+$ scala -cp bf.jar
+scala> import CW10a._
+scala> run(load_bff("sierpinski.bf"))
+*
+* *
+*   *
+* * * *
+*       *
+* *     * *
+*   *   *   *
+* * * * * * * *
+*               *
+* *             * *
+*   *           *   *
+* * * *         * * * *
+*       *       *       *
+* *     * *     * *     * *
+*   *   *   *   *   *   *   *
+* * * * * * * * * * * * * * * *
+*                               *
+* *                             * *
+*   *                           *   *
+* * * *                         * * * *
+*       *                       *       *
+* *     * *                     * *     * *
+*   *   *   *                   *   *   *   *
+* * * * * * * *                 * * * * * * * *
+*               *               *               *
+* *             * *             * *             * *
+*   *           *   *           *   *           *   *
+* * * *         * * * *         * * * *         * * * *
+*       *       *       *       *       *       *       *
+* *     * *     * *     * *     * *     * *     * *     * *
+*   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *
+* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+\end{lstlisting}%$
 \subsection*{Part 1 (6 Marks)}
 Coming from Java or C++, you might think Scala is a rather esoteric
 programming language.  But remember, some serious companies have built
 their business on
 Scala.\footnote{\url{https://en.wikipedia.org/wiki/Scala_(programming_language)\#Companies}}
-And there are far, far more esoteric languages out there. One is
+I claim functional programming is not a fad.  And there are far, far
-called \emph{brainf***}. You are asked in this part to implement an
+more esoteric languages out there. One is called \emph{brainf***}. You
-interpreter and compiler for this language.
+are asked in this part to implement an interpreter for
+this language.
 Urban M\"uller developed brainf*** in 1993.  A close relative of this
 language was already introduced in 1964 by Corado B\"ohm, an Italian
 computer pioneer. The main feature of brainf*** is its minimalistic
 set of instructions---just 8 instructions in total and all of which
 shown to be Turing complete\ldots{}if this doesn't ring any bell with
 you: it roughly means that every algorithm we know can, in principle,
 be implemented in brainf***. It just takes a lot of determination and
 quite a lot of memory resources. Some relatively sophisticated sample
 programs in brainf*** are given in the file \texttt{bf.scala}, including
-a brainf*** program for the Sierpinski triangle and Mandelbot set.\bigskip
+a brainf*** program for the Sierpinski triangle and the Mandelbrot set.\bigskip
 \noindent
 As mentioned above, brainf*** has 8 single-character commands, namely
 \texttt{'>'}, \texttt{'<'}, \texttt{'+'}, \texttt{'-'}, \texttt{'.'},
 \texttt{','}, \texttt{'['} and \texttt{']'}. Every other character is
 repeated until a counter (memory cell) reaches zero.  A typical
 program in brainf*** looks as follows:
 \begin{center}
 \begin{verbatim}
-++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>+[<]<-]>>.>---.+++++++
+++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>+[<]<-]>>.>---.++
-..+++.>>.<-.<.+++.------.--------.>>+.>++.
++++++..+++.>>.<-.<.+++.------.--------.>>+.>++.
 \end{verbatim}
 \end{center}
 \noindent
-This one prints out Hello World\ldots{}obviously.
+This one prints out Hello World\ldots{}obviously ;o)
 \subsubsection*{Tasks (file bf.scala)}
 \begin{itemize}
-\item[(1)]  Write a function that takes a file name as argument and
+\item[(1)]  Write a function that takes a file name as an argument
 and requests the corresponding file from disk. It returns the
 content of the file as a String. If the file does not exists,
 the function should return the empty string.\\
 \mbox{}\hfill[1 Mark]
 \texttt{--[..[[-]+>[.]]-->,++\barbelow{\;\phantom{+}}}
 \end{center}
 \hfill[2 Marks]
-\item[(4)] Write a recursive function \texttt{run} that executes a
+\item[(4)] Write a recursive function \texttt{compute} that runs a
 brainf*** program. It takes a program, a program counter, a memory
 pointer and a memory as arguments. If the program counter is outside
-the program string, the execution stops and \texttt{run} returns the
+the program string, the execution stops and \texttt{compute} returns the
 memory. If the program counter is inside the string, it reads the
 corresponding character and updates the program counter \texttt{pc},
 memory pointer \texttt{mp} and memory \texttt{mem} according to the
 rules shown in Figure~\ref{comms}. It then calls recursively
-\texttt{run} with the updated data. The most convenient way to
+\texttt{compute} with the updated data. The most convenient way to
-implement the rules in \texttt{run} is to use pattern-matching
+implement the brainf**k rules in Scala is to use pattern-matching
-and calculating a triple consisting of the new \texttt{pc},
+and to calculate a triple consisting of the updated \texttt{pc},
 \texttt{mp} and \texttt{mem}.
-Write another function \texttt{start} that calls \texttt{run} with a
+Write another function \texttt{run} that calls \texttt{compute} with a
 given brainfu** program and memory, and the program counter and memory pointer
-set to~$0$. Like \texttt{run} it returns the memory after the execution
+set to~$0$. Like \texttt{compute}, it returns the memory after the execution
 of the program finishes. You can test your brainf**k interpreter with the
 Sierpinski triangle or the Hello world programs (they seem to be particularly
 useful for debugging purposes), or have a look at
 \begin{center}
 \url{https://esolangs.org/wiki/Brainfuck}
 \end{center}\hfill[2 Marks]
 \begin{figure}[p]
 \begin{center}
-\begin{tabular}{|@{}p{0.8cm}|l|}
+\begin{tabular}{|@{\hspace{0.5mm}}p{0.8cm}|l|}
 \hline
 \hfill\texttt{'>'} & \begin{tabular}[t]{@{}l@{\hspace{2mm}}l@{}}
 $\bullet$ & $\texttt{pc} + 1$\\
 $\bullet$ & $\texttt{mp} + 1$\\
 $\bullet$ & \texttt{mem} unchanged
 \end{tabular}\\
 \hline
 \end{tabular}
 \end{center}
 \caption{The rules for how commands in the brainf*** language update the program counter \texttt{pc},
-memory pointer \texttt{mp} and memory \texttt{mem}.\label{comms}}
+the memory pointer \texttt{mp} and the memory \texttt{mem}.\label{comms}}
 \end{figure}
 \end{itemize}\bigskip
 \subsection*{Part 2 (4 Marks)}

changeset 230	bebe34c975a8
parent 229	5549016ab10f
child 233	38ea26f227af