solution
stringlengths 10
983k
| difficulty
int64 0
25
| language
stringclasses 2
values |
|---|---|---|
def solve(n,s):
result=''
i=0
if(s.count('0')==len(s) or s.count('1')==len(s)):
return s[:n]
if(s=='101'):
return '00'
elif(s=='010'):
return '11'
while(i<len(s)):
result+=s[i]
i+=2
return result
t=int(input())
for _ in range(t):
n=int(input())
s=str(input())
print(solve(n,s))
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, area;
long long ret = 0;
int main() {
scanf("%d%d%d", &n, &m, &area);
for (int i = 0; i <= n / 2; i++)
for (int j = 0; j <= m / 2; j++)
for (int k = 0; k <= n / 2; k++) {
long long a = (2 * i + 1) * (2 * j + 1);
int l;
int mi = min(i, k);
if (a == area && k <= i) {
ret += (j + 1) * (n - (i * 2 + 1) + 1) * (m - (j * 2 + 1) + 1);
continue;
}
if ((area + (mi * 2 + 1) * (2 * j + 1) - a) % (2 * k + 1) == 0) {
if (((area + (mi * 2 + 1) * (2 * j + 1) - a) / (2 * k + 1) - 1) % 2 ==
0) {
l = ((area + (mi * 2 + 1) * (2 * j + 1) - a) / (2 * k + 1) - 1) / 2;
if (l >= j) {
if (n - (max(i, k) * 2 + 1) >= 0 && m - (max(j, l) * 2 + 1) >= 0)
ret += (n - (max(i, k) * 2 + 1) + 1) *
(m - (max(j, l) * 2 + 1) + 1);
}
}
}
if (k != mi && (area - a) % (2 * k - 2 * mi) == 0) {
if (((area - a) / (2 * k - 2 * mi) - 1) % 2 == 0) {
l = ((area - a) / (2 * k - 2 * mi) - 1) / 2;
if (l < j && l >= 0) {
if (n - (max(i, k) * 2 + 1) >= 0 && m - (max(j, l) * 2 + 1) >= 0)
ret += (n - (max(i, k) * 2 + 1) + 1) *
(m - (max(j, l) * 2 + 1) + 1);
}
}
}
}
printf("%I64d\n", ret);
}
| 9 | CPP |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Thu Apr 4 16:05:33 2019
@author: xungao
"""
a = input()
if a.isupper():
print(a.lower())
elif a[1:]=='' or a[1:].isupper():
print(a.title())
else:
print(a) | 7 | PYTHON3 |
#include <iostream>
using namespace std;
int main()
{
int x,y;
cin>>x>>y;
cout<<x+(y/2);
} | 0 | CPP |
from fractions import gcd
N = int(input())
A = [int(i) for i in input().split()]
lcm = A[0]
MOD = 10**9 + 7
for a in A:
lcm = (lcm // gcd(lcm,a) * a)
res = 0
for a in A:
res += lcm //a
print(res % MOD)
| 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
namespace Number {
long long int gcd(long long int a, long long int b) {
if (a % b == 0) {
return b;
}
return gcd(b, a % b);
}
long long int gcd_extend(long long int a, long long int b, long long int *x,
long long int *y) {
if (a == 0) {
*x = 0, *y = 1;
return b;
}
long long int x1, y1;
long long int gcd = gcd_extend(b % a, a, &x1, &y1);
*x = y1 - (b / a) * x1;
*y = x1;
return gcd;
}
long long int mod_inv(long long int a, long long int m) {
long long int x, y;
long long int g = gcd_extend(a, m, &x, &y);
long long int a_inv = (x % m + m) % m;
return a_inv;
}
long long int mod_pow(long long int x, long long int n, long long int m) {
if (n == 0) {
return 1;
} else if (n & 1) {
long long int half = mod_pow(x, n / 2, m);
return (half * half % m) * x % m;
} else {
long long int half = mod_pow(x, n / 2, m);
return half * half % m;
}
}
long long int mul(long long int from, long long int to, long long int m) {
long long int ret = 1;
for (long long int i = from; i <= to; i++) {
ret *= i;
ret %= m;
}
return ret;
}
long long int mod_comb(long long int n, long long int k, long long int m) {
long long int mi = k < n - k ? k : n - k;
long long int up = mul(n - mi + 1, n, m);
long long int down = mul(1, mi, m);
return (up * mod_inv(down, m)) % m;
}
} // namespace Number
const int MAXN = 2e5 + 2;
const long long int MOD = 998244353;
long long int a[MAXN];
int main() {
std::ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; ++i) cin >> a[i];
map<int, int> mi, ma;
for (int i = 0; i < n; ++i) {
if (mi.find(a[i]) == mi.end()) {
mi[a[i]] = ma[a[i]] = i;
} else {
ma[a[i]] = i;
}
}
set<int> s;
int res = 0;
for (int i = 0; i < n; ++i) {
s.insert(a[i]);
if (i == ma[a[i]]) s.erase(a[i]);
if (s.size() == 0) ++res;
}
cout << Number::mod_pow(2, res - 1, MOD) << endl;
return 0;
}
| 11 | CPP |
#include<iostream>
using namespace std;
#define M 100001
#define INF 100000000
int gcd(int m, int n) {
int r = m%n;
return r==0 ? n : gcd(n, r);
}
int main() {
int a, b, d, g, sum, sum2, p, q, l, r;
while(1) {
cin >> a >> b >> d;
if(!a&&!b&&!d) break;
sum = sum2 = INF;
g = (a>b ? gcd(a,b) : gcd(b,a));
d /= g; p = a/g; q = b/g;
for(int i=0; i<=d/q; ++i) {
if((d-q*i)%p==0) {
int j = (d - q*i)/p;
if(i+j<sum || (i+j==sum && j*p+i*q<sum2)) {
l = j; r = i;
sum = i+j;
sum2 = j*p+i*q;
}
}
}
for(int i=0; i<M/g; ++i) {
if((q*i+d)%p==0) {
int j = (q*i + d)/p;
if(i+j<sum || (i+j==sum && j*p+i*q<sum2)) {
l = j; r = i;
sum = i+j;
sum2 = j*p+i*q;
}
break;
}
}
for(int j=0; j<M/g; ++j) {
if((p*j+d)%q==0) {
int i = (p*j + d)/q;
if(i+j<sum || (i+j==sum && j*p+i*q<sum2)) {
l = j; r = i;
sum = i+j;
sum2 = j*p+i*q;
}
break;
}
}
cout << l << " " << r << endl;
}
return 0;
} | 0 | CPP |
n,m = map(int,input().split())
x = list(map(int,input().split()))
x.sort()
y = [x[i+1]-x[i] for i in range(m-1)]
if n >= m:
print(0)
else:
y.sort()
print(sum(y[:m-n])) | 0 | PYTHON3 |
#include <bits/stdc++.h>
int t1, t2, x1, x2, t;
int main() {
scanf("%d%d%d%d%d", &t1, &t2, &x1, &x2, &t);
if (t2 == t) {
if (t1 == t)
printf("%d %d", x1, x2);
else
printf("0 %d", x2);
return 0;
} else if (t1 == t) {
if (t2 == t)
printf("%d %d", x1, x2);
else
printf("%d 0", x1);
return 0;
}
long long y1, y2;
long long oy1, oy2;
double ot = 1e10;
for (long long ty1 = 0; ty1 <= x1; ty1++) {
double tt;
if (ty1 == 1000000) ty1 = ty1;
long long ty2 = ty1 * (t - t1) / (t2 - t);
if (ty2 <= x2) {
tt = (1.0 * ty1 * t1 + ty2 * t2) / (ty2 + ty1);
if (tt >= t)
if (tt < ot) {
ot = tt;
oy1 = ty1;
oy2 = ty2;
}
}
ty2 = ty1 * (t - t1) / (t2 - t) + 1;
if (ty2 > x2) continue;
tt = (1.0 * ty1 * t1 + ty2 * t2) / (ty2 + ty1);
if (tt >= t)
if (tt < ot) {
ot = tt;
oy1 = ty1;
oy2 = ty2;
}
}
long long m1 = 100000000, m2 = 100000000;
if (oy1) m1 = x1 / oy1;
if (oy2) m2 = x2 / oy2;
long long m = (m2 > m1) ? m1 : m2;
oy1 *= m;
oy2 *= m;
printf("%lld %lld", oy1, oy2);
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, m, res, d[111];
string s[101];
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> s[i];
}
for (int i = 0; i < m; i++) {
bool o = 1;
for (int j = 0; j < n - 1; j++)
if (s[j][i] > s[j + 1][i] && d[j] == 0) {
o = 0;
break;
}
if (!o) res++;
for (int j = 0; o && j < n - 1; j++) {
if (s[j][i] < s[j + 1][i]) d[j] = 1;
}
}
cout << res;
return 0;
}
| 7 | CPP |
def Game(n,list1):
ce,co=0,0
for i in list1:
if i%2==0:
ce+=1
else:
co+=1
if ce==1:
for i in range(len(list1)):
if list1[i]%2==0:
return i+1
elif co==1:
for i in range(len(list1)):
if list1[i]%2!=0:
return i+1
n=int(input())
text1=input().split()
list1=[int(i) for i in text1]
val=Game(n,list1)
print(val)
| 7 | PYTHON3 |
n=int(input())
a=[int(i) for i in input().split()]
b=[int(i) for i in input().split()]
b.sort()
tv=b[-1]+b[-2]
rv=0
for i in a:
rv+=i
if tv>=rv:
print('YES')
else:
print('NO') | 7 | PYTHON3 |
if __name__== '__main__':
testCases= int(input())
for test in range(testCases):
n= int(input())
array= [int(x) for x in input().split()]
array.sort()
secondIndex= int(( 2* n)/ 2)
firstIndex= secondIndex- 1
array.sort()
print(abs(array[secondIndex]- array[firstIndex]))
| 8 | PYTHON3 |
#include <bits/stdc++.h>
int x[1001];
int sereja = 0;
void run(int l, int r, bool type) {
if (l == r) {
if (type) sereja += x[l];
return;
}
if (x[l] < x[r]) {
if (type) {
sereja += x[r];
run(l, r - 1, false);
} else {
run(l, r - 1, true);
}
} else {
if (type) {
sereja += x[l];
run(l + 1, r, false);
} else {
run(l + 1, r, true);
}
}
}
int main() {
int n;
scanf("%d", &n);
int total = 0;
for (int i = 0; i < n; i++) {
scanf("%d\n", &x[i]);
total += x[i];
}
run(0, n - 1, true);
printf("%d %d\n", sereja, total - sereja);
return 0;
}
| 7 | CPP |
#include<stdio.h>
int main()
{
int n,sum=0;
scanf("%d",&n);
for(int i=1;i<=n;i++)
{
int a,b;
scanf("%d%d",&a,&b);
sum+=b-a+1;
}
printf("%d\n",sum);
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, k;
cin >> n >> k;
long long dp[n + 1][4][k + 1], mod = 998244353;
for (int i = 0; i < n + 1; i++)
for (int j = 0; j < 4; j++)
for (int y = 0; y < k + 1; y++) dp[i][j][y] = 0;
dp[0][0][1] = 1;
dp[0][3][1] = 1;
if (k > 1) {
dp[0][1][2] = 1;
dp[0][2][2] = 1;
}
for (int i = 1; i < n; i++) {
for (int mask = 0; mask < 4; mask++) {
for (int j = 1; j <= k; j++) {
if (mask == 0) {
dp[i][mask][j] = (dp[i][mask][j] + dp[i - 1][0][j]) % mod;
dp[i][mask][j] = (dp[i][mask][j] + dp[i - 1][1][j]) % mod;
dp[i][mask][j] = (dp[i][mask][j] + dp[i - 1][2][j]) % mod;
dp[i][mask][j] = (dp[i][mask][j] + dp[i - 1][3][j - 1]) % mod;
}
if (mask == 1) {
dp[i][mask][j] = (dp[i][mask][j] + dp[i - 1][0][j - 1]) % mod;
dp[i][mask][j] = (dp[i][mask][j] + dp[i - 1][1][j]) % mod;
if (j > 1)
dp[i][mask][j] = (dp[i][mask][j] + dp[i - 1][2][j - 2]) % mod;
dp[i][mask][j] = (dp[i][mask][j] + dp[i - 1][3][j - 1]) % mod;
}
if (mask == 2) {
dp[i][mask][j] = (dp[i][mask][j] + dp[i - 1][0][j - 1]) % mod;
if (j > 1)
dp[i][mask][j] = (dp[i][mask][j] + dp[i - 1][1][j - 2]) % mod;
dp[i][mask][j] = (dp[i][mask][j] + dp[i - 1][2][j]) % mod;
dp[i][mask][j] = (dp[i][mask][j] + dp[i - 1][3][j - 1]) % mod;
}
if (mask == 3) {
dp[i][mask][j] = (dp[i][mask][j] + dp[i - 1][0][j - 1]) % mod;
dp[i][mask][j] = (dp[i][mask][j] + dp[i - 1][1][j]) % mod;
dp[i][mask][j] = (dp[i][mask][j] + dp[i - 1][2][j]) % mod;
dp[i][mask][j] = (dp[i][mask][j] + dp[i - 1][3][j]) % mod;
}
}
}
}
int ans = 0;
for (int mask = 0; mask < 4; ++mask) {
ans += dp[n - 1][mask][k];
ans %= mod;
}
cout << ans;
return 0;
}
| 10 | CPP |
# URL: http://codeforces.com/problemset/problem/149/A
# ~ Correct Error in Type Signature
from typing import List, Tuple
def parse_input() -> Tuple[int, List[int]]:
return int(input()), [int(x) for x in input().split()]
def _solve(h: int, c: int, k: int, a: List[int]) -> int:
if h >= k:
return c
if len(a) == 0:
return -1
return _solve(h + a[-1], c + 1, k, a[:-1])
def solve(k: int, a: List[int]) -> int:
return _solve(0, 0, k, sorted(a))
if __name__ == '__main__':
k, a = parse_input()
print(solve(k, a))
| 7 | PYTHON3 |
for _ in range(int(input())):
n, x, a, b = map(int, input().split())
if a - b == n -1:
print(n-1)
else:
if (x + abs(a - b)) > n-1:
print(n - 1)
else:
print(x + abs(a - b)) | 7 | PYTHON3 |
n=int(input())
s=input()
s='0'+s+'0'
x,y=s.find('000'),s.find('11')
if x==-1 and y==-1:
print('Yes')
else:
print('No') | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long n, a, b;
const int maxn = 200005;
struct G {
long long x, y, vx, vy;
long long dist;
} gh[maxn];
bool cmp(const G& g1, const G& g2) {
if (g1.dist < g2.dist)
return true;
else if (g1.dist > g2.dist)
return false;
else if (g1.vx < g2.vx) {
return true;
} else if (g1.vx > g2.vx) {
return false;
} else {
return g1.vy < g2.vy;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> a >> b;
for (int i = 0; i < n; i++) {
cin >> gh[i].x >> gh[i].vx >> gh[i].vy;
gh[i].y = gh[i].x * a + b;
gh[i].dist = gh[i].vy - gh[i].vx * a;
}
sort(gh, gh + n, cmp);
long long start, en = 0;
long long cnt, all;
long long result = 0;
for (int i = 0; i < n;) {
start = i;
while (i < n && gh[i].dist == gh[start].dist) {
i++;
}
all = i - start;
cnt = 1;
for (int j = start + 1; j < i; j++) {
if (gh[j].vx == gh[j - 1].vx) {
cnt++;
} else {
result += cnt * (all - cnt);
cnt = 1;
}
}
result += cnt * (all - cnt);
}
cout << result << endl;
}
| 10 | CPP |
for _ in range(int(input())):
b, w = map(int, input().split())
y = 2
if w > b:
y = 3
b, w = w, b
if b > (3 * w) + 1:
print("NO")
continue
print("YES")
if b > w:
print("1 " + str(y))
b -= 1
for x in range(2, (2 * w) + 2, 2):
print(str(x) + " " + str(y))
for x in range(3, (2 * min(b, w)) + 3, 2):
print(str(x) + " " + str(y))
y += 1
for x in range(2, (2 * min(b - w, w)) + 2, 2):
print(str(x) + " " + str(y))
y -= 2
for x in range(2, (2 * (b - (2 * w))) + 2, 2):
print(str(x) + " " + str(y)) | 11 | PYTHON3 |
def div(x, a):
left = -1
right = 64
while right - left > 1:
mid = (right + left) // 2
if x // pow(2, mid) <= a:
right = mid
else:
left = mid
return right
n, k = map(int, input().split())
x = [int(x) for x in input().split()]
x.sort()
answer = pow(10, 100)
for i in range(len(x)):
t = x[i]
divs = 0
isDivisible = True
while isDivisible:
cnt = 1
temp = divs
for j in range(len(x)):
#print(x[i], ' to ', t,' and ', x[j], ' got ', temp, ' count ', cnt)
if i == j or x[j] < t or cnt == k:
continue
a = div(x[j], t)
if x[j] // pow(2, a) == t:
cnt += 1
temp += a
if cnt == k:
answer = min(temp, answer)
if t == 0:
isDivisible = False
t //= 2
divs += 1
print(answer) | 12 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 100000;
multiset<long long int> ms;
unordered_set<long long> cubes;
vector<int> par(N);
int find_set(int v) {
if (par[v] == v) return v;
return par[v] = find_set(par[v]);
}
void merge(int u, int v) {
u = find_set(u);
v = find_set(v);
if (u != v) {
par[v] = u;
}
}
int main() {
int n;
cin >> n;
for (int i = 0; i <= n; i++) {
par[i] = i;
}
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
merge(i, x);
}
int cnt = 0;
for (int i = 1; i <= n; i++) {
if (par[i] == i) {
cnt++;
}
}
cout << cnt << '\n';
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
void solve() {}
signed main() {
ios_base ::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
long long t;
cin >> t;
while (t--) {
long long n, e;
cin >> n >> e;
long long arr[n];
for (long long i = 0; i < n; i++) cin >> arr[i];
vector<vector<long long>> v(n);
for (long long i = 0; i < e; i++) {
long long a, b;
cin >> a >> b;
v[b - 1].push_back(a - 1);
}
map<vector<long long>, long long> m;
for (long long i = 0; i < n; i++) {
if (v[i].size()) {
sort(v[i].begin(), v[i].end());
m[v[i]] += arr[i];
}
}
long long ans = 0;
for (auto it : m) {
ans = gcd(ans, it.second);
}
cout << ans << "\n";
}
return 0;
}
| 11 | CPP |
import math
def length(signature):
s = 0
for A0, A1 in zip(signature, signature[1:]):
x0, y0 = A0
x1, y1 = A1
s += math.sqrt((x0 - x1)**2 + (y0 - y1)**2)
return s
def solve():
n, k = map(int, input().split())
signature = []
for _ in range(n):
x, y = map(int, input().split())
signature.append((x, y))
length_signature = length(signature)
total = length_signature*k
time = total/50.
print('{:.9f}'.format(time))
if __name__ == '__main__':
solve()
| 7 | PYTHON3 |
#include<stdio.h>
int main(){
int a[110];
int tc;
scanf("%d", &tc);
for(int i=0; i<tc; i++){
scanf("%d", &a[i]);
}
for(int j=tc; j>0; j--){
if(j==1) printf("%d\n", a[j-1]);
else printf("%d ", a[j-1]);
}
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long double EPS = 1e-12;
struct Point {
long double x;
long double y;
Point(){};
Point(long double _x, long double _y) : x(_x), y(_y){};
};
int N;
vector<Point> p;
int main() {
scanf("%d", &N);
int nb_orig = 0;
for (int i = 0; i < N; i++) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
if (c)
p.push_back(Point(b * c / (long double)(a * a + b * b),
a * c / (long double)(a * a + b * b)));
else
nb_orig++;
}
int orig_N = N;
N = p.size();
long long ans = 0;
for (int i = 0; i < N; i++) {
vector<long double> pentes;
int nb_vert = 0;
for (int j = 0; j < N; j++)
if (i != j) {
if (abs(p[j].x - p[i].x) < EPS)
nb_vert++;
else
pentes.push_back((p[j].y - p[i].y) / (p[j].x - p[i].x));
}
ans += nb_vert * (nb_vert - 1) / 2;
sort(pentes.begin(), pentes.end());
int act = 1;
for (int j = 1; j < (int)pentes.size(); j++) {
if (abs(pentes[j] - pentes[j - 1]) < EPS)
act++;
else {
ans += act * (act - 1) / 2;
act = 1;
}
}
ans += act * (act - 1) / 2;
}
ans = ans / 3 + ((nb_orig == 2) ? orig_N - 2 : 0);
printf("%I64d\n", ans);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
int f[256], b[8];
vector<pair<int, int>> a;
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; i++) {
int l, r;
scanf("%d%d", &l, &r);
a.push_back({l, i});
a.push_back({r + 1, -i});
}
sort(a.begin(), a.end());
for (int i = 0; i < 2 * n; i++) {
if (i > 0) {
int ms = 0;
for (int p = 0; p < 8; p++) {
if (b[p]) ms += 1 << p;
}
for (int s = 0; s < (1 << k); s++) {
int cnt = __builtin_popcount(s & ms);
if (cnt & 1) f[s] += a[i].first - a[i - 1].first;
}
}
int j = i;
while (j < 2 * n && a[j].first == a[i].first) {
int y = a[j].second;
if (y < 0) {
y = -y;
for (int p = 0; p < 8; p++) {
if (b[p] == y) {
for (int s = 0; s < (1 << k); s++)
f[s] = max(f[s], f[s ^ (1 << p)]);
b[p] = 0;
break;
}
}
} else {
for (int p = 0; p < 8; p++) {
if (b[p] == 0) {
b[p] = y;
break;
}
}
}
j++;
}
i = j - 1;
}
int ans = 0;
for (int i = 0; i < (1 << k); i++) ans = max(ans, f[i]);
printf("%d\n", ans);
return 0;
}
| 10 | CPP |
n,m = map(int,input().split())
for i in range(1,n+1):
if i%2 != 0:
print("#"*m)
if i%2 == 0:
if (i//2)%2 != 0:
print("."*(m-1)+"#")
else:
print("#"+"."*(m-1)) | 7 | PYTHON3 |
from collections import defaultdict
class DenseSubsequence():
def __init__(self, m, s):
self.m = m
self.s = s
self.chars = sorted(set(s))
def get_min_sequence(self, ch, mask):
lv, lch, i = -1, -1, 0
is_possible = True
seq = []
while i < len(self.s):
if mask[i] == 1:
lv = i
elif self.s[i] == ch:
lch = i
if i-lv == self.m:
if lch > lv:
seq.append(lch)
lv = lch
else:
is_possible = False
break
i += 1
if not is_possible:
return False, []
else:
return True, seq
def get_sequence(self):
char_map = defaultdict(list)
for i in range(len(self.s)):
char_map[self.s[i]].append(i)
mask = [0]*len(self.s)
res = ''
for ch in self.chars:
is_possible, seq = self.get_min_sequence(ch, mask)
if is_possible:
res = res+''.join([ch]*len(seq))
break
else:
res = res+''.join([ch]*len(char_map[ch]))
for v in char_map[ch]:
mask[v] = 1
print(res)
m = int(input())
s = input().strip(' ')
DenseSubsequence(m,s).get_sequence() | 10 | PYTHON3 |
def ex():
print(0)
exit()
MOD=10**9+7
N=int(input())
A=list(map(int,input().split()))
B=list(map(int,input().split()))
if N==1:
print(1 if A[0]==B[0] else 0)
exit()
ans=1
tmp=[-1]*N
for i in range(N):
if i==0 or (i>0 and A[i-1]<A[i]):
if B[i]<A[i]:
ex()
tmp[i]=A[i]
for i in reversed(range(N)):
if i==N-1 or (i<N-1 and B[i]>B[i+1]):
if tmp[i]!=-1 and tmp[i]!=B[i]:
ex()
if A[i]<B[i]:
ex()
tmp[i]=B[i]
for i in range(N):
if tmp[i]==-1:
ans=ans*min(A[i],B[i])%MOD
print(ans)
| 0 | PYTHON3 |
s = list(input())
n = len(s)
a = [1]*n
prev = -1
cnt = 1
prev_cnt = 0
for i in range(n):
if s[i]==prev:
cnt += 1
else:
prev_cnt = cnt
cnt = 1
if prev_cnt <2:
if cnt>=3:
a[i] = 0
cnt -= 1
else:
if cnt >=2:
a[i] = 0
cnt -= 1
prev = s[i]
for i in range(n):
if a[i]:
print(s[i], end = "")
| 9 | PYTHON3 |
# cook your dish here
import sys,math
try:sys.stdin,sys.stdout=open('input.txt','r'),open('out.txt','w')
except:pass
from sys import stdin,stdout;mod=int(1e9 + 7);from statistics import mode
from collections import *;from math import ceil,floor,inf,factorial,gcd,log2,sqrt,log
ii1=lambda:int(stdin.readline().strip())
is1=lambda:stdin.readline().strip()
iia=lambda:list(map(int,stdin.readline().strip().split()))
isa=lambda:stdin.readline().strip().split()
# print('{:.3f}'.format(1),round(1.123456789,4))
# sys.setrecursionlimit(500000)
def lcm(a,b): return (a*b)//gcd(a,b)
def setbits(n):return bin(n).count('1')
def resetbits(n):return bin(n).count('0')
def modinv(n,p):return pow(n,p-2,p)
def ncr(n,r):
num,den=1,1;r=min(n,n-r)
for i in range(r):num*=(n-i);den*=(i+1)
return num//den
def ncr_p(n, r, p):
num,den=1,1;r=min(r,n-r)
for i in range(r):num = (num * (n - i)) % p ;den = (den * (i + 1)) % p
return (num * modinv(den,p)) % p
def isPrime(num) :
if num<=1:return False
if num==2 or n==3:return True
if (num % 2 == 0 or num % 3 == 0) :return False
m = int(num**0.5)+1
for i in range(5,m,6):
if (num % i == 0 or num % (i + 2) == 0) :return False
return True
def bin_search(s, low, high, val):
while low <= high:
mid = low + (high - low) // 2;
if s[mid] == val:return mid
elif s[mid] < val:low = mid + 1
else:high = mid - 1
return -1
def sumofdigit(num):
count=0;
while num : count+=num % 10;num //= 10;
return count;
def inputmatrix():
r,c=iia();mat=[0]*r;
for i in range(r):mat[i]=iia();
return r,c,mat;
def prefix_sum(n,s):
for i in range(1,n):s[i]+=s[i-1]
return s;
def binomial(n, k):
if 0 <= k <= n:
ntok = 1;ktok = 1
for t in range(1, min(k, n - k) + 1):ntok *= n;ktok *= t;n -= 1
return ntok // ktok
else:return 0
def divisors(n):
res = [];
for i in range(1,ceil(sqrt(n))+1):
if n%i == 0:
if i==n//i:res.append(i)
else:res.append(i);res.append(n//i)
return res;
# coding start heres
for _ in range(ii1()):
n = ii1()
s= is1()
raze,other=[],[]
flag=False
if n%2==0:
for i in range(n):
if i%2==0:
raze.append(s[i])
else:
other.append(s[i])
for i in range(0,11,2):
if str(i) in other:
flag=True
if flag:
print(2)
else:
print(1)
else:
for i in range(n):
if i%2==0:
raze.append(s[i])
else:
other.append(s[i])
for i in range(1,10,2):
if str(i) in raze:
flag=True
if flag:
print(1)
else:
print(2)
| 7 | PYTHON3 |
def capture(mtr, n, m):
tmpy = -1
tmpx = -1
for j in range(n):
for k in range(m):
if mtr[j][k] == 0:
mtr[j][k] = 1
tmpy = j
tmpx = k
break
for q in range(n):
if mtr[q][tmpx] != 1:
mtr[q][tmpx] = 2
for q in range(m):
if mtr[tmpy][q] != 1:
mtr[tmpy][q] = 2
if tmpy == -1:
return False
return True
def main():
t = int(input())
for j in range(t):
n, m = map(int, input().split())
mtr = [0] * n
for i in range(n):
mtr[i] = list(map(int, input().split()))
for i in range(n):
for j in range(m):
if mtr[i][j] == 1:
for k in range(m):
if mtr[i][k] == 0:
mtr[i][k] = 2
for k in range(n):
if mtr[k][j] == 0:
mtr[k][j] = 2
counter = 0
while capture(mtr, n, m):
counter += 1
print('Ashish' if counter % 2 == 1 else 'Vivek')
if __name__ == '__main__':
main() | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
string str, arr = "RGB";
int t, n, k, sz, ans;
int main() {
ios::sync_with_stdio(false);
cin >> t;
while (t--) {
ans = 0x3f3f3f3f;
cin >> n >> k >> str;
sz = str.length();
for (int i = 0; i < sz; i++) {
if (i + k - 1 < sz) {
for (int kk = 0; kk < 3; kk++) {
int tmp = 0, idx = kk;
for (int j = i; j < i + k; j++) {
if (str[j] != arr[idx]) {
tmp++;
}
idx = (idx + 1) % 3;
}
ans = min(ans, tmp);
}
}
}
cout << ans << endl;
}
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
string get_name(int i) {
if (i < 26) return string(1, char('A' + i));
int j = i / 26;
string res(1, char('A' + j));
res += char('a' + i % 26);
return res;
}
int main() {
int n, k;
cin >> n >> k;
vector<string> res(n);
for (int i = 0; i < k - 1; ++i) {
res[i] = get_name(i);
}
int j = k;
for (int i = 0; i < n - k + 1; ++i) {
string s;
cin >> s;
if (s == "YES") {
res[i + k - 1] = get_name(j++);
} else {
res[i + k - 1] = res[i];
}
}
cout << res[0];
for (int i = 1; i < n; ++i) {
cout << ' ' << res[i];
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
#define For(i, a, b) for(int (i)=(int)(a); (i)<(int)(b); ++(i))
#define rFor(i, a, b) for(int (i)=(int)(a)-1; (i)>=(int)(b); --(i))
#define rep(i, n) For((i), 0, (n))
#define rrep(i, n) rFor((i), (n), 0)
#define fi first
#define se second
using namespace std;
typedef long long lint;
typedef unsigned long long ulint;
typedef pair<int, int> pii;
typedef pair<lint, lint> pll;
template<class T> bool chmax(T &a, const T &b){if(a<b){a=b; return true;} return false;}
template<class T> bool chmin(T &a, const T &b){if(a>b){a=b; return true;} return false;}
template<class T> T div_floor(T a, T b){
if(b < 0) a *= -1, b *= -1;
return a>=0 ? a/b : (a+1)/b-1;
}
template<class T> T div_ceil(T a, T b){
if(b < 0) a *= -1, b *= -1;
return a>0 ? (a-1)/b+1 : a/b;
}
constexpr lint mod = 1e9+7;
constexpr lint INF = mod * mod;
constexpr int MAX = 500010;
int main(){
char trump;
string s[4][13];
string str = "23456789TJQKA";
auto mx = [&](string a, string b, char suit){
if(a[1] == trump && b[1] != trump) return a;
else if(a[1] != trump && b[1] == trump) return b;
else if(a[1] == trump && b[1] == trump) return str.find(a[0]) > str.find(b[0]) ? a : b;
else{
if(a[1] == suit && b[1] != suit) return a;
else if(a[1] != suit && b[1] == suit) return b;
else return str.find(a[0]) > str.find(b[0]) ? a : b;
}
};
while(cin >> trump && trump != '#'){
rep(i, 4)rep(j, 13) cin >> s[i][j];
int leader = 3, ew = 0, ns = 0;
rep(i, 13){
char suit = s[leader][i][1];
pair<string, int> p = {s[leader][i], leader};
rep(j, 4)if(mx(p.fi, s[j][i], suit) != p.fi){
p = {s[j][i], j};
}
p.se == 0 || p.se == 2 ? ++ns : ++ew;
leader = p.se;
}
printf("%s ", ns > ew ? "NS" : "EW");
printf("%d\n", max(ns, ew) - 6);
}
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
long long ans, H, W, n;
long long tt[400005];
struct node {
long long h, l, r, s;
} a[100005];
struct point {
long long h, sum;
} now;
stack<point> s[100005];
long long read() {
char ch = getchar();
long long x = 0, ff = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') ff = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return ff * x;
}
void write(long long z) {
if (z < 0) {
putchar('-');
z = -z;
}
if (z >= 10) {
write(z / 10);
}
putchar(z % 10 + '0');
}
bool cmp(node aa, node bb) { return aa.h > bb.h; }
long long mn(long long aa, long long bb) {
return s[aa].top().h > s[bb].top().h ? bb : aa;
}
long long up(long long ll, long long rr) {
if (s[ll].empty())
return rr;
else if (s[rr].empty())
return ll;
else
return mn(ll, rr);
}
void bt(long long rt, long long ll, long long rr) {
if (ll == rr) {
tt[rt] = ll;
return;
}
long long mid = (ll + rr) >> 1;
bt(rt << 1, ll, mid);
bt(rt << 1 | 1, mid + 1, rr);
tt[rt] = up(tt[rt << 1], tt[rt << 1 | 1]);
return;
}
long long query(long long rt, long long ll, long long rr, long long L,
long long R) {
if (ll == L && rr == R) return tt[rt];
long long mid = (ll + rr) >> 1;
if (R <= mid)
return query(rt << 1, ll, mid, L, R);
else if (L > mid)
return query(rt << 1 | 1, mid + 1, rr, L, R);
else
return up(query(rt << 1, ll, mid, L, mid),
query(rt << 1 | 1, mid + 1, rr, mid + 1, R));
}
void update(long long rt, long long ll, long long rr, long long kk,
long long ff) {
if (ll == rr) {
if (ff == -1)
s[tt[rt]].pop();
else
s[tt[rt]].push(now);
return;
}
long long mid = (ll + rr) >> 1;
if (kk <= mid)
update(rt << 1, ll, mid, kk, ff);
else
update(rt << 1 | 1, mid + 1, rr, kk, ff);
tt[rt] = up(tt[rt << 1], tt[rt << 1 | 1]);
return;
}
int main() {
H = read();
W = read();
n = read();
for (long long i = 1; i <= n; ++i)
a[i].h = read(), a[i].l = read(), a[i].r = read(), a[i].s = read();
sort(a + 1, a + n + 1, cmp);
for (long long i = 1; i <= W; ++i) s[i].push((point){H + 1, 1});
bt(1, 1, W);
for (long long i = 1; i <= n; ++i) {
now = ((point){a[i].h, 0});
while (1) {
long long pfy = query(1, 1, W, a[i].l, a[i].r);
if (s[pfy].empty()) break;
point wky = s[pfy].top();
if (wky.h > a[i].h + a[i].s) break;
now.sum = (now.sum + wky.sum) % mod;
update(1, 1, W, pfy, -1);
}
if (a[i].l == 1)
now.sum = (now.sum + now.sum) % mod, update(1, 1, W, a[i].r + 1, 1);
else if (a[i].r == W)
now.sum = (now.sum + now.sum) % mod, update(1, 1, W, a[i].l - 1, 1);
else
update(1, 1, W, a[i].l - 1, 1), update(1, 1, W, a[i].r + 1, 1);
}
for (long long i = 1; i <= W; ++i) {
while (!s[i].empty()) {
ans = (ans + s[i].top().sum) % mod;
s[i].pop();
}
}
write(ans);
return 0;
}
| 13 | CPP |
#include<iostream>
#include<string>
using namespace std;
int main(){
string r, a;
while( cin >> r >> a, r!="0"||a!="0" ){
int hit=0, blow=0;
for( int i=0; i<4; i++ ){
for( int j=0; j<4; j++ ){
if( r[i] == a[j] ){
if( i==j ) hit++;
else blow++;
a[j] = '*';
}
}
}
cout << hit << " " << blow << endl;
}
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
inline void read(int &x) {
char ch = getchar();
int f = 0;
x = 0;
while (!isdigit(ch)) {
if (ch == '-') f = 1;
ch = getchar();
}
while (isdigit(ch)) x = x * 10 + ch - 48, ch = getchar();
if (f) x = -x;
}
int a[123];
signed main() {
int T;
read(T);
while (T--) {
int n;
read(n);
for (int i = 1; i <= n; ++i) read(a[i]);
sort(a + 1, a + n + 1);
for (int i = n; i >= 1; --i) printf("%d ", a[i]);
puts("");
}
return 0;
}
| 8 | CPP |
import re
pattern0 = r"0{7,}"
pattern1 = r"1{7,}"
players = input()
if re.search(pattern0, players) or re.search(pattern1, players):
print("YES")
else:
print("NO")
| 7 | PYTHON3 |
def elepnt_moves(c_x):
stps = [1,2,3,4,5]
cnt = 0
d = len(stps) -1
while c_x > 0:
while c_x >= stps[d]:
c_x -= stps[d]
cnt+=1
d-=1
print(cnt)
if __name__ == '__main__':
n = int(input().strip(" "))
elepnt_moves(n) | 7 | PYTHON3 |
elements = set([
'Ac','Ag','Al','Am','Ar','As','At','Au','B','Ba','Be','Bh','Bi','Bk','Br','C',
'Ca','Cd','Ce','Cf','Cl','Cm','Cn','Co','Cr','Cs','Cu','Db','Ds','Dy','Er',
'Es','Eu','F','Fe','Fl','Fm','Fr','Ga','Gd','Ge','H','He','Hf','Hg','Ho','Hs',
'I','In','Ir','K','Kr','La','Li','Lr','Lu','Lv','Mc','Md','Mg','Mn','Mo','Mt',
'N','Na','Nb','Nd','Ne','Nh','Ni','No','Np','O','Og','Os','P','Pa','Pb','Pd',
'Pm','Po','Pr','Pt','Pu','Ra','Rb','Re','Rf','Rg','Rh','Rn','Ru','S','Sb',
'Sc','Se','Sg','Si','Sm','Sn','Sr','Ta','Tb','Tc','Te','Th','Ti','Tl','Tm',
'Ts','U','V','W','Xe','Y','Yb','Zn','Zr'
])
elem = list(map(lambda x: x.upper(), elements))
def find(s):
if s == "":
return True
if s[0] in elem:
if find(s[1:]):
return True
if s[0:2] in elem:
if find(s[2:]):
return True
return False
if find(input()):
print("YES")
else:
print("NO") | 12 | PYTHON3 |
t = int(input())
for _ in range(t):
N = list(input())
c = len(N)
n = int(N[0])
print(int((c + 1) * c / 2) + 10 * (n - 1)) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 110, mod = 998244353;
int n, l[N], r[N], c[N], m, s[N], f[N][N], inv[N], ans, tmp = 1;
int power(int x, int y) {
int z = 1;
for (; y; y >>= 1, x = 1ll * x * x % mod)
if (y & 1) z = 1ll * z * x % mod;
return z;
}
int main() {
scanf("%d", &n);
inv[1] = 1;
for (int i = 2; i <= n; i++)
inv[i] = mod - 1ll * mod / i * inv[mod % i] % mod;
for (int i = 1, x, y; i <= n; i++)
scanf("%d%d", &l[i], &r[i]), c[i] = l[i], c[i + n] = ++r[i],
tmp = 1ll * tmp * (r[i] - l[i]) % mod;
sort(c + 1, c + n * 2 + 1);
m = unique(c + 1, c + n * 2 + 1) - c - 1;
reverse(l + 1, l + n + 1);
reverse(r + 1, r + n + 1);
for (int i = 1; i <= n; i++)
l[i] = lower_bound(c + 1, c + m + 1, l[i]) - c,
r[i] = lower_bound(c + 1, c + m + 1, r[i]) - c;
for (int i = 0; i <= m; i++) s[i] = 1;
for (int i = 1; i <= n; i++) {
for (int j = 1; j < m; j++) {
bool fl = j >= l[i] && j < r[i];
for (int k = i; k > 1; k--)
f[j][k] = fl ? 1ll * f[j][k - 1] * (c[j + 1] - c[j] + k - 1) % mod *
inv[k] % mod
: 0;
f[j][1] = fl ? 1ll * s[j - 1] * (c[j + 1] - c[j]) % mod : 0;
}
s[0] = 0;
for (int j = 1; j < m; j++) {
s[j] = s[j - 1];
for (int k = 1; k <= i; k++) (s[j] += f[j][k]) %= mod;
}
}
for (int i = 1; i < m; i++)
for (int j = 1; j <= n; j++) (ans += f[i][j]) %= mod;
cout << (1ll * ans * power(tmp, mod - 2) % mod + mod) % mod;
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
int main() {
using namespace std;
int n, i;
cin >> n;
int mas[100000];
int t = 0;
int k = 0;
for (i = 0; i < n; i++) {
cin >> mas[i];
if (mas[i] == -1) {
if (t > 0)
t--;
else
k++;
}
if (mas[i] != -1) t = mas[i] + t;
}
cout << k;
}
| 7 | CPP |
from math import ceil
n,k = map(int,input().split())
s = input()
d = ""
for i in range(n-1):
# print(s[:i+1], s[n-i-1:n],s[:i+1] == s[n-i-1:n] ,s[i+1:n])
if(s[:i+1] == s[n-i-1:n]):
d = s[i+1:n]
if d == "":
d = s
print(s,end="")
for i in range(1,k):
print(d,end="")
| 7 | PYTHON3 |
t = int(input())
for x in range(t):
l1 = [int(x) for x in input().split()]
sing,bulk_num,bulk_cost=l1[0],l1[1],l1[2]
if sing>=bulk_cost:
print(-1,bulk_num)
elif sing<bulk_cost:
if bulk_cost<sing*bulk_num:
print(1,bulk_num)
else:
print(1,-1)
| 7 | PYTHON3 |
#include<stdio.h>
#include<algorithm>
#include<vector>
#include<queue>
using namespace std;
vector<pair<int,pair<int,int> > >g[10][110];
int ijk[30][110];
int v[30][110];
int dp[1000];
int tmp[1000];
int main(){
int a,b,c,d;
while(scanf("%d%d%d%d",&a,&b,&c,&d),a){
for(int i=0;i<d;i++){
for(int j=0;j<a;j++)g[i][j].clear();
}
for(int i=0;i<(1<<d);i++)dp[i]=tmp[i]=999999999;
dp[0]=0;
for(int i=0;i<b;i++){
int v,w,x,y,z;
scanf("%d%d%d%d%d",&v,&w,&x,&y,&z);
v--;w--;z--;
g[z][v].push_back(make_pair(w,make_pair(x,y)));
g[z][w].push_back(make_pair(v,make_pair(x,y)));
}
int s,t;scanf("%d%d",&s,&t);s--;t--;
int e;scanf("%d",&e);
for(int i=0;i<e;i++){
int p,q;scanf("%d%d",&p,&q);
int val=0;
for(int j=0;j<p;j++){
int r;scanf("%d",&r);r--;
val+=(1<<r);
}
tmp[val]=q;
}
for(int i=0;i<(1<<d);i++){
for(int j=0;j<(1<<d);j++){
dp[i|j]=min(dp[i|j],dp[i]+tmp[j]);
}
}
int ret=999999999;
for(int i=0;i<(1<<d);i++){
for(int j=0;j<=c;j++)for(int k=0;k<a;k++){
ijk[j][k]=999999999;
v[j][k]=0;
}
priority_queue<pair<int,pair<int,int> > >Q;
Q.push(make_pair(0,make_pair(s,0)));
ijk[0][s]=0;
while(Q.size()){
int cost=-Q.top().first;
int at=Q.top().second.first;
int time=Q.top().second.second;
Q.pop();
if(v[time][at])continue;
v[time][at]=1;
for(int j=0;j<d;j++){
for(int k=0;k<g[j][at].size();k++){
int to=g[j][at][k].first;
int T=cost+((i&(1<<j))?0:(g[j][at][k].second.first));
int h=time+g[j][at][k].second.second;
if(h>c||v[h][to]||ijk[h][to]<=T)continue;
ijk[h][to]=T;
Q.push(make_pair(-T,make_pair(to,h)));
}
}
}
for(int j=0;j<=c;j++){
ret=min(ret,ijk[j][t]+dp[i]);
}
}
if(ret>99999999)printf("-1\n");
else printf("%d\n",ret);
}
} | 0 | CPP |
#!/usr/bin/env python3
import collections
table = collections.defaultdict(dict)
table[1][3] = '''
aa.
..b
..b
'''.strip().splitlines()
table[2][3] = '''
aab
d.b
dcc
'''.strip().splitlines()
table[3][4] = '''
aadc
bbdc
ghff
ghee
'''.strip().splitlines()
table[3][5] = '''
abb.d
a.ccd
eefgg
hif..
hi.jj
'''.strip().splitlines()
table[3][7] = '''
a.cc.dd
abb..e.
..mm.ef
l...n.f
lk..n..
.k..hhg
jj.ii.g
'''.strip().splitlines()
def solve1(n, q):
dp = [None] * (n + 1)
dp[0] = 0
for i in range(n + 1):
for delta in table[q].keys():
if i - delta >= 0 and dp[i - delta] is not None:
dp[i] = delta
if dp[n] is None:
return None
f = [['.' for _ in range(n)] for _ in range(n)]
k = n
while k:
delta = dp[k]
k -= delta
for y in range(delta):
for x in range(delta):
f[k + y][k + x] = table[q][delta][y][x]
return [''.join(line) for line in f]
def solve(n):
return solve1(n, 1) or solve1(n, 2) or solve1(n, 3)
def main():
n = int(input())
f = solve(n)
if f:
for line in f:
print(line)
else:
print(-1)
if __name__ == "__main__":
main()
| 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1001001001;
int dp[2][300][300];
int mp[300][300];
int dx[] = {1, 0};
int dy[] = {0, 1};
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
scanf("%d", &mp[i][j]);
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
dp[0][i][j] = dp[1][i][j] = -INF;
}
}
dp[0][0][0] = mp[0][0];
for (int i = 1; i < 2 * n - 1; i++) {
int D = min(i + 1, 2 * n - i - 1);
int dr = i < n ? i : n - 1;
int dc = i < n ? 0 : i - n + 1;
for (int j = 0; j < D; j++) {
for (int k = j; k < D; k++) {
int addval = mp[dr - j][dc + j] + (j != k ? mp[dr - k][dc + k] : 0);
for (int dj = 0; dj < 2; dj++) {
for (int dk = 0; dk < 2; dk++) {
int pjr = dr - j - dx[dj], pjc = dc + j - dy[dj];
int pkr = dr - k - dx[dk], pkc = dc + k - dy[dk];
if (!(0 <= min({pjr, pjc, pkr, pkc}) &&
max({pjr, pjc, pkr, pkc}) < n))
continue;
int pj = i - 1 < n ? pjc : pjc - i + n;
int pk = i - 1 < n ? pkc : pkc - i + n;
if (pj > pk) swap(pj, pk);
dp[1][j][k] = max(dp[1][j][k], dp[0][pj][pk] + addval);
}
}
}
}
for (int j = 0; j < D; j++)
for (int k = j; k < D; k++) {
dp[0][j][k] = dp[1][j][k];
dp[1][j][k] = -INF;
}
}
printf("%d\n", dp[0][0][0]);
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct pree {
long long int x, y, z;
};
bool compare(pree aa, pree bb) {
if (aa.y == bb.y) {
return aa.x > bb.x;
}
return aa.y < bb.y;
}
int main() {
ios_base::sync_with_stdio(false);
int n, m;
cin >> n >> m;
pair<long long int, long long int> a[n];
for (int i = 0; i < n; i++) {
cin >> a[i].first >> a[i].second;
}
vector<pree> v;
for (int i = 0; i < n - 1; i++) {
v.push_back({a[i + 1].first - a[i].second, a[i + 1].second - a[i].first,
(long long)i});
}
sort(v.begin(), v.end(), compare);
pair<long long int, long long int> b[m];
multiset<pair<long long int, long long int> > s;
for (int i = 0; i < m; i++) {
cin >> b[i].first;
b[i].second = i + 1;
s.insert(make_pair(b[i].first, b[i].second));
}
sort(b, b + m);
long long int ans[n];
for (int i = 0; i < n - 1; i++) {
long long int xx = v[i].x, yy = v[i].y, zz = v[i].z;
multiset<pair<long long int, long long int> >::iterator it =
s.lower_bound(make_pair(xx, 0));
if (it != s.end()) {
if (it->first <= yy) {
ans[zz] = it->second;
s.erase(it);
} else {
cout << "No\n";
return 0;
}
} else {
cout << "No\n";
return 0;
}
}
cout << "Yes\n";
for (int i = 0; i < n - 1; i++) {
cout << ans[i] << " ";
}
cout << "\n";
}
| 8 | CPP |
#include <bits/stdc++.h>
const int MAXN = 200005;
int n, k, cnt[2];
inline int min(int a, int b) { return a > b ? b : a; }
int main() {
int i, t;
scanf("%d%d", &n, &k);
for (i = 1; i <= n; ++i) {
scanf("%d", &t);
cnt[t & 1]++;
}
if (n == k) {
printf("%s\n", (cnt[1] & 1) ? "Stannis" : "Daenerys");
return 0;
}
if ((n - k) & 1) {
if ((k & 1) == 0)
if (min(cnt[0], cnt[1]) <= (n - k - 1) / 2)
printf("Daenerys\n");
else
printf("Stannis\n");
else if (cnt[1] <= (n - k - 1) / 2)
printf("Daenerys\n");
else
printf("Stannis\n");
} else {
if ((k & 1) == 0)
printf("Daenerys\n");
else if (cnt[0] <= (n - k) / 2)
printf("Stannis\n");
else
printf("Daenerys\n");
}
return 0;
}
| 9 | CPP |
import sys
input = sys.stdin.readline
for _ in range(int(input())):
n = int(input())
arr = list(map(int,input().split()))
ans = True
for i in range(1,len(arr)):
if arr[i]>arr[i-1]:
if arr[i]-1!=arr[i-1]:
ans = False
if ans:
print("Yes")
else:
print("No") | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long n, m;
long long p[6] = {0, 0, 0, 0, 2, 4};
int main() {
cin >> n >> m;
if (n > m) swap(n, m);
if (n < 3 && m < 3)
cout << 0 << endl;
else if (n == 1) {
long long ans = n * m;
if (m / 6 >= 1)
ans -= m % 6 - p[m % 6];
else
ans = p[m];
cout << ans << endl;
} else if (n == 2 && m == 3)
cout << 4 << endl;
else if (n == 2 && m == 7)
cout << 12 << endl;
else
cout << n * m - n * m % 2 << endl;
return 0;
}
| 8 | CPP |
l = lambda: map(int, input().split())
n, k = l()
a = list(l())
print(sum(v >= max(1, a[k - 1]) for v in a))
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = (int)5e5 + 10;
const int mod = (int)1e9 + 7;
const int inf = (1 << 30) - 1;
double dp[5050];
double d[5050];
int n, T;
double pref[5050];
void solve() {
dp[0] = 1;
cin >> n >> T;
double ans = 0;
for (int i = 1; i <= n; i++) {
int P, t;
cin >> P >> t;
double p = P / 100.0;
double q = 1 - p;
double x = 1;
for (int j = 1; j < t; j++) x *= q;
for (int j = 0; j <= T; j++) {
d[j] = dp[j];
dp[j] = 0;
}
double s = 0;
for (int j = 1; j <= T; j++) {
s = s * q + d[j - 1] * p;
if (j >= t) {
s -= x * d[j - t] * p;
dp[j] = d[j - t] * x + s;
} else {
dp[j] = s;
}
ans += dp[j];
}
}
printf("%.12lf\n", ans);
}
int main() {
int t = 1;
for (int i = 1; i <= t; i++) {
solve();
}
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
inline unsigned myrand() {
static unsigned x = 998244353;
return x += x << 2 | 1;
}
inline int getint() {
static char c;
while ((c = getchar()) < '0' || c > '9')
;
int res = c - '0';
while ((c = getchar()) >= '0' && c <= '9') res = res * 10 + c - '0';
return res;
}
const int NDir = 4;
const int MaxN = 5001;
const int MaxQ = 100001;
const int MaxM = 400001;
const int MaxLogM = 19;
const int MaxTN = MaxM * MaxLogM >> 2;
int n, nQu, m = 0, nQuery = 0;
int ans[MaxQ];
struct operation {
int type, lab;
int x, y, dir;
friend inline bool operator<(const operation &lhs, const operation &rhs) {
if (lhs.x != rhs.x) return lhs.x < rhs.x;
return lhs.type <= rhs.type;
}
inline void set(const int &t, const int &l, const int &_x, const int &_y,
const int &d) {
type = t, lab = l;
x = _x, y = _y, dir = d;
}
};
operation q[MaxM], p[MaxM];
struct treap_node {
treap_node *lc, *rc;
int val, size;
unsigned pri;
inline void update() {
size = 1;
if (lc) size += lc->size;
if (rc) size += rc->size;
}
};
treap_node pool[MaxTN], *tail = pool;
inline treap_node *newnode() {
treap_node *x = tail++;
x->lc = x->rc = NULL;
x->pri = myrand(), x->size = 1;
return x;
}
inline void treap_zig(treap_node *&x) {
treap_node *y = x->lc;
x->lc = y->rc;
y->rc = x;
x->update();
x = y;
}
inline void treap_zag(treap_node *&x) {
treap_node *y = x->rc;
x->rc = y->lc;
y->lc = x;
x->update();
x = y;
}
void treap_insert(treap_node *&x, const int &val) {
if (x == NULL) {
x = newnode(), x->val = val;
return;
}
if (val <= x->val) {
treap_insert(x->lc, val);
if (x->pri < x->lc->pri) treap_zig(x);
} else {
treap_insert(x->rc, val);
if (x->pri < x->rc->pri) treap_zag(x);
}
x->update();
}
inline int treap_query(treap_node *x, const int &val) {
int rank = 0;
while (x) {
if (val > x->val)
x = x->rc;
else {
int r = x->rc ? x->rc->size : 0;
rank += r + 1;
x = x->lc;
}
}
return rank;
}
treap_node *bit[NDir][MaxN];
inline void bit_update(treap_node **b, const int &x, const int &val) {
for (int i = x; i <= n; i += i & -i) treap_insert(b[i], val);
}
inline int bit_query(treap_node **b, const int &x, const int &val) {
int res = 0;
for (int i = x; i; i ^= i & -i) res += treap_query(b[i], val);
return res;
}
inline void bit_reinit(treap_node **b, const int &x) {
for (int i = x; i <= n && b[i]; i += i & -i) b[i] = NULL;
}
void solve(const int &l, const int &r) {
if (l == r) return;
int mid = l + r >> 1;
solve(l, mid);
solve(mid + 1, r);
int i = l, j = mid + 1;
for (int t = l; t <= r; ++t) {
if (j > r || (i <= mid && q[i] < q[j])) {
p[t] = q[i++];
if (p[t].type == 0) bit_update(bit[p[t].dir], p[t].y, p[t].lab);
} else {
p[t] = q[j++];
if (p[t].type == 1) {
int len = p[t].x + p[t].y;
ans[p[t].lab] += bit_query(bit[p[t].dir], p[t].y, len);
}
}
}
tail = pool;
for (i = l; i <= r; ++i) {
q[i] = p[i];
if (q[i].type == 0) bit_reinit(bit[q[i].dir], q[i].y);
}
}
int main() {
n = getint(), nQu = getint();
while (nQu--) {
int type = getint();
if (type == 1) {
int dir = getint();
int x = getint(), y = getint(), l = getint();
if (dir == 2 || dir == 4) y = n - y + 1;
if (dir == 3 || dir == 4) x = n - x + 1;
q[++m].set(0, l + x + y, x, y, --dir);
} else {
int x = getint(), y = getint();
q[++m].set(1, ++nQuery, x, y, 0);
q[++m].set(1, nQuery, x, n - y + 1, 1);
q[++m].set(1, nQuery, n - x + 1, y, 2);
q[++m].set(1, nQuery, n - x + 1, n - y + 1, 3);
}
}
solve(1, m);
for (int i = 1; i <= nQuery; ++i) printf("%d\n", ans[i]);
return 0;
}
| 15 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
int x, y, z, sum;
bool impossibleFlag = false;
cin >> a >> b >> c;
if ((a + b + c) % 2 == 1) impossibleFlag = true;
if (!impossibleFlag) {
sum = (a + b + c) / 2;
x = sum - b;
y = sum - c;
z = sum - a;
if (x < 0 || y < 0 || z < 0) impossibleFlag = true;
if (!impossibleFlag) {
cout << y << " " << z << " " << x << endl;
}
}
if (impossibleFlag) {
cout << "Impossible" << endl;
}
return 0;
}
| 8 | CPP |
#include<iostream>
#include<cmath>
#include<cstdio>
using namespace std;
#define rep(i, n) for (int i = 0; i < int(n); ++i)
double x[111], y[111], z[111], r[111];
double dis[111][111];
bool used[111];
int main() {
int n;
for (;;) {
cin >> n;
if (n == 0) break;
rep (i, n) cin >> x[i] >> y[i] >> z[i] >> r[i];
rep (i, n) used[i] = false;
rep (i, n) rep (j, n) dis[i][j] = max(sqrt(pow(x[i] - x[j], 2) + pow(y[i] - y[j], 2) + pow(z[i] - z[j], 2)) - r[i] - r[j], 0.);
double res = 0;
used[0] = true;
rep (i, n - 1) {
int next = -1;
double mincost = 1e10;
rep (j, n) if (used[j]) rep (k, n) if (!used[k]) {
//cout << j << " " << k << " " << dis[j][k] << endl;
if (mincost >= dis[j][k]) {
mincost = dis[j][k];
next = k;
}
}
res += mincost;
used[next] = true;
}
printf("%.3lf\n", res);
}
} | 0 | CPP |
x=int(input())
l=list(map(int,input().split()))
s=max(l)
sum1=0
for i in l:
sum1=sum1+(s-i)
print(sum1) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
clock_t __START, __END;
double __TOTALTIME;
void _MS() { __START = clock(); }
void _ME() {
__END = clock();
__TOTALTIME = (double)(__END - __START) / CLOCKS_PER_SEC;
cout << "Time: " << __TOTALTIME << " s" << endl;
}
const double E = 2.718281828;
const double PI = acos(-1.0);
const long long INF = (1LL << 60);
const int inf = (1 << 30);
const double ESP = 1e-9;
const int mod = (int)1e9 + 7;
const int N = (int)1e6 + 10;
const int maxn = 300011;
struct EDGE {
int v, next;
} e[maxn << 1];
int head[maxn], en;
int f[maxn], md[maxn];
int n, m, q;
int maxd, maxi, thefather;
void add(int x, int y) {
e[en].v = y;
e[en].next = head[x];
head[x] = en++;
}
int getfather(int x) { return f[x] == x ? x : f[x] = getfather(f[x]); }
void link(int x, int y) {
int fx, fy;
fx = getfather(x);
fy = getfather(y);
if (fx == fy) return;
if (md[fx] < md[fy]) swap(fx, fy);
md[fx] = max(md[fx], (md[fx] + 1) / 2 + (md[fy] + 1) / 2 + 1);
f[fy] = fx;
}
void dfs(int x, int prex, int step) {
f[x] = thefather;
if (step > maxd) {
maxd = step;
maxi = x;
}
for (int i = head[x]; i != -1; i = e[i].next)
if (e[i].v != prex) dfs(e[i].v, x, step + 1);
}
void check(int a[], int n) {
for (int i = 0; i < n; i++) printf("%d ", a[i]);
puts("");
}
int main() {
int i, x, y, z;
while (scanf("%d%d%d", &n, &m, &q) != EOF) {
memset(head, -1, sizeof(head));
en = 0;
for (i = 0; i < (m); i++) {
scanf("%d%d", &x, &y);
add(x, y);
add(y, x);
}
for (i = 1; i <= n; i++) f[i] = i;
for (i = 1; i <= n; i++)
if (f[i] == i) {
maxd = -1;
thefather = i;
dfs(i, -1, 0);
maxd = -1;
thefather = maxi;
dfs(thefather, -1, 0);
md[thefather] = maxd;
}
for (i = 0; i < (q); i++) {
scanf("%d", &z);
if (z == 1) {
scanf("%d", &x);
printf("%d\n", md[getfather(x)]);
} else {
scanf("%d%d", &x, &y);
link(x, y);
}
}
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool chkmin(T &a, const T &b) {
return a > b ? a = b, 1 : 0;
}
template <typename T>
inline bool chkmax(T &a, const T &b) {
return a < b ? a = b, 1 : 0;
}
const int oo = 0x3f3f3f3f;
const int maxn = 1010, maxm = 1010;
int an;
int n;
int a[maxm + 5];
int b[maxn + 5][maxm + 5];
int len[maxn + 5];
int dp[maxm + 5][maxn + 5];
int cost[10];
int pos[maxn + 5], ppos[maxn + 5];
int main() {
static char s[maxm + 5];
scanf("%s", s);
an = strlen(s);
reverse(s, s + an);
for (int i = (0), i_end_ = (an); i < i_end_; ++i) {
if (s[i] == '?')
a[i] = -1;
else
a[i] = s[i] - '0';
}
scanf("%d", &n);
for (int i = (0), i_end_ = (n); i < i_end_; ++i) {
scanf("%s", s);
len[i] = strlen(s);
reverse(s, s + len[i]);
for (int j = (0), j_end_ = (len[i]); j < j_end_; ++j) b[i][j] = s[j] - '0';
}
for (int i = (0), i_end_ = (10); i < i_end_; ++i) scanf("%d", cost + i);
for (int i = (0), i_end_ = (n); i < i_end_; ++i) pos[i] = i;
memset(dp, -oo, sizeof dp);
dp[0][0] = 0;
for (int i = (0), i_end_ = (maxm); i < i_end_; ++i) {
static int dcnt[11];
memset(dcnt, 0, sizeof dcnt);
for (int j = (0), j_end_ = (n); j < j_end_; ++j)
if (i < an || i < len[j]) ++dcnt[b[j][i]];
for (int j = (0), j_end_ = (n + 1); j < j_end_; ++j) {
if (dp[i][j] >= 0) {
for (int k = (0), k_end_ = (10); k < k_end_; ++k) {
if (i >= an && k) continue;
if (i == an - 1 && !k) continue;
if (i < an && ~a[i] && k != a[i]) continue;
int delta = 0;
int carry = 0;
for (int l = (0), l_end_ = (11); l < l_end_; ++l)
if (dcnt[l])
delta += dcnt[l] * cost[(l + k) % 10],
carry += (l + k >= 10) * dcnt[l];
chkmax(dp[i + 1][carry], dp[i][j] + delta);
}
}
if (j < n) {
if (i < an || i < len[pos[j]]) --dcnt[b[pos[j]][i]];
++dcnt[b[pos[j]][i] + 1];
}
}
static int sum[10];
memset(sum, 0, sizeof sum);
for (int j = (0), j_end_ = (n); j < j_end_; ++j) ++sum[b[j][i]];
for (int j = 9; j >= 1; --j) sum[j - 1] += sum[j];
for (int j = n - 1; j >= 0; --j) ppos[--sum[b[pos[j]][i]]] = pos[j];
memcpy(pos, ppos, sizeof pos);
}
printf("%d\n", dp[maxm][0]);
return 0;
}
| 11 | CPP |
# -*- coding: utf-8 -*-
"""
Created on Sun Feb 9 14:14:36 2020
@author: CheongRoach
"""
class Flower:
def __init__(self, i, x, y):
self.id = i
self.x, self.y = x, y
def dist2_to(self, x, y):
return (self.x - x) ** 2 + (self.y - y) ** 2
flowers = []
n, x1, y1, x2, y2 = tuple(map(int, input().split()))
for i in range(n):
flowers.append(Flower(i, *map(int, input().split(' '))))
flowers.sort(key=lambda f: -f.dist2_to(x1, y1))
ans = flowers[0].dist2_to(x1, y1)
r22 = 0
for i in range(n):
r22 = max(r22, flowers[i].dist2_to(x2, y2))
r12 = flowers[i+1].dist2_to(x1, y1) if i + 1 < n else 0
ans = min(ans, r22 + r12)
print(ans)
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define repl(i,a,b) for(int i=(int)(a);i<(int)(b);i++)
#define rep(i,n) repl(i,0,n)
#define each(itr,v) for(auto itr:v)
#define pb(s) push_back(s)
#define mp(a,b) make_pair(a,b)
#define all(x) (x).begin(),(x).end()
#define dbg(x) cout<<#x"="<<x<<endl
#define maxch(x,y) x=max(x,y)
#define minch(x,y) x=min(x,y)
#define uni(x) x.erase(unique(all(x)),x.end())
#define exist(x,y) (find(all(x),y)!=x.end())
#define bcnt(x) bitset<32>(x).count()
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> P;
typedef pair<P,P> PP;
typedef pair<P, int> PPI;
typedef pair<ll, ll> PL;
typedef pair<P, ll> PPL;
#define INF INT_MAX/3
#define MAX_N 1000
int h,w;
string s[555];
int dd[]={-1,0,1,0,-1};
int change(int nh,int nw){
int cnt=0;
vector<char> cs;
vector<P> ps;
rep(d,4){
int dh=dd[d],dw=dd[d+1];
int i=nh,j=nw;
while(i>=0&&i<h&&j>=0&&j<w&&s[i][j]=='.'){
i+=dh; j+=dw;
}
if(i>=0&&i<h&&j>=0&&j<w){
cs.pb(s[i][j]);
ps.pb(P(i,j));
}
}
rep(k,cs.size())rep(l,k){
if(cs[k]!='.'&&cs[k]==cs[l]){
s[ps[k].fi][ps[k].se]='.';
s[ps[l].fi][ps[l].se]='.';
cnt+=2;
}
}
return cnt;
}
int main(){
cin.sync_with_stdio(false);
cin>>h>>w;
rep(i,h)cin>>s[i];
int res=0;
while(1){
int cnt=0;
rep(i,h)rep(j,w){
if(s[i][j]!='.')continue;
cnt+=change(i,j);
}
if(cnt==0)break;
res+=cnt;
}
cout<<res<<endl;
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 3e6 + 100;
const long long inf = 0x3f3f3f3f;
const long long iinf = 1 << 30;
const long long linf = 2e18;
const long long mod = 998244353;
const double eps = 1e-7;
template <class T = long long>
T chmin(T &a, T b) {
return a = min(a, b);
}
template <class T = long long>
T chmax(T &a, T b) {
return a = max(a, b);
}
template <class T = long long>
inline void red(T &x) {
x -= mod, x += x >> 31 & mod;
}
template <class T = long long>
T read() {
T f = 1, a = 0;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
a = (a << 3) + (a << 1) + ch - '0';
ch = getchar();
}
return a * f;
}
long long n, q, w = 1e9;
long long a[maxn];
vector<pair<long long, long long> > b[maxn];
long long rt, cnt;
struct node {
long long ls, rs, val;
void clear() { ls = rs = val = 0; }
} tr[maxn];
void modify(long long &tot, long long l, long long r, long long p,
long long x) {
if (!tot) tot = ++cnt, assert(cnt < maxn), tr[tot].clear();
chmax(tr[tot].val, x);
if (l == r) return;
if (p <= ((l + r) >> 1))
modify(tr[tot].ls, l, ((l + r) >> 1), p, x);
else
modify(tr[tot].rs, ((l + r) >> 1) + 1, r, p, x);
}
long long query(long long tot, long long l, long long r, long long L,
long long R) {
if (!tot) return 0;
if (l >= L && r <= R) return tr[tot].val;
long long ret = 0;
if (L <= ((l + r) >> 1))
chmax(ret, query(tr[tot].ls, l, ((l + r) >> 1), L, R));
if (R > ((l + r) >> 1))
chmax(ret, query(tr[tot].rs, ((l + r) >> 1) + 1, r, L, R));
return ret;
}
struct binary_indexed_tree {
long long val[maxn];
void init() {
for (long long i = (1); i <= (n); ++i) val[i] = linf;
}
void add(long long pos, long long x) {
for (long long i = pos; i <= n; i += (i & -i)) chmin(val[i], x);
}
long long query(long long pos) {
long long ret = linf;
for (long long i = pos; i; i -= (i & -i)) chmin(ret, val[i]);
return ret;
}
} bit;
long long ans[maxn];
signed main() {
n = read();
for (long long i = (1); i <= (n); ++i) a[i] = read();
q = read();
for (long long i = (1); i <= (q); ++i) {
long long l = read(), r = read();
b[r].push_back(make_pair(l, i));
ans[i] = linf;
}
bit.init();
for (long long i = (1); i <= (n); ++i) {
if (i % 1000 == 0) cerr << i << endl;
long long pos = query(rt, 1, w, 1, a[i]);
while (pos) {
bit.add(n - pos + 1, a[i] - a[pos]);
if (a[pos] == a[i]) break;
pos = query(rt, 1, w, a[i] - (a[i] - a[pos]) / 2, a[i]);
}
for (pair<long long, long long> j : b[i])
chmin(ans[j.second], bit.query(n - j.first + 1));
modify(rt, 1, w, a[i], i);
}
bit.init();
rt = cnt = 0;
for (long long i = (1); i <= (n); ++i) {
long long pos = query(rt, 1, w, a[i], w);
while (pos) {
bit.add(n - pos + 1, a[pos] - a[i]);
if (a[pos] == a[i]) break;
pos = query(rt, 1, w, a[i], a[i] + (a[pos] - a[i]) / 2);
}
for (pair<long long, long long> j : b[i])
chmin(ans[j.second], bit.query(n - j.first + 1));
modify(rt, 1, w, a[i], i);
}
for (long long i = (1); i <= (q); ++i) printf("%lld\n", ans[i]);
return 0;
}
| 12 | CPP |
from sys import stdin
from math import ceil
input = stdin.readline
for _ in range(int(input())):
a,b,c,d,k = map(int, input().split())
if ceil(a/c) + ceil(b/d) <= k:
print(ceil(a/c), ceil(b/d))
else:
print(-1) | 7 | PYTHON3 |
S=input()
K=int(input())
for i in range(K):
if S[i]!='1':
print(S[i])
exit()
print(S[K-1]) | 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long power(long long a, long long b) {
long long res = 1;
a;
for (; b; b >>= 1) {
if (b & 1) res = res * a;
a = a * a;
}
return res;
}
string a, b, c;
long long q, n, t, m;
int arr[100][100];
int brr[1000009];
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) cin >> arr[i][j];
long long ans = 0;
for (int i = 1; i <= n; i++) {
long long c0 = 0;
for (int j = 1; j <= m; j++)
if (arr[i][j] == 0) c0++;
long long c1 = m - c0;
ans += power(2ll, c0) + power(2ll, c1) - 2;
}
for (int i = 1; i <= m; i++) {
long long c0 = 0;
for (int j = 1; j <= n; j++)
if (arr[j][i] == 0) c0++;
long long c1 = n - c0;
ans += power(2ll, c0) + power(2ll, c1) - 2;
}
cout << ans - n * m;
}
| 8 | CPP |
a=int(input())
if a>0 and a%2==0 and a!=2:
print('YES')
else:
print('NO')
| 7 | PYTHON3 |
import math
import os
import random
import re
import sys
n, k, l, c, d, p, nl, np = map(int, input().rstrip().split())
ml = k*l
toast1 = ml//nl
limetoast = c*d
salttoast = p//np
m = min(toast1 , limetoast , salttoast)
m1 = m//n
print(m1) | 7 | PYTHON3 |
n = int(input()) - 10
s = input()
num_eight = 0
for i in range(0, n) :
if (s[i] == '8') :
num_eight = num_eight + 1
if (num_eight > n / 2) :
print ("YES")
else :
print ("NO") | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
const int INF = 0x3f3f3f3f;
const int mo = 1e9 + 7;
inline int ksm(int a, int b) {
int ret = 1;
for (; b; b >>= 1, a = 1ll * a * a % mo)
if (b & 1) ret = 1ll * ret * a % mo;
return ret;
}
inline int read() {
char ch = getchar();
int x = 0, f = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 3) + (x << 1) + ch - '0';
ch = getchar();
}
return x * f;
}
int n = 4, m, f[N][21], dep[N];
struct node {
int u, v, mx;
bool operator<(const node &A) const { return mx < A.mx; }
} a;
int LCA(int x, int y) {
if (dep[x] < dep[y]) swap(x, y);
for (int i = 20; i >= 0; i--)
if (dep[f[x][i]] >= dep[y]) x = f[x][i];
if (x == y) return x;
for (int i = 20; i >= 0; i--)
if (f[x][i] != f[y][i]) x = f[x][i], y = f[y][i];
return f[x][0];
}
int dist(int x, int y) {
int lca = LCA(x, y);
return dep[x] + dep[y] - 2 * dep[lca];
}
void add(int u) {
int x = n + 1, y = n + 2;
n += 2;
dep[x] = dep[y] = dep[u] + 1;
f[x][0] = f[y][0] = u;
for (int i = 1; i <= 20; i++) f[x][i] = f[y][i] = f[f[x][i - 1]][i - 1];
int xx = a.u, yy = a.v;
node b = (node){xx, x, dist(xx, x)}, c = (node){xx, y, dist(xx, y)};
node d = (node){yy, x, dist(yy, x)}, e = (node){yy, y, dist(yy, y)};
node f = (node){xx, yy, dist(xx, yy)};
if (a < b) a = b;
if (a < c) a = c;
if (a < d) a = d;
if (a < e) a = e;
if (a < f) a = f;
}
signed main() {
dep[1] = 1;
a.u = 2, a.v = 4, a.mx = 2;
dep[2] = dep[3] = dep[4] = 2;
f[1][0] = f[2][0] = f[3][0] = f[4][0] = 1;
m = read();
for (; m; m--) {
int u = read();
add(u);
printf("%d\n", a.mx);
}
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, n, m, k, ans, mx, ar[3505], s1;
cin >> t;
while (t--) {
ans = -1;
cin >> n >> m >> k;
s1 = n - m + 1;
k = min(k, m - 1);
for (int i = 0; i < n; i++) {
cin >> ar[i];
}
for (int i = 0; i <= k; i++) {
for (int j = i + s1 - 1; j < n - k + i; j++) {
if (j == i + s1 - 1)
mx = max(ar[j], ar[j - s1 + 1]);
else
mx = min(mx, max(ar[j], ar[j - s1 + 1]));
}
ans = max(mx, ans);
}
cout << ans << endl;
}
}
| 7 | CPP |
# Author : nitish420 --------------------------------------------------------------------
import os
import sys
from io import BytesIO, IOBase
# mod=10**9+7
# sys.setrecursionlimit(10**6)
# mxm=sys.maxsize
# from functools import lru_cache
from collections import Counter
def main():
c=Counter(input())
l=list(c.values())
ans=0
for item in l:
ans+=(item*item)
print(ans)
# 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() | 8 | PYTHON3 |
t=int(input())
for i in range(t):
l=int(input())
s=input()
flag=False
for j in range(len(s)):
if(s[j]=="8" and l-j>=11):
flag=True
break
if(flag==True):
print("YES")
else:
print("NO") | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long MOD = 998244353;
double eps = 1e-12;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t;
cin >> t;
for (long long it = 0; it < t; it++) {
int n, x;
cin >> n >> x;
vector<int> v1(n);
long long sum = 0;
bool ab = false;
unordered_set<int> s1;
for (long long i = 0; i < n; i++) {
cin >> v1[i];
sum += (v1[i] - x);
if (x == v1[i]) ab = true;
s1.insert(v1[i]);
};
;
;
;
if (s1.size() == 1) {
if (*s1.begin() == x)
cout << 0 << "\n";
else
cout << 2 << "\n";
} else {
if (sum == 0)
cout << 1 << "\n";
else if (ab)
cout << 1 << "\n";
else
cout << 2 << "\n";
}
}
return 0;
}
| 9 | CPP |
#include<bits/stdc++.h>
using namespace std;
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define endl "\n"
#define int long long
const int N = 2e5 + 5;
int32_t main()
{
IOS;
int t;
cin >> t;
while (t--)
{
int n, c;
cin >> n >> c;
vector<int> a(n + 1), b(n + 1);
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i < n; i++) cin >> b[i];
int ans = 4e18, bal = 0, days = 0;
for (int i = 1; i <= n; i++)
{
int cur = days + max(0LL, (c - bal + a[i] - 1) / a[i]);
ans = min(ans, cur);
int newDays = max(0LL, (b[i] - bal + a[i] - 1) / a[i]);
days += newDays + 1;
bal += newDays * a[i] - b[i];
}
cout << ans << endl;
}
return 0;
}
| 12 | CPP |
from sys import stdin
from collections import Counter
def main():
n, m = map(int, input().split())
d = {'B': Counter(), 'S': Counter()}
for s in stdin.read().splitlines():
a, b, c = s.split()
d[a][int(b)] += int(c)
for k in sorted(d['S'].keys(), reverse=True)[-m:]:
print(f"S {k} {d['S'][k]}")
for k in sorted(d['B'].keys(), reverse=True)[:m]:
print(f"B {k} {d['B'][k]}")
if __name__ == '__main__':
main()
| 8 | PYTHON3 |
n, a = int(input()), sorted(map(int, input().split()))
print(min(a[-1] - a[1], a[-2] - a[0])) | 8 | PYTHON3 |
#include <bits/stdc++.h>
int main() {
char inp[100];
scanf("%s", &inp);
int len = strlen(inp);
int mtx[200][200];
for (int i = 0; i < 200; i++) {
for (int j = 0; j < 200; j++) {
mtx[i][j] = 0;
}
}
int x = 100, y = 100, whoops = 0, tempx = 100, tempy = 100;
mtx[100][100] = 1;
for (int i = 0; i < len; i++) {
switch (inp[i]) {
case 'L':
y--;
break;
case 'R':
y++;
break;
case 'U':
x++;
break;
case 'D':
x--;
break;
}
if ((mtx[x + 1][y] == 1 && x + 1 != tempx) ||
(mtx[x - 1][y] == 1 && x - 1 != tempx) ||
(mtx[x][y + 1] == 1 && y + 1 != tempy) ||
(mtx[x][y - 1] == 1 && y - 1 != tempy) || mtx[x][y] == 1) {
printf("BUG");
whoops = 1;
break;
} else {
tempx = x;
tempy = y;
mtx[x][y] = 1;
}
}
if (whoops == 0) {
printf("OK");
}
return 0;
}
| 8 | CPP |
# cf 136 A 700
_ = input()
A = list(map(int, input().split()))
n = len(A)
R = [-1] * n
for i in range(len(A)):
R[A[i] - 1] = i + 1
print(" ".join(map(str, R)))
| 7 | PYTHON3 |
#include <iostream>
#include <cstdio>
#include <vector>
#include <queue>
#include <functional>
#include <string.h>
using namespace std;
static const int INF = 2e9;
static const int SIZE = 10001;
typedef pair<int, int> P;
struct edge
{
int to;
int cost;
};
int d[SIZE];
vector<edge> G[SIZE];
void solve()
{
int n;
cin >> n;
for (int i = 0; i < n; ++i)
{
int u, k;
cin >> u >> k;
for (int j = 0; j < k; ++j)
{
int to, cost;
scanf("%d %d", &to, &cost);
// cin >> to >> cost;
edge e1;
e1.to = to;
e1.cost = cost;
G[u].push_back(e1);
}
}
for (int i = 0; i < SIZE; ++i)
{
d[i] = INF;
}
d[0] = 0;
priority_queue<P, vector<P>, greater<P> > pque;
pque.push(P(0, 0));
while (!pque.empty())
{
P p = pque.top();
pque.pop();
int v = p.second;
for (int i = 0; i < G[v].size(); ++i)
{
edge e = G[v][i];
if (d[e.to] > d[v] + e.cost)
{
d[e.to] = d[v] + e.cost;
pque.push(P(d[e.to], e.to));
}
}
}
for (int i = 0; i < n; ++i)
{
printf("%d %d\n", i, d[i]);
// cout << i << " " << d[i] << endl;
}
}
int main()
{
solve();
return(0);
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<int> E[110];
map<pair<int, int>, int> M;
int n;
void make(int u, int v, double X) {
if (X < 1)
printf("1 %d %d %d %.12f\n", M[pair<int, int>(u, v)], u, v, X);
else
printf("1 %d %d %d %.12f\n", M[pair<int, int>(u, v)], v, u, X - 1);
}
void dfs(int x, int fa, double L) {
int N = ((int)(E[x]).size());
double now = L;
for (int e : E[x])
if (e != fa) {
now += 2.0 / N;
if (now > 2) now -= 2;
make(x, e, now);
dfs(e, x, fmod(now + 1, 2));
}
}
void solve() {
scanf("%d", &n);
for (int i = 0; i < n - 1; i++) {
int x, y;
scanf("%d%d", &x, &y);
E[x].push_back(y);
E[y].push_back(x);
M[pair<int, int>(x, y)] = i + 1;
M[pair<int, int>(y, x)] = i + 1;
}
printf("%d\n", n - 1);
dfs(1, -1, 0);
}
int main() {
int Tc = 1;
for (int tc = 1; tc <= Tc; tc++) {
solve();
}
return 0;
};
| 12 | CPP |
n=int(input())
l=input()
j=1
i=0
s=''
while i<n:
s+=l[i]
i+=j
j+=1
print(s)
| 7 | PYTHON3 |
s=str(input())
s=s.lower()
f="aeiouAEIOUYy"
for i in range(len(s)):
if s[i] in f:
continue
else:
print(".",end="")
print(s[i],end="")
| 7 | PYTHON3 |
S = str(input())
B = []
for i in range(0, len(S), 2):
B.append(S[i])
B.sort()
for i in range(0, len(B)):
if i == len(B) - 1:
print(B[i], sep='', end='')
break
print(B[i], '+', sep='', end='')
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int __SIZE = 1 << 18;
char ibuf[__SIZE], *iS, *iT;
template <typename T>
inline void read(T &x) {
char ch, t = 0;
x = 0;
while (!isdigit(ch = (iS == iT
? (iT = (iS = ibuf) + fread(ibuf, 1, __SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++)))
t |= ch == '-';
while (isdigit(ch))
x = x * 10 + (ch ^ 48),
ch = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, __SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
x = t ? -x : x;
}
inline int read_int() {
int x;
return read(x), x;
}
inline long long read_ll() {
long long x;
return read(x), x;
}
template <typename T>
inline void chkmin(T &a, T b) {
a = a < b ? a : b;
}
template <typename T>
inline void chkmax(T &a, T b) {
a = a > b ? a : b;
}
const int MAXN = 100010;
const int MAXM = 400010;
int n;
int m;
int tot;
int fi[MAXN];
int to[MAXM];
int ne[MAXM];
int br[MAXM];
inline void Link(int u, int v) {
tot++;
to[tot] = v;
ne[tot] = fi[u];
fi[u] = tot;
}
int dfn[MAXN];
int low[MAXN];
int col[MAXN];
int tim;
int N;
inline void dfs(int x, int la = 0) {
dfn[x] = low[x] = ++tim;
for (int i = fi[x]; i; i = ne[i]) {
int u = to[i];
if (u == la) continue;
if (!dfn[u]) dfs(u, x), chkmin(low[x], low[u]);
chkmin(low[x], dfn[u]);
}
}
inline int BFS(int x, int c) {
col[x] = c;
queue<int> q;
q.push(x);
int sz = 1;
while (!q.empty()) {
int x = q.front();
q.pop();
for (int i = fi[x]; i; i = ne[i]) {
if (br[i]) continue;
int u = to[i];
if (col[u] == c) continue;
col[u] = c;
q.push(u);
++sz;
}
}
return sz;
}
struct Graph {
int tot;
int fi[MAXN];
int deg[MAXN];
int ne[MAXN << 1];
int to[MAXN << 1];
inline void Link(int u, int v) {
tot++;
to[tot] = v;
ne[tot] = fi[u];
fi[u] = tot;
++deg[u];
}
int leaf;
int mx, Sum;
int f[MAXN];
int vis[MAXN];
inline void dp(int x, int la) {
leaf += deg[x] <= 1;
f[x] = deg[x] > 1, vis[x] = 1;
for (int i = fi[x]; i; i = ne[i]) {
int u = to[i];
if (u == la) continue;
dp(u, x);
chkmax(mx, f[x] + f[u]);
chkmax(f[x], f[u] + 1);
}
}
inline int solve() {
int Block = 0;
for (int i = 1; i <= N; i++)
if (!vis[i]) mx = 0, dp(i, 0), Sum += mx, ++Block;
return N - Sum - leaf + Block - 1;
}
} G;
int main() {
n = read_int(), m = read_int();
for (int i = 1; i <= m; i++) {
int u = read_int(), v = read_int();
Link(u, v), Link(v, u);
}
int res = 0;
for (int i = 1; i <= n; i++)
if (!dfn[i]) dfs(i);
for (int i = 1; i <= tot; i += 2) {
int u = to[i], v = to[i + 1];
if (dfn[u] > dfn[v]) swap(u, v);
if (dfn[u] < low[v]) br[i] = br[i + 1] = 1;
}
for (int i = 1; i <= n; i++)
if (!col[i]) res += BFS(i, ++N) - 1;
for (int i = 1; i <= tot; i += 2)
if (br[i]) {
int u = col[to[i]], v = col[to[i + 1]];
G.Link(u, v), G.Link(v, u);
}
printf("%d\n", res + G.solve());
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 605;
const int grad = 8;
int n, m, a[N][N], b[N][N];
bool u[N][N], f[N][N];
queue<pair<int, int> > q1, q2;
void can1(int px, int py, int x, int y) {
if (x <= 0 || y <= 0 || x > n || y > m || u[x][y] ||
abs(a[px][py] - a[x][y]) >= grad)
return;
q1.push(pair<int, int>(x, y));
u[x][y] = true;
}
void bfs1(int x, int y) {
q1.push(pair<int, int>(x, y));
while (!q1.empty()) {
x = q1.front().first;
y = q1.front().second;
q1.pop();
can1(x, y, x - 1, y);
can1(x, y, x, y - 1);
can1(x, y, x + 1, y);
can1(x, y, x, y + 1);
can1(x, y, x - 1, y - 1);
can1(x, y, x + 1, y + 1);
}
}
void can2(int px, int py, int x, int y) {
if (x <= 0 || y <= 0 || x > n || y > m || f[x][y] ||
abs(b[px][py] - b[x][y]) >= grad)
return;
q2.push(pair<int, int>(x, y));
f[x][y] = true;
}
void bfs2(int x, int y) {
q2.push(pair<int, int>(x, y));
while (!q2.empty()) {
x = q2.front().first;
y = q2.front().second;
q2.pop();
can2(x, y, x - 1, y);
can2(x, y, x, y - 1);
can2(x, y, x + 1, y);
can2(x, y, x, y + 1);
can2(x, y, x - 1, y - 1);
can2(x, y, x + 1, y + 1);
}
}
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
int test;
cin >> test;
while (test--) {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> a[i][j];
}
}
memset(u, 0, sizeof(u));
memset(f, 0, sizeof(f));
for (int i = 1; i <= n / 2; i++) {
for (int j = 1; j <= m; j++) {
b[i][j] = a[i + n / 2][j];
b[i + n / 2][j] = a[i][j];
}
}
int k1 = 0, k2 = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (!u[i][j]) {
bfs1(i, j);
k1++;
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (!f[i][j]) {
bfs2(i, j);
k2++;
}
}
}
if (k1 < k2)
printf("NO\n");
else
printf("YES\n");
}
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
char expression[5002];
vector<int> pos;
int get_priority(char op) {
if (op == '+')
return 1;
else
return 2;
}
long long int calc(long long int x, long long int y, char op) {
if (op == '+')
return 0LL + x + y;
else
return 1LL * x * y;
}
long long int eval(int start, int end) {
stack<long long int> vals;
stack<char> op;
stack<long long int> middle;
stack<char> mop;
long long int x, y, z;
char opratr;
for (int i = 0; i < start; i++) {
if (expression[i] >= '1' && expression[i] <= '9') {
vals.push(1LL * (expression[i] - '0'));
} else {
while ((!op.empty()) &&
(get_priority(op.top()) >= get_priority(expression[i]))) {
x = vals.top();
vals.pop();
y = vals.top();
vals.pop();
opratr = op.top();
op.pop();
z = calc(y, x, opratr);
vals.push(z);
}
op.push(expression[i]);
}
}
for (int i = start; i <= end; i++) {
if (expression[i] >= '1' && expression[i] <= '9') {
middle.push(1LL * (expression[i] - '0'));
} else {
while ((!mop.empty()) &&
(get_priority(mop.top()) >= get_priority(expression[i]))) {
x = middle.top();
middle.pop();
y = middle.top();
middle.pop();
opratr = mop.top();
mop.pop();
z = calc(y, x, opratr);
middle.push(z);
}
mop.push(expression[i]);
}
}
while (!mop.empty()) {
x = middle.top();
middle.pop();
y = middle.top();
middle.pop();
opratr = mop.top();
mop.pop();
z = calc(y, x, opratr);
middle.push(z);
}
long long int mid = middle.top();
vals.push(mid);
int l = strlen(expression);
for (int i = end + 1; i < l; i++) {
if (expression[i] >= '1' && expression[i] <= '9') {
vals.push(1LL * (expression[i] - '0'));
} else {
while ((!op.empty()) &&
(get_priority(op.top()) >= get_priority(expression[i]))) {
x = vals.top();
vals.pop();
y = vals.top();
vals.pop();
opratr = op.top();
op.pop();
z = calc(y, x, opratr);
vals.push(z);
}
op.push(expression[i]);
}
}
while (!op.empty()) {
x = vals.top();
vals.pop();
y = vals.top();
vals.pop();
opratr = op.top();
op.pop();
z = calc(y, x, opratr);
vals.push(z);
}
return vals.top();
}
long long int solve() {
int s = pos.size() - 1, i, j, x, y;
long long int maxim = 0, curr;
for (i = 0; i <= s; i++) {
for (j = i + 1; j <= s; j++) {
x = pos[i] + 1;
y = pos[j] - 1;
if (x <= y) {
curr = eval(x, y);
maxim = curr > maxim ? curr : maxim;
}
}
}
return maxim;
}
int main() {
scanf("%s", expression);
int i, l = strlen(expression) - 1;
pos.push_back(-1);
for (i = 0; i <= l; i++) {
if (expression[i] == '*') pos.push_back(i);
}
pos.push_back(l + 1);
printf("%I64d\n", solve());
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long powMod(long long x, long long y) {
long long res = 1;
x = x % 1000000007;
while (y > 0) {
if (y & 1) res = (res * x) % 1000000007;
y = y >> 1;
x = (x * x) % 1000000007;
}
return res;
}
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long lcm(long long a, long long b) {
return (max(a, b) / gcd(a, b)) * min(a, b);
}
void solve() {
int n;
cin >> n;
cout << n / 2;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int t = 1;
cin >> t;
while (t--) {
solve();
cout << endl;
}
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long MAX = 300001;
long long n, k, cnt[MAX], mask[MAX], inf = 9999999;
string s;
int main() {
cin >> s;
n = s.size();
set<long long> zeros;
set<long long> ones;
vector<vector<long long>> ans;
zeros.insert(inf);
ones.insert(inf);
long long cnt1 = 0, cnt0 = 0;
for (int i = 0; i < n; i++) {
if (s[i] == '1') {
ones.insert(i);
cnt1++;
} else {
zeros.insert(i);
cnt0++;
}
}
long long w = 0;
vector<long long> tmp;
tmp.push_back(*zeros.lower_bound(0));
if (tmp[0] != inf) {
zeros.erase(tmp[0]);
cnt0 -= 1;
}
while (cnt0 > 0) {
if (w == 0) {
long long a = *ones.lower_bound(tmp[tmp.size() - 1]);
if (a == inf) {
ans.push_back(tmp);
tmp.clear();
a = *zeros.lower_bound(0);
zeros.erase(a);
tmp.push_back(a);
cnt0 -= 1;
continue;
} else {
tmp.push_back(a);
ones.erase(a);
cnt1 -= 1;
}
} else {
long long a = *zeros.lower_bound(tmp[tmp.size() - 1]);
if (a == inf) {
cout << -1;
return 0;
} else {
tmp.push_back(a);
zeros.erase(a);
cnt0 -= 1;
}
}
w ^= 1;
}
if (cnt1 != 0) {
cout << -1;
return 0;
}
if (tmp.size() != 0) ans.push_back(tmp);
cout << ans.size() << "\n";
for (int i = 0; i < ans.size(); i++) {
cout << ans[i].size() << " ";
for (int j = 0; j < ans[i].size(); j++) {
cout << ans[i][j] + 1 << " ";
}
cout << "\n";
}
return 0;
}
| 7 | CPP |
from itertools import tee, combinations
def pairwise(iterable):
"s -> (s0,s1), (s1,s2), (s2, s3), ..."
a, b = tee(iterable)
next(b, None)
return zip(a, b)
def c():
len_v = int(input())
v = list(map(int, input().split()))
qtd_pares = sum(1 for num in v if num % 2 == 0)
qtd_impares = len_v - qtd_pares
if qtd_pares % 2 != qtd_impares % 2:
print('NO')
elif qtd_pares % 2 == 0:
print('YES')
else:
for pair in combinations(v, 2):
if pair[0] % 2 != pair[1] % 2 and abs(pair[0] - pair[1]) == 1:
print('YES')
return
print('NO')
def main():
for _ in range(int(input())):
c()
if __name__ == '__main__':
main()
| 9 | PYTHON3 |
n = int(input())
arr = list(map(int, input().split()))
m = max(arr)
c = 0
temp = 0
for x in arr:
if x == m:
c += 1
else:
if temp < c: temp = c
c = 0
if temp < c: temp = c
print(temp)
| 7 | PYTHON3 |
x, y, z, t1, t2, t3 = list(map(int, input().split()))
print("YES" if 3 * t3 + abs(x - z) * t2 + abs(x - y) * t2 <= abs(x - y) * t1 else "NO") | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return (a / gcd(a, b)) * b; }
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long t;
cin >> t;
while (t--) {
long long n, p;
cin >> n >> p;
long long count = 1;
for (long long i = 1; i <= n; i++) {
for (long long j = i + 1; j <= n; j++) {
if (count > 2 * n + p)
break;
else {
cout << i << " " << j << endl;
count++;
}
}
}
}
return 0;
}
| 7 | CPP |
t = int(input())
for j in range(t):
n = int(input())
a = [int(i) for i in input().split()]
b = [int(i) for i in input().split()]
mina = min(a)
minb = min(b)
ans = 0
for i in range(n):
ans += max(a[i] - mina, b[i] - minb)
print(ans) | 8 | PYTHON3 |
from functools import reduce
def gcd(a, b):
if a == 0:
return b
return gcd(b % a, a)
n, m = [int(x) for x in input().split()]
x = [int(x) for x in input().split()]
arr = [int(x) for x in input().split()]
diff = []
for i in range(1, len(x)):
diff.append(x[i] - x[i - 1])
gc = reduce(gcd, diff)
ok = 0
val = 0
for i in range(len(arr)):
if gc % arr[i] == 0:
ok = 1
pos = i
break
if not ok:
print("NO")
else:
print("YES")
print(min(x), pos + 1)
| 9 | PYTHON3 |
n = int(input())
l = list(map(int, input().rstrip().split(" ")))
l.sort()
m_c = 0
c = 1
la = l[0]
for i in range(1,len(l)):
if l[i]==la:
c+=1
else:
if c>m_c:
m_c = c
c=1
la = l[i]
if c>m_c:
m_c = c
print(m_c) | 9 | PYTHON3 |
#include <iostream>
#include <vector>
using namespace std;
int main() {
vector<int> table(10000,1);
table[0] = 0;
table[1] = 0;
for (int i=2; i<100; i++) {
if (table[i])
for (int j=i*2; j<=10000; j+=i)
table[j] = 0;
}
int n;
while(cin >> n) {
int ans = 0;
for (int i=1; i<=n; i++)
if(table[i] && table[n-i+1])
ans++;
cout << ans << endl;
}
} | 0 | CPP |
Subsets and Splits