trackler 2.2.1.53 → 2.2.1.54

data/tracks/python/exercises/zebra-puzzle/README.md

@@ -25,13 +25,12 @@ drink different beverages and smoke different brands of cigarettes.
 Which of the residents drinks water?
 Who owns the zebra?
 
-### Submitting Exercises
+## 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).
 

data/tracks/python/requirements-travis.txt

@@ -1,3 +1,3 @@
-flake8==3.4.1
+flake8==3.5.0
 pep8>=1.7,<1.7.99
 pyflakes==1.6.0

data/tracks/ruby/config.json

@@ -886,6 +886,17 @@
         "Logic"
       ]
     },
+    {
+      "uuid": "b02a4214-0f1a-9480-2132-2ea3d5073dbfbec0aa4",
+      "slug": "two-fer",
+      "core": false,
+      "unlocked_by": null,
+      "difficulty": 1,
+      "topics": [
+        "Control-flow (conditionals)",
+        "Strings"
+      ]
+    },
     {
       "uuid": "cae4e000-3aac-41f7-b727-f9cce12d058d",
       "slug": "octal",

data/tracks/ruby/docs/TESTS.md

@@ -10,6 +10,12 @@ Only the first test will be executed, all the others have been made pending
 using the `skip` method. Delete or comment the next `skip` as you get
 each test passing.
 
+## Understanding Skips
+
+The `skip` method instructs the test suite to not run a test. This is commonly used to avoid running tests of unimplemented functionality, so you can focus on the part you are currently working on.
+
+The test run summary will list the number of skipped tests. You should disable all of the skips before completing an exercise.
+
 ## Customizing Test Reporting
 
 If you want color, execute the tests with:

data/tracks/ruby/exercises/pangram/.meta/.version

@@ -1 +1 @@
-5
+6

data/tracks/ruby/exercises/pangram/.meta/solutions/pangram.rb

@@ -1,5 +1,5 @@
 module BookKeeping
-  VERSION = 5
+  VERSION = 6
 end
 
 class Pangram

data/tracks/ruby/exercises/pangram/pangram_test.rb

@@ -1,7 +1,7 @@
 require 'minitest/autorun'
 require_relative 'pangram'
 
-# Common test data version: 1.1.0 fba1aef
+# Common test data version: 1.3.0 d79e13e
 class PangramTest < Minitest::Test
   def test_sentence_empty
     # skip
@@ -10,6 +10,13 @@ class PangramTest < Minitest::Test
     refute result, "Expected false, got: #{result.inspect}. #{phrase.inspect} is NOT a pangram"
   end
 
+  def test_recognizes_a_perfect_lower_case_pangram
+    skip
+    phrase = 'abcdefghijklmnopqrstuvwxyz'
+    result = Pangram.pangram?(phrase)
+    assert result, "Expected true, got: #{result.inspect}. #{phrase.inspect} IS a pangram"
+  end
+
   def test_pangram_with_only_lower_case
     skip
     phrase = 'the quick brown fox jumps over the lazy dog'
@@ -24,9 +31,9 @@ class PangramTest < Minitest::Test
     refute result, "Expected false, got: #{result.inspect}. #{phrase.inspect} is NOT a pangram"
   end
 
-  def test_another_missing_character_x
+  def test_another_missing_character_eg_h
     skip
-    phrase = 'the quick brown fish jumps over the lazy dog'
+    phrase = 'five boxing wizards jump quickly at it'
     result = Pangram.pangram?(phrase)
     refute result, "Expected false, got: #{result.inspect}. #{phrase.inspect} is NOT a pangram"
   end
@@ -85,6 +92,6 @@ class PangramTest < Minitest::Test
 
   def test_bookkeeping
     skip
-    assert_equal 5, BookKeeping::VERSION
+    assert_equal 6, BookKeeping::VERSION
   end
 end

data/tracks/ruby/exercises/two-fer/.meta/.version

@@ -0,0 +1 @@
+1

data/tracks/ruby/exercises/two-fer/.meta/generator/two_fer_case.rb

@@ -0,0 +1,12 @@
+require 'generator/exercise_case'
+
+class TwoFerCase < Generator::ExerciseCase
+
+  def workload
+    if input == nil
+      assert_equal {"TwoFer.two_fer"}
+    else
+      assert_equal { "TwoFer.two_fer(#{input.inspect})" }
+    end
+  end
+end

data/tracks/ruby/exercises/two-fer/.meta/solutions/two_fer.rb

@@ -0,0 +1,9 @@
+module BookKeeping
+  VERSION = 1
+end
+
+class TwoFer
+  def self.two_fer(name = 'you')
+    "One for #{name}, one for me."
+  end
+end

data/tracks/ruby/exercises/two-fer/README.md

@@ -0,0 +1,69 @@
+# Two Fer
+
+`Two-fer` or `2-fer` is short for two for one. One for you and one for me.
+
+```text
+"One for X, one for me."
+```
+
+When X is a name or "you".
+
+If the given name is "Alice", the result should be "One for Alice, one for me."
+If no name is given, the result should be "One for you, one for me."
+
+## 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.
+
+## Running the tests
+
+For running the tests provided, you will need the Minitest gem. Open a terminal window and run the following command to install minitest:
+
+`gem install minitest`
+
+If you would like color output, you can require `'minitest/pride'` in the test file, or note the alternative instruction, below, for running the test file.
+
+In order to run the test, you can run the test file from the exercise directory.
+
+`ruby two_fer_test.rb`
+
+To include color from the command line:
+
+`ruby -r minitest/pride two_fer_test.rb`
+
+## Further information
+
+For more detailed information about the Ruby track, including how to get help if you're having trouble, please visit the exercism.io [Ruby language page](http://exercism.io/languages/ruby/about).
+
+## Source
+
+This is an exercise to introduce users to basic programming constructs, just after hello World. [https://en.wikipedia.org/wiki/Two-fer](https://en.wikipedia.org/wiki/Two-fer)
+
+## Submitting Incomplete Solutions
+
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/ruby/exercises/two-fer/two_fer_test.rb

@@ -0,0 +1,42 @@
+require 'minitest/autorun'
+require_relative 'two_fer'
+
+# Common test data version: 1.1.0 c080bdf
+class TwoFerTest < Minitest::Test
+  def test_no_name_given
+    # skip
+    assert_equal "One for you, one for me.", TwoFer.two_fer
+  end
+
+  def test_a_name_given
+    skip
+    assert_equal "One for Alice, one for me.", TwoFer.two_fer("Alice")
+  end
+
+  def test_another_name_given
+    skip
+    assert_equal "One for Bob, one for me.", TwoFer.two_fer("Bob")
+  end
+
+  # Problems in exercism evolve over time, as we find better ways to ask
+  # questions.
+  # The version number refers to the version of the problem you solved,
+  # not your solution.
+  #
+  # Define a constant named VERSION inside of the top level BookKeeping
+  # module, which may be placed near the end of your file.
+  #
+  # In your file, it will look like this:
+  #
+  # module BookKeeping
+  #   VERSION = 1 # Where the version number matches the one in the test.
+  # end
+  #
+  # If you are curious, read more about constants on RubyDoc:
+  # http://ruby-doc.org/docs/ruby-doc-bundle/UsersGuide/rg/constants.html
+
+  def test_bookkeeping
+    skip
+    assert_equal 1, BookKeeping::VERSION
+  end
+end

data/tracks/rust/config.json

@@ -447,6 +447,18 @@
         "Option"
       ]
     },
