trackler 2.2.1.153 → 2.2.1.154

data/tracks/elm/exercises/bracket-push/tests/Tests.elm

@@ -0,0 +1,71 @@
+module Tests exposing (..)
+
+import BracketPush exposing (isPaired)
+import Expect
+import String
+import Test exposing (..)
+
+
+tests : Test
+tests =
+    describe "BracketPush"
+        [ test "paired square brackets" <|
+            \_ ->
+                Expect.equal True (isPaired "[]")
+        , skip <|
+            test "empty string" <|
+                \_ ->
+                    Expect.equal True (isPaired "")
+        , skip <|
+            test "unpaired brackets" <|
+                \_ ->
+                    Expect.equal False (isPaired "[[")
+        , skip <|
+            test "wrong ordered brackets" <|
+                \_ ->
+                    Expect.equal False (isPaired "}{")
+        , skip <|
+            test "wrong closing bracket" <|
+                \_ ->
+                    Expect.equal False (isPaired "{]")
+        , skip <|
+            test "paired with whitespace" <|
+                \_ ->
+                    Expect.equal True (isPaired "{ }")
+        , skip <|
+            test "partially paired brackets" <|
+                \_ ->
+                    Expect.equal False (isPaired "{[])")
+        , skip <|
+            test "simple nested brackets" <|
+                \_ ->
+                    Expect.equal True (isPaired "{[]}")
+        , skip <|
+            test "seceral paired brackets" <|
+                \_ ->
+                    Expect.equal True (isPaired "{}[]")
+        , skip <|
+            test "paired and nested brackets" <|
+                \_ ->
+                    Expect.equal True (isPaired "([{}({}[])])")
+        , skip <|
+            test "unopened closing brackets" <|
+                \_ ->
+                    Expect.equal False (isPaired "{[)][]}")
+        , skip <|
+            test "unpaired and nested brackets" <|
+                \_ ->
+                    Expect.equal False (isPaired "([{])")
+        , skip <|
+            test "paired and wrong nested brackets" <|
+                \_ ->
+                    Expect.equal False (isPaired "[({]})")
+        , skip <|
+            test "math expression" <|
+                \_ ->
+                    Expect.equal True (isPaired "(((185 + 223.85) * 15) - 543)/2")
+        , skip <|
+            test "complex latex expression" <|
+                \_ ->
+                    Expect.equal True (isPaired "\\left(\\begin{array}{cc} \\frac{1}{3} & x\\\\ \\mathrm{e}^{x} &... x^2 \\end{array}\\right)")
+        ]

data/tracks/elm/exercises/bracket-push/tests/elm-package.json

@@ -0,0 +1,16 @@
+{
+    "version": "3.0.0",
+    "summary": "Exercism problems in Elm.",
+    "repository": "https://github.com/exercism/elm.git",
+    "license": "BSD3",
+    "source-directories": [
+        ".",
+        ".."
+    ],
+    "exposed-modules": [],
+    "dependencies": {
+        "elm-lang/core": "5.0.0 <= v < 6.0.0",
+        "elm-community/elm-test": "4.0.0 <= v < 5.0.0"
+    },
+    "elm-version": "0.18.0 <= v < 0.19.0"
+}

data/tracks/go/config.json

@@ -149,7 +149,7 @@
       "unlocked_by": null,
       "uuid": "8b29da0e-8ead-4e72-a12a-d448c8434767"
     },
