Added algorithms and DAta structues, xrange and number converter

Author: omonimus1

README.md

@@ -1,3 +1,4 @@
+
 ## Chicken wings and python
 
 1. [What you can find in this repository](#What-you-can-find-in-this-repository)
@@ -18,10 +19,13 @@ A part these two main projects, you can find few of the exerices that I have mad
 * [Vocal Personal Assistant](personal-assistant/README.md)
 * [A byte of Computer Vision](computer-vision/README.md)
 * [Rock Scissor or Paper game](rock_scissor_paper/rock_scissor_paper.py)
-* Leap year : check if a given year is a leap year or not - [Source Code](LeapYear/leapYear.py)
+* [Algorithms and Datastructures in Pyhon](algorithm_and_datastructure/)
+* [Leap year : check if a given year is a leap year or not](LeapYear/leapYear.py)
 * [Guess the number game](guess_the_number/guessTheNumber.py)
 * [Calculate distance between any two points](distance/points.py)
 *  [given a natural string in input (in English language) and is able to print out the respective numeric encoding](DPOneySolution.py)
+* [Convert number a number to string, binary, octal and word](number_converter/number_converter.py)
+* [Difference between range and xrange](xrange_or_range/xrange_or_range.py)
 * [Form registration GUI with tkinter](form_registration_GUI/first_GUI.py)
 * [40 Python Interview questions](https://www.guru99.com/python-interview-questions-answers.html)
 

algorithm_and_datastructure/array.py

@@ -0,0 +1,28 @@
+'''
+	Author: Davide Pollicino 
+	Date: 27/01/2020
+	
+	Summary: Create an array in python using build it python data structure 
+'''
+
+
+def display(array):
+	# Print all the elements of the array in one line
+	for element in array:
+		print(element , end= " ")
+		
+
+		
+def main():
+	# Create an empty list / array
+	list = []
+	list.append(5)
+	list.append(3)
+	list.append(10)
+	print("Array created")
+	display(list)
+	print("\nSize of the list: {0}".format(len(list)))
+	print("\nLast element of the array: {0}".format(list.pop()))
+
+if __name__ == "__main__":
+	main()

algorithm_and_datastructure/binarySearchTree.py

@@ -0,0 +1,69 @@
+'''
+Author: Davide Pollicino
+Date: 05/02/2020
+Summary: Console application that stores different numbers in a BST (Binary Search Tree) and print the BST in according 
+         with the inorder, preorder and postOrder algorithms. 
+'''
+
+class Node: 
+    def __init__(self, key):
+        self.left = None
+        self.right = None
+        self.val = key
+
+
+# A utility function to insert a new node with the given key 
+def insert(root,node): 
+    if root is None: 
+        root = node 
+    else: 
+        if root.val < node.val: 
+            if root.right is None: 
+                root.right = node 
+            else: 
+                insert(root.right, node) 
+        else: 
+            if root.left is None: 
+                root.left = node 
+            else: 
+                insert(root.left, node) 
+
+
+# Travers our BST using the inorder algorithm 
+def inorder(root): 
+    if root: 
+        inorder(root.left) 
+        print(root.val) 
+        inorder(root.right) 
+
+
+# Travers our BST using the preOrder algorithm 
+def preoder(root):
+    if root: 
+        print(root.val)
+        preoder(root.left)
+        preoder(root.right)
+
+# Travers our BST using the postOrder algorithm 
+def postorder(root):
+    if root: 
+        postorder(root.left)
+        postorder(root.right)
+        print(root.val)
+
+
+# drive code for testing purposes 
+r = Node(50) 
+insert(r,Node(15)) 
+insert(r,Node(34)) 
+insert(r,Node(56)) 
+insert(r,Node(32)) 
+insert(r,Node(11)) 
+insert(r,Node(99)) 
+# Print inoder traversal of the BST
+print('Inorder: ') 
+inorder(r)
+print('Postorder: ')
+postorder(r)
+print('Preorder: ')
+preoder(r)

algorithm_and_datastructure/list_methods_implementation.py

@@ -0,0 +1,57 @@
+'''
+	Author: Davide Pollicno 
+	Date: 27/01/2020
+	Summary: Implementation of the most widely used API of python list
+'''
+
+# Built-in method: clear() -> It removes all the element from the list 
+def clear_method(array):
+	del array[:]
+	return array
+
+	
+def display(array):
+	for el in array:
+		print(el , end=" ")
+	
+	
+# Built-in method: len() -> returns the length / number of elements in a list 
+def length(array):
+	counter = 0
+	for i in array:
+		counter += 1
+	return counter
+	
+# Built-in method: count() -> It returns the number of elements in a list 
+def count_method(array):
+	return len(array)
+
+	
+# Built-in method: append() -> It add a new element at the last position of the list. 
+def append_method(array , element_to_add):
+	array[len(array):] = [element_to_add]
+	
+	
+# Starting point of the program
+def main():
+	array = []
+
+	append_method(array , 5)
+	append_method(array , 3)
+	append_method(array , 450)
+	append_method(array , 66)
+	append_method(array , 12)
+
+	print("Number of elements in the array: {0}".format(count_method(array)))
+	print("Array content: ")
+	display(array)
+
+	print("\nLength of the array: {0}".format(length(array)))
+	
+	clear_method(array)
+	print("\nArray content after clear method: ")
+	display(array)
+	
+	
+if __name__ == "__main__":
+	main()

algorithm_and_datastructure/queue.py

@@ -0,0 +1,27 @@
+'''
+Author: Davide Pollicino 
+Date: 05/02/2020
+
+Summary: Implement a queue in Python using a list
+'''
+# Create an empty list that we will be used a queue
+queue = []
+
+# Add elements in the queue
+queue.append(1)
+queue.append(2)
+queue.append(3)
+queue.append(4)
+
+# Print the content of the queue
+print(queue)
+
+# Pop elements from the list 
+print('Elements popped from the queue')
+print(queue.pop(0))
+print(queue.pop(0))
+print(queue.pop(0))
+
+# Print the content of the queue
+print('Content of the list: ')
+print(queue)

algorithm_and_datastructure/readMe.md

@@ -0,0 +1,47 @@
+## Algorithm And Data-structures
+
+### What you can find in this folder
+
+You will find the implementation of different data structures and algorithm using Python.
+
+### How to contribute
+1. Fork the repository
+2. Do the desired changes (add/delete/modify)
+3. Make a pull request
+
+### Mind that
+Constructive criticisms or code reviews of any kind are very much welcome.
+
+If you have any questions about the solutions you can find here, feel free to contact me at: [[email protected]](mailto:[email protected]?subject=[GitHub]%ChickenWingsAndPythonRepo)
+
+### Requirements
+
+* Python interpreter
+
+
+### Connect with me
+
+* [[email protected]](mailto:[email protected]?subject=[GitHub]%20CompetitiveProgrammigGuide)
+* [Linkedin](https://www.linkedin.com/in/davidepollicino7/)
+* [www.davidepollicino.com](http://davidepollicino.com/)
+
+### Notes
+In python, it is possible to implement a stack using 
+* list
+* deque
+* LifoQueue
+
+For our implementation, we have decided to implement a stack using a list
+
+## Queue
+Queue in Python can be implemented by the following ways:
+
+* list
+* collections.deque
+* queue.Queue
+
+* Enqueue: Adds an item to the queue. If the queue is full, then it is said to be an Overflow condition – Time Complexity : O(1)
+* Dequeue: Removes an item from the queue. The items are popped in the same order in which they are * pushed. If the queue is empty, then it is said to be an Underflow condition – Time Complexity : O(1)
+* Front: Get the front item from queue – Time Complexity : O(1)
+*Rear: Get the last item from queue – Time Complexity : O(1)
+

algorithm_and_datastructure/stack.py

@@ -0,0 +1,33 @@
+'''
+Author: Davide Pollicino 
+Date: 05/02/2020
+
+Summary: Implement a stack in Python using a list
+'''
+
+# Create an empty List that is going to be used as Stack 
+stack = []
+
+# Add (push()) value inside our stack 
+stack.append(1)
+stack.append(2)
+stack.append(3)
+stack.append(4)
+stack.append(5)
+
+# Print the content of the stack 
+print('\nStack: ')
+print(stack)
+
+# Pop elements from the stack
+print('\nstart of pop operations: ')
+print(stack.pop())
+print(stack.pop())
+print(stack.pop())
+print(stack.pop())
+
+print('\nStack after the pop operations: ')
+print(stack)
+
+# Get the size of the stack => Number of elements inside the list 
+print('Size of the stack:', len(stack))

number_converter/README.md

@@ -0,0 +1,3 @@
+## Number conversion
+
+The number conversion is a python exercise that uses the str(), oct(), hex() built in function. 

number_converter/number_converter.py

@@ -0,0 +1,27 @@
+#!/usr/local/bin/python
+"""
+Author: Davide Pollicino 
+Date: 06/05/2020
+Summary: Python script that having in input a number conver it in string, hexadecimal , 
+octal string prefixed with “0o” and binary, using the bin() method, that will 
+provide a string with a 'ob' prefix.
+"""
+
+from num2words import num2words  # pip install num2words
+
+
+def get_user_number():
+    number_to_convert = int(input('Inset a number to convert: '))
+    return number_to_convert
+
+
+def convert_number(number_to_convert):
+    print('Number in string ' + str(number_to_convert))
+    print('Number in words: ' + num2words(number_to_convert))
+    print('Number in decimal ' + bin(number_to_convert))
+    print('Number in oct ' + oct(number_to_convert))
+
+
+if __name__ == '__main__': 
+    number = get_user_number()
+    convert_number(number)

xrange_or_range/xrange_or_range.py

@@ -0,0 +1,36 @@
+#!/usr/local/bin/python
+"""
+Author: Davide Pollicino
+Date: 06/05/2020
+
+range() – This returns a range object (a type of iterable).
+xrange() – This function returns the generator object that can be used to 
+display numbers only by looping. Only particular range is displayed on demand 
+and hence called “lazy evaluation“
+"""
+
+# initializing a with range() 
+a = list(range(1,10000)) 
+  
+# initializing a with xrange() 
+"""
+In python 3 there is not anymore range adn xrange. 
+If we want a range object of type iterable we now need to do for example list(range(1, 1000))
+"""
+try:
+    # Python 2
+    x = xrange(1,10000)
+except NameError:
+    xrange = range
+    x = xrange(1,10000)
+
+
+# testing the type of a 
+print ("The return type of range() is : ") 
+print (type(a)) 
+# print (a) -> Output: ALl the numbers between 1 and 1000
+
+# testing the type of x 
+print ("The return type of xrange() is : ") 
+print (type(x)) 
+print (x)  # Output: range(1,1000)