Sync Fork - TheAlgorithms/master

Sync Fork

Author: ashwek

Maths/3n+1.py

@@ -0,0 +1,19 @@
+def main():
+    def n31(a):# a = initial number
+        c = 0
+        l = [a]
+        while a != 1:
+            if a % 2 == 0:#if even divide it by 2
+                a = a // 2
+            elif a % 2 == 1:#if odd 3n+1
+                a = 3*a +1
+            c += 1#counter
+            l += [a]
+
+        return l , c
+    print(n31(43))
+    print(n31(98)[0][-1])# = a
+    print("It took {0} steps.".format(n31(13)[1]))#optional finish
+
+if __name__ == '__main__':
+    main()

Maths/FindMax.py

@@ -1,8 +1,7 @@
 # NguyenU
 
-import math
 def find_max(nums):
-    max = 0
+    max = nums[0]
     for x in nums:
       if x > max:
         max = x

Maths/FindMin.py

@@ -0,0 +1,12 @@
+def main():
+    def findMin(x):
+        minNum = x[0]
+        for i in x:
+            if minNum > i:
+                minNum = i
+        return minNum
+
+    print(findMin([0,1,2,3,4,5,-3,24,-56])) # = -56
+
+if __name__ == '__main__':
+    main()

Maths/abs.py

@@ -0,0 +1,18 @@
+def absVal(num):
+    """
+    Function to fins absolute value of numbers.
+    >>>absVal(-5)
+    5
+    >>>absVal(0)
+    0
+    """
+    if num < 0:
+        return -num
+    else:
+        return num
+
+def main():
+    print(absVal(-34)) # = 34
+
+if __name__ == '__main__':
+    main()

Maths/absMax.py

@@ -0,0 +1,22 @@
+from abs import absVal
+def absMax(x):
+    """
+    >>>absMax([0,5,1,11])
+    11
+    >>absMax([3,-10,-2])
+    -10
+    """
+    j = x[0]
+    for i in x:
+        if absVal(i) < j:
+            j = i
+    return j
+    #BUG: i is apparently a list, TypeError: '<' not supported between instances of 'list' and 'int' in absVal
+
+
+def main():
+    a = [1,2,-11]
+    print(absVal(a)) # = -11
+
+if __name__ == '__main__':
+    main()

Maths/absMin.py

@@ -0,0 +1,20 @@
+from abs import absVal
+def absMin(x):
+    """
+    >>>absMin([0,5,1,11])
+    0
+    >>absMin([3,-10,-2])
+    -2
+    """
+    j = x[0]
+    for i in x:
+        if absVal(i) < j:
+            j = i
+    return j
+
+def main():
+    a = [1,2,-11]
+    print(absMin(a)) # = 1
+
+if __name__ == '__main__':
+    main()

README.md

@@ -1,38 +1,39 @@
-import numpy as np
+"""
+	Peak signal-to-noise ratio - PSNR - https://en.wikipedia.org/wiki/Peak_signal-to-noise_ratio
+    Soruce: https://tutorials.techonical.com/how-to-calculate-psnr-value-of-two-images-using-python/
+"""
+
 import math
+
 import cv2
+import numpy as np
 
-def Representational(r,g,b):
-	return (0.299*r+0.287*g+0.114*b)
+def psnr(original, contrast):
+    mse = np.mean((original - contrast) ** 2)
+    if mse == 0:
+        return 100
+    PIXEL_MAX = 255.0
+    PSNR = 20 * math.log10(PIXEL_MAX / math.sqrt(mse))
+    return PSNR
 
-def calculate(img):
-	b,g,r = cv2.split(img)
-	pixelAt = Representational(r,g,b)
-	return pixelAt
 
 def main():
-	
-	#Loading images (orignal image and compressed image)
-	orignal_image = cv2.imread('orignal_image.png',1)
-	compressed_image = cv2.imread('compressed_image.png',1)
 
-	#Getting image height and width
-	height,width = orignal_image.shape[:2]
+    # Loading images (original image and compressed image)
+    original = cv2.imread('original_image.png')
+    contrast = cv2.imread('compressed_image.png', 1)
 
-	orignalPixelAt = calculate(orignal_image)
-	compressedPixelAt = calculate(compressed_image)
+    original2 = cv2.imread('PSNR-example-base.png')
+    contrast2 = cv2.imread('PSNR-example-comp-10.jpg', 1)
 
