Implement new Concept Exercise: none exercism#1031 (#2283)

* Added Python Concept Exercise None

* Ran Prettier for Linting

* Updated Story and new Exercises

* Review 1 None-Intro.md

* Review Changes 2

Author: mohanrajanr

exercises/concept/none/.docs/after.md

@@ -0,0 +1,41 @@
+All variables that are assigned `None` point to the same object. New instances of `None` are not created, that is `None` by nature is of type Singleton.
+
+Example, when you assign 2 variables with `None`, both point to the same object.
+
+```python
+a = None
+b = None
+a == b
+#=> True
+```
+
+Python will also return `None` from a function that doesn't already have a stated `return` value, making it easy to check if the function completed without errors.
+
+```python
+def test_func():
+    pass
+test_func()
+#=> returns None
+
+def test_func2():
+    return
+#=> returns None
+```
+
+The `None` Object is a singleton of class `NoneType`. So when you find the type of a variable which is assigned with `None` it will always be of type `NoneType`.
+
+```python
+a = None
+type(a)
+#=> <class 'NoneType'>
+```
+
+When you toggle a variable between a value and `None`, what basically happens is a reset of the variable.
+
+```python
+
+a = [] #=> Variable 'a' is pointing to a list
+
+a = None #=> Variable 'a' is reset to an empty state. the value of a is now absent.
+
+```

exercises/concept/none/.docs/hints.md

@@ -0,0 +1,27 @@
+## General
+
+- In Python, `None` is frequently used as a placeholder to represent the **absence of a value** for a variable, object, or argument.
+
+## 1. Make New Seating Chart
+
+Remember, you will need to create an empty dictionary first. Next, fill the dictionary _keys_ with however many seats are available and set their _values_ to a **placeholder** to indicate that they are available but unassigned.
+
+## 2. Arrange Reservations
+
+- If there isn't a guest list, you will want to return a `new_seating_chart()` filled with placeholders. A `default argument` for your function might be helpful here. If you do have a guest list, you can start with a `new_seating_chart()`, then loop from 1 to the number of guests and assign them to seats in order.
+
+## 3. Find all Available Seats
+
+- You can loop through all the (key, value) pairs in a dictionary by calling `dict.items()`. You can verify that a variable or value is None through an `if statement` -- `if var is None` will return True if the value is `None`. You can add things to a `list` by calling `list.append()`
+
+## 4. Current seating capacity
+
+- You can loop through all of the values in the dict object by calling `dict.values()`. Seats are available when their value is `None`.
+
+## 5. Accommodate Waiting Guests
+
+- You need to find the current number of empty seats and check to see if it is greater than or equal to the number of guests waiting. If the guests can be accommodated, you will need to call `find_all_available_seats()` to get a list of seat numbers you can assign guests to. Remember that `range()` can take any sort of number as an argument....**including** the number returned from calling `len()` on a list. Also remember that using `list[index_number]` will return the **value** that is located at the **index number** inside the brackets.
+
+## 6. Empty the Seats
+
+- Given the seating chart `dict`, and a `list` of seat numbers, you'll want to indicate the seat is now available for another guest by replacing their name with a placeholder. Looping through the seat number list and looking for those seats in the dictionary might be helpful here.

exercises/concept/none/.docs/instructions.md

