initial

Author: pyjads

competitive_programming/__init__.py

@@ -0,0 +1,120 @@
+import math
+
+
+# A class to represent a Point in 2D plane
+class Point():
+    def __init__(self, x, y):
+        self.x = x
+        self.y = y
+
+    # A utility function to find the
+
+
+# distance between two points
+def dist(p1, p2):
+    return math.sqrt((p1.x - p2.x) *
+                     (p1.x - p2.x) +
+                     (p1.y - p2.y) *
+                     (p1.y - p2.y))
+
+
+# A Brute Force method to return the
+# smallest distance between two points  
+# in P[] of size n 
+def bruteForce(P, n):
+    min_val = float('inf')
+    for i in range(n):
+        for j in range(i + 1, n):
+            if dist(P[i], P[j]) < min_val:
+                min_val = dist(P[i], P[j])
+
+    return min_val
+
+
+# A utility function to find the
+# distance beween the closest points of  
+# strip of given size. All points in  
+# strip[] are sorted accordint to  
+# y coordinate. They all have an upper  
+# bound on minimum distance as d.  
+# Note that this method seems to be  
+# a O(n^2) method, but it's a O(n)  
+# method as the inner loop runs at most 6 times 
+def stripClosest(strip, size, d):
+    # Initialize the minimum distance as d
+    min_val = d
+
+    strip.sort(key=lambda point: point.y)
+
+    # Pick all points one by one and  
+    # try the next points till the difference  
+    # between y coordinates is smaller than d.  
+    # This is a proven fact that this loop 
+    # runs at most 6 times  
+    for i in range(size):
+        j = i + 1
+        while j < size and (strip[j].y -
+                            strip[i].y) < min_val:
+            min_val = dist(strip[i], strip[j])
+            j += 1
+
+    return min_val
+
+
+# A recursive function to find the
+# smallest distance. The array P contains  
+# all points sorted according to x coordinate 
+def closestUtil(P, n):
+    # If there are 2 or 3 points,
+    # then use brute force  
+    if n <= 3:
+        return bruteForce(P, n)
+
+        # Find the middle point
+    mid = n // 2
+    midPoint = P[mid]
+
+    # Consider the vertical line passing  
+    # through the middle point calculate  
+    # the smallest distance dl on left  
+    # of middle point and dr on right side  
+    dl = closestUtil(P[:mid], mid)
+    dr = closestUtil(P[mid:], n - mid)
+
+    # Find the smaller of two distances  
+    d = min(dl, dr)
+
+    # Build an array strip[] that contains  
+    # points close (closer than d)  
+    # to the line passing through the middle point  
+    strip = []
+    for i in range(n):
+        if abs(P[i].x - midPoint.x) < d:
+            strip.append(P[i])
+
+            # Find the closest points in strip.
+    # Return the minimum of d and closest  
+    # distance is strip[]  
+    return min(d, stripClosest(strip, len(strip), d))
+
+
+# The main function that finds
+# the smallest distance.  
+# This method mainly uses closestUtil() 
+def closest(P, n):
+    P.sort(key=lambda point: point.x)
+
+    # Use recursive function closestUtil()  
+    # to find the smallest distance  
+    return closestUtil(P, n)
+
+l=[]
+for _ in range(input()):
+    x, y = map(int, input().split(' '))
+    l.append(Point(x,y))
+
+n = len(l)
+print('{:.8f}'.format(closest(l,n)))
+
+# This code is contributed  
+# by Prateek Gupta (@prateekgupta10) 

competitive_programming/contest/__init__.py

@@ -0,0 +1,30 @@
+
+# 5
+# 5 3
+# 1 5 2 6 1
+# 1 6
+# 6
+# 3 2
+# 1 2 3
+# 4 3
+# 3 1 2 3
+# 10 3
+# 1 2 3 4 5 6 7 8 9 10
+
+i = int(input())
+l = []
+for j in range(i):
+    k = list(map(int,(input().split(' '))))
+
+    il = list(map(int,input().split(' ')))
+    if k[1] in il and len(il)==1:
+        l.append('yes')
+    elif k[1] in il[1:] and len(il) % 2 == 1:
+        l.append('yes')
+    elif k[1] in il[1:-1] and len(il) % 2 == 0:
+        l.append('yes')
+    else:
+        l.append('no')
+
+for t in l:
+    print(t)

