Algorithms
Code
Diff
• ``````module AllEqual where

allEqual :: [Int] -> Bool
allEqual = and . (zipWith (==) <*> tail)``````
•  1 1 ```module AllEqual where ``` 2 2 3 3 ```allEqual :: [Int] -> Bool ``` 4 − ```allEqual = all =<< (==) . head ``` 4 + ```allEqual = and . (zipWith (==) <*> tail) ```

Algorithms
Code
Diff
• ``````module AllEqual where

allEqual :: [Int] -> Bool
allEqual = all =<< (==) . head``````
•  1 1 ```module AllEqual where ``` 2 2 3 3 ```allEqual :: [Int] -> Bool ``` 4 − ```allEqual [] = True ``` 5 − ```allEqual (x:xs) = all (== x) xs ``` 4 + ```allEqual = all =<< (==) . head ```

Algorithms

Data.Set is better. It's safer than head/tail and faster than `nub` (O(n^2)). For instance, `size` is O(1) and `fromList` is O(n*log n).

Code
Diff
• ``````module AllEqual where
import Data.Set (fromList, size)

allEqual :: [Int] -> Bool
allEqual xs = (size \$ fromList xs) <= 1``````
•  1 1 ```module AllEqual where ``` 2 − ```import Data.List ``` 2 + ```import Data.Set (fromList, size) ``` 3 3 4 4 ```allEqual :: [Int] -> Bool ``` 5 − ```allEqual xs = length (nub xs) <= 1 ``` 5 + ```allEqual xs = (size \$ fromList xs) <= 1 ```

Algorithms

What is the easiest way to check if all elements are equal in a Haskell list? Perhaps something that is safer than using head or tail?

For instance:

``````allEqual [1,2,3,4] = False
allEqual [1,1,1,1] = True
``````
``````module AllEqual where

allEqual :: [Int] -> Bool
allEqual xs = and \$ map (== head xs) (tail xs)``````
Failed Tests

### word count

Code
Diff
• ``````function wordCount(str) {
return (str.split(" ")).length;
}``````
•  1 − ```function wordCount(str) { ``` 2 − ``` var words = 1; ``` 3 − ``` for(var i = 1; i < str.length; i++) { ``` 4 − ``` if(str[i] == " " && str[i - 1] !== " "&& str[i + 1] !== " ") { ``` 5 − ``` words++; ``` 6 − ``` } ``` 7 − ``` } ``` 8 − ``` return words; ``` 1 + ```function wordCount(str) { ``` 2 + ```return (str.split(" ")).length; ``` 9 9 ```} ```