Update README

Author: Abhijit Sarkar

README.md

@@ -9,31 +9,228 @@ are uninteresting/improbable in the context of Haskell.
 A number of problems were added to fill out 99 problems.
 - These are the problems 29, 30, 42, 43, 44, 45, 51, 52, 53, 74, 75, 76, 77, 78, and 79.
 
-## The problems
+## Working with lists
 
-* Questions 1 to 10: [Lists](src/Lists.hs)
+[P01](src/List/P01.hs) (*) Find the last element of a list.
 
-* Questions 11 to 20: [Lists, continued](src/Lists2.hs)
+[P02](src/List/P02.hs) (*) Find the last but one element of a list.
 
-* Questions 21 to 30: [Lists again](src/Lists3.hs)
+[P03](src/List/P03.hs) (*) Find the Kth element of a list.
 
-* Questions 31 to 45: [Arithmetic](src/Arithmetic.hs)
+[P04](src/List/P04.hs) (*) Find the number of elements of a list.
 
-* Questions 46 to 53: [Logic and codes](src/Logic.hs)
+[P05](src/List/P05.hs) (*) Reverse a list.
 
-* Questions 54A to 60: [Binary trees](src/BinaryTrees.hs)
+[P06](src/List/P06.hs) (*) Find out whether a list is a palindrome.
 
-* Questions 61 to 69: [Binary trees, continued](src/BinaryTrees2.hs)
+[P07](src/List/P07.hs) (**) Flatten a nested list structure.
 
-* Questions 70B to 73: [Multiway trees](src/MultiwayTrees.hs)
+[P08](src/List/P08.hs) (**) Eliminate consecutive duplicates of list elements.
 
-* Questions 74 to 79: [Monads](src/Monads.hs)
+[P09](src/List/P09.hs) (**) Pack consecutive duplicates of list elements into sublists.
 
-* Questions 80 to 89: [Graphs](src/Graphs.hs)
+[P10](src/List/P10.hs) (*) Run-length encoding of a list.
 
-* Questions 90 to 94: [Miscellaneous problems](src/Misc.hs)
+[P11](src/List/P11.hs) (*) Modified run-length encoding.
 
