Merge pull request #20 from AbhiSaphire/pc-upload

HackerCup Qualifier Solutions

Author: AbhiSaphire

Coding Club India/Asked Google Interview Questions/MaxSquareSubMatrixGivenSize.py

@@ -0,0 +1,32 @@
+def Maximum_Sum(mat,n,k):
+ if k > n:
+ return 0
+ stripSum = [[0 for i in range(n)] for j in range(n-k+1)]
+ 
+ for j in range(n):
+ sum = 0
+ for i in range(k):
+ sum += mat[i][j]
+ stripSum[0][j] = sum
+ 
+ for i in range(1, n-k+1):
+ sum += (mat[i+k-1][j] - mat[i-1][j])
+ stripSum[i][j] = sum
+ 
+ print(stripSum)
+ max_sum = -999999999
+ for i in range(n-k+1):
+ sum = 0
+ for j in range(k):
+ sum += stripSum[i][j]
+ if sum > max_sum:
+ max_sum = sum
+
+ for j in range(1, n-k+1):
+ sum += (stripSum[i][j+k-1] - stripSum[i][j-1])
+ if sum > max_sum:
+ max_sum = sum
+ 
+ return max_sum
+
+print(Maximum_Sum([[1, 1, 1, 1, 1], [1, 1, 1, 1, 1], [1, 1, 1, 1, 1], [1, 1, 1, 1, 1], [1, 1, 2, 2, 1]], 5, 3))

Extras/HackerCup/ProblemA_TravelRestrictions.py

@@ -0,0 +1,54 @@
+def travel(n,I,O):
+ l1=[]
+ #print(I,O)
+ for i in range(n):
+ l4=[]
+ for j in range(n):
+ if i==j:
+ l4.append(1)
+ else:
+ l4.append(0)
+ l1.append(l4)
+ #print(l1)
+ #print(l1[0].index(1))
+ for out in range(n):
+ incoming=out
+ outgoing=out
+ while(incoming!=0):
+ incoming-=1
+ #print(outgoing,incoming,O[outgoing],I[incoming])
+ if O[outgoing]=='Y' and I[incoming]=='Y':
+ l1[out][incoming]=1
+ outgoing-=1
+ else:
+ break
+ #print(l1)
+ for out in range(n):
+ incoming=out
+ outgoing=out
+ while(incoming!=(n-1)):
+ incoming+=1
+ #print(outgoing,incoming,O[outgoing],I[incoming])
+ if O[outgoing]=='Y' and I[incoming]=='Y':
+ l1[out][incoming]=1
+ outgoing+=1
+ else:
+ break
+ #print(l1)
+ for i in range(n):
+ for j in range(n):
+ if l1[i][j]==1:
+ print('Y',end="")
+ else:
+ print('N',end="")
+ print()
+
+t=int(input())
+for i in range(t):
+ n=int(input())
+ I=input()
+ I=list(I)
+ O=input()
+ O=list(O)
+ print("Case #",i+1,":",sep="")
+ travel(n,I,O)

Extras/HackerCup/ProblemB_Alchemy.py

@@ -0,0 +1,64 @@
+#include<bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+using namespace __gnu_pbds;
+using namespace std;
+
+#define mod 1000000007
+#define lli long long
+#define fi first
+#define se second
+#define pb emplace_back
+#define FOR(i,n) for(int i=0;i<n;i++)
+#define FORR(x,v) for(auto x : v)
+#define ordered_set tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
+#define MAXC 800005
+// %
+
+int n, m, i, j, t, q, ok, cnt;
+lli k, r, x, y, z, ans, P[MAXC], H[MAXC];
+string s, c;
+
+int main(int argc, char **argv)
+{
+ ios::sync_with_stdio(0);
+ cin.tie(0);
+ cin >> t;
+ for(q=1;q<=t;q++, ans=0){
+ cin >> n;
+ FOR(i, n){
+ cin >> P[i] >> H[i];
+ }
+ vector< int > ord(n);
+ iota(ord.begin(), ord.end(), 0);
+ sort(ord.begin(), ord.end(), [&](int i, int j){
+ return P[i] < P[j];
+ });
+ map< lli, lli > L, R;
+ FORR(i, ord){
+ if(R.count(P[i])){
+ R[P[i]+H[i]] = R.count(P[i] + H[i])? min(R[P[i]+H[i]], R[P[i]]) : R[P[i]] ;
+ }
+ else{
+ R[P[i]+H[i]] = R.count(P[i] + H[i])? min(R[P[i]+H[i]], P[i]) : P[i] ;
+ }
+ ans = max(ans, abs(R[P[i]+H[i]] - (P[i] + H[i])));
+ }
+ reverse(ord.begin(), ord.end());
+ FORR(i, ord){
+ if(L.count(P[i])){
+ L[P[i]-H[i]] = L.count(P[i] - H[i])? max(L[P[i]-H[i]], L[P[i]]) : L[P[i]] ;
+ }
+ else{
+ L[P[i]-H[i]] = L.count(P[i] - H[i])? max(L[P[i]-H[i]], P[i]) : P[i] ;
+ }
+ ans = max(ans, abs(L[P[i]-H[i]] - (P[i] - H[i])));
+ }
+ FORR(x, L){
+ if(R.count(x.fi)){
+ ans = max(ans, abs(x.se - x.fi) + abs(R[x.fi] - x.fi));
+ }
+ }
+ cout << "Case #" << q << ": " << ans << '\n';
+ }
+}

