Pycharm error where it is running hidden in the background
du -d 1
rm -rf ./Pycharm.../

rm -rf .PyCharmCE2013.2/system
--------------------------------------------------------------------------------------------------------------------------
This lab is to give more practice on recursion and linkedlists.
To start with task 1, you need the code completed from last weeks RecursiveList class so if there are any methods you didnt implement, let me know and ill give them to you.

So task 1 is implementing a linkedlist with an iterator. An iterator is the value that changes within while and for loops such as "for i in range()", i is the iterator. So the goal of task 1 is to build another linkedlist and make it as similar to for loop as possible in terms of traversing through the nodes.

Remember that for Linkedlists, each index or item isnt a specific value. Its a node that holds a value.
Let me demonstrate what task 1 should look like.
>>> lst = LinkedList([1, 2, 3])
>>> for x in lst:
...     print(x)

    1
    2
    3
********************************************
TASK 1:------------------------------------------------
So what we are building for Task 1 is essentially that 'int i' variable that starts at 0, or in the linkedlists case, the head or first node and we keep traversing down the linkedlist for however many times. In this case, our iterator 'i' is an object and thus we need to make a class for it, our LinkedListIterator. So this if we need to create
    def __iter__(self) -> LinkedListIterator:
        """Return an iterator for this linked list.

        It should be straightforward to initialize the iterator here
        (see the class documentation below). Just remember to initialize
        it to the first node in this linked list.
        """
        return LinkedListIterator(self._first)


class LinkedListIterator:
    _curr: Optional[_Node]

    def __init__(self, first_node: Optional[_Node]) -> None:
        self._curr = first_node

    def __next__(self) -> Any:
        if self._curr is None:
            raise StopIteration

        item = self._curr.item
        self._curr = self._curr.next
        return item

TASK 2:------------------------------------------------
This task is rather difficult so by all means feel free to spend time on task two finishing up last weeks insert and insert_first methods that I gave for homework.

So copy your code into the last weeks labs recursivelist class and we begin developing the method. Again we want to return a list of recursive lists so we know we need an accumulator for the end result list as well as a temporary recursive list that we can build up and append to our accumulator list.

There are two examples given to you already but I just want to give another example.
Say we have a list with one element [10]. What collections should there be? [] and [10].
Say we have the list with two elements [5, 10]. What collections should there be? [], [5], [10], [5, 10].

Notice a trend?
0 elements gives us 1 selection
1 element  gives us 2 selections
2 elements gives us 4 selections
3 elements gives us 8 selections

See the pattern? We always expect 2^n selections where n is the number of element in our list. Make sure that every selection is not a list, but is a recursivelist(). So with 0 elements, need to build 1 recursivelist that is empty. With 1 element, need to build 2 recursivelists and so on.

def selections(self) -> List[RecursiveList]:
        """Return a list of all selections from this list.

        You can return the selections in any order.

        >>> lst1 = RecursiveList([])
        >>> selections1 = lst1.selections()
        >>> len(selections1)
        1
        >>> selections1[0].is_empty()
        True
        >>> lst2 = RecursiveList([1, 2, 3])
        >>> len(lst2.selections())
        8
        """
        if self.is_empty():
            ...
        else:
            rest_selections = self._rest.selections()
            ...
---------------------------------------------------------------------------------------------------------------------------
Quiz 7:
This question is tricky but if you remember the nested_list_equal() function from the last lab, it follows a similar idea.
Apparently you have see this something similar to this in lecture but with constructs (such as any or all). Here you are to try and complete the function without either of these. You also shouldnt need any list comprehension methods either such as append and pop. HOWEVER, you can use logical operators and will need them. Those operators consist of not, or and and.

There are multiple solutions to this problem and I do recommend going on python visualizer and tracing the code. Bogdan mentions there is also a solution with two different loops so by all means compare this code with yours on a doctest and give it a go. On the exam, if you are not given doctests thus having to create your own doctests AND the code you write fulfills your doctests, you will get part marks. But to be safe, make sure to clarify with TAs.

def semi_homogeneous(obj) -> Bool:
	"""
	>>> semi_homogeneous([])
	True
	>>> semi_homogeneous(1)
	True
	>>> semi_homogeneous([1, 2, 3])
	True
	>>> semi_homogeneous([1, []])
	False
	"""
    if isinstance(obj, int):
        return True
    elif obj == []:
        return True
    else:
        all_ints = True
        all_lists = True
        all_semi = True
        # check all ints
        for sublist in obj:
            if isinstance(sublist, int):
                all_lists = False
            elif isinstance(sublist, list):
                all_ints = False
                all_semi = semi_homogeneous(sublist)

        return (all_ints or all_lists) and all_semi