competitive_programming/contest/test/__init__.py

@@ -0,0 +1,22 @@
+import math
+def c_lcm(greater, l1, l2):
+    while True:
+        if greater % l1 == 0 and greater % l2 == 0:
+            return greater
+        else:
+            greater += 1
+
+def gcd(a,b):
+    if(b==0):
+        return a
+    else:
+        return gcd(b,a%b)
+
+
+n = input()
+l = list(map(int, input().split()))
+lcm = []
+for i in range(l):
+    for j in range(i,l):
+        greater = max(l[i],l[j])
+        lcm.append(c_lcm(greater, l[i], l[j]))

competitive_programming/contest/test/prog_1.py

@@ -0,0 +1,38 @@
+import math
+
+n = int(input())
+fo = []
+for q in range(n):
+
+    l = list(map(int, input().split()))
+    lcm = (l[0] * l[1]) // math.gcd(l[0], l[1])
+    if l[0] > l[1]:
+        l[1], l[0] = l[0], l[1]
+    o = []
+    for i in range(l[2]):
+        t = list(map(int, input().split()))
+        count = 0
+
+        if t[1] < l[1]:
+            o.append(count)
+
+        else:
+
+            if t[0] < l[1]:
+                t[0] = l[1]
+            lower = (t[0] + lcm - 1) // lcm
+            higher = t[1] // lcm
+            m = higher - lower + 1
+            last = ((t[1] // lcm) * lcm) + l[1] - 1
+            value = t[1] - t[0] + 1 - m * l[1]
+            # print(m, last, lcm, t[1], t[0], l[1], value)
+            if last > t[1]:
+                value = value + last - t[1] +1
+
+            o.append(value)
+    fo.append(o)
+
+for i in fo:
+    for j in i:
+        print(j, end=' ')
+    print()

competitive_programming/contest/test/prog_2.py

@@ -65,3 +65,21 @@ def greater(row):
 #%%
 sales.loc[sales['STATUS'] == 'Shipped', 'derived'] = 'H'
 
+#%%
+import matplotlib.pyplot as plt
+import numpy as np
+plt.clf()
+plt.figure(1)                # the first figure
+plt.subplot(211)             # the first subplot in the first figure
+plt.plot([1, 2, 3])
+plt.subplot(212)             # the second subplot in the first figure
+plt.plot([4, 5, 6])
+
+
+plt.figure(2)                # a second figure
+plt.plot([4, 5, 6])          # creates a subplot(111) by default
+
+plt.figure(1)                # figure 1 current; subplot(212) still current
+plt.subplot(211)             # make subplot(211) in figure1 current
+plt.title('Easy as 1, 2, 3') # subplot 211 title
+plt.show()

competitive_programming/contest/test/prog_3.py

@@ -3,4 +3,27 @@
 import numpy as np
 series = pd.Series([1,2,3,4,5,6,7,8,100], index=['A','B','C','D','E','F','G','H','I'], name='Numbers' )
 
-print(series.agg(np.mean))
+print(series.agg(np.mean))
+
+
+#%%
+data = pd.DataFrame({'value':[1,2,3,4,5,6,7,8,9,10]})
+
+def compute(row):
+    if row['value'] > 5:
+        return 'greater than 5'
+    elif row['value'] == 5:
+        return 'equal'
+    else:
+        return 'small'
+
+def compute1(data):
+    if data == 'greater than 5':
+        return 'Hola than 5'
+    else:
+        return data
+
+data['compute'] = data.apply(compute, axis=1)
+data.compute= data.compute.transform(compute1)
+print(data)
+

competitive_programming/contest/test/prog_4.py

@@ -0,0 +1,106 @@
+#%%
+import cv2
+import matplotlib.pyplot as plt
+import numpy as np
+
+#%%
+watermark = cv2.imread(r"E:\Pycharm_Workspace\Data_Science\image_processing\watermark_1.jpg")
+original_1 = cv2.imread(r'E:\Pycharm_Workspace\Data_Science\image_processing\original.jpg')
+
+diff = watermark != original_1
+
+print(diff.sum())
+
+#%%
+
+mark = 'E:\Pycharm_Workspace\Data_Science\image_processing\w_{}.jpg'
+
+# im1 = mark.format('1')
+
+w_1 = cv2.imread(mark.format('1'))
+w_1 = np.array(w_1, dtype=np.uint16)
+
+w_2 = cv2.imread(mark.format('2'))
+w_2 = np.array(w_2, dtype=np.uint16)
+
+w_3 = cv2.imread(mark.format('3'))
+w_3 = np.array(w_3, dtype=np.uint16)
+
+w_4 = cv2.imread(mark.format('4'))
+w_4 = np.array(w_4, dtype=np.uint16)
+
+w_5 = cv2.imread(mark.format('5'))
+w_5 = np.array(w_5, dtype=np.uint16)
+
+# average
+final_image = (w_1 + w_2 + w_3 + w_4 + w_5)/5
+
+cv2.imwrite('image_processing/image_average.jpg',final_image)
+
+
+# majority
+
+red = np.array([w_1.T[0],w_2.T[0], w_3.T[0], w_4.T[0], w_5.T[0]])
+green = np.array([w_1.T[1],w_2.T[1], w_3.T[1], w_4.T[1], w_5.T[1]])
+blue = np.array([w_1.T[2],w_2.T[2], w_3.T[2], w_4.T[2], w_5.T[2]])
+
+red_majority = red.max(axis=0)
+green_majority = green.max(axis=0)
+blue_majority = blue.max(axis=0)
+
+image_median = np.array([red_majority, green_majority, blue_majority])
+cv2.imwrite('image_processing/image_median.jpg',final_image)
+
+
+#%%
+watermark = cv2.imread(r"E:\Pycharm_Workspace\Data_Science\image_processing\StegoWork_with_OutGuess_01.jpg")
+original_1 = cv2.imread(r'E:\Pycharm_Workspace\Data_Science\image_processing\original.jpg')
+
+
+print(original_1.shape)
+
+#%%
+
+watermark = cv2.imread(r"C:\Users\lenovo\Desktop\matlab\input_sat_image.jpg")
+cv2.imshow('image',watermark)
+
+#%%
+
+from io import StringIO # "import StringIO" directly in python2
+from PIL import Image
+# im2 = Image.open('E:\Pycharm_Workspace\Data_Science\image_processing\StegoWork with OutGuess 02.jpg')
+# im1 = Image.open('E:\Pycharm_Workspace\Data_Science\image_processing\StegoWork_with_OutGuess_01.jpg')
+# im3 = Image.open('E:\Pycharm_Workspace\Data_Science\image_processing\StegoWork_with_OutGuess_03.jpg')
+# im4 = Image.open('E:\Pycharm_Workspace\Data_Science\image_processing\StegoWork_with_OutGuess_04.jpg')
+
+im2 = Image.open('E:\Pycharm_Workspace\Data_Science\image_processing\Test_OutGuess_01.jpg')
+r, g, b = im2[:,:,0], im2[:,:,1], im2[:,:,2]
+im2 = 0.2989 * r + 0.5870 * g + 0.1140 * b
+im1 = Image.open('E:\Pycharm_Workspace\Data_Science\image_processing\Test_OutGuess_02.jpg')
+
+im2.save('image_processing/1_c.jpg', quality=0)
+im2.save('image_processing/2_c.jpg', quality=100)
+im2.save('image_processing/3_c.jpg', quality=50)
+im2.save('image_processing/4_c.jpg', quality=30)
+im2.save('image_processing/5_c.jpg', quality=10)
+# im3.save('image_processing/3_compressed.jpg', quality=0)
+# im4.save('image_processing/4_compressed.jpg', quality=0)
+
+#%%
+im1 = cv2.imread('E:\Pycharm_Workspace\Data_Science\image_processing\StegoWork with OutGuess 02.jpg',0)
+im2 = cv2.imread('E:\Pycharm_Workspace\Data_Science\image_processing\StegoWork_with_OutGuess_01.jpg',0)
+im3 = cv2.imread('E:\Pycharm_Workspace\Data_Science\image_processing\StegoWork_with_OutGuess_03.jpg',0)
+plt.hist(im1.ravel(),256,[0,256], color='red')
+plt.title('IM1')
+plt.show()
+plt.clf()
+plt.hist(im2.ravel(),256,[0,256], color='green')
+plt.title('IM2')
+plt.show()
+plt.clf()
+plt.hist(im3.ravel(),256,[0,256], color='blue')
+plt.title('IM3')
+plt.show()
+
+
+