anthonycicc/exercism
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity

initial commit

Browse source
This commit is contained in:
anthony.cicchetti 2017-04-25 15:51:48 -04:00
commit 5f9cd49d7a
61 changed files with 2674 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

71
elixir/accumulate/README.md Normal file
View file

@ -0,0 +1,71 @@
# Accumulate
Implement the `accumulate` operation, which, given a collection and an operation to perform on each element of the collection, returns a new collection containing the result of applying that operation to each element of the input collection.
Given the collection of numbers:
- 1, 2, 3, 4, 5
And the operation:
- square a number (`x => x * x`)
Your code should be able to produce the collection of squares:
- 1, 4, 9, 16, 25
Check out the test suite to see the expected function signature.
## Restrictions
Keep your hands off that collect/map/fmap/whatchamacallit functionality
provided by your standard library!
Solve this one yourself using other basic tools instead.
Lisp specific: it's perfectly fine to use `MAPCAR` or the equivalent,
as this is idiomatic Lisp, not a library function.
## Running tests
Execute the tests with:
```bash
$ elixir bob_test.exs
```
(Replace `bob_test.exs` with the name of the test file.)
### Pending tests
In the test suites, all but the first test have been skipped.
Once you get a test passing, you can unskip the next one by
commenting out the relevant `@tag :pending` with a `#` symbol.
For example:
```elixir
# @tag :pending
test "shouting" do
assert Bob.hey("WATCH OUT!") == "Whoa, chill out!"
end
```
Or, you can enable all the tests by commenting out the
`ExUnit.configure` line in the test suite.
```elixir
# ExUnit.configure exclude: :pending, trace: true
```
For more detailed information about the Elixir track, please
see the [help page](http://exercism.io/languages/elixir).
## Source
Conversation with James Edward Gray II [https://twitter.com/jeg2](https://twitter.com/jeg2)
## Submitting Incomplete Problems
It's possible to submit an incomplete solution so you can see how others have completed the exercise.

33
elixir/accumulate/accumulate.exs Normal file
View file

@ -0,0 +1,33 @@
defmodule Accumulate do
@doc """
Given a list and a function, apply the function to each list item and
replace it with the function's return value.
Returns a list.
## Examples
iex> Accumulate.accumulate([], fn(x) -> x * 2 end)
[]
iex> Accumulate.accumulate([1, 2, 3], fn(x) -> x * 2 end)
[2, 4, 6]
"""
# @spec accumulate(list, (any -> any)) :: list
# def accumulate(list, fun) do
# cond do
# length(list) == 0 -> []
# length(list) == 1 -> fun.(List.first(list))
# true ->
# [head | tail] = list
# [fun.(head), accumulate(tail, fun)]
# end
# end
@spec accumulate(list, (any -> any)) :: list
def accumulate(list, fun) do
List.foldl(list, [], (fn(x, acc) -> acc ++ [fun.(x)] end))
end
end

42
elixir/accumulate/accumulate_test.exs Normal file
View file

@ -0,0 +1,42 @@
if !System.get_env("EXERCISM_TEST_EXAMPLES") do
Code.load_file("accumulate.exs", __DIR__)
end
ExUnit.start
# ExUnit.configure exclude: :pending, trace: true
defmodule AccumulateTest do
use ExUnit.Case
test "accumulate empty list" do
assert Accumulate.accumulate([], fn(n) -> n * n end) == []
end
# @tag :pending
test "accumulate square numbers" do
assert Accumulate.accumulate([1, 2, 3], fn(n) -> n * n end) == [1, 4, 9]
end
@tag :pending
test "accumulate upcased strings" do
fun = fn(w) -> String.upcase(w) end
assert Accumulate.accumulate(["hello", "world"], fun) == ["HELLO", "WORLD"]
end
@tag :pending
test "accumulate reversed strings" do
fun = fn(w) -> String.reverse(w) end
words = ~w(the quick brown fox etc)
expected = ["eht", "kciuq", "nworb", "xof", "cte"]
assert Accumulate.accumulate(words, fun) == expected
end
@tag :pending
test "nested accumulate" do
chars = ~w(a b c)
nums = ~w(1 2 3)
fun = fn(c) -> Accumulate.accumulate(nums, &(c <> &1)) end
expected = [["a1", "a2", "a3"], ["b1", "b2", "b3"], ["c1", "c2", "c3"]]
assert Accumulate.accumulate(chars, fun) == expected
end
end

54
elixir/acronym/README.md Normal file
View file

@ -0,0 +1,54 @@
# Acronym
Convert a long phrase to its acronym
Techies love their TLA (Three Letter Acronyms)!
Help generate some jargon by writing a program that converts a long name
like Portable Network Graphics to its acronym (PNG).
## Running tests
Execute the tests with:
```bash
$ elixir bob_test.exs
```
(Replace `bob_test.exs` with the name of the test file.)
### Pending tests
In the test suites, all but the first test have been skipped.
Once you get a test passing, you can unskip the next one by
commenting out the relevant `@tag :pending` with a `#` symbol.
For example:
```elixir
# @tag :pending
test "shouting" do
assert Bob.hey("WATCH OUT!") == "Whoa, chill out!"
end
```
Or, you can enable all the tests by commenting out the
`ExUnit.configure` line in the test suite.
```elixir
# ExUnit.configure exclude: :pending, trace: true
```
For more detailed information about the Elixir track, please
see the [help page](http://exercism.io/languages/elixir).
## Source
Julien Vanier [https://github.com/monkbroc](https://github.com/monkbroc)
## Submitting Incomplete Problems
It's possible to submit an incomplete solution so you can see how others have completed the exercise.

24
elixir/acronym/acronym.exs Normal file
View file

@ -0,0 +1,24 @@
import Enum
defmodule Acronym do
@doc """
Generate an acronym from a string.
"This is a string" => "TIAS"
"""
@spec abbreviate(String.t()) :: String.t()
def abbreviate(string) do
# Splits sentence into words
tokenized_sentence = String.split(string, ~r{(\W)}, trim: true)
# Splits words if there are caps in the middle of them
letters = Enum.map(tokenized_sentence, (fn x -> grab_acronym(x) end))
Enum.reduce(List.flatten(letters), "", (fn(x, acc) -> acc <> x end))
end
def grab_acronym(string) do
cond do
String.match?(string, ~r{[[:upper:]]}) == true ->
List.flatten(String.split(string, ~r{[^[:upper:]]}, trim: true))
true ->
[String.upcase(String.first(string))]
end
end
end

34
elixir/acronym/acronym_test.exs Normal file
View file

@ -0,0 +1,34 @@
if !System.get_env("EXERCISM_TEST_EXAMPLES") do
Code.load_file("acronym.exs", __DIR__)
end
ExUnit.start
# ExUnit.configure exclude: :pending, trace: true
defmodule AcronymTest do
use ExUnit.Case
test "it produces acronyms from title case" do
assert Acronym.abbreviate("Portable Networks Graphic") === "PNG"
end
@tag :pending
test "it produces acronyms from lower case" do
assert Acronym.abbreviate("Ruby on Rails") === "ROR"
end
@tag :pending
test "it produces acronyms from inconsistent case" do
assert Acronym.abbreviate("HyperText Markup Language") === "HTML"
end
@tag :pending
test "it ignores punctuation" do
assert Acronym.abbreviate("First in, First out") === "FIFO"
end
@tag :pending
test "it produces acronyms ignoring punctuation and casing" do
assert Acronym.abbreviate("Complementary Metal-Oxide semiconductor") === "CMOS"
end
end

57
elixir/bob/README.md Normal file
View file

@ -0,0 +1,57 @@
# Bob
Bob is a lackadaisical teenager. In conversation, his responses are very limited.
Bob answers 'Sure.' if you ask him a question.
He answers 'Whoa, chill out!' if you yell at him.
He says 'Fine. Be that way!' if you address him without actually saying
anything.
He answers 'Whatever.' to anything else.
## Running tests
Execute the tests with:
```bash
$ elixir bob_test.exs
```
(Replace `bob_test.exs` with the name of the test file.)
### Pending tests
In the test suites, all but the first test have been skipped.
Once you get a test passing, you can unskip the next one by
commenting out the relevant `@tag :pending` with a `#` symbol.
For example:
```elixir
# @tag :pending
test "shouting" do
assert Bob.hey("WATCH OUT!") == "Whoa, chill out!"
end
```
Or, you can enable all the tests by commenting out the
`ExUnit.configure` line in the test suite.
```elixir
# ExUnit.configure exclude: :pending, trace: true
```
For more detailed information about the Elixir track, please
see the [help page](http://exercism.io/languages/elixir).
## Source
Inspired by the 'Deaf Grandma' exercise in Chris Pine's Learn to Program tutorial. [http://pine.fm/LearnToProgram/?Chapter=06](http://pine.fm/LearnToProgram/?Chapter=06)
## Submitting Incomplete Problems
It's possible to submit an incomplete solution so you can see how others have completed the exercise.

14
elixir/bob/bob.exs Normal file
View file

@ -0,0 +1,14 @@
defmodule Bob do
def hey(input) do
cond do
String.last(input) == "?" -> "Sure."
String.length(String.trim(input)) == 0 -> "Fine. Be that way!"
String.upcase(input) == input -> if(String.downcase(input) == input) do
"Whatever."
else
"Whoa, chill out!"
end
true -> "Whatever."
end
end
end

84
elixir/bob/bob_test.exs Normal file
View file

@ -0,0 +1,84 @@
if !System.get_env("EXERCISM_TEST_EXAMPLES") do
Code.load_file("bob.exs", __DIR__)
end
ExUnit.start
# ExUnit.configure exclude: :pending, trace: true
defmodule BobTest do
use ExUnit.Case
test "stating something" do
assert Bob.hey("Tom-ay-to, tom-aaaah-to.") == "Whatever."
end
@tag :pending
test "shouting" do
assert Bob.hey("WATCH OUT!") == "Whoa, chill out!"
end
@tag :pending
test "asking a question" do
assert Bob.hey("Does this cryogenic chamber make me look fat?") == "Sure."
end
@tag :pending
test "talking forcefully" do
assert Bob.hey("Let's go make out behind the gym!") == "Whatever."
end
@tag :pending
test "talking in capitals" do
assert Bob.hey("This Isn't Shouting!") == "Whatever."
end
@tag :pending
test "asking in capitals" do
assert Bob.hey("THIS ISN'T SHOUTING?") == "Sure."
end
@tag :pending
test "shouting numbers" do
assert Bob.hey("1, 2, 3 GO!") == "Whoa, chill out!"
end
@tag :pending
test "shouting with special characters" do
assert Bob.hey("ZOMG THE %^*@#$(*^ ZOMBIES ARE COMING!!11!!1!") == "Whoa, chill out!"
end
@tag :pending
test "shouting with no exclamation mark" do
assert Bob.hey("I HATE YOU") == "Whoa, chill out!"
end
@tag :pending
test "statement containing question mark" do
assert Bob.hey("Ending with ? means a question.") == "Whatever."
end
@tag :pending
test "silence" do
assert Bob.hey("") == "Fine. Be that way!"
end
@tag :pending
test "prolonged silence" do
assert Bob.hey(" ") == "Fine. Be that way!"
end
@tag :pending
test "only numbers" do
assert Bob.hey("1, 2, 3") == "Whatever."
end
@tag :pending
test "question with numbers" do
assert Bob.hey("4?") == "Sure."
end
@tag :pending
test "shouting in Russian" do
assert Bob.hey("УХОДИ") == "Whoa, chill out!"
end
end

95
elixir/hello-world/README.md Normal file
View file

@ -0,0 +1,95 @@
# Hello World
Greet the user by name, or by saying "Hello, World!" if no name is given.
["Hello, World!"](http://en.wikipedia.org/wiki/%22Hello,_world!%22_program) is
the traditional first program for beginning programming in a new language.
**Note:** You can skip this exercise by running:
exercism skip $TRACK_ID hello-world
## Specification
Write a `Hello World!` function that can greet someone given their name. The
function should return the appropriate greeting.
For an input of "Alice", the response should be "Hello, Alice!".
If a name is not given, the response should be "Hello, World!"
## Test-Driven Development
As programmers mature, they eventually want to test their code.
Here at Exercism we simulate [Test-Driven
Development](http://en.wikipedia.org/wiki/Test-driven_development) (TDD), where
you write your tests before writing any functionality. The simulation comes in
the form of a pre-written test suite, which will signal that you have solved
the problem.
It will also provide you with a safety net to explore other solutions without
breaking the functionality.
### A typical TDD workflow on Exercism:
1. Run the test file and pick one test that's failing.
2. Write some code to fix the test you picked.
3. Re-run the tests to confirm the test is now passing.
4. Repeat from step 1.
5. Submit your solution (`exercism submit /path/to/file`)
## Instructions
Submissions are encouraged to be general, within reason. Having said that, it's
also important not to over-engineer a solution.
It's important to remember that the goal is to make code as expressive and
readable as we can. However, solutions to the hello-world exercise will not be
reviewed by a person, but by rikki- the robot, who will offer an encouraging
word.
## Running tests
Execute the tests with:
```bash
$ elixir bob_test.exs
```
(Replace `bob_test.exs` with the name of the test file.)
### Pending tests
In the test suites, all but the first test have been skipped.
Once you get a test passing, you can unskip the next one by
commenting out the relevant `@tag :pending` with a `#` symbol.
For example:
```elixir
# @tag :pending
test "shouting" do
assert Bob.hey("WATCH OUT!") == "Whoa, chill out!"
end
```
Or, you can enable all the tests by commenting out the
`ExUnit.configure` line in the test suite.
```elixir
# ExUnit.configure exclude: :pending, trace: true
```
For more detailed information about the Elixir track, please
see the [help page](http://exercism.io/languages/elixir).
## Source
This is an exercise to introduce users to using Exercism [http://en.wikipedia.org/wiki/%22Hello,_world!%22_program](http://en.wikipedia.org/wiki/%22Hello,_world!%22_program)
## Submitting Incomplete Problems
It's possible to submit an incomplete solution so you can see how others have completed the exercise.

29
elixir/hello-world/hello_world.exs Normal file
View file

@ -0,0 +1,29 @@
defmodule HelloWorld do
@moduledoc """
Elixir counts the number of arguments as part of the function name.
For instance;
def hello() do
end
would be a completely different function from
def hello(name) do
end
Can you find a way to make all the tests pass with just one
function?
Hint: look into argument defaults here:
http://elixir-lang.org/getting-started/modules.html#default-arguments
"""
@doc """
Greets the user by name, or by saying "Hello, World!"
if no name is given.
"""
@spec hello(String.t) :: String.t
def hello(name \\ "World") do
"Hello, " <> name <> "!"
end
end

23
elixir/hello-world/hello_world_test.exs Normal file
View file

@ -0,0 +1,23 @@
if !System.get_env("EXERCISM_TEST_EXAMPLES") do
Code.load_file("hello_world.exs", __DIR__)
end
ExUnit.start
ExUnit.configure exclude: :pending, trace: true
defmodule HelloWorldTest do
use ExUnit.Case
test "says hello with no name" do
assert HelloWorld.hello() == "Hello, World!"
end
test "says hello sample name" do
assert HelloWorld.hello("Alice") == "Hello, Alice!"
end
test "says hello other sample name" do
assert HelloWorld.hello("Bob") == "Hello, Bob!"
end
end

72
elixir/nucleotide-count/README.md Normal file
View file

@ -0,0 +1,72 @@
# Nucleotide Count
Given a DNA string, compute how many times each nucleotide occurs in the string.
DNA is represented by an alphabet of the following symbols: 'A', 'C',
'G', and 'T'.
Each symbol represents a nucleotide, which is a fancy name for the
particular molecules that happen to make up a large part of DNA.
Shortest intro to biochemistry EVAR:
- twigs are to birds nests as
- nucleotides are to DNA and RNA as
- amino acids are to proteins as
- sugar is to starch as
- oh crap lipids
I'm not going to talk about lipids because they're crazy complex.
So back to nucleotides.
DNA contains four types of them: adenine (`A`), cytosine (`C`), guanine
(`G`), and thymine (`T`).
RNA contains a slightly different set of nucleotides, but we don't care
about that for now.
## Running tests
Execute the tests with:
```bash
$ elixir bob_test.exs
```
(Replace `bob_test.exs` with the name of the test file.)
### Pending tests
In the test suites, all but the first test have been skipped.
Once you get a test passing, you can unskip the next one by
commenting out the relevant `@tag :pending` with a `#` symbol.
For example:
```elixir
# @tag :pending
test "shouting" do
assert Bob.hey("WATCH OUT!") == "Whoa, chill out!"
end
```
Or, you can enable all the tests by commenting out the
`ExUnit.configure` line in the test suite.
```elixir
# ExUnit.configure exclude: :pending, trace: true
```
For more detailed information about the Elixir track, please
see the [help page](http://exercism.io/languages/elixir).
## Source
The Calculating DNA Nucleotides_problem at Rosalind [http://rosalind.info/problems/dna/](http://rosalind.info/problems/dna/)
## Submitting Incomplete Problems
It's possible to submit an incomplete solution so you can see how others have completed the exercise.

33
elixir/nucleotide-count/nucleotide_count.exs Normal file
View file

@ -0,0 +1,33 @@
defmodule NucleotideCount do
@nucleotides [?A, ?C, ?G, ?T]
@doc """
Counts individual nucleotides in a NucleotideCount strand.
## Examples
iex> NucleotideCount.count('AATAA', ?A)
4
iex> NucleotideCount.count('AATAA', ?T)
1
"""
@spec count([char], char) :: non_neg_integer
def count(strand, nucleotide) do
length(Enum.filter(strand, (fn x -> x == nucleotide end)))
end
@doc """
Returns a summary of counts by nucleotide.
## Examples
iex> NucleotideCount.histogram('AATAA')
%{?A => 4, ?T => 1, ?C => 0, ?G => 0}
"""
@spec histogram([char]) :: map
def histogram(strand) do
temp = Enum.map(@nucleotides, (fn x -> %{x => count(strand, x)} end))
Enum.reduce(temp, Map.new(), (fn (x, acc) -> Map.merge(x, acc) end))
end
end

44
elixir/nucleotide-count/nucleotide_count_test.exs Normal file
View file

@ -0,0 +1,44 @@
if !System.get_env("EXERCISM_TEST_EXAMPLES") do
Code.load_file("nucleotide_count.exs", __DIR__)
end
ExUnit.start
ExUnit.configure exclude: :pending, trace: true
defmodule NucleotideCountTest do
use ExUnit.Case
# @tag :pending
test "empty dna string has no adenine" do
assert NucleotideCount.count('', ?A) == 0
end
# @tag :pending
test "repetitive cytosine gets counted" do
assert NucleotideCount.count('CCCCC', ?C) == 5
end
# @tag :pending
test "counts only thymine" do
assert NucleotideCount.count('GGGGGTAACCCGG', ?T) == 1
end
# @tag :pending
test "empty dna string has no nucleotides" do
expected = %{?A => 0, ?T => 0, ?C => 0, ?G => 0}
assert NucleotideCount.histogram('') == expected
end
# @tag :pending
test "repetitive sequence has only guanine" do
expected = %{?A => 0, ?T => 0, ?C => 0, ?G => 8}
assert NucleotideCount.histogram('GGGGGGGG') == expected
end
# @tag :pending
test "counts all nucleotides" do
s = 'AGCTTTTCATTCTGACTGCAACGGGCAATATGTCTCTGTGTGGATTAAAAAAAGAGTGTCTGATAGCAGC'
expected = %{?A => 20, ?T => 21, ?C => 12, ?G => 17}
assert NucleotideCount.histogram(s) == expected
end
end

63
elixir/raindrops/README.md Normal file
View file

@ -0,0 +1,63 @@
# Raindrops
Convert a number to a string, the contents of which depend on the number's factors.
- If the number has 3 as a factor, output 'Pling'.
- If the number has 5 as a factor, output 'Plang'.
- If the number has 7 as a factor, output 'Plong'.
- If the number does not have 3, 5, or 7 as a factor,
just pass the number's digits straight through.
## Examples
- 28's factors are 1, 2, 4, **7**, 14, 28.
- In raindrop-speak, this would be a simple "Plong".
- 30's factors are 1, 2, **3**, **5**, 6, 10, 15, 30.
- In raindrop-speak, this would be a "PlingPlang".
- 34 has four factors: 1, 2, 17, and 34.
- In raindrop-speak, this would be "34".
## Running tests
Execute the tests with:
```bash
$ elixir bob_test.exs
```
(Replace `bob_test.exs` with the name of the test file.)
### Pending tests
In the test suites, all but the first test have been skipped.
Once you get a test passing, you can unskip the next one by
commenting out the relevant `@tag :pending` with a `#` symbol.
For example:
```elixir
# @tag :pending
test "shouting" do
assert Bob.hey("WATCH OUT!") == "Whoa, chill out!"
end
```
Or, you can enable all the tests by commenting out the
`ExUnit.configure` line in the test suite.
```elixir
# ExUnit.configure exclude: :pending, trace: true
```
For more detailed information about the Elixir track, please
see the [help page](http://exercism.io/languages/elixir).
## Source
A variation on a famous interview question intended to weed out potential candidates. [http://jumpstartlab.com](http://jumpstartlab.com)
## Submitting Incomplete Problems
It's possible to submit an incomplete solution so you can see how others have completed the exercise.

24
elixir/raindrops/raindrops.exs Normal file
View file

@ -0,0 +1,24 @@
defmodule Raindrops do
@doc """
Returns a string based on raindrop factors.
- If the number contains 3 as a prime factor, output 'Pling'.
- If the number contains 5 as a prime factor, output 'Plang'.
- If the number contains 7 as a prime factor, output 'Plong'.
- If the number does not contain 3, 5, or 7 as a prime factor,
just pass the number's digits straight through.
"""
@spec convert(pos_integer) :: String.t
def convert(number) do
case number do
number when (rem(number, 3) == 0 and rem(number, 5) == 0 and rem(number, 7) == 0) -> "PlingPlangPlong"
number when (rem(number, 3) == 0 and rem(number, 5) == 0) -> "PlingPlang"
number when (rem(number, 3) == 0 and rem(number, 7) == 0) -> "PlingPlong"
number when (rem(number, 5) == 0 and rem(number, 7) == 0) -> "PlangPlong"
number when (rem(number, 3) == 0) -> "Pling"
number when (rem(number, 5) == 0) -> "Plang"
number when (rem(number, 7) == 0) -> "Plong"
_ -> Integer.to_string(number)
end
end
end

90
elixir/raindrops/raindrops_test.exs Normal file
View file

@ -0,0 +1,90 @@
if !System.get_env("EXERCISM_TEST_EXAMPLES") do
Code.load_file("raindrops.exs", __DIR__)
end
ExUnit.start
# ExUnit.configure exclude: :pending, trace: true
defmodule RaindropsTest do
use ExUnit.Case
# @tag :pending
test "1" do
assert Raindrops.convert(1) == "1"
end
# @tag :pending
test "3" do
assert Raindrops.convert(3) == "Pling"
end
@tag :pending
test "5" do
assert Raindrops.convert(5) == "Plang"
end
@tag :pending
test "7" do
assert Raindrops.convert(7) == "Plong"
end
# @tag :pending
test "6" do
assert Raindrops.convert(6) == "Pling"
end
# @tag :pending
test "9" do
assert Raindrops.convert(9) == "Pling"
end
@tag :pending
test "10" do
assert Raindrops.convert(10) == "Plang"
end
@tag :pending
test "14" do
assert Raindrops.convert(14) == "Plong"
end
# @tag :pending
test "15" do
assert Raindrops.convert(15) == "PlingPlang"
end
@tag :pending
test "21" do
assert Raindrops.convert(21) == "PlingPlong"
end
@tag :pending
test "25" do
assert Raindrops.convert(25) == "Plang"
end
@tag :pending
test "35" do
assert Raindrops.convert(35) == "PlangPlong"
end
@tag :pending
test "49" do
assert Raindrops.convert(49) == "Plong"
end
@tag :pending
test "52" do
assert Raindrops.convert(52) == "52"
end
@tag :pending
test "105" do
assert Raindrops.convert(105) == "PlingPlangPlong"
end
@tag :pending
test "12121" do
assert Raindrops.convert(12121) == "12121"
end
end

79
elixir/rotational-cipher/README.md Normal file
View file

@ -0,0 +1,79 @@
# Rotational Cipher
Create an implementation of the rotational cipher, also sometimes called the Caesar cipher.
# Rotational Cipher
Create an implementation of the rotational cipher, also sometimes called the Caesar cipher.
The Caesar cipher is a simple shift cipher that relies on
transposing all the letters in the alphabet using an integer key
between `0` and `26`. Using a key of `0` or `26` will always yield
the same output due to modular arithmetic. The letter is shifted
for as many values as the value of the key.
The general notation for rotational ciphers is `ROT + <key>`.
The most commonly used rotational cipher is `ROT13`.
A `ROT13` on the Latin alphabet would be as follows:
```plain
Plain: abcdefghijklmnopqrstuvwxyz
Cipher: nopqrstuvwxyzabcdefghijklm
```
It is stronger than the Atbash cipher because it has 27 possible keys, and 25 usable keys.
Ciphertext is written out in the same formatting as the input including spaces and punctuation.
## Examples
- ROT5 `omg` gives `trl`
- ROT0 `c` gives `c`
- ROT26 `Cool` gives `Cool`
- ROT13 `The quick brown fox jumps over the lazy dog.` gives `Gur dhvpx oebja sbk whzcf bire gur ynml qbt.`
- ROT13 `Gur dhvpx oebja sbk whzcf bire gur ynml qbt.` gives `The quick brown fox jumps over the lazy dog.`
## Running tests
Execute the tests with:
```bash
$ elixir bob_test.exs
```
(Replace `bob_test.exs` with the name of the test file.)
### Pending tests
In the test suites, all but the first test have been skipped.
Once you get a test passing, you can unskip the next one by
commenting out the relevant `@tag :pending` with a `#` symbol.
For example:
```elixir
# @tag :pending
test "shouting" do
assert Bob.hey("WATCH OUT!") == "Whoa, chill out!"
end
```
Or, you can enable all the tests by commenting out the
`ExUnit.configure` line in the test suite.
```elixir
# ExUnit.configure exclude: :pending, trace: true
```
For more detailed information about the Elixir track, please
see the [help page](http://exercism.io/languages/elixir).
## Source
Wikipedia [https://en.wikipedia.org/wiki/Caesar_cipher](https://en.wikipedia.org/wiki/Caesar_cipher)
## Submitting Incomplete Problems
It's possible to submit an incomplete solution so you can see how others have completed the exercise.

34
elixir/rotational-cipher/rotational_cipher.exs Normal file
View file

@ -0,0 +1,34 @@
defmodule RotationalCipher do
@doc """
Given a plaintext and amount to shift by, return a rotated string.
Example:
iex> RotationalCipher.rotate("Attack at dawn", 13)
"Nggnpx ng qnja"
"""
@next_upper %{A: "B", B: "C", C => "D", D => "E", E => "F", }
@spec rotate(text :: String.t(), shift :: integer) :: String.t()
def rotate(text, shift) do
String.codepoints(text)
|> Enum.map(fn(x) -> rotate_upper(x, shift) end)
|> Enum.map(fn(x) -> rotate_lower(x, shift) end)
|> to_string
end
def rotate_upper(text, shift) do
# map(text, (fn x -> if(is_uppercase(x) do
# |> IO.chardata_to_string
# end))
end
def is_uppercase(letter) do
letter =~ ~r/^\p{Lu}$/u
end
def rotate_lower(text, shift) do
String.to_charlist("łł")
end
end

80
elixir/rotational-cipher/rotational_cipher_test.exs Normal file
View file

@ -0,0 +1,80 @@
if !System.get_env("EXERCISM_TEST_EXAMPLES") do
Code.load_file("rotational_cipher.exs", __DIR__)
end
ExUnit.start
ExUnit.configure exclude: :pending, trace: true
defmodule RotationalCipherTest do
use ExUnit.Case
#@tag :pending
test "rotate a by 1" do
plaintext = "a"
shift = 1
assert RotationalCipher.rotate(plaintext, shift) == "b"
end
@tag :pending
test "rotate a by 26, same output as input" do
plaintext = "a"
shift = 26
assert RotationalCipher.rotate(plaintext, shift) == "a"
end
@tag :pending
test "rotate a by 0, same output as input" do
plaintext = "a"
shift = 0
assert RotationalCipher.rotate(plaintext, shift) == "a"
end
@tag :pending
test "rotate m by 13" do
plaintext = "m"
shift = 13
assert RotationalCipher.rotate(plaintext, shift) == "z"
end
@tag :pending
test "rotate n by 13 with wrap around alphabet" do
plaintext = "n"
shift = 13
assert RotationalCipher.rotate(plaintext, shift) == "a"
end
@tag :pending
test "rotate capital letters" do
plaintext = "OMG"
shift = 5
assert RotationalCipher.rotate(plaintext, shift) == "TRL"
end
@tag :pending
test "rotate spaces" do
plaintext = "O M G"
shift = 5
assert RotationalCipher.rotate(plaintext, shift) == "T R L"
end
@tag :pending
test "rotate numbers" do
plaintext = "Testing 1 2 3 testing"
shift = 4
assert RotationalCipher.rotate(plaintext, shift) == "Xiwxmrk 1 2 3 xiwxmrk"
end
@tag :pending
test "rotate punctuation" do
plaintext = "Let's eat, Grandma!"
shift = 21
assert RotationalCipher.rotate(plaintext, shift) == "Gzo'n zvo, Bmviyhv!"
end
@tag :pending
test "rotate all letters" do
plaintext = "The quick brown fox jumps over the lazy dog."
shift = 13
assert RotationalCipher.rotate(plaintext, shift) == "Gur dhvpx oebja sbk whzcf bire gur ynml qbt."
end
end

73
elixir/run-length-encoding/README.md Normal file
View file

@ -0,0 +1,73 @@
# Run Length Encoding
Implement run-length encoding and decoding.
Run-length encoding (RLE) is a simple form of data compression, where runs
(consecutive data elements) are replaced by just one data value and count.
For example we can represent the original 53 characters with only 13.
```
"WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWB" -> "12WB12W3B24WB"
```
RLE allows the original data to be perfectly reconstructed from
the compressed data, which makes it a lossless data compression.
```
"AABCCCDEEEE" -> "2AB3CD4E" -> "AABCCCDEEEE"
```
If the string contains any whitespace, it should be passed through unchanged:
```
"aabc dddef" -> "2abc 3def"
```
For simplicity, you can assume that the unencoded string will only contain
the letters A through Z (either lower or uppercase) and whitespace.
## Running tests
Execute the tests with:
```bash
$ elixir bob_test.exs
```
(Replace `bob_test.exs` with the name of the test file.)
### Pending tests
In the test suites, all but the first test have been skipped.
Once you get a test passing, you can unskip the next one by
commenting out the relevant `@tag :pending` with a `#` symbol.
For example:
```elixir
# @tag :pending
test "shouting" do
assert Bob.hey("WATCH OUT!") == "Whoa, chill out!"
end
```
Or, you can enable all the tests by commenting out the
`ExUnit.configure` line in the test suite.
```elixir
# ExUnit.configure exclude: :pending, trace: true
```
For more detailed information about the Elixir track, please
see the [help page](http://exercism.io/languages/elixir).
## Source
Wikipedia [https://en.wikipedia.org/wiki/Run-length_encoding](https://en.wikipedia.org/wiki/Run-length_encoding)
## Submitting Incomplete Problems
It's possible to submit an incomplete solution so you can see how others have completed the exercise.

18
elixir/run-length-encoding/rle.exs Normal file
View file

@ -0,0 +1,18 @@
defmodule RunLengthEncoder do
@doc """
Generates a string where consecutive elements are represented as a data value and count.
"AABBBCCCC" => "2A3B4C"
For this example, assume all input are strings, that are all uppercase letters.
It should also be able to reconstruct the data into its original form.
"2A3B4C" => "AABBBCCCC"
"""
@spec encode(String.t) :: String.t
def encode(string) do
end
@spec decode(String.t) :: String.t
def decode(string) do
end
end

56
elixir/run-length-encoding/rle_test.exs Normal file
View file

@ -0,0 +1,56 @@
if !System.get_env("EXERCISM_TEST_EXAMPLES") do
Code.load_file("rle.exs", __DIR__)
end
ExUnit.start
ExUnit.configure exclude: :pending, trace: true
defmodule RunLengthEncoderTest do
use ExUnit.Case
test "encode empty string" do
assert RunLengthEncoder.encode("") === ""
end
@tag :pending
test "encode single characters only" do
assert RunLengthEncoder.encode("XYZ") === "XYZ"
end
@tag :pending
test "decode empty string" do
assert RunLengthEncoder.decode("") === ""
end
@tag :pending
test "decode single characters only" do
assert RunLengthEncoder.decode("XYZ") === "XYZ"
end
@tag :pending
test "encode simple" do
assert RunLengthEncoder.encode("AABBBCCCC") == "2A3B4C"
end
@tag :pending
test "decode simple" do
assert RunLengthEncoder.decode("2A3B4C") == "AABBBCCCC"
end
@tag :pending
test "encode with single values" do
assert RunLengthEncoder.encode("WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWB") === "12WB12W3B24WB"
end
@tag :pending
test "decode with single values" do
assert RunLengthEncoder.decode("12WB12W3B24WB") === "WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWB"
end
@tag :pending
test "decode(encode(...)) combination" do
original = "zzz ZZ zZ"
encoded = RunLengthEncoder.encode(original)
assert RunLengthEncoder.decode(encoded) === original
end
end

95
elixir/secret-handshake/README.md Normal file
View file

@ -0,0 +1,95 @@
# Secret Handshake
Given a decimal number, convert it to the appropriate sequence of events for a secret handshake.
> There are 10 types of people in the world: Those who understand
> binary, and those who don't.
You and your fellow cohort of those in the "know" when it comes to
binary decide to come up with a secret "handshake".
```
1 = wink
10 = double blink
100 = close your eyes
1000 = jump
10000 = Reverse the order of the operations in the secret handshake.
```
Here's a couple of examples:
Given the input 3, the function would return the array
["wink", "double blink"] because 3 is 11 in binary.
Given the input 19, the function would return the array
["double blink", "wink"] because 19 is 10011 in binary.
Notice that the addition of 16 (10000 in binary)
has caused the array to be reversed.
use Bitwise (or div/rem)
If you use Bitwise, an easy way to see if a particular bit is set is to compare
the binary AND (`&&&`) of a set of bits with the particular bit pattern you
want to check, and determine if the result is the same as the pattern you're
checking.
Example:
Flags: 0b11011
Check: 0b11010
Flags &&& Check: 0b11010 (All checked bits are set)
Another:
Flags: 0b11011
Check: 0b10110
Flags &&& Check: 0b10010 (Third bit not set)
## Running tests
Execute the tests with:
```bash
$ elixir bob_test.exs
```
(Replace `bob_test.exs` with the name of the test file.)
### Pending tests
In the test suites, all but the first test have been skipped.
Once you get a test passing, you can unskip the next one by
commenting out the relevant `@tag :pending` with a `#` symbol.
For example:
```elixir
# @tag :pending
test "shouting" do
assert Bob.hey("WATCH OUT!") == "Whoa, chill out!"
end
```
Or, you can enable all the tests by commenting out the
`ExUnit.configure` line in the test suite.
```elixir
# ExUnit.configure exclude: :pending, trace: true
```
For more detailed information about the Elixir track, please
see the [help page](http://exercism.io/languages/elixir).
## Source
Bert, in Mary Poppins [http://www.imdb.com/character/ch0011238/quotes](http://www.imdb.com/character/ch0011238/quotes)
## Submitting Incomplete Problems
It's possible to submit an incomplete solution so you can see how others have completed the exercise.

21
elixir/secret-handshake/secret_handshake.exs Normal file
View file

@ -0,0 +1,21 @@
defmodule SecretHandshake do
@doc """
Determine the actions of a secret handshake based on the binary
representation of the given `code`.
If the following bits are set, include the corresponding action in your list
of commands, in order from lowest to highest.
1 = wink
10 = double blink
100 = close your eyes
1000 = jump
10000 = Reverse the order of the operations in the secret handshake
"""
@spec commands(code :: integer) :: list(String.t())
def commands(code) do
end
end

72
elixir/secret-handshake/secret_handshake_test.exs Normal file
View file

@ -0,0 +1,72 @@
if !System.get_env("EXERCISM_TEST_EXAMPLES") do
Code.load_file("secret_handshake.exs", __DIR__)
end
ExUnit.start
ExUnit.configure trace: true, exclude: :pending
defmodule SecretHandshakeTest do
use ExUnit.Case
describe "Create a handshake for a number" do
#@tag :pending
test "wink for 1" do
assert SecretHandshake.commands(1) == ["wink"]
end
@tag :pending
test "double blink for 10" do
assert SecretHandshake.commands(2) == ["double blink"]
end
@tag :pending
test "close your eyes for 100" do
assert SecretHandshake.commands(4) == ["close your eyes"]
end
@tag :pending
test "jump for 1000" do
assert SecretHandshake.commands(8) == ["jump"]
end
@tag :pending
test "combine two actions" do
assert SecretHandshake.commands(3) == ["wink", "double blink"]
end
@tag :pending
test "reverse two actions" do
assert SecretHandshake.commands(19) == ["double blink", "wink"]
end
@tag :pending
test "reversing one action gives the same action" do
assert SecretHandshake.commands(24) == ["jump"]
end
@tag :pending
test "reversing no actions still gives no actions" do
assert SecretHandshake.commands(16) == []
end
@tag :pending
test "all possible actions" do
assert SecretHandshake.commands(15) == ["wink", "double blink", "close your eyes", "jump"]
end
@tag :pending
test "reverse all possible actions" do
assert SecretHandshake.commands(31) == ["jump", "close your eyes", "double blink", "wink"]
end
@tag :pending
test "do nothing for zero" do
assert SecretHandshake.commands(0) == []
end
@tag :pending
test "do nothing if lower 5 bits not set" do
assert SecretHandshake.commands(32) == []
end
end
end

65
elixir/space-age/README.md Normal file
View file

@ -0,0 +1,65 @@
# Space Age
Given an age in seconds, calculate how old someone is in terms of a given planet's solar years.
Given an age in seconds, calculate how old someone would be on:
- Earth: orbital period 365.25 Earth days, or 31557600 seconds
- Mercury: orbital period 0.2408467 Earth years
- Venus: orbital period 0.61519726 Earth years
- Mars: orbital period 1.8808158 Earth years
- Jupiter: orbital period 11.862615 Earth years
- Saturn: orbital period 29.447498 Earth years
- Uranus: orbital period 84.016846 Earth years
- Neptune: orbital period 164.79132 Earth years
So if you were told someone were 1,000,000,000 seconds old, you should
be able to say that they're 31 Earth-years old.
If you're wondering why Pluto didn't make the cut, go watch [this
youtube video](http://www.youtube.com/watch?v=Z_2gbGXzFbs).
## Running tests
Execute the tests with:
```bash
$ elixir bob_test.exs
```
(Replace `bob_test.exs` with the name of the test file.)
### Pending tests
In the test suites, all but the first test have been skipped.
Once you get a test passing, you can unskip the next one by
commenting out the relevant `@tag :pending` with a `#` symbol.
For example:
```elixir
# @tag :pending
test "shouting" do
assert Bob.hey("WATCH OUT!") == "Whoa, chill out!"
end
```
Or, you can enable all the tests by commenting out the
`ExUnit.configure` line in the test suite.
```elixir
# ExUnit.configure exclude: :pending, trace: true
```
For more detailed information about the Elixir track, please
see the [help page](http://exercism.io/languages/elixir).
## Source
Partially inspired by Chapter 1 in Chris Pine's online Learn to Program tutorial. [http://pine.fm/LearnToProgram/?Chapter=01](http://pine.fm/LearnToProgram/?Chapter=01)
## Submitting Incomplete Problems
It's possible to submit an incomplete solution so you can see how others have completed the exercise.

35
elixir/space-age/space_age.exs Normal file
View file

@ -0,0 +1,35 @@
defmodule SpaceAge do
@type planet :: :mercury | :venus | :earth | :mars | :jupiter
| :saturn | :uranus | :neptune
@doc """
Return the number of years a person that has lived for 'seconds' seconds is
aged on 'planet'.
"""
@spec age_on(planet, pos_integer) :: float
def age_on(planet, seconds) do
cond do
planet == :mercury ->
earth_age(seconds) / 0.2408467
planet == :venus ->
earth_age(seconds) / 0.61519726
planet == :earth ->
earth_age(seconds)
planet == :mars ->
earth_age(seconds) / 1.8808158
planet == :jupiter ->
earth_age(seconds) / 11.862615
planet == :saturn ->
earth_age(seconds) / 29.447498
planet == :uranus ->
earth_age(seconds) / 84.016846
planet == :neptune ->
earth_age(seconds) / 164.79132
end
end
def earth_age(seconds) do
seconds / 31557600
end
end

69
elixir/space-age/space_age_test.exs Normal file
View file

@ -0,0 +1,69 @@
if !System.get_env("EXERCISM_TEST_EXAMPLES") do
Code.load_file("space_age.exs", __DIR__)
end
ExUnit.start
ExUnit.configure exclude: :pending, trace: true
# You need to define a SpaceAge module containing a function age_on that given a
# planet (:earth, :saturn, etc) and a number of seconds returns the age in years
# on that planet as a floating point number.
defmodule SpageAgeTest do
use ExUnit.Case
# @tag :pending
test "age on Earth" do
input = 1_000_000_000
assert_in_delta 31.69, SpaceAge.age_on(:earth, input), 0.005
end
# @tag :pending
test "age on Mercury" do
input = 2_134_835_688
assert_in_delta 67.65, SpaceAge.age_on(:earth, input), 0.005
assert_in_delta 280.88, SpaceAge.age_on(:mercury, input), 0.005
end
# @tag :pending
test "age on Venus" do
input = 189_839_836
assert_in_delta 6.02, SpaceAge.age_on(:earth, input), 0.005
assert_in_delta 9.78, SpaceAge.age_on(:venus, input), 0.005
end
# @tag :pending
test "age on Mars" do
input = 2_329_871_239
assert_in_delta 73.83, SpaceAge.age_on(:earth, input), 0.005
assert_in_delta 39.25, SpaceAge.age_on(:mars, input), 0.005
end
# @tag :pending
test "age on Jupiter" do
input = 901_876_382
assert_in_delta 28.58, SpaceAge.age_on(:earth, input), 0.005
assert_in_delta 2.41, SpaceAge.age_on(:jupiter, input), 0.005
end
# @tag :pending
test "age on Saturn" do
input = 3_000_000_000
assert_in_delta 95.06, SpaceAge.age_on(:earth, input), 0.005
assert_in_delta 3.23, SpaceAge.age_on(:saturn, input), 0.005
end
# @tag :pending
test "age on Uranus" do
input = 3_210_123_456
assert_in_delta 101.72, SpaceAge.age_on(:earth, input), 0.005
assert_in_delta 1.21, SpaceAge.age_on(:uranus, input), 0.005
end
# @tag :pending
test "age on Neptune" do
input = 8_210_123_456
assert_in_delta 260.16, SpaceAge.age_on(:earth, input), 0.005
assert_in_delta 1.58, SpaceAge.age_on(:neptune, input), 0.005
end
end

58
elixir/word-count/README.md Normal file
View file

@ -0,0 +1,58 @@
# Word Count
Given a phrase, count the occurrences of each word in that phrase.
For example for the input `"olly olly in come free"`
```plain
olly: 2
in: 1
come: 1
free: 1
```
## Running tests
Execute the tests with:
```bash
$ elixir bob_test.exs
```
(Replace `bob_test.exs` with the name of the test file.)
### Pending tests
In the test suites, all but the first test have been skipped.
Once you get a test passing, you can unskip the next one by
commenting out the relevant `@tag :pending` with a `#` symbol.
For example:
```elixir
# @tag :pending
test "shouting" do
assert Bob.hey("WATCH OUT!") == "Whoa, chill out!"
end
```
Or, you can enable all the tests by commenting out the
`ExUnit.configure` line in the test suite.
```elixir
# ExUnit.configure exclude: :pending, trace: true
```
For more detailed information about the Elixir track, please
see the [help page](http://exercism.io/languages/elixir).
## Source
This is a classic toy problem, but we were reminded of it by seeing it in the Go Tour.
## Submitting Incomplete Problems
It's possible to submit an incomplete solution so you can see how others have completed the exercise.

15
elixir/word-count/word_count.exs Normal file
View file

@ -0,0 +1,15 @@
defmodule Words do
@doc """
Count the number of words in the sentence.
Words are compared case-insensitively.
"""
@spec count(String.t) :: map
def count(sentence) do
tokenized_sentence = String.split(sentence, ~r{\W}, trim: true)
blanked_punctuation = Enum.map(tokenized_sentence, (fn x -> String.split(x, ~r{\W}) end))
removed_punctuation = Enum.reject(blanked_punctuation, (fn x -> x == "" end))
removed_punctuation
Enum.reduce(removed_punctuation, Map.new(), (fn (x, acc) -> Map.update(acc, List.first(x), 1, (fn y -> (y + 1) end)) end))
end
end

62
elixir/word-count/word_count_test.exs Normal file
View file

@ -0,0 +1,62 @@
if !System.get_env("EXERCISM_TEST_EXAMPLES") do
Code.load_file("word_count.exs", __DIR__)
end
ExUnit.start
ExUnit.configure exclude: :pending, trace: true
defmodule WordsTest do
use ExUnit.Case
test "count one word" do
assert Words.count("word") == %{ "word" => 1 }
end
# @tag :pending
test "count one of each" do
expected = %{ "one" => 1 , "of" => 1 , "each" => 1 }
assert Words.count("one of each") == expected
end
# @tag :pending
test "count multiple occurrences" do
expected = %{ "one" => 1 , "fish" => 4 , "two" => 1 , "red" => 1 , "blue" => 1 }
assert Words.count("one fish two fish red fish blue fish") == expected
end
# @tag :pending
test "ignore punctuation" do
expected = %{"car" => 1, "carpet" => 1, "as" => 1, "java" => 1, "javascript" => 1}
assert Words.count("car : carpet as java : javascript!!&@$%^&") == expected
end
@tag :pending
test "include numbers" do
expected = %{"testing" => 2, "1" => 1, "2" => 1}
assert Words.count("testing, 1, 2 testing") == expected
end
@tag :pending
test "hyphens" do
expected = %{"co-operative" => 1}
assert Words.count("co-operative") == expected
end
@tag :pending
test "ignore underscores" do
expected = %{"two" => 1, "words" => 1}
assert Words.count("two_words") == expected
end
@tag :pending
test "normalize case" do
expected = %{"go" => 3}
assert Words.count("go Go GO") == expected
end
@tag :pending
test "German" do
expected = %{"götterfunken" => 1, "schöner" => 1, "freude" => 1}
assert Words.count("Freude schöner Götterfunken") == expected
end
end

36
notes.txt Normal file
View file

@ -0,0 +1,36 @@
German Office Testing Ideas -
With the Syndication Keywords, we could make packages of keywords such as "Complete Multiple Choice Screen" etc
Graph traversal from the spec generated from Study Designer
Data Loader Improvement - Wrapping/Editing codebase to make it better
Data Loader automation - Do an LPA Style, how feasible?
{"method": "DeviceService.getSubjects",
"params": {
"protocol": "GSK_COPDGeneStudy",
"user": "acicchetti",
"pass": "Il0vePht?"
}
}
Study Designer: http://designer-stg.phtstudy.com/
Horizon: http://hzn-dev-4.phtstudy.com:3006/
We don't have any API docs on the designer side currently, but here's a quick overview:
collection types: studies, questionnaires, screens, questions
POST: /api/v2/:collection
GET: /api/v2/:collection\?((\w|.)*)
GET: /api/v2/:collection/:id
PUT: /api/v2/:collection/:id
DELETE: /api/v2/:collection/:id
PUT: /api/v2/:collection/:id/checkout
PUT: /api/v2/:collection/:id/checkin
and for getting the questionnaires it's: http://designer-stg.phtstudy.com/api/v2/questionnaires?query=%7B%22_id%22%3A%7B%22%24in%22%3A%5B%2258c5dcb781ae97a80f7a9561%22%5D%7D%7D
which is just url eoncoded query for this: {"_id":{"$in":["58c5dcb781ae97a80f7a9561"]}}

27
python/clock/README.md Normal file
View file

@ -0,0 +1,27 @@
# Clock
Implement a clock that handles times without dates.
Create a clock that is independent of date.
You should be able to add and subtract minutes to it.
Two clocks that represent the same time should be equal to each other.
### Submitting Exercises
Note that, when trying to submit an exercise, make sure the solution is in the `exercism/python/<exerciseName>` directory.
For example, if you're submitting `bob.py` for the Bob exercise, the submit command would be something like `exercism submit <path_to_exercism_dir>/python/bob/bob.py`.
For more detailed information about running tests, code style and linting,
please see the [help page](http://exercism.io/languages/python).
## Source
Pairing session with Erin Drummond [https://twitter.com/ebdrummond](https://twitter.com/ebdrummond)
## Submitting Incomplete Problems
It's possible to submit an incomplete solution so you can see how others have completed the exercise.

2
python/clock/clock.py Normal file
View file

@ -0,0 +1,2 @@
def Clock:

162
python/clock/clock_test.py Normal file
View file

@ -0,0 +1,162 @@
import unittest
from clock import Clock
class ClockTest(unittest.TestCase):
# Test creating a new clock with an initial time.
def test_on_the_hour(self):
self.assertEqual('08:00', str(Clock(8, 0)))
def test_past_the_hour(self):
self.assertEqual('11:09', str(Clock(11, 9)))
def test_midnight_is_zero_hours(self):
self.assertEqual('00:00', str(Clock(24, 0)))
def test_hour_rolls_over(self):
self.assertEqual('01:00', str(Clock(25, 0)))
def test_hour_rolls_over_continuously(self):
self.assertEqual('04:00', str(Clock(100, 0)))
def test_sixty_minutes_is_next_hour(self):
self.assertEqual('02:00', str(Clock(1, 60)))
def test_minutes_roll_over(self):
self.assertEqual('02:40', str(Clock(0, 160)))
def test_minutes_roll_over_continuously(self):
self.assertEqual('04:43', str(Clock(0, 1723)))
def test_hour_and_minutes_roll_over(self):
self.assertEqual('03:40', str(Clock(25, 160)))
def test_hour_and_minutes_roll_over_continuously(self):
self.assertEqual('11:01', str(Clock(201, 3001)))
def test_hour_and_minutes_roll_over_to_exactly_midnight(self):
self.assertEqual('00:00', str(Clock(72, 8640)))
def test_negative_hour(self):
self.assertEqual('23:15', str(Clock(-1, 15)))
def test_negative_hour_rolls_over(self):
self.assertEqual('23:00', str(Clock(-25, 0)))
def test_negative_hour_rolls_over_continuously(self):
self.assertEqual('05:00', str(Clock(-91, 0)))
def test_negative_minutes(self):
self.assertEqual('00:20', str(Clock(1, -40)))
def test_negative_minutes_roll_over(self):
self.assertEqual('22:20', str(Clock(1, -160)))
def test_negative_minutes_roll_over_continuously(self):
self.assertEqual('16:40', str(Clock(1, -4820)))
def test_negative_hour_and_minutes_both_roll_over(self):
self.assertEqual('20:20', str(Clock(-25, -160)))
def test_negative_hour_and_minutes_both_roll_over_continuously(self):
self.assertEqual('22:10', str(Clock(-121, -5810)))
# Test adding and subtracting minutes.
def test_add_minutes(self):
self.assertEqual('10:03', str(Clock(10, 0).add(3)))
def test_add_no_minutes(self):
self.assertEqual('06:41', str(Clock(6, 41).add(0)))
def test_add_to_next_hour(self):
self.assertEqual('01:25', str(Clock(0, 45).add(40)))
def test_add_more_than_one_hour(self):
self.assertEqual('11:01', str(Clock(10, 0).add(61)))
def test_add_more_than_two_hours_with_carry(self):
self.assertEqual('03:25', str(Clock(0, 45).add(160)))
def test_add_across_midnight(self):
self.assertEqual('00:01', str(Clock(23, 59).add(2)))
def test_add_more_than_one_day(self):
self.assertEqual('06:32', str(Clock(5, 32).add(1500)))
def test_add_more_than_two_days(self):
self.assertEqual('11:21', str(Clock(1, 1).add(3500)))
def test_subtract_minutes(self):
self.assertEqual('10:00', str(Clock(10, 3).add(-3)))
def test_subtract_to_previous_hour(self):
self.assertEqual('10:00', str(Clock(10, 3).add(-3)))
def test_subtract_more_than_an_hour(self):
self.assertEqual('09:33', str(Clock(10, 3).add(-30)))
def test_subtract_across_midnight(self):
self.assertEqual('08:53', str(Clock(10, 3).add(-70)))
def test_subtract_more_than_two_hours(self):
self.assertEqual('21:20', str(Clock(0, 0).add(-160)))
def test_subtract_more_than_two_hours_with_borrow(self):
self.assertEqual('03:35', str(Clock(6, 15).add(-160)))
def test_subtract_more_than_one_day(self):
self.assertEqual('04:32', str(Clock(5, 32).add(-1500)))
def test_subtract_more_than_two_days(self):
self.assertEqual('00:20', str(Clock(2, 20).add(-3000)))
# Construct two separate clocks, set times, test if they are equal.
def test_clocks_with_same_time(self):
self.assertEqual(Clock(15, 37), Clock(15, 37))
def test_clocks_a_minute_apart(self):
self.assertNotEqual(Clock(15, 36), Clock(15, 37))
def test_clocks_an_hour_apart(self):
self.assertNotEqual(Clock(14, 37), Clock(15, 37))
def test_clocks_with_hour_overflow(self):
self.assertEqual(Clock(10, 37), Clock(34, 37))
def test_clocks_with_hour_overflow_by_several_days(self):
self.assertEqual(Clock(3, 11), Clock(99, 11))
def test_clocks_with_negative_hour(self):
self.assertEqual(Clock(22, 40), Clock(-2, 40))
def test_clocks_with_negative_hour_that_wraps(self):
self.assertEqual(Clock(17, 3), Clock(-31, 3))
def test_clocks_with_negative_hour_that_wraps_multiple_times(self):
self.assertEqual(Clock(13, 49), Clock(-83, 49))
def test_clocks_with_minute_overflow(self):
self.assertEqual(Clock(0, 1), Clock(0, 1441))
def test_clocks_with_minute_overflow_by_several_days(self):
self.assertEqual(Clock(2, 2), Clock(2, 4322))
def test_clocks_with_negative_minute(self):
self.assertEqual(Clock(2, 40), Clock(3, -20))
def test_clocks_with_negative_minute_that_wraps(self):
self.assertEqual(Clock(4, 10), Clock(5, -1490))
def test_clocks_with_negative_minute_that_wraps_multiple_times(self):
self.assertEqual(Clock(6, 15), Clock(6, -4305))
def test_clocks_with_negative_hours_and_minutes(self):
self.assertEqual(Clock(7, 32), Clock(-12, -268))
def test_clocks_with_negative_hours_and_minutes_that_wrap(self):
self.assertEqual(Clock(18, 7), Clock(-54, -11513))
if __name__ == '__main__':
unittest.main()

68
python/hello-world/README.md Normal file
View file

@ -0,0 +1,68 @@
# Hello World
Greet the user by name, or by saying "Hello, World!" if no name is given.
["Hello, World!"](http://en.wikipedia.org/wiki/%22Hello,_world!%22_program) is
the traditional first program for beginning programming in a new language.
**Note:** You can skip this exercise by running:
exercism skip $TRACK_ID hello-world
## Specification
Write a `Hello World!` function that can greet someone given their name. The
function should return the appropriate greeting.
For an input of "Alice", the response should be "Hello, Alice!".
If a name is not given, the response should be "Hello, World!"
## Test-Driven Development
As programmers mature, they eventually want to test their code.
Here at Exercism we simulate [Test-Driven
Development](http://en.wikipedia.org/wiki/Test-driven_development) (TDD), where
you write your tests before writing any functionality. The simulation comes in
the form of a pre-written test suite, which will signal that you have solved
the problem.
It will also provide you with a safety net to explore other solutions without
breaking the functionality.
### A typical TDD workflow on Exercism:
1. Run the test file and pick one test that's failing.
2. Write some code to fix the test you picked.
3. Re-run the tests to confirm the test is now passing.
4. Repeat from step 1.
5. Submit your solution (`exercism submit /path/to/file`)
## Instructions
Submissions are encouraged to be general, within reason. Having said that, it's
also important not to over-engineer a solution.
It's important to remember that the goal is to make code as expressive and
readable as we can. However, solutions to the hello-world exercise will not be
reviewed by a person, but by rikki- the robot, who will offer an encouraging
word.
### Submitting Exercises
Note that, when trying to submit an exercise, make sure the solution is in the `exercism/python/<exerciseName>` directory.
For example, if you're submitting `bob.py` for the Bob exercise, the submit command would be something like `exercism submit <path_to_exercism_dir>/python/bob/bob.py`.
For more detailed information about running tests, code style and linting,
please see the [help page](http://exercism.io/languages/python).
## Source
This is an exercise to introduce users to using Exercism [http://en.wikipedia.org/wiki/%22Hello,_world!%22_program](http://en.wikipedia.org/wiki/%22Hello,_world!%22_program)
## Submitting Incomplete Problems
It's possible to submit an incomplete solution so you can see how others have completed the exercise.

9
python/hello-world/hello_world.py Normal file
View file

@ -0,0 +1,9 @@
#
# Skeleton file for the Python "Hello World" exercise.
#
def hello(name="World"):
if name == None or name == '':
name = "World"
return "Hello, " + name + "!"

BIN
python/hello-world/hello_world.pyc Normal file
View file

Binary file not shown.

49
python/hello-world/hello_world_test.py Normal file
View file

@ -0,0 +1,49 @@
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
import unittest
import hello_world
class HelloWorldTests(unittest.TestCase):
def test_hello_without_name(self):
self.assertEqual(
'Hello, World!',
hello_world.hello()
)
def test_hello_with_sample_name(self):
self.assertEqual(
'Hello, Alice!',
hello_world.hello('Alice')
)
def test_hello_with_other_sample_name(self):
self.assertEqual(
'Hello, Bob!',
hello_world.hello('Bob')
)
def test_hello_with_umlaut_name(self):
self.assertEqual(
'Hello, Jürgen!',
hello_world.hello('Jürgen')
)
def test_hello_with_blank_name(self):
self.assertEqual(
'Hello, World!',
hello_world.hello('')
)
def test_hello_with_none_name(self):
self.assertEqual(
'Hello, World!',
hello_world.hello(None)
)
if __name__ == '__main__':
unittest.main()

52
python/kevin/foobar-3.py Normal file
View file

@ -0,0 +1,52 @@
inp_src = 19
inp_dest = 37
def answer(src, dest):
graph_of_valid_moves = make_graph()
required_moves = 0
print graph_of_valid_moves[src]
list_of_paths = shortest_path(graph_of_valid_moves, src, dest)
return len(list_of_paths)-1
def make_graph():
temp_dict = {}
for i in range(0,8):
for j in range(0,8):
temp_dict[(i * 8) + j] = map(lambda x: (x[0] * 8) + x[1], generate_legal_moves(i,j,8))
return temp_dict
def shortest_path(graph, start, goal):
try:
return next(breadth_search(graph, start, goal))
except StopIteration:
return None
def generate_legal_moves(x,y,bdSize):
newMoves = []
moveOffsets = [(-1,-2),(-1,2),(-2,-1),(-2,1),
( 1,-2),( 1,2),( 2,-1),( 2,1)]
for i in moveOffsets:
newX = x + i[0]
newY = y + i[1]
if is_legal(newX,bdSize) and \
is_legal(newY,bdSize):
newMoves.append((newX,newY))
return newMoves
def is_legal(x,bdSize):
if x >= 0 and x < bdSize:
return True
else:
return False
def breadth_search(graph, start, goal):
queue = [(start, [start])]
while queue:
(vertex, path) = queue.pop(0)
for next in graph[vertex]:
if next == goal:
yield path + [next]
else:
queue.append((next, path + [next]))
print answer(inp_src, inp_dest)

7
python/kevin/kevin.py Normal file
View file

@ -0,0 +1,7 @@
# n = int(raw_input())
# arr = map(int, raw_input().split())
arr = [5,4,6,2,3,1,1,1,4,8,7,7]
out = filter(lambda x: x != max(arr), arr)
print max(out)

16
python/kevin/kevin2.py Normal file
View file

@ -0,0 +1,16 @@
# Find the maximum number of slices of repeating characters you can split a string into
import sys
def main(inpString):
max_slices = 0
for i in range(1, len(inpString)):
temp = 0
print inpString[0:i]
print inpString[i:]
nextOccuranceIndex = inpString[i:].index(inpString[0:i])
if nextOccuranceIndex != null:
temp++
return max_slices
if __name__ == "__main__":
print main(sys.argv[1])

0
python/kevin/kevin3-2.py Normal file
View file

52
python/kevin/kevin3.py Normal file
View file

@ -0,0 +1,52 @@
inp_src = 19
inp_dest = 37
def answer(src, dest):
graph_of_valid_moves = make_graph()
required_moves = 0
print graph_of_valid_moves[src]
list_of_paths = shortest_path(graph_of_valid_moves, src, dest)
return len(list_of_paths)-1
def make_graph():
temp_dict = {}
for i in range(0,8):
for j in range(0,8):
temp_dict[(i * 8) + j] = map(lambda x: (x[0] * 8) + x[1], generate_legal_moves(i,j,8))
return temp_dict
def shortest_path(graph, start, goal):
try:
return next(breadth_search(graph, start, goal))
except StopIteration:
return None
def generate_legal_moves(x,y,bdSize):
newMoves = []
moveOffsets = [(-1,-2),(-1,2),(-2,-1),(-2,1),
( 1,-2),( 1,2),( 2,-1),( 2,1)]
for i in moveOffsets:
newX = x + i[0]
newY = y + i[1]
if is_legal(newX,bdSize) and \
is_legal(newY,bdSize):
newMoves.append((newX,newY))
return newMoves
def is_legal(x,bdSize):
if x >= 0 and x < bdSize:
return True
else:
return False
def breadth_search(graph, start, goal):
queue = [(start, [start])]
while queue:
(vertex, path) = queue.pop(0)
for next in graph[vertex]:
if next == goal:
yield path + [next]
else:
queue.append((next, path + [next]))
print answer(inp_src, inp_dest)

45
python/leap/README.md Normal file
View file

@ -0,0 +1,45 @@
# Leap
Given a year, report if it is a leap year.
The tricky thing here is that a leap year in the Gregorian calendar occurs:
```plain
on every year that is evenly divisible by 4
except every year that is evenly divisible by 100
unless the year is also evenly divisible by 400
```
For example, 1997 is not a leap year, but 1996 is. 1900 is not a leap
year, but 2000 is.
If your language provides a method in the standard library that does
this look-up, pretend it doesn't exist and implement it yourself.
## Notes
Though our exercise adopts some very simple rules, there is more to
learn!
For a delightful, four minute explanation of the whole leap year
phenomenon, go watch [this youtube video][video].
[video]: http://www.youtube.com/watch?v=xX96xng7sAE
### Submitting Exercises
Note that, when trying to submit an exercise, make sure the solution is in the `exercism/python/<exerciseName>` directory.
For example, if you're submitting `bob.py` for the Bob exercise, the submit command would be something like `exercism submit <path_to_exercism_dir>/python/bob/bob.py`.
For more detailed information about running tests, code style and linting,
please see the [help page](http://exercism.io/languages/python).
## Source
JavaRanch Cattle Drive, exercise 3 [http://www.javaranch.com/leap.jsp](http://www.javaranch.com/leap.jsp)
## Submitting Incomplete Problems
It's possible to submit an incomplete solution so you can see how others have completed the exercise.

8
python/leap/leap.py Normal file
View file

@ -0,0 +1,8 @@
def is_leap_year(year):
if (year % 4 == 0):
if (year % 100 == 0):
if (year %400 == 0):
return True
return False
return True
return False

BIN
python/leap/leap.pyc Normal file
View file

Binary file not shown.

24
python/leap/leap_test.py Normal file
View file

@ -0,0 +1,24 @@
import unittest
from leap import is_leap_year
class YearTest(unittest.TestCase):
def test_leap_year(self):
self.assertIs(is_leap_year(1996), True)
def test_non_leap_year(self):
self.assertIs(is_leap_year(1997), False)
def test_non_leap_even_year(self):
self.assertIs(is_leap_year(1998), False)
def test_century(self):
self.assertIs(is_leap_year(1900), False)
def test_exceptional_century(self):
self.assertIs(is_leap_year(2400), True)
if __name__ == '__main__':
unittest.main()

7
rust/gigasecond/.gitignore vendored Normal file
View file

@ -0,0 +1,7 @@
# Generated by Cargo
# will have compiled files and executables
/target/
# Remove Cargo.lock from gitignore if creating an executable, leave it for libraries
# More information here http://doc.crates.io/guide.html#cargotoml-vs-cargolock
Cargo.lock

7
rust/gigasecond/Cargo.toml Normal file
View file

@ -0,0 +1,7 @@
[package]
name = "gigasecond"
version = "0.0.0"
[dependencies]
chrono = "0.2"

44
rust/gigasecond/README.md Normal file
View file

@ -0,0 +1,44 @@
# Gigasecond
Calculate the moment when someone has lived for 10^9 seconds.
A gigasecond is 10^9 (1,000,000,000) seconds.
## Rust Installation
Refer to the [exercism help page][help-page] for Rust installation and learning
resources.
## Writing the Code
Execute the tests with:
```bash
$ cargo test
```
All but the first test have been ignored. After you get the first test to
pass, remove the ignore flag (`#[ignore]`) from the next test and get the tests
to pass again. The test file is located in the `tests` directory. You can
also remove the ignore flag from all the tests to get them to run all at once
if you wish.
Make sure to read the [Crates and Modules](https://doc.rust-lang.org/stable/book/crates-and-modules.html) chapter if you
haven't already, it will help you with organizing your files.
## Feedback, Issues, Pull Requests
The [exercism/xrust](https://github.com/exercism/xrust) repository on GitHub is the home for all of the Rust exercises. If you have feedback about an exercise, or want to help implement new exercises, head over there and create an issue. Members of the [rust track team](https://github.com/orgs/exercism/teams/rust) are happy to help!
If you want to know more about Exercism, take a look at the [contribution guide](https://github.com/exercism/x-common/blob/master/CONTRIBUTING.md).
[help-page]: http://exercism.io/languages/rust
[crates-and-modules]: http://doc.rust-lang.org/stable/book/crates-and-modules.html
## Source
Chapter 9 in Chris Pine's online Learn to Program tutorial. [http://pine.fm/LearnToProgram/?Chapter=09](http://pine.fm/LearnToProgram/?Chapter=09)
## Submitting Incomplete Problems
It's possible to submit an incomplete solution so you can see how others have completed the exercise.

8
rust/gigasecond/src/lib.rs Normal file
View file

@ -0,0 +1,8 @@
extern crate chrono;
use chrono::*;
pub fn after(date: Option<&UTC>) -> UTC {
let mut lived_for_date: UTC;
return lived_for_date;
}

50
rust/gigasecond/tests/gigasecond.rs Normal file
View file

@ -0,0 +1,50 @@
extern crate gigasecond;
/*
* Students,
*
* Rust does not currently have a library for handling Time. To solve this exercise
* you'll need to use the Chrono 'crate' (which is Rust's term for an external library).
*
* The first time you run `cargo test`, the Chrono crate will automatically be downloaded
* and installed. More information on crates can be found at
* https://doc.rust-lang.org/book/guessing-game.html#generating-a-secret-number
*
* In order to use the crate, your solution will need to start with the two following lines
*/
extern crate chrono;
use chrono::*;
#[test]
fn test_date() {
let start_date = UTC.ymd(2011, 4, 25).and_hms(0,0,0);
assert_eq!(gigasecond::after(start_date), UTC.ymd(2043, 1, 1).and_hms(1,46,40));
}
#[test]
#[ignore]
fn test_another_date() {
let start_date = UTC.ymd(1977, 6, 13).and_hms(0,0,0);
assert_eq!(gigasecond::after(start_date), UTC.ymd(2009, 2, 19).and_hms(1,46,40));
}
#[test]
#[ignore]
fn test_third_date() {
let start_date = UTC.ymd(1959, 7, 19).and_hms(0,0,0);
assert_eq!(gigasecond::after(start_date), UTC.ymd(1991, 3, 27).and_hms(1,46,40));
}
#[test]
#[ignore]
fn test_datetime() {
let start_date = UTC.ymd(2015, 1, 24).and_hms(22,0,0);
assert_eq!(gigasecond::after(start_date), UTC.ymd(2046, 10, 2).and_hms(23,46,40));
}
#[test]
#[ignore]
fn test_another_datetime() {
let start_date = UTC.ymd(2015, 1, 24).and_hms(23,59,59);
assert_eq!(gigasecond::after(start_date), UTC.ymd(2046, 10, 3).and_hms(1,46,39));
}

7
rust/hello-world/.gitignore vendored Normal file
View file

@ -0,0 +1,7 @@
# Generated by Cargo
# will have compiled files and executables
/target/
# Remove Cargo.lock from gitignore if creating an executable, leave it for libraries
# More information here http://doc.crates.io/guide.html#cargotoml-vs-cargolock
Cargo.lock

3
rust/hello-world/Cargo.toml Normal file
View file

@ -0,0 +1,3 @@
[package]
name = "hello-world"
version = "0.0.0"

160
rust/hello-world/GETTING_STARTED.md Normal file
View file

@ -0,0 +1,160 @@
# Getting Started
These exercises lean on Test-Driven Development (TDD), but they're not
an exact match.
The following steps assume that you are in the same directory as the exercise.
You must have rust installed.
Follow the [Getting Started chapter in the Rust book](https://doc.rust-lang.org/stable/book/getting-started.html).
The [Rust language section](http://exercism.io/languages/rust)
section from exercism is also useful.
## Step 1
Run the test suite. It can be run with `cargo`, which is installed with rust.
```
$ cargo test
```
This will fail, complaining that `hello-world` could not compile.
To fix this, create a new directory called `src`.
Create a new file called, `lib.rs`, inside the `src` directory.
## Step 2
Run the test again. It will give you a new error, another compile error.
Our `lib.rs` does not contain any code, specifically the `hello()`
function that our test is looking for.
### Fixing the Error
To fix it, open up the `src/lib.rs` file and add the following code:
```rust
pub fn hello(name: Option<&str>) -> String {
"".to_string()
}
```
Our test is looking for the `hello()` function from the `hello_world`
crate. `lib.rs`, by default, is our crate root and our test
is looking for the `hello()` function there.
The code we are adding to `lib.rs` defines a public function (`pub fn`) that is called "hello".
The function accepts a `name` as an optional argument (`Option`).
The function returns a `String`.
We start by returning an empty string (`"".to_string()`).
## Step 3
Run the test again.
This time, code compilation will pass and we receive actual test failures.
```
running 3 tests
test test_other_same_name ... ignored
test test_sample_name ... ignored
test test_no_name ... FAILED
failures:
---- test_no_name stdout ----
thread 'test_no_name' panicked at 'assertion failed: `(left == right)`
(left: `"Hello, World!"`, right: `""`)', tests/hello-world.rs:5
failures:
test_no_name
test result: FAILED. 0 passed; 1 failed; 2 ignored; 0 measured
```
### Understanding Test Failures
Only one of the tests runs (`test_no_name`) and it fails. The other
tests are ignored (more on that later).
The `test_no_name` failure states that it is expecting the value,
`"Hello, World!"`, to be returned from `hello("")`.
The left side of the assertion (at line 5) should be equal to the right side.
```
---- test_no_name stdout ----
thread 'test_no_name' panicked at 'assertion failed: `(left == right)`
(left: `"Hello, World!"`, right: `""`)', tests/hello-world.rs:5
```
To fix it, let's return `"Hello, World!"`, instead of an empty string
(`""`) inside our `hello` function.
```rust
pub fn hello(name: Option<&str>) -> String {
"Hello, World!".to_string()
}
```
## Step 4
Run the test again. This time, it will pass.
```
running 3 tests
test test_other_same_name ... ignored
test test_sample_name ... ignored
test test_no_name ... ok
test result: ok. 1 passed; 0 failed; 2 ignored; 0 measured
Doc-tests hello-world
running 0 tests
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured
```
You may have noticed compiler warnings earlier:
```
Compiling hello-world v0.0.0
(file:////exercism/exercises/rust/hello-world)
src/lib.rs:1:14: 1:18 warning: unused variable: `name`, #[warn(unused_variables)] on by default
src/lib.rs:1 pub fn hello(name: Option<&str>) -> String {
^~~~
```
Our `hello` function does not use the `name` argument so the
compiler is letting us know that we could potentially remove the
argument from our function (it likes "clean code").
As we make the rest of the tests pass, we will find that we need the `name`
argument, so don't delete it.
Activate the next test. Open the `tests/hello-world.rs` file.
Delete the `#[ignore]` line for the `test_sample_name` test.
## Step 5
Run the test suite again. Read the test failure and make the test pass.
As a reminder, the [rust book](http://doc.rust-lang.org/stable/book/README.html)
is a good reference for understanding rust.
The cargo output may also have hints to help you, depending on the errors you get.
For example, `rustc --explain E0425` will explain unresolved name errors.
## Wash, Rinse, Repeat
Delete one `#[ignore]` at a time, and make each test pass before you move to
the next one.
## Submit
When everything is passing, you can submit your code with the following
command:
```
$ exercism submit src/lib.rs
```

89
rust/hello-world/README.md Normal file
View file

@ -0,0 +1,89 @@
# Hello World
Greet the user by name, or by saying "Hello, World!" if no name is given.
["Hello, World!"](http://en.wikipedia.org/wiki/%22Hello,_world!%22_program) is
the traditional first program for beginning programming in a new language.
**Note:** You can skip this exercise by running:
exercism skip $TRACK_ID hello-world
## Specification
Write a `Hello World!` function that can greet someone given their name. The
function should return the appropriate greeting.
For an input of "Alice", the response should be "Hello, Alice!".
If a name is not given, the response should be "Hello, World!"
## Test-Driven Development
As programmers mature, they eventually want to test their code.
Here at Exercism we simulate [Test-Driven
Development](http://en.wikipedia.org/wiki/Test-driven_development) (TDD), where
you write your tests before writing any functionality. The simulation comes in
the form of a pre-written test suite, which will signal that you have solved
the problem.
It will also provide you with a safety net to explore other solutions without
breaking the functionality.
### A typical TDD workflow on Exercism:
1. Run the test file and pick one test that's failing.
2. Write some code to fix the test you picked.
3. Re-run the tests to confirm the test is now passing.
4. Repeat from step 1.
5. Submit your solution (`exercism submit /path/to/file`)
## Instructions
Submissions are encouraged to be general, within reason. Having said that, it's
also important not to over-engineer a solution.
It's important to remember that the goal is to make code as expressive and
readable as we can. However, solutions to the hello-world exercise will not be
reviewed by a person, but by rikki- the robot, who will offer an encouraging
word.
## Rust Installation
Refer to the [exercism help page][help-page] for Rust installation and learning
resources.
## Writing the Code
Execute the tests with:
```bash
$ cargo test
```
All but the first test have been ignored. After you get the first test to
pass, remove the ignore flag (`#[ignore]`) from the next test and get the tests
to pass again. The test file is located in the `tests` directory. You can
also remove the ignore flag from all the tests to get them to run all at once
if you wish.
Make sure to read the [Crates and Modules](https://doc.rust-lang.org/stable/book/crates-and-modules.html) chapter if you
haven't already, it will help you with organizing your files.
## Feedback, Issues, Pull Requests
The [exercism/xrust](https://github.com/exercism/xrust) repository on GitHub is the home for all of the Rust exercises. If you have feedback about an exercise, or want to help implement new exercises, head over there and create an issue. Members of the [rust track team](https://github.com/orgs/exercism/teams/rust) are happy to help!
If you want to know more about Exercism, take a look at the [contribution guide](https://github.com/exercism/x-common/blob/master/CONTRIBUTING.md).
[help-page]: http://exercism.io/languages/rust
[crates-and-modules]: http://doc.rust-lang.org/stable/book/crates-and-modules.html
## Source
This is an exercise to introduce users to using Exercism [http://en.wikipedia.org/wiki/%22Hello,_world!%22_program](http://en.wikipedia.org/wiki/%22Hello,_world!%22_program)
## Submitting Incomplete Problems
It's possible to submit an incomplete solution so you can see how others have completed the exercise.

8
rust/hello-world/src/lib.rs Normal file
View file

@ -0,0 +1,8 @@
pub fn hello(name: Option<&str>) -> String {
let mut returnString: String;
match name {
Some(name) => returnString = "Hello, ".to_string() + &name.to_string() + "!",
None => returnString = "Hello, World!".to_string(),
}
return returnString;
}

16
rust/hello-world/tests/hello-world.rs Normal file
View file

@ -0,0 +1,16 @@
extern crate hello_world;
#[test]
fn test_no_name() {
assert_eq!("Hello, World!", hello_world::hello(None));
}
#[test]
fn test_sample_name() {
assert_eq!("Hello, Alice!", hello_world::hello(Some("Alice")));
}
#[test]
fn test_other_same_name() {
assert_eq!("Hello, Bob!", hello_world::hello(Some("Bob")));
}