new execises

Author: essepuntato

exercises/development/advanced/exercise-34.md

@@ -0,0 +1,61 @@
+## Development - Advanced, exercise 34
+
+### Text
+**Letter frequency** is the number of times letters of the alphabet appear on average in written language. It is possible to have a frequency sequence of a language, i.e. the use of letters showing trends in related letter frequencies, by returning the sequence of letters from the most frequent one to least frequent one. For instance, considering the following simple text
+
+> Alice was beginning to get very tired of sitting by her sister on the bank, and of having nothing to do 
+
+has the following letter frequencies:
+
+```
+'n': 10  'i': 9'   't': 9   'e': 8   'o': 7    'g': 6
+'a': 5   's': 4    'r': 4   'h': 4   'b': 3    'd': 3
+'v': 2   'y': 2    'f': 2   'l': 1   'c': 1    'w': 1   'k': 1
+```
+
+and the frequency sequence is represented by the string `"niteogasrhbdvyflcwk"`, where no punctuation and other non-letters are included. It is worth mentioning that, in the frequency sequence, letters having the same frequency are ordered according to their first occurrence in the input text – e.g. 'l' comes before 'c' because the first occurrence of the first letter happens before the first occurrence of the second one (in the word "Alice"). In addition, the input text is considered as lowercase when counting the frequencies.
+
+Write an algorithm in Python – `def sequence(s)` – which takes in input a string `s` representing a text, and returns another string representing the fingerprint of such an input string.
+
+
+### Solution
+```python
+from collections import deque
+
+# Test case for the function
+def test_sequence(s, expected):
+    result = sequence(s)
+    if result == expected:
+        return True
+    else:
+        return False
+
+
+# Code of the function
+def sequence(s):
+    count = {}
+    for c in s.lower():
+        if c not in [".", ",", ";", " ", ":", "'"]:
+            if c not in count:
+                count[c] = 0
+            count[c] += 1
+    
+    result = list()
+    sorted_values = deque(sorted(count.values()))
+    while len(sorted_values) > 0 and len(count) > 0:
+        cur_count = sorted_values.pop()
+        for c in s.lower():
+            char_count = count.get(c)
+            if char_count is not None and char_count == cur_count:
+                result.append(c)
+                del count[c]
+    
+    return "".join(result)
+    
+            
+# Tests
+print(test_sequence("Alice was beginning to get very tired of sitting by her sister on the bank, and of having nothing to do", "niteogasrhbdvyflcwk"))
+``` 
+
+### Additional material
+The runnable [Python file](exercise_34.py) is available online.

exercises/development/advanced/exercise-35.md

@@ -0,0 +1,51 @@
+## Development - Advanced, exercise 35
+
+### Text
+The **index of coincidence** (IC) provides a measure of how likely it is to draw two matching letters by randomly selecting two letters from a given text. The chance of drawing a given letter in the text is calculated by number of times that letter appears divided by length of the text (excluding spaces and punctuation, and considering all letters in lowercase). The chance of drawing that same letter again (without replacement) is the number of occurrences of that letter minus one, divided by the lengh of the text minus one. The product of these two values gives you the chance of drawing that letter twice in a row. One can find this product for each letter that appears in the text, then sum these products to get a chance of drawing two of a kind. This probability is then be normalized by multiplying it by some coefficient c dependant of the language of the text, as shown in the following formula:
+
+<img src="img/ic.png" alt="IC" style="max-height:35px;" />
+
+where *n<sub>a</sub>* is the number of occurrences of the letter *a* in the text, *n<sub>b</sub>* is is the number of occurrences of the letter *b* in the text, and so on (considering all letters in the alphabeth), and *N* is the total number of letters in the text.
+Write an algorithm in Python – `def ic(s, c)` – which takes in input a string `s` representing a text and a number `c` representing the coefficient mentioned in the formula above, and returns a number representing the index of coincidence for the input text.
+
+
+### Solution
+```python
+# Test case for the function
+def test_ic(s, c, expected):
+    result = ic(s, c)
+    # For testing it, I've approximated the result to integer
+    if int(result) == int(expected):
+        return True
+    else:
+        return False
+
+
+# Code of the function
+def ic(s, c):
+    result = 0
+
+    en_alphabeth = "abcdefghijklmnopqrstuvwxyz"
+    s_len = 0
+    for char in s:
+        if char.lower() in en_alphabeth:
+            s_len += 1
+
+    for letter in en_alphabeth:
+        letter_count = 0
+        for char in s:
+            if char.lower() == letter:
+                letter_count += 1
+            result += (letter_count / s_len) * ((letter_count - 1) / (s_len - 1))
+    
+    return c * result
+
+    
+            
+# Tests
+print(test_ic("Alice was beginning to get very tired of sitting by her sister on the bank, and of having nothing to do", 26, 57))
+print(test_ic("This is another text in english", 26, 19))
+``` 
+
+### Additional material
+The runnable [Python file](exercise_35.py) is available online.