-    {
+	{
       "core": true,
       "difficulty": 2,
       "slug": "grains",
@@ -908,6 +908,18 @@
       "unlocked_by": "error-handling",
       "uuid": "408f235e-f1ce-11e7-8c3f-9a214cf093ae"
     },
+    {
+      "core": false,
+      "difficulty": 4,
+      "slug": "linked-list",
+      "topics": [
+        "pointer",
+        "data_structure"
+      ],
+      "unlocked_by": "tree-building",
+      "uuid": "4368df53-39fb-4f36-97c2-39c399cd6d25"
+    },
+
     {
       "core": false,
       "difficulty": 5,
@@ -1072,7 +1084,7 @@
       "unlocked_by": "twelve-days",
       "uuid": "a7469032-c4d0-4e15-aa0c-4e9f6588b4c8"
     },
-    { 
+    {
       "core": false,
       "difficulty": 4,
       "slug": "yacht",
@@ -1340,7 +1352,6 @@
     }
   ],
   "foregone": [
-    "linked-list"
   ],
   "ignore_pattern": "example(?!.*test)",
   "language": "Go"

data/tracks/go/exercises/linked-list/README.md

@@ -0,0 +1,59 @@
+# Linked List
+Implement a doubly linked list.
+
+Like an array, a linked list is a simple linear data structure. Several
+common data types can be implemented using linked lists, like queues,
+stacks, and associative arrays.
+
+A linked list is a collection of data elements called *nodes*. In a
+*singly linked list* each node holds a value and a link to the next node.
+In a *doubly linked list* each node also holds a link to the previous
+node.
+
+You will write an implementation of a doubly linked list. Implement a
+`Node` to hold a value and pointers to the next and previous nodes. Then
+implement a `List` which holds references to the first and last node and
+offers functions for adding and removing items.
+
+Your `Node` should have the following fields and functions:
+
+* `Val`: the node's value (we will use `interface{}`).
+* `Next()`: pointer to the next node.
+* `Prev()`: pointer to the previous node.
+* `First()`: pointer to the first node (head).
+* `Last()`: pointer to the last node (tail).
+
+Your `List` should have the following fields and functions:
+
+* `First()`: pointer to the first node (head).
+* `Last()`: pointer to the last node (tail).
+* `PushBack(v interface{})`: insert value at back.
+* `PopBack() (interface{}, error)`: remove value at back.
+* `PushFront(v interface{}) `: remove value at front.
+* `PopFront() (interface{}, error)`: insert value at front.
+* `Reverse()`: reverse the linked list.
+
+Instead of not covering error conditions, like calling `PopBack` or `PopFront` on an empty list,
+we will follow Go's idiomatic style and implement the error checks as well.
+
+If you want to know more about linked lists, check [Wikipedia](https://en.wikipedia.org/wiki/Linked_list).
+
+## Running the tests
+To run the tests run the command `go test` from within the exercise directory.
+
+If the test suite contains benchmarks, you can run these with the `-bench`
+flag:
+
+    go test -bench .
+
+Keep in mind that each reviewer will run benchmarks on a different machine, with
+different specs, so the results from these benchmark tests may vary.
+
+## Further information
+If you are not familar with linked list, try [this tutorial](https://visualgo.net/en/list).
+
+## Source
+Classic CS data structure.
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/go/exercises/linked-list/cases_test.go

@@ -0,0 +1,189 @@
+package linkedlist
+
+import "testing"
+
+var newListTestCases = []struct {
+	name     string
+	in       []interface{}
+	expected []interface{}
+}{
+	{
+		name:     "from 5 elements",
+		in:       []interface{}{1, 2, 3, 4, 5},
+		expected: []interface{}{1, 2, 3, 4, 5},
+	},
+	{
+		name:     "from 2 elements",
+		in:       []interface{}{1, 2},
+		expected: []interface{}{1, 2},
+	},
+	{
+		name:     "from no element",
+		in:       []interface{}{},
+		expected: []interface{}{},
+	},
+	{
+		name:     "from 1 element",
+		in:       []interface{}{999},
+		expected: []interface{}{999},
+	},
+}
+
+var reverseTestCases = []struct {
+	name     string
+	in       []interface{}
+	expected []interface{}
+}{
+	{
+		name:     "from 5 elements",
+		in:       []interface{}{1, 2, 3, 4, 5},
+		expected: []interface{}{5, 4, 3, 2, 1},
+	},
+	{
+		name:     "from 2 elements",
+		in:       []interface{}{1, 2},
+		expected: []interface{}{2, 1},
+	},
+	{
+		name:     "from no element",
+		in:       []interface{}{},
+		expected: []interface{}{},
+	},
+	{
+		name:     "from 1 element",
+		in:       []interface{}{999},
+		expected: []interface{}{999},
+	},
+}
+
+var pushPopTestCases = []struct {
+	name     string
+	in       []interface{}
+	actions  []checkedAction
+	expected []interface{}
+}{
+	{
+		name: "PushFront only",
+		in:   []interface{}{},
+		actions: []checkedAction{
+			pushFront(4),
+			pushFront(3),
+			pushFront(2),
+			pushFront(1),
+		},
+		expected: []interface{}{1, 2, 3, 4},
+	},
+	{
+		name: "PushBack only",
+		in:   []interface{}{},
+		actions: []checkedAction{
+			pushBack(1),
+			pushBack(2),
+			pushBack(3),
+			pushBack(4),
+		},
+		expected: []interface{}{1, 2, 3, 4},
+	},
+	{
+		name: "PopFront only, pop some elements",
+		in:   []interface{}{1, 2, 3, 4},
+		actions: []checkedAction{
+			popFront(1, nil),
+			popFront(2, nil),
+		},
+		expected: []interface{}{3, 4},
+	},
+	{
+		name: "PopFront only, pop till empty",
+		in:   []interface{}{1, 2, 3, 4},
+		actions: []checkedAction{
+			popFront(1, nil),
+			popFront(2, nil),
+			popFront(3, nil),
+			popFront(4, nil),
+			popFront(0, ErrEmptyList),
+		},
+		expected: []interface{}{},
+	},
+	{
+		name: "PopBack only, pop some elements",
+		in:   []interface{}{1, 2, 3, 4},
+		actions: []checkedAction{
+			popBack(4, nil),
+			popBack(3, nil),
+		},
+		expected: []interface{}{1, 2},
+	},
+	{
+		name: "PopBack only, pop till empty",
+		in:   []interface{}{1, 2, 3, 4},
+		actions: []checkedAction{
+			popBack(4, nil),
+			popBack(3, nil),
+			popBack(2, nil),
+			popBack(1, nil),
+			popBack(0, ErrEmptyList),
+		},
+		expected: []interface{}{},
+	},
+	{
+		name: "mixed actions",
+		in:   []interface{}{2, 3},
+		actions: []checkedAction{
+			pushFront(1),
+			pushBack(4),
+			popFront(1, nil),
+			popFront(2, nil),
+			popBack(4, nil),
+			popBack(3, nil),
+			popBack(0, ErrEmptyList),
+			popFront(0, ErrEmptyList),
+			pushFront(8),
+			pushBack(7),
+			pushFront(9),
+			pushBack(6),
+		},
+		expected: []interface{}{9, 8, 7, 6},
+	},
+}
+
+// checkedAction calls a function of the linked list and (possibly) checks the result
+type checkedAction func(*testing.T, *List)
+
+func pushFront(arg interface{}) checkedAction {
+	return func(t *testing.T, ll *List) {
+		ll.PushFront(arg)
+	}
+}
+
+func pushBack(arg interface{}) checkedAction {
+	return func(t *testing.T, ll *List) {
+		ll.PushBack(arg)
+	}
+}
+
+func popFront(expected interface{}, expectedErr error) checkedAction {
+	return func(t *testing.T, ll *List) {
+		v, err := ll.PopFront()
+		if err != expectedErr {
+			t.Errorf("PopFront() returned wrong, expected no error, got= %v", err)
+		}
+
+		if v != expected {
+			t.Errorf("PopFront() returned wrong, expected= %v, got= %v", expected, v)
+		}
+	}
+}
+
+func popBack(expected interface{}, expectedErr error) checkedAction {
+	return func(t *testing.T, ll *List) {
+		v, err := ll.PopBack()
+		if err != expectedErr {
+			t.Errorf("PopBack() returned wrong, expected no error, got= %v", err)
+		}
+
+		if v != expected {
+			t.Errorf("PopBack() returned wrong, expected= %v, got= %v", expected, v)
+		}
+	}
+}

data/tracks/go/exercises/linked-list/example.go

@@ -0,0 +1,212 @@
+package linkedlist
+
+import (
+	"errors"
+)
+
+// Node is a node in a linked list.
+type Node struct {
+	Val  interface{}
+	next *Node
+	prev *Node
+}
+
+// NewNode constructs a new Node with the given value & no next/prev links.
+func NewNode(v interface{}) *Node {
+	return &Node{
+		Val:  v,
+		next: nil,
+		prev: nil,
+	}
+}
+
+// Next returns a pointer to the next node in the linked list.
+func (n *Node) Next() *Node {
+	return n.next
+}
+
+// Prev returns a pointer to the previous node in the linked list.
+func (n *Node) Prev() *Node {
+	return n.prev
+}
+
+// First returns a pointer to the first node in the linked list (head).
+func (n *Node) First() *Node {
+	cur := n
+	for ; cur.prev != nil; cur = cur.prev {
+	}
+
+	return cur
+}
+
+// Last returns a pointer to the last node in the linked list (tail).
+func (n *Node) Last() *Node {
+	cur := n
+	for ; cur.next != nil; cur = cur.next {
+	}
+
+	return cur
+}
+
+// List is a doubly-linked list with Head and Tail.
+type List struct {
+	head *Node
+	tail *Node
+}
+
+// NewList constructs a doubly linked list from a sequence of integers.
+func NewList(vs ...interface{}) *List {
+	ll := &List{
+		head: nil,
+		tail: nil,
+	}
+
+	if len(vs) < 1 {
+		return ll
+	}
+
+	ll.head = NewNode(vs[0])
+	ll.tail = ll.head
+
+	if len(vs) == 1 {
+		return ll
+	}
+
+	cur := ll.head
+	for i := 1; i < len(vs); i++ {
+		cur.next = NewNode(vs[i])
+		cur.next.prev = cur
+		cur = cur.next
+	}
+
+	ll.tail = cur
+
+	return ll
+}
+
+// First returns a pointer to the first node in the linked list (head).
+func (ll *List) First() *Node {
+	return ll.head
+}
+
+// Last returns a pointer to the last node in the linked list (tail).
+func (ll *List) Last() *Node {
+	return ll.tail
+}
+
+// Reverse reverses the given linked list in-place.
+func (ll *List) Reverse() {
+	if ll.head == nil || ll.head.next == nil {
+		return
+	}
+
+	// construct singly-linked list from the back
+	dummy := NewNode(-1)
+	cur := dummy
+	n := ll.tail
+	for n != nil {
+		cur.next = n
+
+		cur = cur.next
+		n = n.prev
+	}
+	cur.next = nil // cur will be the new ll.Tail -> set .next = nil
+
+	// add prev -> doubly-linked list
+	prev := dummy.next
+	n = dummy.next.next
+	for n != nil {
+		n.prev = prev
+
+		n = n.next
+		prev = prev.next
+	}
+
+	// update Head & Tail
+	ll.head, ll.tail = ll.tail, ll.head
+	ll.head.prev = nil
+}
+
+// PushFront pushes a new value before Head.
+func (ll *List) PushFront(v interface{}) {
+	n := NewNode(v)
+
+	switch {
+	default:
+		panic("bad PushFront implementation")
+	case ll.head == nil && ll.tail == nil: // empty list
+		ll.head = n
+		ll.tail = n
+	case ll.head != nil && ll.tail != nil: // non-empty list
+		n.next = ll.head
+		ll.head.prev = n
+
+		ll.head = n
+	}
+}
+
+// PushBack pushes a new value after Tail.
+func (ll *List) PushBack(v interface{}) {
+	n := NewNode(v)
+
+	switch {
+	default:
+		panic("bad PushBack implementation")
+	case ll.head == nil && ll.tail == nil: // empty list
+		ll.head = n
+		ll.tail = n
+	case ll.head != nil && ll.tail != nil: // non-empty list
+		ll.tail.next = n
+		n.prev = ll.tail
+
+		ll.tail = n
+	}
+}
+
+var (
+	ErrEmptyList = errors.New("list is empty")
+)
+
+// PopFront posp the element at Head. It returns error if the linked list is empty.
+func (ll *List) PopFront() (interface{}, error) {
+	switch {
+	default:
+		panic("bad PopFront implementation")
+	case ll.head == nil && ll.tail == nil: // empty list
+		return 0, ErrEmptyList
+	case ll.head != nil && ll.tail != nil && ll.head.next == nil: // 1 element
+		v := ll.head.Val
+		ll.head = nil
+		ll.tail = nil
+
+		return v, nil
+	case ll.head != nil && ll.tail != nil && ll.head.next != nil: // >1 element
+		v := ll.head.Val
+		ll.head.next.prev = nil
+		ll.head = ll.head.next
+
+		return v, nil
+	}
+}
+
+// PopBack pops the element at Tail. It returns error if the linked list is empty.
+func (ll *List) PopBack() (interface{}, error) {
+	switch {
+	default:
+		panic("bad PopBack implementation")
+	case ll.head == nil && ll.tail == nil: // empty list
+		return 0, ErrEmptyList
+	case ll.head != nil && ll.tail != nil && ll.tail.prev == nil: // 1 element
+		v := ll.tail.Val
+		ll.head = nil
+		ll.tail = nil
+
+		return v, nil
+	case ll.head != nil && ll.tail != nil && ll.tail.prev != nil: // >1 element
+		v := ll.tail.Val
+		ll.tail.prev.next = nil
+		ll.tail = ll.tail.prev
+
+		return v, nil
+	}
+}