@@ -0,0 +1,74 @@
+The exercise has 6 challenges to complete.
+
+You are the Maître D' of a hotel restaurant. Your task is to manage the seating arrangements for the dining room according to the number of seats available today, number of reservations, and the "walk in" guests currently waiting to be seated. For the purposes of this exercise, seating is assigned by first available empty seat.
+
+You have 6 different dining room organization challenges to complete.
+
+## 1. Make Today's Seating Chart
+
+Define the `new_seating_chart()` function that takes a size argument representing the number of seats that will be set in the dining room today. If no `size` is given, the function should return a seating chart with 22 seats. Seat values should have a placeholder of `None` to indicate they are available to assign to a guest.
+
+## 2. Arrange Reservations
+
+Define the `arrange_reservations()` function with 1 parameter for a list of guest names. This represents the number of people who've reserved places in the dining room today.
+
+This function should return a `dict` seating chart of default size (22 seats), with guests assigned to seats in the order they appear on the reservation list. All unassigned seats should be set to `None`. If there are no guests, an "empty" seating chart with all `None` placeholders should be returned.
+
+```python
+arrange_reservatons(guests=["Walter", "Frank", "Jenny", "Carol", "Alice", "George"])
+#=> {1: 'Walter', 2: 'Frank', 3: 'Jenny', 4: 'Carol', 5: 'Alice', 6: 'George', 7: None, 8: None, 9: None, 10: None, 11: None, 12: None, 13: None, 14: None, 15: None, 16: None, 17: None, 18: None, 19: None, 20: None, 21: None, 22: None}
+```
+
+## 3. Find All the "Empty" Seats
+
+Define the `find_all_available_seats(seats)` function that takes 1 parameter (_a seating chart dictionary_) and returns a `list` of seat numbers that are available for guests that are currently waiting.
+If a seat is empty, It will be of `None` value in the dictionary. Occupied seats will have the name of the guest.
+
+```python
+seats = {1: None, 2: 'Frank', 3: 'Jenny', 4: None, 5: 'Alice', 6: 'George', 7: None, 8: 'Carol', 9: None, 10: None, 11: None, 12: 'Walter'}
+find_all_available_seats(seats)
+#>>>[1,4,7,9,10,11]
+```
+
+## 4. Current Empty Seating Capacity
+
+Define the `curr_empty_seat_capacity()` function that takes 1 parameter. The first parameter will list all the seats.
+
+You need to find out what is the total number of seats that are empty.
+
+```python
+curr_empty_seat_capacity(seats={1: "Occupied", 2: None, 3: "Occupied"})
+# => 1
+can_accomodate_seats(seats={1: "Occupied", 2: None, 3: None})
+# => 2
+```
+
+## 5. Should we wait?
+
+Define the `accommodate_waiting_guests(seats, guests)` function that takes two parameters. The first parameter will be a seating chart `dict`. The second parameter will be a `list` of guests who have "walked in" unexpectedly.  
+You'll first need to find out how many seats are available and whether or not you can even give the unannounced guests seats at this time.
+
+If you do not have enough seats, return `False`.
+
+If seats are available, you will want to give the guests places on the seating chart, and return it updated.
+Tip: You can use previously defined functions to do the calculations for you.
+
+```python
+starting_reservations = {1: 'Carol', 2: 'Alice', 3: 'George', 4: None, 5: None, 6: None, 7: 'Frank', 8: 'Walter'}
+accomodate_guests(starting_reservations, ["Mort", "Suze", "Phillip", "Tony"])
+#>>>False
+starting_reservations = {1: None, 2: None, 3: None, 4: 'Carol', 5: 'Alice', 6: 'George', 7: None, 8: None, 9: None, 10: None, 11: None, 12: None, 13: None, 14: None, 15: None, 16: None, 17: None, 18: 'Frank', 19:  'Jenny', 20: None, 21: None, 22: 'Walter'}
+accomodate_guests(starting_reservations, ["Mort", "Suze", "Phillip", "Tony"])
+#>>>{1: 'Mort', 2: 'Suze', 3: 'Phillip', 4: 'Carol', 5: 'Alice', 6: 'George', 7: 'Tony', 8: None, 9: None, 10: None, 11: None, 12: None, 13: None, 14: None, 15: None, 16: None, 17: None, 18: 'Frank', 19: 'Jenny', 20: None, 21: None, 22: 'Walter'}
+```
+
+## 6. Empty Seats
+
+Define the `empty_seats()` function that takes two parameters. The first parameter will be a seating chart dictionary. The second parameter is a list of seat numbers you need to "free up" or empty -- that is, you need to assign the seat number value to `None`.
+
+Return the `dict` of seats sent as the parameter after updating the empty seat values.
+
+```python
+empty_seats(seats={1: "Alice", 2: None, 3: "Bob", 4: "George", 5: "Gloria"}, seat_numbers=[5,3,1])
+# => {1: None, 2: None, 3: None, 4: "George", 5: None}
+```

exercises/concept/none/.docs/introduction.md

@@ -0,0 +1,27 @@
+In Python, `None` is frequently used to represent the absence of a value -- a placeholder to define a `null` (empty) variable, object, or argument.
+
+If you've heard about or used a `NULL` or `nil` type in another programming language, then this usage of `None` in Python will be familiar to you. `None` helps you to declare variables or function arguments that you don't yet have values for. These can then be re-assigned to specific values later as needed.
+
+```python
+a = None
+print(a)
+#=> None
+type(a)
+#=> <class 'NoneType'>
+
+# Adding a Default Argument with `None`
+def add_to_todos(new_task, todo_list=None):
+  if todo_list is None:
+    todo_list = []
+    todo_list.append(new_task)
+  return todo_list
+
+```
+
+`None` will evaluate to `False` when used in a conditional check, so it is useful for validating the "presence of" or "absence of" a value - _any_ value -- a pattern frequently used when a function or process might hand back an error object or message.
+
+```python
+a = None
+if a: #=> a will be evaluated to False when its used in a conditional check.
+    print("This will not be printed")
+```