exercises/development/advanced/exercise-36.md

@@ -0,0 +1,47 @@
+## Development - Advanced, exercise 36
+
+### Text
+The **Vigenère cipher** is a method of encrypting alphabetic text where each letter of the input text is replaced by a letter some fixed number of positions down the alphabet, and the number of positions is determined by the corresponding letter of another input text, the key. For example, if the input text is `"another exam"` and the key is `"bucainangolo"`, then:
+
+* the first letter *a* of the input text is shifted by 1 position in the alphabet (because the first letter *B* of the key is the 2nd letter of the English alphabet, counting from 0), yielding *b*;
+* the second letter *n* is shifted by 20 (because the second letter *U* of the key means 20) yielding *h*, with wrap-around;
+* the third letter *o* is shifted by 2 (*C*) yelding *q*, with wrap-around;
+* and so on; yielding the message `"bhqtprr klla"` (all spaces are preserved).
+
+Write an algorithm in Python – `def vigenere(text, key)` – which considers only English texts, and takes in input a string `text` in lowercase representing the input text to cipher and another lowercase string `key` representing the key for the cipher – where both text and key contain the same number of characters, i.e. `len(text)` is equal to `len(key)`. The algorithm must return the encrypted text according to the rules described above.
+
+
+### Solution
+```python
+# Test case for the function
+def test_vigenere(text, key, expected):
+    result = vigenere(text, key)
+    if result == expected:
+        return True
+    else:
+        return False
+
+
+# Code of the function
+def vigenere(text, key):
+    result = list()
+
+    a = "abcdefghijklmnopqrstuvwxyz"
+    for idx, c in enumerate(text):
+        if c in a:
+            a_idx = a.index(c)
+            k_idx = a.index(key[idx])
+            result.append(a[(a_idx + k_idx) % len(a)])
+        else:
+            result.append(" ")
+    
+    return "".join(result)
+    
+          
+# Tests
+print(test_vigenere("attacking tonight", "oculorhinolaringo", "ovnlqbpvt eoeqtnh"))
+print(test_vigenere("another exam", "bucainangolo", "bhqtprr klla"))
+``` 
+
+### Additional material
+The runnable [Python file](exercise_36.py) is available online.

exercises/development/advanced/exercise-37.md

