🎉 Exercism Research is now launched. Help Exercism, help science and have some fun at research.exercism.io 🎉 # epequeno's solution

## to Nucleotide Count in the Elm Track

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

Given a single stranded DNA string, compute how many times each nucleotide occurs in the string.

The genetic language of every living thing on the planet is DNA. DNA is a large molecule that is built from an extremely long sequence of individual elements called nucleotides. 4 types exist in DNA and these differ only slightly and can be represented as the following symbols: 'A' for adenine, 'C' for cytosine, 'G' for guanine, and 'T' thymine.

Here is an analogy:

• twigs are to birds nests as
• nucleotides are to DNA as
• legos are to lego houses as
• words are to sentences as...

## 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

The Calculating DNA Nucleotides_problem at Rosalind http://rosalind.info/problems/dna/

## 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 Expect
import NucleotideCount exposing (nucleotideCounts)
import Test exposing (..)

tests : Test
tests =
describe "NucleotideCount"
[ test "empty dna strand has no nucleotides" <|
\() ->
Expect.equal { a = 0, t = 0, c = 0, g = 0 }
(nucleotideCounts "")
, skip <|
test "repetitive sequence has only guanine" <|
\() ->
Expect.equal { a = 0, t = 0, c = 0, g = 8 }
(nucleotideCounts "GGGGGGGG")
, skip <|
test "counts all nucleotides" <|
\() ->
Expect.equal { a = 20, t = 21, c = 12, g = 17 }
(nucleotideCounts "AGCTTTTCATTCTGACTGCAACGGGCAATATGTCTCTGTGTGGATTAAAAAAAGAGTGTCTGATAGCAGC")
]``````
``````module NucleotideCount exposing (nucleotideCounts)

type alias NucleotideCounts =
{ a : Int
, t : Int
, c : Int
, g : Int
}

nucleotideCounts : String -> NucleotideCounts
nucleotideCounts sequence =
let
chars =
sequence |> String.toList
in
{ a = count 'A' chars
, t = count 'T' chars
, g = count 'G' chars
, c = count 'C' chars
}

count : Char -> List Char -> Int
count char chars =
List.map
(\c ->
if char == c then
1

else
0
)
chars
|> List.sum``````