solution
stringlengths 10
983k
| difficulty
int64 0
25
| language
stringclasses 2
values |
|---|---|---|
import sys
from collections import deque
n = int(sys.stdin.readline().strip())
s = list(map(int, sys.stdin.readline().strip().split(' ')))
c = list(map(int, sys.stdin.readline().strip().split(' ')))
lower = [float('inf') for i in range(n)]
upper = [float('inf') for i in range(n)]
for i in range(n):
for j in range(i):
if s[i] > s[j]:
lower[i] = min(lower[i], c[j])
for i in range(n-1,-1,-1):
for j in range(i+1,n):
if s[j] > s[i]:
upper[i] = min(upper[i], c[j])
ans = float('inf')
for i in range(n):
ans = min(ans, lower[i] + c[i] + upper[i])
print([-1,ans][ans!=float('inf')]) | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9;
long long MOD = 1e9 + 7;
int a[1111];
int main() {
int n;
cin >> n;
int l = -1;
int res = 0;
int t = 0;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) {
int x;
x = a[n - 1 - i];
if (l == -1) {
l = x;
continue;
}
if (l == x) {
cout << "Infinite";
return 0;
}
if (l == 1) {
if (x == 2) {
res += 3;
t = 0;
} else {
res -= t;
res += 4;
t = 0;
}
l = x;
continue;
}
if (l == 2) {
if (x == 3) {
cout << "Infinite";
return 0;
} else {
t = 1;
res += 3;
}
l = x;
}
if (l == 3) {
if (x == 1) {
t = 0;
res += 4;
} else {
cout << "Infinite";
return 0;
}
l = x;
}
}
cout << "Finite\n";
cout << res << endl;
}
| 7 | CPP |
for _ in range(int(input())):
#x,y,a,b=map(int,(input().split()))
#arr=[int(i) for i in input().split()]
a=input()
b=input()
c=input()
an='YES'
for i in range(len(a)):
if c[i]!=a[i] and c[i]!=b[i]:
an='NO'
print(an)
| 7 | PYTHON3 |
import sys
import os
import time
import collections
from collections import Counter, deque
import itertools
import math
import timeit
import random
#########################
# imgur.com/Pkt7iIf.png #
#########################
def sieve(n):
if n < 2: return list()
prime = [True for _ in range(n + 1)]
p = 3
while p * p <= n:
if prime[p]:
for i in range(p * 2, n + 1, p):
prime[i] = False
p += 2
r = [2]
for p in range(3, n + 1, 2):
if prime[p]:
r.append(p)
return r
def divs(n, start=1):
divisors = []
for i in range(start, int(math.sqrt(n) + 1)):
if n % i == 0:
if n / i == i:
divisors.append(i)
else:
divisors.extend([i, n // i])
return divisors
def divn(n, primes):
divs_number = 1
for i in primes:
if n == 1:
return divs_number
t = 1
while n % i == 0:
t += 1
n //= i
divs_number *= t
def flin(d, x, default=-1):
left = right = -1
for i in range(len(d)):
if d[i] == x:
if left == -1: left = i
right = i
if left == -1:
return (default, default)
else:
return (left, right)
def ceil(n, k): return n // k + (n % k != 0)
def ii(): return int(input())
def mi(): return map(int, input().split())
def li(): return list(map(int, input().split()))
def lcm(a, b): return abs(a * b) // math.gcd(a, b)
def prr(a, sep=' '): print(sep.join(map(str, a)))
def dd(): return collections.defaultdict(int)
def ddl(): return collections.defaultdict(list)
# input = sys.stdin.readline
for _ in range(ii()):
n = ii()
s = input()
r = 0
ans = -1
for i in range(n):
r += int(s[i])
if int(s[i]) % 2 and not r % 2:
ans = s[:i+1]
break
print(ans)
| 7 | PYTHON3 |
from sys import stdin, stdout
import math,sys
from itertools import permutations, combinations
from collections import defaultdict,deque,OrderedDict
from os import path
import bisect as bi
import heapq
def yes():print('YES')
def no():print('NO')
if (path.exists('input.txt')):
#------------------Sublime--------------------------------------#
sys.stdin=open('input.txt','r');sys.stdout=open('output.txt','w');
def I():return (int(input()))
def In():return(map(int,input().split()))
else:
#------------------PYPY FAst I/o--------------------------------#
def I():return (int(stdin.readline()))
def In():return(map(int,stdin.readline().split()))
def main():
try:
n=I()
a=list(In())
b=list(In())
d={}
ans=[]
d1={}
for x in range(n):
d[b[x]]=x
for x in range(n):
temp=d[a[x]]
if temp>x:
jump=n-(temp-x)
else:
jump=x-temp
if d1.get(jump,-1)!=-1:
d1[jump]+=1
else:
d1[jump]=1
t=max(d1.values())
print(t)
except:
pass
M = 998244353
P = 1000000007
if __name__ == '__main__':
#for _ in range(I()):main()
for _ in range(1):main() | 9 | PYTHON3 |
n, t = input().split()
if int(n) >= len(t):
o = 10 ** (int(n) - 1)
if int(t) <= o:
print((o - o % int(t))*2)
else:
print(t)
else:
print(-1)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5, C = 1e6 + 5;
int n;
long long mod[2], P[2], p[2][C], rev_P[2];
vector<long long> h[2][N];
vector<int> sorted[N];
string s[N];
int nxt[C];
int a[C], dp[2][C];
const int MOD = (int)1e9 + 7;
inline void inc(int &x, int y) { x = x + y < MOD ? x + y : x + y - MOD; }
inline long long quickpow(long long a, int n, int hm) {
long long res = 1;
for (; n; n >>= 1, a = (long long)(a * a) % mod[hm])
if (n & 1) res = (long long)(res * a) % mod[hm];
return res;
}
inline char get_c(int i, int x, int numb) {
if (numb < x) return s[i][numb];
if (numb + 1 < (int)s[i].size()) return s[i][numb + 1];
return ' ';
}
inline long long gethash(int t, int i, int x, int len) {
if (len < x) return h[t][i][len];
return (h[t][i][x] +
(h[t][i][len + 1] - h[t][i][x + 1] + mod[t]) * rev_P[t]) %
mod[t];
}
inline pair<long long, long long> get(int i, int x, int len) {
return {gethash(0, i, x, len), gethash(1, i, x, len)};
}
inline bool check(int i, int x, int j, int y) {
int len1 = (int)s[i].size(), len2 = (int)s[j].size();
if (x != len1) --len1;
if (y != len2) --len2;
int lef = 0, rht = min(len1, len2) + 1;
while (rht - lef > 1) {
int mid = (lef + rht) >> 1;
if (get(i, x, mid) == get(j, y, mid))
lef = mid;
else
rht = mid;
}
return get_c(i, x, lef) >= get_c(j, y, lef);
}
int main() {
mod[0] = (int)1e9 + 7;
mod[1] = (int)1e9 + 9;
P[0] = 31;
P[1] = 33;
rev_P[0] = quickpow(P[0], mod[0] - 2, 0),
rev_P[1] = quickpow(P[1], mod[1] - 2, 1);
p[0][0] = 1;
p[1][0] = 1;
for (int i = 1; i < C; ++i)
for (int j = 0; j <= 1; ++j)
p[j][i] = (long long)p[j][i - 1] * P[j] % mod[j];
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> s[i];
for (int j = 0; j <= 1; ++j) {
h[j][i].emplace_back(0);
for (unsigned pos = 0; pos < s[i].size(); ++pos)
h[j][i].emplace_back(
(h[j][i][pos] + p[j][pos] * (s[i][pos] - 'a' + 1)) % mod[j]);
}
nxt[(int)s[i].size() - 1] = (int)s[i].size() - 1;
for (int pos = (int)s[i].size() - 2; pos >= 0; --pos) {
if (s[i][pos] != s[i][pos + 1])
nxt[pos] = pos + 1;
else
nxt[pos] = nxt[pos + 1];
}
int l = 0, r = (int)s[i].size() - 1;
for (int j = 0; j < (int)s[i].size(); ++j) {
if (s[i][nxt[j]] <= s[i][j])
a[l++] = j;
else
a[r--] = j;
}
for (int j = 0; j < (int)s[i].size(); ++j) {
sorted[i].emplace_back(a[j]);
if (a[j] == (int)s[i].size() - 1)
sorted[i].emplace_back((int)s[i].size());
}
}
for (int i = 0; i <= (int)s[1].size(); ++i) dp[0][i] = 1;
for (int i = 2; i <= n; ++i) {
int ptr = 0, sum = 0, cur = -1, now = (i - 1) & 1;
for (auto key : sorted[i]) {
++cur;
while (ptr < (int)sorted[i - 1].size() &&
check(i, key, i - 1, sorted[i - 1][ptr])) {
inc(sum, dp[now ^ 1][ptr]);
++ptr;
}
dp[now][cur] = sum;
}
}
int ans = 0;
for (int i = 0; i <= (int)s[n].size(); ++i) inc(ans, dp[(n - 1) & 1][i]);
printf("%d\n", ans);
return 0;
}
| 11 | CPP |
import math
t=int(input())
for i in range(t):
n=int(input())
if n<=6+10+14:
print("NO")
else:
print("YES")
if n-6-14-10==6:
print(6,15,10,5)
elif n-6-14-10==10:
print(6,15,10,9)
elif n-6-14-10==14:
print(6,15,10,13)
else:
print(6,10,14,n-6-14-10)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T &x) {
x = 0;
int fu = 1;
char c = getchar();
while (c > 57 || c < 48) {
if (c == 45) fu = -1;
c = getchar();
}
while (c <= 57 && c >= 48) {
x = (x << 3) + (x << 1) + c - 48;
c = getchar();
}
x *= fu;
}
template <typename T>
inline void fprint(T x) {
if (x < 0) putchar(45), x = -x;
if (x > 9) fprint(x / 10);
putchar(x % 10 + 48);
}
template <typename T>
inline void fprint(T x, char ch) {
fprint(x);
putchar(ch);
}
int n, m;
int head[3005], nxt[5005], e[5005], cnt;
inline void add(int u, int v) {
nxt[++cnt] = head[u];
head[u] = cnt;
e[cnt] = v;
}
int dis[3005][3005];
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
q;
bitset<3005> vis;
inline void Dijkstra(int s) {
vis &= 0;
dis[s][s] = 0;
q.push(make_pair(0, s));
while (!q.empty()) {
pair<int, int> tp = q.top();
q.pop();
int x = tp.second;
if (vis[x]) continue;
vis[x] = 1;
for (register int i = head[x]; i; i = nxt[i]) {
if (dis[s][e[i]] > dis[s][x] + 1) {
dis[s][e[i]] = dis[s][x] + 1;
q.push(make_pair(dis[s][e[i]], e[i]));
}
}
}
}
int pre[5][3005], succ[5][3005];
int main() {
read(n);
read(m);
for (register int i = 1; i <= n; i++) {
for (register int j = 1; j <= n; j++) {
dis[i][j] = 0x3f3f3f3f;
}
}
while (m--) {
int u, v;
read(u);
read(v);
add(u, v);
}
for (register int i = 1; i <= n; i++) Dijkstra(i);
int a = 0, b = 0, c = 0, d = 0;
for (register int i = 1; i <= n; i++) {
for (register int j = 1; j <= n; j++) {
if (dis[i][j] == 0x3f3f3f3f) dis[i][j] = -0x3f3f3f3f;
if (dis[j][i] == 0x3f3f3f3f) dis[j][i] = -0x3f3f3f3f;
if (dis[i][j] > dis[i][succ[1][i]]) {
succ[3][i] = succ[2][i];
succ[2][i] = succ[1][i];
succ[1][i] = j;
} else {
if (dis[i][j] > dis[i][succ[2][i]]) {
succ[3][i] = succ[2][i];
succ[2][i] = j;
} else {
if (dis[i][j] > dis[i][succ[3][i]]) {
succ[3][i] = j;
}
}
}
if (dis[j][i] > dis[pre[1][i]][i]) {
pre[3][i] = pre[2][i];
pre[2][i] = pre[1][i];
pre[1][i] = j;
} else {
if (dis[j][i] > dis[pre[2][i]][i]) {
pre[3][i] = pre[2][i];
pre[2][i] = j;
} else {
if (dis[j][i] > dis[pre[3][i]][i]) {
pre[3][i] = j;
}
}
}
}
}
for (register int i = 1; i <= n; i++) {
for (register int j = 1; j <= n; j++) {
if (dis[i][j] < 0) continue;
for (register int k1 = 1; k1 <= 3; k1++) {
for (register int k2 = 1; k2 <= 3; k2++) {
if (!pre[k1][i] || !succ[k2][j]) continue;
if ((i ^ j) && (i ^ pre[k1][i]) && (i ^ succ[k2][j]) &&
(j ^ pre[k1][i]) && (j ^ succ[k2][j]) &&
(pre[k1][i] ^ succ[k2][j])) {
if (dis[i][j] + dis[pre[k1][i]][i] + dis[j][succ[k2][j]] >
dis[a][b] + dis[b][c] + dis[c][d]) {
a = pre[k1][i];
b = i;
c = j;
d = succ[k2][j];
}
}
}
}
}
}
printf("%d %d %d %d\n", a, b, c, d);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
typedef long long ll;
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int x[m], xd[m-1];
rep(i, m) cin >> x[i];
sort(x, x+m);
rep(i, m-1) xd[i] = x[i+1] - x[i];
sort(xd, xd+m-1);
int ans = 0;
rep(i, m-n) ans += xd[i];
cout << ans << endl;
return 0;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
void pikachu() {}
short t, n;
char a[111];
int main() {
pikachu();
scanf("%hd", &t);
short u, v;
while (t--) {
scanf("%hd", &n);
scanf("%s", a + 1);
u = 0;
v = n + 1;
for (short i = 1; i <= n; ++i) {
if (a[i] == '<')
u = i;
else
v = min(v, i);
}
printf("%hd\n", min(v - 1, n - u));
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int n;
vector<pair<int, int> > g[N];
bool dead[N];
int sz[N];
int root[N];
long long dp_down[N];
long long dp_up[N];
long long dis[N];
long long ans[N];
queue<int> q;
vector<int> cycle;
vector<int> weight;
long long sumw, sumd, suml, L, sumr, R;
void find_cycle() {
int cnt = 0;
for (int i = 0; i < n; ++i) {
sz[i] = ((int)g[i].size());
if (sz[i] == 1) q.push(i);
}
while (((int)q.size()) && sz[q.front()] == 1) {
int v = q.front();
q.pop();
dead[v] = true;
cnt++;
for (auto nei : g[v]) {
int u = nei.first;
if (!dead[u]) {
sz[v]--;
sz[u]--;
if (sz[u] == 1) q.push(u);
break;
}
}
}
int v = 0;
for (int i = 0; i < n; ++i) {
if (!dead[i]) {
v = i;
break;
}
}
while (sz[v]) {
for (auto nei : g[v]) {
int u = nei.first;
int w = nei.second;
if ((cnt < n - 1 && !dead[u]) || (cnt == n - 1 && sz[u] == sz[v])) {
cycle.push_back(u);
weight.push_back(w);
sumw += w;
sz[v]--, sz[u]--;
dead[v] = true;
cnt++;
v = u;
break;
}
}
}
for (int v : cycle) dead[v] = false;
}
void dfs_down(int v, int p) {
root[v] = root[p];
sz[v] = 1;
for (pair<int, int> nei : g[v]) {
int u = nei.first;
int w = nei.second;
if (u == p || !dead[u]) continue;
dis[u] = dis[v] + w;
dfs_down(u, v);
dp_down[v] += dp_down[u] + 1LL * sz[u] * w;
sz[v] += sz[u];
}
}
void dfs_up(int v, int p) {
long long sum = 0;
for (pair<int, int> nei : g[v]) {
int u = nei.first;
int w = nei.second;
if (u == p || !dead[u]) continue;
sum += dp_down[u] + 1LL * sz[u] * w;
}
for (pair<int, int> nei : g[v]) {
int u = nei.first;
int w = nei.second;
if (u == p || !dead[u]) continue;
dp_up[u] = dp_up[v] + (sum - (dp_down[u] + 1LL * sz[u] * w)) +
1LL * (sz[root[u]] - sz[u]) * w;
dfs_up(u, v);
}
}
inline int st(int x) {
x %= ((int)cycle.size());
x += ((int)cycle.size());
x %= ((int)cycle.size());
return x;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; ++i) {
int u, v, w;
cin >> u >> v >> w;
u--, v--;
g[u].push_back({v, w});
g[v].push_back({u, w});
}
find_cycle();
for (int v : cycle) root[v] = v, dfs_down(v, v), sumd += dp_down[v];
for (int v : cycle) dfs_up(v, v);
int kl = 0, kr = 1;
int szl = sz[cycle[0]], szr = 0;
while (R + weight[kr] <= sumw - R - weight[kr]) {
R += weight[kr];
szr += sz[cycle[kr]];
sumr += R * sz[cycle[kr]];
kr = st(kr + 1);
}
while (L + weight[kl] < sumw - L - weight[kl]) {
L += weight[kl];
kl = st(kl - 1);
szl += sz[cycle[kl]];
suml += L * sz[cycle[kl]];
}
ans[cycle[0]] = suml + sumr + sumd;
for (int i = 1; i < ((int)cycle.size()); ++i) {
if (szr != 0) {
sumr -= szr * weight[i];
R -= weight[i];
szr -= sz[cycle[i]];
suml += szl * weight[i];
L += weight[i];
szl += sz[cycle[i]];
} else {
suml -= L * sz[cycle[i]];
suml += (szl - sz[cycle[i]]) * weight[i];
L += weight[i];
L -= weight[st(i + 1)];
kr = st(kr + 1);
kl = st(kl + 1);
}
while (R + weight[kr] <= sumw - R - weight[kr]) {
R += weight[kr];
szr += sz[cycle[kr]];
sumr += R * sz[cycle[kr]];
kr = st(kr + 1);
suml -= L * sz[cycle[kl]];
szl -= sz[cycle[kl]];
kl = st(kl + 1);
L -= weight[kl];
}
ans[cycle[i]] = suml + sumr + sumd;
}
for (int i = 0; i < n; ++i) {
if (dead[i])
ans[i] = ans[root[i]] - dp_down[root[i]] + dp_down[i] + dp_up[i] +
dis[i] * (n - sz[root[i]]);
cout << ans[i] << " ";
}
cout << "\n";
return 0;
}
| 13 | CPP |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vl = vector<long long>;
using pii = pair<int, int>;
using vpii = vector<pair<int, int>>;
template <class T>
inline bool ckmin(T& a, T b) {
return b < a ? a = b, 1 : 0;
}
template <class T>
inline bool ckmax(T& a, T b) {
return b > a ? a = b, 1 : 0;
}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const char nl = '\n';
const int mxN = 2e5 + 10;
const int MOD = 1e9 + 7;
const long long infLL = 1e18;
struct segtree {
int size;
vector<array<ll, 4>> vals;
array<ll, 4> ne = {0, 0, 0, 0};
array<ll, 4> comb(array<ll, 4> a, array<ll, 4> b) {
array<ll, 4> res;
res = a;
ckmax(res[0], a[0] + b[0]);
ckmax(res[0], a[2] - b[3]);
ckmin(res[1], a[1] + b[1]);
ckmin(res[1], a[3] - b[2]);
ckmax(res[2], a[0] + b[2]);
ckmax(res[2], a[2] - b[1]);
ckmin(res[3], a[1] + b[3]);
ckmin(res[3], a[3] - b[0]);
ckmax(res[0], b[0]);
ckmin(res[1], b[1]);
ckmax(res[2], b[2]);
ckmin(res[3], b[3]);
return res;
}
void init(int n) {
size = 1;
while (size < n) {
size *= 2;
}
vals.assign(2 * size, ne);
}
void build(vector<array<ll, 4>>& a, int x, int lx, int rx) {
if (rx - lx == 1) {
if (lx < (int)a.size()) {
vals[x] = a[lx];
}
return;
}
int m = (lx + rx) / 2;
build(a, 2 * x + 1, lx, m);
build(a, 2 * x + 2, m, rx);
vals[x] = comb(vals[2 * x + 1], vals[2 * x + 2]);
}
void build(vector<array<ll, 4>>& a) { build(a, 0, 0, size); }
void update(int i, array<ll, 4> v, int x, int lx, int rx) {
if (rx - lx == 1) {
vals[x] = v;
return;
}
int m = (lx + rx) / 2;
if (i < m)
update(i, v, 2 * x + 1, lx, m);
else
update(i, v, 2 * x + 2, m, rx);
vals[x] = comb(vals[2 * x + 1], vals[2 * x + 2]);
}
void update(int i, array<ll, 4> v) { update(i, v, 0, 0, size); }
array<ll, 4> query(int l, int r, int x, int lx, int rx) {
if (lx >= r || l >= rx) return ne;
if (lx >= l && rx <= r) {
return vals[x];
}
int m = (lx + rx) / 2;
array<ll, 4> s1 = query(l, r, 2 * x + 1, lx, m);
array<ll, 4> s2 = query(l, r, 2 * x + 2, m, rx);
return comb(s1, s2);
}
array<ll, 4> query(int l, int r) { return query(l, r, 0, 0, size); }
} st;
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
int n, q;
cin >> n >> q;
vl a(n);
st.init(n);
for (int i = (0); i < (n); i++) {
cin >> a[i];
st.update(i, (array<ll, 4>){-1 << 30, 1 << 30, a[i], a[i]});
}
cout << st.query(0, n)[2] << nl;
while (q--) {
int l, r;
cin >> l >> r;
l--;
r--;
if (l != r) {
swap(a[l], a[r]);
st.update(l, {-1 << 30, 1 << 30, a[l], a[l]});
st.update(r, {-1 << 30, 1 << 30, a[r], a[r]});
}
cout << max(st.query(0, n)[2], st.query(0, n)[0]) << nl;
}
}
return 0;
}
| 9 | CPP |
t=int(input())
def cry(elem):
y=0
for i in elem:
y^=i
return y
def roar(stuff,indx):
s[indx]+=1
for i in range(t):
p=1
c=0
n=int(input())
a=list(map(int,input().split()))
s,x=[0,0,0]+list(map(int,bin(sum(a))[2:])),list(map(int,bin(cry(a))[2:]))
x=[0 for i in range(len(s)-len(x)-1)]+x
nextsum,nextxor=False,False
ans=0
if s[-1]==1:
ans+=1
nextsum,nextxor=True,True
# print(s,x)
for i in range(-1,-len(x),-1):
p*=2
se,xe=s[i-1],x[i]
# print(se,xe)
if nextsum:
if se==0:
se=1
nextsum=False
else:
se=0
nextsum=True
if nextxor:
xe=1-xe
nextxor=False
# print(se,xe)
if se!=xe:
ans+=p
c+=1
if se==0:
se=1
else:
se=0
nextsum=True
nextxor=True
print(1,ans,sep='\n')
| 9 | PYTHON3 |
t=int(input())
for _ in range(0,t):
a,b,c,d=[int(z) for z in input().split()]
x,y,z=b,c,c
print(x,y,z) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
char i = getchar();
long long f = 1, res = 0;
while (i < '0' || i > '9') {
if (i == '-') f = -1;
i = getchar();
}
while (i >= '0' && i <= '9') {
res = res * 10 + i - '0';
i = getchar();
}
return f * res;
}
inline bool pd(int x) {
if (x == 2) return 1;
int sz = sqrt(x);
for (register int i = 2; i <= sz; ++i) {
if (x % i == 0) return 0;
}
return 1;
}
inline long long findl(long long x) {
while (!pd(x)) --x;
return x;
}
inline long long findr(long long x) {
while (!pd(x)) ++x;
return x;
}
inline long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
int T = read();
while (T--) {
long long n = read();
long long l = findl(n);
long long r = findr(n + 1);
long long x = (l - 2) * r + 2 * (n - l + 1);
long long y = l * r * 2;
long long g = gcd(x, y);
x /= g;
y /= g;
printf("%lld/%lld\n", x, y);
}
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
int used[405][405];
int main() {
int H, W;
cin >> H >> W;
vector<string> S(H);
for (int i = 0; i < H; i++) cin >> S[i];
long ans = 0;
for (int h = 0; h < H; h++) {
for (int w = 0; w < W; w++) {
if (used[h][w]) continue;
used[h][w] = 1;
long nb = 0, nw = 0;
queue<pair<int, int>> Q;
Q.push(make_pair(h, w));
while (Q.size()) {
auto p = Q.front(); Q.pop();
int h1 = p.first, w1 = p.second;
if (S[h1][w1] == '.') nw++;
else nb++;
for (int i = 0; i < 4; i++) {
int h2 = h1 + dy[i], w2 = w1 + dx[i];
if (h2 < 0 || h2 == H || w2 < 0 || w2 == W || S[h2][w2] == S[h1][w1] || used[h2][w2]) continue;
Q.push(make_pair(h2, w2));
used[h2][w2] = 1;
}
}
ans += nb * nw;
}
}
cout << ans << endl;
} | 0 | CPP |
//#include<bits/stdc++.h>
#include <iostream>
#include<vector>
#include<map>
#include<algorithm>
#include<set>
#include<cstring>
#include<cmath>
#include<climits>
#include<cassert>
#include<numeric>
#include<iomanip> //for memset
#include<queue>
#include<stack>
using namespace std;
#define int long long
#define double long double
#define SHATABDI ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
const int N=4e3+3;
const int mod=1e9+7;
const int inf=1e18 +3;
void testcase(){
int n;
cin>>n;
vector<pair<int,int>>one,two;
for(int i=1;i<=n;i++){
for(int j=1;j<=n;j++){
if((i+j)%2)
one.push_back({i,j});
else
two.push_back({i,j});
}
}
while(one.size()&&two.size()){
int q;
cin>>q;
cout<<endl;
if(q==1){
cout<<2<<" "<<two.back().first<<" "<<two.back().second<<endl;
two.pop_back();
}
else{
cout<<1<<" "<<one.back().first<<" "<<one.back().second<<endl;
one.pop_back();
}
cout<<endl;
}
while(one.size()){
int q;
cin>>q;
cout<<endl;
if(q==1){
cout<<3<<" "<<one.back().first<<" "<<one.back().second<<endl;
}
else{
cout<<1<<" "<<one.back().first<<" "<<one.back().second<<endl;
}
one.pop_back();
cout<<endl;
}
while(two.size()){
int q;
cin>>q;
cout<<endl;
if(q==2){
cout<<3<<" "<<two.back().first<<" "<<two.back().second<<endl;
}
else{
cout<<2<<" "<<two.back().first<<" "<<two.back().second<<endl;
}
two.pop_back();
cout<<endl;
}
return;
}
signed main(){
SHATABDI
int t=1;
//init();
// cin>>t;
while(t--){
testcase();
}
return 0;
}
| 8 | CPP |
n,h=input().split()
p=0
n=int(n)
h=int(h)
s=input().split()
a=list(map(int,s))
for i in range(n):
if a[i]>h:
p=p+2
else:
p=p+1
print(p)
| 7 | PYTHON3 |
import math
s = input()
minpos = len(s)
for i in range(1,len(s)):
if s[i] != s[i-1]:
pos = max(i,len(s)-i)
if pos < minpos:
minpos = pos
print(minpos)
| 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, pair<int, int> > > v;
int main() {
ios_base::sync_with_stdio(false);
;
int n;
cin >> n;
cout << (long long)(n - 2) * (n - 2);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long n, K;
string s, t;
long long a[500005];
long long b[500005];
long long dp[500005][2][2];
void geddit(long long i, long long j, long long k) {
if (j == 0 && k == 0) {
if (a[i] == 0 && b[i] == 0) {
dp[i][j][k] = dp[i - 1][j][k];
} else if (a[i] == 0 && b[i] == 1) {
dp[i][j][k] = 0;
} else if (a[i] == 1 && b[i] == 0) {
dp[i][j][k] = 0;
} else if (a[i] == 1 && b[i] == 1) {
dp[i][j][k] = dp[i - 1][j][k];
}
}
if (j == 0 && k == 1) {
if (a[i] == 0 && b[i] == 0) {
dp[i][j][k] = dp[i - 1][j][k];
} else if (a[i] == 0 && b[i] == 1) {
dp[i][j][k] = dp[i - 1][0][0] + dp[i - 1][0][1];
} else if (a[i] == 1 && b[i] == 0) {
dp[i][j][k] = dp[i - 1][0][1];
} else if (a[i] == 1 && b[i] == 1) {
dp[i][j][k] = dp[i - 1][0][1];
}
}
if (j == 1 && k == 0) {
if (a[i] == 0 && b[i] == 0) {
dp[i][j][k] = dp[i - 1][1][0];
} else if (a[i] == 0 && b[i] == 1) {
dp[i][j][k] = dp[i - 1][0][0] + dp[i - 1][1][0];
} else if (a[i] == 1 && b[i] == 0) {
dp[i][j][k] = dp[i - 1][1][0];
} else if (a[i] == 1 && b[i] == 1) {
dp[i][j][k] = dp[i - 1][1][0];
}
}
if (j == 1 && k == 1) {
if (a[i] == 0 && b[i] == 0) {
dp[i][j][k] = 2 * dp[i - 1][1][1] + dp[i - 1][0][1];
} else if (a[i] == 0 && b[i] == 1) {
dp[i][j][k] = 2 * dp[i - 1][1][1] + dp[i - 1][0][1] + dp[i - 1][1][0];
} else if (a[i] == 1 && b[i] == 0) {
dp[i][j][k] = 2 * dp[i - 1][1][1];
} else if (a[i] == 1 && b[i] == 1) {
dp[i][j][k] = dp[i - 1][1][0] + dp[i - 1][1][1] + dp[i - 1][1][1];
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> K;
cin >> s >> t;
for (long long i = 1; i <= n; i++) {
a[i] = (s[i - 1] == 'b');
b[i] = (t[i - 1] == 'b');
}
dp[0][0][0] = 1;
long long ans = 0;
for (long long i = 1; i <= n; i++) {
long long tmp = 0;
for (long long j = 0; j < 2; j++) {
for (long long k = 0; k < 2; k++) {
geddit(i, j, k);
dp[i][j][k] = min(dp[i][j][k], K);
tmp += dp[i][j][k];
}
}
tmp = min(tmp, K);
ans += tmp;
}
cout << ans << endl;
return 0;
}
| 11 | CPP |
n = int(input())
str = input()
if n%2==1:
print(-1)
else:
arr = [-1 if i == ")" else 1 for i in str]
# print(arr)
if sum(arr) != 0:
print(-1)
else:
c = 0
i = -1
tc = 0
for j,a in enumerate(arr):
c += a
if c == 0:
if a > 0:
tc += j - i
i = j
# print(a,c,tc,i)
print(tc) | 7 | PYTHON3 |
s=str(input())
prv,res='a',0
for i in range(len(s)):
diff=abs(ord(s[i])-ord(prv))
res+=min(diff,26-diff)
prv=s[i]
print(res) | 7 | PYTHON3 |
l=int(input(''))
print((l/3)**3) | 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int mn = 6005;
string s[mn];
vector<string> str;
int main() {
int k, n;
cin >> k >> n;
for (int i = 0; i < k; i++) {
cin >> s[i];
}
bool f = 0;
for (int i = 1; i < k; i++) {
if (s[i] != s[i - 1]) {
f = 1;
}
}
if (f == 0) {
if (n == 2) {
cout << s[0][1] << s[0][0];
} else {
cout << s[0][1] << s[0][0] << s[0].substr(2, n - 2);
}
return 0;
}
string a = "", b = "";
for (int i = 1; i < k; i++) {
if (s[i] != s[0]) {
b = s[i];
}
}
a = s[0];
int rem = 0;
for (int i = 0; i < n; i++) {
if (a[i] != b[i]) {
rem = i;
break;
}
}
for (int i = 0; i < n; i++) {
if (i == rem) continue;
swap(a[i], a[rem]);
str.push_back(a);
swap(a[i], a[rem]);
swap(b[i], b[rem]);
str.push_back(b);
swap(b[i], b[rem]);
}
int raz[2];
unordered_map<char, int> mp;
for (int i = 0; i < str.size(); i++) {
string t = str[i];
bool can = 0;
for (int j = 0; j < min(27, (int)t.size()); j++) {
mp[t[j]]++;
if (mp[t[j]] >= 2) {
can = 1;
}
}
for (int j = 0; j < 26; j++) {
mp[char(j + 'a')] = 0;
}
int cnt = 0;
bool f2 = 0;
for (int j = 0; j < k; j++) {
cnt = 0;
for (int l = 0; l < n; l++) {
if (t[l] != s[j][l]) {
cnt++;
raz[cnt % 2] = l;
}
if (l != 0) {
}
}
if (cnt == 0 || cnt == 2) {
if ((cnt == 2)) {
if ((s[j][raz[1]] == t[raz[0]]) && (t[raz[1]] == s[j][raz[0]])) {
} else {
f2 = 1;
break;
}
}
if (cnt == 0) {
if (!can) {
f2 = 1;
break;
}
}
} else {
f2 = 1;
break;
}
}
if (f2 == 0) {
cout << t;
return 0;
}
}
cout << -1;
return 0;
}
| 11 | CPP |
a=input()
b=input()
z=int(a[:2])
z2=int(b[:2])
z=z-z2
if z<0:
z=24+z
else:
z=str(z)
if len(z)==1:
z='0'+z
hs=z
z=int(a[3:])
z2=int(b[3:])
z=z-z2
if z>=0:
z=str(z)
if len(z)==1:
z='0'+z
else:
z=60+z
hs=int(hs)
i=hs-1
if i<0:
i=24+i
else:
i=str(i)
if len(i)==1:
i='0'+i
hs=i
hs=str(hs)
z=str(z)
if len(z)==1:
z='0'+z
print(hs+':'+z)
| 7 | PYTHON3 |
for i in range(int(input())):
n = int(input())
a = [int(elem) for elem in input().split()]
counter1, counter2 = 0, 0
for i in range(n):
if a[i] % 2 == 1 and i % 2 == 0:
counter1+=1
if a[i] % 2 == 0 and i % 2 == 1:
counter2+=1
if counter1 != counter2:
print(-1)
else:
print(counter1)
| 8 | PYTHON3 |
for _ in range(int(input())):
n, k = map(int, input().split())
st = input()
s = [st[i] for i in range(n)]
res = '()' * (k - 1) + '(' * ((n - 2 * (k - 1)) // 2) + ')' * ((n - 2 * (k - 1)) // 2)
ans = []
for i in range(n):
if s[i] != res[i]:
for j in range(i + 1, n):
if res[i] == s[j]:
ans.append([i + 1, j + 1])
sub = s[i:j + 1]
sub = sub[::-1]
#print(sub)
for k in range(len(sub)):
s[i + k] = sub[k]
break
#print(res, s)
print(len(ans))
for i in range(len(ans)):
print(ans[i][0], ans[i][1]) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> m1;
void remove(int ele) {
m1[ele]--;
if (m1[ele] == 0) {
m1.erase(ele);
}
return;
}
int main() {
int i, j, t1, t2, t3, t4, n, mini = 2e9, maxi = 0;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &t1);
m1[t1]++;
mini = min(mini, t1);
maxi = max(maxi, t1);
}
for (i = mini; i <= maxi; i++) {
if (m1[i] == 0) {
printf("NO\n");
return 0;
}
remove(i);
}
for (i = maxi - 1; i >= mini + 1; i--) {
if (m1[i] == 0) {
printf("NO\n");
return 0;
}
remove(i);
}
while (!m1.empty()) {
auto it = m1.begin();
t1 = it->first;
t2 = t1 + 1;
if (m1[t1] == 0 || m1[t2] == 0) {
printf("NO\n");
return 0;
}
remove(t1);
remove(t2);
}
printf("YES\n");
return 0;
}
| 10 | CPP |
#include <stdio.h>
#pragma warning(disable : 4996)
int N, A, B, C, X, Y[100], P;
int main() {
while (true) {
scanf("%d%d%d%d%d", &N, &A, &B, &C, &X);
if (N == 0 && A == 0 && B == 0 && C == 0 && X == 0) break;
for (int i = 0; i < N; i++) scanf("%d", &Y[i]); P = 0;
bool flag = false;
for (int i = 0; i <= 10000; i++) {
if (X == Y[P]) P++;
if (N == P) {
printf("%d\n", i); flag = true; break;
}
X = (A * X + B) % C;
}
if (!flag) {
printf("-1\n");
}
}
return 0;
} | 0 | CPP |
import sys
inf = 1<<60
def solve():
t = int(sys.stdin.readline())
for i in range(t):
x, y, p, q = map(int, sys.stdin.readline().split())
if p == 0:
if x == 0:
print(0)
else:
print(-1)
continue
if p == q:
if x == y:
print(0)
else:
print(-1)
continue
if x*q > y*p:
z0 = (q*x + p - 1) // p
ans = ((z0 + q - 1) // q) * q - y
elif x*q == y*p:
ans = 0
else:
z0 = (q*(y - x) + q - p - 1) // (q - p)
ans = ((z0 + q - 1) // q) * q - y
print(ans)
if __name__ == '__main__':
solve() | 7 | PYTHON3 |
n=int(input())
l=['a','a','b','b']
s=''
#print(l[6%6])
for i in range(n):
s=s+l[(i%4)]
print(s)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
int const N = 1e5 + 5;
int main() {
int n, l, r;
int a[N];
int b[N];
int c[N];
scanf("%d %d %d", &n, &l, &r);
for (int i = 1; i <= n; i++) c[i] = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (i >= l && i <= r) c[a[i]]++;
}
for (int i = 1; i <= n; i++) {
scanf("%d", &b[i]);
if (i >= l && i <= r) {
c[b[i]]--;
}
}
for (int i = 1; i <= n; i++) {
if (i < l || i > r) {
if (a[i] != b[i]) {
printf("LIE");
return 0;
}
}
}
for (int i = 1; i <= n; i++) {
if (c[i] != 0) {
printf("LIE");
return 0;
}
}
printf("TRUTH");
return 0;
}
| 10 | CPP |
k, n, w = map(int, input().split())
s = 0
for i in range(1, w + 1):
s += i * k
if s <= n:
print(0)
else:
print(s - n) | 7 | PYTHON3 |
s=input()
l=['a','e','i','o','u','y']
t=""
for i in s:
if i.lower() not in l:
t+="."+i
print(t.lower()) | 7 | PYTHON3 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
bool vis[1000005];
long long extend_gcd(long long a, long long b, long long &x, long long &y) {
if (a == 0 && b == 0) return -1;
if (b == 0) {
x = 1;
y = 0;
return a;
}
long long d = extend_gcd(b, a % b, y, x);
y -= a / b * x;
return d;
}
int m;
int getans(long long h, int x, int y, int a) {
memset(vis, 0, sizeof(vis));
int c = 0;
int mm = -1;
vis[h] = 1;
while (1) {
h = (h * x + y) % m;
c++;
if (h == a) {
mm = c;
return mm;
} else if (vis[h])
return -1;
else
vis[h] = 1;
}
}
int main(void) {
long long h1, h2;
long long f1, f2;
long long a1, a2;
int x1, x2;
int y1, y2;
cin >> m;
cin >> h1 >> a1;
cin >> x1 >> y1;
cin >> h2 >> a2;
cin >> x2 >> y2;
int flag = 1;
int n1 = 0, n2 = 0;
int m1, m2;
f1 = h1, f2 = h2;
m1 = getans(h1, x1, y1, a1);
if (m1 == -1) {
printf("-1\n");
return 0;
}
n1 = getans(a1, x1, y1, a1);
m2 = getans(h2, x2, y2, a2);
if (m2 == -1) {
printf("-1\n");
return 0;
}
n2 = getans(a2, x2, y2, a2);
if (m1 == m2)
printf("%d\n", m1);
else if (n1 == -1 || n2 == -1) {
long long cha = abs(m1 - m2);
if (m1 > m2 && n2 != -1 && cha % n2 == 0) {
printf("%d\n", m1);
return 0;
} else if (m2 > m1 && n1 != -1 && cha % n1 == 0) {
printf("%d\n", m2);
return 0;
}
printf("-1\n");
return 0;
} else {
long long x, y;
long long tgcd = extend_gcd(n1, -n2, x, y);
long long b = m2 - m1;
if ((b) % tgcd != 0) {
printf("-1\n");
return 0;
}
long long nd = b / tgcd;
long long tn1 = n1;
long long tn2 = n2;
n1 /= tgcd;
n2 /= tgcd;
b /= tgcd;
if (n1 < 0) n1 = -n1;
if (n2 < 0) n2 = -n2;
long long tx, ty;
tx = (x * b % n2 + n2) % n2;
ty = ((tn1 * tx + m1) - m2) / tn2;
long long ans1 = (1LL << 60), ans2 = (1LL << 60);
if (tx >= 0 && ty >= 0) ans1 = m1 + tx * tn1;
ty = (y * b % n1 + n1) % n1;
tx = ((tn2 * ty + m2) - m1) / tn1;
if (tx >= 0 && ty >= 0) ans2 = m1 + tx * tn1;
printf("%I64d\n", min(ans1, ans2));
}
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int N, M;
struct edge {
int a, b, d;
bool operator<(const edge& other) const { return d < other.d; }
} A[150];
struct matrix {
int data[150][150];
matrix operator*(const matrix& o) const {
matrix ret;
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++) ret.data[i][j] = 0;
for (int i = 0; i < N; i++)
for (int k = 0; k < N; k++)
if (data[i][k])
for (int j = 0; j < N; j++)
ret.data[i][j] += data[i][k] * o.data[k][j];
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++) ret.data[i][j] = !!ret.data[i][j];
return ret;
}
} graph, pos, cost;
int dist[150];
bool seen[150];
int dijkstra() {
for (int i = 0; i < N; i++) {
if (pos.data[i][0])
dist[i] = 0;
else
dist[i] = 0x3f3f3f3f;
seen[i] = false;
}
while (1) {
int idx = -1;
for (int i = 0; i < N; i++)
if (!seen[i] && (idx == -1 || dist[i] < dist[idx])) idx = i;
if (idx == -1 || dist[idx] == 0x3f3f3f3f) break;
seen[idx] = true;
for (int i = 0; i < N; i++)
if (graph.data[i][idx]) dist[i] = min(dist[i], dist[idx] + 1);
}
return dist[N - 1];
}
matrix power(matrix a, int b) {
matrix ret;
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++) ret.data[i][j] = i == j;
while (b) {
if (b & 1) ret = ret * a;
a = a * a;
b /= 2;
}
return ret;
}
int main() {
scanf("%d%d", &N, &M);
for (int i = 0; i < M; i++) {
int a, b, d;
scanf("%d%d%d", &a, &b, &d);
A[i].a = a - 1;
A[i].b = b - 1;
A[i].d = d;
}
sort(A, A + M);
pos.data[0][0] = 1;
int ans = dijkstra();
int cur = 0;
for (int i = 0, j; i < M; i = j) {
matrix tmp = power(graph, A[i].d - cur);
pos = tmp * pos;
for (int k = 0; k < N; k++)
for (int l = 1; l < N; l++) pos.data[k][l] = 0;
for (j = i; j < M && A[j].d == A[i].d; j++) {
int u = A[j].a;
int v = A[j].b;
graph.data[v][u] = 1;
}
ans = min(ans, A[i].d + dijkstra());
cur = A[i].d;
}
if (ans >= 0x3f3f3f3f)
printf("Impossible\n");
else
printf("%d\n", ans);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1064;
int p[maxn];
int find(int x) { return p[x] == x ? x : p[x] = find(p[x]); }
int main() {
ios_base::sync_with_stdio(false);
int n, m;
cin >> n >> m;
bool ok = m == n - 1;
if (ok) {
for (int i = 1; i <= n; ++i) p[i] = i;
while (m--) {
int a, b;
cin >> a >> b;
a = find(a);
b = find(b);
if (a != b) {
p[a] = b;
} else {
ok = false;
break;
}
}
}
cout << (ok ? "yes\n" : "no\n");
}
| 9 | CPP |
a = int(input())
b = int(input())
c = int(input())
d = int(input())
e = int(input())
f = int(input())
if e < f:
x = min(b, c, d)
b -= x
c -= x
d -= x
s = f * x + e * min(a, d)
print(s)
else:
x = min(a, d)
a -= x
d -= x
s = e * x + f * min(b, c, d)
print(s) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long i, j, k, n, len, cnt1, cnt2;
cin >> n;
string s[n];
for (i = 0; i < n; i++) cin >> s[i];
len = s[0].length();
long long num[(1 << len)], var, obt;
long double moves[len + 1];
fill(num, num + (1 << len), 0);
fill(moves, moves + len + 1, 0);
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
if (i == j) continue;
var = 0;
for (k = 0; k < len; k++) {
if (s[i][k] == s[j][k]) var += 1 << k;
}
num[var] |= (long long)1 << i;
}
}
for (i = (1 << len) - 1; i >= 0; i--) {
for (j = 0; j < len; j++) {
if ((i >> j) & 1) {
num[i ^ (1 << j)] |= num[i];
}
}
}
for (i = 0; i < (1 << len); i++) {
cnt1 = __builtin_popcount(i);
cnt1++;
for (j = 0; j < len; j++) {
if (!((i >> j) & 1)) {
obt = num[i] ^ num[i | (1 << j)];
cnt2 = __builtin_popcountll(obt);
;
moves[cnt1] += (long double)cnt2;
}
}
}
long double exp, lc;
exp = 0;
for (i = 1; i <= len; i++) {
lc = moves[i] * (long double)i;
for (j = 0; j < i - 1; j++) {
lc = lc * (long double)(i - j - 1) / (long double)(len - j);
}
lc = lc / (long double)(len - i + 1);
exp += lc;
}
exp /= (long double)n;
cout << fixed << setprecision(12) << exp << endl;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int32_t main() {
int n;
cin >> n;
vector<int> p(n + 1);
set<int> s;
set<int> numbers;
for (int i = 1; i <= n; i++) {
s.insert(i);
numbers.insert(i);
}
int x, y;
while (s.size() >= 2) {
auto u = s.begin();
auto v = (next(s.begin()));
cout << "? " << *u << ' ' << *v << endl;
cin >> x;
cout << "? " << *v << ' ' << *u << endl;
cin >> y;
if (x > y) {
p[*u] = x;
s.erase(u);
numbers.erase(x);
} else {
p[*v] = y;
s.erase(v);
numbers.erase(y);
}
}
cout << "! ";
for (int i = 1; i <= n; i++) {
x = p[i];
if (!x) {
cout << *numbers.begin() << ' ';
} else {
cout << x << ' ';
}
}
cout << endl;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
int n;
cin >> n;
int* a = new int[n];
for (unsigned int i = 0; i < n; i++) cin >> a[i];
;
int m;
cin >> m;
int* b = new int[m];
for (unsigned int i = 0; i < m; i++) cin >> b[i];
;
sort(b, b + m);
sort(a, a + n);
int max = -1;
int count = 0;
for (int i = 0; i < n; i++) {
for (int j = m - 1; j >= 0; j--) {
float x = 1.0 * b[j] / a[i];
if ((int)x * a[i] == b[j]) {
if (max == -1) {
max = x;
count++;
} else if (max == x) {
count++;
} else if (x > max) {
count = 1;
max = x;
}
}
}
}
cout << count;
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
const int di[] = {1, 1, -1, -1};
const int dj[] = {1, -1, -1, 1};
int a, b, c, d, i, j, n, m, k;
bool used_top[1000001][4], used_bottom[1000001][4], used_left[1000001][4],
used_right[1000001][4];
queue<pair<pair<int, int>, int> > q;
inline int bad(int ci, int cj) {
int ans = 0;
if (ci < 0 || ci >= n) ++ans;
if (cj < 0 || cj >= m) ++ans;
return ans;
}
void bfs(int s, int bd) {
int bi = 0, bj = s;
int d = bd;
while (!q.empty()) q.pop();
q.push(make_pair(make_pair(bi, bj), d));
while (!q.empty()) {
int ci = q.front().first.first, cj = q.front().first.second,
cd = q.front().second;
q.pop();
if (!ci && used_top[cj][cd]) continue;
if (ci == n - 1 && used_bottom[cj][cd]) continue;
if (!cj && used_left[ci][cd]) continue;
if (cj == m - 1 && used_right[ci][cd]) continue;
if (!ci) used_top[cj][cd] = 1;
if (ci == n - 1) used_bottom[cj][cd] = 1;
if (!cj) used_left[ci][cd] = 1;
if (cj == m - 1) used_right[ci][cd] = 1;
int ni = ci + di[cd], nj = cj + dj[cd];
int b = bad(ni, nj);
if (b == 2) {
q.push(make_pair(make_pair(ci, cj), (cd + 2) % 4));
continue;
} else if (b == 1) {
if (!ci || ci == n - 1) {
if (cd == 0)
cd = 3;
else if (cd == 1)
cd = 2;
else if (cd == 2)
cd = 1;
else if (cd == 3)
cd = 0;
} else {
if (cd == 0)
cd = 1;
else if (cd == 1)
cd = 0;
else if (cd == 2)
cd = 3;
else if (cd == 3)
cd = 2;
}
q.push(make_pair(make_pair(ci, cj), cd));
} else {
int bl = 1000000000, gi = -1, gj = -1;
if (di[cd] < 0 && ci < bl) {
bl = ci;
gi = 0;
gj = cj + bl * dj[cd];
}
if (di[cd] > 0 && n - ci - 1 < bl) {
bl = n - ci - 1;
gi = n - 1;
gj = cj + bl * dj[cd];
}
if (dj[cd] < 0 && cj < bl) {
bl = cj;
gj = 0;
gi = ci + bl * di[cd];
}
if (dj[cd] > 0 && m - cj - 1 < bl) {
bl = m - cj - 1;
gj = m - 1;
gi = ci + bl * di[cd];
}
q.push(make_pair(make_pair(gi, gj), cd));
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (int _n((m)-1), i(0); i <= _n; i++) {
if (used_top[i][0] || used_top[i][1] || used_top[i][2] || used_top[i][3])
continue;
++c;
bfs(i, 0);
bfs(i, 1);
}
printf("%d\n", c);
}
| 9 | CPP |
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<iostream>
#include<string>
#include<vector>
#include<map>
#include<set>
#include<list>
#include<queue>
#include<deque>
#include<algorithm>
#include<numeric>
#include<utility>
#include<complex>
#include<functional>
using namespace std;
/* constant */
const int MAX_L = 1000;
const int MAX_N = 100;
const int MAX_M = 100;
/* typedef */
typedef pair<int,int> pii;
/* global variables */
int lim, n, m, x;
pii secs[MAX_N], stds[MAX_M];
int dp0[3][MAX_L + 1], dp1[MAX_M + 1][MAX_L + 1];
/* subroutines */
/* main */
int main() {
for (;;) {
cin >> lim >> n >> m >> x;
if (lim == 0) break;
string name;
for (int i = 0; i < n; i++)
cin >> name >> secs[i].first >> secs[i].second;
for (int i = 0; i < m; i++)
cin >> name >> stds[i].first >> stds[i].second;
memset(dp0, -1, sizeof(dp0));
dp0[0][0] = 0;
for (int i = 0; i < n; i++) {
int &ei = secs[i].first, &si = secs[i].second;
int maxl = lim - ei;
for (int j = 1; j >= 0; j--)
for (int l = 0; l <= maxl; l++)
if (dp0[j][l] >= 0 && dp0[j + 1][l + ei] < dp0[j][l] + si)
dp0[j + 1][l + ei] = dp0[j][l] + si;
}
for (int i = 1; i <= 2; i++)
for (int l = 1; l <= lim; l++)
if (dp0[i][l] < dp0[i][l - 1]) dp0[i][l] = dp0[i][l - 1];
memset(dp1, -1, sizeof(dp1));
dp1[0][0] = 0;
for (int i = 0; i < m; i++) {
int &ei = stds[i].first, &si = stds[i].second;
int maxl = lim - ei;
for (int j = m - 1; j >= 0; j--)
for (int l = 0; l <= maxl; l++)
if (dp1[j][l] >= 0 && dp1[j + 1][l + ei] < dp1[j][l] + si)
dp1[j + 1][l + ei] = dp1[j][l] + si;
}
for (int i = 1; i <= m; i++)
for (int l = 1; l <= lim; l++)
if (dp1[i][l] < dp1[i][l - 1]) dp1[i][l] = dp1[i][l - 1];
int maxsum = 0;
for (int i = 1; i <= 2; i++)
for (int j = x; j <= m; j++)
for (int l = 0; l <= lim; l++)
if (dp0[i][l] >= 0 && dp1[j][lim - l] >= 0) {
int sum = dp0[i][l] + dp1[j][lim - l];
if (maxsum < sum) maxsum = sum;
}
cout << maxsum << endl;
}
return 0;
} | 0 | CPP |
#include <cstdio>
char grid[1005][1005];
int dp[1005][1005];
const int MOD=1e9+7;
void addmod(int& x,int y){x=(x+y)%MOD;}
int main(){
int H,W;
scanf("%d %d",&H,&W);
for(int i=0;i<H;i++){
scanf("%s",grid[i]);
}
dp[0][0]=1;
for(int i=0;i<H;i++){
for(int j=0;j<W;j++){
if(grid[i][j]=='.'){
addmod(dp[i+1][j],dp[i][j]);
addmod(dp[i][j+1],dp[i][j]);
}
}
}
printf("%d\n",dp[H-1][W-1]);
return 0;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int toInt(string s) {
istringstream sin(s);
int t;
sin >> t;
return t;
}
template <class T>
string toString(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
template <class T>
void chmin(T &t, T f) {
if (t > f) t = f;
}
template <class T>
void chmax(T &t, T f) {
if (t < f) t = f;
}
int main() {
int n, d, s;
cin >> n >> d >> s;
vector<pair<int, int> > v0, v1;
vector<int> v;
int _n = n;
while (n--) {
int c, f, l;
cin >> c >> f >> l;
if (l >= d) {
if (c)
v1.push_back(make_pair(f, c));
else
v0.push_back(make_pair(f, c));
} else
v.push_back(c);
}
sort(v0.begin(), v0.end());
sort(v1.begin(), v1.end());
sort(v.begin(), v.end());
reverse(v.begin(), v.end());
int i, cnt = 0;
long long cur = 1;
long long t = 0, tot = 0;
for (typeof(v0.begin()) it = v0.begin(); it != v0.end(); it++) {
if (tot + it->first > s) break;
t++;
tot += it->first;
}
for (typeof(v1.begin()) it = v1.begin(); it != v1.end(); it++) {
cur += it->second - 1;
cnt++;
}
for (typeof(v.begin()) it = v.begin(); it != v.end(); it++) {
cur += *it - 1;
cnt++;
if (cur == 0) break;
}
if (cur)
while (v0.size()) {
cur -= 1;
cnt++;
v0.pop_back();
if (cur == 0) break;
}
int r = _n - cnt;
vector<pair<int, int> > vv;
if (v1.size()) {
int m = v1.size();
for (i = (1); i < (m); i++)
if (r) {
vv.push_back(make_pair(v1[i].first, 1));
r--;
}
}
for (typeof(v0.begin()) it = v0.begin(); it != v0.end(); it++)
vv.push_back(make_pair(it->first, 1));
sort(vv.begin(), vv.end());
long long ans = 0, mn = 0;
if (v1.size() && v1[0].first <= s) {
ans += cnt;
mn += v1[0].first;
for (typeof(vv.begin()) it = vv.begin(); it != vv.end(); it++) {
if (mn + it->first > s) break;
ans++;
mn += it->first;
if (ans == _n) break;
}
}
if (ans < t)
cout << t << " " << tot << endl;
else if (ans > t)
cout << ans << " " << mn << endl;
else
cout << ans << " " << min(tot, mn) << endl;
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
ostream &operator<<(ostream &os, vector<T> &v) {
os << "{";
for (int i = (int)(0); i < (int)(v.size()); ++i)
os << v[i] << (i == (int)v.size() - 1 ? "" : ", ");
os << "}";
return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, pair<T, U> &p) {
return (os << "(" << p.first << ", " << p.second << ")");
}
template <typename T, typename U>
ostream &operator<<(ostream &os, map<T, U> &m) {
bool first = true;
os << "{";
for (const auto &e : m) {
if (!first) os << ", ";
os << "{" << e.first << ": " << e.second << "}";
first = false;
}
os << "}";
return os;
}
template <typename T>
ostream &operator<<(ostream &os, set<T> &s) {
os << "{";
bool first = true;
for (const auto &e : s) {
if (!first) os << ", ";
os << e;
first = false;
}
os << "}";
return os;
}
template <typename T>
T dup(T x, T y) {
return (x + y - 1) / y;
};
template <typename A, size_t N, typename T>
inline void arrayFill(A (&array)[N], const T &val) {
std::fill((T *)array, (T *)(array + N), val);
}
template <class T>
inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T>
inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
struct in {
const size_t n = 0;
in() = default;
in(size_t n) : n(n){};
template <typename T>
operator T() {
T ret;
cin >> ret;
return ret;
}
template <typename T>
operator vector<T>() {
assert(n != 0);
vector<T> ret(n);
for (T &x : ret) {
T tmp = in();
x = tmp;
}
return ret;
}
template <typename T, typename U>
operator pair<T, U>() {
pair<T, U> ret;
ret.first = in();
ret.second = in();
return ret;
}
};
using ll = int64_t;
using vint = vector<int32_t>;
using vvint = vector<vint>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vstr = vector<string>;
using pint = pair<int32_t, int32_t>;
using vpint = vector<pint>;
using pll = pair<ll, ll>;
using vpll = vector<pll>;
using setint = set<int32_t>;
using qint = queue<int32_t>;
using qpint = queue<pint>;
constexpr std::int32_t INF = 1001001001;
constexpr std::int64_t LINF = 1001001001001001001;
void Main() {
int t = in();
while (t--) {
int n = in();
vint a = in(n);
for (int i = (int)(0); i < (int)(n); ++i) --a[i];
vvint s(n + 1, vint(200, 0));
for (int i = (int)(0); i < (int)(n); ++i)
for (int j = (int)(0); j < (int)(200); ++j)
s[i + 1][j] += s[i][j] + (a[i] == j);
int ans = 1;
for (int i = (int)(0); i < (int)(200); ++i) {
int l = 0;
int r = n;
for (int j = (int)(0); j < (int)(n / 2 + 1); ++j) {
while (s[l][i] - s[0][i] < j) {
++l;
if (l > r) break;
}
while (s[n][i] - s[r][i] < j) {
--r;
if (l > r) break;
}
if (l > r) break;
int tmp = 0;
for (int k = (int)(0); k < (int)(200); ++k) {
tmp = max(tmp, s[r][k] - s[l][k]);
}
ans = max(2 * j + tmp, ans);
}
}
cout << ans << '\n';
}
}
signed main() {
std::cin.tie(nullptr);
std::ios_base::sync_with_stdio(false);
std::cout << std::fixed << std::setprecision(15);
Main();
return 0;
}
| 8 | CPP |
n = int(input())
arr = [int(x) for x in input().split()]
count = []
for i in arr:
if i not in count:
count.append(i)
count.sort()
if (len(count) == 3) and ((count[0] + count[2])/2 == count[1]):
print(count[2] - count[1])
elif len(count) == 2:
if (count[1] - count[0])//2 != (count[1] - count[0])/2:
print(count[1] - count[0])
else:
print((count[1] - count[0])//2)
elif len(count) == 1:
print(0)
else:
print(-1)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const long long lg = 62;
long long a[lg];
long long n;
long long get_level(long long x) {
for (long long i = 0; i < lg; ++i) {
if ((1LL << (i + 1)) - 1 >= x) return i;
}
assert(false);
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (long long i = 0; i < n; ++i) {
long long t, x, k;
cin >> t;
if (t == 1) {
cin >> x >> k;
x = get_level(x);
long long kek = (1LL << x);
k = (k % kek + kek) % kek;
a[x] += k;
a[x] = (a[x] + (1LL << x)) % (1LL << x);
}
if (t == 2) {
cin >> x >> k;
x = get_level(x);
long long kek = (1LL << x);
k = (k % kek + kek) % kek;
for (long long j = x; j < lg; ++j) {
a[j] += k;
a[j] = (a[j] + (1LL << j)) % (1LL << j);
k *= 2;
}
}
if (t == 3) {
vector<long long> v;
cin >> x;
v.push_back(x);
long long level = get_level(x);
long long p2 = (1LL << level);
x = (x + a[level]) % p2 + p2;
x /= 2;
while (x > 0) {
long long level = get_level(x);
long long p2 = (1LL << level);
x -= p2;
long long y = (x - a[level] + p2) % p2;
v.push_back(y + p2);
x += p2;
x /= 2;
}
for (auto p : v) {
cout << p << " ";
}
cout << endl;
}
}
}
| 10 | CPP |
import sys
from collections import defaultdict
#input = sys.stdin.readline
import math
def main():
s = input()
t = input()
longest_prefix = [0] * len(s)
longest_suffix = [0] * len(s)
longest_prefix[0] = 1 if s[0] == t[0] else 0
for i in range(1, len(s)):
x = longest_prefix[i-1]
if x == len(t) or s[i] != t[x]:
longest_prefix[i] = x
else:
longest_prefix[i] = x + 1
longest_suffix[-1] = 1 if s[-1] == t[-1] else 0
for i in range(len(s)-2, -1, -1):
x = longest_suffix[i+1]
if x == len(t) or s[i] != t[-1-x]:
longest_suffix[i] = x
else:
longest_suffix[i] = x + 1
res = 0
pos1 = 0
while longest_prefix[pos1] != len(t):
pos1 += 1
res = max(res, len(s)-1-pos1)
pos2 = len(s)-1
while longest_suffix[pos2] != len(t):
pos2 -= 1
res = max(res, pos2)
pos1 = 0
pos2 = 0
while pos1 < len(s):
while pos2+1 < len(s) and longest_prefix[pos1] + longest_suffix[pos2+1] >= len(t):
pos2 += 1
res = max(res, pos2-pos1-1)
pos1 += 1
print(res)
if __name__ == '__main__':
main()
| 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[100001];
bool solve() {
int mx = 0;
long long cnt = 0;
for (int i = 0; i < n; i++) {
mx = max(mx, a[i]);
cnt += a[i];
}
if (cnt % 2 == 1) return false;
if (mx > cnt - mx) return false;
return true;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
cout << (solve() ? "HL" : "T") << endl;
}
return 0;
}
| 8 | CPP |
#!/usr/bin/env python
import os
import sys
from io import BytesIO, IOBase
def main():
for _ in range(int(input())):
n = int(input())
a = list(map(int, input().split()))
for i in range(n):
if a[i] != 1:
break
print('Second' if i % 2 else 'First')
# 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 |
n,m = map(int,input().split())
d = dict()
for i in range(m):
a = list(map(str,input().split()))
d[a[0]] = [a[1],a[0]]
s = list(map(str,input().split()))
for i in range(len(s)):
if (len(d[s[i]][0]) < len(d[s[i]][1])):
print(d[s[i]][0],end = ' ')
else:
print(d[s[i]][1],end = ' ') | 8 | PYTHON3 |
N,M=input(" ").split()
N=int(N)
M=int(M)
number_of_dominos=(M*N)//2
print(number_of_dominos) | 7 | PYTHON3 |
for _ in range(int(input())):
n,m = map(int,input().split())
ls = []
row = [True for i in range(n)]
coloumb = [True for i in range(m)]
for i in range(n):
ls.append(list(map(int,input().split())))
if 1 in ls[i]:
row[i] = False
while True:
if 1 in ls[i]:
t = ls[i].index(1)
coloumb[t] = False
ls[i][t] = 0
else:
break
ans = 0
for i in range(n):
for j in range(m):
if row[i] and coloumb[j]:
ans+=1
row[i] = False
coloumb[j] = False
print("Vivek" if ans%2 == 0 else "Ashish")
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[5007], b[5007], c[5007], s[5007], s1[5007], s2[5007], s3[5007];
int f[2][91][91][91];
int ans;
int calc_max(int type, int n) {
if (type == 1) return n;
if (type == 2) return n / 2;
if (type == 3) return n / 4;
if (type == 4) return n / 8;
if (type == 5) return n / 16;
return n / 32;
}
int calc_min(int type, int n) {
if (type == 1) return (n / 2) + 1;
if (type == 2) return (n / 4) + 1;
if (type == 3) return (n / 8) + 1;
if (type == 4) return (n / 16) + 1;
if (type == 5) return (n / 32) + 1;
return 0;
}
int check(int aa, int bb, int cc) {
int A = 2 * aa, B = 2 * bb, C = 2 * cc;
int p_max = calc_max(aa, n), q_max = calc_max(bb, n), r_max = calc_max(cc, n);
int p_min = calc_min(aa, n), q_min = calc_min(bb, n), r_min = calc_min(cc, n);
int cnt1 = 0, cnt2 = 0, cnt3 = 0;
int tot1 = 0, tot2 = 0, tot3 = 0;
for (int i = 1; i <= n; i++) {
if (a[i] < 0) ++cnt1;
if (b[i] < 0) ++cnt2;
if (c[i] < 0) ++cnt3;
if (a[i] != 0) ++tot1;
if (b[i] != 0) ++tot2;
if (c[i] != 0) ++tot3;
}
if (tot1 < p_min) return n;
if (tot2 < q_min) return n;
if (tot3 < r_min) return n;
if (tot1 - cnt1 > p_max) return n;
if (tot2 - cnt2 > q_max) return n;
if (tot3 - cnt3 > r_max) return n;
int p = min(cnt1, tot1 - p_min);
int q = min(cnt2, tot2 - q_min);
int r = min(cnt3, tot3 - r_min);
memset(s, 0, sizeof(s));
for (int i = 1; i <= n; i++) {
if (a[i] != 0) s1[i] = A * (250 - abs(a[i]));
if (b[i] != 0) s2[i] = B * (250 - abs(b[i]));
if (c[i] != 0) s3[i] = C * (250 - abs(c[i]));
s[i] = s1[i] + s2[i] + s3[i];
}
s[1] += 100 * (p + q + r);
int pos = 0, pre = 1;
int tot = 0;
memset(f, 0, sizeof(f));
for (int i = 2; i <= n; i++)
if (s[i] > s[1]) {
++tot;
pre ^= 1, pos ^= 1;
for (int ii = 0; ii <= p; ii++)
for (int jj = 0; jj <= q; jj++)
for (int kk = 0; kk <= r; kk++) {
f[pos][ii][jj][kk] = 0;
f[pos][ii][jj][kk] = max(f[pos][ii][jj][kk], f[pre][ii][jj][kk]);
if (a[i] < 0 && ii > 0 && s[i] - s1[i] <= s[1])
f[pos][ii][jj][kk] =
max(f[pos][ii][jj][kk], f[pre][ii - 1][jj][kk] + 1);
if (b[i] < 0 && jj > 0 && s[i] - s2[i] <= s[1])
f[pos][ii][jj][kk] =
max(f[pos][ii][jj][kk], f[pre][ii][jj - 1][kk] + 1);
if (c[i] < 0 && kk > 0 && s[i] - s3[i] <= s[1])
f[pos][ii][jj][kk] =
max(f[pos][ii][jj][kk], f[pre][ii][jj][kk - 1] + 1);
if (a[i] < 0 && b[i] < 0 && ii > 0 && jj > 0 &&
s[i] - s1[i] - s2[i] <= s[1])
f[pos][ii][jj][kk] =
max(f[pos][ii][jj][kk], f[pre][ii - 1][jj - 1][kk] + 1);
if (a[i] < 0 && c[i] < 0 && ii > 0 && kk > 0 &&
s[i] - s1[i] - s3[i] <= s[1])
f[pos][ii][jj][kk] =
max(f[pos][ii][jj][kk], f[pre][ii - 1][jj][kk - 1] + 1);
if (b[i] < 0 && c[i] < 0 && jj > 0 && kk > 0 &&
s[i] - s2[i] - s3[i] <= s[1])
f[pos][ii][jj][kk] =
max(f[pos][ii][jj][kk], f[pre][ii][jj - 1][kk - 1] + 1);
if (a[i] < 0 && b[i] < 0 && c[i] < 0 && ii > 0 && jj > 0 &&
kk > 0 && s[i] - s1[i] - s2[i] - s3[i] <= s[1])
f[pos][ii][jj][kk] =
max(f[pos][ii][jj][kk], f[pre][ii - 1][jj - 1][kk - 1] + 1);
}
}
return 1 + tot - f[pos][p][q][r];
}
int main() {
scanf("%d", &n);
ans = n;
for (int i = 1; i <= n; i++) scanf("%d%d%d", &a[i], &b[i], &c[i]);
int num = 0;
for (int i = 1; i <= n; i++) {
if (a[i] < 0) ++num;
if (b[i] < 0) ++num;
if (c[i] < 0) ++num;
}
if (num > 90) {
printf("%d\n", 1);
return 0;
}
for (int i = 1; i <= 6; i++)
for (int j = 1; j <= 6; j++)
for (int k = 1; k <= 6; k++) ans = min(ans, check(i, j, k));
printf("%d\n", ans);
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, in, t1, t2;
cin >> n;
string s;
cin >> s;
int count;
if (s[0] == '-') {
count = 1;
} else {
count = 0;
}
for (int i = 0; i < n; i++) {
if (s[i] == '+') {
count++;
} else {
count--;
if (count == 0 && s[i + 1] == '-' && i != n - 1) {
count = count + 1;
}
}
}
cout << count << "\n";
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
string type;
long long a[181], n, i, j, q, len, nom, nom1;
bool x;
bool check(long long l, long long r) {
long long i;
for (i = l; i <= r; i++)
if (a[i] != 9000000000000000000LL) return 0;
return 1;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> q >> n;
for (i = 1; i <= n; i++) a[i] = 9000000000000000000LL;
while (q--) {
cin >> type;
if (type[0] == 'a') {
cin >> len;
x = false;
for (i = 1; i <= n - len + 1; i++)
if (check(i, i + len - 1)) {
x = true;
nom1++;
for (j = i; j <= i + len - 1; j++) a[j] = nom1;
break;
}
if (x)
cout << nom1;
else
cout << "NULL";
cout << '\n';
} else if (type[0] == 'e') {
cin >> nom;
x = false;
for (i = 1; i <= n; i++)
if (a[i] == nom) {
x = true;
a[i] = 9000000000000000000LL;
}
if (!x) cout << "ILLEGAL_ERASE_ARGUMENT" << '\n';
} else {
for (i = 1; i <= n; i++)
if (a[i] != 9000000000000000000LL) {
nom = i;
while (i > 1 && a[nom - 1] == 9000000000000000000LL) {
swap(a[nom], a[nom - 1]);
nom--;
}
}
}
}
return 0;
}
| 8 | CPP |
S = input()
print('Yes') if S[:min(4, len(S))] == 'YAKI' else print('No') | 0 | PYTHON3 |
n = int(input())
a = list(map(int, input().split()))
a.sort()
nxt = 0
ans = 0
for now in a:
ans += max(0, nxt - now)
nxt = max(nxt + 1, now + 1)
print(ans) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, s, k;
cin >> n >> s >> k;
vector<int> c;
int a[100000];
for (int i = 0; i < n; ++i) cin >> a[i];
for (int i = 1; i < n; ++i) c.push_back(a[i] - a[i - 1] - 1);
int answer = a[n - 1] - a[0] + 1;
sort(c.rbegin(), c.rend());
for (int i = 0; i < k - 1; ++i) {
answer -= c[i];
}
cout << answer;
}
| 8 | CPP |
#!/usr/bin/python3.5
n=int(input())
s=input()
b=s.count(s[0])
if b==n:
print(s[0])
quit()
k=0
o=''
b=s.count('B')
if b:
k+=1
else:
o+='B'
g=s.count('G')
if g:
k+=1
else:
o+='G'
r=s.count('R')
if r:
k+=1
else:
o+='R'
if n==2:
print(o)
quit()
if k==3:
print("BGR")
quit()
if b and g:
if b>g and g<2:
o+='G'
elif g>b and b<2:
o+='B'
else:
o+='GB'
elif b and r:
if b>r and r<2:
o+='R'
elif r>b and b<2:
o+='B'
else:
o+='BR'
elif g>r and r<2:
o+='R'
elif r>g and g<2:
o+='G'
else:
o+='RG'
del k
k=list(o)
k.sort()
for i in k:
print(i,end='')
print() | 8 | PYTHON3 |
n = input()
i = 0
while i < len(n):
if n[i] == '.':
print(0, end='')
i += 1
elif n[i] == '-' and n[i + 1] == '.':
print(1, end='')
i += 2
else:
print(2, end='')
i += 2
| 8 | PYTHON3 |
import sys
import math
import heapq
import collections
from collections import OrderedDict
def inputnum():
return(int(input()))
def inputnums():
return(map(int,input().split()))
def inputlist():
return(list(map(int,input().split())))
def inputstring():
return([x for x in input()])
def inputmatrixchar(rows):
arr2d = [[j for j in input().strip()] for i in range(rows)]
return arr2d
def inputmatrixint(rows):
arr2d = []
for _ in range(rows):
arr2d.append([int(i) for i in input().split()])
return arr2d
t=int(input())
for q in range(t):
n, k = inputnums()
a = inputlist()
d = {}
mx = 0
for i in range(n):
mod = k - a[i]%k
if mod == k:
continue
if mod in d:
d[mod] += 1
else:
d[mod] = 1
mx = max(d[mod], mx)
d1 = OrderedDict(sorted(d.items()))
ans = 0
for i in d1:
if d1[i] == mx:
ans = i
print(max(0, 1 + ans + k*(mx-1))) | 10 | PYTHON3 |
#include <cstdio>
#include <cassert>
#include <cstring>
#include <algorithm>
#define meow(args...) fprintf(stderr, args)
const int N=2e5+5, M=2e6, oo=1<<30;
namespace Dinic {
int n, e, S, T, head[N], to[M], next[M], cap[M], q[N], dis[N], cur[N];
void add_edge(int u, int v, int w, int r=0) {
to[e]=v, cap[e]=w, next[e]=head[u], head[u]=e++;
to[e]=u, cap[e]=r, next[e]=head[v], head[v]=e++;
}
bool bfs() {
int l=-1, r=-1, i;
memset(dis, 0, n*sizeof(int));
dis[q[++r]=T]=1;
while(l++<r) {
if(q[l]==S) return true;
for(i=head[q[l]]; ~i; i=next[i])
if(cap[i^1]&&!dis[to[i]]) dis[q[++r]=to[i]]=dis[q[l]]+1;
}
return false;
}
int dfs(int x, int rem) {
if(x==T) return rem;
int save=rem;
for(int &i=cur[x]; ~i; i=next[i])
if(cap[i]&&dis[to[i]]==dis[x]-1) {
int now=dfs(to[i], rem<cap[i]?rem:cap[i]);
cap[i]-=now;
cap[i^1]+=now;
rem-=now;
if(!rem) break;
}
return save-rem;
}
int main() {
int ans=0;
while(bfs()) {
memcpy(cur, head, n*sizeof(int));
ans+=dfs(S, oo);
}
return ans;
}
}
int n, p[N], q[N], a[N], b[N];
template<class Type> Type read() {
Type a;
bool b;
unsigned char c;
while(c=getchar(), c-'0'>9&c!='-');
for(a=(b=c=='-')?0:c-'0'; (c=getchar()-'0')<=9; a=a*10+c);
return b?-a:a;
}
int dump(int *src, int *dst) {
int m=0;
memset(dst, -1, n*sizeof(int));
for(int i=0; i<n; ++i)
if(dst[i]==-1) {
int x=i;
do {
dst[x]=m;
x=src[x];
} while(x!=i);
++m;
}
return m;
}
int main() {
int (*rd)()=read<int>, x, y, s, t, ans;
n=ans=rd();
std::generate(p, p+n, rd), x=dump(p, a);
std::generate(q, q+n, rd), y=dump(q, b);
Dinic::n=x+y+2;
Dinic::S=s=x+y;
Dinic::T=t=x+y+1;
memset(Dinic::head, -1, (x+y+2)*sizeof(int));
for(int i=0; i<n; ++i) {
if(i==p[i]) {
if(i==q[i]) --ans; else Dinic::add_edge(s, x+b[i], 1);
} else {
if(i==q[i]) Dinic::add_edge(a[i], t, 1); else Dinic::add_edge(a[i], x+b[i], 1, p[i]==q[i]);
}
}
printf("%d\n", ans-Dinic::main());
return 0;
}
| 0 | CPP |
x = int(input())
print((-1)**x*(x+1)//2) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100010;
int n, m, k, x, y;
int c[MAXN], res[MAXN];
int head[MAXN], to[MAXN], next2[MAXN], cnt = 1;
inline void adde(int f, int t) {
cnt++, to[cnt] = t, next2[cnt] = head[f], head[f] = cnt;
cnt++, to[cnt] = f, next2[cnt] = head[t], head[t] = cnt;
}
int sz;
bool used[1010];
void DFS(int x) {
sz++;
used[x] = true;
for (int i = head[x]; i; i = next2[i])
if (!used[to[i]]) DFS(to[i]);
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= k; i++) scanf("%d", &c[i]);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &x, &y);
adde(x, y);
}
for (int i = 1; i <= k; i++) sz = 0, DFS(c[i]), res[i] = sz;
int o = 0, sum = 0;
for (int i = 1; i <= k; i++) {
sum += res[i];
if (res[i] > res[o]) o = i;
}
res[o] += n - sum;
int ans = 0;
for (int i = 1; i <= k; i++) ans += res[i] * (res[i] - 1) / 2;
printf("%d\n", ans - m);
return 0;
}
| 7 | CPP |
#include<bits/stdc++.h>
using namespace std;
int main()
{
int a,b,c;
cin>>a>>b>>c;
if((a==b&&c!=a)||(a==c&&b!=c)||(a!=b&&b==c)) cout<<"Yes";
else cout<<"No";
return 0;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
template <class T>
void out(const vector<T> &a) {
cout << "array: ";
for (int i = 0; i < (int)a.size(); i++) cout << a[i] << " ";
cout << endl;
cout.flush();
}
void binprint(int mask, int n) {
int i;
string s = "";
do {
s += (mask % 2 + '0');
mask /= 2;
} while (mask);
reverse(s.begin(), s.end());
s = string((n - (int)s.size() > 0 ? n - (int)s.size() : 0), '0') + s;
for (i = (int)s.size() - n; i < (int)s.size(); i++) printf("%c", s[i]);
printf("\n");
}
void ASCII_Chart() {
int i, j, k;
printf("ASCII Chart:(30-129)\n");
for (i = 30; i <= 50; i++) {
for (j = 0; j < 5; j++) {
k = i + j * 20;
printf("%3d---> '%c' ", k, k);
}
printf("\n");
}
}
template <class T>
inline T gcd(T a, T b) {
if (a < 0) return gcd(-a, b);
if (b < 0) return gcd(a, -b);
return (b == 0) ? a : gcd(b, a % b);
}
template <class T>
inline T lcm(T a, T b) {
if (a < 0) return lcm(-a, b);
if (b < 0) return lcm(a, -b);
return a * (b / gcd(a, b));
}
template <class T>
T Abs(T x) {
return x > 0 ? x : -x;
}
template <class T>
inline T sqr(T x) {
return x * x;
}
template <class T>
inline T Mod(T n, T m) {
return (n % m + m) % m;
}
int BigMod(long long B, long long P, long long M) {
long long R = 1;
while (P > 0) {
if (P % 2 == 1) {
R = (R * B) % M;
}
P /= 2;
B = (B * B) % M;
}
return (int)R;
}
long long mulmod(long long a, long long b, long long c) {
long long x = 0, y = a % c;
while (b > 0) {
if (b % 2 == 1) {
x = (x + y) % c;
}
y = (y * 2) % c;
b /= 2;
}
return x % c;
}
long long mpow(long long x, long long k) {
if (k == 0) return 1;
long long r = mpow(x, k / 2);
return k % 2 ? (r * r * x) : (r * r);
}
template <class T>
inline vector<pair<T, int> > factorize(T n) {
vector<pair<T, int> > R;
for (T i = 2; n > 1;) {
if (n % i == 0) {
int C = 0;
for (; n % i == 0; C++, n /= i)
;
R.push_back(make_pair(i, C));
}
i++;
if (i > n / i) i = n;
}
if (n > 1) R.push_back(make_pair(n, 1));
return R;
}
vector<string> SubstringGenerate(string str) {
int i, j, len;
vector<string> store;
len = (int)str.size();
for (i = 0; i < len; i++)
for (j = i; j <= len; j++) store.push_back(str.substr(i, j - i + 1));
return store;
}
template <class T>
inline bool isPrime(T n) {
if (n <= 1) return false;
for (T i = 2; i * i <= n; i++)
if (n % i == 0) return false;
return true;
}
bool IsVowel(char ch) {
ch = tolower(ch);
if (ch == 'a' || ch == 'e' || ch == 'i' || ch == 'o' || ch == 'u')
return true;
return false;
}
bool isUpperCase(char c) { return c >= 'A' && c <= 'Z'; }
bool isLowerCase(char c) { return c >= 'a' && c <= 'z'; }
bool isLetter(char c) { return c >= 'A' && c <= 'Z' || c >= 'a' && c <= 'z'; }
bool isDigit(char c) { return c >= '0' && c <= '9'; }
double deg2rad(double x) { return (PI * x) / 180.0; }
double rad2deg(double x) { return (180.0 * x) / PI; }
template <class T>
string toString(T n) {
ostringstream oss;
oss << n;
oss.flush();
return oss.str();
}
int toInt(string s) {
int r = 0;
istringstream sin(s);
sin >> r;
return r;
}
long long toLl(string s) {
long long r = 0;
istringstream sin(s);
sin >> r;
return r;
}
double toDouble(string s) {
double r = 0;
istringstream sin(s);
sin >> r;
return r;
}
template <typename T>
static void splitstr(const string &s, vector<T> &out) {
istringstream in(s);
out.clear();
copy(istream_iterator<T>(in), istream_iterator<T>(), back_inserter(out));
}
template <class T>
void debug(T e) {
cout << e << endl;
}
template <class T1, class T2>
void debug(T1 e1, T2 e2) {
cout << e1 << "\t" << e2 << endl;
}
template <class T1, class T2, class T3>
void debug(T1 e1, T2 e2, T3 e3) {
cout << e1 << "\t" << e2 << "\t" << e3 << endl;
}
template <class T1, class T2, class T3, class T4>
void debug(T1 e1, T2 e2, T3 e3, T4 e4) {
cout << e1 << "\t" << e2 << "\t" << e3 << "\t" << e4 << endl;
}
template <class T1, class T2, class T3, class T4, class T5>
void debug(T1 e1, T2 e2, T3 e3, T4 e4, T5 e5) {
cout << e1 << "\t" << e2 << "\t" << e3 << "\t" << e4 << "\t" << e5 << endl;
}
template <class T>
void debug(vector<T> e) {
int i;
for (i = 0; i < (int)e.size(); i++) cout << e[i] << " ";
cout << endl;
}
template <class T>
void debug(vector<T> e, int n) {
int i;
for (i = 0; i < n; i++) cout << e[i] << " ";
cout << endl;
}
template <class T>
void debug(vector<basic_string<T> > e) {
int i, j;
for (i = 0; i < (int)e.size(); i++) {
for (j = 0; j < (int)e[i].size(); j++) cout << e[i][j];
cout << endl;
}
cout << endl;
}
template <class T>
void debug(vector<basic_string<T> > e, int row, int col) {
int i, j;
for (i = 0; i < row; i++) {
for (j = 0; j < col; j++) cout << e[i][j];
cout << endl;
}
cout << endl;
}
template <class T>
void debug(vector<vector<T> > e, int row, int col) {
int i, j;
for (i = 0; i < row; i++) {
for (j = 0; j < col; j++) cout << e[i][j] << "\t";
cout << endl;
}
cout << endl;
}
template <class T>
void debug(T e[1000000][1000000], int row, int col) {
int i, j;
for (i = 0; i < row; i++) {
for (j = 0; j < col; j++) cout << e[i][j] << " ";
cout << endl;
}
}
template <class T>
void debug(T e[], int row) {
int i;
for (i = 0; i < row; i++) cout << e[i] << " ";
cout << endl;
}
vector<vector<int> > v;
int binS(int in, int r) {
int l, h, m;
l = 0;
h = (int)v[in].size();
if (h == 0) return -1;
m = (l + h) / 2;
while (h > l) {
m = (l + h) / 2;
if (v[in][m] > r)
h = m - 1;
else
l = m + 1;
}
return m;
}
int main() {
string s1, s2;
int l1, l2, i, j, cnt, in, c, rp, rr;
bool f, ch;
vector<int> v1;
v1.clear();
cin >> s1 >> s2;
l1 = (int)s1.size();
l2 = (int)s2.size();
for (i = 0; i < 27; i++) v.push_back(v1);
for (i = 0; i < l1; i++) {
v[s1[i] - 'a'].push_back(i);
}
rp = 0;
rr = 0;
cnt = 1;
f = 1;
for (i = 0; i < l2; i++) {
c = s2[i] - 'a';
in = binS(s2[i] - 'a', rp);
if (in == -1) {
f = 0;
break;
}
if (in > 0) in -= 1;
if (in > 0) in -= 1;
ch = false;
for (j = in; j <= (int)v[c].size() - 1; j++) {
if (v[c][j] > rp) {
rr = v[c][j];
ch = true;
break;
}
}
if (!ch) rr = v[c][0];
if (i != 0) {
if (rr <= rp) cnt++;
}
rp = rr;
}
if (!f)
cout << "-1" << endl;
else
cout << cnt << endl;
return 0;
}
| 9 | CPP |
#-------------Program-------------
#----KuzlyaevNikita-Codeforces----
#---------------------------------
n,k,l,c,d,p,nl,np=map(int,input().split())
print(min(k*l//nl,c*d,p//np)//n) | 7 | PYTHON3 |
s = input()
if s.count('4') == 0 and s.count('7') == 0:
print(-1)
elif s.count('4') < s.count('7'):
print(7)
else:
print(4) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long M = 2005, YD = 1e9 + 7;
int n, m, K, C[M][M];
void init(int n) {
for (int i = 0; i <= n; i++) {
C[i][0] = C[i][i] = 1;
for (int j = 1; j < i; j++) C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % YD;
}
}
int main() {
scanf("%d%d%d", &n, &m, &K);
if (n < m) swap(n, m);
init(n);
cout << C[n - 1][2 * K] * (long long)C[m - 1][2 * K] % YD << endl;
return 0;
}
| 9 | CPP |
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,copy,functools
# import time,random,resource
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
mod2 = 998244353
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(): return [list(map(int, l.split())) for l in sys.stdin.readlines()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def pe(s): return print(str(s), file=sys.stderr)
def JA(a, sep): return sep.join(map(str, a))
def JAA(a, s, t): return s.join(t.join(map(str, b)) for b in a)
def IF(c, t, f): return t if c else f
def main():
t = I()
rr = []
for _ in range(t):
s = S()
t = []
u = 0
for c in s:
if c == '0':
if u > 0:
t.append(u)
u = 0
else:
u += 1
if u > 0:
t.append(u)
t = sorted(t, reverse=True)
rr.append(sum(t[::2]))
return JA(rr, "\n")
print(main())
| 8 | PYTHON3 |
#include <bits/stdc++.h>
#pragma GCC optimize(3)
using namespace std;
const int maxnn = 4e5 + 7;
const long long mod = 1e9 + 7;
const long long inf = 1e18;
long long fun(long long x1, long long y1, long long x2, long long y2) {
return abs(x1 - x2) + abs(y1 - y2);
}
int check(long long a, long long b, long long c, long long d, long long i,
long long n) {
if ((c * (n - i - 1) - i * d) <= (b - a) &&
(b - a) <= (d * (n - i - 1) - i * c))
return 1;
else
return 0;
}
long long ksm(long long a, long long b) {
long long ans = 1ll;
while (b) {
if (b & 1) ans = (a * ans) % mod;
a = (a * a) % mod;
b >>= 1;
}
return ans % mod;
}
long long C(long long n, long long m) {
if (m == 0ll) return 1ll;
if (n < m) return 0ll;
if (m < 0ll) return 0ll;
if (n == m) return 1ll;
long long ans = 1ll;
for (long long i = 0; i < m; i++) {
ans = ans * (n - i) % mod;
ans = ans * ksm(i + 1ll, mod - 2ll) % mod;
}
return ans % mod;
}
void getnxt(string s) {
int nxt[10];
int j = 0, k = -1;
nxt[0] = -1;
int len = s.size();
while (j < len) {
if (k == -1 || s[j] == s[k]) {
nxt[++j] = ++k;
} else {
k = nxt[k];
}
}
for (int i = 1; i <= len; i++) {
printf("%d %d\n", i, nxt[i]);
}
return;
}
string Manacher(string s) {
long long ans = 0ll;
long long n = (long long)s.size();
ans = (n - 1ll) * n / 2ll;
long long temp = 0ll;
string t = "$#";
for (int i = 0; i < s.size(); i++) {
t += s[i];
t += "#";
}
vector<int> p(t.size(), 0);
int mx = 0, id = 0, reCenter = 0, reLen = 0;
for (int i = 1; i < t.size(); i++) {
p[i] = mx > i ? min(mx - i, p[2 * id - i]) : 1;
while (t[i + p[i]] == t[i - p[i]]) p[i]++;
if (i + p[i] > mx) {
mx = i + p[i];
id = i;
}
if (p[i] > reLen) {
reLen = p[i];
reCenter = i;
}
if (p[i] > 2ll) {
temp += p[i] - 2ll;
printf("%c %d\n", t[i], p[i]);
}
}
ans -= temp;
cout << ans + 1ll << endl;
return s.substr((reCenter - reLen) / 2, reLen - 1);
}
struct jz {
long long a[2][2];
jz() { memset(a, 0ll, sizeof(a)); }
};
jz jzcf(jz x, jz y) {
jz ans;
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2; j++)
for (int k = 0; k < 2; k++)
ans.a[i][j] = (ans.a[i][j] + (x.a[i][k] * y.a[k][j] % mod)) % mod;
return ans;
}
jz jzksm(jz temp, long long b) {
jz ans;
ans.a[0][0] = 1;
while (b) {
if (b & 1) ans = jzcf(ans, temp);
temp = jzcf(temp, temp);
b >>= 1;
}
return ans;
}
struct dy {
int w, xh;
} sz[26];
bool cmp(dy x, dy y) {
if (x.w == y.w) return x.xh < y.xh;
return x.w > y.w;
}
long long f(long long a) {
if (a <= 0) return 0;
if (a % 4 == 3)
return 0;
else {
long long ans = 0;
for (int i = 0; i < a % 4 + 1; i++) ans ^= a - i;
return ans;
}
}
void init() {
char s[3][20] = {"abcdefghi", "jklmnopqr", "stuvwxyz "};
int a[26][26];
int cz[8][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1},
{1, 1}, {1, -1}, {-1, 1}, {-1, -1}};
for (int i = 0; i < 3; i++) {
int xb;
if (i != 2) {
xb = 9;
} else {
xb = 8;
}
for (int j = 0; j < xb; j++) {
for (int k = 0; k < 8; k++) {
int x = i + cz[k][0];
int y = j + cz[k][1];
if (x >= 0 && x < 3 && y >= 0 && y < 9 && s[x][y] >= 'a' &&
s[x][y] <= 'z') {
a[s[i][j] - 'a'][s[x][y] - 'a'] = 1;
}
}
}
}
}
int da = 0;
void bfs(string s, int cnt) {
da = max(da, cnt);
for (int i = 0; i < s.size(); i++) {
if (i - 1 >= 0 && s[i] - s[i - 1] == 1) {
bfs(string(s, 0, i) + string(s, i + 1, s.size() - i - 1), cnt + 1);
} else if (i + 1 < s.size() && s[i + 1] == s[i] - 1) {
bfs(string(s, 0, i) + string(s, i + 1, s.size() - i - 1), cnt + 1);
}
}
}
int nxt[maxnn];
int head[maxnn];
int to[maxnn];
int cnt = 1;
int n, m, k;
void add(int x, int y) {
to[cnt] = y;
nxt[cnt] = head[x];
head[x] = cnt++;
}
int a[maxnn];
int vis[maxnn];
int w[maxnn];
vector<int> szz[maxnn];
void bfs(int t) {
w[t] = 0;
vis[t] = 1;
priority_queue<pair<int, int>> que;
que.push(make_pair(0, t));
while (!que.empty()) {
int p = que.top().second;
int q = que.top().first;
que.pop();
for (int i = head[p]; i; i = nxt[i]) {
if (!vis[to[i]]) {
vis[to[i]] = 1;
w[to[i]] = w[p] + 1;
que.push(make_pair(-w[to[i]], to[i]));
}
if (w[to[i]] == w[p] + 1) {
szz[to[i]].push_back(p);
}
}
}
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d %d", &x, &y);
add(y, x);
}
scanf("%d", &k);
for (int i = 1; i <= k; i++) {
scanf("%d", &a[i]);
}
bfs(a[k]);
int mi = 0;
int mx = 0;
for (int i = 1; i < k; i++) {
int flag = 0;
for (int j = 0; j < szz[a[i]].size(); j++) {
if (szz[a[i]][j] == a[i + 1]) {
flag = 1;
}
}
if (flag == 1 && szz[a[i]].size() > 1) {
mx++;
} else if (flag == 0) {
mi++;
mx++;
}
}
printf("%d %d\n", mi, mx);
return 0;
}
| 8 | CPP |
n,m,a=map(int,input().split())
if n%a==0:
x=int(n/a)
else:
x=int(n/a)+1
if m%a==0:
y=int(m/a)
else:
y=int(m/a)+1
print(x*y)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
inline long long tavan(long long a, long long n, long long mod) {
long long p = 1;
while (n > 0) {
if (n % 2) {
p = p * a;
p %= mod;
}
n >>= 1;
a *= a;
a %= mod;
}
return p % mod;
}
long long r, c, n, m, a[(20)][(20)], ans;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> r >> c >> n >> m;
for (int i = 0; i < n; i++) {
long long x, y;
cin >> x >> y;
a[x][y]++;
}
for (int i = 1; i <= r; i++)
for (int i2 = i; i2 <= r; i2++)
for (int j = 1; j <= c; j++)
for (int j2 = j; j2 <= c; j2++) {
long long cnt = 0;
for (int k = i; k <= i2; k++)
for (int q = j; q <= j2; q++) cnt += a[k][q];
if (cnt >= m) ans++;
}
cout << ans;
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int mod = int(1e9) + 7, INF = 0x3f3f3f3f;
const int maxn = 200;
struct node {
int num, ran, add;
bool operator<(const node &a) const {
return num > a.num || (num == a.num && ran < a.ran);
}
} a[maxn];
int ok(int i, int j) {
node x = a[i], y = a[j], first = x, second = y;
first.num += x.add, second.num += y.add;
if (x < y && second < first) return 1;
if (y < x && first < second) return 1;
if (x < y && y < first && first < second) return 2;
if (y < x && x < second && second < first) return 2;
if (second < first && first < y && y < x) return 2;
if (first < second && second < x && x < y) return 2;
return 0;
}
int main(void) {
int n, ans = 0;
scanf("%d", &n);
for (int i = 1; i <= n; i++)
scanf("%d %d", &a[i].num, &a[i].add), a[i].ran = i;
for (int i = 1; i <= n; i++) {
for (int j = i + 1; j <= n; j++) {
ans += ok(i, j);
}
}
printf("%d\n", ans);
return 0;
}
| 11 | CPP |
#include <cstdio>
#include <climits>
#include <vector>
#include <algorithm>
#define inf INT_MAX/2
using namespace std;
int ok[100][100];
int main() {
int n; scanf("%d",&n);
for (int i=0; i<n; i++) for (int j=0; j<n; j++) ok[i][j]=inf;
for (int i=0; i<n; i++) {
int r,k; scanf("%d%d",&r,&k);
for (int j=0; j<k; j++) {
int t; scanf("%d",&t);
ok[r-1][t-1]=1;
}
}
for (int k=0; k<n; k++) {
for (int i=0; i<n; i++) {
for (int j=0; j<n; j++) {
ok[i][j]=min(ok[i][j],ok[i][k]+ok[k][j]);
}
}
}
int p; scanf("%d",&p);
for (int i=0; i<p; i++) {
int s,d,v; scanf("%d%d%d",&s,&d,&v);
if (v<=ok[s-1][d-1]) puts("NA");
else printf("%d\n",ok[s-1][d-1]+1);
}
} | 0 | CPP |
#include<iostream>
#include<cstring>
using namespace std;
int n, m;
int scene[100][100], pict[50][50];
int x, y;
bool check0(int si, int sj){
bool first = true;
for(int i = 0; i < m; i++){
for(int j = 0; j < m; j++){
if(pict[i][j] == -1) continue;
if(pict[i][j] == scene[si+i][sj+j]){
if(first){
first = false;
x = sj+j; y = si+i;
}
}else{
return false;
}
}
}
return true;
}
bool check90(int si, int sj){
bool first = true;
for(int i = 0; i < m; i++){
for(int j = 0; j < m; j++){
if(pict[m-1-j][i] == -1) continue;
if(pict[m-1-j][i] == scene[si+i][sj+j]){
if(first){
first = false;
x = sj+j; y = si+i;
}
}else{
return false;
}
}
}
return true;
}
bool check180(int si, int sj){
bool first = true;
for(int i = 0; i < m; i++){
for(int j = 0; j < m; j++){
if(pict[m-1-i][m-1-j] == -1) continue;
if(pict[m-1-i][m-1-j] == scene[si+i][sj+j]){
if(first){
first = false;
x = sj+j; y = si+i;
}
}else{
return false;
}
}
}
return true;
}
bool check270(int si, int sj){
bool first = true;
for(int i = 0; i < m; i++){
for(int j = 0; j < m; j++){
if(pict[j][m-1-i] == -1) continue;
if(pict[j][m-1-i] == scene[si+i][sj+j]){
if(first){
first = false;
x = sj+j; y = si+i;
}
}else{
return false;
}
}
}
return true;
}
int main(){
while(1){
cin >> n >> m;
if(n+m == 0) break;
memset(scene, -1, sizeof(scene));
memset(pict, -1, sizeof(pict));
for(int i = 0; i < n; i++){
for(int j = 0; j < n; j++){
cin >> scene[i][j];
}
}
for(int i = 0; i < m; i++){
for(int j = 0; j < m; j++){
cin >> pict[i][j];
}
}
bool cont = true;
// for(int i = 0; i < m; i++){
// for(int j = 0; j < m; j++){
// cout << pict[m-1-i][m-1-j] << " ";
// }
// cout << endl;
// }
for(int i = 0; i <= n-m && cont; i++){
for(int j = 0; j <= n-m && cont; j++){
if(check0(i,j)){
cout << x+1 << " " << y+1 << endl;
cont = false;
break;
}
if(check90(i,j)){
cout << x+1 << " " << y+1 << endl;
cont = false;
break;
}
if(check180(i,j)){
cout << x+1 << " " << y+1 << endl;
cont = false;
break;
}
if(check270(i,j)){
cout << x+1 << " " << y+1 << endl;
cont = false;
break;
}
}
}
if(cont) cout << "NA" << endl;
}
return 0;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio();
cin.tie();
cout.tie();
;
long long t, n, m, i, j, a, cnt;
cin >> t;
while (t != 0) {
vector<pair<long long, long long>> ara, ara1;
cin >> n;
cnt = 0;
long long e1 = 0, e2 = 0, o1 = 0, o2 = 0;
for (i = 0; i < n; i++) {
cin >> a;
ara.push_back({a, 0});
if (a % 2 == 0) {
e1++;
} else {
o1++;
}
}
cin >> m;
for (i = 0; i < m; i++) {
cin >> a;
ara1.push_back({a, 0});
if (a % 2 == 0) {
e2++;
} else {
o2++;
}
}
cnt = e1 * e2 + o1 * o2;
cout << cnt << endl;
t--;
}
return 0;
}
| 7 | CPP |
n = int(input())
A = list(map(int, input().split()))
r = 0
for i in range(n):
if A[i]%2==0:
r+=1
print(3**n-2**r) | 0 | PYTHON3 |
import sys
import math
from collections import defaultdict
# sys.stdin = open('input.txt', 'r')
# sys.stdout = open('output.txt', 'w')
def solve(test):
s = list(input())
n = len(s)
rec = set(s)
char = {'1': 0, '2': 0, '3': 0}
if not ('1' in rec and '2' in rec and '3' in rec):
print(0)
return
start, end = 0, 0
ans = sys.maxsize
while end <= n:
flag = 1
for c in char:
if char[c] < 1:
flag = 0
break
if flag:
ans = min(ans, end - start)
char[s[start]] -= 1
start += 1
else:
if end == n:
break
char[s[end]] += 1
end += 1
flag = 0
print(ans)
if __name__ == "__main__":
test_cases = int(input())
for t in range(1, test_cases + 1):
solve(t)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
bool m1;
FILE *Input = stdin, *Output = stdout;
const int maxn = 1e5 + 5;
struct Edge {
int to, next;
Edge(){};
Edge(int ar1, int ar2) {
to = ar1;
next = ar2;
}
} Tree_List[maxn << 1], Tree2_List[maxn << 2];
int Numt[maxn], tott, deg[maxn], totn;
int Numt2[maxn << 1], tott2, size[maxn << 1], Max_Len2;
int Start_Mark, End_Mark, All_Mark[maxn << 1];
int Start, End, All[maxn << 1], Max_Len, next[maxn];
bool Found, onLine[maxn << 1], Mark[maxn << 1];
bool m2;
void Add_Tree(int ar1, int ar2) {
Tree_List[++tott] = Edge(ar2, Numt[ar1]);
Numt[ar1] = tott;
}
void Add_Tree2(int ar1, int ar2) {
Tree2_List[++tott2] = Edge(ar2, Numt2[ar1]);
Numt2[ar1] = tott2;
}
void Get_next(int ar1, int ar2) {
next[ar1] = ar1;
for (int i = Numt[ar1]; i; i = Tree_List[i].next) {
int hh = Tree_List[i].to;
if (hh == ar2) continue;
Get_next(hh, ar1);
if (deg[ar1] == 2) next[ar1] = next[hh];
}
}
void Link(int ar1, int ar2) {
for (int i = Numt[ar1]; i; i = Tree_List[i].next) {
int hh = Tree_List[i].to;
if (hh == ar2 || next[hh] == ar1) continue;
if (deg[next[hh]] == 1 || deg[ar1] == 1) {
Add_Tree2(ar1, next[hh]);
Add_Tree2(next[hh], ar1);
Link(next[hh], ar1);
} else {
Add_Tree2(ar1, hh);
Add_Tree2(hh, ar1);
Link(hh, ar1);
}
}
}
void Get_One_Mark(int ar1, int ar2, int ar3) {
if (Mark[ar1] && ar3 > Max_Len) {
Start_Mark = ar1;
Max_Len = ar3;
}
for (int i = Numt2[ar1]; i; i = Tree2_List[i].next) {
int hh = Tree2_List[i].to;
if (hh == ar2) continue;
Get_One_Mark(hh, ar1, ar3 + 1);
}
}
void Get_the_Other_Mark(int ar1, int ar2, int ar3) {
if (Mark[ar1] && ar3 > Max_Len) {
End_Mark = ar1;
Max_Len = ar3;
}
for (int i = Numt2[ar1]; i; i = Tree2_List[i].next) {
int hh = Tree2_List[i].to;
if (hh == ar2) continue;
Get_the_Other_Mark(hh, ar1, ar3 + 1);
}
}
void Get_One(int ar1, int ar2, int ar3) {
if (ar3 > Max_Len) {
Start = ar1;
Max_Len = ar3;
}
for (int i = Numt2[ar1]; i; i = Tree2_List[i].next) {
int hh = Tree2_List[i].to;
if (hh == ar2) continue;
Get_One(hh, ar1, ar3 + 1);
}
}
void Get_the_Other(int ar1, int ar2, int ar3) {
if (ar3 > Max_Len) {
End = ar1;
Max_Len = ar3;
}
for (int i = Numt2[ar1]; i; i = Tree2_List[i].next) {
int hh = Tree2_List[i].to;
if (hh == ar2) continue;
Get_the_Other(hh, ar1, ar3 + 1);
}
}
void Get_All(int ar1, int ar2, int ar3) {
All[++All[0]] = ar1;
if (ar1 == ar3) {
Found = 1;
return;
}
for (int i = Numt2[ar1]; i; i = Tree2_List[i].next) {
int hh = Tree2_List[i].to;
if (hh == ar2) continue;
Get_All(hh, ar1, ar3);
if (Found) return;
}
All[0]--;
}
void Get_All_Mark(int ar1, int ar2, int ar3) {
if (Mark[ar1]) All[++All[0]] = ar1;
if (ar1 == ar3) {
Found = 1;
return;
}
for (int i = Numt2[ar1]; i; i = Tree2_List[i].next) {
int hh = Tree2_List[i].to;
if (hh == ar2) continue;
Get_All_Mark(hh, ar1, ar3);
if (Found) return;
}
if (Mark[ar1]) All[0]--;
}
void Get_Two(int ar1, int ar2, int ar3) {
if (ar3 > Max_Len) {
Max_Len2 = Max_Len;
End = Start;
Max_Len = ar3;
Start = ar1;
} else if (ar3 > Max_Len2) {
Max_Len2 = ar3;
End = ar1;
}
for (int i = Numt2[ar1]; i; i = Tree2_List[i].next) {
int hh = Tree2_List[i].to;
if (hh == ar2) continue;
Get_Two(hh, ar1, ar3 + 1);
}
}
void Get_size(int ar1, int ar2) {
size[ar1] = 1;
for (int i = Numt2[ar1]; i; i = Tree2_List[i].next) {
int hh = Tree2_List[i].to;
if (hh == ar2) continue;
Get_size(hh, ar1);
size[ar1] += size[hh];
}
}
int main() {
int n;
while (fscanf(Input, "%d", &n) == 1) {
memset(Numt, 0, sizeof(Numt));
memset(Numt2, 0, sizeof(Numt2));
memset(deg, 0, sizeof(deg));
memset(Mark, 0, sizeof(Mark));
memset(onLine, 0, sizeof(onLine));
tott = 0;
totn = n;
tott2 = 0;
for (int i = 1; i < n; i++) {
int h1, h2;
fscanf(Input, "%d %d", &h1, &h2);
Add_Tree(h1, h2);
Add_Tree(h2, h1);
deg[h1]++;
deg[h2]++;
}
int Root = 1;
while (Root <= n && deg[Root] == 2) Root++;
if (Root > n) abort();
Get_next(Root, 0);
Link(Root, 0);
bool Could = 1;
Max_Len = 0;
Get_One(Root, 0, 0);
Max_Len = 0;
Get_the_Other(Start, 0, 0);
Found = All[0] = 0;
Get_All(Start, 0, End);
for (int i = 1; i <= All[0]; i++) onLine[All[i]] = 1;
for (int i = 1; i <= All[0]; i++) {
bool flag = 0;
for (int j = Numt2[All[i]]; j; j = Tree2_List[j].next) {
int hh = Tree2_List[j].to;
if (onLine[hh]) continue;
Get_size(hh, All[i]);
if (size[hh] > 3) {
flag = 1;
break;
}
if (size[hh] == 2) abort();
}
if (flag) {
Could = 0;
break;
}
}
if (Could)
fprintf(Output, "Yes\n");
else
fprintf(Output, "No\n");
}
fclose(Input);
fclose(Output);
return 0;
}
| 9 | CPP |
t=int(input())
while t>0:
n=int(input())
a=[]
ans=True
for i in range(n):
a.append(input())
for i in range(n-1):
for j in range(n-1):
if a[i][j]=='1' and a[i+1][j]=='0' and a[i][j+1]=='0':
ans=False
if ans:
print("YES")
else:
print("NO")
t-=1 | 11 | PYTHON3 |
#!/usr/bin/env python
# coding: utf-8
# In[8]:
x=int(input())
y=(list(map(int,input().split())))
d=(max(y)-min(y))+1
print(d-x)
# In[ ]:
# In[ ]:
1
| 7 | PYTHON3 |
import sys
from collections import defaultdict
readline = sys.stdin.buffer.readline
#sys.setrecursionlimit(10**8)
def geta(fn=lambda s: s.decode()):
return map(fn, readline().split())
def gete(fn=lambda s: s.decode()):
return fn(readline().rstrip())
def main():
for _ in range(gete(int)):
n = gete(int)
b, ans = 1, 0
while b <= n:
ans += n // b
b *= 2
print(ans)
if __name__ == "__main__":
main() | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int kN = 2e5 + 10;
int n;
vector<int> g[kN];
int sz[kN], mx[kN];
int pos[kN];
vector<int> point[kN];
long long ans = 0;
bool flag;
void Dfs(int u, int fa = -1, int top = -1) {
sz[u] = 1, mx[u] = 0;
if (top != -1 && !flag) point[top].push_back(u);
for (int v : g[u])
if (v != fa) {
Dfs(v, u, top == -1 ? v : top);
sz[u] += sz[v], mx[u] = max(mx[u], sz[v]);
if (flag) ans += min(sz[v], n - sz[v]) * 2;
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
g[x].push_back(y), g[y].push_back(x);
}
if (n == 2) {
printf("2\n2 1\n");
return 0;
}
if (n == 3) {
int cen = -1;
for (int i = 1; i <= 3; i++)
if (g[i].size() != 1) cen = i;
for (int i = 1; i <= n; i++) pos[i] = i;
for (int i = 1; i <= 3; i++)
if (i != cen) swap(pos[i], pos[cen]);
printf("4\n");
for (int i = 1; i <= 3; i++) printf("%d ", pos[i]);
puts("");
return 0;
}
flag = 1;
Dfs(1);
flag = 0;
int cen = -1;
for (int i = 1; i <= n; i++) {
if (max(mx[i], n - sz[i]) * 2 <= n) cen = i;
}
Dfs(cen);
vector<pair<int, int>> son;
for (int v : g[cen]) son.emplace_back(int(point[v].size()), v);
sort(son.begin(), son.end());
for (int i = 1; i <= n; i++) pos[i] = i;
int v = son.back().second;
swap(pos[cen], pos[point[v].back()]);
point[v].pop_back();
priority_queue<pair<int, int>> pq;
for (int v : g[cen])
if (!point[v].empty()) pq.emplace(int(point[v].size()), v);
while (true) {
if (pq.top().first == 1 && int(pq.size()) <= 3) break;
auto p = pq.top().second;
pq.pop();
auto q = pq.top().second;
pq.pop();
int x = point[p].back(), y = point[q].back();
swap(pos[x], pos[y]);
point[p].pop_back(), point[q].pop_back();
if (!point[p].empty()) pq.emplace(int(point[p].size()), p);
if (!point[q].empty()) pq.emplace(int(point[q].size()), q);
}
vector<int> tmp;
while (!pq.empty()) {
auto p = pq.top().second;
pq.pop();
int x = point[p][0];
point[p].pop_back();
tmp.push_back(x);
}
if (int(tmp.size()) == 1) {
swap(pos[cen], pos[tmp[0]]);
} else {
int cur = pos[tmp[0]];
for (int i = 1; i < int(tmp.size()); i++) {
int t = pos[tmp[i]];
pos[tmp[i]] = cur;
cur = t;
}
pos[tmp[0]] = cur;
}
printf("%lld\n", ans);
for (int i = 1; i <= n; i++) printf("%d ", pos[i]);
puts("");
return 0;
}
| 8 | CPP |
# Aizu Problem 0016: Treasure Hunt
#
import sys, math, os
# read input:
PYDEV = os.environ.get('PYDEV')
if PYDEV=="True":
sys.stdin = open("sample-input.txt", "rt")
x, y = 0, 0
direction = 90
while True:
d, t = [int(_) for _ in input().split(',')]
if d == t == 0:
break
angle = direction * math.pi / 180
x += d * math.cos(angle)
y += d * math.sin(angle)
direction = (direction - t) % 360
print(int(x))
print(int(y)) | 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000;
const double eps = 1e-9;
long long INF = 1e9 + 7;
bool comp(pair<int, double> a, pair<int, double> b) {
if (a.second > b.second)
return true;
else if (a.second < b.second)
return false;
else
return a.first < b.first;
}
struct compare {
bool operator()(const int& l, const int& r) { return l > r; }
};
void read(string str, int node) {
stringstream ss;
int number;
ss << str;
while (ss >> number) cout << number << endl;
}
int dx[] = {1, -1, 0, 0, 1, -1, 1, -1};
int dy[] = {0, 0, 1, -1, 1, -1, -1, 1};
long long fp(long long b, long long p) {
if (p == 0) return 1;
if (p % 2 == 0) return fp((b * b) % INF, p / 2);
return (fp(b, p - 1) * b) % INF;
}
long long read_binary(string s) {
unsigned long long x = 0, tmp = 1;
for (int i = s.size() - 1; i >= 0; i--) {
x = (x + tmp * (s[i] - '0')) % INF;
tmp = (tmp * 2) % INF;
}
return x;
}
long long com(long long x, long long y) {
long long sum = 1;
for (int i = 1; i <= y; i++) {
sum *= x;
x--;
sum /= i;
}
return sum;
}
int main() {
long long n, k;
cin >> n >> k;
vector<long long> a(n + 1);
for (int i = 1; i <= n; i++) cin >> a[i];
partial_sum(a.begin(), a.end(), a.begin());
vector<unsigned long long> seg;
for (int i = k; i <= n; i++) seg.push_back(a[i] - a[i - k]);
unsigned long long sum = 0, csu = 0;
int l = -1, r = -1, c = -1;
for (int i = k, j = 0; i < seg.size(); i++, j++) {
if (seg[j] > sum) c = j, sum = seg[j];
if (csu < (sum + seg[i])) {
csu = sum + seg[i];
l = c;
r = i;
}
}
cout << ++l << ' ' << ++r << endl;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long MOD = 1e9 + 7;
long long MAX = 1e17;
int main() {
int n;
cin >> n;
long long a, b;
for (int i = 0; i < n; ++i) {
scanf("%I64d%I64d", &a, &b);
long long x = a * b;
if (a == 1 and b == 1) {
cout << "Yes"
<< "\n";
;
continue;
}
long long y = cbrtl(x);
if (y * (y * y) != x) {
cout << "No"
<< "\n";
;
continue;
}
if (a % y == 0 and b % y == 0) {
cout << "Yes"
<< "\n";
;
} else {
cout << "No"
<< "\n";
;
}
}
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e6 + 3;
int n, a[N];
void init() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
}
int cnt[N];
void solve() {
fill_n(cnt, n + 1, 0);
for (int i = 0; i < n; i++) {
cnt[a[i]]++;
}
vector<int> freq;
for (int i = 0; i <= n; i++) {
if (cnt[i]) {
freq.push_back(cnt[i]);
}
}
sort(freq.begin(), freq.end());
int pages, spaces, ans;
bool fail;
for (int sz = freq[0] + 1; sz > 1; sz--) {
fail = false;
ans = 0;
for (int f : freq) {
pages = (f + sz - 1) / sz;
spaces = pages * sz - f;
if (spaces > pages) {
fail = true;
break;
}
ans += pages;
}
if (fail) continue;
printf("%d\n", ans);
return;
}
printf("%d\n", n);
}
int main() {
int t;
scanf("%d", &t);
while (t--) {
init();
solve();
}
return 0;
}
| 16 | CPP |
#include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#include <cfloat>
using std::cerr;
using std::cin;
using std::cout;
using std::endl;
int main(void){
cout << std::fixed << std::setprecision(16);
cin.tie(0);
std::ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
std::vector<int> a(m);
for (auto &e: a) cin >> e;
std::vector<bool> used(n+1, false);
for (int i = m-1; i >= 0; i--) {
if (!used[a[i]]) {
cout << a[i] << endl;
used[a[i]] = true;
}
}
for (int i = 1; i <= n; ++i) {
if (!used[i]) {
cout << i << endl;
}
}
return 0;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct record {
long long x, y;
bool operator<(const record &b) const { return x == b.x ? y > b.y : x < b.x; }
record() {}
record(long long _x, long long _y) {
x = _x;
y = _y;
}
};
vector<long long> p[10010];
long long a[100010];
long long c[100010];
long long d[10010];
priority_queue<record> q;
long long newk[100010];
long long cnt = 0;
long long h, n, m, k;
bool cmp(long long i, long long j) { return a[i] < a[j]; }
void spfa() {
queue<long long> bfs;
bool flag[10010];
for (long long i = 0; i < k; i++)
if (d[i] < 1e18 + 100) {
bfs.push(i);
flag[i] = true;
} else
flag[i] = false;
while (!bfs.empty()) {
long long now = bfs.front();
bfs.pop();
flag[now] = false;
for (long long i = 0; i < cnt; i++) {
long long next = d[now] + newk[i];
long long y = next % k;
if (next < d[y]) {
d[y] = next;
if (!flag[y]) {
bfs.push(y);
flag[y] = true;
}
}
}
}
for (long long i = 0; i < k; i++)
while (p[i].size() > 0 && a[p[i][p[i].size() - 1]] >= d[i]) {
q.push(record(c[p[i][p[i].size() - 1]], p[i][p[i].size() - 1]));
p[i].pop_back();
}
}
int main() {
cin >> h >> n >> m >> k;
for (long long i = 0; i < n; i++) {
cin >> a[i] >> c[i];
a[i]--;
p[a[i] % k].push_back(i);
}
for (long long i = 0; i < k; i++) {
sort(p[i].begin(), p[i].end(), cmp);
d[i] = 1e18 + 100;
}
d[0] = 0;
spfa();
while (m--) {
long long op;
cin >> op;
if (op == 1) {
cin >> newk[cnt++];
spfa();
} else if (op == 2) {
long long x, y;
cin >> x >> y;
x--;
c[x] -= y;
if (d[a[x] % k] <= a[x]) q.push(record(c[x], x));
} else if (op == 3) {
while (!q.empty() && q.top().x != c[q.top().y]) q.pop();
if (!q.empty()) {
cout << q.top().x << endl;
c[q.top().y] = 0;
q.pop();
} else
cout << 0 << endl;
}
}
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
class FortunateNumbers {
public:
void getFortunate() {
int i = 0, j = 0, k = 1, count = 0, n;
char c;
c = 'a';
char a[100000];
cin >> n;
while (1) {
cout << c;
a[i] = c;
c++;
i = i + 1;
k = k + 1;
count = count + 1;
if (k >= 5) {
c = a[j];
j = j + 1;
}
if (count == n) {
break;
}
}
}
};
int main() {
FortunateNumbers a1;
a1.getFortunate();
return 0;
}
| 8 | CPP |
n = int(input())
x = 0
for i in range(n):
s = input()
if '+' in s:
x += 1
if '-' in s:
x -= 1
print(x)
| 7 | PYTHON3 |
#Code by Sounak, IIESTS
#------------------------------warmup----------------------------
import os
import sys
import math
from io import BytesIO, IOBase
from fractions import Fraction
from collections import defaultdict
from itertools import permutations
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
#-------------------game starts now-----------------------------------------------------
f, s, fs, sf = map(int, input().split(' '))
if sf - fs == 1 and f - sf + 1 > 0 and s - sf + 1 > 0: # 7444...444474747474...7777...7774
r = ['7', '4'] * sf
r[1] = '4' * (f - sf + 1)
r[-2] = '7' * (s - sf + 1)
print(''.join(r))
elif sf == fs and f - sf > 0 and s - sf + 1 > 0: # 444...44474747474777...7774
r = ['4', '7'] * sf + ['4']
r[0] = '4' * (f - (sf + 1) + 1)
r[-2] = '7' * (s - sf + 1)
print(''.join(r))
elif fs - sf == 1 and f - fs + 1 > 0 and s - fs + 1 > 0: # 444...444747474777...777
r = ['4', '7'] * fs
r[0] = '4' * (f - fs + 1)
r[-1] = '7' * (s - fs + 1)
print(''.join(r))
elif f == fs == sf and s - f > 0: # 747474777...777
print('74' * f + '7' * (s - f))
else:
print(-1) | 8 | PYTHON3 |
users_tracker, servr_answer = {}, ''
for i in range(int(input())):
name = input()
if name in users_tracker:
server_answer = name + str(users_tracker[name])
else:
server_answer = 'OK'
print(server_answer)
users_tracker[name] = users_tracker.get(name, 0) + 1
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
set<pair<long long, long long> > Set;
vector<long long> v[120001];
string s[3];
long long a[120001], pref[120001], n, m, i, x, y, k, t, zn;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m >> k >> t;
for (i = 1; i <= n; i++) a[i] = m;
for (i = 1; i <= k; i++) {
cin >> x >> y;
Set.insert(make_pair(x, y));
a[x]--;
v[x].push_back(y);
}
for (i = 1; i <= n; i++) pref[i] = pref[i - 1] + a[i];
s[0] = "Grapes";
s[1] = "Carrots";
s[2] = "Kiwis";
while (t--) {
cin >> x >> y;
if (Set.find(make_pair(x, y)) != Set.end()) {
cout << "Waste" << '\n';
continue;
}
zn = pref[x - 1];
zn += y;
for (i = 0; i < v[x].size(); i++)
if (v[x][i] < y) zn--;
cout << s[zn % 3] << '\n';
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
map<int, vector<pair<int, int> > > m;
set<pair<long long, int> > best[N];
int n, c, s;
long long best_stack;
int glob_a_part, glob_b_part, glob_a_col, glob_b_col;
void try_it(int a_part, int i, int b_part, int j) {
if (best[a_part].size() >= (i + 1) && best[b_part].size() >= (j + 1)) {
set<pair<long long, int> >::reverse_iterator q1 = best[a_part].rbegin(),
q2 = best[b_part].rbegin();
if (i) q1++;
if (j) q2++;
int col_a = q1->second, col_b = q2->second;
if (col_a == col_b) {
if (!i) try_it(a_part, i + 1, b_part, j);
if (!j) try_it(a_part, i, b_part, j + 1);
} else {
long long total_height = q1->first + q2->first;
if (total_height > best_stack) {
best_stack = total_height;
glob_a_part = a_part;
glob_b_part = b_part;
glob_a_col = col_a;
glob_b_col = col_b;
}
}
}
}
int main() {
best_stack = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> c >> s;
m[c].push_back(make_pair(-s, i + 1));
}
for (map<int, vector<pair<int, int> > >::iterator q = m.begin(); q != m.end();
q++) {
sort(q->second.begin(), q->second.end());
vector<pair<int, int> > v = q->second;
long long sum = 0;
for (int i = 0; i < v.size(); i++) {
sum += -v[i].first;
best[i + 1].insert(make_pair(sum, q->first));
}
}
for (int i = 2; i <= n; i++) {
int a_part = i / 2, b_part = i / 2 + (i % 2);
try_it(a_part, 0, b_part, 0);
}
cout << best_stack << endl << glob_a_part + glob_b_part << endl;
for (int i = 0; i < glob_a_part + glob_b_part; i++) {
if (glob_a_part > glob_b_part != (i % 2))
cout << m[glob_a_col][i / 2].second;
else
cout << m[glob_b_col][i / 2].second;
if (i + 1 != glob_a_part + glob_b_part) cout << " ";
}
}
| 11 | CPP |
Subsets and Splits