exercises/concept/none/.meta/config.json

@@ -0,0 +1,12 @@
+{
+  "authors": [
+    {
+      "github_username": "mohanrajanr",
+      "exercism_username": "mohanrajanr"
+    },
+    {
+      "github_username": "BethanyG",
+      "exercism_username": "BethanyG"
+    }
+  ]
+}

exercises/concept/none/.meta/design.md

@@ -0,0 +1,37 @@
+## Goal
+
+The goal of this exercise is to teach the student what None means and how None is used in Python.
+
+## Learning objectives
+
+- create a `None` object via literal declaration
+- check if an object is `None`
+- use a `None` object as a "False statement"
+- use `None` as a default parameter value
+
+## Out of scope
+
+- catching/raising Exceptions
+
+## Concepts
+
+- **none:**
+
+## Prerequisites
+
+- `bracket notation`,
+- `dicts`,
+- `dict-methods`,
+- `indexing`,
+- `len()`,
+- `lists`,
+- `list-methods`,
+- `loops()`,
+- `range()`
+
+## Resources
+
+- [the null object](https://docs.python.org/3/library/stdtypes.html#the-null-object)
+- [edspresso_none](https://www.educative.io/edpresso/what-is-the-none-keyword-in-python)
+- [none_keyword](https://docs.python.org/3/library/constants.html#None)
+- [None (Stackoverflow)](https://stackoverflow.com/questions/19473185/what-is-a-none-value)

exercises/concept/none/.meta/example.py

@@ -0,0 +1,43 @@
+def new_seating_chart(size=22):
+    seats = dict()
+    for number in range(1, size+1):
+        seats[number] = None
+    return seats
+
+def arrange_reservations(guests=None):
+    if guests is None:
+        return new_seating_chart()
+    else:
+        seats = new_seating_chart()
+        for seat_number in range(1, len(guests)):
+            seats[seat_number] = guests[seat_number]
+    return seats
+
+def find_all_available_seats(seats):
+    available = []
+    for seat_num, value in seats.items():
+        if value is None:
+            available.append(seat_num)
+    return available
+
+def curr_empty_seat_capacity(seats):
+    count = 0
+    for value in seats.values():
+        if value is None:
+            count += 1
+    return count
+
+def accommodate_waiting_guests(seats, guests):
+    curr_empty_seats = curr_empty_seat_capacity(seats)
+    empty_seat_list = find_all_available_seats(seats)
+    if len(guests) > curr_empty_seats:
+        return False
+    else:
+        for index in range(len(guests)):
+            seats[empty_seat_list[index]] = guests[index]
+    return seats
+
+def empty_seats(seats, seat_numbers):
+   for seat in seat_numbers:
+      seats[seat] = None
+   return seats

exercises/concept/none/none.py

@@ -0,0 +1,16 @@
+def new_seating_chart():
+    pass
+
+def arrange_reservations():
+    pass
+
+def find_all_available_seats():
+   pass
+
+def current_seating_capacity():
+   pass
+
+def accommodate_waiting_guests():
+   pass
+def empty_seats():
+    pass

exercises/concept/none/none_test.py

@@ -0,0 +1,90 @@
+import unittest
+from none import *
+
+
+class TestNoneType(unittest.TestCase):
+
+    def test_new_seating_chart_1(self):
+        self.assertDictEqual(
+            new_seating_chart(3),
+            {1: None, 2: None, 3: None},
+            msg="The New Seating chart does not match with the expected."
+        )
+    
+    def test_new_seating_chart_2(self):
+        self.assertDictEqual(
+            new_seating_chart(),
+            {1: None, 2: None, 3: None, 4: None, 5: None, 6: None, 7: None, 8: None, 9: None, 10: None, 11: None, 12: None, 13: None, 14: None, 15: None, 16: None, 17: None, 18: None, 19: None, 20: None, 21: None, 22: None},
+            msg="The New Seating chart does not match with the expected."
+        )
+    
+    def test_arrange_reservations_1(self):
+        self.assertDictEqual(
+            arrange_reservations(guests=["Walter", "Frank", "Jenny", "Carol", "Alice", "George"]),
+            {1: 'Frank', 2: 'Jenny', 3: 'Carol', 4: 'Alice', 5: 'George', 6: None, 7: None, 8: None, 9: None, 10: None, 11: None, 12: None, 13: None, 14: None, 15: None, 16: None, 17: None, 18: None, 19: None, 20: None, 21: None, 22: None},
+            msg="The reservation dict is incorrect"
+        )
+    
+    def test_arrange_reservations_2(self):
+        self.assertDictEqual(
+            arrange_reservations(),
+            {1: None, 2: None, 3: None, 4: None, 5: None, 6: None, 7: None, 8: None, 9: None, 10: None, 11: None, 12: None, 13: None, 14: None, 15: None, 16: None, 17: None, 18: None, 19: None, 20: None, 21: None, 22: None},
+            msg="The reservation dict is incorrect"
+        )
+    
+    def test_find_all_available_seats_1(self):
+        self.assertListEqual(
+            find_all_available_seats(seats = {1: None, 2: 'Frank', 3: 'Jenny', 4: None, 5: 'Alice', 6: 'George', 7: None, 8: 'Carol', 9: None, 10: None, 11: None, 12: 'Walter'}),
+            [1,4,7,9,10,11],
+            msg="The Available Seat list is incorrect"
+        )
+    
+    def test_find_all_available_seats_2(self):
+        self.assertListEqual(
+            find_all_available_seats(seats = {1: None, 2: None, 3: None, 4: None, 5: 'Alice', 6: None, 7: None, 8: None, 9: None, 10: None, 11: None, 12: None}),
+            [1, 2, 3, 4, 6, 7, 8, 9, 10, 11, 12],
+            msg="The Available Seat list is incorrect"
+        )
+
+    def test_curr_empty_seat_capacity_1(self):
+        self.assertIs(
+            curr_empty_seat_capacity({1: "Occupied", 2: None, 3: "Occupied"}),
+            1,
+            msg="the index of the seat which is empty is invalid."
+        )
+
+    def test_curr_empty_seat_capacity_2(self):
+        self.assertIs(
+            curr_empty_seat_capacity({1: "Occupied", 2: "Occupied", 3: None, 4: "Occupied", 5: None}),
+            2,
+            msg="the index of the seat which is empty is invalid."
+        )
+    
+    def test_accommodate_waiting_guests_1(self):
+        starting_reservations = {1: 'Carol', 2: 'Alice', 3: 'George', 4: None, 5: None, 6: None, 7: 'Frank', 8: 'Walter'}
+        self.assertFalse(
+            accommodate_waiting_guests(starting_reservations, ["Mort", "Suze", "Phillip", "Tony"]),
+            msg="The Accomodation of waiting guests are incorrect"
+        )
+
+    def test_accommodate_waiting_guests_2(self):
+        starting_reservations = {1: None, 2: None, 3: None, 4: 'Carol', 5: 'Alice', 6: 'George', 7: None, 8: None, 9: None, 10: None, 11: None, 12: None, 13: None, 14: None, 15: None, 16: None, 17: None, 18: 'Frank', 19:  'Jenny', 20: None, 21: None, 22: 'Walter'}
+        self.assertDictEqual(
+            accommodate_waiting_guests(starting_reservations, ["Mort", "Suze", "Phillip", "Tony"]),
+            {1: 'Mort', 2: 'Suze', 3: 'Phillip', 4: 'Carol', 5: 'Alice', 6: 'George', 7: 'Tony', 8: None, 9: None, 10: None, 11: None, 12: None, 13: None, 14: None, 15: None, 16: None, 17: None, 18: 'Frank', 19: 'Jenny', 20: None, 21: None, 22: 'Walter'},
+            msg="The Accomodation of waiting guests are incorrect"
+        )
+
+    def test_empty_seats_1(self):
+        self.assertDictEqual(
+            empty_seats(seats={1: "Alice", 2: None, 3: "Bob", 4: "George", 5: "Gloria"}, seat_numbers=[5,3,1]),
+            {1: None, 2: None, 3: None, 4: "George", 5: None},
+            msg="Seats are not emptied properly"
+        )
+
+    def test_empty_seats_2(self):
+        self.assertDictEqual(
+            empty_seats(seats={1: "Alice", 2: None, 3: "Bob", 4: "George", 5: "Gloria"}, seat_numbers=[]),
+            {1: "Alice", 2: None, 3: "Bob", 4: "George", 5: "Gloria"},
+            msg="Seats are not emptied properly"
+        )