Merge pull request #1 from TheAlgorithms/master

Pull from TheAlgorithms/Python

Author: aalhour

Bisection.py renamed to ArithmeticAnalysis/Bisection.py

@@ -0,0 +1,34 @@
+import math
+import numpy
+
+def LUDecompose (table): #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
+    for i in range (columns):
+        for j in range(i-1):
+            sum=0
+            for k in range (j-1):
+                sum+=L[i][k]*U[k][j]
+            L[i][j]=(table[i][j]-sum)/U[j][j]
+        L[i][i]=1
+        for j in range(i-1,columns):
+            sum1=0
+            for k in range(i-1):
+                sum1+=L[i][k]*U[k][j]
+            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)

Intersection.py renamed to ArithmeticAnalysis/Intersection.py

@@ -8,21 +8,21 @@
 s.bind((host, port))            # Bind to the port
 s.listen(5)                     # Now wait for client connection.
 
-print 'Server listening....'
+print('Server listening....')
 
 while True:
     conn, addr = s.accept()     # Establish connection with client.
-    print 'Got connection from', addr
+    print('Got connection from', addr)
     data = conn.recv(1024)
     print('Server received', repr(data))
 
-    filename='mytext.txt'
-    f = open(filename,'rb')
-    l = f.read(1024)
-    while (l):
-       conn.send(l)
-       print('Sent ',repr(l))
-       l = f.read(1024)
+    filename = 'mytext.txt'
+    f = open(filename, 'rb')
+    in_data = f.read(1024)
+    while (in_data):
+       conn.send(in_data)
+       print('Sent ', repr(in_data))
+       in_data = f.read(1024)
     f.close()
 
     print('Done sending')
@@ -42,7 +42,7 @@
 s.send("Hello server!")
 
 with open('received_file', 'wb') as f:
-    print 'file opened'
+    print('file opened')
     while True:
         print('receiving data...')
         data = s.recv(1024)
@@ -55,4 +55,4 @@
 f.close()
 print('Successfully get the file')
 s.close()
-print('connection closed')
+print('connection closed')

ArithmeticAnalysis/LUdecomposition.py

@@ -0,0 +1,49 @@
+
+'''
+Numerical integration or quadrature for a smooth function f with known values at x_i
+
+This method is the classical approch of suming 'Equally Spaced Abscissas' 
+
+method 2: 
+"Simpson Rule"
+
+'''
+from __future__ import print_function
+
+
+def method_2(boundary, steps):
+# "Simpson Rule"
+# int(f) = delta_x/2 * (b-a)/3*(f1 + 4f2 + 2f_3 + ... + fn)
+	h = (boundary[1] - boundary[0]) / steps
+	a = boundary[0]
+	b = boundary[1]
+	x_i = makePoints(a,b,h)
+	y = 0.0
+	y += (h/3.0)*f(a)
+	cnt = 2
+	for i in x_i:
+		y += (h/3)*(4-2*(cnt%2))*f(i)	
+		cnt += 1
+	y += (h/3.0)*f(b)
+	return y
+
+def makePoints(a,b,h):
+	x = a + h
+	while x < (b-h):
+		yield x
+		x = x + h
+
+def f(x): #enter your function here
+	y = (x-0)*(x-0)
+	return y
+
+def main():
+	a = 0.0 #Lower bound of integration
+	b = 1.0	#Upper bound of integration
+	steps = 10.0		#define number of steps or resolution
+	boundary = [a, b]	#define boundary of integration
+	y = method_2(boundary, steps)
+	print('y = {0}'.format(y))
+
+if __name__ == '__main__':
+        main()

NeutonMethod.py renamed to ArithmeticAnalysis/NeutonMethod.py

@@ -0,0 +1,46 @@
+'''
+Numerical integration or quadrature for a smooth function f with known values at x_i
+
+This method is the classical approch of suming 'Equally Spaced Abscissas' 
+
+method 1: 
+"extended trapezoidal rule"
+
+'''
+from __future__ import print_function
+
+def method_1(boundary, steps):
+# "extended trapezoidal rule"
+# int(f) = dx/2 * (f1 + 2f2 + ... + fn)
+	h = (boundary[1] - boundary[0]) / steps
+	a = boundary[0]
+	b = boundary[1]
+	x_i = makePoints(a,b,h)
+	y = 0.0	
+	y += (h/2.0)*f(a)
+	for i in x_i:
+		#print(i)	
+		y += h*f(i)
+	y += (h/2.0)*f(b)	
+	return y	
+
+def makePoints(a,b,h):
+	x = a + h	
+	while x < (b-h):
+		yield x
+		x = x + h
+		
+def f(x): #enter your function here
+	y = (x-0)*(x-0)
+	return y
+
+def main():
+	a = 0.0 #Lower bound of integration
+	b = 1.0	#Upper bound of integration
+	steps = 10.0		#define number of steps or resolution	
+	boundary = [a, b]	#define boundary of integration
+	y = method_1(boundary, steps)
+	print('y = {0}'.format(y))
+
+if __name__ == '__main__':
+	main()

