DSA

Author: arbitrarymahi

Class_fraction.py

@@ -0,0 +1,22 @@
+from Fraction import Fraction,gcd 
+#fra.show()
+f1 = Fraction(3,2)
+f2 = Fraction(5,2)
+print("%s + %s = "%(f1,f2)),
+print(f1+f2)
+print(f1-f2)
+print(f1*f2)
+print(f1/f2)
+print(f1==f2) 	#checks only for  shallow equality i.e. 
+				#whether both var reference to same object
+f3 = f1 		#assigning reference of f1 to f3, i.e. both points to same object
+print(f1==f3) 	#hence shallow equality is true
+print(f1==f2) 
+
+print(f1<=f2) 
+print(f1>=f2)
+
+print f1.get_num()
+print f1.get_den()
+
+

Deque.py

@@ -0,0 +1,24 @@
+class Deque:
+    def __init__(self):
+        self.items = []
+        
+    def is_empty(self):
+        return self.items == []
+        
+    def add_front(self, item):
+        self.items.append(item)
+        
+    def add_rear(self, item):
+        self.items.insert(0, item)
+        
+    def remove_front(self):
+        return self.items.pop()
+        
+    def remove_rear(self):  
+        return self.items.pop(0)
+        
+    def size(self):
+        return len(self.items)
+        
+    def __str__(self):
+        return (str(self.items))

Deque.pyc

@@ -0,0 +1,14 @@
+from Deque import Deque
+
+dq = Deque()
+
+print(dq.is_empty())
+print(dq.add_rear(4))
+print(dq.add_rear('dog'))
+print(dq.add_front('cat'))
+print(dq.add_front(True))
+print(dq.size())
+print(dq.is_empty())
+print(dq.add_rear(8.4))
+print(dq.remove_rear())
+print(dq.remove_front())

Deque1.py

@@ -0,0 +1,23 @@
+from Deque import Deque
+
+def pal_checker(test_string):
+    tst_str = Deque()
+    
+    for ch in test_string:
+        tst_str.add_front(ch)
+       
+    pal_flag = True
+    
+    while tst_str.size() > 1 and pal_flag:
+        first_c = tst_str.remove_front()
+        last_c = tst_str.remove_rear()
+                
+        if first_c != last_c:
+            pal_flag = False
+           
+    return pal_flag
+    
+print(pal_checker('qasdfghfdsa'))
+print(pal_checker('asdfggfdsa'))
+print(pal_checker('asdfgfdsa'))
+print(pal_checker('1234321'))

Deque_palindrome.py

@@ -0,0 +1,97 @@
+class Fraction:
+	"""docstring fos Fraction"""
+	def __init__(self, up,down):
+		x = gcd(up,down)
+		self.num = up/x
+		self.den = down/x
+
+	def show(self):
+		#print('%d/%d'%(self.num,self.den))
+		print self.num,"/",self.den
+
+	def __str__(self):
+		return str(self.num)+"/"+str(self.den)
+
+	def __add__(self,other):
+		sum_num = self.num*other.den + self.den*other.num
+		sum_den = self.den*other.den
+		temp = gcd(sum_num,sum_den)
+		return str(sum_num/temp)+'/'+str(sum_den/temp)
+
+	def __sub__(self,other):
+		sum_num = self.num*other.den - self.den*other.num
+		sum_den = self.den*other.den
+		temp = gcd(sum_num,sum_den)
+		return str(sum_num/temp)+'/'+str(sum_den/temp)
+
+	def __mul__(self,other):
+		sum_num = self.num*other.num
+		sum_den = self.den*other.den
+		temp = gcd(sum_num,sum_den)
+		return str(sum_num/temp)+'/'+str(sum_den/temp)
+
+	def __div__(self,other):
+
+		sum_num = self.num*other.den
+		sum_den = self.den*other.num
+		temp = gcd(sum_num,sum_den)
+		return str(sum_num/temp)+'/'+str(sum_den/temp)
+
+	def __eq__(self,other):	
+			#to check deep equality I have overriden the __eq__ fn so that 
+			#instead of checking reference it compares values and 
+			#returns True if both matches 
+		first_num = self.num*other.den
+		second_num = self.den*other.num
+		
+		return first_num == second_num
+
+	def __lt__(self,other):	
+			
+		first_num = self.num*other.den
+		second_num = self.den*other.num
+		
+		return first_num < second_num
+
+	def __le__(self,other):	
+			
+		first_num = self.num*other.den
+		second_num = self.den*other.num
+		
+		return first_num <= second_num
+
+	def __gt__(self,other):	
+			
+		first_num = self.num*other.den
+		second_num = self.den*other.num
+		
+		return first_num > second_num
+
+	def __ge__(self,other):	
+				
+		first_num = self.num*other.den
+		second_num = self.den*other.num
+		
+		return first_num >= second_num
+
+	def __ne__(self,other):	
+			
+		first_num = self.num*other.den
+		second_num = self.den*other.num
+		
+		return first_num != second_num
+
+
+	def get_num(self):
+		return(self.num)
+
+	def get_den(self):
+		return(self.den)
+
+def gcd(m,n):
+	while (m % n != 0):
+		temp = m % n
+		m = n
+		n = temp
+	return n
+

