description stringlengths 171 4k | code stringlengths 94 3.98k | normalized_code stringlengths 57 4.99k |
|---|---|---|
Polycarpus plays with red and blue marbles. He put n marbles from the left to the right in a row. As it turned out, the marbles form a zebroid.
A non-empty sequence of red and blue marbles is a zebroid, if the colors of the marbles in this sequence alternate. For example, sequences (red; blue; red) and (blue) are zebr... | class CodeforcesTask209ASolution:
def __init__(self):
self.result = ""
self.n = 0
def read_input(self):
self.n = int(input())
def process_task(self):
ways = [0] * (self.n + 1)
ways[0] = 1
ways[1] = 2
md = 1000000007
for x in range(2, self.n ... | CLASS_DEF FUNC_DEF ASSIGN VAR STRING ASSIGN VAR NUMBER FUNC_DEF ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_DEF ASSIGN VAR BIN_OP LIST NUMBER BIN_OP VAR NUMBER ASSIGN VAR NUMBER NUMBER ASSIGN VAR NUMBER NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER ASSIGN VAR VAR BIN_OP BIN_OP BIN_OP NUMBER VA... |
Polycarpus plays with red and blue marbles. He put n marbles from the left to the right in a row. As it turned out, the marbles form a zebroid.
A non-empty sequence of red and blue marbles is a zebroid, if the colors of the marbles in this sequence alternate. For example, sequences (red; blue; red) and (blue) are zebr... | R = lambda: map(int, input().split())
n = int(input())
arr = [1, 2] + [0] * n
for i in range(2, n):
arr[i] = (arr[i - 1] + arr[i - 2]) % 1000000007
for i in range(n):
arr[i] = (arr[i] + arr[i - 1]) % 1000000007
print(arr[n - 1]) | ASSIGN VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR BIN_OP LIST NUMBER NUMBER BIN_OP LIST NUMBER VAR FOR VAR FUNC_CALL VAR NUMBER VAR ASSIGN VAR VAR BIN_OP BIN_OP VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR BIN_OP BIN_OP ... |
Polycarpus plays with red and blue marbles. He put n marbles from the left to the right in a row. As it turned out, the marbles form a zebroid.
A non-empty sequence of red and blue marbles is a zebroid, if the colors of the marbles in this sequence alternate. For example, sequences (red; blue; red) and (blue) are zebr... | n = int(input())
a = [0] * n
b = 0
a[0] = 1
if n > 1:
a[1] = 2
for i in range(2, n):
a[i] = (a[i - 2] + a[i - 1] + 1) % (10**9 + 7)
if n > 1:
b = a[n - 2]
print((a[n - 1] + b) % (10**9 + 7)) | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR BIN_OP LIST NUMBER VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER NUMBER IF VAR NUMBER ASSIGN VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER VAR ASSIGN VAR VAR BIN_OP BIN_OP BIN_OP VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER NUMBER BIN_OP BIN_OP NUMBER NUMBER NUMBER IF VAR NUM... |
Polycarpus plays with red and blue marbles. He put n marbles from the left to the right in a row. As it turned out, the marbles form a zebroid.
A non-empty sequence of red and blue marbles is a zebroid, if the colors of the marbles in this sequence alternate. For example, sequences (red; blue; red) and (blue) are zebr... | n = int(input())
if n != 1:
array = [(1) for k in range(n + 1)]
array[1] = 1
array[2] = 2
sumi = 3
for k in range(3, n + 1):
array[k] = array[k - 1] + array[k - 2] % int(1000000000.0 + 7)
sumi += array[k] % int(1000000000.0 + 7)
print(sumi % int(1000000000.0 + 7))
else:
print... | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR IF VAR NUMBER ASSIGN VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR NUMBER NUMBER ASSIGN VAR NUMBER NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER ASSIGN VAR VAR BIN_OP VAR BIN_OP VAR NUMBER BIN_OP VAR BIN_OP VAR NUMBER FUNC_CALL VAR BIN_OP NUMB... |
Polycarpus plays with red and blue marbles. He put n marbles from the left to the right in a row. As it turned out, the marbles form a zebroid.
A non-empty sequence of red and blue marbles is a zebroid, if the colors of the marbles in this sequence alternate. For example, sequences (red; blue; red) and (blue) are zebr... | n = int(input())
mod = 1000000007
red, blue = 0, 0
for i in range(n):
if i % 2 == 0:
red += blue + 1
red %= mod
else:
blue += red + 1
blue %= mod
print((red + blue) % mod) | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR NUMBER ASSIGN VAR VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR VAR IF BIN_OP VAR NUMBER NUMBER VAR BIN_OP VAR NUMBER VAR VAR VAR BIN_OP VAR NUMBER VAR VAR EXPR FUNC_CALL VAR BIN_OP BIN_OP VAR VAR VAR |
Polycarpus plays with red and blue marbles. He put n marbles from the left to the right in a row. As it turned out, the marbles form a zebroid.
A non-empty sequence of red and blue marbles is a zebroid, if the colors of the marbles in this sequence alternate. For example, sequences (red; blue; red) and (blue) are zebr... | n = int(input())
dp = [1] * n
sb = 0
sr = 0
j = 0
ans = 0
while j < n:
if j % 2 == 0:
dp[j] += sb
dp[j] = dp[j] % 1000000007
sr += dp[j]
else:
dp[j] += sr
dp[j] = dp[j] % 1000000007
sb += dp[j]
ans += dp[j]
ans = ans % 1000000007
j += 1
print(ans) | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR BIN_OP LIST NUMBER VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER WHILE VAR VAR IF BIN_OP VAR NUMBER NUMBER VAR VAR VAR ASSIGN VAR VAR BIN_OP VAR VAR NUMBER VAR VAR VAR VAR VAR VAR ASSIGN VAR VAR BIN_OP VAR VAR NUMBER VAR VAR VAR VAR VAR VAR... |
Polycarpus plays with red and blue marbles. He put n marbles from the left to the right in a row. As it turned out, the marbles form a zebroid.
A non-empty sequence of red and blue marbles is a zebroid, if the colors of the marbles in this sequence alternate. For example, sequences (red; blue; red) and (blue) are zebr... | n = int(input())
a, b = 0, 0
for i in range(n):
if i % 2 == 0:
a += b + 1
else:
b += a + 1
a, b = a % 1000000007, b % 1000000007
print((a + b) % 1000000007) | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR VAR IF BIN_OP VAR NUMBER NUMBER VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER ASSIGN VAR VAR BIN_OP VAR NUMBER BIN_OP VAR NUMBER EXPR FUNC_CALL VAR BIN_OP BIN_OP VAR VAR NUMBER |
Polycarpus plays with red and blue marbles. He put n marbles from the left to the right in a row. As it turned out, the marbles form a zebroid.
A non-empty sequence of red and blue marbles is a zebroid, if the colors of the marbles in this sequence alternate. For example, sequences (red; blue; red) and (blue) are zebr... | n = int(input())
mod = 10**9 + 7
if n >= 2:
dp = [(0) for i in range(n)]
dp[0], dp[1] = 1, 2
ans = 3
for i in range(2, n):
dp[i] = (dp[i - 1] + dp[i - 2]) % mod
ans = (ans + dp[i]) % mod
print(ans)
else:
print(1) | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR BIN_OP BIN_OP NUMBER NUMBER NUMBER IF VAR NUMBER ASSIGN VAR NUMBER VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER VAR NUMBER NUMBER NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER VAR ASSIGN VAR VAR BIN_OP BIN_OP VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER VAR ASSIGN VAR... |
Polycarpus plays with red and blue marbles. He put n marbles from the left to the right in a row. As it turned out, the marbles form a zebroid.
A non-empty sequence of red and blue marbles is a zebroid, if the colors of the marbles in this sequence alternate. For example, sequences (red; blue; red) and (blue) are zebr... | n = int(input())
if n == 1:
print(1)
elif n == 2:
print(3)
else:
a = [1, 3]
i = 2
while i < n:
a.append((a[0] + a[1] + 2) % 1000000007)
i += 1
a.pop(0)
print(a[1]) | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR IF VAR NUMBER EXPR FUNC_CALL VAR NUMBER IF VAR NUMBER EXPR FUNC_CALL VAR NUMBER ASSIGN VAR LIST NUMBER NUMBER ASSIGN VAR NUMBER WHILE VAR VAR EXPR FUNC_CALL VAR BIN_OP BIN_OP BIN_OP VAR NUMBER VAR NUMBER NUMBER NUMBER VAR NUMBER EXPR FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR VAR NUM... |
Initially on a notepad only one character 'A' is present. You can perform two operations on this notepad for each step:
Copy All: You can copy all the characters present on the notepad (partial copy is not allowed).
Paste: You can paste the characters which are copied last time.
Given a number n. You have to get ... | class Solution:
def minSteps(self, n):
res = 0
p = 2
while n > 1:
while n % p == 0:
res += p
n /= p
p += 1
return res | CLASS_DEF FUNC_DEF ASSIGN VAR NUMBER ASSIGN VAR NUMBER WHILE VAR NUMBER WHILE BIN_OP VAR VAR NUMBER VAR VAR VAR VAR VAR NUMBER RETURN VAR |
Initially on a notepad only one character 'A' is present. You can perform two operations on this notepad for each step:
Copy All: You can copy all the characters present on the notepad (partial copy is not allowed).
Paste: You can paste the characters which are copied last time.
Given a number n. You have to get ... | class Solution:
def minSteps(self, n):
if n == 1:
return 0
return self.calcsteps(0, n)
def isprime(self, n):
if n == 2 or n == 3:
return True
if n % 2 == 0 or n % 3 == 0:
return False
i = 5
w = 2
while i * i <= n:
... | CLASS_DEF FUNC_DEF IF VAR NUMBER RETURN NUMBER RETURN FUNC_CALL VAR NUMBER VAR FUNC_DEF IF VAR NUMBER VAR NUMBER RETURN NUMBER IF BIN_OP VAR NUMBER NUMBER BIN_OP VAR NUMBER NUMBER RETURN NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER WHILE BIN_OP VAR VAR VAR IF BIN_OP VAR VAR NUMBER RETURN NUMBER VAR VAR ASSIGN VAR BIN_OP ... |
Initially on a notepad only one character 'A' is present. You can perform two operations on this notepad for each step:
Copy All: You can copy all the characters present on the notepad (partial copy is not allowed).
Paste: You can paste the characters which are copied last time.
Given a number n. You have to get ... | class Solution:
def minSteps(self, n):
f = 2
s = 0
while f * f <= n:
while n % f == 0:
s += f
n = int(n / f)
f += 1
if n > 1:
s += n
return int(s) | CLASS_DEF FUNC_DEF ASSIGN VAR NUMBER ASSIGN VAR NUMBER WHILE BIN_OP VAR VAR VAR WHILE BIN_OP VAR VAR NUMBER VAR VAR ASSIGN VAR FUNC_CALL VAR BIN_OP VAR VAR VAR NUMBER IF VAR NUMBER VAR VAR RETURN FUNC_CALL VAR VAR |
Initially on a notepad only one character 'A' is present. You can perform two operations on this notepad for each step:
Copy All: You can copy all the characters present on the notepad (partial copy is not allowed).
Paste: You can paste the characters which are copied last time.
Given a number n. You have to get ... | class Solution:
def minSteps(self, n):
def factors(n):
d = 2
while d * d <= n:
while n % d == 0:
n /= d
yield d
d += 1
if n > 1:
yield n
return int(sum(factors(n))) | CLASS_DEF FUNC_DEF FUNC_DEF ASSIGN VAR NUMBER WHILE BIN_OP VAR VAR VAR WHILE BIN_OP VAR VAR NUMBER VAR VAR EXPR VAR VAR NUMBER IF VAR NUMBER EXPR VAR RETURN FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR VAR |
Initially on a notepad only one character 'A' is present. You can perform two operations on this notepad for each step:
Copy All: You can copy all the characters present on the notepad (partial copy is not allowed).
Paste: You can paste the characters which are copied last time.
Given a number n. You have to get ... | class Solution:
def minSteps(self, n):
m = n
sum = 0
tmp = 2
if m == 1:
return 0
if m == 2:
return 2
else:
while m > tmp:
k = m % tmp
if k == 0:
m = m / tmp
su... | CLASS_DEF FUNC_DEF ASSIGN VAR VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER IF VAR NUMBER RETURN NUMBER IF VAR NUMBER RETURN NUMBER WHILE VAR VAR ASSIGN VAR BIN_OP VAR VAR IF VAR NUMBER ASSIGN VAR BIN_OP VAR VAR VAR VAR ASSIGN VAR BIN_OP VAR NUMBER ASSIGN VAR BIN_OP VAR VAR RETURN VAR |
Initially on a notepad only one character 'A' is present. You can perform two operations on this notepad for each step:
Copy All: You can copy all the characters present on the notepad (partial copy is not allowed).
Paste: You can paste the characters which are copied last time.
Given a number n. You have to get ... | class Solution:
def minSteps(self, n):
d = 2
ans = 0
while n > 1:
while n % d == 0:
ans += d
n = n / d
d = d + 1
return ans | CLASS_DEF FUNC_DEF ASSIGN VAR NUMBER ASSIGN VAR NUMBER WHILE VAR NUMBER WHILE BIN_OP VAR VAR NUMBER VAR VAR ASSIGN VAR BIN_OP VAR VAR ASSIGN VAR BIN_OP VAR NUMBER RETURN VAR |
Initially on a notepad only one character 'A' is present. You can perform two operations on this notepad for each step:
Copy All: You can copy all the characters present on the notepad (partial copy is not allowed).
Paste: You can paste the characters which are copied last time.
Given a number n. You have to get ... | class Solution:
def minSteps(self, n):
if n == 1:
return 0
isPrime = [(True) for _ in range(n + 1)]
isPrime[1] = False
prime = []
for i in range(2, n + 1):
if isPrime[i] == True:
prime.append(i)
k = 1
wh... | CLASS_DEF FUNC_DEF IF VAR NUMBER RETURN NUMBER ASSIGN VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR NUMBER NUMBER ASSIGN VAR LIST FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER IF VAR VAR NUMBER EXPR FUNC_CALL VAR VAR ASSIGN VAR NUMBER WHILE BIN_OP BIN_OP VAR NUMBER VAR VAR ASSIGN VAR BIN_OP BIN_OP VAR NUMB... |
Initially on a notepad only one character 'A' is present. You can perform two operations on this notepad for each step:
Copy All: You can copy all the characters present on the notepad (partial copy is not allowed).
Paste: You can paste the characters which are copied last time.
Given a number n. You have to get ... | class Solution:
def minSteps(self, n):
primeFactors = []
for i in range(2, int(n**0.5) + 1):
while n % i == 0:
primeFactors.append(i)
n = n // i
if n > 1:
primeFactors.append(n)
return sum(primeFactors) | CLASS_DEF FUNC_DEF ASSIGN VAR LIST FOR VAR FUNC_CALL VAR NUMBER BIN_OP FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER WHILE BIN_OP VAR VAR NUMBER EXPR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP VAR VAR IF VAR NUMBER EXPR FUNC_CALL VAR VAR RETURN FUNC_CALL VAR VAR |
Initially on a notepad only one character 'A' is present. You can perform two operations on this notepad for each step:
Copy All: You can copy all the characters present on the notepad (partial copy is not allowed).
Paste: You can paste the characters which are copied last time.
Given a number n. You have to get ... | class Solution:
def minSteps(self, n):
primes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31]
ret = 0
for p in primes:
while not n % p:
n /= p
ret += p
return int(ret + n * (n > 1)) | CLASS_DEF FUNC_DEF ASSIGN VAR LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER ASSIGN VAR NUMBER FOR VAR VAR WHILE BIN_OP VAR VAR VAR VAR VAR VAR RETURN FUNC_CALL VAR BIN_OP VAR BIN_OP VAR VAR NUMBER |
Given a triangular pyramid with its vertices marked as O, A, B and C and a number N, the task is to find the number of ways such that a person starting from the origin O initially, reaches back to the origin in N steps. In a single step, a person can go to any of its adjacent vertices.
Example 1:
Input:
N = 1
Output: 0... | class Solution:
def countPaths(self, N):
if N == 1:
return 0
else:
result = 0
for i in range(2, N + 1):
if i % 2 == 0:
result = (3 * result + 3) % (10**9 + 7)
else:
result = (3 * result - 3) ... | CLASS_DEF FUNC_DEF IF VAR NUMBER RETURN NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER IF BIN_OP VAR NUMBER NUMBER ASSIGN VAR BIN_OP BIN_OP BIN_OP NUMBER VAR NUMBER BIN_OP BIN_OP NUMBER NUMBER NUMBER ASSIGN VAR BIN_OP BIN_OP BIN_OP NUMBER VAR NUMBER BIN_OP BIN_OP NUMBER NUMBER NUMBER RETURN BIN... |
Given a triangular pyramid with its vertices marked as O, A, B and C and a number N, the task is to find the number of ways such that a person starting from the origin O initially, reaches back to the origin in N steps. In a single step, a person can go to any of its adjacent vertices.
Example 1:
Input:
N = 1
Output: 0... | class Solution:
def countPaths(self, N):
mod = 10**9 + 7
if N == 1:
return 0
a, b = 1, 0
for i in range(2, N):
b, a = a, (2 * a + 3 * b) % mod
return 3 * a % mod | CLASS_DEF FUNC_DEF ASSIGN VAR BIN_OP BIN_OP NUMBER NUMBER NUMBER IF VAR NUMBER RETURN NUMBER ASSIGN VAR VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER VAR ASSIGN VAR VAR VAR BIN_OP BIN_OP BIN_OP NUMBER VAR BIN_OP NUMBER VAR VAR RETURN BIN_OP BIN_OP NUMBER VAR VAR |
Given a triangular pyramid with its vertices marked as O, A, B and C and a number N, the task is to find the number of ways such that a person starting from the origin O initially, reaches back to the origin in N steps. In a single step, a person can go to any of its adjacent vertices.
Example 1:
Input:
N = 1
Output: 0... | class Solution:
def countPaths(self, N):
dp = [(0) for i in range(N + 1)]
prev = pres = 0
for i in range(2, N + 1):
if i % 2 == 0:
pres = (prev * 3 + 3) % (10**9 + 7)
else:
pres = prev * 3 - 3 % (10**9 + 7)
prev = pres
... | CLASS_DEF FUNC_DEF ASSIGN VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER IF BIN_OP VAR NUMBER NUMBER ASSIGN VAR BIN_OP BIN_OP BIN_OP VAR NUMBER NUMBER BIN_OP BIN_OP NUMBER NUMBER NUMBER ASSIGN VAR BIN_OP BIN_OP VAR NUMBER BIN_OP NUMBER BIN_OP BIN_OP N... |
Given a triangular pyramid with its vertices marked as O, A, B and C and a number N, the task is to find the number of ways such that a person starting from the origin O initially, reaches back to the origin in N steps. In a single step, a person can go to any of its adjacent vertices.
Example 1:
Input:
N = 1
Output: 0... | class Solution:
def countPaths(self, n):
if n < 2:
return 0
m = 10**9
m += 7
t = 0
i = 2
while i <= n:
t = t * 3 % m
if i % 2:
t -= 3
else:
t = (t + 3) % m
i += 1
retu... | CLASS_DEF FUNC_DEF IF VAR NUMBER RETURN NUMBER ASSIGN VAR BIN_OP NUMBER NUMBER VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER WHILE VAR VAR ASSIGN VAR BIN_OP BIN_OP VAR NUMBER VAR IF BIN_OP VAR NUMBER VAR NUMBER ASSIGN VAR BIN_OP BIN_OP VAR NUMBER VAR VAR NUMBER RETURN VAR |
Given a triangular pyramid with its vertices marked as O, A, B and C and a number N, the task is to find the number of ways such that a person starting from the origin O initially, reaches back to the origin in N steps. In a single step, a person can go to any of its adjacent vertices.
Example 1:
Input:
N = 1
Output: 0... | MODULO = 10**9 + 7
class Solution:
def countPaths(self, N):
dp = [0] * max(N + 1, 3)
dp[0] = 1
dp[1] = 0
dp[2] = 3
pow3 = 3
for i in range(3, N + 1):
pow3 *= 3
pow3 %= MODULO
dp[i] = (pow3 - dp[i - 1]) % MODULO
return dp[... | ASSIGN VAR BIN_OP BIN_OP NUMBER NUMBER NUMBER CLASS_DEF FUNC_DEF ASSIGN VAR BIN_OP LIST NUMBER FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER ASSIGN VAR NUMBER NUMBER ASSIGN VAR NUMBER NUMBER ASSIGN VAR NUMBER NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER VAR NUMBER VAR VAR ASSIGN VAR VAR BIN_OP BIN_O... |
Given a triangular pyramid with its vertices marked as O, A, B and C and a number N, the task is to find the number of ways such that a person starting from the origin O initially, reaches back to the origin in N steps. In a single step, a person can go to any of its adjacent vertices.
Example 1:
Input:
N = 1
Output: 0... | MOD = 1000000007
class Solution:
def countPaths(self, N):
if N == 1:
return 0
res = 0
for i in range(2, N + 1):
if i & 1:
res = (res * 3 - 3) % MOD
else:
res = (res * 3 + 3) % MOD
return res % MOD | ASSIGN VAR NUMBER CLASS_DEF FUNC_DEF IF VAR NUMBER RETURN NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER IF BIN_OP VAR NUMBER ASSIGN VAR BIN_OP BIN_OP BIN_OP VAR NUMBER NUMBER VAR ASSIGN VAR BIN_OP BIN_OP BIN_OP VAR NUMBER NUMBER VAR RETURN BIN_OP VAR VAR |
Given a triangular pyramid with its vertices marked as O, A, B and C and a number N, the task is to find the number of ways such that a person starting from the origin O initially, reaches back to the origin in N steps. In a single step, a person can go to any of its adjacent vertices.
Example 1:
Input:
N = 1
Output: 0... | class Solution:
def countPaths(self, N):
if N == 1:
return 0
mod = 10**9 + 7
t1 = 1
t2 = 0
for i in range(2, N):
t2, t1 = t1, (2 * t1 + 3 * t2) % mod
ans = 3 * t1 % mod
return ans | CLASS_DEF FUNC_DEF IF VAR NUMBER RETURN NUMBER ASSIGN VAR BIN_OP BIN_OP NUMBER NUMBER NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER VAR ASSIGN VAR VAR VAR BIN_OP BIN_OP BIN_OP NUMBER VAR BIN_OP NUMBER VAR VAR ASSIGN VAR BIN_OP BIN_OP NUMBER VAR VAR RETURN VAR |
Given a triangular pyramid with its vertices marked as O, A, B and C and a number N, the task is to find the number of ways such that a person starting from the origin O initially, reaches back to the origin in N steps. In a single step, a person can go to any of its adjacent vertices.
Example 1:
Input:
N = 1
Output: 0... | class Solution:
def countPaths(self, N):
if N < 2:
return 0
dp = [(0) for _ in range(N + 1)]
dp[2] = 3
mod = 1000000007
num = 3
for i in range(3, N + 1):
num = num * 3 % mod
dp[i] = (num - dp[i - 1] + mod) % mod
return dp[N... | CLASS_DEF FUNC_DEF IF VAR NUMBER RETURN NUMBER ASSIGN VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR NUMBER NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER ASSIGN VAR BIN_OP BIN_OP VAR NUMBER VAR ASSIGN VAR VAR BIN_OP BIN_OP BIN_OP VAR VAR BIN_OP VAR NUMBER VAR VAR R... |
Given a triangular pyramid with its vertices marked as O, A, B and C and a number N, the task is to find the number of ways such that a person starting from the origin O initially, reaches back to the origin in N steps. In a single step, a person can go to any of its adjacent vertices.
Example 1:
Input:
N = 1
Output: 0... | class Solution:
def countPaths(self, N):
M = 1000000000.0 + 7
if N <= 1:
return 0
prev0 = 2
prev1 = 3
for i in range(3, N + 1):
temp1 = 3 * prev0 % M
temp0 = (2 * prev0 + prev1) % M
prev0 = temp0
prev1 = temp1
... | CLASS_DEF FUNC_DEF ASSIGN VAR BIN_OP NUMBER NUMBER IF VAR NUMBER RETURN NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER ASSIGN VAR BIN_OP BIN_OP NUMBER VAR VAR ASSIGN VAR BIN_OP BIN_OP BIN_OP NUMBER VAR VAR VAR ASSIGN VAR VAR ASSIGN VAR VAR RETURN FUNC_CALL VAR VAR |
Given a triangular pyramid with its vertices marked as O, A, B and C and a number N, the task is to find the number of ways such that a person starting from the origin O initially, reaches back to the origin in N steps. In a single step, a person can go to any of its adjacent vertices.
Example 1:
Input:
N = 1
Output: 0... | class Solution:
def countPaths(self, N):
bigNum = 10**9 + 7
if N <= 1:
return 0
if N == 2:
return 3
ans = 0
prev = 3
for k in range(2, N):
if k % 2 == 0:
ans = 3 * prev - 3
else:
ans = 3 ... | CLASS_DEF FUNC_DEF ASSIGN VAR BIN_OP BIN_OP NUMBER NUMBER NUMBER IF VAR NUMBER RETURN NUMBER IF VAR NUMBER RETURN NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER VAR IF BIN_OP VAR NUMBER NUMBER ASSIGN VAR BIN_OP BIN_OP NUMBER VAR NUMBER ASSIGN VAR BIN_OP BIN_OP NUMBER VAR NUMBER ASSIGN VAR BIN_O... |
Given a triangular pyramid with its vertices marked as O, A, B and C and a number N, the task is to find the number of ways such that a person starting from the origin O initially, reaches back to the origin in N steps. In a single step, a person can go to any of its adjacent vertices.
Example 1:
Input:
N = 1
Output: 0... | class Solution:
def countPaths(self, N):
a = 1
M = 1000000000 + 7
for i in range(N):
if i % 2 == 0:
a = a * 3 - 3
else:
a = a * 3 + 3
a = a % M
return a | CLASS_DEF FUNC_DEF ASSIGN VAR NUMBER ASSIGN VAR BIN_OP NUMBER NUMBER FOR VAR FUNC_CALL VAR VAR IF BIN_OP VAR NUMBER NUMBER ASSIGN VAR BIN_OP BIN_OP VAR NUMBER NUMBER ASSIGN VAR BIN_OP BIN_OP VAR NUMBER NUMBER ASSIGN VAR BIN_OP VAR VAR RETURN VAR |
Given a triangular pyramid with its vertices marked as O, A, B and C and a number N, the task is to find the number of ways such that a person starting from the origin O initially, reaches back to the origin in N steps. In a single step, a person can go to any of its adjacent vertices.
Example 1:
Input:
N = 1
Output: 0... | class Solution:
def countPaths(self, N):
ans = []
if N == 0 or N == 1:
return 0
ans.append(0)
ans.append(3)
for i in range(3, N + 1):
ans.append((ans[-1] * 2 + ans[-2] * 3) % 1000000007)
return ans[-1] | CLASS_DEF FUNC_DEF ASSIGN VAR LIST IF VAR NUMBER VAR NUMBER RETURN NUMBER EXPR FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER EXPR FUNC_CALL VAR BIN_OP BIN_OP BIN_OP VAR NUMBER NUMBER BIN_OP VAR NUMBER NUMBER NUMBER RETURN VAR NUMBER |
Given a triangular pyramid with its vertices marked as O, A, B and C and a number N, the task is to find the number of ways such that a person starting from the origin O initially, reaches back to the origin in N steps. In a single step, a person can go to any of its adjacent vertices.
Example 1:
Input:
N = 1
Output: 0... | class Solution:
def countPaths(self, N):
mod = 1000000007
low, high = 1, 0
tlow, thigh = 1, 0
for i in range(2, N + 1):
high = 3 * tlow % mod
low = (2 * tlow % mod + thigh) % mod
tlow = low
thigh = high
return high | CLASS_DEF FUNC_DEF ASSIGN VAR NUMBER ASSIGN VAR VAR NUMBER NUMBER ASSIGN VAR VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER ASSIGN VAR BIN_OP BIN_OP NUMBER VAR VAR ASSIGN VAR BIN_OP BIN_OP BIN_OP BIN_OP NUMBER VAR VAR VAR VAR ASSIGN VAR VAR ASSIGN VAR VAR RETURN VAR |
Given a triangular pyramid with its vertices marked as O, A, B and C and a number N, the task is to find the number of ways such that a person starting from the origin O initially, reaches back to the origin in N steps. In a single step, a person can go to any of its adjacent vertices.
Example 1:
Input:
N = 1
Output: 0... | class Solution:
def countPaths(self, N):
if N < 2:
return 0
res = 3
k = 3
for temp in range(1, N - 1):
if temp % 2 == 0:
res = (res * 3 + k) % (10**9 + 7)
else:
res = (res * 3 - k) % (10**9 + 7)
return res | CLASS_DEF FUNC_DEF IF VAR NUMBER RETURN NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER IF BIN_OP VAR NUMBER NUMBER ASSIGN VAR BIN_OP BIN_OP BIN_OP VAR NUMBER VAR BIN_OP BIN_OP NUMBER NUMBER NUMBER ASSIGN VAR BIN_OP BIN_OP BIN_OP VAR NUMBER VAR BIN_OP BIN_OP NUMBER NUMBER NUMBE... |
Given a triangular pyramid with its vertices marked as O, A, B and C and a number N, the task is to find the number of ways such that a person starting from the origin O initially, reaches back to the origin in N steps. In a single step, a person can go to any of its adjacent vertices.
Example 1:
Input:
N = 1
Output: 0... | class Solution:
def countPaths(self, n):
add = True
ans = 0
for i in range(n - 1):
if add:
ans = ans * 3 + 3
else:
ans = ans * 3 - 3
add = not add
ans = ans % 1000000007
return ans % 1000000007 | CLASS_DEF FUNC_DEF ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER IF VAR ASSIGN VAR BIN_OP BIN_OP VAR NUMBER NUMBER ASSIGN VAR BIN_OP BIN_OP VAR NUMBER NUMBER ASSIGN VAR VAR ASSIGN VAR BIN_OP VAR NUMBER RETURN BIN_OP VAR NUMBER |
Given a triangular pyramid with its vertices marked as O, A, B and C and a number N, the task is to find the number of ways such that a person starting from the origin O initially, reaches back to the origin in N steps. In a single step, a person can go to any of its adjacent vertices.
Example 1:
Input:
N = 1
Output: 0... | class Solution:
def countPaths(self, N):
a, b = 0, 3
if N == 1:
return 0
for i in range(N - 2):
if i & 1:
b = (b * 3 + 3) % 1000000007
else:
b = (b * 3 - 3) % 1000000007
return b | CLASS_DEF FUNC_DEF ASSIGN VAR VAR NUMBER NUMBER IF VAR NUMBER RETURN NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER IF BIN_OP VAR NUMBER ASSIGN VAR BIN_OP BIN_OP BIN_OP VAR NUMBER NUMBER NUMBER ASSIGN VAR BIN_OP BIN_OP BIN_OP VAR NUMBER NUMBER NUMBER RETURN VAR |
Given a triangular pyramid with its vertices marked as O, A, B and C and a number N, the task is to find the number of ways such that a person starting from the origin O initially, reaches back to the origin in N steps. In a single step, a person can go to any of its adjacent vertices.
Example 1:
Input:
N = 1
Output: 0... | class Solution:
def countPaths(self, N):
if N == 1:
return 0
ans = 0
for i in range(2, N + 1):
if i % 2 == 0:
ans = 3 * (ans + 1)
else:
ans = 3 * (ans - 1)
ans = ans % (1000000000.0 + 7)
return int(ans) | CLASS_DEF FUNC_DEF IF VAR NUMBER RETURN NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER IF BIN_OP VAR NUMBER NUMBER ASSIGN VAR BIN_OP NUMBER BIN_OP VAR NUMBER ASSIGN VAR BIN_OP NUMBER BIN_OP VAR NUMBER ASSIGN VAR BIN_OP VAR BIN_OP NUMBER NUMBER RETURN FUNC_CALL VAR VAR |
Given a triangular pyramid with its vertices marked as O, A, B and C and a number N, the task is to find the number of ways such that a person starting from the origin O initially, reaches back to the origin in N steps. In a single step, a person can go to any of its adjacent vertices.
Example 1:
Input:
N = 1
Output: 0... | class Solution:
def countPaths(self, N):
mod = 10**9 + 7
if N == 1:
return 0
if N == 2:
return 3
dp = [0] * (N + 1)
dp[1] = 1
dp[2] = 3
cur = 3
for i in range(3, N + 1):
cur = cur * 3 % mod
dp[i] = (cur ... | CLASS_DEF FUNC_DEF ASSIGN VAR BIN_OP BIN_OP NUMBER NUMBER NUMBER IF VAR NUMBER RETURN NUMBER IF VAR NUMBER RETURN NUMBER ASSIGN VAR BIN_OP LIST NUMBER BIN_OP VAR NUMBER ASSIGN VAR NUMBER NUMBER ASSIGN VAR NUMBER NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER ASSIGN VAR BIN_OP BIN_OP VAR NUMBER ... |
Given a triangular pyramid with its vertices marked as O, A, B and C and a number N, the task is to find the number of ways such that a person starting from the origin O initially, reaches back to the origin in N steps. In a single step, a person can go to any of its adjacent vertices.
Example 1:
Input:
N = 1
Output: 0... | class Solution:
def countPaths_v1(self, N):
prevo = 1
prevA = 0
prevB = 0
prevC = 0
curro = 0
currA = 0
currB = 0
currC = 0
modv = 10**9 + 7
for i in range(1, N + 1):
curro = (prevA + prevB + prevC) % modv
currA... | CLASS_DEF FUNC_DEF ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR BIN_OP BIN_OP NUMBER NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER ASSIGN VAR BIN_OP BIN_OP BIN_OP VAR VAR VAR VAR ASSIGN VAR BIN_O... |
Given a triangular pyramid with its vertices marked as O, A, B and C and a number N, the task is to find the number of ways such that a person starting from the origin O initially, reaches back to the origin in N steps. In a single step, a person can go to any of its adjacent vertices.
Example 1:
Input:
N = 1
Output: 0... | class Solution:
def countPaths(self, N):
if N == 1:
return 0
val, curr, mod = 0, 2, 10**9 + 7
while curr <= N:
if curr % 2 == 0:
val = (val + 1) * 3 % mod
else:
val = (val - 1) * 3 % mod
curr += 1
return... | CLASS_DEF FUNC_DEF IF VAR NUMBER RETURN NUMBER ASSIGN VAR VAR VAR NUMBER NUMBER BIN_OP BIN_OP NUMBER NUMBER NUMBER WHILE VAR VAR IF BIN_OP VAR NUMBER NUMBER ASSIGN VAR BIN_OP BIN_OP BIN_OP VAR NUMBER NUMBER VAR ASSIGN VAR BIN_OP BIN_OP BIN_OP VAR NUMBER NUMBER VAR VAR NUMBER RETURN VAR |
Given a triangular pyramid with its vertices marked as O, A, B and C and a number N, the task is to find the number of ways such that a person starting from the origin O initially, reaches back to the origin in N steps. In a single step, a person can go to any of its adjacent vertices.
Example 1:
Input:
N = 1
Output: 0... | class Solution:
def countPaths(self, n):
mod = int(1000000000.0 + 7)
pre0 = 0
pre1 = 1
for i in range(1, n):
dp1 = 3 * pre1 % mod
dp2 = (2 * pre1 + pre0) % mod
pre0 = dp1
pre1 = dp2
return pre0 | CLASS_DEF FUNC_DEF ASSIGN VAR FUNC_CALL VAR BIN_OP NUMBER NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER VAR ASSIGN VAR BIN_OP BIN_OP NUMBER VAR VAR ASSIGN VAR BIN_OP BIN_OP BIN_OP NUMBER VAR VAR VAR ASSIGN VAR VAR ASSIGN VAR VAR RETURN VAR |
There is a 2D matrix of N rows and M columns. Rows are number 1 to N from top to bottom and columns 1 to M from left to right. You are standing at (1,1).
From, A [ i ] [ j ] you can move to A [ i + 1 ] [ j ] if A [ i + 1 ] [ j ] > A [ i ] [ j ].
Or, from, A [ i ] [ j ] you can move to A [ i ] [ j + 1 ] if A [ i ] [... | def longestPath(matrix):
path_matrix = []
temp = []
for i in range(len(matrix)):
for j in range(len(matrix[0])):
temp.append(0)
path_matrix.append(temp)
temp = []
for i in range(len(matrix)):
for j in range(len(matrix[0])):
if i == 0 and j == 0:
... | FUNC_DEF ASSIGN VAR LIST ASSIGN VAR LIST FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR VAR ASSIGN VAR LIST FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER IF VAR NUMBER VAR NUMBER ASSIGN VAR VAR ... |
There is a 2D matrix of N rows and M columns. Rows are number 1 to N from top to bottom and columns 1 to M from left to right. You are standing at (1,1).
From, A [ i ] [ j ] you can move to A [ i + 1 ] [ j ] if A [ i + 1 ] [ j ] > A [ i ] [ j ].
Or, from, A [ i ] [ j ] you can move to A [ i ] [ j + 1 ] if A [ i ] [... | def adjList(i, j, N, M):
l = []
if i + 1 < N and A[i + 1][j] > A[i][j]:
l.append((i + 1, j))
if j + 1 < M and A[i][j + 1] > A[i][j]:
l.append((i, j + 1))
return l
def dfs(li, curlen):
global length, A, visit, N, M
if length < curlen:
length = curlen
l = adjList(li[0... | FUNC_DEF ASSIGN VAR LIST IF BIN_OP VAR NUMBER VAR VAR BIN_OP VAR NUMBER VAR VAR VAR VAR EXPR FUNC_CALL VAR BIN_OP VAR NUMBER VAR IF BIN_OP VAR NUMBER VAR VAR VAR BIN_OP VAR NUMBER VAR VAR VAR EXPR FUNC_CALL VAR VAR BIN_OP VAR NUMBER RETURN VAR FUNC_DEF IF VAR VAR ASSIGN VAR VAR ASSIGN VAR FUNC_CALL VAR VAR NUMBER VAR N... |
There is a 2D matrix of N rows and M columns. Rows are number 1 to N from top to bottom and columns 1 to M from left to right. You are standing at (1,1).
From, A [ i ] [ j ] you can move to A [ i + 1 ] [ j ] if A [ i + 1 ] [ j ] > A [ i ] [ j ].
Or, from, A [ i ] [ j ] you can move to A [ i ] [ j + 1 ] if A [ i ] [... | tc = eval(input())
while tc > 0:
n, m = list(map(int, input().split()))
ar = [0] * n
for i in range(n):
ar[i] = list(map(int, input().split()))
c = [(0) for i in range(m)]
ml = 0
for i in range(0, n):
for j in range(0, m):
idx = j
if j > 0 and c[j - 1] != ... | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR WHILE VAR NUMBER ASSIGN VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR BIN_OP LIST NUMBER VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER FOR ... |
There is a 2D matrix of N rows and M columns. Rows are number 1 to N from top to bottom and columns 1 to M from left to right. You are standing at (1,1).
From, A [ i ] [ j ] you can move to A [ i + 1 ] [ j ] if A [ i + 1 ] [ j ] > A [ i ] [ j ].
Or, from, A [ i ] [ j ] you can move to A [ i ] [ j + 1 ] if A [ i ] [... | def process(mat, n, m):
sol = [[(1) for j in range(m)] for i in range(n)]
for i in reversed(list(range(n - 1))):
if mat[i + 1][m - 1] > mat[i][m - 1]:
sol[i][m - 1] = sol[i + 1][m - 1] + 1
for j in reversed(list(range(m - 1))):
if mat[n - 1][j + 1] > mat[n - 1][j]:
so... | FUNC_DEF ASSIGN VAR NUMBER VAR FUNC_CALL VAR VAR VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR BIN_OP VAR NUMBER IF VAR BIN_OP VAR NUMBER BIN_OP VAR NUMBER VAR VAR BIN_OP VAR NUMBER ASSIGN VAR VAR BIN_OP VAR NUMBER BIN_OP VAR BIN_OP VAR NUMBER BIN_OP VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR FUN... |
There is a 2D matrix of N rows and M columns. Rows are number 1 to N from top to bottom and columns 1 to M from left to right. You are standing at (1,1).
From, A [ i ] [ j ] you can move to A [ i + 1 ] [ j ] if A [ i + 1 ] [ j ] > A [ i ] [ j ].
Or, from, A [ i ] [ j ] you can move to A [ i ] [ j + 1 ] if A [ i ] [... | test_cases = eval(input())
for i in range(test_cases):
n, m = list(map(int, input().split()))
a = []
for i in range(n):
a.append(list(map(int, input().split())))
lis = [[(1) for i in range(m)] for j in range(n)]
lis[n - 1][m - 1] = 1
for i in range(n - 1):
if a[n - i - 1][m - 1] ... | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER VAR FUNC_CALL VAR VAR VAR FUNC_CALL VAR VAR ASSIG... |
There is a 2D matrix of N rows and M columns. Rows are number 1 to N from top to bottom and columns 1 to M from left to right. You are standing at (1,1).
From, A [ i ] [ j ] you can move to A [ i + 1 ] [ j ] if A [ i + 1 ] [ j ] > A [ i ] [ j ].
Or, from, A [ i ] [ j ] you can move to A [ i ] [ j + 1 ] if A [ i ] [... | for _ in range(int(input())):
N, M = list(map(int, input().strip().split()))
arr = [[(0) for i in range(M + 1)] for j in range(N + 1)]
dp = [[(0) for i in range(M)] for j in range(N)]
for i in range(N):
arr[i][:M] = list(map(int, input().strip().split()))
for i in range(N - 1, -1, -1):
... | FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR NUMBER VAR FUNC_CALL VAR VAR VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR ... |
Reziba has many magic gems. Each magic gem can be split into $M$ normal gems. The amount of space each magic (and normal) gem takes is $1$ unit. A normal gem cannot be split.
Reziba wants to choose a set of magic gems and split some of them, so the total space occupied by the resulting set of gems is $N$ units. If a m... | import sys
input = lambda: sys.stdin.readline().rstrip("\r\n")
def mat_mul_mod(A, B, mod):
n, p = len(A), len(B[0])
fmod = float(mod)
float_prec = float(1 << 51)
B = [[((Bij & (1 << 16) - 1) - 1.0j * (Bij >> 16)) for Bij in Bi] for Bi in B]
C = [([0] * p) for _ in range(n)]
for i, Ai in enume... | IMPORT ASSIGN VAR FUNC_CALL FUNC_CALL VAR STRING FUNC_DEF ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR BIN_OP NUMBER NUMBER ASSIGN VAR BIN_OP BIN_OP VAR BIN_OP BIN_OP NUMBER NUMBER NUMBER BIN_OP NUMBER BIN_OP VAR NUMBER VAR VAR VAR VAR ASSIGN VAR BIN_OP... |
Reziba has many magic gems. Each magic gem can be split into $M$ normal gems. The amount of space each magic (and normal) gem takes is $1$ unit. A normal gem cannot be split.
Reziba wants to choose a set of magic gems and split some of them, so the total space occupied by the resulting set of gems is $N$ units. If a m... | import sys
MOD = 10**9 + 7
double_prec = float(2**51)
MODF = float(MOD)
def mult(A, B):
n = len(A)
m = len(B[0])
C = [([0] * n) for _ in range(m)]
A = [[((Aij & 2**16 - 1) - 1.0j * (Aij >> 16)) for Aij in A_j] for A_j in A]
for j, B_j in enumerate(B):
buffer = [0.0] * n
for k, A_k... | IMPORT ASSIGN VAR BIN_OP BIN_OP NUMBER NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR BIN_OP NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR NUMBER ASSIGN VAR BIN_OP LIST NUMBER VAR VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP BIN_OP VAR BIN_OP BIN_OP NUMBER NUMBER NUMBE... |
Reziba has many magic gems. Each magic gem can be split into $M$ normal gems. The amount of space each magic (and normal) gem takes is $1$ unit. A normal gem cannot be split.
Reziba wants to choose a set of magic gems and split some of them, so the total space occupied by the resulting set of gems is $N$ units. If a m... | import sys
MOD = 10**9 + 7
def mult(A, B):
n = len(A)
C = []
for x in range(n):
c = [0] * n
for z in range(n):
b = B[x][z]
a = A[z]
for y in range(n):
c[y] += a[y] * b
C.append(c)
for x in range(n):
c = C[x]
f... | IMPORT ASSIGN VAR BIN_OP BIN_OP NUMBER NUMBER NUMBER FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP LIST NUMBER VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR VAR ASSIGN VAR VAR VAR FOR VAR FUNC_CALL VAR VAR VAR VAR BIN_OP VAR VAR VAR EXPR FUNC_CALL VAR VAR FOR VAR F... |
Reziba has many magic gems. Each magic gem can be split into $M$ normal gems. The amount of space each magic (and normal) gem takes is $1$ unit. A normal gem cannot be split.
Reziba wants to choose a set of magic gems and split some of them, so the total space occupied by the resulting set of gems is $N$ units. If a m... | import sys
MOD = 10**9 + 7
MODF = 1.0 * MOD
MODF_inv = 1.0 / MODF
SHRT = 1.0 * (1 << 16)
SHRT_inv = 1.0 / SHRT
MAGIC = float(2**52 + 2**51)
fround = lambda x: x + MAGIC - MAGIC
modder = lambda a: a - MODF * fround(a * MODF_inv)
mod_prod = lambda a, b, c=0.0: modder(
(b - SHRT * fround(SHRT_inv * b)) * a + c + modd... | IMPORT ASSIGN VAR BIN_OP BIN_OP NUMBER NUMBER NUMBER ASSIGN VAR BIN_OP NUMBER VAR ASSIGN VAR BIN_OP NUMBER VAR ASSIGN VAR BIN_OP NUMBER BIN_OP NUMBER NUMBER ASSIGN VAR BIN_OP NUMBER VAR ASSIGN VAR FUNC_CALL VAR BIN_OP BIN_OP NUMBER NUMBER BIN_OP NUMBER NUMBER ASSIGN VAR BIN_OP BIN_OP VAR VAR VAR ASSIGN VAR BIN_OP VAR B... |
Reziba has many magic gems. Each magic gem can be split into $M$ normal gems. The amount of space each magic (and normal) gem takes is $1$ unit. A normal gem cannot be split.
Reziba wants to choose a set of magic gems and split some of them, so the total space occupied by the resulting set of gems is $N$ units. If a m... | import sys
MOD = 10**9 + 7
def mult(A, B):
n = len(A)
cut = 2**16
cutmask = cut - 1
C = [([0.0] * n) for _ in range(n)]
tmp1 = [[float(aa & cutmask) for aa in a] for a in A]
tmp2 = [[float(aa >> 16) for aa in a] for a in A]
for x in range(n):
c = C[x]
for z in range(n):
... | IMPORT ASSIGN VAR BIN_OP BIN_OP NUMBER NUMBER NUMBER FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP NUMBER NUMBER ASSIGN VAR BIN_OP VAR NUMBER ASSIGN VAR BIN_OP LIST NUMBER VAR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR BIN_OP VAR VAR VAR VAR VAR VAR ASSIGN VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR VAR VAR V... |
Reziba has many magic gems. Each magic gem can be split into $M$ normal gems. The amount of space each magic (and normal) gem takes is $1$ unit. A normal gem cannot be split.
Reziba wants to choose a set of magic gems and split some of them, so the total space occupied by the resulting set of gems is $N$ units. If a m... | from sys import stdin
def _solve(n, m, memo):
if n <= 0:
return 0
if n < m:
return 1
if n == 1:
return 2
if (n, m) in memo:
return memo[n, m]
out = 0
mid = n // 2
out = (out + _solve(mid, m, memo) * _solve(n - mid, m, memo)) % 1000000007
for i in range(1... | FUNC_DEF IF VAR NUMBER RETURN NUMBER IF VAR VAR RETURN NUMBER IF VAR NUMBER RETURN NUMBER IF VAR VAR VAR RETURN VAR VAR VAR ASSIGN VAR NUMBER ASSIGN VAR BIN_OP VAR NUMBER ASSIGN VAR BIN_OP BIN_OP VAR BIN_OP FUNC_CALL VAR VAR VAR VAR FUNC_CALL VAR BIN_OP VAR VAR VAR VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER VAR IF BIN_OP ... |
Reziba has many magic gems. Each magic gem can be split into $M$ normal gems. The amount of space each magic (and normal) gem takes is $1$ unit. A normal gem cannot be split.
Reziba wants to choose a set of magic gems and split some of them, so the total space occupied by the resulting set of gems is $N$ units. If a m... | import sys
MOD = 10**9 + 7
def polymod(P, Q):
assert Q[-1] == 1
n = len(Q)
while len(P) >= n:
p = P[-1]
for i in range(n):
P[-i - 1] -= p * Q[-i - 1]
assert P[-1] == 0
P.pop()
return P
def polyprod(P, Q):
n = len(P)
m = len(Q)
W = [0] * (n + m... | IMPORT ASSIGN VAR BIN_OP BIN_OP NUMBER NUMBER NUMBER FUNC_DEF VAR NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR VAR WHILE FUNC_CALL VAR VAR VAR ASSIGN VAR VAR NUMBER FOR VAR FUNC_CALL VAR VAR VAR BIN_OP VAR NUMBER BIN_OP VAR VAR BIN_OP VAR NUMBER VAR NUMBER NUMBER EXPR FUNC_CALL VAR RETURN VAR FUNC_DEF ASSIGN VAR FUNC_CALL VA... |
Given an array arr of size N, the task is to make strictly increasing and strictly decreasing subsequences from the array such that each array element belongs to increasing subsequence or decreasing subsequence, but not both, or can be part of none of the subsequence. Minimize the number of elements that are not part o... | class Solution:
def minCount(self, arr, n):
dp = [
[[float("inf") for k in range(n + 1)] for j in range(n + 1)]
for i in range(n + 1)
]
val = self.mindp(arr, n, 1, float("-inf"), float("inf"), dp, 0, 0)
return val
def mindp(self, arr, n, st, incm, decmin... | CLASS_DEF FUNC_DEF ASSIGN VAR FUNC_CALL VAR STRING VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR NUMBER FUNC_CALL VAR STRING FUNC_CALL VAR STRING VAR NUMBER NUMBER RETURN VAR FUNC_DEF IF VAR BIN_OP VAR NUMBER RETURN NUMBER IF... |
Given an array arr of size N, the task is to make strictly increasing and strictly decreasing subsequences from the array such that each array element belongs to increasing subsequence or decreasing subsequence, but not both, or can be part of none of the subsequence. Minimize the number of elements that are not part o... | class Solution:
def minCount(self, nums, n):
dp = [
[[(0) for _ in range(n + 2)] for __ in range(n + 2)] for ___ in range(n + 1)
]
for i in range(n + 1):
for j in range(1, n + 2):
for k in range(1, n + 2):
if i > 0:
... | CLASS_DEF FUNC_DEF ASSIGN VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER IF VAR NUMBER ASSIGN VAR VAR VAR VAR VAR ... |
Given an array arr of size N, the task is to make strictly increasing and strictly decreasing subsequences from the array such that each array element belongs to increasing subsequence or decreasing subsequence, but not both, or can be part of none of the subsequence. Minimize the number of elements that are not part o... | class Solution:
def minCount(self, l, n):
l.insert(0, float("inf"))
l.insert(0, -float("inf"))
dp = [
[[(-1) for _ in range(n + 1)] for _ in range(n + 1)] for _ in range(n + 1)
]
def ss(i, j, k):
if k - 2 >= n:
return 0
if... | CLASS_DEF FUNC_DEF EXPR FUNC_CALL VAR NUMBER FUNC_CALL VAR STRING EXPR FUNC_CALL VAR NUMBER FUNC_CALL VAR STRING ASSIGN VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER FUNC_DEF IF BIN_OP VAR NUMBER VAR RETURN NUMBER IF VAR VAR BIN_OP VAR NUMBER BIN_... |
Given an array arr of size N, the task is to make strictly increasing and strictly decreasing subsequences from the array such that each array element belongs to increasing subsequence or decreasing subsequence, but not both, or can be part of none of the subsequence. Minimize the number of elements that are not part o... | MAX = 102
def countMin(arr, dp, n, dec, inc, i):
if dp[dec][inc][i] != -1:
return dp[dec][inc][i]
if i == n:
return 0
if arr[i] < arr[dec]:
dp[dec][inc][i] = countMin(arr, dp, n, i, inc, i + 1)
if arr[i] > arr[inc]:
if dp[dec][inc][i] == -1:
dp[dec][inc][i] ... | ASSIGN VAR NUMBER FUNC_DEF IF VAR VAR VAR VAR NUMBER RETURN VAR VAR VAR VAR IF VAR VAR RETURN NUMBER IF VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR FUNC_CALL VAR VAR VAR VAR VAR VAR BIN_OP VAR NUMBER IF VAR VAR VAR VAR IF VAR VAR VAR VAR NUMBER ASSIGN VAR VAR VAR VAR FUNC_CALL VAR VAR VAR VAR VAR VAR BIN_OP VAR NUMBER ASSIG... |
Given an array arr of size N, the task is to make strictly increasing and strictly decreasing subsequences from the array such that each array element belongs to increasing subsequence or decreasing subsequence, but not both, or can be part of none of the subsequence. Minimize the number of elements that are not part o... | class Solution:
def minCount(self, arr, n):
inf = float("inf")
dic = {}
def dfs(mn, mx, i):
if (mn, mx, i + 1) in dic:
return dic[mn, mx, i + 1]
if i >= n:
return 0
ans = inf
if arr[i] < mx:
ans... | CLASS_DEF FUNC_DEF ASSIGN VAR FUNC_CALL VAR STRING ASSIGN VAR DICT FUNC_DEF IF VAR VAR BIN_OP VAR NUMBER VAR RETURN VAR VAR VAR BIN_OP VAR NUMBER IF VAR VAR RETURN NUMBER ASSIGN VAR VAR IF VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR VAR VAR BIN_OP VAR NUMBER IF VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR FU... |
Kaavi, the mysterious fortune teller, deeply believes that one's fate is inevitable and unavoidable. Of course, she makes her living by predicting others' future. While doing divination, Kaavi believes that magic spells can provide great power for her to see the future.
<image>
Kaavi has a string T of length m and a... | import sys
mod = 998244353
eps = 10**-9
def main():
import sys
input = sys.stdin.readline
S = input().rstrip("\n")
S = S[::-1]
T = input().rstrip("\n")
NS = len(S)
NT = len(T)
dp = [([0] * (NT + 1)) for _ in range(NS + 1)]
dp[0][0] = 1
for i in range(NS):
s = S[i]
... | IMPORT ASSIGN VAR NUMBER ASSIGN VAR BIN_OP NUMBER NUMBER FUNC_DEF IMPORT ASSIGN VAR VAR ASSIGN VAR FUNC_CALL FUNC_CALL VAR STRING ASSIGN VAR VAR NUMBER ASSIGN VAR FUNC_CALL FUNC_CALL VAR STRING ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP LIST NUMBER BIN_OP VAR NUMBER VAR FUNC_CALL VAR BI... |
Kaavi, the mysterious fortune teller, deeply believes that one's fate is inevitable and unavoidable. Of course, she makes her living by predicting others' future. While doing divination, Kaavi believes that magic spells can provide great power for her to see the future.
<image>
Kaavi has a string T of length m and a... | s = input()
t = input()
n, m = len(s), len(t)
dp = [[(0) for _ in range(n + 1)] for _ in range(n + 1)]
for i in range(n + 1):
for j in range(n + 1):
if i == j:
dp[i][j] = 1
for i in range(n - 1, -1, -1):
for j in range(i + 1, n + 1):
if i >= m or t[i] == s[j - i - 1]:
dp[... | ASSIGN VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER IF VAR VAR ASSIGN VAR VAR VAR NUMBER FOR VAR FUNC... |
Kaavi, the mysterious fortune teller, deeply believes that one's fate is inevitable and unavoidable. Of course, she makes her living by predicting others' future. While doing divination, Kaavi believes that magic spells can provide great power for her to see the future.
<image>
Kaavi has a string T of length m and a... | from sys import stdin, stdout
def kaavi_and_magic_spell(S, T):
MOD = 998244353
n = len(S)
m = len(T)
dp = [[(0) for _ in range(n)] for _ in range(n)]
for i in range(n):
if comp(S, T, 0, i):
dp[i][i] = 1
for l in range(2, n + 1):
for i in range(n - l + 1):
... | FUNC_DEF ASSIGN VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER VAR FUNC_CALL VAR VAR VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR VAR IF FUNC_CALL VAR VAR VAR NUMBER VAR ASSIGN VAR VAR VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP BIN_OP VA... |
Kaavi, the mysterious fortune teller, deeply believes that one's fate is inevitable and unavoidable. Of course, she makes her living by predicting others' future. While doing divination, Kaavi believes that magic spells can provide great power for her to see the future.
<image>
Kaavi has a string T of length m and a... | import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**5)
s = input()[:-1]
t = input()[:-1]
MOD = 998244353
r_lim = len(t)
n = len(s)
dp = [([0] * (n + 1)) for i in range(n + 1)]
for length in range(1, n + 1):
for l in range(n + 1):
r = l + length
if r > n:
break
if len... | IMPORT ASSIGN VAR VAR EXPR FUNC_CALL VAR BIN_OP NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR NUMBER ASSIGN VAR FUNC_CALL VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP LIST NUMBER BIN_OP VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_O... |
Once upon a time Petya and Gena gathered after another programming competition and decided to play some game. As they consider most modern games to be boring, they always try to invent their own games. They have only stickers and markers, but that won't stop them.
The game they came up with has the following rules. In... | n = int(input())
a = [0] + list(map(int, input().split()))
dp = [0] * (n + 1)
s = [0] * (n + 1)
for i in range(1, n + 1):
s[i] = s[i - 1] + a[i]
dp[n] = 0
cur = s[n]
for i in range(n - 1, 0, -1):
dp[i] = cur
cur = max(cur, s[i] - dp[i])
print(dp[1]) | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR BIN_OP LIST NUMBER FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR BIN_OP LIST NUMBER BIN_OP VAR NUMBER ASSIGN VAR BIN_OP LIST NUMBER BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER ASSIGN VAR VAR BIN_OP VAR BIN_OP VAR NUMBER VAR VAR ... |
Once upon a time Petya and Gena gathered after another programming competition and decided to play some game. As they consider most modern games to be boring, they always try to invent their own games. They have only stickers and markers, but that won't stop them.
The game they came up with has the following rules. In... | n = int(input())
a = list(map(int, input().split()))
p = s = sum(a)
for i in range(n - 2, 0, -1):
s -= a[i + 1]
p = max(p, s - p)
print(p) | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER NUMBER VAR VAR BIN_OP VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR BIN_OP VAR VAR EXPR FUNC_CALL VAR VAR |
Once upon a time Petya and Gena gathered after another programming competition and decided to play some game. As they consider most modern games to be boring, they always try to invent their own games. They have only stickers and markers, but that won't stop them.
The game they came up with has the following rules. In... | def f(a):
n = len(a)
dp = [0] * n
s = [0] * (n + 1)
for i in range(0, n):
s[i + 1] = s[i] + a[i]
maxdiffyet = s[n]
for i in range(n - 2, -1, -1):
dp[i] = maxdiffyet
maxdiffyet = max(maxdiffyet, s[i + 1] - dp[i])
return dp[0]
n = int(input())
a = [int(x) for x in inp... | FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP LIST NUMBER VAR ASSIGN VAR BIN_OP LIST NUMBER BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER VAR ASSIGN VAR BIN_OP VAR NUMBER BIN_OP VAR VAR VAR VAR ASSIGN VAR VAR VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER NUMBER ASSIGN VAR VAR VAR ASSIGN VAR FUNC_CALL VA... |
Once upon a time Petya and Gena gathered after another programming competition and decided to play some game. As they consider most modern games to be boring, they always try to invent their own games. They have only stickers and markers, but that won't stop them.
The game they came up with has the following rules. In... | n = int(input())
a = [0] * n
a = list(map(int, input().split()))
for i in range(1, len(a)):
a[i] += a[i - 1]
ans = a[-1]
for i in range(n - 2, 0, -1):
ans = max(ans, a[i] - ans)
print(ans) | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR BIN_OP LIST NUMBER VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR FOR VAR FUNC_CALL VAR NUMBER FUNC_CALL VAR VAR VAR VAR VAR BIN_OP VAR NUMBER ASSIGN VAR VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR VA... |
Once upon a time Petya and Gena gathered after another programming competition and decided to play some game. As they consider most modern games to be boring, they always try to invent their own games. They have only stickers and markers, but that won't stop them.
The game they came up with has the following rules. In... | n = int(input())
raw = input().split()
d = []
prev = 0
for i in range(n):
di = int(raw[i])
di += prev
d.append(di)
prev = di
i = n - 2
cur = d[n - 1]
while i > 0:
cur = max(cur, d[i] - cur)
i -= 1
print(cur) | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR LIST ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR VAR EXPR FUNC_CALL VAR VAR ASSIGN VAR VAR ASSIGN VAR BIN_OP VAR NUMBER ASSIGN VAR VAR BIN_OP VAR NUMBER WHILE VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR... |
Jon Snow is on the lookout for some orbs required to defeat the white walkers. There are k different types of orbs and he needs at least one of each. One orb spawns daily at the base of a Weirwood tree north of the wall. The probability of this orb being of any kind is equal. As the north of wall is full of dangers, he... | import sys
def main():
eps = 10**-7
k, q = readIntArr()
def rowFactory():
row = [(0) for _ in range(k + 1)]
return row
dp = [rowFactory()]
dp[0][0] = 1
while dp[-1][-1] <= 0.5:
newRow = rowFactory()
for j in range(1, k + 1):
newRow[j] += dp[-1][j] ... | IMPORT FUNC_DEF ASSIGN VAR BIN_OP NUMBER NUMBER ASSIGN VAR VAR FUNC_CALL VAR FUNC_DEF ASSIGN VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER RETURN VAR ASSIGN VAR LIST FUNC_CALL VAR ASSIGN VAR NUMBER NUMBER NUMBER WHILE VAR NUMBER NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER VAR ... |
Jon Snow is on the lookout for some orbs required to defeat the white walkers. There are k different types of orbs and he needs at least one of each. One orb spawns daily at the base of a Weirwood tree north of the wall. The probability of this orb being of any kind is equal. As the north of wall is full of dangers, he... | k, q = list(map(int, input().split()))
t = [0] * (k + 1)
t[1] = 1
d = [0]
n = i = 1
while i < 1001:
if 2000 * t[k] > i - 1e-07:
d.append(n)
i += 1
else:
t = [0] + [((j * t[j] + (k - j + 1) * t[j - 1]) / k) for j in range(1, k + 1)]
n += 1
for i in range(q):
print(d[int(input(... | ASSIGN VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR BIN_OP LIST NUMBER BIN_OP VAR NUMBER ASSIGN VAR NUMBER NUMBER ASSIGN VAR LIST NUMBER ASSIGN VAR VAR NUMBER WHILE VAR NUMBER IF BIN_OP NUMBER VAR VAR BIN_OP VAR NUMBER EXPR FUNC_CALL VAR VAR VAR NUMBER ASSIGN VAR BIN_OP LIST NUMBER BIN_OP ... |
Jon Snow is on the lookout for some orbs required to defeat the white walkers. There are k different types of orbs and he needs at least one of each. One orb spawns daily at the base of a Weirwood tree north of the wall. The probability of this orb being of any kind is equal. As the north of wall is full of dangers, he... | k, q = map(int, input().split())
dp = [[(0.0) for i in range(k + 1)] for j in range(10000)]
dp[0][0] = 1.0
for i in range(1, 10000):
for j in range(1, k + 1):
dp[i][j] = dp[i - 1][j] * j / k + dp[i - 1][j - 1] * (k - j + 1) / k
for t in range(q):
p = int(input())
for i in range(10000):
if p ... | ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR FUNC_CALL VAR NUMBER ASSIGN VAR NUMBER NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER ASSIGN VAR VAR VAR BIN_OP BIN_OP BIN_OP VAR BIN_OP VAR NUMBER VAR VAR... |
A top secret message containing letters from A-Z is being encoded to numbers using the following mapping:
'A' -> 1
'B' -> 2
...
'Z' -> 26
You are an FBI agent. You have to determine the total number of ways that message can be decoded, as the answer can be large return the answer modulo 10^{9} + 7.
Note: An empty digit... | class Solution:
def CountWays(self, s):
if len(s) == 1 and s == "0":
return 0
elif len(s) == 1 and s != "0":
return 1
temp = {}
for i in range(1, 27):
temp["{}".format(i)] = True
memo = {}
def check(first, second):
if ... | CLASS_DEF FUNC_DEF IF FUNC_CALL VAR VAR NUMBER VAR STRING RETURN NUMBER IF FUNC_CALL VAR VAR NUMBER VAR STRING RETURN NUMBER ASSIGN VAR DICT FOR VAR FUNC_CALL VAR NUMBER NUMBER ASSIGN VAR FUNC_CALL STRING VAR NUMBER ASSIGN VAR DICT FUNC_DEF IF VAR STRING IF BIN_OP BIN_OP VAR STRING VAR VAR RETURN VAR BIN_OP BIN_OP VAR ... |
A top secret message containing letters from A-Z is being encoded to numbers using the following mapping:
'A' -> 1
'B' -> 2
...
'Z' -> 26
You are an FBI agent. You have to determine the total number of ways that message can be decoded, as the answer can be large return the answer modulo 10^{9} + 7.
Note: An empty digit... | class Solution:
def CountWays(self, str):
mod = 1000000007
if str[0] == "0":
return 0
prev0 = 1
prev1 = 1
for i in range(2, len(str) + 1):
curr = 0
if str[i - 1] != "0":
curr += prev1
if str[i - 2] == "1" or str... | CLASS_DEF FUNC_DEF ASSIGN VAR NUMBER IF VAR NUMBER STRING RETURN NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP FUNC_CALL VAR VAR NUMBER ASSIGN VAR NUMBER IF VAR BIN_OP VAR NUMBER STRING VAR VAR IF VAR BIN_OP VAR NUMBER STRING VAR BIN_OP VAR NUMBER STRING VAR BIN_OP VAR NUMBER STRING VAR... |
A top secret message containing letters from A-Z is being encoded to numbers using the following mapping:
'A' -> 1
'B' -> 2
...
'Z' -> 26
You are an FBI agent. You have to determine the total number of ways that message can be decoded, as the answer can be large return the answer modulo 10^{9} + 7.
Note: An empty digit... | class Solution:
def CountWays(self, str):
memo = {x: (-1) for x in range(len(str) + 1)}
mod = 1000000007
if str[0] == "0":
return 0
def dp(i):
if i == 1 or i == 0:
return 1
if memo[i] != -1:
return memo[i]
... | CLASS_DEF FUNC_DEF ASSIGN VAR VAR NUMBER VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER ASSIGN VAR NUMBER IF VAR NUMBER STRING RETURN NUMBER FUNC_DEF IF VAR NUMBER VAR NUMBER RETURN NUMBER IF VAR VAR NUMBER RETURN VAR VAR ASSIGN VAR NUMBER IF VAR BIN_OP VAR NUMBER STRING ASSIGN VAR BIN_OP VAR BIN_OP FUNC_CALL VAR BI... |
A top secret message containing letters from A-Z is being encoded to numbers using the following mapping:
'A' -> 1
'B' -> 2
...
'Z' -> 26
You are an FBI agent. You have to determine the total number of ways that message can be decoded, as the answer can be large return the answer modulo 10^{9} + 7.
Note: An empty digit... | class Solution:
def CountWays(self, str):
mod = 1000000007
dp = []
def rec(i, str, dp):
if i == len(str):
return 1
if dp[i] != -1:
return dp[i]
c1 = 0
c2 = 0
if str[i] >= "1" and str[i] <= "9":
... | CLASS_DEF FUNC_DEF ASSIGN VAR NUMBER ASSIGN VAR LIST FUNC_DEF IF VAR FUNC_CALL VAR VAR RETURN NUMBER IF VAR VAR NUMBER RETURN VAR VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER IF VAR VAR STRING VAR VAR STRING ASSIGN VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR VAR ASSIGN VAR VAR VAR BIN_OP VAR NUMBER IF VAR BIN_OP FUNC_CALL VAR V... |
A top secret message containing letters from A-Z is being encoded to numbers using the following mapping:
'A' -> 1
'B' -> 2
...
'Z' -> 26
You are an FBI agent. You have to determine the total number of ways that message can be decoded, as the answer can be large return the answer modulo 10^{9} + 7.
Note: An empty digit... | class Solution:
def CountWays(self, string):
def dfs(i):
if i >= len(string):
return 1
if string[i] == "0":
return 0
if i in mem:
return mem[i]
c = 0
c += dfs(i + 1)
if string[i] == "1" ... | CLASS_DEF FUNC_DEF FUNC_DEF IF VAR FUNC_CALL VAR VAR RETURN NUMBER IF VAR VAR STRING RETURN NUMBER IF VAR VAR RETURN VAR VAR ASSIGN VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER IF VAR VAR STRING BIN_OP VAR NUMBER FUNC_CALL VAR VAR VAR FUNC_CALL VAR BIN_OP VAR NUMBER IF VAR VAR STRING BIN_OP VAR NUMBER FUNC_CALL VAR V... |
A top secret message containing letters from A-Z is being encoded to numbers using the following mapping:
'A' -> 1
'B' -> 2
...
'Z' -> 26
You are an FBI agent. You have to determine the total number of ways that message can be decoded, as the answer can be large return the answer modulo 10^{9} + 7.
Note: An empty digit... | class Solution:
def CountWays(self, str):
n = len(str)
count = [0] * (n + 1)
count[0] = 1
count[1] = 1
for i in range(2, n + 1):
count[i] = 0
if str[i - 1] > "0":
count[i] = count[i - 1]
if str[i - 2] == "1" or str[i - 2] =... | CLASS_DEF FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP LIST NUMBER BIN_OP VAR NUMBER ASSIGN VAR NUMBER NUMBER ASSIGN VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER ASSIGN VAR VAR NUMBER IF VAR BIN_OP VAR NUMBER STRING ASSIGN VAR VAR VAR BIN_OP VAR NUMBER IF VAR BIN_OP VAR NUMBER STRING VAR ... |
A top secret message containing letters from A-Z is being encoded to numbers using the following mapping:
'A' -> 1
'B' -> 2
...
'Z' -> 26
You are an FBI agent. You have to determine the total number of ways that message can be decoded, as the answer can be large return the answer modulo 10^{9} + 7.
Note: An empty digit... | class Solution:
def CountWays(self, str):
n = len(str)
t = [(0) for i in range(n + 1)]
if str[0] == "0":
return 0
t[0] = 1
t[1] = 1
mod = 10**9 + 7
for i in range(1, n):
if str[i] > "0":
t[i + 1] = t[i]
if s... | CLASS_DEF FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER IF VAR NUMBER STRING RETURN NUMBER ASSIGN VAR NUMBER NUMBER ASSIGN VAR NUMBER NUMBER ASSIGN VAR BIN_OP BIN_OP NUMBER NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER VAR IF VAR VAR STRING ASSIGN VAR BIN_OP VAR NUMBER VAR VAR... |
A top secret message containing letters from A-Z is being encoded to numbers using the following mapping:
'A' -> 1
'B' -> 2
...
'Z' -> 26
You are an FBI agent. You have to determine the total number of ways that message can be decoded, as the answer can be large return the answer modulo 10^{9} + 7.
Note: An empty digit... | class Solution:
def CountWays(self, str):
ans = [(0) for i in range(len(str) + 1)]
ans[0] = 1
ans[1] = 1
for i in range(2, len(str) + 1):
if str[i - 1] > "0":
ans[i] = ans[i - 1]
if (
str[i - 2] == "1"
or str[i ... | CLASS_DEF FUNC_DEF ASSIGN VAR NUMBER VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER ASSIGN VAR NUMBER NUMBER ASSIGN VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP FUNC_CALL VAR VAR NUMBER IF VAR BIN_OP VAR NUMBER STRING ASSIGN VAR VAR VAR BIN_OP VAR NUMBER IF VAR BIN_OP VAR NUMBER STRING VAR BIN_OP VAR NUMBER... |
A top secret message containing letters from A-Z is being encoded to numbers using the following mapping:
'A' -> 1
'B' -> 2
...
'Z' -> 26
You are an FBI agent. You have to determine the total number of ways that message can be decoded, as the answer can be large return the answer modulo 10^{9} + 7.
Note: An empty digit... | class Solution:
def func(self, str, n, dp):
m = 1000000007
if n == 0 or n == 1:
return 1
if dp[n] != -1:
return dp[n]
cnt = 0
if str[n - 1] >= "1":
cnt = cnt + self.func(str, n - 1, dp) % m
if str[n - 2] == "1" or str[n - 2] == "2"... | CLASS_DEF FUNC_DEF ASSIGN VAR NUMBER IF VAR NUMBER VAR NUMBER RETURN NUMBER IF VAR VAR NUMBER RETURN VAR VAR ASSIGN VAR NUMBER IF VAR BIN_OP VAR NUMBER STRING ASSIGN VAR BIN_OP VAR BIN_OP FUNC_CALL VAR VAR BIN_OP VAR NUMBER VAR VAR IF VAR BIN_OP VAR NUMBER STRING VAR BIN_OP VAR NUMBER STRING VAR BIN_OP VAR NUMBER STRIN... |
A top secret message containing letters from A-Z is being encoded to numbers using the following mapping:
'A' -> 1
'B' -> 2
...
'Z' -> 26
You are an FBI agent. You have to determine the total number of ways that message can be decoded, as the answer can be large return the answer modulo 10^{9} + 7.
Note: An empty digit... | class Solution:
def CountWays(self, str):
mp = {}
return self.countWaysHelper(str, 0, mp) % (10**9 + 7)
def countWaysHelper(self, str, i, mp):
if i == len(str):
return 1
if str[i] == "0":
return 0
if i == len(str) - 1:
return 1
... | CLASS_DEF FUNC_DEF ASSIGN VAR DICT RETURN BIN_OP FUNC_CALL VAR VAR NUMBER VAR BIN_OP BIN_OP NUMBER NUMBER NUMBER FUNC_DEF IF VAR FUNC_CALL VAR VAR RETURN NUMBER IF VAR VAR STRING RETURN NUMBER IF VAR BIN_OP FUNC_CALL VAR VAR NUMBER RETURN NUMBER IF VAR VAR RETURN VAR VAR IF VAR VAR STRING VAR VAR STRING VAR BIN_OP VAR ... |
A top secret message containing letters from A-Z is being encoded to numbers using the following mapping:
'A' -> 1
'B' -> 2
...
'Z' -> 26
You are an FBI agent. You have to determine the total number of ways that message can be decoded, as the answer can be large return the answer modulo 10^{9} + 7.
Note: An empty digit... | class Solution:
def CountWays(self, str):
mod = 10**9 + 7
n = len(str)
prev1 = 1
prev2 = 1
for i in range(2, n + 1):
curr = 0
if str[i - 1] != "0":
curr = prev1
if str[i - 2] == "1" or str[i - 2] == "2" and str[i - 1] <= "6... | CLASS_DEF FUNC_DEF ASSIGN VAR BIN_OP BIN_OP NUMBER NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER ASSIGN VAR NUMBER IF VAR BIN_OP VAR NUMBER STRING ASSIGN VAR VAR IF VAR BIN_OP VAR NUMBER STRING VAR BIN_OP VAR NUMBER STRING VAR BIN_OP VAR NU... |
A top secret message containing letters from A-Z is being encoded to numbers using the following mapping:
'A' -> 1
'B' -> 2
...
'Z' -> 26
You are an FBI agent. You have to determine the total number of ways that message can be decoded, as the answer can be large return the answer modulo 10^{9} + 7.
Note: An empty digit... | class Solution:
def CountWays(self, str):
if str[0] == "0":
return 0
n = len(str)
mod = 1000000007
dp = [(0) for i in range(n + 1)]
dp[0] = dp[1] = 1
for i in range(1, n):
if str[i] == "0" and str[i - 1] > "2":
return 0
... | CLASS_DEF FUNC_DEF IF VAR NUMBER STRING RETURN NUMBER ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER VAR IF VAR VAR STRING VAR BIN_OP VAR NUMBER STRING RETURN NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP... |
A top secret message containing letters from A-Z is being encoded to numbers using the following mapping:
'A' -> 1
'B' -> 2
...
'Z' -> 26
You are an FBI agent. You have to determine the total number of ways that message can be decoded, as the answer can be large return the answer modulo 10^{9} + 7.
Note: An empty digit... | class Solution:
def CountWays(self, str):
def fun(i):
if i == n:
return 1
if i > n:
return 0
if dp[i] != -1:
return dp[i]
ans = 0
if str[i] != "0":
ans += fun(i + 1)
if s... | CLASS_DEF FUNC_DEF FUNC_DEF IF VAR VAR RETURN NUMBER IF VAR VAR RETURN NUMBER IF VAR VAR NUMBER RETURN VAR VAR ASSIGN VAR NUMBER IF VAR VAR STRING VAR FUNC_CALL VAR BIN_OP VAR NUMBER IF VAR VAR STRING FUNC_CALL VAR VAR VAR BIN_OP VAR NUMBER NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR BIN_OP VAR NUMBER ASSIGN ... |
A top secret message containing letters from A-Z is being encoded to numbers using the following mapping:
'A' -> 1
'B' -> 2
...
'Z' -> 26
You are an FBI agent. You have to determine the total number of ways that message can be decoded, as the answer can be large return the answer modulo 10^{9} + 7.
Note: An empty digit... | class Solution:
def CountWays(self, str):
t = [(-1) for i in range(len(str) + 1)]
mod = 10**9 + 7
def helper(idx, str, t):
if idx == len(str):
return 1
if str[idx] == "0":
return 0
if t[idx] != -1:
return t... | CLASS_DEF FUNC_DEF ASSIGN VAR NUMBER VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER ASSIGN VAR BIN_OP BIN_OP NUMBER NUMBER NUMBER FUNC_DEF IF VAR FUNC_CALL VAR VAR RETURN NUMBER IF VAR VAR STRING RETURN NUMBER IF VAR VAR NUMBER RETURN VAR VAR ASSIGN VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR VAR IF VAR BIN_OP FUNC_CALL... |
A top secret message containing letters from A-Z is being encoded to numbers using the following mapping:
'A' -> 1
'B' -> 2
...
'Z' -> 26
You are an FBI agent. You have to determine the total number of ways that message can be decoded, as the answer can be large return the answer modulo 10^{9} + 7.
Note: An empty digit... | class Solution:
def isValid(self, s, n):
if s[0] == "0":
return True
for i in range(n - 1):
if s[i] == s[i + 1] == "0":
return True
return False
def CountWays(self, s):
mod = 1000000000.0 + 7
n = len(s)
flag = self.isValid... | CLASS_DEF FUNC_DEF IF VAR NUMBER STRING RETURN NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER IF VAR VAR VAR BIN_OP VAR NUMBER STRING RETURN NUMBER RETURN NUMBER FUNC_DEF ASSIGN VAR BIN_OP NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR IF VAR RETURN NUMBER ASSIGN VAR BIN_OP LIST NUMBER BIN_... |
A top secret message containing letters from A-Z is being encoded to numbers using the following mapping:
'A' -> 1
'B' -> 2
...
'Z' -> 26
You are an FBI agent. You have to determine the total number of ways that message can be decoded, as the answer can be large return the answer modulo 10^{9} + 7.
Note: An empty digit... | class Solution:
def CountWays(self, str):
m = 1000000007
if str[-1] == "0":
first = 0
second = 1
else:
first = 1
second = 1
for i in range(len(str) - 1)[::-1]:
if str[i] == "0":
if first == 0:
... | CLASS_DEF FUNC_DEF ASSIGN VAR NUMBER IF VAR NUMBER STRING ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER NUMBER IF VAR VAR STRING IF VAR NUMBER RETURN NUMBER ASSIGN VAR VAR ASSIGN VAR NUMBER IF VAR VAR STRING VAR VAR STRING FUNC_CALL VAR VAR... |
A top secret message containing letters from A-Z is being encoded to numbers using the following mapping:
'A' -> 1
'B' -> 2
...
'Z' -> 26
You are an FBI agent. You have to determine the total number of ways that message can be decoded, as the answer can be large return the answer modulo 10^{9} + 7.
Note: An empty digit... | class Solution:
def CountWays(self, str):
if len(str) == 1:
return 1
dp = [0] * len(str)
if str[0] == "0":
return 0
dp[0] = 1
if str[1] != "0":
dp[1] = 1
if str[0:2] <= "26":
dp[1] += 1
mod = 10**9 + 7
f... | CLASS_DEF FUNC_DEF IF FUNC_CALL VAR VAR NUMBER RETURN NUMBER ASSIGN VAR BIN_OP LIST NUMBER FUNC_CALL VAR VAR IF VAR NUMBER STRING RETURN NUMBER ASSIGN VAR NUMBER NUMBER IF VAR NUMBER STRING ASSIGN VAR NUMBER NUMBER IF VAR NUMBER NUMBER STRING VAR NUMBER NUMBER ASSIGN VAR BIN_OP BIN_OP NUMBER NUMBER NUMBER FOR VAR FUNC_... |
A top secret message containing letters from A-Z is being encoded to numbers using the following mapping:
'A' -> 1
'B' -> 2
...
'Z' -> 26
You are an FBI agent. You have to determine the total number of ways that message can be decoded, as the answer can be large return the answer modulo 10^{9} + 7.
Note: An empty digit... | class Solution:
def CountWays(self, str):
s = str
hm = {}
for i in range(1, 27):
hm["{}".format(i)] = 1
dp = [(0) for i in range(len(s) + 1)]
dp[0] = 1
for i in range(len(s)):
if s[i] in hm:
dp[i + 1] = dp[i]
if i >... | CLASS_DEF FUNC_DEF ASSIGN VAR VAR ASSIGN VAR DICT FOR VAR FUNC_CALL VAR NUMBER NUMBER ASSIGN VAR FUNC_CALL STRING VAR NUMBER ASSIGN VAR NUMBER VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER ASSIGN VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR IF VAR VAR VAR ASSIGN VAR BIN_OP VAR NUMBER VAR VAR IF VAR NUM... |
A top secret message containing letters from A-Z is being encoded to numbers using the following mapping:
'A' -> 1
'B' -> 2
...
'Z' -> 26
You are an FBI agent. You have to determine the total number of ways that message can be decoded, as the answer can be large return the answer modulo 10^{9} + 7.
Note: An empty digit... | class Solution:
def CountWays(self, s):
if not s:
return 1
n = len(s)
self.s = s
self.cache = [None] * (n + 1)
self.cache[n - 1 :] = int(s[-1] != "0"), 1
return self.DP(0)
def DP(self, j):
if self.cache[j]:
return self.cache[j]
... | CLASS_DEF FUNC_DEF IF VAR RETURN NUMBER ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR VAR ASSIGN VAR BIN_OP LIST NONE BIN_OP VAR NUMBER ASSIGN VAR BIN_OP VAR NUMBER FUNC_CALL VAR VAR NUMBER STRING NUMBER RETURN FUNC_CALL VAR NUMBER FUNC_DEF IF VAR VAR RETURN VAR VAR IF VAR VAR STRING RETURN NUMBER ASSIGN VAR FUNC_CALL VAR BI... |
A top secret message containing letters from A-Z is being encoded to numbers using the following mapping:
'A' -> 1
'B' -> 2
...
'Z' -> 26
You are an FBI agent. You have to determine the total number of ways that message can be decoded, as the answer can be large return the answer modulo 10^{9} + 7.
Note: An empty digit... | class Solution:
def CountWays(self, s):
n = len(s)
if n == 0:
return 1
if n == 1:
return 0 if s[0] == "0" else 1
dp = [(0) for i in range(n)]
dp[0] = 1
dp[1] = 1
if int(s[0] + s[1]) <= 26:
dp[1] += 1
mod = 10**9 + 7... | CLASS_DEF FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR IF VAR NUMBER RETURN NUMBER IF VAR NUMBER RETURN VAR NUMBER STRING NUMBER NUMBER ASSIGN VAR NUMBER VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER NUMBER ASSIGN VAR NUMBER NUMBER IF FUNC_CALL VAR BIN_OP VAR NUMBER VAR NUMBER NUMBER VAR NUMBER NUMBER ASSIGN VAR BIN_OP BIN_OP NUMBE... |
A top secret message containing letters from A-Z is being encoded to numbers using the following mapping:
'A' -> 1
'B' -> 2
...
'Z' -> 26
You are an FBI agent. You have to determine the total number of ways that message can be decoded, as the answer can be large return the answer modulo 10^{9} + 7.
Note: An empty digit... | class Solution:
def CountWays(self, str):
if len(str) == 0:
return 1
memory = {}
return self.helper(0, str, memory) % (10**9 + 7)
def helper(self, i, str, memory):
if str[i:] in memory:
return memory[str[i:]]
if i >= len(str):
return ... | CLASS_DEF FUNC_DEF IF FUNC_CALL VAR VAR NUMBER RETURN NUMBER ASSIGN VAR DICT RETURN BIN_OP FUNC_CALL VAR NUMBER VAR VAR BIN_OP BIN_OP NUMBER NUMBER NUMBER FUNC_DEF IF VAR VAR VAR RETURN VAR VAR VAR IF VAR FUNC_CALL VAR VAR RETURN NUMBER IF VAR VAR STRING RETURN NUMBER IF VAR BIN_OP FUNC_CALL VAR VAR NUMBER RETURN NUMBE... |
A top secret message containing letters from A-Z is being encoded to numbers using the following mapping:
'A' -> 1
'B' -> 2
...
'Z' -> 26
You are an FBI agent. You have to determine the total number of ways that message can be decoded, as the answer can be large return the answer modulo 10^{9} + 7.
Note: An empty digit... | class Solution:
def CountWays(self, str):
def helper(str, k, memo):
if k == 0:
return 1
s = len(str) - k
if str[s] == "0":
return 0
if memo[k] != None:
return memo[k]
res = helper(str, k - 1, memo)
... | CLASS_DEF FUNC_DEF FUNC_DEF IF VAR NUMBER RETURN NUMBER ASSIGN VAR BIN_OP FUNC_CALL VAR VAR VAR IF VAR VAR STRING RETURN NUMBER IF VAR VAR NONE RETURN VAR VAR ASSIGN VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER VAR IF VAR NUMBER FUNC_CALL VAR VAR VAR BIN_OP VAR NUMBER NUMBER VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER VAR ASSIG... |
A top secret message containing letters from A-Z is being encoded to numbers using the following mapping:
'A' -> 1
'B' -> 2
...
'Z' -> 26
You are an FBI agent. You have to determine the total number of ways that message can be decoded, as the answer can be large return the answer modulo 10^{9} + 7.
Note: An empty digit... | class Solution:
def CountWays(self, str):
s = str
n = len(s)
h = {(-1): 1, (0): 1}
div = 10**9 + 7
if s[0] == 0:
return 0
for i in range(1, n):
if s[i] == "0":
if s[i - 1] == "0":
return 0
h[... | CLASS_DEF FUNC_DEF ASSIGN VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR DICT NUMBER NUMBER NUMBER NUMBER ASSIGN VAR BIN_OP BIN_OP NUMBER NUMBER NUMBER IF VAR NUMBER NUMBER RETURN NUMBER FOR VAR FUNC_CALL VAR NUMBER VAR IF VAR VAR STRING IF VAR BIN_OP VAR NUMBER STRING RETURN NUMBER ASSIGN VAR VAR BIN_OP BIN_OP VAR BI... |
A top secret message containing letters from A-Z is being encoded to numbers using the following mapping:
'A' -> 1
'B' -> 2
...
'Z' -> 26
You are an FBI agent. You have to determine the total number of ways that message can be decoded, as the answer can be large return the answer modulo 10^{9} + 7.
Note: An empty digit... | class Solution:
def CountWays(self, str):
md = 10**9 + 7
n = len(str)
tem = [0] * (n + 1)
tem[0] = 1
for i in range(n):
if str[i] != "0":
tem[i + 1] = tem[i + 1] + tem[i]
if str[i - 1] != "0" and i - 1 >= 0 and int(str[i - 1 : i + 1]) ... | CLASS_DEF FUNC_DEF ASSIGN VAR BIN_OP BIN_OP NUMBER NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP LIST NUMBER BIN_OP VAR NUMBER ASSIGN VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR VAR IF VAR VAR STRING ASSIGN VAR BIN_OP VAR NUMBER BIN_OP VAR BIN_OP VAR NUMBER VAR VAR IF VAR BIN_OP VAR NUMBER STRING BIN_OP VAR ... |
A top secret message containing letters from A-Z is being encoded to numbers using the following mapping:
'A' -> 1
'B' -> 2
...
'Z' -> 26
You are an FBI agent. You have to determine the total number of ways that message can be decoded, as the answer can be large return the answer modulo 10^{9} + 7.
Note: An empty digit... | class Solution:
def CountWays(self, str):
if str[0] == "0":
return 0
dp = [0] * (len(str) + 1)
dp[0] = dp[1] = 1
mod = 10**9 + 7
for i in range(2, len(str) + 1):
one = int(str[i - 1])
two = int(str[i - 2 : i])
if 10 <= two <= 2... | CLASS_DEF FUNC_DEF IF VAR NUMBER STRING RETURN NUMBER ASSIGN VAR BIN_OP LIST NUMBER BIN_OP FUNC_CALL VAR VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER NUMBER ASSIGN VAR BIN_OP BIN_OP NUMBER NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP FUNC_CALL VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER ASSIGN VAR FUN... |
A top secret message containing letters from A-Z is being encoded to numbers using the following mapping:
'A' -> 1
'B' -> 2
...
'Z' -> 26
You are an FBI agent. You have to determine the total number of ways that message can be decoded, as the answer can be large return the answer modulo 10^{9} + 7.
Note: An empty digit... | import sys
sys.setrecursionlimit(10**9)
class Solution:
mod = 10**9 + 7
arr = []
def fun(self, ind, st, n):
if ind == n:
return 1
if self.arr[ind] != -1:
return self.arr[ind]
take = 0
leave = 0
if st[ind] >= "1" and st[ind] <= "9":
... | IMPORT EXPR FUNC_CALL VAR BIN_OP NUMBER NUMBER CLASS_DEF ASSIGN VAR BIN_OP BIN_OP NUMBER NUMBER NUMBER ASSIGN VAR LIST FUNC_DEF IF VAR VAR RETURN NUMBER IF VAR VAR NUMBER RETURN VAR VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER IF VAR VAR STRING VAR VAR STRING ASSIGN VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR VAR IF VAR BIN_OP ... |
A top secret message containing letters from A-Z is being encoded to numbers using the following mapping:
'A' -> 1
'B' -> 2
...
'Z' -> 26
You are an FBI agent. You have to determine the total number of ways that message can be decoded, as the answer can be large return the answer modulo 10^{9} + 7.
Note: An empty digit... | class Solution:
def CountWays(self, s):
if s[0] == "0":
return 0
n = len(s)
dp = [0] * (n + 1)
dp[0] = 1
dp[1] = 1
for i in range(2, n + 1):
if s[i - 1] != "0":
dp[i] += dp[i - 1]
if s[i - 2 : i] >= "10" and s[i - 2... | CLASS_DEF FUNC_DEF IF VAR NUMBER STRING RETURN NUMBER ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP LIST NUMBER BIN_OP VAR NUMBER ASSIGN VAR NUMBER NUMBER ASSIGN VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER IF VAR BIN_OP VAR NUMBER STRING VAR VAR VAR BIN_OP VAR NUMBER IF VAR BIN_OP VAR NUMBER VAR S... |
A top secret message containing letters from A-Z is being encoded to numbers using the following mapping:
'A' -> 1
'B' -> 2
...
'Z' -> 26
You are an FBI agent. You have to determine the total number of ways that message can be decoded, as the answer can be large return the answer modulo 10^{9} + 7.
Note: An empty digit... | class Solution:
def CountWays(self, str):
s = str
mod = 10**9 + 7
dp = {len(s): 1}
for i in range(len(s) - 1, -1, -1):
if s[i] == "0":
dp[i] = 0
else:
dp[i] = dp[i + 1]
if i + 1 < len(s) and (
s[i] =... | CLASS_DEF FUNC_DEF ASSIGN VAR VAR ASSIGN VAR BIN_OP BIN_OP NUMBER NUMBER NUMBER ASSIGN VAR DICT FUNC_CALL VAR VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER NUMBER NUMBER IF VAR VAR STRING ASSIGN VAR VAR NUMBER ASSIGN VAR VAR VAR BIN_OP VAR NUMBER IF BIN_OP VAR NUMBER FUNC_CALL VAR VAR VAR VAR STRING ... |
A top secret message containing letters from A-Z is being encoded to numbers using the following mapping:
'A' -> 1
'B' -> 2
...
'Z' -> 26
You are an FBI agent. You have to determine the total number of ways that message can be decoded, as the answer can be large return the answer modulo 10^{9} + 7.
Note: An empty digit... | class Solution:
def CountWays(self, s):
def dfs(i, n):
nonlocal d
if i in d:
return d[i]
if s[i] == "0":
return 0
res = 0
res = (res + dfs(i + 1, n)) % (10**9 + 7)
if i + 1 < n and (s[i] == "1" or s[i] ... | CLASS_DEF FUNC_DEF FUNC_DEF IF VAR VAR RETURN VAR VAR IF VAR VAR STRING RETURN NUMBER ASSIGN VAR NUMBER ASSIGN VAR BIN_OP BIN_OP VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR BIN_OP BIN_OP NUMBER NUMBER NUMBER IF BIN_OP VAR NUMBER VAR VAR VAR STRING VAR VAR STRING VAR BIN_OP VAR NUMBER STRING ASSIGN VAR BIN_OP BIN_OP VAR FUN... |
A top secret message containing letters from A-Z is being encoded to numbers using the following mapping:
'A' -> 1
'B' -> 2
...
'Z' -> 26
You are an FBI agent. You have to determine the total number of ways that message can be decoded, as the answer can be large return the answer modulo 10^{9} + 7.
Note: An empty digit... | class Solution:
def decode(self, digits, n, count, dp):
if n == 0 or n == 1:
return 1
if digits[0] == 0:
return 0
if dp[n] != -1:
return dp[n]
if digits[n - 1] > "0":
count = self.decode(digits, n - 1, count, dp)
if digits[n - ... | CLASS_DEF FUNC_DEF IF VAR NUMBER VAR NUMBER RETURN NUMBER IF VAR NUMBER NUMBER RETURN NUMBER IF VAR VAR NUMBER RETURN VAR VAR IF VAR BIN_OP VAR NUMBER STRING ASSIGN VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER VAR VAR IF VAR BIN_OP VAR NUMBER STRING VAR BIN_OP VAR NUMBER STRING VAR BIN_OP VAR NUMBER STRING VAR FUNC_CALL VAR... |
A top secret message containing letters from A-Z is being encoded to numbers using the following mapping:
'A' -> 1
'B' -> 2
...
'Z' -> 26
You are an FBI agent. You have to determine the total number of ways that message can be decoded, as the answer can be large return the answer modulo 10^{9} + 7.
Note: An empty digit... | class Solution:
def CountWays(self, str):
MOD = 10**9 + 7
n = len(str)
dp = {n: 1}
def f(i):
if i in dp:
return dp[i]
if str[i] == "0":
return 0
ans = f(i + 1)
if i + 1 < n and (
str[i] ... | CLASS_DEF FUNC_DEF ASSIGN VAR BIN_OP BIN_OP NUMBER NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR DICT VAR NUMBER FUNC_DEF IF VAR VAR RETURN VAR VAR IF VAR VAR STRING RETURN NUMBER ASSIGN VAR FUNC_CALL VAR BIN_OP VAR NUMBER IF BIN_OP VAR NUMBER VAR VAR VAR STRING VAR BIN_OP VAR NUMBER STRING VAR VAR STRING VAR B... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.