trackler 2.0.3.2 → 2.0.3.3

data/tracks/java/exercises/binary-search/build.gradle

@@ -0,0 +1,17 @@
+apply plugin: "java"
+apply plugin: "eclipse"
+apply plugin: "idea"
+
+repositories {
+  mavenCentral()
+}
+
+dependencies {
+  testCompile "junit:junit:4.12"
+}
+test {
+  testLogging {
+    exceptionFormat = 'full'
+    events = ["passed", "failed", "skipped"]
+  }
+}

data/tracks/java/exercises/binary-search/src/example/java/BinarySearch.java

@@ -0,0 +1,40 @@
+
+import java.util.List;
+
+public class BinarySearch<T extends Comparable<T>> {
+
+    private List<T> array;
+    private int arraySize;
+
+    public BinarySearch(List<T> array) {
+        this.array = array;
+        this.arraySize = array.size();
+    }
+
+    public int indexOf(T value) {
+        return search(value);
+    }
+
+    public List<T> getArray() {
+        return array;
+    }
+
+    private int search(T value) {
+        int left = 0;
+        int right = this.arraySize - 1;
+        int middle;
+        T element;
+        while (left <= right) {
+            middle = (int) Math.floor(0.5 * (left + right));
+            element = this.array.get(middle);
+            if (value.compareTo(element) > 0) {
+                left = middle + 1;
+            } else if (value.compareTo(element) < 0) {
+                right = middle - 1;
+            } else {
+                return middle;
+            }
+        }
+        return -1;
+    }
+}

data/tracks/java/exercises/binary-search/src/main/java/BinarySearch.java

@@ -0,0 +1,4 @@
+
+public class BinarySearch {
+
+}

data/tracks/java/exercises/binary-search/src/test/java/BinarySearchTest.java

@@ -0,0 +1,136 @@
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import static org.junit.Assert.assertEquals;
+import org.junit.Ignore;
+import org.junit.Test;
+
+public class BinarySearchTest {
+
+    public static final List<Integer> EMPTY_LIST
+            = Collections.unmodifiableList(new ArrayList<Integer>(0));
+
+    public static final List<Integer> LIST_OF_UNIT_LENGTH
+            = Collections.unmodifiableList(
+                    Arrays.asList(6)
+            );
+
+    private static final List<Integer> SORTED_LIST
+            = Collections.unmodifiableList(
+                    Arrays.asList(1, 3, 4, 6, 8, 9, 11)
+            );
+
+    public static final List<Integer> SORTED_LIST_OF_ODD_LENGTH
+            = Collections.unmodifiableList(
+                    Arrays.asList(1, 3, 5, 8, 13, 21, 34, 55,
+                            89, 144, 233, 377, 634)
+            );
+
+    public static final List<Integer> SORTED_LIST_OF_EVEN_LENGTH
+            = Collections.unmodifiableList(
+                    Arrays.asList(1, 3, 5, 8, 13, 21, 34, 55,
+                            89, 144, 233, 377)
+            );
+
+    @Test
+    public void findsAValueInAnArrayWithOneElement() {
+        BinarySearch<Integer> sut = new BinarySearch<>(LIST_OF_UNIT_LENGTH);
+        final int value = 6;
+        final int actual = sut.indexOf(value);
+        final int expected = 0;
+        assertEquals(expected, actual);
+    }
+
+    @Ignore
+    @Test
+    public void findsAValueInTheMiddleOfAnArray() {
+        BinarySearch<Integer> sut = new BinarySearch<>(SORTED_LIST);
+        final int value = 6;
+        final int actual = sut.indexOf(value);
+        final int expected = 3;
+        assertEquals(expected, actual);
+    }
+
+    @Ignore
+    @Test
+    public void findsAValueAtTheBeginningOfAnArray() {
+        BinarySearch<Integer> sut = new BinarySearch<>(SORTED_LIST);
+        final int value = 1;
+        final int actual = sut.indexOf(value);
+        final int expected = 0;
+        assertEquals(expected, actual);
+    }
+
+    @Ignore
+    @Test
+    public void findsAValueAtTheEndOfAnArray() {
+        BinarySearch<Integer> sut = new BinarySearch<>(SORTED_LIST);
+        final int value = 11;
+        final int actual = sut.indexOf(value);
+        final int expected = 6;
+        assertEquals(expected, actual);
+    }
+
+    @Ignore
+    @Test
+    public void findsAValueInAnArrayOfOddLength() {
+        BinarySearch<Integer> sut = new BinarySearch<>(SORTED_LIST_OF_ODD_LENGTH);
+        final int value = 144;
+        final int actual = sut.indexOf(value);
+        final int expected = 9;
+        assertEquals(expected, actual);
+    }
+
+    @Ignore
+    @Test
+    public void findsAValueInAnArrayOfEvenLength() {
+        BinarySearch<Integer> sut
+                = new BinarySearch<>(SORTED_LIST_OF_EVEN_LENGTH);
+        final int value = 21;
+        final int actual = sut.indexOf(value);
+        final int expected = 5;
+        assertEquals(expected, actual);
+    }
+
+    @Ignore
+    @Test
+    public void identifiesThatAValueIsNotIncludedInTheArray() {
+        BinarySearch<Integer> sut = new BinarySearch<>(SORTED_LIST);
+        final int value = 7;
+        final int actual = sut.indexOf(value);
+        final int expected = -1;
+        assertEquals(expected, actual);
+    }
+
+    @Ignore
+    @Test
+    public void aValueSmallerThanTheArraysSmallestValueIsNotIncluded() {
+        BinarySearch<Integer> sut = new BinarySearch<>(SORTED_LIST);
+        final int value = 0;
+        final int actual = sut.indexOf(value);
+        final int expected = -1;
+        assertEquals(expected, actual);
+    }
+
+    @Ignore
+    @Test
+    public void aValueLargerThanTheArraysSmallestValueIsNotIncluded() {
+        BinarySearch<Integer> sut = new BinarySearch<>(SORTED_LIST);
+        final int value = 13;
+        final int actual = sut.indexOf(value);
+        final int expected = -1;
+        assertEquals(expected, actual);
+    }
+
+    @Ignore
+    @Test
+    public void nothingIsIncludedInAnEmptyArray() {
+        BinarySearch<Integer> sut = new BinarySearch<>(EMPTY_LIST);
+        final int value = 1;
+        final int actual = sut.indexOf(value);
+        final int expected = -1;
+        assertEquals(expected, actual);
+    }
+}

