solution
stringlengths 10
159k
| difficulty
int64 0
3.5k
| language
stringclasses 2
values |
|---|---|---|
#include <bits/stdc++.h>
using namespace std;
long long val[30] = {0}, sum[100000 + 8] = {0};
vector<long long> pos[30];
int main() {
long long i, j, k, s, d, r, m, n;
for (i = 0; i < 26; i++) {
cin >> m;
val[i] = m;
}
string line;
cin >> line;
for (i = 0; i < line.size(); i++) {
m = line[i] - 'a';
sum[i + 1] = val[m];
sum[i + 1] += sum[i];
pos[m].push_back(i + 1);
}
long long ans = 0;
for (i = 0; i < 26; i++) {
map<long long, long long> Map;
for (j = 0; j < pos[i].size(); j++) {
long long p = pos[i][j];
ans += Map[sum[p - 1]];
Map[sum[p]]++;
}
Map.clear();
}
cout << ans << endl;
}
| 1,800 | CPP |
from collections import defaultdict
def mex(ad, n):
"""Naive O(n) way to find the mex."""
for i in range(n+1):
if (i not in ad) or ad[i] == 0:
return i
def update(ad, old_value, new_value):
ad[old_value] -= 1
ad[new_value] += 1
def valid(a):
for i in range(n-1):
if a[i] > a[i+1]:
return False
return True
def find(a, n):
for i in range(n-1, -1, -1):
if a[i] != i:
return i
return None
def solve(a, n):
k = 0
ans = []
ad = defaultdict(int)
for x in a:
ad[x] += 1
while True:
if valid(a):
break
if k >= 2*n:
break
m = mex(ad, n)
k += 1
if m < n:
prev = a[m]
a[m] = m
update(ad, prev, m)
ans.append(m+1)
else: # m==n
i = find(a, n)
# i should not be None because that case should be valid and catched above
prev = a[i]
a[i] = n
update(ad, prev, n)
ans.append(i+1)
return k, ans
t = int(input())
for case in range(t):
n = int(input())
a = [int(x) for x in input().strip().split()]
k, ans = solve(a, n)
print(k)
print(*ans, sep=' ')
| 1,900 | PYTHON3 |
# 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)
# input = lambda: sys.stdin.readline().rstrip("\r\n")
import math
t = int(input())
for _ in range(t):
x,y,k = map(int,input().split())
mul = x-1
ans = k
needstick = k * (y+1)
trade = (needstick-1)//mul + 1
if (needstick-1)%mul == 0:
ans -= 1
ans += trade
print(ans)
| 1,000 | PYTHON3 |
def solve():
genome = [ord(c) for c in "ACTG"]
N = int(input())
s = input()
ans = 10**10
z = ord("Z")-ord("A")+1
for i in range(N-3):
cur = 0
for j in range(len(genome)):
dif = abs(ord(s[i+j]) - genome[j])
cur += min(dif, z - dif)
ans = min(ans,cur)
print (ans)
if __name__ == "__main__":
solve() | 1,000 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int count(int n, int m) {
if (n <= 0 || m <= 0) return 0;
return (n * m) / 2 + (n * m) % 2;
}
int main() {
int n, m, i;
cin >> n >> m >> i;
cout << count(n - 2 * i + 2, m - 2 * i + 2) - count(n - 2 * i, m - 2 * i);
return 0;
}
| 1,600 | CPP |
t = int(input())
for i in range(t):
n,k = map(int,input().split())
numk_1 = (k-2) * 2 + 1
summ = (k-1)*(1 + numk_1) // 2
numk = n - summ
if numk > numk_1 and numk % 2 == 1:
print("YES")
else:
print("NO")
| 1,100 | PYTHON3 |
s = input().split(' ')
n = int(s[0])
k = int(s[1])
if k > n // 2 + n % 2:
k -= n // 2 + n % 2 + 1
print(2 * (k + 1))
else:
print(2 * k - 1) | 900 | PYTHON3 |
n,k=input().split()
n=int(n)
k=int(k)
low=0
high=n-1
while(high-low>1):
mid=(low+high)//2
if(((n-mid)*(n-mid+1)//2 )-mid > k):
low=mid
else:
high=mid
print(high) | 1,000 | PYTHON3 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
template <class _T>
inline string tostr(const _T& a) {
ostringstream os("");
os << a;
return os.str();
}
const long double pi = 3.1415926535897932384626433832795;
const long double eps = 1e-9;
const int N = (int)1e5 + 5;
const int INF = (int)1e9 + 10;
int n, k;
int main() {
ios_base::sync_with_stdio(0);
cout.flags(ios::fixed);
cout.precision(2);
cin >> n >> k;
if (n / k >= 3) {
for (int i = 1; i <= k; i++) cout << i << ' ';
cout << k << ' ';
for (int i = 1; i < k; i++) cout << i << ' ';
for (int i = 1; i <= k; i++) cout << i << ' ';
for (int i = k * 3 + 1; i <= n; i++) cout << 1 << ' ';
} else
cout << -1;
return 0;
}
| 1,500 | CPP |
t=int(input())
for _ in range(t):
x,y,a,b=map(int,input().split())
t=(y-x)/(a+b)
if t.is_integer():
print(int(t))
else:
print(-1) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (!b) return a;
return gcd(b, a % b);
}
signed main() {
long long q;
cin >> q;
for (long long j = 0; j < q; j++) {
long long n;
cin >> n;
vector<long long> a(n);
for (long long i = 0; i < n; i++) cin >> a[i];
sort(a.begin(), a.end());
long long x, a1, y, b1, k;
cin >> x >> a1 >> y >> b1 >> k;
if (n == 1) {
long long ans = 0;
if (a1 == 1) ans += a[0] / 100 * x;
if (b1 == 1) ans += a[0] / 100 * y;
if (ans >= k) {
cout << 1 << endl;
continue;
} else {
cout << -1 << endl;
continue;
}
}
long long l = -1, r = n, ca = 0;
while (l + 1 < r) {
long long m = (l + r) / 2;
long long ans = 0;
long long cur = n - 1;
long long step = a1 * b1 / gcd(a1, b1);
vector<long long> u1(n, 0);
vector<long long> u2(n, 0);
for (long long pos = step - 1; pos <= m; pos += step) {
ans += (a[cur] / 100) * (x + y);
cur--;
u1[pos] = 1;
u2[pos] = 1;
}
long long ad1 = 0, cur1 = cur;
for (long long pos = a1 - 1; pos <= m; pos += a1) {
if (u1[pos] == 1) continue;
ad1 += (a[cur1] / 100) * x;
cur1--;
u1[pos] = 1;
}
for (long long pos = b1 - 1; pos <= m; pos += b1) {
if (u1[pos] == 1) continue;
ad1 += (a[cur1] / 100) * y;
cur1--;
u1[pos] = 1;
}
long long ad2 = 0, cur2 = cur;
for (long long pos = b1 - 1; pos <= m; pos += b1) {
if (u2[pos] == 1) continue;
ad2 += (a[cur2] / 100) * y;
cur2--;
u2[pos] = 1;
}
for (long long pos = a1 - 1; pos <= m; pos += a1) {
if (u2[pos] == 1) continue;
ad2 += (a[cur2] / 100) * x;
cur2--;
u2[pos] = 1;
}
ans += max(ad1, ad2);
if (ans >= k) {
r = m;
ca = ans;
} else {
l = m;
}
}
if (ca < k) {
cout << -1 << endl;
} else {
cout << r + 1 << endl;
}
}
}
| 1,600 | CPP |
for i in range(int(input())): print((i+2)*(i+2)*(i+1)-(2 if i==0 else i)) | 1,600 | PYTHON3 |
#problem 281A
initial=input()
answer=""
for i in range(0,len(initial)):
if i==0:
answer+=initial[i].upper()
else:
answer+=initial[i]
print(answer) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int l, r;
cin >> l >> r;
cout << "YES" << endl;
for (long long int i = l; i <= r; i += 2) cout << i << " " << i + 1 << endl;
return 0;
}
| 1,000 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (b >= a && c >= a)
cout << "Yes";
else
cout << "No";
}
| 800 | CPP |
s = input()
tv_l = [0]*len(s)
tv_p = [0]*len(s)
g_l = 0
g_r = 0
num_v = 0
wyn = 0
if 'v' not in s:
print('0')
exit(0)
for x in range(0,len(s),+1):
if s[x] == 'v':
num_v+=1
elif s[x] == 'o':
if num_v <= 1:
num_v = 0
tv_l[x] = g_l
continue
g_l += num_v-1
tv_l[x] = g_l
num_v = 0
if s[-1]=='v':
if num_v > 1:
tv_l[-1] = num_v - 1
num_v = 0
for x in range(len(s)-1,-1,-1):
if s[x] == 'v':
num_v+=1
elif s[x] == 'o':
if num_v <= 1:
num_v = 0
tv_p[x] = g_r
continue
g_r += num_v - 1
tv_p[x] = g_r
num_v = 0
if s[0]=='v':
if num_v > 1:
tv_p[0] = num_v - 1
for x in range(0,len(s),+1):
if s[x] == 'o':
wyn += tv_p[x] * tv_l[x]
print(wyn) | 1,300 | PYTHON3 |
a,d,m=list(map(int,input().split()))
g,p,b=list(map(int,input().split()))
al=g+p+b
if a<=g:
g-=a
al-=a
if d<=g+p:
al-=d
if m<=al:
print("YES")
else:
print("NO")
else:
print("NO")
else:
print("NO") | 800 | PYTHON3 |
n = int(input())
k = 0
phn = []
for i in range(n):
phn.append(input())
for i in range(len(phn[0])):
s = set()
for j in range(n):
s = s.union({int(phn[j][i])})
if len(s) == 1:
k = k +1
else:
break
print(k) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> A;
char _buf[1048576], *S, *T, c;
char gc() {
if (S == T) {
T = (S = _buf) + fread(_buf, 1, 1048576, stdin);
if (S == T) return 0;
}
return *S++;
}
void get(int& x) {
for (c = gc(); c < '0' || c > '9'; c = gc())
;
for (x = c ^ '0', c = gc(); c >= '0' && c <= '9'; c = gc())
x = (x << 3) + (x << 1) + (c ^ '0');
}
long long ans;
int n, N, M, I[100005], t[100005], m, i, j, k, l, h[100005], ne[100005 << 1],
p[100005 << 1], w[100005 << 1], R, s[100005], f[100005], a[100005],
b[100005], sum;
bool v[100005];
void dfs(int now, int fa) {
s[now] = 1;
f[now] = 0;
for (int i = h[now]; i; i = ne[i])
if (!v[p[i]] && p[i] != fa) {
dfs(p[i], now);
s[now] += s[p[i]];
f[now] = max(f[now], s[p[i]]);
}
f[now] = max(f[now], sum - s[now]);
if (f[now] < f[R]) R = now;
}
void dfs(int now, int d, int d1, int D, int fa) {
a[++M] = d;
b[M] = d1;
for (int i = h[now]; i; i = ne[i])
if (!v[p[i]] && p[i] != fa)
dfs(p[i], (d + (long long)w[i] * t[D]) % N,
(d1 + (long long)w[i] * I[D + 1]) % N, D + 1, now);
}
void work(int now, int d, int d1, int D, int x) {
M = 0;
dfs(now, d, d1, D, 0);
A.clear();
int i;
for (i = 1; i <= M; i++) A[a[i]]++;
for (i = 1; i <= M; i++) ans += x * A[(N - b[i]) % N];
}
void work(int now) {
v[now] = 1;
work(now, 0, 0, 0, 1);
for (int i = h[now]; i; i = ne[i])
if (!v[p[i]]) {
work(p[i], w[i] % N, (long long)w[i] * I[1] % N, 1, -1);
R = 0;
sum = s[p[i]];
dfs(p[i], 0);
work(R);
}
}
int main() {
get(n);
get(N);
for (i = 1; i < 10; i++)
if (((long long)i * N + 1) % 10 == 0) break;
for (I[0] = 1, I[1] = ((long long)i * N + 1) / 10, i = 2; i <= n; i++)
I[i] = (long long)I[i - 1] * I[1] % N;
for (t[0] = i = 1; i <= n; i++) t[i] = (long long)t[i - 1] * 10 % N;
for (i = 1; i < n; i++) {
get(j);
get(k);
get(l);
j++;
k++;
p[++m] = k;
w[m] = l;
ne[m] = h[j];
h[j] = m;
p[++m] = j;
w[m] = l;
ne[m] = h[k];
h[k] = m;
}
f[0] = n + 1;
sum = n;
R = 0;
dfs(1, 0);
work(R);
cout << ans - n << endl;
return 0;
}
| 2,700 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1001000;
const double eps = 1e-10, inf = 1e20, pi = acos(-1);
struct poi {
double x, y;
} c, p[maxn];
poi operator-(const poi &a, const poi &b) {
return (poi){a.x - b.x, a.y - b.y};
}
int dcmp(double x) { return fabs(x) < eps ? 0 : x < 0 ? -1 : 1; }
double dot(poi a, poi b) { return a.x * b.x + a.y * b.y; }
double cross(poi a, poi b) { return a.x * b.y - a.y * b.x; }
int n;
double mxd = -1, mnd = inf;
double poi_dis_to_seg(poi p, poi a, poi b) {
poi AB = b - a, AP = p - a, BP = p - b;
if (dcmp(dot(AB, AP)) < 0) return dot(AP, AP);
if (dcmp(dot(AB, BP)) > 0) return dot(BP, BP);
return pow(fabs(cross(AB, AP) / sqrt(dot(AB, AB))), 2);
}
int main() {
scanf("%d%lf%lf", &n, &c.x, &c.y);
for (int i = 1; i <= n; i++) scanf("%lf%lf", &p[i].x, &p[i].y);
for (int i = 1; i <= n; i++) {
mxd = max(mxd, dot(p[i] - c, p[i] - c));
double dis = poi_dis_to_seg(c, p[i % n + 1], p[i]);
mnd = min(mnd, dis);
}
printf("%.12lf\n", pi * (mxd - mnd));
return 0;
}
| 1,900 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, k;
int n;
int a1, b1, c1;
int a2, b2, c2;
int a, b, c;
int d[8], x[8], y[8], f[8];
scanf("%d", &n);
while (n--) {
scanf("%d %d %d", &a1, &b1, &c1);
scanf("%d %d %d", &a2, &b2, &c2);
scanf("%d %d %d %d %d %d %d", &d[1], &d[4], &d[3], &d[5], &d[2], &d[6],
&d[7]);
a2 = d[1] + d[3] + d[4] + d[5] - a2;
b2 = d[1] + d[2] + d[4] + d[6] - b2;
c2 = d[1] + d[2] + d[3] + d[7] - c2;
if (a1 < a2 || b1 < b2 || c1 < c2) {
printf("-1\n");
continue;
}
for (f[2] = 0; f[2] <= d[2]; f[2]++) {
for (f[3] = 0; f[3] <= d[3]; f[3]++) {
for (f[4] = 0; f[4] <= d[4]; f[4]++) {
a = f[3] + f[4];
b = f[2] + f[4];
c = f[2] + f[3];
if (a > a1 || b > b1 || c > c1) continue;
f[5] = max(min(a2 - a, d[5]), 0);
f[6] = max(min(b2 - b, d[6]), 0);
f[7] = max(min(c2 - c, d[7]), 0);
a += f[5];
b += f[6];
c += f[7];
f[1] = min(d[1],
max(max(max(0, a2 - a), max(0, b2 - b)), max(0, c2 - c)));
a += f[1];
b += f[1];
c += f[1];
if (a > a1) {
int ta = a;
a -= f[5];
f[5] -= min(ta - a1, f[5]);
a += f[5];
}
if (b > b1) {
int tb = b;
b -= f[6];
f[6] -= min(tb - b1, f[6]);
b += f[6];
}
if (c > c1) {
int tc = c;
c -= f[7];
f[7] -= min(tc - c1, f[7]);
c += f[7];
}
if (a2 > a || a1 < a || b2 > b || b1 < b || c2 > c || c1 < c)
continue;
printf("%d %d %d %d %d %d %d\n", f[1], f[4], f[3], f[5], f[2], f[6],
f[7]);
goto l;
}
}
}
printf("-1\n");
l:;
}
}
| 2,700 | CPP |
m=int(input())
print('25') | 800 | PYTHON3 |
input()
s = input()
sf_count = 0
fs_count = 0
for i in range(len(s) - 1):
if s[i] == 'S' and s[i + 1] == 'F':
sf_count += 1
if s[i] == 'F' and s[i + 1] == 'S':
fs_count += 1
if sf_count > fs_count:
print('YES')
else:
print('NO') | 800 | PYTHON3 |
from math import ceil
import sys
n, p, w, d = map(int, input().split())
def gcd(a : int, b : int):
if a == 0: return (0, 1)
(x, y) = gcd(b % a, a)
return (y - (b // a) * x, x)
def cd(a : int, b : int):
while b > 0:
(a, b) = (b, a % b)
return a
(x0, y0) = gcd(w, d)
g = cd(w, d)
if p % g > 0 :
print(-1)
sys.exit()
x0 *= p // g
y0 *= p // g
k = max(-x0 * g // d + (-x0 * g % d != 0), g * (n - x0 - y0) // (d - w) + (g * (n - x0 - y0) % (d - w) != 0))
if k > y0 * g // w :
print(-1)
sys.exit()
x = x0 + k * (d // g)
y = y0 - k * (w // g)
print(x, y, n - x - y) | 2,000 | PYTHON3 |
#!/usr/bin/env python
import os
import sys
from io import BytesIO, IOBase
def main():
for t in range(int(input())):
n,m = map(int, input().split())
nummins = 0
abssum = 0
minabs = 10000000
for i in range(n):
ms = list(map(int,input().split()))
for m in ms:
abssum += abs(m)
if m < 0:
nummins += 1
if abs(m) < minabs:
minabs = abs(m)
if nummins % 2 == 0:
print(abssum)
else:
print(abssum-2*minabs)
# 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() | 1,000 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long n, ans = 1;
long long C(long long m, long long n) {
long long p = 1;
for (long long i = 1; i <= n; i++) p *= i;
for (long long i = 1; i <= m; i++) p /= i;
for (long long i = 1; i <= n - m; i++) p /= i;
return p;
}
signed main() {
cin >> n;
for (long long i = 1; i <= n / 2 - 1; i++) ans *= i;
ans *= ans;
ans *= C(n / 2, n);
ans /= 2;
cout << ans;
return 0;
}
| 1,300 | CPP |
#include <bits/stdc++.h>
using namespace std;
int dp[38][38][58];
int n, m;
void upd(int &x, int y) { x = min(x, y); }
int main() {
memset(dp, 0x3f, sizeof(dp));
for (n = 1; n <= 32; n++) {
for (m = 1; m <= 32; m++) {
dp[n][m][0] = 0;
if (n * m < 52) dp[n][m][n * m] = 0;
for (int i = 1; i < n; i++)
for (int k1 = 0; k1 <= 52; k1++)
for (int k2 = 0; k2 <= 52 - k1; k2++)
upd(dp[n][m][k1 + k2], dp[i][m][k1] + dp[n - i][m][k2] + m * m),
upd(dp[n][m][k1], dp[i][m][k1] + m * m);
for (int i = 1; i < m; i++)
for (int k1 = 0; k1 <= 52; k1++)
for (int k2 = 0; k2 <= 52 - k1; k2++)
upd(dp[n][m][k1 + k2], dp[n][i][k1] + dp[n][m - i][k2] + n * n),
upd(dp[n][m][k1], dp[n][i][k1] + n * n);
}
}
int T;
cin >> T;
while (T--) {
int k;
scanf("%d%d%d", &n, &m, &k);
printf("%d\n", dp[n][m][k]);
}
}
| 2,000 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
int n;
int a[maxn];
vector<int> g[40];
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
int cnt = 0, tmp = a[i];
while (tmp) {
if (tmp & 1) g[cnt].push_back(a[i]);
cnt++;
tmp /= 2;
}
}
int ans = 0;
for (int i = 29; i >= 0; i--) {
int sum = (1 << (i + 1)) - 1;
for (int j = 0; j < g[i].size(); j++) sum &= g[i][j];
if (sum % (1 << i) == 0) {
ans = i;
break;
}
}
cout << g[ans].size() << endl;
for (int i = 0; i < g[ans].size(); i++)
if (i == 0)
cout << g[ans][i];
else
cout << " " << g[ans][i];
cout << endl;
return 0;
}
| 1,800 | CPP |
n,t=map(int,input().split())
num=pow(10,n-1)
for i in range(num,num*10):
if i%t==0:
print(i)
exit(0)
print(-1)
| 1,000 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long n, u, v, i, vis[100005];
vector<long long> ans;
set<long long> edges[100005];
bool check(int u, int v, int p) {
if (p > 0 && !edges[p].count(v)) return 0;
long long cnt = 0;
for (int x : edges[v]) cnt += edges[u].count(x);
return (cnt >= 2);
}
void solve(int u = 1, int p = 0) {
if (vis[u]++) return;
ans.push_back(u);
for (int v : edges[u])
if (!vis[v] && check(u, v, p)) return solve(v, u);
}
int main() {
cin.tie(0);
std ::ios ::sync_with_stdio(false);
;
cin >> n;
for (i = 0; i < 2 * n; ++i) {
cin >> u >> v;
edges[u].insert(v);
edges[v].insert(u);
}
solve();
if (ans.size() != n) return printf("-1\n"), 0;
for (int x : ans) printf("%d ", x);
printf("\n");
return 0;
}
| 2,000 | CPP |
n=int(input())
a=list(map(int,input().split()))
b = a[:]
b.reverse()
u = a.index(max(a))
l = n-1-b.index(min(a))
if u > l:
print(u+(n-1-l)-1)
else:
print(u+(n-1-l))
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
unordered_map<int, ll> shift_nums, shift_trees;
int get_lvl(ll a) {
int lvl = 0;
while (a > 0) {
a >>= 1;
++lvl;
}
return lvl - 1;
}
ll original_pos(ll x, int lvl) { return x - (1ll << lvl); }
ll mod(ll x, int lvl) {
ll cnt = 1ll << lvl;
x %= cnt;
if (x < 0) x += cnt;
return x;
}
ll up(ll x, int lvl) {
if (lvl == 0) return 0;
ll pos = mod(original_pos(x, lvl) + shift_nums[lvl] + shift_trees[lvl], lvl);
ll up_pos =
mod(pos / 2 - shift_nums[lvl - 1] - shift_trees[lvl - 1], lvl - 1) +
(1ll << (lvl - 1));
return up_pos;
}
void print(ll x, int lvl) {
while (lvl != -1) {
printf("%lld ", x);
x = up(x, lvl);
--lvl;
}
putchar('\n');
}
int main() {
int q;
scanf("%d", &q);
for (int j = 0; j < q; ++j) {
int t;
scanf("%d", &t);
if (t == 1) {
ll x, k;
scanf("%lld%lld", &x, &k);
shift_nums[get_lvl(x)] += k;
} else if (t == 2) {
ll x, k;
scanf("%lld%lld", &x, &k);
k %= 1ll << get_lvl(x);
for (int i = get_lvl(x); i <= 61; ++i, k *= 2) {
shift_trees[i] += k;
}
} else {
ll x;
scanf("%lld", &x);
print(x, get_lvl(x));
}
}
}
| 2,100 | CPP |
#include <bits/stdc++.h>
using namespace std;
int upperbound(int sz, vector<int> &v, int val) {
int low = 0;
int high = sz - 1;
int mid;
while (high >= low) {
mid = (high + low) / 2;
if (v[mid] > val)
high = mid - 1;
else {
if (mid + 1 == sz || v[mid + 1] > val) return mid;
low = mid + 1;
}
}
return -1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m, k, x, mana;
cin >> n >> m >> k >> x >> mana;
vector<int> typefmana(m), typeftime(m);
vector<int> typesmana(k), typesspells(k);
for (int i = 0; i < m; i++) cin >> typeftime[i];
for (int i = 0; i < m; i++) cin >> typefmana[i];
for (int i = 0; i < k; i++) cin >> typesspells[i];
for (int i = 0; i < k; i++) cin >> typesmana[i];
long long mintime = n * 1LL * x;
int i = upperbound(k, typesmana, mana);
long long ctime = mintime;
if (i >= 0) ctime = max(0, n - typesspells[i]) * 1LL * x;
mintime = min(mintime, ctime);
int instant;
for (int f = 0; f < m; f++) {
if (typefmana[f] > mana || typeftime[f] >= x) continue;
instant = 0;
i = upperbound(k, typesmana, mana - typefmana[f]);
if (i >= 0 && typesmana[i] <= mana - typefmana[f]) {
instant = typesspells[i];
}
ctime = max(0, n - instant) * 1LL * typeftime[f];
mintime = min(mintime, ctime);
}
cout << mintime << endl;
return 0;
}
| 1,600 | CPP |
n = int(input())
d = [x for x in input().strip()]
f = [-1] + [int(x) for x in input().split(' ')]
b = False
for i, e in enumerate(d):
e = int(e)
if not b:
if f[e] > e:
d[i] = f[e]
b = True
elif f[e] >= e:
d[i] = f[e]
b = True
else:
if b:
break
print("".join([str(x) for x in d])) | 1,300 | PYTHON3 |
n, m = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
cout = 0
j = 0
for i in a:
while j<m:
if b[j]>= i:
cout += 1
j += 1
break
j += 1
print(n - cout)
| 1,200 | PYTHON3 |
n,h = map(int,input().split())
a=[int(x) for x in input().split()]
res=[]
for i in a:
if i > h:
res.append(2)
else:
res.append(1)
print(sum(res)) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long int n;
cin >> n;
vector<long long int> a(n), b(n);
for (auto &i : a) cin >> i;
for (auto &i : b) cin >> i;
unordered_map<long long int, long long int> mp;
long long int i = 0;
long long int cnt = 0;
for (long long int j = 0; j < n; j++) {
if (b[j] == a[i]) {
mp[b[j]]++;
cnt++;
while (mp[a[i]]) {
i++;
}
} else {
mp[b[j]]++;
}
}
cout << (n - cnt) << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
return 0;
}
| 1,300 | CPP |
import math
t = int(input())
def solve(n):
if d == 0:
print("Y", 0.0, 0.0)
return
if d < 4:
print("N")
return
D = float(math.sqrt(d*(d-4)))
a = (d+D) / 2
b = (d-D) / 2
print("Y", a, b)
while t > 0:
d = int(input())
solve(d)
t -= 1
| 1,300 | PYTHON3 |
n = int(input())
l = list(map(int, input().split()))
output = 1 if l[0] == 0 else 0
u = False
for i in range(1, n):
if l[i] == 0:
output += 1
elif l[i] == l[i - 1] and l[i] != 3:
output += 1
l[i] = 0
elif l[i] == 3:
if l[i - 1] == 1:
l[i] = 2
elif l[i - 1] == 2:
l[i] = 1
print(output) | 1,400 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
ifstream Cin("input.txt");
ofstream Cout("output.txt");
int main() {
long long x, y, i;
string a, b;
x = y = 0;
cin >> a >> b;
for (i = 0; i < a.length(); ++i)
if (a[i] == '1') x++;
for (i = 0; i < b.length(); ++i)
if (b[i] == '1') y++;
x += x % 2;
if (x >= y)
cout << "YES";
else
cout << "NO";
}
| 1,700 | CPP |
#include <bits/stdc++.h>
using namespace std;
int solve() {
long long n, m;
cin >> n >> m;
long long mean = 0, mx = -1, mn = (long long)1e18;
for (long long int i = 0; i < n; i++) {
long long val = (n * (n - 1)) / 2 - i * (n - i - 1);
mx = max(mx, val);
mn = min(mn, val);
}
for (long long int i = 0; i < m; i++) {
long long x, d;
cin >> x >> d;
mean += x * n;
if (d > 0)
mean += mx * d;
else
mean += mn * d;
}
double ans = (double)mean / (double)n;
cout << setprecision(20) << ans << "\n";
return 0;
}
int main() {
auto start = chrono::high_resolution_clock::now();
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long test_cases = 1;
while (test_cases--) solve();
auto stop = chrono::high_resolution_clock::now();
auto duration = chrono::duration_cast<chrono::milliseconds>(stop - start);
}
| 1,700 | CPP |
a=input()
b=input()
c=input()
result='YES'
if len(c)!=len(a)+len(b):
result='NO'
for i in a:
if a.count(i)+b.count(i)!=c.count(i):
result='NO'
for i in b:
if a.count(i)+b.count(i)!=c.count(i):
result='NO'
if len(c)<len(a)+len(b):
result='NO'
print(result) | 800 | PYTHON3 |
n=int(input())
k=[]
for i in range(n):
a=tuple(map(int,input().split()))
k.append(set(a[1:]))
k=set.intersection(*k)
print(*k)
| 800 | PYTHON3 |
for a in range(int(input())):
n=int(input())
l=[int(x) for x in input().split()]
ll=sorted(l)
c=0
while l!=ll:
for i in range(c%2,n-1,2):
if l[i]>l[i+1]:
l[i],l[i+1]=l[i+1],l[i]
c+=1
# print(l)
print(c) | 800 | PYTHON3 |
t=int(input())
while t:
t-=1
n,k=input().split(" ")
n,k=int(n),int(k)
a=input().split(" ")
for i in range(n):
a[i]=int(a[i])
if len(set(a))>k:
print(-1,end="")
else:
print(n*k)
a=sorted(list(set(a)))
while len(a)!=k:
a.append(n)
while n:
n-=1
for i in a:
print(i,end=" ")
print() | 1,400 | PYTHON3 |
f=lambda:map(int,input().split())
n=int(input())
l=list(f())
print(max(l)-min(l)+1-n) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<string, int> > vec[5][10005];
int n, cnt[5][10005];
string str;
pair<int, int> solve(int nop, int node) {
pair<int, int> mx = make_pair(0, 0);
if (node != 0) {
mx.first = 0;
mx.second = cnt[nop][node];
}
for (int i = 0; i < vec[nop][node].size(); i++) {
int ts = vec[nop][node][i].second;
pair<int, int> pans = solve(nop, ts);
if (node == 0) {
mx.first = max(mx.first, pans.first);
mx.second = max(mx.second, pans.second);
} else {
mx.first += pans.first + 1;
mx.second += pans.second;
}
}
return mx;
}
int main() {
while (getline(cin, str)) {
char ch = str[0];
int bel = ch - 'C';
int i = 3, num, nv = 0;
string now;
nv = 0;
for (; i < str.size(); i++) {
if (str[i] == '.')
break;
else if (str[i] == '\\') {
int j = 0;
for (; j < vec[bel][nv].size(); j++)
if (vec[bel][nv][j].first == now) break;
if (j == vec[bel][nv].size()) {
n++;
vec[bel][nv].push_back(make_pair(now, n));
nv = n;
} else
nv = vec[bel][nv][j].second;
now.clear();
} else
now += str[i];
}
cnt[bel][nv]++;
}
pair<int, int> ans = make_pair(0, 0);
for (int i = 0; i < 5; i++) {
pair<int, int> ns = solve(i, 0);
ans.first = max(ans.first, ns.first);
ans.second = max(ans.second, ns.second);
}
cout << ans.first << " " << ans.second << endl;
return 0;
}
| 1,800 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > points;
int n;
double result = -1;
inline double get_abs(double first) { return first > 0 ? first : -first; }
inline bool CCW(pair<int, int> a, pair<int, int> b, pair<int, int> c) {
int sign = a.first * b.second + b.first * c.second + c.first * a.second;
sign -= (b.first * a.second + c.first * b.second + a.first * c.second);
return sign > 0;
}
inline double get_area(pair<int, int> a, pair<int, int> b, pair<int, int> c) {
double area = a.first * b.second + b.first * c.second + c.first * a.second;
area -= (b.first * a.second + c.first * b.second + a.first * c.second);
return get_abs(area) / 2.0;
}
void get_max_min(double& maxmax, double& minmin, vector<pair<int, int> > p,
int inx1, int inx2) {
for (int i = 0; i < p.size(); i++) {
double myvalue = get_area(p[i], points[inx1], points[inx2]);
maxmax = max(myvalue, maxmax);
minmin = min(myvalue, minmin);
}
}
void get_result(int inx1, int inx2) {
vector<pair<int, int> > above;
vector<pair<int, int> > below;
double above_max = -1, above_min = 987987987, below_max = -1,
below_min = 987987987;
for (int i = 0; i < points.size(); i++) {
if (i == inx1 || i == inx2) continue;
if (CCW(points[inx1], points[inx2], points[i]) == true)
above.push_back(points[i]);
else
below.push_back(points[i]);
}
if (above.size() == 0 || below.size() == 0) return;
get_max_min(above_max, above_min, above, inx1, inx2);
get_max_min(below_max, below_min, below, inx1, inx2);
result = max(result, above_max + below_max);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int a, b;
scanf("%d %d", &a, &b);
points.push_back(make_pair(a, b));
}
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
get_result(i, j);
}
}
printf("%lf\n", result);
return 0;
return 0;
return 0;
}
| 2,100 | CPP |
s=input()
s1=[]
s2=[]
for i in range (len(s)):
if(s[i]=='r'):
s1.append(i+1)
else:
s2.append(i+1)
s3=s1+s2[::-1]
for i in range (len(s)):
print(s3[i])
| 1,200 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double i, j;
cin >> i >> j;
int n;
cin >> n;
double a[n][3];
for (int x = 0; x < n; x++) {
cin >> a[x][0] >> a[x][1] >> a[x][2];
}
double ans = -1;
double t;
for (int x = 0; x < n; x++) {
t = sqrt((a[x][0] - i) * (a[x][0] - i) + (a[x][1] - j) * (a[x][1] - j)) /
a[x][2];
if (t < ans || ans == -1) {
ans = t;
}
}
printf("%.10lf", ans);
return 0;
}
| 900 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long powmod(long long a, long long b) {
long long res = 1;
a %= 1000000007;
for (; b; b >>= 1) {
if (b & 1) res = res * a % 1000000007;
a = a * a % 1000000007;
}
return res;
}
char s[505][505];
long long ans1[505][505], ans2[505][505];
bool vis[20004];
int a[3], n;
int X[7], cnt[7];
void take(int x) {
for (int i = x; i >= 0; i--)
if (cnt[i] > 0) {
cnt[i]--;
return;
}
}
int fckn() {
int xx[7];
for (int i = 0; i < 7; i++) xx[i] = cnt[i];
int res = xx[6] + xx[5];
xx[0] = max(xx[0] - xx[5], 0);
xx[1] += xx[0];
res += xx[4];
xx[1] = max(xx[1] - xx[4], 0);
xx[2] += xx[1];
res += max(xx[3], (xx[2] + xx[3] + 1) / 2);
return res;
}
int main() {
scanf("%d", &n);
scanf("%d%d%d", &a[0], &a[1], &a[2]);
sort(a, a + 3);
X[0] = a[0], X[1] = a[1], X[2] = a[2];
X[3] = a[0] + a[1], X[4] = a[0] + a[2], X[5] = a[1] + a[2];
X[6] = a[0] + a[1] + a[2];
sort(X, X + 7);
bool can = 1;
for (int i = 1; i <= n; i++) {
int t;
scanf("%d", &t);
for (int j = 0; j < 7; j++)
if (X[j] >= t) {
cnt[j]++;
break;
}
if (t > X[6]) {
can = 0;
}
}
if (!can) {
return puts("-1"), 0;
}
int ans = n;
for (int i = 0; i < n + 1; i++) {
ans = min(fckn() + i, ans);
take(0);
take(1);
take(a[0] + a[1] > a[2] ? 2 : 3);
}
cout << ans << endl;
return 0;
}
| 2,400 | CPP |
import math
x,y=map(int,input().split())
xx=math.log(x)*y
yy=math.log(y)*x
if(xx==yy):
print("=")
elif(xx>yy):
print(">")
elif(xx<yy):
print("<")
| 1,100 | PYTHON3 |
from sys import stdin
input = stdin.readline
import sys
n = int(input())
l = list(map(int,input().split()))
if l[-1] > 1:
print(-1)
sys.exit(0)
next_nonzero = [1000000] * n
next_nonzero[n-1] = n
best = n
for i in range(n-1):
j = n - 2 - i
if l[j+1] > 0:
best = j+1
next_nonzero[j] = best
col = [[] for i in range(n)]
for i in range(n):
if l[i] > 0:
col[i].append(n-1-i)
for i in range(n):
if l[i] == 3:
if next_nonzero[i] == n:
print(-1)
sys.exit(0)
else:
col[next_nonzero[i]].append(n-i-1)
#tylko dwojki chuje zostaly
jedynki = []
ile_jedynek = 0
ind = 0
for i in range(n):
j = n-1-i
if l[j] == 1 and len(col[j]) == 1:
jedynki.append(j)
ile_jedynek += 1
if l[j] == 2:
if ind >= ile_jedynek:
print(-1)
sys.exit(0)
kolu = jedynki[ind]
ind += 1
col[kolu].pop(0)
col[kolu].append(n-j-1)
wyn = 0
for i in col:
wyn += len(i)
print(wyn)
for i in range(n):
for row in col[i]:
print(n-row, i+1)
#print("MACIERZ")
#for i in mat:
#print(*i)
| 1,900 | PYTHON3 |
n,k=map(int,input().split())
if(n%2==0):
if(k<=n//2):
print(k+k-1)
else:
print((k-(n//2))*2)
else:
if(k==n//2+1):
print(n)
elif(k<n//2+1):
print(k+k-1)
else:
print((k-(n//2+1))*2)
| 900 | PYTHON3 |
def answer(n,k):
if k%(n-1)==0:
x=k//(n-1)
return n*x-1
else:
x=k//(n-1)
return n*x+k%(n-1)
t=int(input())
for i in range(t):
n,k=map(int,input().split())
print(answer(n,k)) | 1,200 | PYTHON3 |
n=int(input())
m=1000000007
print(int((pow(3, n, 4*m)+3*(-1)**n)/4)%(4*m))
| 1,500 | PYTHON3 |
# n=int(input())
# n,k=map(int,input().split())
# arr=list(map(int,input().split()))
#for i in range(m):
n=int(input())
if n<25:
print(-1)
exit()
f=0
for i in range(5,n):
if n%i==0 and (n//i)>=5:
f=1
t=[[" " for i in range(i)]for j in range(n//i)]
v="aeiou"
ans=0
for j in range(n//i):
ans=ans%5
cnt=ans
for k in range(i):
t[j][k]=v[cnt%5]
cnt+=1
ans+=1
break
#cnt+=1
if f==0:
print(-1)
else:
s = ""
for i in range(len(t)):
s += "".join(t[i])
print(s)
| 1,100 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int b, d;
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int _;
bool p2(int x) {
_ = 0;
while (gcd(x, b) != 1) x /= gcd(x, b), ++_;
return x == 1;
}
bool p3(int x) { return b % x == 1; }
bool p11(int x) { return b % x == x - 1; }
bool p6(int x) {
int __;
for (int i = 2; x > 1; ++i)
if (x % i == 0) {
__ = 1;
while (x % i == 0) x /= i, __ *= i;
;
if (!(p2(__) || p3(__) || p11(__))) return 0;
}
return 1;
}
int main() {
scanf("%d%d", &b, &d);
if (p2(d))
printf("2-type\n%d\n", _);
else if (p3(d))
printf("3-type\n");
else if (p11(d))
printf("11-type\n");
else if (p6(d))
printf("6-type\n");
else
printf("7-type\n");
return 0;
}
| 2,300 | CPP |
#include <bits/stdc++.h>
int a[100000];
int b[100000];
int fs[100000];
int bs[100000];
void func(int *n, int c) {
if (*n < 0) {
*n += c;
} else if (*n >= c) {
*n -= c;
}
}
void solve(int n, int m, int c) {
int i, j, k, t;
fs[0] = b[0];
for (i = 1; i < m; i++) {
fs[i] = fs[i - 1] + b[i];
func(&fs[i], c);
}
bs[m - 1] = b[m - 1];
for (i = m - 2; i >= 0; i--) {
bs[i] = bs[i + 1] + b[i];
func(&bs[i], c);
}
for (i = 0; i < n - m + 1 && i < m; i++) {
a[i] += fs[i];
func(&a[i], c);
}
for (k = 0, j = n - 1, t = m - 1; k < n - m + 1 && k < m && j >= i;
k++, j--, t--) {
a[j] += bs[t];
func(&a[j], c);
}
for (; i <= j; i++) {
if ((m << 1) < n) {
a[i] += fs[m - 1];
} else {
a[i] += (fs[i] - fs[i - k]);
}
func(&a[i], c);
}
for (i = 0; i < n - 1; i++) {
printf("%d ", a[i]);
}
printf("%d\n", a[i]);
}
int main() {
int n, m, c, i;
while (scanf("%d%d%d", &n, &m, &c) == 3) {
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
for (i = 0; i < m; i++) {
scanf("%d", &b[i]);
}
solve(n, m, c);
}
return 0;
}
| 1,200 | CPP |
x, y = map(int, input().split())
res = int(0)
while x <= y :
x *= 3
y *= 2
res += 1
print(res) | 800 | PYTHON3 |
n, m = list(map(int, input().split()))
a = []
ma = ""
b = []
check = set()
for i in range(n):
a.append(input())
for i in range(n):
f = True
for j in range(n):
if i == j:
continue
x = a[i]
y = a[j][::-1]
if x == y and (i, j) not in check:
f = False
b.append([x, y[::-1]])
check.add((i, j))
check.add((j, i))
if f:
ff = True
for r in range(len(a[i]) // 2):
if a[i][r] != a[i][-1 - r]:
ff = False
if ff:
if len(a[i]) > len(ma):
ma = a[i]
s = ""
s2 = ""
for i in b:
s += i[0]
s2 = i[1] + s2
s3 = s + ma + s2
print(len(s3))
print(s3)
| 1,100 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
int dcmp(double x) {
if (x < -eps)
return -1;
else
return x > eps;
}
const int N = 1050;
const int mod = 998244353;
int n;
int k;
long long lft, rht;
int cb[N];
long long cnt[20][N][2];
long long dp[20][N][2];
long long val[20];
int f[20];
long long calc(long long x) {
int len = 0;
while (x) {
f[len++] = x % 10;
x /= 10;
}
long long ans = 0;
for (int i = 0; i < (int)(len); i++) {
for (int st = 0; st < (int)((1 << 10)); st++) {
if (cb[st] > k) continue;
ans += dp[i][st][1];
ans %= mod;
}
}
long long p = 0;
int st = 0;
for (int i = (int)(len)-1; i >= 0; --i) {
for (int v = 0; v < (int)(f[i]); v++) {
if (i == len - 1 && v == 0) continue;
long long pp = p + val[i] * v;
pp %= mod;
for (int tt = 0; tt < (int)((1 << 10)); tt++) {
int ut = st | tt | (1 << v);
if (cb[ut] > k) continue;
long long tmp = pp * cnt[i][tt][0] + dp[i][tt][0];
ans = (ans + tmp) % mod;
}
}
p += val[i] * f[i];
p %= mod;
st |= (1 << f[i]);
}
if (cb[st] <= k) {
ans += p;
ans %= mod;
}
return ans;
}
long long solve() {
cb[0] = 0;
for (int i = (1); i < ((1 << 10)); ++i) {
cb[i] = cb[i & (i - 1)] + 1;
}
val[0] = 1;
for (int i = (1); i < (20); ++i) {
val[i] = val[i - 1] * 10 % mod;
}
memset(dp, 0, sizeof(dp));
memset(cnt, 0, sizeof(cnt));
cnt[0][0][0] = 1;
for (int i = 0; i < (int)(19); i++) {
for (int st = 0; st < (int)((1 << 10)); st++) {
if (cnt[i][st][0] == 0) {
continue;
}
for (int b = 0; b < (int)(10); b++) {
int tt = (st | (1 << b));
dp[i + 1][tt][0] += val[i] * b * cnt[i][st][0];
dp[i + 1][tt][0] += dp[i][st][0];
dp[i + 1][tt][0] %= mod;
cnt[i + 1][tt][0] += cnt[i][st][0];
cnt[i + 1][tt][0] %= mod;
if (b != 0) {
dp[i + 1][tt][1] += val[i] * b * cnt[i][st][0];
dp[i + 1][tt][1] += dp[i][st][0];
dp[i + 1][tt][1] %= mod;
cnt[i + 1][tt][1] += cnt[i][st][0];
cnt[i + 1][tt][1] %= mod;
}
}
}
}
long long ans = calc(rht) - calc(lft - 1);
ans = (ans % mod + mod) % mod;
return ans;
}
int main(int argc, char *argv[]) {
while (scanf("%I64d"
"%I64d"
"%d",
&lft, &rht, &k) != EOF) {
long long ret = solve();
printf(
"%I64d"
"\n",
ret);
}
return 0;
}
| 2,300 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n;
int A[200005];
int vt[200005];
int test(int x) {
int k = n / 2;
printf("? %d\n", x);
fflush(stdout);
scanf("%d", &A[x]);
printf("? %d\n", x + k);
fflush(stdout);
scanf("%d", &A[x + k]);
return A[x + k] - A[x];
}
int main() {
scanf("%d", &n);
int k = n / 2;
if (k % 2) {
puts("! -1");
fflush(stdout);
return 0;
}
int l = 1, r = k + 1;
vt[l] = test(l);
vt[r] = -vt[l];
int ans = -1;
int mid = 1;
while (vt[mid] != 0) {
mid = (l + r) / 2;
int d = vt[mid] = test(mid);
if (d == 0) {
ans = mid;
break;
}
if (d * vt[l] < 0) {
r = mid;
} else {
l = mid;
}
}
if (ans == -1 && vt[l] != 0 && vt[r] != 0) {
puts("! -1");
fflush(stdout);
return 0;
}
ans = mid;
printf("! %d\n", ans);
fflush(stdout);
return 0;
}
| 2,000 | CPP |
#include <bits/stdc++.h>
using namespace std;
using llg = long long;
const int maxNod = (int)(1e5) + 5;
const int maxEdges = 3 * (int)(1e5) + 5;
const int maxQueries = 3 * (int)(1e5) + 5;
const int maxTokens = 2 * maxQueries;
const llg BIG = (llg)(1e9) * (llg)(1e9);
int nbNod, nbEdges, nbCentrals, nbQueries;
llg rep[maxQueries];
int dsuRepr[maxNod];
int dsuSize[maxNod];
vector<int> tokenIn[maxNod];
int baseTok[maxTokens];
void dsuInit() {
for (int nod = 0; nod < maxNod; ++nod) {
dsuRepr[nod] = nod;
dsuSize[nod] = 1;
}
}
int dsuFind(int x) {
if (x != dsuRepr[x]) {
dsuRepr[x] = dsuFind(dsuRepr[x]);
}
return dsuRepr[x];
}
void dsuMerge(int small, int big, llg curCap) {
small = dsuFind(small);
big = dsuFind(big);
if (small == big) return;
if (dsuSize[small] > dsuSize[big]) swap(small, big);
for (int token : tokenIn[small]) {
int oth = token ^ 1;
int query = token / 2;
if (dsuFind(baseTok[oth]) == big) {
rep[query] = curCap;
}
tokenIn[big].push_back(token);
}
tokenIn[small].clear();
tokenIn[small].shrink_to_fit();
dsuSize[big] += dsuSize[small];
dsuRepr[small] = big;
}
vector<pair<int, llg>> adj[maxNod];
llg mdis[maxNod];
void dijkstra() {
priority_queue<pair<llg, int>> pq;
for (int nod = 0; nod < nbNod; ++nod) {
if (nod < nbCentrals) {
pq.push({0, nod});
} else {
mdis[nod] = BIG;
}
}
while (!pq.empty()) {
llg dist = -pq.top().first;
int nod = pq.top().second;
pq.pop();
if (dist != mdis[nod]) continue;
for (auto rawNeigh : adj[nod]) {
int neighbor = rawNeigh.first;
llg newDis = dist + rawNeigh.second;
if (newDis < mdis[neighbor]) {
mdis[neighbor] = newDis;
pq.push({-newDis, neighbor});
}
}
}
}
struct Edge {
llg weight, n1, n2;
};
bool operator<(Edge a, Edge b) { return a.weight < b.weight; }
vector<Edge> tabEdges;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
dsuInit();
cin >> nbNod >> nbEdges >> nbCentrals >> nbQueries;
for (int iEdge = 0; iEdge < nbEdges; ++iEdge) {
int n1, n2;
llg weight;
cin >> n1 >> n2 >> weight;
--n1;
--n2;
adj[n1].emplace_back(n2, weight);
adj[n2].emplace_back(n1, weight);
tabEdges.push_back({weight, n1, n2});
}
for (int query = 0; query < nbQueries; ++query) {
int n1, n2;
cin >> n1 >> n2;
--n1;
--n2;
int tk1 = 2 * query, tk2 = 2 * query + 1;
baseTok[tk1] = n1;
baseTok[tk2] = n2;
tokenIn[n1].push_back(tk1);
tokenIn[n2].push_back(tk2);
}
dijkstra();
for (auto &edge : tabEdges) {
edge.weight += mdis[edge.n1] + mdis[edge.n2];
}
sort(tabEdges.begin(), tabEdges.end());
for (auto edge : tabEdges) {
dsuMerge(edge.n1, edge.n2, edge.weight);
}
for (int query = 0; query < nbQueries; ++query) {
cout << rep[query] << "\n";
}
}
| 2,500 | CPP |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
int main() {
int n, b;
while (scanf("%d", &n) != EOF) {
b = 0;
int ans;
scanf("%d", &ans);
for (int i = 1; i < n; i++) {
scanf("%d", &b);
ans = gcd(ans, b);
}
printf("%d\n", ans * n);
}
return 0;
}
| 1,000 | CPP |
n = int(input())
m = int(input()[::-1], 2)
mask = (1 << n) - 1
m = m ^ (m + 1) & mask
rt = 0
while(m):
rt += m % 2
m //= 2
print(rt)
| 900 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e5;
int n, k, tot;
map<pair<int, int>, int> M;
vector<double> arm[maxn + 5];
int mabs(int x) { return x < 0 ? -x : x; }
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
double solve_center() {
vector<double> vec;
vec.push_back(0);
for (int i = (1); i <= int(tot); i++)
for (int j = (0); j <= int(arm[i].size() - 1); j++)
vec.push_back(arm[i][j] * (k - 1 - j * 2));
sort(vec.begin(), vec.end());
reverse(vec.begin(), vec.end());
double res = 0;
for (int i = (0); i <= int(k - 1); i++) res += vec[i];
return res;
}
double solve_arm() {
int t = (k + 1) / 2, p = 0;
for (int i = (1); i <= int(tot); i++)
if (n - arm[i].size() + t + 1 <= k) {
p = i;
break;
}
if (!p) return -1e18;
double res = 0;
for (int i = (1); i <= int(tot); i++)
if (i != p)
for (int j = (0); j <= int(arm[i].size() - 1); j++) {
double x = arm[i][j] - (j == arm[i].size() - 1 ? 0 : arm[i][j + 1]);
res += x * (j + 1) * (k - 1 - j);
}
for (int i = (0); i <= int(arm[p].size() - 1); i++) {
double x = arm[p][i] - (i == arm[p].size() - 1 ? 0 : arm[p][i + 1]);
int y = i < t ? i + 1
: arm[p].size() - i <= k - t - n + arm[p].size() ? n - 1 - i
: t;
res += x * y * (k - y);
}
return res;
}
int main() {
scanf("%d %d", &n, &k);
for (int i = 1, x, y, d; i <= n; i++) {
scanf("%d %d", &x, &y);
if (!x && !y) continue;
d = gcd(mabs(x), mabs(y));
if (!M[pair<int, int>(x / d, y / d)])
M[pair<int, int>(x / d, y / d)] = ++tot;
arm[M[pair<int, int>(x / d, y / d)]].push_back(
sqrt(1ll * x * x + 1ll * y * y));
}
for (int i = (1); i <= int(tot); i++) {
sort(arm[i].begin(), arm[i].end());
reverse(arm[i].begin(), arm[i].end());
}
printf("%.12lf\n", max(solve_center(), solve_arm()));
return 0;
}
| 2,900 | CPP |
# import sys
# sys.stdin=open('input.txt','r')
from itertools import *
l=['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z']
for _ in range(int(input())):
a,b,c=map(int,input().split())
x=l[:c]
for a,b in zip(range(a),cycle(x)):
print(b,end='')
print()
| 900 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
void func(void) {
freopen("input.c", "r", stdin);
freopen("output.c", "w", stdout);
}
void print(vector<long long> &v) {
cout << v.size() << endl;
for (int i = 0; i < v.size(); i++) {
printf("%lld ", v[i]);
}
printf("\n");
}
void print(vector<pair<long long, long long> > &v) {
cout << v.size() << endl;
for (int i = 0; i < v.size(); i++) {
printf("%lld %lld\n", v[i].first, v[i].second);
}
}
void print(double d) { cout << fixed << setprecision(10) << d << endl; }
void print(string s, double d) {
cout << s << " ";
cout << fixed << setprecision(10) << d << endl;
}
long long mn = 8000000000000000000;
long long sum = 0;
string s;
long long dp[220][220][220][2];
long long n;
long long dp1[220][2];
long long get(long long len, long long left) {
string s1 = "";
if (len >= s.size()) return 0;
long long &ret = dp1[len][left];
if (ret != -1) return ret;
for (int i = 0; i < len; i++) {
s1.push_back(s[i]);
}
if (!left)
s1.push_back('(');
else
s1.push_back(')');
int mx = 0;
for (int i = 0; i < s1.size(); i++) {
int cnt = 0;
for (int j = 0; j < s.size(); j++) {
if (s1[i + cnt] != s[j]) break;
cnt++;
}
if (i + cnt == s1.size()) mx = max(mx, cnt);
}
return ret = mx;
}
long long calc(long long i, long long cnt, long long nisi, long long ok) {
long long ok1 = ok;
if (nisi == s.size()) ok1 = 1;
if (i == 2 * n) {
if (cnt == 0 and ok1) return 1LL;
return 0;
}
if (cnt < 0) return 0;
long long &ret = dp[i][cnt][nisi][ok];
if (ret != -1) return ret;
long long x = 0;
long long open = get(nisi, 0);
long long close = get(nisi, 1);
x = calc(i + 1, cnt + 1, open, ok1);
x += calc(i + 1, cnt - 1, close, ok1);
x %= 1000000007;
return ret = x;
}
int main() {
long long q, i, j = 0, temp, t, k, ans = 0, x, y, z, cnt = 0, m, fg = 0,
mx1 = 0, mn1 = 8000000000000000000;
cin >> n >> s;
for (char ch : s) {
if (ch == '(')
sum++;
else
sum--;
mn = min(mn, sum);
}
memset((dp), -1, sizeof(dp));
memset((dp1), -1, sizeof(dp1));
ans = calc(0, 0, 0, 0);
cout << ans << endl;
}
| 2,300 | CPP |
t = int(input())
result = []
for i in range(t):
r = 0
n = int(input())
a = input()
b = input()
e = [int(x) for x in str(a)]
h = [int(x) for x in str(b)]
for j in range(n):
if e[j] == 0 and h[j] == 1:
r +=1
continue
elif j != 0 and h[j] == 1 and e[j-1] == 1:
r +=1
e[j-1] = 0
continue
elif j != n-1 and h[j] == 1 and e[j+1] == 1:
r +=1
e[j+1] = 0
continue
result.append(r)
for i in result:
print(i) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, k, v[505][505], b[250005], cur = 1, cnt;
char a[505][505];
void dfs(int first, int second) {
if (v[first][second] || a[first][second] == 'X') return;
v[first][second] = cur;
cnt++;
dfs(first + 1, second);
dfs(first, second + 1);
dfs(first - 1, second);
dfs(first, second - 1);
}
int f[250005] = {0}, first = 0, curans = 0, ans = 0;
void solve() {
cin >> n >> k;
for (int i = 0; i < n + 2; i++) {
for (int j = 0; j < n + 2; j++) {
if (i == 0 || j == 0 || i == n + 1 || j == n + 1)
a[i][j] = 'X';
else
cin >> a[i][j];
}
}
for (int i = 1; i < n + 1; i++) {
for (int j = 1; j < n + 1; j++) {
if (!v[i][j] && a[i][j] == '.') {
cnt = 0;
dfs(i, j);
b[cur] = cnt;
cur++;
}
}
}
for (int i = 1; i < k + 1; i++) {
for (int j = 1; j < k + 1; j++) {
if (a[i][j] == 'X') first++;
}
}
for (int i = 0; i < k + 2; i++) {
for (int j = (i == 0 || i == k + 1); j < k + 2 - (i == 0 || i == k + 1);
j++) {
if (a[i][j] == '.') {
f[v[i][j]]++;
if (f[v[i][j]] == 1) curans += b[v[i][j]];
}
}
}
ans = max(ans, curans + first);
for (int i = 0; i < n - k + 1; i++) {
int tempans = curans, tempx = first, tempf[cur + 1];
for (int j = 0; j < cur + 1; j++) tempf[j] = f[j];
for (int j = 0; j < n - k; j++) {
for (int l = 1; l < k + 1; l++) {
if (a[i + l][j + k + 1] == 'X') first++;
if (a[i + l][j + 1] == 'X') first--;
}
for (int l = 0; l < k + 2; l++) {
if (a[i + l][j + k + 2 - (l == 0 || l == k + 1)] == '.') {
f[v[i + l][j + k + 2 - (l == 0 || l == k + 1)]]++;
if (f[v[i + l][j + k + 2 - (l == 0 || l == k + 1)]] == 1)
curans += b[v[i + l][j + k + 2 - (l == 0 || l == k + 1)]];
}
if (a[i + l][j + (l == 0 || l == k + 1)] == '.') {
f[v[i + l][j + (l == 0 || l == k + 1)]]--;
if (f[v[i + l][j + (l == 0 || l == k + 1)]] == 0)
curans -= b[v[i + l][j + (l == 0 || l == k + 1)]];
}
}
ans = max(ans, curans + first);
}
curans = tempans;
first = tempx;
for (int j = 0; j < cur + 1; j++) f[j] = tempf[j];
for (int l = 1; l < k + 1; l++) {
if (a[i + k + 1][l] == 'X') first++;
if (a[i + 1][l] == 'X') first--;
}
for (int l = 0; l < k + 2; l++) {
if (a[i + k + 2 - (l == 0 || l == k + 1)][l] == '.') {
f[v[i + k + 2 - (l == 0 || l == k + 1)][l]]++;
if (f[v[i + k + 2 - (l == 0 || l == k + 1)][l]] == 1)
curans += b[v[i + k + 2 - (l == 0 || l == k + 1)][l]];
}
if (a[i + (l == 0 || l == k + 1)][l] == '.') {
f[v[i + (l == 0 || l == k + 1)][l]]--;
if (f[v[i + (l == 0 || l == k + 1)][l]] == 0)
curans -= b[v[i + (l == 0 || l == k + 1)][l]];
}
}
if (i == n - k) break;
ans = max(ans, curans + first);
}
cout << ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) solve();
return 0;
}
| 2,400 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
double ans = 0;
double y;
for (int i = 0; i < n; i++) {
cin >> y >> y;
ans += y;
}
printf("%.3lf", ans / n + 5 + 0.001);
return 0;
}
| 2,200 | CPP |
contestant,place=map(int,input().split())
score=list(map(int,input().split()))
count=0
l=[]
for i in range(0,contestant):
if(score[i]>0):
if(score[i]>=score[place-1]):
count+=1
l.append(count)
else:
l.append(int(0))
print(max(l))
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b, c;
cin >> a >> b;
c = 0;
while (b) {
c = c * 10 + (b % 10);
b /= 10;
}
cout << a + c << endl;
}
| 1,200 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long int pwr(long long int base, long long int p, long long int mod) {
long long int ans = 1;
while (p) {
if (p & 1) ans = (ans * base) % mod;
base = (base * base) % mod;
p /= 2;
}
return ans;
}
long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
struct node {
long long int l, h;
};
bool comp(node a, node b) { return a.h < b.h; }
int main() {
long long int n, m;
scanf("%lld", &n);
scanf("%lld", &m);
vector<node> v1;
vector<node> v2;
long long int first = 0, second = 0, c1 = 0, c2 = 0;
for (long long int i = 0; i < n; i++) {
long long int s, a, b;
scanf("%lld", &s);
scanf("%lld", &a);
scanf("%lld", &b);
if (a > b) {
c1 += s;
first += a * s;
v1.push_back({s, a - b});
} else {
c2 += s;
second += b * s;
v2.push_back({s, b - a});
}
}
if ((c1 % m) + (c2 % m) > m) {
printf("%lld\n", first + second);
return 0;
}
long long int ans = first + second;
sort(v1.begin(), v1.end(), comp);
sort(v2.begin(), v2.end(), comp);
long long int x = c1 % m;
long long int l = v1.size();
long long int ans1 = ans;
for (int i = 0; i < l; i++) {
long long int r = min(v1[i].l, x);
ans1 -= (r * v1[i].h);
x -= r;
if (x <= 0) break;
}
x = c2 % m;
l = v2.size();
long long int ans2 = ans;
for (int i = 0; i < l; i++) {
long long int r = min(v2[i].l, x);
ans2 -= (r * v2[i].h);
x -= r;
if (x <= 0) break;
}
printf("%lld\n", max(ans1, ans2));
return 0;
}
| 1,900 | CPP |
#include <bits/stdc++.h>
char ss[][4] = {"H", "He", "Li", "Be", "B", "C", "N", "O", "F", "Ne",
"Na", "Mg", "Al", "Si", "P", "S", "Cl", "Ar", "K", "Ca",
"Sc", "Ti", "V", "Cr", "Mn", "Fe", "Co", "Ni", "Cu", "Zn",
"Ga", "Ge", "As", "Se", "Br", "Kr", "Rb", "Sr", "Y", "Zr",
"Nb", "Mo", "Tc", "Ru", "Rh", "Pd", "Ag", "Cd", "In", "Sn",
"Sb", "Te", "I", "Xe", "Cs", "Ba", "La", "Ce", "Pr", "Nd",
"Pm", "Sm", "Eu", "Gd", "Tb", "Dy", "Ho", "Er", "Tm", "Yb",
"Lu", "Hf", "Ta", "W", "Re", "Os", "Ir", "Pt", "Au", "Hg",
"Tl", "Pb", "Bi", "Po", "At", "Rn", "Fr", "Ra", "Ac", "Th",
"Pa", "U", "Np", "Pu", "Am", "Cm", "Bk", "Cf", "Es", "Fm"};
int s2a(char *s) {
int i;
for (i = 0; i < 100; i++)
if (strcmp(ss[i], s) == 0) return i + 1;
return 0;
}
int main() {
static int aa[17], aa_[17], sa[1 << 17], pp[1 << 17], bb[1 << 17];
static char cc[128];
int n, k, i, j, b_, b, c, sum, sum_;
scanf("%d%d", &n, &k);
sum = 0;
for (i = 0; i < n; i++) {
static char s[4];
scanf("%s", s);
sum += aa[i] = s2a(s);
}
sum_ = 0;
for (j = 0; j < k; j++) {
static char s[4];
scanf("%s", s);
sum_ += aa_[j] = s2a(s);
}
if (sum != sum_) {
printf("NO\n");
return 0;
}
for (b = 1; b < 1 << n; b++)
for (i = 0; i < n; i++)
if (b & 1 << i) {
sa[b] = sa[b ^ 1 << i] + aa[i];
break;
}
memset(pp, -1, (1 << n) * sizeof *pp), pp[0] = 0;
for (b = 0; b < 1 << n; b++) {
int j = pp[b];
if (j == -1) continue;
c = (1 << n) - 1 ^ b;
for (b_ = 0; (b_ = b_ - c & c) != 0;)
if (sa[b_] == aa_[j]) {
pp[b | b_] = j + 1;
bb[b | b_] = b_;
}
}
b--;
if (pp[b] == -1) {
printf("NO\n");
return 0;
}
printf("YES\n");
for (j = k - 1; j >= 0; j--) {
char *s = cc;
b_ = bb[b];
for (i = 0; i < n; i++)
if ((b_ & 1 << i) != 0) s += sprintf(s, "%s+", ss[aa[i] - 1]);
s--;
s += sprintf(s, "->%s", ss[aa_[j] - 1]);
*s = 0;
printf("%s\n", cc);
b ^= b_;
}
return 0;
}
| 2,200 | CPP |
n, t = map(int, input().split())
queue = list(input())
j = 0
while j < t:
i = 0
while i < len(queue) - 1:
if queue[i:i + 2] == ['B', 'G']:
queue[i:i + 2] = ['G', 'B']
i += 2
else:
i += 1
j += 1
print(''.join(queue)) | 800 | PYTHON3 |
V = int(input())
f = list(map(int, input().split()))
exist = False
for node in range(1, V + 1):
if f[f[f[node - 1] - 1] - 1] == node:
exist = True
if exist:
print ("YES")
else:
print ("NO") | 800 | PYTHON3 |
'''
cars = 100
space_in_a_car = 4.0
drivers = 30
passengers = 90
cars_not_driven = cars - drivers
cars_driven = drivers
carpool_capacity = cars_driven * space_in_a_car
average_passengers_per_car = passengers / cars_driven
print("there are" + " " ,cars , "cars available")
print("there are only" + " " ,drivers, "drivers only")
print("there will be " + " ",cars_not_driven,"empty cars today")
print("We can transport",carpool_capacity,"people today")
print("We have" + " " ,passengers, "to carpool today")
print("We habe to put about",average_passengers_per_car, "in each other")
'''
s = input()
v = []
for i in s:
v.append(int(i))
n = len(v)
v.append(0)
v.append(0)
v.append(0)
ok = True
i = 0
while i < n:
if v[i] == 1 and v[i + 1] == 4 and v[i + 2] == 4:
i += 2
elif v[i] == 1 and v[i + 1] == 4:
i += 1
elif v[i] == 1:
i
else:
ok = False
i += 1
if ok:
print("YES")
else:
print("NO")
| 900 | PYTHON3 |
T = int(input())
for _ in range(T):
n = list(map(int, input().strip().split()))
a, b, c, r = min(n[0], n[1]), max(n[0], n[1]), n[2], n[3]
L = max(min(a, b), c - r)
R = min(max(a, b), c + r)
print(max(a, b) - min(a, b) - max(0, R - L))
# Editorial
'''
int L = max(min(a, b), c - r);
int R = min(max(a, b), c + r);
cout << max(a, b) - min(a, b) - max(0, R - L) << endl;
'''
| 900 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
ifstream fin("frac1.in");
ofstream fout("frac1.out");
class compare : public std::binary_function<double, double, bool> {
public:
compare(double arg = 1e-7) : e(arg) {}
bool operator()(const double &left, const double &right) const {
return (abs(left - right) > e) && (left < right);
}
double e;
};
inline long long myabs(long long a) { return (a < 0) ? -a : a; }
inline int d_compare(double x, double y) {
return (fabs(x - y) <= 1e-7) ? 0 : (x > y) ? 1 : -1;
}
inline int mod(long long x, int y) {
if (y == 0) return x;
if (x < 0) x = -x;
if (x >= y) x %= y;
return x;
}
inline int cmod(int x, int y) {
if (y == 0) return x;
if (x < 0) x += (abs(x) / y + 1) * y;
if (x >= y) x = x % y;
return x;
}
int Bcount(int mask) {
int n = 0;
while (mask) n += ((mask & -mask) != 0), mask &= ~(mask & -mask);
return n;
}
inline bool Bstate(int mask, int idx) { return (mask & (1 << idx)); }
inline int B1(int mask, int idx) { return mask | (1 << idx); }
inline int B0(int mask, int idx) { return mask & ~(1 << idx); }
inline int drift(int mask, int n) { return mask & ((1 << n) - 1); }
void debugmask(int mask, int n) {
for (int i = 0; i < n; i++) cout << Bstate(mask, i);
}
int dr[8] = {0, 0, -1, 1, -1, 1, -1, 1}, dc[8] = {-1, 1, 0, 0, 1, -1, -1, 1};
template <typename Ty>
void clear(Ty &q) {
Ty empty;
swap(q, empty);
}
bool check1(int n, int m, vector<vector<char> > &v, vector<vector<char> > &r,
vector<bool> &res) {
int i, j;
vector<bool> b(n, 1);
for (i = 0; i < n; ++i) {
for (j = 0; j < m; ++j) {
if (v[i][j] != '0') {
if (r[i % 2][(j % 2) ^ res[i]] != v[i][j] && b[i] &&
r[i % 2][1 - j % 2] == v[i][j]) {
res[i] = 1;
} else if (r[i % 2][(j % 2) ^ res[i]] != v[i][j]) {
return 0;
}
b[i] = 0;
}
}
}
return 1;
}
bool check2(int n, int m, vector<vector<char> > &v, vector<vector<char> > &r,
vector<bool> &res) {
int i, j;
vector<bool> b(m, 1);
for (i = 0; i < n; ++i) {
for (j = 0; j < m; ++j) {
if (v[i][j] != '0') {
if (r[j % 2][(i % 2) ^ res[j]] != v[i][j] && b[j] &&
r[j % 2][1 - i % 2] == v[i][j]) {
res[j] = 1;
} else if (r[j % 2][(i % 2) ^ res[j]] != v[i][j]) {
return 0;
}
b[j] = 0;
}
}
}
return 1;
}
void print1(int n, int m, vector<vector<char> > &r, vector<bool> &res) {
int i, j;
for (i = 0; i < n; ++i) {
for (j = 0; j < m; ++j) {
cout << r[i % 2][(j % 2) ^ res[i]];
}
cout << endl;
}
}
void print2(int n, int m, vector<vector<char> > &r, vector<bool> &res) {
int i, j;
for (i = 0; i < n; ++i) {
for (j = 0; j < m; ++j) {
cout << r[j % 2][(i % 2) ^ res[j]];
}
cout << endl;
}
}
bool solve(int first, int second, vector<vector<char> > &r, vector<bool> &b,
int n, int m, vector<vector<char> > &v) {
if (second == 2) {
if (first == 1) {
vector<bool> res(max(n, m));
if (check1(n, m, v, r, res)) {
print1(n, m, r, res);
return 1;
}
if (check2(n, m, v, r, res)) {
print2(n, m, r, res);
return 1;
}
} else {
if (solve(1, 0, r, b, n, m, v)) {
return 1;
}
}
} else {
for (int i = 1; i < 5; ++i) {
if (b[i]) {
b[i] = 0;
r[first][second] = '0' + i;
if (solve(first, second + 1, r, b, n, m, v)) {
return 1;
}
b[i] = 1;
}
}
}
return 0;
}
int main() {
cin.tie(NULL);
ios_base::sync_with_stdio(0);
int n, m, i, j;
cin >> n >> m;
vector<vector<char> > r(2, vector<char>(2)), v(n, vector<char>(m));
for (i = 0; i < n; ++i) {
for (j = 0; j < m; ++j) {
cin >> v[i][j];
}
}
vector<bool> b(5, 1);
if (!solve(0, 0, r, b, n, m, v)) {
cout << 0 << endl;
}
return 0;
}
| 2,500 | CPP |
#include <bits/stdc++.h>
using namespace std;
set<int> s;
int main() {
int n, i, maxk = 0;
cin >> n;
for (int i = 0; i < (n); i++) {
int g;
cin >> g;
while (s.count(g)) {
s.erase(g);
g++;
}
s.insert(g);
if (g > maxk) maxk = g;
}
cout << maxk + 1 - s.size() << endl;
return 0;
}
| 1,600 | CPP |
from sys import stdin, stdout
input = stdin.readline
# int main()
n = (int)(input())
l,lim=0,1;
for i in range(1,n+2):
for j in range(1,n-i+2):
print(end=" ")
for j in range(1,i+1):
if j==i: print(j-1,end="")
else: print(j-1,end=" ")
for j in range(i-2,-1,-1):
if j==i-2: print(' ',end="");
if j==0: print(j,end="")
else : print(j,end=" ")
print()
for i in range(n,0,-1):
for j in range(n-i+1,0,-1):
print(end=" ")
for j in range(0,i):
if j==i-1: print(j,end="")
else : print(j,end=" ")
for j in range(i-2,-1,-1):
if j==i-2: print(" ",end="")
if j==0: print(j,end="")
else : print(j,end=" ")
print() | 1,000 | PYTHON3 |
#!/usr/bin/python3
if __name__ == '__main__':
cad = input()
tmp = sorted(cad)
n = tmp.count('+')
for i in range(0, n):
tmp.remove('+')
print('+'.join(tmp)) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int t;
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> t;
for (int i = 0; i < t; i++) {
long double min1 = -1;
int n;
cin >> n;
vector<long long> v;
vector<pair<long long, long long> > v2;
int side1 = 0, side2 = 0;
for (int j = 0; j < n; j++) {
int a;
cin >> a;
v.push_back(a);
}
sort(v.begin(), v.end());
for (int j = 0; j < n; j++) {
int cnt = 1;
while (j < n - 1 && v[j] == v[j + 1]) {
j++;
cnt++;
}
v2.push_back(make_pair(v[j], cnt));
}
int b = -1;
for (int j = 0; j < v2.size(); j++) {
if (v2[j].second < 2) continue;
if (j != 0 && b != -1) {
if (min1 < 0 ||
(long double)((long double)2 * (v2[j].first + v2[b].first)) *
((long double)2 * (v2[j].first + v2[b].first)) /
((long double)v2[j].first * v2[b].first) <
min1) {
min1 = (long double)((long double)2 * (v2[j].first + v2[b].first)) *
((long double)2 * (v2[j].first + v2[b].first)) /
((long double)v2[j].first * v2[b].first);
side1 = v2[j].first;
side2 = v2[b].first;
}
}
b = j;
if (v2[j].second >= 4)
if (min1 < 0 || (long double)(2 * (v2[j].first + v2[j].first)) *
(2 * (v2[j].first + v2[j].first)) /
(v2[j].first * v2[j].first) <
min1) {
min1 = (long double)((long double)2 * (v2[j].first + v2[j].first)) *
((long double)2 * (v2[j].first + v2[j].first)) /
((long double)v2[j].first * v2[j].first);
side1 = v2[j].first;
side2 = v2[j].first;
}
}
if (side1 == 0) exit(-1);
cout << side1 << ' ' << side1 << ' ' << side2 << ' ' << side2 << endl;
}
}
| 1,600 | CPP |
import sys
def kth(n, k):
length_cycle = n - 1
number_cycles = k // length_cycle
remainder = k % length_cycle
correction_factor = remainder if remainder > 0 else -1
kth_elem = number_cycles * n + correction_factor
return kth_elem
number_loops = input()
for _ in range(int(number_loops)):
inputs = input().split()
print(kth(int(inputs[0]), int(inputs[1])))
| 1,200 | PYTHON3 |
def dfs(a, b, v, e):
if a == b:
return True
v[a] = True
for x in e[a]:
if not v[x] and dfs(x, b, v, e):
return True
return False
a, e = [], []
for i in range(int(input())):
t, x, y = map(int, input().split())
if t == 1:
a.append((x, y))
e.append([])
for i, ai in enumerate(a):
if x in range(ai[0] + 1, ai[1]) or y in range(ai[0] + 1, ai[1]):
e[-1].append(i)
if ai[0] in range(x + 1, y) or ai[1] in range(x + 1, y):
e[i].append(len(a) - 1)
else:
print('YES' if dfs(x - 1, y - 1, [False] * len(a), e) else 'NO')
| 1,500 | PYTHON3 |
for _ in range(int(input())):
n, x = map(int, input().split(' '))
a = [i for i in map(int, input().split(' '))]
cnt1 = 0
cnt2 = 0
for i in a:
if i % 2 == 0:
cnt1 += 1
else:
cnt2 += 1
if cnt2 > 0:
x -= 1
m = min((cnt2 - 1) // 2 * 2, x)
m -= m % 2
x -= m
x -= cnt1
if x <= 0:
print("Yes")
else:
print("No")
else:
print("No") | 1,200 | PYTHON3 |
n=int(input())
A=list(input())
a=A.count('1')
b=A.count('0')
print(abs(a-b))
| 900 | PYTHON3 |
year=int(input())
a=""
for i in range(year+1,9013):
i=list(str(i))
if (i[0] == i[1] or i[0]==i[2]or i[0] ==i[3] or i[1] ==i[2] or i[1] ==i[3] or i[2] == i[3] ):
continue
else:
for j in i:
a=a+j
print(a)
break
| 800 | PYTHON3 |
shate="I hate that "
slove="I love that "
shatelast="I hate it"
slovelast="I love it"
s=""
n=input()
n=int(n)
for i in range(1,n+1):
if(i==n and i%2!=0):
s+=shatelast
elif(i==n and i%2==0):
s+=slovelast
elif(i%2!=0):
s+=shate
else:
s+=slove
print(s)
| 800 | PYTHON3 |
# https://codeforces.com/problemset/problem/1345/A
tests = int(input())
while tests > 0:
n, m = [int(i) for i in input().split(" ")]
if n == 1 or m == 1 or (n == 2 and m == 2):
print("YES")
else:
print("NO")
tests = tests - 1
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<int> v(n);
for (int i = 0; i < n; i++) cin >> v[i];
sort(v.rbegin(), v.rend());
cout << v[k - 1] << endl;
return 0;
}
| 900 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n;
int d;
long long qp[2000000];
long long p, k;
int main() {
ios_base::sync_with_stdio(false);
cin >> p >> k;
if (p < k) {
cout << 1 << endl;
cout << p << endl;
return 0;
}
long long cr = p;
int i;
for (i = 0; i <= 1000000; i++) {
int popa = -(cr % k);
if (i % 2 == 1) {
if (cr % k == 0) {
popa = 0;
} else {
popa = k - cr % k;
}
}
long long topa = (cr + popa) / k;
if (i % 2 == 0) {
topa = -topa;
}
qp[i] = topa;
if (topa > 0 && topa < k) {
break;
} else {
cr = (cr + popa) / k;
}
}
if (i >= 1000000) {
cout << -1 << endl;
return 0;
}
cout << i + 2 << endl;
cout << k * qp[0] + p << " ";
for (int j = 1; j <= i; j++) {
cout << k * qp[j] + qp[j - 1] << " ";
}
cout << qp[i];
cout << endl;
return 0;
}
| 2,000 | CPP |
s = input().rstrip()
print(s + s[::-1]) | 1,000 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200020;
int n, now;
pair<string, int> s[MAXN];
int a[MAXN][2];
int b[MAXN];
bool Check() {
for (int i = 1; i <= n; ++i) {
int x;
scanf("%d", &x);
if (max(a[x][0], a[x][1]) < now) return false;
if (a[x][0] > a[x][1]) swap(a[x][0], a[x][1]);
if (a[x][0] > now)
now = a[x][0];
else
now = a[x][1];
}
return true;
}
int main() {
scanf("%d\n", &n);
for (int i = 1; i <= n; ++i) {
cin >> s[i + i - 1].first >> s[i + i].first;
s[i + i - 1].second = i;
s[i + i].second = n + i;
}
sort(s + 1, s + n + n + 1);
for (int i = 1; i <= n + n; ++i)
if (s[i].second > n)
a[s[i].second - n][1] = i;
else
a[s[i].second][0] = i;
puts(Check() ? "YES" : "NO");
return 0;
}
| 1,400 | CPP |
y = int(input()) + 1
while len(list(set(str(y)))) != len(str(y)) :
y += 1
print(y) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long dp[1 << 22];
long long a[22];
long long b[22][22];
long long bef[22];
int main() {
long long n, k, t;
string base;
cin >> n >> k >> t >> base;
for (long long i = 0; i < ((long long)k); i++) cin >> a[i];
for (long long i = 0; i < ((long long)k); i++)
for (long long j = 0; j < ((long long)k); j++) cin >> b[i][j];
for (long long i = 0; i < ((long long)22); i++) bef[i] = -1;
for (long long i = 0; i < ((long long)((long long)base.size())); i++) {
long long pos = base[i] - 'A', mask = 0;
vector<pair<long long, long long> > vec;
for (long long j = 0; j < ((long long)k); j++)
if (bef[j] != -1 && bef[pos] <= bef[j])
vec.push_back(make_pair(-bef[j], j));
sort(vec.begin(), vec.end());
bef[pos] = i;
for (long long j = 0; j < ((long long)((long long)vec.size())); j++) {
dp[mask] += b[vec[j].second][pos];
dp[mask | (1 << pos)] -= b[vec[j].second][pos];
dp[mask | (1 << vec[j].second)] -= b[vec[j].second][pos];
dp[mask | (1 << vec[j].second) | (1 << pos)] += b[vec[j].second][pos];
mask |= 1 << vec[j].second;
}
}
for (long long j = 0; j < ((long long)k); j++)
for (long long i = 0; i < ((long long)1 << k); i++)
if ((i >> j) & 1) dp[i] += dp[i ^ (1 << j)];
for (long long i = 0; i < ((long long)1 << k); i++)
for (long long j = 0; j < ((long long)k); j++)
if ((i >> j) & 1) dp[i] += a[j];
long long mask = 0;
for (long long i = 0; i < ((long long)((long long)base.size())); i++)
mask |= (1 << (base[i] - 'A'));
long long res = 0;
for (long long i = 0; i < ((long long)1 << k); i++)
if (mask == (mask | i) && mask != i && dp[i] <= t) res++;
cout << res << endl;
}
| 2,700 | CPP |
for t in range(int(input())):
s = input()
l = len(s)
res=s[0]
for i in range(1,l-1,2):
res+=s[i]
res+=s[-1]
print(res)
| 800 | PYTHON3 |
T = int(input())
def solve(n, x):
n -= 1
if n <= 1:
print(1)
else:
print(((n-2) // x) + 2)
for _ in range(T):
n, x = map(int, input().split())
solve(n, x)
| 800 | PYTHON3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.