solution
stringlengths 10
983k
| difficulty
int64 0
25
| language
stringclasses 2
values |
|---|---|---|
input()
a = [int(x) for x in input().split()]
a.sort()
x = a[0]
y = a[-1]
n = len(a)
l = y - x + 1
print(l - n) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000007;
const int MOD = 1000000007;
const int nmax = 201234;
int n, k, a[nmax], cnt[2][nmax], res;
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
sort(a, a + n);
for (int i = 0; i < n; ++i) {
int b = a[i];
int cnt2 = 0;
while (b) {
if (cnt[0][b] < k) {
cnt[0][b]++;
cnt[1][b] += cnt2;
}
b >>= 1;
cnt2++;
}
}
res = INF;
for (int i = 200000; i >= 0; --i)
if (cnt[0][i] == k && cnt[1][i] < res) res = cnt[1][i];
printf("%d\n", res);
return 0;
}
| 10 | CPP |
import math,sys,bisect,heapq,os
from collections import defaultdict,Counter,deque
from itertools import groupby,accumulate
from functools import lru_cache
#sys.setrecursionlimit(200000000)
pr = lambda x: x
def input(): return sys.stdin.readline().rstrip('\r\n')
#input = iter(sys.stdin.buffer.read().decode().splitlines()).__next__
aj = lambda: list(map(int, input().split()))
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
MOD = 1000000000 + 7
def Y(c): print(["NO","YES"][c])
def y(c): print(["no","yes"][c])
def Yy(c): print(["No","Yes"][c])
def solve():
for _ in range(int(input())):
n, = aj()
A = aj()
print(n//2)
for i in range(1,n,2):
print(i,i+1,min(A[i],A[i-1]),MOD)
try:
#os.system("online_judge.py")
sys.stdin = open('input.txt', 'r')
sys.stdout = open('output.txt', 'w')
from aj import *
except:
pass
solve() | 8 | PYTHON3 |
s=set()
a=list(map(int,input().split()))
for i in a:
s.add(i)
print(len(a)-len(s))
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t, n, x, y;
cin >> t;
while (t--) {
cin >> n;
vector<long long> v(n + 1, 0);
for (long long i = 0; i < n; i++) {
long long a;
cin >> a;
v[a]++;
}
auto it = max_element(v.begin(), v.end());
long long count = 0;
for (long long i = 1; i <= n; i++) {
if (v[i] != 0) count++;
}
if (count == *it)
cout << *it - 1 << "\n";
else if (count > *it)
cout << *it << "\n";
else
cout << count << "\n";
}
return 0;
}
| 9 | CPP |
n = int(input())
a = [int(x) for x in input().split()]
print([1,-1][min(a) == 1])
| 7 | PYTHON3 |
ts = int(input())
for t in range(ts):
n3 = 0
n5 = 0
n7 = 0
n = int(input())
ls = [1,2,4]
if n in ls:
print(-1)
elif n==3:
n3 = 1
print(str(n3) + " " + str(n5) + " " + str(n7))
else:
n5 += n//5-1
n = n-5*n5
if n==5:
n5 +=1
if n==6:
n3 = 2
if n==7:
n7 = 1
if n==8:
n3=1
n5+=1
if n==9:
n3 = 3
print(str(n3) + " " + str(n5) + " " + str(n7))
| 7 | PYTHON3 |
n = int(input())
s = input()
s = s.lower()
s = ''.join(sorted(s))
state = True
if n < 26 or s[0] != 'a':
print("NO")
else:
for i in range(n-1):
if ord(s[i]) != ord(s[i+1]) and ord(s[i]) != (ord(s[i+1]) - 1):
print("NO")
state = False
break
if state == True:
if s[-1] != 'z':
print("NO")
else:
print("YES") | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const double eps(1e-8);
int n, cnt, sum, m;
long long x, y;
int a[1010], b[1010], C[1010];
long long f[1010];
int p[100010], v[100010];
long long g[100010], d[100010];
vector<int> prime;
void GetPrime() {
for (int i = 2; i <= 100000; i++) {
if (v[i]) continue;
prime.push_back(i);
for (int j = 1; i * j <= 100000; j++) v[i * j] = i;
}
cnt = prime.size();
}
void Divide(int x) {
for (int i = 0; i < (int)prime.size(); i++)
if (x % prime[i] == 0) {
while (x % prime[i] == 0) {
x /= prime[i];
p[i]++;
}
}
if (x != 1) {
bool flag = false;
for (int i = 0; i < m; i++)
if (x == b[i]) {
flag = true;
C[i]++;
break;
}
if (!flag) {
C[m] = 1;
b[m++] = x;
}
}
}
long long Exgcd(long long a, long long b) {
if (b == 0) {
x = 1, y = 0;
return a;
} else {
long long i = Exgcd(b, a % b);
long long temp = x;
x = y;
y = temp - (a / b * y);
return i;
}
}
long long Comb(int n, int m) {
long long ret = g[n];
ret = ret * d[m] % 1000000007LL;
ret = ret * d[n - m] % 1000000007LL;
return ret;
}
long long Count(int n) {
long long ret = 1;
for (int i = 0; i <= cnt; i++)
ret = (ret * Comb(n + p[i] - 1, p[i])) % 1000000007LL;
for (int i = 0; i < m; i++)
ret = (ret * Comb(C[i] + n - 1, C[i])) % 1000000007LL;
return ret;
}
int main() {
g[0] = 1;
for (long long i = 0; i <= 100000; i++) {
if (i) g[i] = g[i - 1] * i % 1000000007LL;
Exgcd(g[i], 1000000007LL);
x = x % 1000000007LL;
x = (x + 1000000007LL) % 1000000007LL;
d[i] = x;
}
GetPrime();
scanf("%d", &n);
int a;
for (int i = 1; i <= n; i++) {
scanf("%d", &a);
Divide(a);
}
long long ans = Count(n);
cout << ans << endl;
return 0;
}
| 9 | CPP |
#define _CRT_SECURE_NO_WARNINGS
#pragma comment (linker, "/STACK:526000000")
#include "bits/stdc++.h"
using namespace std;
typedef string::const_iterator State;
#define eps 1e-11L
#define MAX_MOD 1000000007LL
#define GYAKU 500000004LL
#define MOD 998244353LL
#define seg_size 262144*2LL
#define pb push_back
#define mp make_pair
typedef long long ll;
#define REP(a,b) for(long long (a) = 0;(a) < (b);++(a))
#define ALL(x) (x).begin(),(x).end()
unsigned long xor128() {
static unsigned long x = 123456789, y = 362436069, z = 521288629, w = time(NULL);
unsigned long t = (x ^ (x << 11));
x = y; y = z; z = w;
return (w = (w ^ (w >> 19)) ^ (t ^ (t >> 8)));
}
void init() {
iostream::sync_with_stdio(false);
cout << fixed << setprecision(20);
}
#define int ll
void solve(){
while (true) {
string s;
cin >> s;
if (s == "#") return;
vector<vector<string>> inputs;
REP(i, 4) {
inputs.push_back(vector<string>());
REP(q, 13) {
string s;
cin >> s;
inputs.back().push_back(s);
}
}
map<char, int> calc;
for (int i = 2; i <= 9; ++i) {
calc[i + '0'] = i;
}
calc['T'] = 10;
calc['J'] = 11;
calc['Q'] = 12;
calc['K'] = 13;
calc['A'] = 14;
int ans[2] = { -6,-6 };
int nowTurn = 0;
REP(i, 13) {
int winning = -1;
int now_max = -1;
REP(q, 4) {
int go = calc[inputs[q][i][0]];
if (inputs[q][i][1] == s[0]) {
go += 100;
}
if (inputs[q][i][1] == inputs[nowTurn][i][1]) {
go += 20;
}
if (go > winning) {
winning = go;
now_max = q;
}
}
ans[now_max & 1]++;
nowTurn = now_max;
}
if (ans[0] > 0) {
cout << "NS " << ans[0] << endl;
}
else {
cout << "EW " << ans[1] << endl;
}
}
}
#undef int
int main() {
init();
solve();
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
struct BIT {
int n;
vector<T> bit;
BIT(int n_ = 0) : n(n_), bit(n_ + 1) {}
T sum(int i) {
T ans = 0;
for (; i > 0; i -= i & -i) ans += bit[i];
return ans;
}
void add(int i, T a) {
if (i == 0) return;
for (; i <= n; i += i & -i) bit[i] += a;
}
int lower_bound(T k) {
if (k <= 0) return 0;
int ret = 0, i = 1;
while ((i << 1) <= n) i <<= 1;
for (; i; i >>= 1)
if (ret + i <= n && bit[ret + i] < k) k -= bit[ret += i];
return ret + 1;
}
};
int N, M;
int A[2 << 17];
int B[2 << 17];
long long f(int M) {
vector<int> vs;
vs.push_back(0);
for (int i = 0; i < N; i++) {
int a = B[i];
a = a <= M ? 1 : -1;
A[i + 1] = a + A[i];
vs.push_back(A[i + 1]);
}
sort(vs.begin(), vs.end());
vs.erase(unique(vs.begin(), vs.end()), vs.end());
BIT<int> P(vs.size());
long long ans = 0;
for (int i = 0; i <= N; i++) {
int a = lower_bound(vs.begin(), vs.end(), A[i]) - vs.begin();
ans += P.sum(a + 1);
P.add(a + 1, 1);
}
return ans;
}
int main() {
scanf("%d%d", &N, &M);
for (int i = 0; i < N; i++) scanf("%d", &B[i]);
printf("%lld\n", f(M) - f(M - 1));
}
| 11 | CPP |
def mi():
return map(int, input().split())
n,k = mi()
a = list(mi())
dp = [0]*k
for i in range(k):
for j in range(i, n, k):
dp[i]+=a[j]
print (1+dp.index(min(dp))) | 8 | PYTHON3 |
name = set(input())
male = len(name) % 2
if male:
print('IGNORE HIM!')
else:
print('CHAT WITH HER!')
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long int ara[200010];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long int w, h, n, t, x, a, b, l, r, f, i, j, p, d, k;
string s;
cin >> t;
while (t--) {
cin >> n;
map<char, long long int> mp;
map<char, long long int>::iterator it;
for (j = 1; j <= n; j++) {
cin >> s;
for (i = 0; i < s.length(); i++) {
mp[s[i]]++;
}
}
f = 0;
for (it = mp.begin(); it != mp.end(); it++) {
a = it->second;
if (a % n != 0) f = 1;
}
if (f == 0)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)1E9;
int s[1000005];
void add(int k, int v) {
k++;
for (; k < 1000005; k += -k & k) s[k] += v;
}
int get(int k) {
k++;
int ans = 0;
for (; k; k -= -k & k) ans += s[k];
return ans;
}
int findkth(int k) {
int e = 0, cnt = 0;
for (int i = 20; i >= 0; i--) {
int b = 1 << i;
if (e + b >= 1000005 || cnt + s[e + b] >= k) continue;
e += b;
cnt += s[e];
}
return e;
}
int N, M, K;
int x[1000005], str[1000005], pre[1000005], nxt[1000005];
int main() {
cin >> M >> N;
for (int i = (0); i < (N); i++) {
scanf("%d", x + i);
}
int cnt = 0;
fill_n(pre, M + 1, -1);
fill_n(nxt, M + 1, -1);
while (M--) {
int op;
scanf("%d", &op);
if (op == -1) {
for (int i = (0); i < (N); i++) {
if (x[i] - i > cnt) break;
int e = findkth(x[i] - i);
add(e, -1);
cnt--;
if (nxt[e] != -1) pre[nxt[e]] = pre[e];
if (pre[e] != -1) nxt[pre[e]] = nxt[e];
}
} else {
str[K] = op;
if (cnt > 0) {
int e = findkth(cnt);
nxt[e] = K;
pre[K] = e;
}
add(K, 1);
K++;
cnt++;
}
}
if (cnt == 0)
puts("Poor stack!");
else {
int e = findkth(1);
while (e != -1) {
printf("%d", str[e]);
e = nxt[e];
}
}
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int n;
cin >> n;
vector<int> arr1(n + 1);
bool scan = true;
int key = n;
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
arr1[x]++;
if (x == key)
while (arr1[key]) {
cout << key << " ";
key--;
}
cout << "\n";
}
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, k, x, km, ptr, ii, y;
km = 0;
cin >> n >> k;
int pos[n + 1];
vector<int> div[n + 1];
for (int i = 1; i <= n; i++) {
x = i;
while (x <= n) {
div[x].push_back(i);
x += i;
}
}
for (int i = 1; i < n + 1; i++) {
km += div[i].size() - 1;
}
if (k > km) {
cout << "No";
return 0;
}
if (n <= 21) {
int pow = 1;
for (int i = 0; i < n; i++) {
pow *= 2;
}
vector<int> used;
for (int i = 0; i < pow; i++) {
used.clear();
ii = i;
km = 0;
for (int j = 1; j <= n; j++) {
if (ii % 2) used.push_back(j);
ii /= 2;
}
for (int j = 0; j < used.size(); j++) {
for (int k = j + 1; k < used.size(); k++) {
if (used[k] % used[j] == 0) km++;
}
}
if (km == k) {
cout << "Yes" << endl;
cout << used.size() << endl;
for (int j = 0; j < used.size(); j++) {
cout << used[j] << " ";
}
return 0;
}
}
cout << "No";
} else {
vector<int> out;
pair<int, int> rem[n + 1];
for (int i = 1; i <= n; i++) {
rem[i] = make_pair(div[i].size() + n / i - 2, i);
}
sort(rem + 1, rem + n + 1);
reverse(rem + 1, rem + n + 1);
for (int i = 1; i <= n; i++) {
pos[rem[i].second] = i;
}
ptr = 0;
while (km > k) {
if (km - rem[ptr + 1].first >= k) {
km -= rem[ptr + 1].first;
rem[ptr + 1].first = 1e9;
out.push_back(rem[ptr + 1].second);
for (int i = 0; i < div[rem[ptr + 1].second].size() - 1; i++) {
rem[pos[div[rem[ptr + 1].second][i]]].first--;
}
x = rem[ptr + 1].second * 2;
while (x <= n) {
rem[pos[x]].first--;
x += rem[ptr + 1].second;
}
}
ptr = (ptr + 1) % n;
if (ptr == 0) y++;
}
int in[n + 1];
fill(in, in + n + 1, 0);
for (int i = 0; i < out.size(); i++) {
in[out[i]] = 1;
}
cout << "Yes" << endl;
cout << n - out.size() << endl;
for (int i = 1; i <= n; i++) {
if (in[i] == 0) cout << i << " ";
}
}
}
| 12 | CPP |
#include<iostream>
#include<vector>
using namespace std;
int parent(int a,vector<int>& p) {
if(p[a] == a)return a;
else return p[a] = parent(p[a],p);
}
void unite(int a,int b,vector<int>& p) {
p[parent(a,p)] = parent(b,p);
}
int main() {
int N,M,K;
cin >> N >> M >> K;
vector<int> FB(N,0),cnt(N,0),p(N);
int i,j,a,b;
for(i=0;i<N;i++)p[i] = i;
for(i=0;i<M;i++) {
cin >> a >> b;
FB[a-1]++;
FB[b-1]++;
unite(a-1,b-1,p);
}
for(i=0;i<K;i++) {
cin >> a >> b;
if(parent(a-1,p) == parent(b-1,p)) {
FB[a-1]++;
FB[b-1]++;
}
}
for(i=0;i<N;i++) {
cnt[parent(i,p)]++;
}
for(i=0;i<N;i++)cout << cnt[parent(i,p)]-FB[i]-1 << endl;
} | 0 | CPP |
import sys
# import math
from collections import deque
# import heapq
# from math import inf
# from math import gcd
# print(help(deque))
# 26
pprint = lambda s: print(' '.join(map(str, s)))
input = lambda: sys.stdin.readline().strip()
ipnut = input
# n,x = map(int,input().split())
for i in range(int(input())):
m = 0
s = list(map(int,input()))
d = []
ans = ["NET","DA"]
for i in s:
# print(i,d)
if d:
if i!=d[-1]:
d.pop()
m+=1
else:
d.append(i)
else:
d.append(i)
# print(m)
print(ans[m%2]) | 8 | PYTHON3 |
n,d=map(int,input().split())
if(d==0):
if(n>1):
print('No solution')
else:
print(0)
else:
s=str(d)+'0'*(n-1)
print(int(s))
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int tc;
cin >> tc;
while (tc--) {
string s;
cin >> s;
int l = s.size(), t1 = count(s.begin(), s.end(), '1'), t2 = l - t1;
if (t1 == 0 || t2 == 0)
cout << s << "\n";
else {
string res;
if (s[0] == '1') {
while (l--) res += "10";
} else {
while (l--) res += "01";
}
cout << res << "\n";
}
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[500005], b[500005], c[500005];
void solve() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
b[i] = a[i];
}
sort(b + 1, b + n + 1);
int len = unique(b + 1, b + n + 1) - b - 1, mx = 0;
for (int i = 1; i <= n; i++) {
a[i] = lower_bound(b + 1, b + len + 1, a[i]) - b;
mx = max(mx, a[i]);
c[a[i]]++;
}
int s1 = c[mx], s2 = 0, s3 = 0, i;
for (i = mx - 1; i >= 1; i--) {
s2 += c[i];
if (s2 > s1) break;
}
for (int j = i - 1; j >= 1; j--) {
s3 += c[j];
if (s3 > s1) {
i = j - 1;
break;
}
}
if (s1 + s2 + s3 > n / 2)
puts("0 0 0");
else {
for (int j = i; j >= 1; j--) {
if (s1 + s2 + s3 + c[j] > n / 2) break;
s3 += c[j];
}
printf("%d %d %d\n", s1, s2, s3);
}
for (int i = 1; i <= mx; i++) {
c[i] = 0;
}
}
int main() {
int T;
cin >> T;
while (T--) {
solve();
}
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll INF=1LL<<60;
struct edge {
ll from;
ll to;
ll cost;
};
int main(void){
ll n,m;
ll d[1000];
vector<edge> edges;
cin>>n>>m;
for(int i=0;i<m;i++){
struct edge add;
cin>>add.from>>add.to>>add.cost;
add.from--,add.to--;
edges.push_back(add);
}
fill(d,d+n,-INF);
d[0]=0;
for(int i=0;i<n-1;i++){
for(auto e:edges){
if(d[e.from]!=-INF&&d[e.to]<d[e.from]+e.cost){
d[e.to]=d[e.from]+e.cost;
}
}
}
ll a=d[n-1];
for(auto e:edges){
if(d[e.from]!=-INF&&d[e.to]<d[e.from]+e.cost){
d[e.to]=d[e.from]+e.cost;
}
}
if(a!=d[n-1]) cout<<"inf"<<endl;
else cout<<d[n-1]<<endl;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 300010;
int n, m;
int arr[4][N];
int idx[4];
long long best[N], ans = 0;
pair<int, int> best2[N];
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
int w, c;
scanf("%d%d", &w, &c);
arr[w][idx[w]++] = c;
}
for (int i = 0; i < 4; i++) {
sort(arr[i], arr[i] + idx[i]);
reverse(arr[i], arr[i] + idx[i]);
}
best[1] = arr[1][0];
ans = max(ans, best[1]);
best2[1] = make_pair(0, -1);
best2[0] = make_pair(-1, -1);
for (int i = 2; i <= m; i++) {
best[i] = best[i - 1] + arr[1][best2[i - 1].first + 1];
best2[i] = best2[i - 1];
best2[i].first++;
if (best[i - 2] + arr[2][best2[i - 2].second + 1] > best[i]) {
best[i] = best[i - 2] + arr[2][best2[i - 2].second + 1];
best2[i] = best2[i - 2];
best2[i].second++;
}
ans = max(ans, best[i]);
}
long long sum = 0;
int i = 0;
int cur = 0;
while (cur + 3 <= m) {
cur += 3;
sum += arr[3][i++];
ans = max(ans, sum + best[m - cur]);
}
cout << ans << endl;
return 0;
}
| 11 | CPP |
#include <vector>
#include <cstdio>
using namespace std;
int main(){
int N,R=1<<29;
scanf("%d",&N);
vector<int>v(N);
for(int i=0;i<N;i++)scanf("%d",&v[i]);
for(int p=0;p<=v[0];p++){
int cur=v[0]-p,r=p;
for(int i=0;i<N-1;i++){
r+=cur*2;
cur=max(v[i+1]-cur,0);
}
R=min(R,r+cur);
}
printf("%d\n",R);
} | 0 | CPP |
n = int(input())
lst = list(map(int,input().split()))
ck = 1
while(n!=1):
ck = 0
j = 0
while(j<=len(lst)-n):
ck=0
for i in range(j,j+n-1):
if lst[i] > lst[i+1]:
ck=1
if ck==0:
break
j+=n
if ck == 0:
print(n)
break
n//=2
if n == 1:
print(1) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int q, sq, ctr, lens;
string s, res;
bool check() {
int lenr = res.size();
string wynik;
for (int i = 0; i < lenr; i++) {
if (res[i] == 'H')
wynik += 'H';
else
for (int j = 0; j < lenr; j++) wynik += res[j];
if (wynik.size() > 1000 * 1000) break;
}
return wynik == s;
}
int main() {
cin >> s;
lens = s.size();
for (int i = 0; i < lens; i++)
if (s[i] == 'Q') q++;
if (q == 0) {
printf("Yes\n");
return 0;
}
sq = sqrt(q);
if (sq * sq != q) {
printf("No\n");
return 0;
}
for (int i = 0; i < lens; i++) {
if (s[i] == 'Q') break;
ctr++;
}
if (ctr & 1) {
printf("No\n");
return 0;
}
for (int i = 0; i < ctr / 2; i++) res += 'H';
for (int i = ctr; i < lens && sq; i++) {
if (s[i] == 'Q') sq--;
res += s[i];
}
ctr = 0;
for (int i = lens - 1; s[i] != 'Q'; i--) ctr++;
if (ctr & 1) {
printf("No\n");
return 0;
}
for (int i = 0; i < ctr / 2; i++) res += 'H';
if (check()) {
printf("Yes\n");
return 0;
}
printf("No\n");
return 0;
}
| 11 | CPP |
#include <iostream>
using namespace std;
struct points
{
int towards[501];
} point[501];
int main()
{
int n,m,q;
int i,j,k,l,a,b;
cin>>n>>m>>q;
for(i=0;i<=n;i++)
for(j=i;j<=n;j++)
point[i].towards[j]=0;
for(i=0;i<m;i++)
{
cin>>j>>k;
for(l=k;l<=n;l++)
point[j].towards[l]++;
}
for(i=0;i<q;i++)
{
a=0;
cin>>j>>k;
for(l=j;l<=k;l++)
a+=point[l].towards[k];
cout<<a<<endl;
}
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 60;
int h[N], ans[2];
int main() {
int test, n;
char ch;
cin >> test;
while (test--) {
cin >> n;
memset(h, 0, sizeof(h));
for (int i = 2; i <= n; i += 2) {
printf("? %d %d\n", i - 1, i);
fflush(stdout);
cin >> ch;
if (ch == '<')
h[i - 1] = 1;
else
h[i] = 1;
}
for (int i = 1; i >= 0; i--) {
if (n & 1) h[n] = i;
ans[i] = 1;
while (h[ans[i]] != i) ans[i]++;
for (int j = ans[i] + 1; j <= n; j++)
if (h[j] == i) {
printf("? %d %d\n", j, ans[i]);
fflush(stdout);
cin >> ch;
if (ch == (i ? '<' : '>')) ans[i] = j;
}
}
printf("! %d %d\n", ans[1], ans[0]);
fflush(stdout);
}
}
| 8 | CPP |
#include<iostream>
#include<algorithm>
#include<vector>
#include<map>
using namespace std;
int main()
{
int n;
long long sn, x, y;
vector<long long>p;
map<long, long>m;
while (1){
m.clear();
p.clear();
cin >> n;
if (n == 0)break;
for (int i = 0; i < n; i++){
cin >> sn >> x >> y;
if (m.find(sn) == m.end()){
p.push_back(sn);
}
m[sn] += x*y;
}
int flag = 0;
for (int i = 0; i < p.size(); i++){
if (m[p[i]] >= 1000000){
cout << p[i] << endl;
flag++;
}
}
if (flag==0)cout << "NA" << endl;
}
} | 0 | CPP |
#!/usr/bin/env python3
from sys import stdin, stdout
def rint():
return map(int, stdin.readline().split())
#lines = stdin.readlines()
a = input()
b = a[::-1]
a = a+b
print(a)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int i, j, k, n, m, ans, s, f;
string x, y;
bool tell(string txt, string s) {
int pos = -1;
bool ok = true;
for (int i = 0; ok && i != s.size(); i++) {
ok = (pos = txt.find(s[i], pos + 1)) != string::npos;
}
if (ok)
return true;
else
return false;
}
int main() {
cin >> x >> y;
int a[26] = {0}, b[26] = {0};
for (i = 0; i < x.length(); i++) a[x[i] - 97]++;
for (i = 0; i < y.length(); i++) b[y[i] - 97]++;
for (i = 0; i < 26; i++)
if (a[i] < b[i]) f = 1;
if (f) {
cout << "need tree\n";
return 0;
}
for (i = 0; i < 26; i++) {
if (a[i] > b[i]) f = 1;
ans += a[i] - b[i];
}
if (ans == 0 && f == 0) {
cout << "array\n";
return 0;
}
if (f) {
if (tell(x, y))
cout << "automaton\n";
else
cout << "both\n";
return 0;
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<int> p[151];
void pre() {
p[0] = {1};
p[1] = {0, 1};
for (int i = (2); i <= (150); ++i) {
vector<int> np;
np.emplace_back(0);
for (int j = (0); j <= (((int)(p[i - 1]).size()) - 1); ++j)
np.emplace_back(p[i - 1][j]);
for (int j = (0); j <= (((int)(p[i - 2]).size()) - 1); ++j)
np[j] = (np[j] + p[i - 2][j]) % 2;
p[i] = np;
}
}
void print(int id) {
for (int i = (0); i <= (((int)(p[id]).size()) - 1); ++i)
cout << p[id][i] << " \n"[i == ((int)(p[id]).size()) - 1];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
pre();
int n;
cin >> n;
cout << n << '\n';
print(n);
cout << n - 1 << '\n';
print(n - 1);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
template <class T>
using V = vector<T>;
const ll inf = (1e18);
const ll mod = 998244353;
ll GCD(ll a, ll b) { return b ? GCD(b, a % b) : a; }
ll LCM(ll c, ll d) { return c / GCD(c, d) * d; }
struct __INIT {
__INIT() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
}
} __init;
template <class T>
bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
V<V<int>> g;
int ma, id;
int a, b;
int dd;
void dfs(int cur, int par, int cnt) {
for (int v : g[cur]) {
if (v == par) continue;
dfs(v, cur, cnt + 1);
}
if (chmax(ma, cnt)) id = cur;
if (cur == b - 1) dd = cnt;
}
void solve() {
int n, da, db;
ma = 0;
cin >> n >> a >> b >> da >> db;
g = V<V<int>>(n);
int u, v;
for (int i = 0; i < n - 1; i++) {
cin >> u >> v;
--u;
--v;
g[u].emplace_back(v);
g[v].emplace_back(u);
}
id = 0;
dfs(0, -1, 0);
ma = 0;
dfs(id, -1, 0);
int dist = ma;
ma = 0;
dd = 0;
dfs(a - 1, -1, 0);
if (dd <= da || 2 * da >= db || 2 * da >= dist) {
cout << "Alice"
<< "\n";
return;
} else {
cout << "Bob"
<< "\n";
}
}
int main() {
int t;
cin >> t;
while (t--) solve();
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
string inp;
cin >> inp;
int a = 0, b = 0, c = 0;
int i = 0;
while (inp[i] != '+') {
a++;
i++;
}
i++;
while (inp[i] != '=') {
b++;
i++;
}
i++;
while (i < inp.size()) {
i++;
c++;
}
if (abs((a + b) - c) == 2) {
if (a + b > c) {
if (a == 1)
b--;
else
a--;
c++;
} else {
c--;
a++;
}
for (int i = 0; i < a; i++) {
cout << "|";
}
cout << "+";
for (int i = 0; i < b; i++) {
cout << "|";
}
cout << "=";
for (int i = 0; i < c; i++) {
cout << "|";
}
cout << endl;
} else if (abs((a + b) - c) == 0) {
cout << inp << endl;
} else {
cout << "Impossible" << endl;
}
std::cin.get();
std::cin.get();
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
string a;
string b;
int at = 0;
int cnt = 0;
int addat(int, int);
int addstring(int, int);
int addstring2(int, int);
int main() {
cin >> a;
if (a[0] == '@' || a[a.size() - 1] == '@') {
cout << "No solution";
return 0;
}
int last = 0;
for (int i = 0; i < a.size(); i++) {
if (a[i] == '@') {
at++;
last = i;
}
}
addstring(0, last);
if (cnt == at)
cout << b;
else
cout << "No solution";
}
int addat(int ind, int last) {
b += a[ind];
return addstring2(ind + 1, last);
}
int addstring(int ind, int lastt) {
bool go = false;
if (a[ind] == '@') {
cnt = -1e2;
} else {
for (int i = ind; i < a.size(); i++) {
if (a[i] != '@')
b += a[i];
else {
go = true;
cnt++;
return addat(i, lastt);
}
}
if (go == false) {
cnt = -1e2;
}
}
return 1;
}
int addstring2(int ind, int last) {
if (a[ind] == '@') {
cnt = -1e2;
} else if (ind - 1 == last) {
for (int i = ind; i < a.size(); i++) {
b += a[i];
}
} else {
b += a[ind];
b += ',';
addstring(ind + 1, last);
}
return 1;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long int n, count = 0;
cin >> n;
while (n--) {
long long int a, b, c;
cin >> a >> b >> c;
long long int maxi = max(a, max(b, c));
long long int mini = min(a, min(b, c));
maxi = maxi - mini;
maxi = maxi * maxi;
mini = mini * mini;
cout << (long long int)(sqrt(maxi + mini)) << endl;
;
}
return 0;
}
| 7 | CPP |
l1=list(map(int,input().split(":")))
l2=list(map(int,input().split(":")))
t=(l2[0]-l1[0])*60+(l2[1]-l1[1])
t//=2
h=t//60
m=t%60
l1[0]+=h
l1[1]+=m
l1[0]+=(l1[1]//60)
l1[1]=l1[1]%60
l1=list(map(str,l1))
for i in range(2):
if len(l1[i])<2:
print("0"+l1[i],end="")
else:
print(l1[i],end="")
if i==0:
print(":",end="") | 7 | PYTHON3 |
def dc(c, d):
x, y = ord(c) - ord('a'), ord(d) - ord('a')
return min(abs(x - y), 26 - max(x, y) + min(x, y))
def ds(s1, s2):
r = 0
a, b = 10 ** 5, -1
for i in range(len(s1)):
c, d = s1[i], s2[i]
r += dc(c, d)
if c != d:
a = min(a, i)
b = max(b, i)
return a, b, r
n, p = map(int, input().split())
s = input()
p -= 1
m = n // 2
y = m + (1 if n % 2 else 0)
s1, s2 = s[:m], s[y:][::-1]
a, b, r = ds(s1, s2)
#print(s1, s2, a, b, r)
d1 = min(abs(p - a), abs(p - b)) + abs(a - b)
d2 = min(abs(p - y - m + 1 + a), abs(p - y - m + 1 + b)) + abs(a - b)
#print(d1, d2)
if r == 0:
print(0)
else:
print(min(d1, d2) + r)
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
using ll = int;
vector<pair<ll, string>> con[101010];
int main() {
int n, m;
cin >> n >> m;
int reg, sc;
string name;
while (n--) {
cin >> name;
cin >> reg;
cin >> sc;
con[reg].push_back(make_pair(sc, name));
}
for (int i = 1; i <= m; i++) {
sort(con[i].begin(), con[i].end());
reverse(con[i].begin(), con[i].end());
if ((int)con[i].size() > 2 && con[i][1].first == con[i][2].first) {
cout << "?\n";
} else {
cout << con[i][0].second << " " << con[i][1].second << endl;
}
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename TH>
void _dbg(const char* sdbg, TH h) {
cerr << sdbg << "=" << h << "\n";
}
template <typename TH, typename... TA>
void _dbg(const char* sdbg, TH h, TA... t) {
while (*sdbg != ',') {
cerr << *sdbg++;
}
cerr << "=" << h << ",";
_dbg(sdbg + 1, t...);
}
template <class C>
void mini(C& a4, C b4) {
a4 = min(a4, b4);
}
template <class C>
void maxi(C& a4, C b4) {
a4 = max(a4, b4);
}
template <class T1, class T2>
ostream& operator<<(ostream& out, pair<T1, T2> pair) {
return out << "(" << pair.first << ", " << pair.second << ")";
}
template <class A, class B, class C>
struct Triple {
A first;
B second;
C third;
bool operator<(const Triple& t) const {
if (first != t.first) return first < t.first;
if (second != t.second) return second < t.second;
return third < t.third;
}
};
template <class T>
void ResizeVec(T&, vector<long long>) {}
template <class T>
void ResizeVec(vector<T>& vec, vector<long long> sz) {
vec.resize(sz[0]);
sz.erase(sz.begin());
if (sz.empty()) {
return;
}
for (T& v : vec) {
ResizeVec(v, sz);
}
}
template <class A, class B, class C>
ostream& operator<<(ostream& out, Triple<A, B, C> t) {
return out << "(" << t.first << ", " << t.second << ", " << t.third << ")";
}
template <class T>
ostream& operator<<(ostream& out, vector<T> vec) {
out << "(";
for (auto& v : vec) out << v << ", ";
return out << ")";
}
template <class T>
ostream& operator<<(ostream& out, set<T> vec) {
out << "(";
for (auto& v : vec) out << v << ", ";
return out << ")";
}
template <class L, class R>
ostream& operator<<(ostream& out, map<L, R> vec) {
out << "(";
for (auto& v : vec) out << v << ", ";
return out << ")";
}
struct LCA {
LCA(const vector<vector<long long> >& their_slo, long long root = 1) {
M = 1;
while (M <= 2 * ((long long)(their_slo).size())) {
M *= 2;
}
my_slo.resize(M);
for (long long i = 0; i < (((long long)(their_slo).size())); ++i) {
for (auto nei : their_slo[i]) {
my_slo[i].push_back(nei);
}
}
drz.resize(2 * M + 5);
pre.resize(M);
inv.resize(M);
vis.resize(M);
ind.resize(M);
dep.resize(M);
d = 1;
akt = 1;
dfs(root);
for (long long i = M - 1; i >= 1; i--) {
drz[i] = min(drz[2 * i], drz[2 * i + 1]);
}
}
long long M;
vector<long long> drz;
vector<long long> pre;
vector<long long> inv;
vector<long long> vis;
vector<long long> ind;
vector<long long> dep;
vector<vector<long long> > my_slo;
long long d;
long long akt;
long long Lca(long long a, long long b) {
a = pre[a];
b = pre[b];
long long w;
w = czyt(min(ind[a], ind[b]), max(ind[a], ind[b]));
return inv[w];
}
long long Dis(long long a, long long b) {
return dep[a] + dep[b] - 2 * dep[Lca(a, b)];
}
private:
long long czyt(long long a, long long b) {
a += M - 1;
b += M - 1;
long long mini = M;
mini = min(mini, drz[a]);
mini = min(mini, drz[b]);
while (a / 2 != b / 2) {
if (a % 2 == 0) {
mini = min(mini, drz[a + 1]);
}
if (b % 2 == 1) {
mini = min(mini, drz[b - 1]);
}
a /= 2;
b /= 2;
}
return mini;
}
void dfs(long long v) {
vis[v] = 1;
pre[v] = d;
inv[d] = v;
d++;
drz[akt + M - 1] = pre[v];
ind[pre[v]] = akt;
akt++;
for (long long nei : my_slo[v]) {
if (vis[nei]) {
continue;
}
dep[nei] = dep[v] + 1;
dfs(nei);
drz[akt + M - 1] = pre[v];
ind[pre[v]] = akt;
akt++;
}
}
};
const long long N = 2e5 + 5;
long long dep[N];
long long hei[N];
long long par[N];
long long vis[N];
vector<vector<long long> > slo;
long long furthest;
long long dis0[N], dis1[N], dis2[N];
void Dfs(long long v) {
vis[v] = 1;
if (dis0[v] > dis0[furthest]) {
furthest = v;
}
hei[v] = 0;
for (auto nei : slo[v]) {
if (vis[nei]) {
continue;
}
dis0[nei] = dis0[v] + 1;
par[nei] = v;
Dfs(nei);
maxi(hei[v], hei[nei] + 1);
}
}
int32_t main() {
ios_base::sync_with_stdio(0);
cout << fixed << setprecision(10);
if (0) cout << fixed << setprecision(10);
cin.tie(0);
long long n, k;
cin >> n >> k;
slo.resize(n + 2);
for (long long i = (1); i <= (n - 1); ++i) {
long long a, b;
cin >> a >> b;
slo[a].push_back(b);
slo[b].push_back(a);
}
LCA lca(slo);
Dfs(1);
long long e1 = furthest;
for (long long i = (1); i <= (n); ++i) {
vis[i] = 0;
dis0[i] = 0;
}
Dfs(e1);
for (long long i = (1); i <= (n); ++i) {
vis[i] = 0;
dis1[i] = dis0[i];
dis0[i] = 0;
}
long long e2 = furthest;
Dfs(e2);
for (long long i = (1); i <= (n); ++i) {
dis2[i] = dis0[i];
vis[i] = 0;
dis0[i] = 0;
}
Dfs(e1);
long long diam = dis1[e2];
if (k == 2 || diam < k - 1) {
cout << "Yes\n";
for (long long i = (1); i <= (n); ++i) {
cout << 1 + (dis1[i] % 2) << " ";
}
cout << endl;
return 0;
}
vector<long long> res(n + 2);
for (long long i = (1); i <= (n); ++i) {
long long is_on_diam = ((dis1[i] + dis2[i]) == diam);
vector<long long> sons;
for (auto son : slo[i]) {
if (par[i] == son) {
continue;
}
sons.push_back(hei[son] + 1);
}
sort((sons).begin(), (sons).end(), greater<long long>());
long long third = 0;
if (((long long)(sons).size()) <= is_on_diam) {
third = 0;
} else {
third = sons[is_on_diam];
}
if (!is_on_diam && min(dis1[i], dis2[i]) + 1 >= k) {
cout << "No\n";
return 0;
}
long long to_diam = (dis1[i] + dis2[i] - diam) / 2;
if (dis2[i] <= dis1[i]) {
res[i] = dis1[i] % k;
} else {
res[i] = (dis1[i] - 2 * to_diam) % k;
}
}
cout << "Yes\n";
for (long long i = (1); i <= (n); ++i) {
cout << res[i] + 1 << " ";
}
cout << endl;
return 0;
}
| 14 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int a[N + 1];
for (int i = 1; i < N + 1; i++) {
int v;
cin >> v;
a[i] = v;
}
int mid;
if (!N % 2) {
mid = N / 2;
} else
mid = (N + 1) / 2;
for (int i = 1; i < mid + 1; i++) {
if (i % 2) {
swap(a[i], a[N - i + 1]);
}
}
for (int i = 1; i < N + 1; i++) {
cout << a[i] << " ";
;
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
char mps[10005];
int t[1005], k;
int main() {
cin >> mps;
int n = strlen(mps);
for (int i = n; i >= 1; i--) mps[i] = mps[i - 1];
for (int i = 1; i <= n; i++) {
if (mps[i] == '@') {
t[++k] = i;
}
}
if (t[1] == 1 || t[k] == n || k == 0) {
cout << "No solution" << endl;
return 0;
}
for (int i = 1; i <= k - 1; i++) {
if (t[i + 1] - t[i] <= 2) {
cout << "No solution" << endl;
return 0;
}
}
for (int i = 1; i <= t[1]; i++) {
cout << mps[i];
}
for (int i = 1; i <= k - 1; i++) {
cout << mps[t[i] + 1] << ",";
for (int j = t[i] + 2; j <= t[i + 1]; j++) {
cout << mps[j];
}
}
for (int i = t[k] + 1; i <= n; i++) {
cout << mps[i];
}
cout << endl;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-7;
int main() {
int n, l, v1, v2, k;
cin >> n >> l >> v1 >> v2 >> k;
int T = n / k;
if (n % k != 0) T++;
double s = 1.0 * (v1 + v2) * l / (1.0 * ((2 * T - 1) * v1 + v2));
double ans = 1.0 * s / (1.0 * v2) + 1.0 * (l - s) / (1.0 * v1);
printf("%.10f\n", ans);
}
| 7 | CPP |
from bisect import bisect_left
t = int(input())
for _ in range(t):
s = input()
t = input()
d = {}
for i in range(len(s)):
if s[i] not in d:
d[s[i]] = []
d[s[i]].append(i)
ans = 1
j = 0
for i in range(len(t)):
if t[i] not in d:
print(-1)
break
nxt = bisect_left(d[t[i]], j)
if nxt != len(d[t[i]]):
j = d[t[i]][nxt] + 1
else:
j = d[t[i]][0] + 1
ans += 1
else:
print(ans)
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using PII = pair<ll, ll>;
#define FOR(i, a, n) for (ll i = (ll)a; i < (ll)n; ++i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(x) x.begin(), x.end()
template<typename T> void chmin(T &a, const T &b) { a = min(a, b); }
template<typename T> void chmax(T &a, const T &b) { a = max(a, b); }
struct FastIO {FastIO() { cin.tie(0); ios::sync_with_stdio(0); }}fastiofastio;
#ifdef DEBUG_
#include "../program_contest_library/memo/dump.hpp"
#else
#define dump(...)
#endif
const ll INF = 1LL<<60;
template <class T, class W>
class rerooting {
private:
struct edge {
ll to, rev;
W w;
};
const ll n;
vector<vector<edge>> g;
vector<vector<T>> ldp, rdp;
vector<ll> lptr, rptr;
const function<T(T,T)> merge;
const function<T(T,W)> add;
const T id;
T dfs(ll v, ll p) {
while(lptr[v] != p && lptr[v] < (ll)g[v].size()) {
edge &e = g[v][lptr[v]];
ldp[v][lptr[v]+1] = merge(ldp[v][lptr[v]], add(dfs(e.to, e.rev), e.w));
lptr[v]++;
}
while(rptr[v] != p && rptr[v] >= 0) {
edge &e = g[v][rptr[v]];
rdp[v][rptr[v]] = merge(add(dfs(e.to, e.rev), e.w), rdp[v][rptr[v]+1]);
rptr[v]--;
}
if(p < 0) return rdp[v][0];
return merge(ldp[v][p], rdp[v][p+1]);
}
public:
rerooting(ll n, function<T(T,T)> merge, function<T(T,W)> add, T id) : n(n), g(n), ldp(n), rdp(n), lptr(n), rptr(n), merge(merge), add(add), id(id) {}
void add_edge(ll u, ll v, W w) {
g[u].push_back({v, (ll)g[v].size(), w});
g[v].push_back({u, (ll)g[u].size()-1, w});
}
vector<T> build() {
REP(i, n) {
ldp[i].assign(g[i].size()+1, id);
rdp[i].assign(g[i].size()+1, id);
lptr[i] = 0;
rptr[i] = (ll)g[i].size()-1;
}
vector<T> ans;
REP(i, n) ans.emplace_back(dfs(i, -1));
return ans;
}
};
int main(void) {
ll n;
cin >> n;
auto merge = [&](ll l, ll r) { return max(l, r); };
auto add = [&](ll v, ll w) { return v+w; };
rerooting<ll, ll> graph(n, merge, add, 0);
REP(i, n-1) {
ll u, v;
cin >> u >> v;
u--, v--;
graph.add_edge(u, v, 1);
}
auto ans = graph.build();
REP(i, n) cout << 2*(n-1) - ans[i] << "\n";
return 0;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
char s1[1010], s2[1010];
vector<int> vec, vv;
int main() {
int n, m;
scanf("%d%d", &n, &m);
scanf("%s%s", s1 + 1, s2 + 1);
int ans = n;
for (int i = 1; i <= n; i++) vv.push_back(i);
for (int i = 1; i <= m - n + 1; i++) {
int num = 0;
for (int j = 1; j <= n; j++) {
if (s2[i + j - 1] != s1[j]) {
num++;
vec.push_back(j);
}
}
if (num < ans) {
ans = num;
vv = vec;
}
vec.clear();
}
printf("%d\n", ans);
for (int i = 0; i < vv.size(); i++) {
printf("%d ", vv[i]);
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int a[100002], t[10002], x[10002], y[10002];
pair<int, int> w[3];
vector<int> vec;
int main() {
int i, j, k, l, m, n;
cin >> n;
for (i = 1; i <= n; i++) {
cin >> t[i] >> x[i] >> y[i];
if (t[i] == 1)
w[1].first += x[i], w[1].second += y[i];
else
w[2].first += x[i], w[2].second += y[i];
}
if (w[1].first >= (w[1].first + w[1].second) / 2)
cout << "LIVE\n";
else
cout << "DEAD\n";
if (w[2].first >= (w[2].first + w[2].second) / 2)
cout << "LIVE\n";
else
cout << "DEAD\n";
}
| 7 | CPP |
for _ in range(int(input())):
n = int(input())
l = []
for i in range(n):
a,b = map(int, input().split(' '))
l.append((a,b))
l.append((0,0))
l.sort()
#print(l)
if(len(l)==2):
print("YES")
r = l[1][0]-l[0][0]
u = l[1][1]-l[0][1]
path = ""+("R"*r)+("U"*u)
print(path)
else:
path = []
c = 0
for i in range(1,len(l)):
if(l[i][0]<l[i-1][0] or l[i][1]<l[i-1][1]):
c = c+1
if(c!=0):
print("NO")
else:
for i in range(1,len(l)):
r = l[i][0] - l[i-1][0]
u = l[i][1] - l[i-1][1]
y = ("R"*r)+("U"*u)
path.append(y)
print("YES")
print("".join(path))
| 8 | PYTHON3 |
# -*- encoding: utf-8 -*-
import sys
r_input = sys.stdin.readline
q = int(r_input())
for _ in range(q):
s = r_input().rstrip()
l = s.count('L')
r = s.count('R')
u = s.count('U')
d = s.count('D')
# print(l, r, u, d)
result = ''
save1 = min(l, r)
save2 = min(u, d)
if not save1 and not save2:
print(0)
elif not save1:
print(2)
print('UD')
elif not save2:
print(2)
print('LR')
else:
print((save1 + save2) * 2)
print('U' * save2 + 'R' * save1 + 'D' * save2 + 'L' * save1)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
struct node {
double x, y;
};
node b[200011], a[200011];
double t, ans, d[200011], c[200011];
long double sum, f, w, s, ti;
int n, m, cnt1, cnt2;
bool cmp1(node aa, node bb) { return (aa.x < bb.x); }
bool cmp2(node aa, node bb) { return (aa.x > bb.x); }
int main() {
scanf("%d%lf", &n, &t);
ans = 0;
for (int i = 1; i <= n; i++) scanf("%lf", &c[i]);
for (int i = 1; i <= n; i++) scanf("%lf", &d[i]);
cnt1 = 0;
cnt2 = 0;
ti = t;
for (int i = 1; i <= n; i++)
if (d[i] == t)
ans = ans + c[i];
else {
if (d[i] > t) {
cnt1++;
a[cnt1].x = d[i];
a[cnt1].y = c[i];
} else {
cnt2++;
b[cnt2].x = d[i];
b[cnt2].y = c[i];
}
}
sort(a + 1, a + 1 + cnt1, cmp1);
sort(b + 1, b + 1 + cnt2, cmp2);
sum = s = 0;
for (int i = 1; i <= n; i++) {
w = c[i];
f = d[i];
sum = sum + w * f;
s = s + w;
}
w = ti;
if (sum < w * s) {
sum = s = 0;
for (int i = 1; i <= cnt1; i++) {
w = a[i].y;
f = a[i].x;
sum = sum + w * f;
s = s + w;
}
for (int i = 1; i <= cnt2; i++) {
w = b[i].y;
f = b[i].x;
if (sum + w * f < (s + w) * ti) {
w = (sum - s * ti) / (ti - f);
s = s + w;
break;
}
s = s + w;
sum = sum + w * f;
}
} else {
sum = s = 0;
for (int i = 1; i <= cnt2; i++) {
w = b[i].y;
f = b[i].x;
sum = sum + w * f;
s = s + w;
}
t = sum;
for (int i = 1; i <= cnt1; i++) {
w = a[i].y;
f = a[i].x;
if (sum + w * f >= (s + w) * ti) {
w = (sum - s * ti) / (ti - f);
s = s + w;
break;
}
s = s + w;
sum = sum + w * f;
}
}
ans = ans + s;
printf("%.10lf\n", ans);
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int w[10010];
long long b[10100];
vector<int> c[1010];
long long ans[1010][1010];
bool bol[1010];
int uk;
vector<long long> k[1010];
void dfs(int n) {
bol[n] = true;
for (vector<int>::iterator it = c[n].begin(); it != c[n].end(); it++) {
if (bol[*it] == false) {
k[uk].push_back(*it);
dfs(*it);
}
}
}
int main() {
int n, m, w1;
cin >> n >> m >> w1;
for (int i = 1; i <= n; i++) cin >> w[i];
for (int i = 1; i <= n; i++) cin >> b[i];
for (int i = 1; i <= n; i++) bol[i] = false;
for (int i = 1; i <= m; i++) {
int x, y;
cin >> x >> y;
c[x].push_back(y);
c[y].push_back(x);
}
uk = 1;
int p = n + 1;
for (int i = 1; i <= n; i++) {
if (bol[i] == true) continue;
k[uk].push_back(i);
dfs(i);
int sw = 0;
long long sb = 0;
for (vector<long long>::iterator it = k[uk].begin(); it != k[uk].end();
it++) {
sw += w[*it];
sb += b[*it];
}
if (sw > w1) {
uk++;
continue;
}
w[p] = sw;
b[p] = sb;
k[uk].push_back(p);
p++;
uk++;
}
for (int i = 0; i <= 1001; i++)
for (int j = 0; j <= 1001; j++) {
ans[i][j] = 0;
}
for (int i = 1; i < uk; i++)
for (vector<long long>::iterator it = k[i].begin(); it != k[i].end();
it++) {
int ww = w[*it];
long long bb = b[*it];
for (int j = 1; j <= w1; j++) {
if (j - ww < 0) {
ans[i][j] = max(ans[i - 1][j], ans[i][j]);
} else {
ans[i][j] =
max(ans[i - 1][j], max(ans[i - 1][j - ww] + bb, ans[i][j]));
}
}
}
long long max1 = 0;
for (int i = 1; i <= w1; i++) max1 = max(max1, ans[uk - 1][i]);
cout << max1;
return 0;
}
| 10 | CPP |
t=int(input())
def check(a):
if a.count(a[0])==len(a):
return False
else:
return True
for q in range(t):
n=int(input())
a=list(map(int,input().split()))
m=max(a)
ans=a.index(m)+1
if a[0]==m and a[1]!=m:
ans=1
elif a[-1]==m and a[n-2]!=m:
ans=n
else :
for i in range(1,n-1):
if a[i]==m and (a[i-1]!=m or a[i+1]!=m):
ans=i+1
break
if (not check(a)):
print(-1)
else:
print(ans)
| 9 | PYTHON3 |
z=input()
d=int(input())
di={}
x=list(map(int,input().split()))
c=0
for i in range(97,123):
if di.get(chr(i),0)==0:
di[chr(i)]=x[c]
c+=1
ma=max(di.values())
w=0
for i in range(len(z)+d):
if i<len(z):
w+=di[z[i]]*(i+1)
else:
w+=ma*(i+1)
print(w)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
long long s = 0;
for (int x, i = 0; i < n; i++) {
cin >> x;
s += x * (i + 1);
}
cout << s << "\n";
}
| 9 | CPP |
n=int(input())
s=input()
x=int(n/11)
y=0
for i in range (0, n):
if s[i]=='8':
y=y+1
if x>y:
pn=y
else:
pn=x
print(pn) | 7 | PYTHON3 |
#include <bits/stdc++.h>
#pragma gcc optimize("Ofast,no-stack-protector,tune=native")
#pragma gcc optimize("sse,sse2,sse3,sse4,ssse3")
#pragma gcc optimize("abm,mmx,avx,avx2,unroll-loops,fast-math,section-anchors")
using namespace std;
bool check(long long n, long long k, long long m) {
long long cnt = m;
long long k1 = k;
while (m / k1 > 0 && cnt < n) {
cnt += m / k1;
k1 *= k;
}
return cnt >= n;
}
signed main() {
long long n, k;
cin >> n >> k;
long long l = 0, r = 1e9 + 1;
while (r - l > 1) {
long long m = (r + l) >> 1;
if (check(n, k, m))
r = m;
else
l = m;
}
cout << r;
}
| 8 | CPP |
n=int(input())
match={}
for i in range(n):
team=input()
try:
match[team] += 1
except:
match[team] = 0
e=sorted(match,reverse=True,key=lambda x:match[x])
print(e[0])
| 7 | PYTHON3 |
import os
import sys
debug = True
if debug and os.path.exists("input.in"):
input = open("input.in", "r").readline
else:
debug = False
input = sys.stdin.readline
def inp():
return (int(input()))
def inlt():
return (list(map(int, input().split())))
def insr():
s = input()
return s[:len(s) - 1] # Remove line char from end
def invr():
return (map(int, input().split()))
test_count = inp()
for t in range(test_count):
if debug:
print("Test Case #", t + 1)
# Start code here
a = inlt()
a.sort()
if a[2] - (a[0] + a[1]) > 1:
print("NO")
else:
print("YES")
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int q;
char c[1001][21], d[1001][21];
int a[1001], b[1001];
char ccc[1001][21], ddd[1001][21];
int tot = 0;
void init() {
scanf("%d", &q);
for (int i = 1; i <= q; i++) scanf("%s%s", &c[i], &d[i]);
for (int i = 2; i <= q; i++) {
for (int j = i - 1; j >= 1; j--) {
if (strcmp(c[i], d[j]) == 0) {
a[j] = i;
b[i] = j;
break;
}
}
}
for (int i = 1; i <= q; i++) {
if (a[i] == 0 && b[i] == 0) {
tot++;
for (int j = 0; j <= 20; j++) {
ccc[tot][j] = c[i][j];
ddd[tot][j] = d[i][j];
}
}
if (a[i] != 0 && b[i] == 0) {
char cc[21], dd[21];
for (int j = 0; j <= 20; j++) cc[j] = c[i][j];
int find = i;
while (a[find] != 0) find = a[find];
for (int j = 0; j <= 20; j++) dd[j] = d[find][j];
tot++;
for (int j = 0; j <= 20; j++) {
ccc[tot][j] = cc[j];
ddd[tot][j] = dd[j];
}
}
}
cout << tot << endl;
for (int i = 1; i <= tot; i++) cout << ccc[i] << " " << ddd[i] << endl;
}
int main() {
init();
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)2e5 + 5;
const int INF = (int)1e9 + 7;
int ini() {
int x;
scanf("%d", &x);
return x;
}
long long inl() {
long long x;
scanf("%lld", &x);
return x;
}
int pres[100009], s[100009];
int main() {
int n, i, j, a, b;
n = ini();
a = ini();
b = ini();
for (i = 0; i < n; i++) {
cin >> s[i];
}
pres[0] = s[0];
sort(s + 1, s + n);
for (int i = 1; i < n; i++) {
pres[i] = pres[i - 1] + s[i];
}
int res;
int k = (s[0] * a) / pres[n - 1];
if (k > b) {
cout << 0 << endl;
} else {
for (int i = n - 1, j = 0; i >= 0; i--, j++) {
int l = (s[0] * a) / (pres[i]);
if (l >= b) {
res = j;
break;
}
}
cout << res << endl;
}
return 0;
}
| 8 | CPP |
import sys
from collections import OrderedDict
#from me.io import dup_file_stdin
#@dup_file_stdin
def solve():
while True:
n = int(sys.stdin.readline())
if n==0 :
break
emps = OrderedDict()
for i in range(n):
no,price,amount = map(int,sys.stdin.readline().split(' '))
emps[no]=emps.get(no,0)+price*amount
results = [k for k,v in emps.items() if v>=1000000]
if len(results) > 0:
[print(emp) for emp in results]
else:
print("NA")
solve()
| 0 | PYTHON3 |
from sys import maxsize
t=int(input())
for i in range(t):
n=int(input())
A=list(map(int,input().split()))
S=sum(A)
mx=-maxsize-1
cur_mx=0
start=0
end=0
s=0
for i in range(n):
cur_mx+=A[i]
if(mx<cur_mx):
mx=cur_mx
start=s
end=i
if(cur_mx<=0):
cur_mx=0
s=i+1
x=end-start+1
if(S==mx):
if(x==n):
print("YES")
else:
print("NO")
elif(S>mx):
print("YES")
else:
print("NO")
| 8 | PYTHON3 |
import math
t = int(input())
for i in range(t):
a = int(input())
a = 360 / (180 - a)
print("YES" if a == math.trunc(a) else "NO")
| 7 | PYTHON3 |
#include <bits/stdc++.h>
int main() {
int i, n, m, j = 0, cmt = 0;
scanf("%d %d", &n, &m);
int T[m + 1];
int N[n];
for (i = 0; i < n; i++) N[i] = 0;
for (i = 0; i < m; i++) scanf("%d", &T[i]);
for (i = 0; i < m; i++) {
N[T[i] - 1] = N[T[i] - 1] + 1;
while (j < n) {
if (N[j] == 0) break;
j++;
}
if (j == n) {
for (j = 0; j < n; j++) {
if (N[j] > 0) N[j] = N[j] - 1;
}
cmt++;
}
j = 0;
}
printf("%d", cmt);
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename F, typename S>
ostream &operator<<(ostream &os, const pair<F, S> &p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
os << "{";
typename vector<T>::const_iterator it;
for (it = v.begin(); it != v.end(); it++) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "}";
}
template <typename T>
ostream &operator<<(ostream &os, const set<T> &v) {
os << "[";
typename set<T>::const_iterator it;
for (it = v.begin(); it != v.end(); it++) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "]";
}
template <typename F, typename S>
ostream &operator<<(ostream &os, const map<F, S> &v) {
os << "[";
typename map<F, S>::const_iterator it;
for (it = v.begin(); it != v.end(); it++) {
if (it != v.begin()) os << ", ";
os << it->first << " = " << it->second;
}
return os << "]";
}
signed main() {
long double n;
cin >> n;
long double ans = 0;
for (long double i = 1; i <= n; i++) {
ans += (long double)(1 / i);
}
cout << setprecision(10) << ans << endl;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<ll, ll> P;
#define EACH(i,a) for (auto& i : a)
#define FOR(i,a,b) for (ll i=(a);i<(b);i++)
#define RFOR(i,a,b) for (ll i=(b)-1;i>=(a);i--)
#define REP(i,n) for (ll i=0;i<(n);i++)
#define RREP(i,n) for (ll i=(n)-1;i>=0;i--)
#define debug(x) cout<<#x<<": "<<x<<endl
#define pb push_back
#define ALL(a) (a).begin(),(a).end()
const ll linf = 1e18;
const int inf = 1e9;
const double eps = 1e-12;
const double pi = acos(-1);
template<typename T>
istream& operator>>(istream& is, vector<T>& vec) {
EACH(x,vec) is >> x;
return is;
}
template<typename T>
ostream& operator<<(ostream& os, vector<T>& vec) {
REP(i,vec.size()) {
if (i) os << " ";
os << vec[i];
}
return os;
}
template<typename T>
ostream& operator<<(ostream& os, vector< vector<T> >& vec) {
REP(i,vec.size()) {
if (i) os << endl;
os << vec[i];
}
return os;
}
typedef vector<ll> Row;
typedef vector<Row> Matrix;
Matrix G;
Matrix mul(const Matrix& A, const Matrix& B) {
Matrix res(A.size(), Row(B[0].size(), 0));
REP(i, A.size()) REP(j, B[0].size()) REP(k, B.size()) {
if ( A[i][k] && B[k][j] ) res[i][j] = (res[i][j] + A[i][k] * B[k][j]) % 2;
}
return res;
}
Matrix E(const int n) {
Matrix res(n, Row(n, 0));
REP(i, n) res[i][i] = 1;
return res;
}
Matrix power(const Matrix& A, const ll n) {
Matrix x = A;
Matrix res = E(A.size());
for (ll i = 1; i <= n; i <<= 1) {
if (i & n) {
res = mul(res, x);
}
x = mul(x, x);
}
return res;
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
int n; cin >> n;
Matrix G(n, Row(n)); cin >> G;
vector<ll> b(n); cin >> b;
ll T; cin >> T;
vector<bool> used(n, false);
G = power(G, T);
REP(i, n) {
int pos = -1;
REP(j, n) {
if (used[j]) continue;
if (G[j][i]) {
pos = j;
}
}
if (pos < 0) continue;
REP(j, n) {
if (j == pos) continue;
if (G[j][i] == 0) continue;
REP(k, n) {
G[j][k] = (G[j][k] + G[pos][k]) & 1;
}
b[j] = (b[j] + b[pos]) & 1;
}
// REP(j, n) {
// if (j != pos && G[j][i]) {
// assert(false);
// cout << i << " " << j << " " << pos << " " << G[pos][i] << endl;
// }
// }
used[pos] = true;
}
int flag = 0;
REP(i, n) {
bool f = false;
REP(j, n) {
if ( G[i][j] ) {
f = true;
}
}
if (!f) {
if ( b[i] == 0 ) {
flag = max(flag, 1);
}
else {
flag = 2;
}
}
}
if (flag == 2) {
cout << "none" << endl;
}
else if (flag == 1) {
cout << "ambiguous" << endl;
}
else {
vector<int> ans(G.size());
REP(i, b.size()) {
REP(j, G.size()) {
if ( G[i][j] ) {
ans[j] = b[i];
}
}
}
cout << ans << endl;
}
} | 0 | CPP |
import math
t=int(input())
for _ in range(t):
n=int(input())
eights= math.ceil(n/4.0)
print('9'*(n-eights)+'8'*eights) | 8 | PYTHON3 |
#include<bits/stdc++.h>
using namespace std;
const int N=85,low=81*81;
int a[N][N],b[N][N];
bitset<N*N*2>dp[N][N];
int mx[N][N];
int n,m;
int main()
{
scanf("%d%d",&n,&m);
for(int i=1;i<=n;i++)
for(int j=1;j<=m;j++)
scanf("%d",&a[i][j]);
for(int i=1;i<=n;i++)
for(int j=1;j<=m;j++)
scanf("%d",&b[i][j]);
dp[1][1].set(a[1][1]-b[1][1]+low,1);
dp[1][1].set(b[1][1]-a[1][1]+low,1);
for(int i=1;i<=n;i++)
for(int j=1;j<=m;j++)
{
if(i==1&&j==1)
continue;
int x=abs(a[i][j]-b[i][j]);
dp[i][j]=(dp[i-1][j]<<x)|(dp[i-1][j]>>x)|(dp[i][j-1]<<x)|(dp[i][j-1]>>x);
}
int ans=1e9;
for(int i=0;i<=low*2;i++)
if(dp[n][m][i])
ans=min(ans,abs(i-low));
printf("%d\n",ans);
} | 0 | CPP |
n=int(input())
li=list(input().split())
li1=[0,0,0]
li2=['chest','biceps','back']
for i,j in enumerate(li):
li1[int(i)%3]+=int(j)
print(li2[li1.index(max(li1))])
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
struct Node {
vector<Node*> neighbour;
int parent = 0;
int index = 0;
};
struct Input_record {
int a, b, c;
};
struct List_num {
int a, b;
};
int num = 0;
Node node[1010];
Input_record input_record[1010];
int connect_num[100010] = {0};
int one_son_find(int a, int b) {
int parent = b;
int next = a;
vector<Node*> nei;
while (node[next].neighbour.size() != 1) {
nei = node[next].neighbour;
for (auto iter = nei.begin(); iter != nei.end(); iter++) {
if ((*iter)->index != parent) {
parent = next;
next = (*iter)->index;
break;
}
}
}
return next;
}
List_num son_find(int a, int b) {
int temp = a;
int parent = b;
int count = 0;
vector<int> next;
vector<Node*> nei;
int next1, next2;
nei = node[a].neighbour;
for (auto iter = nei.begin(); iter != nei.end(); iter++) {
if ((*iter) != &node[b]) {
next.push_back((*iter)->index);
count++;
}
if (count == 2) break;
}
next1 = next[0];
next2 = next[1];
List_num ret;
ret.a = one_son_find(next1, a);
ret.b = one_son_find(next2, a);
return ret;
}
void opt(int a, int b, int c, int mode) {
Node temp1 = node[a];
Node temp2 = node[b];
int modify_num = c / 2;
if (temp1.neighbour.size() == 1 && temp2.neighbour.size() == 1) {
if (mode == 0)
num += 1;
else
cout << a << " " << b << " " << modify_num * 2 << endl;
} else if (temp1.neighbour.size() == 1) {
if (mode == 0)
num += 3;
else {
int right1, right2;
List_num temp = son_find(b, a);
right1 = temp.a;
right2 = temp.b;
cout << a << " " << right1 << " " << modify_num << endl;
cout << a << " " << right2 << " " << modify_num << endl;
cout << right1 << " " << right2 << " " << -1 * modify_num << endl;
}
} else if (temp2.neighbour.size() == 1) {
if (mode == 0)
num += 3;
else {
int left1, left2;
List_num temp = son_find(a, b);
left1 = temp.a;
left2 = temp.b;
cout << b << " " << left1 << " " << modify_num << endl;
cout << b << " " << left2 << " " << modify_num << endl;
cout << left1 << " " << left2 << " " << -1 * modify_num << endl;
}
} else {
if (mode == 0)
num += 4;
else {
int left1, left2;
int right1, right2;
List_num temp = son_find(b, a);
right1 = temp.a;
right2 = temp.b;
temp = son_find(a, b);
left1 = temp.a;
left2 = temp.b;
cout << left1 << " " << right1 << " " << modify_num << endl;
cout << left2 << " " << right2 << " " << modify_num << endl;
cout << left1 << " " << left2 << " " << (-1) * modify_num << endl;
cout << right1 << " " << right2 << " " << (-1) * modify_num << endl;
}
}
}
void right_print(int n) {
for (int i = 0; i < (n - 1); i++) {
opt(input_record[i].a, input_record[i].b, input_record[i].c, 0);
}
cout << num << endl;
for (int i = 0; i < (n - 1); i++) {
opt(input_record[i].a, input_record[i].b, input_record[i].c, 1);
}
}
int main() {
int n;
int a, b;
cin >> n;
int add;
for (int i = 0; i < n - 1; i++) {
cin >> a >> b;
cin >> add;
connect_num[a] += 1;
connect_num[b] += 1;
node[a].neighbour.push_back(&node[b]);
node[b].neighbour.push_back(&node[a]);
node[a].parent = b;
node[b].parent = a;
node[a].index = a;
node[b].index = b;
input_record[i].a = a;
input_record[i].b = b;
input_record[i].c = add;
}
for (int i = 0; i < n; i++) {
if (connect_num[i] == 2) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
right_print(n);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
long long n;
cin >> n;
vector<pair<long long, long long> > a(n);
for (long long i = 0; i < (long long)(n); ++i) {
cin >> a[i].first;
a[i].second = i;
}
sort(a.begin() + 1, a.end());
reverse(a.begin() + 1, a.end());
vector<pair<long long, long long> > ans;
long long i = 0, j = 1;
if (a[0].first == 0) {
cout << -1;
return 0;
}
while (j < n) {
while (i < n && a[i].first == 0) {
i++;
}
if (i == n) break;
ans.push_back({a[i].second, a[j].second});
a[i].first--;
j++;
}
if ((long long)(ans).size() < n - 1) {
cout << -1;
} else {
cout << (long long)(ans).size() << endl;
for (auto i : ans) {
cout << i.first + 1 << ' ' << i.second + 1 << endl;
}
}
return 0;
}
| 8 | CPP |
t = int(input())
cases = []
for i in range(t):
n, m = map(int, input().strip().split())
mat = []
for i in range (n):
mat.append(list(map(int, input().strip().split())))
cases.append(mat)
def solve(case):
ans = [["0" for j in range(len(case[0]))] for i in range(len(case))]
for r in range(len(case)):
for c in range(len(case[r])):
nb = 4
if (r == 0 and c == 0) or \
(r == 0 and c == len(case[r])-1) or \
(r == len(case)-1 and c == 0) or \
(r == len(case)-1 and c == len(case[r]) - 1):
nb = 2
elif r == 0 or r == len(case)-1 or c == 0 or c == len(case[r])-1:
nb = 3
true = case[r][c]
if true > nb:
print("NO")
return
ans[r][c]=str(nb)
print("YES")
print("\n".join(map(lambda row: " ".join(row), ans)))
for case in cases:
solve(case)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a,b,c;
cin>>a>>b>>c;
int p=a+b+c;
cout<<p-max(max(a,b),c)<<endl;
} | 0 | CPP |
t=int(input())
for i in range(t):
n=int(input())
cnt=0
while n>=2:
val=int((-1+(24*n+1)**(0.5))/6)
sum1=(val*(3*val+1))/2
n-=sum1
cnt+=1
print(cnt)
| 8 | PYTHON3 |
n = int(input())
A = [int(input()) for _ in range(n)]
cnt = 0
G = [797161,265720,88573,29524,9841,3280,1093,364,121,40,13,4,1]
G = [v for v in G if v <= n]
m = len(G)
def insertionSort(A, n, g):
global cnt
for i in range(g, n):
v = A[i]
j = i - g
while j >= 0 and A[j] > v:
A[j+g] = A[j]
j = j - g
cnt += 1
A[j+g] = v
for g in G:
insertionSort(A, n, g)
print(m)
print(*G)
print(cnt)
print(*A, sep='\n')
| 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, q;
char s[2005][2005];
long long sum[2005][2005];
bool cnt(long long x) {
int ret = 0;
while (x > 0) {
if (x & 1) ret++;
x >>= 1;
}
return (ret & 1);
}
long long f(long long a, long long b, bool inv) {
if (!a || !b) return 0;
if (a <= n && b <= m) {
if (inv)
return a * b - sum[a][b];
else
return sum[a][b];
}
if (a <= n) {
if (b <= 2 * m) return f(a, m, inv) + f(a, b - m, !inv);
long long M = 2 * m;
long long t = a * m;
while (2 * M <= b) M <<= 1, t <<= 1;
return t + f(a, b - M, !inv);
} else {
if (a <= 2 * n) return f(n, b, inv) + f(a - n, b, !inv);
long long N = 2 * n;
long long t = b * n;
while (2 * N <= a) N <<= 1, t <<= 1;
return t + f(a - N, b, !inv);
}
}
void solve() {
cin >> n >> m >> q;
for (long long i = 0; i < n; i++) {
scanf("%s", s[i]);
}
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
sum[i + 1][j + 1] =
-sum[i][j] + sum[i][j + 1] + sum[i + 1][j] + (s[i][j] == '1');
}
}
while (q--) {
long long x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
cout << f(x2, y2, false) - f(x1 - 1, y2, false) - f(x2, y1 - 1, false) +
f(x1 - 1, y1 - 1, false)
<< endl;
}
}
int main(void) {
long long t;
t = 1;
while (t--) solve();
return 0;
}
| 11 | CPP |
def main():
k = int(input())
for q in range(k):
n, m = map(int, input().split())
if n*m <= n+m:
print('YES')
else:
print('NO')
if __name__ == '__main__':
main() | 7 | PYTHON3 |
#include <iostream>
#include <string>
using namespace std;
int main(){
string bad;
int a,b;
while(true){
a=0;b=0;
cin >> bad;
if(bad=="0"){
break;
}
for(int i=1;i<bad.size();i++){
if(bad[i]=='A'){
a++;
}else{
b++;
}
}
if(a>b){
a++;
}else{
b++;
}
cout << a << ' ' << b << endl;
}
return 0;
} | 0 | CPP |
# ///////////////////////////////////////////////////////////////////////////
# //////////////////// PYTHON IS THE BEST ////////////////////////
# ///////////////////////////////////////////////////////////////////////////
import sys,os,io
from sys import stdin
import math
from collections import defaultdict
from heapq import heappush, heappop, heapify
from bisect import bisect_left , bisect_right
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
alphabets = list('abcdefghijklmnopqrstuvwxyz')
#for deep recursion__________________________________________-
from types import GeneratorType
def bootstrap(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
def ncr(n, r, p):
num = den = 1
for i in range(r):
num = (num * (n - i)) % p
den = (den * (i + 1)) % p
return (num * pow(den,p - 2, p)) % p
def primeFactors(n):
l = []
while n % 2 == 0:
l.append(2)
n = n / 2
for i in range(3,int(math.sqrt(n))+1,2):
while n % i== 0:
l.append(int(i))
n = n / i
if n > 2:
l.append(n)
# c = dict(Counter(l))
return list(set(l))
# return c
def power(x, y, p) :
res = 1
x = x % p
if (x == 0) :
return 0
while (y > 0) :
if ((y & 1) == 1) :
res = (res * x) % p
y = y >> 1 # y = y/2
x = (x * x) % p
return res
#____________________GetPrimeFactors in log(n)________________________________________
def sieveForSmallestPrimeFactor():
MAXN = 100001
spf = [0 for i in range(MAXN)]
spf[1] = 1
for i in range(2, MAXN):
spf[i] = i
for i in range(4, MAXN, 2):
spf[i] = 2
for i in range(3, math.ceil(math.sqrt(MAXN))):
if (spf[i] == i):
for j in range(i * i, MAXN, i):
if (spf[j] == j):
spf[j] = i
return spf
def getPrimeFactorizationLOGN(x):
spf = sieveForSmallestPrimeFactor()
ret = list()
while (x != 1):
ret.append(spf[x])
x = x // spf[x]
return ret
#____________________________________________________________
def SieveOfEratosthenes(n):
#time complexity = nlog(log(n))
prime = [True for i in range(n+1)]
p = 2
while (p * p <= n):
if (prime[p] == True):
for i in range(p * p, n+1, p):
prime[i] = False
p += 1
return prime
def si():
return input()
def divideCeil(n,x):
if (n%x==0):
return n//x
return n//x+1
def ii():
return int(input())
def li():
return list(map(int,input().split()))
# ///////////////////////////////////////////////////////////////////////////
# //////////////////// DO NOT TOUCH BEFORE THIS LINE ////////////////////////
# ///////////////////////////////////////////////////////////////////////////
if(os.path.exists('input.txt')):
sys.stdin = open("input.txt","r") ; sys.stdout = open("output.txt","w")
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
mex = 0
vis = [False]*200001
@bootstrap
def dfs(node):
global mex
for kid in adj[node]:
if vis[kid]==False:
vis[kid]=True
mex=max(mex,kid)
yield dfs(kid)
yield
n,m = li()
adj = [[] for i in range(n)]
for i in range(m):
u,v = li()
u-=1
v-=1
adj[u].append(v)
adj[v].append(u)
ans = 0
for i in range(n):
if vis[i]==False:
vis[i]=True
if i<mex:
ans+=1
dfs(i)
print(ans)
| 10 | PYTHON3 |
from math import sqrt, ceil, floor
n = int(input())
cnt = 0
for i in range(0, n):
a, b = input().split()
if b == 'soft':
cnt += 1
cnt = max(cnt, n-cnt)
for i in range(0, 100):
t = i*i
a, b = int(ceil(t/2)), int(floor(t/2))
if(a >= cnt and b >= n-cnt) or (b >= cnt and a >= n-cnt):
print(i)
break
| 11 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long M;
cin >> M;
long long sx = 1, dx = 5e15;
long long answ = -1;
while (sx <= dx) {
long long mid = (sx + dx) / 2;
long long comb = 0;
for (long long i = 2; i * i * i <= mid; i++) comb += (mid / (i * i * i));
if (comb >= M) {
dx = mid - 1;
if (comb == M) answ = mid;
} else
sx = mid + 1;
}
cout << answ;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int nmax = 100005;
int x[nmax][10];
int y[nmax];
bool flag[nmax], checksum = false, checksum2 = true;
int n, cnt;
int temp1, temp2;
int i, j;
void run(int i, int j) {
memset(flag, true, sizeof(flag));
y[2] = x[1][i];
flag[y[2]] = false;
y[3] = x[1][j];
flag[y[3]] = false;
flag[y[1]] = false;
cnt = 3;
bool check[nmax];
memset(check, false, sizeof(check));
while (cnt < n) {
for (int t = 1; t <= 4; t++) {
for (int k = 1; k <= 4; k++)
if (x[y[cnt]][t] == x[y[cnt - 1]][k] && flag[x[y[cnt]][t]]) {
y[cnt + 1] = x[y[cnt]][t];
flag[y[cnt + 1]] = false;
check[cnt + 1] = true;
break;
}
if (check[cnt + 1]) {
break;
}
}
if (check[cnt + 1]) {
cnt++;
} else
return;
}
if (cnt == n) {
for (int m = 1; m <= n; m++) cout << y[m] << " ";
checksum = true;
} else
return;
}
int main() {
cin >> n;
memset(x, 0, sizeof(x));
memset(flag, true, sizeof(flag));
for (int p = 1; p <= 2 * n; p++) {
cin >> temp1 >> temp2;
if (x[temp1][0] < 4 && x[temp2][0] < 4) {
x[temp1][++x[temp1][0]] = temp2;
x[temp2][++x[temp2][0]] = temp1;
} else
checksum2 = false;
}
if (!checksum2)
cout << "-1" << endl;
else {
y[1] = 1;
for (i = 1; i <= 4; i++) {
for (j = 1; j <= 4; j++)
if (i != j) {
if (!checksum) run(i, j);
}
}
if (!checksum) cout << "-1" << endl;
}
}
| 9 | CPP |
n=int(input())
list1=[]
for i in range(n):
list1.append(input())
dict1={"Tetrahedron":4,"Cube":6,"Octahedron":8,"Dodecahedron":12,"Icosahedron":20}
count=0
for i in list1:
count+=dict1[i]
print(count) | 7 | PYTHON3 |
T = int(input())
for _ in range(T):
d = int(input())
if d == 0:
print('Y 0.000000000 0.000000000')
elif d < 4:
print('N')
else:
a = (d+(((d**2)-(4*d))**(0.5)))/2
b = (d-(((d**2)-(4*d))**(0.5)))/2
if a>=0 and b>=0:
print(f'Y {a:.9f} {b:.9f}')
else:
print('N')
| 9 | PYTHON3 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
vector<pair<int,int> > p;
bool cmp(pair<int,int> p1,pair<int,int> p2){
return min(p1.second,p1.first+p2.second)>min(p2.second,p2.first+p1.second);
}//{cnt,mn}
int main(){
int n,sum=0;
scanf("%d",&n);
for(int i=0;i<n;i++){
string s;
int cnt=0,mn=0;
cin>>s;
for(int j=0;j<s.length();j++){
char c=s[j];
if(c=='(') cnt++;
else cnt--;
mn=min(mn,cnt);
}
p.push_back({cnt,mn});
sum+=cnt;
}
if(sum!=0) {
printf("No");
return 0;
}
sort(p.begin(),p.end(),cmp);
int res=0;
for(int i=0;i<p.size();i++){
if(res+p[i].second<0 ){
printf("No");
return 0;
}
res+=p[i].first;
}
printf("Yes");
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int a[n][m], b[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) cin >> a[i][j];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) cin >> b[i][j];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int x = min(a[i][j], b[i][j]);
int y = max(a[i][j], b[i][j]);
a[i][j] = x;
b[i][j] = y;
}
}
bool check = true;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m - 1; j++) {
if (a[i][j] >= a[i][j + 1] || b[i][j] >= b[i][j + 1]) {
cout << "Impossible\n";
return 0;
}
}
}
for (int j = 0; j < m; j++) {
for (int i = 0; i < n - 1; i++) {
if (a[i][j] >= a[i + 1][j] || b[i][j] >= b[i + 1][j]) {
cout << "Impossible\n";
return 0;
}
}
}
cout << "Possible\n";
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int a[2000000];
int pow(int k) {
int ans = 1;
while (k--) {
ans *= 2;
}
return ans;
}
int f(long long x) {
int ans = 0;
int k = 0;
while (x) {
int temp = x % 10;
if (temp & 1) ans += pow(k);
x /= 10;
k++;
}
return ans;
}
int g(string s) {
int l = s.length();
int ans = 0;
for (int i = l - 1; i >= 0; i--) {
ans += (s[i] - 48) * pow(l - 1 - i);
}
return ans;
}
int main() {
int t;
scanf("%d", &t);
memset(a, 0, sizeof(a));
while (t--) {
getchar();
char x;
long long y;
string s;
cin >> x;
if (x == '+') {
cin >> y;
int temp = f(y);
a[temp]++;
}
if (x == '-') {
cin >> y;
int temp = f(y);
a[temp]--;
}
if (x == '?') {
cin >> s;
int temp = g(s);
cout << a[temp] << endl;
}
}
}
| 9 | CPP |
n = int(input())
coord = []
while n > 0:
x, y, z = [int(x) for x in input().split()]
coord.append(x)
n -= 1
if sum(coord) == 0:
print("YES")
else:
print("NO") | 7 | PYTHON3 |
# -*- coding: utf-8 -*-
import sys
# sys.setrecursionlimit(10**6)
# buff_readline = sys.stdin.buffer.readline
buff_readline = sys.stdin.readline
readline = sys.stdin.readline
INF = 2**62-1
def read_int():
return int(buff_readline())
def read_int_n():
return list(map(int, buff_readline().split()))
def read_float():
return float(buff_readline())
def read_float_n():
return list(map(float, buff_readline().split()))
def read_str():
return readline().strip()
def read_str_n():
return readline().strip().split()
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
def slv(N, A):
A.sort(reverse=True)
for i in range(N):
if A[i] <= N - i:
break
else:
pass
else:
i += 1
return N + 1 - i
def main():
T = read_int()
for _ in range(T):
N = read_int()
A = read_int_n()
print(slv(N, A))
if __name__ == '__main__':
main()
| 8 | PYTHON3 |
import os
import sys
from io import BytesIO, IOBase
from math import gcd
def solution(arr, n):
res = []
srr = arr[:]
mx = max(srr)
srr.remove(mx)
res.append(mx)
c = [mx]
while srr:
cur = c[-1]
rem = -1
for x in srr:
gc = gcd(x, cur)
if gc > rem:
rem = gc
ele = x
c.append(rem)
res.append(ele)
srr.remove(ele)
write(*res)
def main():
for _ in range(r_int()):
n = r_int()
arr = r_array()
solution(arr, n)
# fast-io region
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
def input():
return sys.stdin.readline().rstrip("\r\n")
def write(*args, end='\n'):
for x in args[:-1]:
sys.stdout.write(str(x) + ' ')
sys.stdout.write(str(args[-1]))
sys.stdout.write(end)
def r_array():
return [int(x) for x in input().split()]
def r_int():
return int(input())
if __name__ == "__main__":
main() | 8 | PYTHON3 |
t=int(input())
for i in range(0,t):
n=int(input())
L=list(map(int,input().split()))
count=0
for i in range(0,len(L)):
if(L[i]%2==1):
count+=1
if(count==n):
print("Yes")
else:
print("No")
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int MIN(int a, int b) {
int x = (b > a) ? a : b;
return x;
}
int MAX(int a, int b) {
int x = (b < a) ? a : b;
return x;
}
const int size = 1000007;
const long long modulo = 1000000007;
const long long inf = 1e18;
const double eps = 1e-6;
long long n, m, a[4000], b[4000], k, n25, n50, n100;
int f[1000];
int pos[1000];
bool xx[1000000];
char str[100009];
int main() {
char temp[100009];
char ss;
while (scanf("%d", &n) == 1) {
scanf("%s", temp);
int N = strlen(temp);
for (int i = 0; i < N; i++) {
if (temp[i] == '?')
str[i] = '~';
else
str[i] = temp[i];
}
for (int j = 1; j < n; j++) {
scanf("%s", temp);
for (int i = 0; i < N; i++) {
if (temp[i] == '?') {
} else if (str[i] != temp[i]) {
if (str[i] == '~')
str[i] = temp[i];
else
str[i] = '?';
}
}
}
for (int i = 0; i < N; i++)
if (str[i] == '~') str[i] = 'a';
str[N] = 0;
printf("%s\n", str);
}
return 0;
}
| 9 | CPP |
prime=[True]*1000000
for i in range(2,1000):
if prime[i]:
for j in range(i*2,1000000,i):
prime[j]=False
while True:
try:
n=int(input())
except:
break
print(sum(prime[2:n+1])) | 0 | PYTHON3 |
from copy import copy
length = int(input())
nums= input().split(" ")
numsList = []
for n in nums:
numsList.append(int(n))
left = []
right = []
for i in range(length):
left.append(1)
right.append(1)
for i in range(1, length):
if numsList[i] > numsList[i-1]:
left[i] = left[i-1] + 1
if numsList[length-i] > numsList[length-i-1]:
right[length-i-1] = right[length-i] + 1
answer = 0
for i in range(length):
if length == 1:
answer = 1
elif i == 0:
if left[i] == 1:
maxVal = right[i+1] + left[i]
if maxVal > answer:
answer = maxVal
# if right[i] == 1:
# maxVal = right[i+1] + left[i]
# if maxVal > answer:
# answer = maxVal
elif i == length-1:
if left[i] == 1:
maxVal = left[i-1] + right[i]
if maxVal > answer:
answer = maxVal
else:
if left[i] == 1:
if (numsList[i+1] - numsList[i-1] >= 2 or (i-2 > 0 and numsList[i] - numsList[i-2] >= 2)):
maxVal = left[i-1] + right[i]
if maxVal > answer:
answer = maxVal
else:
maxVal = left[i-1] + 1
if maxVal > answer:
answer = maxVal
if right[i] == 1:
if (numsList[i+1] - numsList[i-1] >= 2 or (i+2 < length and numsList[i+2] - numsList[i] >= 2)):
maxVal = right[i+1] + left[i]
if maxVal > answer:
answer = maxVal
else:
maxVal = right[i+1] + 1
if maxVal > answer:
answer = maxVal
print (answer)
| 7 | 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, m;
cin >> n >> m;
for (long long int i = 0; i < n; i++) {
cout << i % 2;
}
}
| 8 | CPP |
// template version 1.14
using namespace std;
#include <bits/stdc++.h>
// varibable settings
#define int long long
const int INF=1e18;
const int MOD=1e9+7;
// define basic macro {{{
#define _overload3(_1,_2,_3,name,...) name
#define _rep(i,n) repi(i,0,n)
#define repi(i,a,b) for(int i=(int)(a);i<(int)(b);++i)
#define rep(...) _overload3(__VA_ARGS__,repi,_rep,)(__VA_ARGS__)
#define _rrep(i,n) rrepi(i,0,n)
#define rrepi(i,a,b) for(int i=(int)((b)-1);i>=(int)(a);--i)
#define rrep(...) _overload3(__VA_ARGS__,rrepi,_rrep,)(__VA_ARGS__)
#define each(i,a) for (auto&& i : a)
#define all(x) (x).begin(),(x).end()
#define sz(x) ((int)(x).size())
#define pb(a) push_back(a)
#define mp(a, b) make_pair(a, b)
#define mt(a, b, c) make_tuple(a, b, c)
#define ceil(a,b) ((a)+(b)-1)/(b)
#define is_in(x, a, b) ((a)<=(x) && (x)<(b))
#define uni(x) sort(all(x));x.erase(unique(all(x)),x.end())
#define ub upper_bound
#define lb lower_bound
#define posl(A, x) (lower_bound(all(A), x)-A.begin())
#define posu(A, x) (upper_bound(all(A),x)-A.begin())
template<class T> inline void chmax(T &a, const T &b) { if((a) < (b)) (a) = (b); }
template<class T> inline void chmin(T &a, const T &b) { if((a) > (b)) (a) = (b); }
typedef long long ll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef long double ld;
typedef pair<int,int> pii;
typedef tuple<int,int,int> iii;
template<typename T> using PQ = priority_queue<T, vector<T>, greater<T>>;
struct Fast { Fast(){ std::cin.tie(0); ios::sync_with_stdio(false); } } fast;
#if defined(PCM) || defined(LOCAL)
#include "lib/dump.hpp"
#else
#define dump(...) 42
#define dump_1d(...) 42
#define dump_2d(...) 42
#endif
//}}}
bool is_prime(int n) {/*{{{*/
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) return false;
}
return n != 1;
}/*}}}*/
signed main() {
int n;cin>>n;
set<int> d;
set<int> d2;
for(int i=1; i*i<=n; i++){
if (n%i==0){
d.insert(i);
if (is_prime(n/i)) d2.insert(i);
d.insert(n/i);
if (is_prime(n/(n/i))) d2.insert(n/i);
}
}
d.erase(n);
d2.erase(n);
dump(d);
dump(d2);
int M = sz(d);
int m = sz(d2);
cout << m << " " << M << endl;
return 0;
}
| 0 | CPP |
#include<bits/stdc++.h>
using namespace std;
using ll=long long;
int main(){
int i,j,k,cnt=0;
int h,w;
cin>>h>>w;
string s[h+1];
for(i=0;i<h;i++)cin>>s[i];
for(i=0;i<h;i++)s[i]+='#';
s[h]="";
for(i=0;i<=w;i++)s[h]+='#';
int c[h][w];
for(i=0;i<h;i++)for(j=0;j<w;j++)c[i][j]=0;
for(i=0;i<h;i++){
cnt=-1;
for(j=0;j<=w;j++){
if(s[i][j]=='#'){
for(k=cnt+1;k<j;k++){
c[i][k]+=j-cnt-1;
}
cnt=j;
}
}
}
for(i=0;i<w;i++){
cnt=-1;
for(j=0;j<=h;j++){
if(s[j][i]=='#'){
for(k=cnt+1;k<j;k++){
if(c[k][i]==0)c[k][i]+=j-cnt-1;
else c[k][i]+=j-cnt-2;
}
cnt=j;
}
}
}
int ma=0;
for(i=0;i<h;i++){
for(j=0;j<w;j++){
ma=max(ma,c[i][j]);
}
}
cout<<ma;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
int n, K, tr[6000010], tag[6000010], lc[6000010], rc[6000010], rt, x = 0,
lst = -1;
priority_queue<pair<int, int> > q;
void pushup(int t) { tr[t] = max(tr[lc[t]], tr[rc[t]]) + tag[t]; }
void upd(int a, int l, int r, int &t, int c) {
if (!t) t = ++x;
if (l == r) return tag[t] = tr[t] = c, void();
int mid = (l + r) >> 1;
if (a <= mid)
upd(a, l, mid, lc[t], c);
else
upd(a, mid + 1, r, rc[t], c);
pushup(t);
}
void add(int ll, int rr, int l, int r, int t) {
if (!t) return;
if (ll <= l && r <= rr) return tr[t]++, tag[t]++, void();
int mid = (l + r) >> 1;
if (ll <= mid) add(ll, rr, l, mid, lc[t]);
if (mid < rr) add(ll, rr, mid + 1, r, rc[t]);
pushup(t);
}
int qry(int ll, int rr, int l, int r, int t) {
if (!t) return 0;
if (ll <= l && r <= rr) return tr[t];
int mid = (l + r) >> 1;
if (rr <= mid) return qry(ll, rr, l, mid, lc[t]) + tag[t];
if (mid < ll) return qry(ll, rr, mid + 1, r, rc[t]) + tag[t];
return max(qry(ll, rr, l, mid, lc[t]), qry(ll, rr, mid + 1, r, rc[t])) +
tag[t];
}
int main() {
scanf("%d%d", &n, &K);
for (int i = 1, s, t; i <= n; i++) {
scanf("%d%d", &s, &t);
if (t < 0) continue;
s = max(0, s);
q.push(make_pair((-t), (-s))), q.push(make_pair((-s), (1)));
}
while (q.size()) {
int l = -q.top().second, r = -q.top().first;
q.pop();
if (l >= 0) {
add(l, r, 0, inf, rt);
continue;
}
if (r == lst) continue;
int u = lst >= 0 ? qry(lst, lst, 0, inf, rt) : 0,
v = r - K >= 0 ? qry(0, r - K, 0, inf, rt) : 0;
if (l == -1 || u < v) {
lst = r;
upd(r, 0, inf, rt, v);
if (r + K <= inf) q.push(make_pair((-r - K), (2)));
}
}
printf("%d\n", tr[rt]);
}
| 8 | CPP |
n = int(input())
a = list(map(int, input().split()))
a.sort(reverse=True)
cmin = 0
track = 0
total = sum(a)
min = a[-1]
for i in range(n):
cmin += a[i]
if cmin <= total/2 :
track += 1
print(track+1)
| 7 | PYTHON3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.