-* Questions 95 to 99: [Miscellaneous problems, continued](src/Misc2.hs)
+[P12](src/List/P12.hs) (**) Decode a run-length encoded list.
+
+[P13](src/List/P13.hs) (**) Run-length encoding of a list (direct solution).
+
+[P14](src/List/P14.hs) (*) Duplicate the elements of a list.
+
+[P15](src/List/P15.hs) (**) Duplicate the elements of a list a given number of times.
+
+[P16](src/List/P16.hs) (**) Drop every Nth element from a list.
+
+[P17](src/List/P17.hs) (*) Split a list into two parts.
+
+[P18](src/List/P18.hs) (**) Extract a slice from a list.
+
+[P19](src/List/P19.hs) (**) Rotate a list N places to the left.
+
+[P20](src/List/P20.hs) (*) Remove the Kth element from a list.
+
+[P21](src/List/P21.hs) (*) Insert an element at a given position into a list.
+
+[P22](src/List/P22.hs) (*) Create a list containing all integers within a given range.
+
+[P23](src/List/P23.hs) (**) Extract a given number of randomly selected elements from a list.
+
+[P24](src/List/P24.hs) (*) Lotto: Draw N different random numbers from the set 1..M.
+
+[P25](src/List/P25.hs) (*) Generate a random permutation of the elements of a list.
+
+[P26](src/List/P26.hs) (**) Generate the combinations of K distinct objects chosen from the N elements of a list.
+
+[P27](src/List/P27.hs) (**) Group the elements of a set into disjoint subsets.
+
+[P28](src/List/P28.hs) (**) Sorting a list of lists according to length of sublists.
+
+[P29](src/List/P28.hs) (*) Write a function to compute the nth Fibonacci number.
+
+[P30](src/List/P30.hs) (**) Write a function to compute the nth Fibonacci number.
+
+## Arithmetic
+
+[P31](src/Arithmetic/P31.hs) (**) Determine whether a given integer number is prime.
+
+[P32](src/Arithmetic/P32.hs) (**) Determine the greatest common divisor of two positive integer numbers.
+
+[P33](src/Arithmetic/P33.hs) (*) Determine whether two positive integer numbers are coprime.
+
+[P34](src/Arithmetic/P34.hs) (**) Calculate Euler’s totient function ϕ(m).
+
+[P35](src/Arithmetic/P35.hs) (**) Determine the prime factors of a given positive integer.
+
+[P36](src/Arithmetic/P36.hs) (**) Determine the prime factors of a given positive integer (2).
+
+[P37](src/Arithmetic/P37.hs) (**) Calculate Euler’s totient function ϕ(m) (improved).
+
+[P38](src/Arithmetic/P38.hs) (*) Compare the two methods of calculating Euler’s totient function.
+
+[P39](src/Arithmetic/P39.hs) (*) A list of prime numbers.
+
+[P40](src/Arithmetic/P40.hs) (**) Goldbach's conjecture.
+
+[P41](src/Arithmetic/P41.hs) (**) A list of Goldbach compositions.
+
+[P42](src/Arithmetic/P42.hs) (**) Modular multiplicative inverse.
+
+[P43](src/Arithmetic/P43.hs) (*) Gaussian integer divisibility.
+
+[P44](src/Arithmetic/P44.hs) (**) Gaussian primes.
+
+[P45](src/Arithmetic/P45.hs) (*) Gaussian primes using the two-square theorem.
+
+## Logic and Codes
+
+[P46](src/Logic/P46.hs) (**) Truth tables for logical expressions.
+
+[P47](src/Logic/P47.hs) (*) Truth tables for logical expressions (2).
+
+[P48](src/Logic/P48.hs) (**) Truth tables for logical expressions (3).
+
+[P49](src/Logic/P49.hs) (**) Gray code.
+
+[P50](src/Logic/P50.hs) (***) Huffman code.
+
+[P51](src/Logic/P51.hs) (*) Error correction codes.
+
+[P52](src/Logic/P52.hs) (***) Conjunctive normal form.
+
+[P53](src/Logic/P53.hs) (***) Resolution rule.
+
+## Binary Trees
+
+P54A omitted; our tree representation will only allow well-formed trees.
+
+[P55](src/BinaryTree/P55.hs) (**) Construct completely balanced binary trees.
+
+[P56](src/BinaryTree/P56.hs) (**) Symmetric binary trees.
+
+[P57](src/BinaryTree/P57.hs) (**) Binary search trees (dictionaries).
+
+[P58](src/BinaryTree/P58.hs) (**) Generate-and-test paradigm.
+
+[P59](src/BinaryTree/P59.hs) (**) Construct height-balanced binary trees.
+
+[P60](src/BinaryTree/P60.hs) (**) Construct height-balanced binary trees with a given number of nodes.
+
+[P61](src/BinaryTree/P61.hs) (*) Count the leaves of a binary tree.
+
+[P61A](src/BinaryTree/P61a.hs) (*) Collect the leaves of a binary tree in a list.
+
+[P62](src/BinaryTree/P62.hs) (*) Collect the internal nodes of a binary tree in a list.
+
+[P62B](src/BinaryTree/P62b.hs) (*) Collect the nodes at a given level in a list.
+
+[P63](src/BinaryTree/P63.hs) (**) Construct a complete binary tree.
+
+[P64](src/BinaryTree/P64.hs) (**) Layout a binary tree (1).
+
+[P65](src/BinaryTree/P65.hs) (**) Layout a binary tree (2).
+
+[P66](src/BinaryTree/P66.hs) (***) Layout a binary tree (3).
+
+[P67A](src/BinaryTree/P67a.hs) (**) A string representation of binary trees.
+
+[P68](src/BinaryTree/P68.hs) (**) Preorder and inorder sequences of binary trees.
+
+[P69](src/BinaryTree/P69.hs) (**) Dotstring representation of binary trees.
+
+## Multiway Trees
+
+P70B omitted; we can only create well-formed trees.
+
+[P70C](src/MultiwayTree/P70c.hs) (*) Count the nodes of a multiway tree.
+
+[P70](src/MultiwayTree/P70.hs) (**) Tree construction from a node string.
+
+[P71](src/MultiwayTree/P71.hs) (*) Determine the internal path length of a tree.
+
+[P72](src/MultiwayTree/P72.hs) (*) Construct the postorder sequence of the tree nodes.
+
+[P73](src/MultiwayTree/P73.hs) (**) Lisp-like tree representation.
+
+
+## Monads
+
+[P74](src/Monad/P74.hs) (**) Monads without do notation.
+
+[P75](src/Monad/P75.hs) (*) Maybe monad.
+
+[P76](src/Monad/P76.hs) (*) Either monad.
+
+[P77](src/Monad/P77.hs) (*) List monad.
+
+[P78](src/Monad/P78.hs) (*) Collatz conjecture.
+
+[P79](src/Monad/P79.hs) (**) Postfix notation.
+
+## Graphs
+
+[P80](src/Graph/P80.hs) (***) Conversions.
+
+[P81](src/Graph/P81.hs) (**) Path from one node to another one.
+
+[P82](src/Graph/P82.hs) (*) Cycle from a given node.
+
+[P83](src/Graph/P83.hs) (**) Construct all spanning trees.
+
+[P84](src/Graph/P84.hs) (**) Construct the minimal spanning tree.
+
+[P85](src/Graph/P85.hs) (**) Graph isomorphism.
+
+[P86](src/Graph/P86.hs) (**) Node degree and graph coloration.
+
+[P87](src/Graph/P87.hs) (**) Depth-first order graph traversal.
+
+[P88](src/Graph/P88.hs) (**) Connected components.
+
+[P89](src/Graph/P89.hs) (**) Bipartite graphs.
+
+## Miscellaneous Problems
+
+[P90](src/Misc/P90.hs) (**) Eight queens problem.
+
+[P91](src/Misc/P91.hs) (**) Knight’s tour.
+
+[P92](src/Misc/P92.hs) (***) Von Koch’s conjecture.
+
+[P93](src/Misc/P93.hs) (***) An arithmetic puzzle.
+
+[P94](src/Misc/P94.hs) (***) Generate K-regular simple graphs with N nodes.
+
+[P95](src/Misc/P95.hs) (**) English number words.
+
+[P96](src/Misc/P96.hs) (**) Syntax checker.
+
+[P97](src/Misc/P97.hs) (**) Sudoku.
+
+[P98](src/Misc/P98.hs) (***) Nonograms.
+
+[P99](src/Misc/P99.hs) (***) Crossword puzzle.
 
 ## Running tests
 