Extras/HackerCup/a.out

@@ -0,0 +1,22 @@
+def JosephusProblem(n, k):
+if n == 1:
+return 1
+ret = (JosephusProblem(n-1, k) + k-1) % n+1
+# print(ret, n, k)
+return ret
+
+print(JosephusProblem(7, 3))
+print(JosephusProblem(5, 2))
+print(JosephusProblem(6, 2))
+
+
+
+# n = 6, k = 2 ------> 5
+# 
+#	->	1 ->
+#	6	2
+#	^	|
+#	|	v
+#	5	3
+#	<-	4 <-
+# 

Extras/HackerCup/c.cpp

@@ -0,0 +1,12 @@
+def RecursivePalindrome(s):
+if len(s) <= 1:
+return True
+if s[0] != s[-1]:
+return False
+if s[0] == s[-1]:
+return RecursivePalindrome(s[1:-1])
+
+print(RecursivePalindrome("abba"))# True
+print(RecursivePalindrome("abvba"))# True
+print(RecursivePalindrome("abdc"))# False
+print(RecursivePalindrome("aabba"))# False

HackerEarth/Recursion/JosephusProblem.py

@@ -0,0 +1,10 @@
+def RecursiveSearch(l, x):
+if not len(l):
+return False
+if l[0] == x:
+return True
+if l[-1] == x:
+return True
+return RecursiveSearch(l[1:-1], x)
+
+print(RecursiveSearch([10, 22, 343, 421, 11, 6, 7, 8, 9, 10], 11))

HackerEarth/Recursion/RecursivePalindrome.py

@@ -0,0 +1,27 @@
+# Subset or Subsequence generation 
+# Input - "abc", Output - "a", "b", "c", "ab", "ac", "abc", "bc"
+# Input - "abcd", Output - "a", "b", "c", "d", "ab", "ac", "ad", "abc", "acd", "abd", "abcd", "bc", "bcd", "bd", "cd"
+
+# "abc" "ab" "ac" "a" "bc" "b" "c" ""
+# \ / \ / \ / \ /
+# "ab" "a" "b" ""
+#	\ / \ /
+# "a" ""
+# \ /
+# curr = ""
+
+# Options - 
+# 1) Consider curr as a part of subset
+# 2) Do not consider curr as a part of subset
+
+def Subset(s, index = 0, curr = ''):
+if index == len(s):
+print(curr, end = ' ')
+return
+Subset(s, index + 1, curr + s[index])
+Subset(s, index + 1, curr)
+
+Subset("abc")
+print()
+Subset("abcd")
+print()

HackerEarth/Recursion/RecursiveSearch.py

@@ -0,0 +1,26 @@
+# Factorial Function With and Without Tail Recursion
+
+# The tail-recursive functions are considered better than 
+# non-tail recursive functions as tail-recursion can be 
+# optimized by compiler. The idea used by compilers to 
+# optimize tail-recursive functions is simple, since the
+# recursive call is the last statement, there is nothing 
+# left to do in the current function, so saving the current 
+# function’s stack frame is of no use.
+
+
+def NotTailFactorial(n):
+if n <= 1:
+return 1
+return n*NotTailFactorial(n-1)
+
+def TailFactorial(n, a):
+if n <= 1:
+return a
+return TailFactorial(n-1, n*a)
+
+print(NotTailFactorial(20))
+print(TailFactorial(20, 1))
+
+print(NotTailFactorial(30))
+print(TailFactorial(30, 1))