Add linked list practice exercise (#567)

Author: vaeng

config.json

@@ -994,6 +994,20 @@
           "strings"
         ]
       },
+      {
+        "slug": "linked-list",
+        "name": "Linked List ",
+        "uuid": "6f6c55dd-db6b-40ca-96f2-d9b7232dcbb0",
+        "practices": [],
+        "prerequisites":[],
+        "difficulty": 6,
+        "topics": [ 
+          "classes",
+          "conditionals",
+          "loops",
+          "pointers"
+        ]
+      },
       {
         "slug": "simple-linked-list",
         "name": "Simple linked list",

exercises/practice/linked-list/.docs/instructions.append.md

@@ -0,0 +1,23 @@
+# Instructions append
+
+## How this Exercise is Structured on the C++ Track
+
+While linked lists can be implemented in a variety of ways with a variety of underlying data structures, we ask here that you implement your linked list in an OOP fashion.
+
+In the `linked_list_test.cpp` file, you will see that a [__templated__][template classes] `List` class is called.
+You are expected to write this class with the following member functions:
+
+-  `push` adds an element to the end of the list,
+-  `pop` removes and returns the last element of the list,
+- `shift` removes and returns the first element of the list,
+- `unshift` adds an element to the start of the list, and
+- `count` returns the total number of elements in the current list.
+
+Finally, we would like you to implement `erase` in addition to the methods outlined above.
+`erase` will take one argument, which is the value to be removed from the linked list.
+If the value appears more than once, only the **first** occurrence should be removed.
+It should return if an element was deleted or not.
+
+Although it is not tested, you might want to raise an exception if `pop` and `shift` are called on an empty `List`.
+
+[template classes]: https://www.learncpp.com/cpp-tutorial/template-classes/

exercises/practice/linked-list/.docs/instructions.md

@@ -0,0 +1,26 @@
+# Instructions
+
+Your team has decided to use a doubly linked list to represent each train route in the schedule.
+Each station along the train's route will be represented by a node in the linked list.
+
+You don't need to worry about arrival and departure times at the stations.
+Each station will simply be represented by a number.
+
+Routes can be extended, adding stations to the beginning or end of a route.
+They can also be shortened by removing stations from the beginning or the end of a route.
+
+Sometimes a station gets closed down, and in that case the station needs to be removed from the route, even if it is not at the beginning or end of the route.
+
+The size of a route is measured not by how far the train travels, but by how many stations it stops at.
+
+~~~~exercism/note
+The linked list is a fundamental data structure in computer science, often used in the implementation of other data structures.
+As the name suggests, it is a list of nodes that are linked together.
+It is a list of "nodes", where each node links to its neighbor or neighbors.
+In a **singly linked list** each node links only to the node that follows it.
+In a **doubly linked list** each node links to both the node that comes before, as well as the node that comes after.
+
+If you want to dig deeper into linked lists, check out [this article][intro-linked-list] that explains it using nice drawings.
+
+[intro-linked-list]: https://medium.com/basecs/whats-a-linked-list-anyway-part-1-d8b7e6508b9d
+~~~~

exercises/practice/linked-list/.docs/introduction.md

@@ -0,0 +1,6 @@
+# Introduction
+
+You are working on a project to develop a train scheduling system for a busy railway network.
+
+You've been asked to develop a prototype for the train routes in the scheduling system.
+Each route consists of a sequence of train stations that a given train stops at.

exercises/practice/linked-list/.meta/config.json

@@ -0,0 +1,20 @@
+{
+  "authors": [
+    "vaeng"
+  ],
+  "files": {
+    "solution": [
+      "linked_list.cpp",
+      "linked_list.h"
+    ],
+    "test": [
+      "linked_list_test.cpp"
+    ],
+    "example": [
+      ".meta/example.cpp",
+      ".meta/example.h"
+    ]
+  },
+  "blurb": "Implement a doubly linked list.",
+  "source": "Classic computer science topic"
+}

exercises/practice/linked-list/.meta/example.cpp

@@ -0,0 +1,5 @@
+#include "linked_list.h"
+
+namespace linked_list {
+
+}  // namespace linked_list

exercises/practice/linked-list/.meta/example.h

@@ -0,0 +1,69 @@
+#pragma once
+
+#include <memory>
+#include <stdexcept>
+
+namespace linked_list {
+template <typename T>
+struct Node {
+    Node() {}
+    Node(std::shared_ptr<Node<T>> prev, std::shared_ptr<Node<T>> next, T value)
+        : previous(prev), next(next), data(value) {}
+    std::shared_ptr<Node<T>> previous;
+    std::shared_ptr<Node<T>> next;
+    T data;
+};
+
+template <typename T>
+class List {
+   public:
+    List() {
+        sentinel = std::make_shared<Node<T>>();
+        sentinel->next = sentinel;
+        sentinel->previous = sentinel;
+    }
+
+    void push(T entry) { insert(sentinel->previous, sentinel, entry); }
+
+    void unshift(T entry) { insert(sentinel, sentinel->next, entry); }
+
+    T pop() { return remove(sentinel->previous); }
+
+    T shift() { return remove(sentinel->next); }
+
+    bool erase(T entry) {
+        auto ptr = sentinel->next;
+        while (ptr->data != entry) {
+            if (ptr == sentinel) return false;
+            ptr = ptr->next;
+        }
+        remove(ptr);
+        return true;
+    }
+
+    size_t count() { return current_size; }
+
+   private:
+    std::shared_ptr<Node<T>> sentinel;
+    size_t current_size{};
+
+    T remove(std::shared_ptr<Node<T>> to_be_deleted) {
+        if (current_size < 1)
+            throw std::runtime_error("Cannot remove elements from empty list.");
+        T data = to_be_deleted->data;
+        to_be_deleted->next->previous = to_be_deleted->previous;
+        to_be_deleted->previous->next = to_be_deleted->next;
+        --current_size;
+        return data;
+    }
+
+    void insert(std::shared_ptr<Node<T>> prev, std::shared_ptr<Node<T>> next,
+                T value) {
+        auto new_element = std::make_shared<Node<T>>(prev, next, value);
+        prev->next = new_element;
+        next->previous = new_element;
+        ++current_size;
+    }
+};
+
+}  // namespace linked_list

exercises/practice/linked-list/.meta/tests.toml

@@ -0,0 +1,67 @@
+# This is an auto-generated file.
+#
+# Regenerating this file via `configlet sync` will:
+# - Recreate every `description` key/value pair
+# - Recreate every `reimplements` key/value pair, where they exist in problem-specifications
+# - Remove any `include = true` key/value pair (an omitted `include` key implies inclusion)
+# - Preserve any other key/value pair
+#
+# As user-added comments (using the # character) will be removed when this file
+# is regenerated, comments can be added via a `comment` key.
+
+[7f7e3987-b954-41b8-8084-99beca08752c]
+description = "pop gets element from the list"
+
+[c3f67e5d-cfa2-4c3e-a18f-7ce999c3c885]
+description = "push/pop respectively add/remove at the end of the list"
+
+[00ea24ce-4f5c-4432-abb4-cc6e85462657]
+description = "shift gets an element from the list"
+
+[37962ee0-3324-4a29-b588-5a4c861e6564]
+description = "shift gets first element from the list"
+
+[30a3586b-e9dc-43fb-9a73-2770cec2c718]
+description = "unshift adds element at start of the list"
+
+[042f71e4-a8a7-4cf0-8953-7e4f3a21c42d]
+description = "pop, push, shift, and unshift can be used in any order"
+
+[88f65c0c-4532-4093-8295-2384fb2f37df]
+description = "count an empty list"
+
+[fc055689-5cbe-4cd9-b994-02e2abbb40a5]
+description = "count a list with items"
+
+[8272cef5-130d-40ea-b7f6-5ffd0790d650]
+description = "count is correct after mutation"
+
+[229b8f7a-bd8a-4798-b64f-0dc0bb356d95]
+description = "popping to empty doesn't break the list"
+
+[4e1948b4-514e-424b-a3cf-a1ebbfa2d1ad]
+description = "shifting to empty doesn't break the list"
+
+[e8f7c600-d597-4f79-949d-8ad8bae895a6]
+description = "deletes the only element"
+
+[fd65e422-51f3-45c0-9fd0-c33da638f89b]
+description = "deletes the element with the specified value from the list"
+
+[59db191a-b17f-4ab7-9c5c-60711ec1d013]
+description = "deletes the element with the specified value from the list, re-assigns tail"
+
+[58242222-5d39-415b-951d-8128247f8993]
+description = "deletes the element with the specified value from the list, re-assigns head"
+
+[ee3729ee-3405-4bd2-9bad-de0d4aa5d647]
+description = "deletes the first of two elements"
+
+[47e3b3b4-b82c-4c23-8c1a-ceb9b17cb9fb]
+description = "deletes the second of two elements"
+
+[7b420958-f285-4922-b8f9-10d9dcab5179]
+description = "delete does not modify the list if the element is not found"
+
+[7e04828f-6082-44e3-a059-201c63252a76]
+description = "deletes only the first occurrence"

exercises/practice/linked-list/CMakeLists.txt

@@ -0,0 +1,64 @@
+# Get the exercise name from the current directory
+get_filename_component(exercise ${CMAKE_CURRENT_SOURCE_DIR} NAME)
+
+# Basic CMake project
+cmake_minimum_required(VERSION 3.5.1)
+
+# Name the project after the exercise
+project(${exercise} CXX)
+
+# Get a source filename from the exercise name by replacing -'s with _'s
+string(REPLACE "-" "_" file ${exercise})
+
+# Implementation could be only a header
+if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${file}.cpp)
+    set(exercise_cpp ${file}.cpp)
+else()
+    set(exercise_cpp "")
+endif()
+
+# Use the common Catch library?
+if(EXERCISM_COMMON_CATCH)
+    # For Exercism track development only
+    add_executable(${exercise} ${file}_test.cpp ${exercise_cpp} ${file}.h $<TARGET_OBJECTS:catchlib>)
+elseif(EXERCISM_TEST_SUITE)
+    # The Exercism test suite is being run, the Docker image already
+    # includes a pre-built version of Catch.
+    find_package(Catch2 REQUIRED)
+    add_executable(${exercise} ${file}_test.cpp ${exercise_cpp} ${file}.h)
+    target_link_libraries(${exercise} PRIVATE Catch2::Catch2WithMain)
+    # When Catch is installed system wide we need to include a different
+    # header, we need this define to use the correct one.
+    target_compile_definitions(${exercise} PRIVATE EXERCISM_TEST_SUITE)
+else()
+    # Build executable from sources and headers
+    add_executable(${exercise} ${file}_test.cpp ${exercise_cpp} ${file}.h test/tests-main.cpp)
+endif()
+
+set_target_properties(${exercise} PROPERTIES
+    CXX_STANDARD 17
+    CXX_STANDARD_REQUIRED OFF
+    CXX_EXTENSIONS OFF
+)
+
+set(CMAKE_BUILD_TYPE Debug)
+
+if("${CMAKE_CXX_COMPILER_ID}" MATCHES "(GNU|Clang)")
+    set_target_properties(${exercise} PROPERTIES
+        COMPILE_FLAGS "-Wall -Wextra -Wpedantic -Werror"
+    )
+endif()
+
+# Configure to run all the tests?
+if(${EXERCISM_RUN_ALL_TESTS})
+    target_compile_definitions(${exercise} PRIVATE EXERCISM_RUN_ALL_TESTS)
+endif()
+
+# Tell MSVC not to warn us about unchecked iterators in debug builds
+if(${MSVC})
+    set_target_properties(${exercise} PROPERTIES
+        COMPILE_DEFINITIONS_DEBUG _SCL_SECURE_NO_WARNINGS)
+endif()
+
+# Run the tests on every build
+add_custom_target(test_${exercise} ALL DEPENDS ${exercise} COMMAND ${exercise})

exercises/practice/linked-list/linked_list.cpp

@@ -0,0 +1,5 @@
+#include "linked_list.h"
+
+namespace linked_list {
+
+}  // namespace linked_list

exercises/practice/linked-list/linked_list.h

@@ -0,0 +1,5 @@
+#pragma once
+
+namespace linked_list {
+
+}  // namespace linked_list