-	diff = orignalPixelAt - compressedPixelAt
-	error = np.sum(np.abs(diff) ** 2)
-
-	error = error/(height*width)
-
-	#MSR = error_sum/(height*width)
-	PSNR = -(10*math.log10(error/(255*255)))
-
-	print("PSNR value is {}".format(PSNR))
+    # Value expected: 29.73dB
+    print("-- First Test --")
+    print(f"PSNR value is {psnr(original, contrast)} dB")
+    
+    # # Value expected: 31.53dB (Wikipedia Example)
+    print("\n-- Second Test --")
+    print(f"PSNR value is {psnr(original2, contrast2)} dB")
 
 
 if __name__ == '__main__':
-	main()
-
+    main()

analysis/compression_analysis/PSNR-example-base.png

@@ -15,7 +15,7 @@ def bisection(function, a, b):  # finds where the function becomes 0 in [a,b] us
         return
     else:
         mid = (start + end) / 2
-        while abs(start - mid) > 0.0000001:  # until we achieve precise equals to 10^-7
+        while abs(start - mid) > 10**-7:  # until we achieve precise equals to 10^-7
             if function(mid) == 0:
                 return mid
             elif function(mid) * function(start) < 0:
@@ -29,5 +29,5 @@ def bisection(function, a, b):  # finds where the function becomes 0 in [a,b] us
 def f(x):
     return math.pow(x, 3) - 2*x - 5
 
-
-print(bisection(f, 1, 1000))
+if __name__ == "__main__":
+    print(bisection(f, 1, 1000))

analysis/compression_analysis/PSNR-example-comp-10.jpg

@@ -5,12 +5,13 @@ def intersection(function,x0,x1): #function is the f we want to find its root an
     x_n1 = x1
     while True:
         x_n2 = x_n1-(function(x_n1)/((function(x_n1)-function(x_n))/(x_n1-x_n)))
-        if abs(x_n2 - x_n1)<0.00001 :
+        if abs(x_n2 - x_n1) < 10**-5:
             return x_n2
         x_n=x_n1
         x_n1=x_n2
 
 def f(x):
-    return math.pow(x,3)-2*x-5
+    return math.pow(x , 3) - (2 * x) -5
 
-print(intersection(f,3,3.5))
+if __name__ == "__main__":
+    print(intersection(f,3,3.5))

analysis/compression_analysis/example_wikipedia_image.jpg

@@ -1,13 +1,14 @@
+# lower–upper (LU) decomposition - https://en.wikipedia.org/wiki/LU_decomposition
 import numpy
 
 def LUDecompose (table):
-    #table that contains our data
-    #table has to be a square array so we need to check first
+    # Table that contains our data
+    # Table has to be a square array so we need to check first
     rows,columns=numpy.shape(table)
     L=numpy.zeros((rows,columns))
     U=numpy.zeros((rows,columns))
     if rows!=columns:
-        return
+        return []
     for i in range (columns):
         for j in range(i-1):
             sum=0
@@ -22,13 +23,10 @@ def LUDecompose (table):
             U[i][j]=table[i][j]-sum1
     return L,U
 
-
-
-
-
-
-
-matrix =numpy.array([[2,-2,1],[0,1,2],[5,3,1]])
-L,U = LUDecompose(matrix)
-print(L)
-print(U)
+if __name__ == "__main__":
+    matrix =numpy.array([[2,-2,1],
+                         [0,1,2],
+                         [5,3,1]])
+    L,U = LUDecompose(matrix)
+    print(L)
+    print(U)

analysis/compression_analysis/orignal_image.png renamed to analysis/compression_analysis/original_image.png

@@ -1,15 +1,18 @@
+# Newton's Method - https://en.wikipedia.org/wiki/Newton%27s_method
+
 def newton(function,function1,startingInt): #function is the f(x) and function1 is the f'(x)
   x_n=startingInt
   while True:
       x_n1=x_n-function(x_n)/function1(x_n)
-      if abs(x_n-x_n1)<0.00001:
+      if abs(x_n-x_n1) < 10**-5:
           return x_n1
       x_n=x_n1
 
 def f(x):
-    return (x**3)-2*x-5
+    return (x**3) - (2 * x) -5
 
 def f1(x):
-    return 3*(x**2)-2
+    return 3 * (x**2) -2
 
-print(newton(f,f1,3))
+if __name__ == "__main__":
+    print(newton(f,f1,3))

analysis/compression_analysis/psnr.py

