solution
stringlengths 10
159k
| difficulty
int64 0
3.5k
| language
stringclasses 2
values |
|---|---|---|
R=lambda:map(int,input().split())
q,=R()
for _ in[0]*q:input();a=sorted(R());print(3-min(y-x
for x,y in zip([a[0]-2]+a,a)))
| 800 |
PYTHON3
|
n=int(input())
arr=[int(x) for x in input().split()]
ans=''
i=0
j=n-1
last=0
while i<=j:
#print(ans)
if arr[i]>last and arr[j]>last:
if arr[i]>arr[j]:
ans+='R'
last=arr[j]
j-=1
elif arr[j]>arr[i]:
ans+='L'
last=arr[i]
i+=1
else:
a1=1
a2=1
while i+a1<=j and arr[i+a1]>arr[i+a1-1]:
a1+=1
while j-a2>=i and arr[j-a2+1]<arr[j-a2]:
a2+=1
#print(a1,a2)
if a1>a2:
ans+='L'*a1
break
else:
ans+='R'*a2
break
elif arr[i]>last:
ans+='L'
last=arr[i]
i+=1
elif arr[j]>last:
ans+='R'
last=arr[j]
j-=1
else:
break
print(len(ans))
print(ans)
| 1,300 |
PYTHON3
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
long long n, m;
long long dp[2][3010][3010];
char maze[3010][3010];
int main() {
scanf("%lld%lld", &n, &m);
memset(dp, 0, sizeof(dp));
for (int i = 1; i <= n; i++) {
scanf("%s", maze[i] + 1);
}
dp[0][1][2] = 1;
if (maze[1][2] == '#') dp[0][1][2] = 0;
for (int i = 1; i <= n; i++) {
for (int j = 2; j <= m; j++) {
if (i == 1 && j == 2) continue;
if (j == 2) {
dp[0][i][j] = dp[0][i - 1][j];
} else if (i == 1) {
dp[0][i][j] = dp[0][i][j - 1];
} else {
dp[0][i][j] = (dp[0][i][j - 1] + dp[0][i - 1][j]) % mod;
}
if (maze[i][j] == '#') {
dp[0][i][j] = 0;
}
}
}
dp[1][2][1] = 1;
if (maze[2][1] == '#') dp[1][2][1] = 0;
for (int i = 2; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (i == 2 && j == 1) continue;
if (j == 1) {
dp[1][i][j] = dp[1][i - 1][j];
} else if (i == 2) {
dp[1][i][j] = dp[1][i][j - 1];
} else {
dp[1][i][j] = (dp[1][i][j - 1] + dp[1][i - 1][j]) % mod;
}
if (maze[i][j] == '#') {
dp[1][i][j] = 0;
;
;
;
;
;
}
}
}
long long fans = dp[0][n - 1][m] * dp[1][n][m - 1] % mod -
dp[0][n][m - 1] * dp[1][n - 1][m] % mod;
fans %= mod;
fans += mod;
fans %= mod;
printf("%lld\n", fans);
return 0;
}
| 2,500 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
set<long long> gera_primos(long long n) {
set<long long> primos;
vector<bool> crivo(n + 1);
primos.insert(2);
for (long long i = 3; i <= n; i += 2) {
if (crivo[i]) continue;
primos.insert(i);
for (long long j = i; j <= n; j += i) {
crivo[j] = true;
}
}
return primos;
}
struct Link {
long long from, to, cost;
};
struct Node {
bool visitado = false;
bool cor = false;
vector<long long> in, out;
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, m;
cin >> n >> m;
vector<string> a(n);
for (auto &x : a) cin >> x;
vector<long long> d(n);
long long soma = 0;
for (long long i = 0; i < (long long)n; i++) {
long long l, r;
for (long long j = 0; j < (long long)m; j++) {
if (a[i][j] == 'G') l = j;
if (a[i][j] == 'S') r = j;
}
long long dif = r - l;
soma += dif;
if (dif < 0) {
puts("-1");
return 0;
}
d[i] = dif;
}
long long total = 0;
while (soma > 0) {
long long minimo = (long long)1e18;
for (long long i = 0; i < (long long)n; i++) {
minimo = min(minimo, d[i]);
}
for (long long i = 0; i < (long long)n; i++) {
if (d[i] < (long long)1e18) {
d[i] -= minimo;
soma -= minimo;
}
if (d[i] == 0) d[i] = (long long)1e18;
}
total++;
}
cout << total << "\n";
}
| 1,200 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
long long int pw(long long int a, long long int b, long long int mod) {
if (!b) return 1;
if (b & 1) return a * pw(a * a % mod, b / 2, mod) % mod;
return pw(a * a % mod, b / 2, mod) % mod;
}
const long long int MAXN = 300 + 10;
const long long int INF = 8e18;
const long long int MOD = 1e9 + 7;
int m, t, r, _mark[4 * MAXN], *mark = _mark + 2 * MAXN, w[MAXN], ans;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cin >> m >> t >> r;
for (long long int i = 0; i < m; i++) {
cin >> w[i];
}
sort(w, w + m);
for (int i = 0; i < m; i++) {
int cnt = 0;
for (int j = w[i]; j > w[i] - t; j--) cnt += mark[j];
if (cnt >= r) continue;
for (int j = w[i]; cnt < r && j > w[i] - t; j--)
if (!mark[j]) {
mark[j] = 1;
ans++, cnt++;
}
if (cnt < r) return cout << -1 << '\n', 0;
}
cout << ans << '\n';
return 0;
}
| 1,600 |
CPP
|
"""
Author: guiferviz
Time: 2020-01-29 20:26:47
"""
import bisect
def solve_slow():
s = input()
t = input()
t_i = 0
last_add = -1
add = 0
while add != last_add and t_i < len(t):
last_add = add
addition = False
for s_i in s:
if s_i == t[t_i]:
addition = True
t_i += 1
if t_i >= len(t):
break
if addition:
add += 1
if add == last_add:
print(-1)
else:
print(add)
def to_n(c):
return ord(c) - ord('a')
def search(l, x):
'Locate the leftmost value exactly equal to x'
i = bisect.bisect_left(l, x)
if i != len(l) and l[i] == x:
return i
raise -1
def solve():
s = input()
t = input()
# Create an index in which we store where can you find the letters in s.
idx = []
for i in range(26):
idx.append([])
for i, s_v in enumerate(s):
idx[to_n(s_v)].append(i)
# Search for a solution.
sol = 1
cur = 0
for t_i in t:
# Get positions of t_i in s.
l = idx[to_n(t_i)]
# If there are not occurencies of t_i in s, no solution is possible.
if len(l) == 0:
sol = -1
break
# Search for the next ocurrence in s if we are in cur in s.
b = bisect.bisect_left(l, cur)
if b == len(l) and l[b-1] < cur:
sol += 1
cur = l[0]
elif b == len(l) and l[b-1] >= cur:
cur = l[b-1]
else:
cur = l[b]
cur += 1
print(sol)
def main():
t = int(input())
for _ in range(t):
solve()
if __name__ == "__main__":
main()
| 1,600 |
PYTHON3
|
def read():
return [int(c) for c in input().split()]
def main():
n, k = read()
soldiers = read()
ranks = [0] * 101
for s in soldiers:
ranks[s] += 1
ans = 0
while ranks[k] < n:
inc, dec = [], []
for i in range(k):
if ranks[i] > 0:
inc.append(i+1)
dec.append(i)
for i in inc:
ranks[i] += 1
for i in dec:
ranks[i] -= 1
ans += 1
print(ans)
if __name__ == "__main__":
main()
| 1,200 |
PYTHON3
|
from sys import stdin,stdout
nmbr = lambda: int(stdin.readline())
lst = lambda: list(map(int,stdin.readline().split()))
for _ in range(1):#nmbr()):
n,m,k=lst()
f=0
a=sorted(lst(),reverse=1)
b=sorted(lst(),reverse=1)
p=p1=0
while p<n and p1<m:
if a[p]>b[p1]:
f=1
break
p+=1
p1+=1
if p<n and p1>=m:
f=1
print('YES' if f else 'NO')
| 1,600 |
PYTHON3
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 10, mod = 1e9 + 7;
const long long inf = 1e18;
int a[maxn], arr[maxn];
pair<int, int> p[maxn];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie();
int q;
cin >> q;
while (q--) {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
arr[i] = a[i];
}
sort(arr, arr + n);
int C = unique(arr, arr + n) - arr;
for (int i = 0; i < C; i++) {
p[i].second = -1;
}
for (int i = 0; i < n; i++) {
a[i] = lower_bound(arr, arr + C, a[i]) - arr;
if (p[a[i]].second == -1) p[a[i]].first = i;
p[a[i]].second = i;
}
int ans = 0;
for (int l = 0, r = 0; l < C; l = r + 1) {
r = l;
while (r < C - 1 && p[r].second < p[r + 1].first) r++;
ans = max(ans, r - l + 1);
}
cout << C - ans << "\n";
}
return 0;
}
| 2,000 |
CPP
|
def maxel(a,b,c):
max = a
if max <= b:
max = b
if max <= c:
max = c
return max
t = int(input())
bo = []
i = 0
while i < t:
bo.append("NO")
i += 1
i = 0
while i < t:
a,b,c,n = input().split()
a = int(a)
b = int(b)
c = int(c)
n = int(n)
sum = 0
m = max(a,b,c)
sum += (m-a)
sum += (m-b)
sum += (m-c)
if sum <= n:
n -= sum
if n % 3 == 0:
bo[i] = "YES"
i += 1
for q in bo:
print(q)
| 800 |
PYTHON3
|
n = int(input())
s = input()
k1, k0 = 0, 0
a = 0
for i in range(n):
if s[i] == '0':
a = a * 10 + k1
k1 = 0
else:
k1 += 1
else:
a = a * 10 + k1
print(a)
| 1,100 |
PYTHON3
|
import math
n,k=map(int,input().split())
r=n*2
g=n*5
b=n*8
t=math.ceil(r/k)+math.ceil(g/k)+math.ceil(b/k)
print(t)
| 800 |
PYTHON3
|
#include <bits/stdc++.h>
using namespace std;
struct UnionFind {
vector<int> data;
UnionFind(int size) : data(size, -1) {}
bool unionSet(int x, int y) {
x = root(x);
y = root(y);
if (x != y) {
if (data[y] < data[x]) swap(x, y);
data[x] += data[y];
data[y] = x;
}
return x != y;
}
bool findSet(int x, int y) { return root(x) == root(y); }
int root(int x) { return data[x] < 0 ? x : data[x] = root(data[x]); }
int size(int x) { return -data[root(x)]; }
};
struct Edge {
int src;
int dst;
int cost;
int id;
};
class Compare {
public:
bool operator()(const Edge& l, const Edge& r) { return l.cost > r.cost; }
};
vector<int> mst(vector<vector<Edge>>& g, int num) {
priority_queue<Edge, vector<Edge>, Compare> que;
vector<int> v(num);
for (auto es : g) {
for (auto e : es) {
que.push(e);
}
}
UnionFind uf(g.size());
while (!que.empty()) {
auto atop(que.top());
que.pop();
if (uf.root(atop.src) != uf.root(atop.dst)) {
v[atop.id] = true;
uf.unionSet(atop.src, atop.dst);
}
}
return v;
}
long long int INI = 0;
class Tree {
public:
Tree(int V, int root)
: V(V),
root(root),
cnum(V),
place(V),
id(V),
T(V),
parent(MAXLOGV, vector<int>(V)),
depth(V),
ws(MAXLOGV, vector<int>(V, 1e9 + 2)) {}
void init() {
dfs(root, 0, 0, 0, -1);
int id = 0;
getid(root, 0, id);
}
void unite(Edge& e) {
T[e.src].push_back(Edge{e.src, e.dst, e.cost, e.id});
T[e.dst].push_back(Edge{e.dst, e.src, e.cost, e.id});
}
int connect(const int& l, const int& r) const { return max(l, r); }
pair<int, int> lca(int u, int v) const {
if (depth[u] > depth[v]) swap(u, v);
int ans = -10000;
for (int k = 0; k < MAXLOGV; k++) {
if ((depth[v] - depth[u]) >> k & 1) {
ans = connect(ans, ws[k][v]);
v = parent[k][v];
}
}
if (u == v) return make_pair(u, ans);
for (int k = MAXLOGV - 1; k >= 0; k--) {
if (parent[k][u] != parent[k][v]) {
ans = connect(ans, ws[k][u]);
ans = connect(ans, ws[k][v]);
u = parent[k][u];
v = parent[k][v];
}
}
ans = connect(ans, ws[0][u]);
ans = connect(ans, ws[0][v]);
return make_pair(parent[0][u], ans);
}
int dfs(int v, int p, int d, long long int w, int id) {
parent[0][v] = p;
ws[0][v] = w;
depth[v] = d;
cnum[v] = 0;
for (int i = 1; i < MAXLOGV; i++) {
parent[i][v] = parent[i - 1][parent[i - 1][v]];
ws[i][v] = connect(ws[i - 1][v], ws[i - 1][parent[i - 1][v]]);
}
for (auto e : T[v]) {
auto next = e.dst;
if (next != p) cnum[v] += dfs(next, v, d + 1, e.cost, e.id);
}
return cnum[v] + 1;
}
void getid(const int v, const int p, int& nplace) {
place[v] = nplace;
id[nplace] = v;
nplace++;
for (auto e : T[v]) {
const auto next = e.dst;
if (next != p) getid(next, v, nplace);
}
}
static const int MAXLOGV = 25;
vector<vector<Edge>> T;
int V;
int root;
vector<vector<int>> parent;
vector<vector<int>> ws;
vector<int> depth;
vector<int> cnum;
vector<int> place;
vector<int> id;
};
vector<vector<int>> adds, dels;
vector<int> anss;
void dfs(const vector<vector<Edge>>& g, const int now, const int from_id,
multiset<int>& nms) {
for (auto& e : g[now]) {
if (e.id == from_id) continue;
multiset<int> ams;
dfs(g, e.dst, e.id, ams);
if (nms.size() < ams.size()) swap(nms, ams);
for (auto am : ams) nms.emplace(am);
}
for (auto ad : adds[now]) nms.emplace(ad);
for (auto de : dels[now]) nms.erase(nms.find(de));
if (from_id != -1) anss[from_id] = nms.empty() ? -1 : *nms.begin() - 1;
}
int main() {
int N, M;
cin >> N >> M;
anss.assign(M, -100);
adds.resize(N);
dels.resize(N);
vector<vector<Edge>> g(N);
vector<Edge> all_es;
for (int i = 0; i < M; ++i) {
int a, b, c;
cin >> a >> b >> c;
a--;
b--;
g[a].push_back(Edge{a, b, c, i});
g[b].push_back(Edge{b, a, c, i});
all_es.emplace_back(Edge{a, b, c, i});
}
auto v(mst(g, M));
Tree t(N, 0);
for (int i = 0; i < M; ++i) {
if (v[i]) t.unite(all_es[i]);
}
t.init();
for (int i = 0; i < M; ++i) {
if (v[i]) continue;
auto alca = t.lca(all_es[i].src, all_es[i].dst);
adds[all_es[i].src].push_back(all_es[i].cost);
adds[all_es[i].dst].push_back(all_es[i].cost);
dels[alca.first].push_back(all_es[i].cost);
dels[alca.first].push_back(all_es[i].cost);
anss[i] = alca.second - 1;
}
multiset<int> ms;
dfs(t.T, 0, -1, ms);
for (int i = 0; i < M; ++i) {
cout << anss[i];
if (i == M - 1)
cout << endl;
else
cout << " ";
}
return 0;
}
| 2,700 |
CPP
|
for _ in range(int(input())):
n=int(input())
arr=map(int,input().split())
arr=list(arr)
s=map(int,input().split())
s=set(s)
#print(arr,sorted(arr))
if len(s)==2 or list(arr)==sorted(arr):
print('YES')
else:
print('NO')
| 1,300 |
PYTHON3
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100000 + 10;
const int oo = 1 << 30;
int N, M, tree1[4 * maxn], tree2[4 * maxn], lazy[4 * maxn], A[maxn];
void build(int node, int start, int end) {
if (start == end) {
tree1[node] = tree2[node] = A[start];
} else {
int mid = (start + end) / 2;
build(2 * node, start, mid);
build(2 * node + 1, mid + 1, end);
tree1[node] = max(tree1[2 * node], tree1[2 * node + 1]);
tree2[node] = min(tree2[2 * node], tree2[2 * node + 1]);
}
}
void update(int node, int start, int end, int l, int r, int val) {
if (lazy[node] != 0) {
tree1[node] += lazy[node];
tree2[node] += lazy[node];
if (start != end) {
lazy[node * 2] += lazy[node];
lazy[node * 2 + 1] += lazy[node];
}
lazy[node] = 0;
}
if (start > end || start > r || end < l) return;
if (start >= l && end <= r) {
tree1[node] += val;
tree2[node] += val;
if (start != end) {
lazy[node * 2] += val;
lazy[node * 2 + 1] += val;
}
return;
}
int mid = (start + end) / 2;
update(node * 2, start, mid, l, r, val);
update(node * 2 + 1, mid + 1, end, l, r, val);
tree1[node] = max(tree1[node * 2], tree1[node * 2 + 1]);
tree2[node] = min(tree2[node * 2], tree2[node * 2 + 1]);
}
int query(int node, int start, int end, int l, int r, int opc) {
if (start > end || start > r || end < l) return 0;
if (lazy[node] != 0) {
tree1[node] += lazy[node];
tree2[node] += lazy[node];
if (start != end) {
lazy[node * 2] += lazy[node];
lazy[node * 2 + 1] += lazy[node];
}
lazy[node] = 0;
}
if (start >= l && end <= r) {
if (opc == 1) return tree1[node];
return tree2[node];
}
int mid = (start + end) / 2;
int p1 = query(node * 2, start, mid, l, r, opc);
int p2 = query(node * 2 + 1, mid + 1, end, l, r, opc);
if (opc == 1) {
return max(p1, p2);
}
return min(p1, p2);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> N >> M;
for (int i = 0; i < N; i++) cin >> A[i];
vector<pair<int, int> > seg(M);
for (int i = 0; i < M; i++) {
cin >> seg[i].first >> seg[i].second;
seg[i].first--;
seg[i].second--;
}
build(1, 0, N - 1);
int res = -oo;
vector<int> ress;
for (int i = 0; i < N; i++) {
int cnt = 0;
vector<int> tmp;
for (int j = 0; j < M; j++) {
if (seg[j].first <= i && i <= seg[j].second) continue;
cnt++;
tmp.push_back(j);
update(1, 0, N - 1, seg[j].first, seg[j].second, -1);
}
if (cnt) {
int maxi = -oo;
int mini = oo;
maxi = query(1, 0, N - 1, 0, N - 1, 1);
mini = query(1, 0, N - 1, 0, N - 1, 0);
int diff = maxi - mini;
if (diff > res) {
res = diff;
ress = tmp;
}
for (int j = 0; j < M; j++) {
if (seg[j].first <= i && i <= seg[j].second) continue;
update(1, 0, N - 1, seg[j].first, seg[j].second, +1);
}
}
}
int maxi = A[0];
int mini = A[0];
maxi = query(1, 0, N - 1, 0, N - 1, 1);
mini = query(1, 0, N - 1, 0, N - 1, 0);
if (maxi - mini > res) {
res = maxi - mini;
ress = vector<int>();
}
cout << res << '\n';
cout << ress.size() << '\n';
for (int i = 0; i < ress.size(); i++)
cout << ress[i] + 1 << " \n"[i == ress.size() - 1];
return 0;
}
| 1,800 |
CPP
|
nm = list(map(int, input().split()))
c = list(map(int, input().split()))
a = list(map(int, input().split()))
games = 0
for i in range(nm[0]):
if len(a) > 0:
if c[i] <= a[0]:
games += 1
a.pop(0)
else:
break
print(games)
| 800 |
PYTHON3
|
a,b = map(int,input().split())
s = [6,2,5,5,4,5,6,3,7,6]
rs = 0
nums = str(list(range(a,b+1)))
for i in range(len(s)):
rs += s[i] * nums.count(str(i))
print(rs)
| 1,000 |
PYTHON3
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, tmp = 0, r, s, d;
cin >> n;
long long day;
for (int i = 0; i < n; i++) {
cin >> s >> d;
while (s <= tmp) s += d;
tmp = s;
}
cout << tmp << endl;
}
| 900 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
typedef long double ld;
const int maxn = 1e4 + 10, Six = 1e6;
ld dp[maxn], f[maxn], C[maxn];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, x;
cin >> n >> x;
ld c = ld(x) / Six;
C[0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = i; j >= 1; j--) C[j] += C[j - 1];
}
for (int i = 0; i <= n; i++) {
cin >> f[i];
if (f[i] == 0)
f[i] = 1;
else
f[i] *= 1e20;
f[i] /= C[i];
}
for (int tot = n - 1; tot >= 0; tot--) {
for (int i = 0; i <= tot; i++) {
f[i] += f[i + 1];
dp[i] =
max(ld(0), dp[i] - c + (f[i + 1] / f[i]) * (dp[i + 1] - dp[i] + 1));
}
}
return cout << setprecision(10) << fixed << dp[0] << endl, 0;
}
| 2,800 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
long long q;
cin >> q;
while (q--) {
long long n;
cin >> n;
long long cont = 0;
while (true) {
if (n == 1) {
printf("%d\n", cont);
break;
}
if (n % 2 == 0) {
n -= n / 2;
} else if (n % 3 == 0) {
n -= n / 3;
} else if (n % 5 == 0) {
n -= n / 5;
} else {
printf("%d\n", -1);
break;
}
cont++;
}
}
}
| 800 |
CPP
|
I = lambda:map(int,input().split())
from collections import defaultdict
for t in range(int(input())):
n, l, r = I()
k = abs(l-r)//2
c = I()
C = defaultdict(lambda:[0,0])
for _ in range(l):
C[next(c)][0] += 1
for _ in range(r):
C[next(c)][1] += 1
d = 0
L = 0
R = 0
for x in C.values():
dif = x[0]-x[1]
d += abs(dif)
if dif>=0:
L += dif//2
else:
R += -dif//2
print(d//2+max(0,k-L) if l>=r else d//2+max(0,k-R))
| 1,500 |
PYTHON3
|
s=input()
s=s.lower()
ans=""
for i in s:
if i=="a"or i=="o"or i=="y" or i=="e" or i=="u" or i=="i":
continue
else:
ans+="."
ans+=i
print(ans)
| 1,000 |
PYTHON3
|
# for t in range(int(input())):
# s = input()
# i, j = 0, 0
# cnt = 0
# ans = float('inf')
# dic = {}
# while j < len(s):
# if len(dic) < 3:
# dic[s[j]] = dic.get(s[j], 0) + 1
# # print(j)
# # print(dic)
# while len(dic) == 3:
# ans = min(ans, j - i + 1)
# dic[s[i]] -= 1
# if dic[s[i]] == 0:
# del dic[s[i]]
# i += 1
#
# j += 1
# print((0, ans)[ans < float('inf')])
# for t in range(int(input())):
# n = int(input())
# s = list(map(int, input().split()))
# dp = [1] * n
# for i in range(n):
# k = 2
# while (i + 1) * k <= n:
# j = (i + 1) * k
# if s[i] < s[j - 1]:
# dp[j - 1] = max(dp[j - 1], dp[i] + 1)
# k += 1
# print(max(dp))
# for T in range(int(input())):
# t = input()
# z, o = 0, 0
# for ch in t:
# z = z + 1 if ch == '0' else z
# o = o + 1 if ch == '1' else o
# if z > 0 and o > 0:
# print('01' * len(t))
# elif o > 0 and not z:
# print('1' * len(t))
# else:
# print('0' * len(t))
# for t in range(int(input())):
# n = int(input())
# a = list(map(int, input().split()))
# a.sort()
# ans = []
# while a:
# ans.append(str(a.pop(len(a) // 2)))
# print(' '.join(ans))
# for t in range(int(input())):
# n = int(input())
# a = list(map(int, input().split()))
# cnt = 0
# p = set()
# l, r = 0, sum(a)
# left, right = {}, {}
# for i in a:
# right[i] = right.get(i, 0) + 1
# for i in range(n - 1):
# l += a[i]
# left[a[i]] = left.get(a[i], 0) + 1
# r -= a[i]
# right[a[i]] = right.get(a[i], 0) - 1
# if not right[a[i]]:
# del right[a[i]]
# j = n - i - 1
# if (2 + i) * (i + 1) // 2 == l and (j + 1) * j // 2 == r:
# if len(left) == i + 1 and len(right) == j:
# cnt += 1
# p.add((i + 1, n - i - 1))
# print(cnt)
# if cnt:
# for el in p:
# print(*el)
# for t in range(int(input())):
# n = int(input())
# G = []
# taken = [False] * n
# girl = -1
# for i in range(n):
# g = list(map(int, input().split()))
# k = g[0]
# single = True
# for j in range(1, k + 1):
# if not taken[g[j] - 1]:
# taken[g[j] - 1] = True
# single = False
# break
# if single:
# girl = i
# if girl == -1:
# print('OPTIMAL')
# else:
# print('IMPROVE')
# print(girl + 1, taken.index(False) + 1)
# for t in range(int(input())):
# n = int(input())
# a = list(map(int, input().split()))
# odd, even = [], []
# for i in range(2 * n):
# if a[i] % 2:
# odd.append(i + 1)
# else:
# even.append(i + 1)
# for i in range(n - 1):
# if len(odd) >= len(even):
# print(odd.pop(), odd.pop())
# else:
# print(even.pop(), even.pop())
# for t in range(int(input())):
# n = int(input())
# a = list(map(int, input().split()))
# a.sort()
# ans, i, j = 0, 0, 1
# while j < n:
# if a[i] < a[j]:
# ans += 1
# i += 1
# j += 1
# else:
# while j < n and a[i] == a[j]:
# i += 1
# j += 1
# print(ans + 1)
# for t in range(int(input())):
# n = int(input())
# a = list(map(int, input().split()))
# got = False
#
# b = 1
# while not got and b < 2 * n - 1:
# if b % 2:
# i, j = (b - 1) // 2, (b + 1) // 2
# else:
# i, j = b // 2 - 1, b // 2 + 1
# left, right = set(a[:i]), set(a[j:])
# if left & right:
# got = True
# b += 1
# print('YES' if got else 'NO')
# n, m, k = list(map(int, input().split()))
# A = list(map(int, input().split()))
# B = list(map(int, input().split()))
# ans = 0
# a, b = [0], [0]
# for el in A:
# a.append(a[-1] + el)
# for el in B:
# b.append(b[-1] + el)
# d = [(i, k//i) for i in range(1, int(k**0.5)+1) if k % i == 0]
# d += [(j, i) for i, j in d if i != j]
# for i in range(n):
# for j in range(m):
# for q, p in d:
# if i + q <= n and j + p <= m:
# if a[i + q] - a[i] == q and b[j + p] - b[j] == p:
# ans += 1
# print(ans)
# for t in range(int(input())):
# n = int(input())
# s = input()
# dic, se = {s: 1}, {s}
# for k in range(2, n):
# p = s[k - 1:] + (s[:k - 1], s[:k - 1][::-1])[(n % 2) == (k % 2)]
# # print(k, p)
# if p not in dic:
# # print(dic, p)
# dic[p] = k
# se.add(p)
# if s[::-1] not in dic:
# dic[s[::-1]] = n
# se.add(s[::-1])
# # print(dic)
# ans = min(se)
# print(ans)
# print(dic[ans])
# for t in range(int(input())):
# a, b, p = list(map(int, input().split()))
# s = input()
# road = [a if s[0] == 'A' else b]
# st = [0]
# for i in range(1, len(s) - 1):
# if s[i] != s[i - 1]:
# road.append(road[-1] + (a, b)[s[i] == 'B'])
# st.append(i)
# # print(road)
# pay = road[-1]
# j = 0
# while pay > p and j < len(st):
# pay = road[-1] - road[j]
# j += 1
# # print(j)
# print(st[j] + 1 if j < len(st) else len(s))
# for t in range(int(input())):
# n, x, y = list(map(int, input().split()))
# print(max(1, min(x + y - n + 1, n)), min(n, x + y - 1))
# for t in range(int(input())):
# n = int(input())
# a = list(map(int, input().split()))
# print(' '.join(map(str, sorted(a, reverse=True))))
# s = input()
# open, close = [], []
# i = 0
# for i in range(len(s)):
# if s[i] == '(':
# open.append(i)
# else:
# close.append(i)
# i, j = 0, len(close) - 1
# ans = []
# while i < len(open) and j >= 0 and open[i] < close[j]:
# ans += [open[i] + 1, close[j] + 1]
# i += 1
# j -= 1
# ans.sort()
# print('0' if not ans else '1\n{}\n{}'.format(len(ans), ' '.join([str(idx) for idx in ans])))
import collections
# n, m = list(map(int, input().split()))
# a = list(input() for i in range(n))
# dic = {}
# for w in a:
# dic[w] = dic.get(w, 0) + 1
# l, r = '', ''
# for i in range(n):
# for j in range(i + 1, n):
# # print(i, j, a)
# if a[i] == a[j][::-1] and dic[a[i]] and dic[a[j]]:
# l += a[i]
# r = a[j] + r
# dic[a[i]] -= 1
# dic[a[j]] -= 1
# c = ''
# for k, v in dic.items():
# if v and k == k[::-1]:
# if c and c[-m] == k or not c:
# c += k
# print(f'{len(l) + len(c) + len(r)}\n{l + c + r}')
# for t in range(int(input())):
# n, g, b = list(map(int, input().split()))
# d = n // 2 + n % 2
# full, inc = divmod(d, g)
# ans = (g + b) * (full - 1, full)[inc > 0] + (g, inc)[inc > 0]
# print(ans if ans >= n else n)
# for t in range(int(input())):
# n = int(input())
# a = list(map(int, input().split()))
# a.sort()
# print(a[n] - a[n - 1])
# for t in range(int(input())):
# n, x = list(map(int, input().split()))
# s = input()
# cntz = s.count('0')
# total = 2 * cntz - n
# bal = 0
# ans = 0
# for i in range(n):
# if not total:
# if bal == x:
# ans = -1
# elif not abs(x - bal) % abs(total):
# if (x - bal) // total >= 0:
# ans += 1
# bal += 1 if s[i] == '0' else -1
# print(ans)
# n = int(input())
# ans = 0
# for i in range(1, n + 1):
# ans += 1 / i
# print(ans)
# for t in range(int(input())):
# n = int(input())
# a = list(map(int, input().split()))
# p, s = 0, n - 1
# for i in range(n):
# if a[i] < i:
# break
# p = i
# for i in range(n - 1, -1, -1):
# if a[i] < n - i - 1:
# break
# s = i
# print('Yes' if s <= p else 'No')
# n, k = list(map(int, input().split()))
# a = [input() for i in range(n)]
# c = set(a)
# b = set()
# for i in range(n):
# for j in range(i + 1, n):
# third = ''
# for c1, c2 in zip(a[i], a[j]):
# if c1 == c2:
# third += c1
# else:
# if c1 != 'S' and c2 != 'S':
# third += 'S'
# elif c1 != 'E' and c2 != 'E':
# third += 'E'
# else:
# third += 'T'
# if third in c:
# b.add(frozenset([a[i], a[j], third]))
# print(len(b))
# for t in range(int(input())):
# n = int(input())
# a = list(map(int, input().split()))
# total, curr = sum(a), 0
# ans, i, start = 'YES', 0, 0
# while ans == 'YES' and i < n:
# if curr > 0:
# curr += a[i]
# else:
# curr = a[i]
# start = i
# # print(curr, i, start, total)
# if i - start + 1 < n and curr >= total:
# ans = 'NO'
# i += 1
# print(ans)
# for t in range(int(input())):
# n, p, k = list(map(int, input().split()))
# a = list(map(int, input().split()))
# a.sort(reverse=True)
# odd, even = 0, 0
# i, j = len(a) - 1, len(a) - 2
# curr = 0
# while curr < p and i >= 0:
# curr += a[i]
# if curr <= p:
# odd += 1
# i -= 2
# curr = 0
# while curr < p and j >= 0:
# curr += a[j]
# if curr <= p:
# even += 1
# j -= 2
# print(max(odd * 2 - 1, even * 2))
# for t in range(int(input())):
# s, c = input().split()
# s = list(ch for ch in s)
# sor = sorted(s)
# for i in range(len(s)):
# if s[i] != sor[i]:
# j = max(j for j, v in enumerate(s[i:], i) if v == sor[i])
# s = s[:i] + [s[j]] + s[i + 1:j] + [s[i]] + s[j + 1:]
# break
# s = ''.join(s)
# print(s if s < c else '---')
# for t in range(int(input())):
# n, s = list(map(int, input().split()))
# a = list(map(int, input().split()))
# if sum(a) <= s:
# print(0)
# else:
# curr, i, j = 0, 0, 0
# for i in range(n):
# if a[i] > a[j]:
# j = i
# s -= a[i]
# if s < 0:
# break
# print(j + 1)
# for t in range(int(input())):
# a, b = list(map(int, input().split()))
# a, b = (b, a) if b > a else (a, b)
# if not ((1 + 8 * (a - b))**0.5 - 1) % 2 and ((1 + 8 * (a - b))**0.5 - 1) // 2 >= 0:
# ans = ((1 + 8 * (a - b))**0.5 - 1) // 2
# print(int(ans))
# else:
# n1 = int(((1 + 8 * (a - b))**0.5 - 1) // 2) + 1
# while (n1 * (n1 + 1) // 2) % 2 != (a - b) % 2:
# n1 += 1
# print(n1)
# for t in range(int(input())):
# n = int(input())
# a = list(map(int, input().split()))
# a.sort()
# ans = 0
# l = 0
# dic = {}
# for i in range(n - 1, -1, -1):
# if not a[i] % 2:
# l, r = 0, 30
# while l < r:
# m = (l + r) // 2
# # print(l, r, m, a[i] % 2**m)
# if a[i] % 2**m:
# r = m
# else:
# l = m + 1
# dic[a[i] // 2**(l - 1)] = max(dic.get(a[i] // 2**(l - 1), 0), l - 1)
# print(sum(list(dic.values())))
# n = int(input())
# s = input()
# b = s.count('B')
# w = n - b
# if b % 2 and w % 2:
# print(-1)
# elif not b or not w:
# print(0)
# else:
# ans = []
# if not b % 2:
# for i in range(n - 1):
# if s[i] != 'W':
# ans += [str(i + 1)]
# s = s[:i] + 'W' + 'BW'[s[i + 1] == 'B'] + s[i + 2:]
# elif not w % 2:
# for i in range(n - 1):
# if s[i] != 'B':
# ans += [str(i + 1)]
# s = s[:i] + 'B' + 'WB'[s[i + 1] == 'W'] + s[i + 2:]
# print(len(ans))
# print(' '.join(ans))
# n, m = list(map(int, input().split()))
# a = list(map(int, input().split()))
# b = list(map(int, input().split()))
# b.sort()
# ans = float('inf')
# for i in range(n):
# x = (b[0] - a[i]) % m
# ax = []
# for j in range(n):
# ax.append((a[j] + x) % m)
# if b == sorted(ax):
# ans = min(ans, x)
# print(ans)
# for t in range(int(input())):
# n = int(input())
# ans = [1] + [0] * (n - 1)
# p = list(map(int, input().split()))
# i, j, curr, m = p.index(1), 1, 1, 1
# l, r = i, i
# while l >= 0 and r < n:
# if l and curr + p[l - 1] == (m + 2) * (m + 1) // 2:
# ans[m] = 1
# curr += p[l - 1]
# l -= 1
#
# elif r + 1 < n and curr + p[r + 1] == (m + 2) * (m + 1) // 2:
# ans[m] = 1
# curr += p[r + 1]
# r += 1
# else:
# if l and r + 1 < n:
# curr, l, r = ((curr + p[l - 1], l - 1, r),
# (curr + p[r + 1], l, r + 1))[p[r + 1] < p[l - 1]]
# elif not l and r + 1 < n:
# curr, l, r = curr + p[r + 1], l, r + 1
# elif r + 1 == n and l:
# curr, l, r = curr + p[l - 1], l - 1, r
# else:
# break
# m += 1
# print(''.join([str(i) for i in ans]))
# for t in range(int(input())):
# n = int(input())
# p = [input() for i in range(n)]
# ans = 0
# for i in range(n):
# if p[i] in p[i + 1:]:
# for j in range(10):
# code = p[i][:3] + str(j)
# if code not in p:
# p[i] = code
# ans += 1
# break
# print(ans)
# for code in p:
# print(code)
# for t in range(int(input())):
# a, b = list(map(int, input().split()))
# if (a + b) % 3 == 0 and 2 * min(a, b) >= max(a, b):
# print('YES')
# else:
# print('NO')
# for t in range(int(input())):
# x, y = list(map(int, input().split()))
# if (x == 1 and y > 1) or (x == 2 and y > 3) or (x == 3 and y > 3):
# print('NO')
# else:
# print('YES')
# for t in range(int(input())):
# n, m = list(map(int, input().split()))
# a = list(map(int, input().split()))
# if m < n or n == 2:
# print(-1)
# elif m == n:
# print(2 * sum(a))
# for i in range(n - 1):
# print(i + 1, i + 2)
# print(n, 1)
# else:
# b = [(a[i], i + 1) for i in range(n)]
# b.sort()
# d = m - n
# ans = sum(a) + d * (b[0][0] + b[1][0])
# for i in range(d):
# print(b[0][1], b[1][1])
# for i in range(n - 1):
# print(i + 1, i + 2)
# print(n, 1)
# n = int(input())
# a = list(map(int, input().split()))
# if n % 2:
# print(-1)
# else:
# d = 0
# c = []
# curr = 0
# came = set()
# day = set()
# inc = False
# for i in range(n):
# if a[i] > 0:
# if a[i] in day:
# inc = True
# break
# else:
# day.add(a[i])
# came.add(a[i])
# else:
# if abs(a[i]) not in came:
# inc = True
# break
# else:
# came.remove(abs(a[i]))
# if len(came) == 0:
# d += 1
# c.append(i + 1)
# day = set()
# if len(came) > 0:
# inc = True
# if inc:
# print(-1)
# else:
# print(d)
# print(c[0])
# for i in range(1, len(c)):
# print(c[i] - c[i - 1])
# n = int(input())
# a = list(map(int, input().split()))
# a.sort()
# x, y = sum(a[:n // 2])**2, sum(a[n // 2:])**2
# print(x + y)
# for t in range(int(input())):
# n = int(input())
# r, p, s = list(map(int, input().split()))
# b = input()
# S, P, R = b.count('S'), b.count('P'), b.count('R')
# cnt = 0
# ans = ''
# # print(r, 'rock', p, 'paper', s, 'sc')
# for i in range(n):
# if b[i] == 'S':
# if r > 0:
# ans, r, cnt = ans + 'R', r - 1, cnt + 1
# else:
# if p > R:
# ans, p = ans + 'P', p - 1
# if len(ans) < i + 1 and s > P:
# ans, s = ans + 'S', s - 1
# S -= 1
# elif b[i] == 'P':
# if s > 0:
# ans, s, cnt = ans + 'S', s - 1, cnt + 1
# else:
# if p > R:
# ans, p = ans + 'P', p - 1
# if len(ans) < i + 1 and r > S:
# ans, r = ans + 'R', r - 1
# P -= 1
# else:
# if p > 0:
# ans, p, cnt = ans + 'P', p - 1, cnt + 1
# else:
# if s > P:
# ans, s = ans + 'S', s - 1
# if len(ans) < i + 1 and r > S:
# ans, r = ans + 'R', r - 1
# R -= 1
# if cnt < (n // 2 + n % 2):
# print('NO')
# else:
# print('YES')
# # print(r, p, s)
# print(ans)
# for t in range(int(input())):
# n = int(input())
# s = input()
# f, l = s.find('1'), s.rfind('1')
# f, l = max(f + 1, n - f) if f != -1 else 0, max(l + 1, n - l) if l != -1 else 0
# if not f and not l:
# print(n)
# else:
# print(f * 2) if f > l else print(l * 2)
# t = int(input())
# ans = list()
# for _ in [0] * t:
# n, r = map(int, input().split())
# x = sorted(set(map(int, input().split())))[::-1]
# ans.append(sum([x - i * r > 0 for i, x in enumerate(x)]))
# print(' '.join(map(str, ans)))
# n = int(input())
# dots = []
# for i in range(n):
# dots.append(sum(list(map(int, input().split()))))
# print(max(dots))
# n, m = map(int, input().split())
# print(pow(2**m - 1, n, 10**9 + 7))
# n, k = map(int, input().split())
# s = input()
# if not k:
# print(s)
# elif n == 1:
# print('0')
# else:
# s = [int(i) for i in s]
# if s[0] > 1:
# s[0], k = 1, k - 1
# for i in range(1, n):
# if not k:
# break
# if s[i] > 0:
# s[i], k = 0, k - 1
# print(''.join(map(str, s))) if len(s) > 1 else print('0')
# m, n = map(int, input().split())
# r = list(map(int, input().split()))
# c = list(map(int, input().split()))
# grid = [['ok'] * (n + 1) for i in range(m + 1)]
#
# for i in range(m):
# row = r[i]
# if row:
# for j in range(row):
# grid[i][j] = 1
# grid[i][row] = 0
# else:
# grid[i][row] = 0
#
#
# inv = False
# for j in range(n):
# col = c[j]
# if col:
# for i in range(col):
# if grid[i][j] == 0:
# inv = True
# break
# else:
# grid[i][j] = 1
# if grid[col][j] == 1:
# inv = True
# break
# else:
# grid[col][j] = 0
# else:
# if grid[col][j] == 1:
# inv = True
# break
# else:
# grid[col][j] = 0
#
# if inv:
# print(0)
# else:
# cnt = 0
# for row in grid[:m]:
# cnt += row[:n].count('ok')
# print(pow(2, cnt, 10**9 + 7))
# n = int(input())
# for i in range(n):
# print('BW' * (n // 2) + 'B' * (n % 2) if i % 2 else 'WB' * (n // 2) + 'W' * (n % 2))
# n = int(input())
# a = list(map(int, input().split()))
# curr, odd, even = 0, 0, 0
# p = 0
# for d in a:
# odd, even = ((odd, even + 1), (odd + 1, even))[curr % 2]
# curr += 1 if d < 0 else 0
# p += odd if curr % 2 else even
# print(n * (n + 1) // 2 - p, p)
# n = int(input())
# a = list(map(int, input().split()))
# p, m, z = 0, [], 0
# for d in a:
# if d > 0:
# p += d
# elif d < 0:
# m.append(d)
# else:
# z += 1
# ans = p - (n - z - len(m))
#
# if len(m) % 2:
# if z:
# m.append(-1)
# ans += 1
# z -= 1
# else:
# m.sort(reverse=True)
# x = m.pop()
# ans += 1 - x
#
# mm = len(m)
# ans += abs(sum(m)) - mm
# ans += z
# print(ans)
# n, l, r = map(int, input().split())
# a = [2**i for i in range(r)]
# print(sum(a[:l]) + n - l, sum(a) + (n - r) * a[-1])
# n = int(input())
# a = list(map(int, input().split()))
# a.sort()
# print('YES' if not sum(a) % 2 and a[-1] <= sum(a) - a[-1] else 'NO')
# for t in range(int(input())):
# n, m, k = map(int, input().split())
# h = list(map(int, input().split()))
# ans = 'YES'
# for i in range(n - 1):
# if abs(h[i] - h[i + 1]) > k:
# d = h[i] - h[i + 1]
# if d < 0 and m >= abs(d) - k:
# m -= -k - d
# elif d > 0:
# m += min(d + k, h[i])
# else:
# ans = 'NO'
# break
# else:
# d = h[i] - h[i + 1]
# if d >= 0:
# m += min(d + k, h[i])
# else:
# m += min(k + d, h[i])
# print(ans)
# h, l = map(int, input().split())
# print((h**2 + l**2) / (2 * h) - h)
# n = int(input())
# a = list(map(int, input().split()))
# a = {i: j for i, j in enumerate(a)}
# m, idx = 0, 0
# ans = 'YES'
# for i in range(n):
# if a[i] > m:
# m = a[i]
# idx = i
# for i in range(1, idx):
# if a[i] < a[i - 1]:
# ans = 'NO'
# break
# for i in range(idx + 1, n):
# if a[i] > a[i - 1]:
# ans = 'NO'
# break
# print(ans)
# n, k = map(int, input().split())
# l, r = 0, n
# while l <= r:
# m = (l + r) // 2
# t = n - m
# if m * (m + 1) // 2 - t == k:
# ans = t
# break
# elif m * (m + 1) // 2 - t < k:
# l = m + 1
# else:
# r = m - 1
# print(ans)
# for t in range(int(input())):
# n, m = map(int, input().split())
# grid = [input() for i in range(n)]
# rows = []
# cols = [0] * m
# for row in grid:
# rows.append(0)
# for i in range(m):
# if row[i] == '.':
# rows[-1] += 1
# cols[i] += 1
# ans = m + n - 1
# for i in range(n):
# for j in range(m):
# ans = min(ans, rows[i] + cols[j] - (grid[i][j] == '.'))
# print(ans)
# tiles = input().split()
# unique = {}
# m, p, s = set(), set(), set()
# m_unique = 0
# for t in tiles:
# unique[t] = unique.get(t, 0) + 1
# m_unique = max(m_unique, unique[t])
# if t[1] == 'm':
# m.add(int(t[0]))
# elif t[1] == 'p':
# p.add(int(t[0]))
# else:
# s.add(int(t[0]))
# ans = 3 - m_unique
# for t in (m, p, s):
# if not t:
# continue
# else:
# m_sub = 0
# l = list(sorted(t))
# dif = []
# for i in range(1, len(t)):
# dif.append(l[i] - l[i - 1])
# if dif[-1] == 1 or dif[-1] == 2:
# m_sub = max(m_sub, 2)
# if i > 1 and dif[-1] == dif[-2] == 1:
# m_sub = 3
# # print(l, dif, m_sub)
# ans = min(ans, 3 - m_sub)
# print(ans)
# n = int(input())
# a = list(map(int, input().split()))
# a.sort()
# print('NO' if a[-3] + a[-2] <= a[-1] else 'YES')
# if a[-3] + a[-2] > a[-1]:
# print(' '.join(str(i) for i in a[:-3] + [a[-3]] + [a[-1]] + [a[-2]]))
# n = int(input())
# s = input()
# m = int(input())
# dic = {}
# for i in range(n):
# dic.setdefault(s[i], []).append(i)
# for t in range(m):
# name = [ch for ch in input()]
# c = {}
# ans = 0
# # print(t)
# for i in range(len(name)):
# idx = c.get(name[i], -1)
# # print(name[i], dic[name[i]], c)
# c[name[i]] = idx + 1
# ans = max(ans, dic[name[i]][idx + 1])
# print(ans + 1)
# for t in range(int(input())):
# a = input()
# b = input()
# if len(b) < len(a):
# print('NO')
# else:
# ans = 'YES'
# i, j = 0, 0
# while i < len(a):
# cnt1 = 1
# while i + 1 < len(a) and a[i] == a[i + 1]:
# cnt1 += 1
# i += 1
# cnt2 = 0
# while j < len(b) and b[j] == a[i]:
# cnt2 += 1
# j += 1
# if cnt1 > cnt2:
# ans = 'NO'
# break
# i += 1
# print(ans if i == len(a) and j == len(b) else 'NO')
# m, n = map(int, input().split())
# g = [input() for i in range(m)]
# ans = 'YES'
# if m < 3 and n < 3:
# ans = 'NO'
# if ans == 'YES':
# c = (-1, -1)
# for i in range(1, m - 1):
# for j in range(1, n - 1):
# if g[i][j] == '*':
# if all(g[I][J] == '*' for I, J in ((i + 1, j), (i - 1, j), (i, j + 1), (i, j - 1))):
# c = (i, j)
# break
# if c == (-1, -1):
# ans = 'NO'
#
# if ans == 'YES':
# plus = {c}
# I, J = c
# i, j = I - 1, I + 1
# while i >= 0 and g[i][J] == '*':
# plus.add((i, J))
# i -= 1
# while j < m and g[j][J] == '*':
# plus.add((j, J))
# j += 1
# i, j = J - 1, J + 1
# while i >= 0 and g[I][i] == '*':
# plus.add((I, i))
# i -= 1
# while j < n and g[I][j] == '*':
# plus.add((I, j))
# j += 1
#
# for i in range(m):
# for j in range(n):
# if g[i][j] == '*' and (i, j) not in plus:
# ans = 'NO'
# break
#
# print(ans)
# for t in range(int(input())):
# n = int(input())
# if not n % 2:
# print(f'{n // 2} {n // 2}')
# else:
# idx = 1
# for i in range(3, int(n**0.5) + 1):
# if not n % i:
# idx = i
# break
# print(f'{n // idx} {n - n // idx}' if idx > 1 else f'{1} {n - 1}')
# l = int(input())
# n = input()
# i = l // 2
# if not l % 2 and n[i] != '0':
# print(int(n[:i]) + int(n[i:]))
# else:
# j = i + 1
# while n[i] == '0':
# i -= 1
# while j < l and n[j] == '0':
# j += 1
# if i > 0 and j < l - 1:
# print(min(int(n[:i]) + int(n[i:]), int(n[:j]) + int(n[j:])))
# else:
# if not i:
# print(int(n[:j]) + int(n[j:]))
# else:
# print(int(n[:i]) + int(n[i:]))
# n = int(input())
# a = list(map(int, input().split()))
# b = a.copy()
# for i in range(n):
# if a[i] >= 0:
# a[i] = (a[i] + 1) * -1
# if not n % 2:
# print(' '.join((str(i) for i in a)))
# else:
# m = (float('inf'), -1)
# for i in range(n):
# m = (m, (a[i], i))[m[0] > a[i] and a[i] < -1]
# if m[1] == -1:
# b[0] = 0
# print(' '.join((str(i) for i in b)))
# else:
# a[m[1]] = (a[m[1]] + 1) * -1
# print(' '.join((str(i) for i in a)))
# l = int(input())
# ans = 0
# c = [input() for i in range(l)]
# stack = [1]
# for i in range(l):
# if c[i] == 'add':
# ans += stack[-1]
# elif c[i] == 'end':
# stack.pop()
# else:
# stack.append(min(stack[-1] * int(c[i].split()[1]), 2**32))
# if ans >= 2**32:
# ans = 'OVERFLOW!!!'
# break
# print(ans)
# n = int(input())
# a = list(map(int, input().split()))
# odd = 0
# for d in a:
# if d % 2:
# odd += 1
# if 0 < odd < n:
# print(' '.join((str(i) for i in sorted(a))))
# else:
# print(' '.join((str(i) for i in a)))
# n = int(input())
# print(n // 2 + 1)
# i, j = 1, 1
# for k in range(n):
# print(i, j)
# if i == j:
# j += 1
# else:
# i += 1
# n, m = map(int, input().split())
# a = [list(map(int, input().split())) for i in range(m)]
# x, y = a.pop()
# ans = 'NO'
# for v in (x, y):
# val = [0] * (n + 1)
# cnt = 0
# for v1, v2 in a:
# if v1 != v and v2 != v:
# val[v1], val[v2], cnt = val[v1] + 1, val[v2] + 1, cnt + 1
# if max(val) == cnt:
# ans = 'YES'
# break
# print(ans)
# k = int(input())
# idx = 1
# for j in range(5, int(k**0.5) + 1):
# if not k % j:
# idx = j
# break
#
# if idx < 5 or k // idx < 5:
# print('-1')
# else:
# pattern = 'aeiou' + 'aeiou'[:max(0, idx - 5)]
# ans = ''
# for i in range(k // idx):
# j = i % len(pattern)
# ans += pattern[j:] + pattern[:j]
# print(ans)
# n = int(input())
# u = list(map(int, input().split()))
# g, cnt = [0] * 10, 0
# ans = 0
# for i in range(n):
# g[u[i] - 1] += 1
# unique = set(g)
# unique.discard(0)
# if len(unique) == 1:
# k = unique.pop()
# if k == 1:
# ans = i
# elif g.count(k) == 1:
# ans = i
# elif len(unique) == 2:
# if 1 in unique and g.count(1) == 1:
# ans = i
# else:
# a, b = unique
# if a < b:
# b, a = a, b
# if a - b == 1 and g.count(a) == 1:
# ans = i
# print(ans + 1)
# m, n = map(int, input().split())
# a = [list(map(int, input().split())) for i in range(m)]
# b = [list(map(int, input().split())) for j in range(m)]
# ans = 'Possible'
# for i in range(m):
# j = 0
# a[i][0], b[i][0] = ((a[i][j], b[i][j]), (b[i][j], a[i][j]))[a[i][j] > b[i][j]]
# if i and (a[i][j] <= a[i - 1][j] or b[i][j] <= b[i - 1][j]):
# ans = 'Impossible'
# break
# if ans == 'Possible':
# for j in range(n):
# i = 0
# a[i][j], b[i][j] = ((a[i][j], b[i][j]), (b[i][j], a[i][j]))[a[i][j] > b[i][j]]
# if j and (a[i][j] <= a[i][j - 1] or b[i][j] <= b[i][j - 1]):
# ans = 'Impossible'
# break
#
# if ans == 'Possible':
# for i in range(1, m):
# if ans == 'Possible':
# for j in range(1, n):
# a[i][j], b[i][j] = ((a[i][j], b[i][j]), (b[i][j], a[i][j]))[a[i][j] > b[i][j]]
# if a[i][j] <= a[i - 1][j] or a[i][j] <= a[i][j - 1]:
# ans = 'Impossible'
# break
# if b[i][j] <= b[i - 1][j] or b[i][j] <= b[i][j - 1]:
# ans = 'Impossible'
# break
# print(ans)
# n = int(input())
# a = list(map(int, input().split()))
# ans = float('inf')
# for i in range(n):
# ans = min(ans, a[i] // max(i, n - i - 1))
# print(ans)
# import string
# alpha = string.ascii_lowercase
# for t in range(int(input())):
# s = input()
# a = [ord(ch) - ord('a') for ch in s]
# a.sort()
# odd, even = [], []
# for ch in a:
# if ch % 2:
# odd.append(ch)
# else:
# even.append(ch)
# if odd and even:
# b = odd + even if abs(odd[-1] - even[0]) > 1 else even + odd
# else:
# b = (odd, even)[not len(odd)]
# ans = ''
# for i in range(1, len(b)):
# if abs(b[i] - b[i - 1]) == 1:
# ans = 'No answer'
# break
# if ans == '':
# for i in range(len(b)):
# ans += alpha[b[i]]
# print(ans)
# n = int(input())
# s = input()
# eight = s.count('8')
# ans = 'YES'
# if (n - 11) // 2 >= eight or eight == 0:
# ans = 'NO'
# if ans == 'YES':
# cnt, e, i = 0, 0, 0
# while e <= (n - 11) // 2:
# if s[i] == '8':
# e += 1
# else:
# cnt += 1
# i += 1
# if cnt > (n - 11) // 2:
# ans = 'NO'
# print(ans)
# m, n, h = map(int, input().split())
# front = list(map(int, input().split())) # n
# left = list(map(int, input().split())) # m
# up = [list(map(int, input().split())) for i in range(m)]
# for i in range(m):
# for j in range(n):
# if up[i][j]:
# up[i][j] = min(left[i], front[j])
# for row in up:
# print(' '.join((str(i) for i in row)))
# x = int(input())
# c, ans = 0, []
# for i in range(40):
# if x == (2**len(format(x, 'b')) - 1):
# break
# if i % 2:
# x += 1
# else:
# ans.append(len(format(x, 'b')))
# x = x ^ (2**ans[-1] - 1)
# c += 1
# print(c)
# if c:
# print(' '.join((str(i) for i in ans)))
# m, n = map(int, input().split())
# a = [list(map(int, input().split())) for i in range(m)]
# b = a[0][0]
# ans = [1] * m
# for i in range(1, m):
# b = b ^ a[i][0]
# for i in range(m):
# for j in range(n):
# if b ^ a[i][0] ^ a[i][j] != 0:
# ans[i] = j + 1
# print('TAK')
# exit(print(*ans))
# break
# print('NIE')
n = int(input())
a = [list(ch for ch in input()) for i in range(n)]
for i in range(n - 2):
for j in range(n - 2):
if a[i][j] == '#':
if all(a[I][J] == '.' for I, J in ((i, j + 1),
(i + 1, j), (i + 1, j + 1), (i + 1, j + 2),
(i + 2, j + 1))):
for I, J in ((i, j + 1),
(i + 1, j), (i + 1, j + 1), (i + 1, j + 2),
(i + 2, j + 1)):
a[I][J] = '#'
for i in range(n):
for j in range(n):
if a[i][j] == '.':
exit(print('NO'))
print('YES')
| 900 |
PYTHON3
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x;
scanf("%d%d", &n, &x);
int res = 0;
for (int i = 1; i <= n; ++i)
if (x % i == 0 && x / i <= n) {
++res;
}
printf("%d\n", res);
return 0;
}
| 1,000 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int ans[100005], LOG[100005], n, w, q;
struct node {
int id, w;
bool operator<(node x) const { return w < x.w; }
} Q[100005];
struct Node {
int p, nxt, w;
bool operator<(Node x) const {
if (w == x.w) return nxt < x.nxt;
return w < x.w;
}
};
vector<Node> V;
int lim[100005], nxt[100005], maxn[17][100005], minn[17][100005], a[100005];
int query(int l, int r) {
int p = LOG[r - l + 1];
return max(maxn[p][l], maxn[p][r - (1 << p) + 1]) -
min(minn[p][l], minn[p][r - (1 << p) + 1]);
}
struct lct {
struct node {
int son[2], fa, rev, siz, val, maxn;
} tree[100005];
int stck[100005], top;
int ls(int p) { return tree[p].son[0]; }
int rs(int p) { return tree[p].son[1]; }
int fa(int p) { return tree[p].fa; }
int which(int p) {
if (rs(fa(p)) == p) return 1;
if (ls(fa(p)) == p) return 0;
return -1;
}
void pushup(int p) {
tree[p].siz = tree[ls(p)].siz + tree[rs(p)].siz + 1;
tree[p].maxn = tree[p].val;
if (tree[p].val == n + 1) tree[p].maxn = 0;
if (tree[ls(p)].maxn != n + 1)
tree[p].maxn = max(tree[p].maxn, tree[ls(p)].maxn);
if (tree[rs(p)].maxn != n + 1)
tree[p].maxn = max(tree[p].maxn, tree[rs(p)].maxn);
}
void pushdown(int p) {
if (tree[p].rev) {
tree[ls(p)].rev ^= 1;
tree[rs(p)].rev ^= 1;
swap(tree[p].son[0], tree[p].son[1]);
tree[p].rev = 0;
}
}
void rotate(int p) {
int f1 = fa(p), f2 = fa(f1);
pushdown(f2), pushdown(f1), pushdown(p);
int now1 = which(p), now2 = which(f1);
if (now1 == -1) return;
tree[f1].son[now1] = tree[p].son[now1 ^ 1];
tree[tree[p].son[now1 ^ 1]].fa = f1;
tree[p].son[now1 ^ 1] = f1;
tree[p].fa = f2;
tree[f1].fa = p;
if (now2 != -1) tree[f2].son[now2] = p;
pushup(f1);
pushup(p);
}
void splay(int p) {
int pp = p;
while (which(p) != -1) stck[++top] = p, p = fa(p);
stck[++top] = p;
while (top) pushdown(stck[top--]);
p = pp;
while (which(p) != -1) {
int f1 = fa(p);
if (which(f1) != -1) {
if (which(p) == which(f1))
rotate(f1);
else
rotate(p);
}
rotate(p);
}
}
void access(int p) {
int tmp = 0;
while (p) {
splay(p);
tree[p].son[1] = tmp;
pushup(p);
tmp = p;
p = fa(p);
}
}
void makeroot(int p) {
access(p);
splay(p);
tree[p].rev ^= 1;
}
int findroot(int p) {
access(p);
splay(p);
pushdown(p);
while (ls(p)) p = ls(p), pushdown(p);
splay(p);
return p;
}
void link(int x, int y) {
makeroot(x);
if (findroot(y) != x) tree[x].fa = y;
}
void cut(int x, int y) {
makeroot(x);
if (findroot(y) == x && !ls(y) && tree[x].son[1] == y) {
tree[x].son[1] = tree[y].fa = 0;
pushup(x);
}
}
} LCT;
int main() {
cin >> n >> w >> q;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= q; i++) cin >> Q[i].w;
for (int i = 1; i <= q; i++) {
Q[i].w = w - Q[i].w;
Q[i].id = i;
}
sort(Q + 1, Q + q + 1);
for (int i = 1; i <= n; i++) {
maxn[0][i] = a[i];
minn[0][i] = a[i];
}
for (int i = 1; i <= 16; i++)
for (int j = 1; j + (1 << i) - 1 <= n; j++) {
maxn[i][j] = max(maxn[i - 1][j], maxn[i - 1][j + (1 << i - 1)]);
minn[i][j] = min(minn[i - 1][j], minn[i - 1][j + (1 << i - 1)]);
}
int block = 40;
for (int i = 2; i <= n; i++) LOG[i] = LOG[i >> 1] + 1;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= block; j++) {
int r = i + j;
if (r > n) break;
int tmp = query(i, r);
V.push_back(Node{i, r, tmp});
}
if (i + block + 1 <= n)
lim[i] = query(i, i + block + 1);
else
lim[i] = query(i, n);
}
vector<pair<int, int> > v;
for (int i = 1; i <= n; i++) v.push_back(make_pair(lim[i], i));
int poss = 0;
sort(v.begin(), v.end());
for (int i = 1; i <= n; i++) {
LCT.tree[i].fa = i + 1;
LCT.tree[i].siz = 1;
LCT.tree[i].val = i;
nxt[i] = i;
}
sort(V.begin(), V.end());
int pos = 0;
for (int i = 1; i <= q; i++) {
int ww = Q[i].w;
while (pos < V.size() && V[pos].w <= ww) {
int p = V[pos].p;
LCT.cut(p, nxt[p] + 1);
nxt[p] = V[pos].nxt;
LCT.link(p, nxt[p] + 1);
pos++;
}
while (poss < v.size() && v[poss].first <= ww)
LCT.cut(v[poss].second, nxt[v[poss].second] + 1),
LCT.link(v[poss].second, n + 1), ++poss;
int p = 1;
bool flag = 0;
while (p != n + 1) {
if (lim[p] <= ww) {
int l = p, r = n, anss = n + 1;
while (l <= r) {
int mid = (l + r) >> 1;
if (query(p, mid) > ww)
anss = mid, r = mid - 1;
else
l = mid + 1;
}
if (!flag) ans[Q[i].id]++;
flag = 0;
p = anss;
} else {
LCT.makeroot(p);
LCT.access(n + 1);
LCT.splay(n + 1);
if (p == LCT.tree[n + 1].maxn) {
if (!flag) ans[Q[i].id]++;
p++;
continue;
}
if (flag) ans[Q[i].id]--;
ans[Q[i].id] += -1 + LCT.tree[n + 1].siz;
p = LCT.tree[n + 1].maxn;
flag = 1;
}
}
}
for (int i = 1; i <= q; i++) cout << ans[i] - 1 << '\n';
}
| 3,400 |
CPP
|
#!python3
from collections import deque, Counter
import array
from itertools import combinations, permutations
from math import sqrt, gcd, floor
import unittest
def read_int():
return int(input().strip())
def read_int_array():
return [int(i) for i in input().strip().split(' ')]
######################################################
n = read_int()
a = read_int_array()
d = a[0]
for e in a[1:]:
d = gcd(d, e)
if d == 1:
print(1)
exit()
divisors = 2
for x in range(2 if d % 2 == 0 else 3, int(d**.5)+1, 1 if d % 2 == 0 else 2 ):
if d % x == 0:
divisors += 2
if d**.5 % 1 == 0:
divisors -= 1
print(divisors)
| 1,300 |
PYTHON3
|
# Description of the problem can be found at http://codeforces.com/problemset/problem/160/B
n = int(input())
s = input()
l_1 = list()
l_2 = list()
for c in s[:n]:
l_1.append(int(c))
for c in s[n:]:
l_2.append(int(c))
l_1.sort()
l_2.sort()
if(l_1[0] == l_2[0]):
print("NO")
quit()
else:
g = l_1[0] > l_2[0]
for i in range(1, n):
if g and l_1[i] > l_2[i]:
pass
elif not g and l_1[i] < l_2[i]:
pass
else:
print("NO")
quit()
print("YES")
| 1,100 |
PYTHON3
|
t = int(input())
while t > 0:
n = int(input())
if n%2 != 0:
f = n - 3
o = f//2
print("7", end='')
for i in range(o):
print("1", end='')
else:
o = n//2
for i in range(o):
print("1", end='')
print(" ")
t = t - 1
| 900 |
PYTHON3
|
# from debug import debug
from collections import Counter
import sys;input = sys.stdin.readline
t = int(input())
for _ in range(t):
n = int(input())
lis = list(map(int, input().strip()))
c = [0]*(n+1)
for i in range(1, n+1): c[i] = c[i-1]+lis[i-1]
p = [(c[i] - i) for i in range(n+1)]
p = Counter(p)
ans = 0
for i in p.values(): ans += i*(i-1)//2
print(ans)
| 1,600 |
PYTHON3
|
#include <bits/stdc++.h>
using namespace std;
int N, M[3];
struct Criminal {
multiset<int> s;
void clear() { s.clear(); }
void insert(const int v) { s.insert(v); }
bool empty() { return s.empty(); }
int back() {
auto it = s.end();
return *--it;
}
void defeat(const int v) {
auto it = s.upper_bound(v);
if (it == s.begin()) return;
s.erase(--it);
}
void defeat(const int a, const int b) {
if (s.size() <= 1)
defeat(a + b);
else {
auto ita = s.begin(), itb = s.begin();
itb++;
if ((*ita) <= a && (*itb) <= b)
defeat(b), defeat(a);
else
defeat(a + b);
}
}
} CRIM;
int Solve() {
if (CRIM.back() > M[0] + M[1] + M[2]) return -1;
int ans = 0;
while (!CRIM.empty()) {
if (CRIM.back() <= M[2]) {
CRIM.defeat(M[2]);
CRIM.defeat(M[0], M[1]);
} else if (CRIM.back() <= M[0] + M[1])
CRIM.defeat(M[0] + M[1]), CRIM.defeat(M[2]);
else if (CRIM.back() <= M[0] + M[2])
CRIM.defeat(M[0] + M[2]), CRIM.defeat(M[1]);
else if (CRIM.back() <= M[1] + M[2])
CRIM.defeat(M[1] + M[2]), CRIM.defeat(M[0]);
else
CRIM.defeat(M[0] + M[1] + M[2]);
ans++;
}
return ans;
}
int main() {
while (scanf("%d", &N) == 1) {
CRIM.clear();
for (int i = 0; i < 3; i++) scanf("%d", &M[i]);
for (int i = 0, c; i < N; i++) scanf("%d", &c), CRIM.insert(c);
sort(M, M + 3);
int ans = Solve();
printf("%d\n", ans);
break;
}
return 0;
}
| 2,400 |
CPP
|
t = int(input())
while t:
t = t - 1
string = input()
size = len(string)
string1 = string[size::-1]
if (string1.find("op")) == 0:
print("FILIPINO")
if (string1.find("used")) == 0 or (string1.find("usam")) == 0:
print("JAPANESE")
if (string1.find("adinm")) == 0:
print("KOREAN")
| 800 |
PYTHON3
|
z=int(input())
while(z>0):
m,c,d=input().split()
n=int(m)
a=int(c)
b=int(d)
if(b<2*a and n>1):
if(n%2==0):
print(int(b*int(n/2)))
else:
print(int(b*int(n/2))+a)
else:
print(n*a)
z=z-1
| 800 |
PYTHON3
|
n = int(input())
a = list(map(int, input().rstrip().split()))
b = list(map(int, input().rstrip().split()))
diff = [0 for i in range(n)]
for i in range(n):
a_el = a[i]
diff[a_el-1] += i + n
b_el = b[i]
diff[b_el-1] += - i + n
diff[a_el-1] = diff[a_el-1] % n
diff[b_el-1] = diff[b_el-1] % n
frequency = [0 for i in range(n)]
for i in range(n):
el = diff[i]
frequency[el] += 1
print(max(frequency))
| 1,400 |
PYTHON3
|
n = input()
arr = [int(i) for i in input().split()]
min = 10**9 + 1
for i in arr:
if i < min:
min = i
indices = [i for i, x in enumerate(arr) if x == min]
d = len(arr) + 1
for i in range(len(indices) - 1):
temp = indices[i+1] - indices[i]
if temp < d:
d = temp
print(d)
| 1,100 |
PYTHON3
|
t=int(input())
for i in range(t):
n,m = list(map(int,input().rstrip().split()))
res = ['a']*(n)
temp=2*1e9;
low=0;
high=min(temp,(n*(n-1))/2);
mid=0;
index1=0;
while(low<=high):
mid=int((high+low)//2);
if((int(mid*(mid+1)))//2>=m):
index1=mid;
high=mid-1;
else:
low=mid+1;
index2=index1-((index1*(index1+1))//2-m+1);
u = n - index1 - 1
t = n - index2 - 1
res[u] = 'b'
res[t] = 'b'
print("".join(res))
| 1,300 |
PYTHON3
|
# -*- coding: utf-8 -*-
def main():
s = int(input())
ret = 0
for i in range(s):
ret += (1 / (s - i))
print(ret)
if __name__ == '__main__':
main()
| 1,000 |
PYTHON3
|
l = ['a', 'o', 'e', 'u', 'i', '1', '3', '5', '7', '9']
s = input()
result = len(list(filter(lambda x: x in l, s)))
print(result)
| 800 |
PYTHON3
|
#include <bits/stdc++.h>
using namespace std;
const int M = (int)1e5 + 10;
int n, m, ans[M], head[2 * M], f[M], cnt, low[M], pre[M], dfs_clock, vis[M];
struct node1 {
int to, w, next;
} e[2 * M];
struct node2 {
int a, b, w, pos;
bool operator<(const node2& y) const { return w < y.w; }
} a[M];
int find(int x) { return x == f[x] ? x : f[x] = find(f[x]); }
void add(int from, int to, int w) {
e[cnt].to = to;
e[cnt].w = w;
e[cnt].next = head[from];
head[from] = cnt++;
}
void merge(int x, int y) {
int fx = find(x), fy = find(y);
if (fx != fy) {
pre[fx] = pre[fy] = 0;
head[fx] = head[fy] = -1;
low[fx] = low[fy] = 0;
vis[fx] = vis[fy] = 0;
f[fx] = fy;
}
}
int dfs(int x, int p) {
int lowu = pre[x] = ++dfs_clock;
vis[x] = 1;
for (int i = head[x]; i != -1; i = e[i].next) {
int v = e[i].to;
if (!vis[v]) {
int lowv = dfs(v, e[i].w);
lowu = min(lowu, lowv);
if (lowv > pre[x]) ans[e[i].w] = 1;
} else if (e[i].w != p)
lowu = min(lowu, pre[v]);
}
return low[x] = lowu;
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) f[i] = i;
memset(head, -1, sizeof(head));
for (int i = 0; i < m; i++)
scanf("%d %d %d", &a[i].a, &a[i].b, &a[i].w), a[i].pos = i;
sort(a, a + m);
for (int i = 0; i < m; i++) {
int t = i;
while (t + 1 < m && a[t].w == a[t + 1].w) t++;
for (int j = i; j <= t; j++) {
int fx = find(a[j].a), fy = find(a[j].b);
if (fx != fy) {
ans[a[j].pos] = 2;
add(fx, fy, a[j].pos);
add(fy, fx, a[j].pos);
}
}
for (int j = i; j <= t; j++) {
int fx = find(a[j].a), fy = find(a[j].b);
if (fx != fy && !vis[fx]) dfs(fx, -1);
if (fx != fy && !vis[fy]) dfs(fy, -1);
}
for (int j = i; j <= t; j++) merge(a[j].a, a[j].b);
i = t;
}
for (int i = 0; i < m; i++) {
if (ans[i] == 0)
printf("none\n");
else if (ans[i] == 1)
printf("any\n");
else
printf("at least one\n");
}
return 0;
}
| 2,300 |
CPP
|
a=[int(a) for a in input().split()]
b=[char for char in input()]
c=[char for char in input().split()]
r=0
s=0
k=0
while r<a[0]:
if b[r] not in c:
n=len(b[s:r])
k=k+(n*(n+1))//2
s=r+1
r=r+1
n=len(b[s:])
k=k+(n*(n+1))//2
print(k)
| 1,200 |
PYTHON3
|
d1, d2, d3 = map(int, input().split())
if d1 + d2 + d3 < d1 * 2 + d2 * 2 or min(d1, d2) * 2 + d3 * 2 < d1 * 2 + d2 * 2:
print(min((min(d1, d2) * 2 + d3 * 2), d1 + d2 + d3))
else:
print(d2 * 2 + d1 * 2)
| 800 |
PYTHON3
|
#include <bits/stdc++.h>
void print_perm(const std::vector<int>& p) {
bool is_first = true;
for (const auto c : p) {
if (is_first) {
std::cout << c;
is_first = false;
} else {
std::cout << ' ' << c;
}
}
std::cout << '\n';
}
int f(const std::vector<int>& p) {
int res = 0;
for (auto i = std::begin(p); i != std::end(p); i++) {
for (auto j = i; j != std::end(p); j++) res += *std::min_element(i, j + 1);
}
return res;
}
int main() {
int n;
int m;
std::cin >> n;
std::cin >> m;
std::vector<int> p(n);
for (int i = 0; i < n; i++) p.at(i) = i + 1;
int max_p = 0;
int n_lex = 0;
std::vector<int> res;
do {
int cur_p = f(p);
if (cur_p > max_p) {
max_p = cur_p;
n_lex = 1;
if (n_lex == m) res = p;
} else if (cur_p == max_p) {
n_lex++;
if (n_lex == m) res = p;
}
} while (std::next_permutation(p.begin(), p.end()));
print_perm(res);
}
| 1,400 |
CPP
|
def Sieve(n): #n以下の素数全列挙(O(nloglogn)) retは素数が入ってる。divlisはその数字の素因数が一つ入ってる
ret = []
divlis = [-1] * (n+1) #何で割ったかのリスト(初期値は-1)
flag = [True] * (n+1)
flag[0] = False
flag[1] = False
ind = 2
while ind <= n:
if flag[ind]:
ret.append(ind)
ind2 = ind ** 2
while ind2 <= n:
flag[ind2] = False
divlis[ind2] = ind
ind2 += ind
ind += 1
return ret,divlis
import sys
a = int(input())
slis,divlis = Sieve(1000)
for i in slis:
if a % i == 0:
ans = str(i) + str(a // i)
print (ans)
sys.exit()
| 0 |
PYTHON3
|
s = input()
t = input()
i = len(s) -1
x = list(s)
while (i>= 0 and x[i] == 'z'):
x[i] = 'a'
i-=1
if (i >= 0):
x[i] = chr(ord(s[i]) + 1)
x = ''.join(x)
if x < t:
print(x)
else:
print("No such string")
| 1,600 |
PYTHON3
|
#include <bits/stdc++.h>
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
using namespace std;
inline int get() {
int n;
char c;
while ((c = getchar()) || 23333) {
if (c == '-') goto s;
if (c >= '0' && c <= '9') break;
}
n = c - '0';
while ((c = getchar()) || 23333) {
if (c >= '0' && c <= '9')
n = n * 10 + c - '0';
else
return (n);
}
s:
while ((c = getchar()) || 23333) {
if (c >= '0' && c <= '9')
n = n * 10 - c + '0';
else
return (n);
}
}
int ints[300001];
typedef struct _n {
int me;
int you;
_n(int a, int b) {
me = a;
you = b;
}
friend bool operator<(const _n &a, const _n &b) {
return (ints[a.you] > ints[b.you]);
}
} node;
priority_queue<node> que;
int pointat[300001];
int main() {
int n = get();
for (register int i = 1; i <= n; i++) ints[i] = get(), pointat[i] = i;
long long ans = 0;
for (register int i = 1; i <= n; i++) {
if (que.empty()) {
que.push(_n(i, i));
continue;
}
if (ints[que.top().you] >= ints[i]) {
que.push(_n(i, i));
continue;
}
ans += (long long)ints[i] - ints[que.top().you];
node cjr = que.top();
que.pop();
if (cjr.me != cjr.you)
pointat[cjr.you] = cjr.you, que.push(_n(cjr.you, cjr.you));
pointat[i] = cjr.me;
pointat[cjr.me] = 0;
que.push(_n(cjr.me, i));
}
cout << ans << endl;
return (0);
}
| 2,400 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int iinf = 0x7fffffff;
const long long linf = ~(1LL << 63);
template <typename T>
inline T gcd(T a, T b) {
if (a < b) return gcd(b, a);
if (b == 0) return a;
return gcd(b, a % b);
}
template <typename C>
inline void sort(C& v) {
sort(v.begin(), v.end());
}
inline void println(int u) { printf("%d\n", u); }
inline void printsp(int u) { printf("%d ", u); }
const int maxn = 1010;
int main() {
ios::sync_with_stdio(0);
int T;
cin >> T;
while (T--) {
string target;
cin >> target;
for (int i = 0; i < target.size(); i++) {
if (target[i] == '\'') {
target = target.substr(i + 1);
break;
}
}
long long ten = 1;
long long key = 1989;
long long prefix = 198;
long long ans = 0;
while (target.size() > 0) {
ans += ten * (target[target.size() - 1] - '0');
target = target.substr(0, target.size() - 1);
while ((prefix * ten * 10 + ans <= key && ten > 1) ||
(prefix * ten * 10 + ans < key)) {
prefix += 1;
}
key = prefix * ten * 10 + ans;
prefix /= 10;
ten *= 10;
}
cout << key << endl;
}
return 0;
}
| 2,000 |
CPP
|
text = input()
if text[0].islower() and text[1:].isupper():
print("{0}{1}".format(text[0].upper(), text[1:].lower()))
elif text.isupper():
print(text.lower())
elif len(text) == 1 and text[0].islower():
print(text[0].upper())
else:
print(text)
| 1,000 |
PYTHON3
|
#include <bits/stdc++.h>
using namespace std;
template <class c>
struct rge {
c b, e;
};
template <class c>
rge<c> range(c i, c j) {
return {i, j};
}
struct printer {
~printer() { cerr << endl; }
template <class c>
printer& operator,(c x) {
cerr << boolalpha << x;
return *this;
}
printer& operator,(string x) {
cerr << x;
return *this;
}
template <class c, class d>
printer& operator,(pair<c, d> x) {
return *this, "(", x.first, ", ", x.second, ")";
}
template <class... d, template <class...> class c>
printer& operator,(c<d...> x) {
return *this, range(begin(x), end(x));
}
template <class c>
printer& operator,(rge<c> x) {
*this, "[";
for (auto it = x.b; it != x.e; ++it) *this, (it == x.b ? "" : ", "), *it;
return *this, "]";
}
};
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int my_rand(int l, int r) { return uniform_int_distribution<int>(l, r)(rng); }
const int N = 309;
int par[N], ar[N], leaf[N], vis[N][N];
vector<int> vec[N], order;
void dfs(int node) {
int i, sz = vec[node].size(), v;
for (i = 0; i < sz; i++) {
v = vec[node][i];
if (v != par[node]) {
par[v] = node;
dfs(v);
}
}
}
void clrparent(int n) {
for (int i = 1; i <= n; i++) {
par[i] = -1;
}
}
void path(int u) {
vector<int> temp;
while (1) {
temp.push_back(u);
if (par[u] == -1) break;
u = par[u];
}
int sz = temp.size(), a, b, last = -1, cur;
for (int i = sz - 1; i >= 0; i--) {
if (last == -1) {
last = temp[i];
} else {
order.push_back(temp[i]);
cur = temp[i];
a = min(last, cur);
b = max(last, cur);
vis[a][b]++;
last = cur;
}
}
}
int main() {
int n, i, u, v, j, ln = 0;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
for (j = 1; j <= n; j++) vis[i][j] = 0;
}
for (i = 1; i < n; i++) {
scanf("%d %d", &u, &v);
vec[u].push_back(v);
vec[v].push_back(u);
ar[u]++;
ar[v]++;
}
for (i = 1; i <= n; i++) {
if (ar[i] == 1 && i != 1) ln++;
}
for (i = 1; i <= ln; i++) {
scanf("%d", &leaf[i]);
}
order.push_back(1);
leaf[++ln] = 1;
int pre = 1;
for (i = 1; i <= ln; i++) {
clrparent(n);
dfs(pre);
path(leaf[i]);
pre = leaf[i];
}
int flag = true;
for (i = 1; i <= n && flag; i++) {
for (j = 1; j <= n && flag; j++) {
if (vis[i][j] > 2) flag = false;
}
}
if (flag) {
int sz = order.size();
for (i = 0; i < sz; i++) {
printf("%d ", order[i]);
}
printf("\n");
} else {
printf("-1\n");
}
return 0;
}
| 2,000 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 1000000007;
const int MV = 300002;
long long int pw(long long int x, long long int n) {
if (n == 0) return 1;
long long int tmp = pw(x, n / 2);
if (n % 2)
return (tmp * tmp % mod) * x % mod;
else
return tmp * tmp % mod;
}
long long int mod_inv(long long int x) { return pw(x, mod - 2); }
vector<long long int> pw2;
void fill_pw2() {
pw2.resize(MV);
pw2[0] = 1;
for (int i = 1; i < MV; i++) {
pw2[i] = pw2[i - 1] * 2;
pw2[i] %= mod;
}
}
vector<int> P, chk, invP;
void fill_P() {
chk = vector<int>(MV, 0);
for (int i = 2; i < MV; i++) {
if (chk[i]) continue;
P.push_back(i);
chk[i] = i;
int mul = 2;
while (i * mul < MV) {
chk[i * mul] = i;
mul++;
}
}
invP = vector<int>(MV, -1);
for (int i = 0; i < P.size(); i++) {
invP[P[i]] = i;
}
}
int N;
vector<int> T;
vector<vector<int> > E;
vector<long long int> cmb;
void fill_cmb() {
cmb = vector<long long int>(N, 0);
cmb[0] = 1;
for (int i = 1; i < N; i++) {
cmb[i] = cmb[i - 1] * (N - i) % mod;
cmb[i] *= mod_inv(i);
cmb[i] %= mod;
}
}
vector<long long int> psum;
void fill_psum() {
psum.resize(N);
for (int i = 0; i < N; i++) {
psum[i] = cmb[i];
if (i != 0) psum[i] += psum[i - 1];
}
}
void get_E() {
E.resize(P.size());
for (int i = 0; i < N; i++) {
int t = T[i];
int nowp = chk[t];
int cnt = 0;
if (!chk[t]) continue;
while (1) {
if (nowp == chk[t]) {
cnt++;
if (t == chk[t]) {
E[invP[nowp]].push_back(cnt);
nowp = chk[t];
break;
}
} else {
E[invP[nowp]].push_back(cnt);
nowp = chk[t];
cnt = 1;
if (t == chk[t]) {
E[invP[nowp]].push_back(cnt);
nowp = chk[t];
break;
}
}
t /= chk[t];
}
}
}
long long int ans;
void solve(int pidx) {
sort(E[pidx].begin(), E[pidx].end());
int zero = N - E[pidx].size();
long long int ans2 = 0;
for (int i = zero; i < N; i++) {
long long int tmp;
tmp = psum[N - i - 1] % mod;
tmp %= mod;
tmp *= E[pidx][i - zero];
tmp %= mod;
ans2 -= tmp;
ans2 %= mod;
}
for (int i = zero; i < N; i++) {
long long int tmp;
long long int tmp2 = (N - i - 1 == 0) ? 0 : psum[N - i - 2];
tmp = psum[N - 1] - tmp2;
tmp *= E[pidx][i - zero];
tmp %= mod;
ans2 += tmp;
ans2 %= mod;
}
ans += ans2;
ans %= mod;
}
int main() {
fill_P();
fill_pw2();
scanf("%d", &N);
T.resize(N);
for (int i = 0; i < N; i++) {
scanf("%d", &T[i]);
}
get_E();
fill_cmb();
fill_psum();
ans = 0;
for (int i = 0; i < P.size(); i++) {
solve(i);
}
if (ans < 0) ans += mod;
printf("%I64d", ans);
}
| 3,100 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int n;
long long a[150005];
map<long long, int> ma;
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
while (ma[a[i]] != 0) {
a[ma[a[i]]] = 0;
ma[a[i]] = 0;
a[i] *= 2;
}
ma[a[i]] = i;
}
int cnt = 0;
for (int i = 1; i <= n; i++) {
if (a[i]) cnt++;
}
cout << cnt << endl;
for (int i = 1; i <= n; i++) {
if (a[i]) cout << a[i] << ' ';
}
return 0;
}
| 1,600 |
CPP
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
void fio() {}
void pti() {
double timeuse = clock() * 1000.0 / CLOCKS_PER_SEC;
cerr << "Timeuse " << timeuse << "ms" << endl;
}
void end() {
pti();
exit(0);
}
namespace io {
const int SIZ = 55;
int que[SIZ], op, qr;
char ch;
template <class I>
inline void gi(I &w) {
ch = getchar(), op = 1, w = 0;
while (!isdigit(ch)) {
if (ch == '-') op = -1;
ch = getchar();
}
while (isdigit(ch)) {
w = w * 10 + ch - '0';
ch = getchar();
}
w *= op;
}
template <class I>
inline void print(I w) {
qr = 0;
if (!w) putchar('0');
if (w < 0) putchar('-'), w = -w;
while (w) que[++qr] = w % 10 + '0', w /= 10;
while (qr) putchar(que[qr--]);
}
} // namespace io
using io::gi;
using io::print;
const int N = 2e5 + 5;
struct pot {
int x, y;
bool operator==(const pot &a) const { return (x == a.x) && (y == a.y); }
};
int n;
pot s[N];
void solve(int l, int r) {
if (l >= r) return;
int mid = (l + r) >> 1;
for (int i = l; i <= r; ++i) s[++n] = {s[mid].x, s[i].y};
solve(l, mid - 1), solve(mid + 1, r);
}
int main() {
fio();
gi(n);
for (int i = 1; i <= n; ++i) gi(s[i].x), gi(s[i].y);
sort(s + 1, s + n + 1, [](pot a, pot b) { return a.x < b.x; });
solve(1, n);
sort(s + 1, s + n + 1,
[](pot a, pot b) { return a.x == b.x ? a.y < b.y : a.x < b.x; });
n = unique(s + 1, s + n + 1) - s - 1;
print(n), putchar(10);
for (int i = 1; i <= n; ++i)
print(s[i].x), putchar(' '), print(s[i].y), putchar(10);
end();
}
| 2,300 |
CPP
|
for t in range(int(input())):
n,p,k=map(int,input().split())
a=list(map(int,input().split()))
a.sort()
a.insert(0,0)
dp=[0]*(n+5)
for i in range(1,n+1):
if i<k:
dp[i]=dp[i-1]+a[i]
else:
dp[i]=dp[i-k]+a[i]
#print(dp)
for i in range(n,-1,-1):
#print(dp[i])
if p>=dp[i]:
ans=i
break
print(ans)
| 1,400 |
PYTHON3
|
n,m,a=list(map(int,input().split()))
c1,c2=0,0
c1=n//a
if(n%a):
c1=c1+1
c2=m//a
if(m%a):
c2=c2+1
print((c1)*(c2))
| 1,000 |
PYTHON3
|
n, m, k = map(int, input().split())
from collections import defaultdict
graph = defaultdict(list)
for i in range(0, m):
s, t = map(int, input().split())
graph[s].append(t)
graph[t].append(s)
i = 1
l = 1
res = []
visited = [False] * (n + 1)
while True:
visited[i] = True
res.append(i)
for e in graph[i]:
if not visited[e]:
i = e
l += 1
break
if visited[i]:
for j in range(0, l+1):
if i in graph[res[j]]:
print(l-j)
print(' '.join([str(x) for x in res[j:l]]))
exit(0)
| 1,800 |
PYTHON3
|
#include <bits/stdc++.h>
using namespace std;
int main() {
bool a, b, c, d;
cin >> a >> b >> c >> d;
bool aa = a ^ b, bb = c | d, cc = b & c, dd = a ^ d;
bool aaa = aa & bb, bbb = cc | dd;
cout << (aaa ^ bbb);
return 0;
}
| 2,000 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
int n, xx;
vector<int> G[MAXN], s;
int main() {
scanf("%d", &n);
for (int i = 0; i < n - 1; i++) {
int u, v;
scanf("%d%d", &u, &v);
G[u].push_back(v);
G[v].push_back(u);
}
vector<int> x;
int cnt = 0, s = 0;
for (int i = 1; i <= n; i++) {
if (G[i].size() == 1) x.push_back(i);
if (G[i].size() > 2) s = i, cnt++;
}
if (cnt >= 2)
printf("No\n");
else {
printf("Yes\n");
if (s == 0) {
printf("%d\n", 1);
printf("%d %d\n", x[0], x[1]);
} else {
printf("%d\n", x.size());
for (auto i : x) printf("%d %d\n", s, i);
}
}
return 0;
}
| 1,400 |
CPP
|
n=int(input())
for i in range(n):
a=list(map(int,input().split(' ')))
b=a[0]*a[1]
c=b//2+b%2
print(c)
| 800 |
PYTHON3
|
#include <bits/stdc++.h>
using namespace std;
void run() {
int a;
cin >> a;
vector<int> ans(a);
for (int i = 0; i < a; i++) cin >> ans[i];
vector<int> comp = ans;
int answer = 0;
sort(ans.begin(), ans.end());
for (int i = 0; i < a; i++) {
if (ans[i] != comp[i]) answer++;
}
if (answer > 2)
cout << "NO";
else
cout << "YES";
}
int main() { run(); }
| 1,300 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
long long a[25][25];
long long n, m, k;
map<long long, long long> dp[25];
void dfs(int x, int y, long long val) {
if (x > n || y > m) return;
val ^= a[x][y];
if (x + y == (n + m) / 2 + 1) {
dp[x][val]++;
return;
}
dfs(x + 1, y, val);
dfs(x, y + 1, val);
}
long long Ans(int x, int y, long long val) {
if (x < 1 || y < 1) return 0;
if (x + y == (n + m) / 2 + 1) {
return dp[x][val];
}
val ^= a[x][y];
return Ans(x - 1, y, val) + Ans(x, y - 1, val);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> a[i][j];
}
}
dfs(1, 1, 0);
cout << Ans(n, m, k) << endl;
return 0;
}
| 2,100 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, a, b, c, d, x, y;
cin >> n >> m;
cin >> a >> b >> c >> d;
x = abs(a - c);
y = abs(b - d);
if ((x == 0 && y < 5) || (y == 0 && x < 5))
cout << "First" << endl;
else if (x < 5 && y < 5 && (x + y) < 7)
cout << "First" << endl;
else
cout << "Second" << endl;
return 0;
}
| 2,000 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
struct edge {
int v;
int w;
};
struct vertex {
int t, c;
};
struct node {
int id;
long long int dis;
};
node h[1001] = {};
long long int cost[1001][1001] = {};
int h_p[1001] = {};
int h_size;
const long long mmax = 1125899906842624;
void decreasekey(int k) {
while (h[k].dis < h[k / 2].dis) {
swap(h[k], h[k / 2]);
swap(h_p[h[k].id], h_p[h[k / 2].id]);
k /= 2;
}
}
void downheap(int k) {
int j;
node tmp = h[k];
while (2 * k <= h_size) {
j = 2 * k;
if (j <= h_size && h[j].dis > h[j + 1].dis) ++j;
if (tmp.dis <= h[j].dis) break;
h[k] = h[j];
h_p[h[k].id] = k;
k = j;
}
h[k] = tmp;
h_p[tmp.id] = k;
}
node extract_min() {
node minimum = h[1];
h[1] = h[h_size];
h_p[h[1].id] = 1;
--h_size;
downheap(1);
return minimum;
}
void create_heap(int s) {
for (int i = 1; i <= h_size; ++i) {
h[i].id = i;
h[i].dis = mmax;
h_p[i] = i;
}
h[s].dis = 0;
swap(h[s], h[1]);
h_p[s] = 1;
h_p[1] = s;
}
int main() {
int m, n, u, v, w, t, c, x, y;
long long int arr[1001] = {};
list<edge> e[1001];
edge e_tmp;
vertex taxi[1001];
long long int d[1001] = {};
h[0].dis = -1;
node now;
cin >> n >> m >> x >> y;
for (int i = 0; i < m; ++i) {
cin >> u >> v >> w;
e_tmp.v = v;
e_tmp.w = w;
e[u].push_back(e_tmp);
e_tmp.v = u;
e[v].push_back(e_tmp);
}
for (int i = 1; i <= n; ++i) {
cin >> t >> c;
taxi[i].t = t;
taxi[i].c = c;
}
for (int i = 1; i <= n; ++i) {
h_size = n;
create_heap(i);
for (int k = 1; k <= n; ++k) {
arr[k] = mmax;
cost[i][k] = mmax;
}
arr[i] = 0;
cost[i][i] = 0;
while (h_size != 1) {
now = extract_min();
if (now.dis > taxi[i].t) break;
for (list<edge>::iterator it = e[now.id].begin(); it != e[now.id].end();
++it) {
if (arr[it->v] > arr[now.id] + it->w) {
arr[it->v] = arr[now.id] + it->w;
h[h_p[it->v]].dis = arr[it->v];
decreasekey(h_p[it->v]);
if (arr[it->v] <= taxi[i].t) cost[i][it->v] = taxi[i].c;
}
}
}
}
h_size = n;
create_heap(x);
for (int i = 1; i <= n; ++i) arr[i] = mmax;
arr[x] = 0;
while (h_size != 1) {
now = extract_min();
for (int i = 1; i <= n; ++i) {
if (arr[i] > arr[now.id] + cost[now.id][i]) {
arr[i] = arr[now.id] + cost[now.id][i];
h[h_p[i]].dis = arr[i];
decreasekey(h_p[i]);
}
}
}
if (arr[y] != mmax)
cout << arr[y] << endl;
else
cout << -1 << endl;
}
| 1,900 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.precision(10), cout << fixed;
int t;
cin >> t;
while (t--) {
int n, even = 0;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; ++i) {
cin >> v[i];
even += (v[i] & 1 ^ 1);
}
sort(v.begin(), v.end());
if (even & 1 ^ 1) {
cout << "YES\n";
} else {
bool flag = 0;
for (int i = 0; i < n - 1; ++i) flag |= (v[i + 1] - 1 == v[i]);
cout << (flag ? "YES" : "NO") << '\n';
}
}
return 0;
}
| 1,100 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
long long max(long long a, long long b) { return a > b ? a : b; }
long long min(long long a, long long b) { return a < b ? a : b; }
long long lowbit(long long x) { return x & (-x); }
long long prime(long long x) {
if (x <= 1) return false;
for (int i = 2; i <= int(sqrt(x)); i++) {
if (x % i == 0) return false;
}
return true;
}
bool cmp(long long a, long long b) { return a > b; }
long long gcd(long long a, long long b) {
long long r;
while (b > 0) {
r = a % b;
a = b;
b = r;
}
return a;
}
long long powmod(long long a, long long b, long long mod) {
if (b < 0) return 1;
long long res = 1;
a %= mod;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
inline int readint() {
int f = 1, x = 0;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch <= '9' && ch >= '0') x = x * 10 + ch - '0', ch = getchar();
return f * x;
}
inline long long readll() {
long long f = 1, x = 0;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch <= '9' && ch >= '0') x = x * 10 + ch - '0', ch = getchar();
return f * x;
}
void fl(string name) {
freopen((name + ".in").c_str(), "r", stdin);
freopen((name + ".out").c_str(), "w", stdout);
}
const int dx[8] = {-1, 1, 0, 0, -1, 1, -1, 1},
dy[8] = {0, 0, -1, 1, -1, -1, 1, 1};
const long long MAXN = 40;
long long n, tot, head[MAXN], in[MAXN];
pair<long long, long long> ans[MAXN];
struct EDGE {
long long nxt, to;
} edge[MAXN << 1];
void add_edge(long long u, long long v) {
edge[++tot].nxt = head[u];
edge[tot].to = v;
head[u] = tot;
}
long long pos[4][2] = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
void dfs(long long u, long long fa, long long x, long long y, long long tag,
long long from) {
long long tot = 0;
ans[u].first = x;
ans[u].second = y;
for (int i = head[u]; i; i = edge[i].nxt) {
long long v = edge[i].to;
if (v == fa) continue;
if (tot == from) tot++;
dfs(v, u, x + (1 << tag) * pos[tot][0], y + (1 << tag) * pos[tot][1],
tag - 1, (tot + 2) % 4);
tot++;
}
}
int main() {
n = readll();
for (int i = 1; i < n; i++) {
long long u = readll(), v = readll();
add_edge(u, v);
add_edge(v, u);
in[u]++;
in[v]++;
if (in[u] > 4 || in[v] > 4) {
puts("NO");
return 0;
}
}
dfs(1, 0, 0, 0, 30, -1);
puts("YES");
for (int i = 1; i <= n; i++)
printf("%lld %lld\n", ans[i].first, ans[i].second);
return 0;
}
| 2,000 |
CPP
|
import re
def remove(text):
return re.sub("[aeiouy]","",text)
a = remove(str(input()).lower())
s = ""
for i in range(len(a)):
s += '.'+a[i]
print(s)
| 1,000 |
PYTHON3
|
#include <bits/stdc++.h>
using namespace std;
int n, m, mm;
int kq = 1000000000;
int a[100005];
int b[100005];
void dauvao() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
void nhap() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
sort(a + 1, a + n + 1);
for (int i = 1; i <= m; i++) {
int u, v, h;
cin >> u >> v >> h;
if (u == 1) {
mm++;
b[mm] = v;
}
}
sort(b + 1, b + mm + 1);
int vt1 = 1;
int vt2 = 1;
while (vt1 <= n) {
while (vt2 <= mm && b[vt2] < a[vt1]) vt2++;
kq = min(kq, vt1 - 1 + mm - vt2 + 1);
vt1++;
}
while (vt2 <= mm && b[vt2] < 1000000000) vt2++;
kq = min(kq, n + mm - vt2 + 1);
cout << kq;
}
int main() {
dauvao();
nhap();
return 0;
}
| 1,700 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000 + 5;
bool ok[MAXN];
char a[MAXN][MAXN];
int n, m;
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%s", a[i]);
int ans = 0;
for (int col = 0; col < m; col++) {
bool flag = false;
for (int row = 0; row < n - 1; row++) {
if ((a[row][col] > a[row + 1][col]) && (ok[row] == false)) {
ans++;
flag = true;
break;
}
}
if (!flag) {
for (int row = 0; row < n - 1; row++)
if (a[row][col] < a[row + 1][col]) ok[row] = true;
}
}
cout << ans << endl;
return 0;
}
| 1,500 |
CPP
|
n=int(input())
l=list(map(int,input().split()))
l.sort()
c=1
a=l[0]
for i in range(1,len(l)):
if a<=l[i]:
a+=l[i]
c+=1
print(c)
| 1,300 |
PYTHON3
|
# -*- coding: utf-8 -*-
"""
Created on Sat Mar 7 19:30:45 2020
@author: hp
"""
t = int(input())
for j in range(t):
n,x,y = [int(i) for i in input().split()]
Sum = x+y
if(Sum<=n):
first = 1
last=Sum-1
else:
first = Sum-n+1
if(Sum == 2*n):
first = n
last = n
print(first,last)
| 1,700 |
PYTHON3
|
n,m,x,y=map(int,input().split())
d={'#':0,'.':1}
l=[[0,0] for i in range(m)]
for i in range(n):
s=input()
for j in range(m):
l[j][d[s[j]]]+=1
pb,pw=[0],[0]
for i in range(m):
pb.append(pb[-1]+l[i][0])
pw.append(pw[-1]+l[i][1])
dp=[[float('inf')]*(m+1) for i in range(2)]
dp[0][0]=dp[1][0]=0
for i in range(1,m+1):
for j in range(x,y+1):
if i-j>=0:
dp[0][i]=min(dp[0][i],dp[1][i-j]+pb[i]-pb[i-j])
dp[1][i]=min(dp[1][i],dp[0][i-j]+pw[i]-pw[i-j])
print(min(dp[0][-1],dp[1][-1]))
| 1,700 |
PYTHON3
|
#include <bits/stdc++.h>
using namespace std;
#define sz(x) ((int) ((x).size()))
typedef long long ll;
typedef long double ld;
int n, q, p[200100];
ll a[200100], b[200100];
int m[2][200100][18];
ll c[2][200100][18];
void computeTable(int k, int i) {
for (int b = 1; b < 18; b++) {
m[k][i][b] = m[k][m[k][i][b - 1]][b - 1];
c[k][i][b] = c[k][i][b - 1] + c[k][m[k][i][b - 1]][b - 1];
}
}
ll cost(int k, int i, int j) {
ll r = 0;
for (int b = 17; b >= 0; b--)
if (k == 0 && m[k][i][b] <= j || k == 1 && m[k][i][b] >= j)
r += c[k][i][b], i = m[k][i][b];
return r;
}
ll cost(int i, int j) {
return cost(0, i, j) + cost(1, j, i);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(10);
cin >> n >> q;
for (int i = 0; i < n; i++)
cin >> p[i], p[i]--;
p[n] = n;
for (int i = 0; i < n; i++)
cin >> a[i];
for (int i = 0; i < n; i++)
cin >> b[i];
stack<int> s;
s.push(n);
m[0][n][0] = n;
c[0][n][0] = 0;
computeTable(0, n);
for (int i = n - 1; i >= 0; i--) {
while (!s.empty() && p[s.top()] < p[i])
s.pop();
if (s.empty()) {
m[0][i][0] = i;
c[0][i][0] = 0;
} else {
int j = s.top();
m[0][i][0] = j;
c[0][i][0] = min(b[i], a[i] + cost(0, i + 1, j));
}
computeTable(0, i);
s.push(i);
}
while (!s.empty())
s.pop();
for (int i = 0; i <= n; i++) {
while (!s.empty() && p[s.top()] < p[i])
s.pop();
if (s.empty()) {
m[1][i][0] = i;
c[1][i][0] = 0;
} else {
int j = s.top();
m[1][i][0] = j;
c[1][i][0] = a[j] + cost(0, j + 1, i);
}
computeTable(1, i);
s.push(i);
}
set<int> cs;
cs.insert(0);
cs.insert(n);
ll res = cost(0, n);
int x;
for (int i = 0; i < q; i++) {
cin >> x, x--;
if (x > 0) {
int f = 1;
if (cs.find(x) != cs.end())
cs.erase(cs.find(x)), f = -1;
auto it = cs.lower_bound(x);
int k = *it;
it--;
int j = *it;
res += f * (cost(j, x) + cost(x, k) - cost(j, k));
if (f == 1)
cs.insert(x);
}
cout << res << "\n";
}
}
| 3,300 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
bool magical(string s) {
for (int i = 0; i < s.size(); i++)
if (s[i] != '1' && s[i] != '4') return false;
if (s[0] == '4') return false;
if (s.find("444") != string::npos) return false;
return true;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
string s;
cin >> s;
cout << (magical(s) ? "YES\n" : "NO\n");
}
| 900 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
vector<long long> v[26];
for (long long i = 0; i < s.size(); i++) {
v[s[i] - 'a'].push_back(i);
}
long long it = -1;
for (long long i = 25; i >= 0; i--) {
if (!v[i].size() == 0) {
for (int j = 0; j < v[i].size(); j++) {
if (v[i][j] > it) cout << (char)(i + 'a');
}
if (v[i][v[i].size() - 1] > it) it = v[i][v[i].size() - 1];
}
}
}
| 1,100 |
CPP
|
t = int(input())
for t in range(0, t):
n, k = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
b = [int(x) for x in input().split()]
for i in range(0, k):
x = min(a)
y = max(b)
x_index = a.index(x)
y_index = b.index(y)
if y > x:
a[x_index] = y
b[y_index] = x
x = sum(a)
print(x)
| 800 |
PYTHON3
|
for t in range(int(input())):
n, x = map(int, input().split())
n -= 2
if n <= 0:
print(1)
else:
print((n+x-1)//x+1)
| 800 |
PYTHON3
|
#include <bits/stdc++.h>
using namespace std;
const double EPS = 10e-11;
class VagueDouble {
public:
double vd;
VagueDouble() { vd = nan(""); }
VagueDouble(const double d) { vd = d; }
inline VagueDouble operator-() const { return VagueDouble(-vd); }
inline VagueDouble operator+(const VagueDouble VD) const {
return VagueDouble(vd + VD.vd);
}
inline VagueDouble operator-(const VagueDouble VD) const {
return VagueDouble(vd - VD.vd);
}
inline VagueDouble operator*(const VagueDouble VD) const {
return VagueDouble(vd * VD.vd);
}
inline VagueDouble operator/(const VagueDouble VD) const {
return VagueDouble(vd / VD.vd);
}
inline VagueDouble operator+(const double d) const {
return VagueDouble(vd + d);
}
inline VagueDouble operator-(const double d) const {
return VagueDouble(vd - d);
}
inline VagueDouble operator*(const double d) const {
return VagueDouble(vd * d);
}
inline VagueDouble operator/(const double d) const {
return VagueDouble(vd / d);
}
inline bool operator<(const VagueDouble VD) const {
return vd + EPS < VD.vd && vd + EPS * abs(vd) < VD.vd;
}
inline bool operator>(const VagueDouble VD) const {
return vd - EPS > VD.vd && vd - EPS * abs(vd) > VD.vd;
}
inline bool operator==(const VagueDouble VD) const {
return !(*this < VD.vd) && !(*this > VD.vd);
}
inline bool operator<(const double d) const { return *this < VagueDouble(d); }
inline bool operator>(const double d) const { return *this > VagueDouble(d); }
inline bool operator==(const double d) const {
return *this == VagueDouble(d);
}
inline void operator+=(const VagueDouble VD) { *this = *this + VD; }
inline void operator-=(const VagueDouble VD) { *this = *this - VD; }
inline void operator*=(const VagueDouble VD) { *this = *this * VD; }
inline void operator/=(const VagueDouble VD) { *this = *this / VD; }
inline friend VagueDouble operator+(const double d, const VagueDouble &VD) {
return VagueDouble(d) + VD;
}
inline friend VagueDouble operator-(const double d, const VagueDouble &VD) {
return VagueDouble(d) - VD;
}
inline friend VagueDouble operator*(const double d, const VagueDouble &VD) {
return VagueDouble(d) * VD;
}
inline friend VagueDouble operator/(const double d, const VagueDouble &VD) {
return VagueDouble(d) / VD;
}
inline friend bool operator<(const double d, const VagueDouble &VD) {
return VagueDouble(d) < VD;
}
inline friend bool operator>(const double d, const VagueDouble &VD) {
return VagueDouble(d) > VD;
}
inline friend bool operator==(const double d, const VagueDouble &VD) {
return VagueDouble(d) == VD;
}
inline double to_double() { return vd; }
inline friend std::ostream &operator<<(std::ostream &os,
const VagueDouble VD) {
os << VD.vd;
return os;
}
inline friend std::istream &operator>>(std::istream &is, VagueDouble &VD) {
double d;
is >> d;
VD = VagueDouble(d);
return is;
}
};
inline VagueDouble abs(VagueDouble VD) {
return (VD.vd < 0) ? (-VD.vd) : VD.vd;
}
inline VagueDouble sqr(VagueDouble VD) { return VD.vd * VD.vd; }
inline VagueDouble sqr(double d) { return d * d; }
inline VagueDouble sqrt(VagueDouble VD) { return VagueDouble(sqrt(VD.vd)); }
inline bool isnan(VagueDouble VD) { return isnan(VD.vd); }
class P {
private:
public:
VagueDouble x, y;
P() {
x = nan("");
y = nan("");
}
P(double _x, double _y) {
x = _x;
y = _y;
}
P(VagueDouble _x, VagueDouble _y) {
x = _x;
y = _y;
}
P operator-() const { return P(-x, -y); }
P operator+(const P p) const { return P(x + p.x, y + p.y); }
P operator-(const P p) const { return P(x - p.x, y - p.y); }
P operator*(const double d) const { return P(x * d, y * d); }
P operator/(const double d) const { return P(x / d, y / d); }
bool operator<(const P &p) const {
return (x == p.x) ? (y < p.y) : (x < p.x);
}
bool operator>(const P &p) const {
return (x == p.x) ? (y > p.y) : (x > p.x);
}
bool operator==(const P &p) const { return (x == p.x) && (y == p.y); }
void operator+=(const P &p) { *this = *this + p; }
void operator-=(const P &p) { *this = *this - p; }
void operator*=(const double &p) { *this = *this * p; }
void operator/=(const double &p) { *this = *this / p; }
friend std::ostream &operator<<(std::ostream &os, const P &p) {
os << p.x.vd << " " << p.y.vd;
return os;
}
friend std::istream &operator>>(std::istream &is, P &p) {
double _x, _y;
is >> _x >> _y;
p = P(_x, _y);
return is;
}
};
inline VagueDouble dist(P p0, P p1) {
return sqrt(sqr(p0.x - p1.x) + sqr(p0.y - p1.y));
}
inline VagueDouble area(P p0, P p1, P p2) {
return abs((p1.x - p0.x) * (p2.y - p0.y) - (p2.x - p0.x) * (p1.y - p0.y)) /
0.5;
}
inline bool isnan(P p) { return isnan(p.x); }
VagueDouble distPL(P l0, P l1, P p) {
if (l0 == l1) return dist(l0, p);
VagueDouble dx = l0.x - l1.x;
VagueDouble dy = l0.y - l1.y;
return abs(dy * (l0.x - p.x) - dx * (l0.y - p.y)) / sqrt(dx * dx + dy * dy);
}
bool onLine(P l0, P l1, P p) {
if (l0 == l1) return l0 == p;
if (p.x < min(l0.x, l1.x) || max(l0.x, l1.x) < p.x) return false;
if (p.y < min(l0.y, l1.y) || max(l0.y, l1.y) < p.y) return false;
return distPL(l0, l1, p) == 0;
}
P findCross(P a0, P a1, P b0, P b1) {
P a = a0 - a1, b = b0 - b1, res;
VagueDouble den = (a.x * b.y - a.y * b.x);
if (den == 0) return P();
res.x =
(a.x * b.x * (a0.y - b0.y) + a.x * b.y * b0.x - a.y * b.x * a0.x) / den;
if (res.x < min(a0.x, a1.x) || max(a0.x, a1.x) < res.x) return P();
if (res.x < min(b0.x, b1.x) || max(b0.x, b1.x) < res.x) return P();
res.y =
-(a.y * b.y * (a0.x - b0.x) + a.y * b.x * b0.y - a.x * b.y * a0.y) / den;
if (res.y < min(a0.y, a1.y) || max(a0.y, a1.y) < res.y) return P();
if (res.y < min(b0.y, b1.y) || max(b0.y, b1.y) < res.y) return P();
return res;
}
class Polygon {
private:
public:
vector<P> points;
Polygon() {}
Polygon(vector<P> vec) { points = vec; }
Polygon(int num) { points.resize(num); }
int size() { return ((int)(points).size()); }
P &operator[](int pos) { return points[pos]; }
bool onPoly(P p) {
int n = ((int)(points).size());
for (int i = 0; i < ((int)(n)); ++i)
if (onLine(points[i], points[(i + 1) % n], p)) return true;
return false;
}
bool inPoly(P p) {
int n = ((int)(points).size());
if (n == 0) return false;
if (onPoly(p)) return true;
P right_point = p;
for (int i = 0; i < ((int)(n)); ++i)
right_point.x = max(right_point.x, points[i].x);
if (right_point == p) return false;
int cnt = 0;
for (int i = 0; i < ((int)(n)); ++i) {
P cross = findCross(points[i], points[(i + 1) % n], p, right_point);
if (!isnan(cross)) cnt++;
}
for (int i = 0; i < ((int)(((int)(points).size()))); ++i)
if (onLine(p, right_point, points[i])) {
VagueDouble dy0 = points[(i - 1 + n) % n].y - p.y;
VagueDouble dy1 = points[(i + 1 + n) % n].y - p.y;
if (dy0 * dy1 < 0) cnt++;
}
return cnt % 2 == 1;
}
friend std::ostream &operator<<(std::ostream &os, Polygon &poly) {
for (int i = 0; i < ((int)(((int)(poly).size()))); ++i)
os << poly[i] << " ";
return os;
}
friend std::istream &operator>>(std::istream &is, Polygon &poly) {
for (int i = 0; i < ((int)(((int)(poly).size()))); ++i) is >> poly[i];
return is;
}
};
int main() {
int n;
cin >> n;
vector<Polygon> base(n, Polygon(3));
for (int i = 0; i < ((int)(n)); ++i) cin >> base[i];
set<P> seg[10005];
for (int i = 0; i < ((int)(((int)(base).size()))); ++i)
for (int j = 0; j < ((int)(((int)(base[i]).size()))); ++j)
seg[i * 3 + j].insert(base[i][(j + 0) % 3]);
for (int i = 0; i < ((int)(((int)(base).size()))); ++i)
for (int j = 0; j < ((int)(((int)(base[i]).size()))); ++j)
seg[i * 3 + j].insert(base[i][(j + 1) % 3]);
for (int i = 0; i < ((int)(((int)(base).size()))); ++i)
for (int j = 0; j < ((int)(((int)(base[i]).size()))); ++j)
for (int k = 0; k < ((int)(((int)(base).size()))); ++k)
for (int l = 0; l < ((int)(((int)(base[k]).size()))); ++l) {
if (i == k) continue;
P cross = findCross(base[i][j], base[i][(j + 1) % 3], base[k][l],
base[k][(l + 1) % 3]);
if (isnan(cross)) continue;
seg[i * 3 + j].insert(cross);
}
VagueDouble res = 0.0;
vector<P> vec[10005];
for (int i = 0; i < ((int)(((int)(base).size()))); ++i)
for (int j = 0; j < ((int)(((int)(base[i]).size()))); ++j)
for (__typeof((seg[i * 3 + j]).begin()) it = (seg[i * 3 + j]).begin();
it != (seg[i * 3 + j]).end(); it++)
vec[i * 3 + j].push_back(*it);
for (int i = 0; i < ((int)(((int)(base).size()))); ++i)
for (int j = 0; j < ((int)(((int)(base[i]).size()))); ++j)
for (int k = 0; k < ((int)(((int)(vec[i * 3 + j]).size()) - 1)); ++k) {
P mid = (vec[i * 3 + j][k] + vec[i * 3 + j][k + 1]) / 2.0;
bool ok = true;
for (int l = 0; l < ((int)(((int)(base).size()))); ++l)
if (i != l && base[l].inPoly(mid)) {
ok = false;
break;
}
if (ok) res += dist(vec[i * 3 + j][k], vec[i * 3 + j][k + 1]);
}
printf("%0.20lf\n", res.to_double());
}
| 2,300 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
int main() {
long long n, a, b, p, q;
cin >> n >> a >> b >> p >> q;
long long m1 = p * (n / a), m2 = q * (n / b);
long long gcdd = a * b / gcd(a, b);
long long pq = min(p, q);
cout << m1 + m2 - pq * (n / gcdd) << endl;
}
| 1,600 |
CPP
|
#include <bits/stdc++.h>
double sum1, sum2, sum3, dp[110][110][110];
int a, b, c, t;
int main() {
scanf("%d%d%d", &a, &b, &c);
dp[a][b][c] = 1.0;
for (int i = a; i >= 0; i--)
for (int j = b; j >= 0; j--)
for (int k = c; k >= 0; k--) {
t = i * j + j * k + i * k;
if (i && j) dp[i][j - 1][k] += dp[i][j][k] * (1.0 * i * j) / t;
if (i && k) dp[i - 1][j][k] += dp[i][j][k] * (1.0 * i * k) / t;
if (j && k) dp[i][j][k - 1] += dp[i][j][k] * (1.0 * j * k) / t;
}
for (int i = 1; i <= a; i++) sum1 += dp[i][0][0];
for (int i = 1; i <= b; i++) sum2 += dp[0][i][0];
for (int i = 1; i <= c; i++) sum3 += dp[0][0][i];
printf("%.9lf %.9lf %.9lf\n", sum1, sum2, sum3);
return 0;
}
| 1,900 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 200005;
const int N = 100005;
const int M = N << 1;
vector<int> v1, v2;
int main() {
int n;
while (cin >> n) {
int val;
v1.clear();
v2.clear();
int last = 1;
long long t1 = 0, t2 = 0;
for (int i = 0; i < n; i++) {
cin >> val;
if (val > 0) {
t1 += val;
v1.push_back(val);
} else {
t2 += (-val);
v2.push_back(-val);
}
if (i == n - 1 && val < 0) last = 2;
}
if (t1 != t2) {
cout << (t1 > t2 ? "first" : "second") << endl;
continue;
}
int i = 0, j = 0, flag = 0;
while (i < v1.size() && j < v2.size()) {
if (v1[i] > v2[j]) {
flag = 1;
break;
} else if (v1[i] < v2[j]) {
flag = 2;
break;
}
i++, j++;
}
if (flag == 0) {
if (v1.size() == v2.size())
flag = last;
else if (v2.size() > v1.size())
flag = 2;
else
flag = 1;
}
cout << (flag == 1 ? "first" : "second") << endl;
}
return 0;
}
| 1,400 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
struct point {
double x, y;
point() { x = y = 0.0; }
point(double _x, double _y) : x(_x), y(_y) {}
bool operator<(point other) const {
if (fabs(x - other.x) > 1e-9) return x < other.x;
return y < other.y;
}
bool operator>(point other) const {
if (fabs(x - other.x) > 1e-9) return x > other.x;
return y > other.y;
}
bool operator==(point other) const {
return (fabs(x - other.x) < 1e-9 && (fabs(y - other.y) < 1e-9));
}
};
double DEG_to_RAD(double t) { return t * M_PI / 180.0; }
double RAD_to_DEG(double t) { return t * 180.0 / M_PI; }
point rotate(point p, double theta) {
double rad = DEG_to_RAD(theta);
point t;
if (fabs(p.x * cos(rad) - p.y * sin(rad)) < 1e-9)
t.x = 0.0;
else
t.x = p.x * cos(rad) - p.y * sin(rad);
if (fabs(p.x * sin(rad) + p.y * cos(rad)) < 1e-9)
t.y = 0.0;
else
t.y = p.x * sin(rad) + p.y * cos(rad);
return t;
}
double dist(point p1, point p2) { return hypot(p1.x - p2.x, p1.y - p2.y); }
struct line {
double a, b, c;
};
void pointsToLine(point p1, point p2, line &l) {
if (fabs(p1.x - p2.x) < 1e-9) {
l.a = 1.0;
l.b = 0.0;
l.c = -p1.x;
} else {
l.a = -(double)(p1.y - p2.y) / (p1.x - p2.x);
l.b = 1.0;
l.c = -(double)(l.a * p1.x) - p1.y;
}
}
void point_and_m_ToLine(point p, double m, line &l) {
l.a = -1 * m;
l.b = 1;
l.c = m * p.x - p.y;
}
bool areParallel(line l1, line l2) {
return (fabs(l1.a - l2.a) < 1e-9) && (fabs(l1.b - l2.b) < 1e-9);
}
bool areSame(line l1, line l2) {
return areParallel(l1, l2) && (fabs(l1.c - l2.c) < 1e-9);
}
bool areIntersect(line l1, line l2, point &p) {
if (areParallel(l1, l2)) return false;
p.x = (l2.b * l1.c - l1.b * l2.c) / (l2.a * l1.b - l1.a * l2.b);
if (fabs(l1.b) > 1e-9)
p.y = -(l1.a * p.x + l1.c);
else
p.y = -(l2.a * p.x + l2.c);
return true;
}
struct vec {
double x, y;
vec(double _x, double _y) : x(_x), y(_y) {}
};
vec toVec(point a, point b) { return vec(b.x - a.x, b.y - a.y); }
vec scale(vec v, double s) { return vec(v.x * s, v.y * s); }
point translate(point p, vec v) {
point t;
if (fabs(p.x + v.x) < 1e-9)
t.x = 0.0;
else
t.x = p.x + v.x;
if (fabs(p.y + v.y) < 1e-9)
t.y = 0.0;
else
t.y = p.y + v.y;
return t;
}
double dot(vec a, vec b) { return (a.x * b.x + a.y * b.y); }
double norm_sq(vec v) { return v.x * v.x + v.y * v.y; }
double distToLine(point p, point a, point b, point &c) {
vec ap = toVec(a, p), ab = toVec(a, b);
double u = dot(ap, ab) / norm_sq(ab);
c = translate(a, scale(ab, u));
return dist(p, c);
}
double distToLineSegment(point p, point a, point b, point &c) {
vec ap = toVec(a, p), ab = toVec(a, b);
double u = dot(ap, ab) / norm_sq(ab);
if (u < 0.0) {
c = point(a.x, a.y);
return dist(p, a);
}
if (u > 1.0) {
c = point(b.x, b.y);
return dist(p, b);
}
return distToLine(p, a, b, c);
}
double angle(point a, point o, point b) {
vec oa = toVec(o, a), ob = toVec(o, b);
return acos(dot(oa, ob) / sqrt(norm_sq(oa) * norm_sq(ob)));
}
long long Pow(long long b, long long p) {
if (p == 0) return 1;
if (p == 1) return b;
if (p % 2 == 1) return b * Pow(b, p - 1);
long long r = Pow(b, p / 2);
return r * r;
}
double Triangle_area(double a, double b, double c) {
double v = 0.5 * (a + b + c);
return sqrt(v * (v - a) * (v - b) * (v - c));
}
long double teta(long double a, long double b, long double c) {
long double s = Triangle_area(a, b, c);
if (c > (sqrt(Pow(a, 2) + Pow(b, 2))))
return M_PI - (asin((2 * s) / (a * b)));
else
return (asin((2 * s) / (a * b)));
}
double get_height(point a, point b, point c) {
double tet = angle(b, a, c);
return sin(tet) * dist(a, b);
}
int main() {
point a[100005];
int n;
double m = 1e15;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i].x >> a[i].y;
for (int i = 0; i < n; i++) {
point p1 = a[i];
point p2 = a[(i + 1) % n];
point p3 = a[(i + 2) % n];
point p4;
double t = distToLineSegment(p2, p1, p3, p4);
t /= 2;
m = min(m, t);
}
cout << fixed << setprecision(10) << m;
return 0;
}
| 1,800 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
string s, t[2000006];
int pos[2000006];
vector<int> v[2000006];
int main() {
int n, k, i, j;
cin >> n >> k;
if (k == n - 1) {
cout << 2 << endl;
for (i = 2; i <= n; i++) cout << i << " " << 1 << endl;
return 0;
}
if (n == 3) {
cout << 2 << endl;
cout << 1 << " " << 2 << endl;
cout << 1 << " " << 3 << endl;
return 0;
}
int r = 0;
for (i = 2; i <= 2 + k - 1; i++) {
v[r].push_back(i);
}
r++;
int st = 2 + k;
for (i = st; i <= n; i += k) {
for (j = i; j < i + k; j++) {
if (j > n) break;
v[r].push_back(j);
}
r++;
}
if (v[r - 1].size() > 1)
cout << 2 * r << endl;
else
cout << 2 * r - 1 << endl;
for (i = 0; i < v[0].size(); i++) cout << 1 << " " << v[0][i] << endl;
for (i = 0; i < r; i++) {
for (j = 0; j < v[i].size(); j++) {
if (v[i + 1].size() > j && v[i][j] <= n && v[i + 1][j] <= n)
cout << v[i][j] << " " << v[i + 1][j] << endl;
}
}
return 0;
}
| 1,800 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int n;
int main() {
cin >> n;
if (n & 1)
cout << "black";
else {
cout << "white" << endl;
cout << 1 << " " << 2;
}
return 0;
}
| 1,700 |
CPP
|
s=str(input())
a=len(s)
c=0
l=[]
for i in s:
if i in l:
continue
else:
c=c+1
l.append(i)
if c%2==0:
print('CHAT WITH HER!')
else:
print('IGNORE HIM!')
| 800 |
PYTHON3
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int sz = s.size();
putchar(s[0]);
string cur = "";
bool at = false;
for (int i = 1; i < sz; ++i) {
if (cur == "" && (s[i] == 'd' || s[i] == 'a')) {
cur += s[i];
} else if (cur == "d" && s[i] == 'o')
cur += 'o';
else if (cur == "do" && s[i] == 't') {
if (i < sz - 1) {
putchar('.');
} else
printf("dot");
cur = "";
} else if (cur == "a" && s[i] == 't') {
if (at)
printf("at");
else {
putchar('@');
at = true;
}
cur = "";
} else {
printf(cur.c_str());
cur = "";
if (s[i] == 'a' || s[i] == 'd')
cur += s[i];
else
putchar(s[i]);
}
}
puts(cur.c_str());
return 0;
}
| 1,300 |
CPP
|
#include <bits/stdc++.h>
int main() {
int n, m, i, j;
scanf("%d %d", &n, &m);
int ara[m + 1];
for (i = 1; i < m + 1; i++) {
ara[i] = 0;
}
for (i = 0; i < n; i++) {
int t;
scanf("%d", &t);
for (j = 0; j < t; j++) {
int l;
scanf("%d", &l);
ara[l] = 1;
}
}
int count = 0;
for (i = 1; i < m + 1; i++) {
if (ara[i] != 0) {
count++;
}
}
if (count == m)
printf("YES\n");
else
printf("NO\n");
return 0;
}
| 800 |
CPP
|
l=[2,1,0,1,2]
for i in l:
s=input()
if '1'in s:
print(l[s.find('1')//2]+i)
| 800 |
PYTHON3
|
#include <bits/stdc++.h>
using namespace std;
char s[100010];
bool check[100010];
int cnt[100010];
int m;
int main() {
scanf("%s", s);
int n = strlen(s);
for (int i = 0; i < n - 1; i++) {
if (s[i] == s[i + 1]) check[i] = 1;
}
for (int i = 0; i < n; i++) {
if (check[i] == 1)
cnt[i] = cnt[i - 1] + 1;
else
cnt[i] = cnt[i - 1];
}
scanf("%d", &m);
for (int t = 0; t < m; t++) {
int l, r;
scanf("%d%d", &l, &r);
l--;
r--;
int a, b;
if (l - 1 < 0)
a = 0;
else
a = cnt[l - 1];
b = cnt[r - 1];
printf("%d\n", b - a);
}
return 0;
}
| 1,100 |
CPP
|
q=int(input())
for i in range(q):
n=int(input())
l=map(int,input().split())
l=list(l)
l.sort()
c=0
for x in range(n-1):
if(abs(l[x]-l[x+1])==1):
c+=1
if c==0:
print(1)
else:
print(2)
| 800 |
PYTHON3
|
#include <bits/stdc++.h>
using namespace std;
int ans[200005];
int main() {
ios::sync_with_stdio(false);
int a, b, c, d, aa, bb, cc, dd, aaa, bbb, ccc, ddd, aaaa, bbbb, cccc, dddd;
cin >> a >> b >> c >> d;
aaaa = aaa = aa = a, bbbb = bbb = bb = b, cccc = ccc = cc = c,
dddd = ddd = dd = d;
int all = a + b + c + d;
int co = 0;
int flag = 0;
for (int i = 0; i < all; i++) {
if (i == 0) {
if (a > 0) {
a--;
ans[0] = 0;
} else {
flag = 1;
break;
}
} else if (ans[i - 1] == 0) {
if (b > 0) {
b--;
ans[i] = 1;
} else {
flag = 1;
break;
}
} else if (ans[i - 1] == 1) {
if (a > 0) {
ans[i] = 0;
a--;
} else if (c > 0) {
ans[i] = 2;
c--;
} else {
flag = 1;
break;
}
} else if (ans[i - 1] == 2) {
if (b > 0) {
ans[i] = 1;
b--;
} else if (d > 0) {
ans[i] = 3;
d--;
} else {
flag = 1;
break;
}
} else if (ans[i - 1] == 3) {
if (c > 0) {
ans[i] = 2;
c--;
} else {
flag = 1;
break;
}
}
}
if (flag == 1) {
flag = 0;
for (int i = 0; i < all; i++) {
if (i == 0) {
if (bb > 0) {
bb--;
ans[0] = 1;
} else {
flag = 1;
break;
}
} else if (ans[i - 1] == 0) {
if (bb > 0) {
bb--;
ans[i] = 1;
} else {
flag = 1;
break;
}
} else if (ans[i - 1] == 1) {
if (aa > 0) {
ans[i] = 0;
aa--;
} else if (cc > 0) {
ans[i] = 2;
cc--;
} else {
flag = 1;
break;
}
} else if (ans[i - 1] == 2) {
if (bb > 0) {
ans[i] = 1;
bb--;
} else if (dd > 0) {
ans[i] = 3;
dd--;
} else {
flag = 1;
break;
}
} else if (ans[i - 1] == 3) {
if (cc > 0) {
ans[i] = 2;
cc--;
} else {
flag = 1;
break;
}
}
}
if (flag == 1) {
flag = 0;
for (int i = 0; i < all; i++) {
if (i == 0) {
if (ccc > 0) {
ccc--;
ans[0] = 2;
} else {
flag = 1;
break;
}
} else if (ans[i - 1] == 0) {
if (bbb > 0) {
bbb--;
ans[i] = 1;
} else {
flag = 1;
break;
}
} else if (ans[i - 1] == 1) {
if (aaa > 0) {
ans[i] = 0;
aaa--;
} else if (ccc > 0) {
ans[i] = 2;
ccc--;
} else {
flag = 1;
break;
}
} else if (ans[i - 1] == 2) {
if (bbb > 0) {
ans[i] = 1;
bbb--;
} else if (ddd > 0) {
ans[i] = 3;
ddd--;
} else {
flag = 1;
break;
}
} else if (ans[i - 1] == 3) {
if (ccc > 0) {
ans[i] = 2;
ccc--;
} else {
flag = 1;
break;
}
}
}
if (flag == 1) {
flag = 0;
for (int i = 0; i < all; i++) {
if (i == 0) {
if (dddd > 0) {
dddd--;
ans[0] = 3;
} else {
flag = 1;
break;
}
} else if (ans[i - 1] == 0) {
if (bbbb > 0) {
bbbb--;
ans[i] = 1;
} else {
flag = 1;
break;
}
} else if (ans[i - 1] == 1) {
if (aaaa > 0) {
ans[i] = 0;
aaaa--;
} else if (ccc > 0) {
ans[i] = 2;
cccc--;
} else {
flag = 1;
break;
}
} else if (ans[i - 1] == 2) {
if (bbbb > 0) {
ans[i] = 1;
bbbb--;
} else if (dddd > 0) {
ans[i] = 3;
dddd--;
} else {
flag = 1;
break;
}
} else if (ans[i - 1] == 3) {
if (cccc > 0) {
ans[i] = 2;
cccc--;
} else {
flag = 1;
break;
}
}
}
if (flag == 1) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
for (int i = 0; i < all; i++) {
cout << ans[i] << " ";
}
cout << endl;
}
} else {
cout << "YES" << endl;
for (int i = 0; i < all; i++) {
cout << ans[i] << " ";
}
cout << endl;
}
} else {
cout << "YES" << endl;
for (int i = 0; i < all; i++) {
cout << ans[i] << " ";
}
cout << endl;
}
} else {
cout << "YES" << endl;
for (int i = 0; i < all; i++) {
cout << ans[i] << " ";
}
cout << endl;
}
return 0;
}
| 1,900 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int n;
int a[1000005];
int main() {
scanf("%d", &n);
for (int i = 0; i <= n; i++) {
char x;
scanf("%c", &x);
switch (x) {
case 'R':
a[i] = 1;
break;
case 'G':
a[i] = 2;
break;
case 'B':
a[i] = 3;
break;
}
}
a[n + 1] = a[n - 1] + 1;
if (a[n + 1] == 4) a[n + 1] = 1;
int sl = 1, res = 0;
for (int i = 2; i <= n; i++) {
if (a[i] != a[i - 1]) {
res += sl / 2;
sl = 1;
} else {
sl++;
int x = a[i - 1], y = a[i + 1];
if (x > y) x += y, y = x - y, x = x - y;
if (x == 1 && y == 2) a[i] = 3;
if (x == 1 && y == 3) a[i] = 2;
if (x == 2 && y == 3) a[i] = 1;
if (x == y) {
a[i] = x + 1;
if (a[i] == 4) a[i] = 1;
}
}
}
res += sl / 2;
printf("%d\n", res);
for (int i = 1; i <= n; i++) {
switch (a[i]) {
case 1:
printf("R");
break;
case 2:
printf("G");
break;
case 3:
printf("B");
break;
}
}
return 0;
}
| 1,400 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<long long> v;
long long a, b;
long long ans = 0, flag = 0;
cin >> a >> b;
while (b > a) {
v.push_back(b);
if (b % 2 == 0) {
b /= 2;
ans++;
} else if (b % 10 == 1) {
b = b - 1;
b = b / 10;
ans++;
} else {
flag = 1;
break;
}
}
if (flag == 1) {
cout << "NO";
} else if (b == a) {
ans++;
v.push_back(a);
cout << "YES" << endl << ans << endl;
long long sz = v.size();
for (long long x = sz - 1; x >= 0; x--) {
cout << v[x] << " ";
}
} else {
cout << "NO";
}
return 0;
}
| 1,000 |
CPP
|
for _ in range(int(input())):
n = int(input())
s = input()
x = s.count('0')
y = s.count('1')
if x > y:
print('0'*n)
else:
print('1'*n)
| 800 |
PYTHON3
|
def solve(n,s):
turn = True
prev = 0
turns = 0
a_count = 0
b_count = 0
while len(s) > 0:
candy = 0
turns += 1
if turn == True:
while candy <= prev:
if len(s) == 0:
break
candy += s[0]
s.pop(0)
turn = False
a_count += candy
else:
while candy <= prev:
if len(s) == 0:
break
candy += s[len(s)-1]
s.pop()
b_count += candy
turn = True
prev = candy
return(" ".join(list(map(str,[turns,a_count,b_count]))))
t = int(input())
for i in range(t):
n = int(input())
s = list(map(int,input().split()))
print(solve(n,s))
| 1,300 |
PYTHON3
|
N = int(input())
S = input()
T = input()
ab,ba = -1,-1
ans = []
for p,(s,t) in enumerate(zip(S,T)):
i=p+1
if s+t=='ab':
if ab == -1:
ab = i
else:
ans.append('%d %d'%(ab,i))
ab=-1;
if s+t=='ba':
if ba == -1:
ba = i
else:
ans.append('%d %d'%(ba,i))
ba=-1;
if ab==-1 and ba==-1:
print(len(ans))
print('\n'.join(ans))
elif ab!=-1 and ba!=-1:
ans.append('%d %d' % (ab, ab))
ans.append('%d %d' % (ab, ba))
print(len(ans))
print('\n'.join(ans))
else:
print(-1)
| 1,500 |
PYTHON3
|
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1);
void read(int& x) {
x = 0;
int f = 1;
char ch = getchar();
while ((ch < '0' || ch > '9') && ch != '-') ch = getchar();
if (ch == '-') f = -1, ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
x *= f;
}
int n, m, a[3005], sum[3005];
char s[3005][3005];
void rev(int len) {
for (int i = (1); i <= (len / 2); i++) swap(a[i], a[m - i + 1]);
}
pair<int, int> yf[3005];
int main() {
read(n);
read(m);
int sum = 0;
for (int i = (1); i <= (m); i++) read(a[i]), sum += a[i];
sort(a + 1, a + m + 1);
rev(m);
int all = n * (n - 1) - sum;
if (n != m) {
int cnt = all / (n - m);
for (int i = (m + 1); i <= (n); i++) a[i] = cnt;
all -= (n - m) * cnt;
for (int i = (m + 1); i <= (m + all); i++) a[i]++;
all = 0;
}
if (all != 0) {
printf("no\n");
return 0;
}
for (int i = (1); i < (n); i++)
if (a[i] < a[i + 1]) {
printf("no\n");
return 0;
}
for (int i = (1); i <= (n); i++) {
all += a[n - i + 1];
if (all < i * (i - 1)) {
printf("no\n");
return 0;
}
}
for (int i = (1); i <= (n); i++) yf[i] = make_pair(a[i], i);
for (int i = (n); i >= (1); i--) {
sort(yf + 1, yf + i + 1);
int now = 1;
while (now < i && yf[i].first >= 2)
yf[i].first -= 2, s[yf[i].second][yf[now].second] = 'W',
s[yf[now].second][yf[i].second] = 'L', now++;
if (yf[i].first == 1) {
s[yf[i].second][yf[now].second] = s[yf[now].second][yf[i].second] = 'D';
yf[i].first--;
yf[now].first--;
now++;
}
while (now < i)
s[yf[i].second][yf[now].second] = 'L',
s[yf[now].second][yf[i].second] = 'W', yf[now].first -= 2, now++;
s[yf[i].second][yf[i].second] = 'X';
}
printf("yes\n");
for (int i = (1); i <= (n); i++) {
for (int j = (1); j <= (n); j++) putchar(s[i][j]);
putchar('\n');
}
return 0;
}
| 2,900 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, k, l;
cin >> n >> m >> k >> l;
if (n / m and (m * (n / m)) - k >= l) {
long long res, lo = 1, hi = n / m;
while (lo <= hi) {
long long mid = (hi + lo) / 2;
if (mid * m >= l + k) {
res = mid;
hi = mid - 1;
} else
lo = mid + 1;
}
cout << res << endl;
} else
cout << "-1" << endl;
return 0;
}
| 1,400 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int a[3000001];
int main() {
int p, n, i, t;
scanf("%d", &n);
for (i = 0; i < n; i++) a[i] = i + 1;
int k = 2, r;
for (k = 2, r = 0; k <= n; k++, r++) {
t = 0;
for (i = r; i <= r + n - 1; i += k) {
p = a[i];
a[i] = t;
t = p;
}
a[n + r] = t;
}
for (i = r; i < n + r; i++) printf("%d ", a[i]);
return 0;
}
| 2,200 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
long long INF = 1E9;
long long M = 1E9 + 7;
inline long long power(long long a, long long p) {
long long res = 1, x = a;
while (p) {
if (p & 1) res = (res * x);
x = (x * x);
p >>= 1;
}
return res;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
if (fopen("input.txt", "r")) {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
long long h1, c1, h2, a1, a2;
cin >> h1 >> a1 >> c1;
cin >> h2 >> a2;
long long cnt = 0;
string ans = "";
while (1) {
if (a1 >= h2) {
cnt++;
ans += "STRIKE\n";
break;
}
if (h1 <= a2) {
ans += "HEAL\n";
h1 += c1;
} else {
ans += "STRIKE\n";
h2 -= a1;
}
cnt++;
if (h2 <= 0) break;
h1 -= a2;
}
cout << cnt << "\n";
cout << ans;
return 0;
}
| 1,200 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long n, m, sum = 0;
cin >> n >> m;
vector<long long> ans(n);
for (int i = 0; i < n; ++i) {
long long a;
cin >> a;
sum += a;
ans[i] = sum / m;
}
cout << ans[0];
for (int i = 1; i < n; ++i) {
cout << " " << ans[i] - ans[i - 1];
}
cout << endl;
}
| 900 |
CPP
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:100000000,100000000")
using namespace std;
const long long inf = 1e9 + 7;
const long long mod = 1e9 + 7;
const double eps = 1e-9;
const double PI = 2 * acos(0.0);
const double E = 2.71828;
int main(void) {
long long n;
cin >> n;
double ans = 0, e = 0;
for (int i = 0; i < n; i++) {
double temp;
cin >> temp;
ans += temp * (2.0 * e + 1);
e = temp * (e + 1);
}
cout << setprecision(8) << fixed << ans << endl;
return 0;
}
| 2,000 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
long long int seg[4000005];
long long int query(long long int x, long long int l, long long int r,
long long int tl, long long int tr) {
if (tl == l && tr == r)
return seg[x];
else if (tl > r || tr < tl)
return 0;
else {
long long int mid = (l + r) / 2;
long long int a = 0, b = 0;
a = query(2 * x + 1, l, mid, tl, min(tr, mid));
b = query(2 * x + 2, mid + 1, r, max(mid + 1, tl), tr);
return (a + b);
}
}
int main() {
long long int n;
cin >> n;
long long int ar[n];
vector<long long int> v;
for (long long int i = 0; i < n; i++) {
cin >> ar[i];
v.push_back(ar[i]);
}
sort(v.begin(), v.end());
for (long long int i = 0; i < n; i++) {
auto rank = lower_bound(v.begin(), v.end(), ar[i]) - v.begin();
ar[i] = rank;
}
long long int ans = 0;
for (long long int i = 0; i < 4000005; i++) seg[i] = 0;
for (long long int i = 0; i < n; i++) {
long long int rank = ar[i];
long long int z = query(0, 0, 1000000, rank + 1, 1000000), zz;
zz = rank - (i - z);
ans += z * zz;
long long int l = 0, r = 1000000, x = 0;
while (1) {
long long int mid = (l + r) / 2;
seg[x]++;
if (rank <= mid) {
r = mid;
x = 2 * x + 1;
} else {
l = mid + 1;
x = 2 * x + 2;
}
if (l == r) {
seg[x]++;
break;
}
}
}
cout << ans << '\n';
}
| 1,900 |
CPP
|
n = int(input())
X = list(map(int, input().split(" ")))
X.sort()
print(sum([abs(X[i-1]-i) for i in range(1,n+1)]))
| 1,200 |
PYTHON3
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.