Fix ch4 largestSmallest (#225)

* Make chapter4 largestSmallest solution and test use Array Path

* Update instructions for largestSmallest and change difficulty

* Swap largestSmallest and whereIs test/solution order to reflect instructions

* Expand on smallestLargest instructions

* Fix instruction grammar

* Simplify root test case

* Add single file dir and empty dir test cases

* Remove now unused imports

* Make note style consistent with other examples

Author: ericArbour

exercises/chapter4/src/Data/Path.purs

@@ -1,5 +1,5 @@
 module Data.Path
-  ( Path()
+  ( Path(..)
   , root
   , ls
   , filename

exercises/chapter4/test/Main.purs

@@ -6,7 +6,7 @@ import Test.MySolutions
 import Test.NoPeeking.Solutions  -- Note to reader: Delete this line
 import Data.Array (sort)
 import Data.Maybe (Maybe(..))
-import Data.Path (filename, root)
+import Data.Path (Path(..), filename, root)
 import Data.Tuple (fst)
 import Effect (Effect)
 import Test.Unit (TestSuite, suite, test)
@@ -155,10 +155,6 @@ Note to reader: Delete this line to expand comment block -}
           ]
           $ map filename
           $ onlyFiles root
-      test "Exercise - largestSmallest for root" do
-        Assert.equal [ "/home/user/code/js/test.js", "/etc/hosts" ]
-          $ map fst
-          $ largestSmallest root
       suite "Exercise - whereIs" do
         test "locates a file"
           $ Assert.equal (Just ("/bin/"))
@@ -168,6 +164,21 @@ Note to reader: Delete this line to expand comment block -}
           $ Assert.equal (Nothing)
           $ map filename
           $ whereIs root "cat"
+      suite "Exercise - largestSmallest" do
+        let
+          testls :: String -> Array String -> Path -> TestSuite
+          testls label expected path =
+            test label do
+              Assert.equal expected
+              -- Sorting to allow any ordering
+                $ sort
+                $ map filename
+                $ largestSmallest path
+          oneFileDir = Directory "/etc/" [ File "/etc/hosts" 300 ]
+          emptyDir = Directory "/etc/" []
+        testls "works for root" ["/etc/hosts", "/home/user/code/js/test.js"] root
+        testls "works for a directory with one file" ["/etc/hosts"] oneFileDir
+        testls "works for an empty directory" [] emptyDir
 
 {- Note to reader: Delete this line to expand comment block
 -}

exercises/chapter4/test/no-peeking/Solutions.purs

@@ -2,7 +2,7 @@ module Test.NoPeeking.Solutions where
 
 import Prelude
 import Control.MonadZero (guard)
-import Data.Array (cons, filter, head, last, length, tail, (..))
+import Data.Array (catMaybes, cons, filter, find, head, last, length, nub, tail, (..))
 import Data.Foldable (foldl)
 import Data.Int (rem, quot)
 import Data.Maybe (Maybe(..), fromMaybe, maybe)
@@ -97,27 +97,6 @@ reverse = foldl (\xs x -> [ x ] <> xs) []
 onlyFiles :: Path -> Array Path
 onlyFiles p = filter (\p' -> not $ isDirectory p') $ allFiles p
 
-maxSigned32BitInt :: Int
-maxSigned32BitInt = 2147483647
-
-largestSmallest :: Path -> Array (Tuple String Int)
-largestSmallest path = largestSmallestPaths (allFiles path)
-  where
-  largestSmallestPaths :: Array Path -> Array (Tuple String Int)
-  largestSmallestPaths paths = [ outlier (\i j -> i > j) 0 paths, outlier (\i j -> i < j) maxSigned32BitInt paths ]
-    where
-    outlier :: (Int -> Int -> Boolean) -> Int -> Array Path -> Tuple String Int
-    outlier criteria startValue paths' =
-      foldl
-        ( \acc p' ->
-            ( case size p' of
-                Just n -> if criteria n $ snd acc then Tuple (filename p') n else acc
-                Nothing -> acc
-            )
-        )
-        (Tuple "" startValue)
-        paths'
-
 allSizes :: Array Path -> Array (Tuple String Int)
 allSizes paths =
   map
@@ -136,3 +115,19 @@ whereIs path fileName = head $ whereIs' $ allFiles path
     child <- ls path
     guard $ eq fileName $ fromMaybe "" $ last $ split (Pattern "/") $ filename child
     pure path
+
+largestSmallest :: Path -> Array Path
+largestSmallest path = 
+  let files = onlyFiles path
+      maybeSizes = map size files
+      maybeMax = foldl (outlier (>)) Nothing maybeSizes
+      maybeMin = foldl (outlier (<)) Nothing maybeSizes
+  in catMaybes $ map (findFileBySize files) $ nub $ [maybeMax, maybeMin]
+  where
+  outlier :: (Int -> Int -> Boolean) -> Maybe Int -> Maybe Int -> Maybe Int
+  outlier criteria Nothing Nothing = Nothing
+  outlier criteria (Just x) Nothing = Just x
+  outlier criteria Nothing (Just x) = Just x
+  outlier criteria (Just x1) (Just x2) = if criteria x1 x2 then Just x1 else Just x2
+  findFileBySize :: Array Path -> Maybe Int -> Maybe Path
+  findFileBySize files maybeSize = find (\file -> size file == maybeSize) files

text/chapter4.md

@@ -643,8 +643,7 @@ Try out the new version in PSCi - you should get the same result. I'll let you d
  ## Exercises
 
  1. (Easy) Write a function `onlyFiles` which returns all _files_ (not directories) in all subdirectories of a directory.
- 1. (Medium) Write a function `largestSmallest` which returns an array containing the single largest and single smallest files in the filesystem.
- 1. (Difficult) Write a function `whereIs` to search for a file by name. The function should return a value of type `Maybe Path`, indicating the directory containing the file, if it exists. It should behave as follows:
+ 2. (Medium) Write a function `whereIs` to search for a file by name. The function should return a value of type `Maybe Path`, indicating the directory containing the file, if it exists. It should behave as follows:
 
      ```text
      > whereIs root "ls"
@@ -655,6 +654,7 @@ Try out the new version in PSCi - you should get the same result. I'll let you d
      ```
 
      _Hint_: Try to write this function as an array comprehension using do notation.
+ 3. (Difficult) Write a function `largestSmallest` which takes a `Path` and returns an array containing the single largest and single smallest files in the `Path`. _Note_: consider the cases where there are zero or one files in the `Path` by returning an empty array or a one-element array respectively.
 
 ## Conclusion