solution
stringlengths 11
983k
| difficulty
int64 0
21
| language
stringclasses 2
values |
|---|---|---|
import sys
from collections import defaultdict
#input driver
name = sys.stdin.read()
jobGrid = []
isJob = True
row = []
grid = name.split('\n')
grid = grid[:-1]
number_of_cases = int(grid[0])
for i in range(number_of_cases):
l = list(map(int,grid[i*2+2].split()))
sum1 = 0
sum2 = 0
l.sort()
newvalue = 0
if(l[0] != 0):
print(0)
continue
for j,k in enumerate(l):
if(k - newvalue > 1):
sum1 = newvalue + 1
break
else:
newvalue = k
sum1 = newvalue + 1
if(len(l) > 1 and l[1] != 0):
print(sum1)
continue
newvalue = 0
twice = 0
for k in range(0, len(l), 1 ):
if(l[k] - newvalue > 1):
sum2 = newvalue + 1
break
else:
if(twice == 1 and sum2 != l[k]+1):
newvalue = l[k]
sum2 = newvalue + 1
twice = 0
elif(twice == 0 and sum2 != l[k] + 1):
twice = 1
print(sum1+sum2)
| 7 | PYTHON3 |
t=int(input())
for ttt in range(t):
n=int(input())
f=list(map(int, input().split()))
d={}
max=0
for i in range(len(f)):
if f[i] not in d.keys():
d[f[i]]=0
d[f[i]]+=1
if f[i]>max:
max=f[i]
k=0
q=0
for i in range(max+2):
if i not in d.keys() or d[i]==0:
k+=(i*(2-q))
break
elif d[i]==1:
if q==0:
k+=i
q+=1
print(k) | 7 | PYTHON3 |
tc = int(input())
for t in range(tc):
n = int(input())
arr = list(map(int, input().strip().split()))[:n]
arr = sorted(arr)
setA = []
setB = []
for num in arr:
if not setA:
setA.append(num)
elif num in setA:
setB.append(num)
else:
setA.append(num)
mexA = mexB = 0
if not setA:
mexA = 0
else:
for x in range(0, max(setA)+2):
if x not in setA:
mexA = x
break
if not setB:
mexB = 0
else:
for x in range(0, max(setB)+2):
if x not in setB:
mexB = x
break
print(mexA+mexB)
| 7 | PYTHON3 |
import sys
input = sys.stdin.readline
from collections import defaultdict
for _ in range(int(input())):
n = int(input())
a = list(map(int,input().split()))
mx = max(a)
freq = defaultdict(int)
for i in a:
freq[i] += 1
if freq[0]==0: print(0)
else:
ans = 0
mexa,mexb = 0,0
for i in range(max(a)+2):
if freq[i]==0:
if mexb:
ans += i
else:
ans = 2*i
break
elif freq[i]==1 and mexb==0:
mexb = 1
ans += i
if mexa==1 and mexb==1:
break
print(ans)
| 7 | PYTHON3 |
#https://codeforces.com/problemset/problem/1406/A
for _ in range(int(input())):
n=int(input())
l=list(map(int,input().split()))
l1,l2={},{}
for i in l:
if i not in l1:
l1[i]=1
else:
l2[i]=1
l1=sorted(list(l1.keys()))
l2=sorted(list(l2.keys()))
m1,m2=None,None
for i in range(len(l1)):
if i!=l1[i]:
m1=i
break
if m1==None:
m1=len(l1)
for i in range(len(l2)):
if i!=l2[i]:
m2=i
break
if m2==None:
m2=len(l2)
print(m1+m2)
| 7 | PYTHON3 |
for _ in range(int(input())):
n = int(input())
a = list(map(int, input().split()))
a.sort(reverse = False)
s, b = 0, 0
for i in a:
if s == i:
s += 1
elif b == i:
b += 1
print( b + s )
| 7 | PYTHON3 |
for t in range(int(input())):
n=int(input())
a=list(map(int,input().split()))
freq=[0]*101
for i in a:
freq[i]+=1
ans=0
for j in range(2):
for i in range(101):
if freq[i]==0:
ans+=i
break
else:
freq[i]-=1
print(ans) | 7 | PYTHON3 |
from sys import stdin
import math
inp = lambda : stdin.readline().strip()
t = int(inp())
for _ in range(t):
n = int(inp())
a = [int(x) for x in inp().split()]
a.sort()
ans = 0
twos = True
ones = True
c = 0
while True:
if a.count(c) < 2 and twos:
ans += c
twos = False
if a.count(c) < 1 and ones:
ans += c
ones = False
if twos == False and ones == False:
break
c += 1
print(ans) | 7 | PYTHON3 |
from sys import stdin,stdout
from collections import defaultdict as dd
input=stdin.readline
for _ in range(int(input())):
n=int(input())
a=list(map(int,input().split()))
a.sort(reverse=True)
d=dd(int)
for i in a:
d[i]+=1
fl=0
ans=0
for i in range(102):
if fl>=2:
break
if fl==0 and d[i]==1:
ans+=i
fl+=1
if d[i]==0:
if fl==0:
ans+=2*i
fl=2
else:
ans+=i
fl=2
print(ans)
| 7 | PYTHON3 |
t=int(input())
for i in range(t):
n=int(input())
x=[int(x) for x in input().split()]
x.sort()
a=set(x)
b=[]
for item in a:
if x.count(item)>1:
b.append(item)
def func(x):
if x==[]:
return 0
for i in range(0,max(x)+2):
if i in x:
continue
else:
return i
print(func(a)+func(b)) | 7 | PYTHON3 |
for _ in range(int(input())):
a = {x:0 for x in range(101)}
n = int(input())
l = list(map(int,input().split()))
for i in l:
a[i]+=1
ans = 0
i = 0
while True:
if a[i] == 0:
ans+=i
break
i+=1
i = 0
while True:
if a[i]<=1:
ans+=i
break
i+=1
print(ans) | 7 | PYTHON3 |
T = int(input())
while T >= 1:
n = int(input())
arr = list(map(int,input().split()))
lst = [0] * (101) ; size = 2 ; res = 0
for i in arr:
lst[i] += 1
while size >= 1:
check = True
for i in range(0,101):
if lst[i] > 0: lst[i] -= 1
else:
res += i
break
size -= 1
print(res)
T -= 1 | 7 | PYTHON3 |
#to run: ctrl+alt+b
#del window: ctrl+w
def mex(a):
a_s=list(set(a))
a_s.sort()
for i in range(len(a_s)):
if i!=a_s[i]:
return i
return len(a_s)
for _ in range(int(input())):
n=int(input())
arr=list(map(int,input().split()))
if 0 not in arr:
print(0)
elif arr.count(0)==1:
print(mex(arr))
else:
a=mex(arr)
for i in range(a):
arr.remove(i)
b=mex(arr)
print(a+b)
| 7 | PYTHON3 |
for _ in range(int(input())):
x=[]
lsta=[]
lstb=[]
i=int(input())
x= list(map(int, input().split()[:i]))
x.sort()
for j in x:
if j not in lsta:
lsta.append(j)
else:
lstb.append(j)
a=max(lsta)+2
try:
b=max(lstb)+2
except:
b=0
val2=0
for l in range(a):
if l not in lsta:
val1=l
break
for m in range(b):
if m not in lstb:
val2=m
break
print(val1+val2)
| 7 | PYTHON3 |
from collections import Counter
t = int(input())
while t :
t -= 1
n = int(input())
a = [int(i) for i in input().split()]
if 0 not in a : print(0)
else :
l = list(dict.fromkeys(a))
x,y = 0,0 ; x1,y1 = True , True
for i in l :
a.remove(i)
for i in range(101) :
if i not in l and x1:
x = i ; x1 = False
if i not in a and y1 :
y = i ; y1 = False
if x1 == False and y1 == False : break
print(x+y)
| 7 | PYTHON3 |
def main(n,arr):
val1,val2 = 0,n
for i in range(n):
if arr.count(i) < 2:
val1 = i
break
for i in range(n):
if arr.count(i) == 0:
val2 = i
break
return val1+val2
if __name__ == '__main__':
t = int(input())
for _ in range(t):
n = int(input())
arr = list(map(int,input().split()))
val = main(n,arr)
print(val) | 7 | PYTHON3 |
n = int(input().strip())
for i in range(n):
k = int(input().strip())
all = [int(i) for i in input().strip().split()]
total = {}
for i in all:
total[i] = total.get(i,0)+1
resa = 0
resb = 0
for i in range(101):
if i in total and total[resa]:
total[resa]-=1
resa+=1
else:
break
for i in range(101):
if i in total and total[resb]:
total[resb]-=1
resb+=1
else:
break
print(resa+resb)
| 7 | PYTHON3 |
# cook your dish here
t=int(input())
for _ in range(t):
n=int(input())
a=list(map(int,input().split()))
m=0
ans=0
f=0
for i in range(n+1):
k=a.count(i)
if k==1:
ans=i+1
f=1
elif k>1:
if f==0:
ans=i+1
m=i+1
else:
ans=i+1
elif k==0:
break
print(ans+m) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int mex(vector<int>& arr) {
if (arr.size() == 0) return 0;
if (arr[0] > 0) return 0;
for (int i = 1; i < arr.size(); i++) {
if (arr[i] != arr[i - 1] && arr[i] - arr[i - 1] > 1) return arr[i - 1] + 1;
}
return arr.back() + 1;
}
void solve() {
int n, re, ans = 0;
cin >> n;
map<int, int> arr;
vector<int> a, b;
for (int i = 0; i < n; i++) {
cin >> re;
arr[re]++;
}
for (auto x : arr) {
if (x.second & 1 && x.second > 1) {
a.push_back(x.first);
b.push_back(x.first);
} else if (x.second >= 2) {
a.push_back(x.first);
b.push_back(x.first);
} else if (x.second == 1) {
a.push_back(x.first);
}
}
cout << mex(a) + mex(b) << endl;
}
int main() {
int t;
cin >> t;
while (t--) solve();
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
int M = 1000000007;
long long n, m;
void solve() {}
void test() {
long long n;
cin >> n;
vector<int> a(n);
int count[101] = {
0,
};
for (long long i = 0; i < n; i++) {
cin >> a[i];
count[a[i]]++;
}
bool flag = 1;
int ans = 0;
for (long long i = 0; i < 101; i++) {
if (count[i] == 0 && flag) {
cout << 2 * i << endl;
return;
}
if (count[i] == 1 && flag) {
ans += i;
flag = 0;
}
if (count[i] == 0 && !flag) {
ans += i;
cout << ans << endl;
return;
}
}
}
int main() {
long long t;
cin >> t;
while (t--) test();
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 5;
const long long mod = 1e9 + 7;
long long t, n, ans, k, cnt, s;
long long a[maxn];
map<long long, long long> m;
int main() {
cin >> t;
while (t--) {
cin >> n;
m.clear();
s = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
m[a[i]]++;
}
sort(a + 1, a + 1 + n);
int flag = 0;
for (int i = 0; i <= 100; i++) {
if (m[i] >= 2)
continue;
else {
if (m[i] == 1 && flag == 0) {
flag = 1;
s += i;
}
if (m[i] == 0) {
if (flag == 0) {
s += i;
}
s += i;
break;
}
}
}
cout << s << endl;
}
return 0;
}
| 7 | CPP |
import sys as _sys
def main():
t = int(input())
for i in range(t):
n, = _read_ints()
a = tuple(_read_ints())
result = find_max_two_subsets_mex_sum(a)
print(result)
def _read_line():
result = _sys.stdin.readline()
assert result[-1] == "\n"
return result[:-1]
def _read_ints():
return map(int, _read_line().split(" "))
def find_max_two_subsets_mex_sum(sequence):
sequence = sorted(sequence)
a_last = -1
b_last = -1
for x in sequence:
a_next = a_last + 1
if x == a_next:
a_last = x
continue
b_next = b_last + 1
if x == b_next:
b_last = x
continue
return (a_last + 1) + (b_last + 1)
if __name__ == '__main__':
main()
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long const INF = 1e6;
long long power(long long a, long long b) {
long long result = 1;
while (b) {
if (b % 2) result = (result * a) % 1000000007;
a = (a * a) % 1000000007;
b /= 2;
}
return result;
}
void sol() {
int n;
cin >> n;
map<int, int> mp;
vector<int> a(n);
for (long long i = 0; i < n; i++) {
cin >> a[i];
mp[a[i]]++;
}
int m1 = 101, m2 = 101;
for (int i = 0; i < 101; i++) {
if (mp[i] >= 2) continue;
if (mp[i] == 0) {
m1 = min(m1, i);
m2 = min(m2, i);
break;
} else if (mp[i] == 1)
m1 = min(i, m1);
}
cout << m1 + m2 << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int T = 1;
cin >> T;
while (T--) sol();
return 0;
}
| 7 | CPP |
import sys
def minp():
return sys.stdin.readline().strip()
def mint():
return int(minp())
def mints():
return map(int, minp().split())
def solve():
n = mint()
b = [0]*101
for i in mints():
b[i] += 1
a = 0
for j in range(101):
if b[j] >= 2:
a = j + 1
else:
break
c = 0
for j in range(101):
if b[j] >= 1:
c = j + 1
else:
break
print(a+c)
for i in range(mint()):
solve()
| 7 | PYTHON3 |
for _ in range(int(input())):
n = int(input())
arr = list(map(int, input().split()))
# arr.sort()
A = set()
B = set()
for num in arr:
if not (num in A):
A.add(num)
elif not (num in B):
B.add(num)
A = list(A)
B = list(B)
A.sort()
B.sort()
# print(A, B)
res = 0
for ind, num in enumerate(A):
if ind != num:
res += ind
break
else:
res += len(A)
for ind, num in enumerate(B):
if ind != num:
res += ind
break
else:
res += len(B)
print(res)
| 7 | PYTHON3 |
for i in range(int(input())):
j=int(input())
k=list(map(int,input().split()))
a=[]
b=[]
for l in k:
if l in a:
b.append(l);
else:
a.append(l)
ai=0;
bi=0
for l in range(len(a)+1):
if l in a:
continue
ai=l;
break
for l in range(len(b)+1):
if l in b:
continue
bi=l;
break
print(ai+bi)
| 7 | PYTHON3 |
# cook your dish here
for _ in range(int(input())):
n = int(input())
a = list(map(int, input().split()))
s1, s2 = set(), set()
for i in a:
if a.count(i) > 1:
s1.add(i)
s2.add(i)
else:
s1.add(i)
ans = 0
for i in range(n + 1):
if i not in s1:
ans += i
break
for i in range(n + 1):
if i not in s2:
ans += i
break
print(ans) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n;
cin >> n;
vector<long long> v(n);
for (long long &x : v) cin >> x;
map<long long, long long> m;
for (long long x : v) m[x]++;
long long i = 0;
for (auto p : m) {
if (p.first == i and p.second >= 1)
m[p.first]--, i++;
else
break;
}
long long mex_a = i;
i = 0;
for (auto p : m) {
if (p.first == i and p.second >= 1)
m[p.first]--, i++;
else
break;
}
cout << mex_a + i << '\n';
}
void solve(bool testcase) {
long long t;
cin >> t;
while (t--) solve();
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve(true);
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
int arr[105];
int a[105], b[105];
int main() {
int t;
cin >> t;
while (t--) {
memset(a, 0, sizeof(a));
memset(b, 0, sizeof(b));
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> arr[i];
}
sort(arr + 1, arr + n + 1);
a[1] = arr[1];
int c1 = 2, c2 = 1;
for (int i = 2; i <= n; i++) {
if (arr[i] != arr[i - 1]) {
a[c1++] = arr[i];
} else {
b[c2++] = arr[i];
}
}
int ans = 0;
int f1 = 0, f2 = 0;
for (int i = 1; i < c1; i++) {
if (a[1] != 0) {
f1 = 1;
break;
}
if (a[i] == a[i - 1] || a[i] == a[i - 1] + 1)
continue;
else {
ans += a[i - 1] + 1;
f1 = 1;
break;
}
}
if (!f1) ans += a[c1 - 1] + 1;
for (int i = 1; i < c2; i++) {
if (b[1] != 0) {
f2 = 1;
break;
}
if (b[i] == b[i - 1] || b[i] == b[i - 1] + 1)
continue;
else {
ans += b[i - 1] + 1;
f2 = 1;
break;
}
}
if (!f2 && c2 != 1) ans += b[c2 - 1] + 1;
cout << ans << endl;
}
return 0;
}
| 7 | CPP |
t= int(input())
for _ in range(t):
length = int(input())
array = [int(i) for i in input().split()]
if 0 not in array:
print(0)
else:
new_array=list()
new_array.append(0)
array.remove(0)
for i in range(1,length+1):
if (i) in array:
new_array.append(i)
array.remove(i)
else:
break
newarray2 = list()
for i in range(length+1):
if i in array:
newarray2.append(i)
array.remove(i)
else:
break
ans=0
for i in range(length+1):
if i not in new_array:
ans+=i
break
for i in range(length+1):
if i not in newarray2:
ans+=i
break
print(ans)
| 7 | PYTHON3 |
from collections import Counter
def find_ans(n):
s=list(map(int,input().split()))
s=sorted(dict(Counter(s)).items())
a=[]
b=[]
for i in s:
if i[1]>=2:
a.append(i[0])
b.append(i[0])
elif i[1]<2 :
a.append(i[0])
qa=1111111110
qb=1111111110
for i in range(101):
if i not in a:
qa=min(i,qa)
if i not in b:
qb=min(qb,i)
print(qa+qb)
for _ in range(int(input())):
find_ans(int(input()))
| 7 | PYTHON3 |
t=int(input())
for _ in range(t):
n=int(input())
a=list(map(int,input().split()))
dic=[0]*101
for i in range(n):
dic[a[i]]+=1
ans=0
for i in range(101):
if dic[i]<2:
ans+=i
break
for i in range(101):
if dic[i]<1:
ans+=i
break
print(ans) | 7 | PYTHON3 |
from collections import Counter
t = int(input())
for _ in range(t):
n = int(input())
a = list(map(int, input().split()))
cnt = Counter(a)
num1, num2 = -1, -1
num1_modded, num2_modded = False, False
for i in range(101):
if cnt[i] >= 2:
continue
if cnt[i] == 1:
if not num1_modded:
num1_modded = True
num1 = i
if cnt[i] == 0:
if num1_modded:
num2 = i
num2_modded = True
else:
num1_modded = num2_modded = True
num1 = num2 = i
if num1_modded and num2_modded:
break
print(num1 + num2)
| 7 | PYTHON3 |
import sys
import math
from collections import Counter
input = sys.stdin.readline
def solve():
n=int(input())
L=list(map(int,input().split()))
#S=list(set(L))
val =max(L)
for i in range(val):
if i not in L:
a=i
break
else:
a=val+1
li=[]
C = dict(Counter(L))
for i in C:
if C[i]>1:
li.append(i)
if li==[]:
print(a)
return
else:
val = max(li)
for i in range(val):
if i not in li:
b=i
break
else:
b=val+1
print(a+b)
if __name__=="__main__":
for _ in range(int(input())):
solve()
| 7 | PYTHON3 |
from collections import Counter
for t in range(int(input())):
n = int(input())
a = list(map(int, input().split()))
a = sorted(a)
temp = set([i for i in range(0, 101)])
cnt = Counter(a)
ans = 0
p, q = 0, 0
for x in temp:
if x not in cnt:
p = x
break
for x in temp:
if cnt[x] <= 1:
q = x
break
ans = p+q
print(ans) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
void printVec(vector<int> &v) {
for (int i = 0; i < (int)v.size(); i++) {
cout << v[i] << " ";
}
cout << endl;
}
int main() {
int t, n, x;
vector<int> testCase;
cin >> t;
while (t) {
cin >> n;
int maximum = INT_MIN;
for (int i = 0; i < n; i++) {
cin >> x;
maximum = max(maximum, x);
testCase.push_back(x);
}
vector<int> counter(maximum + 1, 0);
for (int i = 0; i < n; i++) {
counter[testCase[i]] += 1;
}
int i = 0;
int j = 0;
while (i <= maximum and counter[i] >= 2) {
i++;
j++;
}
while (i <= maximum and counter[i] >= 1) {
i++;
}
cout << i + j << endl;
testCase.clear();
counter.clear();
t--;
}
return 0;
}
| 7 | CPP |
def getInts():
return [int(s) for s in input().split()]
def getInt():
return int(input())
def getStrs():
return [s for s in input().split()]
def getStr():
return input()
def listStr():
return list(input())
import collections as c
def solve():
N = getInt()
A = getInts()
counts = c.defaultdict(int)
for a in A:
counts[a] += 1
j = 0
ans = []
while True:
if len(ans) == 0:
if counts[j] == 0:
ans.append(j)
if len(ans) == 2:
break
ans.append(j)
break
elif counts[j] == 1:
ans.append(j)
if len(ans) == 2:
break
else:
if counts[j] == 0:
ans.append(j)
break
j += 1
return sum(ans)
T = getInt()
for t in range(T):
ans = solve()
print(ans)
| 7 | PYTHON3 |
t = int(input())
for _ in range(t):
n = int(input())
l = list(map(int, input().split(" ")))
i = 0
mex1 = 0
mex2 = 0
while (l.count(i) > 0):
if l.count(i) > 1 and mex1 == mex2:
mex2 = i + 1
mex1 = i + 1
i += 1
print(mex1 + mex2)
| 7 | PYTHON3 |
from collections import defaultdict,Counter
for i in range(int(input())):
n=int(input())
l=list(map(int,input().split()))
l.sort()
d=defaultdict(int)
d=Counter(l)
l1=set()
l2=set()
for i in l:
if d[i]>1:
l1.add(i)
l2.add(i)
else:
l1.add(i)
j=0
s=0
l1=list(l1)
l2=list(l2)
l1.sort()
l2.sort()
c1=0
for i in l1:
if i==j:
j+=1
else:
s+=j
c1=1
break
if c1==0:
s+=j
j=0
c1=0
for i in l2:
if i==j:
j+=1
else:
s+=j
c1=1
break
if c1==0:
s+=j
print(s)
| 7 | PYTHON3 |
import sys, os.path
import math
from collections import Counter
if(os.path.exists('input.txt')):
sys.stdin = open("input.txt","r")
sys.stdout = open("output.txt","w")
def solve():
n = int(input())
l = list(map(int,input().split()))
c = Counter(l)
mex1 = 0
mex2 = 0
for i in range(101):
if c[i] >=2:
mex1 = i+1
mex2 = i+1
else:
break
while(i < 101):
if (c[i]):
mex1 = i+1
else:
break
i += 1
return (mex1 + mex2)
for _ in range(int(input())):
print(solve())
| 7 | PYTHON3 |
t = int(input())
for index in range(t):
n = int(input())
arr = list(map(int, input().split()))
cnt = [0 for i in range(102)]
for i in range(n):
cnt[arr[i]] += 1
first = 0
second = 0
for i in range(102):
if cnt[i] == 0:
first = i
break
for i in range(102):
if cnt[i] <= 1:
second = i
break
print(first + second) | 7 | PYTHON3 |
def Mex( arr ) :
i, n = 0, len(arr)
curr = 0
while i < n :
if arr[i] != curr :
return curr
else :
while (i<n) and (arr[i] == curr) :
i += 1
curr += 1
return curr
def Subset_Mex( n, arr ) :
arr.sort()
i = 0
A, B = [], []
while i < n :
if (i < n-1) and (arr[i] == arr[i+1]) :
A.append(arr[i])
B.append(arr[i])
i += 2
else :
A.append(arr[i])
i += 1
return Mex(A) + Mex(B)
if __name__ == '__main__':
t = int( input() )
for i in range( t ) :
n = int( input() )
arr = list( map( int, input().split() ) )
print( Subset_Mex( n, arr ) ) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long nxt() {
long long res = 0;
cin >> res;
return res;
}
long long MOD = 1000 * 1000 * 1000 + 7;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
unsigned long long t = 1;
cin >> t;
for (; t > 0; --t) {
long long n = nxt();
unordered_map<int, int> m;
for (int i = 0; i < n; ++i) {
int tmp;
cin >> tmp;
++m[tmp];
}
int res = 0;
for (int i = 0; i < 200; ++i) {
if (m[i] > 0)
--m[i];
else {
res += i;
break;
}
}
for (int i = 0; i < 200; ++i) {
if (!m[i]) {
res += i;
break;
}
}
cout << res << endl;
}
}
| 7 | CPP |
t = int(input())
ans = list()
for zxc in range(t):
n = int(input())
arr = list(map(int, input().split()))
arr.sort()
c = -1
maxx = -1
arr1 = list([i for i in range(202)])
arr2 = list(i for i in range(202))
for i in arr:
if i + arr1[0]>=i+arr2[0]:
if i in arr1:
arr1.pop(arr1.index(i))
else:
if i in arr2:
arr2.pop(arr2.index(i))
else:
if i in arr2:
arr2.pop(arr2.index(i))
else:
if i in arr1:
arr1.pop(arr1.index(i))
ans.append(arr1[0]+arr2[0])
for z in ans:
print(z) | 7 | PYTHON3 |
import heapq as hq
from heapq import heappop,heappush
from collections import deque,defaultdict,Counter
from sys import stdin,stdout
def inp():
return int(stdin.readline())
def inlt():
return list(map(int,stdin.readline().split()))
def insr():
return list(stdin.readline().strip())
def invr():
return map(int,stdin.readline().split())
def subset_sum_count(arr,n,sum):
dp=[[0 for _ in range(sum+1)] for _ in range(n+1)]
for i in range(n+1):
for j in range(sum+1):
if j==0:
dp[i][j]=1
elif arr[i-1]<=j:
dp[i][j]=dp[i-1][j-arr[i-1]]+dp[i-1][j]
else:
dp[i][j]=dp[i-1][j]
return dp[n][sum]
def binary_search(func,lo,hi,abs_prec=1e-7):
""" Locate the first value x s.t. func(x) = True within [lo, hi] """
while abs(hi-lo)>abs_prec:
mi=lo+(hi-lo)/2
if func(mi):
hi=mi
else:
lo=mi
return (lo+hi)/2
def ternary_search(func,lo,hi,abs_prec=1e-7):
""" Find maximum of unimodal function func() within [lo, hi] """
while abs(hi-lo)>abs_prec:
lo_third=lo+(hi-lo)/3
hi_third=hi-(hi-lo)/3
if func(lo_third)<func(hi_third):
lo=lo_third
else:
hi=hi_third
return (lo+hi)/2
def discrete_binary_search(func,lo,hi):
""" Locate the first value x s.t. func(x) = True within [lo, hi] """
while lo<hi:
mi=lo+(hi-lo)//2
if func(mi):
hi=mi
else:
lo=mi+1
return lo
def discrete_ternary_search(func,lo,hi):
""" Find the first maximum of unimodal function func() within [lo, hi] """
while lo<=hi:
lo_third=lo+(hi-lo)//3
hi_third=lo+(hi-lo)//3+(1 if 0<hi-lo<3 else (hi-lo)//3)
if func(lo_third)<func(hi_third):
lo=lo_third+1
else:
hi=hi_third-1
return lo
return -1
def right_rotate(a,s):
return a[s:]+a[:s]
def dec_to_bin(x):
return int(bin(x)[2:])
def str_to_integer_list(n):
a=[]
for i in range(len(n)):
a.append(int(n[i]))
return a
def list_to_str(l):
s=""
for i in l:
s+=str(i)
return s
def dijkstra(s,N,E):
visited=set()
dist={}
for i in range(1,N+1):
dist[i]=1<<29
queue=[(dist[i],i) for i in range(1,N+1)]
hq.heappush(queue,(0,s))
dist[s]=0
while queue:
d,u=hq.heappop(queue)
if u in visited:
continue
#Relax all the neighbours of u
for t in E[u]:
v,r=t
if dist[v]>d+r:
dist[v]=d+r
hq.heappush(queue,(dist[v],v))
#Node u has been processed
visited.add(u)
return dist
def prime_sieve(n):
"""returns a sieve of primes >= 5 and < n"""
flag=n%6==2
sieve=bytearray((n//3+flag>>3)+1)
for i in range(1,int(n**0.5)//3+1):
if not (sieve[i>>3]>>(i&7))&1:
k=(3*i+1)|1
for j in range(k*k//3,n//3+flag,2*k):
sieve[j>>3]|=1<<(j&7)
for j in range(k*(k-2*(i&1)+4)//3,n//3+flag,2*k):
sieve[j>>3]|=1<<(j&7)
return sieve
def prime_list(n):
"""returns a list of primes <= n"""
res=[]
if n>1:
res.append(2)
if n>2:
res.append(3)
if n>4:
sieve=prime_sieve(n+1)
res.extend(3*i+1|1 for i in range(1,(n+1)//3+(n%6==1)) if not (sieve[i>>3]>>(i&7))&1)
return res
def dijkstra(n,graph,start):
""" Uses Dijkstra's algortihm to find the shortest path between in a graph. """
dist,parents=[float("inf")]*n,[-1]*n
dist[start]=0
queue=[(0,start)]
while queue:
path_len,v=heappop(queue)
if path_len==dist[v]:
for w,edge_len in graph[v]:
if edge_len+path_len<dist[w]:
dist[w],parents[w]=edge_len+path_len,v
heappush(queue,(edge_len+path_len,w))
return dist,parents
def path(start,end,parent):
path=[end]
while path[-1]!=start:
path.append(parent[path[-1]])
path.reverse()
return path
def bfs(graph,start,goal):
"""
finds a shortest path in undirected `graph` between `start` and `goal`.
If no path is found, returns `None`
"""
if start==goal:
return [start]
visited={start}
queue=deque([(start,[])])
while queue:
current,path=queue.popleft()
visited.add(current)
for neighbor in graph[current]:
if neighbor==goal:
return path+[current,neighbor]
if neighbor in visited:
continue
queue.append((neighbor,path+[current]))
visited.add(neighbor)
return None # no path found. not strictly needed
def fillPrefixSum(arr,n,prefixSum):
prefixSum[0]=arr[0]
# Adding present element
# with previous element
for i in range(1,n):
prefixSum[i]=prefixSum[i-1]+arr[i]
def check(a,ind,d1):
beg=a[:ind+1]
end=a[ind+1:]
d=[]
c=0
for i in end:
if i-d1 in beg:
c+=1
return c
'''for _ in range(int(input())):
n,m=list(map(int,input().split()))
graph=defaultdict(list)
distance=[-1]*(n+1)
visited=[False]*(n+1)
for _ in range(m):
x,y=list(map(int,input().split()))
graph[x].append(y)
graph[y].append(x)'''
'''for _ in range(int(input())):
n,m=list(map(int,input().split()))
graph=[[]for _ in range(n+1)]
distance=[-1]*(n+1)
visited=[False]*(n+1)
for _ in range(m):
x,y,w=list(map(int,input().split()))
graph[x].append([y,w])
graph[y].append([x,w])'''
import os
import sys
from io import BytesIO,IOBase
def DecimalToBinary(n):
def helper(n):
if n==0:
return '' # <- empty string
else:
if n%2==1:
binaryDigit='1'
else:
binaryDigit='0'
return helper(n//2)+binaryDigit
if n==0:
result='0' # <- "leading zero" only for `n == 0`
else:
result=helper(n)
return result
def p(board):
for i in range(8):
s=""
for j in range(8):
s+=board[i][j]
print(s)
def binaryToDecimal(n):
return int(n,2)
def decimalToBinary(n):
return bin(n).replace("0b","")
def solve(a,b):
x=DecimalToBinary(a);
y=DecimalToBinary(b)
z=x+y
l=y+x
r=binaryToDecimal(z)-binaryToDecimal(l)
return r
def mostFrequent(arr,n):
# Sort the array
arr.sort()
# find the max frequency using
# linear traversal
max_count=1;
res=arr[0];
curr_count=1
for i in range(1,n):
if (arr[i]==arr[i-1]):
curr_count+=1
else:
if (curr_count>max_count):
max_count=curr_count
res=arr[i-1]
curr_count=1
# If last element is most frequent
if (curr_count>max_count):
max_count=curr_count
res=arr[n-1]
return res
from bisect import bisect_right,bisect_left
def lds(arr,n):
lds=[0]*n
max=0
for i in range(n):
lds[i]=1
for i in range(1,n):
for j in range(i):
if (arr[i]<arr[j] and
lds[i]<lds[j]+1):
lds[i]=lds[j]+1
for i in range(n):
if (max<lds[i]):
max=lds[i]
# returns the length of the LDS
return max
import math
def prefix(a):
pre=[]
pre.append(a[0])
for i in range(1,len(a)):
pre.append(pre[i-1]+a[i])
return pre
def solve(n,x,size):
res=10000000
if n==0:
return 0
if size==0:
return 0
for i in x:
res=1+min(res,solve(n-i,x,size-1))
return res
def main():
for _ in range(inp()):
n=inp()
a=inlt()
c=[0 for _ in range(101)]
ans=0
pp=0
qq=0
for i in a:
c[int(i)]+=1
for i in range(101):
if c[i]>0:
c[i]-=1
else:
pp=i
break
for i in range(101):
if c[i]>0:
c[i]-=1
else:
qq=i
break
print(pp+qq)
# region fastio
BUFSIZE=8192
class FastIO(IOBase):
newlines=0
def __init__(self,file):
self._fd=file.fileno()
self.buffer=BytesIO()
self.writable="x" in file.mode or "r" not in file.mode
self.write=self.buffer.write if self.writable else None
def read(self):
while True:
b=os.read(self._fd,max(os.fstat(self._fd).st_size,BUFSIZE))
if not b:
break
ptr=self.buffer.tell()
self.buffer.seek(0,2),self.buffer.write(b),self.buffer.seek(ptr)
self.newlines=0
return self.buffer.read()
def readline(self):
while self.newlines==0:
b=os.read(self._fd,max(os.fstat(self._fd).st_size,BUFSIZE))
self.newlines=b.count(b"\n")+(not b)
ptr=self.buffer.tell()
self.buffer.seek(0,2),self.buffer.write(b),self.buffer.seek(ptr)
self.newlines-=1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd,self.buffer.getvalue())
self.buffer.truncate(0),self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self,file):
self.buffer=FastIO(file)
self.flush=self.buffer.flush
self.writable=self.buffer.writable
self.write=lambda s:self.buffer.write(s.encode("ascii"))
self.read=lambda:self.buffer.read().decode("ascii")
self.readline=lambda:self.buffer.readline().decode("ascii")
sys.stdin,sys.stdout=IOWrapper(sys.stdin),IOWrapper(sys.stdout)
input=lambda:sys.stdin.readline().rstrip("\r\n")
# endregion
if __name__=="__main__":
main()
| 7 | PYTHON3 |
for test in range(int(input())):
n = int(input())
l = list(map(int,input().split()))
l.sort()
if(l[0]!=0):
print(0)
else:
mexa = 0
j = 0
setd = list(set(l))
mexb = len(setd)
setd.sort()
# print(setd)
for i in range(len(setd)):
if(i!=setd[i]):
mexb = i
break
d = {}
for i in l:
if(i in d):
d[i]+=1
else:
d[i]=1
for i in range(n):
if(i not in d or d[i]<2):
mexa = i
break
# print(mexa,mexb)
print(mexa+mexb)
| 7 | PYTHON3 |
# cook your dish here
t = int(input())
for _ in range(t):
n = int(input())
li = list(map(int, input().split()))
i = 0
res = 0
cnt = 0
while cnt != 2:
if li.count(i) == 0:
if cnt == 0:
res += (2 * i)
else:
res += (i)
cnt = 2
if li.count(i) >= (2 - cnt):
i += 1
continue
else:
cnt += 1
res += i
print(res) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
mt19937 mt_rng(chrono::steady_clock::now().time_since_epoch().count());
long long int randint(long long int a, long long int b) {
return uniform_int_distribution<long long int>(a, b)(mt_rng);
}
long long int mod(long long int a, long long int b) {
long long int ret = a % b;
return ret >= 0 ? ret : ret + b;
}
void solve() {
int n;
cin >> n;
multiset<int> s;
for (int i = 0; i < n; i++) {
int j;
cin >> j;
s.insert(j);
}
int a = INT_MIN, b = INT_MIN;
int cnt = 0;
for (int i = 0; i < 10000000; i++) {
if (s.count(i) > 0) {
s.erase(s.find(i));
continue;
} else {
a = i;
break;
}
}
for (int i = 0; i < 10000000; i++) {
if (s.count(i) > 0) {
s.erase(s.find(i));
continue;
} else {
b = i;
break;
}
}
cout << a + b << "\n";
}
int main() {
ios::sync_with_stdio(0);
int t = 1;
cin >> t;
while (t--) {
solve();
}
}
| 7 | CPP |
for _ in range(int(input())):
n = int(input())
l = sorted(list(map(int, input().split())))
d = {}
for i in l:
d[i] = d.get(i, 0) + 1
# print(d)
a = 0
b = 0
flag1, flag2 = 1, 1
while flag1 or flag2:
if a not in d:
break
else:
a += 1
if flag2:
if b not in d or (b <= a and d[b] == 1):
flag2 = 0
else:
b += 1
# print(a, b)
print(a + b)
| 7 | PYTHON3 |
for _ in range(int(input())):
n = int(input())
a = sorted(map(int, input().split()))
c0 = c1 = 0
for i in a:
if c0 == i:
c0 += 1
continue
if c1 == i:
c1 += 1
print(c0 + c1)
| 7 | PYTHON3 |
import sys
input = sys.stdin.readline
############ ---- Input Functions ---- ############
def inp():
return(int(input()))
def inlt():
return(list(map(int,input().split())))
def insr():
s = input()
return(list(s[:len(s) - 1]))
def invr():
return(map(int,input().split()))
def solve(arr,n):
ans = 0
res = [0 for i in range(101)]
for i in range(n):
res[arr[i]] += 1
sec = None
for i in range(101):
if res[i] <= 1 and sec == None:
sec = i
if res[i] == 0:
ans = i
break
return ans + sec
t = inp()
while t > 0:
n = inp()
arr = inlt()
print(solve(arr,n))
t -= 1
| 7 | PYTHON3 |
t = int(input())
while (t > 0):
nr_mex = 2
sum = 0
nr = []
n = int(input())
aux = input()
for i in range (102):
nr.append(0)
for i in range(n):
val = int(aux.split()[i])
nr[val] += 1
for i in range(102):
if nr[i] < nr_mex:
if nr[i] == 0 and nr_mex == 2:
sum += i
nr_mex -= 1
sum += i
nr_mex -= 1
if nr_mex == 0:
break
print(sum)
t -= 1 | 7 | PYTHON3 |
def mex(m):
for i in range(len(m)):
if i not in m:
return i
return len(m)
t = int(input()) # amount of test cases
res = []
for i in range(t):
s = int(input()) # size of set
M = [int(x) for x in input().split()]
if len(M) == max(M) + 1 == mex(M):
res.append(max(M) + 1)
if len(M) > mex(M):
A = mex(M)
for i in range(A):
M.pop(M.index(i))
res.append(A + mex(M))
for e in res:
print(e) | 7 | PYTHON3 |
from collections import defaultdict as dd
import sys
input=sys.stdin.readline
t=int(input())
while t:
n=int(input())
#n,m=map(int,input().split())
l=list(map(int,input().split()))
l.sort()
ans=0
d=dd(int)
for i in range(n):
d[l[i]]+=1
for i in range(102):
if(d[i]==1 or d[i]==0):
ans=i
break
for i in range(102):
if(not d[i]):
ans+=i
break
print(ans)
t-=1 | 7 | PYTHON3 |
for i in range(int(input())):
n=int(input())
a=sorted(list(map(int,input().split())))
l=[0,0]
for i in a:
if i==l[0]:
l[0]+=1
elif i==l[1]:
l[1]+=1
print(sum(l)) | 7 | PYTHON3 |
t=int(input())
while t:
t=t-1
n=int(input())
a=list(map(int,input().split()))
x=[0 for i in range(101)]
cnt=0
out=0
for i in a:
x[i]+=1
flag=0
for i in range(101):
if x[i]>=1:
x[i]-=1
continue
if x[i]==0:
out+=i
flag=1
if flag:
break
flag=0
for i in range(101):
if x[i]>=1:
x[i]-=1
continue
if x[i]==0:
out+=i
flag=1
if flag:
break
print(out)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long md = 1e9 + 7;
int an[310000];
char sn[310000];
int main() {
int z;
int n, m;
int i, j, k;
cin >> z;
while (z--) {
scanf("%d%d", &n, &k);
scanf("%s", sn);
bool flag = 1;
int first, last;
for (i = 0; i < n; i++) {
if (sn[i] == 'W' && flag) {
flag = 0;
first = i;
}
if (sn[i] == 'W') last = i;
}
int ans;
if (flag) {
ans = max(k * 2 - 1, 0);
} else {
int l;
bool bl = 0;
int num = 0;
ans = 1;
for (i = first + 1; i <= last; i++) {
if (bl == 0 && sn[i] == 'L') {
l = 1;
bl = 1;
} else if (bl == 0 && sn[i] == 'W') {
ans += 2;
} else if (bl == 1 && sn[i] == 'L') {
l++;
} else {
bl = 0;
an[num++] = l;
ans += 1;
}
}
sort(an, an + num);
for (i = 0; i < num; i++) {
if (k >= an[i]) {
ans += an[i] * 2 + 1;
k -= an[i];
} else {
ans += k * 2;
k = 0;
break;
}
}
if (k > 0) {
ans += min(k, n - (last - first + 1)) * 2;
}
}
printf("%d\n", ans);
}
return 0;
}
| 8 | CPP |
from functools import reduce
import os
import sys
from collections import *
#from fractions import *
from math import *
from bisect import *
from heapq import *
from io import BytesIO, IOBase
input = lambda: sys.stdin.readline().rstrip("\r\n")
def value(): return tuple(map(int, input().split())) # multiple values
def arr(): return [int(i) for i in input().split()] # array input
def sarr(): return [int(i) for i in input()] #array from string
def starr(): return [str(x) for x in input().split()] #string array
def inn(): return int(input()) # integer input
def svalue(): return tuple(map(str, input().split())) #multiple string values
def parr(): return [(value()) for i in range(n)] # array of pairs
mo = 1000000007
inf=1e18
div=998244353
#print("Case #{}:".format(_+1),end=" ")
# ----------------------------CODE------------------------------#
for _ in range(inn()):
n,k=value()
a=[str(x) for x in input()]
ans=0
c=0
if(len(set(a))==1 and a[0]=='L'):
print(max(0,k*2-1))
continue
for i in range(n):
if(a[i]=='W'):
if(i>0 and a[i-1]=='W'):
ans+=2
else:
ans+=1
else:
c+=1
i=0
while(i<n and a[i]=='L'):
i+=1
j=n-1
while(j>=0 and a[j]=='L'):
j-=1
res=[]
while(i<j):
val=i
while(i<j and a[i]=='L'):
i+=1
if(i-val>0):
res+=[i-val]
else:
i+=1
res.sort()
#print(res,c)
for i in res:
if(i>k):
break
ans+=(i*2+1)
k-=i
c-=i
ans+=min(c,k)*2
#print(c,k)
print(min((n-1)*2+1,ans))
| 8 | PYTHON3 |
def examA():
T = I()
ans = []
for _ in range(T):
N = I()
B = LI()
if sum(B)==0:
print("NO")
continue
print("YES")
B.sort()
for i in range(N):
cur = []
now = 0
for j in range(N):
now += B[i-j]
if now==0:
break
cur.append(B[i-j])
if len(cur)==N:
print(" ".join(map(str,cur)))
break
return
def examB():
T = I()
ans = []
for _ in range(T):
N, K = LI()
S = SI()
L = []
W = 0
WW = 0
cur = 0
l = -inf
flag_W = False
for s in S:
if s=="W":
WW += 1
if flag_W:
cur += 2
continue
if l>0:
L.append(l)
l = 0
flag_W = True
W += 1
cur += 1
else:
flag_W = False
l += 1
#print("途中")
#print(cur,l)
#print(L)
if WW==0:
cur = max(0,2*K-1)
elif K==0:
pass
elif N-WW<=K:
cur = 2*N-1
else:
L.sort()
for i in range(len(L)):
a = L[i]
if a<=K:
cur += 1 + 2*a
K -= a
else:
cur += 2*K
K = 0
break
if K>0:
cur += 2*K
ans.append(min(2*N-1,cur))
for v in ans:
print(v)
return
def examC():
T = I()
ans = []
for _ in range(T):
cur = 0
ans.append(cur)
for v in ans:
print(v)
return
def examD():
ans = 0
print(ans)
return
def examE():
ans = 0
print(ans)
return
def examF():
ans = 0
print(ans)
return
from decimal import getcontext,Decimal as dec
import sys,bisect,heapq
from copy import deepcopy
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
def I(): return int(input())
def LI(): return list(map(int,sys.stdin.readline().split()))
def DI(): return dec(input())
def LDI(): return list(map(dec,sys.stdin.readline().split()))
def LSI(): return list(map(str,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def SI(): return sys.stdin.readline().strip()
global mod,mod2,inf,alphabet,_ep
mod = 10**9 + 7
mod2 = 998244353
inf = 10**18
_ep = dec("0.000000000001")
alphabet = [chr(ord('a') + i) for i in range(26)]
alphabet_convert = {chr(ord('a') + i): i for i in range(26)}
getcontext().prec = 28
sys.setrecursionlimit(2*10**5)
if __name__ == '__main__':
examB()
"""
1
6 1
LLLWWL
""" | 8 | PYTHON3 |
for _ in range(int(input())):
n,k=map(int,input().split())
s=list(input())
st,ed=0,0
for i in range(n):
if s[i]=='W':
stw=i
break
st+=1
if st!=n:
for j in range(n-1,-1,-1):
if s[j]=='W':
edw=j
break
ed+=1
else:
print(max(0,k*2-1))
continue
l=[]
i=s.index('W')
while i<n:
if s[i]=='W':
i+=1
else:
j=i
c=0
while j<n and s[j]=='L':
c+=1
j+=1
if j==n:
break
l.append([c,i])
i=j
l.sort()
for e in l:
if e[0]<=k:
k-=e[0]
idx=e[1]
for p in range(idx,idx+e[0]):
s[p]='W'
else:
idx=e[1]
for p in range(idx,idx+k):
s[p]='W'
k=0
if k!=0:
if st!=0:
for i in range(stw-1,-1,-1):
s[i]='W'
k-=1
if k==0:
break
if k!=0:
if ed!=0:
for i in range(edw+1,n):
s[i]='W'
k-=1
if k==0:
break
ans=0
pre=0
for i in range(n):
if s[i]=='L':
pre=0
continue
elif pre==0:
ans+=1
pre=1
else:
ans+=2
print(ans)
| 8 | PYTHON3 |
z,zz=input,lambda:list(map(int,z().split()))
fast=lambda:stdin.readline().strip()
zzz=lambda:[int(i) for i in stdin.readline().split()]
szz,graph,mod,szzz=lambda:sorted(zz()),{},10**9+7,lambda:sorted(zzz())
from string import *
from re import *
from collections import *
from queue import *
from sys import *
from collections import *
from math import *
from heapq import *
from itertools import *
from bisect import *
from collections import Counter as cc
from math import factorial as f
from bisect import bisect as bs
from bisect import bisect_left as bsl
from itertools import accumulate as ac
def lcd(xnum1,xnum2):return (xnum1*xnum2//gcd(xnum1,xnum2))
def prime(x):
p=ceil(x**.5)+1
for i in range(2,p):
if (x%i==0 and x!=2) or x==0:return 0
return 1
def dfs(u,visit,graph):
visit[u]=True
for i in graph[u]:
if not visit[i]:
dfs(i,visit,graph)
###########################---Test-Case---#################################
"""
"""
###########################---START-CODING---##############################
def solve(n,k,s):
arr=[]
sm=s.count("W")
if sm==0:
return max(min(n,k)*2 -1,0)
arr=s.split("W")[1:-1]
arr=list(filter(None,arr))
arr=[len(i) for i in arr]
arr.sort()
t=len(arr)
ncut=t+1
for i in range(t):
if k>=arr[i]:
sm+=arr[i]
k-=arr[i]
ncut-=1
return max(0,min(2*n-1,(sm+k)*2-ncut))
ann=[]
t = int(input())
for x in range(t):
n,k=zz()
s = fast()
h = solve(n,k,s)
ann.append(h)
for i in ann:print(i)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long Min(long long a, long long b) { return (a < b) ? a : b; }
long long Max(long long a, long long b) { return (a < b) ? b : a; }
long long gcd(long long m, long long n) {
if (n == 0) return m;
return gcd(n, m % n);
}
long long lcm(long long m, long long n) { return m * n / gcd(m, n); }
long long dx[6] = {-1, 0, 1, 0, 0, 0}, dy[6] = {0, 1, 0, -1, 0, 0},
dz[6] = {0, 0, 0, 0, 1, -1};
void solve() {
long long n, k;
string s;
cin >> n >> k >> s;
long long cnt = 0, ccnt = 0, ans = 0;
deque<long long> v;
for (int i = 0; i < n; i++) {
if (s[i] == 'L')
cnt++, ccnt++;
else {
if (ccnt > 0) v.push_back(ccnt);
ccnt = 0;
}
if (s[i] == 'W') {
if (i > 0 && s[i - 1] == 'W')
ans += 2;
else
ans++;
}
}
if (ccnt > 0) v.push_back(ccnt);
if (!v.empty() && s[0] == 'L') v.pop_front();
if (!v.empty() && s[n - 1] == 'L') v.pop_back();
if (cnt <= k) {
cout << 2 * n - 1 << "\n";
return;
}
if (cnt == n) {
if (k == 0)
cout << "0\n";
else
cout << 2 * k - 1 << '\n';
return;
}
sort((v).begin(), (v).end());
ans += 2 * k;
long long idx = 0;
while (k > 0) {
if (idx < v.size() && k >= v[idx]) {
k -= v[idx];
ans++;
} else {
break;
}
idx++;
}
cout << ans << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long tc = 1;
cin >> tc;
while (tc--) solve();
exit(0);
}
| 8 | CPP |
# Author : raj1307 - Raj Singh
# Date : 10.10.2020
from __future__ import division, print_function
import os,sys
from io import BytesIO, IOBase
if sys.version_info[0] < 3:
from __builtin__ import xrange as range
from future_builtins import ascii, filter, hex, map, oct, zip
def ii(): return int(input())
def si(): return input()
def mi(): return map(int,input().strip().split(" "))
def msi(): return map(str,input().strip().split(" "))
def li(): return list(mi())
def dmain():
sys.setrecursionlimit(1000000)
threading.stack_size(1024000)
thread = threading.Thread(target=main)
thread.start()
#from collections import deque, Counter, OrderedDict,defaultdict
#from heapq import nsmallest, nlargest, heapify,heappop ,heappush, heapreplace
#from math import log,sqrt,factorial,cos,tan,sin,radians
#from bisect import bisect,bisect_left,bisect_right,insort,insort_left,insort_right
#from decimal import *
#import threading
#from itertools import permutations
#Copy 2D list m = [x[:] for x in mark] .. Avoid Using Deepcopy
abc='abcdefghijklmnopqrstuvwxyz'
abd={'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'h': 7, 'i': 8, 'j': 9, 'k': 10, 'l': 11, 'm': 12, 'n': 13, 'o': 14, 'p': 15, 'q': 16, 'r': 17, 's': 18, 't': 19, 'u': 20, 'v': 21, 'w': 22, 'x': 23, 'y': 24, 'z': 25}
mod=1000000007
#mod=998244353
inf = float("inf")
vow=['a','e','i','o','u']
dx,dy=[-1,1,0,0],[0,0,1,-1]
def getKey(item): return item[1]
def sort2(l):return sorted(l, key=getKey,reverse=True)
def d2(n,m,num):return [[num for x in range(m)] for y in range(n)]
def isPowerOfTwo (x): return (x and (not(x & (x - 1))) )
def decimalToBinary(n): return bin(n).replace("0b","")
def ntl(n):return [int(i) for i in str(n)]
def ncr(n,r): return factorial(n)//(factorial(r)*factorial(max(n-r,1)))
def ceil(x,y):
if x%y==0:
return x//y
else:
return x//y+1
def powerMod(x,y,p):
res = 1
x %= p
while y > 0:
if y&1:
res = (res*x)%p
y = y>>1
x = (x*x)%p
return res
def gcd(x, y):
while y:
x, y = y, x % y
return x
def isPrime(n) : # Check Prime Number or not
if (n <= 1) : return False
if (n <= 3) : return True
if (n % 2 == 0 or n % 3 == 0) : return False
i = 5
while(i * i <= n) :
if (n % i == 0 or n % (i + 2) == 0) :
return False
i = i + 6
return True
def read():
sys.stdin = open('input.txt', 'r')
sys.stdout = open('output.txt', 'w')
def main():
for _ in range(ii()):
n,k=mi()
s=si()
ans=0
p=0
l=[]
for i in range(n):
if s[i]=='W':
if p==0:
ans+=1
else:
ans+=2
p=1
else:
p=0
cnt=0
first=-1
last=-1
for i in range(n):
if s[i]=='L':
cnt+=1
else:
if(cnt!=0):
if s[0]=='L' and first==-1:
first=cnt
else:
l.append(cnt)
cnt=0
if cnt!=0:
last=cnt
l.sort()
if last==n:
print(max(2*k-1,0))
continue
for i in range(len(l)):
if l[i]<=k:
ans+=l[i]*2 + 1
k-=l[i]
else:
ans+=(k*2)
k=0
break
if k!=0:
if last!=-1:
p=min(last,k)
ans+=p*2
k-=p
if k!=0:
if first!=-1:
p=min(first,k)
if p>=first:
ans+=p*2
else:
ans+=p*2
print(ans)
# region fastio
# template taken from https://github.com/cheran-senthil/PyRival/blob/master/templates/template.py
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
if sys.version_info[0] < 3:
sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# endregion
if __name__ == "__main__":
#read()
main()
#dmain()
# Comment Read()
| 8 | PYTHON3 |
import sys
input = sys.stdin.readline
def print(val):
sys.stdout.write(str(val) + '\n')
def prog():
for _ in range(int(input())):
n,k = map(int,input().split())
s = list(input().strip() + 'W')
bounds = []
if s[0] == 'L':
bounds.append([1,1,0])
for i in range(len(s)-1):
if s[i] == 'L':
if s[i+1] == 'L':
bounds[-1][1] += 1
if s[i] == 'W':
if s[i+1] == 'L':
bounds.append([0,1,i+1])
if s[-2] == 'L':
bounds[-1][0] = 2
bounds.sort()
for i in range(len(bounds)):
if k >= bounds[i][1]:
k -= bounds[i][1]
for j in range(bounds[i][2],bounds[i][2]+bounds[i][1]):
s[j] = 'W'
else:
if bounds[i][0] == 1:
for j in range(bounds[i][2] + bounds[i][1]-1,bounds[i][2] + bounds[i][1]-1-k,-1):
s[j] = 'W'
else:
for j in range(bounds[i][2],bounds[i][2]+k):
s[j] = 'W'
break
tot = 0
for i in range(len(s)-1):
tot += (s[i] == 'W') + (s[i] == 'W' and i > 0 and s[i-1] == 'W')
print(tot)
prog()
| 8 | PYTHON3 |
I=input
for _ in[0]*int(I()):
n,k=map(int,I().split());s=I();c=s.count('W');n=min(n,c+k);a=sorted(map(len,filter(None,s.strip('L').split('W'))))[::-1]
while a and c+a[-1]<=n:c+=a.pop()
print((2*n-len(a)or 1)-1) | 8 | PYTHON3 |
for t in range(int(input())):
n, k = [int(i ) for i in input().split()]
wd = input()
sc = 0
if wd[0] == 'W':
sc += 1
ls = []
l_cnt = 0
for i in range(1, n):
if wd[i] == 'W':
if wd[i-1] == 'W':
sc += 2
else:
sc += 1
for i in range(n):
if wd[i] == 'W':
if len(ls) == 0 or ls[-1] != 0:
ls.append(0)
else:
l_cnt += 1
if ls:
ls[-1] += 1
if l_cnt <= k:
print(2*n-1)
continue
if ls:
ls.pop()
else:
print(max(0,2*k-1))
continue
sm = 0
ls.sort()
ext = 0
for ll in ls:
if sm + ll <= k:
sm += ll
ext += 1
else:
break
assert sc + 2*k + ext <= 2*n-1
# print('sc, ext', sc, ext, ls)
print(sc + 2*k + ext)
| 8 | PYTHON3 |
#######################################################################################################################
# Author: BlackFyre
# Language: PyPy 3.7
#######################################################################################################################
from sys import stdin, stdout, setrecursionlimit
from math import floor, gcd, fabs, factorial, fmod, sqrt, inf, log, log2
from random import seed, randint
from datetime import datetime
from collections import defaultdict as dd, deque
from heapq import merge, heapify, heappop, heappush, nsmallest
from bisect import bisect_left as bl, bisect_right as br, bisect
from collections import defaultdict as dd
mod = pow(10, 9) + 7
mod2 = 998244353
# setrecursionlimit(3000)
def inp(): return stdin.readline().strip()
def iinp(): return int(inp())
def out(var, end="\n"): stdout.write(str(var) + "\n")
def outa(*var, end="\n"): stdout.write(' '.join(map(str, var)) + end)
def lmp(): return list(mp())
def mp(): return map(int, inp().split())
def smp(): return map(str, inp().split())
def l1d(n, val=0): return [val for i in range(n)]
def l2d(n, m, val=0): return [l1d(m, val) for j in range(n)]
def remadd(x, y): return 1 if x % y else 0
def ceil(a, b): return (a + b - 1) // b
def def_value(): return 0
def def_inf(): return inf
def atoi(s): return ord(s)-ord('a')
def inc(s, n=1): return chr((ord(s)-ord('a')+n)%26+ord('a'))
for _ in range(iinp()):
n,k = mp()
s = inp()
win = s.count('W')
if win==0:
print(max(2*min(n,k)-1,0))
else:
dis = int(s[0]=='W')
for i in range(n-1):
if s[i]=='L' and s[i+1]=='W': dis+=1
gp = []
i = 0
while i<n:
if s[i]=='L': i+=1
else: break
while i<n:
cnt = 0
while i<n:
if s[i]=='L': cnt+=1
else: break
i+=1
if cnt>0: gp.append(cnt)
i+=1
if s[n-1]=='L' and len(gp)>0: gp.pop()
#print(gp, dis, win)
gp.sort()
inc = 0
ans = 0
for i in gp:
if inc+i<=k:
inc+=i
ans+=1
else: break
if k+win>=n: print(2*n-1)
else: print(2*(win+k)-dis+ans) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
template <class c>
struct rge {
c b, e;
};
template <class c>
rge<c> range(c i, c j) {
return rge<c>{i, j};
}
template <class c>
auto dud(c* x) -> decltype(cerr << *x, 0);
template <class c>
char dud(...);
struct debug {
template <class c>
debug& operator<<(const c&) {
return *this;
}
};
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t;
cin >> t;
while (t--) {
long long n, k;
cin >> n >> k;
string s;
cin >> s;
vector<pair<pair<long long, long long>, long long>> a;
long long i = 0;
while (i < n) {
if (s[i] == 'L') {
i++;
continue;
}
long long cnt = 0;
long long j = i;
while (j < n and s[j] == 'W') {
j++;
cnt++;
}
a.push_back({{i, j - 1}, cnt});
i = j;
}
sort(a.begin(), a.end());
long long mx = 0;
set<pair<long long, pair<long long, long long>>> p;
for (long long i = 0; i + 1 < a.size(); i++) {
p.insert({a[i + 1].first.first - a[i].first.second - 1, {i + 1, i}});
}
while (1) {
if (p.empty()) break;
long long tp = p.begin()->first;
if (tp <= k) {
for (long long i = a[p.begin()->second.second].first.second;
i <= a[p.begin()->second.first].first.first; i++) {
s[i] = 'W';
}
k -= tp;
} else {
for (long long i = a[p.begin()->second.first].first.first - 1;
i > a[p.begin()->second.second].first.second; i--) {
if (k == 0) break;
s[i] = 'W';
k--;
}
}
p.erase(p.begin());
}
if (k and a.size() > 0) {
for (long long i = a[0].first.first - 1; i >= 0; i--) {
if (k == 0) break;
s[i] = 'W';
k--;
}
for (long long i = a[a.size() - 1].first.second + 1; i < n; i++) {
if (k == 0) break;
s[i] = 'W';
k--;
}
} else {
for (long long i = 0; i < n; i++) {
if (k == 0) break;
s[i] = 'W';
k--;
}
}
i = 0;
while (i < n) {
if (s[i] == 'L') {
i++;
continue;
}
long long cnt = 0;
long long j = i;
while (j < n and s[j] == 'W') {
cnt++;
j++;
}
mx += (cnt * 2) - 1;
i = j;
}
cout << mx << "\n";
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cout << name << " : " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cout.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int TC, i, j;
cin >> TC;
while (TC--) {
long long int n, k, m, q, r;
cin >> n >> k;
string s;
cin >> s;
long long int cW = count(s.begin(), s.end(), 'W');
int ans = 0, fst = 0, lst = 0;
if (cW == 0) {
cout << max(0LL, 2 * k - 1) << '\n';
} else {
vector<pair<int, int> > v;
for (i = 0; i < n; i++) {
bool fl = 0;
if (s[i] == 'L') {
if (i == 0) fl = 1;
int cnt = 1;
while (i < n && s[i + 1] == 'L') {
i++;
cnt++;
}
if (i == n - 1) fl = 1;
if (fl && i != n - 1) {
fst = cnt;
}
if (fl && i == n - 1) {
lst = cnt;
}
if (fl == 0) v.push_back({cnt, fl});
} else if (s[i] == 'W') {
int cnt = 1;
while (i < n && s[i + 1] == 'W') {
i++;
cnt++;
}
ans += 2 * cnt - 1;
}
}
sort(v.begin(), v.end());
int mn = min(fst, lst);
int mx = max(fst, lst);
v.push_back({mn, 1});
v.push_back({mx, 1});
int sum = 0;
for (i = 0; i < (long long int)v.size(); i++) {
if (sum >= k) break;
if (sum + v[i].first <= k) {
ans += 2 * v[i].first + (v[i].second != 1);
sum += v[i].first;
} else {
ans += 2 * (k - sum);
sum += (k - sum);
}
}
cout << ans << '\n';
}
}
return 0;
}
| 8 | CPP |
import sys
import math
import bisect
from sys import stdin, stdout
from math import gcd, floor, sqrt, log2, ceil
from collections import defaultdict as dd
from bisect import bisect_left as bl, bisect_right as br
from bisect import insort
from collections import Counter
from collections import deque
from heapq import heappush,heappop,heapify
from itertools import permutations,combinations
mod = int(1e9)+7
ip = lambda : int(stdin.readline())
inp = lambda: map(int,stdin.readline().split())
ips = lambda: stdin.readline().rstrip()
out = lambda x : stdout.write(str(x)+"\n")
t = ip()
for _ in range(t):
n,k = inp()
s = ips()
if s.count("L") == n:
ans = 0
for i in range(k):
if i == 0:
ans += 1
else:
ans += 2
k = 0
else:
ans = 0
win = 0
for i in range(n):
if s[i] == "W":
if win == 0:
ans += 1
else:
ans += 2
win += 1
else:
win = 0
ct = 0
gap = []
for i in range(n):
if s[i] == "L":
ct += 1
else:
if ct != 0:
gap.append(ct)
ct = 0
if ct != 0:
gap.append(ct)
if s[0] == "L":
gap.pop(0)
if s[-1] == "L":
gap.pop()
gap.sort()
for i in gap:
if k>=i:
ans += 2*i
k -= i
ans += 1
else:
ans += 2*k
k = 0
if k>0:
flag = True
if s[-1] == "L":
for i in range(n-1,-1,-1):
if k == 0:
break
else:
if s[i] == "W":
flag = False
break
else:
ans += 2
k -= 1
if s[0] == "L":
flag = False
for i in range(n):
if k == 0:
break
else:
if s[i] == "W":
flag = True
break
else:
ans += 2
k -= 1
lose = s.count("L")
if lose <= k:
ans = 0
for i in range(n):
if i == 0:
ans += 1
else:
ans += 2
out(ans)
| 8 | PYTHON3 |
t = int(input())
for i in range(t):
n, k = map(int, input().split())
binstr = list(input())
losearr = []
current = 0
active = 0
wincntr = 0
for result in binstr:
if result == 'L':
if active:
wincntr += active
active = 0
current += 1
else:
if current:
losearr.append(current)
current = 0
active += 1
else:
if active:
active += 2
else:
active += 1
wincntr += active
start= 0
if current:
start += current
if binstr[0] == 'L' and losearr:
start += losearr[0]
del losearr[0]
#if binstr[-1] == 'L' and losearr:
# start += losearr[-1]
# del losearr[-1]
#print(losearr)
#print(start)
#print(wincntr)
losearr.sort()
for rest in losearr:
if k >= rest:
wincntr += rest * 2 + 1
k -= rest
else:
wincntr += k * 2
k = 0
break
if k:
if k >= start:
if wincntr:
wincntr += 2 * start
else:
wincntr += 2 * start - 1
else:
if wincntr:
wincntr += k * 2
else:
wincntr += k * 2 - 1
print(wincntr)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1e9;
const int mod = (int)1e9 + 7;
vector<int> g[200200];
void solve() {
int n, k;
scanf("%d%d\n", &n, &k);
vector<char> A(n);
for (int i = 0; i < n; i++) {
scanf("%c", &A[i]);
}
scanf("\n");
for (int i = 0; i <= n; i++) g[i].clear();
int last1 = -1;
for (int i = 0; i < n; i++) {
if (A[i] == 'W') {
if (last1 != -1) {
int len = i - last1;
if (len > 0) {
g[len].push_back(i);
}
}
last1 = i;
}
}
vector<int> order;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < g[i].size(); j++) {
order.push_back(g[i][j]);
}
}
for (int i = 0; i < n; i++) {
if (A[i] == 'W') {
order.push_back(i);
break;
}
}
for (int i = 0; i < order.size(); i++) {
int pos = order[i];
int q = pos - 1;
while (k > 0 && q >= 0 && A[q] != 'W') {
A[q] = 'W';
k--;
q--;
}
}
bool hasSeen1 = false;
for (int i = 0; i < n; i++) {
if (A[i] == 'W') {
hasSeen1 = true;
}
if (A[i] == 'L' && hasSeen1 && k > 0) {
A[i] = 'W';
k--;
}
}
for (int i = 0; i < n; i++) {
if (A[i] == 'L' && k > 0) {
A[i] = 'W';
k--;
}
}
int ans = 0;
for (int i = 0; i < n; i++) {
if (A[i] == 'W') {
if (i >= 1 && A[i - 1] == 'W')
ans += 2;
else
ans += 1;
}
}
cout << ans << endl;
}
int main() {
int t;
scanf("%d", &t);
for (int i = 0; i < t; i++) {
solve();
}
return 0;
}
| 8 | CPP |
from collections import deque
from collections import OrderedDict
import math
import sys
import os
import threading
import bisect
import operator
import heapq
from atexit import register
from io import BytesIO
#sys.stdin = BytesIO(os.read(0, os.fstat(0).st_size))
#sys.stdout = BytesIO()
#register(lambda: os.write(1, sys.stdout.getvalue()))
import io
#input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
from sys import stdin, stdout
#input = sys.stdin.readline
#input = stdin.buffer.readline
#print = stdout.write
#a = [int(x) for x in input().split()]
#import os,io
#input=io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
#sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
#sys.stdin = open("F:\PY\\test.txt", "r")
input = lambda: sys.stdin.readline().rstrip("\r\n")
def printEr(ar1):
for i in range(len(ar1)):
print(ar1[i], end=" ")
for _ in range(int(input())):
n, k = map(int, input().split())
tK = k
s = input()
if n==1:
if s[0]=='L' and k==0:
print(0)
else:
print(1)
continue
if k==1 and s.count('L')==n:
print(1)
continue
if s.count('L')<=k:
print(2*n-1)
continue
if s.count('W')==0 and k!=0:
print(k*2-1)
continue
dp = [0]*(n+1)
dp[0]=(1 if s[0]=='L' else 0)
#need to improve
conLost = []
afWin = False
if s[0]=='W':
afWin = True
for i in range(1, len(s)):
if s[i]=='L':
dp[i]=dp[i-1]+1
else:
if dp[i-1]!=0:
if afWin==True:
conLost.append(dp[i-1])
else:
afWin=True
conLost.sort()
#print(conLost)
s = s+'L'
conWin =0
for i in range(1, n+1):
if s[i]=='L' and s[i-1]=='W':
conWin+=1
# print(conWin)
for i in range(len(conLost)):
if conLost[i]<=k:
conWin-=1
k-=conLost[i]
else:
break
# print(conWin)
answer = 2*(tK+s.count('W'))-conWin
print(answer)
'''
sys.exit(0)
n = int(input())
lis = list(map(int, input().split()))
answer = 0
for i in range(n):
answer+=lis[i]-1
if n==1:
print(n-1)
elif n>32:
print(answer)
sys.exit(0)
lis.sort()
for i in range(2, 50000):
localMin = 0
for j in range(n):
needVal = i**j
localMin+=abs(lis[j]-needVal)
if localMin>answer:
break
else:
answer = min(localMin, answer)
print(answer)
n = int(input())
lis = list(map(int, input().split()))
sumAr = 0
for i in range(n):
sumAr+=lis[i]
k = (sumAr-(n*(n-1)//2))//n
dif = sumAr - (k*n+(n*(n-1)//2))
answer=[]
for i in range(n):
if i<dif:
print(k+i+1)
#print(k+i+1, end=" ")
else:
print(k+i)
#print(k+i, end=" ")
#print(*answer, sep=" ")
sys.exit(0)
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
p1 = Person("heelo", 27)
print(help(Person))
age = 26
name = 'Swaroop'
print('Возрас {} -- {} лет'.format(name, age))
print(help(object))
for _ in range(int(input())):
n = int(input())
ar = list(map(int, input().split()))
dp = [0]*100005
for i in range(n):
dp[ar[i]]+=1
ar.clear()
for i in range(len(dp)):
if dp[i]!=0:
ar.append(dp[i])
ar.sort()
maxC = ar[len(ar)-1]
sumA = sum(ar)
answer=0
for i in range(len(ar)):
if ar[i]==maxC:
answer+=1
sumA-=maxC
answer-=1
answer+= min(sumA//(maxC-1), len(ar)-1)
print(answer)
#sys.exit(0)
def maxDisjointIntervals(list_):
list_.sort(key=lambda x: x[1])
print(list_[0][0], list_[0][1])
r1 = list_[0][1]
for i in range(1, len(list_)):
l1 = list_[i][0]
r2 = list_[i][1]
if l1>r1:
print(l1, r2)
r1 = r2
if __name__ =="__main__1":
N=4
intervals = [[1, 4], [2, 3], [4,6], [8,9]]
maxDisjointIntervals(intervals)
'''
| 8 | PYTHON3 |
import sys
rd = sys.stdin.readline
t = int(rd())
for _ in range(t):
n,k = map(int,rd().split())
s = rd()
if n == 1:
if s[0] == "L" and k == 0:
print(0)
else:
print(1)
continue
gap = [0]*(n-1)
renpai = 0
score = 0
startrenpai,lastrenpai = 0,0
for i in range(n):
if s[i] == "L":
renpai += 1
if i == n-1:
lastrenpai = renpai
else:
if i >= 1 and s[i-1] == "W":
score += 2
else:
score += 1
if renpai == i:
startrenpai = renpai
else:
gap[renpai] += 1
renpai = 0
if n == lastrenpai:
print(max(0,2*min(k,n)-1))
continue
now = 1
while True:
if now == n-1:
score += 2*min(k,startrenpai + lastrenpai)
break
if gap[now] > 0:
if k >= now:
score += 2*now + 1
k -= now
else:
score += 2*k
break
gap[now] -= 1
else:
now += 1
print(score) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 7, inf = 0x3f3f3f3f, mod = 1e9 + 7;
int a[maxn];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int kase;
cin >> kase;
while (kase--) {
int n, k;
cin >> n >> k;
int ans = 0;
string s;
cin >> s;
int last = -1;
vector<int> v;
int sz = 0;
for (int i = 0; i < s.size(); ++i) {
if (s[i] == 'W') {
if (i && s[i - 1] == 'W')
ans += 2;
else {
if (last != -1) v.push_back(i - last - 1);
ans++;
}
last = i;
sz++;
}
}
if (sz == 0) {
cout << max(0, 2 * (k - 1) + 1) << '\n';
continue;
}
sort(v.begin(), v.end());
for (auto &it : v) {
if (k >= it) {
ans += 2 * it + 1, k -= it;
} else {
ans += 2 * k;
k = 0;
break;
}
}
int p1 = 0;
while (s[p1] == 'L') p1++;
ans += min(k, p1) * 2;
k = max(0, k - p1);
int p2 = n - 1, len = 0;
;
while (s[p2] == 'L') p2--, len++;
ans += min(k, len) * 2;
cout << min(ans, 2 * (n - 1) + 1) << '\n';
}
return 0;
}
| 8 | CPP |
import math
from sys import stdin
from sys import setrecursionlimit
setrecursionlimit(100000)
def put(): return map(int, stdin.readline().split())
for _ in range(int(input())):
n,k=put()
s=input()
mx=2*n-1
l=[]
ind=-1
ans=0
# if(s=="L" and k>)
if(s.count("W")==0 and k>0):
print(2*k-1)
else:
if(s[0]=="W"):
ans+=1
for i in range(1,len(s)):
if(s[i]=="W" and s[i-1]=="W"):
ans+=2
elif(s[i]=="W"):
ans+=1
for i in range(len(s)):
if(ind==-1 and s[i]=="W"):
ind=i
elif(s[i]=="W" and (i-ind)>1):
# print(i,i-ind-1)
l.append(i-ind-1)
ind=i
elif(s[i]=="W"):
ind=i
l.sort()
ind=0
while(ind<len(l) and k>=0):
if(l[ind]<=k):
ans+=2*l[ind]+1
k-=l[ind]
else:
ans+=2*k
k=0
ind+=1
if(k>0):
ans+=2*k
print(min(mx,ans)) | 8 | PYTHON3 |
t = int(input())
for _ in range(t):
n, k = map(int, input().split())
s = str(input())
cw = 0
cnt = 0
lcount = -1
llen = dict()
for i in range(n):
if i == 0 and s[i] == 'W':
cnt += 1
lcount = 0
cw += 1
else:
if s[i] == 'W':
if s[i - 1] == 'W':
cnt += 2
else:
cnt += 1
cw += 1
if lcount > 0:
if lcount not in llen.keys():
llen[lcount] = 0
llen[lcount] += 1
lcount = 0
elif lcount < 0:
lcount = 0
else:
if lcount >= 0:
lcount += 1
cl = n - cw
if k == 0:
print(cnt)
else:
lens = []
for e in llen.keys():
lens.append(e)
lens.sort()
delta = 0
for l in lens:
if k < l:
break
count = min(k//l, llen[l])
delta += count * (l * 2 + 1)
k -= count * l
cl -= count * l
if k > 0:
if k <= cl:
if cnt == 0:
delta += (k - 1) * 2 + 1
else:
delta += k * 2
else:
delta += cl * 2
print(cnt + delta)
| 8 | PYTHON3 |
import sys
input = sys.stdin.readline
t=int(input())
for tests in range(t):
n,k=map(int,input().split())
S=input().strip()
if not ("W" in S):
if k==0:
print(0)
else:
print(min(n,k)*2-1)
continue
LIST=[[S[0],0]]
for s in S:
if s==LIST[-1][0]:
LIST[-1][1]+=1
else:
LIST.append([s,1])
#print(LIST)
if LIST[0][0]=="L":
F=LIST.pop(0)
F=F[1]
else:
F=-1
if LIST and LIST[-1][0]=="L":
L=LIST.pop()
L=L[1]
else:
L=-1
#print(LIST,F,L)
# LIST: +2 ,full bonus: +1
# L:+2
# F:+2
ANS=0
LS=[]
for x,y in LIST:
if x=="W":
ANS+=y*2-1
else:
LS.append(y)
LS.sort()
#print(ANS,LS,L,F)
for ls in LS:
if k>=ls:
k-=ls
ANS+=ls*2+1
else:
ANS+=k*2
k=0
if L!=-1:
if k>=L:
ANS+=2*L
k-=L
else:
ANS+=k*2
k=0
#print(ANS)
if F!=-1:
if k>=F:
ANS+=2*F
else:
ANS+=2*k
print(ANS)
| 8 | PYTHON3 |
for _ in range(int(input())):
n,k=map(int,input().split())
s=list(input())
l=[]
prev=0
c=0
f=0
for i in range(n):
if s[i]=='L':
if f==0:
ind=i
f=1
prev=i
c+=1
else:
if c!=0:
l.append([c,ind,prev])
c=0
f=0
if c!=0:
l.append([c,ind,prev])
if s.count('L')<=k:
print(2*n-1)
elif s.count('L')==n:
print(max(2*k-1,0))
else:
l.sort(key=lambda x:x[0])
for i in range(len(l)):
if l[i][1]==0 or l[i][-1]==n-1:
continue
for j in range(l[i][1],l[i][-1]+1):
if k==0:
break
s[j]='W'
k=k-1
if k==0:
break
ans=0
f=0
for i in range(n):
if s[i]=='L':
f=0
else:
if f==0:
ans+=1
f=1
else:
ans+=2
if k==0:
print(ans)
else:
print(ans+k*2) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
char a[100000 + 200];
int lose[100000 + 100];
int main() {
int T;
cin >> T;
while (T--) {
int len, k;
memset(lose, 0, sizeof(lose));
cin >> len >> k;
scanf("%s", a);
int ans = 0, L = 0, c = 0, Lnum = 0;
bool flag = false;
for (int i = 0; i < len; i++) {
if (a[i] == 'W') {
flag = true;
if (L != 0) {
lose[++c] = L;
L = 0;
}
if (a[i - 1] != 'W')
ans += 1;
else
ans += 2;
} else if (a[i] == 'L') {
Lnum++;
if (flag) L++;
}
}
if (L) {
lose[++c] = L;
L = 0;
}
if (Lnum == len) {
printf("%d\n", max(0, min(k, len) * 2 - 1));
continue;
}
if (a[len - 1] == 'L') {
c--;
}
sort(lose + 1, lose + c + 1);
int ori = 1;
while (k && lose[ori] != 0) {
if (k >= lose[ori] && ori <= c) {
k -= lose[ori];
ans += lose[ori] * 2 + 1;
Lnum -= lose[ori];
ori++;
} else {
break;
}
}
if (k > 0 && Lnum > 0) {
int temp = min(k, Lnum);
ans += temp * 2;
}
printf("%d\n", ans);
}
return 0;
}
| 8 | CPP |
from sys import stdin
input = stdin.readline
q = int(input())
for _ in range(q):
n, k = map(int,input().split())
s = input()
if n == 1:
if s.count('W') + k >= 1:
print(1)
else:
print(0)
else:
s = s[:n]
if s.count('L') == n:
du = 2*k-1
du = min(du, 2*n-1)
if k == 0:
du = 0
print(du)
else:
k = min(k, s.count('L'))
los = []
count = 0
for i in range(n):
if s[i] == 'L':
count += 1
else:
if count > 0:
los.append(count)
count = 0
if count > 0:
los.append(count)
if s[0] == 'L':
los.pop(0)
if s[-1] == 'L' and len(los)>0:
los.pop(-1)
los.sort()
win = []
count = 0
for i in range(n):
if s[i] == 'W':
count += 1
else:
if count > 0:
win.append(count)
count = 0
if count > 0:
win.append(count)
wyn = 0
for x in win:
wyn += (2*x-1)
wyk = 0
i = 0
while i < len(los) and wyk + los[i] <= k:
wyn += (2*(los[i]+1)-1)
wyk += los[i]
i += 1
dup = k-wyk
wyn += dup*2
wyn = min(wyn, 2*n-1)
print(wyn) | 8 | PYTHON3 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
const int N = 100010;
char s[N];
int n, k;
int main() {
ios::sync_with_stdio(false);
cin.tie();
cout.tie(0);
int T = 1;
cin >> T;
while (T--) {
cin >> n >> k;
cin >> s + 1;
priority_queue<int, vector<int>, greater<int>> q1, q2, q3;
priority_queue<int> p1, p2;
int cnt = 0;
for (int i = 1; i <= n; i++) {
if (s[i] == 'L')
cnt++;
else {
if (!cnt) continue;
if (i > cnt + 1 && s[i - cnt - 1] == 'W' && i <= n && s[i] == 'W')
q1.push(cnt);
else if (i > cnt + 1 && s[i - cnt - 1] == 'W' || i <= n && s[i] == 'W')
q2.push(cnt);
else
q3.push(cnt);
cnt = 0;
}
}
if (cnt) {
if (n > cnt && s[n - cnt] == 'W')
q2.push(cnt);
else
q3.push(cnt);
}
int res = 0;
while (k && q1.size()) {
auto v = q1.top();
q1.pop();
if (k >= v)
res += 2 * v + 1, k -= v;
else
p1.push(v);
}
while (k && q2.size()) {
auto v = q2.top();
q2.pop();
if (k >= v)
res += 2 * v, k -= v;
else
p2.push(v);
}
while (k && (p1.size() || p2.size())) {
res += 2 * k;
k = 0;
}
if (k && q3.size()) {
auto v = q3.top();
res = 2 * min(k, v) - 1;
}
for (int i = 1; i <= n; i++) {
if (s[i] == 'W') {
if (i > 1 && s[i - 1] == 'W')
res += 2;
else
res++;
}
}
cout << res << '\n';
}
return 0;
}
| 8 | CPP |
for _ in range(int(input())):
n, k = [int(i) for i in input().split()]
s = input()
s2 = s.strip("L")
Ls = len(s)-len(s2)
chains = []
chain = 0
score = 0
streak = False
for char in s2:
if char == "W":
if streak:
score += 2
else:
score += 1
streak = True
else:
streak = False
for char in s2.strip("W"):
if char == "W" and chain != 0:
chains.append(chain)
chain = 0
elif char == "L":
chain += 1
if chain != 0:
chains.append(chain)
chains.sort()
i = 0
while chains and k >= chains[i]:
k -= chains[i]
score += 2*chains[i]+1
i += 1
if i >= len(chains):
break
Ls += sum(chains[i:])
if k:
if k > Ls:
score += 2*Ls
else:
if "W" in s:
score += 2*k
else:
score += 2*k-1
print(score)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 200000;
const int MOD = 1000000007;
const int OO = 0x3f3f3f3f;
const double EPS = 1e-9;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int32_t main() {
int t;
cin >> t;
while (t--) {
int n, k;
string s;
cin >> n >> k >> s;
int l = 0, r = n - 1;
while (l < n and s[l] == 'L') l++;
while (r >= 0 and s[r] == 'L') r--;
vector<pair<int, int> > arr;
while (l <= r) {
while (l <= r and s[l] != 'L') l++;
int L = l;
while (l <= r and s[l] == 'L') l++;
int R = l - 1;
if (L <= R) arr.push_back({L, R});
}
sort(arr.begin(), arr.end(), [](pair<int, int> a, pair<int, int> b) {
return a.second - a.first < b.second - b.first;
});
for (int i = 0; i < arr.size(); i++) {
int a = arr[i].first;
int b = arr[i].second;
if (b - a + 1 > k) continue;
for (int j = a; j <= b; j++) s[j] = 'W';
k -= (b - a + 1);
}
int w = 0;
for (int i = 0; i < n; i++)
if (s[i] == 'W') w = i, i = n;
for (int j = w; j < n and k > 0; j++)
if (s[j] == 'L') s[j] = 'W', k--;
for (int j = w; j >= 0 and k > 0; j--)
if (s[j] == 'L') s[j] = 'W', k--;
int ans = 0;
for (int i = 0; i < n; i++) {
if (s[i] != 'W') continue;
if (!i)
ans++;
else if (s[i - 1] == 'W')
ans += 2;
else
ans++;
}
cout << ans << endl;
}
return 0;
}
| 8 | CPP |
for _ in range(int(input())):
n, k = map(int, input().split())
s = input()
k = min(k, s.count("L"))
arr = []
cur = 0
sc = 0
se = False
if s[0] == "W":
sc += 1
for e in s:
if e == "L":
cur += 1
else:
if cur > 0 and se:
arr.append(cur)
se = True
cur = 0
for i in range(1, n):
if s[i] == "W":
if s[i-1] == "W":
sc += 2
else:
sc += 1
arr.sort()
arr.reverse()
#print(arr, sc)
while len(arr) > 0 and arr[-1] <= k:
k -= arr[-1]
sc += arr[-1]*2+1
arr.pop()
#print(k)
sc += k*2
if k > 0 and s.count("W") == 0:
sc -= 1
print(sc)
| 8 | PYTHON3 |
import random
def gcd(a, b):
if a == 0:
return b
return gcd(b % a, a)
def lcm(a, b):
return (a * b) / gcd(a, b)
for _ in range(int(input())):
n, k = map(int, input().split())
s = input()
a = []
for i in s:
if i == 'L':
a.append(0)
else:
a.append(1)
for i in range(n):
if i != 0 and i != n - 1:
if a[i - 1] == 1 and a[i + 1] == 1 and a[i] == 0 and k>0:
k -= 1
a[i] = 1
c = 0
l = -1
f = []
edge=[]
for i in range(n):
if a[i] == 0 and l == -1:
l = i
elif a[i] == 1 and l != -1:
if l==0:
edge.append([i - l, [l, i - 1]])
else:
f.append([i-l, [l, i - 1]])
l=-1
if l != -1:
edge.append([n - l, [l, n - 1]])
f.sort()
edge.sort()
i = 0
while (k > 0 and i<len(f)):
for j in range(f[i][1][0], f[i][1][1] + 1):
a[j] = 1
k -= 1
if k == 0:
break
i += 1
i=0
while(k>0 and i<len(edge)):
if edge[i][1][0]==0:
for j in range(edge[i][1][1], edge[i][1][0]-1,-1):
a[j] = 1
k -= 1
if k == 0:
break
else:
for j in range(edge[i][1][0], edge[i][1][1] + 1):
a[j] = 1
k -= 1
if k == 0:
break
i += 1
ans=0
for i in range(n):
if a[i]==1:
if i==0:
ans+=1
else:
if a[i-1]==1:
ans+=2
else:
ans+=1
print(ans)
# print(a)
# print('------------')
| 8 | PYTHON3 |
for _ in range(int(input())):
n,k = map(int,input().split())
s = input()
L = s.count("L")
W = s.count("W")
score = 0
if(s[0] == "W"):
score+=1
for i in range(1,n):
if(s[i] == "W"):
if(s[i-1] == "W"):
score += 2
else:
score += 1
start = False
count = 0
List = []
for i in range(n):
if(start):
if(s[i] == "W"):
if(count):
List.append(count)
count = 0
else:
count+=1
else:
if(s[i] == "W"):
start = True
List.sort()
if(W):
for i in List:
if(k):
if(k>=i):
score += (i-1) * 2 + 3
k-=i
L-=i
else:
score += k * 2
k = 0
L-=k
if(k):
score += min(k,L) * 2
print(score)
else:
if(k):
print(min(k,L)*2 -1)
else:
print(0)
| 8 | PYTHON3 |
import sys
input = lambda:sys.stdin.readline()
int_arr = lambda: list(map(int,input().split()))
str_arr = lambda: list(map(str,input().split()))
get_str = lambda: map(str,input().split())
get_int = lambda: map(int,input().split())
get_flo = lambda: map(float,input().split())
mod = 1000000007
def solve(n,k,s):
c = 0
if s[0] == "W":
c = 1
for i in range(1,n):
if s[i] == "W" and s[i-1] == "W":
c += 2
elif s[i] == "W":
c += 1
if k == 0:
print(c)
return
l,r = 0,0
for i in range(n):
if s[i] == "W":
l = i
break
for i in range(n-1,-1,-1):
if s[i] == "W":
r = i
break
ans = []
tmp = 0
for i in range(l,r+1):
if s[i] == "L":
tmp += 1
else:
if tmp != 0:
ans.append(tmp)
tmp = 0
ans.sort()
for i in ans:
if i <= k:
c += (2*i)+1
k -= i
else:
c += (2*k)
k = 0
break
if k > 0 and c > 0:
c += min(n-(r+1),k)*(2)
k -= (n-(r+1))
if k > 0:
c += min(k,l)*(2)
print(c if c != 0 else max(k,1)*2-1)
for _ in range(int(input())):
n,k = get_int()
s = str(input())[:-1]
solve(n,k,s) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long int n, k;
cin >> n >> k;
;
string s;
cin >> s;
long long int nl = 0, nw = 0;
vector<long long int> g;
long long int gl = 0;
bool ok = false;
for (long long int i = 0; i < n; i++) {
if (s[i] == 'W')
nw++;
else {
nl++;
}
if (s[i] == 'W') {
if (gl != 0) g.push_back(gl);
gl = 0;
ok = true;
} else {
if (ok) gl++;
}
}
if (nl <= k) {
cout << 1 + ((n - 1) * 2) << "\n";
return;
}
if (nw == 0) {
if (k == 0)
cout << 0 << "\n";
else
cout << 1 + ((k - 1) * 2) << "\n";
return;
}
sort((g).begin(), (g).end());
long long int ans = 0;
for (long long int i = 0; i < n; i++) {
if (i == 0) {
if (s[i] == 'W') ans++;
continue;
}
if (s[i] == 'W') {
ans++;
if (s[i - 1] == 'W') ans++;
}
}
for (auto e : g) {
if (e <= k) {
ans += 1 + (e * 2);
k -= e;
} else {
break;
}
}
ans += k * 2;
cout << ans;
cout << "\n";
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t;
cin >> t;
while (t-- > 0) {
solve();
}
return 0;
}
| 8 | CPP |
from sys import stdin
"""
n=int(stdin.readline().strip())
n,m=map(int,stdin.readline().strip().split())
s=list(map(int,stdin.readline().strip().split()))
s=stdin.readline().strip()
"""
T=int(stdin.readline().strip())
for caso in range(T):
n,k=map(int,stdin.readline().strip().split())
s=list(stdin.readline().strip())
aux=[]
last=-1
for i in range(n):
if i>0 and s[i]=='L' and s[i-1]=='W':
last=i
if i<n-1 and s[i]=='L' and s[i+1]=='W' and last!=-1:
aux.append([i-last,last,i])
aux.sort()
for i in aux:
for j in range(i[1],i[2]+1):
if k>0:
s[j]='W'
k-=1
ini=-1
fin=n
for i in range(n):
if s[i]=='W':
ini=i-1
break
for i in range(n-1,-1,-1):
if s[i]=='W':
fin=i+1
break
for i in range(ini,-1,-1):
if k>0:
s[i]='W'
k-=1
for i in range(fin,n):
if k>0:
s[i]='W'
k-=1
ans=0
if ini==-1 and fin==n:
for i in range(n):
if k>0:
s[i]='W'
k-=1
for i in range(n):
if s[i]=='W':
if i>0 and s[i-1]=='W':
ans+=2
else:
ans+=1
print(ans)
| 8 | PYTHON3 |
import sys
T = int(sys.stdin.readline())
for t in range(0, T):
n, k = list(map(int, sys.stdin.readline().strip().split()))
s = sys.stdin.readline().strip()
ans = 0
v = False
k2 = k
x = 0
y = 0
if s[0] == "W":
y = 1
ans = 1
v = True
else:
x = 1
L = []
for i in range (1, n):
if s[i] == "W":
if x > 0:
L.append(x)
if v == True:
ans = ans + 2
else:
ans = ans + 1
v = True
x = 0
y = y + 1
else:
v = False
x = x + 1
L2 = []
if x > 0:
L2.append(x)
if s[0] == "L" and len(L) > 0:
L2.append(L[0])
L = L[1:]
L.sort()
L.reverse()
while k > 0 and len(L) > 0:
l = L.pop()
if l <= k:
k = k - l
ans = ans + 2 * l + 1
else:
ans = ans + 2 * k
k = 0
if k > 0:
ans = ans + min(sum(L2), k) * 2
if y > 0:
print(ans)
else:
print(max(0, 2 * k2 - 1)) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
bool customSort(pair<int, int> a, pair<int, int> b) {
if (a.first == b.first) {
return a.second > b.second;
}
return a.first < b.first;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int t;
cin >> t;
while (t--) {
int n, k;
cin >> n >> k;
string str;
cin >> str;
str = "L" + str + "L";
vector<int> p1, p2, p3;
int totw = 0;
vector<int> wind;
int score = 0;
for (int i = 1; i <= n; i++) {
if (str[i] == 'W') {
totw++;
score++;
if (str[i - 1] == 'W') {
score++;
}
wind.push_back(i);
}
}
if (totw == 0) {
for (int i = 1; i <= k; i++) {
str[i] = 'W';
score++;
if (str[i - 1] == 'W') {
score++;
}
}
} else if (totw + k >= n) {
for (int i = 1; i <= n; i++) {
str[i] = 'W';
}
score = (n - 1) * 2 + 1;
} else {
vector<pair<int, int>> gaps;
for (int i = 1; i < wind.size(); i++) {
if (wind[i] - wind[i - 1] - 1 > 0) {
gaps.push_back(
{wind[i] - wind[i - 1] - 1, 2 * (wind[i] - wind[i - 1] - 1) + 1});
}
}
sort(gaps.begin(), gaps.end(), customSort);
int ind = 0;
while (k > 0) {
if (ind >= gaps.size()) {
break;
}
int replace = gaps[ind].first;
if (k >= replace) {
k -= replace;
score += gaps[ind].second;
} else {
score += k * 2;
k = 0;
}
ind++;
}
if (k > 0) {
score += 2 * k;
}
}
cout << score << endl;
}
}
| 8 | CPP |
for _ in range(int(input())):
#n = int(input())
n, k = map(int, input().split())
a = list(input())
f = False
d = 0
cntt = 0
temp = []
for i, c in enumerate(a):
if c=='W':
if f and cntt != 0:
temp.append((cntt, d))
cntt = 0
elif f==False:f = True
else:
if cntt == 0 and f:
d = i
if f:cntt += 1
temp.sort()
#print(temp)
for x, y in temp:
if k>x:
a[y:y+x] = ['W']*x
k -= x
else:
a[y:y+k] = ['W']*k
k = 0
break
#print(a)
f = False
for i, c in enumerate(a):
if k==0:break
if f:
if c=='L':
a[i]='W'
k -= 1
if k==0:break
elif c=='W':
dist = i
f = True
#print(a)
if k>0 and f:
if dist>=k:
a[dist-k:dist] = ['W']*k
else:
a[0:dist] = ['W']*dist
elif k>0:
for i, c in enumerate(a):
if c=='L':
a[i] = 'W'
k -= 1
if k==0:break
#print(a)
ans = 0
p=False
for c in a:
if p==False and c=='W':
ans += 1
p = True
elif p and c=='W':
ans += 2
else:
p = False
print(ans) | 8 | PYTHON3 |
for _ in range(int(input())):
n, k = map(int, input().split())
inp = input().lower()
k = min(k, inp.count('l'))
ans = inp.count('w') + tuple(zip(inp, 'l' + inp)).count('ww') + k * 2
if 'w' in inp:
inp2 = []
cur = -1
for c in inp:
if cur != -1:
if c == 'l':
cur += 1
else:
inp2.append(cur)
if c == 'w':
cur = 0
inp2.sort()
for inp2i in inp2:
if inp2i > k:
break
k -= inp2i
ans += 1
else:
ans = max(ans - 1, 0)
print(ans)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long int t;
cin >> t;
while (t--) {
int n, k;
cin >> n >> k;
string s;
cin >> s;
int w = 0;
for (auto i : s) {
if (i == 'W') {
w++;
}
}
if (w == 0) {
cout << max(2 * k - 1, 0) << "\n";
continue;
}
w += k;
if (w >= n) {
cout << n * 2 - 1 << "\n";
continue;
}
vector<long long int> v;
long long int val = 0;
for (long long int i = 0; i < n; i++) {
if (s[i] == 'L') {
val++;
} else {
v.push_back(val);
val = 0;
}
}
if (val > 0) {
v.push_back(val);
}
if (s[0] == 'L') {
v.erase(v.begin());
}
if (s[n - 1] == 'L') {
v.erase(v.begin() + v.size() - 1);
}
long long int p = 0, i;
sort(v.begin(), v.end());
for (i = 0; i < v.size(); i++) {
if (p + v[i] > k) {
break;
}
p += v[i];
}
long long int wl = v.size() - i;
cout << 2 * w - wl - 1 << "\n";
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<long long> gap;
long long n, k, cnt, ccnt;
char seq[100005];
void solve() {
gap.clear();
long long lent = 0;
long long i = 0;
while (seq[i] == 'L') {
++i;
}
for (; i < n; ++i) {
if (seq[i] == 'L') {
lent++;
} else {
if (lent) {
gap.push_back(lent);
lent = 0;
}
}
}
sort(gap.begin(), gap.end());
long long gaps = gap.size() + 1;
for (int i = 0; i < (int)gap.size(); ++i) {
if (k >= gap[i]) {
k -= gap[i];
gaps--;
}
}
printf("%lld\n", cnt * 2 - gaps > 0 ? cnt * 2 - gaps : 0);
}
int main() {
int Case;
scanf("%d", &Case);
while (Case--) {
scanf("%lld %lld", &n, &k);
getchar();
ccnt = cnt = 0;
for (int i = 0; i < n; ++i) {
scanf("%c", &seq[i]);
if (seq[i] == 'W') {
ccnt++;
}
}
cnt = ccnt + k;
cnt = cnt > n ? n : cnt;
solve();
}
return 0;
}
| 8 | CPP |
t = int(input())
for it in range(0, t):
n, k = tuple(list(map(int, input().split(' '))))
results = [char for char in input()]
initial_score = 0
loss_amount = 0
for i in range(0, len(results)):
if i > 0 and results[i] == 'W' and results[i - 1] == 'W':
initial_score += 1
if results[i] == 'L':
loss_amount += 1
k = min(k, loss_amount)
initial_score += (n - loss_amount)
streak_increase_added_score = 2 * k
if loss_amount == n and streak_increase_added_score > 0:
streak_increase_added_score -= 1
streak_diffs = []
current_streak_diff = 0
streak_found = 0
for i in range(0, n):
if results[i] == 'W':
streak_found = True
if current_streak_diff != 0:
streak_diffs.append(current_streak_diff)
current_streak_diff = 0
if results[i] == 'L' and streak_found:
current_streak_diff += 1
sorted_streak_diffs = sorted(streak_diffs)
disjoint_streak_decrease_added_score = 0
for i in range(0, len(sorted_streak_diffs)):
if k >= sorted_streak_diffs[i]:
disjoint_streak_decrease_added_score += 1
k -= sorted_streak_diffs[i]
else:
break
final_score = (initial_score + streak_increase_added_score + disjoint_streak_decrease_added_score)
print(final_score)
| 8 | PYTHON3 |
# ---------------------------iye ha aam zindegi---------------------------------------------
import math
import random
import heapq, bisect
import sys
from collections import deque, defaultdict
from fractions import Fraction
import sys
import threading
from collections import defaultdict
#threading.stack_size(10**8)
mod = 10 ** 9 + 7
mod1 = 998244353
# ------------------------------warmup----------------------------
import os
import sys
from io import BytesIO, IOBase
#sys.setrecursionlimit(300000)
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# -------------------game starts now----------------------------------------------------import math
class TreeNode:
def __init__(self, k, v):
self.key = k
self.value = v
self.left = None
self.right = None
self.parent = None
self.height = 1
self.num_left = 1
self.num_total = 1
class AvlTree:
def __init__(self):
self._tree = None
def add(self, k, v):
if not self._tree:
self._tree = TreeNode(k, v)
return
node = self._add(k, v)
if node:
self._rebalance(node)
def _add(self, k, v):
node = self._tree
while node:
if k < node.key:
if node.left:
node = node.left
else:
node.left = TreeNode(k, v)
node.left.parent = node
return node.left
elif node.key < k:
if node.right:
node = node.right
else:
node.right = TreeNode(k, v)
node.right.parent = node
return node.right
else:
node.value = v
return
@staticmethod
def get_height(x):
return x.height if x else 0
@staticmethod
def get_num_total(x):
return x.num_total if x else 0
def _rebalance(self, node):
n = node
while n:
lh = self.get_height(n.left)
rh = self.get_height(n.right)
n.height = max(lh, rh) + 1
balance_factor = lh - rh
n.num_total = 1 + self.get_num_total(n.left) + self.get_num_total(n.right)
n.num_left = 1 + self.get_num_total(n.left)
if balance_factor > 1:
if self.get_height(n.left.left) < self.get_height(n.left.right):
self._rotate_left(n.left)
self._rotate_right(n)
elif balance_factor < -1:
if self.get_height(n.right.right) < self.get_height(n.right.left):
self._rotate_right(n.right)
self._rotate_left(n)
else:
n = n.parent
def _remove_one(self, node):
"""
Side effect!!! Changes node. Node should have exactly one child
"""
replacement = node.left or node.right
if node.parent:
if AvlTree._is_left(node):
node.parent.left = replacement
else:
node.parent.right = replacement
replacement.parent = node.parent
node.parent = None
else:
self._tree = replacement
replacement.parent = None
node.left = None
node.right = None
node.parent = None
self._rebalance(replacement)
def _remove_leaf(self, node):
if node.parent:
if AvlTree._is_left(node):
node.parent.left = None
else:
node.parent.right = None
self._rebalance(node.parent)
else:
self._tree = None
node.parent = None
node.left = None
node.right = None
def remove(self, k):
node = self._get_node(k)
if not node:
return
if AvlTree._is_leaf(node):
self._remove_leaf(node)
return
if node.left and node.right:
nxt = AvlTree._get_next(node)
node.key = nxt.key
node.value = nxt.value
if self._is_leaf(nxt):
self._remove_leaf(nxt)
else:
self._remove_one(nxt)
self._rebalance(node)
else:
self._remove_one(node)
def get(self, k):
node = self._get_node(k)
return node.value if node else -1
def _get_node(self, k):
if not self._tree:
return None
node = self._tree
while node:
if k < node.key:
node = node.left
elif node.key < k:
node = node.right
else:
return node
return None
def get_at(self, pos):
x = pos + 1
node = self._tree
while node:
if x < node.num_left:
node = node.left
elif node.num_left < x:
x -= node.num_left
node = node.right
else:
return (node.key, node.value)
raise IndexError("Out of ranges")
@staticmethod
def _is_left(node):
return node.parent.left and node.parent.left == node
@staticmethod
def _is_leaf(node):
return node.left is None and node.right is None
def _rotate_right(self, node):
if not node.parent:
self._tree = node.left
node.left.parent = None
elif AvlTree._is_left(node):
node.parent.left = node.left
node.left.parent = node.parent
else:
node.parent.right = node.left
node.left.parent = node.parent
bk = node.left.right
node.left.right = node
node.parent = node.left
node.left = bk
if bk:
bk.parent = node
node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
node.num_left = 1 + self.get_num_total(node.left)
def _rotate_left(self, node):
if not node.parent:
self._tree = node.right
node.right.parent = None
elif AvlTree._is_left(node):
node.parent.left = node.right
node.right.parent = node.parent
else:
node.parent.right = node.right
node.right.parent = node.parent
bk = node.right.left
node.right.left = node
node.parent = node.right
node.right = bk
if bk:
bk.parent = node
node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
node.num_left = 1 + self.get_num_total(node.left)
@staticmethod
def _get_next(node):
if not node.right:
return node.parent
n = node.right
while n.left:
n = n.left
return n
# -----------------------------------------------binary seacrh tree---------------------------------------
class SegmentTree1:
def __init__(self, data, default=2**30, func=lambda a, b: min(a , b)):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
# -------------------game starts now----------------------------------------------------import math
class SegmentTree:
def __init__(self, data, default=0, func=lambda a, b:max(a , b)):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
# -------------------------------iye ha chutiya zindegi-------------------------------------
class Factorial:
def __init__(self, MOD):
self.MOD = MOD
self.factorials = [1, 1]
self.invModulos = [0, 1]
self.invFactorial_ = [1, 1]
def calc(self, n):
if n <= -1:
print("Invalid argument to calculate n!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.factorials):
return self.factorials[n]
nextArr = [0] * (n + 1 - len(self.factorials))
initialI = len(self.factorials)
prev = self.factorials[-1]
m = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = prev * i % m
self.factorials += nextArr
return self.factorials[n]
def inv(self, n):
if n <= -1:
print("Invalid argument to calculate n^(-1)")
print("n must be non-negative value. But the argument was " + str(n))
exit()
p = self.MOD
pi = n % p
if pi < len(self.invModulos):
return self.invModulos[pi]
nextArr = [0] * (n + 1 - len(self.invModulos))
initialI = len(self.invModulos)
for i in range(initialI, min(p, n + 1)):
next = -self.invModulos[p % i] * (p // i) % p
self.invModulos.append(next)
return self.invModulos[pi]
def invFactorial(self, n):
if n <= -1:
print("Invalid argument to calculate (n^(-1))!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.invFactorial_):
return self.invFactorial_[n]
self.inv(n) # To make sure already calculated n^-1
nextArr = [0] * (n + 1 - len(self.invFactorial_))
initialI = len(self.invFactorial_)
prev = self.invFactorial_[-1]
p = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = (prev * self.invModulos[i % p]) % p
self.invFactorial_ += nextArr
return self.invFactorial_[n]
class Combination:
def __init__(self, MOD):
self.MOD = MOD
self.factorial = Factorial(MOD)
def ncr(self, n, k):
if k < 0 or n < k:
return 0
k = min(k, n - k)
f = self.factorial
return f.calc(n) * f.invFactorial(max(n - k, k)) * f.invFactorial(min(k, n - k)) % self.MOD
# --------------------------------------iye ha combinations ka zindegi---------------------------------
def powm(a, n, m):
if a == 1 or n == 0:
return 1
if n % 2 == 0:
s = powm(a, n // 2, m)
return s * s % m
else:
return a * powm(a, n - 1, m) % m
# --------------------------------------iye ha power ka zindegi---------------------------------
def sort_list(list1, list2):
zipped_pairs = zip(list2, list1)
z = [x for _, x in sorted(zipped_pairs)]
return z
# --------------------------------------------------product----------------------------------------
def product(l):
por = 1
for i in range(len(l)):
por *= l[i]
return por
# --------------------------------------------------binary----------------------------------------
def binarySearchCount(arr, n, key):
left = 0
right = n - 1
count = 0
while (left <= right):
mid = int((right + left) / 2)
# Check if middle element is
# less than or equal to key
if (arr[mid] < key):
count = mid + 1
left = mid + 1
# If key is smaller, ignore right half
else:
right = mid - 1
return count
# --------------------------------------------------binary----------------------------------------
def countdig(n):
c = 0
while (n > 0):
n //= 10
c += 1
return c
def binary(x, length):
y = bin(x)[2:]
return y if len(y) >= length else "0" * (length - len(y)) + y
def countGreater(arr, n, k):
l = 0
r = n - 1
# Stores the index of the left most element
# from the array which is greater than k
leftGreater = n
# Finds number of elements greater than k
while (l <= r):
m = int(l + (r - l) / 2)
if (arr[m] > k):
leftGreater = m
r = m - 1
# If mid element is less than
# or equal to k update l
else:
l = m + 1
# Return the count of elements
# greater than k
return (n - leftGreater)
# --------------------------------------------------binary------------------------------------
class TrieNode:
def __init__(self):
self.children = [None] * 26
self.isEndOfWord = False
class Trie:
def __init__(self):
self.root = self.getNode()
def getNode(self):
return TrieNode()
def _charToIndex(self, ch):
return ord(ch) - ord('a')
def insert(self, key):
pCrawl = self.root
length = len(key)
for level in range(length):
index = self._charToIndex(key[level])
if not pCrawl.children[index]:
pCrawl.children[index] = self.getNode()
pCrawl = pCrawl.children[index]
pCrawl.isEndOfWord = True
def search(self, key):
pCrawl = self.root
length = len(key)
for level in range(length):
index = self._charToIndex(key[level])
if not pCrawl.children[index]:
return False
pCrawl = pCrawl.children[index]
return pCrawl != None and pCrawl.isEndOfWord
#-----------------------------------------trie---------------------------------
class Node:
def __init__(self, data):
self.data = data
self.count=0
self.left = None # left node for 0
self.right = None # right node for 1
class BinaryTrie:
def __init__(self):
self.root = Node(0)
def insert(self, pre_xor):
self.temp = self.root
for i in range(31, -1, -1):
val = pre_xor & (1 << i)
if val:
if not self.temp.right:
self.temp.right = Node(0)
self.temp = self.temp.right
self.temp.count+=1
if not val:
if not self.temp.left:
self.temp.left = Node(0)
self.temp = self.temp.left
self.temp.count += 1
self.temp.data = pre_xor
def query(self, xor):
self.temp = self.root
for i in range(31, -1, -1):
val = xor & (1 << i)
if not val:
if self.temp.left and self.temp.left.count>0:
self.temp = self.temp.left
elif self.temp.right:
self.temp = self.temp.right
else:
if self.temp.right and self.temp.right.count>0:
self.temp = self.temp.right
elif self.temp.left:
self.temp = self.temp.left
self.temp.count-=1
return xor ^ self.temp.data
#-------------------------bin trie-------------------------------------------
for ik in range(int(input())):
n,k=map(int,input().split())
s=list(input())
last=-1
diff=[]
cou=0
cur=0
ans=0
for i in range(n):
if s[i]=='W':
ans+=1
if i>0 and s[i-1]=='W':
ans+=1
if last!=-1:
if cur!=0:
diff.append(cur)
cur=0
last=i
else:
cou+=1
cur+=1
k=min(cou,k)
diff.sort()
for i in range(len(diff)):
if k>=diff[i]:
ans+=diff[i]*2+1
k-=diff[i]
else:
break
ans+=k*2
if cou==n and k>0:
ans-=1
print(ans)
| 8 | PYTHON3 |
for _ in range(int(input())):
n,x=map(int,input().split())
l=list(input())
t=[]
temp=x
c=0
m=0
s=0
f=0
m2=0
e=0
for i in range(1,n):
if l[i]=='W':
if l[i-1]=='W':
s+=2
else:
s+=1
if l[0]=='W':
s+=1
for i in range(n):
if l[i]=='L':
if i==0:
f=1
c+=1
else:
if c!=0 and f==0:
t.append(c)
if f==1:
m2=c
c=0
f=0
if c!=0:
if f==1:
e=1
m2=c
else:
m=c
c=0
t.sort()
for i in t:
if x>=i:
s+=2*i
s+=1
x-=i
else:
s+=2*x
x-=x
if x!=0 and m!=0:
if x>=m:
s+=2*m
x-=m
else:
s+=2*x
x-=x
if x!=0 and m2!=0:
if x>=m2:
s+=2*m2
x-=m2
else:
s+=2*x
x-=x
if e==1:
if temp!=0:
print(2*(temp-1)+1)
else:
print(0)
else:
print(s)
| 8 | PYTHON3 |
t = int(input())
for q in range(t):
n, k = map(int, input().split())
s = input()
kol = []
mas = []
l = -1
kz = 0
for i in range(n):
if s[i] == 'W':
if l == -1:
l = i
r = i
else:
r = i
mas.append(1)
else:
if l != -1:
kol.append([l, r])
l = -1
mas.append(0)
if l != -1:
kol.append([l, r])
ans = []
for i in range(len(kol) - 1):
ans.append(kol[i + 1][0] - kol[i][1] - 1)
ans.sort()
#print(mas)
#print(kol)
#print(ans)
if kol == []:
gh = 0
if k > 0:
gh += 1
k -= 1
gh += k * 2
print(gh)
else:
gh = 0
for i in kol:
if i[0] == i[1]:
gh += 1
else:
gh += 1 + (i[1] - i[0]) * 2
#print("A", gh)
for i in ans:
z = i
#print(k, z)
if k < z:
break
if z == 1:
if k > 0:
gh += 3
k -= 1
kz += 1
else:
gh += 3 + (z - 1) * 2
k -= z
kz += z
#print("B", gh)
dz = sum(mas) + kz
dz = n - dz
gh += min(k, dz) * 2
print(gh)
| 8 | PYTHON3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.