adc soluções em python

analise-de-dados/src/test.py

@@ -0,0 +1,58 @@
+import sys
+MOD = 1000000007
+n = 0
+d = []
+
+
+def read_input():
+    global n
+    global d
+    n = int(input())
+    d = list(map(int, input().split()))
+
+
+def compute(dp, i, j, k):
+    global d
+    if dp[i][j][k] != -1:
+        return dp[i][j][k]
+
+    if i == 1:
+        return 1 if k == 1 else 0
+
+    dp[i][j][k] = 0
+
+    if k>1:
+        dp[i][j][k] = compute(dp, i-1, j, k-1) % MOD
+        dp[i][j][k] %= MOD
+
+    else:
+        for x in range(6):
+            if x == j:
+                continue
+            for l in range(1, d[x]+1):
+                dp[i][j][k] += compute(dp, i-1, x, l)
+                dp[i][j][k] %= MOD
+
+
+    return dp[i][j][k]
+
+
+def solve():
+    global n
+    global d
+    dp = [[[-1 for _ in range(d[j]+1)] for j in range(6)] for _ in range(n+1)]
+    ans = 0
+    for j in range(6):
+        for k in range(1,min(d[j]+1,n+1)):
+            ans = (ans + compute(dp, n, j, k)) % MOD
+
+    print(ans)
+
+def main():
+    sys.setrecursionlimit(10000)   
+    read_input()
+    solve()
+
+
+if __name__ == "__main__":
+    main()

edit-distance/src/saad.py

@@ -0,0 +1,35 @@
+class Solver:
+    def __init__(self) -> None:
+        self.s1 = ""
+        self.s2 = ""
+        self.n = 0
+        self.m = 0
+
+    def read_input(self) -> None:
+        (self.n,self.m) = map(int, input().split())
+        (self.s1,self.s2) = input().split()
+
+    def solve(self) -> None:
+        dp: list[list[int]] = [[0] * (self.m + 1) for _ in range(self.n + 1)]
+        for i in range(self.n + 1):
+            dp[i][0] = i
+        for j in range(self.m + 1):
+            dp[0][j] = j
+        for i in range(1, self.n + 1):
+            for j in range(1, self.m + 1):
+                if self.s1[i - 1] == self.s2[j - 1]:
+                    dp[i][j] = dp[i - 1][j - 1]
+                else:
+                    dp[i][j] = min(dp[i - 1][j] + 1, dp[i]
+                                   [j - 1] + 1, dp[i - 1][j - 1] + 1)
+        print(dp[self.n][self.m])
+
+
+def main():
+    solver = Solver()
+    solver.read_input()
+    solver.solve()
+
+
+if __name__ == "__main__":
+    main()

flowers/src/dp_bottom_up.py

@@ -0,0 +1,80 @@
+import sys
+MOD = 1000000000 + 7
+
+
+class Solver:
+    def __init__(self) -> None:
+        self.n = 0
+        self.m = 0
+
+    def read_input(self) -> None:
+        self.n, self.m = map(int, input().split())
+
+    def solve(self) -> None:
+        dp = [[[0] * (self.m + 1) for _ in range(2)] for _ in range(2)]
+
+        prev = 0
+        cur = 1
+
+        dp[prev][0][0] = 1
+        dp[prev][1][0] = 1
+
+        for _ in range(1, self.n + 1):
+            # clear current layer
+            for j in range(2):
+                for k in range(self.m + 1):
+                    dp[cur][j][k] = 0
+
+            for j in range(2):
+                # Start a new run of j
+                for l in range(self.m + 1):
+                    dp[cur][j][1] += dp[prev][1 - j][l]
+                    dp[cur][j][1] %= MOD
+
+                # Extend existing run
+                for k in range(2, self.m + 1):
+                    dp[cur][j][k] = dp[prev][j][k - 1]
+                    dp[cur][j][k] %= MOD
+
+            cur, prev = prev, cur
+
+        ans = 0
+
+        for j in range(2):
+            for k in range(1, self.m + 1):
+                ans += dp[prev][j][k]
+                ans %= MOD
+
+        print(ans)
+
+    def recurse(self, dp: list[list[list[int]]], i: int, j: int, k: int) -> int:
+        if i == 0:
+            dp[i][j][k] = 1 if k == 0 else 0
+        elif i == 1:
+            dp[i][j][k] = 1 if k == 1 else 0
+
+        if dp[i][j][k] != -1:
+            return dp[i][j][k]
+
+        ans = 0
+        if k > 1:
+            ans = self.recurse(dp, i-1, j, k-1)
+            ans %= MOD
+        else:
+            for l in range(1, self.m+1):
+                ans += self.recurse(dp, i-1, 1-j, l)
+                ans %= MOD
+
+        dp[i][j][k] = ans
+        return ans
+
+
+def main() -> None:
+    solver = Solver()
+    solver.read_input()
+    solver.solve()
+
+
+if __name__ == "__main__":
+    sys.setrecursionlimit(10**7)
+    main()

flowers/src/saad.py

@@ -0,0 +1,52 @@
+import sys
+MOD = 1000000000 + 7
+
+
+class Solver:
+    def __init__(self) -> None:
+        self.n = 0
+        self.m = 0
+
+    def read_input(self) -> None:
+        self.n, self.m = map(int, input().split())
+
+    def solve(self) -> None:
+        dp = [[[-1] * (self.m+1) for _ in range(2)] for _ in range(self.n+1)]
+        ans = 0
+        for j in range(2):
+            for k in range(1,self.m+1):
+                ans += self.recurse(dp, self.n, j, k)
+                ans %= MOD
+        print(ans)
+
+    def recurse(self, dp: list[list[list[int]]], i: int, j: int, k: int) -> int:
+        if i==0:
+            dp[i][j][k] = 1 if k == 0 else 0
+        elif i == 1:
+            dp[i][j][k] = 1 if k == 1 else 0
+
+        if dp[i][j][k] != -1:
+            return dp[i][j][k]
+
+        ans = 0
+        if k > 1:
+            ans = self.recurse(dp, i-1, j, k-1)
+            ans %= MOD
+        else:
+            for l in range(1,self.m+1):
+                ans += self.recurse(dp, i-1, 1-j, l)
+                ans %= MOD
+
+        dp[i][j][k] = ans
+        return ans
+
+
+def main() -> None:
+    solver = Solver()
+    solver.read_input()
+    solver.solve()
+
+
+if __name__ == "__main__":
+    sys.setrecursionlimit(10**7)
+    main()

maximum-subarray-sum/src/saad.py

@@ -0,0 +1,24 @@
+class solver:
+    def __init__(self):
+        self.v_ = []
+        self.n = 0
+
+    def read_input(self):
+        self.n = int(input())
+        self.v_ = list(map(int, input().split()))
+
+    def solve(self):
+        (v, n) = self.v_, self.n
+        dp = [ x for x in v]
+        for i in range(1, n):
+            dp[i] = max(dp[i-1] + v[i], dp[i])
+        ans = max(dp)
+        print(ans)
+    
+def main()->None: 
+    s = solver()
+    s.read_input()
+    s.solve()
+
+if __name__ == "__main__":
+    main()