@@ -0,0 +1,11 @@
+import base64
+
+def main():
+    inp = input('->')
+    encoded = inp.encode('utf-8') #encoded the input (we need a bytes like object)
+    b16encoded = base64.b16encode(encoded) #b16encoded the encoded string
+    print(b16encoded)
+    print(base64.b16decode(b16encoded).decode('utf-8'))#decoded it
+
+if __name__ == '__main__':
+    main()

arithmetic_analysis/bisection.py

@@ -0,0 +1,11 @@
+import base64
+
+def main():
+    inp = input('->')
+    encoded = inp.encode('utf-8') #encoded the input (we need a bytes like object)
+    b32encoded = base64.b32encode(encoded) #b32encoded the encoded string
+    print(b32encoded)
+    print(base64.b32decode(b32encoded).decode('utf-8'))#decoded it
+
+if __name__ == '__main__':
+    main()

arithmetic_analysis/intersection.py

@@ -0,0 +1,11 @@
+import base64
+
+def main():
+    inp = input('->')
+    encoded = inp.encode('utf-8') #encoded the input (we need a bytes like object)
+    b64encoded = base64.b64encode(encoded) #b64encoded the encoded string
+    print(b64encoded)
+    print(base64.b64decode(b64encoded).decode('utf-8'))#decoded it
+
+if __name__ == '__main__':
+    main()

arithmetic_analysis/lu_decomposition.py

@@ -0,0 +1,11 @@
+import base64
+
+def main():
+    inp = input('->')
+    encoded = inp.encode('utf-8') #encoded the input (we need a bytes like object)
+    a85encoded = base64.a85encode(encoded) #a85encoded the encoded string
+    print(a85encoded)
+    print(base64.a85decode(a85encoded).decode('utf-8'))#decoded it
+
+if __name__ == '__main__':
+    main()

arithmetic_analysis/newton_method.py

@@ -34,35 +34,30 @@ def brute_force(strng):
 
 
 def main():
-    print('-' * 10 + "\n**Menu**\n" + '-' * 10)
-    print("1.Encrpyt")
-    print("2.Decrypt")
-    print("3.BruteForce")
-    print("4.Quit")
     while True:
+        print('-' * 10 + "\n**Menu**\n" + '-' * 10)
+        print("1.Encrpyt")
+        print("2.Decrypt")
+        print("3.BruteForce")
+        print("4.Quit")
         choice = input("What would you like to do?: ")
         if choice not in ['1', '2', '3', '4']:
             print ("Invalid choice")
         elif choice == '1':
             strng = input("Please enter the string to be ecrypted: ")
-            while True:
-                key = int(input("Please enter off-set between 1-94: "))
-                if key in range(1, 95):
-                    print (encrypt(strng, key))
-                    main()
+            key = int(input("Please enter off-set between 1-94: "))
+            if key in range(1, 95):
+                print (encrypt(strng.lower(), key))
         elif choice == '2':
             strng = input("Please enter the string to be decrypted: ")
-            while True:
-                key = int(input("Please enter off-set between 1-94: "))
-                if key > 0 and key <= 94:
-                    print(decrypt(strng, key))
-                    main()
+            key = int(input("Please enter off-set between 1-94: "))
+            if key > 0 and key <= 94:
+                print(decrypt(strng, key))
         elif choice == '3':
             strng = input("Please enter the string to be decrypted: ")
             brute_force(strng)
             main()
         elif choice == '4':
             print ("Goodbye.")
-            sys.exit()
-
+            break
 main()

ciphers/base16.py

@@ -1,3 +1,3 @@
 arr = [10, 20, 30, 40]
-arr[1] = 30
+arr[1] = 30 # set element 1 (20) of array to 30
 print(arr)

ciphers/base32.py

@@ -21,7 +21,7 @@ def minDist(mdist, vset, V):
 def Dijkstra(graph, V, src):
 	mdist=[float('inf') for i in range(V)]
 	vset = [False for i in range(V)]
-	mdist[src] = 0.0;
+	mdist[src] = 0.0
 
 	for i in range(V-1):
 		u = minDist(mdist, vset, V)

ciphers/base64_cipher.py

@@ -40,7 +40,7 @@ def maxHeapify(self,node):
 	def buildHeap(self,a):
 		self.currsize = len(a)
 		self.h = list(a)
-		for i in range(self.currsize/2,-1,-1):
+		for i in range(self.currsize//2,-1,-1):
 			self.maxHeapify(i)
 
 	def getMax(self):