Dataset Viewer
_id
stringlengths 2
5
| partition
stringclasses 2
values | text
stringlengths 5
289k
| language
stringclasses 1
value | meta_information
dict | title
stringclasses 1
value |
|---|---|---|---|---|---|
d1
|
train
|
for _ in range(int(input())):
n = int(input())
mass = []
zo = 0
oz = 0
zz = 0
oo = 0
ozs = []
zos = []
ozss = set()
zoss = set()
for j in range(n):
k = input()
mass.append(k)
if k[0] == '0' and k[-1] == '1':
zoss.add(k)
zos.append(j + 1)
zo += 1
elif k[0] == '1' and k[-1] == '0':
ozss.add(k)
ozs.append(j + 1)
oz += 1
elif k[0] == '0' and k[-1] == '0':
zz += 1
else:
oo += 1
if zz and oo and not oz and not zo:
print(-1)
continue
else:
if zo > oz:
print((zo - oz) // 2)
ans = []
need = (zo - oz) // 2
i = 0
while need:
zzz = mass[zos[i] - 1][len(mass[zos[i] - 1]) - 1:: -1]
if zzz not in ozss:
ans.append(zos[i])
need -= 1
i += 1
print(*ans)
else:
print((oz - zo) // 2)
ans = []
need = (oz - zo) // 2
i = 0
while need:
zzz = mass[ozs[i] - 1][len(mass[ozs[i] - 1]) - 1:: -1]
if zzz not in zoss:
ans.append(ozs[i])
need -= 1
i += 1
print(*ans)
|
PYTHON
|
{
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/1259/D"
}
| |
d4
|
train
|
def solve():
n, k = map(int,input().split())
lst = list(map(int,input().split()))
lst.sort()
ans = 0
for i in range(n - k - 1, n):
ans += lst[i]
print(ans)
for i in range(int(input())):
solve()
|
PYTHON
|
{
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/1430/B"
}
| |
d7
|
train
|
import sys
input = sys.stdin.readline
for f in range(int(input())):
n,m=list(map(int,input().split()))
neig=[0]*n
for i in range(n):
neig[i]=[0]
for i in range(m):
a,b=list(map(int,input().split()))
a-=1
b-=1
neig[a][0]+=1
neig[a].append(b)
lev=[1]*n
for i in range(n):
for j in range(1,neig[i][0]+1):
x=lev[i]+1
if x==4:
x=1
lev[neig[i][j]]=max(lev[neig[i][j]],x)
sol=0
s=[]
for i in range(n):
if lev[i]==3:
sol+=1
s.append(i+1)
print(sol)
print(*s)
|
PYTHON
|
{
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/1368/E"
}
| |
d10
|
train
|
for _ in range(int(input())):
s = input()
p = [i for i in s.split("0") if i!=""]
p.sort(reverse=True)
ans = 0
for i in range(0,len(p),2):
ans+=len(p[i])
print(ans)
|
PYTHON
|
{
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/1398/B"
}
| |
d13
|
train
|
from math import *
mod = 1000000007
for zz in range(int(input())):
n = int(input())
a = [ int(i) for i in input().split()]
b = [int(i) for i in input().split()]
ha = True
hp = False
hm = False
for i in range(n):
if b[i] != a[i]:
if b[i] > a[i]:
if (hp):
pass
else:
ha = False
break
else:
if (hm):
pass
else:
ha = False
break
if a[i] > 0:
hp = True
elif a[i] < 0:
hm = True
if ha:
print('YES')
else:
print('NO')
|
PYTHON
|
{
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/1333/B"
}
| |
d16
|
train
|
from math import *
zzz = int(input())
for zz in range(zzz):
a, b, x, y = list(map(int, input().split()))
print(max(x*b, (a-x-1)*b, y*a, (b - y - 1)*a))
|
PYTHON
|
{
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/1315/A"
}
| |
d19
|
train
|
import math
T = int(input())
for _ in range(T):
n = int(input())
print(1/math.tan(math.pi/2/n))
|
PYTHON
|
{
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/1354/C1"
}
| |
d22
|
train
|
t = int(input())
for _ in range(t):
n = list(input().strip())
s = list(map(int, input().strip().split()))
check = set(s)
found = False
for i in range(1, 1025):
newset = set([e^i for e in s])
if check == newset:
print(i)
found = True
break
if not found:
print(-1)
|
PYTHON
|
{
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/1362/B"
}
| |
d25
|
train
|
for _ in range(int(input())):
d=int(input())
anws=False
if d**2>=4*d:
root=(d**2-4*d)**0.5
a=(d+root)/2
b=(d-root)/2
anws=True
if anws:
print("Y {:.9f} {:.9f}".format(a,b))
else:
print("N")
|
PYTHON
|
{
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/1076/C"
}
| |
d28
|
train
|
tests = int(input())
for test in range(tests):
n = int(input())
a = [int(i) for i in input().split()]
d = {}
for i in range(n):
s = 0
while a[i] % 2 == 0:
a[i] //= 2
s += 1
if a[i] in list(d.keys()):
d[a[i]] = max(s, d[a[i]])
else:
d[a[i]] = s
s = 0
for i in list(d.keys()):
s += d[i]
print(s)
|
PYTHON
|
{
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/1259/B"
}
| |
d31
|
train
|
t = int(input())
for i in range(t):
n = int(input())
s = input()
ans = 0
for y in range(1, n):
if s[y] == s[y-1]:
ans += 1
print((ans + ans % 2) // 2)
|
PYTHON
|
{
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/1437/B"
}
| |
d34
|
train
|
t=int(input())
for i in range(t):
n=int(input())
print(2)
print(n-1,n)
for i in range(n-2,0,-1):
print(i,i+2)
|
PYTHON
|
{
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/1430/C"
}
| |
d37
|
train
|
n=int(input())
a=list(map(int,input().split()))
k=[]
for i in range(n):
for j in range(a[i]):
k.append(i+1)
m=int(input())
b=list(map(int,input().split()))
for i in b:
print(k[i-1])
|
PYTHON
|
{
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/474/B"
}
| |
d40
|
train
|
t=int(input())
for tt in range(t):
a,b,p=map(int,input().split())
s=input()
n=len(s)
cost = [0]*n
cost[-1] = 0
typ = ''
i=n-2
while i>=0:
if s[i]==typ:
cost[i] = cost[i+1]
else:
typ = s[i]
cost[i] = cost[i+1] + (a if typ=='A' else b)
i-=1
i=0
while cost[i] > p:
i+=1
print(i+1)
|
PYTHON
|
{
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/1315/B"
}
| |
d43
|
train
|
LOG = 20
def solve(s):
n = len(s)
res = 0
z = 0
for t in range(0, n):
if s[t] == '0':
z += 1
continue
for l in range(1, min(LOG, n - t + 1)):
x = int(s[t:t+l], 2)
# print(l, t, x, l + z)
if l + z >= x:
res += 1
# print(t, l, x, res, z)
z = 0
return res
t = int(input())
while t > 0:
t -= 1
s = input()
print(solve(s))
|
PYTHON
|
{
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/1217/C"
}
| |
d46
|
train
|
import sys
import random
from fractions import Fraction
from math import *
def input():
return sys.stdin.readline().strip()
def iinput():
return int(input())
def finput():
return float(input())
def tinput():
return input().split()
def linput():
return list(input())
def rinput():
return list(map(int, tinput()))
def fiinput():
return list(map(float, tinput()))
def rlinput():
return list(map(int, input().split()))
def trinput():
return tuple(rinput())
def srlinput():
return sorted(list(map(int, input().split())))
def NOYES(fl):
if fl:
print("NO")
else:
print("YES")
def YESNO(fl):
if fl:
print("YES")
else:
print("NO")
def main():
n = iinput()
#k = iinput()
#m = iinput()
#n = int(sys.stdin.readline().strip())
#n, k = rinput()
#n, m = rinput()
#m, k = rinput()
#n, k, m = rinput()
#n, m, k = rinput()
#k, n, m = rinput()
#k, m, n = rinput()
#m, k, n = rinput()
#m, n, k = rinput()
#q = srlinput()
#q = linput()
s, t, res = 1, 1, 0
while s <= n:
res += 1
n -= s
t = 2 * t + 1
s = (t * (t + 1)) // 2
print(res)
for i in range(iinput()):
main()
|
PYTHON
|
{
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/1419/B"
}
| |
d49
|
train
|
for haaghfj in range(int(input())):
x,y,k = list(map(int,input().split()))
print(k + (y * k + k - 1 +x-2) // (x - 1))
|
PYTHON
|
{
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/1418/A"
}
| |
d52
|
train
|
def main():
t = int(input())
for z in range(t):
n, k, d1, d2 = map(int, input().split())
if n % 3 != 0:
print('no')
continue
f = 0
for i in [-1, +1]:
for j in [-1, +1]:
w = (k - i * d1 - j * d2)
if f == 0 and (w % 3 == 0) and (n//3)>=(w//3)>=0 and (n//3)>=(w//3 + i * d1)>=0 and (n//3)>=(w//3 + j * d2)>=0:
print('yes')
f = 1
if f == 0:
print('no')
main()
|
PYTHON
|
{
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/451/C"
}
| |
d55
|
train
|
for i in range(int(input())):
n=int(input())
s=list(map(int,input().split()))
a=0
for i in s:
if i<2049:a+=i
if a<2048:print("NO")
else:print("YES")
|
PYTHON
|
{
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/1221/A"
}
| |
d58
|
train
|
t = int(input())
for case in range(t):
n = int(input())
arr = list(map(int, input().split()))
if arr[-1] > arr[0]:
print("YES")
else:
print("NO")
|
PYTHON
|
{
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/1375/C"
}
| |
d61
|
train
|
n = int(input())
for _ in range(n):
a, b = list(map(int, input().split()))
print(a ^ b)
|
PYTHON
|
{
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/1421/A"
}
| |
d64
|
train
|
def solve():
n, k = map(int,input().split())
lst1 = list(map(int,input().split()))
lst1.sort(reverse=True)
ind = 0
ans = 0
lst2 = list(map(int,input().split()))
lst2.sort()
for i in range(k):
lst2[i] -= 1
if lst2[i] == 0: ans += lst1[ind]
ans += lst1[ind]
ind += 1
lst2.sort()
for i in lst2:
if i != 0:
ind += i - 1
ans += lst1[ind]
ind += 1
print(ans)
for i in range(int(input())):
solve()
|
PYTHON
|
{
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/1369/C"
}
| |
d70
|
train
|
t = int(input())
for case in range(t):
a, b = list(map(int, input().split()))
s = input()
z = 10000
total = 0
act = False
for i in range(len(s)):
cur = s[i]
if cur == '0':
z += 1
act = False
else:
if not act:
act = True
total += min(a, b * z)
z = 0
print(total)
|
PYTHON
|
{
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/1443/B"
}
| |
d76
|
train
|
import math
T = int(input())
for _ in range(T):
n = int(input())
diags = 1/math.sin(math.pi/2/n)
print(diags * math.cos(math.pi/4/n))
|
PYTHON
|
{
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/1354/C2"
}
| |
d79
|
train
|
import sys
q = int(sys.stdin.readline().strip())
for t in range(0, q):
n, m = list(map(int, sys.stdin.readline().strip().split()))
L = []
R = [0] * n
C = [0] * m
for i in range (0, n):
L.append(sys.stdin.readline().strip())
for j in range (0, m):
if L[i][j] != "*":
R[i] = R[i] + 1
C[j] = C[j] + 1
ans = n + m - 1
for i in range (0, n):
for j in range (0, m):
x = 0
if L[i][j] != "*":
x = -1
ans = min([ans, R[i]+C[j]+x])
print(ans)
|
PYTHON
|
{
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/1194/B"
}
| |
d82
|
train
|
for _ in range(int(input())):
a, b, c = input(), input(), input()
n = len(a)
ok = True
for i in range(n):
if c[i] not in [a[i], b[i]]:
ok = False
print('YES' if ok else 'NO')
|
PYTHON
|
{
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/1301/A"
}
| |
d85
|
train
|
# encoding: utf-8
from sys import stdin
def solve(a):
# root node of tries denotes empty stack
stack = [None]
node_stack = [[1, {}]]
trie = node_stack[-1]
counter = 0
for i in range(len(a)):
el = a[i]
if len(stack) == 0 or stack[-1] != el:
current_node = node_stack[-1]
stack.append(el)
if el not in current_node[1]:
current_node[1][el] = [0, {}]
next_node = current_node[1][el]
next_node[0] += 1
node_stack.append(next_node)
else:
# just go up in trie
stack.pop()
node_stack.pop()
node_stack[-1][0] += 1
value = node_stack[-1][0]
counter -= (((value - 1) * (value - 2)) // 2)
counter += (((value) * (value - 1)) // 2)
return counter
q = int(stdin.readline().strip())
for _ in range(q):
n = int(stdin.readline().strip())
a = [int(i) for i in stdin.readline().strip().split()]
print(solve(a))
|
PYTHON
|
{
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/1241/F"
}
| |
d88
|
train
|
import sys
readline = sys.stdin.readline
readlines = sys.stdin.readlines
ns = lambda: readline().rstrip()
ni = lambda: int(readline().rstrip())
nm = lambda: map(int, readline().split())
nl = lambda: list(map(int, readline().split()))
prn = lambda x: print(*x, sep='\n')
def gcd(a, b):
while b:
a, b = b, a%b
return a
def solve():
m, d, w = nm()
g = w // gcd(d-1, w)
c = min(m, d)
v = c // g
ans = v * (v - 1) // 2 * g
ans += (c - g * v) * v
print(ans)
return
# solve()
T = ni()
for _ in range(T):
solve()
|
PYTHON
|
{
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/1389/E"
}
| |
d91
|
train
|
import math
from collections import deque
from sys import stdin, stdout
from string import ascii_letters
import sys
letters = ascii_letters
input = stdin.readline
#print = stdout.write
for _ in range(int(input())):
n = int(input())
arr = list(map(int, input().split()))
can = list(map(int, input().split()))
vals = sorted([i for i in range(n) if not can[i]], key=lambda x: -arr[x])
res = [0] * n
last = 0
for i in range(n):
if can[i]:
res[i] = arr[i]
else:
res[i] = arr[vals[last]]
last += 1
print(*res)
|
PYTHON
|
{
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/1418/B"
}
| |
d94
|
train
|
for tc in range(int(input())):
n,m = list(map(int, input().split()))
al = list(map(int, input().split()))
bl = list(map(int, input().split()))
aidx = {}
for i,e in enumerate(al):
aidx[e]=i
midx = -1
res = 0
for i,e in enumerate(bl):
idx = aidx[e]
if idx <= midx:
res += 1
else:
res += 2*(idx-i)+1
midx = max(midx, idx)
print(res)
|
PYTHON
|
{
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/1279/C"
}
| |
d97
|
train
|
import sys
from operator import itemgetter
def count(a, b, num_a, num_b, cur_time):
current_result = 0
#print('count time = ', cur_time, "num_a =", num_a, 'num_b = ', num_b)
if num_a * a + num_b * b <= cur_time and cur_time >= 0:
cur_time -= num_a * a + num_b * b
current_result = num_a + num_b
if num_a < total_a:
if (total_a - num_a) * a <= cur_time:
current_result += total_a - num_a
cur_time -= (total_a - num_a) * a
#print(1)
else:
current_result += cur_time // a
cur_time -= a *(cur_time // a)
#print(2)
if num_b < total_b:
if (total_b - num_b) * b <= cur_time:
current_result += total_b - num_b
#print(3)
else:
#print(4)
current_result += cur_time // b
#print('current_result = ', current_result)
return current_result
def solve(n, T, a, b, tasks, total_a, total_b):
tasks = sorted(tasks)
#print(tasks)
result = 0
num_a = 0
num_b = 0
for i in range(len(tasks)):
time, t = tasks[i]
#print(tasks[i])
cur_time = time - 1
#print('cur time = ', cur_time)
current_result = count(a, b, num_a, num_b, cur_time)
result = max(current_result, result)
if t == 0:
num_a += 1
else:
num_b += 1
if i == len(tasks) - 1 or tasks[i + 1][1] != tasks[i][1]:
result = max(result, count(a, b, num_a, num_b, cur_time))
#print("i =", i, "result = ", result)
result = max(result, count(a, b, total_a, total_b, T))
return result
q = int(input())
for i in range(q):
n, T, a, b = list(map(int, input().split()))
types = list(map(int, input().split()))
total_a, total_b = 0, 0
for t in types:
if t == 0:
total_a += 1
else:
total_b += 1
t = list(map(int, input().split()))
#print(t)
#print(types)
tasks = list(zip(t, types))
print(solve(n, T, a, b, tasks, total_a, total_b))
|
PYTHON
|
{
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/1282/C"
}
| |
d100
|
train
|
for _ in range(int(input())):
# a, b = map(int, input().split())
n = int(input())
# arr = list(map(int, input().split()))
s = input()
l = 0
r = n - 1
if s.count('0') == n:
print(s)
continue
if s.count('1') == n:
print(s)
continue
while s[l] == '0':
l += 1
while s[r] == '1':
r -= 1
if r <= l:
print(s)
continue
print(l * '0' + '0' + (n - r - 1) * '1')
|
PYTHON
|
{
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/1369/B"
}
| |
d103
|
train
|
s = []
for i in range(1, 10):
k = 0
for l in range(1, 10):
k *= 10
k += i
s.append(k)
s.sort()
q = int(input())
while q:
n = int(input())
l = 0
r = len(s)
while l + 1 < r:
m = (l + r) // 2
if s[m] <= n:
l = m
else:
r = m
print(r)
q -= 1
|
PYTHON
|
{
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/1259/A"
}
| |
d106
|
train
|
import math
t = int(input())
for test in range(t):
n,k = map(int,input().split())
A = list(map(int,input().split()))
A.sort()
ans = 0
for i in range(1,n):
if(A[i]>k):
ans = 0
break
rem = k-A[i]
ans+=rem//A[0]
print(ans)
|
PYTHON
|
{
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/1417/A"
}
| |
d109
|
train
|
for _ in range(int(input())):
n=int(input())
li=list(map(int,input().split()))
ans=0
for i in range(n):
if li[i]>=i:
ans+=1
else:
break
for i in range(n):
if li[n-1-i]>=i:
ans+=1
else:
break
if ans>n:
print("Yes")
else:
print("No")
|
PYTHON
|
{
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/1291/B"
}
| |
d112
|
train
|
#!/usr/bin/env python
# coding:utf-8
# Copyright (C) dirlt
from sys import stdin
def run(n, m, pixels):
ans = 1 << 30
acc = [[0] * (m + 1) for _ in range(n + 1)]
for i in range(n):
for j in range(m):
acc[i + 1][j + 1] = acc[i + 1][j] + int(pixels[i][j])
for j in range(m):
acc[i + 1][j + 1] += acc[i][j + 1]
# print(acc)
for k in range(2, max(n, m) + 1):
r, c = (n + k - 1) // k, (m + k - 1) // k
res = 0
for i in range(r):
for j in range(c):
x, y = i * k, j * k
x2, y2 = min(x + k - 1, n - 1), min(y + k - 1, m - 1)
zero = acc[x2 + 1][y2 + 1] - acc[x][y2 + 1] - acc[x2 + 1][y] + acc[x][y]
# print(x, y, k, zero, k * k - zero)
res += min(zero, k * k - zero)
# print(k, res)
ans = min(ans, res)
print(ans)
def main():
n, m = [int(x) for x in stdin.readline().split()]
pixels = []
for i in range(n):
pixels.append(stdin.readline().strip())
run(n, m, pixels)
def __starting_point():
import os
if os.path.exists('tmp.in'):
stdin = open('tmp.in')
main()
__starting_point()
|
PYTHON
|
{
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/838/A"
}
| |
d115
|
train
|
import sys
input = sys.stdin.readline
import bisect
t=int(input())
for testcases in range(t):
n=int(input())
A=list(map(int,input().split()))
m=int(input())
PS=[tuple(map(int,input().split())) for i in range(m)]
PS.sort()
K=[PS[-1]]
for a,b in PS[::-1][1:]:
if b<=K[-1][1]:
continue
else:
K.append((a,b))
K.reverse()
ANS=1
count=0
countmax=n+1
LEN=len(K)
for a in A:
x=bisect.bisect_left(K,(a,0))
if x==LEN:
print(-1)
break
elif K[x][1]>=count+1 and countmax>=count+1:
count+=1
countmax=min(countmax,K[x][1])
else:
ANS+=1
count=1
countmax=K[x][1]
#print(a,count,countmax,ANS)
else:
print(ANS)
|
PYTHON
|
{
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/1257/D"
}
| |
d118
|
train
|
from sys import stdin
input = stdin.readline
tests = int(input())
for test in range(tests):
n, m = list(map(int, input().split()))
a = [[0] * m for _ in range(n)]
r = [[int(i) for i in input().split()] for _ in range(n)]
c = [[int(i) for i in input().split()] for _ in range(m)]
z = [[-1, -1] for _ in range(n * m + 1)]
for i in range(n):
for j in range(m):
z[r[i][j]][0] = j
for i in range(m):
for j in range(n):
z[c[i][j]][1] = j
for i in range(1, n * m + 1):
a[z[i][1]][z[i][0]] = i
for i in a:
print(' '.join([str(j) for j in i]))
|
PYTHON
|
{
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/1413/B"
}
| |
d121
|
train
|
import sys
input = sys.stdin.readline
t=int(input())
def calc(x):
return x*(x+1)//2
for test in range(t):
n,m=list(map(int,input().split()))
ANS=calc(n)
k=n-m
q,mod=divmod(k,m+1)
ANS-=calc(q+1)*mod+calc(q)*(m+1-mod)
print(ANS)
|
PYTHON
|
{
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/1301/C"
}
| |
d124
|
train
|
import math
class Solution:
def numMusicPlaylists(self, N: int, L: int, K: int) -> int:
s=0
c=0
r=0
x=math.factorial(N)
while(True):
c=x*((N-r-K)**(L-K))*(-1)**(r)//(math.factorial(N-r-K)*math.factorial(r))
if(c!=0):
s=(s+c)%(10**9+7)
r+=1
else:
return s
|
PYTHON
|
{
"starter_code": "\nclass Solution:\n def numMusicPlaylists(self, N: int, L: int, K: int) -> int:\n ",
"url": "https://leetcode.com/problems/number-of-music-playlists/"
}
| |
d127
|
train
|
class Solution:
def maxFreq(self, s: str, maxLetters: int, minSize: int, maxSize: int) -> int:
n = len(s)
count = collections.Counter(s[i : i + minSize] for i in range(0, n - minSize + 1))
res = 0
for k, v in count.items():
if len(set(k)) <= maxLetters:
res = max(res, v)
return res
|
PYTHON
|
{
"starter_code": "\nclass Solution:\n def maxFreq(self, s: str, maxLetters: int, minSize: int, maxSize: int) -> int:\n ",
"url": "https://leetcode.com/problems/maximum-number-of-occurrences-of-a-substring/"
}
| |
d130
|
train
|
class Solution:
def maxScoreSightseeingPair(self, A: List[int]) -> int:
curmaxsight = A[0] - 1
curmaxpair = 0
for sight in A[1:]:
if sight + curmaxsight > curmaxpair:
curmaxpair = sight + curmaxsight
if sight > curmaxsight:
curmaxsight = sight
curmaxsight -= 1
return curmaxpair
|
PYTHON
|
{
"starter_code": "\nclass Solution:\n def maxScoreSightseeingPair(self, A: List[int]) -> int:\n ",
"url": "https://leetcode.com/problems/best-sightseeing-pair/"
}
| |
d133
|
train
|
class Solution:
def mincostTickets(self, days: List[int], costs: List[int]) -> int:
dp = [0] + [-1 for i in range(days[-1])]
for day in days:
dp[day] = 0
for i in range(1, len(dp)):
if dp[i] == -1:
dp[i] = dp[i-1]
else:
dp[i] = min(
dp[i-1] + costs[0],
dp[max(i-7, 0)] + costs[1],
dp[max(i-30, 0)] + costs[2],
)
return dp[-1]
|
PYTHON
|
{
"starter_code": "\nclass Solution:\n def mincostTickets(self, days: List[int], costs: List[int]) -> int:\n ",
"url": "https://leetcode.com/problems/minimum-cost-for-tickets/"
}
| |
d136
|
train
|
class Solution:
def validateStackSequences(self, pushed: List[int], popped: List[int]) -> bool:
j = 0
l = []
for i in pushed:
l.append(i)
while l and (l[-1] == popped[j]):
l.pop()
j += 1
if l:
return False
return True
|
PYTHON
|
{
"starter_code": "\nclass Solution:\n def validateStackSequences(self, pushed: List[int], popped: List[int]) -> bool:\n ",
"url": "https://leetcode.com/problems/validate-stack-sequences/"
}
| |
d139
|
train
|
class Solution:
def getMaxLen(self, nums: List[int]) -> int:
maxx = 0
nums.append(0)
# starting position
# where we find a 0
i = -1
minusarr = []
for j,n in enumerate(nums):
if n == 0:
# now figure out previous ones
tot = j-i-1
if not minusarr or len(minusarr)%2 == 0:
maxx = max(maxx, tot)
else:
# drop the first or last 0
left = minusarr[0]-i
right = j-minusarr[-1]
maxx = max(maxx, tot - min(left, right))
# reinitiate
minusarr = []
i = j
elif n < 0:
minusarr.append(j)
return maxx
|
PYTHON
|
{
"starter_code": "\nclass Solution:\n def getMaxLen(self, nums: List[int]) -> int:\n ",
"url": "https://leetcode.com/problems/maximum-length-of-subarray-with-positive-product/"
}
| |
d142
|
train
|
class Solution:
def numRescueBoats(self, people: List[int], limit: int) -> int:
people.sort()
lo = 0
hi = len(people) - 1
count = 0
while lo <= hi:
count += 1
if people[lo] + people[hi] <= limit:
lo += 1
hi -= 1
return count
|
PYTHON
|
{
"starter_code": "\nclass Solution:\n def numRescueBoats(self, people: List[int], limit: int) -> int:\n ",
"url": "https://leetcode.com/problems/boats-to-save-people/"
}
| |
d145
|
train
|
class Solution:
def minSteps(self, n):
"""
:type n: int
:rtype: int
"""
primeFactors=[]
for i in range(2,int(n**.5)+1):
while n%i==0:
primeFactors.append(i)
n=n//i
if n>1:
primeFactors.append(n)
return sum(primeFactors)
|
PYTHON
|
{
"starter_code": "\nclass Solution:\n def minSteps(self, n: int) -> int:\n ",
"url": "https://leetcode.com/problems/2-keys-keyboard/"
}
| |
d148
|
train
|
class Solution:
def maxPerformance(self, n: int, speed: List[int], efficiency: List[int], k: int) -> int:
mod = 10**9+7
order = sorted(range(n), key=lambda i: efficiency[i], reverse=True)
heap = []
filled = 0
rec = 0
speed_sum = 0
for i in order:
if filled < k:
heapq.heappush(heap, speed[i])
filled += 1
speed_sum += speed[i]
else:
removed = heapq.heappushpop(heap, speed[i])
speed_sum += speed[i] - removed
rec = max(rec, speed_sum*efficiency[i])
return rec %mod
|
PYTHON
|
{
"starter_code": "\nclass Solution:\n def maxPerformance(self, n: int, speed: List[int], efficiency: List[int], k: int) -> int:\n ",
"url": "https://leetcode.com/problems/maximum-performance-of-a-team/"
}
| |
d151
|
train
|
class Solution:
def partitionDisjoint(self, A: List[int]) -> int:
biggest = A[0]
newbiggest = A[0]
lenL = 1
total = 1
for itr in A[1:]:
total += 1
if itr < biggest:
lenL = total
biggest = newbiggest
else:
if itr > newbiggest:
newbiggest = itr
return lenL
|
PYTHON
|
{
"starter_code": "\nclass Solution:\n def partitionDisjoint(self, A: List[int]) -> int:\n ",
"url": "https://leetcode.com/problems/partition-array-into-disjoint-intervals/"
}
| |
d154
|
train
|
class Solution:
def makesquare(self, nums):
"""
:type nums: List[int]
:rtype: bool
"""
if len(nums) < 4:
return False
length = sum(nums)
if length % 4:
return False
length = (int) (length / 4)
nums.sort(reverse=True)
#print(nums)
if length < nums[0]:
return False
elif length == nums[0]:
stack = list([(set([0]), 1, length, 1)])
else:
stack = list([(set([0]), 1, length - nums[0], 2)]) # (usedIndexSet, searchStartFromIndex, target, remainRounds)
while stack:
usedSet, startIndex, target, remainRounds = stack.pop()
#print(usedSet, set(range(0, len(nums))) - usedSet, target, remainRounds)
for i in range(len(nums) - 1, startIndex - 1, -1):
if i in usedSet:
continue
num = nums[i]
if num < target and i + 1 < len(nums):
stack.append((usedSet | {i}, i+1, target - num, remainRounds))
elif num == target:
if remainRounds == 0:
return True
else:
stack.append((usedSet | {i}, 1, length, remainRounds - 1))
# Else not valid path, continue
return False
|
PYTHON
|
{
"starter_code": "\nclass Solution:\n def makesquare(self, nums: List[int]) -> bool:\n ",
"url": "https://leetcode.com/problems/matchsticks-to-square/"
}
| |
d157
|
train
|
import sys
def dp(s1, s2, i, j, mem):
if (i, j) in mem:
return mem[(i, j)]
elif i >= len(s1) and j >= len(s2):
res = ''
elif i >= len(s1):
res = s2[j:]
elif j >= len(s2):
res = s1[i:]
else:
if s1[i] == s2[j]:
res = s1[i] + dp(s1, s2, i+1, j+1, mem)
else:
left = s1[i] + dp(s1, s2, i+1, j, mem)
right = s2[j] + dp(s1, s2, i, j+1, mem)
if len(left) < len(right):
res = left
else:
res = right
mem[(i, j)] = res
return res
class Solution:
def shortestCommonSupersequence(self, str1: str, str2: str) -> str:
if len(str1) == len(str2) and len(str1) == 1000:
return 'xjatuwbmvsdeogmnzorndhmjoqnrqjnhmfueifqwleggfbctttiqkezrltzyeqvqemfoikpzgotfyghxkyzdenhftafiepwrvmrovwtpzzsyuiseumzmywongllqmtvsdsoptwammerovabtgemkhpowndejvbuwbporfyroknrjoekdgqhqlgzxifiswevpepegmyhnxagjtsqlradgcciaecsvbpgqjzwtdebctmtallzyuvxkdztoavfxysgejqgrqkliixuvnagwzmassthjecvkfzmyongloclemvjnxkcwqqvgrzpsnsrwnigjmxyokbthtkesuawirecfugzrbydifsupuqanetgunwolqmupndhcapzxvduqwmzidatefhvpfmaqmzzzfjapdxgmddsdlhyoktbdeugqoyepgbmjkhmfjztsxpgojqbfspedhzrxavmpjmwmhngtnlduynskpapvwlprzruadbmeeqlutkwdvgyzghgprqcdgqjjbyefsujnnssfmqdsvjhnvcotynidziswpzhkdszbblmrustoxwtilhkoawcrpatbypvkmajumsthbebdxqqrpphuncthosljxxvfaeidbozayekxrolwezqtfzlifyzqcvvxmmnehrcskstepwshupglzgmbretpmyehtavnwzyunsxegmbtzjflnqmfghsvwpbknqhczdjlzibhrlmnouxrljwabwpxkeiedzoomwhoxuhffpfinhnairblcayygghzqmotwrywqaxdwetyvvgohmujneqlzurxcpnwdhipldofyqvfdhrggurbszqeqoxdurlofkqqnunrjomszjimrxbqyzyagyoptfzakolkieayzojwkryidtctemtesuhbzczzvhlbbhacnubdifjjocporuzuevsofbuevuxhgiexsmckibyfntnfcxhqgaoqyhfwqdakyobcooubdvypxjjtsrqarqagogrnaxeugzdmapyaggknksrfdrmuwqnoxrctnqspsztnyszhwqgdqjxxechxrsmbyhdlkwkvtlkdbjnmzgvdmhvbllqqlcemkqxopyixdlldcomhnmvnsaftphjdqkyjrrjqqqpkdgnmmelrdcscbwhtyhugieuppqqtwychtpjmlaeoxsckdlhlzyitomjczympqqmnisxzztlliydwtxhddvtvpleqdwamfbnhhkszsfgfcdvakysqmmausdvihopbvygqdktcwesudmhffagxmuayoalovskvcgetapucehntotdqbfxlqhkrolvxfzrtrmrfvjqoczkfaexwxsvujizcficzeuqflegwpbuuoyfuoovycmahhpzodstmpvrvkzxxtrsdsxjuuecpjwimbutnvqtxiraphjlqvesaxrvzywxcinlwfslttrgknbpdlscvvtkfqfzwudspewtgjposiixrfkkeqmdbvlmpazzjnywxjyaquilxrqnpdvinaegpccnnweuobqvgxnomulzoejantsalzyjjpnsrqkxemyivcatemoluhqngifychonbnizcjrlmuywxtlezdwnkkztancarphldmwhnkdguheloqyywrxrzjganyevjtrzofmtpuhifoqnokglbdeyshpodpmdcnhbccqtzxmimp'
sys.setrecursionlimit(10**6)
return dp(str1, str2, 0, 0, {})
|
PYTHON
|
{
"starter_code": "\nclass Solution:\n def shortestCommonSupersequence(self, str1: str, str2: str) -> str:\n ",
"url": "https://leetcode.com/problems/shortest-common-supersequence/"
}
| |
d160
|
train
|
from collections import deque
class Solution:
def constrainedSubsetSum(self, nums, k):
N, queue = len(nums), deque()
dp = [val for val in nums]
for i, val in enumerate(nums):
if queue and (i - queue[0] > k):
queue.popleft()
if queue and dp[queue[0]] > 0:
dp[i] += dp[queue[0]]
while queue and dp[i] >= dp[queue[-1]]:
queue.pop()
queue.append(i)
return max(dp)
|
PYTHON
|
{
"starter_code": "\nclass Solution:\n def constrainedSubsetSum(self, nums: List[int], k: int) -> int:\n ",
"url": "https://leetcode.com/problems/constrained-subsequence-sum/"
}
| |
d163
|
train
|
class Solution:
def longestCommonSubsequence(self, a: str, b: str) -> int:
last, current = [0] * (len(b) + 1), [0] * (len(b) + 1)
for i in range(len(a) - 1, -1, -1):
for j in range(len(b) - 1, -1, -1):
if a[i] == b[j]:
current[j] = 1 + last[j + 1]
else:
current[j] = max(last[j], current[j + 1])
last = current
current = [0] * (len(b) + 1)
return last[0]
|
PYTHON
|
{
"starter_code": "\nclass Solution:\n def longestCommonSubsequence(self, text1: str, text2: str) -> int:\n ",
"url": "https://leetcode.com/problems/longest-common-subsequence/"
}
| |
d166
|
train
|
class Solution:
def findLongestWord(self, s, d):
"""
:type s: str
:type d: List[str]
:rtype: str
"""
result = ''
for word in d:
lo = 0
for l in word:
lo = s.find(l, lo)+1
if lo == 0:
break
if lo > 0 and len(word) >= len(result):
if len(word) == len(result):
result = word if word < result else result
else:
result = word
return result
|
PYTHON
|
{
"starter_code": "\nclass Solution:\n def findLongestWord(self, s: str, d: List[str]) -> str:\n ",
"url": "https://leetcode.com/problems/longest-word-in-dictionary-through-deleting/"
}
| |
d169
|
train
|
from collections import Counter
class Solution:
def canConstruct(self, s: str, k: int) -> bool:
if k > len(s): #return False
return False
counter = Counter(s)
odd_counts = 0
for char in counter:
if counter[char] % 2 == 1:
odd_counts += 1
return odd_counts <= k
|
PYTHON
|
{
"starter_code": "\nclass Solution:\n def canConstruct(self, s: str, k: int) -> bool:\n ",
"url": "https://leetcode.com/problems/construct-k-palindrome-strings/"
}
| |
d172
|
train
|
class Solution:
def maxProduct(self, nums):
"""
:type nums: List[int]
:rtype: int
"""
def prod(nums):
#function to calculate product
prod = 1
for i in nums:
prod*=i
return prod
def listsplit(ls1,index):
result = []
st = -1
for i in index:
if i == 0:
st = i
else:
result.append(ls1[st+1:i])
st = i
if st<len(ls1)-1:
result.append(ls1[st+1:])
return result
#main starts here
if not nums:
return 0
if len(nums) == 1:
return nums[0]
#find zeros: if zeros are included the result would be zeros only
result=[]
if 0 in nums:
zeros = [i for i in range(len(nums)) if nums[i] ==0]
sublist = listsplit(nums,zeros)
result.append(0)
else:
sublist = [nums]
#find negative numbers. consider even or odd
sublist = [i for i in sublist if i]
for i in sublist:
if prod(i) <0:
#there is negative number in the list
negative = [j for j in range(len(i)) if i[j] < 0]
left,right = negative[0],negative[-1]
if len(i) == 1:
result_t = i[0]
elif left == 0 or right == len(i) -1:
result_t = max(prod(i[left+1:]),prod(i[:right]))
else:
left_p,right_p = prod(i[:left]),prod(i[right+1:])
if left_p <= right_p:
result_t = prod(i[left+1:])
else:
result_t = prod(i[:right])
else:
result_t = prod(i)
result.append(result_t)
return max(result)
|
PYTHON
|
{
"starter_code": "\nclass Solution:\n def maxProduct(self, nums: List[int]) -> int:\n ",
"url": "https://leetcode.com/problems/maximum-product-subarray/"
}
| |
d178
|
train
|
class Solution:
def minWindow(self, s, t):
"""
:type s: str
:type t: str
:rtype: str
"""
left=-1
right = 0
result = ""
totalMatch = 0
d = {}
for c in t:
d[c] = d.get(c, 0) + 1
for right in range(len(s)):
c = s[right]
d[c] = d.get(c, 0) - 1
# good match
if d[c] >=0:
totalMatch +=1
#over match 可以不移动left
#total match, need to advance left
if totalMatch == len(t):
totalMatch -= 1
left +=1
while d[s[left]]<0:
d[s[left]] += 1
left += 1
# we dec the count here so that next round right need to match one more s[left],
d[s[left]] += 1
if result == "" or len(result) > right - left:
result = s[left: right+1]
return result
|
PYTHON
|
{
"starter_code": "\nclass Solution:\n def minWindow(self, s: str, t: str) -> str:\n ",
"url": "https://leetcode.com/problems/minimum-window-substring/"
}
| |
d181
|
train
|
class Solution:
def minRefuelStops(self, target: int, startFuel: int, stations: List[List[int]]) -> int:
if startFuel >= target: return 0
heap = [] #record the reachable gas for now
stop = 0 #total stops
dist = startFuel #reachable distance
for d, g in stations:
if dist >= target: #if reach target, return
return stop
while heap and dist < d: #make sure we can reach current station by make minimum stops
gas = heapq.heappop(heap)
dist += -gas
stop += 1
if dist < d: #if not reachable, return -1
return -1
heapq.heappush(heap, (-g)) #add current gas to heap for future stop
if dist >= target:
return stop
while heap: #add the rest gas in heap from max to min to reach the target
g = heapq.heappop(heap)
stop += 1
dist += -g
if dist >= target:
return stop
return -1
|
PYTHON
|
{
"starter_code": "\nclass Solution:\n def minRefuelStops(self, target: int, startFuel: int, stations: List[List[int]]) -> int:\n ",
"url": "https://leetcode.com/problems/minimum-number-of-refueling-stops/"
}
| |
d184
|
train
|
class Solution:
def maxDotProduct(self, nums1: List[int], nums2: List[int]) -> int:
# DP(a=index of last, b=index of last) = max of:
# DP(a-1, b)
# DP(a-1, i) + nums1[a] * max_or_min(nums2[i+1:b+1])
# same for b
INF = int(1e9)
n, m = len(nums1), len(nums2)
DP = [-INF] * (m + 1)
NDP = [-INF] * (m + 1)
for a in range(n):
for b in range(m):
el = nums1[a] * nums2[b]
diag = DP[b]
NDP[b + 1] = max(el, DP[b + 1], NDP[b], diag, diag + el)
DP, NDP = NDP, DP
return DP[-1]
|
PYTHON
|
{
"starter_code": "\nclass Solution:\n def maxDotProduct(self, nums1: List[int], nums2: List[int]) -> int:\n ",
"url": "https://leetcode.com/problems/max-dot-product-of-two-subsequences/"
}
| |
d187
|
train
|
class Solution:
def largestNumber(self, cost: List[int], target: int) -> str:
dp = [0] + [-target]*target
for t in range(1, target+1):
dp[t] = max([dp[t-i] for i in cost if i<=t]+[dp[t]]) + 1
if dp[-1]<=0: return '0'
res = ''
for i in range(8, -1, -1):
while target>=cost[i] and dp[target-cost[i]]==dp[target]-1:
res += str(i+1)
target -= cost[i]
return res
|
PYTHON
|
{
"starter_code": "\nclass Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n ",
"url": "https://leetcode.com/problems/form-largest-integer-with-digits-that-add-up-to-target/"
}
| |
d190
|
train
|
class Solution:
def preferences_to_scores(self, preferences):
scores = {}
for u, up in enumerate(preferences):
for s, v in enumerate(up):
scores[(u, v)] = s
return scores
def unhappy_friends(self, scores, a, b):
ret = set()
for ai, aa in enumerate(a):
af = a[1 - ai]
for bi, bb in enumerate(b):
bf = b[1 - bi]
if scores[(aa, bb)] < scores[(aa, af)] and scores[(bb, aa)] < scores[(bb, bf)]:
ret.add(aa)
ret.add(bb)
return ret
def unhappyFriends(self, n: int, preferences: List[List[int]], pairs: List[List[int]]) -> int:
scores = self.preferences_to_scores(preferences)
ret = set()
for i, a in enumerate(pairs):
for j in range(i):
b = pairs[j]
ret |= self.unhappy_friends(scores, a, b)
return len(ret)
|
PYTHON
|
{
"starter_code": "\nclass Solution:\n def unhappyFriends(self, n: int, preferences: List[List[int]], pairs: List[List[int]]) -> int:\n ",
"url": "https://leetcode.com/problems/count-unhappy-friends/"
}
| |
d193
|
train
|
class Solution:
def maxCoins(self, piles: List[int]) -> int:
piles.sort()
i = 0
j = len(piles) - 1
max_coins = 0
for i in range(len(piles) // 3, len(piles), 2):
max_coins += piles[i]
return max_coins
|
PYTHON
|
{
"starter_code": "\nclass Solution:\n def maxCoins(self, piles: List[int]) -> int:\n ",
"url": "https://leetcode.com/problems/maximum-number-of-coins-you-can-get/"
}
| |
d196
|
train
|
class Solution:
def countTriplets(self, A: List[int]) -> int:
counters = [0] * (1 << 16)
counters[0] = len(A)
for num in A:
mask = (~num) & ((1 << 16) - 1)
sm = mask
while sm != 0:
counters[sm] += 1
sm = (sm - 1) & mask
return sum(counters[num1 & num2] for num1 in A for num2 in A)
|
PYTHON
|
{
"starter_code": "\nclass Solution:\n def countTriplets(self, A: List[int]) -> int:\n ",
"url": "https://leetcode.com/problems/triples-with-bitwise-and-equal-to-zero/"
}
| |
d199
|
train
|
class Solution:
def equalSubstring(self, s: str, t: str, maxCost: int) -> int:
dist = [ abs( ord(s[i]) - ord(t[i]) ) for i in range(len(s))]
# i = 0
# cur = 0
# res = 0
# for j in range(len(s)):
# cur += dist[j]
# while cur>maxCost:
# cur -= dist[i]
# i += 1
# res = max(res, j-i+1)
# return res
i = 0
cost = maxCost
for j in range(len(s)):
cost -= dist[j]
if cost < 0:
cost += dist[i]
i += 1
return j-i+1
|
PYTHON
|
{
"starter_code": "\nclass Solution:\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\n ",
"url": "https://leetcode.com/problems/get-equal-substrings-within-budget/"
}
| |
d202
|
train
|
class Solution:
hash = {}
def numTrees(self, n):
"""
:type n: int
:rtype: int
"""
# return base case
if n == 0:
return 1
if n == 1 or n == 2:
return n
# try fetching from hash
try:
return self.hash[n]
except KeyError:
pass
# holds the sum
resSum = 0
# iterate i from 1 to n-1
# should add up (0,4), (1,3), (2,2), (3,1), (4,0)
for i in range(n):
#print(i,n - (i+1))
tempSum = self.numTrees(i) * self.numTrees(n - (i+1))
#print(tempSum)
resSum += tempSum
# append to hash
self.hash[n]=resSum
return resSum
|
PYTHON
|
{
"starter_code": "\nclass Solution:\n def numTrees(self, n: int) -> int:\n ",
"url": "https://leetcode.com/problems/unique-binary-search-trees/"
}
| |
d205
|
train
|
class Solution:
def search(self, nums, target):
"""
:type nums: List[int]
:type target: int
:rtype: int
"""
# left = 0
# right = len(nums) - 1
# while left <= right:
# mid = int((left + right)/2)
# if nums[mid] == target:
# return mid
# elif (nums[right] < target) or (nums[mid] > target and nums[right] > target):
# right = mid - 1
# else:
# left = mid + 1
# return -1
left = 0
right = len(nums) - 1
while left <= right:
mid = int((left + right)/2)
if nums[mid] == target:
return mid
if (nums[left] < nums[mid]):
if (target < nums[left]) or (target > nums[mid]):
left = mid + 1
else:
right = mid - 1
elif (nums[left] > nums[mid]):
if (target < nums[mid]) or (target >= nums[left]):
right = mid - 1
else:
left = mid + 1
else:
if nums[right] == target:
return right
else:
return -1
return -1
|
PYTHON
|
{
"starter_code": "\nclass Solution:\n def search(self, nums: List[int], target: int) -> int:\n ",
"url": "https://leetcode.com/problems/search-in-rotated-sorted-array/"
}
| |
d208
|
train
|
class Solution:
def largestNumber(self, nums):
"""
:type nums: List[int]
:rtype: str
"""
nums = [str(n) for n in nums]
nums.sort(reverse=True)
for i in range(1, len(nums)):
if len(nums[i-1]) > len(nums[i]):
ran = len(nums[i])
j = i
while j-1 >= 0 and nums[j-1][:ran] == nums[j] and nums[j-1]+nums[j]<=nums[j]+nums[j-1]:
nums[j-1], nums[j] = nums[j], nums[j-1]
j -= 1
return str(int(''.join(nums)))
|
PYTHON
|
{
"starter_code": "\nclass Solution:\n def largestNumber(self, nums: List[int]) -> str:\n ",
"url": "https://leetcode.com/problems/largest-number/"
}
| |
d211
|
train
|
class Solution:
def containsNearbyAlmostDuplicate(self, nums, k, t):
"""
:type nums: List[int]
:type k: int
:type t: int
:rtype: bool
"""
if len(nums) < 2 or k <= 0 or t < 0: return False
if t == 0:
visited = set()
for i, n in enumerate(nums):
if n in visited: return True
visited.add(n)
if i >= k: visited.remove(nums[i-k])
return False
bucket = {}
for i, n in enumerate(nums):
b = n // t
if b in bucket: return True
if b+1 in bucket and abs(bucket[b+1]-n) <= t: return True
if b-1 in bucket and abs(bucket[b-1]-n) <= t: return True
bucket[b] = n
if i >= k: del bucket[nums[i-k]//t]
return False
|
PYTHON
|
{
"starter_code": "\nclass Solution:\n def containsNearbyAlmostDuplicate(self, nums: List[int], k: int, t: int) -> bool:\n ",
"url": "https://leetcode.com/problems/contains-duplicate-iii/"
}
| |
d214
|
train
|
class Solution:
def myPow(self, x, n):
"""
:type x: float
:type n: int
:rtype: float
"""
if n == 0:
return 1
if abs(n) == 1:
if n == 1:
return x
else:
return 1/x
if n > 0:
a, b = int(n//2), n%2
else:
a, b = -int(-n//2), -(n%2)
y = self.myPow(x, a)
z = self.myPow(x, b)
return y*y*z
|
PYTHON
|
{
"starter_code": "\nclass Solution:\n def myPow(self, x: float, n: int) -> float:\n ",
"url": "https://leetcode.com/problems/powx-n/"
}
| |
d217
|
train
|
class Solution:
def minNumberOfFrogs(self, croakOfFrogs: str) -> int:
# valid string? can be seperated into full croaks:
### dict of letters. c, r, o, a, k should all be equal, nothing else in
if len(croakOfFrogs)%5!=0 or croakOfFrogs[0]!='c' or croakOfFrogs[-1]!='k':
return -1
letters = {
'c': 0,
'r': 0,
'o': 0,
'a': 0,
'k': 0
}
frogs = 0
temp = 0
for l in croakOfFrogs:
letters[l] += 1
temp = letters['c'] - letters['k']
if temp > frogs:
frogs = temp
c_count = letters['c']
for letter in letters:
if letters[letter] != c_count:
return -1
return frogs
|
PYTHON
|
{
"starter_code": "\nclass Solution:\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\n ",
"url": "https://leetcode.com/problems/minimum-number-of-frogs-croaking/"
}
| |
d220
|
train
|
class Solution:
def longestWPI(self, hours: List[int]) -> int:
ans, count, seen = 0, 0, {}
for i, hour in enumerate(hours):
count = count + 1 if hour > 8 else count - 1
if count > 0:
ans = i + 1
else:
if count not in seen:
seen[count] = i
if count - 1 in seen:
ans = max(ans, i - seen[count - 1])
return ans
|
PYTHON
|
{
"starter_code": "\nclass Solution:\n def longestWPI(self, hours: List[int]) -> int:\n ",
"url": "https://leetcode.com/problems/longest-well-performing-interval/"
}
| |
d223
|
train
|
class Solution:
def lenLongestFibSubseq(self, A: List[int]) -> int:
def getFS(x1, x2):
F = [x1, x2]
while F[-1] <= 1000000000:
F.append(F[-2] + F[-1])
return F
C1 = getFS(1, 0)
C2 = C1[1:]
def getLLFS(x1, x2):
max_len = 2
F = [x1, x2]
xi = x1 + x2
while xi in setA:
max_len += 1
F.append(xi)
xi = F[-2] + F[-1]
if max_len == 6:
print(F)
return max_len
max_len = 2
setA = set(A)
for i in range(len(A)):
for j in range(i+1, len(A)):
x1, x2 = A[i], A[j]
# calculate X_{max_len+1}
if x1 * C1[max_len] + x2 * C2[max_len] > A[-1]:
break
max_len = max(max_len, getLLFS(x1, x2))
if max_len < 3:
return 0
return max_len
|
PYTHON
|
{
"starter_code": "\nclass Solution:\n def lenLongestFibSubseq(self, A: List[int]) -> int:\n ",
"url": "https://leetcode.com/problems/length-of-longest-fibonacci-subsequence/"
}
| |
d226
|
train
|
INF = float('inf')
class Solution:
def pushDominoes(self, dominoes: str) -> str:
n = len(dominoes)
d1 = [-1] * n
d2 = [-1] * n
cnt = INF
for i in range(n - 1, -1, -1):
if dominoes[i] == 'L':
cnt = 0
elif dominoes[i] == '.':
cnt += 1
elif dominoes[i] == 'R':
cnt = INF
d1[i] = cnt
cnt = INF
for i in range(n):
if dominoes[i] == 'R':
cnt = 0
elif dominoes[i] == '.':
cnt += 1
elif dominoes[i] == 'L':
cnt = INF
d2[i] = cnt
ret = []
for i in range(n):
if d1[i] == d2[i]:
ret.append('.')
elif d1[i] < d2[i]:
ret.append('L')
else:
ret.append('R')
return ''.join(ret)
|
PYTHON
|
{
"starter_code": "\nclass Solution:\n def pushDominoes(self, dominoes: str) -> str:\n ",
"url": "https://leetcode.com/problems/push-dominoes/"
}
| |
d229
|
train
|
class Solution:
def maxVowels(self, s: str, k: int) -> int:
n = len(s)
vowel = set(['a','e','i','o','u'])
i=0
res = 0
while i<k:
if s[i] in vowel:
res+=1
i+=1
j=k
i=0
maxV = res
while j<n:
if s[i] in vowel:
res-=1
if s[j] in vowel:
res+=1
i+=1
j+=1
if maxV<res:
maxV = res
return maxV
|
PYTHON
|
{
"starter_code": "\nclass Solution:\n def maxVowels(self, s: str, k: int) -> int:\n ",
"url": "https://leetcode.com/problems/maximum-number-of-vowels-in-a-substring-of-given-length/"
}
| |
d232
|
train
|
class Solution:
def firstMissingPositive(self, nums):
"""
:type nums: List[int]
:rtype: int
"""
nums = sorted(set(nums), key=lambda x: x)
result = 0
for i in range(len(nums)):
if nums[i] <= 0:
continue
elif nums[i] == result + 1:
result += 1
else:
break
return result + 1
|
PYTHON
|
{
"starter_code": "\nclass Solution:\n def firstMissingPositive(self, nums: List[int]) -> int:\n ",
"url": "https://leetcode.com/problems/first-missing-positive/"
}
| |
d235
|
train
|
class Solution:
def minAddToMakeValid(self, S: str) -> int:
if not S:
return 0
stack = []
add = 0
for c in S:
if c == '(':
stack.append(c)
elif c == ')':
if stack:
stack.pop()
else:
add += 1
add += len(stack)
return add
|
PYTHON
|
{
"starter_code": "\nclass Solution:\n def minAddToMakeValid(self, S: str) -> int:\n ",
"url": "https://leetcode.com/problems/minimum-add-to-make-parentheses-valid/"
}
| |
d238
|
train
|
class Solution:
def numSubarraysWithSum(self, pl, S):
ans = 0
if(S == 0):
c = 0
for i in range(len(pl)):
if(pl[i] == 0):
c+=1
else:
c = 0
ans +=c
return ans;
l = [-1]
for i in range(len(pl)):
if(pl[i] == 1 ):
l.append(i)
l.append(len(pl))
ans = 0
for i in range(1,len(l)-S):
ans += (l[i]-l[i-1])*(l[i+S] - l[i+S-1])
return ans
|
PYTHON
|
{
"starter_code": "\nclass Solution:\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\n ",
"url": "https://leetcode.com/problems/binary-subarrays-with-sum/"
}
| |
d241
|
train
|
class Solution:
def frequencySort(self, s):
"""
:type s: str
:rtype: str
"""
counter = collections.Counter(s)
colls = sorted(counter.items(), key=lambda k: k[1], reverse=True)
res = ''
for k, v in colls:
res += k * v
return res
|
PYTHON
|
{
"starter_code": "\nclass Solution:\n def frequencySort(self, s: str) -> str:\n ",
"url": "https://leetcode.com/problems/sort-characters-by-frequency/"
}
| |
d244
|
train
|
class Solution:
def flipgame(self, fronts: List[int], backs: List[int]) -> int:
w = set(fronts[i] for i in range(len(fronts)) if fronts[i] == backs[i])
x = set()
for a in fronts:
if a not in w:
x.add(a)
for a in backs:
if a not in w:
x.add(a)
if not x:
return 0
return min(x)
|
PYTHON
|
{
"starter_code": "\nclass Solution:\n def flipgame(self, fronts: List[int], backs: List[int]) -> int:\n ",
"url": "https://leetcode.com/problems/card-flipping-game/"
}
| |
d247
|
train
|
class Solution:
def replaceWords(self, dt, sentence):
"""
:type dict: List[str]
:type sentence: str
:rtype: str
"""
trie = {}
for w in dt:
t = trie
for c in w:
if c not in t: t[c] = {}
t = t[c]
t['#'] = w
# result = []
# for word in sentence.split():
# result.append(self.replace(word, trie))
# return " ".joinresult
# OR
return " ".join([ self.replace(i, trie) for i in sentence.split() ])
def replace( self, word, trie ):
cur = trie
for letter in word:
if letter not in cur: break
cur = cur[letter]
if "#" in cur:
return cur['#']
return word
setenceAsList = sentence.split(" ")
for i in range(len(setenceAsList)):
for j in dt:
if setenceAsList[i].startswith(j):
setenceAsList[i] = j
return " ".join(setenceAsList)
arrs = sentence.split()
for i in range(len(arrs)):
w = arrs[i]
for j in range(len(arrs[i])):
cur = w[:j]
if cur in dt:
arrs[i] = cur
break
return ' '.join(arrs)
|
PYTHON
|
{
"starter_code": "\nclass Solution:\n def replaceWords(self, dictionary: List[str], sentence: str) -> str:\n ",
"url": "https://leetcode.com/problems/replace-words/"
}
| |
d250
|
train
|
class Solution:
def numMagicSquaresInside(self, grid: List[List[int]]) -> int:
# slide window and call isMagicSquare
if len(grid) < 3 or len(grid[0]) < 3:
return 0
rows = len(grid)
cols = len(grid[0])
magic_squares = 0
for i in range(rows - 2):
for j in range(cols - 2):
window = [tmp[j:j + 3] for tmp in grid[i: i + 3]]
if self.isMagicSquare(window):
magic_squares += 1
return magic_squares
def isMagicSquare(self, square: List[List[int]]) -> bool:
target = square[0][0] + square[0][1] + square[0][2]
seen = {}
print(square)
# check rows
for row in square:
tmp = 0
for i in row:
tmp += i
if i in seen or i > 9 or i < 1:
return False
else:
seen[i] = 1
if tmp != target:
return False
# check cols
for i in range(3):
tmp = 0
for row in square:
tmp += row[i]
if tmp != target:
return False
# check left to right diag
tmp = 0
for i in range(3):
tmp += square[i][i]
if tmp != target:
return False
# check right to left diag
tmp = 0
for i in range(3):
tmp += square[i][2 - i]
if tmp != target:
return False
return True
|
PYTHON
|
{
"starter_code": "\nclass Solution:\n def numMagicSquaresInside(self, grid: List[List[int]]) -> int:\n ",
"url": "https://leetcode.com/problems/magic-squares-in-grid/"
}
| |
d253
|
train
|
class Solution:
def minTaps(self, n: int, ranges: List[int]) -> int:
for i,r in enumerate(ranges):
l = max(0,i-r)
ranges[l] = max(i+r, ranges[l])
res = lo = hi = 0
while hi < n:
lo, hi = hi, max(ranges[lo:hi+1])
if hi == lo: return -1
res += 1
return res
|
PYTHON
|
{
"starter_code": "\nclass Solution:\n def minTaps(self, n: int, ranges: List[int]) -> int:\n ",
"url": "https://leetcode.com/problems/minimum-number-of-taps-to-open-to-water-a-garden/"
}
| |
d256
|
train
|
class Solution:
def jump(self,nums):
"""
:type nums: List[int]
:rtype: int
"""
if len(nums) == 1:
return 0
else:
step = 0
pos = 0
while pos != len(nums) - 1:
bestStep = -1
bestValue = -1
for i in range(nums[pos], 0, -1):
if len(nums) - 1 == pos + i:
bestStep = i
break
if (pos + i < len(nums) and nums[pos + i] != 0 and nums[pos + i] + i > bestValue):
bestStep = i
bestValue = nums[pos + i] + i
print(bestStep)
pos += bestStep
step += 1
return step
|
PYTHON
|
{
"starter_code": "\nclass Solution:\n def jump(self, nums: List[int]) -> int:\n ",
"url": "https://leetcode.com/problems/jump-game-ii/"
}
| |
d259
|
train
|
class Solution:
def originalDigits(self, s):
"""
:type s: str
:rtype: str
"""
dmap={}
dmap[0]=s.count('z')
dmap[2]=s.count('w')
dmap[4]=s.count('u')
dmap[6]=s.count('x')
dmap[8]=s.count('g')
dmap[1]=s.count('o')-dmap[0]-dmap[2]-dmap[4]
dmap[3]=s.count('h')-dmap[8]
dmap[5]=s.count('f')-dmap[4]
dmap[7]=s.count('s')-dmap[6]
dmap[9]=s.count('i')-dmap[6]-dmap[8]-dmap[5]
res=''
#现在的问题就是如何在这里输入
dmap=sorted(list(dmap.items()),key=lambda x:x[0])
lst=['0','1','2','3','4','5','6','7','8','9']
#就是按照第一个来进行排序
'''
lst=['zero','one','two','three','four','five',
'six','seven','eight','nine']
这个是错误示范 我们需要输出的是数字 字符串 而不是字母
'''
for i in range(len(lst)):
res+=lst[i]*dmap[i][1]
return res
#注意 这道题比较关键的就是需要找到规律才行
|
PYTHON
|
{
"starter_code": "\nclass Solution:\n def originalDigits(self, s: str) -> str:\n ",
"url": "https://leetcode.com/problems/reconstruct-original-digits-from-english/"
}
| |
d262
|
train
|
class Solution:
def findKthLargest(self, nums, k):
"""
:type nums: List[int]
:type k: int
:rtype: int
"""
nums = sorted(nums, reverse=True)
return nums[k - 1]
|
PYTHON
|
{
"starter_code": "\nclass Solution:\n def findKthLargest(self, nums: List[int], k: int) -> int:\n ",
"url": "https://leetcode.com/problems/kth-largest-element-in-an-array/"
}
| |
d265
|
train
|
class Solution:
def maxLength(self, arr: List[str]) -> int:
def digit_representation(s):
ans = 0
for c in s:
ans |= 1<<(ord(c)-ord('a'))
return ans
A = sorted([(len(s), digit_representation(s)) for s in set(arr) if len(set(s))==len(s)], reverse=True)
if not A: return 0
R = [sum(t[0] for t in A)]
for i in range(1, len(A)):
R.append(R[-1] - A[i][0])
self.ans = A[0][0]
def helper(i, b, k):
if i == len(A):
self.ans = max(self.ans, k)
elif k + R[i] > self.ans:
if not (b & A[i][1]):
helper(i+1, b | A[i][1], k+A[i][0])
helper(i+1, b, k)
helper(0, 0, 0); return self.ans
|
PYTHON
|
{
"starter_code": "\nclass Solution:\n def maxLength(self, arr: List[str]) -> int:\n ",
"url": "https://leetcode.com/problems/maximum-length-of-a-concatenated-string-with-unique-characters/"
}
| |
d268
|
train
|
class Solution:
def evalRPN(self, tokens):
"""
:type tokens: List[str]
:rtype: int
"""
s = []
for token in tokens:
if token == "+":
a = int(s.pop())
b = int(s.pop())
s.append(a+b)
elif token == "/":
a = int(s.pop())
b = int(s.pop())
s.append(b/a)
elif token == "*":
a = int(s.pop())
b = int(s.pop())
s.append(a*b)
elif token == "-":
a = int(s.pop())
b = int(s.pop())
s.append(b-a)
else:
s.append(token)
if len(s) is not 1:
return False
else:
return int(s.pop())
|
PYTHON
|
{
"starter_code": "\nclass Solution:\n def evalRPN(self, tokens: List[str]) -> int:\n ",
"url": "https://leetcode.com/problems/evaluate-reverse-polish-notation/"
}
| |
d271
|
train
|
import math
class Solution:
def __init__(self):
self.happy_string = ''
def getHappyString(self, n: int, k: int) -> str:
# determine starting character
poss_per_group = 2 ** (n - 1)
group_num = math.ceil(k / poss_per_group) - 1
starting_char = ''
# check to make sure there are at least k happy strings
if k > poss_per_group * 3:
return ''
if group_num == 0:
self.happy_string += 'a'
elif group_num == 1:
self.happy_string += 'b'
else:
self.happy_string += 'c'
self.findNextChar(group_num, n - 1, group_num * poss_per_group, (group_num + 1) * poss_per_group, k)
return self.happy_string
def findNextChar(self, char_index: int, n: int, start: int, end: int, k: int) -> None:
if n != 0:
lower_index = -1
upper_index = -1
# 0 = 'a', 1 = 'b', 2 = 'c'
if char_index == 0:
lower_index = 1
upper_index = 2
elif char_index == 1:
lower_index = 0
upper_index = 2
else:
lower_index = 0
upper_index = 1
midpoint = int((start + end ) / 2)
if (k <= midpoint):
self.happy_string += self.indexToStr(lower_index)
self.findNextChar(lower_index, n - 1, start, midpoint, k)
else:
self.happy_string += self.indexToStr(upper_index)
self.findNextChar(upper_index, n - 1, midpoint, end, k)
def indexToStr(self, index: int) -> str:
if index == 0:
return 'a'
elif index == 1:
return 'b'
else:
return 'c'
|
PYTHON
|
{
"starter_code": "\nclass Solution:\n def getHappyString(self, n: int, k: int) -> str:\n ",
"url": "https://leetcode.com/problems/the-k-th-lexicographical-string-of-all-happy-strings-of-length-n/"
}
| |
d274
|
train
|
class Solution:
dp = {0: 0}
def racecar(self, target: int) -> int:
if target in self.dp:
return self.dp[target]
n = target.bit_length()
if 2**n - 1 == target:
self.dp[target] = n
else:
self.dp[target] = self.racecar(2**n - 1 - target) + n + 1
for m in range(n - 1):
self.dp[target] = min(self.dp[target], self.racecar(target - 2**(n - 1) + 2**m) + n + m + 1)
return self.dp[target]
|
PYTHON
|
{
"starter_code": "\nclass Solution:\n def racecar(self, target: int) -> int:\n ",
"url": "https://leetcode.com/problems/race-car/"
}
| |
d277
|
train
|
class Solution:
def findMinStep(self, board, hand):
"""
:type board: str
:type hand: str
:rtype: int
"""
res=float("inf")
hmap=collections.defaultdict(int)
for c in hand:
hmap[c]+=1
res=self.helper(board,hmap)
if res == float("inf"):
return -1
return res
def helper(self,board,hmap):
board=self.removeConsecutive(board)
if len(board) ==0:
return 0
cnt=float("inf")
j=0
for i in range(len(board)+1):
if i<len(board) and board[i] ==board[j]:
continue
need=3-(i-j)
if hmap[board[j]]>=need:
hmap[board[j]]-=need
res=self.helper(board[0:j]+board[i:],hmap)
if res!=float("inf"):
cnt=min(cnt,res+need)
hmap[board[j]]+=need
j=i
return cnt
def removeConsecutive(self,board):
j=0
for i in range(len(board)+1):
if i<len(board) and board[i] ==board[j]:
continue
if i-j>=3:
return self.removeConsecutive(board[0:j]+board[i:])
else:
j=i
return board
|
PYTHON
|
{
"starter_code": "\nclass Solution:\n def findMinStep(self, board: str, hand: str) -> int:\n ",
"url": "https://leetcode.com/problems/zuma-game/"
}
| |
d280
|
train
|
class Solution:
def getPermutation(self, n, k):
"""
:type n: int
:type k: int
:rtype: str
"""
nums = list("123456789")
k -= 1
factor = 1
for i in range(1, n):
factor *= i
res = []
for i in reversed(list(range(n))):
res.append(nums[k//factor])
nums.remove(nums[k//factor])
if i:
k %= factor
factor //= i
return "".join(res)
|
PYTHON
|
{
"starter_code": "\nclass Solution:\n def getPermutation(self, n: int, k: int) -> str:\n ",
"url": "https://leetcode.com/problems/permutation-sequence/"
}
| |
d283
|
train
|
class Solution:
def maxSideLength(self, mat: List[List[int]], threshold: int) -> int:
dp = [[0 for _ in range(len(mat[0]) + 1)]for r in range(len(mat) + 1)]
for r in range(1, len(mat) + 1):
for c in range(1, len(mat[r-1]) + 1):
dp[r][c] += mat[r-1][c-1]
if not r and not c:
continue
elif not r:
dp[r][c] += dp[r][c-1]
continue
elif not c:
dp[r][c] += dp[r-1][c]
continue
dp[r][c] += dp[r][c-1] + dp[r-1][c] - dp[r-1][c-1]
# print(dp)
highest = -1
for r in range(1, len(dp)):
r0= r1 = r
c0= c1 = 1
while r1 < len(dp) and c1 < len(dp[0]):
result = dp[r1][c1] + dp[r0-1][c0-1] - dp[r1][c0-1] - dp[r0-1][c1]
# print(f'r0:{r0} r1:{r1} c0:{c0} c1:{c1} result:{result}')
if result <= threshold:
highest = max(r1-r0, highest)
r1 += 1
c1 +=1
else:
r1 -=1
c0 +=1
r1 = max(r0+1,r1)
c1 = max(c0+1,c1)
return highest + 1
|
PYTHON
|
{
"starter_code": "\nclass Solution:\n def maxSideLength(self, mat: List[List[int]], threshold: int) -> int:\n ",
"url": "https://leetcode.com/problems/maximum-side-length-of-a-square-with-sum-less-than-or-equal-to-threshold/"
}
| |
d286
|
train
|
class Solution:
def smallestRangeII(self, A: List[int], K: int) -> int:
if not A:
return 0
nums = sorted([num + K for num in set(A)], reverse=True)
max_num = nums[0]
min_num = nums[-1]
changed_max = max_num - 2 * K
res = max_num - min_num
for i in range(len(nums) - 1):
changed = nums[i] - 2 * K
max_num = max(nums[i + 1], changed, changed_max)
min_num = min(min_num, changed)
res = min(res, max_num - min_num)
return res
|
PYTHON
|
{
"starter_code": "\nclass Solution:\n def smallestRangeII(self, A: List[int], K: int) -> int:\n ",
"url": "https://leetcode.com/problems/smallest-range-ii/"
}
| |
d289
|
train
|
class Solution:
def flipLights(self, n, m):
"""
:type n: int
:type m: int
:rtype: int
"""
states = set()
for op_odd in [0, 1]:
for op_even in [0, 1]:
for op_third in [0, 1]:
op_all = m - op_odd - op_even - op_third
if op_all >= 0:
one = (op_odd + op_all + op_third) % 2
two = (op_even + op_all) % 2
three = op_odd % 2
four = (op_even + op_all + op_third) % 2
states.add((one, two, three, four)[:n])
return len(states)
|
PYTHON
|
{
"starter_code": "\nclass Solution:\n def flipLights(self, n: int, m: int) -> int:\n ",
"url": "https://leetcode.com/problems/bulb-switcher-ii/"
}
| |
d292
|
train
|
class Solution:
def numOfSubarrays(self, arr: List[int]) -> int:
mod = 10**9+7
odd_presum_cnt = 0
par = 0
for a in arr:
par ^= a & 1
if par:
odd_presum_cnt += 1
return odd_presum_cnt * (len(arr)+1 - odd_presum_cnt)%mod
|
PYTHON
|
{
"starter_code": "\nclass Solution:\n def numOfSubarrays(self, arr: List[int]) -> int:\n ",
"url": "https://leetcode.com/problems/number-of-sub-arrays-with-odd-sum/"
}
| |
d298
|
train
|
class Solution:
def numTilePossibilities(self, tiles: str) -> int:
res = 0
freqs = [f + 1 for f in Counter(tiles).values()]
for t in itertools.product(*map(range, freqs)):
n = sum(t)
subtotal = math.factorial(n)
for freq in t:
subtotal //= math.factorial(freq)
res += subtotal
return res - 1
|
PYTHON
|
{
"starter_code": "\nclass Solution:\n def numTilePossibilities(self, tiles: str) -> int:\n ",
"url": "https://leetcode.com/problems/letter-tile-possibilities/"
}
| |
d301
|
train
|
class Solution:
def leastOpsExpressTarget(self, x: int, target: int) -> int:
def dp(i, j):
if i==0: return 2*j
# if j==0: return 0
if j==1: return 2
if (i, j) in memo: return memo[(i, j)]
base = x**i
q, r = divmod(j, base)
if r==0: return q*i
memo[(i, j)]=min(q*i+dp(i-1, r), (q+1)*i+dp(i-1, base-r))
return memo[(i, j)]
memo = {}
return dp(ceil(log(target, x)), target)-1
|
PYTHON
|
{
"starter_code": "\nclass Solution:\n def leastOpsExpressTarget(self, x: int, target: int) -> int:\n ",
"url": "https://leetcode.com/problems/least-operators-to-express-number/"
}
| |
d304
|
train
|
class Solution:
def maxSumAfterPartitioning(self, arr, k):
res = [0]
for idx, val in enumerate(arr):
max_val, cur_val = 0, 0
for i in range(max(0, idx-k+1), idx+1)[::-1]:
if arr[i] > max_val:
max_val = arr[i]
if res[i] + (idx-i+1)*max_val > cur_val:
cur_val = res[i] + (idx-i+1)*max_val
res.append(cur_val)
return res[-1]
|
PYTHON
|
{
"starter_code": "\nclass Solution:\n def maxSumAfterPartitioning(self, arr: List[int], k: int) -> int:\n ",
"url": "https://leetcode.com/problems/partition-array-for-maximum-sum/"
}
| |
d307
|
train
|
class Solution:
def combinationSum4(self, nums, target):
"""
:type nums: List[int]
:type target: int
:rtype: int
"""
cache = {}
def f(val):
if val == target:
return 1
total = 0
remain = target - val
for num in nums:
if num <= remain:
k = val+num
if k in cache:
total += cache[k]
else:
cache[k] = f(val + num)
total += cache[k]
return total
return f(0)
|
PYTHON
|
{
"starter_code": "\nclass Solution:\n def combinationSum4(self, nums: List[int], target: int) -> int:\n ",
"url": "https://leetcode.com/problems/combination-sum-iv/"
}
| |
d310
|
train
|
from collections import Counter
class Solution:
def longestArithSeqLength(self, A: List[int]) -> int:
c = dict(Counter(A).most_common())
# print(c)
m1 = max(c.values())
# A = list(set(A))
# A.sort()
index = {}
# for i in range(len(A)):
# index[A[i]]=i
dp = [[2] * len(A) for i in A]
m = 2
for i in range(len(A)):
# print(\"I=\", i)
# index[A[i+1]]=(i+1)
for j in range(i+1, len(A)):
# index[A[j]]=(j)
a = A[i]
c = A[j]
b = 2 * a - c
# print(b,a,c)
if b in index :
# print(\"B {} in index \".format(b))
# print(b,a,c,i,j)
dp[i][j] = dp[index[b]][i] + 1
index[A[i]]=i
m = max(m, max(dp[i]))
# # print(A)
# for i,d in enumerate(dp):
# print(A[i],d)
return max(m,m1)
|
PYTHON
|
{
"starter_code": "\nclass Solution:\n def longestArithSeqLength(self, A: List[int]) -> int:\n ",
"url": "https://leetcode.com/problems/longest-arithmetic-subsequence/"
}
|
End of preview. Expand
in Data Studio
README.md exists but content is empty.
- Downloads last month
- 19