description stringlengths 171 4k | code stringlengths 94 3.98k | normalized_code stringlengths 57 4.99k |
|---|---|---|
As Will is stuck in the Upside Down, he can still communicate with his mom, Joyce, through the Christmas lights (he can turn them on and off with his mind). He can't directly tell his mom where he is, because the monster that took him to the Upside Down will know and relocate him.
<image>
Thus, he came up with a puz... | s = str(input())
n = len(s)
ans = 0
dp = [[(0) for _ in range(n)] for _ in range(2)]
for i in range(n - 1):
if s[i] == ")":
continue
dp[0][i] = 1
dp[1][i] = 1
for j in range(i + 1, n):
if s[j] == "(":
dp[0][j] = dp[0][j - 1] + 1
dp[1][j] = dp[1][j - 1] + 1
... | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER VAR FUNC_CALL VAR VAR VAR FUNC_CALL VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER IF VAR VAR STRING ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR IF VAR VA... |
As Will is stuck in the Upside Down, he can still communicate with his mom, Joyce, through the Christmas lights (he can turn them on and off with his mind). He can't directly tell his mom where he is, because the monster that took him to the Upside Down will know and relocate him.
<image>
Thus, he came up with a puz... | s = input()
l = len(s)
ans = 0
for i in range(0, l):
ln = n = 0
for j in range(i, l):
if s[j] == "(":
ln += 1
elif s[j] == ")":
ln -= 1
else:
n += 1
ln -= 1
if ln == 0:
ans += 1
elif ln < 0:
if n > 0:... | ASSIGN VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER VAR ASSIGN VAR VAR NUMBER FOR VAR FUNC_CALL VAR VAR VAR IF VAR VAR STRING VAR NUMBER IF VAR VAR STRING VAR NUMBER VAR NUMBER VAR NUMBER IF VAR NUMBER VAR NUMBER IF VAR NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER EXPR FUN... |
As Will is stuck in the Upside Down, he can still communicate with his mom, Joyce, through the Christmas lights (he can turn them on and off with his mind). He can't directly tell his mom where he is, because the monster that took him to the Upside Down will know and relocate him.
<image>
Thus, he came up with a puz... | s = input()
res, n = 0, len(s)
for i in range(n - 1):
j, c, q = i, 0, 0
while j < n and c + q >= 0:
if s[j] == "(":
c += 1
elif s[j] == ")":
c -= 1
else:
q += 1
if c < q:
c, q = q, c
res += c == q
j += 1
print(res) | ASSIGN VAR FUNC_CALL VAR ASSIGN VAR VAR NUMBER FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR VAR VAR VAR NUMBER NUMBER WHILE VAR VAR BIN_OP VAR VAR NUMBER IF VAR VAR STRING VAR NUMBER IF VAR VAR STRING VAR NUMBER VAR NUMBER IF VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR VAR VAR NUMBER EXPR FUNC_CALL V... |
As Will is stuck in the Upside Down, he can still communicate with his mom, Joyce, through the Christmas lights (he can turn them on and off with his mind). He can't directly tell his mom where he is, because the monster that took him to the Upside Down will know and relocate him.
<image>
Thus, he came up with a puz... | s = input().strip()
n = len(s)
ques = ans = ini = 0
for i in range(n):
ques = ini = 0
for j in range(i, n):
c = s[j]
if c == "?":
ques += 1
elif c == "(":
ini += 1
else:
ini -= 1
if ini < 0:
break
if ques > ini:
... | ASSIGN VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR NUMBER FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR NUMBER FOR VAR FUNC_CALL VAR VAR VAR ASSIGN VAR VAR VAR IF VAR STRING VAR NUMBER IF VAR STRING VAR NUMBER VAR NUMBER IF VAR NUMBER IF VAR VAR VAR NUMBER VAR NUMBER IF BIN_OP BIN_OP BIN_OP V... |
Jeff got 2n real numbers a1, a2, ..., a2n as a birthday present. The boy hates non-integer numbers, so he decided to slightly "adjust" the numbers he's got. Namely, Jeff consecutively executes n operations, each of them goes as follows:
* choose indexes i and j (i ≠ j) that haven't been chosen yet;
* round elemen... | n = int(input())
a = list(map(lambda x: int(x.split(".")[1]), input().split()))
s = sum(a) - n * 1000
zero_cnt = a.count(0)
min_add = max(0, zero_cnt - n)
max_add = min(n, zero_cnt)
answ = min(abs(s + i * 1000) for i in range(min_add, max_add + 1))
print("{:d}.{:0>3d}".format(answ // 1000, answ % 1000)) | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR STRING NUMBER FUNC_CALL FUNC_CALL VAR ASSIGN VAR BIN_OP FUNC_CALL VAR VAR BIN_OP VAR NUMBER ASSIGN VAR FUNC_CALL VAR NUMBER ASSIGN VAR FUNC_CALL VAR NUMBER BIN_OP VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR ASSIGN VAR... |
Jeff got 2n real numbers a1, a2, ..., a2n as a birthday present. The boy hates non-integer numbers, so he decided to slightly "adjust" the numbers he's got. Namely, Jeff consecutively executes n operations, each of them goes as follows:
* choose indexes i and j (i ≠ j) that haven't been chosen yet;
* round elemen... | n = int(input())
a = map(float, input().split())
s = 0
m = 0
for val in a:
s += val - int(val)
m += val - int(val) > 0
v = 1000000000.0
for i in range(max(0, m - n), min(n, m) + 1):
v = min(v, abs(s - i))
print("%.3f" % v) | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR VAR VAR BIN_OP VAR FUNC_CALL VAR VAR VAR BIN_OP VAR FUNC_CALL VAR VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR FUNC_CALL VAR NUMBER BIN_OP VAR VAR BIN_OP FUNC_CALL VAR VAR VAR NU... |
Vlad and Nastya live in a city consisting of $n$ houses and $n-1$ road. From each house, you can get to the other by moving only along the roads. That is, the city is a tree.
Vlad lives in a house with index $x$, and Nastya lives in a house with index $y$. Vlad decided to visit Nastya. However, he remembered that he h... | t = int(input())
for case in range(t):
input()
n, k = list(map(int, input().split()))
x, y = list(map(int, input().split()))
x -= 1
y -= 1
things = list(map(int, input().split()))
things = set([(i - 1) for i in things])
adj = [[] for _ in range(n)]
for i in range(n - 1):
u, v... | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR ASSIGN VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR VAR NUMBER VAR NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIG... |
Vlad and Nastya live in a city consisting of $n$ houses and $n-1$ road. From each house, you can get to the other by moving only along the roads. That is, the city is a tree.
Vlad lives in a house with index $x$, and Nastya lives in a house with index $y$. Vlad decided to visit Nastya. However, he remembered that he h... | def solve(N, K, vlad, nast, to_do, g):
to_do.add(vlad)
to_do.add(nast)
S = [(vlad, 0)]
prnt = (N + 1) * [-1]
time = None
while S:
cur, t = S.pop()
if cur == nast:
time = t
for nxt in g[cur]:
if nxt != prnt[cur]:
prnt[nxt] = cur
... | FUNC_DEF EXPR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR ASSIGN VAR LIST VAR NUMBER ASSIGN VAR BIN_OP BIN_OP VAR NUMBER LIST NUMBER ASSIGN VAR NONE WHILE VAR ASSIGN VAR VAR FUNC_CALL VAR IF VAR VAR ASSIGN VAR VAR FOR VAR VAR VAR IF VAR VAR VAR ASSIGN VAR VAR VAR EXPR FUNC_CALL VAR VAR BIN_OP VAR NUMBER ASSIGN VAR FUNC_CA... |
Vlad and Nastya live in a city consisting of $n$ houses and $n-1$ road. From each house, you can get to the other by moving only along the roads. That is, the city is a tree.
Vlad lives in a house with index $x$, and Nastya lives in a house with index $y$. Vlad decided to visit Nastya. However, he remembered that he h... | def solve(n, k, x, y, a, graph):
a.add(x)
a.add(y)
stack = [(x, 0)]
parent = (n + 1) * [-1]
y_height = None
while stack:
node, height = stack.pop()
if node == y:
y_height = height
for child in graph[node]:
if child != parent[node]:
... | FUNC_DEF EXPR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR ASSIGN VAR LIST VAR NUMBER ASSIGN VAR BIN_OP BIN_OP VAR NUMBER LIST NUMBER ASSIGN VAR NONE WHILE VAR ASSIGN VAR VAR FUNC_CALL VAR IF VAR VAR ASSIGN VAR VAR FOR VAR VAR VAR IF VAR VAR VAR ASSIGN VAR VAR VAR EXPR FUNC_CALL VAR VAR BIN_OP VAR NUMBER ASSIGN VAR FUNC_CA... |
Chef has an array A of length N.
He calls an index i (1 ≤ i ≤ N) *good* if there exists some j \neq i such that A_{i} = A_{j}.
Chef can perform the following operation at most once:
Choose any [subsequence] of the array A and add any positive integer to all the elements of the chosen subsequence.
Determine the maxi... | for _ in range(int(input())):
n = int(input())
a = sorted(list(map(int, input().split())))
freq = [0] * 1001
for x in a:
freq[x] += 1
ans = 0
for d in range(1, 1001):
cur = 0
mark = [0] * 1001
for x in a:
if mark[x] == 1:
continue
... | FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR BIN_OP LIST NUMBER NUMBER FOR VAR VAR VAR VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER NUMBER ASSIGN VAR NUMBER ASSIGN VAR BIN... |
Chef has an array A of length N.
He calls an index i (1 ≤ i ≤ N) *good* if there exists some j \neq i such that A_{i} = A_{j}.
Chef can perform the following operation at most once:
Choose any [subsequence] of the array A and add any positive integer to all the elements of the chosen subsequence.
Determine the maxi... | for _ in range(int(input())):
N = int(input())
A = [*map(int, input().split())]
freq = [0] * 1001
for x in A:
freq[x] += 1
D = {}
for i in range(1001):
if freq[i]:
D[i] = freq[i]
ans = sum(D[x] for x in D if D[x] > 1)
for x in range(1, 1001):
s, p, cur... | FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR LIST FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR BIN_OP LIST NUMBER NUMBER FOR VAR VAR VAR VAR NUMBER ASSIGN VAR DICT FOR VAR FUNC_CALL VAR NUMBER IF VAR VAR ASSIGN VAR VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR V... |
Chef has an array A of length N.
He calls an index i (1 ≤ i ≤ N) *good* if there exists some j \neq i such that A_{i} = A_{j}.
Chef can perform the following operation at most once:
Choose any [subsequence] of the array A and add any positive integer to all the elements of the chosen subsequence.
Determine the maxi... | def soln(A):
freq = {}
for i in A:
if i in freq.keys():
freq[i] += 1
else:
freq[i] = 1
A = [*freq.keys()]
A.sort()
max_count = sum(freq[x] for x in freq if freq[x] > 1)
for x in range(1, A[-1] - A[0] + 1):
s, p, count = [], {}, 0
for i in A... | FUNC_DEF ASSIGN VAR DICT FOR VAR VAR IF VAR FUNC_CALL VAR VAR VAR NUMBER ASSIGN VAR VAR NUMBER ASSIGN VAR LIST FUNC_CALL VAR EXPR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR VAR VAR VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP BIN_OP VAR NUMBER VAR NUMBER NUMBER ASSIGN VAR VAR VAR LIST DICT NUMBER FOR VAR VAR ... |
Chef has an array A of length N.
He calls an index i (1 ≤ i ≤ N) *good* if there exists some j \neq i such that A_{i} = A_{j}.
Chef can perform the following operation at most once:
Choose any [subsequence] of the array A and add any positive integer to all the elements of the chosen subsequence.
Determine the maxi... | for _ in range(int(input())):
n = int(input())
a = [int(x) for x in input().split()]
a.sort()
freq = [0] * 1001
ans = 0
for x in a:
freq[x] += 1
for d in range(1, 1001):
mark = [0] * 1001
Ans = 0
for x in a:
pointer = x
if mark[pointer]... | FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR EXPR FUNC_CALL VAR ASSIGN VAR BIN_OP LIST NUMBER NUMBER ASSIGN VAR NUMBER FOR VAR VAR VAR VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER NUMBER ASSIGN VAR BIN_OP LIST NUMBER NUMBER ... |
Given a set of N jobs where each job_{i} has a deadline and profit associated with it.
Each job takes 1 unit of time to complete and only one job can be scheduled at a time. We earn the profit associated with job if and only if the job is completed by its deadline.
Find the number of jobs done and the maximum profit.... | class Solution:
def JobScheduling(self, Jobs, n):
Jobs.sort(key=lambda x: x.profit, reverse=True)
maxi = -sys.maxsize
for i in range(0, n):
maxi = max(maxi, Jobs[i].deadline)
schedule = [(-1) for i in range(maxi + 1)]
count = 0
maxProfit = 0
for i... | CLASS_DEF FUNC_DEF EXPR FUNC_CALL VAR VAR NUMBER ASSIGN VAR VAR FOR VAR FUNC_CALL VAR NUMBER VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR ASSIGN VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER VAR ASSIGN VAR VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR VAR VAR FOR VA... |
Given a set of N jobs where each job_{i} has a deadline and profit associated with it.
Each job takes 1 unit of time to complete and only one job can be scheduled at a time. We earn the profit associated with job if and only if the job is completed by its deadline.
Find the number of jobs done and the maximum profit.... | class Solution:
def JobScheduling(self, Jobs, n):
l = Jobs
l.sort(reverse=True, key=lambda x: x.profit)
max = 0
for i in l:
if i.deadline > max:
max = i.deadline
l1 = [0] * max
c = 0
for i in l:
j = i.deadline - 1
... | CLASS_DEF FUNC_DEF ASSIGN VAR VAR EXPR FUNC_CALL VAR NUMBER VAR ASSIGN VAR NUMBER FOR VAR VAR IF VAR VAR ASSIGN VAR VAR ASSIGN VAR BIN_OP LIST NUMBER VAR ASSIGN VAR NUMBER FOR VAR VAR ASSIGN VAR BIN_OP VAR NUMBER WHILE NUMBER IF VAR VAR NUMBER ASSIGN VAR VAR VAR ASSIGN VAR BIN_OP VAR NUMBER VAR NUMBER IF VAR NUMBER IF ... |
Given a set of N jobs where each job_{i} has a deadline and profit associated with it.
Each job takes 1 unit of time to complete and only one job can be scheduled at a time. We earn the profit associated with job if and only if the job is completed by its deadline.
Find the number of jobs done and the maximum profit.... | class Solution:
def JobScheduling(self, Jobs, n):
Jobs.sort(key=lambda x: x.profit, reverse=True)
vis = [-1] * n
ans = 0
cnt = 0
for i in range(n):
job = Jobs[i]
if vis[job.deadline - 1] == -1:
vis[job.deadline - 1] = job.id
... | CLASS_DEF FUNC_DEF EXPR FUNC_CALL VAR VAR NUMBER ASSIGN VAR BIN_OP LIST NUMBER VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR IF VAR BIN_OP VAR NUMBER NUMBER ASSIGN VAR BIN_OP VAR NUMBER VAR VAR VAR VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER NUMBER IF VAR VAR NUMBER ... |
Given a set of N jobs where each job_{i} has a deadline and profit associated with it.
Each job takes 1 unit of time to complete and only one job can be scheduled at a time. We earn the profit associated with job if and only if the job is completed by its deadline.
Find the number of jobs done and the maximum profit.... | class Solution:
def JobScheduling(self, jobs, n):
jobs.sort(key=lambda x: x.profit, reverse=True)
maxDeadline = max(jobs, key=lambda x: x.deadline).deadline
sequence = {}
total_jobs = 0
total_profit = 0
for job in jobs:
index = job.deadline - 1
... | CLASS_DEF FUNC_DEF EXPR FUNC_CALL VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR ASSIGN VAR DICT ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR VAR ASSIGN VAR BIN_OP VAR NUMBER WHILE VAR NUMBER VAR VAR VAR NUMBER IF VAR NUMBER ASSIGN VAR VAR VAR VAR NUMBER VAR VAR RETURN VAR VAR |
Given a set of N jobs where each job_{i} has a deadline and profit associated with it.
Each job takes 1 unit of time to complete and only one job can be scheduled at a time. We earn the profit associated with job if and only if the job is completed by its deadline.
Find the number of jobs done and the maximum profit.... | class DisjointSet:
def __init__(self, n):
self.parent = [i for i in range(n)]
def find(self, x):
if x == self.parent[x]:
return x
self.parent[x] = self.find(self.parent[x])
return self.parent[x]
def merge(self, x, y):
self.parent[y] = x
class Solution... | CLASS_DEF FUNC_DEF ASSIGN VAR VAR VAR FUNC_CALL VAR VAR FUNC_DEF IF VAR VAR VAR RETURN VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR RETURN VAR VAR FUNC_DEF ASSIGN VAR VAR VAR CLASS_DEF FUNC_DEF ASSIGN VAR NUMBER FOR VAR VAR IF VAR VAR ASSIGN VAR VAR RETURN VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR VAR NUMBER ASSIGN VAR FUN... |
Given a set of N jobs where each job_{i} has a deadline and profit associated with it.
Each job takes 1 unit of time to complete and only one job can be scheduled at a time. We earn the profit associated with job if and only if the job is completed by its deadline.
Find the number of jobs done and the maximum profit.... | class Solution:
def JobScheduling(self, Jobs, n):
Jobs.sort(key=lambda x: x.profit, reverse=True)
no = 0
profit = 0
visited = [0] * n
for i in Jobs:
for j in range(i.deadline - 1, -1, -1):
if visited[j] == 0:
visited[j] = 1
... | CLASS_DEF FUNC_DEF EXPR FUNC_CALL VAR VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR BIN_OP LIST NUMBER VAR FOR VAR VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER NUMBER IF VAR VAR NUMBER ASSIGN VAR VAR NUMBER VAR NUMBER VAR VAR RETURN VAR VAR |
Given a set of N jobs where each job_{i} has a deadline and profit associated with it.
Each job takes 1 unit of time to complete and only one job can be scheduled at a time. We earn the profit associated with job if and only if the job is completed by its deadline.
Find the number of jobs done and the maximum profit.... | class Solution:
def JobScheduling(self, Jobs, n):
s_jobs = sorted(Jobs, key=lambda x: x.profit, reverse=True)
maxV = max([job.deadline for job in Jobs])
arr = [-1] * (maxV + 1)
sumV = 0
count = 0
for i in range(n):
if arr[s_jobs[i].deadline] == -1:
... | CLASS_DEF FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR VAR ASSIGN VAR BIN_OP LIST NUMBER BIN_OP VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR IF VAR VAR VAR NUMBER VAR VAR VAR VAR NUMBER ASSIGN VAR VAR VAR VAR VAR FOR VAR FUNC_CALL VAR BIN_OP VAR VAR NUMBE... |
Given a set of N jobs where each job_{i} has a deadline and profit associated with it.
Each job takes 1 unit of time to complete and only one job can be scheduled at a time. We earn the profit associated with job if and only if the job is completed by its deadline.
Find the number of jobs done and the maximum profit.... | class Solution:
def JobScheduling(self, jobs, n):
jobs.sort(key=lambda x: x.profit, reverse=True)
slots = [False] * n
max_profit = 0
num_jobs = 0
for i in range(n):
for j in range(min(n, jobs[i].deadline) - 1, -1, -1):
if not slots[j]:
... | CLASS_DEF FUNC_DEF EXPR FUNC_CALL VAR VAR NUMBER ASSIGN VAR BIN_OP LIST NUMBER VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR VAR VAR NUMBER NUMBER NUMBER IF VAR VAR ASSIGN VAR VAR NUMBER VAR VAR VAR VAR NUMBER RETURN VAR VAR |
Given a set of N jobs where each job_{i} has a deadline and profit associated with it.
Each job takes 1 unit of time to complete and only one job can be scheduled at a time. We earn the profit associated with job if and only if the job is completed by its deadline.
Find the number of jobs done and the maximum profit.... | class Solution:
def JobScheduling(self, Jobs, n):
stateMap = [(0) for _ in range(n)]
sortedJobs = sorted(Jobs, key=lambda x: x.profit, reverse=True)
profitSum = 0
jobsDone = 0
for job in sortedJobs:
for currState in range(job.deadline - 1, -1, -1):
... | CLASS_DEF FUNC_DEF ASSIGN VAR NUMBER VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER NUMBER IF VAR VAR ASSIGN VAR VAR NUMBER VAR VAR VAR NUMBER RETURN VAR VAR |
Given a set of N jobs where each job_{i} has a deadline and profit associated with it.
Each job takes 1 unit of time to complete and only one job can be scheduled at a time. We earn the profit associated with job if and only if the job is completed by its deadline.
Find the number of jobs done and the maximum profit.... | class Solution:
def JobScheduling(self, jobs, n):
jobs.sort(key=lambda x: x.profit, reverse=True)
maxi = jobs[0].deadline
for i in range(1, len(jobs)):
maxi = max(maxi, jobs[i].deadline)
slot = [-1] * (maxi + 1)
countJobs = 0
jobProfit = 0
for i i... | CLASS_DEF FUNC_DEF EXPR FUNC_CALL VAR VAR NUMBER ASSIGN VAR VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR ASSIGN VAR BIN_OP LIST NUMBER BIN_OP VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR VAR VAR NUMBER NUMB... |
Given a set of N jobs where each job_{i} has a deadline and profit associated with it.
Each job takes 1 unit of time to complete and only one job can be scheduled at a time. We earn the profit associated with job if and only if the job is completed by its deadline.
Find the number of jobs done and the maximum profit.... | class Solution:
def JobScheduling(self, Jobs, n):
Jobs.sort(key=lambda x: -x.profit)
slot = [False] * (n + 1)
maxprofit = 0
cnt = 0
for i in range(n):
for j in range(Jobs[i].deadline, 0, -1):
if slot[j] == False:
maxprofit += J... | CLASS_DEF FUNC_DEF EXPR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP LIST NUMBER BIN_OP VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR VAR VAR NUMBER NUMBER IF VAR VAR NUMBER VAR VAR VAR ASSIGN VAR VAR NUMBER VAR NUMBER RETURN LIST VAR VAR |
Given a set of N jobs where each job_{i} has a deadline and profit associated with it.
Each job takes 1 unit of time to complete and only one job can be scheduled at a time. We earn the profit associated with job if and only if the job is completed by its deadline.
Find the number of jobs done and the maximum profit.... | class Solution:
def JobScheduling(self, Jobs, n):
max_d = max({x.deadline for x in Jobs})
Jobs.sort(key=lambda x: -x.profit)
dp = [0] * max_d
for i in range(len(Jobs)):
for j in range(min(max_d - 1, Jobs[i].deadline - 1), -1, -1):
if dp[j] == 0:
... | CLASS_DEF FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR VAR VAR EXPR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP LIST NUMBER VAR FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR FUNC_CALL VAR BIN_OP VAR NUMBER BIN_OP VAR VAR NUMBER NUMBER NUMBER IF VAR VAR NUMBER ASSIGN VAR VAR VAR VAR ASSIGN VAR VAR NUMBER NUMBER FOR VAR... |
Given a set of N jobs where each job_{i} has a deadline and profit associated with it.
Each job takes 1 unit of time to complete and only one job can be scheduled at a time. We earn the profit associated with job if and only if the job is completed by its deadline.
Find the number of jobs done and the maximum profit.... | class Solution:
def JobScheduling(self, Jobs, n):
Jobs = sorted(Jobs, key=lambda x: x.profit, reverse=True)
max_deadline = -1
for i in range(n):
if Jobs[i].deadline > max_deadline:
max_deadline = Jobs[i].deadline
arr = [-1] * max_deadline
count = ... | CLASS_DEF FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR IF VAR VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR BIN_OP LIST NUMBER VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR IF VAR BIN_OP VAR VAR NUMBER NUMBER ASSIGN VAR BIN_OP VAR VAR NUMBER VAR VAR VAR NUMBER... |
Given a set of N jobs where each job_{i} has a deadline and profit associated with it.
Each job takes 1 unit of time to complete and only one job can be scheduled at a time. We earn the profit associated with job if and only if the job is completed by its deadline.
Find the number of jobs done and the maximum profit.... | class Solution:
def JobScheduling(self, Jobs, n):
Jobs.sort(key=lambda x: -x.profit)
max_deadline = Jobs[0].deadline
for job in Jobs:
max_deadline = max(max_deadline, job.deadline)
deadlines = [-1] * (max_deadline + 1)
max_profit = 0
cnt = 0
for j... | CLASS_DEF FUNC_DEF EXPR FUNC_CALL VAR VAR ASSIGN VAR VAR NUMBER FOR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR ASSIGN VAR BIN_OP LIST NUMBER BIN_OP VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR VAR FOR VAR FUNC_CALL VAR VAR NUMBER NUMBER IF VAR VAR NUMBER ASSIGN VAR VAR VAR VAR VAR VAR NUMBER RETURN VAR VAR |
Given a set of N jobs where each job_{i} has a deadline and profit associated with it.
Each job takes 1 unit of time to complete and only one job can be scheduled at a time. We earn the profit associated with job if and only if the job is completed by its deadline.
Find the number of jobs done and the maximum profit.... | class Solution:
def JobScheduling(self, Jobs, n):
array = sorted(Jobs, key=lambda x: x.profit, reverse=True)
visited = [0] * n
day = 0
profit = 0
for i in range(n):
j = min(n, array[i].deadline - 1)
for j in range(j, -1, -1):
if visite... | CLASS_DEF FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR VAR NUMBER ASSIGN VAR BIN_OP LIST NUMBER VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR BIN_OP VAR VAR NUMBER FOR VAR FUNC_CALL VAR VAR NUMBER NUMBER IF VAR VAR NUMBER ASSIGN VAR VAR NUMBER VAR VAR VAR VAR NUMBER RETURN VAR ... |
Given a set of N jobs where each job_{i} has a deadline and profit associated with it.
Each job takes 1 unit of time to complete and only one job can be scheduled at a time. We earn the profit associated with job if and only if the job is completed by its deadline.
Find the number of jobs done and the maximum profit.... | class Solution:
def JobScheduling(self, Jobs, n):
jobs = []
for i in range(n):
jobs.append([Jobs[i].deadline, Jobs[i].profit])
def sort(jobs):
r = sorted(jobs, key=lambda x: x[1], reverse=True)
return r
arr = sort(jobs)
visited = [False]... | CLASS_DEF FUNC_DEF ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR LIST VAR VAR VAR VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR VAR NUMBER NUMBER RETURN VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP LIST NUMBER BIN_OP FUNC_CALL VAR VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR... |
Given a set of N jobs where each job_{i} has a deadline and profit associated with it.
Each job takes 1 unit of time to complete and only one job can be scheduled at a time. We earn the profit associated with job if and only if the job is completed by its deadline.
Find the number of jobs done and the maximum profit.... | class Solution:
def JobScheduling(self, Jobs, n):
given = []
for i in range(n):
given.append([Jobs[i].deadline, Jobs[i].profit])
given.sort(key=lambda x: x[1], reverse=True)
jobsdone = [False] * n
profit = []
for i in range(n):
j = given[i][0]... | CLASS_DEF FUNC_DEF ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR LIST VAR VAR VAR VAR EXPR FUNC_CALL VAR VAR NUMBER NUMBER ASSIGN VAR BIN_OP LIST NUMBER VAR ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER NUMBER IF VAR VAR NUMBER EXPR FUN... |
Given a set of N jobs where each job_{i} has a deadline and profit associated with it.
Each job takes 1 unit of time to complete and only one job can be scheduled at a time. We earn the profit associated with job if and only if the job is completed by its deadline.
Find the number of jobs done and the maximum profit.... | class Solution:
def JobScheduling(self, Jobs, n):
Jobs.sort(key=lambda x: x.profit, reverse=True)
done = [-1] * 101
cost = 0
ans = 0
count = 0
for i in range(n):
cost = Jobs[i].profit
serial = Jobs[i].id
dead = Jobs[i].deadline
... | CLASS_DEF FUNC_DEF EXPR FUNC_CALL VAR VAR NUMBER ASSIGN VAR BIN_OP LIST NUMBER NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR VAR VAR FOR VAR FUNC_CALL VAR VAR NUMBER NUMBER IF VAR VAR NUMBER ASSIGN VAR VAR VAR VAR VAR VAR NUMBER R... |
Given a set of N jobs where each job_{i} has a deadline and profit associated with it.
Each job takes 1 unit of time to complete and only one job can be scheduled at a time. We earn the profit associated with job if and only if the job is completed by its deadline.
Find the number of jobs done and the maximum profit.... | class Solution:
def JobScheduling(self, Jobs, n):
j = sorted(Jobs, key=lambda x: x.profit, reverse=True)
max_d = 0
for jb in Jobs:
max_d = max(max_d, jb.deadline)
time = set()
for i in range(1, max_d + 1):
time.add(i)
ans = 0
k = 0
... | CLASS_DEF FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR VAR NUMBER ASSIGN VAR NUMBER FOR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER EXPR FUNC_CALL VAR VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR IF FUNC_CALL VAR VAR NUMBER ASSIGN VAR VA... |
Given a set of N jobs where each job_{i} has a deadline and profit associated with it.
Each job takes 1 unit of time to complete and only one job can be scheduled at a time. We earn the profit associated with job if and only if the job is completed by its deadline.
Find the number of jobs done and the maximum profit.... | class Solution:
def JobScheduling(self, Jobs, n):
Jobs.sort(key=lambda x: x.profit, reverse=True)
maxi = Jobs[0].deadline
for i in range(n):
maxi = max(maxi, Jobs[i].deadline)
arr = [(0) for i in range(maxi)]
count = 0
profits = 0
for i in range(n... | CLASS_DEF FUNC_DEF EXPR FUNC_CALL VAR VAR NUMBER ASSIGN VAR VAR NUMBER FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR ASSIGN VAR NUMBER VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR BIN_OP VAR VAR NUMBER NUMBER NUMBER IF VAR VAR NUMBER ASSIGN V... |
Given a set of N jobs where each job_{i} has a deadline and profit associated with it.
Each job takes 1 unit of time to complete and only one job can be scheduled at a time. We earn the profit associated with job if and only if the job is completed by its deadline.
Find the number of jobs done and the maximum profit.... | class Solution:
def JobScheduling(self, Jobs, n):
Jobs.sort(key=lambda x: x.profit, reverse=True)
places = [(False) for _ in range(n)]
res = 0
count = 0
for i in range(n):
for j in reversed(range(min(n - 1, Jobs[i].deadline - 1) + 1)):
if places[j... | CLASS_DEF FUNC_DEF EXPR FUNC_CALL VAR VAR NUMBER ASSIGN VAR NUMBER VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR BIN_OP VAR NUMBER BIN_OP VAR VAR NUMBER NUMBER IF VAR VAR NUMBER VAR VAR VAR ASSIGN VAR VAR NUMBER VAR NUMBER RE... |
Given a set of N jobs where each job_{i} has a deadline and profit associated with it.
Each job takes 1 unit of time to complete and only one job can be scheduled at a time. We earn the profit associated with job if and only if the job is completed by its deadline.
Find the number of jobs done and the maximum profit.... | class Solution:
def JobScheduling(self, jobs, n):
jobs.sort(key=lambda x: x.profit)
jobs.reverse()
maxDeadline = max(map(lambda x: x.deadline, jobs))
arr = [(True) for _ in range(maxDeadline)]
count, profit = 0, 0
for job in jobs:
for i in range(job.deadl... | CLASS_DEF FUNC_DEF EXPR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR VAR ASSIGN VAR NUMBER VAR FUNC_CALL VAR VAR ASSIGN VAR VAR NUMBER NUMBER FOR VAR VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER NUMBER IF VAR VAR ASSIGN VAR VAR NUMBER VAR NUMBER VAR VAR RETURN LIST VAR VAR |
Given a set of N jobs where each job_{i} has a deadline and profit associated with it.
Each job takes 1 unit of time to complete and only one job can be scheduled at a time. We earn the profit associated with job if and only if the job is completed by its deadline.
Find the number of jobs done and the maximum profit.... | class Solution:
def JobScheduling(self, Jobs, n):
max_deadline = 0
Jobs.sort(key=lambda x: x.profit, reverse=True)
for i in Jobs:
max_deadline = max(max_deadline, i.deadline)
possible_deadlines = [0] * max_deadline
count = 0
for i in Jobs:
if ... | CLASS_DEF FUNC_DEF ASSIGN VAR NUMBER EXPR FUNC_CALL VAR VAR NUMBER FOR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR ASSIGN VAR BIN_OP LIST NUMBER VAR ASSIGN VAR NUMBER FOR VAR VAR IF VAR BIN_OP VAR NUMBER NUMBER ASSIGN VAR BIN_OP VAR NUMBER VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER NUMBER IF VAR VAR NUMBER ASSIGN ... |
Given a set of N jobs where each job_{i} has a deadline and profit associated with it.
Each job takes 1 unit of time to complete and only one job can be scheduled at a time. We earn the profit associated with job if and only if the job is completed by its deadline.
Find the number of jobs done and the maximum profit.... | class Solution:
def JobScheduling(self, Jobs, n):
Jobs.sort(key=lambda x: x.profit, reverse=True)
maxjobs = 0
for job in Jobs:
if maxjobs < job.deadline:
maxjobs = job.deadline
arrans = [-1] * (maxjobs + 1)
for job in Jobs:
i = job.dea... | CLASS_DEF FUNC_DEF EXPR FUNC_CALL VAR VAR NUMBER ASSIGN VAR NUMBER FOR VAR VAR IF VAR VAR ASSIGN VAR VAR ASSIGN VAR BIN_OP LIST NUMBER BIN_OP VAR NUMBER FOR VAR VAR ASSIGN VAR VAR WHILE VAR NUMBER IF VAR VAR NUMBER ASSIGN VAR VAR VAR ASSIGN VAR BIN_OP VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR VAR IF VAR NU... |
Given a set of N jobs where each job_{i} has a deadline and profit associated with it.
Each job takes 1 unit of time to complete and only one job can be scheduled at a time. We earn the profit associated with job if and only if the job is completed by its deadline.
Find the number of jobs done and the maximum profit.... | class Solution:
def JobScheduling(self, Jobs, n):
max_profit, n_jobs = 0, 0
Jobs.sort(reverse=True, key=lambda x: x.profit)
max_deadline = 0
for i in Jobs:
if i.deadline > max_deadline:
max_deadline = i.deadline
freq_arr = [-1] * (max_deadline + 1... | CLASS_DEF FUNC_DEF ASSIGN VAR VAR NUMBER NUMBER EXPR FUNC_CALL VAR NUMBER VAR ASSIGN VAR NUMBER FOR VAR VAR IF VAR VAR ASSIGN VAR VAR ASSIGN VAR BIN_OP LIST NUMBER BIN_OP VAR NUMBER FOR VAR VAR FOR VAR FUNC_CALL VAR VAR NUMBER NUMBER IF VAR VAR NUMBER ASSIGN VAR VAR VAR VAR NUMBER VAR VAR RETURN LIST VAR VAR |
Given a set of N jobs where each job_{i} has a deadline and profit associated with it.
Each job takes 1 unit of time to complete and only one job can be scheduled at a time. We earn the profit associated with job if and only if the job is completed by its deadline.
Find the number of jobs done and the maximum profit.... | class Solution:
def JobScheduling(self, Jobs, n):
job_count = 0
profit = 0
Jobs.sort(key=lambda x: x.profit, reverse=True)
max_time = max(Jobs, key=lambda x: x.deadline).deadline
profit_list = [0] * max_time
for job in Jobs:
if job.deadline <= max_time:
... | CLASS_DEF FUNC_DEF ASSIGN VAR NUMBER ASSIGN VAR NUMBER EXPR FUNC_CALL VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR ASSIGN VAR BIN_OP LIST NUMBER VAR FOR VAR VAR IF VAR VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER NUMBER IF VAR VAR NUMBER ASSIGN VAR VAR NUMBER ASSIGN VAR BIN_OP VAR VAR VAR NUMBER RETURN LIST VA... |
Given a set of N jobs where each job_{i} has a deadline and profit associated with it.
Each job takes 1 unit of time to complete and only one job can be scheduled at a time. We earn the profit associated with job if and only if the job is completed by its deadline.
Find the number of jobs done and the maximum profit.... | class Solution:
def JobScheduling(self, Jobs, n):
arr = [0] * n
Jobs.sort(key=lambda x: x.profit, reverse=True)
max_profit = 0
count = 0
for i in range(n):
for j in range(Jobs[i].deadline - 1, -1, -1):
if not arr[j]:
arr[j] = T... | CLASS_DEF FUNC_DEF ASSIGN VAR BIN_OP LIST NUMBER VAR EXPR FUNC_CALL VAR VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR BIN_OP VAR VAR NUMBER NUMBER NUMBER IF VAR VAR ASSIGN VAR VAR NUMBER VAR VAR VAR VAR NUMBER RETURN LIST VAR VAR |
Given a set of N jobs where each job_{i} has a deadline and profit associated with it.
Each job takes 1 unit of time to complete and only one job can be scheduled at a time. We earn the profit associated with job if and only if the job is completed by its deadline.
Find the number of jobs done and the maximum profit.... | class Solution:
def JobScheduling(self, Jobs, n):
jobs = sorted(Jobs, key=lambda job: job.profit, reverse=True)
number = 0
profit = 0
time = [None] * n
for i in jobs:
for j in range(i.deadline, 0, -1):
if time[j - 1] == None:
t... | CLASS_DEF FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR BIN_OP LIST NONE VAR FOR VAR VAR FOR VAR FUNC_CALL VAR VAR NUMBER NUMBER IF VAR BIN_OP VAR NUMBER NONE ASSIGN VAR BIN_OP VAR NUMBER VAR VAR NUMBER VAR VAR RETURN LIST VAR VAR |
Given a set of N jobs where each job_{i} has a deadline and profit associated with it.
Each job takes 1 unit of time to complete and only one job can be scheduled at a time. We earn the profit associated with job if and only if the job is completed by its deadline.
Find the number of jobs done and the maximum profit.... | class Solution:
def JobScheduling(self, Jobs, n):
Jobs.sort(key=lambda x: x.profit, reverse=True)
maxDeadline = -1
for i in Jobs:
if i.deadline > maxDeadline:
maxDeadline = i.deadline
result = [(-1) for i in range(maxDeadline + 1)]
jobcount = 0
... | CLASS_DEF FUNC_DEF EXPR FUNC_CALL VAR VAR NUMBER ASSIGN VAR NUMBER FOR VAR VAR IF VAR VAR ASSIGN VAR VAR ASSIGN VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR VAR VAR NUMBER NUMBER IF VAR VAR NUMBER ASSIGN VAR VAR VAR VAR NUMBER VAR VAR... |
Given a set of N jobs where each job_{i} has a deadline and profit associated with it.
Each job takes 1 unit of time to complete and only one job can be scheduled at a time. We earn the profit associated with job if and only if the job is completed by its deadline.
Find the number of jobs done and the maximum profit.... | class Solution:
def JobScheduling(self, Jobs, n):
Jobs.sort(key=lambda x: -1 * x.profit)
mxl = 10**5
occupied = [False] * (mxl + 1)
ans = 0
count = 0
for i in range(n):
jobs = Jobs[i]
id = jobs.id
p = jobs.profit
dd = j... | CLASS_DEF FUNC_DEF EXPR FUNC_CALL VAR BIN_OP NUMBER VAR ASSIGN VAR BIN_OP NUMBER NUMBER ASSIGN VAR BIN_OP LIST NUMBER BIN_OP VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR VAR ASSIGN VAR VAR ASSIGN VAR VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER NUMBER IF V... |
Given a set of N jobs where each job_{i} has a deadline and profit associated with it.
Each job takes 1 unit of time to complete and only one job can be scheduled at a time. We earn the profit associated with job if and only if the job is completed by its deadline.
Find the number of jobs done and the maximum profit.... | class Solution:
def JobScheduling(self, Jobs, n):
Jobs.sort(key=lambda x: -x.profit)
maxi = 0
for i in range(n):
maxi = max(Jobs[i].profit, maxi)
slots = [-1] * maxi
p = 0
c = 0
for i in range(n):
dead = Jobs[i].deadline - 1
... | CLASS_DEF FUNC_DEF EXPR FUNC_CALL VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR ASSIGN VAR BIN_OP LIST NUMBER VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP VAR VAR NUMBER FOR VAR FUNC_CALL VAR VAR NUMBER NUMBER IF VAR VAR NUMBER ASSIGN VAR... |
Given a set of N jobs where each job_{i} has a deadline and profit associated with it.
Each job takes 1 unit of time to complete and only one job can be scheduled at a time. We earn the profit associated with job if and only if the job is completed by its deadline.
Find the number of jobs done and the maximum profit.... | class Solution:
def JobScheduling(self, Jobs, n):
Job = [[a.id, a.deadline, a.profit] for a in Jobs]
Job.sort(key=lambda x: x[2], reverse=True)
slots = [(False) for i in range(n)]
tm = 0
prof = 0
for i in range(n):
jb = Job[i]
for j in range(j... | CLASS_DEF FUNC_DEF ASSIGN VAR LIST VAR VAR VAR VAR VAR EXPR FUNC_CALL VAR VAR NUMBER NUMBER ASSIGN VAR NUMBER VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER NUMBER NUMBER IF VAR VAR NUMBER ASSIGN VAR VAR NUMBER VAR VA... |
Given a set of N jobs where each job_{i} has a deadline and profit associated with it.
Each job takes 1 unit of time to complete and only one job can be scheduled at a time. We earn the profit associated with job if and only if the job is completed by its deadline.
Find the number of jobs done and the maximum profit.... | class Solution:
def JobScheduling(self, Jobs, n):
Jobs.sort(key=lambda x: x.profit, reverse=True)
time = [0] * max(Jobs, key=lambda x: x.deadline).deadline
for job in Jobs:
if time[job.deadline - 1] == 0:
time[job.deadline - 1] = job.id, job.profit
el... | CLASS_DEF FUNC_DEF EXPR FUNC_CALL VAR VAR NUMBER ASSIGN VAR BIN_OP LIST NUMBER FUNC_CALL VAR VAR VAR FOR VAR VAR IF VAR BIN_OP VAR NUMBER NUMBER ASSIGN VAR BIN_OP VAR NUMBER VAR VAR FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR IF VAR VAR NUMBER ASSIGN VAR VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR NUMBER VAR VAR FUNC_CALL VAR... |
Given a set of N jobs where each job_{i} has a deadline and profit associated with it.
Each job takes 1 unit of time to complete and only one job can be scheduled at a time. We earn the profit associated with job if and only if the job is completed by its deadline.
Find the number of jobs done and the maximum profit.... | class Solution:
def JobScheduling(self, Jobs, n):
Jobs.sort(key=lambda x: x.profit, reverse=True)
m = 0
for x in Jobs:
if x.deadline > m:
m = x.deadline
r = [-1] * (m + 1)
a = [0, 0]
for i in Jobs:
for j in range(i.deadline, 0,... | CLASS_DEF FUNC_DEF EXPR FUNC_CALL VAR VAR NUMBER ASSIGN VAR NUMBER FOR VAR VAR IF VAR VAR ASSIGN VAR VAR ASSIGN VAR BIN_OP LIST NUMBER BIN_OP VAR NUMBER ASSIGN VAR LIST NUMBER NUMBER FOR VAR VAR FOR VAR FUNC_CALL VAR VAR NUMBER NUMBER IF VAR VAR NUMBER VAR NUMBER NUMBER VAR NUMBER VAR ASSIGN VAR VAR NUMBER RETURN VAR |
Given a set of N jobs where each job_{i} has a deadline and profit associated with it.
Each job takes 1 unit of time to complete and only one job can be scheduled at a time. We earn the profit associated with job if and only if the job is completed by its deadline.
Find the number of jobs done and the maximum profit.... | class Solution:
def JobScheduling(self, Jobs, n):
if not Jobs or Jobs == None or Jobs == {}:
return []
maxi = 0
for i in Jobs:
maxi = max(maxi, i.deadline)
out = 0
cj = 0
Jobs = sorted(Jobs, key=lambda x: x.profit, reverse=True)
seq = ... | CLASS_DEF FUNC_DEF IF VAR VAR NONE VAR DICT RETURN LIST ASSIGN VAR NUMBER FOR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR NUMBER ASSIGN VAR BIN_OP LIST NUMBER BIN_OP VAR NUMBER FOR VAR VAR ASSIGN VAR BIN_OP VAR NUMBER WHILE VAR VAR NUMBER VAR NUMBER IF V... |
Given a set of N jobs where each job_{i} has a deadline and profit associated with it.
Each job takes 1 unit of time to complete and only one job can be scheduled at a time. We earn the profit associated with job if and only if the job is completed by its deadline.
Find the number of jobs done and the maximum profit.... | class Solution:
def JobScheduling(self, jobs, n):
jobs.sort(key=lambda x: x.profit, reverse=True)
profit, totalJ = 0, 0
visited = [-1] * (n + 1)
for i in range(n):
for j in range(jobs[i].deadline, 0, -1):
if visited[j] == -1:
profit +=... | CLASS_DEF FUNC_DEF EXPR FUNC_CALL VAR VAR NUMBER ASSIGN VAR VAR NUMBER NUMBER ASSIGN VAR BIN_OP LIST NUMBER BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR VAR VAR NUMBER NUMBER IF VAR VAR NUMBER VAR VAR VAR VAR NUMBER ASSIGN VAR VAR VAR VAR RETURN VAR VAR |
Given a set of N jobs where each job_{i} has a deadline and profit associated with it.
Each job takes 1 unit of time to complete and only one job can be scheduled at a time. We earn the profit associated with job if and only if the job is completed by its deadline.
Find the number of jobs done and the maximum profit.... | class Solution:
def JobScheduling(self, Jobs, n):
Jobs.sort(key=lambda x: x.profit, reverse=True)
maxiDeadline = 0
for i in range(n):
if Jobs[i].deadline > maxiDeadline:
maxiDeadline = Jobs[i].deadline
slot = [-1] * (maxiDeadline + 1)
countJobs = ... | CLASS_DEF FUNC_DEF EXPR FUNC_CALL VAR VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR IF VAR VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR BIN_OP LIST NUMBER BIN_OP VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR FUNC_CALL VAR NUMBER BIN_OP VAR VAR NUMBER IF VAR VAR NUMBER ... |
Given a set of N jobs where each job_{i} has a deadline and profit associated with it.
Each job takes 1 unit of time to complete and only one job can be scheduled at a time. We earn the profit associated with job if and only if the job is completed by its deadline.
Find the number of jobs done and the maximum profit.... | class Solution:
def JobScheduling(self, Jobs, n):
profits = []
length = 0
for i in range(n):
length = max(length, Jobs[i].deadline)
profits.append([Jobs[i].deadline, Jobs[i].profit])
profits.sort(key=lambda x: x[1], reverse=True)
check = [0] * (length... | CLASS_DEF FUNC_DEF ASSIGN VAR LIST ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR EXPR FUNC_CALL VAR LIST VAR VAR VAR VAR EXPR FUNC_CALL VAR VAR NUMBER NUMBER ASSIGN VAR BIN_OP LIST NUMBER BIN_OP VAR NUMBER ASSIGN VAR VAR NUMBER FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR NUMBER WHILE... |
Given a set of N jobs where each job_{i} has a deadline and profit associated with it.
Each job takes 1 unit of time to complete and only one job can be scheduled at a time. We earn the profit associated with job if and only if the job is completed by its deadline.
Find the number of jobs done and the maximum profit.... | class Solution:
def JobScheduling(self, Jobs, n):
res, count = 0, 0
Jobs = sorted(Jobs, key=lambda x: x.profit, reverse=True)
result = [(0) for i in range(n)]
slot = [(False) for i in range(n)]
for i in range(n):
for j in range(min(n, Jobs[i].deadline) - 1, -1, -... | CLASS_DEF FUNC_DEF ASSIGN VAR VAR NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR NUMBER ASSIGN VAR NUMBER VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR VAR VAR NUMBER NUMBER NUMBER IF VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR VAR NUMBE... |
Given a set of N jobs where each job_{i} has a deadline and profit associated with it.
Each job takes 1 unit of time to complete and only one job can be scheduled at a time. We earn the profit associated with job if and only if the job is completed by its deadline.
Find the number of jobs done and the maximum profit.... | class Solution:
def JobScheduling(self, Jobs, n):
Jobs.sort(reverse=True, key=lambda x: x.profit)
vac = [0] * n
for job in Jobs:
h = job.deadline - 1
l = 0
res = -1
for i in range(h, -1, -1):
if not vac[i]:
... | CLASS_DEF FUNC_DEF EXPR FUNC_CALL VAR NUMBER VAR ASSIGN VAR BIN_OP LIST NUMBER VAR FOR VAR VAR ASSIGN VAR BIN_OP VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR NUMBER NUMBER IF VAR VAR ASSIGN VAR VAR IF VAR NUMBER ASSIGN VAR VAR VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR VAR IF VAR VAR NU... |
Given a set of N jobs where each job_{i} has a deadline and profit associated with it.
Each job takes 1 unit of time to complete and only one job can be scheduled at a time. We earn the profit associated with job if and only if the job is completed by its deadline.
Find the number of jobs done and the maximum profit.... | class Solution:
def JobScheduling(self, jobs, n):
lookup = set()
jobs.sort(key=lambda x: x.profit, reverse=True)
mdl = jobs[0].deadline
for jb in jobs:
mdl = max(mdl, jb.deadline)
is_worked = [False] * mdl
count = 0
profit = 0
for jb in jo... | CLASS_DEF FUNC_DEF ASSIGN VAR FUNC_CALL VAR EXPR FUNC_CALL VAR VAR NUMBER ASSIGN VAR VAR NUMBER FOR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR ASSIGN VAR BIN_OP LIST NUMBER VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER NUMBER IF VAR VAR VAR VAR VAR NUMBER ASSIGN VAR VA... |
Given a set of N jobs where each job_{i} has a deadline and profit associated with it.
Each job takes 1 unit of time to complete and only one job can be scheduled at a time. We earn the profit associated with job if and only if the job is completed by its deadline.
Find the number of jobs done and the maximum profit.... | class Solution:
def JobScheduling(self, Jobs, n):
sr = sorted(Jobs, key=lambda job: job.profit, reverse=True)
co = 0
pr = 0
st = set()
for i in range(n):
if sr[i].deadline not in st:
pr += sr[i].profit
co += 1
st.ad... | CLASS_DEF FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR IF VAR VAR VAR VAR VAR VAR VAR NUMBER EXPR FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR IF VAR NUMBER VAR VAR VAR VAR NUMBER EXPR FUNC_CALL VAR VAR RETURN LIST ... |
Given a set of N jobs where each job_{i} has a deadline and profit associated with it.
Each job takes 1 unit of time to complete and only one job can be scheduled at a time. We earn the profit associated with job if and only if the job is completed by its deadline.
Find the number of jobs done and the maximum profit.... | import sys
def func(x):
return x.deadline
sys.setrecursionlimit(10**6)
class Solution:
def helper(self, A, i, c):
key = i, c
if self.d.get(key) is not None:
return self.d[key]
if i == len(A):
return 0, 0
if c < A[i].deadline:
n1, c1 = se... | IMPORT FUNC_DEF RETURN VAR EXPR FUNC_CALL VAR BIN_OP NUMBER NUMBER CLASS_DEF FUNC_DEF ASSIGN VAR VAR VAR IF FUNC_CALL VAR VAR NONE RETURN VAR VAR IF VAR FUNC_CALL VAR VAR RETURN NUMBER NUMBER IF VAR VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER BIN_OP VAR NUMBER ASSIGN VAR VAR FUNC_CALL VAR VAR BIN_OP VAR ... |
Given a set of N jobs where each job_{i} has a deadline and profit associated with it.
Each job takes 1 unit of time to complete and only one job can be scheduled at a time. We earn the profit associated with job if and only if the job is completed by its deadline.
Find the number of jobs done and the maximum profit.... | class Solution:
def JobScheduling(self, Jobs, n):
jobday = [-1] * max(Jobs, key=lambda x: x.deadline).deadline
profit = 0
count = 0
Jobs.sort(key=lambda x: [-x.profit])
for x in Jobs:
id, dl, pr = x.id, x.deadline, x.profit
j = dl - 1
whil... | CLASS_DEF FUNC_DEF ASSIGN VAR BIN_OP LIST NUMBER FUNC_CALL VAR VAR VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER EXPR FUNC_CALL VAR LIST VAR FOR VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR ASSIGN VAR BIN_OP VAR NUMBER WHILE NUMBER VAR VAR VAR NUMBER VAR NUMBER IF VAR NUMBER ASSIGN VAR VAR VAR VAR VAR VAR NUMBER IF VAR FUNC_CALL V... |
Given a set of N jobs where each job_{i} has a deadline and profit associated with it.
Each job takes 1 unit of time to complete and only one job can be scheduled at a time. We earn the profit associated with job if and only if the job is completed by its deadline.
Find the number of jobs done and the maximum profit.... | class Solution:
def JobScheduling(self, Jobs, n):
def sortProfit(x):
return x.profit
profit = 0
numberOfJobs = 0
slot = [-1] * (n + 1)
slot[0] = 1
arr = list(Jobs)
def checkSlot(d):
for i in range(d, -1, -1):
if slot... | CLASS_DEF FUNC_DEF FUNC_DEF RETURN VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR BIN_OP LIST NUMBER BIN_OP VAR NUMBER ASSIGN VAR NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR VAR FUNC_DEF FOR VAR FUNC_CALL VAR VAR NUMBER NUMBER IF VAR VAR NUMBER RETURN VAR RETURN NUMBER EXPR FUNC_CALL VAR VAR NUMBER FOR VAR FUNC_CALL VAR... |
Given a set of N jobs where each job_{i} has a deadline and profit associated with it.
Each job takes 1 unit of time to complete and only one job can be scheduled at a time. We earn the profit associated with job if and only if the job is completed by its deadline.
Find the number of jobs done and the maximum profit.... | class Solution:
def JobScheduling(self, Jobs, n):
Jobs.sort(key=lambda x: x.profit, reverse=True)
maxDead = max(job.deadline for job in Jobs)
slots = [(-1) for i in range(maxDead)]
maxProf = 0
count = 0
for i in range(n):
for j in range(Jobs[i].deadline -... | CLASS_DEF FUNC_DEF EXPR FUNC_CALL VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR VAR ASSIGN VAR NUMBER VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR BIN_OP VAR VAR NUMBER NUMBER NUMBER IF VAR VAR NUMBER ASSIGN VAR VAR VAR VAR VAR NUMBER VAR VAR VAR RETURN VAR... |
Given a set of N jobs where each job_{i} has a deadline and profit associated with it.
Each job takes 1 unit of time to complete and only one job can be scheduled at a time. We earn the profit associated with job if and only if the job is completed by its deadline.
Find the number of jobs done and the maximum profit.... | class Solution:
def JobScheduling(self, Jobs, n):
Jobs = sorted(Jobs, key=lambda x: x.profit, reverse=True)
dead = -1
for i in range(n):
if Jobs[i].deadline > dead:
dead = Jobs[i].deadline
ans = [-1] * dead
maxp = 0
count = 0
for i... | CLASS_DEF FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR IF VAR VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR BIN_OP LIST NUMBER VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER VAR ASSIGN VAR VAR VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER NUMBER IF VAR ... |
Given a set of N jobs where each job_{i} has a deadline and profit associated with it.
Each job takes 1 unit of time to complete and only one job can be scheduled at a time. We earn the profit associated with job if and only if the job is completed by its deadline.
Find the number of jobs done and the maximum profit.... | class Solution:
def JobScheduling(self, Jobs, n):
maxi = 0
arr = []
for i in range(n):
maxi = max(maxi, Jobs[i].deadline)
result = [(-1) for i in range(maxi)]
total = 0
jobs_done = 0
for i in range(n):
arr.append([Jobs[i].profit, Jobs[... | CLASS_DEF FUNC_DEF ASSIGN VAR NUMBER ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR ASSIGN VAR NUMBER VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR LIST VAR VAR VAR VAR EXPR FUNC_CALL VAR NUMBER FOR VAR FUNC_CALL VAR VAR FOR VAR FU... |
Given a set of N jobs where each job_{i} has a deadline and profit associated with it.
Each job takes 1 unit of time to complete and only one job can be scheduled at a time. We earn the profit associated with job if and only if the job is completed by its deadline.
Find the number of jobs done and the maximum profit.... | class Solution:
def JobScheduling(self, jobs, n):
ma = 0
res = []
for i in range(0, len(jobs)):
k = [jobs[i].deadline, jobs[i].profit]
res.append(k)
if jobs[i].deadline > ma:
ma = jobs[i].deadline
res.sort(key=lambda x: x[1], rever... | CLASS_DEF FUNC_DEF ASSIGN VAR NUMBER ASSIGN VAR LIST FOR VAR FUNC_CALL VAR NUMBER FUNC_CALL VAR VAR ASSIGN VAR LIST VAR VAR VAR VAR EXPR FUNC_CALL VAR VAR IF VAR VAR VAR ASSIGN VAR VAR VAR EXPR FUNC_CALL VAR VAR NUMBER NUMBER ASSIGN VAR NUMBER VAR FUNC_CALL VAR NUMBER VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUN... |
Lee tried so hard to make a good div.2 D problem to balance his recent contest, but it still doesn't feel good at all. Lee invented it so tediously slow that he managed to develop a phobia about div.2 D problem setting instead. And now he is hiding behind the bushes...
Let's define a Rooted Dead Bush (RDB) of level $n... | MOD, N = 10**9 + 7, 2 * 1001 * 1001
dp = [0] * N
for i in range(3, N):
dp[i] = (2 * dp[i - 2] + dp[i - 1] + 4 * (i % 3 == 0)) % MOD
for _ in range(int(input())):
print(dp[int(input())]) | ASSIGN VAR VAR BIN_OP BIN_OP NUMBER NUMBER NUMBER BIN_OP BIN_OP NUMBER NUMBER NUMBER ASSIGN VAR BIN_OP LIST NUMBER VAR FOR VAR FUNC_CALL VAR NUMBER VAR ASSIGN VAR VAR BIN_OP BIN_OP BIN_OP BIN_OP NUMBER VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER BIN_OP NUMBER BIN_OP VAR NUMBER NUMBER VAR FOR VAR FUNC_CALL VAR FUNC_CALL... |
Lee tried so hard to make a good div.2 D problem to balance his recent contest, but it still doesn't feel good at all. Lee invented it so tediously slow that he managed to develop a phobia about div.2 D problem setting instead. And now he is hiding behind the bushes...
Let's define a Rooted Dead Bush (RDB) of level $n... | from sys import stdin
input = stdin.readline
mod = 10**9 + 7
dp = [0, 0, 0, 4, 4, 12]
for x in range(6, 2000001):
if x % 6 == 3 or x % 6 == 5:
dp.append((dp[-1] * 2 + 4) % mod)
elif x % 6 == 4:
dp.append((dp[-1] * 2 - 4) % mod)
else:
dp.append(dp[-1] * 2 % mod)
for _ in range(int(in... | ASSIGN VAR VAR ASSIGN VAR BIN_OP BIN_OP NUMBER NUMBER NUMBER ASSIGN VAR LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER NUMBER IF BIN_OP VAR NUMBER NUMBER BIN_OP VAR NUMBER NUMBER EXPR FUNC_CALL VAR BIN_OP BIN_OP BIN_OP VAR NUMBER NUMBER NUMBER VAR IF BIN_OP VAR NUMBER NUMBER EXPR FUNC_CALL ... |
Lee tried so hard to make a good div.2 D problem to balance his recent contest, but it still doesn't feel good at all. Lee invented it so tediously slow that he managed to develop a phobia about div.2 D problem setting instead. And now he is hiding behind the bushes...
Let's define a Rooted Dead Bush (RDB) of level $n... | import sys
def input():
return sys.stdin.readline().strip()
def list2d(a, b, c):
return [([c] * b) for i in range(a)]
def list3d(a, b, c, d):
return [[([d] * c) for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e):
return [[[([e] * d) for j in range(c)] for j in range(b)] for i in ran... | IMPORT FUNC_DEF RETURN FUNC_CALL FUNC_CALL VAR FUNC_DEF RETURN BIN_OP LIST VAR VAR VAR FUNC_CALL VAR VAR FUNC_DEF RETURN BIN_OP LIST VAR VAR VAR FUNC_CALL VAR VAR VAR FUNC_CALL VAR VAR FUNC_DEF RETURN BIN_OP LIST VAR VAR VAR FUNC_CALL VAR VAR VAR FUNC_CALL VAR VAR VAR FUNC_CALL VAR VAR FUNC_DEF NUMBER RETURN FUNC_CALL ... |
Lee tried so hard to make a good div.2 D problem to balance his recent contest, but it still doesn't feel good at all. Lee invented it so tediously slow that he managed to develop a phobia about div.2 D problem setting instead. And now he is hiding behind the bushes...
Let's define a Rooted Dead Bush (RDB) of level $n... | l = [0, 0, 0]
mod = int(1000000000.0) + 7
for i in range(3, 2000005):
l.append((l[i - 1] + l[i - 2] * 2 + (4 if i % 3 == 0 else 0)) % mod)
t = int(input())
for _ in range(t):
n = int(input())
print(l[n]) | ASSIGN VAR LIST NUMBER NUMBER NUMBER ASSIGN VAR BIN_OP FUNC_CALL VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER NUMBER EXPR FUNC_CALL VAR BIN_OP BIN_OP BIN_OP VAR BIN_OP VAR NUMBER BIN_OP VAR BIN_OP VAR NUMBER NUMBER BIN_OP VAR NUMBER NUMBER NUMBER NUMBER VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR... |
Lee tried so hard to make a good div.2 D problem to balance his recent contest, but it still doesn't feel good at all. Lee invented it so tediously slow that he managed to develop a phobia about div.2 D problem setting instead. And now he is hiding behind the bushes...
Let's define a Rooted Dead Bush (RDB) of level $n... | def gns():
return list(map(int, input().split()))
t = int(input())
ns = []
ans = [0, 0, 0, 4, 4, 12]
for _ in range(t):
n = int(input())
ns.append(n)
mx = max(ns)
md = 10**9 + 7
for i in range(6, mx + 6):
ans.append((ans[-2] * 2 + ans[-1] + (4 if i % 3 == 0 else 0)) % md)
for ni in ns:
print(ans[n... | FUNC_DEF RETURN FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR LIST ASSIGN VAR LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR EXPR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP ... |
Lee tried so hard to make a good div.2 D problem to balance his recent contest, but it still doesn't feel good at all. Lee invented it so tediously slow that he managed to develop a phobia about div.2 D problem setting instead. And now he is hiding behind the bushes...
Let's define a Rooted Dead Bush (RDB) of level $n... | inp = lambda: int(input())
inpm = lambda: map(int, input().split())
inpl = lambda: list(inpm())
l2mn = lambda _n, _m: [[(0) for __ in range(_m)] for _ in range(_n)]
l2n = lambda _n: l2mn(_n, _n)
INF = int(1e18)
MOD = int(1000000000.0) + 7
N = 2000009
dp = [0] * N
for i in range(3, N):
dp[i] = (dp[i - 2] * 2 + dp[i ... | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR NUMBER VAR FUNC_CALL VAR VAR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL VAR NUMBER ASSIGN VAR BIN_OP FUNC_CALL VAR NUMBER NUMBER ASSIGN VAR NUMBE... |
Lee tried so hard to make a good div.2 D problem to balance his recent contest, but it still doesn't feel good at all. Lee invented it so tediously slow that he managed to develop a phobia about div.2 D problem setting instead. And now he is hiding behind the bushes...
Let's define a Rooted Dead Bush (RDB) of level $n... | pe = [(0) for i in range(2000001)]
for i in range(3, 2000001):
if i % 3 == 0:
pe[i] = (pe[i - 1] + pe[i - 2] * 2 + 1) % 1000000007
else:
pe[i] = (pe[i - 1] + pe[i - 2] * 2) % 1000000007
for _ in range(int(input())):
n = int(input())
print(pe[n] * 4 % 1000000007) | ASSIGN VAR NUMBER VAR FUNC_CALL VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER NUMBER IF BIN_OP VAR NUMBER NUMBER ASSIGN VAR VAR BIN_OP BIN_OP BIN_OP VAR BIN_OP VAR NUMBER BIN_OP VAR BIN_OP VAR NUMBER NUMBER NUMBER NUMBER ASSIGN VAR VAR BIN_OP BIN_OP VAR BIN_OP VAR NUMBER BIN_OP VAR BIN_OP VAR NUMBER NUMBER NUMBER FOR VAR FUN... |
Lee tried so hard to make a good div.2 D problem to balance his recent contest, but it still doesn't feel good at all. Lee invented it so tediously slow that he managed to develop a phobia about div.2 D problem setting instead. And now he is hiding behind the bushes...
Let's define a Rooted Dead Bush (RDB) of level $n... | d = [(0) for _ in range(2000001)]
d[3] = 4
for i in range(4, 2000001):
if i % 3 == 0:
d[i] = (2 * d[i - 2] + d[i - 1] + 4) % 1000000007
else:
d[i] = (2 * d[i - 2] + d[i - 1]) % 1000000007
n = int(input())
while n > 0:
x = int(input())
print(d[x])
n -= 1 | ASSIGN VAR NUMBER VAR FUNC_CALL VAR NUMBER ASSIGN VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER NUMBER IF BIN_OP VAR NUMBER NUMBER ASSIGN VAR VAR BIN_OP BIN_OP BIN_OP BIN_OP NUMBER VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER NUMBER NUMBER ASSIGN VAR VAR BIN_OP BIN_OP BIN_OP NUMBER VAR BIN_OP VAR NUMBER VAR BIN_OP VAR ... |
Lee tried so hard to make a good div.2 D problem to balance his recent contest, but it still doesn't feel good at all. Lee invented it so tediously slow that he managed to develop a phobia about div.2 D problem setting instead. And now he is hiding behind the bushes...
Let's define a Rooted Dead Bush (RDB) of level $n... | f = [0, 0, 0, 4, 4]
for i in range(5, 2000001):
f.append((2 * f[-2] + f[-1] + (4 if i % 3 == 0 else 0)) % 1000000007)
for tt in range(int(input())):
print(f[int(input())]) | ASSIGN VAR LIST NUMBER NUMBER NUMBER NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER NUMBER EXPR FUNC_CALL VAR BIN_OP BIN_OP BIN_OP BIN_OP NUMBER VAR NUMBER VAR NUMBER BIN_OP VAR NUMBER NUMBER NUMBER NUMBER NUMBER FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR EXPR FUNC_CALL VAR VAR FUNC_CALL VAR FUNC_CALL VAR |
Lee tried so hard to make a good div.2 D problem to balance his recent contest, but it still doesn't feel good at all. Lee invented it so tediously slow that he managed to develop a phobia about div.2 D problem setting instead. And now he is hiding behind the bushes...
Let's define a Rooted Dead Bush (RDB) of level $n... | p = [0, 0, 4]
n = 1000000007
for i in range(4, 2 * 1000000 + 1):
p.append((p[-1] + 2 * p[-2] + (i % 3 == 0) * 4) % n)
for i in range(int(input())):
n = int(input())
print(p[n - 1]) | ASSIGN VAR LIST NUMBER NUMBER NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP BIN_OP NUMBER NUMBER NUMBER EXPR FUNC_CALL VAR BIN_OP BIN_OP BIN_OP VAR NUMBER BIN_OP NUMBER VAR NUMBER BIN_OP BIN_OP VAR NUMBER NUMBER NUMBER VAR FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CA... |
Lee tried so hard to make a good div.2 D problem to balance his recent contest, but it still doesn't feel good at all. Lee invented it so tediously slow that he managed to develop a phobia about div.2 D problem setting instead. And now he is hiding behind the bushes...
Let's define a Rooted Dead Bush (RDB) of level $n... | dp = [0, 0, 0, 4, 4, 12]
for n in range(2000000 // 6):
dp.append(dp[-1] * 2 % (10**9 + 7))
dp.append(dp[-1] * 2 % (10**9 + 7))
dp.append(dp[-1] * 2 % (10**9 + 7))
dp.append((dp[-1] * 2 + 4) % (10**9 + 7))
dp.append((dp[-1] * 2 - 4) % (10**9 + 7))
dp.append((dp[-1] * 2 + 4) % (10**9 + 7))
T = int... | ASSIGN VAR LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER FOR VAR FUNC_CALL VAR BIN_OP NUMBER NUMBER EXPR FUNC_CALL VAR BIN_OP BIN_OP VAR NUMBER NUMBER BIN_OP BIN_OP NUMBER NUMBER NUMBER EXPR FUNC_CALL VAR BIN_OP BIN_OP VAR NUMBER NUMBER BIN_OP BIN_OP NUMBER NUMBER NUMBER EXPR FUNC_CALL VAR BIN_OP BIN_OP VAR NUMBER NUM... |
Lee tried so hard to make a good div.2 D problem to balance his recent contest, but it still doesn't feel good at all. Lee invented it so tediously slow that he managed to develop a phobia about div.2 D problem setting instead. And now he is hiding behind the bushes...
Let's define a Rooted Dead Bush (RDB) of level $n... | mod = 1000000007
MAX = 2000000
arr = [int(-1)] * (MAX + 1)
arr[0] = 0
arr[1] = 0
arr[2] = 0
arr[3] = 4
arr[4] = 4
for i in range(5, MAX + 1):
arr[i] = (arr[i - 1] + 2 * arr[i - 2] + 4 * (i % 3 == 0)) % mod
t = int(input())
while t > 0:
n = int(input())
print(arr[n])
t -= 1 | ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR BIN_OP LIST FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER ASSIGN VAR NUMBER NUMBER ASSIGN VAR NUMBER NUMBER ASSIGN VAR NUMBER NUMBER ASSIGN VAR NUMBER NUMBER ASSIGN VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER ASSIGN VAR VAR BIN_OP BIN_OP BIN_OP VAR BIN_OP VAR... |
Lee tried so hard to make a good div.2 D problem to balance his recent contest, but it still doesn't feel good at all. Lee invented it so tediously slow that he managed to develop a phobia about div.2 D problem setting instead. And now he is hiding behind the bushes...
Let's define a Rooted Dead Bush (RDB) of level $n... | import sys
input = sys.stdin.readline
mod = 10**9 + 7
ANS = [0, 0, 0, 4, 4]
HEAD = [0, 0, 0, 1, 0]
for i in range(2 * 10**6):
if HEAD[-1] == 0 and HEAD[-2] == 0:
ANS.append((ANS[-1] + ANS[-2] * 2 + 4) % mod)
HEAD.append(1)
else:
ANS.append((ANS[-1] + ANS[-2] * 2) % mod)
HEAD.app... | IMPORT ASSIGN VAR VAR ASSIGN VAR BIN_OP BIN_OP NUMBER NUMBER NUMBER ASSIGN VAR LIST NUMBER NUMBER NUMBER NUMBER NUMBER ASSIGN VAR LIST NUMBER NUMBER NUMBER NUMBER NUMBER FOR VAR FUNC_CALL VAR BIN_OP NUMBER BIN_OP NUMBER NUMBER IF VAR NUMBER NUMBER VAR NUMBER NUMBER EXPR FUNC_CALL VAR BIN_OP BIN_OP BIN_OP VAR NUMBER BIN... |
Lee tried so hard to make a good div.2 D problem to balance his recent contest, but it still doesn't feel good at all. Lee invented it so tediously slow that he managed to develop a phobia about div.2 D problem setting instead. And now he is hiding behind the bushes...
Let's define a Rooted Dead Bush (RDB) of level $n... | limit = 10**9 + 7
k = 2000001
A = [0] * k
A[3] = 4
for i in range(4, 2000001):
save = A[i - 1] + 2 * A[i - 2]
if i % 3 == 0:
save += 4
A[i] = save % limit
for t in range(int(input())):
n = int(input())
print(A[n]) | ASSIGN VAR BIN_OP BIN_OP NUMBER NUMBER NUMBER ASSIGN VAR NUMBER ASSIGN VAR BIN_OP LIST NUMBER VAR ASSIGN VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER NUMBER ASSIGN VAR BIN_OP VAR BIN_OP VAR NUMBER BIN_OP NUMBER VAR BIN_OP VAR NUMBER IF BIN_OP VAR NUMBER NUMBER VAR NUMBER ASSIGN VAR VAR BIN_OP VAR VAR FOR VAR FUNC_CAL... |
Lee tried so hard to make a good div.2 D problem to balance his recent contest, but it still doesn't feel good at all. Lee invented it so tediously slow that he managed to develop a phobia about div.2 D problem setting instead. And now he is hiding behind the bushes...
Let's define a Rooted Dead Bush (RDB) of level $n... | from sys import maxsize, stdin, stdout
def solve():
pass
val = 10**9 + 7
dp = [0, 0, 0, 4]
for n in range(4, 2 * 10**6 + 1):
if n % 3 == 0:
dp.append((dp[n - 1] + 2 * dp[n - 2] + 4) % val)
else:
dp.append((dp[n - 1] + 2 * dp[n - 2]) % val)
test = 1
test = int(input())
for t in range(0, t... | FUNC_DEF ASSIGN VAR BIN_OP BIN_OP NUMBER NUMBER NUMBER ASSIGN VAR LIST NUMBER NUMBER NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP BIN_OP NUMBER BIN_OP NUMBER NUMBER NUMBER IF BIN_OP VAR NUMBER NUMBER EXPR FUNC_CALL VAR BIN_OP BIN_OP BIN_OP VAR BIN_OP VAR NUMBER BIN_OP NUMBER VAR BIN_OP VAR NUMBER NUMBER VAR EXPR F... |
Lee tried so hard to make a good div.2 D problem to balance his recent contest, but it still doesn't feel good at all. Lee invented it so tediously slow that he managed to develop a phobia about div.2 D problem setting instead. And now he is hiding behind the bushes...
Let's define a Rooted Dead Bush (RDB) of level $n... | m = 1000000007
k = 2000001
x = [0] * k
x[3] = 4
c = 3
for t in range(int(input())):
n = int(input())
if n <= c:
print(x[n])
else:
for i in range(c + 1, n + 1):
a = x[i - 1] + 2 * x[i - 2]
if i % 3 == 0:
a += 4
x[i] = a % m
c = n
... | ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR BIN_OP LIST NUMBER VAR ASSIGN VAR NUMBER NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR IF VAR VAR EXPR FUNC_CALL VAR VAR VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER BIN_OP VAR NUMBER ASSIGN VAR BIN_OP VAR ... |
Lee tried so hard to make a good div.2 D problem to balance his recent contest, but it still doesn't feel good at all. Lee invented it so tediously slow that he managed to develop a phobia about div.2 D problem setting instead. And now he is hiding behind the bushes...
Let's define a Rooted Dead Bush (RDB) of level $n... | a = [0, 0, 1, 1]
m = 10**9 + 7
for i in range(5, 2000001):
x = a[i - 2] + 2 * a[i - 3]
if i % 3 == 0:
a.append((x + 1) % m)
else:
a.append(x % m)
for _ in range(int(input())):
n = int(input())
print(a[n - 1] * 4 % m) | ASSIGN VAR LIST NUMBER NUMBER NUMBER NUMBER ASSIGN VAR BIN_OP BIN_OP NUMBER NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER NUMBER ASSIGN VAR BIN_OP VAR BIN_OP VAR NUMBER BIN_OP NUMBER VAR BIN_OP VAR NUMBER IF BIN_OP VAR NUMBER NUMBER EXPR FUNC_CALL VAR BIN_OP BIN_OP VAR NUMBER VAR EXPR FUNC_CALL VAR BIN_OP VAR VAR FOR VAR ... |
Lee tried so hard to make a good div.2 D problem to balance his recent contest, but it still doesn't feel good at all. Lee invented it so tediously slow that he managed to develop a phobia about div.2 D problem setting instead. And now he is hiding behind the bushes...
Let's define a Rooted Dead Bush (RDB) of level $n... | t = int(input())
dp = [(0) for i in range(2 * 10**6 + 1)]
dp[0] = 0
dp[1] = 0
dp[2] = 0
dp[3] = 4
for i in range(4, 2 * 10**6 + 1):
if i % 3 == 0:
dp[i] = (dp[i - 2] * 2 + dp[i - 1] + 4) % (10**9 + 7)
else:
dp[i] = (dp[i - 2] * 2 + dp[i - 1]) % (10**9 + 7)
for _ in range(t):
n = int(input())... | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR NUMBER VAR FUNC_CALL VAR BIN_OP BIN_OP NUMBER BIN_OP NUMBER NUMBER NUMBER ASSIGN VAR NUMBER NUMBER ASSIGN VAR NUMBER NUMBER ASSIGN VAR NUMBER NUMBER ASSIGN VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP BIN_OP NUMBER BIN_OP NUMBER NUMBER NUMBER IF BIN_OP VAR NUMB... |
Lee tried so hard to make a good div.2 D problem to balance his recent contest, but it still doesn't feel good at all. Lee invented it so tediously slow that he managed to develop a phobia about div.2 D problem setting instead. And now he is hiding behind the bushes...
Let's define a Rooted Dead Bush (RDB) of level $n... | t = int(input())
maxn = int(1000000.0 * 2 + 7)
mod = int(1000000000.0 + 7)
dp = list(bytearray(maxn))
for i in range(3, maxn):
add4 = 4 if i % 3 == 0 else 0
dp[i] = (dp[i - 2] * 2 + dp[i - 1]) % mod + add4
for _ in range(t):
n = int(input())
print(dp[n]) | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR BIN_OP BIN_OP NUMBER NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR BIN_OP NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR NUMBER VAR ASSIGN VAR BIN_OP VAR NUMBER NUMBER NUMBER NUMBER ASSIGN VAR VAR BIN_OP BIN_OP BIN_OP BIN_OP VAR BI... |
Lee tried so hard to make a good div.2 D problem to balance his recent contest, but it still doesn't feel good at all. Lee invented it so tediously slow that he managed to develop a phobia about div.2 D problem setting instead. And now he is hiding behind the bushes...
Let's define a Rooted Dead Bush (RDB) of level $n... | import sys
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def II():
return int(sys.stdin.readline())
def MI():
return map(int, sys.stdin.readline().split())
def LI():
return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number):
return [LI() for _ in range(rows_numb... | IMPORT ASSIGN VAR BIN_OP FUNC_CALL VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR STRING FUNC_DEF RETURN FUNC_CALL VAR FUNC_CALL VAR FUNC_DEF RETURN FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR FUNC_DEF RETURN FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR FUNC_DEF RETURN FUNC_CALL VAR VAR FUNC_CALL VAR VAR FUNC_DEF... |
Lee tried so hard to make a good div.2 D problem to balance his recent contest, but it still doesn't feel good at all. Lee invented it so tediously slow that he managed to develop a phobia about div.2 D problem setting instead. And now he is hiding behind the bushes...
Let's define a Rooted Dead Bush (RDB) of level $n... | t = int(input())
dp = []
dp.append(0)
dp.append(0)
dp.append(0)
dp.append(4)
dp.append(4)
mod = 10**9 + 7
for i in range(5, 2000001, 1):
a = dp[i - 1] + 2 * dp[i - 2]
if i % 3 == 0:
a += 4
a %= mod
dp.append(a)
for i in range(t):
n = int(input())
print(dp[n]) | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR LIST EXPR FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR NUMBER ASSIGN VAR BIN_OP BIN_OP NUMBER NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER NUMBER NUMBER ASSIGN VAR BIN_OP VAR BIN_OP VAR NUMBER BIN_OP... |
Lee tried so hard to make a good div.2 D problem to balance his recent contest, but it still doesn't feel good at all. Lee invented it so tediously slow that he managed to develop a phobia about div.2 D problem setting instead. And now he is hiding behind the bushes...
Let's define a Rooted Dead Bush (RDB) of level $n... | import sys
pprint = lambda s: print(" ".join(map(str, s)))
input = lambda: sys.stdin.readline().strip()
ipnut = input
n = 2000000
dp = [0] * n
mod = 1000000007
for i in range(2, n):
dp[i] = (dp[i - 1] + 2 * dp[i - 2] + int(i % 3 == 2)) % mod
for i in range(int(input())):
print(dp[int(input()) - 1] * 4 % mod) | IMPORT ASSIGN VAR FUNC_CALL VAR FUNC_CALL STRING FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR VAR ASSIGN VAR NUMBER ASSIGN VAR BIN_OP LIST NUMBER VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER VAR ASSIGN VAR VAR BIN_OP BIN_OP BIN_OP VAR BIN_OP VAR NUMBER BIN_OP NUMBER VAR BIN_OP VAR NUMBER FU... |
Lee tried so hard to make a good div.2 D problem to balance his recent contest, but it still doesn't feel good at all. Lee invented it so tediously slow that he managed to develop a phobia about div.2 D problem setting instead. And now he is hiding behind the bushes...
Let's define a Rooted Dead Bush (RDB) of level $n... | k = 2000005
l = [0] * k
l[1] = 0
l[2] = 0
l[3] = 4
l[4] = 4
def ans():
mod = 1000000000.0 + 7
for i in range(5, k):
if i % 3 == 0:
ans = l[i - 1] + 2 * l[i - 2] + 4
else:
ans = l[i - 1] + 2 * l[i - 2]
ans = ans % mod
l[i] = int(ans)
ans()
for _ in rang... | ASSIGN VAR NUMBER ASSIGN VAR BIN_OP LIST NUMBER VAR ASSIGN VAR NUMBER NUMBER ASSIGN VAR NUMBER NUMBER ASSIGN VAR NUMBER NUMBER ASSIGN VAR NUMBER NUMBER FUNC_DEF ASSIGN VAR BIN_OP NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER VAR IF BIN_OP VAR NUMBER NUMBER ASSIGN VAR BIN_OP BIN_OP VAR BIN_OP VAR NUMBER BIN_OP NUMBER VAR B... |
Lee tried so hard to make a good div.2 D problem to balance his recent contest, but it still doesn't feel good at all. Lee invented it so tediously slow that he managed to develop a phobia about div.2 D problem setting instead. And now he is hiding behind the bushes...
Let's define a Rooted Dead Bush (RDB) of level $n... | def preprocess(pref):
mod = int(1000000000.0) + 7
for i in range(3, 2000005):
pref.append((pref[i - 1] + pref[i - 2] * 2 + (4 if i % 3 == 0 else 0)) % mod)
def main():
pref = [0, 0, 0]
preprocess(pref)
for _ in range(int(input())):
print(pref[int(input())])
main() | FUNC_DEF ASSIGN VAR BIN_OP FUNC_CALL VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER NUMBER EXPR FUNC_CALL VAR BIN_OP BIN_OP BIN_OP VAR BIN_OP VAR NUMBER BIN_OP VAR BIN_OP VAR NUMBER NUMBER BIN_OP VAR NUMBER NUMBER NUMBER NUMBER VAR FUNC_DEF ASSIGN VAR LIST NUMBER NUMBER NUMBER EXPR FUNC_CALL VAR VAR FOR VAR FUNC_CALL V... |
Lee tried so hard to make a good div.2 D problem to balance his recent contest, but it still doesn't feel good at all. Lee invented it so tediously slow that he managed to develop a phobia about div.2 D problem setting instead. And now he is hiding behind the bushes...
Let's define a Rooted Dead Bush (RDB) of level $n... | mod = 10**9 + 7
ans = [0, 0, 4, 4]
t = int(input())
for i in range(5, 2000010):
temp = ans[i - 2] + 2 * ans[i - 3]
if i % 3 == 0:
temp += 4
ans.append(temp % mod)
for _ in range(t):
n = int(input())
print(ans[n - 1]) | ASSIGN VAR BIN_OP BIN_OP NUMBER NUMBER NUMBER ASSIGN VAR LIST NUMBER NUMBER NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR NUMBER NUMBER ASSIGN VAR BIN_OP VAR BIN_OP VAR NUMBER BIN_OP NUMBER VAR BIN_OP VAR NUMBER IF BIN_OP VAR NUMBER NUMBER VAR NUMBER EXPR FUNC_CALL VAR BIN_OP VAR VAR FOR VA... |
Lee tried so hard to make a good div.2 D problem to balance his recent contest, but it still doesn't feel good at all. Lee invented it so tediously slow that he managed to develop a phobia about div.2 D problem setting instead. And now he is hiding behind the bushes...
Let's define a Rooted Dead Bush (RDB) of level $n... | mod = 1000000007
dp = [0, 0, 0, 1, 1]
for i in range(5, 2000001):
if i % 3 == 0:
dp.append((dp[i - 1] + 2 * dp[i - 2] + 1) % mod)
else:
dp.append((dp[i - 1] + 2 * dp[i - 2]) % mod)
t = int(input())
for i in range(t):
n = int(input())
print(4 * dp[n] % mod) | ASSIGN VAR NUMBER ASSIGN VAR LIST NUMBER NUMBER NUMBER NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER NUMBER IF BIN_OP VAR NUMBER NUMBER EXPR FUNC_CALL VAR BIN_OP BIN_OP BIN_OP VAR BIN_OP VAR NUMBER BIN_OP NUMBER VAR BIN_OP VAR NUMBER NUMBER VAR EXPR FUNC_CALL VAR BIN_OP BIN_OP VAR BIN_OP VAR NUMBER BIN_OP NUMBER VAR BIN_O... |
Lee tried so hard to make a good div.2 D problem to balance his recent contest, but it still doesn't feel good at all. Lee invented it so tediously slow that he managed to develop a phobia about div.2 D problem setting instead. And now he is hiding behind the bushes...
Let's define a Rooted Dead Bush (RDB) of level $n... | solution = [0, 0, 0, 4, 4]
def store(n):
prev1, prev2, sol = 1, 1, 0
for i in range(5, n + 1):
sol = 2 * prev2 + prev1
if i % 3 == 0:
sol += 1
sol = sol % 1000000007
prev2, prev1 = prev1, sol
solution.append(sol * 4 % 1000000007)
t = int(input())
store(200... | ASSIGN VAR LIST NUMBER NUMBER NUMBER NUMBER NUMBER FUNC_DEF ASSIGN VAR VAR VAR NUMBER NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER ASSIGN VAR BIN_OP BIN_OP NUMBER VAR VAR IF BIN_OP VAR NUMBER NUMBER VAR NUMBER ASSIGN VAR BIN_OP VAR NUMBER ASSIGN VAR VAR VAR VAR EXPR FUNC_CALL VAR BIN_OP BIN_OP VAR NUMBE... |
Lee tried so hard to make a good div.2 D problem to balance his recent contest, but it still doesn't feel good at all. Lee invented it so tediously slow that he managed to develop a phobia about div.2 D problem setting instead. And now he is hiding behind the bushes...
Let's define a Rooted Dead Bush (RDB) of level $n... | max_s = 2000003
c = 1000000007
q = [0] * max_s
for i in range(3, max_s):
if not i % 3:
q[i] = (q[i - 1] + 2 * q[i - 2] + 1) % c
else:
q[i] = (q[i - 1] + 2 * q[i - 2]) % c
for _ in range(int(input())):
print(q[int(input())] * 4 % c) | ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR BIN_OP LIST NUMBER VAR FOR VAR FUNC_CALL VAR NUMBER VAR IF BIN_OP VAR NUMBER ASSIGN VAR VAR BIN_OP BIN_OP BIN_OP VAR BIN_OP VAR NUMBER BIN_OP NUMBER VAR BIN_OP VAR NUMBER NUMBER VAR ASSIGN VAR VAR BIN_OP BIN_OP VAR BIN_OP VAR NUMBER BIN_OP NUMBER VAR BIN_OP VAR NUMBER VAR ... |
Lee tried so hard to make a good div.2 D problem to balance his recent contest, but it still doesn't feel good at all. Lee invented it so tediously slow that he managed to develop a phobia about div.2 D problem setting instead. And now he is hiding behind the bushes...
Let's define a Rooted Dead Bush (RDB) of level $n... | mod = 1000000007
dp = [(0, 0), (0, 0)]
for i in range(2, 2000001):
dp.append(
((max(dp[-1]) + 2 * max(dp[-2])) % mod, (dp[-1][0] + 2 * dp[-2][0] + 1) % mod)
)
for o in range(int(input())):
print(max(dp[int(input()) - 1]) * 4 % mod) | ASSIGN VAR NUMBER ASSIGN VAR LIST NUMBER NUMBER NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER NUMBER EXPR FUNC_CALL VAR BIN_OP BIN_OP FUNC_CALL VAR VAR NUMBER BIN_OP NUMBER FUNC_CALL VAR VAR NUMBER VAR BIN_OP BIN_OP BIN_OP VAR NUMBER NUMBER BIN_OP NUMBER VAR NUMBER NUMBER NUMBER VAR FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUN... |
Lee tried so hard to make a good div.2 D problem to balance his recent contest, but it still doesn't feel good at all. Lee invented it so tediously slow that he managed to develop a phobia about div.2 D problem setting instead. And now he is hiding behind the bushes...
Let's define a Rooted Dead Bush (RDB) of level $n... | def draw(n):
MOD = 10**9 + 7
INV = 47619048
ADD = [6, -30, -18]
def fpow(x, n):
r = 1
while n > 1:
if n & 1:
r = r * x % MOD
x = x * x % MOD
n >>= 1
return x * r % MOD
return (fpow(2, n + 3) + 14 * (2 * (n & 1) - 1) + ADD[... | FUNC_DEF ASSIGN VAR BIN_OP BIN_OP NUMBER NUMBER NUMBER ASSIGN VAR NUMBER ASSIGN VAR LIST NUMBER NUMBER NUMBER FUNC_DEF ASSIGN VAR NUMBER WHILE VAR NUMBER IF BIN_OP VAR NUMBER ASSIGN VAR BIN_OP BIN_OP VAR VAR VAR ASSIGN VAR BIN_OP BIN_OP VAR VAR VAR VAR NUMBER RETURN BIN_OP BIN_OP VAR VAR VAR RETURN BIN_OP BIN_OP BIN_OP... |
You are given a Young diagram.
Given diagram is a histogram with n columns of lengths a_1, a_2, …, a_n (a_1 ≥ a_2 ≥ … ≥ a_n ≥ 1).
<image> Young diagram for a=[3,2,2,2,1].
Your goal is to find the largest number of non-overlapping dominos that you can draw inside of this histogram, a domino is a 1 × 2 or 2 × 1 recta... | from sys import gettrace, stdin
if not gettrace():
def input():
return next(stdin)[:-1]
def main():
n = int(input())
aa = [int(a) for a in input().split()]
rem = 0
black = 0
white = 0
for i, a in enumerate(aa):
black += a // 2
white += a // 2
if a % 2 == 1... | IF FUNC_CALL VAR FUNC_DEF RETURN FUNC_CALL VAR VAR NUMBER FUNC_DEF ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR VAR FUNC_CALL VAR VAR VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER IF BIN_OP VAR NUMBER NUMBER I... |
You are given a Young diagram.
Given diagram is a histogram with n columns of lengths a_1, a_2, …, a_n (a_1 ≥ a_2 ≥ … ≥ a_n ≥ 1).
<image> Young diagram for a=[3,2,2,2,1].
Your goal is to find the largest number of non-overlapping dominos that you can draw inside of this histogram, a domino is a 1 × 2 or 2 × 1 recta... | n = int(input())
l = [int(i) for i in input().split(" ")]
tot = sum(i // 2 for i in l)
stack = []
for i in range(n):
l[i] &= 1
if not stack or stack[-1] != l[i]:
stack.append(l[i])
else:
tot += stack.pop()
print(tot) | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR STRING ASSIGN VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR VAR ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR VAR VAR NUMBER IF VAR VAR NUMBER VAR VAR EXPR FUNC_CALL VAR VAR VAR VAR FUNC_CALL VAR EXPR FUNC_CALL VAR VAR |
You are given a Young diagram.
Given diagram is a histogram with n columns of lengths a_1, a_2, …, a_n (a_1 ≥ a_2 ≥ … ≥ a_n ≥ 1).
<image> Young diagram for a=[3,2,2,2,1].
Your goal is to find the largest number of non-overlapping dominos that you can draw inside of this histogram, a domino is a 1 × 2 or 2 × 1 recta... | n = int(input())
arr = list(map(int, input().split()))
ans_1 = 0
ans_2 = 0
for i in range(n):
if i % 2 == 1:
ans_1 += int(arr[i] / 2) + arr[i] % 2
ans_2 += int(arr[i] / 2)
else:
ans_1 += int(arr[i] / 2)
ans_2 += int(arr[i] / 2) + arr[i] % 2
print(min(ans_1, ans_2)) | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR IF BIN_OP VAR NUMBER NUMBER VAR BIN_OP FUNC_CALL VAR BIN_OP VAR VAR NUMBER BIN_OP VAR VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR VAR NUMBER VAR FUNC_CALL V... |
You are given a Young diagram.
Given diagram is a histogram with n columns of lengths a_1, a_2, …, a_n (a_1 ≥ a_2 ≥ … ≥ a_n ≥ 1).
<image> Young diagram for a=[3,2,2,2,1].
Your goal is to find the largest number of non-overlapping dominos that you can draw inside of this histogram, a domino is a 1 × 2 or 2 × 1 recta... | n = int(input())
a = list(map(int, input().split()))
sol = 0
w = 0
b = 0
for i, ai in enumerate(a):
w += ai // 2
b += ai // 2
if ai % 2:
if i % 2:
w += 1
else:
b += 1
sol = min(w, b)
print(sol) | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR VAR FUNC_CALL VAR VAR VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER IF BIN_OP VAR NUMBER IF BIN_OP VAR NUMBER VAR NUMBER VAR NUMBER ASSIGN VAR FUNC_CALL V... |
You are given a Young diagram.
Given diagram is a histogram with n columns of lengths a_1, a_2, …, a_n (a_1 ≥ a_2 ≥ … ≥ a_n ≥ 1).
<image> Young diagram for a=[3,2,2,2,1].
Your goal is to find the largest number of non-overlapping dominos that you can draw inside of this histogram, a domino is a 1 × 2 or 2 × 1 recta... | n, m = 0, 0
l = int(input())
a = input().split()
for i in range(l):
a[i] = int(a[i])
for i in range(l):
m += a[i]
if i % 2 == 0:
n += a[i] // 2
else:
n += a[i] - a[i] // 2
m -= n
print(min(n, m)) | ASSIGN VAR VAR NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR FOR VAR FUNC_CALL VAR VAR VAR VAR VAR IF BIN_OP VAR NUMBER NUMBER VAR BIN_OP VAR VAR NUMBER VAR BIN_OP VAR VAR BIN_OP VAR VAR NUMBER VAR VAR EXPR FUNC_CAL... |
You are given a Young diagram.
Given diagram is a histogram with n columns of lengths a_1, a_2, …, a_n (a_1 ≥ a_2 ≥ … ≥ a_n ≥ 1).
<image> Young diagram for a=[3,2,2,2,1].
Your goal is to find the largest number of non-overlapping dominos that you can draw inside of this histogram, a domino is a 1 × 2 or 2 × 1 recta... | n = int(input())
a = list(map(int, input().split()))
black, white = 0, 0
for i in range(n):
black += a[i] // 2
white += a[i] // 2
if i % 2:
black += a[i] % 2
else:
white += a[i] % 2
if white == black:
print(white)
else:
print(min(black, white)) | 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 NUMBER NUMBER FOR VAR FUNC_CALL VAR VAR VAR BIN_OP VAR VAR NUMBER VAR BIN_OP VAR VAR NUMBER IF BIN_OP VAR NUMBER VAR BIN_OP VAR VAR NUMBER VAR BIN_OP VAR VAR NUMBER IF VAR VAR EXPR FUNC_CALL VAR VAR ... |
You are given a Young diagram.
Given diagram is a histogram with n columns of lengths a_1, a_2, …, a_n (a_1 ≥ a_2 ≥ … ≥ a_n ≥ 1).
<image> Young diagram for a=[3,2,2,2,1].
Your goal is to find the largest number of non-overlapping dominos that you can draw inside of this histogram, a domino is a 1 × 2 or 2 × 1 recta... | import sys
n = int(input())
a = list(map(int, input().split(" ")))
parity = 0
even, odd = 0, 0
for x in a:
even += x // 2
odd += x // 2
if x % 2 == 1:
if parity == 0:
even += 1
else:
odd += 1
parity = 1 - parity
print(min(even, odd)) | IMPORT ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR STRING ASSIGN VAR NUMBER ASSIGN VAR VAR NUMBER NUMBER FOR VAR VAR VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER IF BIN_OP VAR NUMBER NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER ASSIGN VAR BIN_OP NUMBER VAR EXPR... |
You are given a Young diagram.
Given diagram is a histogram with n columns of lengths a_1, a_2, …, a_n (a_1 ≥ a_2 ≥ … ≥ a_n ≥ 1).
<image> Young diagram for a=[3,2,2,2,1].
Your goal is to find the largest number of non-overlapping dominos that you can draw inside of this histogram, a domino is a 1 × 2 or 2 × 1 recta... | n = int(input())
a = list(map(int, input().split()))
k = 1
white = 0
black = 0
for i in a:
black += i // 2 + k * (i % 2)
white += i // 2 + (1 - k) * (i % 2)
k = 1 - k
print(min(black, white)) | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR VAR VAR BIN_OP BIN_OP VAR NUMBER BIN_OP VAR BIN_OP VAR NUMBER VAR BIN_OP BIN_OP VAR NUMBER BIN_OP BIN_OP NUMBER VAR BIN_OP VAR NUMBER ASSIGN VAR BIN_OP ... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.