-
-
Notifications
You must be signed in to change notification settings - Fork 24
Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
Add List Ops practice exercise (#288)
- Loading branch information
Showing
11 changed files
with
6,183 additions
and
22 deletions.
There are no files selected for viewing
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,19 @@ | ||
| # Instructions | ||
|
|
||
| Implement basic list operations. | ||
|
|
||
| In functional languages list operations like `length`, `map`, and `reduce` are very common. | ||
| Implement a series of basic list operations, without using existing functions. | ||
|
|
||
| The precise number and names of the operations to be implemented will be track dependent to avoid conflicts with existing names, but the general operations you will implement include: | ||
|
|
||
| - `append` (_given two lists, add all items in the second list to the end of the first list_); | ||
| - `concatenate` (_given a series of lists, combine all items in all lists into one flattened list_); | ||
| - `filter` (_given a predicate and a list, return the list of all items for which `predicate(item)` is True_); | ||
| - `length` (_given a list, return the total number of items within it_); | ||
| - `map` (_given a function and a list, return the list of the results of applying `function(item)` on all items_); | ||
| - `foldl` (_given a function, a list, and initial accumulator, fold (reduce) each item into the accumulator from the left_); | ||
| - `foldr` (_given a function, a list, and an initial accumulator, fold (reduce) each item into the accumulator from the right_); | ||
| - `reverse` (_given a list, return a list with all the original items, but in reversed order_). | ||
|
|
||
| Note, the ordering in which arguments are passed to the fold functions (`foldl`, `foldr`) is significant. |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,17 @@ | ||
| { | ||
| "authors": [ | ||
| "kahgoh" | ||
| ], | ||
| "files": { | ||
| "solution": [ | ||
| "src/ListOps.re" | ||
| ], | ||
| "test": [ | ||
| "__tests__/ListOps_test.re" | ||
| ], | ||
| "example": [ | ||
| ".meta/src/Example.re" | ||
| ] | ||
| }, | ||
| "blurb": "Implement basic list operations." | ||
| } |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,45 @@ | ||
| let rec append = (list1: list('item), list2: list('item)): list('item) => { | ||
| switch (list2) { | ||
| | [] => list1 | ||
| | [next, ...rest] => append(list1 @ [next], rest) | ||
| }; | ||
| }; | ||
|
|
||
| let rec foldl = | ||
| (list: list('item), initial: 'acc, func: ('acc, 'item) => 'acc): 'acc => { | ||
| switch (list) { | ||
| | [] => initial | ||
| | [next, ...rest] => foldl(rest, func(initial, next), func) | ||
| }; | ||
| }; | ||
|
|
||
| let reverse = (list: list('item)): list('item) => { | ||
| foldl(list, [], (acc, elem) => {[elem, ...acc]}); | ||
| }; | ||
|
|
||
| let concat = (list: list(list('item))): list('item) => { | ||
| foldl(list, [], (acc, elem) => {append(acc, elem)}); | ||
| }; | ||
|
|
||
| let filter = (list: list('item), filter: 'item => bool): list('item) => { | ||
| foldl(list, [], (acc, elem) => | ||
| if (filter(elem)) { | ||
| [elem, ...acc]; | ||
| } else { | ||
| acc; | ||
| } | ||
| ) | ||
| ->reverse; | ||
| }; | ||
|
|
||
| let length = (list: list('item)): int => { | ||
| foldl(list, 0, (acc, _elem) => acc + 1); | ||
| }; | ||
|
|
||
| let map = (list: list('item), func: 'item => 'mapped): list('mapped) => { | ||
| foldl(list, [], (acc, elem) => acc @ [func(elem)]); | ||
| }; | ||
|
|
||
| let foldr = (list: list('item), initial: 'acc, func: ('acc, 'item) => 'acc) => { | ||
| list->reverse->foldl(initial, func); | ||
| }; |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,106 @@ | ||
| # 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. | ||
|
|
||
| [485b9452-bf94-40f7-a3db-c3cf4850066a] | ||
| description = "append entries to a list and return the new list -> empty lists" | ||
|
|
||
| [2c894696-b609-4569-b149-8672134d340a] | ||
| description = "append entries to a list and return the new list -> list to empty list" | ||
|
|
||
| [e842efed-3bf6-4295-b371-4d67a4fdf19c] | ||
| description = "append entries to a list and return the new list -> empty list to list" | ||
|
|
||
| [71dcf5eb-73ae-4a0e-b744-a52ee387922f] | ||
| description = "append entries to a list and return the new list -> non-empty lists" | ||
|
|
||
| [28444355-201b-4af2-a2f6-5550227bde21] | ||
| description = "concatenate a list of lists -> empty list" | ||
|
|
||
| [331451c1-9573-42a1-9869-2d06e3b389a9] | ||
| description = "concatenate a list of lists -> list of lists" | ||
|
|
||
| [d6ecd72c-197f-40c3-89a4-aa1f45827e09] | ||
| description = "concatenate a list of lists -> list of nested lists" | ||
|
|
||
| [0524fba8-3e0f-4531-ad2b-f7a43da86a16] | ||
| description = "filter list returning only values that satisfy the filter function -> empty list" | ||
|
|
||
| [88494bd5-f520-4edb-8631-88e415b62d24] | ||
| description = "filter list returning only values that satisfy the filter function -> non-empty list" | ||
|
|
||
| [1cf0b92d-8d96-41d5-9c21-7b3c37cb6aad] | ||
| description = "returns the length of a list -> empty list" | ||
|
|
||
| [d7b8d2d9-2d16-44c4-9a19-6e5f237cb71e] | ||
| description = "returns the length of a list -> non-empty list" | ||
|
|
||
| [c0bc8962-30e2-4bec-9ae4-668b8ecd75aa] | ||
| description = "return a list of elements whose values equal the list value transformed by the mapping function -> empty list" | ||
|
|
||
| [11e71a95-e78b-4909-b8e4-60cdcaec0e91] | ||
| description = "return a list of elements whose values equal the list value transformed by the mapping function -> non-empty list" | ||
|
|
||
| [613b20b7-1873-4070-a3a6-70ae5f50d7cc] | ||
| description = "folds (reduces) the given list from the left with a function -> empty list" | ||
| include = false | ||
|
|
||
| [e56df3eb-9405-416a-b13a-aabb4c3b5194] | ||
| description = "folds (reduces) the given list from the left with a function -> direction independent function applied to non-empty list" | ||
| include = false | ||
|
|
||
| [d2cf5644-aee1-4dfc-9b88-06896676fe27] | ||
| description = "folds (reduces) the given list from the left with a function -> direction dependent function applied to non-empty list" | ||
| include = false | ||
|
|
||
| [36549237-f765-4a4c-bfd9-5d3a8f7b07d2] | ||
| description = "folds (reduces) the given list from the left with a function -> empty list" | ||
| reimplements = "613b20b7-1873-4070-a3a6-70ae5f50d7cc" | ||
|
|
||
| [7a626a3c-03ec-42bc-9840-53f280e13067] | ||
| description = "folds (reduces) the given list from the left with a function -> direction independent function applied to non-empty list" | ||
| reimplements = "e56df3eb-9405-416a-b13a-aabb4c3b5194" | ||
|
|
||
| [d7fcad99-e88e-40e1-a539-4c519681f390] | ||
| description = "folds (reduces) the given list from the left with a function -> direction dependent function applied to non-empty list" | ||
| reimplements = "d2cf5644-aee1-4dfc-9b88-06896676fe27" | ||
|
|
||
| [aeb576b9-118e-4a57-a451-db49fac20fdc] | ||
| description = "folds (reduces) the given list from the right with a function -> empty list" | ||
| include = false | ||
|
|
||
| [c4b64e58-313e-4c47-9c68-7764964efb8e] | ||
| description = "folds (reduces) the given list from the right with a function -> direction independent function applied to non-empty list" | ||
| include = false | ||
|
|
||
| [be396a53-c074-4db3-8dd6-f7ed003cce7c] | ||
| description = "folds (reduces) the given list from the right with a function -> direction dependent function applied to non-empty list" | ||
| include = false | ||
|
|
||
| [17214edb-20ba-42fc-bda8-000a5ab525b0] | ||
| description = "folds (reduces) the given list from the right with a function -> empty list" | ||
| reimplements = "aeb576b9-118e-4a57-a451-db49fac20fdc" | ||
|
|
||
| [e1c64db7-9253-4a3d-a7c4-5273b9e2a1bd] | ||
| description = "folds (reduces) the given list from the right with a function -> direction independent function applied to non-empty list" | ||
| reimplements = "c4b64e58-313e-4c47-9c68-7764964efb8e" | ||
|
|
||
| [8066003b-f2ff-437e-9103-66e6df474844] | ||
| description = "folds (reduces) the given list from the right with a function -> direction dependent function applied to non-empty list" | ||
| reimplements = "be396a53-c074-4db3-8dd6-f7ed003cce7c" | ||
|
|
||
| [94231515-050e-4841-943d-d4488ab4ee30] | ||
| description = "reverse the elements of the list -> empty list" | ||
|
|
||
| [fcc03d1e-42e0-4712-b689-d54ad761f360] | ||
| description = "reverse the elements of the list -> non-empty list" | ||
|
|
||
| [40872990-b5b8-4cb8-9085-d91fc0d05d26] | ||
| description = "reverse the elements of the list -> list of lists is not flattened" |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,104 @@ | ||
| open Jest; | ||
| open Expect; | ||
| open ListOps; | ||
|
|
||
| describe("append entries to a list and return the new list", () => { | ||
| test("empty lists", () => | ||
| expect(append([], [])) |> toEqual([]) | ||
| ); | ||
| test("list to empty list", () => | ||
| expect(append([], [1, 2, 3, 4])) |> toEqual([1, 2, 3, 4]) | ||
| ); | ||
| test("empty list to list", () => | ||
| expect(append([1, 2, 3, 4], [])) |> toEqual([1, 2, 3, 4]) | ||
| ); | ||
| test("non-empty list", () => | ||
| expect(append([1, 2], [2, 3, 4, 5])) |> toEqual([1, 2, 2, 3, 4, 5]) | ||
| ); | ||
| }); | ||
|
|
||
| describe("concatenate a list of lists", () => { | ||
| test("empty list", () => | ||
| expect(concat([])) |> toEqual([]) | ||
| ); | ||
| test("list of lists", () => | ||
| expect(concat([[1, 2], [3], [], [4, 5, 6]])) | ||
| |> toEqual([1, 2, 3, 4, 5, 6]) | ||
| ); | ||
| test("list of nested lists", () => { | ||
| expect(concat([[[1], [2]], [[3]], [[]], [[4, 5, 6]]])) | ||
| |> toEqual([[1], [2], [3], [], [4, 5, 6]]) | ||
| }); | ||
| }); | ||
|
|
||
| describe( | ||
| "filter list returning only values that satisfy the filter function", () => { | ||
| test("empty list", () => { | ||
| expect(filter([], x => x mod 2 == 1)) |> toEqual([]) | ||
| }); | ||
| test("non-empty list", () => { | ||
| expect(filter([1, 2, 3, 5], x => x mod 2 == 1)) |> toEqual([1, 3, 5]) | ||
| }); | ||
| }); | ||
|
|
||
| describe("returns the length of a list", () => { | ||
| test("empty list", () => { | ||
| expect(length([])) |> toEqual(0) | ||
| }); | ||
| test("non-empty list", () => { | ||
| expect(length([1, 2, 3, 4])) |> toEqual(4) | ||
| }); | ||
| }); | ||
|
|
||
| describe( | ||
| "return a list of elements whose values equal the list value transformed by the mapping function", | ||
| () => { | ||
| test("empty list", () => { | ||
| expect(map([], x => x + 1)) |> toEqual([]) | ||
| }); | ||
| test("non-empty list", () => { | ||
| expect(map([1, 3, 5, 7], x => x + 1)) |> toEqual([2, 4, 6, 8]) | ||
| }); | ||
| }, | ||
| ); | ||
|
|
||
| describe("folds (reduces) the given list from the left with a function", () => { | ||
| test("empty list", () => { | ||
| expect(foldl([], 2, (acc, elem) => elem * acc)) |> toEqual(2) | ||
| }); | ||
| test("direction independent function applied to non-empty list", () => { | ||
| expect(foldl([1, 2, 3, 4], 5, (acc, elem) => elem + acc)) | ||
| |> toEqual(15) | ||
| }); | ||
| test("direction dependent function applied to non-empty list", () => { | ||
| expect(foldl([1.0, 2.0, 3.0, 4.0], 24.0, (acc, elem) => elem /. acc)) | ||
| |> toEqual(64.0) | ||
| }); | ||
| }); | ||
|
|
||
| describe("folds (reduces) the given list from the right with a function", () => { | ||
| test("empty list", () => { | ||
| expect(foldr([], 2, (acc, elem) => elem * acc)) |> toEqual(2) | ||
| }); | ||
| test("direction independent function applied to non-empty list", () => { | ||
| expect(foldr([1, 2, 3, 4], 5, (acc, elem) => elem + acc)) | ||
| |> toEqual(15) | ||
| }); | ||
| test("direction dependent function applied to non-empty list", () => { | ||
| expect(foldr([1.0, 2.0, 3.0, 4.0], 24.0, (acc, elem) => elem /. acc)) | ||
| |> toEqual(9.0) | ||
| }); | ||
| }); | ||
|
|
||
| describe("reverse the elements of the list", () => { | ||
| test("empty list", () => { | ||
| expect(reverse([])) |> toEqual([]) | ||
| }); | ||
| test("non-empty list", () => { | ||
| expect(reverse([1, 3, 5, 7])) |> toEqual([7, 5, 3, 1]) | ||
| }); | ||
| test("list of lists is not flattened", () => { | ||
| expect(reverse([[1, 2], [3], [], [4, 5, 6]])) | ||
| |> toEqual([[4, 5, 6], [], [3], [1, 2]]) | ||
| }); | ||
| }); |
Oops, something went wrong.