trackler 2.2.1.45 → 2.2.1.46

data/tracks/common-lisp/exercises/hello-world/example.lisp

@@ -0,0 +1,9 @@
+(defpackage #:hello-world
+  (:use #:common-lisp)
+  (:export #:hello-world)
+  (:nicknames #:hw))
+
+(in-package #:hello-world)
+
+(defun hello-world (&optional name)
+  (format nil "Hello ~A!" (or name "World")))

data/tracks/common-lisp/exercises/hello-world/hello-world-test.lisp

@@ -0,0 +1,21 @@
+(ql:quickload "lisp-unit")
+#-xlisp-test (load "hello-world")
+
+(defpackage #:hello-world-test
+  (:use #:common-lisp #:lisp-unit))
+
+(in-package #:hello-world-test)
+
+(define-test hello-world-test
+  (assert-equal "Hello World!" (hw:hello-world)))
+
+(define-test hello-alice-test
+  (assert-equal "Hello Alice!" (hw:hello-world "Alice")))
+
+(define-test hello-bob-test
+  (assert-equal "Hello Bob!" (hw:hello-world "Bob")))
+
+#-xlisp-test
+(let ((*print-errors* t)
+      (*print-failures* t))
+  (run-tests :all))

data/tracks/common-lisp/exercises/hello-world/hello-world.lisp

@@ -0,0 +1,6 @@
+(defpackage #:hello-world
+  (:use #:common-lisp)
+  (:export #:hello-world)
+  (:nicknames #:hw))
+
+(in-package #:hello-world)

data/tracks/common-lisp/exercises/perfect-numbers/README.md

@@ -0,0 +1,72 @@
+# Perfect numbers
+
+Determine if a number is perfect, abundant, or deficient based on
+Nicomachus' (60 - 120 CE) classification scheme for natural numbers.
+
+The Greek mathematician [Nicomachus](https://en.wikipedia.org/wiki/Nicomachus) devised a classification scheme for natural numbers, identifying each as belonging uniquely to the categories of **perfect**, **abundant**, or **deficient** based on their [aliquot sum](https://en.wikipedia.org/wiki/Aliquot_sum). The aliquot sum is defined as the sum of the factors of a number not including the number itself. For example, the aliquot sum of 15 is (1 + 3 + 5) = 9
+
+- **Perfect**: aliquot sum = number
+  - 6 is a perfect number because (1 + 2 + 3) = 6
+  - 28 is a perfect number because (1 + 2 + 4 + 7 + 14) = 28
+- **Abundant**: aliquot sum > number
+  - 12 is an abundant number because (1 + 2 + 3 + 4 + 6) = 16
+  - 24 is an abundant number because (1 + 2 + 3 + 4 + 6 + 8 + 12) = 36
+- **Deficient**: aliquot sum < number
+  - 8 is a deficient number because (1 + 2 + 4) = 7
+  - Prime numbers are deficient
+
+Implement a way to determine whether a given number is **perfect**. Depending on your language track, you may also need to implement a way to determine whether a given number is **abundant** or **deficient**.
+
+## Setup
+
+Check out [Exercism Help](http://exercism.io/languages/lisp) for instructions to
+get started writing Common Lisp. That page will explain how to install and setup
+a Lisp implementation and how to run the tests.
+
+## Formatting
+
+While Common Lisp doesn't care about indentation and layout of code,
+nor whether you use spaces or tabs, this is an important consideration
+for submissions to exercism.io. Excercism.io's code widget cannot
+handle mixing of tab and space characters well so using only spaces is recommended to make
+the code more readable to the human reviewers. Please review your
+editors settings on how to accomplish this. Below are instructions for
+popular editors for Common Lisp.
+
+### VIM
+
+Use the following commands to ensure VIM uses only spaces for
+indentation:
+
+```vimscript
+:set tabstop=2
+:set shiftwidth=2
+:set expandtab
+```
+
+(or as a oneliner `:set tabstop=2 shiftwidth=2 expandtab`). This can
+be added to your `~/.vimrc` file to use it all the time.
+
+### Emacs
+
+Emacs is very well suited for editing Common Lisp and has many
+powerful add-on packages available. The only thing that one needs to
+do with a stock emacs to make it work well with exercism.io is to
+evaluate the following code:
+
+`(setq indent-tab-mode nil)`
+
+This can be placed in your `~/.emacs` (or `~/.emacs.d/init.el`) in
+order to have it set whenever Emacs is launched.
+
+One suggested add-on for Emacs and Common Lisp is
+[SLIME](https://github.com/slime/slime) which offers tight integration
+with the REPL; making iterative coding and testing very easy.
+
+
+## Source
+Taken from Chapter 2 of Functional Thinking by Neal Ford.
+[http://shop.oreilly.com/product/0636920029687.do](http://shop.oreilly.com/product/0636920029687.do)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/common-lisp/exercises/perfect-numbers/example.lisp

@@ -0,0 +1,17 @@
+(defpackage #:perfect-numbers
+  (:use #:common-lisp)
+  (:export #:classify))
+
+(in-package #:perfect-numbers)
+
+(defun divisors (n)
+  (remove-if-not (lambda (x) (= 0 (rem n x)))
+                 (loop for x from 1 to (floor n 2) collect x)))
+
+(defun classify (n)
+  (if (> n 0)
+    (let ((div-sum (reduce #'+ (divisors n))))
+      (cond ((= n div-sum) "perfect")
+            ((< n div-sum) "abundant")
+            (T             "deficient")))
+    (warn "Just defined for natural numbers")))

data/tracks/common-lisp/exercises/perfect-numbers/perfect-numbers-test.lisp

@@ -0,0 +1,56 @@
+(ql:quickload "lisp-unit")
+#-xlisp-test (load "perfect-numbers")
+
+(defpackage #:perfect-numbers-test
+  (:use #:common-lisp #:lisp-unit))
+
+(in-package #:perfect-numbers-test)
+
+
+;; Perfect numbers tests:
+(define-test smallest-perfect-number
+  (assert-equal "perfect" (perfect-numbers:classify 6)))
+
+(define-test medium-perfect-number
+  (assert-equal "perfect" (perfect-numbers:classify 28)))
+
+(define-test large-perfect-number
+  (assert-equal "perfect" (perfect-numbers:classify 33550336)))
+
+
+;; Abundant numbers tests:
+(define-test smallest-abundant-number
+  (assert-equal "abundant" (perfect-numbers:classify 12)))
+
+(define-test medium-abundant-number
+  (assert-equal "abundant" (perfect-numbers:classify 30)))
+
+(define-test large-abundant-number
+  (assert-equal "abundant" (perfect-numbers:classify 33550335)))
+
+
+;; Deficient numbers tests:
+(define-test smallest-prime-deficient-number
+  (assert-equal "deficient" (perfect-numbers:classify 2)))
+
+(define-test smallest-non-prime-deficient-number
+  (assert-equal "deficient" (perfect-numbers:classify 1)))
+
+(define-test medium-deficient-number
+  (assert-equal "deficient" (perfect-numbers:classify 32)))
+
+(define-test large-deficient-number
+  (assert-equal "deficient" (perfect-numbers:classify 33550337)))
+
+
+;; Undefined values of classify tests:
+(define-test undefinded-0
+  (assert-equal NIL (perfect-numbers:classify 0)))
+
+(define-test undefined-negative
+  (assert-equal NIL (perfect-numbers:classify -3)))
+
+#-xlisp-test
+(let ((*print-errors* t)
+      (*print-failures* t))
+  (run-tests :all))

data/tracks/common-lisp/exercises/perfect-numbers/perfect-numbers.lisp

@@ -0,0 +1,7 @@
+(defpackage #:perfect-numbers
+  (:use #:common-lisp)
+  (:export #:classify))
+
+(in-package #:perfect-numbers)
+
+(defun classify (n))

data/tracks/cpp/.travis.yml

@@ -1,19 +1,39 @@
----
 dist: trusty
-sudo: required
+sudo: false 
 language: cpp
-compiler:
-- gcc
-- clang
+
+matrix:
+  include:
+    # GCC 4.9
+    - os: linux
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+          packages:
+            - g++-4.9
+      env: MATRIX_EVAL="CC=gcc-4.9 && CXX=g++-4.9"
+
+    # Clang 3.8
+    - os: linux
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.8
+          packages:
+            - clang-3.8
+      env: MATRIX_EVAL="CC=clang-3.8 && CXX=clang++-3.8"
+
 before_install:
-- sudo add-apt-repository -y ppa:samuel-bachmann/boost
-- sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test
-- sudo apt-get -qq -d update
+  - sudo add-apt-repository -y ppa:samuel-bachmann/boost
+  - sudo apt-get -y -d update
+  - eval "${MATRIX_EVAL}"
 install:
-- sudo apt-get -qq install boost1.60 cmake g++-4.8
-- sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-4.8 90
+  - sudo apt-get -y install libboost-regex1.60-dev libboost-test1.60-dev libboost-date-time1.60-dev
 script:
-- bin/fetch-configlet
-- bin/configlet lint .
-- cmake -G "Unix Makefiles"
-- make
+  - bin/fetch-configlet
+  - bin/configlet lint .
+  - cmake -G "Unix Makefiles"
+  - make
+

data/tracks/cpp/docs/INSTALLATION.md

@@ -14,42 +14,33 @@ as separate command-line tools.
 
 ### Prerequisite: A Modern C++11 Compiler
 
-This language track assumes [C++11](http://en.wikipedia.org/wiki/C%2B%2B11),
-the latest version of the ISO C++ standard that is
-[widely supported](http://en.cppreference.com/w/cpp/compiler_support) on all
-major platforms (Linux, Windows and MacOS).
-[C++14](http://en.wikipedia.org/wiki/C%2B%2B14) has been recently ratified
-as the most recent version of the ISO standard.  The language track will
-be updated to C++14 once support is sufficiently mature in the development
-environments across all major platforms.
-
-Free compilers exist for C++11 on all major platforms, although the version
-of the C++ compiler installed on your system may be an older version that
-doesn't fully support C++11.  A comparison chart of
-[C++ compiler support](http://en.cppreference.com/w/cpp/compiler_support)
-and related [discussion](http://en.cppreference.com/w/Talk:cpp/compiler_support)
-shows that most of the major features of C++11 are available on all major
-platforms.
+This language track requires a compiler with [C++11](http://en.wikipedia.org/wiki/C%2B%2B11)
+support, which was release in 2011. All major compilers released in the last few years should
+be compatible, so as long as you are on a fairly recent version you should be fine.
+Specifically, GCC version 5.1 or later, Clang version 3.8 or later, or Visual
+Studio 2015 or later.
 
 #### Linux
 
-Linux users will need gcc 4.8 or later or clang 3.4 or later for the compiler
-and `make` will be needed for the native build.  Make is pre-installed on most
-unix systems, but is available via `sudo apt-get install make` if not present.
-Gcc 4.8 supports C++11 with the `-std=c++11` argument and can be installed and
-set as the default compiler with the following recipe:
+Ubuntu 16.04 and later have compatible compilers in the package manager, so
+installing the necessary compiler can be done with `sudo apt-get install gcc`.
+If you're on an older version of Ubuntu, you should be able to install a newer
+GCC version using the following:
 
 ```bash
 $ sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test
 $ sudo apt-get -qq -d update
-$ sudo apt-get -qq install g++-4.8
-$ # make g++ 4.8 the default g++ executable
-$ sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-4.8 90
+$ sudo apt-get -qq install g++-5
+$ # make g++ 5 the default g++ executable
+$ sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-5 90
 ```
 
+For other distributions, you should be able to acquire the compiler through your
+package manager.
+
 #### MacOS
 
-MacOS users can install gcc 4.8 with [Homebrew](http://brew.sh/) via
+MacOS users can install GCC with [Homebrew](http://brew.sh/) via
 `brew install gcc`.
 
 #### Windows
@@ -87,9 +78,7 @@ improve the CMake support.
 
 The unit tests use Boost.Test, the unit testing framework included with
 [Boost](http://www.boost.org/index.html).  You may find other libraries
-in Boost useful to you as you work through the exercises.  In particular,
-gcc 4.8 does not have a proper implementation of the standard regular
-expression library, but you can find a compatible library in Boost.
+in Boost useful to you as you work through the exercises.
 You will need to download and install Boost.  As of this writing Boost
 1.59+ is the required version.  You will need a compiled version of the
 boost libraries Boost.Test, Boost.DateTime and Boost.Regex, or you will

data/tracks/cpp/docs/TESTS.md

@@ -52,7 +52,7 @@ Once the build environment has been created by CMake, you can build your
 code using the appropriate command for your environment:
 
 * Linux with make: `make`
-* Windows with Visual Studio 2013: Select Build / Build Solution from the menu.
+* Windows with Visual Studio: Select Build / Build Solution from the menu.
 * MacOS with Xcode: Select Build from the toolbar
 
 Examples of running CMake for different environments are shown below.
@@ -77,36 +77,32 @@ Simply type make in the build directory to compile the tests. This should
 generate compile time errors. Once the errors are fixed make will build and 
 run the tests.
 
-#### Windows with Visual Studio 2013
+#### Windows with Visual Studio 2017
 
-The generator name for CMake is `Visual Studio 12`.  The same generator
-supports all editions of Visual Studio 2013: Express, Professional,
-Ultimate, etc.
-Assuming the current exercise is `bob` and we're in the exercise folder:
+The generator name for CMake is `Visual Studio 15`.  The same generator
+supports all IDE editions of Visual Studio 2017: Community, Professional,
+and Enterprise. Assuming the current exercise is `bob` and we're in the
+exercise folder:
 
 ```
 > copy nul: bob.h
 > copy nul: bob.cpp
 > mkdir build
 > cd build
-> cmake -G "Visual Studio 12" ..
+> cmake -G "Visual Studio 15" ..
 ```
 
 This example shows creating empty files for the implementation before
 running CMake.
 
-On Linux and MacOS boost packages install the headers and libraries to
-a standard global location on the system.  On Windows, you unpack the
-binaries wherever you like or build from source wherever you like and
-there is no standard install location on the system.
-
-If you get complaints from CMake about not being able to find Boost, you
+If you installed boost to the default location, Cmake may be able to
+find it for you automatically. If it can't find it, you will need to
 need to supply additional arguments to tell CMake where to find it by
 setting the `BOOST_INCLUDEDIR` variable on the command-line.  Here is an
-example using the Visual Studio 2013 generator:
+example using the Visual Studio 2017 generator:
 
 ```
-> cmake -G "Visual Studio 12" -DBOOST_INCLUDEDIR:PATH=D:/Code/boost/boost_1_59_0 ..
+> cmake -G "Visual Studio 15" -DBOOST_INCLUDEDIR:PATH=D:/Code/boost/boost_1_59_0 ..
 ```
 
 **Note:** Path locations passed to CMake always use slash (`/`) as the
@@ -129,10 +125,6 @@ running CMake.
 
 ## Boost.Test Documentation
 
-The Boost.Test documentation is being rewritten to improve usability
-and is nearly complete.
-Prefer the documentation rewrite to look up something if you're unfamiliar
-with Boost.Test and want to know more.
+If you need to consult the Boost.Test documentation you can find it here:
 
-* [Boost.Test documentation rewrite](http://user.xmission.com/~legalize/boost.test/)
-* [Boost.Test 1.55 official documentation](http://www.boost.org/doc/libs/1_55_0/libs/test/doc/html/index.html)
+* [Boost.Test 1.59 official documentation](http://www.boost.org/doc/libs/1_59_0/libs/test/doc/html/index.html)

data/tracks/crystal/config.json

@@ -73,6 +73,16 @@
 
       ]
     },
+    {
+      "uuid": "64f8e403-9a3d-4094-9114-f1bee88c072b",
+      "slug": "triangle",
+      "core": false,
+      "unlocked_by": null,
+      "difficulty": 1,
+      "topics": [
+
+      ]
+    },
     {
       "uuid": "19298c02-b34f-4f11-aad6-5da4838967a0",
       "slug": "difference-of-squares",

data/tracks/crystal/exercises/triangle/spec/triangle_spec.cr

@@ -0,0 +1,60 @@
+require "spec"
+require "../src/*"
+
+describe "Triangle" do
+  it "true if all sides are equal" do
+    Triangle.new([2, 2, 2]).equilateral?.should eq(true)
+  end
+
+  pending "false if any side is unequal" do
+    Triangle.new([2, 3, 2]).equilateral?.should eq(false)
+  end
+
+  pending "false if no sides are equal" do
+    Triangle.new([5, 4, 6]).equilateral?.should eq(false)
+  end
+
+  pending "All zero sides are illegal, so the triangle is not equilateral" do
+    Triangle.new([0, 0, 0]).equilateral?.should eq(false)
+  end
+
+  pending "true if last two sides are equal" do
+    Triangle.new([3, 4, 4]).isosceles?.should eq(true)
+  end
+
+  pending "true if first two sides are equal" do
+    Triangle.new([4, 4, 3]).isosceles?.should eq(true)
+  end
+
+  pending "true if first and last sides are equal" do
+    Triangle.new([4, 3, 4]).isosceles?.should eq(true)
+  end
+
+  pending "equilateral triangles are also isosceles" do
+    Triangle.new([4, 4, 4]).isosceles?.should eq(true)
+  end
+
+  pending "false if no sides are equal" do
+    Triangle.new([2, 3, 4]).isosceles?.should eq(false)
+  end
+
+  pending "Sides that violate triangle inequality are not isosceles, even if two are equal" do
+    Triangle.new([1, 1, 3]).isosceles?.should eq(false)
+  end
+
+  pending "true if no sides are equal" do
+    Triangle.new([5, 4, 6]).scalene?.should eq(true)
+  end
+
+  pending "false if all sides are equal" do
+    Triangle.new([4, 4, 4]).scalene?.should eq(false)
+  end
+
+  pending "false if two sides are equal" do
+    Triangle.new([4, 4, 3]).scalene?.should eq(false)
+  end
+
+  pending "Sides that violate triangle inequality are not scalene, even if they are all different" do
+    Triangle.new([7, 3, 2]).scalene?.should eq(false)
+  end
+end