added new problems

Author: gauraviuiux

New folder/binaryexponentiation.py

@@ -0,0 +1,25 @@
+def biex(a,n):
+    res=1
+    while(n):
+        if n%2:
+            res=res*a
+            n=n-1
+        else:
+            a=a*a
+            n=n//2
+    return res
+
+def modex(a,n,p):
+    res=1
+    while(n):
+        if n%2:
+            res=(res*a)%p
+            n=n-1
+
+        else:
+            a=(a*a)%p
+            n=n//2
+
+    return res
+print(biex(2,6))
+print(modex(2,6,2))

New folder/cseserslegions.py

@@ -0,0 +1,21 @@
+
+memo={}
+
+def getans(n,f,h,k1,k2,z1,z2):
+
+    if n==0:
+        return 1
+
+    if (n,f,h,k1,k2,z1,z2) in memo:
+        return memo[(n,f,h,k1,k2,z1,z2)]
+    x=0
+    if f>0 and k1>0:
+        x=getans(n-1,f-1,h,k1-1,z2,z1,z2)
+    y=0
+    if h>0 and k2>0:
+        y=getans(n-1,f,h-1,z1,k2-1,z1,z2)
+    memo[(n,f,h,k1,k2,z1,z2)]=x+y
+    return x+y
+
+n1,n2,k1,k2=map(int,input().split())
+print(getans(n1+n2,n1,n2,k1,k2,k1,k2))

New folder/disjointset.py

@@ -0,0 +1,36 @@
+#owl fight hackerrank.com
+
+
+# n=input()
+n=5
+parent=[-1 for i in range(n+1)]
+
+def find(a):
+    if parent[a]<0:
+        return a
+
+    else:
+        x=find(parent[a])
+        parent[a]=x
+        return x
+        
+
+def union(a,b):
+    parent[a]=min(parent[a],parent[b])
+    parent[b]=a
+
+for i in range(3):
+    a,b=map(int,input().split())
+    union(a,b)
+
+for q in range(2):
+    x,y=map(int,input().split())
+    if find(x)==find(y):
+        print("TIE")
+    if find(x)>find(y):
+        print(x)
+    if find(y)>find(x):
+        print(y)
+
+
+

New folder/eulerstotientfunction.py

@@ -0,0 +1,51 @@
+
+
+
+def phi1(n):
+    ''' 
+    sqrt(n)
+    '''
+    res=n
+    i=2
+    while(i*i<=n):
+        if n%i==0:
+            res=res//i
+            res=res*(i-1)
+
+            while(n%i==0):
+                n=n//i
+
+        i+=1
+
+    if n>1:
+        res=res//n
+        res=res*(n-1)
+    return res
+
+
+'''
+log(log(n))
+'''
+def phi2(maxn):
+    phi=[]
+    for i in range(maxn+2):
+        phi.append(i)
+
+    for i in range(2,maxn+2):
+        if phi[i]==i:
+            for j in range(i,maxn+2,i):
+                phi[j]=phi[j]//i
+                phi[j]*=(i-1)
+
+
+    return phi[maxn]
+
+
+
+t=10
+while(t):
+    n=int(input())
+
+    print(phi1(n))
+    print(phi2(n))
+

New folder/gcdquery.py

@@ -0,0 +1,28 @@
+'''
+given an array=[2,4,6,9,10] and two integers L,R you have to find gcd of all numbers from L to R excluding L,R'''
+
+from math import gcd
+
+array=[2,4,6,9,10]
+def pre(arr,n):
+    pre=[0 for i in range(n)]
+    pre[0]=arr[0]
+    for i in range(1,n):
+        pre[i]=gcd(arr[i],pre[i-1])
+
+
+    return pre
+
+def suf(arr,n):
+    suf=[0 for i in range(n)]
+    suf[n-1]=arr[n-1]
+    for i in range(n-2,0):
+        suf[i]=gcd(arr[i],suf[i+1])
+
+    return suf
+
+
+n=len(array)
+pre=pre(array, n)
+suf=suf(array, n)
+print(gcd(pre[1],suf[3]))

New folder/matrixexpo.py

@@ -0,0 +1,2 @@
+from math import gcd
+print(gcd(1,2))

New folder/owlfight(disjointset).py

@@ -0,0 +1,51 @@
+#owl fight hackerrank.com
+
+
+# n=input()
+n=5
+parent=[-1 for i in range(n+1)]
+rank=[1 for i in range(n+1)]
+def find(a):
+    if parent[a]<0:
+        return a
+
+    else:
+        x=find(parent[a])
+        parent[a]=x
+        return x
+        
+
+def union(a,b):
+    parent[a]=min(parent[a],parent[b])
+    parent[b]=a
+
+# original
+def merge(a,b):
+    a=find(a)
+    b=find(b)
+    if a==b:
+        return 
+
+    if rank[a]>rank[b]:
+        parent[b]=a
+        rank[a]+=rank[b]
+    else:
+        parent[a]=b
+        rank[b]+=a
+
+
+for i in range(3):
+    a,b=map(int,input().split())
+    union(a,b)
+
+for q in range(2):
+    x,y=map(int,input().split())
+    if find(x)==find(y):
+        print("TIE")
+    if find(x)>find(y):
+        print(x)
+    if find(y)>find(x):
+        print(y)
+
+
+