@@ -0,0 +1,56 @@
+## Development - Advanced, exercise 37
+
+### Text
+**Trial division** is one of the integer factorisation algorithms. The idea is to see if an integer n greater than 1, provided as input, can be divided by each number in turn from 2 to n. For example:
+
+* for the integer *n = 12*, the list of factors dividing it is *2, 2, 3* (i.e. *12 = 2 * 2 * 3*);
+* for the integer *n = 11*, the list of factors dividing it is *11* (i.e. *11 = 11*, since 11 is prime andm thus, it can be divided by itself only);
+* for the integer *n = 15*, the list of factors dividing it is *3, 5* (i.e. *15 = 3 * 5*).
+
+The algorithm proceed by dividing the input number starting from the smallest possible number *f*, initially set to 2. If the division returns a reminder, it repeat the operation by incrementing f of one unit. Instead, if the division returns no reminder, *f* is added to the list of factors, and n will be assigned with the result of the division, before repeating the operation. For instance, considering *n = 18*, the initial *f = 2*, and the list of factors to return initially empty:
+
+1. 18 / 2 = 9 (with no remainder) → list of factors: 2; n = 9
+2. 9 / 2 = 4 (with remainder 1) → f = 3
+3. 9 / 3 = 3 (with no remainder) → list of factors: 2, 3; n = 3
+4. 3 / 3 = 1 (with no reminder) → list of factors: 2, 3, 3; n = 1
+
+The algorithm stop when *f* is greater than *n*, and returns the list of factors.
+
+Write an algorithm in Python – `def trial_div(n)` – which takes in input an integer `n` greater than 1, and returns the list with the factors dividing `n` according to the rules described above.
+
+
+### Solution
+```python
+# Test case for the function
+def test_trial_div(n, expected):
+    result = trial_div(n)
+    if result == expected:
+        return True
+    else:
+        return False
+
+
+# Code of the function
+def trial_div(n):
+    result = []
+    f = 2
+
+    while not f > n:
+        if n % f == 0:
+            result.append(f)
+            n = n / f
+        else:
+            f = f + 1
+    
+    return result
+    
+            
+# Tests
+print(test_trial_div(12, [2, 2, 3]))
+print(test_trial_div(11, [11]))
+print(test_trial_div(15, [3, 5]))
+print(test_trial_div(18, [2, 3, 3]))
+``` 
+
+### Additional material
+The runnable [Python file](exercise_37.py) is available online.

exercises/development/advanced/exercise-38.md

@@ -0,0 +1,71 @@
+## Development - Advanced, exercise 38
+
+### Text
+The **PageRank** is an algorithm used by Google Search to rank web pages in their search engine results. It works on a directed graph where nodes represent webpages and each directed edge is a link connecting a source webpage to a target one. Each node of the graph has associated a PageRank that measures its relative importance within the graph (the greater, the more important).
+
+In its simplified version, it is computed as follows. It takes in input a directed graph where each node a potential PageRank transfer value to share with other nodes set to 1. Then, the algoritm transfers the such potential value of a given node to the targets of its outbound links, dividing such a value equally among all outbound links. For instance, suppose that page B had a link to pages C and A, page C has a link to page A, and page D has links to all three pages. Thus, page B would transfer half of its existing value (0.5) to page A and the other half (0.5) to page C. Page C would transfer all of its existing value (1) to the only page it links to, A. Since D had three outbound links, it would transfer one third of its existing value, or approximately 0.33, to A, B and C. The sum of all the values that are transferred to a given node is the PageRank of that node – for instance, page A will have a PageRank of approximately 1.83.
+
+Write an algorithm in Python – `def simplified_pr(g)` – which takes in input a directed graph created using the networkx library, and returns a dictionary having as many key-value pairs as the number of the nodes in the graph. In particular, each pair has the name of a node as the key and the PageRank of that node as the value. It is possible to use the method `adj[n]` of a graph for getting all the nodes reacheable from a node `n` by following its outbound edges. For instance, considering the example shown above stored as a `DiGraph` in the variable `my_g`, the execution of `my_g.adj["D"]` returns a collection containing the nodes A, B and C.
+
+
+### Solution
+```python
+from networkx import DiGraph
+
+
+# Test case for the function
+def test_simplified_pr(g, expected):
+    result = simplified_pr(g)
+    
+    if len(result) == len(expected):
+        test_res = True
+        for key in result:
+            if round(result[key], 2) != round(expected[key], 2):
+                test_res = False
+        return test_res
+    else:
+        return False
+
+
+# Code of the function
+def simplified_pr(g):
+    result = {}
+
+    for n in g.nodes:
+        if n not in result:
+            result[n] = 0
+        
+        adj_n = g.adj[n]
+
+        if len(adj_n):
+            value = 1 / len(adj_n)
+
+            for a in adj_n:
+                if a not in result:
+                    result[a] = 0
+                result[a] += value
+
+    return result
+    
+            
+# Tests
+my_g = DiGraph()
+my_g.add_edge("B", "C")
+my_g.add_edge("B", "A")
+my_g.add_edge("C", "A")
+my_g.add_edge("D", "A")
+my_g.add_edge("D", "B")
+my_g.add_edge("D", "C")
+
+res = {
+    "A": 1.83,
+    "B": 0.33,
+    "C": 0.83,
+    "D": 0
+}
+
+print(test_simplified_pr(my_g, res))
+``` 
+
+### Additional material
+The runnable [Python file](exercise_38.py) is available online.

