We need a function ```count_sel()``` that receives an array or list of integers (positive and negative) and may give us the following information in the order and  structure presented bellow:

```[(1), (2), (3), [[(4)], 5]]```

(1) - Total amount of received integers.

(2) - Total amount of different values the array has.

(3) - Total amount of values that occur only once.

(4) and (5) both in a list

(4) - It is (or they are) the element(s) that has (or have) the maximum occurrence. If there are more than one, the elements should be sorted (by their value obviously)

(5) - Maximum occurrence of the integer(s)

Let's see some cases
```python
____ count_sel([-3, -2, -1, 3, 4, -5, -5, 5, -1, -5]) ----> [10, 7, 5, [[-5], 3]]

(1) - The list has ten elements (10 numbers)

(2) - We have seven different values: -5, -3, -2, -1, 3, 4, 5 (7 values)

(3) - The numbers that occur only once: -3, -2, 3, 4, 5 (5 values)

(4) and (5) - The number -5 occurs three times (3 occurrences)

____ count_sel([4, 4, 2, -3, 1, 4, 3, 2, 0, -5, 2, -2, -2, -5]) ----> [14, 8, 4, [[2, 4], 3]]
```
Enjoy it and happy coding!!

Difficulty: introductory

Starter code:

def count_sel(lst):
	

Solutions:
from collections import defaultdict, Counter


def count_sel(nums):
    cnt = Counter(nums)
    d = defaultdict(list)
    total = 0
    unique = 0
    for k, v in cnt.items():
        d[v].append(k)
        total += v
        unique += 1
    maximum = max(d)
    return [total, unique, len(d[1]), [sorted(d[maximum]), maximum]]


def count_sel(lst):
    occ = lst.count(sorted(lst, key=lambda x: lst.count(x), reverse=True)[0])
    return [len(lst), len(set(lst)), len([x for x in lst if lst.count(x) == 1]), [sorted(set(x for x in lst if lst.count(x) == occ)), occ]]


from collections import Counter


def count_sel(lst):
    c = Counter(lst)
    m = max(c.values())
    return [
        len(lst),
        len(c),
        sum(x == 1 for x in c.values()),
        [sorted(k for k, v in c.items() if v == m), m,],
    ]

def count_sel(lst):
    dic = {}
    result = []
    arr_temp = []
    for elm in lst:
        if elm not in dic:
            dic[elm] = 1
        else:
            dic[elm] += 1
    result.append(len(lst))
    result.append(len(dic.keys()))
    result.append(list(dic.values()).count(1))
    for elm, occurrence in dic.items():
        if occurrence == max(dic.values()):
            arr_temp.append(elm)
    result.append([sorted(arr_temp), max(dic.values())])
    return result

def count_sel(lst):
    r = [len(lst),len(set(lst)),sum(lst.count(i)==1 for i in set(lst))]
    rm = max(lst.count(i) for i in set(lst))
    rv = sorted(i for i in set(lst) if lst.count(i)==rm)    
    r.append([rv,rm])
    return r

from collections import Counter

def count_sel(lst):
    freq = Counter(lst)
    return [len(lst),len(set(lst)),len([x for x in lst if lst.count(x) == 1]),[sorted(k for k,v in list(freq.items()) if v == freq[max(freq, key=freq.get)]), freq[max(freq, key=freq.get)]]]


from collections import Counter, defaultdict

def count_sel(lst):
    c    = Counter(lst)
    freq = defaultdict(list)
    for n,v in c.items(): freq[v].append(n)
    maxF,fLst = max(freq.items(), default=(0,[]))
    
    return [len(lst),
            len(c),
            len(freq[1]),
            [ sorted(fLst),
              maxF] ]

import collections

def count_sel(lst):
    counter = collections.Counter(lst)
    mode_count = counter.most_common(1)[0][1] if lst else 0
    return [len(lst),
            len(counter),
            sum(v == 1 for v in counter.values()),
            [sorted(k for k, v in counter.items() if v == mode_count), mode_count]]

from collections import Counter
def count_sel(lst):
    one = sum(float(i).is_integer() for i in lst)
    two = len(set(lst))
    three = sum(lst.count(i)==1 for i in lst)
    four = [i for i in Counter(lst).most_common()]
    k = max(i[1] for i in four)
    four = sorted(i[0] for i in four if i[1]==k)
    five = lst.count(four[0])
    return [one, two, three, [four, five]]

from collections import Counter

def count_sel(lst):
    c = Counter(lst)
    length = len(lst)
    unique = len(c)
    once = sum(1 for elem, cnt in c.items() if cnt == 1)
    max_occur = max(c.values())
    most = sorted(elem for elem, cnt in c.items() if cnt == max_occur)
    
    return [length, unique, once, [most, max_occur]]