ðŸŽ‰ Exercism Research is now launched. Help Exercism, help science and have some fun at research.exercism.io ðŸŽ‰

# epequeno's solution

## to Anagram in the Elm Track

Published at Apr 24 2021 · 0 comments
Instructions
Test suite
Solution

An anagram is a rearrangement of letters to form a new word. Given a word and a list of candidates, select the sublist of anagrams of the given word.

Given `"listen"` and a list of candidates like `"enlists" "google" "inlets" "banana"` the program should return a list containing `"inlets"`.

## Elm Installation

Refer to the Installing Elm page for information about installing elm.

## Writing the Code

The code you have to write is located inside the `src/` directory of the exercise. Elm automatically installs packages dependencies the first time you run the tests so we can start by running the tests from the exercise directory with:

``````\$ elm-test
``````

To automatically run tests again when you save changes:

``````\$ elm-test --watch
``````

As you work your way through the tests suite in the file `tests/Tests.elm`, be sure to remove the `skip <|` calls from each test until you get them all passing!

## Source

Inspired by the Extreme Startup game https://github.com/rchatley/extreme_startup

## Submitting Incomplete Solutions

It is possible to submit an incomplete solution so you can see how others have completed the exercise.

### Tests.elm

``````module Tests exposing (tests)

import Anagram exposing (detect)
import Expect
import Test exposing (..)

tests : Test
tests =
describe "Anagram"
[ test "no matches" <|
\() ->
Expect.equal []
(detect "diaper" [ "hello", "world", "zombies", "pants" ])
, skip <|
test "detects simple anagram" <|
\() ->
Expect.equal [ "tan" ]
(detect "ant" [ "tan", "stand", "at" ])
, skip <|
test "does not detect false positives" <|
\() ->
Expect.equal []
(detect "galea" [ "eagle" ])
, skip <|
test "detects multiple anagrams" <|
\() ->
Expect.equal [ "stream", "maters" ]
(detect "master" [ "stream", "pigeon", "maters" ])
, skip <|
test "does not detect anagram subsets" <|
\() ->
Expect.equal []
(detect "good" [ "dog", "goody" ])
, skip <|
test "detects anagram" <|
\() ->
Expect.equal [ "inlets" ]
(detect "listen" [ "enlists", "google", "inlets", "banana" ])
, skip <|
test "detects even more anagrams" <|
\() ->
Expect.equal [ "gallery", "regally", "largely" ]
(detect "allergy" [ "gallery", "ballerina", "regally", "clergy", "largely", "leading" ])
, skip <|
test "does not detect identical words" <|
\() ->
Expect.equal [ "cron" ]
(detect "corn" [ "corn", "dark", "Corn", "rank", "CORN", "cron", "park" ])
, skip <|
test "does not detect non-anagrams with identical checksum" <|
\() ->
Expect.equal []
(detect "mass" [ "last" ])
, skip <|
test "detects anagrams case-insensitively" <|
\() ->
Expect.equal [ "Carthorse" ]
(detect "Orchestra" [ "cashregister", "Carthorse", "radishes" ])
, skip <|
test "detects anagrams using case-insensitive subject" <|
\() ->
Expect.equal [ "carthorse" ]
(detect "Orchestra" [ "cashregister", "carthorse", "radishes" ])
, skip <|
test "detects anagrams using case-insensitive possible matches" <|
\() ->
Expect.equal [ "Carthorse" ]
(detect "orchestra" [ "cashregister", "Carthorse", "radishes" ])
, skip <|
test "does not detect a word as its own anagram" <|
\() ->
Expect.equal []
(detect "banana" [ "Banana" ])
, skip <|
test "does not detect a anagram if the original word is repeated" <|
\() ->
Expect.equal []
(detect "go" [ "go Go GO" ])
, skip <|
test "anagrams must use all letters exactly once (go)" <|
\() ->
Expect.equal []
(detect "tapper" [ "patter" ])
, skip <|
test "eliminates anagrams with the same checksum" <|
\() ->
Expect.equal []
(detect "mass" [ "last" ])
, skip <|
test "detects unicode anagrams" <|
\() ->
Expect.equal [ "Î’Î“Î‘", "Î³Î²Î±" ]
(detect "Î‘Î’Î“" [ "Î’Î“Î‘", "Î’Î“Î”", "Î³Î²Î±" ])
, skip <|
test "eliminates misleading unicode anagrams" <|
\() ->
Expect.equal []
(detect "Î‘Î’Î“" [ "ABÎ“" ])
, skip <|
test "capital word is not own anagram" <|
\() ->
Expect.equal []
(detect "BANANA" [ "Banana" ])
, skip <|
test "anagrams must use all letters exactly once (banana)" <|
\() ->
Expect.equal []
(detect "patter" [ "tapper" ])
]``````
``````module Anagram exposing (detect)

detect : String -> List String -> List String
detect word candidates =
candidates
|> List.filter
(\c ->
(sorted c == sorted word)
&& (String.toLower c /= String.toLower word)
)

sorted : String -> String
sorted =
String.toLower
>> String.toList
>> List.sort
>> String.fromList``````