ninety-nine-haskell.cabal

@@ -36,6 +36,7 @@ library
       Arithmetic.P44
       Arithmetic.P45
       BinaryTree.BinaryTree
+      BinaryTree.P54a
       BinaryTree.P55
       BinaryTree.P56
       BinaryTree.P57
@@ -92,10 +93,8 @@ library
       List.P24
       List.P25
       List.P26
-      List.P27a
-      List.P27b
-      List.P28a
-      List.P28b
+      List.P27
+      List.P28
       List.P29
       List.P30
       Logic.Logic
@@ -112,6 +111,7 @@ library
       Misc.P91
       Misc.P92
       Misc.P93
+      Misc.P94
       Misc.P95
       Misc.P96
       Misc.P97
@@ -216,9 +216,8 @@ test-suite ninety-nine-test
       List.P24Spec
       List.P25Spec
       List.P26Spec
-      List.P27bSpec
-      List.P28aSpec
-      List.P28bSpec
+      List.P27Spec
+      List.P28Spec
       List.P29Spec
       List.P30Spec
       Logic.LogicSpec

src/BinaryTree/P54a.hs

@@ -0,0 +1,4 @@
+module BinaryTree.P54a where
+
+-- Problem 54A: (*) Check whether a given term represents a binary tree.
+-- ANSWER: Creating an invalid tree is not possible in Haskell.

src/BinaryTree/P55.hs

@@ -2,9 +2,6 @@ module BinaryTree.P55 (cbalTree) where
 
 import BinaryTree.BinaryTree (Tree (..))
 
--- Problem 54A: (*) Check whether a given term represents a binary tree.
--- ANSWER: Creating an invalid tree is not possible in Haskell.
-
 {-
 Problem 55: (**) Construct completely balanced binary trees.
 

src/BinaryTree/P64.hs

@@ -1,4 +1,4 @@
-module BinaryTree.P64 where
+module BinaryTree.P64 (layout) where
 
 import BinaryTree.BinaryTree (Tree (..))
 

src/List/P23.hs

@@ -1,4 +1,4 @@
-module List.P23 where
+module List.P23 (rndSelect) where
 
 import qualified Control.Monad as M
 import Data.Functor ((<&>))

src/List/P27b.hs src/List/P27.hssrc/List/P27b.hs renamed to src/List/P27.hs

@@ -1,8 +1,17 @@
-module List.P27b where
+module List.P27 where
 
 import Data.List ((\\))
 import List.P26
 
+{-
+Problem 27a: (**) In how many ways can a group of 9 people
+work in 3 disjoint subgroups of 2, 3 and 4 persons?
+Write a function that generates all the possibilities
+and returns them in a list.
+-}
+group3 :: (Eq a) => [a] -> [[[a]]]
+group3 = group [2 .. 4]
+
 {-
 Problem 27b: (**) In how many ways can a group of 9 people
 work in disjoint subgroups of the given sizes?

src/List/P27a.hs

@@ -1,7 +1,12 @@
-module List.P28b where
+module List.P28 where
 
 import qualified Data.List as L
 
+-- Problem 28a: (**) Sort the elements of this list according to their length;
+-- i.e short lists first, longer lists later.
+lsort :: [[a]] -> [[a]]
+lsort = L.sortOn length
+
 -- Problem 28b: (**) Sort the elements of this list according to their length frequency;
 -- i.e., lists with rare lengths are placed first, others with a more frequent length come later.
 lfsort :: [[a]] -> [[a]]