+    {
+      "uuid": "dd74b65c-0d26-4821-9add-064e32e3a5bd",
+      "slug": "binary-search",
+      "core": false,
+      "unlocked_by": null,
+      "difficulty": 4,
+      "topics": [
+        "slices",
+        "trait (optional)",
+        "Option"
+      ]
+    },
     {
       "uuid": "1beb8b0c-d06d-4569-80e5-866ed01a7a66",
       "slug": "robot-simulator",

data/tracks/rust/exercises/binary-search/.meta/hints.md

@@ -0,0 +1,38 @@
+## Restrictions
+
+Rust provides in its standard library already a
+[binary search function](https://doc.rust-lang.org/std/primitive.slice.html#method.binary_search).
+For this exercise you should not use this function but just other basic tools instead.
+
+## Hints
+
+[Slices](https://doc.rust-lang.org/book/second-edition/ch04-03-slices.html) have additionally to
+the normal element access via indexing (slice[index]) many useful functions like
+[split_at](https://doc.rust-lang.org/std/primitive.slice.html#method.split_at) or [getting
+subslices](https://doc.rust-lang.org/std/primitive.slice.html#method.get) (slice[start..end]).
+
+You can solve this exercise by just using boring old element access via indexing, but maybe the
+other provided functions can make your code cleaner and safer.
+
+## For bonus points
+
+Did you get the tests passing and the code clean? If you want to, there
+are some additional things you could try.
+
+- Currently your find function will probably only work for slices of numbers,
+  but the Rust type system is flexible enough to create a find function which
+  works on all slices which contains elements which can be ordered.
+- Additionally this find function can work not only on slices, but at the
+  same time also on a Vec or an Array.
+
+You can find tests (commented out) for these bonus tasks in the test file.
+
+Then please share your thoughts in a comment on the submission. Did this
+experiment make the code better? Worse? Did you learn anything from it?
+
+### Hints for Bonus Points
+
+- To get your function working with all kind of elements which can be ordered,
+  have a look at the [Ord Trait](https://doc.rust-lang.org/std/cmp/trait.Ord.html).
+- To get your function working directly on Vec and Array, you can use the
+  [AsRef Trait](https://doc.rust-lang.org/std/convert/trait.AsRef.html)

data/tracks/rust/exercises/binary-search/Cargo.lock

@@ -0,0 +1,4 @@
+[root]
+name = "binary-search"
+version = "1.0.0"
+

data/tracks/rust/exercises/binary-search/Cargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "binary-search"
+version = "1.0.0"
+authors = ["<marco.stahl@mailbox.org>"]
+
+[dependencies]

data/tracks/rust/exercises/binary-search/README.md

@@ -0,0 +1,113 @@
+# Binary Search
+
+Implement a binary search algorithm.
+
+Searching a sorted collection is a common task. A dictionary is a sorted
+list of word definitions. Given a word, one can find its definition. A
+telephone book is a sorted list of people's names, addresses, and
+telephone numbers. Knowing someone's name allows one to quickly find
+their telephone number and address.
+
+If the list to be searched contains more than a few items (a dozen, say)
+a binary search will require far fewer comparisons than a linear search,
+but it imposes the requirement that the list be sorted.
+
+In computer science, a binary search or half-interval search algorithm
+finds the position of a specified input value (the search "key") within
+an array sorted by key value.
+
+In each step, the algorithm compares the search key value with the key
+value of the middle element of the array.
+
+If the keys match, then a matching element has been found and its index,
+or position, is returned.
+
+Otherwise, if the search key is less than the middle element's key, then
+the algorithm repeats its action on the sub-array to the left of the
+middle element or, if the search key is greater, on the sub-array to the
+right.
+
+If the remaining array to be searched is empty, then the key cannot be
+found in the array and a special "not found" indication is returned.
+
+A binary search halves the number of items to check with each iteration,
+so locating an item (or determining its absence) takes logarithmic time.
+A binary search is a dichotomic divide and conquer search algorithm.
+
+## Restrictions
+
+Rust provides in its standard library already a
+[binary search function](https://doc.rust-lang.org/std/primitive.slice.html#method.binary_search).
+For this exercise you should not use this function but just other basic tools instead.
+
+## Hints
+
+[Slices](https://doc.rust-lang.org/book/second-edition/ch04-03-slices.html) have additionally to
+the normal element access via indexing (slice[index]) many useful functions like
+[split_at](https://doc.rust-lang.org/std/primitive.slice.html#method.split_at) or [getting
+subslices](https://doc.rust-lang.org/std/primitive.slice.html#method.get) (slice[start..end]).
+
+You can solve this exercise by just using boring old element access via indexing, but maybe the
+other provided functions can make your code cleaner and safer.
+
+## For bonus points
+
+Did you get the tests passing and the code clean? If you want to, there
+are some additional things you could try.
+
+- Currently your find function will probably only work for slices of numbers,
+  but the Rust type system is flexible enough to create a find function which
+  works on all slices which contains elements which can be ordered.
+- Additionally this find function can work not only on slices, but at the
+  same time also on a Vec or an Array.
+
+You can find tests (commented out) for these bonus tasks in the test file.
+
+Then please share your thoughts in a comment on the submission. Did this
+experiment make the code better? Worse? Did you learn anything from it?
+
+### Hints for Bonus Points
+
+- To get your function working with all kind of elements which can be ordered,
+  have a look at the [Ord Trait](https://doc.rust-lang.org/std/cmp/trait.Ord.html).
+- To get your function working directly on Vec and Array, you can use the
+  [AsRef Trait](https://doc.rust-lang.org/std/convert/trait.AsRef.html)
+
+
+## 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/rust](https://github.com/exercism/rust) 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/docs/blob/master/contributing-to-language-tracks/README.md).
+
+[help-page]: http://exercism.io/languages/rust
+[crates-and-modules]: http://doc.rust-lang.org/stable/book/crates-and-modules.html
+
+## Source
+
+Wikipedia [http://en.wikipedia.org/wiki/Binary_search_algorithm](http://en.wikipedia.org/wiki/Binary_search_algorithm)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/rust/exercises/binary-search/example.rs

@@ -0,0 +1,29 @@
+use std::cmp::Ordering;
+
+pub fn find<C, T>(elements: C, needle: T) -> Option<usize>
+    where
+        C: AsRef<[T]>,
+        T: Ord,
+
+{
+    let mut base = 0usize;
+    let mut slice: &[T] = elements.as_ref();
+
+    loop {
+        let (head, tail) = slice.split_at(slice.len() >> 1);
+        if let Some(middle_element) = tail.first() {
+            match middle_element.cmp(&needle) {
+                Ordering::Less => {
+                    base += head.len() + 1;
+                    slice = &tail[1..];
+                }
+                Ordering::Greater => slice = head,
+                Ordering::Equal => {
+                    return Some(base + head.len());
+                }
+            }
+        } else {
+            return None;
+        }
+    }
+}