File_Transfer_Protocol/ftp_client_server.py

@@ -0,0 +1,32 @@
+def mulitples(limit):
+    xmulti = []
+    zmulti = []
+    z = 3
+    x = 5
+    temp = 1
+    while True:
+        result = z * temp
+        if (result < limit):
+            zmulti.append(result)
+            temp += 1
+            continue
+        else:
+            temp = 1
+            break
+    while True:
+        result = x * temp
+        if (result < limit):
+            xmulti.append(result)
+            temp += 1
+            continue
+        else:
+            temp = 1
+            break
+    return (sum(zmulti) + sum(xmulti))
+    
+    
+        
+        
+        
+    
+print (mulitples(100))

Maths/SimpsonRule.py

@@ -0,0 +1,13 @@
+def fib(n):
+    ls = []
+    a,b = 0,1
+    n += 1
+    for i in range(n):
+        if (b % 2 == 0):
+            ls.append(b)
+        else:
+            pass
+        a,b = b, a+b
+    print (sum(ls))
+    return None
+fib(10)

Maths/TrapezoidalRule.py

@@ -0,0 +1,20 @@
+'''
+Problem:
+Each new term in the Fibonacci sequence is generated by adding the previous two terms. 
+                0,1,1,2,3,5,8,13,21,34,55,89,..
+Every third term from 0 is even So using this I have written a simple code
+By considering the terms in the Fibonacci sequence whose values do not exceed n, find the sum of the even-valued terms.
+e.g. for n=10, we have {2,8}, sum is 10.
+'''
+"""Python 3"""
+n = int(input())
+a=0
+b=2
+count=0
+while 4*b+a<n:
+    c=4*b+a
+    a=b
+    b=c
+    count=count+a
+print(count+b)
+   

Project Euler/Problem 01/sol4.py

@@ -0,0 +1,20 @@
+#!/bin/python3
+'''
+Problem:
+2520 is the smallest number that can be divided by each of the numbers from 1 to 10 without any remainder.
+What is the smallest positive number that is evenly divisible(divisible with no remainder) by all of the numbers from 1 to N?
+'''
+
+""" Euclidean GCD Algorithm """
+def gcd(x,y):
+    return x if y==0 else gcd(y,x%y)
+
+""" Using the property lcm*gcd of two numbers = product of them """
+def lcm(x,y):
+    return (x*y)//gcd(x,y)
+
+n = int(input())
+g=1
+for i in range(1,n+1):
+    g=lcm(g,i)
+print(g)

Project Euler/Problem 02/sol2.py

@@ -0,0 +1,15 @@
+import sys
+def main():
+    LargestProduct = -sys.maxsize-1
+    number=input().strip()
+    for i in range(len(number)-13):
+        product=1
+        for j in range(13):
+            product *= int(number[i+j])
+        if product > LargestProduct:
+            LargestProduct = product
+    print(LargestProduct)
+
+
+if __name__ == '__main__':
+    main()

Project Euler/Problem 02/sol3.py

@@ -0,0 +1,38 @@
+from __future__ import print_function
+from math import sqrt
+
+try:
+	xrange			#Python 2
+except NameError:
+	xrange = range	#Python 3
+
+def is_prime(n):
+	for i in xrange(2, int(sqrt(n))+1):
+		if n%i == 0:
+			return False
+
+	return True
+
+def sum_of_primes(n):
+	if n > 2:
+		sumOfPrimes = 2
+	else:
+		return 0
+
+	for i in xrange(3, n, 2):
+		if is_prime(i):
+			sumOfPrimes += i
+
+	return sumOfPrimes
+
+if __name__ == '__main__':
+	import sys
+
+	if len(sys.argv) == 1:
+		print(sum_of_primes(2000000))
+	else:
+		try:
+			n = int(sys.argv[1])
+			print(sum_of_primes(n))
+		except ValueError:
+			print('Invalid entry - please enter a number.')

Project Euler/Problem 05/sol2.py

@@ -0,0 +1,20 @@
+08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08
+49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00
+81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65
+52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91
+22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80
+24 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50
+32 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 70
+67 26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 21
+24 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72
+21 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 95
+78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92
+16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57
+86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58
+19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40
+04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66
+88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69
+04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36
+20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16
+20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54
+01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48