trackler 2.0.6.10 → 2.0.6.11

data/tracks/lua/exercises/luhn/luhn_spec.lua

@@ -1,51 +1,24 @@
-local Luhn = require('luhn')
+local luhn = require('luhn')
 
 describe('luhn', function()
-  it('should give the last digit of a number as the check digit', function()
-    assert.equal(7, Luhn.new('34567'):check_digit())
-    assert.equal(0, Luhn.new('91370'):check_digit())
+  it('should indicate that single digits are invalid', function()
+    assert.equal(false, luhn.valid('1'))
+    assert.equal(false, luhn.valid('0'))
   end)
 
-  it('should determine the addends of a value', function()
-    local luhn = Luhn.new('12121')
-    assert.same({ 1, 4, 1, 4, 1 }, luhn:addends())
+  it('should check a valid Canadian SIN', function()
+    assert.equal(true, luhn.valid('046 454 286'))
   end)
 
-  it('should subtract 9 from any addends >9', function()
-    local luhn = Luhn.new('8631')
-    assert.same({ 7, 6, 6, 1 }, luhn:addends())
+  it('should check an invalid Canadian SIN', function()
+    assert.equal(false, luhn.valid('046 454 287'))
   end)
 
-  it('should calculate the checksum of a number by summing the addends', function()
-    assert.equal(22, Luhn.new('4913'):checksum())
-    assert.equal(21, Luhn.new('201773'):checksum())
+  it('should check an invalid credit card', function()
+    assert.equal(false, luhn.valid('8273 1232 7352 0569'))
   end)
 
-  it('should indicate that a number with a checksum indivisible by 0 is not valid', function()
-    local luhn = Luhn.new('738')
-    assert.equal(false, luhn:valid())
-  end)
-
-  it('should indicate that a number with a checksum divisible by 0 is valid', function()
-    local luhn = Luhn.new('8739567')
-    assert.equal(true, luhn:valid())
-  end)
-
-  it('should create valid numbers by appending the correct check digit', function()
-    assert.equal('1230', Luhn.create('123'))
-    assert.equal('8739567', Luhn.create('873956'))
-    assert.equal('8372637564', Luhn.create('837263756'))
-  end)
-
-  it('should support extremely large input', function()
-    local luhn = Luhn.new('34598754109846124372104312349048732432143214732140498237142')
-    assert.equal(2, luhn:check_digit())
-    assert.equal(268, luhn:checksum())
-    assert.equal(false, luhn:valid())
-
-    assert.equal(
-      '345987541098461243721043123490487324321432147321404982371420',
-      Luhn.create('34598754109846124372104312349048732432143214732140498237142')
-    )
+  it('should not allow non-digits', function()
+    assert.equal(false, luhn.valid('a46 454 286'))
   end)
 end)

data/tracks/ocaml/exercises/all-your-base/all_your_base.mli

@@ -1,5 +1,3 @@
-open Core.Std
-
 type base = int
 
 val convert_bases : from: base -> digits: int list -> target: base -> (int list) option

data/tracks/ocaml/exercises/bracket-push/bracket_push.mli

@@ -1,3 +1 @@
-open Core.Std
-
 val are_balanced : string -> bool

data/tracks/ocaml/exercises/luhn/example.ml

@@ -1,20 +1,16 @@
 open Core.Std
 
-let digit character =
-  (int_of_char character) - 48
-
-let rec sum_digits s r c = function
-  | 0 -> r
-  | i ->
-    let d = c * (digit s.[i - 1]) in
-    sum_digits s (r + (d/10) + (d mod 10)) (3-c) (i-1)
-
-let checksum s =
-  (sum_digits s 0 1 (String.length s))
+let every_second_digit_doubled =
+  let double_digit n = let d = n * 2 in if d >= 10 then d - 9 else d in
+  List.rev_mapi ~f:(fun i -> if i % 2 = 1 then double_digit else Fn.id)
 
 let valid s =
-  (checksum s) mod 10 = 0
-
-let add_check_digit s =
-  let check = ((sum_digits s 0 2 (String.length s)) mod 10) in
-  String.concat ~sep:"" [s; (string_of_int ((10 - check) mod 10))]
+  let s = String.filter s ~f:(fun ch -> ch <> ' ') in
+  if String.length s > 1
+  then
+    let checksum = String.to_list s
+    |> List.rev_map ~f:(fun ch -> Char.to_int ch - Char.to_int '0')
+    |> every_second_digit_doubled
+    |> List.sum (module Int) ~f:Fn.id in
+    checksum % 10 = 0
+  else false

data/tracks/ocaml/exercises/luhn/luhn.mli

@@ -1,3 +1,2 @@
-val checksum: string -> int
+(* Returns true if the input is a valid Luhn string *)
 val valid : string -> bool
-val add_check_digit: string -> string

data/tracks/ocaml/exercises/luhn/test.ml

@@ -2,20 +2,23 @@ open Core.Std
 open OUnit2
 open Luhn
 
-let ae exp got _test_ctxt = assert_equal exp got
+let assert_valid expected input _test_ctxt = 
+  assert_equal ~printer:Bool.to_string expected (valid input)
 
 let tests = [
-  "checksum of 4913"          >:: ae 22 (checksum "4913");
-  "checksum of 201773"        >:: ae 21 (checksum "201773");
-  "invalid number 1111"       >:: ae false (valid "1111");
-  "invalid number 738"        >:: ae false (valid "738");
-  "valid number 8739567"      >:: ae true (valid "8739567");
-  "valid number 8763"         >:: ae true (valid "8763");
-  "valid number long"         >:: ae true (valid "2323200577663554");
-  "create valid number"       >:: ae "1230" (add_check_digit "123");
-  "create large valid number" >:: ae "8739567" (add_check_digit "873956");
-  "even larger valid number"  >:: ae "8372637564" (add_check_digit "837263756");
+  "single digit strings are not valid" >::
+    assert_valid false "1";
+  "A single zero is invalid" >::
+    assert_valid false "0";
+  "valid Canadian SIN" >::
+    assert_valid true "046 454 286";
+  "invalid Canadian SIN" >::
+    assert_valid false "046 454 287";
+  "invalid credit card" >::
+    assert_valid false "8273 1232 7352 0569";
+  "strings that contain non-digits are not valid" >::
+    assert_valid false "827a 1232 7352 0569";
 ]
 
 let () =
-  run_test_tt_main ("luhn tests" >::: tests)
+  run_test_tt_main ("luhn tests" >::: tests)

data/tracks/php/config.json

@@ -307,6 +307,14 @@
     "slug": "markdown",
     "difficulty": 3,
     "topics": ["refactoring"]
+  },
+  {
+    "slug": "grains",
+    "difficulty": 3,
+    "topics": [
+      "Floating-point numbers",
+      "Algorithms"
+    ]
   }
   ]
 }

data/tracks/php/exercises/grains/example.php

@@ -0,0 +1,63 @@
+<?php
+
+/**
+ *
+Here is the simplest solution. But King hates floats.
+
+function square($n)
+{
+    if ($n < 1 || $n > 64) {
+        throw new InvalidArgumentException();
+    }
+    return pow(2, $n - 1);
+}
+
+function total()
+{
+    return array_reduce(range(1, 64), function ($acc, $n) {
+        return $acc += square($n);
+    });
+}
+ */
+
+function square($n)
+{
+    if ($n < 1 || $n > 64) {
+        throw new InvalidArgumentException();
+    }
+
+    $result = [1];
+    for ($i = $n - 1; $i > 0; $i--) {
+        $result = sum($result, $result);
+    }
+
+    return implode('', array_reverse($result));
+}
+
+function total()
+{
+    return implode('', array_reverse(
+        array_reduce(range(1, 64), function ($acc, $n) {
+            return sum($acc, array_reverse(str_split(square($n))));
+        }, [])
+    ));
+}
+
+function sum($x, $y)
+{
+    $shift = 0;
+    $result = array_map(function ($a, $b) use (&$shift) {
+        $value = $a + $b + $shift;
+        if ($value >= 10) {
+            $value -= 10;
+            $shift = 1;
+        } else {
+            $shift = 0;
+        }
+        return $value;
+    }, $x, $y);
+    if ($shift) {
+        array_push($result, $shift);
+    }
+    return $result;
+}

data/tracks/php/exercises/grains/grains_test.php

@@ -0,0 +1,82 @@
+<?php
+
+include_once 'grains.php';
+
+class GrainsTest extends PHPUnit_Framework_TestCase
+{
+    /**
+     * PHP integers greater than 2^31 (32-bit systems)
+     * or 2^63 (64-bit) are casted to floats.
+     * In some cases it may lead to problems
+     * http://php.net/manual/ru/language.types.float.php#warn.float-precision
+     *
+     * Consider King hates floats and demands solution with
+     * precise integer-only calculations. Don't involve any floats.
+     * Don't use gmp or any other similar libraries.
+     * Try to make the solution for virtually any board size.
+     */
+
+    public function testInput1()
+    {
+        $this->assertSame('1', square(1));
+    }
+
+    public function testInput2()
+    {
+        $this->assertSame('2', square(2));
+    }
+
+    public function testInput3()
+    {
+        $this->assertSame('4', square(3));
+    }
+
+    public function testInput4()
+    {
+        $this->assertSame('8', square(4));
+    }
+
+    public function testInput16()
+    {
+        $this->assertSame('32768', square(16));
+    }
+
+    public function testInput32()
+    {
+        $this->assertSame('2147483648', square(32));
+    }
+
+    public function testInput64()
+    {
+        $this->assertSame('9223372036854775808', square(64));
+    }
+
+    /**
+     * @expectedException InvalidArgumentException
+     */
+    public function testRejectsZero()
+    {
+        square(0);
+    }
+
+    /**
+     * @expectedException InvalidArgumentException
+     */
+    public function testRejectsNegative()
+    {
+        square(-1);
+    }
+
+    /**
+     * @expectedException InvalidArgumentException
+     */
+    public function testRejectsGreaterThan64()
+    {
+        square(65);
+    }
+
+    public function testTotal()
+    {
+        $this->assertSame('18446744073709551615', total());
+    }
+}

data/tracks/pony/config.json

@@ -3,53 +3,65 @@
   "language": "Pony",
   "repository": "https://github.com/exercism/xpony",
   "active": false,
-  "test_pattern": "TODO",
-  "deprecated": [
-
-  ],
   "ignored": [
     "bin",
     "docs",
     "img"
-  ],
-  "foregone": [
-
   ],
   "exercises": [
     {
       "difficulty": 1,
       "slug": "hello-world",
-      "topics": []
+      "topics": [
+        "strings",
+        "default arguments"
+      ]
     },
     {
       "difficulty": 1,
       "slug": "difference-of-squares",
-      "topics": []
+      "topics": [
+        "iterators"
+      ]
     },
     {
       "difficulty": 1,
       "slug": "bob",
-      "topics": []
+      "topics": [
+        "strings"
+      ]
     },
     {
       "difficulty": 1,
       "slug": "hamming",
-      "topics": []
+      "topics": [
+        "errors"
+      ]
     },
     {
       "difficulty": 1,
       "slug": "leap",
-      "topics": []
+      "topics": [
+        "math",
+        "booleans"
+      ]
     },
     {
       "difficulty": 1,
       "slug": "anagram",
-      "topics": []
+      "topics": [
+        "reference capabilities",
+        "strings"
+      ]
     },
     {
       "difficulty": 1,
       "slug": "rna-transcription",
-      "topics": []
+      "topics": [
+        "strings",
+        "errors",
+        "iterators"
+      ]
     }
   ]
 }

data/tracks/pony/exercises/anagram/example.pony

@@ -1,73 +1,17 @@
-use "ponytest"
-
-class Anagram
-
-  fun apply(word: String, phrase: Array[String]): Array[String] ?  =>
-    let anagrams: Array[String] = Array[String]
-    let word_array: Array[U8] = _to_array_and_order(word.lower())
-
-
-    for (index, value) in phrase.pairs() do
-      let value_array: Array[U8] = _to_array_and_order(value.lower())
-
-      if value.size() != word.size() then continue end
-      if value.lower() == word.lower() then continue end
-      if _check_array_eq(word_array, value_array) then
-        anagrams.push(value)
-      end
-    end
-
-    anagrams
-
-  fun _to_array_and_order(word: String): Array[U8] ? =>
-    // As of right now the String.split() function doesn't appear to work
-    // on no delimiter, i.e. "abcd".split("") to ["a", "b", "c", "d"]
-    // So I pull of the bytes
-
-    let word_array: Array[U8] = Array[U8]
-    let sorted_array: Array[U8] = Array[U8]
-
-    for value in word.values() do
-      word_array.push(value)
-    end
-
-
-    for (index, value) in word_array.pairs() do
-      var inserted = false
-      if (index == 0) then sorted_array.push(value) end
-      if (index > 0) then
-        for (i, v) in sorted_array.pairs() do
-          if value <= v then
-            sorted_array.insert(i, value)
-            inserted = true
-            break
-          end
-        end
-        if not inserted then
-          sorted_array.push(value)
-          inserted = false
-        end
-      end
-    end
-
-    sorted_array
-
-  // https://github.com/ponylang/ponyc/blob/master/packages/ponytest/helper.pony#L163-L188
-  // there isn't a join function as of 2.1, and Array doesn't support eq()
-  fun _check_array_eq(expect: Array[U8], actual: Array[U8]): Bool ? =>
-    var ok = true
-
-    if expect.size() != actual.size() then
-      ok = false
-    else
-      var i: USize = 0
-      while i < expect.size() do
-        if expect(i) != actual(i) then
-          ok = false
-          break
-        end
-
-        i = i + 1
-      end
-    end
-    ok
+use "collections"
+use "itertools"
+
+primitive Anagram
+  fun apply(word: String, phrase: Array[String]): Array[String] =>
+    let lower: String = word.lower()
+    let sorted = _strsort(lower)
+
+    Iter[String](phrase.values())
+      .filter({(s: String)(lower, sorted): Bool =>
+        let lower': String = s.lower()
+        (lower != lower') and (sorted == Anagram._strsort(lower'))
+      })
+      .collect[Array[String] iso](recover Array[String] end)
+
+  fun _strsort(s: String): String =>
+    String.from_array(recover Sort[Array[U8], U8](s.array().clone()) end)