Some Scala problems for self

Transcription

1 Some Scala problems for self May 4, 2012

2 2

3 Chapter 1 Getting Started 1.1 Background The book, Programming in Scala, Second Edition (PINS), is very good, and the best way to learn Scala is probably to read it and write as many programs as possible. There are also some url:s which can be useful, such as: The specification (API) of the standard library it s searchable, and has links to the implementation of the standard classes. Contains guides, tutorials, cheat sheets, specifications and information on language improvement proposals. This web-site is quite new, but is intended to become a onestop resource for information about Scala. Lots of links, and lots of questions and answers. The first seminar, and also this text, is geared towards those without, or with only little prior experience of Scala. The purpose of the seminar was to get you started, and these notes contain some problems which hopefully can help you. All problems marked with (*) have solutions in the appendix, and since there usually are several ways to do things in Scala, the appendix have alternative solutions to many of the problems. Feel free to ask me (Christian) anything, either during the scheduled sessions, or at any other time when I m available. 1.2 Fundamentals The form of a simple program in Scala is: object SimpleApp { def main(args: Array[String]) { //... actual code... or, even simpler: 3

4 4 CHAPTER 1. GETTING STARTED object SimplerApp extends App { //... actual code... We begin with some examples just to get to know the REPL, the compiler, and the simplest possible Scala program. Problem 1.1 ( ) Fire up the Scala REPL, and try to make it show the type of the expression println( hello, world ) What is the value of the expression? Problem 1.2 ( ) Implement the hello, world -program, and run it both as a script and as a compiled program. One of the ideas underlaying Scala is to make things easier and more enjoyable for the programmer, and one of the ways it does this is by removing as much boilerplate as possible. To this end it includes an object called Predef, which adds conveniences such as: Methods to print: print, printf and println these are shortcuts to methods on an object called Console. Methods to read from the keyboard: readline, readint and readdouble these are also shortcuts to methods on Console. Some standard collection classes (more about them later). For someone who has used Java, some of the fundamentals of Scala will be very familiar it has if-statements, while-statements, and for-statements (although Scala s for-statement it s much more powerful than it s Java counterpart). Actually, anything we can do in Java, we can do almost exactly the same way in Scala, albeit somewhat more concisely. Sections 2.1 to 2.5 i PINS covers some of the background needed to solve the following problems: Problem 1.3 ( ) Write a program which reads a temperature in F, and outputs the same temperature in C (see the API-docs for how to read and write the temperatures). C = ( F 32) 5 9. Problem 1.4 ( ) Write a program defining a method sum which uses a while-statement to calculate n. Let the program read a n-value from the keyboard and output the sum. 1.3 All values are objects In many languages we have to differentiate between primitive types and reference types, but in Scala every value is an object. This means that should actually be interpreted as: (1).+(2)

5 1.4. FUNCTIONS ARE VALUES 5 Scala has classes corresponding to the primitive types of Java, so there are classes like Int, Double, Char and Boolean, and we can call methods on our primitive values. This means that we can write: val p = x.round.toint instead of (as we do in Java): int p = (int) Math.round(x); One interesting method on Int-values is to when we write val interval = 1 to 100 we get a NumericRange-object, which is a kind of collection containing the values the values are generated on demand, so we don t have to save 100 values at once. The for-statement allows us to iterate through every value of a collection, so we can print the numbers this way: for (k <- 1 to 100) println(k) A NumericRange has a by-method, so we can write for (x <- 0.0 to 1.0 by 0.1) printf( %.1f: %.4f\n, x, math.exp(x)) Observe that we must use a start value of type Double if we re to use a step value of type Double the expression 0 to 5 gives us a NumericRange[Int], whereas 0.0 to 1.0 gives us a NumericRange[Double]. Another kind of value is the tuple (page 46 in PINS) Scala allows us to create tuples of any arity up to 22, and we can create a tuple t with a String, a Boolean and a Double by just writing: val t = ( hello, true, ) We can get the parts of a tuple either by using underscores: val msg = t._1 val b = t._2 val x = t._3 We can also use pattern matching (much more about that later): val (msg, b, x) = t Here each of the variables msg, b and x is set to the corresponding value of t. 1.4 Functions are values During the seminar we spent some time discussing methods and functions they are also described in various places in chapter 2 and 3 of PINS. Problem 1.5 ( ) Write a method fahr2cels which converts from F to C. Also define a function literal ( anonymous function ) which calculates the same conversion, and save the function in a val (eg. f2c). What is the type of the method/function? Write a method tabulate which prints a temperature conversion table, like:

6 6 CHAPTER 1. GETTING STARTED 50.0: : : : : 21.1 It should take four parameters: A function which converts between different temperature scales. A minimum and a maximum temperature. A temperature increment. Call tabulate, once for each of fahr2cels and f2c. Problem 1.6 ( ) Write a method integrate which calculates a b f(x)dx using a simple Riemann sum. The function should take four parameters: The function to integrate (f R R). Lower and upper limits. The step length this parameter could be given a default value of Use this function to calculate: 0 1 x 2 dx and 1 1 e x2 /2 2π dx. The answers should be (approximately) 0.33 and Hint: Look at the until-method on Double, and the by-method on NumericRange[Double] (they may look like one operator: a until b by c, but really are two methods, called on different objects). 1.5 Scala s collections Some of Scala s collection classes are described in chapter 3, and you can find an abundance of information about them on and It is a good idea to read through some of the documentation and get a feel for what the collection classes can do (it s much more than one might at first expect). Problem 1.7 ( ) Write a program which prints all command line arguments in upper case and it should do it two times, first with a for-statement, then with foreach. Hint: An App has access to an Array named args, which gives the command line parameters.

7 1.5. SCALA S COLLECTIONS 7 Problem 1.8 ( ) Write a function which takes a list of Double:s, and returns their average, the number of values less than the average, and the number of values bigger than the average (efficiency is not an issue here) these values should be returned as a 3-tuple. We may safely assume that the list isn t empty (if it were, there wouldn t be any average anyway). Test the program by calling the function with the numbers given on the command line. Hint: Look closely at what the List-class has to offer. Problem 1.9 ( ) In problem 1.6 we wrote a function which calculated a b f(x)dx using a for-loop now we want to do it using some Seq-methods. Hint: Once again, browse through all the Seq methods using two of them we can turn this method into a one-liner (which isn t necessarily a good thing, but in this case it is convenient). Problem 1.10 ( ) Write a program which counts the number of different words on the command line (you get to decide if it should be case sensitive or case insensitive). Hint: Look at Set, and ways to obtain a Set from a Seq (all Seq-methods can be called on an Array). Problem 1.11 ( ) Write a program which prints the first number n for which the decimal representation of n! contains all decimal digits (ie ). The class BigInt is introduced on page 5 in PINS. Hint: It s probably a good idea to convert the BigInt-values to String:s before checking the digits. Problem 1.12 ( ) Write a program which reads a glossary on the form: venio:comes sub:under nostrum:our and puts it in a Map. The lines are read from a file, where the file name is given on the command line. The program should then repetitiously read words and output their translation (or don t know for words it doesn t know): $ scala Translations glossary input word: nostrum translation: our input word: pulchra translation: don t know input word: $... File input is discussed on page 55 in PINS. Hint: To split the word-pairs, we can use the split-method of java.lang.string, and then we can actually create a Map by using the tomap-method on a sequence of pairs (2-tuples). Problem 1.13 ( ) This problem is admittedly rather contrived, but serves to illustrate the use of Map:s, and also that functions can be stored as values in a map (or any kind of collection). We want to read an integer, and then a string of instructions, where the instructions are coded by the following letters:

8 8 CHAPTER 1. GETTING STARTED d : double the current value (always an integer), h : halve the current value (if the current value is odd, divide by two and truncate to the closest smaller integer), p : increase the current value by 1, and m : decrease the current value by 1. The program should then update the input value according to the instructions, such as in this sample run: $ scala Update 1 ddddm 15 $ scala Update 1 ddmdp The value is 7 To solve the problem, we want a Map[Char,Int=>Int], which maps each of the four letters to the corresponding function.

9 Appendix A Suggested solutions to some problems 1.1 We can find the return type by writing: scala> :type println( hello, world ) Unit So, it turns out println returns Unit-values (of which there aren t that many ). We get the return value by writing: println(println( hello, world )) hello, world () or by saving it into a value: scala> val v = println( hello, world ) hello, world v: Unit = () Here the () on the second output line is that unique value of type Unit. If we asked if v is really (), the REPL would reply: if (v == ()) ok else surprising <console>:9: warning: comparing values of types Unit and Unit using == will always yield true if (v == ()) ok else surprising ^ res0: java.lang.string = ok 1.2 A simple hello, world -program is: object Hello extends App { println( hello, world ) and we run it as a script by: $ scala Hello.scala To compile and run it we write: $ fsc Hello.scala $ scala Hello Using fsc will make subsequent compilations much faster (the first time we run it, the compiler daemon must start up, so then there is no gain of time). 9

10 10 APPENDIX A. SUGGESTED SOLUTIONS TO SOME PROBLEMS 1.3 Predef (which is automatically imported) enables us to write: object Temperatures extends App { print( Degrees Fahrenheit: ) val fahrenheit = readdouble val celsius = 5 * (fahrenheit - 32) / 9 printf( That corresponds to %.1f degrees Celsius\n, celsius) The readline-method, which reads a String, can be called with a prompt so if we use.todouble (see below) we can simplify the input slightly: val fahrenheit = readline( Degrees Fahrenheit: ).todouble 1.4 object NotExactlyGauss extends App { def sum(n: Int) = { var sum = 0 var term = 0 while (term < n) { term += 1 sum += term sum print( Enter n: ) val n = readint println(sum(n)) 1.5 The type of the function is R R, which i Scala-speak is Double => Double. Using a regular for-loop in tabulate, we get something like: object Temperatures extends App { def fahr2cels(degf: Double) = (degf - 32) * 5 / 9 val f2c = (degf: Double) => (degf - 32) * 5 / 9 def tabulate(conv: Double => Double, min: Double, max: Double, step: Double) = for (temp <- min to max by step) printf( %5.1f: %5.1f\n, temp, conv(temp)) tabulate(fahr2cels, 30, 80, 5) tabulate(f2c, 30, 80, 5) Instead of an ordinary for-loop, we can use foreach:

11 11 (min to max by step) foreach { temp => printf( %5.1f: %5.1f\n, temp, conv(temp)) 1.6 We want to step through the x-axis, in small steps (dx), and in every step we calculate the area of a narrow rectangle. Since we don t want the rectangles to pass max (or at least by as little as possible), we step only until, not to the max limit. Using a for-loop and a var we get: object Calculus extends App { def integrate(f: Double => Double, min: Double, max: Double, dx: Double = 1e-3) = { var s = 0.0 for (x <- min until max by dx) { s += f(x) * dx s println(integrate(x => x * x, 0, 1)) println(integrate(x => math.exp(- x * x / 2) / math.sqrt(2 * math.pi), -1, 1)) In problem 1.9 we will see an easier way (a one-liner) to implement integrate. 1.7 object ArgsInUppercase extends App { for (arg <- args) println(arg.touppercase) args.foreach(arg => println(arg.touppercase)) 1.8 object BigAndSmall extends App { def statistics(values: List[Double]): (Double, Int, Int) = { val average = values.sum / values.size (average, values.count(_ < average), values.count(_ > average)) val (avg, less, bigger) = statistics(args.tolist.map(_.todouble)) println( Average: %.2f, less: %d, bigger: %d.format(avg, less, bigger)) 1.9 This time we can simplify integrate into: def integrate(f: Double => Double, min: Double, max: Double, dx: Double = 1e-3) = (min until max by dx).map(f).sum * dx

12 12 APPENDIX A. SUGGESTED SOLUTIONS TO SOME PROBLEMS 1.10 We can use the.toset method on args (it feels almost like cheating, but the method is there because Scala tries to be as helpful as possible). object CountWords extends App { println(args.toset.size) If we want a case insensitive solution, we can first map tolowercase over all words: println(args.map(_.tolowercase).toset.size) If we hadn t noticed the toset-method, we could have used a mutable set: object CountWords extends App { val words = collection.mutable.set[string]() for (word <- args) { words += word println(words.size) or, with foreach: object CountWords extends App { val words = collection.mutable.set[string]() args.foreach(words += _) println(words.size) 1.11 A function to calculate n! is given in the book: def factorial(n: BigInt): BigInt = if (n < 2) 1 else n * factorial(n - 1) There are several ways to check if a BigDecimal contains all digits, either way it seems to be a good idea to first convert it into a String. We can check that each of the digits 0 to 9 occurs: val alldigits = ( 0 to 9 ) def containsalldigits(n: BigInt) = { val digits = n.tostring alldigits.forall(c => digits.contains(c)) We can create a set of all digits in n!, and see if the size of the set is 10: def containsalldigits(n: BigInt) = n.tostring.toset.size == 10 We now need a way to iterate until we find the first n with the given property, and we can do it in many ways. A simple iterative solution is: var k = 0 while (!containsalldigits(factorial(k))) k += 1 println(k)

13 Scala s standard library defines streams, and using them we could first define the positive integers, and then drop them as long as n! doesn t contains all digits we then pick up the first number we find. val positiveints = Stream.from(1) val first = positiveints.dropwhile(n =>!containsalldigits(factorial(n))).head println(first) 1.12 Using the hint we get (but of course we can create a mutable Map, and add to it as we input our words): object Translations extends App { val filename = if (args.size > 0) args(0) else glossary val dictionary = io.source.fromfile(filename)( UTF-8 ).getlines.map(_.split( : )).filter(_.size == 2).map(a => (a(0), a(1))).tomap 13 def translate: Unit = { val word = readline( input word: ) if (word.length > 0) { println( translation: + dictionary.getorelse(word, don t know )) translate translate 1.13 If we declare the type of the Map (it will be a Map[Char,Int=>Int]), we don t have to declare the type of every function in its definition (we will have to use parentheses though, because of precedence rules): object MapOfFunctions extends App { val f = Map[Char, Int => Int] ( d -> (n => n * 2), h -> (n => n / 2), p -> (n => n + 1), m -> (n => n - 1)) We can also use placeholder syntax (ie. an underscore) to define our functions: val f = Map[Char, Int => Int] ( d -> (_ * 2), h -> (_ / 2), p -> (_ + 1), m -> (_ - 1)) To use this map for evaluating the sequence of instructions, given the initial number, we have a choice we could either write imperatively, or functionally. We begin with an imperative solution:

14 14 APPENDIX A. SUGGESTED SOLUTIONS TO SOME PROBLEMS var n = args(0).toint for (c <- args(1)) { val conv = f(c) n = conv(n) println(n) Here we could equally well have written n = f(c)(n) directly (inside the loop). We can also map the string of instructions to a sequence of functions, and then fold them together with andthen (ie. using function composition¹): val initialnumber = args(0).toint val conversion = args(1).map(f).reduce(_ andthen _) println(conversion(initialnumber)) Normally there is at least one instruction (otherwise args.size would have been < 2 unless the user entered as second parameter, that would be mean-spirited though ), but if args(1) is empty, reduce will fail to avoid this we can use fold instead: val id = (n: Int) => n val conversion = args(1).map(f).fold(id)(_ andthen _) println(conversion(initialnumber)) It turns out that the Function-object has a function chain which handles the chaining of the functions: val conversion = Function.chain(args(1).map(f)) println(conversion(initialnumber)) ¹To be precise, the andthen- and the compose-methods works in different directions andthen applies this first, compose applies this last.