From 94f32a0866c8c4aa47d722ba49a31c509c1599c6 Mon Sep 17 00:00:00 2001 From: BethanyG Date: Tue, 20 Jul 2021 19:53:18 -0700 Subject: [PATCH 1/8] Added set concept blurb. --- concepts/sets/.meta/config.json | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/concepts/sets/.meta/config.json b/concepts/sets/.meta/config.json index 9b9e8da5a9..7e4b5b00cc 100644 --- a/concepts/sets/.meta/config.json +++ b/concepts/sets/.meta/config.json @@ -1,5 +1,5 @@ { - "blurb": "TODO: add blurb for this concept", - "authors": ["bethanyg", "cmccandless"], + "blurb": "A set is a mutable & unordered collection of hashable objects. Members must be unique, and sets are often used to quickly dedupe groups of items. They can be iterated over via \"for item in \" or \"for index, item in enumerate()\", but do not support sequence-type behaviors like indexing, slicing, or sorting.", + "authors": ["bethanyg"], "contributors": [] -} +} \ No newline at end of file From d81ce49734130baf088f4404b1e154316b20ec6d Mon Sep 17 00:00:00 2001 From: BethanyG Date: Tue, 20 Jul 2021 19:53:45 -0700 Subject: [PATCH 2/8] Added about.md. --- concepts/sets/about.md | 324 ++++++++++++++++++++++++++++++++++++++++- 1 file changed, 322 insertions(+), 2 deletions(-) diff --git a/concepts/sets/about.md b/concepts/sets/about.md index c628150d56..71cdc40ae9 100644 --- a/concepts/sets/about.md +++ b/concepts/sets/about.md @@ -1,2 +1,322 @@ -#TODO: Add about for this concept. - +# Sets + +A [`set`][type-set] is a mutable and _unordered_ collection of _hashable_ objects. +Items within a `set` are distinct and duplicate members are not allowed. +Like most collections, `sets` can hold any (or multiple) data type(s) -- as long as those types can be [hashed][hashable]. +Sets also come in an _immutable_ [`frozenset`][type-frozenset] flavor. + +Like other collection types, `sets` support membership testing through `in`, length calculation through `len()`, shallow copies through `copy()`, and iteration via `for item in `. +_Unlike_ sequence types (_`string`, `list` & `tuple`_), `sets` are **neither ordered nor indexed**, and _do not support_ slicing, sorting, or other sequence-type behaviors. + +`sets` are most commonly used to quickly dedupe groups of items. +They're also used for fast membership testing, finding supersets & subsets of items, and performing "set math" (_calculating union, intersection, difference & symmetric difference between groups of items._). + +Checking membership in a `set` has only O(1) time complexity versus checking for membership in a `list` or `string`, which has worst-case O(n) time complexity. +Operations such as `.union()`, `.intersection()`, or `.diference()` have an average O(n) time complexity. + +## Construction + +A `set` can be declared as a _set literal_ with curly `{}` brackets and commas between elements. +Duplicates are silently omitted: + +```python +>>> one_element = {'๐Ÿ˜€'} +>>> one_element +{'๐Ÿ˜€'} + +>>> multiple_elements = {'๐Ÿ˜€', '๐Ÿ˜ƒ', '๐Ÿ˜„', '๐Ÿ˜'} +>>> multiple_elements +{'๐Ÿ˜€', '๐Ÿ˜ƒ', '๐Ÿ˜„', '๐Ÿ˜'} + +>>> multiple_duplicates = {'๐Ÿ˜€', '๐Ÿ˜ƒ', '๐Ÿ˜„', '๐Ÿ˜', '๐Ÿ˜ƒ', '๐Ÿ˜„'} +>>> multiple_duplicates +{'๐Ÿ˜€', '๐Ÿ˜', '๐Ÿ˜ƒ', '๐Ÿ˜„'} +``` + +Set literals use the same curly braces as `dict` literals, so the `set()` constructor must be used to declare an empty `set`. + +The `set()` constructor can also be used with any _iterable_ passed as an argument. +Elements are cycled through by the constructor and added to the `set` individually. +Order is not preserved and duplicates are silently omitted: + +```python +>>> no_elements = set() +>>> no_elements +set() + +# The tuple is unpacked and each distinct element is added. Duplicates are removed. +>>> multiple_elements_from_tuple = set(("Parrot", "Bird", 334782, "Bird", "Parrot")) +>>> multiple_elements_from_tuple +{334782, 'Bird', 'Parrot'} + +# The list is unpacked and each distinct element is added. +>>> multiple_elements_from_list = set([2, 3, 2, 3, 3, 3, 5, 7, 11, 7, 11, 13, 13]) +>>> multiple_elements_from_set +{2, 3, 5, 7, 11} +``` + +Results when using a set constructor with a string or dictionary may be surprising: + +```python +# String elements (Unicode code points) are iterated through and added *individually*. +>>> multiple_elements_string = set("Timbuktu") +>>> multiple_elements_string +{'T', 'b', 'i', 'k', 'm', 't', 'u'} + +# Unicode separators and positioning code points are also added *individually*. +>>> multiple_code_points_string = set('เค…เคญเฅเคฏเคพเคธ') +>>> multiple_code_points_string +{'เค…', 'เคญ', 'เคฏ', 'เคธ', 'เคพ', 'เฅ'} + +# The iteration default for dictionaries is over the keys. +>>> source_data = {"fish": "gold", "monkey": "brown", "duck" : "white", "crow": "black"} +>>> set(source_data) +{'crow', 'duck', 'fish', 'monkey'} +``` + +Sets can hold heterogeneous datatypes, but all `set` elements must be _hashable_: + +```python + +>>> lists_as_elements = {['๐Ÿ˜…','๐Ÿคฃ'], ['๐Ÿ˜‚','๐Ÿ™‚','๐Ÿ™ƒ'], ['๐Ÿ˜œ', '๐Ÿคช', '๐Ÿ˜']} + +Traceback (most recent call last): + + File "", line 1, in + lists_as_elements = {['๐Ÿ˜…','๐Ÿคฃ'], ['๐Ÿ˜‚','๐Ÿ™‚','๐Ÿ™ƒ'], ['๐Ÿ˜œ', '๐Ÿคช', '๐Ÿ˜']} + +TypeError: unhashable type: 'list' + +# standard sets are mutable, so they cannot be hashed. +>>> sets_as_elements = {{'๐Ÿ˜…','๐Ÿคฃ'}, {'๐Ÿ˜‚','๐Ÿ™‚','๐Ÿ™ƒ'}, {'๐Ÿ˜œ', '๐Ÿคช', '๐Ÿ˜'}} +Traceback (most recent call last): + + File "", line 1, in + sets_as_elements = {{'๐Ÿ˜…','๐Ÿคฃ'}, {'๐Ÿ˜‚','๐Ÿ™‚','๐Ÿ™ƒ'}, {'๐Ÿ˜œ', '๐Ÿคช', '๐Ÿ˜'}} + +TypeError: unhashable type: 'set' +``` + +Therefore, to create a `set` of `sets`, the contained sets must be of type `frozenset()` + +```python +# frozensets don't have a literal form +>>> set_1 = frozenset({'๐Ÿ˜œ', '๐Ÿ˜', '๐Ÿคช'}) +>>> set_2 = frozenset({'๐Ÿ˜…', '๐Ÿคฃ'}) +>>> set_3 = frozenset({'๐Ÿ˜‚', '๐Ÿ™‚', '๐Ÿ™ƒ'}) + +>>> frozen_sets_as_elements = {set_1, set_2, set_3} +>>> frozen_sets_as_elements +{frozenset({'๐Ÿ˜œ', '๐Ÿ˜', '๐Ÿคช'}), frozenset({'๐Ÿ˜…', '๐Ÿคฃ'}), frozenset({'๐Ÿ˜‚', '๐Ÿ™‚', '๐Ÿ™ƒ'})} +``` + +## Working with Sets + +Elements can be added/removed using `.add()` / `.remove()`. +`remove()` will raise a `KeyError` if the item is not present in the `set`. + +```python +>>> creatures = {'crow', 'duck', 'fish', 'monkey', 'elephant'} +>>> creatures.add('beaver') +>>> creatures.remove('duck') +>>> creatures +{'beaver', 'crow', 'elephant', 'fish', 'monkey'} + +# Trying to remove an item that is not present will raise a KeyError +>>> creatures.remove('bear') +Traceback (most recent call last): + + File "", line 1, in + creatures.remove('bear') + +KeyError: 'bear' +``` + +`.discard()` will also remove an item from the `set`, but will **not** raise a `KeyError` if the item is not present. +`.clear()` will remove all items. +`.pop()` will remove and _return_ an **arbitrary** item and raises a `KeyError` if the `set` is empty. + +## Set Methods + +Sets implement methods that generally mimic [mathematical set operations][mathematical-sets]. +Most (_though not all_) of these methods can be performed using either operator(s) or method call(s). +Using operators requires that both inputs be `sets` or `frozensets`, while methods will generally take any iterable as an argument. + +### Fast Membership Testing Between Groups + +The `.isdisjoint()` method is used to test if a `set` has **no elements in common** with another set or iterable. +It will accept any `iterable` or `set` as an arugment, returning `True` if they are **disjoint**, `False` otherwise. +Note that for `dcts`, the iteration default is over`.keys()`. + +```python +>>> mammals = {'squirrel','dog','cat','cow', 'tiger', 'elephant'} +>>> birds = {'crow','sparrow','eagle','chicken', 'albatross'} + +# Dictionary of animal names with colors +>>> animals = {'chicken': 'white','sparrow': 'grey','eagle': 'brown and white', + 'albatross': 'grey and white','crow': 'black','elephant': 'grey', + 'dog': 'rust','cow': 'black and white','tiger': 'orange and black', + 'cat': 'grey','squirrel': 'black'} + +# List of additonal animals +>>> additional_animals = ['pangolin', 'panda', 'parrot', 'lemur', 'tiger', 'pangolin'] +... + +>>> mammals.isdisjoint(birds) +True + +>>> mammals.isdisjoint(animals) +False + +>>> birds.isdisjoint(additional_animals) +True + +>>> set(additional_animals).isdisjoint(animals) +False +``` + +`.issubset()` | ` <= ` are used to check if every element in `` is also in ``. +`.issuperset()` | ` >= ` are used to check the inverse -- if every element in `` is also in ``. + +```python +>>> animals = {'chicken': 'white','sparrow': 'grey','eagle': 'brown and white', + 'albatross': 'grey and white','crow': 'black','elephant': 'grey', + 'dog': 'rust','cow': 'black and white','tiger': 'organge and black', + 'cat': 'grey','squirrel': 'black'} + +>>> mammals = {'squirrel','dog','cat','cow', 'tiger', 'elephant'} +>>> birds = {'crow','sparrow','eagle','chicken', 'albatross'} + +# Methods will take any iterable as an argument +>>> mammals.issubset(animal_colors) +True + + +# A set is always a loose subset of itself +>>> animals <= animals +True + +>>> birds <= animals +True + +>>> birds <= mammals +False +``` + +` < ` and ` > ` are used to test for _proper subsets_: +(`` <= ``) AND (`` != ``) for the `<` operator; (`` >= ``) AND (`` != ``) for the `>` operator. +They have no method equivelent. + +```python +>>> animal_names = {'albatross','cat','chicken','cow','crow','dog', + 'eagle','elephant','sparrow','squirrel','tiger'} + +>>> animal_names_also = {'albatross','cat','chicken','cow','crow','dog', + 'eagle','elephant','sparrow','squirrel','tiger'} + +>>> mammals = {'squirrel','dog','cat','cow', 'tiger', 'elephant'} +>>> birds = {'crow','sparrow','eagle','chicken', 'albatross'} + +>>> mammals < animal_names +True + +>>> animal_names > birds +True + +# A set is never a *proper subset* of itself +>>> animal_names_also < animal_names +False + + +>>> animals < animals + +``` + +### Set Operations + +`.union(*)` and ` | | | ... | ` return a new `set` with elements from `` and all ``. + +```python +>>> perennial_vegetables = {'Asparagus', 'Broccoli', 'Sweet Potatoe', 'Kale'} +>>> annual_vegetables = {'Corn', 'Zucchini', 'Sweet Peas', 'Summer Squash'} + +>>> more_perennials = ['Radicchio', 'Rhubarb', 'Spinach', 'Watercress'] + +# Methods will take any iterable as an argument. +>>> perennial_vegetables.union(more_perennials) +{'Asparagus','Broccoli','Kale','Radicchio','Rhubarb','Spinach','Sweet Potatoe','Watercress'} + +# Operators require sets. +>>> perennial_vegetables | annual_vegetables +{'Asparagus','Broccoli','Corn','Kale','Summer Squash','Sweet Peas','Sweet Potatoe','Zucchini'} + +``` + +`.difference(*)` and ` - - - ...` return a new `set` with elements from the original `` that are not in ``. + +```python +>>> berries_and_veggies = {'Asparagus', 'Broccoli', 'Watercress', 'Goji Berries', 'Goose Berries', 'Ramps', + 'Walking Onions', 'Raspberries','Blueberries', 'Blackberries', 'Strawberries', + 'Rhubarb', 'Kale', 'Artichokes', 'Currants', 'Honeyberries'} + +# Methods will take any iterable as an argument. +>>> veggies = ('Asparagus', 'Broccoli', 'Watercress', 'Ramps', + 'Walking Onions', 'Rhubarb', 'Kale', 'Artichokes') + +>>> just_berries = berries_and_veggies.difference(veggies) +>>> just_berries +{'Blackberries','Blueberries','Currants','Goji Berries', + 'Goose Berries','Honeyberries','Raspberries','Strawberries'} + +>>> berries_and_veggies - just_berries +{'Artichokes','Asparagus','Broccoli','Kale','Ramps','Rhubarb','Walking Onions','Watercress'} +``` + +`.intersection(*)` and ` & & & ... ` return a new `set` with elements common to the original `set` and all ``. + +```python +>>> perennials = {'Annatto','Asafetida','Asparagus','Azalea','Winter Savory', 'Blackberries','Broccoli','Curry Leaf', + 'Fennel','French Sorrel','Fuchsia','Kaffir Lime','Kale','Lavender','Mint','Oranges', + 'Oregano','Ramps','Roses','Tarragon','Watercress','Wild Bergamot'} + +>>> annuals = {'Corn', 'Zucchini', 'Sweet Peas', 'Marjoram', 'Summer Squash', 'Okra', + 'Shallots', 'Basil', 'Cilantro', 'Cumin', 'Sunflower', 'Chervil', 'Summer Savory'} + +>>> herbs = ['Annatto','Asafetida','Basil','Chervil','Cilantro','Curry Leaf','Fennel','Kaffir Lime', + 'Lavender','Marjoram','Mint','Oregano','Summer Savory' 'Tarragon','Wild Bergamot', + 'Wild Celery','Winter Savory'] + + +# Methods will take any iterable as an argument. +>>> perennial_herbs = perennials.intersection(herbs) +>>> perennial_herbs +{'Mint', 'Annatto', 'Winter Savory', 'Curry Leaf', 'Lavender', 'Fennel', + 'Oregano', 'Kaffir Lime','Asafetida', 'Wild Bergamot', 'Tarragon'} + +>>> annuals & set(herbs) + {'Basil', 'Chervil', 'Marjoram', 'Cilantro'} +``` + +`.symmetric_difference()` and ` ^ ` return a new `set` that contains elements that are in `` OR ``, but **not in both**. + +```python +>>> plants_1 = {'๐ŸŒฒ','๐Ÿˆ','๐ŸŒต', '๐Ÿฅ‘','๐ŸŒด', '๐Ÿฅญ'} +>>> plants_2 = ('๐ŸŒธ','๐ŸŒด', '๐ŸŒบ', '๐ŸŒฒ', '๐ŸŒป', '๐ŸŒต') + + +# Methods will take any iterable as an argument. +>>> fruit_and_flowers = plants_1.symmetric_difference(plants_2) +>>> fruit_and_flowers +{'๐ŸŒธ', '๐ŸŒบ', '๐Ÿˆ', '๐Ÿฅ‘', '๐Ÿฅญ','๐ŸŒป' } + +>>> fruit_and_flowers ^ plants_1 +{'๐ŸŒฒ', '๐ŸŒธ', '๐ŸŒด', '๐ŸŒต','๐ŸŒบ', '๐ŸŒป'} + +>>> fruit_and_flowers ^ plants_2 +{ '๐Ÿฅ‘', '๐ŸŒด','๐ŸŒฒ', '๐ŸŒต', '๐Ÿˆ', '๐Ÿฅญ'} +``` + +[type-set]: https://docs.python.org/3/library/stdtypes.html#set +[type-frozenset]: https://docs.python.org/3/library/stdtypes.html#frozenset +[mathematical-sets]: https://en.wikipedia.org/wiki/Set_theory#Basic_concepts_and_notation +[hashable]: https://docs.python.org/3.7/glossary.html#term-hashable From e6100b7c9714ff664a80c03c507fbe893326b1e8 Mon Sep 17 00:00:00 2001 From: BethanyG Date: Tue, 20 Jul 2021 19:54:02 -0700 Subject: [PATCH 3/8] Added introduction.md. --- concepts/sets/introduction.md | 17 +++++++++++++++-- 1 file changed, 15 insertions(+), 2 deletions(-) diff --git a/concepts/sets/introduction.md b/concepts/sets/introduction.md index fcde74642c..b2eaddc8e6 100644 --- a/concepts/sets/introduction.md +++ b/concepts/sets/introduction.md @@ -1,2 +1,15 @@ -#TODO: Add introduction for this concept. - +# Sets + +A [`set`][type-set] is a mutable and _unordered_ collection of _hashable_ objects. +Items within a `set` are unique, and no duplicates are allowed. +Like most collections, `sets` can hold any (or multiple) data type(s) -- as long as those types can be [hashed][hashable]. +Sets also come in an _immutable_ [`frozenset`][type-frozenset] flavor. + +Like other collection types, `sets` support membership testing through `in`, length calculation through `len()`, shallow copies through `copy()`, & iteration via `for item in `. +_Unlike_ sequence types (_`string`, `list` & `tuple`_), `sets` are **neither ordered nor indexed**, and _do not support_ slicing, sorting, or other sequence-type behaviors. + +`sets` are most commonly used to quickly dedupe groups of items. + +[type-set]: https://docs.python.org/3/library/stdtypes.html#set +[hashable]: https://docs.python.org/3.7/glossary.html#term-hashable +[type-frozenset]: https://docs.python.org/3/library/stdtypes.html#frozenset From ff2241cf272290cb48a5513b415320ec7ee44849 Mon Sep 17 00:00:00 2001 From: BethanyG Date: Tue, 20 Jul 2021 19:54:27 -0700 Subject: [PATCH 4/8] Added links.json file. --- concepts/sets/links.json | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/concepts/sets/links.json b/concepts/sets/links.json index eb5fb7c38a..1ad0ee4beb 100644 --- a/concepts/sets/links.json +++ b/concepts/sets/links.json @@ -1,18 +1,18 @@ [ { - "url": "http://example.com/", - "description": "TODO: add new link (above) and write a short description here of the resource." + "url": "https://docs.python.org/3/library/stdtypes.html#set", + "description": "Python Documentation on Standard Types: Set" }, { - "url": "http://example.com/", - "description": "TODO: add new link (above) and write a short description here of the resource." + "url": "https://realpython.com/python-sets/", + "description": "Real Python: Sets in Python." }, { - "url": "http://example.com/", - "description": "TODO: add new link (above) and write a short description here of the resource." + "url": "https://towardsdatascience.com/5-pythons-sets-problems-to-solve-before-your-coding-interview-41bb1d14ac25", + "description": "5 Problems with Sets to Solve (Towards Data Science)" }, { - "url": "http://example.com/", - "description": "TODO: add new link (above) and write a short description here of the resource." + "url": " http://notes.imt-decal.org/sets/cheat-sheet.html", + "description": "Set and Logic symbols cheat sheet." } ] From 4e7450afbd2e3bd7da06d57d7a8058acb8a484ac Mon Sep 17 00:00:00 2001 From: BethanyG Date: Tue, 20 Jul 2021 19:54:58 -0700 Subject: [PATCH 5/8] Added and edtied set design.md file. --- exercises/concept/sets/.meta/design.md | 94 +++++++++++++++++--------- 1 file changed, 62 insertions(+), 32 deletions(-) diff --git a/exercises/concept/sets/.meta/design.md b/exercises/concept/sets/.meta/design.md index 62b644eca5..c94d703c6c 100644 --- a/exercises/concept/sets/.meta/design.md +++ b/exercises/concept/sets/.meta/design.md @@ -1,38 +1,68 @@ -# Design - -## Learning Objectives - -- Access values in a tuple via index using [] (bracket notation). -- Create a tuple via constructor (tuple(_iterable_)) and/or literal (a,b,c or (a, b, c)) -- Understand that tuples are an **immutable data type** (like strings). Changing a tuple means creating a new copy. -- Understand that tuples can contain other tuples. (e.g. tuples can be nested). -- Create a new tuple from two or more previous tuples via concatenation using the `+` operator. -- Iterate through a tuple using `for item in`. -- Check for membership of an item in a given tuple using the `in` keyword. -- Understand that it is the comma in a sequence that makes a tuple, and that the () are optional, except for denoting an empty tuple or when omitting them creates ambiguity. - -## Out of Scope - -- Common Sequence type methods such as `min()`, `max()`, `x.index()`, `x.count()`, `len()` -- Slicing or slice notation ([start:stop:step]) -- Additional builtin functions as they relate to this data structure (e.g. `sorted()`, `enumerate()`, `reversed()`, or `hash()`. -- Knowing that tuples can be used as objects in other data structures, -- e.g. " a "List of tuples", "tuples as keys in Dictionaries", or "A Set of tuples". -- Hash-ability and when a tuple is not hash-able. -- Related [collections](https://docs.python.org/3/library/collections.html#collections.namedtuple) module with `namedtuple()` -- Related [dataclass](https://docs.python.org/3.7/library/dataclasses.html) and `@dataclass` decorator -- Memory storage and performance characteristics. +## Goal + +The goal of this exercise is to teach the basics of [`sets`][set type] (_set type_) in Python. + + +## Learning objectives + +* understand that a set is an **unordered collection of distinct hashable objects** +* create a `set` via constructor (`set()`) and literal (`{}`) +* de-dupe a list of elements by converting a sequence type such as a `list` to a `set` type +* check for a membership of an element in a given set via `in` +* set comparison functions and set comparison operators (`=<`, `>=`, `issubset()`, `issuperset()`, etc.) +* additional set operators (`union`, `intersection`, `difference`, and `symmetric_difference`) +* add values to a given set via `add()` +* remove values from a given set via `discard()` +* iterate through a given set by using `for item in ` and `for index, item in enumerate()` +* understand that iterating through a set twince may result in a different iteration order (_sets are unordered_) + +## Out of scope + +* `frozenset()` +* `clear()` to delete all elements of a set +* check the length of a given set via `len()` +* `remove` as opposed to `discard` (_`remove` tosses a `keyerror` if the element is not present_) +* all forms/variants of `update()` +* remove (and use) a value from a given set via `pop()` +* make shallow copy(s) of a given set via `copy()` +* using additional builtins such as `sorted()`, `min()`, or `map()` with a set +* set comprehensions ## Concepts -- `tuples` +* `sets` +* [`hashable`][term-hashable] objects +* `set` comparisons +* `set` operations ## Prerequisites -- `booleans` -- `for-loops` -- `functions` -- `if-keyword` -- `in-keyword` -- `integers` -- `return-keyword` -- `strings` +* `basics` +* `booleans` +* `comparisons` +* `dicts` +* `lists` +* `loops` + +## Resources to refer to + +* [Set Types (Python Official Docs)][set types](https://docs.python.org/3/library/stdtypes.html#set-types-set-frozenset) +* [Hashable (Python Official Docs Glossary)][term-hashable] +* [immutable (Python Official Docs Glossary)][term-immutable] + +### Hints + +Hints should link to the `Sets` section of the Python docs tutorial: [Sets][sets-tutorial], or equivelent resources. + + +### After + +After, the student can explore comprehension syntax, although it will be taught in separate exercises. This would also be a good time to explore set comparisons via function &/or operator, or experimenting with the `issuperset()` & `issubset()` functions. + + + +[set type]: https://github.com/exercism/v3/blob/master/languages/python/reference/concepts/builtin_types/set.md +[set types]: https://docs.python.org/3/library/stdtypes.html#set-types-set-frozenset +[sets-tutorial]: https://docs.python.org/3/tutorial/datastructures.html#sets +[term-hashable]: https://docs.python.org/3/glossary.html#term-hashable +[term-immutable]: https://docs.python.org/3/glossary.html#term-immutable \ No newline at end of file From fcc05092b41562ba2a2df34328a9b9b7df409a22 Mon Sep 17 00:00:00 2001 From: BethanyG Date: Tue, 20 Jul 2021 20:01:12 -0700 Subject: [PATCH 6/8] Corrected bad link in links.json file. --- concepts/sets/links.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/concepts/sets/links.json b/concepts/sets/links.json index 1ad0ee4beb..769f590ce5 100644 --- a/concepts/sets/links.json +++ b/concepts/sets/links.json @@ -12,7 +12,7 @@ "description": "5 Problems with Sets to Solve (Towards Data Science)" }, { - "url": " http://notes.imt-decal.org/sets/cheat-sheet.html", + "url": "http://notes.imt-decal.org/sets/cheat-sheet.html", "description": "Set and Logic symbols cheat sheet." } ] From 5bb2b593184b14bbb30c20bf14cf3581eba46c44 Mon Sep 17 00:00:00 2001 From: BethanyG Date: Tue, 20 Jul 2021 19:54:27 -0700 Subject: [PATCH 7/8] Added links.json file. --- concepts/sets/links.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/concepts/sets/links.json b/concepts/sets/links.json index 769f590ce5..1ad0ee4beb 100644 --- a/concepts/sets/links.json +++ b/concepts/sets/links.json @@ -12,7 +12,7 @@ "description": "5 Problems with Sets to Solve (Towards Data Science)" }, { - "url": "http://notes.imt-decal.org/sets/cheat-sheet.html", + "url": " http://notes.imt-decal.org/sets/cheat-sheet.html", "description": "Set and Logic symbols cheat sheet." } ] From b559c91bfbc3827cab23cd2b2f18242bc64222a9 Mon Sep 17 00:00:00 2001 From: BethanyG Date: Tue, 20 Jul 2021 20:01:12 -0700 Subject: [PATCH 8/8] Corrected bad link in links.json file. --- concepts/sets/links.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/concepts/sets/links.json b/concepts/sets/links.json index 1ad0ee4beb..769f590ce5 100644 --- a/concepts/sets/links.json +++ b/concepts/sets/links.json @@ -12,7 +12,7 @@ "description": "5 Problems with Sets to Solve (Towards Data Science)" }, { - "url": " http://notes.imt-decal.org/sets/cheat-sheet.html", + "url": "http://notes.imt-decal.org/sets/cheat-sheet.html", "description": "Set and Logic symbols cheat sheet." } ]