exercises/development/advanced/exercise-39.md

@@ -0,0 +1,41 @@
+## Development - Advanced, exercise 39
+
+### Text
+The **Sørensen–Dice coefficient** is a statistic used to gauge the similarity of two samples, that was intended to be applied to discrete data. Given two sets, A and B, it is defined as twice the number of elements common to both sets divided by the sum of the number of elements in each set, as defined in the following formula:
+
+<img src="img/sd.png" alt="Sørensen–Dice coefficient" style="max-height:35px;" />
+
+Write an algorithm in Python – `def sd_coeff(s1, s2)` – which takes in input two sets and returns the number defining the Sørensen–Dice coefficient for those sets.
+
+
+### Solution
+```python
+# Test case for the function
+def test_sd_coeff(s1, s2, expected):
+    result = sd_coeff(s1, s2)
+    print(result)
+    if result is not None and (round(result, 2) == round(expected, 2)):
+        return True
+    else:
+        return False
+
+
+# Code of the function
+def sd_coeff(s1, s2):
+    count = 0
+    for i in s1:
+        if i in s2:
+            count += 1
+    
+    den = len(s1) + len(s2)
+
+    return (2 * count) / den
+    
+            
+# Tests
+print(test_sd_coeff({1, 2, 3}, {1, 2, 3}, 1.0))
+print(test_sd_coeff({1, 2}, {1, 2, 3}, 0.8))
+``` 
+
+### Additional material
+The runnable [Python file](exercise_39.py) is available online.

exercises/development/advanced/exercise_34.py

@@ -0,0 +1,50 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) 2022, Silvio Peroni <essepuntato@gmail.com>
+#
+# Permission to use, copy, modify, and/or distribute this software for any purpose
+# with or without fee is hereby granted, provided that the above copyright notice
+# and this permission notice appear in all copies.
+#
+# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+# REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+# FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT,
+# OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+# DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
+# ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+# SOFTWARE.
+
+from collections import deque
+
+# Test case for the function
+def test_sequence(s, expected):
+    result = sequence(s)
+    if result == expected:
+        return True
+    else:
+        return False
+
+
+# Code of the function
+def sequence(s):
+    count = {}
+    for c in s.lower():
+        if c not in [".", ",", ";", " ", ":", "'"]:
+            if c not in count:
+                count[c] = 0
+            count[c] += 1
+    
+    result = list()
+    sorted_values = deque(sorted(count.values()))
+    while len(sorted_values) > 0 and len(count) > 0:
+        cur_count = sorted_values.pop()
+        for c in s.lower():
+            char_count = count.get(c)
+            if char_count is not None and char_count == cur_count:
+                result.append(c)
+                del count[c]
+    
+    return "".join(result)
+    
+            
+# Tests
+print(test_sequence("Alice was beginning to get very tired of sitting by her sister on the bank, and of having nothing to do", "niteogasrhbdvyflcwk"))