New folder/seivefactorisation.py

@@ -0,0 +1,17 @@
+maxn=1000001
+
+
+def seivefact():
+    arr=[-1 for i in range(maxn+1)]
+    for i in range(2,maxn+1):
+        if arr[i]==-1:
+            j=i
+            while(j<=maxn):
+                if arr[j]==-1:
+                    arr[j]=i
+                j=j+i
+    return arr
+
+
+
+print(seivefact())

bridges.py

@@ -0,0 +1,18 @@
+def dfs(node,par):
+    vis[node]=1
+    In[node]=low[node]=timer 
+    timer+=1
+    for child in graph[node]:
+        if child==par:
+            continue
+        if vis[child]==1:
+            low[node]=min(low[node], In[child])
+        else:
+            dfs(child,node)
+
+            if low[child]>In[node]:
+                print("{0} -> {1} is a bridge".format(child,node))
+                low[node]=min(low[node], low[child])
+
+
+    

cereja and brackets.py

@@ -0,0 +1,45 @@
+def combine(left,right):
+    z=min(left[1],right[2])
+    a=left[0]+right[0]+z
+    b=left[1]+right[1]-z
+    c=left[2]+right[2]-z
+    return (a,b,c)
+
+
+def build(idx,l,r):
+    if l==r:
+        if string[l]=='(':
+            tree[1]+=1
+        else:
+            tree[2]+=1
+    else:
+        mid=(l+r)//2
+        build(2*idx+1,l,mid)
+        build(2*idx+2,mid+1,r)
+        tree[idx]=combine(tree[2*idx+1],tree[2*idx+2])
+
+def query(idx,x,y,l,r):
+    if l>=y or x>=r:
+        return (0,0,0)
+    if x<=l and r<=y:
+        return tree[idx]
+    mid=(l+r)//2
+    left=query(2*idx+1,x,y,l,mid)
+    right=query(2*idx+2,x,y,mid+1,r)
+    
+    return combine(left,right)
+
+
+if __name__ == '__main__':
+    string=input()
+    n=len(string)
+    m=int(input())
+    tree=[(0,0,0) for i in range(5*n)]
+    build(0,0,n-1)
+    for i in range(m):
+        a,b=map(int,input().split())
+        a=a-1
+        b=b-1
+        ans=query(0,a,b,0,n-1)
+        print(ans)
+    

dpontrees.py

@@ -12,7 +12,7 @@ def dfs(x:int,parent:int):
 		taking+=dp[y][1]
 		nottaking+=dp[y][0]
 	dp[x][1]=nottaking
-	dp[x][False]=max(taking,nottaking)
+	dp[x][0]=max(taking,nottaking)
 
 if __name__ == '__main__':
 	n=int(input())

flateningoftree.py

@@ -0,0 +1,23 @@
+
+
+def dfs(root,parent):
+    global timer
+    flat[timer]=root
+    timer+=1
+    for child in tree[root]:
+        if child!=parent:
+            dfs(child,root)
+
+    flat[timer]=root
+    timer+=1
+
+tree=[[] for i in range(4)]
+for i in range(1,4):
+    a,b=map(int,input().split())
+    tree[a].append(b)
+    tree[b].append(a)
+timer=1
+flat=[0 for i in range(2*3+2)]
+dfs(1,0)
+print(flat)
+

lazypropagation.py

@@ -0,0 +1,40 @@
+def upd(idx,l,r,x):
+    lazy[idx]+=x
+    s[idx]+=(r-l)*x
+
+def shift(id,l,r):
+    mid=(l+r)//2
+    upd(2*idx+1,l,mid,lazy[idx])
+    upd(2*idx+2,mid+1,r,lazy[idx])
+    lazy[idx]=0
+
+
+def increase(x,y,val,idx,l,r):
+    if x>=r or l>=y:
+        return 0
+    if x<=l and r<=y:
+        upd(idx,l,r,val)
+    shift(idx,l,r)
+    mid=(l+r)//2
+    increase(x,y,val,2*idx+1,l,mid)
+    increase(x,y,val,2*idx+2,mid+1,r)
+    s[idx]=s[2*idx+1]+s[2*idx+2]
+
+def calsum(x,y,idx,l,r):
+    if x>=r or l>=y:
+        return 0
+    if x<=l and r<=y:
+        return s[idx]
+    shift(idx,l,r)
+    return calsum(x,y,2*idx+1,l,mid)+calsum(x,y,idx,2*idx+2,mid+1,r)
+
+
+
+
+if __name__ == '__main__':
+    arr=[1,2,3,4,5]
+    n=5
+    s=[0 for i in range(2*n)]
+    lazy=[0 for j in range(2*n)]
+    ans1=calsum(0, n-1, idx=0, l=0, r=n-1)
+    increase(0, n-1, 1, idx=0, l=0, r=n-1)