\documentclass{article}

\usepackage{../style}

\usepackage{../langs}

\begin{document}

\section*{Replacement Coursework 1 (Roman Numerals)}

This coursework is worth 10\%. It is about translating roman numerals

into integers and also about validating roman numerals.  The coursework

is due on 2 February at 5pm.  Make sure the files you submit can be

processed by just calling \texttt{scala <<filename.scala>>}.\bigskip

\noindent

\textbf{Important:} Do not use any mutable data structures in your

submission! They are not needed. This excludes the use of

\texttt{ListBuffer}s, for example. Do not use \texttt{return} in your

code! It has a different meaning in Scala, than in Java.  Do not use

\texttt{var}! This declares a mutable variable.  Make sure the

functions you submit are defined on the ``top-level'' of Scala, not

inside a class or object. Also note that the running time will be

restricted to a maximum of 360 seconds.

\subsection*{Disclaimer}

It should be understood that the work you submit represents your own

effort! You have not copied from anyone else. An exception is the

Scala code I showed during the lectures or uploaded to KEATS, which

you can freely use.\bigskip

\subsection*{Part 1 (Translation)}

\noindent

Roman numerals are strings consisting of the letters $I$, $V$, $X$,

$L$, $C$, $D$, and $M$. Such strings should be transformed into an

internal representation using the datatypes \texttt{RomanDigit} and

\texttt{RomanNumeral}, and then from this internal representation

converted into an Integer.

\begin{itemize}

\item[(1)] First write a polymorphic function that recursively

  transforms a list of options into an option of a list. For example,

  if you have the lists on the left, they should be transformed into

  the option on the right:

  \begin{center}

  \begin{tabular}{lcl}  

    \texttt{List(Some(1), Some(2), Some(3))} & $\Rightarrow$ &

    \texttt{Some(List(1, 2, 3))} \\

    \texttt{List(Some(1), None, Some(3))} & $\Rightarrow$ &

    \texttt{None} \\

    \texttt{List()} & $\Rightarrow$ & \texttt{Some(List())}

  \end{tabular}  

  \end{center}

  This means the function should produce \texttt{None} as soon

  as a \texttt{None} is inside the list. Otherwise it produces

  a list of all \texttt{Some}s. In case the list is empty, it

  produces \texttt{Some} of the empty list. \hfill[1 Mark]

\item[(2)] Write a function first a function that converts a character

  $I$, $V$, $X$, $L$, $C$, $D$, or $M$ into an option of a \texttt{RomanDigit}.

  If it is one of the roman digits, it should produce \texttt{Some};

  otherwise \texttt{None}.

  Next write a function that converts a string into a \texttt{RomanNumeral}.

  Again, this function should return an \texttt{Option}:

  If the string consists of $I$, $V$, $X$, $L$, $C$, $D$, and $M$ only, then

  it produces \texttt{Some}; otherwise if there is any other character in

  the string, it should produce \texttt{None}. The empty string is just

  the empty \texttt{RomanNumeral}, that is empty list of \texttt{RomanDigit}'s.

  You should use the function under Task (1) to produce the result.

  \hfill[2 Marks]

\item[(3)] Write a recursive function RomanNumral2Int that converts a

  \texttt{RomanNumeral} into an integer. You can assume the generated

  integer will be between 0 and 3999.  The argument of the function is

  a list of roman digits. It should look how this list starts and then

  calculate what the corresponding integer is for this ``start'' and

  add it with the integer for the rest of the list. That means if the

  argument is of the form shown on the left-hand side, it should do

  the calculation on the right-hand side.

  \begin{center}

  \begin{tabular}{lcl}

    $M::r$    & $\Rightarrow$ & $1000 + \text{roman numeral of rest}\; r$\\

    $C::M::r$ & $\Rightarrow$ & $900 + \text{roman numeral of rest}\; r$\\

    $D::r$    & $\Rightarrow$ & $500 + \text{roman numeral of rest}\; r$\\

    $C::D::r$ & $\Rightarrow$ & $400 + \text{roman numeral of rest}\; r$\\

    $C::r$    & $\Rightarrow$ & $100 + \text{roman numeral of rest}\; r$\\

    $X::C::r$ & $\Rightarrow$ & $90 + \text{roman numeral of rest}\; r$\\

    $L::r$    & $\Rightarrow$ & $50 + \text{roman numeral of rest}\; r$\\

    $X::L::r$ & $\Rightarrow$ & $40 + \text{roman numeral of rest}\; r$\\

    $X::r$    & $\Rightarrow$ & $10 + \text{roman numeral of rest}\; r$\\

    $I::X::r$ & $\Rightarrow$ & $9 + \text{roman numeral of rest}\; r$\\

    $V::r$    & $\Rightarrow$ & $5 + \text{roman numeral of rest}\; r$\\

    $I::V::r$ & $\Rightarrow$ & $4 + \text{roman numeral of rest}\; r$\\

    $I::r$    & $\Rightarrow$ & $1 + \text{roman numeral of rest}\; r$

  \end{tabular}  

  \end{center}    

  The empty list will be converted into integer $0$.\hfill[1 Mark]

\item[(4)] Write a function that takes a string and if possible

  converts it into the internal representation. If successful, then

  calculate the integer (an option of an integer) according to the

  function in (3).  If this is not possible, then return

  \texttt{None}.\hfill[1 Mark]

\item[(5)] The file \texttt{roman.txt} contains a list of roman numerals.

  Read in these numerals, convert them into integers and then add them all

  up. The function for reading a file is

  \begin{center}

  \texttt{Source.fromFile("filename")("ISO-8859-9")}

  \end{center}

  Make sure you process the strings correctly by ignoring whitespaces

  where neded.\\ \mbox{}\hfill[1 Mark]

\end{itemize}

\subsection*{Part 2 (Validation)}

\end{document}

%%% Local Variables: 

%%% mode: latex

%%% TeX-master: t

%%% End: