trackler 2.2.1.138 → 2.2.1.139

data/tracks/nim/exercises/bob/README.md

@@ -6,6 +6,8 @@ Bob answers 'Sure.' if you ask him a question.
 
 He answers 'Whoa, chill out!' if you yell at him.
 
+He answers 'Calm down, I know what I'm doing!' if you yell a question at him.
+
 He says 'Fine. Be that way!' if you address him without actually saying
 anything.
 

data/tracks/nim/exercises/bob/bob_test.nim

@@ -1,19 +1,27 @@
 import unittest
-from bob import hey
+
+import bob
 
 suite "hey tests":
+
   test "stating something":
     check hey("Tom-ay-to, tom-aaaah-to.") == "Whatever."
 
   test "shouting":
     check hey("WATCH OUT!") == "Whoa, chill out!"
 
+  test "shouting gibberish":
+    check hey("FCECDFCAAB") == "Whoa, chill out!"
+
   test "asking a question":
     check hey("Does this cryogenic chamber make me look fat?") == "Sure."
 
   test "asking a numeric question":
     check hey("You are, what, like 15?") == "Sure."
 
+  test "asking a numeric question":
+    check hey("fffbbcbeab?") == "Sure."
+
   test "talking forcefully":
     check hey("Let's go make out behind the gym!") == "Whatever."
 
@@ -33,13 +41,7 @@ suite "hey tests":
     check hey("4?") == "Sure."
 
   test "shouting with special characters":
-    check hey("ZOMG THE %^*@#$(^ ZOMBIES ARE COMING!!1!") == "Whoa, chill out!"
-
-  test "shouting with umlauts":
-    check hey("ÜMLÄÜTS!") == "Whoa, chill out!"
-
-  test "calmly speaking with umlauts":
-    check hey("Ümläüts!") == "Whatever."
+    check hey("ZOMG THE %^*@#$(*^ ZOMBIES ARE COMING!!11!!1!") == "Whoa, chill out!"
 
   test "shouting with no exclamation mark":
     check hey("I HATE YOU") == "Whoa, chill out!"
@@ -47,6 +49,9 @@ suite "hey tests":
   test "statement containing question mark":
     check hey("Ending with ? means a question.") == "Whatever."
 
+  test "non-letters with question":
+    check hey(":) ?") == "Sure."
+
   test "prattling on":
     check hey("Wait! Hang on. Are you going to be OK?") == "Sure."
 
@@ -54,10 +59,23 @@ suite "hey tests":
     check hey("") == "Fine. Be that way!"
 
   test "prolonged silence":
-    check hey("    ") == "Fine. Be that way!"
+    check hey("          ") == "Fine. Be that way!"
+
+  test "alternate silence":
+    check hey("\t\t\t\t\t\t\t\t\t\t") == "Fine. Be that way!"
+
+  test "multiple line question":
+    check hey("\nDoes this cryogenic chamber make me look fat?\nno") == "Whatever."
+
+  test "starting with whitespace":
+    check hey("         hmmmmmmm...") == "Whatever."
+
+  test "ending with whitespace":
+    check hey("Okay if like my  spacebar  quite a bit?   ") == "Sure."
+
+  test "other whitespace":
+    check hey("\n\r \t") == "Fine. Be that way!"
 
-  test "really prolonged silence":
-    check hey("              \t\n") == "Fine. Be that way!"
+  test "non-question ending with whitespace":
+    check hey("This is a statement ending with whitespace      ") == "Whatever."
 
-  test "multi line trick question":
-    check hey("Do I ever change my mind?\nNo.") == "Whatever."

data/tracks/nim/exercises/bob/example.nim

@@ -1,4 +1,4 @@
-from strutils import endsWith
+from strutils import endsWith, strip
 from unicode import isLower, isUpper, isWhiteSpace, runes
 
 proc isSilence(s: string): bool =
@@ -17,7 +17,7 @@ proc isYelling(s: string): bool =
   return nUpperRunes > 0
 
 proc isQuestion(s: string): bool =
-  return s.endsWith("?")
+  return s.strip().endsWith("?")
 
 proc hey*(msg: string): string {.noSideEffect.} =
   ## Returns the response of a lackadaisical teenager to a futile attempt to

data/tracks/nim/exercises/gigasecond/README.md

@@ -0,0 +1,22 @@
+# Gigasecond
+
+Calculate the moment when someone has lived for 10^9 seconds.
+
+A gigasecond is 10^9 (1,000,000,000) seconds.
+
+## Submitting Exercises
+
+Note that, when trying to submit an exercise, make sure the solution is in the `$EXERCISM_WORKSPACE/nim/gigasecond` directory.
+
+You can find your Exercism workspace by running `exercism debug` and looking for the line that starts with `Workspace`.
+
+For more detailed information about running tests, code style and linting,
+please see the [help page](http://exercism.io/languages/nim).
+
+## 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 Solutions
+
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/nim/exercises/gigasecond/example.nim

@@ -0,0 +1,4 @@
+import times
+
+proc add_gigasecond*(date: DateTime): DateTime =
+    date + initInterval(seconds=1_000_000_000)

data/tracks/nim/exercises/gigasecond/gigasecond_test.nim

@@ -0,0 +1,32 @@
+import unittest, times
+
+import gigasecond
+
+suite "Gigasecond":
+
+    test "date only specification of time":
+        let birthday = initDateTime(25, mApr, 2011, 0, 0, 0, utc())
+        let expected = initDateTime(1, mJan, 2043, 1, 46, 40, utc())
+        check add_gigasecond(birthday) == expected
+
+    test "second test for date only specification of time":
+        let birthday = initDateTime(13, mJun, 1977, 0, 0, 0, utc())
+        let expected = initDateTime(19, mFeb, 2009, 1, 46, 40, utc())
+        check add_gigasecond(birthday) == expected
+
+    test "third test for date only specification of time":
+        let birthday = initDateTime(19, mJul, 1959, 0, 0, 0, utc())
+        let expected = initDateTime(27, mMar, 1991, 1, 46, 40, utc())
+        check add_gigasecond(birthday) == expected
+
+    test "full time specified":
+        let birthday = initDateTime(24, mJan, 2015, 22, 0, 0, utc())
+        let expected = initDateTime(2, mOct, 2046, 23, 46, 40, utc())
+        check add_gigasecond(birthday) == expected
+
+    test "full time with day roll-over":
+        let birthday = initDateTime(24, mJan, 2015, 23, 59, 59, utc())
+        let expected = initDateTime(3, mOct, 2046, 1, 46, 39, utc())
+        check add_gigasecond(birthday) == expected
+
+

data/tracks/nim/exercises/isogram/README.md

@@ -0,0 +1,20 @@
+# Isogram
+
+Determine if a word or phrase is an isogram.
+
+An isogram (also known as a "nonpattern word") is a word or phrase without a repeating letter, however spaces and hyphens are allowed to appear multiple times.
+
+Examples of isograms:
+
+- lumberjacks
+- background
+- downstream
+- six-year-old
+
+The word *isograms*, however, is not an isogram, because the s repeats.
+## Source
+
+Wikipedia [https://en.wikipedia.org/wiki/Isogram](https://en.wikipedia.org/wiki/Isogram)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/nim/exercises/isogram/example.nim

@@ -0,0 +1,6 @@
+import
+  sequtils, sets, strutils
+
+proc isIsogram*(phrase: string): bool =
+  let characters_lower = phrase.filterIt(it.isAlphaAscii()).mapIt(it.toLowerAscii)
+  len(toSet(characters_lower)) == len(characters_lower)

data/tracks/nim/exercises/isogram/isogram_test.nim

@@ -0,0 +1,32 @@
+import unittest
+
+import isogram
+
+suite "Isogram":
+
+  test "empty string":
+    check isIsogram("") == true
+    
+  test "isogram with only lower case characters":
+    check isIsogram("isogram") == true
+    
+  test "word with one duplicated character":
+    check isIsogram("eleven") == false
+    
+  test "longest reported english isogram":
+    check isIsogram("subdermatoglyphic") == true
+    
+  test "word with duplicated character in mixed case":
+    check isIsogram("Alphabet") == false
+    
+  test "hypothetical isogrammic word with hyphen":
+    check isIsogram("thumbscrew-japingly") == true
+    
+  test "isogram with duplicated hyphen":
+    check isIsogram("six-year-old") == true
+
+  test "made up name that is an isogram":
+    check isIsogram("Emily Jung Schwartzkopf") == true
+
+  test "duplicated character in the middle":
+    check isIsogram("accentor") == false

data/tracks/nim/exercises/space-age/README.md

@@ -0,0 +1,24 @@
+# Space Age
+
+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.69 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).
+## 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 Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/nim/exercises/space-age/example.nim

@@ -0,0 +1,17 @@
+import
+  math, tables
+
+let
+  times = {
+    "Earth": 31558149.76,
+    "Mercury": 7600530.24,
+    "Venus": 19413907.2,
+    "Mars": 59354294.4,
+    "Jupiter": 374335776.0,
+    "Saturn": 929596608.0,
+    "Uranus": 2661041808.0,
+    "Neptune": 5200418592.0
+  }.toTable
+
+proc age*(planet: string, seconds: int64): float =
+  round(seconds.float / times[planet], 2)

data/tracks/nim/exercises/space-age/space_age_test.nim

@@ -0,0 +1,29 @@
+import unittest
+
+import space_age
+
+suite "Space Age":
+
+  test "age on Earth":
+    check age("Earth", 1000000000) == 31.69
+    
+  test "age on Mercury":
+    check age("Mercury", 2134835688) == 280.88
+
+  test "age on Venus":
+    check age("Venus", 189839836) == 9.78
+    
+  test "age on Mars":
+    check age("Mars", 2329871239) == 39.25
+
+  test "age on Jupiter":
+    check age("Jupiter", 901876382) == 2.41
+
+  test "age on Saturn":
+    check age("Saturn", 3000000000) == 3.23
+
+  test "age on Uranus":
+    check age("Uranus", 3210123456) == 1.21
+
+  test "age on Neptune":
+    check age("Neptune", 8210123456) == 1.58

data/tracks/nim/exercises/triangle/example.nim

@@ -1,25 +1,25 @@
-import math
+import sequtils
 
-type
-  TriangleKind* = enum
-    tkEquilateral,
-    tkIsosceles,
-    tkScalene
+proc valid(a, b, c: int): bool =
+    let greatThenZero = all([a, b, c], proc (x: int): bool = return x > 0)
+    let equalityCheck = (a + b >= c) and (a + c >= b) and (b + c >= a)
 
-proc checkInvalidSide(f: float) =
-  let fc = classify(f)
-  if not (fc == fcNormal or fc == fcSubnormal) or f < 0:
-    raise newException(ValueError, "invalid side: " & $f)
+    greatThenZero and equalityCheck
 
-proc kind*(a, b, c: float): TriangleKind =
-  checkInvalidSide(a)
-  checkInvalidSide(b)
-  checkInvalidSide(c)
-  if a + b <= c or a + c <= b or b + c <= a:
-    raise newException(ValueError, "one side is larger than the other two combined")
-  elif a == b and b == c:
-    return tkEquilateral
-  elif a == b or b == c or a == c:
-    return tkIsosceles
-  else:
-    return tkScalene
+proc is_equilateral*(sides: array[3, int]): bool =
+    let a = sides[0]
+    let b = sides[1]
+    let c = sides[2]
+    valid(a, b, c) and all(sides, proc (x: int): bool = return a == x)
+
+proc is_isosceles*(sides: array[3, int]): bool =
+    let a = sides[0]
+    let b = sides[1]
+    let c = sides[2]
+    valid(a, b, c) and (a == b or b == c or a == c)
+
+proc is_scalene*(sides: array[3, int]): bool =
+    let a = sides[0]
+    let b = sides[1]
+    let c = sides[2]
+    valid(a, b, c) and not is_isosceles(sides)

data/tracks/nim/exercises/triangle/triangle_test.nim

@@ -2,64 +2,52 @@ import unittest
 
 import triangle
 
-test "equilateral triangles have equal sides":
-  check kind(2, 2, 2) == tkEquilateral
+suite "returns true if the triangle is equilateral":
 
-test "larger equilateral triangles also have equal sides":
-  check kind(10, 10, 10) == tkEquilateral
+  test "true if all sides are equal":
+      check is_equilateral([2, 2, 2]) == true
 
-test "isosceles triangles have last two sides equal":
-  check kind(3, 4, 4) == tkIsosceles
+  test "false if any side is unequal":
+      check is_equilateral([2, 3, 2]) == false
 
-test "isosceles triangles have first and last sides equal":
-  check kind(4, 3, 4) == tkIsosceles
+  test "false if no sides are equal":
+      check is_equilateral([5, 4, 6]) == false
 
-test "isosceles triangles have two first sides equal":
-  check kind(4, 4, 3) == tkIsosceles
+  test "false if all sides are zero":
+      check is_equilateral([0, 0, 0]) == false
 
-test "isosceles triangles have in fact exactly two sides equal":
-  check kind(10, 10, 2) == tkIsosceles
 
-test "scalene triangles have no equal sides":
-  check kind(3, 4, 5) == tkScalene
+suite "returns true if the triangle is isosceles":
 
-test "scalene triangles have no equal sides at a larger scale too":
-  check kind(10, 11, 12) == tkScalene
+  test "true if last two sides are equal":
+      check is_isosceles([3, 4, 4]) == true
 
-test "scalene triangles have no equal sides in descending order either":
-  check kind(5, 4, 2) == tkScalene
+  test "true if first two sides are equal":
+      check is_isosceles([4, 4, 3]) == true
 
-test "very small triangles are legal":
-  check kind(0.4, 0.6, 0.3) == tkScalene
+  test "true if first and last sides are equal":
+      check is_isosceles([4, 3, 4]) == true
 
-test "triangles with no size are illegal":
-  expect(ValueError):
-    discard kind(0, 0, 0)
+  test "is equilateral triangles are also is isosceles":
+      check is_isosceles([4, 4, 4]) == true
 
-test "triangles with negative sides are illegal":
-  expect(ValueError):
-    discard kind(3, 4, -5)
+  test "false if no sides are equal":
+      check is_isosceles([2, 3, 4]) == false
 
-test "triangles violating triangle inequality are illegal":
-  expect(ValueError):
-    discard kind(1, 1, 3)
+  test "violation of triangle inequality not is isosceles":
+      check is_isosceles([1, 1, 3]) == false
 
-test "triangles violating triangle inequality are illegal 2":
-  expect(ValueError):
-    discard kind(2, 4, 2)
 
-test "triangles violating triangle inequality are illegal 3":
-  expect(ValueError):
-    discard kind(7, 3, 2)
+suite "returns true if the triangle is scalene":
 
-test "triangles with not a number are illegal":
-  expect(ValueError):
-    discard kind(7, 3, NaN)
+  test "true if no sides are equal":
+      check is_scalene([5, 4, 6]) == true
 
-test "triangles with infinity are illegal":
-  expect(ValueError):
-    discard kind(7, 3, Inf)
+  test "false if all sides are equal":
+      check is_scalene([4, 4, 4]) == false
 
-test "triangles with negative infinity are illegal":
-  expect(ValueError):
-    discard kind(7, Neginf, 4)
+  test "false if two sides are equal":
+      check is_scalene([4, 4, 3]) == false
+
+  test "violation of triangle inequality not is scalene":
+      check is_scalene([7, 3, 2]) == false