Differences

This shows you the differences between two versions of the page.

Link to this comparison view

Both sides previous revision Previous revision
fp2023:hw1 [2023/03/28 14:10]
pdmatei 		fp2023:hw1 [2023/03/28 14:11] (current)
pdmatei
Line 45: Line 45:
 </​code>​ </​code>​
  
-**3.** Write a function ''​fromBounds''​ which takes two integer bounds ''​start''​ and ''​stop''​ and returns the set $math[\{start,​ start+1, \ldots, stop\}]. It is guaranteed that $math[start \leq stop] (you do not need to check this condition in your implementation).+**4.** Write a function ''​fromBounds''​ which takes two integer bounds ''​start''​ and ''​stop''​ and returns the set $math[\{start,​ start+1, \ldots, stop\}]. It is guaranteed that $math[start \leq stop] (you do not need to check this condition in your implementation).
  
 <code scala> <code scala>
Line 51: Line 51:
 </​code>​ </​code>​
  
-**4.** Write the function which performs the union of two sets:+**5.** Write the function which performs the union of two sets:
 <code scala> <code scala>
 def union(set1: Set, set2: Set): Set = ??? def union(set1: Set, set2: Set): Set = ???
 </​code>​ </​code>​
  
-**5.** Write a function which computes the complement of a set with respect to the set of integers:+**6.** Write a function which computes the complement of a set with respect to the set of integers:
 <code scala> <code scala>
 def complement(s1:​ Set): Set = ??? def complement(s1:​ Set): Set = ???
 </​code>​ </​code>​
  
-**6.** Write a function which computes the sum of value ''​b''​ to all elements from a set, for given **bounds**. Use a tail-end recursive function:+**7.** Write a function which computes the sum of value ''​b''​ to all elements from a set, for given **bounds**. Use a tail-end recursive function:
 <code scala> <code scala>
   def sumSet(b: Int)(start: Int, stop: Int)(set: Set): Int = {   def sumSet(b: Int)(start: Int, stop: Int)(set: Set): Int = {
Line 69: Line 69:
 </​code>​ </​code>​
  
-**7.** Generalise the previous function such that we can **fold** a set using any binary commutative operation over integers. Make sure this is a **left** fold: Folding the set: ''​{x,​y,​z}''​ with ''​b''​ should produce: ''​( (b op x) op y) op z''​+**8.** Generalise the previous function such that we can **fold** a set using any binary commutative operation over integers. Make sure this is a **left** fold: Folding the set: ''​{x,​y,​z}''​ with ''​b''​ should produce: ''​( (b op x) op y) op z''​
 <code scala> <code scala>
   def foldLeftSet   def foldLeftSet
Line 78: Line 78:
 </​code>​ </​code>​
  
-**8.** Implement an alternative to the previous function, namely **foldRight**. Applying ''​foldRight''​ on the set ''​{x,​y,​z}''​ with ''​b''​ should produce: ''​a op (b op (c op b))''​. Use direct recursion instead of tail recursion.+**9.** Implement an alternative to the previous function, namely **foldRight**. Applying ''​foldRight''​ on the set ''​{x,​y,​z}''​ with ''​b''​ should produce: ''​a op (b op (c op b))''​. Use direct recursion instead of tail recursion.
 <code scala> <code scala>
   def foldRightSet   def foldRightSet
Line 87: Line 87:
 </​code>​ </​code>​
  
-**9.** Implement operation ''​filter''​ which takes a set and returns another one containing only those elements that satisfy the predicate:+**10.** Implement operation ''​filter''​ which takes a set and returns another one containing only those elements that satisfy the predicate:
 <code scala> <code scala>
 def filter(p: Int => Boolean)(set:​ Set): Set = ??? def filter(p: Int => Boolean)(set:​ Set): Set = ???
 </​code>​ </​code>​
  
-**10.** Implement a function which **partitions** a set into two sets. The left-most contains those elements that satisfy the predicate, while the right-most contains those elements that do not satisfy the predicate. Use pairs. A pair is constructed with simple parentheses. E.g. ''​(1,​2)''​ is a pair of two integers. Suppose ''​val p: (Int,​Int)''​ is another pair of two integers. Then ''​p._1''​ is the left-most part of the pair while ''​p._2''​ is the right-most part of the pair.+**11.** Implement a function which **partitions** a set into two sets. The left-most contains those elements that satisfy the predicate, while the right-most contains those elements that do not satisfy the predicate. Use pairs. A pair is constructed with simple parentheses. E.g. ''​(1,​2)''​ is a pair of two integers. Suppose ''​val p: (Int,​Int)''​ is another pair of two integers. Then ''​p._1''​ is the left-most part of the pair while ''​p._2''​ is the right-most part of the pair.
 <code scala> <code scala>
   def partition(p:​ Int => Boolean)(set:​ Set): (Set,Set) = ???   def partition(p:​ Int => Boolean)(set:​ Set): (Set,Set) = ???
 </​code>​ </​code>​
  
-**11.** Implement a function ''​forall''​ which checks if all elements in a given range of a set satisfy a predicate (condition). (Such a condition may be that all elements from given bounds are even numbers).+**12.** Implement a function ''​forall''​ which checks if all elements in a given range of a set satisfy a predicate (condition). (Such a condition may be that all elements from given bounds are even numbers).
 <code scala> <code scala>
   def forall(cond:​ Int => Boolean) // condition to be checked   def forall(cond:​ Int => Boolean) // condition to be checked
Line 105: Line 105:
 </​code>​ </​code>​
  
-**12.** Implement a function ''​exists''​ which checks if a predicate holds for **some** element from the range of a set. Hint: it is easier to implement ''​exists''​ using the logical relation: $math[ \exists x. P(X) \iff \lnot \forall x.\lnot P(X)].+**13.** Implement a function ''​exists''​ which checks if a predicate holds for **some** element from the range of a set. Hint: it is easier to implement ''​exists''​ using the logical relation: $math[ \exists x. P(X) \iff \lnot \forall x.\lnot P(X)].
  
-**13.** Implement the function ''​setOfDivByK''​ which returns the set of integers divisible by a value ''​k''​. Use the appropriate functions you have defined.+**14.** Implement the function ''​setOfDivByK''​ which returns the set of integers divisible by a value ''​k''​. Use the appropriate functions you have defined.
 <code scala> <code scala>
 def setOfDivByK(k:​ Int): Set = ?? def setOfDivByK(k:​ Int): Set = ??
 </​code>​ </​code>​
  
-**14.** Implement the function ''​moreDivs''​ which verifies if ''​set1''​ contains more divisors of ''​k''​ than ''​set2'',​ over the range ''​[start,​stop]''​. Use any combination of the previous functions you have defined for your implementation.+**15.** Implement the function ''​moreDivs''​ which verifies if ''​set1''​ contains more divisors of ''​k''​ than ''​set2'',​ over the range ''​[start,​stop]''​. Use any combination of the previous functions you have defined for your implementation.
 <code scala> <code scala>
 def moreDivs(k: Int)(start: Int, stop:​Int)(set1:​ Set, set2: Set): Boolean = ??? def moreDivs(k: Int)(start: Int, stop:​Int)(set1:​ Set, set2: Set): Boolean = ???