solution
stringlengths 10
159k
| difficulty
int64 0
3.5k
| language
stringclasses 2
values |
|---|---|---|
#include <bits/stdc++.h>
using namespace std;
int N, M, ans[200011];
int depth[200011], p[200011][19], largest[200011][19];
vector<vector<int>> adj[200011];
int id[200011];
priority_queue<pair<int, int>> pq[200011];
void merge_pq(int a, int b) {
if (pq[id[a]].size() > pq[id[b]].size()) swap(a, b);
while (pq[id[a]].size()) {
pq[id[b]].push(pq[id[a]].top());
pq[id[a]].pop();
}
id[a] = id[b];
}
bool used[200011];
int edges[200011][3], container[200011];
int find(int x) { return x == p[x][0] ? x : p[x][0] = find(p[x][0]); }
void merge(int a, int b) { p[find(a)][0] = find(b); }
bool comp(int a, int b) { return edges[a][2] < edges[b][2]; }
int lca(int a, int b) {
if (depth[a] > depth[b]) swap(a, b);
int diff = depth[b] - depth[a];
for (int i = 0; i < 19; i++)
if (diff & (1 << i)) b = p[b][i];
if (a == b) return a;
for (int i = 19 - 1; i >= 0; i--) {
if (p[a][i] != p[b][i]) {
a = p[a][i];
b = p[b][i];
}
}
return p[a][0];
}
void dfs(int x, int v) {
p[x][0] = v;
depth[x] = depth[v] + 1;
for (auto e : adj[x]) {
if (e[1] != v && used[e[2]]) {
dfs(e[1], x);
largest[e[1]][0] = e[0];
}
}
}
void dfs2(int x, int v) {
int parentEdge = -1;
for (auto e : adj[x]) {
if (e[1] == v)
parentEdge = e[2];
else if (used[e[2]]) {
dfs2(e[1], x);
merge_pq(x, e[1]);
} else {
pq[id[x]].push(make_pair(-e[0], depth[lca(x, e[1])]));
}
}
while (pq[id[x]].size() && pq[id[x]].top().second >= depth[x])
pq[id[x]].pop();
if (parentEdge != -1 && pq[id[x]].size())
ans[parentEdge] = -pq[id[x]].top().first;
}
int main() {
if (fopen("data.in", "r")) freopen("data.in", "r", stdin);
cin >> N >> M;
for (int i = 0; i < M; i++) {
cin >> edges[i][0] >> edges[i][1] >> edges[i][2];
edges[i][0]--;
edges[i][1]--;
container[i] = i;
adj[edges[i][0]].push_back({edges[i][2], edges[i][1], i});
adj[edges[i][1]].push_back({edges[i][2], edges[i][0], i});
}
sort(container, container + M, comp);
for (int i = 0; i < N; i++) p[i][0] = i;
for (int i = 0; i < M; i++) {
if (find(edges[container[i]][0]) != find(edges[container[i]][1])) {
merge(edges[container[i]][0], edges[container[i]][1]);
used[container[i]] = true;
}
}
dfs(0, 0);
for (int x = 1; x < 19; x++) {
for (int i = 0; i < N; i++) {
p[i][x] = p[p[i][x - 1]][x - 1];
largest[i][x] = max(largest[i][x - 1], largest[p[i][x - 1]][x - 1]);
}
}
for (int i = 0; i < N; i++) id[i] = i;
dfs2(0, 0);
for (int i = 0; i < M; i++) {
if (!used[i]) {
int c = lca(edges[i][0], edges[i][1]);
for (int j = 0; j < 2; j++) {
for (int k = 0; k < 19; k++) {
if ((depth[edges[i][j]] - depth[c]) & (1 << k)) {
ans[i] = max(ans[i], largest[edges[i][j]][k]);
edges[i][j] = p[edges[i][j]][k];
}
}
}
}
cout << ans[i] - 1 << " ";
}
cout << endl;
}
| 2,700 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
long long m, k;
cin >> m >> k;
long long ans = 0;
long long s = k / m;
if (k % m) {
long long op = k % m;
ans += (m - op) * (s * s);
ans += op * (s + 1) * (s + 1);
} else {
ans += m * s * s;
}
cout << ans << endl;
}
return 0;
}
| 1,000 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long double EPS = 1e-9;
const long double PI = 3.1415926535897932384626433832795;
const int INF = 1000 * 1000 * 1000;
const int NMAX = 1000 * 1000;
long i, j, k, l, n, m, x, y, ans;
long a[3000];
int main() {
freopen("out.deb", "w", stderr);
scanf("%d %d", &n, &x);
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
ans = x;
for (i = 1; i <= n; i++) {
for (j = i; j <= n; j++)
if (a[j] * (x / a[i]) + (x % a[i]) > ans) {
ans = a[j] * (x / a[i]) + x % a[i];
}
}
printf("%d", ans);
return 0;
}
| 1,400 | CPP |
#include <bits/stdc++.h>
const int MOD = 1e9 + 7;
using namespace std;
vector<pair<int, int>> sur = {{1, 0}, {0, -1}, {0, 1}, {-1, 0},
{-1, -1}, {1, 1}, {1, -1}, {-1, 1}};
bool bounds(int i, int j, int n, int m) {
return i >= 0 && i <= n && j >= 0 && j <= m;
}
long long t, x, y, a, b, c, k, n, d;
string s;
string s2;
const int maxn = 207;
vector<vector<long long>> g;
vector<long long> arr;
deque<long long> arr2;
vector<bool> visited;
vector<bool> primes;
void sieve(long long n) {
primes = vector<bool>(n + 1, true);
for (long long i = 2; i * i < n; i++) {
if (primes[i]) {
for (long long j = i * i; j < n; j += i) {
primes[j] = false;
}
}
}
}
long long binpow(long long a, long long b, long long m) {
a %= m;
long long res = 1;
while (b > 0) {
if (b & 1) res = res * a % m;
a = a * a % m;
b >>= 1;
}
return res;
}
bool allSame() {
for (int i = 0; i < arr.size() - 1; i++) {
if (arr[i] != arr[i + 1]) {
return false;
}
}
return true;
}
void solved() {
long long orB = b;
arr = vector<long long>();
arr.push_back(b);
while (b > a) {
if (b % 2 == 0) {
b /= 2;
} else if (b % 10 == 1) {
b /= 10;
} else {
break;
}
arr.push_back(b);
}
if (b != a) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
cout << arr.size() << endl;
for (auto i = arr.rbegin(); i != arr.rend(); ++i) {
cout << *i << " ";
}
cout << endl;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin >> a >> b;
solved();
return 0;
}
| 1,000 | CPP |
#include <bits/stdc++.h>
#ifndef LOCAL_RUN
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("fast-math")
#pragma GCC target("avx2,tune=native")
#endif
#define fr first
#define sc second
#define m_p make_pair
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
const int N = 2e5+10;
vector<int> graph[N], order;
int d[N], n, dp[N];
void calc()
{
queue<int> q;
q.push(1);
for (int i = 2; i <= n; i++)
d[i] = INT_MAX/2;
while (!q.empty()) {
int v = q.front();
q.pop();
for (int u: graph[v]) {
if (d[u] > d[v]+1) {
d[u] = d[v]+1;
q.push(u);
}
}
}
}
bool used[N];
void dfs(int v)
{
used[v] = true;
for (int u: graph[v]) {
if (d[v] < d[u]) {
if (!used[u])
dfs(u);
}
}
order.push_back(v);
}
void solve()
{
int m;
cin >> n >> m;
while (m--) {
int x, y; cin >> x >> y;
graph[x].push_back(y);
}
calc();
dfs(1);
for (int i: order) {
dp[i] = d[i];
for (int u: graph[i]) {
if (d[i] < d[u])
dp[i] = min(dp[i], dp[u]);
else
dp[i] = min(dp[i], d[u]);
}
}
for (int i = 1; i <= n; i++) {
graph[i].clear();
used[i] = false;
}
order.clear();
for (int i = 1; i <= n; i++)
cout << dp[i] << " ";
cout << "\n";
}
int main()
{
#ifdef LOCAL_RUN
freopen("input.txt", "r", stdin);
#else
//freopen("input.txt", "r", stdin);
//freopen("output.txt", "w", stdout);
ios::sync_with_stdio(false);
cin.tie(0);
#endif
int q;
cin >> q;
while (q--)
solve();
return 0;
}
| 2,100 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long k, n, x, y;
long long maxa = 0;
cin >> n;
for (k = 0; k < n; k++) {
cin >> x >> y;
maxa = max(maxa, x + y);
}
cout << maxa;
return 0;
}
| 900 | CPP |
#include <bits/stdc++.h>
using namespace std;
int const M = 60 + 10, mod = 1e9 + 7, inf = 1e9 + 10;
long long a[M];
bool dp[M][M];
void fdp(int i, int j, long long hlp, int n) {
long long smm = 0;
for (int k = i; k <= n; k++) {
smm += a[k];
if ((smm & hlp) == hlp) dp[i][j] |= dp[k + 1][j + 1];
}
}
int32_t main() {
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
long long now = 0;
for (int j = 60; j >= 0; j--) {
long long hlp = (now xor (1LL << j));
for (int jj = 1; jj <= n; jj++)
for (int l = 0; l <= k; l++) dp[jj][l] = 0;
dp[n + 1][k] = 1;
for (int i = n; i >= 1; i--) {
for (int l = 0; l <= k; l++) {
fdp(i, l, hlp, n);
}
}
if (dp[1][0]) now = hlp;
}
cout << now;
}
| 1,900 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long int n, m, a[1000005];
multiset<long long int> st;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
for (long long int i = 1; i <= n; i++) cin >> a[i];
long long int ans = 0;
for (long long int i = 1; i <= n; i++) {
st.insert(a[i]);
auto it = st.begin();
if (*it < a[i]) {
ans += a[i] - *it;
st.erase(it);
st.insert(a[i]);
}
}
cout << ans;
return 0;
}
| 2,400 | CPP |
n=int(input())
k=0
ma=0
for i in range(n):
a,b=map(int,input().split())
k=k-a+b
if k>ma:
ma=k
print(ma)
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int MX = 2000;
int n, b, e;
vector<int> adjList[MX];
int treeSize[MX];
int a[MX];
int ai;
void addA(int root, int parent, int depth) {
cout << root + 1 << " " << parent + 1 << " " << a[ai] - depth << endl;
depth = a[ai++];
for (int i = int(0); i < int(adjList[root].size()); i++) {
int v = adjList[root][i];
if (v == parent) continue;
addA(v, root, depth);
}
}
int dfs(int root, int parent = -1) {
treeSize[root] = 1;
for (int i = int(0); i < int(adjList[root].size()); i++) {
int v = adjList[root][i];
if (v == parent) continue;
treeSize[root] += dfs(v, root);
}
return treeSize[root];
}
int getCentroid(int root, int parent = -1) {
bool cent = 1;
int heavy = -1;
for (int i = int(0); i < int(adjList[root].size()); i++) {
int v = adjList[root][i];
if (v == parent) continue;
if (treeSize[v] > n / 2) cent = 0;
if (heavy == -1 || treeSize[v] > treeSize[heavy]) heavy = v;
}
if (cent) return root;
return getCentroid(heavy, root);
}
int getCentroid() {
dfs(0);
return getCentroid(0);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
for (int i = int(0); i < int(n - 1); i++)
cin >> b >> e, b--, e--, adjList[b].push_back(e), adjList[e].push_back(b);
if (n == 1) return 0;
if (n == 2) {
cout << "1 2 1" << endl;
return 0;
}
int cent = getCentroid();
dfs(cent);
priority_queue<pair<int, vector<int>>, vector<pair<int, vector<int>>>,
greater<pair<int, vector<int>>>>
groups;
for (int i = int(0); i < int(adjList[cent].size()); i++) {
int v = adjList[cent][i];
groups.push({treeSize[v], {v}});
}
while (groups.size() >= 3) {
auto p1 = groups.top();
groups.pop();
auto p2 = groups.top();
groups.pop();
p2.first += p1.first;
p2.second.insert(p2.second.end(), p1.second.begin(), p1.second.end());
groups.push(p2);
}
auto groupa = groups.top();
groups.pop();
auto groupb = groups.top();
groups.pop();
for (int i = int(0); i < int(groupa.first); i++) a[i] = i + 1;
ai = 0;
for (int i = int(0); i < int(groupa.second.size()); i++) {
int v = groupa.second[i];
addA(v, cent, 0);
}
for (int i = int(0); i < int(groupb.first); i++)
a[i] = (i + 1) * (groupa.first + 1);
ai = 0;
for (int i = int(0); i < int(groupb.second.size()); i++) {
int v = groupb.second[i];
addA(v, cent, 0);
}
}
| 2,700 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long int dx[] = {-1, 0, 1, 0};
long long int dy[] = {0, 1, 0, -1};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n, ai, aj, bi, bj, ci, cj;
cin >> n;
cin >> ai >> aj >> bi >> bj >> ci >> cj;
if (((bi - ai) * (ci - ai)) > 0 && ((bj - aj) * (cj - aj)) > 0)
cout << "YES";
else
cout << "NO";
return 0;
}
| 1,000 | CPP |
m, n = map(int, input().split())
if(m == 1 and n == 1):
print (0)
else:
print (int(m*n) // 2)
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 100003417;
long long mod2 = 100003559;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
vector<vector<long long> > ar(n, vector<long long>(m, 0));
vector<vector<long long> > dp1(n, vector<long long>(m, 0));
vector<vector<long long> > dp2(n, vector<long long>(m, 0));
vector<vector<long long> > mp1(n, vector<long long>(m, 0));
vector<vector<long long> > mp2(n, vector<long long>(m, 0));
char a;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> a;
if (a == '#') ar[i][j] = 1;
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (i == 0 && j == 0) {
dp1[i][j] = 1;
mp1[i][j] = 1;
continue;
}
if (ar[i][j]) {
dp1[i][j] = 0;
mp1[i][j] = 0;
continue;
}
if (i) {
dp1[i][j] += dp1[i - 1][j];
mp1[i][j] += mp1[i - 1][j];
if (mp1[i][j] >= mod) mp1[i][j] -= mod;
if (dp1[i][j] >= mod2) dp1[i][j] -= mod2;
}
if (j) {
dp1[i][j] += dp1[i][j - 1];
mp1[i][j] += mp1[i][j - 1];
if (mp1[i][j] >= mod) mp1[i][j] -= mod;
if (dp1[i][j] >= mod2) dp1[i][j] -= mod2;
}
}
}
for (int i = n - 1; i >= 0; i--) {
for (int j = m - 1; j >= 0; j--) {
if ((i == n - 1) && (j == m - 1)) {
dp2[i][j] = 1;
mp2[i][j] = 1;
continue;
}
if (ar[i][j]) {
dp2[i][j] = 0;
mp2[i][j] = 0;
continue;
}
if ((i + 1) < n) {
dp2[i][j] += dp2[i + 1][j];
mp2[i][j] += mp2[i + 1][j];
if (mp2[i][j] >= mod) mp2[i][j] -= mod;
if (dp2[i][j] >= mod) dp2[i][j] -= mod2;
}
if ((j + 1) < m) {
dp2[i][j] += dp2[i][j + 1];
mp2[i][j] += mp2[i][j + 1];
if (mp2[i][j] >= mod) mp2[i][j] -= mod;
if (dp2[i][j] >= mod) dp2[i][j] -= mod2;
}
}
}
if (dp1[n - 1][m - 1] == 0 && (mp1[n - 1][m - 1] == 0) && (dp2[0][0] == 0) &&
(mp2[0][0] == 0)) {
cout << "0";
return 0;
}
int ans = 2;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (i == 0 && j == 0) continue;
if ((i == n - 1) && (j == m - 1)) continue;
long long f = 0;
f = dp1[i][j] * dp2[i][j];
f %= mod2;
long long x = mp1[i][j] * mp2[i][j];
x %= mod;
if ((f == (dp1[n - 1][m - 1])) && (x == mp1[n - 1][m - 1])) {
ans = 1;
break;
}
}
}
cout << ans;
return 0;
}
| 1,900 | CPP |
t=int(input())
for i in range(t):
n=int(input())
c=0
while(n!=1):
if n%2==0:
n=n//2
c+=1
elif n%3==0:
n=2*n
n=n//3
c+=1
elif n%5==0:
n=4*n
n=n//5
c+=1
elif n%2!=0 and n%3!=0 and n%5!=0:
c=-1
break
print(c) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
class Video {
public:
Video() {}
Video(int num, long long last) : num(num), last(last) {}
bool operator<(const Video v) const {
if (last == v.last) return num < v.num;
return last < v.last;
}
int num;
long long last;
};
long long ans[500010];
set<Video> s;
int main() {
int n, m;
scanf("%d%d", &n, &m);
long long maxn = 0;
for (int i = 1; i <= n; i++) {
long long st, ed;
scanf("%I64d%I64d", &st, &ed);
if (s.size() == m) {
maxn = s.begin()->last;
maxn = max(maxn, st);
ans[s.begin()->num] = s.begin()->last;
s.erase(s.begin());
} else
maxn = st;
s.insert(Video(i, maxn + ed));
}
while (!s.empty()) {
ans[s.begin()->num] = s.begin()->last;
s.erase(s.begin());
}
for (int i = 1; i <= n; i++) printf("%I64d\n", ans[i]);
return 0;
}
| 1,600 | CPP |
x,y,z = map(int,input().split())
r = int((x*y*z)**0.5)
p = r//x +r//y +r//z
print(4*p) | 1,100 | PYTHON3 |
n, m = (int(x) for x in input().split())
results = [0]*n # n = 3 -> [0, 0, 0] [kn-1]
pointers = [k for k in range(2, n+2)] # n = 3 -> [2, 3, 4] [kn-1]
for i in range(m):
l, r, x = [int(k) for k in input().split()]
while l <= r:
if l != x and results[l-1] == 0: results[l-1] = x
nxt = pointers[l-1]
if l < x: pointers[l-1] = x
else: pointers[l-1] = r+1
l = nxt
print(*results) | 1,500 | PYTHON3 |
n = int(input())
for i in range (n):
x,y = map(int,input().split())
if x % y != 0:
print(y - ( x % y))
else:
print(x%y) | 1,500 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int OO = (int)2e9;
const double eps = 1e-9;
int daysInMonths[] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
int di[] = {-1, 0, 1, 0};
int dj[] = {0, 1, 0, -1};
int arr[1002], maxi = -1;
void Gen(string s) {
int res = 0;
for (int i = (0); i < ((int)s.size()); i++) {
if (s[i] != ',') {
res *= 10;
res += (s[i] - '0');
} else if (s[i] == ',') {
arr[res]++;
if (res > maxi) maxi = res;
res = 0;
}
}
arr[res]++;
if (res > maxi) maxi = res;
}
int main() {
std::ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
string s;
cin >> s;
Gen(s);
for (int i = (1); i < (1001); i++) {
if (arr[i] != 0) {
int last_non_zero = i, j;
for (j = i;; j++) {
if (arr[j] != 0)
last_non_zero = j;
else
break;
}
if (i == last_non_zero)
cout << last_non_zero;
else
cout << i << "-" << last_non_zero;
if (maxi != last_non_zero) cout << ",";
i = last_non_zero;
}
}
return 0;
}
| 1,300 | CPP |
#include<bits/stdc++.h>
using namespace std;
int main()
{
int t;
cin>>t;
while(t--)
{
int n,flag=0;
cin>>n;
int ar[n];
for(int i=0;i<n;i++)
{
cin>>ar[i];
if(ar[i]<0)
flag=1;
}
if(flag==1)
cout<<"NO"<<endl;
else
{
sort(ar,ar+n);
cout<<"YES"<<endl;
cout<<ar[n-1]+1<<endl;
for(int i=0;i<=ar[n-1];i++)
cout<<i<<" ";
cout<<endl;
}
}
return(0);
} | 800 | CPP |
def main():
n,m= [int(i) for i in input().split()]
arr= [int(i) for i in input().split()]
count=0
last=1
for i in range(len(arr)):
if arr[i]>=last:
count+= arr[i]-last
else:
count+=n-last+arr[i]
last=arr[i]
print(count)
return 0
if __name__ == '__main__':
main()
| 1,000 | PYTHON3 |
def find(a,i,j,b):
n = len(a)
a = a[i:j+1]
try:
index = b.index(a)
except:
return float('inf')
total = index + len(b)-index-len(a) + i + n-j-1
return total
def solve(a,b,ans):
min_val = float('inf')
for i in range(len(a)):
for j in range(i,len(a)):
min_val = min(min_val,find(a,i,j,b))
if min_val == float('inf'):
min_val = len(a)+len(b)
ans.append(str(min_val))
def main():
t = int(input())
ans = []
for i in range(t):
a = input()
b = input()
solve(a,b,ans)
print('\n'.join(ans))
main()
| 1,000 | PYTHON3 |
t=int(input())
for i in range(t):
n,x,a,b=map(int,input().split())
mi=min(a,b)
mx=max(a,b)
while(x>=1):
if mi>1 and x>=1:
mi-=1
x-=1
if mx<n and x>=1:
mx+=1
x-=1
if mi==1 and mx==n:
break
print(mx-mi)
| 800 | PYTHON3 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
typedef long long ll;
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll my_exp(ll a, ll b, ll MOD = numeric_limits<ll>::max()) {
a %= MOD;
return b ? (((b % 2 == 1 ? a : 1) * my_exp(a * a, b / 2, MOD)) % MOD) : 1;
}
bool is_prime(ll n) {
if (n != 2 && n % 2 == 0)
return false;
else {
for (ll i = 3; (i * i) <= n; i += 2)
if (n % i == 0) return false;
return true;
}
}
int main() {
ll n;
cin >> n;
vector<ll> v(n), d(n), p(n);
for (ll i = 0; i < n; ++i) cin >> v[i] >> d[i] >> p[i];
list<ll> con;
for (ll i = 0; i < n; ++i) {
con.push_back(i);
}
set<ll> ans;
while (!con.empty()) {
ll curr = con.front();
con.pop_front();
ans.insert(curr + 1);
ll red = v[curr];
for (decltype(con.begin()) it = con.begin(); it != con.end(); it++) {
if (red > 0) {
p[*it] -= red--;
} else {
break;
}
}
bool neg = true;
while (neg) {
bool found = false;
ll damage = 0;
auto it = con.begin();
while (it != con.end()) {
if (p[*it] < 0 && !found) {
damage = d[*it];
found = true;
it = con.erase(it);
} else {
p[*it] -= damage;
++it;
}
}
if (!found) {
neg = false;
}
}
}
cout << ans.size() << endl;
for (decltype(ans.begin()) it = ans.begin(); it != ans.end(); it++) {
cout << *it << " ";
}
return (0);
}
| 1,800 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long n, p[20010], depth[20001], mx = -99099;
bool used[20001];
vector<long long> g[20001];
void dfs(long long v, long long high) {
used[v] = true;
depth[v] = high;
for (long long i = 0; i < g[v].size(); ++i) {
if (!used[g[v][i]]) {
dfs(g[v][i], high + 1);
}
}
}
int main() {
cin >> n;
for (long long i = 1; i <= n; ++i) {
cin >> p[i];
if (p[i] != -1) {
g[p[i]].push_back(i);
}
}
for (long long i = 1; i <= n; ++i) {
if (p[i] == -1) {
dfs(i, 1);
}
}
for (long long i = 1; i <= n; ++i) {
mx = max(mx, depth[i]);
}
cout << mx;
return 0;
}
| 900 | CPP |
#include<bits/stdc++.h>
#define ll long long
using namespace std;
template<class T>inline void read(T &x)
{
x=0;int f=0;char ch=getchar();
while(!isdigit(ch)) f=ch=='-',ch=getchar();
while(isdigit(ch)) x=(x<<1)+(x<<3)+(ch^48),ch=getchar();
x=f?-x:x;
}
template<class T>inline void write(T x)
{
if(x<0) return putchar('-'),write(-x);
if(x>9) write(x/10);
putchar('0'+x%10);
}
const int N=205,MOD=1e9+7,HALF=5e8+4;
int n,m;
struct edge{
int next,to;
}e[N<<1];
int head[N],cnt,f[N][N],lca[N][N],dep[N],ans;
int ksm(int x,int y)
{
int res=1;
while(y)
{
if(y&1) res=(ll)res*x%MOD;
x=(ll)x*x%MOD,y>>=1;
}
return res;
}
void add(int u,int v)
{
e[++cnt]={head[u],v};
head[u]=cnt;
}
vector<int> dfs0(int x,int fa)
{
dep[x]=dep[fa]+1;
vector<int> poi,tmp;poi.push_back(x);
for(int i=head[x];i;i=e[i].next)
{
int y=e[i].to;
if(y==fa) continue;
tmp=dfs0(y,x);
for(auto u:tmp) for(auto v:poi) lca[u][v]=lca[v][u]=x;
for(auto u:tmp) poi.push_back(u);
}
return poi;
}
int main()
{
read(n);
for(int i=1,u,v;i<n;i++) read(u),read(v),add(u,v),add(v,u);
for(int i=1;i<=n;i++) f[i][0]=0,f[0][i]=1;
for(int i=1;i<=n;i++) for(int j=1;j<=n;j++)
f[i][j]=(ll)HALF*(f[i-1][j]+f[i][j-1])%MOD;
for(int i=1;i<=n;i++)
{
dfs0(i,0);
for(int i=1;i<n;i++) for(int j=i+1;j<=n;j++)
ans=((ll)ans+f[dep[j]-dep[lca[i][j]]][dep[i]-dep[lca[i][j]]])%MOD;
}
write((ll)ans*ksm(n,MOD-2)%MOD);
} | 2,300 | CPP |
a=input()
b=a.split("+")
b.sort()
for i in b[:-1]:
print(i+"+",end="")
print(b[-1]) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
string arr[505];
int visited[505][505];
int n, m, k;
void dfs(int x, int y) {
if (k == 0) return;
if (x >= n or x < 0 or y >= m or y < 0) return;
if (arr[x][y] == '#') return;
if (visited[x][y]) return;
visited[x][y] = 1;
dfs(x + 1, y);
dfs(x - 1, y);
dfs(x, y + 1);
dfs(x, y - 1);
if (k) {
arr[x][y] = 'X';
k--;
}
return;
}
int main() {
int cnt, i, j;
scanf("%d", &(n));
scanf("%d", &(m));
scanf("%d", &(k));
for (i = 0; i < n; i++) cin >> arr[i];
for (i = 0; i < n; i++) {
cnt = 0;
for (j = 0; j < m; j++) {
if (arr[i][j] == '.') {
dfs(i, j);
cnt = 1;
break;
}
}
}
for (i = 0; i < n; i++) cout << arr[i] << endl;
return 0;
}
| 1,600 | CPP |
d,sumTime=map(int,input().split())
sum2=0
sumlist=[]
output=[]
lisa=[]
for i in range(d):
a,b=map(int,input().split())
lisa.append(a)
sum2+=b
sumlist.append((a,b))
output.append(b)
if sum2<sumTime:
print("NO")
else:
if sum(lisa)>sumTime:
print("NO")
else:
print("YES")
kamkarnahai=sum2-sumTime
length=len(sumlist)
for i in range(length):
if kamkarnahai==0:
break
if kamkarnahai>=sumlist[i][1]-sumlist[i][0]:
kamkarnahai-=(sumlist[i][1]-sumlist[i][0])
output[i]=sumlist[i][0]
else:
output[i]-=kamkarnahai
break
for i in output:
print(i,end=" ") | 1,200 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int a[10];
int main() {
cin >> a[0] >> a[1] >> a[2] >> a[3];
sort(a, a + 4);
if (a[0] + a[3] == a[1] + a[2] || a[0] + a[1] + a[2] == a[3])
printf("YES\n");
else
printf("NO\n");
return 0;
}
| 800 | CPP |
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
using VI = vector<int>;
using VVI = vector<VI>;
using VL = vector<LL>;
using VVL = vector<VL>;
using VD = vector<double>;
using VVD = vector<VD>;
using PII = pair<int, int>;
using PDD = pair<double, double>;
using PLL = pair<LL, LL>;
using VPII = vector<PII>;
template <typename T>
using VT = vector<T>;
template <typename T>
inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T>
inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
const int INF = 1e9;
const int MOD = INF + 7;
const LL LLINF = 1e18;
const int MAX = 1e5 + 10;
int N;
LL W[MAX], H[MAX];
int main(void) {
scanf("%d", &N);
for (int(i) = 0; (i) < (N); (i)++) scanf("%lld%lld", W + i, H + i);
int pre = 0;
for (int(i) = (N)-1; (i) >= 0; (i)--) {
if (pre <= min(W[i], H[i])) {
pre = min(W[i], H[i]);
} else if (pre <= max(W[i], H[i])) {
pre = max(W[i], H[i]);
} else {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
}
| 1,000 | CPP |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:64000000")
const int infi = 1e9 + 7;
const long long infl = 1e18;
const double eps = 1e-7;
inline int readChar();
template <class T>
inline void writeInt(T x);
inline void writeChar(int x);
inline void writeWord(const char *s);
inline void flush();
static const int buf_size = 4096;
inline int getChar() {
static char buf[buf_size];
static int len = 0, pos = 0;
if (pos == len) pos = 0, len = fread(buf, 1, buf_size, stdin);
if (pos == len) return -1;
return buf[pos++];
}
inline int readChar() {
int c = getChar();
while (c <= 32) c = getChar();
return c;
}
inline int readInt() {
int s = 1, c = readChar();
int x = 0;
if (c == '-') s = -1, c = getChar();
while ('0' <= c && c <= '9') x = x * 10 + c - '0', c = getChar();
return s == 1 ? x : -x;
}
static int write_pos = 0;
static char write_buf[buf_size];
inline void writeChar(int x) {
if (write_pos == buf_size)
fwrite(write_buf, 1, buf_size, stdout), write_pos = 0;
write_buf[write_pos++] = x;
}
inline void flush() {
if (write_pos) fwrite(write_buf, 1, write_pos, stdout), write_pos = 0;
}
template <class T>
inline void writeInt(T x) {
if (x < 0) writeChar('-'), x = -x;
char s[24];
int n = 0;
while (x || !n) s[n++] = '0' + x % 10, x /= 10;
while (n--) writeChar(s[n]);
}
int pr[] = {1000000007, 1000000009, 1000000021, 1000000033, 1000000087,
1000000093, 1000000097, 1000000103, 1000000123, 1000000181};
inline long long bin_pow(long long a, int p, long long mod) {
long long ans = 1;
while (p) {
if (p & 1) {
ans *= a;
ans %= mod;
}
p >>= 1;
a *= a;
a %= mod;
}
return ans;
}
inline long long get_obr(long long a, long long mod) {
return bin_pow(a, mod - 2, mod);
}
long long ar[200500];
long long p[10];
const int max_mod = 5;
int main() {
cin.sync_with_stdio(false);
cin.tie(0);
int n;
long long k;
cin >> n >> k;
for (int i = 0; i <= n; ++i) {
cin >> ar[i];
for (int j = 0; j < max_mod; ++j) {
p[j] += bin_pow(2, i, pr[j]) * (ar[i] + pr[j]);
p[j] %= pr[j];
}
}
for (int j = 0; j < max_mod; ++j) {
p[j] = (pr[j] - p[j]) % pr[j];
}
const int max_k = 1000000000;
int ans = 0;
for (int i = 0; i <= n; ++i) {
long long st = bin_pow(2, i, pr[0]);
long long a = (ar[i] + pr[0]) * st + p[0];
a %= pr[0];
a *= get_obr(st, pr[0]);
a %= pr[0];
if (a > max_k) a -= pr[0];
while (a >= -max_k) {
int flag = 1;
for (int j = 1; j < max_mod; ++j) {
long long b = a - ar[i];
b *= bin_pow(2, i, pr[j]);
b %= pr[j];
b = (b + pr[j]) % pr[j];
if (p[j] != b) {
flag = 0;
break;
}
}
if (flag && abs(a) <= k && (i != n || a)) {
++ans;
break;
}
a -= pr[0];
}
}
cout << ans;
return 0;
}
| 2,200 | CPP |
#include <bits/stdc++.h>
using namespace std;
inline void read(int &x) {
x = 0;
char c = getchar();
while (c < '0' || c > '9') c = getchar();
while (c >= '0' && c <= '9') {
x = (x << 3) + (x << 1) + (c ^ 48);
c = getchar();
}
}
void print(int x) {
if (x > 9) print(x / 10);
putchar(x % 10 + '0');
}
inline int power(int a, int t) {
int res = 1;
while (t) {
if (t & 1) res = (long long)res * a % 1000000007;
a = (long long)a * a % 1000000007;
t >>= 1;
}
return res;
}
inline int dec(int a, int b) { return a < b ? a - b + 1000000007 : a - b; }
int pr[303], a[400003], tag1[400003 << 2], mul[400003 << 2], inv[303];
bool vis[303];
unsigned long long st[303], s[400003 << 2], tag2[400003 << 2];
char str[233];
int n, q, cnt;
inline void sieve(int n) {
for (register int i = 2; i <= n; ++i) {
if (!vis[i]) pr[++cnt] = i;
for (register int j = 1; j <= cnt; ++j) {
if (i * pr[j] > n) break;
vis[i * pr[j]] = true;
if (i % pr[j] == 0) break;
}
}
inv[1] = 1;
for (register int i = 2; i <= n; ++i)
inv[i] = (long long)(1000000007 - 1000000007 / i) * inv[1000000007 % i] %
1000000007;
}
void pushup(int u) {
s[u] = s[(u << 1)] | s[(u << 1 | 1)];
mul[u] = (long long)mul[(u << 1)] * mul[(u << 1 | 1)] % 1000000007;
}
inline void pushdown(int u, int l, int r) {
if (tag1[u] != 1) {
tag1[(u << 1)] = (long long)tag1[(u << 1)] * tag1[u] % 1000000007;
tag1[(u << 1 | 1)] = (long long)tag1[(u << 1 | 1)] * tag1[u] % 1000000007;
mul[(u << 1)] = (long long)mul[(u << 1)] *
power(tag1[u], ((l + r) >> 1) - l + 1) % 1000000007;
mul[(u << 1 | 1)] = (long long)mul[(u << 1 | 1)] *
power(tag1[u], r - ((l + r) >> 1)) % 1000000007;
tag1[u] = 1;
}
if (tag2[u]) {
tag2[(u << 1)] |= tag2[u], tag2[(u << 1 | 1)] |= tag2[u];
s[(u << 1)] |= tag2[u], s[(u << 1 | 1)] |= tag2[u];
tag2[u] = 0;
}
}
void build(int l, int r, int u) {
if (l == r) {
s[u] = st[a[l]];
mul[u] = a[l];
return;
}
build(l, ((l + r) >> 1), (u << 1));
build(((l + r) >> 1) + 1, r, (u << 1 | 1));
pushup(u);
}
void modify(int nl, int nr, int l, int r, int u, int k) {
if (nl <= l && r <= nr) {
tag1[u] = (long long)tag1[u] * k % 1000000007;
tag2[u] |= st[k];
s[u] |= st[k];
mul[u] = (long long)mul[u] * power(k, r - l + 1) % 1000000007;
return;
}
pushdown(u, l, r);
if (nl <= ((l + r) >> 1)) modify(nl, nr, l, ((l + r) >> 1), (u << 1), k);
if (nr > ((l + r) >> 1))
modify(nl, nr, ((l + r) >> 1) + 1, r, (u << 1 | 1), k);
pushup(u);
}
int qmul(int nl, int nr, int l, int r, int u) {
if (nl <= l && r <= nr) return mul[u];
pushdown(u, l, r);
int res = 1;
if (nl <= ((l + r) >> 1))
res =
(long long)res * qmul(nl, nr, l, ((l + r) >> 1), (u << 1)) % 1000000007;
if (nr > ((l + r) >> 1))
res = (long long)res * qmul(nl, nr, ((l + r) >> 1) + 1, r, (u << 1 | 1)) %
1000000007;
return res;
}
unsigned long long qset(int nl, int nr, int l, int r, int u) {
if (nl <= l && r <= nr) return s[u];
pushdown(u, l, r);
unsigned long long res = 0;
if (nl <= ((l + r) >> 1)) res |= qset(nl, nr, l, ((l + r) >> 1), (u << 1));
if (nr > ((l + r) >> 1))
res |= qset(nl, nr, ((l + r) >> 1) + 1, r, (u << 1 | 1));
return res;
}
int main() {
for (register int i = 0; i < (400003 << 2); ++i) tag1[i] = 1;
int l, r, k, pt, ans;
unsigned long long tmp;
sieve(300);
read(n), read(q);
for (register int i = 1; i <= n; ++i) read(a[i]);
for (register int i = 1; i <= 300; ++i)
for (register int j = 1; j <= cnt; ++j)
if (i % pr[j] == 0) st[i] |= 1ull << j;
build(1, n, 1);
while (q--) {
pt = 0;
char c = getchar();
while (c < 'A' || c > 'Z') c = getchar();
while (c >= 'A' && c <= 'Z') {
str[++pt] = c;
c = getchar();
}
read(l), read(r);
if (str[1] == 'T') {
ans = qmul(l, r, 1, n, 1);
tmp = qset(l, r, 1, n, 1);
for (register int i = 1; i <= cnt; ++i) {
if (!((tmp >> i) & 1)) continue;
ans = (long long)ans * dec(1, inv[pr[i]]) % 1000000007;
}
print(ans);
putchar('\n');
} else {
read(k);
modify(l, r, 1, n, 1, k);
}
}
return 0;
}
| 2,400 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 150005;
int n, a[maxn], box[maxn], Max, ans, b[maxn];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i], box[a[i]]++, Max = max(Max, a[i]);
for (int i = Max; i > 0; i--) {
if (!b[i + 1] && box[i]) ans++, box[i]--, b[i + 1] = 1;
if (!b[i] && box[i]) ans++, box[i]--, b[i] = 1;
if (i > 1 && !b[i - 1] && box[i]) ans++, box[i]--, b[i - 1] = 1;
}
printf("%d\n", ans);
return 0;
}
| 1,500 | CPP |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, max = -1;
scanf("%d", &n);
string a, b;
cin >> a >> b;
int ca[26], cb[26];
for (int i = 0; i < 26; i++) {
ca[i] = 0;
cb[i] = 0;
}
for (int i = 0; i < n; i++) {
ca[a[i] - 'a']++;
cb[b[i] - 'a']++;
}
for (int i = 0; i < 26; i++) {
if (ca[i] != cb[i]) {
printf("-1\n");
return;
}
}
for (int i = 0; i < b.size(); i++) {
int k = i;
for (int j = 0; j < a.size(); j++) {
if (a[j] == b[k]) {
k++;
}
}
if (k - i > max) {
max = k - i;
}
}
printf("%d\n", n - max);
}
int main() {
int t;
scanf("%d", &t);
for (int i = 0; i < t; i++) {
solve();
}
}
| 2,200 | CPP |
import sys
input, print = sys.stdin.buffer.readline, sys.stdout.write
for _ in range(int(input())):
n = int(input())
a1, b1 = map(int, input().split())
a, b, s = [a1], [0], 0
for _ in range(n-1):
a2, b2 = map(int, input().split())
a.append(a2)
b.append(max(a2 - b1, 0))
a1, b1 = a2, b2
s += b[-1]
b[0] = max(a[0] - b1, 0)
s += b[0]
print(str(min([s+a[i]-b[i] for i in range(n)]))+'\n') | 1,600 | PYTHON3 |
t=int(input())
for _ in range(t):
l=input()
count=0
a=[]
for x in range(len(l)):
if l[x]!='0':
c=l[x]
for t in range(x,len(l)-1):
c=c+'0'
a.append(c)
count=count+1
print(count)
for x in a:
print(x,end=' ')
print()
| 800 | PYTHON3 |
# Author : -Pratyay-
import sys
inp=sys.stdin.buffer.readline
inar=lambda: list(map(int,inp().split()))
inin=lambda: int(inp())
inst=lambda: inp().decode().rstrip('\n\r')
# Am I debugging, check if I'm using same variable name in two places
# Start Pyrival Bootstrap (Pajenegod's Infinite Recursion trick)
from types import GeneratorType
def recursive(f, stack=[]):
def wrappedfunc(*args, **kwargs):
if stack: return f(*args, **kwargs)
else:
to = f(*args, **kwargs)
while True:
if type(to) is GeneratorType:
stack.append(to); to = next(to)
else:
stack.pop()
if not stack: break
to = stack[-1].send(to)
return to
return wrappedfunc
# End PyRival Bootstrap;
def centroid(g):
n=len(g)
centroid=[]
size=[0 for i in range(n)]
@recursive
def dfs(node,par):
size[node]=1
iscent=True
for nei in g[node]:
if nei!=par:
yield dfs(nei,node)
size[node]+=size[nei]
if size[nei]> n//2:
iscent=False
if n-size[node]>n//2:
iscent=False
if iscent:
centroid.append(node)
yield
dfs(0,-1)
return centroid,size
_T_=inin()
for _t_ in range(_T_):
n=inin()
gr=[[] for i in range(n)]
vis=[False for i in range(n)]
for i in range(n-1):
x,y=inar()
x-=1
y-=1
gr[x].append(y)
gr[y].append(x)
cent,size=centroid(gr)
if len(cent)==1:
print(x+1,y+1)
print(x+1,y+1)
else:
#print(size)
opponent=-1
maxsize=-12
to_remove=-1
for node in cent:
for nei in gr[node]:
if size[nei]>maxsize and nei not in cent:
maxsize=size[nei]
opponent=node
to_remove=nei
if opponent==cent[0]:
print(cent[0]+1,to_remove+1)
print(cent[1]+1,to_remove+1)
else:
print(cent[1]+1,to_remove+1)
print(cent[0]+1,to_remove+1)
| 1,700 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, w = 1;
cin >> a;
cin >> b;
a = min(a, b);
for (b = 1; b <= a; b++) {
w *= b;
}
cout << w;
return 0;
}
| 800 | CPP |
import sys
def input():return sys.stdin.readline()[:-1]
def N(): return int(input())
def NM():return map(int,input().split())
def L():return list(NM())
def LN(n):return [N() for i in range(n)]
def LL(n):return [L() for i in range(n)]
t=N()
import collections
def f():
n=N()
a=L()
if n%2:
m=a[n//2]
d=collections.defaultdict(int)
for i in range(n//2):
x,y=a[i],a[-1-i]
if y<x:
x,y=y,x
d[(x,y)]+=1
a=L()
if n%2:
if m!=a[n//2]:
print("No")
return
for i in range(n//2):
x,y=a[i],a[-1-i]
if y<x:
x,y=y,x
if d[(x,y)]==0:
print("No")
return
d[(x,y)]-=1
print("Yes")
return
for i in range(t):
f() | 2,100 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
inline void debugMode() {}
const int NMax = 1e5 + 5;
int v[105];
int b[105];
int main() {
debugMode();
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> v[i];
}
for (int i = 1; i <= m; i++) {
cin >> b[i];
}
sort(b + 1, b + m + 1);
int i, j;
i = n;
j = 1;
while (i > 0 && j <= m) {
if (v[i] == 0) {
v[i] = b[j];
j++;
}
i--;
}
if (n == 1) {
cout << "No";
return 0;
}
bool ok = false;
for (int i = 2; i <= n; i++) {
if (v[i] < v[i - 1]) {
ok = true;
}
}
if (ok) {
cout << "Yes";
} else {
cout << "No";
}
return 0;
}
| 900 | CPP |
n= int(input())
if n % 2:
print(((n+1)+2)*(n+1)//2)
else:
print((n+2)**2//4)
| 1,300 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long n, k, ans;
string s;
int main() {
cin >> n;
cin >> s;
for (k = 0; k < n - 2; k++) {
if (s[k] == s[k + 1]) {
ans++;
if (s[k] != 'B' && s[k + 2] != 'B') {
s[k + 1] = 'B';
} else if (s[k] != 'G' && s[k + 2] != 'G')
s[k + 1] = 'G';
else
s[k + 1] = 'R';
}
}
if (s[n - 1] == s[n - 2]) {
ans++;
if (s[n - 2] != 'R')
s[n - 1] = 'R';
else
s[n - 1] = 'G';
}
cout << ans << endl;
cout << s;
}
| 1,400 | CPP |
t = int(input())
for i in range(t):
n = int(input())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
c = list(map(int, input().split()))
p = [0] * n
pred = -1
for i in range(n - 1):
if a[i] != pred:
pred = a[i]
p[i] = a[i]
else:
pred = b[i]
p[i] = b[i]
if p[-2] != a[-1] and p[0] != a[-1]:
p[-1] = a[-1]
elif p[-2] != b[-1] and p[0] != b[-1]:
p[-1] = b[-1]
else:
p[-1] = c[-1]
print(" ".join(map(str, p)))
| 800 | PYTHON3 |
import sys
lines = [line.strip() for line in sys.stdin.readlines()]
n = int(lines[0].split(' ')[0])
a = list(map(int, lines[1].split(' ')))
count = 0
steps = []
for idx, step in enumerate(a):
if step == 1:
count += 1
if idx != 0:
steps.append(a[idx-1])
steps.append(a[-1])
print(count)
print(' '.join(map(str, steps))) | 800 | PYTHON3 |
import sys
import itertools as it
import math
n = int(sys.stdin.readline())
p = list(map(int, sys.stdin.readline().split()))
level = dict()
level[1] = 1
for k in range(len(p)):
level[k+2] = level[p[k]]+1
level_cnt = dict()
for v in level.values():
level_cnt.setdefault(v,0)
level_cnt[v]+=1
r = sum(map(lambda e: e%2, level_cnt.values()))
print(r) | 1,500 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int N, M;
char s[105][20005];
int col[105][20005], col2[105][20005];
int arr[105][20005], arr2[105][20005];
int main() {
memset(col, -1, sizeof col);
memset(col2, -1, sizeof col2);
scanf("%d %d", &N, &M);
for (int i = 0; i < N; i++) {
scanf("%s", s[i]);
for (int j = M; j < M + M; j++) s[i][j] = s[i][j - M];
}
M += M;
int k = 0, F = 0;
for (int i = 0; i < N; i++) {
k = 0;
bool flag = 0;
for (int j = 0; j < M; j++) {
if (s[i][j] == '1') flag = 1;
arr[i][j] = k;
if (s[i][j] == '1') {
col[i][k] = j;
k++;
}
}
if (!flag) {
F = 1;
}
}
if (F) {
printf("-1\n");
return 0;
}
for (int i = 0; i < N; i++) {
k = 0;
for (int j = M - 1; j >= 0; j--) {
arr2[i][j] = k;
if (s[i][j] == '1') {
col2[i][k] = j;
k++;
}
}
}
int ret = 1 << 30;
for (int i = 0; i < M; i++) {
int x = 0;
for (int j = 0; j < N; j++) {
int a = 1 << 30;
if (col[j][arr[j][i]] != -1) a = abs(i - col[j][arr[j][i]]);
int b = 1 << 30;
if (col2[j][arr2[j][i]] != -1) b = abs(i - col2[j][arr2[j][i]]);
x += min(a, b);
}
ret = min(ret, x);
}
printf("%d\n", ret);
getchar();
getchar();
}
| 1,500 | CPP |
n = int(input())
sx = 0
sy = 0
l = []
while n > 0:
n -= 1
x, y = map(int, input().split())
sx += x
sy += y
l.append([x, y])
if sx % 2 == 0 and sy % 2 == 0:
print(0)
elif (sx % 2 == 0 and sy % 2 != 0) or (sx % 2 != 0 and sy % 2 == 0):
print(-1)
else:
f = 0
for i in l:
if (i[0]+i[1]) % 2 != 0:
f = 1
if f == 0:
print(-1)
else:
print(1)
| 1,200 | PYTHON3 |
# import sys
# sys.stdin=open("input.in","r")
# sys.stdout=open("output.out","w")
a=(input())
b=(input())
for i in range(len(a)):
if a[i] != b[i]:
print('1',end='')
else:
print('0',end='') | 800 | PYTHON3 |
for _ in range(int(input())):
n,k=map(int,input().split())
if n>k:
print(k)
elif n==k:
print(k+1)
else:
r = k // (n - 1)
if k%(n - 1)==0:
r=(k//(n-1))-1
print(k+r)
| 1,200 | PYTHON3 |
# cook your dish here
import math
def main():
for q in range(int(input())):
A,B,C = map(int,input().split())
if(A < C and B!=1):
print("1",end=" ")
else :
print("-1",end=" ")
if(A*B > C):
print(B,end=" ")
else :
print("-1",end=" ")
print()
if __name__ == "__main__":
main() | 1,000 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
clock_t __START, __END;
double __TOTALTIME;
void _MS() { __START = clock(); }
void _ME() {
__END = clock();
__TOTALTIME = (double)(__END - __START) / CLOCKS_PER_SEC;
cout << "Time: " << __TOTALTIME << " s" << endl;
}
const double E = 2.718281828;
const double PI = acos(-1.0);
const long long INF = (1LL << 60);
const int inf = (1 << 30);
const double ESP = 1e-9;
const int mod = (int)1e9 + 7;
const int N = (int)1e6 + 10;
bool zero(double x) { return (x > 0 ? x : -x) < ESP; }
struct point {
double x, y;
};
struct line {
point a, b;
};
double xmult(point p1, point p2, point p0) {
return (p1.x - p0.x) * (p2.y - p0.y) - (p2.x - p0.x) * (p1.y - p0.y);
}
double dmult(point p1, point p2, point p0) {
return (p1.x - p0.x) * (p2.x - p0.x) + (p1.y - p0.y) * (p2.y - p0.y);
}
double distance(point p1, point p2) {
return sqrt((p1.x - p2.x) * (p1.x - p2.x) + (p1.y - p2.y) * (p1.y - p2.y));
}
bool isIntersected(point s1, point e1, point s2, point e2) {
return (max(s1.x, e1.x) >= min(s2.x, e2.x)) &&
(max(s2.x, e2.x) >= min(s1.x, e1.x)) &&
(max(s1.y, e1.y) >= min(s2.y, e2.y)) &&
(max(s2.y, e2.y) >= min(s1.y, e1.y)) &&
(xmult(s1, s2, e1) * xmult(s1, e1, e2) > 0) &&
(xmult(s2, s1, e2) * xmult(s2, e2, e1) > 0);
}
point intersection(point u1, point u2, point v1, point v2) {
point ret = u1;
double t = ((u1.x - v1.x) * (v1.y - v2.y) - (u1.y - v1.y) * (v1.x - v2.x)) /
((u1.x - u2.x) * (v1.y - v2.y) - (u1.y - u2.y) * (v1.x - v2.x));
ret.x += (u2.x - u1.x) * t;
ret.y += (u2.y - u1.y) * t;
return ret;
}
point rotate(point p0, double alpha) {
alpha = alpha / 180 * PI;
return {p0.x * cos(alpha) - p0.y * sin(alpha),
p0.y * cos(alpha) + p0.x * sin(alpha)};
}
point Pin[20];
int cmp(point a, point b) {
if (xmult(a, b, Pin[1]) > ESP) return 1;
if (fabs(xmult(a, b, Pin[1])) < ESP &&
distance(b, Pin[1]) - distance(a, Pin[1]) > ESP)
return 1;
return 0;
}
point Stack[N];
int top;
void Graham(int n, point p[]) {
top = 3;
sort(p + 2, p + 1 + n, cmp);
Stack[1] = p[1];
Stack[2] = p[2];
Stack[3] = p[3];
for (int i = 4; i <= n; i++) {
while (top >= 1 && xmult(p[i], Stack[top], Stack[top - 1]) > ESP) {
top--;
}
Stack[++top] = p[i];
}
}
double getArea() {
double sum = fabs(xmult(Stack[2], Stack[3], Stack[1]));
for (int i = 3; i < top; i++)
sum += fabs(xmult(Stack[i], Stack[i + 1], Stack[1]));
return sum / 2.0;
}
int main() {
double w, h, alpha;
scanf("%lf%lf%lf", &w, &h, &alpha);
if (alpha == 0 || alpha == 180) {
printf("%.10lf\n", w * h);
return 0;
}
if (alpha == 90 && w == h) {
printf("%.10lf\n", w * h);
return 0;
}
line line1[10];
point p1 = {-w / 2, h / 2};
point p2 = {w / 2, h / 2};
point p3 = {w / 2, -h / 2};
point p4 = {-w / 2, -h / 2};
line1[1] = {p1, p2};
line1[2] = {p2, p3};
line1[3] = {p3, p4};
line1[4] = {p4, p1};
line line2[10];
p1 = rotate(p1, alpha);
p2 = rotate(p2, alpha);
p3 = rotate(p3, alpha);
p4 = rotate(p4, alpha);
line2[1] = {p1, p2};
line2[2] = {p2, p3};
line2[3] = {p3, p4};
line2[4] = {p4, p1};
int cp = 0;
for (int i = 1; i <= 4; ++i) {
for (int j = 1; j <= 4; ++j) {
if (isIntersected(line1[i].a, line1[i].b, line2[j].a, line2[j].b))
Pin[++cp] =
intersection(line1[i].a, line1[i].b, line2[j].a, line2[j].b);
}
}
Graham(cp, Pin);
printf("%.10lf\n", getArea());
return 0;
}
| 2,000 | CPP |
n = int(input())
if n % 2 == 1:
print(-1)
else:
edges = [[] for i in range(n)]
for i in range(n-1):
[a,b] = [int(j) for j in input().split()]
edges[a-1].append(b-1)
edges[b-1].append(a-1)
dfs_stack = [0]
comp_size = [1 for i in range(n)]
visited = [-1 for i in range(n)]
visited[0] = 0
while dfs_stack != []:
current_node = dfs_stack[-1]
can_go_further = False
for i in edges[current_node]:
if visited[i] == -1:
dfs_stack.append(i)
visited[i] = current_node
can_go_further = True
if can_go_further == False:
dfs_stack.pop(-1)
comp_size[visited[current_node]] += comp_size[current_node]
ans = 0
for i in comp_size[1:]:
if i % 2 == 0:
ans += 1
print(ans) | 1,500 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n;
cin >> n;
long long arr[2 * n];
for (long long i = 0; i < 2 * n; i++) {
cin >> arr[i];
}
vector<long long> odd, even;
for (long long i = 0; i < 2 * n; i++) {
if (arr[i] % 2)
odd.push_back(i + 1);
else
even.push_back(i + 1);
}
vector<pair<long long, long long>> ans;
for (long long i = 0; i + 1 < odd.size(); i += 2) {
ans.push_back({odd[i], odd[i + 1]});
}
for (long long i = 0; i + 1 < even.size(); i += 2) {
ans.push_back({even[i], even[i + 1]});
}
for (long long i = 0; i < n - 1; i++)
cout << ans[i].first << ' ' << ans[i].second << endl;
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long t = 1;
cin >> t;
for (long long i = 0; i < t; i++) {
solve();
}
return 0;
}
| 1,100 | CPP |
n,m = input().split()
n = int(n)
m = int(m)
contador = 0
for x in range(n):
dato = input()
dato = sorted(set(dato))
if m < len(dato):
if m == int(dato[m]) :
contador = contador+1
print(contador) | 1,100 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int r = 0, f = 1;
char ch = getchar();
while (ch < 48) {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch > 47) r = r * 10 + (ch ^ 48), ch = getchar();
return r * f;
}
inline int max(const int &a, const int &b) { return a > b ? a : b; }
inline int min(const int &a, const int &b) { return a > b ? b : a; }
const int maxn = 400086;
int a, b, c, d;
int arr[maxn], num;
int tim[5], pt;
void fuck() {
puts("NO");
exit(0);
}
void work() {
memset(arr, -1, sizeof(arr));
tim[0] = read(), tim[1] = read();
tim[2] = read(), tim[3] = read();
pt = tim[0] + tim[1] + tim[2] + tim[3];
int sum = tim[0] + tim[1] + tim[2] + tim[3];
if (tim[0] > tim[1] + 1) fuck();
if (tim[0] == tim[1] + 1) {
if (tim[2] || tim[3])
fuck();
else {
printf("YES\n");
for (int i = 1; i <= tim[1]; ++i) printf("%d %d ", 0, 1);
printf("0\n");
return;
}
}
for (int i = 1; i <= tim[0]; ++i) arr[++num] = 0, arr[++num] = 1, tim[1]--;
if (tim[3] > tim[2] + 1) fuck();
if (tim[3] == tim[2] + 1) {
if (tim[0] || tim[1]) fuck();
printf("YES\n");
for (int i = 1; i <= tim[2]; ++i) printf("3 2 ");
printf("3");
return;
}
for (int i = 1; i <= tim[3]; ++i) arr[pt--] = 3, arr[pt--] = 2, tim[2]--;
if (abs(tim[1] - tim[2]) <= 1) {
printf("YES\n");
if (tim[1] > tim[2]) printf("1 ");
for (int i = 1; i <= num; ++i) printf("%d ", arr[i]);
for (int i = 1; i <= min(tim[1], tim[2]); ++i) printf("2 1 ");
for (int i = pt + 1; i <= sum; ++i) printf("%d ", arr[i]);
if (tim[1] < tim[2]) printf("2 ");
return;
}
fuck();
}
signed main() { work(); }
| 1,900 | CPP |
n,p=map(int,input().split())
ans=[0]*n
if p>(n+1)//2:p=(~(p-1))%n+1
s=input()
for i in range(n//2):ans[i]=min((ord(s[i])-ord(s[~i]))%26,(ord(s[~i])-ord(s[i]))%26)
fz,lz=0,n//2-1
while fz<n and ans[fz]==0:fz+=1
while lz>=0 and ans[lz]==0:lz-=1
l=max(0,p-1-fz);r=max(0,n//2-p-n//2+1+lz)
print(sum(ans)+min(l*2+r,r*2+l)) | 1,700 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long int n, i, m, j, k;
long long int t;
cin >> t;
while (t--) {
cin >> n >> m;
string s[n];
for (long long int i = 0; i < n; i++) cin >> s[i];
long long int x = 0;
for (i = 0; i < n; i++) {
if (s[i][m - 1] == 'R') x++;
}
for (i = 0; i < m; i++) {
if (s[n - 1][i] == 'D') x++;
}
cout << x;
cout << "\n";
}
return 0;
}
| 800 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long i, j, k, n, m, p;
scanf("%lld", &n);
if (n <= 2)
printf("-1\n");
else if (n & 1) {
printf("%lld %lld\n", (n * n + 1) / 2, (n * n - 1) / 2);
} else {
printf("%lld %lld\n", n * n / 4 + 1, n * n / 4 - 1);
}
return 0;
}
| 1,500 | CPP |
n=int(input())
a=[1]
b=[]
i=2
if(n==1):
print("YES")
print("1 2")
if(n%2==0):
print("NO")
elif(n>=3):
print("YES")
while(i<=n*2):
if(i%4==0):
if(i<n*2):
a.append(i)
a.append(i+1)
elif(i==n*2):
a.append(i)
i=i+2
continue
else:
if(i<n*2):
b.append(i)
b.append(i+1)
elif(i==n*2):
b.append(i)
i=i+2
continue
for j in range(n):
print(a[j],end=" ")
for j in range(n):
print(b[j],end=" ")
| 1,200 | PYTHON3 |
# AC
import sys
class Main:
def __init__(self):
self.buff = None
self.index = 0
def next(self):
if self.buff is None or self.index == len(self.buff):
self.buff = sys.stdin.readline().split()
self.index = 0
val = self.buff[self.index]
self.index += 1
return val
def next_int(self):
return int(self.next())
def solve(self):
n = self.next_int()
x = sorted([(self.next_int(), self.next_int()) for _ in range(0, n)], key=lambda o: o[1] - o[0])
ans = 0
for i in range(0, n):
ans += x[i][0] * i + x[i][1] * (n - i - 1)
print(ans)
if __name__ == '__main__':
Main().solve()
| 1,600 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int read() {
int kkk = 0, x = 1;
char c = getchar();
while ((c < '0' || c > '9') && c != '-') c = getchar();
if (c == '-') c = getchar(), x = -1;
while (c >= '0' && c <= '9')
kkk = (kkk << 3) + (kkk << 1) + (c - '0'), c = getchar();
return kkk * x;
}
const int oo = 0x3f3f3f3f;
int n, m, N = 1, head[1200001], tot, mem[1200001], col, ans, dl[1200001], h, t,
S, T, Plus, lid[1200001], pd[1200001], ans1[1200001], ans2[1200001],
point[1200001], Lid[1200001];
int deep[1200001], father[1200001], id[1200001], top[1200001], son[1200001],
size[1200001], cnt;
struct sb {
int from, to, nextn, l;
} a[1200001];
struct node {
int l, r;
} tree[1200001];
void ADD(int from, int to, int l) {
a[++tot].to = to, a[tot].nextn = head[from], a[tot].from = from, a[tot].l = l;
head[from] = tot;
}
void build(int from, int to, int l) {
ADD(from, to, l);
ADD(to, from, 0);
}
void fun1(int u, int fa) {
father[u] = fa, deep[u] = deep[fa] + 1, size[u] = 1;
for (int i = head[u]; i != 0; i = a[i].nextn) {
int v = a[i].to;
if (v == fa) continue;
lid[v] = (i + 1) / 2;
fun1(v, u);
size[u] += size[v];
if (size[v] > size[son[u]]) son[u] = v;
}
}
void fun2(int u, int toop) {
id[u] = ++cnt, point[cnt] = u, top[u] = toop;
if (!son[u]) return;
fun2(son[u], toop);
for (int i = head[u]; i != 0; i = a[i].nextn) {
int v = a[i].to;
if (v == father[u] || v == son[u]) continue;
fun2(v, v);
}
}
int build_t(int l, int r) {
int bj = ++N;
if (l == r) {
Lid[bj] = lid[point[l]];
build(bj, bj + Plus, 1);
return bj;
}
int mid = (l + r) / 2;
tree[bj].l = build_t(l, mid);
tree[bj].r = build_t(mid + 1, r);
build(bj, tree[bj].l, oo);
build(bj, tree[bj].r, oo);
build(tree[bj].l + Plus, bj + Plus, oo);
build(tree[bj].r + Plus, bj + Plus, oo);
return bj;
}
void xg(int l, int r, int L, int R, int bj) {
if (L <= l && r <= R) {
build(col, bj, oo);
build(bj + Plus, col + 1, oo);
return;
}
int mid = (l + r) / 2;
if (L <= mid) xg(l, mid, L, R, tree[bj].l);
if (mid < R) xg(mid + 1, r, L, R, tree[bj].r);
}
void qxg(int x, int y) {
while (top[x] != top[y]) {
if (deep[top[x]] < deep[top[y]]) swap(x, y);
xg(2, n, id[top[x]], id[x], 2);
x = father[top[x]];
}
if (x == y) return;
if (deep[x] > deep[y]) swap(x, y);
xg(2, n, id[son[x]], id[y], 2);
}
int make() {
memset(deep, 0, sizeof(deep));
deep[S] = 1;
h = t = 0;
dl[++t] = S;
while (h != t) {
int u = dl[++h];
for (int i = head[u]; i != 0; i = a[i].nextn) {
int v = a[i].to;
if (deep[v] || !a[i].l) continue;
deep[v] = deep[u] + 1;
dl[++t] = v;
if (v == T) return 1;
}
}
return 0;
}
int fun(int u, int flow) {
if (u == T) return flow;
int rest = flow;
for (int i = head[u]; i != 0 && rest != 0; i = a[i].nextn) {
int v = a[i].to;
if (deep[v] != deep[u] + 1 || !a[i].l) continue;
int K = fun(v, min(rest, a[i].l));
if (!K) deep[v] = 0;
a[i].l -= K;
a[i ^ 1].l += K;
rest -= K;
}
return flow - rest;
}
void Dinic() {
while (make())
while (1) {
int K = fun(S, oo);
if (!K) break;
ans += K;
}
}
void paint(int u) {
pd[u] = 1;
for (int i = head[u]; i != 0; i = a[i].nextn) {
int v = a[i].to;
if (!a[i].l || pd[v]) continue;
paint(v);
}
}
int main() {
n = read(), m = read();
Plus = 14 * n;
for (int i = 1; i < n; ++i) {
int u = read(), v = read();
build(u, v, 0);
}
fun1(1, 0);
fun2(1, 1);
memset(head, 0, sizeof(head));
tot = 1;
build_t(2, n);
N = 2 * Plus;
S = 0, T = 1;
for (int i = 1; i <= m; ++i) {
int x = read(), y = read();
col = ++N;
mem[N] = i;
build(S, N, 1);
qxg(x, y);
++N;
build(N, T, oo);
}
Dinic();
printf("%d\n", ans);
paint(S);
for (int i = 2; i <= tot; i += 2)
if (pd[a[i].from] != pd[a[i].to] && !a[i].l) {
if (a[i].from == S)
ans1[++ans1[0]] = mem[a[i].to];
else
ans2[++ans2[0]] = Lid[a[i].from];
}
sort(ans1 + 1, ans1 + ans1[0] + 1);
sort(ans2 + 1, ans2 + ans2[0] + 1);
printf("%d", ans1[0]);
for (int i = 1; i <= ans1[0]; ++i) printf(" %d", ans1[i]);
putchar('\n');
printf("%d", ans2[0]);
for (int i = 1; i <= ans2[0]; ++i) printf(" %d", ans2[i]);
return 0;
}
| 3,200 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <class T1, class T2>
inline void upd1(T1& a, const T2& b) {
a = a < b ? a : b;
}
template <class T1, class T2>
inline void upd2(T1& a, const T2& b) {
a = b < a ? a : b;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
struct Ano {
operator long long() {
long long x = 0, y = 0, c = getchar();
while (c < 48) {
y = c == 45;
c = getchar();
}
while (c > 47) {
x = x * 10 + c - 48;
c = getchar();
}
return y ? -x : x;
}
} buf;
const int N = 2e5 + 5;
set<int> f[N], g[N];
struct vec {
int a, b, s;
} t[N * 4];
vec operator+(vec a, vec b) {
return {max(a.a, b.a), min(a.b, b.b), a.s && b.s && b.a < a.b};
}
void upd(int u, int i, int j, int k) {
if (i == j) {
int a = f[i].empty() ? -1 : *f[i].rbegin();
int b = g[i].empty() ? N : *g[i].begin();
t[k] = {a, b, a < b};
} else {
if (u < ((i + j >> 1) + 1))
upd(u, i, (i + j >> 1), (k << 1));
else
upd(u, ((i + j >> 1) + 1), j, ((k << 1) ^ 1));
t[k] = t[(k << 1)] + t[((k << 1) ^ 1)];
}
}
int main() {
int n = buf, m = buf, q = buf;
for (int i = 0; i < n; ++i) upd(i, 0, n - 1, 1);
while (q--) {
int i = buf - 1, j = buf - 1;
auto& c = i & 1 ? f : g;
i /= 2, j /= 2;
auto p = c[i].find(j);
if (c[i].end() == p)
c[i].insert(j);
else
c[i].erase(p);
upd(i, 0, n - 1, 1);
puts(t[1].s ? "YES" : "NO");
}
}
| 2,800 | CPP |
import math
t = int(input())
for i in range(t):
n = int(input())
lst= list(map(int,input().split()))
dp = [0 for i in range(n)]
Max= lst[0]
for j in range(1,n):
Max = max(Max,lst[j])
dp[j] = lst[j] - Max
Min = abs(min(dp))
ans = math.log((Min+1),2)
print(math.ceil(ans))
| 1,500 | PYTHON3 |
import sys
end = sys.exit
n , k = map(int,input().split())
l = list(map(int,input().split()))
temp = n
minn = n
for i in range(k):
if temp <= 0:
print(i)
end()
minn = min(minn,temp)
temp += l[i]
one_round = sum(l)
if one_round >= 0:
print(-1)
end()
rounds = (minn - one_round - 1) // (-one_round)
n += rounds*one_round
for i in range(k):
if n <= 0:
print( rounds*k + i )
end()
n += l[i]
| 1,700 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, i, b, ans, r, p, k;
pair<long long, long long> a[100000];
int main() {
cin >> n >> m;
for (i = 0; i < n; i++) {
cin >> a[i].second >> a[i].first >> b;
r += a[i].second;
ans += b * a[i].second;
a[i].first -= b;
}
r %= m;
if (r) r = m - r;
sort(a, a + n);
for (i = n - 1; i >= 0; i--) {
if (a[i].first >= 0) {
if (a[i].second + p >= m) {
ans += k + (m - p) * a[i].first;
a[i].second -= m - p;
k = 0;
p = 0;
}
ans += a[i].first * (a[i].second / m) * m;
a[i].second %= m;
p += a[i].second;
k += a[i].second * a[i].first;
continue;
}
if (p + r >= m) {
ans += k;
break;
}
if (a[i].second + p + r >= m) {
if (k + (m - p - r) * a[i].first > 0) ans += k + (m - p - r) * a[i].first;
break;
}
p += a[i].second;
k += a[i].second * a[i].first;
}
if (a[0].first > 0) ans += k;
cout << ans << endl;
return 0;
}
| 1,900 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[200020];
char s[200020];
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
cin >> s;
for (int i = 0; i < n - 1; i++) {
if (s[i] == '1') {
int j = i;
for (; s[j] == '1'; j++) {
}
sort(a + i, a + j + 1);
i = j;
}
}
for (int i = 0; i < n - 1; i++) {
if (a[i] > a[i + 1]) {
printf("NO\n");
return 0;
}
}
printf("YES\n");
return 0;
}
| 1,400 | CPP |
def debug(*a):
return
print('[DEBUG]', *a)
is_prime = [False, False] + [True] * (2600-2)
for i in range(2, 2600):
if is_prime[i]:
for j in range(i+i, 2600, i):
is_prime[j] = False
n, m = map(int, input().split())
a = [None] * n
for i in range(n):
a[i] = input()
b = [None] * (n+1)
b[n] = [0] * (m+1)
for i in range(n-1, -1, -1):
b[i] = [0] * (m+1)
for j in range(m-1, -1, -1):
b[i][j] = b[i+1][j] + b[i][j+1] - b[i+1][j+1] + int(a[i][j])
# debug(b[i])
ans = None
for k in range(2, max(n, m)+1):
if is_prime[k]:
# debug('k=', k)
kk = k*k
aa = 0
for i in range(0, n, k):
for j in range(0, m, k):
bb = b[i][j]
if i + k < n:
bb -= b[i+k][j]
if j + k < m:
bb -= b[i][j+k]
if i + k < n and j + k < m:
bb += b[i+k][j+k]
# debug(i, j, bb)
aa += min(bb, kk-bb)
# debug('aa=', aa)
if ans == None or aa < ans:
ans = aa
print(ans)
| 1,400 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1E5 + 10;
const int INF = 2E8 + 10;
struct Point {
int x, y;
Point(int _x = 0, int _y = 0) : x(_x), y(_y) {}
bool operator<(const Point &other) const { return y < other.y; }
};
int n, m;
Point a[N], b[N];
vector<int> rar;
struct SegmentTree {
vector<int> val[N * 4];
void Update(int id, int l, int r, int i, int key) {
if (i < l || r < i || l > r) return;
val[id].push_back(key);
if (l == r) return;
if (i <= (l + r) / 2)
Update(id << 1, l, (l + r) / 2, i, key);
else
Update(id << 1 | 1, (l + r) / 2 + 1, r, i, key);
}
bool Query(int id, int l, int r, int Jug, int jgu, int ujg, int ugj) {
if (jgu < l || r < Jug || l > r) return 0;
if (Jug <= l && r <= jgu) {
vector<int>::iterator it =
lower_bound(val[id].begin(), val[id].end(), ujg);
if (it == val[id].end()) return 0;
return (*it) <= ugj;
}
return Query(id << 1, l, (l + r) / 2, Jug, jgu, ujg, ugj) ||
Query(id << 1 | 1, (l + r) / 2 + 1, r, Jug, jgu, ujg, ugj);
}
bool Query(int Jug, int jgu, int ujg, int ugj) {
if (Jug > jgu || ujg > ugj) return 0;
Jug = lower_bound(rar.begin(), rar.end(), Jug) - rar.begin() + 1;
jgu = upper_bound(rar.begin(), rar.end(), jgu) - rar.begin();
return Query(1, 1, m, Jug, jgu, ujg, ugj);
}
} ST;
void Read_Input() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &a[i].x, &a[i].y);
a[i] = Point(a[i].x - a[i].y, a[i].x + a[i].y);
}
for (int i = 1; i <= m; i++) {
scanf("%d%d", &b[i].x, &b[i].y);
b[i] = Point(b[i].x - b[i].y, b[i].x + b[i].y);
rar.push_back(b[i].x);
}
}
void BuildTree() {
sort(b + 1, b + 1 + m);
sort(rar.begin(), rar.end());
for (int i = 1; i <= m; i++) {
int pos = lower_bound(rar.begin(), rar.end(), b[i].x) - rar.begin() + 1;
ST.Update(1, 1, m, pos, b[i].y);
}
}
int dist[N], idx[N];
bool cmp(int x, int y) { return dist[x] > dist[y]; }
void FindClosestStation() {
for (int i = 1; i <= n; i++) {
int l = 0, h = INF;
idx[i] = i;
dist[i] = INF;
while (l <= h) {
int mid = (l + h) >> 1;
if (ST.Query(a[i].x - mid, a[i].x + mid, a[i].y - mid, a[i].y + mid)) {
dist[i] = mid;
h = mid - 1;
} else
l = mid + 1;
}
}
sort(idx + 1, idx + 1 + n, cmp);
}
bool Check(int len) {
int Jug = -INF, ujg = -INF;
int jgu = INF, ugj = INF;
for (int jug = 1; jug <= n; jug++) {
int i = idx[jug];
int rem = len - dist[i];
if (rem >= 0 && ST.Query(Jug - rem, jgu + rem, ujg - rem, ugj + rem))
return 1;
Jug = max(Jug, a[i].x - len);
ujg = max(ujg, a[i].y - len);
jgu = min(jgu, a[i].x + len);
ugj = min(ugj, a[i].y + len);
if (Jug > jgu || ujg > ugj) return 0;
}
return 1;
}
void Solve() {
int l = 0, h = INF, ans;
while (l <= h) {
int mid = (l + h) >> 1;
if (Check(mid)) {
ans = mid;
h = mid - 1;
} else
l = mid + 1;
}
printf("%d", ans);
}
int main() {
Read_Input();
BuildTree();
FindClosestStation();
Solve();
return 0;
}
| 3,000 | CPP |
#include <bits/stdc++.h>
using namespace std;
int LIM = 2e5;
int main() {
int n, k;
cin >> n >> k;
vector<long long int> arr(n + 1, 0);
for (int i = 1; i <= n; i++) cin >> arr[i];
string s;
cin >> s;
s = "a" + s;
vector<long long int> temp;
long long int ans = 0;
temp.push_back(arr[1]);
for (int i = 2; i <= n; i++) {
if (s[i] == s[i - 1]) {
temp.push_back(arr[i]);
} else {
sort(temp.begin(), temp.end(), greater<int>());
for (int j = 0; j < min(k, (int)temp.size()); j++) {
ans += temp[j];
}
vector<long long int> t2;
temp = t2;
temp.push_back(arr[i]);
}
}
sort(temp.begin(), temp.end(), greater<int>());
for (int i = 0; i < min(k, (int)temp.size()); i++) {
ans += temp[i];
}
cout << ans << endl;
return 0;
}
| 1,300 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7, N = 3e5 + 5;
long long n, m, k;
long long a[N], ar[N];
long long l[N], r[N], d[N];
long long pr[N], p[N];
void solve(long long test_case) {
long long i, j;
cin >> n >> m >> k;
for (i = 0; i < n; i++) cin >> a[i];
for (i = 0; i < m; i++) cin >> l[i] >> r[i] >> d[i];
while (k--) {
long long X, Y;
cin >> X >> Y;
pr[X - 1]++;
pr[Y]--;
}
long long s = 0;
for (i = 0; i < m; i++) {
s += pr[i];
ar[l[i] - 1] += s * d[i];
ar[r[i]] -= s * d[i];
}
s = 0;
for (i = 0; i < n; i++) {
s += ar[i];
cout << s + a[i] << ' ';
}
return;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
solve(1);
return 0;
}
| 1,400 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int t;
cin >> t;
if (t % 2 == 0) {
cout << t / 2 << endl;
} else {
t -= 1;
cout << t / 2 << endl;
}
}
return 0;
}
| 800 | CPP |
#include <bits/stdc++.h>
using namespace std;
string str1, str2, str3, f0;
long long l1, l2, l3;
long long ln[100005];
char rec(long long n, long long k) {
if (n == 0) {
if (k <= ln[0]) {
return f0[k - 1];
} else {
return '.';
}
} else if (k <= l1) {
return str1[k - 1];
} else if (k <= ln[n - 1] + l1) {
return (rec(n - 1, k - l1));
} else if (k <= ln[n - 1] + l1 + l2) {
return str2[k - l1 - ln[n - 1] - 1];
} else if (k <= 2 * ln[n - 1] + l1 + l2) {
return (rec(n - 1, k - l1 - l2 - ln[n - 1]));
} else if (k <= 2 * ln[n - 1] + l1 + l2 + l3) {
return str3[k - 2 * ln[n - 1] - l1 - l2 - 1];
} else {
return '.';
}
}
int main() {
std::ios::sync_with_stdio(false);
;
str1 = "What are you doing while sending \"";
str2 = "\"? Are you busy? Will you send \"";
str3 = "\"?";
f0 = "What are you doing at the end of the world? Are you busy? Will you "
"save us?";
long long n, k, q;
l1 = str1.length();
l2 = str2.length();
l3 = str3.length();
std::cin >> q;
ln[0] = f0.length();
for (int i = 1; i <= 100000; i++) {
ln[i] = l1 + ln[i - 1] + l2 + ln[i - 1] + l3;
if (ln[i] >= 1000000000000000000) {
ln[i] = 1000000000000000000;
}
}
while (q--) {
std::cin >> n >> k;
std::cout << rec(n, k);
}
return 0;
}
| 1,700 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int targetSum;
cin >> targetSum;
int dayCount = 0;
vector<int> pagesToRead(7);
for (int i = 0; i < 7; i++) cin >> pagesToRead[i];
int sumSoFar = 0;
int i = 0;
while (sumSoFar < targetSum) {
sumSoFar += (pagesToRead[i % 7]);
i++;
}
if (i % 7)
cout << i % 7 << endl;
else
cout << 7 << endl;
return 0;
}
| 1,000 | CPP |
#include <bits/stdc++.h>
inline int Bitcount(int x) {
int ret = 0;
while (x) ret += x & 1, x >>= 1;
return ret;
}
int n, k;
int main() {
scanf("%d %d", &n, &k);
if (n == 1 && k == 0) {
printf("YES\n0\n");
return 0;
}
if (!(n & 1) || n - 2 * k < 3) {
puts("NO");
return 0;
}
if (n == 9 && k == 2) {
puts("NO");
return 0;
}
if (k == 0 && Bitcount(n + 1) != 1) {
puts("NO");
return 0;
}
if (k == 1 && Bitcount(n + 1) == 1) {
puts("NO");
return 0;
}
puts("YES");
if (k == 0 || k == 1) {
for (int i = 1; i < n; i++) printf("%d ", i >> 1);
printf("%d\n", n >> 1);
return 0;
}
int lim = n - 2 * (k - 1);
printf("%d", lim + 2);
for (int i = 2; i <= lim - 2; i++) printf(" %d", i >> 1);
if (Bitcount(lim + 1) == 1)
printf(" %d %d", n - 1, n - 1);
else
printf(" %d %d", (lim - 1) >> 1, lim >> 1);
for (int i = lim + 1; i < n - 1; i += 2) printf(" %d %d", i + 1, i + 3);
printf(" %d 0\n", n);
return 0;
}
| 2,800 | CPP |
#include <bits/stdc++.h>
using namespace std;
int t;
map<long long, int> m1;
map<string, int> m2;
int main() {
m1.clear();
m2.clear();
scanf("%d\n", &t);
while (t--) {
char s[20];
scanf("%s", s);
if (s[0] == '+') {
long long x;
scanf("%I64d", &x);
m1[x] += 1;
for (int i = 17; i >= 0; i--) {
s[i] = 48 + (x & 1LL);
x /= 10LL;
}
string ss(s);
m2[ss]++;
} else if (s[0] == '-') {
long long x;
scanf("%I64d", &x);
m1[x] -= 1;
for (int i = 17; i >= 0; i--) {
s[i] = 48 + (x & 1LL);
x /= 10LL;
}
string ss(s);
m2[ss]--;
} else {
scanf("%s", s);
int len = strlen(s);
for (int i = len - 1; i >= 0; i--) {
s[18 + i - len] = s[i];
}
for (int i = 17 - len; i >= 0; i--) s[i] = '0';
string ss(s);
printf("%d\n", m2[ss]);
}
}
return 0;
}
| 1,400 | CPP |
expr = input().split("+")
expr.sort()
print("+".join(expr))
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7, INF = 0x3f3f3f3f;
const long long LNF = 0x3f3f3f3f3f3f3f3f;
int main() {
int n, s;
cin >> n >> s;
if (s < 2 * n)
cout << "NO" << endl;
else {
cout << "YES" << endl;
for (int i = 1; i < n; ++i) cout << 2 << " ";
cout << s - (n - 1) * 2 << endl;
cout << 1 << endl;
}
}
| 1,400 | CPP |
s=str(input())
m,n=0,0
for i in s:
if i.isupper() is True:
m+=1
else:
n+=1
if m>n:
print(s.upper())
else:
print(s.lower()) | 800 | PYTHON3 |
for t in range(int(input())) :
n,m,k = map(int,input().split())
eachPlayerCard = n // k
winnnerJoker = 0
if m <= eachPlayerCard :
winnerJoker = m
m = 0
else :
winnerJoker = eachPlayerCard
m = m - eachPlayerCard
loserJoker = m // (k-1)
if m % (k-1) != 0 :
loserJoker += 1
print(winnerJoker - loserJoker)
| 1,000 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string m;
cin >> m;
long long int sum = 0, sum2 = 0, goal = 0;
for (int i = 0; i < m.length(); i++) {
goal += pow(2.0, i);
if (m[i] == 'B') sum += pow(2.0, i);
if (m[i] == 'A') sum2 += pow(2.0, i);
}
cout << -(goal - sum - (goal - sum2)) << endl;
}
| 0 | CPP |
#include <bits/stdc++.h>
long long mpow(long long a, long long n, long long mod) {
long long ret = 1;
long long b = a;
while (n) {
if (n & 1) ret = (ret * b) % mod;
b = (b * b) % mod;
n >>= 1;
}
return (long long)ret;
}
using namespace std;
bool a[6000001];
int x[51];
int main() {
int n, d, i, j;
cin >> n >> d;
for (j = 0; j < n; j++) cin >> x[j];
int sum = 0;
a[0] = true;
for (i = 0; i < n; i++) {
sum += x[i];
for (j = sum; j >= x[i]; j--) {
a[j] |= a[j - x[i]];
}
}
int cnt = 0, res = 0;
for (;; cnt++) {
for (j = d; j; j--) {
if (a[res + j]) {
res += j;
break;
}
}
if (!j) break;
}
cout << res << " " << cnt;
return 0;
}
| 2,200 | CPP |
q = int(input())
for i in range(q):
n, k = map(int, input().split())
s = input()
mas = []
for i in range(n):
if s[i] == '0':
mas.append(i)
for i in range(len(mas)):
if mas[i] - i <= k:
k -= mas[i] - i
mas[i] = i
else:
mas[i] -= k
break
num = 0
for i in range(n):
if num < len(mas) and mas[num] == i:
print (0, end = '')
num += 1
else:
print (1, end = '')
print ()
| 1,500 | PYTHON3 |
#include<bits/stdc++.h>
using namespace std;
#define int long long
#define inf 0x3f3f3f3f3f3f3f3f
const int N=4e5+5;
inline int read()
{
int x=0,f=1;
char c=getchar();
while(c<'0'||c>'9')
{
if(c=='-')
f=-1;
c=getchar();
}
while(c>='0'&&c<='9')
{
x=x*10+c-'0';
c=getchar();
}
return x*f;
}
int n;
int a[N],b[N],c[N],re[N],val[N],len=0;
inline int Find(int x)
{
return lower_bound(re+1,re+len+1,x)-re;
}
int tree[N];
inline int lowbit(int x)
{
return x&(-x);
}
inline void add(int place,int c)
{
for(int i=place;i<=len;i+=lowbit(i))
tree[i]=min(tree[i],c);
}
inline int ask(int place)
{
int ans=inf;
for(int i=place;i;i-=lowbit(i))
ans=min(ans,tree[i]);
return ans;
}
int Ans=0;
struct node{
int c1,c2,val;
}re1[N],re2[N];
inline bool cmp1(node x,node y)
{
return x.c1<y.c1;
}
inline bool cmp2(node x,node y)
{
return x.c1>y.c1;
}
inline void Work1()
{
for(int i=1;i<=n;i++) re1[i].c1=a[i], re1[i].c2=b[i], re1[i].val=-re[a[i]]-re[b[i]]-val[i];
for(int i=1;i<=n;i++) re2[i].c1=b[i], re2[i].c2=a[i], re2[i].val=re[a[i]]+re[b[i]]-val[i];
sort(re1+1,re1+n+1,cmp1); sort(re2+1,re2+n+1,cmp1);
int p1=1,p2=1; memset(tree,0x3f3f3f3f,sizeof(tree));
while(p1<=n || p2<=n)
{
if(p2>n || (p1<=n && re1[p1].c1<=re2[p2].c1)) add(re1[p1].c2,re1[p1].val), p1++;
else Ans=min(Ans,ask(re2[p2].c2)+re2[p2].val), p2++;
}
}
inline void Work2()
{
for(int i=1;i<=n;i++) re1[i].c1=a[i], re1[i].c2=b[i], re1[i].val=-re[a[i]]+re[b[i]]-val[i];
for(int i=1;i<=n;i++) re2[i].c1=b[i], re2[i].c2=a[i], re2[i].val=re[b[i]]-re[a[i]]-val[i];
sort(re1+1,re1+n+1,cmp1); sort(re2+1,re2+n+1,cmp1);
int p1=1,p2=1; memset(tree,0x3f3f3f3f,sizeof(tree));
while(p1<=n || p2<=n)
{
if(p2>n || (p1<=n && re1[p1].c1<=re2[p2].c1)) add(len-re1[p1].c2+1,re1[p1].val), p1++;
else Ans=min(Ans,ask(len-re2[p2].c2+1)+re2[p2].val), p2++;
}
}
inline void Work3()
{
for(int i=1;i<=n;i++) re1[i].c1=a[i], re1[i].c2=b[i], re1[i].val=re[a[i]]-re[b[i]]-val[i];
for(int i=1;i<=n;i++) re2[i].c1=b[i], re2[i].c2=a[i], re2[i].val=-re[b[i]]+re[a[i]]-val[i];
sort(re1+1,re1+n+1,cmp2); sort(re2+1,re2+n+1,cmp2);
int p1=1,p2=1; memset(tree,0x3f3f3f3f,sizeof(tree));
while(p1<=n || p2<=n)
{
if(p2>n || (p1<=n && re1[p1].c1>=re2[p2].c1)) add(re1[p1].c2,re1[p1].val), p1++;
else Ans=min(Ans,ask(re2[p2].c2)+re2[p2].val), p2++;
}
}
inline void Work4()
{
for(int i=1;i<=n;i++) re1[i].c1=a[i], re1[i].c2=b[i], re1[i].val=re[a[i]]+re[b[i]]-val[i];
for(int i=1;i<=n;i++) re2[i].c1=b[i], re2[i].c2=a[i], re2[i].val=-re[b[i]]-re[a[i]]-val[i];
sort(re1+1,re1+n+1,cmp2); sort(re2+1,re2+n+1,cmp2);
int p1=1,p2=1; memset(tree,0x3f3f3f3f,sizeof(tree));
while(p1<=n || p2<=n)
{
if(p2>n || (p1<=n && re1[p1].c1>=re2[p2].c1)) add(len-re1[p1].c2+1,re1[p1].val), p1++;
else Ans=min(Ans,ask(len-re2[p2].c2+1)+re2[p2].val), p2++;
}
}
signed main()
{
n=read(); int tot=0,sum=0;
for(int i=1;i<=n;i++) a[i]=read(), c[++tot]=a[i];
for(int i=1;i<=n;i++) b[i]=read(), c[++tot]=b[i], sum+=abs(a[i]-b[i]), val[i]=abs(a[i]-b[i]);
c[0]=-1; sort(c+1,c+tot+1);
for(int i=1;i<=tot;i++)
if(c[i]!=c[i-1])
re[++len]=c[i];
for(int i=1;i<=n;i++) a[i]=Find(a[i]), b[i]=Find(b[i]);
Work1(); Work2(); Work3(); Work4();
printf("%lld\n",sum+Ans);
return 0;
} | 2,500 | CPP |
#include <bits/stdc++.h>
int main() {
int n, a, b, trash;
assert(scanf("%d%d%d%d ", &n, &a, &b, &trash) == 4);
char s[n + 2];
assert(fgets(s, n + 1, stdin));
s[n] = '1';
int res[n], ans = 0, k = 0, st = 0;
for (int i = 0; i <= n; i++) {
if (s[i] == '0') {
k++;
continue;
}
for (int j = 0; j < k / b; j++) res[ans++] = st + (j + 1) * b - 1;
st = i + 1;
k = 0;
}
assert(ans >= a);
ans -= a - 1;
printf("%d\n", ans);
for (int i = 0; i < ans; i++) printf("%d%c", res[i] + 1, "\n "[i < ans - 1]);
return 0;
}
| 1,700 | CPP |
n = int(input())
s = input()
k = s.count('z')
print("1 " * ((len(s) - 4 * k) // 3) + "0 " * k)
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> adj[200001];
vector<int> v;
int dis[200001];
bool vis[200001];
long long ans = 0, mx = 0, n;
int even[1000001], odd[100011], good[100001], arr[100001];
void dfs(int s) {
vis[s] = true;
if (dis[s] % 2) {
if (odd[s] % 2) arr[s] = arr[s] ^ 1;
if (arr[s] != good[s]) {
odd[s]++;
v.push_back(s);
}
} else {
if (even[s] % 2) arr[s] = arr[s] ^ 1;
if (arr[s] != good[s]) {
even[s]++;
v.push_back(s);
}
}
for (int i = 0; i < adj[s].size(); i++) {
if (!vis[adj[s][i]]) {
dis[adj[s][i]] = dis[s] + 1;
odd[adj[s][i]] = odd[s];
even[adj[s][i]] = even[s];
dfs(adj[s][i]);
}
}
return;
}
int main() {
int x, y;
cin >> n;
for (int i = 1; i < n; i++) {
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
for (int i = 1; i <= n; i++) cin >> arr[i];
for (int i = 1; i <= n; i++) cin >> good[i];
dis[1] = 1;
dfs(1);
cout << v.size() << endl;
for (int i = 0; i < v.size(); i++) cout << v[i] << endl;
return 0;
}
| 1,300 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long a[5001], n, m;
double b[5001];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
cin >> n >> m;
for (long long i = 0; i < n; i++) cin >> a[i] >> b[i];
vector<long long> dp;
dp.push_back(INT_MAX);
for (long long i = 0; i < n; i++) {
if (a[i] >= dp.back())
dp.push_back(a[i]);
else {
long long j = upper_bound(dp.begin(), dp.end(), a[i]) - dp.begin();
dp[j] = a[i];
}
}
cout << n - dp.size() << endl;
}
| 1,700 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int frog;
cin >> frog;
for (int i = 0; i < frog; i++) {
long long int right, left, time;
cin >> right >> left >> time;
cout << ((time / 2) * (right - left)) + (right) * (time % 2) << endl;
}
return 0;
}
| 800 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, dis[1000][1000], k;
long long sum = 0;
int main() {
cin >> n;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) cin >> dis[i][j];
for (int i = 1; i <= n; i++)
for (int j = 1; j < i; j++) sum += dis[i][j];
int A, B, C;
cin >> k;
for (int times = 0; times < k; times++) {
cin >> A >> B >> C;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (dis[i][j] > dis[i][A] + C + dis[B][j]) {
int temp = dis[i][A] + C + dis[B][j];
sum -= dis[i][j] - temp;
dis[i][j] = dis[j][i] = temp;
}
printf("%I64d ", sum);
}
return 0;
}
| 1,900 | CPP |
# cook your dish here
from sys import stdin, stdout
import math
from itertools import permutations, combinations
from collections import defaultdict
from bisect import bisect_left
from bisect import bisect_right
def L():
return list(map(int, stdin.readline().split()))
def In():
return map(int, stdin.readline().split())
def I():
return int(stdin.readline())
P = 1000000007
def main():
for t in range(I()):
n = I()
arr = L()
for i in range(n):
if i%2 == 0:
arr[i] = abs(arr[i])
else:
arr[i] = -abs(arr[i])
print(*arr)
if __name__ == '__main__':
main()
| 1,100 | PYTHON3 |
#in the end,add 1 as we are playing with indices
#only pass sorted lists
def binary_search(x,list1,end,start=0):
middle=(start+end)//2
current_start=start
current_end=end
m=list1[middle]
if x>=list1[current_end]:
return current_end
elif x>=list1[current_start] and x<list1[current_start+1]:
return current_start
elif x<list1[current_start]:
return -1
else:
if x<m and x>list1[middle-1]:
return middle-1
elif x>=m and x<list1[middle+1]:
return middle
elif x>=m :
return binary_search(x,list1,end=current_end,start=middle)
elif x<m:
return binary_search(x,list1,end=middle,start=current_start)
#print(binary_search(10,[3,10,8,6,11],4)+1)
n=int(input())
shop_prices=input().split(" ")
shop_prices=list(map(int,shop_prices))
shop_prices.sort()
days=int(input())
list_of_cash=[]
for i in range(days):
list_of_cash.append(int(input()))
for cash in list_of_cash:
print(binary_search(cash,shop_prices,n-1)+1)
| 1,100 | PYTHON3 |
s=input()
if len(s)==1:
if s.isupper():
print (s.lower())
else:
print (s.upper())
else:
if s.isupper():
s=s.lower()
print (s)
elif s[0].islower() and s[1:len(s)+1].isupper():
print (s[0].upper()+s[1:len(s)+1].lower())
else:
print (s) | 1,000 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, p, k;
int main() {
cin >> n >> p >> k;
if (p - k > 1)
cout << "<<"
<< " ";
for (int i = p - k; i <= p + k; i++) {
if (i == p)
cout << "(" << p << ")"
<< " ";
else if (i >= 1 && i <= n)
cout << i << " ";
}
if (p + k < n) cout << ">>";
}
| 0 | CPP |
t = input()
a = [int(i) for i in input().split()]
a.sort()
maxxx = a[-1]
wyn = 0
for q in a:
wyn += maxxx-q
print(wyn) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d, A, B, C;
cin >> a >> b >> c >> d;
vector<int> v = {a, b, c};
sort(v.begin(), v.end());
A = v[0];
B = v[1];
C = v[2];
int mi = INT_MAX;
if (B - d > A) {
if (B + d < C)
mi = 0;
else
mi = B + d - C;
} else {
if (B + d < C)
mi = A - B + d;
else
mi = A + 2 * d - C;
}
cout << mi << endl;
}
| 800 | CPP |
Gems = {'purple': 'Power', 'green': 'Time', 'blue': 'Space', 'orange': 'Soul', 'red': 'Reality', 'yellow': 'Mind'}
n = int(input())
b = []
for i in range(0, n):
word = str(input())
del Gems[word]
print(len(Gems))
for i in Gems:
print(Gems[i])
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
struct point {
double x, y;
point() {}
point(double a, double b) { x = a, y = b; }
point operator+(const point &a) const { return point(x + a.x, y + a.y); }
point operator-(const point &a) const { return point(x - a.x, y - a.y); }
point operator*(const double &a) const { return point(x * a, y * a); }
double operator*(const point &a) const { return x * a.y - y * a.x; }
} A, B, P, C, D, O;
struct line {
point p, v;
line() {}
line(point a, point b) { p = a, v = b; }
} K, K1;
int n, m, sum;
double R, ans;
struct node {
double x;
int k;
node() {}
node(double a, int b) { x = a, k = b; }
} q[maxn << 1];
inline double dis(point a) { return sqrt(a.x * a.x + a.y * a.y); }
inline point getpoint(line l1, line l2) {
point u = l1.p - l2.p;
double t = (l2.v * u) / (l1.v * l2.v);
return l1.p + l1.v * t;
}
inline int rd() {
int ret = 0, f = 1;
char gc = getchar();
while (gc < '0' || gc > '9') {
if (gc == '-') f = -f;
gc = getchar();
}
while (gc >= '0' && gc <= '9') ret = ret * 10 + (gc ^ '0'), gc = getchar();
return ret * f;
}
bool cmp(const node &a, const node &b) { return a.x < b.x; }
int main() {
double l, r, mid;
A.x = rd(), A.y = rd(), B.x = rd(), B.y = rd(), n = rd(), C = (A + B) * 0.5,
K = line(A, B - A);
K.v = K.v * (1.0 / dis(K.v)), K1 = line(C, point(-K.v.y, K.v.x));
int i, j, flag;
for (i = 1; i <= n; i++) {
P.x = rd(), P.y = rd(), R = rd();
K1.p = P, D = getpoint(K, K1);
if (dis(P - D) < R) {
l = -1e12, r = 0;
for (j = 1; j <= 80; j++) {
mid = (l + r) / 2, O = C + (K1.v * mid);
if (dis(P - O) > dis(A - O) + R)
r = mid;
else
l = mid;
}
sum++, q[++m] = node(r, -1);
l = 0, r = 1e12;
for (j = 1; j <= 80; j++) {
mid = (l + r) / 2, O = C + (K1.v * mid);
if (dis(P - O) > dis(A - O) + R)
l = mid;
else
r = mid;
}
q[++m] = node(l, 1);
continue;
}
flag = ((P - A) * (B - P) > 0);
l = -1e12, r = 1e12;
for (j = 1; j <= 80; j++) {
mid = (l + r) / 2, O = C + (K1.v * mid);
if ((dis(P - O) > dis(A - O) + R) ^ flag)
l = mid;
else
r = mid;
}
q[++m] = node(l, flag ? -1 : 1);
l = -1e12, r = 1e12;
for (j = 1; j <= 80; j++) {
mid = (l + r) / 2, O = C + (K1.v * mid);
if ((dis(A - O) > dis(P - O) + R) ^ flag)
r = mid;
else
l = mid;
}
q[++m] = node(r, flag ? 1 : -1);
}
q[++m] = node(1e12, 0), q[++m] = node(-1e12, 0), q[++m] = node(0, 0);
sort(q + 1, q + m + 1, cmp);
ans = 1e12;
for (flag = 0, i = 1; i <= m; i++) {
if (!sum) flag = 1, ans = min(ans, fabs(q[i].x));
sum += q[i].k;
if (!sum) flag = 1, ans = min(ans, fabs(q[i].x));
}
if (!flag)
puts("-1");
else
O = C + (K1.v * ans), printf("%.10lf", dis(A - O));
return 0;
}
| 2,800 | CPP |
n = int(input())
s = sum(list(map(int,input().split())))
print("%.12f" %float(s/n))
| 800 | PYTHON3 |
def primes(n):
onlytwo = True
primfac = []
d = 2
while d*d <= n:
while (n % d) == 0:
if d!=2:
onlytwo=False
primfac.append(d) # supposing you want multiple factors repeated
n //= d
d += 1
if n > 1:
if n!=2:
onlytwo=False
primfac.append(n)
return primfac, onlytwo
def fret(n):
ans = ["Ashishgup","FastestFinger"]
b=0
if n==1:
b=1
elif n==2 or n%2==1:
b=0
else:
nos, onlytwo = primes(n)
if onlytwo:
b=1
elif len(nos)>2:
b=0
else:
b=1
return ans[b]
for _ in range(int(input())):
n=int(input())
print(fret(n))
| 1,400 | PYTHON3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.