data/tracks/java/exercises/settings.gradle

@@ -1,5 +1,6 @@
 include 'accumulate'
 include 'acronym'
+include 'all-your-base'
 include 'allergies'
 include 'anagram'
 include 'atbash-cipher'

data/tracks/lua/config.json

@@ -558,6 +558,14 @@
       "control-flow (if-else statements)",
       "control-flow (loops)"
     ]
+  }, {
+    "slug": "say",
+    "difficulty": 7,
+    "topics": [
+      "strings",
+      "text formatting",
+      "control-flow (loops)"
+    ]
   }, {
     "slug": "pov",
     "difficulty": 9,
@@ -575,6 +583,14 @@
       "control-flow (if-else statements)",
       "control-flow (loops)"
     ]
+  }, {
+    "slug": "secret-handshake",
+    "difficulty": 3,
+    "topics": [
+      "control-flow (if-else statements)",
+      "arrays",
+      "bitwise operations"
+    ]
   }],
   "deprecated": [
 

data/tracks/lua/exercises/say/example.lua

@@ -0,0 +1,92 @@
+local ones = {
+  [1] = 'one',
+  [2] = 'two',
+  [3] = 'three',
+  [4] = 'four',
+  [5] = 'five',
+  [6] = 'six',
+  [7] = 'seven',
+  [8] = 'eight',
+  [9] = 'nine'
+}
+
+local teens = {
+  [10] = 'ten',
+  [11] = 'eleven',
+  [12] = 'twelve',
+  [13] = 'thirteen',
+  [14] = 'fourteen',
+  [15] = 'fifteen',
+  [16] = 'sixteen',
+  [17] = 'seventeen',
+  [18] = 'eighteen',
+  [19] = 'nineteen',
+}
+
+local tens = {
+  [2] = 'twenty',
+  [3] = 'thirty',
+  [4] = 'forty',
+  [5] = 'fifty',
+  [6] = 'sixty',
+  [7] = 'seventy',
+  [8] = 'eighty',
+  [9] = 'ninety'
+}
+
+local group_name = {
+  'thousand',
+  'million',
+  'billion'
+}
+
+local function say_group(n)
+  local said = ''
+
+  if n // 100 > 0 then
+    said = said .. ones[n // 100] .. ' hundred'
+    n = n - (n // 100) * 100
+    if n > 0 then said = said .. ' ' end
+  end
+
+  if tens[n // 10] then
+    said = said .. tens[n // 10]
+    n = n - (n // 10) * 10
+    if n > 0 then said = said .. '-' end
+  end
+
+  if teens[n] then
+    said = said .. teens[n]
+  elseif ones[n] then
+    said = said .. ones[n]
+  end
+
+  return said
+end
+
+return function(n)
+  if n < 0 or n > 999999999999 then return -1 end
+
+  local blahs = {}
+  local group_index = 0
+
+  while n > 0 do
+    local group = say_group(n % 1000)
+
+    if group ~= '' then
+      if group_name[group_index] then
+        group = group .. ' ' .. group_name[group_index]
+      end
+      table.insert(blahs, 1, group)
+    end
+
+    n = n // 1000
+    group_index = group_index + 1
+  end
+
+  if #blahs == 0 then
+    return 'zero'
+  else
+    return table.concat(blahs, ' ')
+  end
+end

data/tracks/lua/exercises/say/say_spec.lua

@@ -0,0 +1,105 @@
+-- Workaround for the fact busted has a built-in called 'say'
+local say = loadfile 'say.lua'()
+
+describe('say', function()
+  it('should say 0', function()
+    assert.are.equal('zero', say(0))
+  end)
+
+  it('should say 1', function()
+    assert.are.equal('one', say(1))
+  end)
+
+  it('should say 14', function()
+    assert.are.equal('fourteen', say(14))
+  end)
+
+  it('should say 20', function()
+    assert.are.equal('twenty', say(20))
+  end)
+
+  it('should say 22', function()
+    assert.are.equal('twenty-two', say(22))
+  end)
+
+  it('should say 100', function()
+    assert.are.equal('one hundred', say(100))
+  end)
+
+  it('should say 123', function()
+    assert.are.equal('one hundred twenty-three', say(123))
+  end)
+
+  it('should say 1,000', function()
+    assert.are.equal('one thousand', say(1000))
+  end)
+
+  it('should say 1,234', function()
+    assert.are.equal('one thousand two hundred thirty-four', say(1234))
+  end)
+
+  it('should say 1,000,000', function()
+    assert.are.equal('one million', say(1000000))
+  end)
+
+  it('should say 1,002,345', function()
+    assert.are.equal('one million two thousand three hundred forty-five', say(1002345))
+  end)
+
+  it('should say 1,000,000,000', function()
+    assert.are.equal('one billion', say(1000000000))
+  end)
+
+  it('should say very large numbers', function()
+    assert.are.equal(
+      'nine hundred eighty-seven billion six hundred fifty-four million three hundred twenty-one thousand one hundred twenty-three',
+      say(987654321123)
+    )
+  end)
+
+  it('should say all ones', function()
+    assert.are.equal('one', say(1))
+    assert.are.equal('two', say(2))
+    assert.are.equal('three', say(3))
+    assert.are.equal('four', say(4))
+    assert.are.equal('five', say(5))
+    assert.are.equal('six', say(6))
+    assert.are.equal('seven', say(7))
+    assert.are.equal('eight', say(8))
+    assert.are.equal('nine', say(9))
+  end)
+
+  it('should say all teens', function()
+    assert.are.equal('ten', say(10))
+    assert.are.equal('eleven', say(11))
+    assert.are.equal('twelve', say(12))
+    assert.are.equal('thirteen', say(13))
+    assert.are.equal('fourteen', say(14))
+    assert.are.equal('fifteen', say(15))
+    assert.are.equal('sixteen', say(16))
+    assert.are.equal('seventeen', say(17))
+    assert.are.equal('eighteen', say(18))
+    assert.are.equal('nineteen', say(19))
+  end)
+
+  it('should say all tens', function()
+    assert.are.equal('twenty', say(20))
+    assert.are.equal('thirty', say(30))
+    assert.are.equal('forty', say(40))
+    assert.are.equal('fifty', say(50))
+    assert.are.equal('sixty', say(60))
+    assert.are.equal('seventy', say(70))
+    assert.are.equal('eighty', say(80))
+    assert.are.equal('ninety', say(90))
+  end)
+
+  it('should not say negative numbers', function()
+    assert.are.equal(-1, say(-1))
+    assert.are.equal(-1, say(-5))
+  end)
+
+  it('should not say numbers above 999,999,999,999', function()
+    assert.are.equal(-1, say(1000000000000))
+    assert.are.equal(-1, say(1000000000005))
+  end)
+end)

data/tracks/lua/exercises/secret-handshake/example.lua

@@ -0,0 +1,17 @@
+local function reverse(t)
+  local reversed = {}
+  for i = #t, 1, -1 do
+    table.insert(reversed, t[i])
+  end
+  return reversed
+end
+
+return function(n)
+  local handshake = {}
+  if n & 1 > 0 then table.insert(handshake, 'wink') end
+  if n & 2 > 0 then table.insert(handshake, 'double blink') end
+  if n & 4 > 0 then table.insert(handshake, 'close your eyes') end
+  if n & 8 > 0 then table.insert(handshake, 'jump') end
+  if n & 16 > 0 then handshake = reverse(handshake) end
+  return handshake
+end