Fraction.py

@@ -0,0 +1,25 @@
+numbers = [2,3,49999,5,6,6,7,223,45,75,8,5,97,3200,5222,37,8,23,3,5,66,4,2,4,6,74,846,85,6,56,3,2,43,83,58,368,57,386,4,3,7,64]
+
+def functionQuadSearch(numbers):
+	greater = 0;
+
+	for i in numbers:
+		temp = i
+		for j in numbers:
+
+			if j>i:
+				if j>greater:
+					greater = j
+
+	return greater
+
+def functionLinearSearch(numbers):
+	greater = 0
+	for i in numbers:
+		if i < greater:
+			greater = i
+	return greater 
+
+
+print(functionQuadSearch(numbers))
+print(functionLinearSearch(numbers))

Fraction.pyc

@@ -0,0 +1,105 @@
+class Node:
+    def __init__(self,init_data):
+        self.data = init_data
+        self.next = None
+        
+    def get_data(self):
+        return self.data
+        
+    def get_next(self):
+        return self.next
+        
+    def set_data(self, new_data):
+        self.data = new_data
+        
+    def set_next(self, new_next):
+        self.next = new_next
+        
+class UnorderedList:
+    def __init__(self):
+        self.head = None
+                
+    def is_empty(self):
+        return self.head == None
+    
+    def add(self, item):
+        temp = Node(item)
+        temp.next = self.head
+        self.head = temp
+               
+    def size(self):
+        count = 0
+        current = self.head
+        while current != None:
+            count += 1
+            current = current.get_next()
+            
+        return count
+        
+    def search(self, item):
+        loc = None
+        count = 0
+        found = False
+        current = self.head
+               
+        while current != None and not found:
+            if item == current.get_data():
+                found = True
+                loc = count
+            current = current.get_next()
+            count += 1
+        
+        if found:
+            return str("item found at position %r"%(loc))
+        else:
+            return "item not found"
+            
+    def remove(self, item):
+        prev = None
+        found = False
+        current = self.head
+               
+        while current != None and not found:
+            if item == current.get_data():
+                found = True
+            else:
+                prev = current
+                current = current.get_next()
+                    
+        if prev == None:
+            self.head = current.get_next()
+        else:
+            prev.set_next(current.get_next())
+            
+    def append(self, item):
+        prev = None
+        found = False
+        current = self.head
+               
+        while current != None and not found:
+            
+                prev = current
+                current = current.get_next()
+                
+        temp = Node(item)
+        prev.set_next(temp)
+    
+    
+list1 = UnorderedList()
+
+print list1.is_empty()
+list1.add(31)
+list1.add(77)
+list1.add(17)
+print list1.size()
+list1.add(93)
+list1.add(54)
+print list1.size()
+print list1.remove(31)
+print list1.size()
+print list1.remove(54)
+print list1.size()
+list1.append(73)
+print list1.size()
+list1.append(799)
+print list1.size()

ListSearch.py

@@ -0,0 +1,15 @@
+class Queue:
+    def __init__(self):
+        self.items = []
+        
+    def is_empty(self):
+        return self.items == []
+        
+    def enqueue(self, item):
+        self.items.insert(0, item)
+        
+    def dequeue(self):
+        return self.items.pop()
+        
+    def size(self):
+        return len(self.items)