solution
stringlengths 10
159k
| difficulty
int64 0
3.5k
| language
stringclasses 2
values |
|---|---|---|
n = int(input())
counter = 0
for i in range(0,n):
team = input()
count_1s = team.count('1')
if(count_1s > 1):
counter += 1
print(counter)
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, x, y, cnt;
int arr[200500];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
;
cin >> n;
for (int i = 0; i < n; i++) cin >> arr[i];
sort(arr, arr + n);
for (int i = 1, j = 0; i <= n; i++) {
while (j < n) {
if (i <= arr[j++]) {
cnt++;
break;
}
}
if (j >= n) break;
}
cout << cnt << endl;
return 0;
}
| 1,000 | CPP |
''' ===============================
-- @uthor : Kaleab Asfaw
-- Handle : kaleabasfaw2010
-- Bio : High-School Student
==============================='''
# Fast IO
import sys
import os
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file): self._fd = file.fileno(); self.buffer = BytesIO(); self.writable = "x" in file.mode or "r" not in file.mode; self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b: break
ptr = self.buffer.tell(); self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0; return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE)); self.newlines = b.count(b"\n") + (not b); ptr = self.buffer.tell(); self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1; return self.buffer.readline()
def flush(self):
if self.writable: os.write(self._fd, self.buffer.getvalue()); self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file): self.buffer = FastIO(file); self.flush = self.buffer.flush; self.writable = self.buffer.writable; self.write = lambda s: self.buffer.write(s.encode("ascii")); self.read = lambda: self.buffer.read().decode("ascii"); self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout); input = lambda: sys.stdin.readline().rstrip("\r\n")
# Others
# from math import floor, ceil, gcd
# from decimal import Decimal as d
mod = 10**9+7
def lcm(x, y): return (x * y) / (gcd(x, y))
def fact(x, mod=mod):
ans = 1
for i in range(1, x+1): ans = (ans * i) % mod
return ans
def arr2D(n, m, default=0): return [[default for j in range(m)] for i in range(n)]
def arr3D(n, m, r, default=0): return [[[default for k in range(r)] for j in range(m)] for i in range(n)]
def sortDictV(x): return {k: v for k, v in sorted(x.items(), key = lambda item : item[1])}
class DSU:
def __init__(self, length): self.length = length; self.parent = [-1] * self.length # O(log(n))
def getParent(self, node, start): # O(log(n))
if node >= self.length: return False
if self.parent[node] < 0:
if start != node: self.parent[start] = node
return node
return self.getParent(self.parent[node], start)
def union(self, node1, node2): # O(log(n))
parent1 = self.getParent(node1, node1); parent2 = self.getParent(node2, node2)
if parent1 == parent2: return False
elif self.parent[parent1] <= self.parent[parent2]: self.parent[parent1] += self.parent[parent2]; self.parent[parent2] = parent1
else: self.parent[parent2] += self.parent[parent1]; self.parent[parent1] = parent2
return True
def getCount(self, node): return -self.parent[self.getParent(node, node)] # O(log(n))
def exact(num):
if abs(num - round(num)) <= 10**(-9):return round(num)
return num
def solve(n, k, lst, delNum):
m = len(lst[delNum[0]-1])
for i in delNum:
if len(lst[i-1]) != m: return "No"
common = ""
for i in range(m):
for j in delNum:
if j == delNum[0]:
common += lst[j-1][i]
if common[i] != lst[j-1][i]:
common = common[:i] + "?"
notDelNum = []
for i in range(1, n+1):
if i not in delNum:
notDelNum.append(i)
ques = common.count("?")
for i in notDelNum:
if len(lst[i-1]) == m:
diff = 0
for j in range(m):
if lst[i-1][j] != common[j]:
diff += 1
if diff == ques:
return "No"
print("Yes")
return common
n, k = list(map(int, input().split()))
lst = []
for i in range(n):
lst.append(input())
delNum = list(map(int, input().split()))
print(solve(n, k, lst, delNum)) | 1,300 | PYTHON3 |
c = [0 for i in range(6)]
ex = [4,8,15,16,23,42]
q = int(input())
inp = input().split()
l = []
for j in range(q):
l.append(int(inp[j]))
for el in l:
if el == 4: c[0] += 1
for i in range(1, 6):
if el == ex[i] and c[i - 1] > 0:
c[i] += 1
c[i - 1] -= 1
print(q - c[5] * 6)
| 1,300 | PYTHON3 |
a = int(input())
for _ in range(a):
size = int(input())
ar = list(map(int, input().split()))
g = (2,3,5,7,11,13,17,19,23,29,31)
v = [0]*size
z = [0]*11
u = 0
for i in range(size):
if ar[i]%31 == 0:
if z[0] == 0:
u += 1
z[0] = u
v[i] = z[0]
elif ar[i]%29 == 0:
if z[1] == 0:
u += 1
z[1] = u
v[i] = z[1]
elif ar[i]%23 == 0:
if z[2] == 0:
u += 1
z[2] = u
v[i] = z[2]
elif ar[i]%19 == 0:
if z[3] == 0:
u += 1
z[3] = u
v[i] = z[3]
elif ar[i]%17 == 0:
if z[4] == 0:
u += 1
z[4] = u
v[i] = z[4]
elif ar[i]%13 == 0:
if z[5] == 0:
u += 1
z[5] = u
v[i] = z[5]
elif ar[i]%11 == 0:
if z[6] == 0:
u += 1
z[6] = u
v[i] = z[6]
elif ar[i]%7 == 0:
if z[7] == 0:
u += 1
z[7] = u
v[i] = z[7]
elif ar[i]%5 == 0:
if z[8] == 0:
u += 1
z[8] = u
v[i] = z[8]
elif ar[i]%3 == 0:
if z[9] == 0:
u += 1
z[9] = u
v[i] = z[9]
elif ar[i]%2 == 0:
if z[10] == 0:
u += 1
z[10] = u
v[i] = z[10]
print(u)
for i in range(size):
print(v[i], end = ' ')
print()
| 1,400 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
const int maxn = 1000000;
int task, n, m, tot, prime[100005], phi[1000005], sumg[1000005], f[1000005],
sumf0[1000005], sumf1[1000005], sumf2[1000005], ans;
bool check[1000005];
inline void euler() {
phi[1] = 1;
for (int i = 2; i <= maxn; i++) {
if (!check[i]) {
prime[++tot] = i;
phi[i] = i - 1;
}
for (int j = 1; j <= tot; j++) {
if (i * prime[j] > maxn) break;
check[i * prime[j]] = true;
if (i % prime[j] == 0) {
phi[i * prime[j]] = phi[i] * prime[j];
break;
}
phi[i * prime[j]] = phi[i] * (prime[j] - 1);
}
}
for (int i = 1; i <= maxn; i++)
for (int j = 1; i * j <= maxn; j++)
sumg[i * j] = (sumg[i * j] + (long long)i * phi[j]) % mod;
for (int i = 1; i <= maxn; i++)
f[i] = ((((long long)i * (i + 1) * (2 * i + 1) / 3) - (long long)3 * i * i +
2 * sumg[i]) %
mod +
mod) %
mod;
for (int i = 1; i <= maxn; i++) {
sumf0[i] = (sumf0[i - 1] + f[i]) % mod;
sumf1[i] = (sumf1[i - 1] + (long long)i * f[i]) % mod;
sumf2[i] = (sumf2[i - 1] + (long long)i * i % mod * (long long)f[i]) % mod;
}
}
int main() {
euler();
scanf("%d", &task);
while (task--) {
scanf("%d%d", &n, &m);
ans =
(long long)(n + 1) * (m + 1) % mod * (long long)sumf0[min(n, m)] % mod;
ans = (ans - (long long)(n + m + 2) * sumf1[min(n, m)] % mod + mod) % mod;
ans = (ans + sumf2[min(n, m)]) % mod;
printf("%d\n", ans);
}
return 0;
}
| 2,900 | CPP |
dir = {'N':0, 'S':0, 'E':0, 'W':0}
t,sx,sy,ex,ey = map(int, input().split())
req = {'N':0, 'S':0, 'E':0, 'W':0}
if sx>ex:
req['W']=sx-ex
if ex>sx:
req['E']=ex-sx
if sy>ey:
req['S']=sy-ey
if ey>sy:
req['N']=ey-sy
dirs=input()
left = lambda: req['N']>0 or req['S']>0 or req['W']>0 or req['E']>0
for i in range(t):
if left():
req[dirs[i]]-=1
else:
print(i)
break
else:
print(-1 if left() else t)
| 1,200 | PYTHON3 |
# ANSHUL GAUTAM
# IIIT-D
from math import *
from copy import * # ll = deepcopy(l)
from heapq import * # heappush(hp,x)
from string import * # alpha = ascii_lowercase
from random import * # l.sort(key=lambda l1:l1[0]-l1[1]) => ex: sort on the basis difference
from bisect import * # bisect_left(arr,x,start,end) => start and end parameters are temporary
from sys import stdin # bisect_left return leftmost position where x should be inserted to keep sorted
from sys import maxsize # minn = -maxsize
from operator import * # d = sorted(d.items(), key=itemgetter(1))
from itertools import * # pre = [0] + list(accumulate(l))
from collections import Counter # d = dict(Counter(l))
from collections import defaultdict # d = defaultdict(list)
'''
5
7 20 3 101 18
11 11 10 234 2
8 9 7 250 122
19 41 21 321 10
3 10 8 6 1
'''
def solve(l):
n,a,b,c,d = l
minnwt = a-b
maxxwt = a+b
minntot = c-d
maxxtot = c+d
minn = minnwt*n
maxx = maxxwt*n
if(minntot <= minnwt*n <= maxxtot):
return 'Yes'
if(minntot <= maxxwt*n <= maxxtot):
return 'Yes'
if(minnwt*n > maxxtot or maxxwt*n < minntot):
return 'No'
return 'Yes'
T = int(input())
for _ in range(T):
l = list(map(int, stdin.readline().rstrip().split()))
print(solve(l))
| 900 | PYTHON3 |
import os
from io import BytesIO
input = BytesIO(os.read(0, os.fstat(0).st_size)).readline
def lii(): return list(map(int, input().split()))
def ii(): return int(input())
n, m = lii()
A = lii()
B = lii()
for res in range(0, 2**9):
flag = True
for a in A:
found = False
for b in B:
c = a & b
if c | res == res:
found = True
break
if not found:
flag = False
break
if flag:
print(res)
break
else:
continue
| 1,600 | PYTHON3 |
//#include<bits/stdc++.h>
#include<iostream>
#include<vector>
#include<algorithm>
#include<set>
#include<iomanip>
#include<queue>
#include<cmath>
#include<stack>
#include <map>
#define ll long long
#define skip cin>>ws;
#define vll vector<ll>
#define vb vector<bool>
#define vpll vector<pair<ll,ll>>
#define vvll vector<vector<ll>>
#define pll pair<ll,ll>
#define vs vector<string>
#define vvpll vector<vector<pair<ll, ll>>>
#define pb push_back
#define pob pop_back()
#define MOD (ll)(1e9 + 7)
#define INF (ll)(1e18 + 5)
#define count1(n) __builtin_popcountll(n)
#define test ll t; cin>>t; while(t--)
#define loop(i,a,b) for(ll i=(ll)a;i<(ll)b;++i)
#define enter(a) for(ll i=0;i<a.size();i++) cin>>a[i];
#define show(a) for(ll e: a) cout<<e<<" "; cout<<"\n";
using namespace std;
ll mo(ll a){ return a%MOD;}
ll po(ll x, ll y, ll p)
{
ll res = 1; x = x % p;
while (y > 0) { if (y & 1) res = (res * x) % p; y >>= 1; x = (x * x) % p; }
return res%p;
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
test
{
ll n;
cin>>n;
vll mir(10, INF), mar(10, -INF), mic(10, INF), mac(10, -INF), ans(10);
vvll a(n, vll (n));
for(ll i=0;i<n;i++)
{
string s;
skip
cin>>s;
skip
for(ll j=0;j<n;j++)
{
a[i][j] = s[j] - '0';
ll k = a[i][j];
mir[k] = min(mir[k], i);
mar[k] = max(mar[k], i);
mic[k] = min(mic[k], j);
mac[k] = max(mac[k], j);
}
}
for(ll i=0;i<n;i++)
{
for(ll j=0;j<n;j++)
{
ll k = a[i][j];
ans[k] = max({ans[k],
max(i - mir[k], mar[k] - i)*max(j, n - j - 1),
max(j - mic[k], mac[k] - j)*max(i, n - i - 1)});
}
}
show(ans);
}
return 0;
} | 1,700 | CPP |
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<bitset>
#include<cmath>
#include<cstdlib>
#include<ctime>
#include<deque>
#include<iomanip>
#include<list>
#include<map>
#include<deque>
#include<queue>
#include<set>
#include<stack>
#include<vector>
#include<string>
#include<chrono>
#include<random>
#include<unordered_map>
#include<ctype.h>
#include<cassert>
using namespace std;
typedef long long ll;typedef pair<ll,ll> pll; typedef pair<int, int> pii; typedef unsigned long long ull; typedef long double ld; typedef long double ldb; typedef vector<long long> vll; typedef vector<int> vi;
#define pb push_back
#define mp make_pair
#define fi first
#define se second
#define all(a) (a).begin(),(a).end()
const double Pi = acos(-1.0);
const ll N = 200001, modd = 1000000007; const int INF = 0x3f3f3f3;
ll n, m, a, b; vector<ll> s;
int main()
{
ios::sync_with_stdio(0); cin.tie(0), cout.tie(0);
ll ts; cin >> ts;
while(ts--)
{
s.clear();
cin >> n >> m >> a >> b;
ll max_drop = abs(b - a) - 1, t,ans=0;
if (a < b) t = a - 1 + max_drop;
else t = n - a + max_drop;
for (ll i = 0; i < m; i++)
{
ll tmp; cin >> tmp;
if (tmp > t)continue;
s.pb(tmp);
}
sort(all(s));reverse(all(s));
for (ll i = 0; i < s.size()&&max_drop; ++i)
if (t >= s[i])
{
ans++;
t--;
max_drop--;
}
cout << ans << '\n';
}
}
| 1,700 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct data {
int id, a;
data() {}
data(int id, int a) : id(id), a(a) {}
bool operator<(const data &r) const { return a < r.a; }
} da[100010];
int n, h;
int main() {
scanf("%d%d", &n, &h);
for (int i = 0; i < n; i++) scanf("%d", &da[i].a), da[i].id = i;
if (n == 2) {
printf("0\n");
for (int i = 0; i < n; i++) printf("1 ");
puts("");
return 0;
}
sort(da, da + n);
int f1 = da[n - 1].a + da[n - 2].a - da[0].a - da[1].a;
int f2 = max(da[n - 1].a + da[0].a + h, da[n - 1].a + da[n - 2].a) -
min(da[0].a + da[1].a + h, da[1].a + da[2].a);
if (f1 <= f2) {
printf("%d\n", f1);
for (int i = 0; i < n; i++) printf("1 ");
puts("");
} else {
printf("%d\n", f2);
for (int i = 0; i < n; i++)
if (da[0].id == i)
printf("1 ");
else
printf("2 ");
puts("");
}
return 0;
}
| 1,800 | CPP |
#include <bits/stdc++.h>
using namespace std;
bool found;
char s[5050], t[5050], ans[5050];
int cnt[300], len;
void solve(int idx) {
if (idx == len) {
return;
}
if (found) {
for (int i = ('a'), _n = ('z'); i <= _n; i++)
if (cnt[i]) {
cnt[i]--;
ans[idx] = i;
solve(idx + 1);
return;
}
} else {
for (int i = t[idx]; i <= 'z' && !found; i++)
if (cnt[i]) {
if (i > t[idx]) found = 1;
cnt[i]--;
ans[idx] = i;
solve(idx + 1);
cnt[i]++;
}
}
}
int main() {
scanf("%s %s", s, t);
len = strlen(s);
for (int i = 0, _n = (len); i < _n; i++) cnt[s[i]]++;
solve(0);
puts(found ? ans : "-1");
return 0;
}
| 1,900 | CPP |
s=input()
d=list(s.split('*'))
last=0;
po=[]
ki=[]
for i in range(len(d)):
po+=[last]
ki+=[len(d[i])+last]
last+=len(d[i])+1
ans=[eval(s)]
for a in po:
for b in ki:
if a>b-2: continue
x=s[:a]+'('+s[a:b]+')'+s[b:]
ans+=[eval(x)]
print(max(ans))
| 2,100 | PYTHON3 |
def solve(arr):
res = ""
i=0
while i<len(arr)-1:
if arr[i]==arr[i+1]:
res+=arr[i]
i+=1
else:
res+=arr[i]
i+=1
res+=arr[len(arr)-1]
return res
if __name__=="__main__":
test = int(input())
for i in range(test):
s = input()
print(solve(s)) | 800 | PYTHON3 |
n = int(input())
l = list(map(int, input().split()))
l.sort()
l1 = []
l2 = []
cur = l[0]
l1.append(cur)
while( True ):
if cur % 3 == 0 and cur // 3 in l:
cur //= 3
l1.append(cur)
elif cur * 2 in l:
cur *= 2
l1.append(cur)
else:
break
cur = l[0]
while( True ):
if cur % 2 == 0 and cur // 2 in l:
cur //= 2
l2.append(cur)
elif cur * 3 in l:
cur *= 3
l2.append(cur)
else:
break
for x in reversed(l2):
print(x, end=' ')
for x in l1:
print(x, end=' ')
| 1,400 | PYTHON3 |
#include<bits/stdc++.h>
#define ll long long int
using namespace std;
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll n,q,k,ans,l,r;
cin>>n>>q>>k;
vector<ll>a(n+2),b(n+2,0);
for(int i=1;i<=n;i++){
cin>>a[i];
}
a[0]=0,a[n+1]=k+1;
for(int i=1;i<=n;i++){
if(a[i]!=1){
b[i]=a[i]-a[i-1]-1;
}
if(a[i]!=k){
b[i]+=a[i+1]-a[i]-1;
}
b[i]+=b[i-1];
}
while(q--){
ans=0;
cin>>l>>r;
ans=b[r]-b[l-1];
ans+=a[l-1];
ans+=k-a[r+1]+1;
cout<<ans<<endl;
}
return 0;
}
| 1,200 | CPP |
#include <bits/stdc++.h>
char str1[] = {'X', '+', '+', '\0'};
char str2[] = {'+', '+', 'X', '\0'};
char str3[] = {'X', '-', '-', '\0'};
char str4[] = {'-', '-', 'X', '\0'};
int main() {
int n, count = 0, i, j;
char str[5];
scanf("%d", &n);
if (n >= 1 && n <= 150) {
for (i = 0; i < n; i++) {
scanf("%s", &str);
int a = strcmp(str1, str);
int b = strcmp(str2, str);
int c = strcmp(str3, str);
int d = strcmp(str4, str);
if (a == 0 || b == 0) {
count++;
} else if (c == 0 || d == 0) {
count--;
}
}
}
printf("%d\n", count);
return 0;
}
| 800 | CPP |
#include <bits/stdc++.h>
#define PI atan(1.0)*4
#define rp(i,s,t) for (register int i = (s); i <= (t); i++)
#define RP(i,t,s) for (register int i = (t); i >= (s); i--)
#define sc(x) scanf("%d",&x)
#define scl(x) scanf("%lld",&x)
#define ll long long
#define ull unsigned long long
#define mst(a,b) memset(a,b,sizeof(a))
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
#define pii pair<int,int>
#define pll pair<ll,ll>
#define pil pair<int,ll>
#define m_p make_pair
#define p_b push_back
#define ins insert
#define era erase
#define INF 0x3f3f3f3f
#define LINF 0x3f3f3f3f3f3f3f3f
#define dg if(debug)
#define outval(a) cout << "Debuging...|" << #a << ": " << a << "\n";
using namespace std;
int debug = 0;
ll gcd(ll a,ll b){
return b?gcd(b,a%b):a;
}
ll lcm(ll a,ll b){
return a/gcd(a,b)*b;
}
inline int read(){
int s=0,f=1;
char ch=getchar();
while(ch<'0'||ch>'9'){
if(ch=='-') f=-1;
ch=getchar();
}
while(ch>='0'&&ch<='9'){
s=s*10+ch-'0';
ch=getchar();
}
return s*f;
}
const int N = 1e6+7;
const double eps = 1e-7;
int a[N];
int f[N];
void solve(){
int n=read(),m=read();
rp(i,1,n) a[i]=read();
rp(i,1,n) f[i]=0;
RP(i,n,1){
if(a[i]!=i) break;
else f[i]=1;
}
int flag=1;
rp(i,1,n){
if(f[i]==0){
flag=0;
}
}
double ans=0.0;
double cur=1;
int ff=0;
rp(i,1,m){
int r;double p;
scanf("%d%lf",&r,&p);
// printf("%d %lf\n",r,p);
if(r==n||f[r+1]){
ans+=cur*p;
cur*=(1.0-p);
if(fabs(p-1.0)<=eps) ff=1;
}
}
if(ff||flag){
printf("1.000000\n");
return ;
}
printf("%.6f\n",ans);
}
int main(){
//ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
#ifdef ONLINE_JUDGE
#else
freopen("in.txt", "r", stdin);
//debug = 1;
#endif
time_t beg, end;
//if(debug) beg = clock();
int T=read();
while(T--) solve();
/*
if(debug) {
end = clock();
printf("time:%.2fs\n", 1.0 * (end - beg) / CLOCKS_PER_SEC);
}
*/
return 0;
} | 1,500 | CPP |
n=int(input())
s=input()
l=[]
for i in s:
l.append(i)
c=0
for i in range(0,n-1):
if((l[i]=='R' and l[i+1]=='R') or (l[i]=='B' and l[i+1]=='B') or (l[i]=='G' and l[i+1]=='G')):
c=c+1
print(c)
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int a, b;
int gcd(int a, int b) { return (b == 0) ? a : gcd(b, a % b); }
long long lcm(int a, int b) {
long long ret = a / gcd(a, b);
ret *= b;
return ret;
}
int main() {
scanf("%d %d", &a, &b);
long long lcms = lcm(a, b);
long long x = lcms / a;
long long y = lcms / b;
if (y < x) {
x--;
} else if (x <= y) {
y--;
}
if (x == y)
puts("Equal");
else if (x > y)
puts("Dasha");
else if (y > x)
puts("Masha");
return 0;
}
| 1,500 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int mai = 100010;
int dp[mai];
int temp[mai];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int t, k;
scanf("%d%d", &t, &k);
int flag = 0;
for (int z = 1; z <= t; z++) {
scanf("%d", &temp[z]);
if (temp[z] == k) flag = 1;
}
if (!flag) {
printf("no\n");
continue;
}
if (flag == 1 && t == 1) {
printf("yes\n");
continue;
}
flag = 0;
for (int z = 1; z < t; z++) {
if (temp[z] >= k) {
if (temp[z + 1] >= k || (temp[z + 2] >= k && z + 2 <= t)) {
flag = 1;
break;
}
}
}
if (k == 1) {
printf("yes\n");
continue;
}
if (flag == 1) {
printf("yes\n");
} else
printf("no\n");
}
}
| 2,000 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, num, count = 0;
cin >> n;
for (long long int i = 1; i < n; i++) {
for (long long int j = i + 1; j < n; j++) {
num = i ^ j;
if (num > j && num <= n && (i + j) > num) {
count++;
}
}
}
cout << count << endl;
}
| 1,300 | CPP |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,sse4.1,sse4.2,popcnt,abm,mmx,avx")
template <typename T1, typename T2>
inline bool chkmin(T1& x, const T2& y) {
if (x > y) {
x = y;
return 1;
}
return 0;
}
template <typename T1, typename T2>
inline bool chkmax(T1& x, const T2& y) {
if (x < y) {
x = y;
return 1;
}
return 0;
}
using namespace std;
const long long maxn = 2e5 + 20;
ostream& operator<<(ostream& out, vector<long long>& v) {
for (auto& x : v) out << x << ' ';
return out;
}
ostream& operator<<(ostream& out, pair<long long, long long>& v) {
out << v.first << ", " << v.second;
return out;
}
istream& operator>>(istream& in, pair<long long, long long>& a) {
in >> a.first >> a.second;
return in;
}
const long long inf = (long long)2e9;
const long double pi = asin(1) * 2;
const long double eps = 1e-8;
const long long mod = (long long)1e9 + 7;
const long long ns = 97;
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
long long dp[3], f[maxn];
long long mult(long long a, long long b) { return a * b % mod; }
long long add(long long a, long long b) {
long long c = a + b;
if (c >= mod) c -= mod;
if (c < 0) c += mod;
return c;
}
long long powmod(long long a, long long n) {
if (n == 0) return 1;
if (n % 2) return mult(a, powmod(a, n - 1));
long long b = powmod(a, n / 2);
return mult(b, b);
}
long long inv(long long a) { return powmod(a, mod - 2); }
long long kek(long long t) { return add(powmod(3, t), -powmod(2, t)); }
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
long long n;
cin >> n;
string s;
cin >> s;
long long ans = 1, t = 0;
for (long long i = (long long)s.size() - 1; i >= 0; --i) {
if (s[i] == 'c') {
dp[2] = add(dp[2], powmod(3, t));
} else if (s[i] == 'b') {
dp[1] = add(dp[1], dp[2]);
} else if (s[i] == 'a') {
dp[0] = add(dp[0], dp[1]);
} else {
dp[0] = add(add(dp[0], dp[0]), add(dp[0], dp[1]));
dp[1] = add(add(dp[1], dp[1]), add(dp[1], dp[2]));
dp[2] = add(add(dp[2], dp[2]), add(dp[2], powmod(3, t)));
++t;
}
for (auto& x : dp)
;
;
}
cout << dp[0] << '\n';
}
| 2,000 | CPP |
n, m = input().split(), input().split()
count = 0
for i in range(int(n[0])):
if int(m[i]) <= int(n[1]):
count += 1
else:
count += 2
print(count) | 800 | PYTHON3 |
# #include<bits/stdc++.h>
# using namespace std;
# #define ll long long
#
# void solve(){
# ll n,k;
# cin>>n>>k;
# ll arr[n];
# ll summ=0;
# for(int i=0;i<n;i++){
# cin>>arr[i];
# summ+=arr[i];
# }
# sort(arr,arr+n);
# stack<ll> s;
# for(int i=1;i<n;i++){
# s.push(arr[i]-arr[0]);
# }
# ll ct=0;
# ll minn=INT_MAX;
# while(!s.empty() && summ>k){
# minn=min(minn,ct+(summ-k+ct)/(ct+1));
# summ-=s.top();
# s.pop();
# ct++;
# }
# if(summ>k){
# ct+=(summ-k+ct)/(ct+1);
# }
# cout<<min(minn,ct)<<endl;
# }
# int main(){
# ll t=1;
# cin>>t;
# while(t--){
# solve();
# }
# }
for t in range(int(input())):
n,k = map(int,input().split())
arr = list(map(int,input().split()))
sm = sum(arr)
arr.sort()
stck = []
for i in range(1,n):
stck.append(arr[i]-arr[0])
ct = 0
mn = float('inf')
while stck and sm > k:
mn = min(mn,ct + (sm - k + ct)//(ct+1))
sm -= stck[-1]
stck.pop()
ct += 1
if sm > k:
ct += (sm - k + ct) // (ct+1)
print(min(mn,ct))
| 1,600 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, d, s;
cin >> n;
int** a = new int*[n];
for (int i = 0; i < n; i++) {
a[i] = new int[2];
for (int j = 0; j < 2; j++) cin >> a[i][j];
}
d = a[0][0];
for (int i = 1; i < n; i++) {
while (a[i][0] <= d) {
a[i][0] += a[i][1];
}
d = a[i][0];
}
cout << d;
return 0;
}
| 900 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int oo = 0x3f3f3f3f;
const long long ooo = 9223372036854775807ll;
const int _cnt = 1000 * 1000 + 7;
const int _p = 1000 * 1000 * 1000 + 7;
const int N = 100105;
const double PI = acos(-1.0);
const double eps = 1e-6;
int o(int x) { return x % _p; }
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int lcm(int a, int b) { return a / gcd(a, b) * b; }
void file_put() {
freopen("filename.in", "r", stdin);
freopen("filename.out", "w", stdout);
}
struct ttype {
int x, y;
ttype(int _x = 0, int _y = oo) { x = _x, y = _y; }
friend bool operator>(const ttype &p, const ttype &q) {
return p.x > q.x || p.x == q.x && p.y < q.y;
}
};
char st[N];
int a[2][N], b[2][N], c[N], n, m, op;
ttype dp[N], temp;
bool p[N];
int main() {
scanf("%d%s%d", &n, st + 1, &m);
a[0][0] = b[0][0] = a[1][0] = b[1][0] = c[0] = 0;
memset(p, 0, sizeof(p));
for (int i = (1); i <= (n); ++i)
if (i & 1) {
a[1][i] = a[1][i - 1] + (st[i] != 'b');
a[0][i] = a[0][i - 1];
b[1][i] = b[1][i - 1] + (st[i] != 'a');
b[0][i] = b[0][i - 1];
} else {
a[0][i] = a[0][i - 1] + (st[i] != 'b');
a[1][i] = a[1][i - 1];
b[0][i] = b[0][i - 1] + (st[i] != 'a');
b[1][i] = b[1][i - 1];
}
for (int i = (1); i <= (n); ++i) c[i] = c[i - 1] + (st[i] == '?');
for (int i = (m); i <= (n); ++i) {
op = ((i - m + 1) & 1), p[i] = 1;
p[i] &= (a[op][i] - a[op][i - m] == (m + 1) / 2);
p[i] &= (b[op ^ 1][i] - b[op ^ 1][i - m] == m / 2);
}
dp[0].y = 0;
for (int i = (1); i <= (n); ++i) {
if (i >= m && p[i])
dp[i] = ttype(dp[i - m].x + 1, dp[i - m].y + c[i] - c[i - m]);
dp[i] = ((dp[i]) > (dp[i - 1]) ? (dp[i]) : (dp[i - 1]));
}
printf("%d\n", dp[n].y);
return 0;
}
| 2,100 | CPP |
#include <bits/stdc++.h>
int main() {
int i, n, a, b, f = -1, s = -1, t = 5001;
double r;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &a);
if (a > f) f = a;
}
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &a);
if (a > s) s = a;
}
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &a);
if (a < t) t = a;
}
scanf("%d%d", &a, &b);
r = (double)f * sqrt((double)(s * b) / (t * a + s * b));
printf("%.12lf", r);
return 0;
}
| 1,300 | CPP |
from collections import deque
def solve():
n = int(input())
t = [int(a) for a in input()]
prawo = len(t)-1
kolejkaMnozen = deque([])
idx = 0
lMnozenia = 1
for i in range(n):
while idx >= len(t):
if len(kolejkaMnozen) == 0: # trzeba sie juz zatrzymac
exit(666)
if kolejkaMnozen[0] != 1:
t.extend((kolejkaMnozen[0]-1)*t[lMnozenia:])
lMnozenia += 1
kolejkaMnozen.popleft()
mnoznik = t[idx]
prawo = prawo*mnoznik
prawo -= 1
prawo %= 1000000007
kolejkaMnozen.append(t[idx])
idx+=1
return (n+prawo+1)%1000000007
n = int(input())
for i in range(n):
print(solve())
| 1,700 | PYTHON3 |
input()
l = map(int, input().split())
for el in l:
if el > 14 and 1 <= el % 14 <= 6:
print('YES')
else:
print('NO')
| 1,000 | PYTHON3 |
t=int(input())
for i in range(t):
n=int(input())
a=n//2
if a%2!=0:
print("NO")
else:
l=[0]*n
for j in range(1,n//2+1):
l[j-1]=j*2
for k in range(n//2+1,n):
l[k-1]=2*(k-n//2)-1
b=a//2
b=b+1
l[n-1]=l[-2]+b*2
print("YES")
for x in l:
print(x,end=" ")
print() | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void Read(T &x) {
char c = getchar();
bool f = false;
for (x = 0; !isdigit(c); c = getchar()) {
if (c == '-') {
f = true;
}
}
for (; isdigit(c); c = getchar()) {
x = x * 10 + c - '0';
}
if (f) {
x = -x;
}
}
template <typename T>
inline bool CheckMax(T &a, const T &b) {
return a < b ? a = b, true : false;
}
template <typename T>
inline bool CheckMin(T &a, const T &b) {
return a > b ? a = b, true : false;
}
const int N = 5005;
vector<int> p[N];
int n, ans, c[N];
char s[N << 1];
int main() {
scanf("%s", s), n = strlen(s);
for (int i = 0; i < n; ++i) {
p[s[i] - 'a'].push_back(i), s[i + n] = s[i];
}
for (int i = 0; i < 26; ++i) {
int val = 0;
for (int j = 0; j < n; ++j) {
int ret = 0;
for (int k = 0; k < 26; ++k) {
c[k] = 0;
}
for (auto x : p[i]) {
++c[s[j + x] - 'a'];
}
for (int k = 0; k < 26; ++k) {
if (c[k] == 1) {
++ret;
}
}
CheckMax(val, ret);
}
ans += val;
}
printf("%lf\n", (double)ans / n);
return 0;
}
| 1,600 | CPP |
a, b, c = sorted(map(int, input().split()))
n = a + b - c - 1
if n < 0:
print(abs(n))
else:
print(0)
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int q;
cin >> q;
for (int d = 0; d < q; d++) {
string s, t;
cin >> s >> t;
int n = s.size();
int m = t.size();
n = n % 2;
m = m % 2;
int y = abs(n - m);
int j = 0;
for (int i = y; i < s.size(); i++) {
if (s[i] == t[j]) {
j++;
} else {
i++;
}
if (j == t.size()) {
break;
}
}
if (j == t.size()) {
cout << "YES" << '\n';
;
} else {
cout << "NO" << '\n';
;
}
}
}
| 1,500 | CPP |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
int n;
cin >> n;
cout << "0 0 " << n << endl;
return 0;
}
| 900 | CPP |
#include <bits/stdc++.h>
using namespace std;
bool sieve[1006];
void primeTable() {
int i, j;
int lim = sqrt((double)1006) + 2;
for (i = 4; i < 1006; i += 2) sieve[i] = true;
for (i = 3; i < lim; i += 2) {
if (!sieve[i]) {
for (j = i * i; j <= 1006; j += (i << 1)) sieve[j] = true;
}
}
}
char str[1006];
int freq[26];
int main() {
primeTable();
int N, p, i, s, c;
while (scanf("%s", str) != EOF) {
memset(freq, 0, sizeof(freq));
for (N = 0; str[N]; ++N) ++freq[str[N] - 'a'];
if (N <= 3) {
puts("YES");
puts(str);
continue;
}
p = 1;
for (i = N / 2 + 1; i <= N; ++i) {
if (!sieve[i]) ++p;
}
s = N - p;
for (i = 0; i < 26; ++i) {
if (freq[i] >= s) break;
}
if (i == 26) {
puts("NO");
continue;
}
puts("YES");
memset(str, 0, sizeof(str));
c = i;
for (i = 2; i <= N; ++i) {
if (sieve[i]) {
str[i] = c + 'a';
--freq[c];
}
}
for (i = 2; i <= N / 2; ++i) {
if (!str[i]) {
str[i] = c + 'a';
--freq[c];
}
}
c = 0;
for (i = N / 2 + 1; i <= N; ++i) {
while (freq[c] == 0) ++c;
if (!str[i]) {
str[i] = c + 'a';
--freq[c];
}
}
while (freq[c] == 0) ++c;
str[1] = c + 'a';
puts(&str[1]);
}
return 0;
}
| 1,300 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
const int mod = 1e9 + 7;
int a[maxn], v[maxn];
vector<int> p;
int b[80];
int ct;
void insert_basis(int x) {
if (x == 0) return;
int msb = 31 - __builtin_clz(x);
if (b[msb] == 0)
b[msb] = x, ct++;
else
insert_basis(b[msb] ^ x);
}
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 2; i <= 70; i++) {
bool primo = true;
for (int j = 2; j * j <= i; j++) {
if (i % j == 0) {
primo = false;
break;
}
}
if (!primo) continue;
for (int j = 1; j <= n; j++) {
if (a[j] % i == 0) {
p.push_back(i);
break;
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = (int)p.size() - 1; j >= 0; j--) {
int x = a[i];
while (x % p[j] == 0) v[i] ^= (1 << j), x /= p[j];
}
insert_basis(v[i]);
}
long long pot = 1;
for (int i = 1; i <= (n - ct); i++) {
pot *= 2;
pot %= mod;
}
int resp = (pot - 1 + mod) % mod;
cout << resp << "\n";
return 0;
}
| 2,000 | CPP |
input()
r=t=0
a=11**11
for x in map(int,input().split()):
if x<a:
t=0
t+=1
r=max(r,t)
a=x
print(r) | 900 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int t, n;
struct People {
int m;
long long p;
bool operator>(const People a) const { return p < a.p; }
bool operator<(const People a) const { return p > a.p; }
} s[200005];
vector<long long> v[200005];
priority_queue<long long, vector<long long>, greater<long long> > q;
bool cmp(People a, People b) {
if (a.m != b.m) return a.m > b.m;
return a.p < b.p;
}
int main() {
cin >> t;
while (t--) {
cin >> n;
for (int i = 0; i < n; ++i) v[i].clear();
for (int i = 1; i <= n; ++i) {
cin >> s[i].m >> s[i].p;
v[s[i].m].push_back(s[i].p);
}
int cnt = 0, tmp = n;
long long ans = 0;
while (q.size()) q.pop();
for (int i = n - 1; i >= 0; --i) {
tmp -= v[i].size();
for (int j = 0; j < (signed)v[i].size(); ++j) {
q.push(v[i][j]);
}
while (cnt + tmp < i) {
ans += q.top();
q.pop();
++cnt;
}
}
printf("%lld\n", ans);
}
return 0;
}
| 2,300 | CPP |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
int arr[n];
set<int> s;
for (int i = 0; i < n; i++) {
cin >> arr[i];
s.insert(arr[i]);
}
for (int i = 1; i < 1024; i++) {
set<int> t;
for (auto x : s) {
t.insert(x ^ i);
}
if (t == s) {
cout << i << "\n";
return;
}
}
cout << -1 << "\n";
}
int main() {
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 1,200 | CPP |
n=int(input())
for i in range(n):
q=int(input())
a=list(map(int,input().split()))
a.sort()
j=0
a=list(set(a))
a.sort()
q=len(a)
while(q!=1 and j<=q-2):
if abs(a[j+1]-a[j])==1:
a.remove(a[j])
else:
j=j+1
q=len(a)
if(len(a)==1):print("YES")
else: print("NO") | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long double pi = 3.1415926535897932384626433832795l;
template <typename T>
inline auto sqr(T x) -> decltype(x * x) {
return x * x;
}
template <typename T>
inline T abs(T x) {
return x > T() ? x : -x;
}
template <typename T1, typename T2>
inline bool umx(T1& a, T2 b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <typename T1, typename T2>
inline bool umn(T1& a, T2 b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
const int N = 1000100;
struct Input {
int n, c;
int tp[N];
int a[N], b[N];
bool read() {
if (scanf("%d %d", &n, &c) != 2) return 0;
for (int i = int(0); i < int(c); ++i) {
scanf("%d %d ", &a[i], &b[i]);
a[i]--, b[i]--;
char c1;
scanf("%c", &c1);
tp[i] = (c1 == 'R');
string qwe;
getline(cin, qwe);
}
return 1;
}
void init(const Input& input) { *this = input; }
};
struct Data : Input {
vector<int> ans;
bool ok;
void write() {
if (ok) {
for (int i = int(0); i < int(ans.size()); ++i) {
printf("%d ", ans[i] + 1);
}
} else {
puts("IMPOSSIBLE");
}
}
virtual void solve() {}
virtual void clear() { *this = Data(); }
};
struct Solution : Data {
int l[N], r[N];
int cnt;
int tol[N], tor[N];
vector<int> left[N], right[N];
void dfs(int v, int mn, bool only) {
if (l[v] > v && cnt < n) {
cnt++;
tol[v] = cnt - 1;
dfs(cnt - 1, l[v], 0);
}
ans.push_back(v);
umx(mn, r[v]);
if (mn > cnt - 1 || (only && cnt < n)) {
cnt++;
tor[v] = cnt - 1;
dfs(cnt - 1, mn, only);
}
}
bool use[N];
void dfs(int v) {
use[v] = 1;
;
for (int i = int(0); i < int(left[v].size()); ++i) {
int to = left[v][i];
if (use[to]) {
ok = 0;
}
}
if (tol[v] >= 0) {
dfs(tol[v]);
}
for (int i = int(0); i < int(left[v].size()); ++i) {
int to = left[v][i];
if (!use[to]) {
ok = 0;
}
}
for (int i = int(0); i < int(right[v].size()); ++i) {
int to = right[v][i];
if (use[to]) {
ok = 0;
}
};
if (tor[v] >= 0) {
dfs(tor[v]);
}
for (int i = int(0); i < int(right[v].size()); ++i) {
int to = right[v][i];
if (!use[to]) {
ok = 0;
}
};
}
void solve() {
memset(l, -1, sizeof(l));
memset(r, -1, sizeof(r));
memset(tol, -1, sizeof(tol));
memset(tor, -1, sizeof(tor));
for (int i = int(0); i < int(c); ++i) {
if (a[i] > b[i]) {
ok = 0;
return;
}
if (tp[i]) {
umx(r[a[i]], b[i]);
} else {
umx(l[a[i]], b[i]);
}
}
cnt = 1;
dfs(0, -1, 1);
ok = 1;
for (int i = int(0); i < int(c); ++i) {
if (tp[i] == 0)
left[a[i]].push_back(b[i]);
else
right[a[i]].push_back(b[i]);
}
dfs(0);
}
void clear() { *this = Solution(); }
};
Solution sol;
int main() {
cout.setf(ios::showpoint | ios::fixed);
cout.precision(20);
sol.read();
sol.solve();
sol.write();
return 0;
}
| 2,400 | CPP |
s=input() #input string in the first line
n,k,x=s.split()
n=int(n)
k=int(k)
x=int(x)
s=input()
A=s.split()
A= list(map(int, A))
l=len(A)
t=0 # minimum time taken
while(k>0):
t=t+x
k=k-1
A[l-1]=0
l=l-1
while(l>0):
t=t+A[l-1]
l=l-1
print(t) | 800 | PYTHON3 |
import sys
import math
import re
from functools import reduce
n = int(input())
for _ in range(n):
n, s, t = map(int, sys.stdin.readline().split())
if s == t and s == n:
print(1)
elif s == t:
print(n - s + 1)
else:
print(n - min(s, t) + 1)
| 900 | PYTHON3 |
test_cases = int(input())
for i in range(test_cases):
x = input()
times = int(x[-1]) - 1
s1 = 10 * times
n2 = len(x)
s2 = n2 * (n2 + 1) // 2
print(s1 + s2) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
namespace io {
template <typename First, typename Second>
ostream &operator<<(ostream &os, const pair<First, Second> &p) {
return os << p.first << " " << p.second;
}
template <typename First, typename Second>
ostream &operator<<(ostream &os, const map<First, Second> &mp) {
for (auto it : mp) {
os << it << endl;
}
return os;
}
template <typename First>
ostream &operator<<(ostream &os, const vector<First> &v) {
bool space = false;
for (First x : v) {
if (space) os << " ";
space = true;
os << x;
}
return os;
}
template <typename First>
ostream &operator<<(ostream &os, const set<First> &st) {
bool space = false;
for (First x : st) {
if (space) os << " ";
space = true;
os << x;
}
return os;
}
template <typename First>
ostream &operator<<(ostream &os, const multiset<First> &st) {
bool space = false;
for (First x : st) {
if (space) os << " ";
space = true;
os << x;
}
return os;
}
template <typename First, typename Second>
istream &operator>>(istream &is, pair<First, Second> &p) {
return is >> p.first >> p.second;
}
template <typename First>
istream &operator>>(istream &is, vector<First> &v) {
for (First &x : v) {
is >> x;
}
return is;
}
long long fastread() {
char c;
long long d = 1, x = 0;
do c = getchar();
while (c == ' ' || c == '\n');
if (c == '-') c = getchar(), d = -1;
while (isdigit(c)) {
x = x * 10 + c - '0';
c = getchar();
}
return d * x;
}
static bool sep = false;
using std::to_string;
string to_string(bool x) { return (x ? "true" : "false"); }
string to_string(const string &s) { return "\"" + s + "\""; }
string to_string(const char *s) { return "\"" + string(s) + "\""; }
string to_string(const char &c) {
string s;
s += c;
return "\'" + s + "\'";
}
template <typename First, typename Second>
string to_string(pair<First, Second> p) {
return "{" + to_string(p.first) + ", " + to_string(p.second) + "}";
}
template <typename Type>
string to_string(vector<Type> v) {
bool sep = false;
string s = "[";
for (Type x : v) {
if (sep) s += ", ";
sep = true;
s += to_string(x);
}
s += "]";
return s;
}
template <typename Collection>
string to_string(Collection collection) {
bool sep = false;
string s = "{";
for (auto x : collection) {
if (sep) s += ", ";
sep = true;
s += to_string(x);
}
s += "}";
return s;
}
void print() {
cerr << endl;
sep = false;
}
template <typename First, typename... Other>
void print(First first, Other... other) {
if (sep) cerr << " | ";
sep = true;
cerr << to_string(first);
print(other...);
}
} // namespace io
using namespace io;
const long long INF = (long long)1e9 + 10;
const long long MAXN = (long long)1e6 + 10;
long long cnt[MAXN * 10 + 10], a[MAXN];
long long f(long long m, long long k, long long n) {
if (m <= 0) return 0;
for (long long i = 1; i <= n; i++) {
cnt[a[i]]++;
}
long long ret = 0;
for (long long i = 10 * MAXN; i >= m; i--) {
if (i / 2 >= m) {
cnt[i / 2] += cnt[i];
cnt[(i + 1) / 2] += cnt[i];
} else {
ret += cnt[i];
if (ret >= k) return 1;
}
}
return 0;
}
void solution(istream &cin, ostream &cout, const long long &test_case) {
long long n, k;
cin >> n >> k;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
}
long long l = -1, r = MAXN * 10;
while (r - l > 1) {
long long m = (l + r) >> 1;
if (f(m, k, n)) {
l = m;
} else {
r = m;
}
fill(cnt, cnt + MAXN * 10, 0);
}
cout << l << endl;
}
int32_t main() {
ios::sync_with_stdio(0);
long long t = 1;
for (long long i = 1; i <= t; i++) solution(cin, cout, i);
}
| 2,100 | CPP |
n, m = map(int, input().split())
print(pow((pow(2, m, 1000000007) - 1) % 1000000007, n, 1000000007)) | 1,500 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long P = 1e9 + 7;
long long n, ans;
long long a[200009];
long long pr[1000009];
long long s[1000009];
long long c[1000009];
int main() {
pr[0] = 1;
for (long long i = 1; i <= 1000000; i++) pr[i] = (pr[i - 1] * 2) % P;
scanf("%lld", &n);
for (long long i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
long long k = a[i];
long long p = sqrt(k);
for (long long j = 1; j <= p; j++) {
if (k % j == 0) {
s[j]++;
if (j * j != k) s[k / j]++;
}
}
}
for (long long i = 1000000; i > 1; i--) {
if (!s[i]) continue;
long long an = (s[i] * pr[s[i] - 1] - c[i] + P) % P;
ans = (ans + an * i) % P;
long long k = i;
long long p = sqrt(k);
for (long long j = 2; j <= p; j++) {
if (k % j == 0) {
c[j] = (c[j] + an) % P;
if (j * j != k) {
c[k / j] = (c[k / j] + an) % P;
}
}
}
}
printf("%lld\n", ans);
return 0;
}
| 2,200 | CPP |
for i in range(int(input())):
n=int(input())
arr=list(map(int,input().split()))
arr.sort()
l1=[]
if(n%2==0):
j=(n//2)-1
while(j>-1):
l1.append(arr[j])
l1.append(arr[n-1-j])
j-=1
else:
l1.append(arr[n//2])
j=(n//2)-1
while(j>-1):
l1.append(arr[j])
l1.append(arr[n-1-j])
j-=1
for j in range(n):
print(l1[j],end=" ")
print()
| 1,200 | PYTHON3 |
m=input()
length=len(m)
flag=int(0)
for i in range(0,length-4):
if(m[i]==m[i+1]):
a=int(i+2)
jsj=int(2)
while(m[i]==m[a]):
jsj=jsj+1
if(jsj==7):
flag=1
break
if(a>=length-1):
break
a=a+1
if(flag==1):
break
if(flag==1):
print('YES')
else:
print('NO')
| 900 | PYTHON3 |
"""
T = int(input())
for t in range(T):
line = "Case #" + str(t+1) + ": "
"""
from functools import cmp_to_key
t = int(input())
for _ in range(t):
n = int(input())
a = list(map(int, input().split()))
for i in range(len(a)-2,-1,-1):
a[i] += a[i+1]
print(max(a))
| 1,000 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::system_clock::now().time_since_epoch().count());
template <class T = int>
T __rand(T range = numeric_limits<T>::max()) {
return (T)(rng() % range);
}
template <class T>
ostream& operator,(ostream& out, const T& thing) {
return out << ", " << thing;
}
template <class U, class V>
ostream& operator<<(ostream& out, const pair<U, V>& p) {
return (out << "(" << p.first, p.second) << ")";
}
template <class A, class B>
ostream& operator<<(ostream& out, const tuple<A, B>& t) {
return (out << "(" << get<0>(t), get<1>(t)) << ")";
}
template <class A, class B, class C>
ostream& operator<<(ostream& out, const tuple<A, B, C>& t) {
return (out << "(" << get<0>(t), get<1>(t), get<2>(t)) << ")";
}
template <class T>
ostream& operator<<(ostream& out, const vector<T>& container) {
out << "{";
if (((int)container.size())) out << container[0];
for (int i = 0; i++ < ((int)container.size()) - 1;) out, container[i];
return out << "}";
}
template <class x>
vector<typename x::value_type> $v(const x& a) {
return vector<typename x::value_type>(a.begin(), a.end());
}
template <class u>
vector<typename iterator_traits<u>::value_type> $v(u a, u b) {
return vector<typename iterator_traits<u>::value_type>(a, b);
}
int main(void) {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int ntest;
cin >> ntest;
while (ntest--) {
string s;
cin >> s;
int cur_depth = 0;
long long ans = ((int)s.size());
for (int i = -1; ++i < ((int)s.size());) {
cur_depth += (s[i] == '-' ? -1 : 1);
if (cur_depth < 0) {
ans += i + 1;
cur_depth++;
}
}
cout << ans << '\n';
}
return 0;
}
| 1,300 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 5000 + 100;
const int M = 30;
int n;
string s;
string t;
int mat[M][M][N];
int ones[N];
int ans;
long double javab;
set<char> g;
bool mark[30];
int chand[30];
bool oomade[30];
int main() {
cin >> s;
n = s.size();
for (int i = 0; i < n; i++) {
g.insert(s[i]);
chand[s[i] - 'a']++;
oomade[s[i] - 'a'] = 1;
}
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n + i; j++) {
int y = j % n;
int f = (int)s[i] - (int)'a';
int l = (int)s[y] - (int)'a';
mat[f][l][j - i]++;
}
}
for (int i = 0; i < 26; i++) {
if (oomade[i] == 1) {
for (int j = 0; j < n; j++) {
int tmp = 0;
for (int k = 0; k < 26; k++) {
if (mat[i][k][j] == 1) {
tmp++;
}
}
ones[i] = max(ones[i], tmp);
}
ans += ones[i];
}
}
javab = (long double)ans / (n);
cout << fixed << setprecision(10) << javab;
}
| 1,600 | CPP |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll mod;
const int maxsize = 60;
int calsize;
struct matrix {
ll m[maxsize][maxsize];
matrix() {
for (int i = 0; i < calsize; i++) {
for (int j = 0; j < calsize; j++) {
m[i][j] = 0;
}
}
}
};
matrix operator*(const matrix &a, const matrix &b) {
matrix ret;
for (int i = 0; i < calsize; i++) {
for (int j = 0; j < calsize; j++) {
for (int k = 0; k < calsize; k++) {
if (a.m[i][k] && b.m[k][j]) {
ret.m[i][j] = (ret.m[i][j] % mod + a.m[i][k] * b.m[k][j] % mod) % mod;
if (ret.m[i][j] < 0) ret.m[i][j] = (ret.m[i][j] + mod) % mod;
}
}
}
}
return ret;
}
matrix quick(matrix base, ll pow) {
matrix ret = base;
pow--;
while (pow) {
if (pow & 1) ret = ret * base;
base = base * base;
pow >>= 1;
}
return ret;
}
int main() {
matrix ori, tool;
ll n, x, y, dx, dy, t;
scanf("%lld%lld%lld%lld%lld%lld", &n, &x, &y, &dx, &dy, &t);
if (t == 0)
printf("%lld %lld\n", x, y);
else {
calsize = 6;
mod = n;
memset(tool.m, 0, sizeof(tool.m));
;
memset(ori.m, 0, sizeof(ori.m));
;
tool.m[0][0] = tool.m[0][5] = 2,
tool.m[0][1] = tool.m[0][2] = tool.m[0][4] = 1;
tool.m[1][0] = tool.m[1][3] = tool.m[1][4] = 1;
tool.m[1][1] = tool.m[1][5] = 2;
tool.m[2][0] = tool.m[2][1] = tool.m[2][2] = tool.m[2][4] = 1;
tool.m[2][5] = 2;
tool.m[3][0] = tool.m[3][1] = tool.m[3][3] = tool.m[3][4] = 1;
tool.m[3][5] = 2;
tool.m[4][4] = tool.m[4][5] = tool.m[5][5] = 1;
tool = quick(tool, t);
ori.m[0][0] = x - 1;
ori.m[1][0] = y - 1;
ori.m[2][0] = dx;
ori.m[3][0] = dy;
ori.m[4][0] = 0;
ori.m[5][0] = 1;
ori = tool * ori;
cout << ori.m[0][0] + 1 << " " << ori.m[1][0] + 1 << endl;
}
return 0;
}
| 2,300 | CPP |
from collections import Counter,defaultdict,deque
#alph = 'abcdefghijklmnopqrstuvwxyz'
#from math import factorial as fact
#import math
#tt = 1#int(input())
#total=0
#n = int(input())
#n,m,k = [int(x) for x in input().split()]
#n = int(input())
#n,m = [int(x) for x in input().split()]
t = int(input())
for i in range(t):
a,b,c = [int(x) for x in input().split()]
print((a+b+c)//2)
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
int n;
vector<long long> a;
while (t > 0) {
cin >> n;
int tmp;
long long maxN;
for (int i = 0; i < n; i++) {
cin >> tmp;
a.push_back(tmp);
}
if (n == 1) {
cout << tmp << endl;
t--;
a.clear();
continue;
}
sort(a.begin(), a.end());
maxN = a[0];
for (int i = 1; i < n; i++) {
maxN = max(maxN, a[i] - a[i - 1]);
}
cout << maxN << endl;
a.clear();
t--;
}
return 0;
}
| 1,000 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, y, z;
cin >> x >> y >> z;
int res = 0;
res += min(x, y);
res += min(z, x + y);
res += min(z + min(x, y), max(x, y));
cout << res << endl;
return 0;
}
| 800 | CPP |
#include <bits/stdc++.h>
using namespace std;
void setIO(string str) {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
freopen((str + ".in").c_str(), "r", stdin);
freopen((str + ".out").c_str(), "w", stdout);
}
const long long MAX = 3e5 + 5;
const long long MOD = 1e9 + 7;
const long long INF = 1e9 + 5;
int t = 1;
int n;
int cnt = 0;
int typ[MAX];
vector<int> con[MAX];
int dfs(int pos) {
if (!con[pos].size()) return 0;
int num = 0;
if (typ[pos] == 1) num = cnt;
if (typ[pos] == 0) num = con[pos].size() - 1;
for (int adj : con[pos]) {
if (typ[pos] == 1) num = min(num, dfs(adj));
if (typ[pos] == 0) num = num + dfs(adj);
}
return num;
}
void slv() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> typ[i];
int inp;
for (int i = 2; i <= n; i++) cin >> inp, con[inp].push_back(i);
for (int i = 1; i <= n; i++)
if (!con[i].size()) cnt++;
int ans = cnt - dfs(1);
cout << ans << "\n";
}
int main() {
while (t--) slv();
return 0;
}
| 1,900 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long max(long long a, long long b) { return a > b ? a : b; }
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return a * b / gcd(a, b); }
void dfs(const vector<int>& f, vector<pair<int, int> >& d, vector<int>& v,
int i, int h = 0) {
if (v[i] >= 0) {
d.push_back(pair<int, int>(v[i], h - v[i]));
return;
}
v[i] = h;
dfs(f, d, v, f[i], h + 1);
}
int main() {
int n;
scanf("%d", &n);
vector<int> f(n + 1);
vector<pair<int, int> > d;
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
f[i] = x;
}
for (int i = 1; i <= n; i++) {
vector<int> v(n + 1, -1);
dfs(f, d, v, i);
}
long long ans = 0, cyc = 1;
for (int i = 0; i < n; i++) {
ans = max(ans, d[i].first);
cyc = lcm(cyc, d[i].second);
}
if (ans % cyc != 0) ans = (ans / cyc + 1) * cyc;
ans = max(ans, cyc);
printf("%I64d\n", ans);
}
| 2,000 | CPP |
M = 2 * 3 * 5 * 7
v = [0] * M
for i in range(1, M):
v[i] = v[i - 1] + bool(i % 2 and i % 3 and i % 5 and i % 7)
n = int(input())
print(n // M * v[-1] + v[n % M]) | 1,500 | PYTHON3 |
t = int(input())
while t:
t -= 1
n = int(input())
a = []
for _ in range(n):
a.append(input())
for d in range(10):
minrow, maxrow, ans = 20000, 0, 0
mincol, maxcol = 20000, 0
for i in range(n):
for j in range(n):
if a[i][j] == str(d):
minrow = min(minrow, i+1)
maxrow = max(maxrow, i+1)
mincol = min(mincol, j+1)
maxcol = max(maxcol, j+1)
# print(maxrow, maxcol, minrow, mincol)
for i in range(n):
for j in range(n):
if a[i][j] == str(d):
hb, hh = max(j, n-j-1), max(maxrow-i-1, i-minrow+1)
vb, vh = max(i, n-i-1), max(maxcol-j-1, j-mincol+1)
# print(hb, hh, vb, vh, i-mincol+1)
ans = max(ans, hb*hh, vb*vh)
print(ans, end=' ')
print()
| 1,700 | PYTHON3 |
n=int(input())
str=input()
count=0
i=0
while i<=n-2:
if str[i]=='U' and str[i+1]=='R' or str[i]=='R' and str[i+1]=='U':
count+=1
i+=1
i+=1
print(n-count) | 800 | PYTHON3 |
n = int(input())
ans = 0
while(n>0):
n = n//2
ans+=1
print(ans) | 1,300 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
inline int gcd(int a, int b) {
while (b != 0) {
int c = a;
a = b;
b = c % b;
}
return a;
}
inline void normalize(int& x, int& y) {
int g = gcd(x, y);
x /= g;
y /= g;
}
const int MAXN = 1e6 + 42;
unordered_map<int, int> lines[MAXN];
inline void update_(vector<pair<int, int>>& bucket) {
int sx = bucket.back().first, sy = bucket.back().second;
for (auto u : bucket) {
int x = u.first, y = u.second;
int mx = sx + x, my = sy + y;
normalize(mx, my);
lines[mx][my] += 2;
}
normalize(sx, sy);
--lines[sx][sy];
}
inline void delete_(vector<pair<int, int>>& bucket, int x, int y) {
for (auto u : bucket) {
int sx = u.first, sy = u.second;
int mx = sx + x, my = sy + y;
normalize(mx, my);
lines[mx][my] -= 2;
}
for (int i = 0; i < bucket.size(); ++i) {
if (bucket[i] == make_pair(x, y)) {
swap(bucket[i], bucket.back());
bucket.pop_back();
break;
}
}
normalize(x, y);
++lines[x][y];
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int ctr = 0;
unordered_map<long long, vector<pair<int, int>>> bucket;
int q;
scanf("%d", &q);
while (q--) {
int type, x, y;
scanf("%d%d%d", &type, &x, &y);
long long gg = 1LL * x * x + 1LL * y * y;
if (type == 1) {
bucket[gg].push_back({x, y});
update_(bucket[gg]);
++ctr;
} else if (type == 2) {
delete_(bucket[gg], x, y);
--ctr;
} else {
normalize(x, y);
printf("%d\n", ctr - lines[x][y]);
}
}
}
| 2,900 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 500005;
int n, a[N], an[N];
int sta[N], top, b1[N], b2[N];
long long ans, sum1[N], sum2[N];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
sta[++top] = 1;
sum1[1] = a[1];
b1[1] = a[1];
sta[0] = 0;
for (int i = 2; i <= n; i++) {
while (top > 0 && a[i] <= a[sta[top]]) top--;
sta[++top] = i;
b1[i] = a[sta[top]];
sum1[i] =
sum1[sta[top - 1]] + 1ll * a[sta[top]] * (sta[top] - sta[top - 1]);
}
top = 0;
sta[++top] = n;
sum2[n] = a[n];
b2[n] = a[n];
sta[0] = n + 1;
for (int i = n - 1; i >= 1; i--) {
while (top > 0 && a[i] <= a[sta[top]]) top--;
sta[++top] = i;
b2[i] = a[sta[top]];
sum2[i] =
sum2[sta[top - 1]] + 1ll * a[sta[top]] * (sta[top - 1] - sta[top]);
}
int f = -1;
for (int i = 0; i <= n; i++) {
if (ans < sum1[i] + sum2[i + 1]) {
ans = sum1[i] + sum2[i + 1];
f = i;
}
}
int lim = b1[f];
for (int i = f; i >= 1; i--) {
lim = min(lim, a[i]);
an[i] = lim;
}
lim = b2[f + 1];
for (int i = f + 1; i <= n; i++) {
lim = min(lim, a[i]);
an[i] = lim;
}
for (int i = 1; i <= n; i++) printf("%d ", an[i]);
return 0;
}
| 1,500 | CPP |
#include <bits/stdc++.h>
using namespace std;
int gi() {
int a;
scanf("%d", &a);
return a;
}
long long gli() {
long long a;
scanf("%I64d", &a);
return a;
}
long long gcd(long long a, long long b) {
if (a == 0) return b;
if (b == 0) return a;
if (a > b) return gcd(a % b, b);
return gcd(b % a, a);
}
int pr[1000000];
int main() {
unordered_map<long long, vector<pair<long long, long long> > > m;
unordered_map<long long, vector<pair<long long, long long> > >::iterator it;
int n = gi();
for (int i = 0; i < n; i++) {
long long x = gli();
long long y = gli();
long long c = gli();
m[x].push_back(make_pair(y, c));
}
vector<pair<long long, long long> > main;
int L = 0;
long long gg = 0;
int first = 1;
for (it = m.begin(); it != m.end(); it++) {
vector<pair<long long, long long> > &v = it->second;
sort(v.begin(), v.end());
if (first) {
first = 0;
L = v.size();
long long g = 0;
for (int i = 0; i < L; i++) g = gcd(g, v[i].second);
for (int i = 0; i < L; i++)
main.push_back(make_pair(v[i].first, v[i].second / g));
} else {
if (int(v.size()) != L || v[0].first != main[0].first ||
v[0].second % main[0].second != 0) {
printf("0\n");
return 0;
}
long long f = v[0].second / main[0].second;
for (int i = 1; i < L; i++)
if (v[i].first != main[i].first || v[i].second % main[i].second != 0 ||
v[i].second / main[i].second != f) {
printf("0\n");
return 0;
}
}
gg = gcd(gg, v[0].second);
}
m.clear();
long long g = 0;
for (int i = 0; i < L; i++) g = gcd(g, main[i].second);
g *= gg / main[0].second;
memset(pr, -1, sizeof(pr));
long long r = 1;
long long c = 1;
while (g % 2 == 0) {
c++;
g /= 2;
}
r *= c;
for (int i = 3; i < 1000000; i += 2)
if (pr[i]) {
for (int j = i * 3; j < 1000000; j += i * 2) pr[i] = 0;
long long c = 1;
while (g % i == 0) {
c++;
g /= i;
}
r *= c;
}
if (g > 1LL) r *= 2;
cout << r << endl;
return 0;
}
| 2,600 | CPP |
n = int(input())
t = [0] * n
t1 = -1
t2 = -1
ff = True
for i in range(n):
a, b = map(int, input().split())
t[i] = (a, b)
t.sort()
for i in range(n):
bl = False
if t[i][0] > t1:
t1 = t[i][1]
bl = True
if not bl and t[i][0] > t2:
t2 = t[i][1]
bl = True
if not bl:
ff = False
break
if ff:
print("YES")
else:
print("NO")
| 1,500 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
vector<int>v(200000);
int f(int i, int j, int k) {
if(v[i]>=v[j] && v[j]>=v[k]) return 1;
if(v[i]<=v[j] && v[j]<=v[k]) return 1;
return 0;
}
int main() {
int t;
cin>>t;
while(t--) {
int n;
cin>>n;
for(int i=0; i<n; ++i) cin>>v[i];
int cnt=n+n-1;
for(int i=2; i<n; ++i) {
if(f(i, i-1, i-2)) continue;
++cnt;
}
for(int i=3; i<n; ++i) {
if(f(i, i-1, i-2)) continue;
if(f(i, i-1, i-3)) continue;
if(f(i, i-2, i-3)) continue;
if(f(i-1, i-2, i-3)) continue;
++cnt;
}
cout<<cnt<<endl;
}
} | 1,700 | CPP |
n = int(input())
i=0
num = list()
while i < 2:
num.append(input())
i+=1
arr = []
for i in num:
count = None
for j in range(0,len(i)):
if i[j] == ' ':
if count == None:
count = j + 1
else :
arr.append(int(i[count:j]))
count = j + 1
elif j == len(i)-1:
arr.append(int(i[count:len(i)]))
check = [False]*(n+1)
counting=0
for i in range(0,len(arr)):
#when zero value it is a special case
if arr[i]==0:
pass
elif check[arr[i]] == False:
check[arr[i]]=True
counting+=1
if counting == n:
print('I become the guy.')
else :
print('Oh, my keyboard!')
| 800 | PYTHON3 |
test_case = int(input())
for test in range(test_case):
n, m = tuple(int(item) for item in input().split())
array = [[None] * m for row in range(n)]
start = True
for row in range(n):
for column in range(m):
array[row][column] = start
start = not start
start = not array[row][0]
if n % 2 == 0:
array[n - 1][0] = True
elif m % 2 == 0:
array[0][m - 1] = True
for row in range(n):
for column in range(m):
print('B' if array[row][column] else 'W', end='')
print()
| 1,000 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
template <class c>
struct rge {
c b, e;
};
template <class c>
rge<c> range(c i, c j) {
return rge<c>{i, j};
}
template <class c>
auto dud(c* x) -> decltype(cerr << *x, 0);
template <class c>
char dud(...);
struct debug {
template <class c>
debug& operator<<(const c&) {
return *this;
}
};
const int N = 13;
int n, m, q;
int Adj[N];
int Child[N];
int orAdj[1 << N];
bool Valid[N][1 << N];
long long Dp[N][1 << N];
int FirstNode(int Mask) {
for (int x = 0; x < n; x++)
if (Mask & (1 << x)) return x;
return -1;
}
long long Rec(int x = 0, int Mask = (1 << n) - 2) {
if (!Mask) return 1;
long long& Res = Dp[x][Mask];
if (Res + 1) return Res;
Res = 0;
int X = FirstNode(Mask);
assert(X + 1);
Mask ^= (1 << X);
for (int Sub = Mask;; Sub = (Sub - 1) & Mask) {
int Mask1 = Sub | (1 << X);
int Mask2 = Mask ^ Sub;
if (!(orAdj[Mask1] & Mask2)) {
if (Valid[x][Mask1]) {
for (int y = 0; y < n; y++) {
if (Mask1 & (1 << y)) {
if ((Child[y] & Mask1) == Child[y]) {
if (!(Adj[x] & (Mask1 ^ (1 << y)))) {
Res += Rec(y, Mask1 ^ (1 << y)) * Rec(x, Mask2);
}
}
}
}
}
}
if (!Sub) break;
}
return Res;
}
int main() {
cin >> n >> m >> q;
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d%d", &x, &y);
x--, y--;
Adj[x] |= (1 << y);
Adj[y] |= (1 << x);
}
memset(Valid, true, sizeof(Valid));
for (int i = 0; i < q; i++) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
a--, b--, c--;
Child[c] |= (1 << a);
Child[c] |= (1 << b);
for (int Mask = 0; Mask < (1 << n); Mask++)
if (Mask & (1 << a))
if (Mask & (1 << b)) Valid[c][Mask] = false;
}
for (int Mask = 0; Mask < (1 << n); Mask++)
for (int x = 0; x < n; x++)
if (Mask & (1 << x)) orAdj[Mask] |= Adj[x];
memset(Dp, -1, sizeof(Dp));
cout << Rec() << endl;
}
| 2,600 | CPP |
"""
Please FUCKING
*** * * ********* *** * * ***
** * * * ** * ** ***
** * * * ** * ** ***
** ********* ********* ** *** ***
** * * * ** * **
** * * * ** * ** ***
*** * * ********* *** * * ***
check 1: idk
check 2: idk
check 3: idk
"""
from sys import stdin
def inp():
return stdin.buffer.readline().rstrip().decode("utf8")
def itg():
return int(stdin.buffer.readline())
def mpint():
return map(int, stdin.buffer.readline().split())
def main():
n = itg()
arr = [list(map(int, inp())) for _ in range(n)]
g = [[0]*n for _ in range(n)]
for i in range(n):
g[i][-1] = arr[i][-1]
g[-1] = arr[-1].copy()
modify = True
while modify:
modify = False
for i in range(n-2, -1, -1):
for j in range(n-2, -1, -1):
if arr[i][j] and not g[i][j] and (arr[i+1][j] or arr[i][j+1]):
g[i][j] = 1
modify = True
break
if modify:
break
return "YES" if arr == g else "NO"
for case in range(itg()):
print(main())
# Please FUCKING check!
| 1,300 | PYTHON3 |
letter=input()
if(letter.islower()):
print(letter)
elif(letter.isupper()):
print(letter)
else:
upper=0
lower=0
for i in letter:
if i.isupper():
upper+=1
elif i.islower():
lower+=1
if upper >lower:
print(letter.upper())
else:
print(letter.lower()) | 800 | PYTHON3 |
n, x = map(int, input().split())
arr = [int(x) for x in input().split()]
dp = [[0 for _ in range(n)] for _ in range(3)]
dp[0][0] = max(arr[0], 0)
dp[1][0] = max(arr[0] * x, 0)
dp[2][0] = max(arr[0], 0)
answer = max(dp[0][0], dp[1][0], dp[2][0])
for i in range(1, n):
dp[0][i] = max(dp[0][i - 1] + arr[i], arr[i], 0)
dp[1][i] = max(dp[0][i - 1] + arr[i] * x, dp[1][i - 1] + arr[i] * x, arr[i] * x, 0)
dp[2][i] = max(dp[1][i - 1] + arr[i], dp[2][i - 1] + arr[i], arr[i], 0)
answer = max(answer, dp[0][i], dp[1][i], dp[2][i])
print(answer)
| 1,900 | PYTHON3 |
if __name__ == '__main__':
arr = list(map(int,input().split()))
max = (max(arr))
foundmax = False
for num in arr:
if not foundmax and num==max:
continue
print(max - num,end=' ') | 800 | PYTHON3 |
q = int(input())
for z in range(q):
a, b = map(int, input().split(' '))
if(a == b):
print(0)
else:
if (a > b):
a, b = b, a
r = 0
while(a*8 <= b):
a *= 8
r += 1
while(a*4 <= b):
a *= 4
r += 1
while(a*2 <= b):
a *= 2
r += 1
if(a == b):
print(r)
else:
print(-1)
| 1,000 | PYTHON3 |
def inversePermutation(arr, size):
# To store element to index mappings
arr2 = [0] * (size)
# Inserting position at their
# respective element in second array
for i in range(0, size):
arr2[arr[i] - 1] = i + 1
for i in range(0, size):
print(arr2[i], end=" ")
# Driver program
no_friends = int(input())
arr = [int(x) for x in input().split(' ')]
# size = len(arr)
inversePermutation(arr, no_friends) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int infK = 0x3f3f3f3f;
const long long infLLK = 0x3f3f3f3f3f3f3f3f;
int main() {
int i, j, k;
int num, len;
priority_queue<int> pq;
cin >> num >> len;
for (i = 0; i < num; i++) {
int temp;
cin >> temp;
if (len % temp == 0) {
pq.push(temp);
}
}
int a = pq.top();
cout << len / a << endl;
return 0;
}
| 900 | CPP |
z=int(input())
while z>0:
z-=1
p=int(input())
s=input()
s=list(s)
q=1
a=0
b=0
c=0
for i in range(p-1):
if s[i]=="<":
a=1
elif s[i]==">":
b=1
else:
if s[i+1]=='-':
c+=1
else:
c+=2
if s[p-1]=="<":
a=1
elif s[p-1]==">":
b=1
elif s[p-1]=='-':
if s[0]=='-':
c+=1
else:
c+=2
if a==1 and b==1:
if c==0:
print(0)
else:
print(c)
elif a==0 or b==0:
print(p)
| 1,200 | PYTHON3 |
from collections import Counter
k = int(input(""))
total_capacity = 2 * k
panels = str()
for i in range(4):
panels = panels + input()
count = Counter(panels)
del count['.']
flag = True
for key in count:
if count[key] > total_capacity:
print("NO")
exit()
if (flag == True):
print("YES")
| 900 | PYTHON3 |
number = int(input())
pas_list = []
for i in range(number):
pas_list.append(tuple(map(int, input().split())))
current = 0
maxi = 0
for i in range(number):
current = current - pas_list[i][0] + pas_list[i][1]
maxi = max(maxi, current)
print(maxi)
| 800 | PYTHON3 |
from collections import defaultdict
x,y=map(int,input().split())
n=list(input())
a=list(input().split())
d=defaultdict(int)
for i in a:
d[i]=1
s=0
k=x
for i in range(x):
if d[n[-(i+1)]]==1:
s+=x-(k)
else:
k=x-(i+1)
s+=(x-k)
print((x*(x+1))//2-s) | 1,200 | PYTHON3 |
n=list(input())
z=0
o=0
x=0
y=0
for i in range(0,len(n)):
if n[i]=='0':
z+=1
if z>=x:
x=z
o=0
elif n[i]=='1':
o+=1
z=0
if o>=y:
y=o
if max(x,y)>=7:
print('YES')
else:
print('NO') | 900 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1000000 + 10;
const int NUM = 20;
int n, r, c;
string s[MAX];
int sum[MAX];
int fa[MAX][NUM];
int getlen(int l, int r) { return sum[r] - sum[l - 1] + (r - (l - 1) - 1); }
int main() {
int i, j;
scanf("%d%d%d", &n, &r, &c);
for ((i) = (1); (i) <= (n); ++(i)) cin >> s[i];
for ((i) = (1); (i) <= (n); ++(i)) sum[i] = sum[i - 1] + s[i].size();
int ll = 1;
pair<int, int> ans;
for ((i) = (1); (i) <= (n); ++(i)) {
while (ll <= i && getlen(ll, i) > c) ++ll;
fa[i][0] = ll - 1;
for ((j) = (1); (j) != (NUM); ++(j)) fa[i][j] = fa[fa[i][j - 1]][j - 1];
int j = NUM - 1, u = i, s = r;
while (s) {
while (j && (1 << j) > s) --j;
u = fa[u][j];
s -= (1 << j);
}
pair<int, int> t = make_pair(u, i);
if (t.second - t.first > ans.second - ans.first || !ans.second) ans = t;
}
int now = ans.first + 1;
int last = c + 1;
int sum = 0;
for (; now <= ans.second; ++now) {
if (last + 1 + (int)s[now].size() > c) {
++sum;
if (now != ans.first + 1) cout << endl;
last = s[now].size();
} else {
last += 1 + s[now].size();
cout << " ";
}
cout << s[now];
}
for (; sum < r; ++sum) cout << endl;
return 0;
}
| 2,100 | CPP |
for s in[*open(0)][1:]:n,k=map(int,s.split());m=(k-1).bit_length();print(m--(n-2**m)//k) | 1,100 | PYTHON3 |
def solve(p):
ans=[]
for i in range(2,p+1):
a=p%i
for j in range(p,i+1,-1):
b=p%j
if a==b:
ans.append(i)
ans.append(j)
return ans
t = int(input())
for _ in range(t):
p=int(input())
ans=solve(p)
print(ans[0],ans[1])
| 800 | PYTHON3 |
ns = int(input())
n = 0
pp = 0
ppmax = 0
while n < ns:
l = input().split()
pp = pp - int(l[0]) + int(l[1])
if pp > ppmax:
ppmax = pp
n = n + 1
print(ppmax)
| 800 | PYTHON3 |
s = input()
for ch in 'AEIOUY':
s = s.replace(ch, ' ')
print((max(map(len, s.split())) if s.split() else 0) + 1) | 1,000 | PYTHON3 |
a=int(input())
for i in range(0,a):
b,c=map(int,input().split())
if c>b:
if (c-b)%2==1:
print(1)
else:
print(2)
elif c<b:
if (b-c)%2==0:
print(1)
else:
print(2)
else:
print(0)
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const double kEps = 10e-8;
const int kMax = 1000005;
const int kInf = 1 << 30;
bool check(int h, int n, int m) {
int m3 = h / 3;
int v2 = m3 / 2;
int v3 = m3 - v2;
int m2 = h / 2 - v2;
m -= min(m, v3);
if (m > 0) {
int x = min(m, v2);
m -= x;
v2 -= x;
}
if (m > 0) {
return false;
}
m2 += v2;
return n <= m2;
}
int main() {
int n, m;
cin >> n >> m;
int low = 0;
int high = n * 2 + m * 3 + 6;
while (low < high) {
int mid = low + (high - low) / 2;
if (check(mid, n, m)) {
high = mid;
} else {
low = mid + 1;
}
}
cout << low << endl;
return EXIT_SUCCESS;
}
| 1,600 | CPP |
from collections import Counter
T = int(input())
for i in range(T):
N = int(input())
A = list(map(int, input().split()))
c = Counter(A)
if (c.most_common()[0][1]-1 >=len(c)):
ans = len(c)
elif (c.most_common()[0][1] > len(c)-1):
ans = len(c)-1
else:
ans = c.most_common()[0][1]
print(ans) | 1,100 | PYTHON3 |
import sys
def getGreatest(left, right, top, down):
x = right - 1
while(x != left and x != top):
if (x < right and x > left and x > top and x < down):
return x
x -= 1
return('-1')
def summ(matrix, n, m):
s = 0
for i in range(n):
for j in range(m):
s += matrix[i][j]
return s
inp = input().split()
n = int(inp[0])
m = int(inp[1])
matrix = []
for i in range(n):
row = list(map(int, input().split()))
matrix.append(row)
for i in range(n - 2, 0, -1):
for j in range(m - 2, 0, -1):
if (matrix[i][j] == 0):
test = getGreatest(
matrix[i][j-1], matrix[i][j+1], matrix[i-1][j], matrix[i+1][j])
if (test != '-1'):
matrix[i][j] = test
else:
print('-1')
sys.exit()
for i in range(n - 1):
for j in range(m):
if (matrix[i][j] >= matrix[i+1][j]):
print('-1')
sys.exit()
for i in range(n):
for j in range(m - 1):
if (matrix[i][j] >= matrix[i][j+1]):
print('-1')
sys.exit()
s = summ(matrix, n, m)
print(s)
| 1,100 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
scanf("%lld", &n);
if (n < 3)
printf("-1\n");
else if (n & 1LL)
printf("%lld %lld\n", n * n / 2, n * n / 2 + 1);
else
printf("%lld %lld\n", n * n / 4 - 1, n * n / 4 + 1);
}
| 1,500 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t = 0;
cin >> t;
for (long long i = 0; i < t; i++) {
long long a, b;
cin >> a >> b;
string stra = bitset<40>(a).to_string();
string strb = bitset<40>(b).to_string();
for (int i = 0; i < strb.size(); i++) {
if (stra[i] == strb[i] && strb[i] == '1') {
stra[i] = '0';
strb[i] = '0';
}
}
long long anew = bitset<40>(stra).to_ulong();
long long bnew = bitset<40>(strb).to_ulong();
cout << anew + bnew << '\n';
}
return 0;
}
| 800 | CPP |
def function(expr):
A, subexpr = expr.split('+')
B, C = subexpr.split('=')
a = A.count('|')
b = B.count('|')
c = C.count('|')
if abs(a + b - c) == 2:
if a + b > c:
if a != 1:
a -= 1
c += 1
else:
b -= 1
c += 1
else:
c -= 1
a += 1
return ('|' * a) + ('+') + ('|' * b) + ('=') + ('|' * c)
elif abs(a + b - c) == 0:
return expr
else:
return 'Impossible'
def main():
expr = input().strip()
expr = function(expr)
print(expr)
if __name__ == '__main__':
main()
| 0 | PYTHON3 |
def read_int():
n = int(input())
return n
def read_ints():
ints = [int(x) for x in input().split(" ")]
return ints
#---
def solve(n):
p1 = []
p2 = []
for i in range(1, n+1):
if i == n:
p1.append(pow(2,i))
elif i < n//2:
p1.append(pow(2,i))
else:
p2.append(pow(2,i))
return sum(p1) - sum(p2)
# Main
t = read_int()
for case in range(t):
n = read_int()
sol = solve(n)
print (sol) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 4;
const int MAXM = 302;
const int INF = 1e9;
const int OPEN = 0;
const int CLOSE = 1;
struct node {
int length;
int add;
int mn;
int mx;
node() : length(0), add(0), mn(0), mx(0) {}
} t[4 * MAXN];
vector<int> a;
pair<int, int> segments[MAXM];
vector<int> events[MAXN];
void push(int v) {
if (t[v].add) {
t[v].mn += t[v].add;
t[v].mx += t[v].add;
if (t[v].length != 1) {
t[v * 2].add += t[v].add;
t[v * 2 + 1].add += t[v].add;
}
t[v].add = 0;
}
}
void build(int v, int tl, int tr) {
t[v].add = 0;
if (tl == tr) {
t[v].mn = t[v].mx = a[tl];
t[v].length = 1;
} else {
int tm = (tl + tr) / 2;
build(v * 2, tl, tm);
build(v * 2 + 1, tm + 1, tr);
t[v].length = t[v * 2].length + t[v * 2 + 1].length;
t[v].mn = min(t[v * 2].mn, t[v * 2 + 1].mn);
t[v].mx = max(t[v * 2].mx, t[v * 2 + 1].mx);
}
}
void query_add(int v, int tl, int tr, int l, int r, int add) {
if (l > r) {
return;
}
if (tl == l && tr == r) {
t[v].add += add;
} else {
push(v);
int tm = (tl + tr) / 2;
query_add(v * 2, tl, tm, l, min(tm, r), add);
query_add(v * 2 + 1, tm + 1, tr, max(tm + 1, l), r, add);
t[v].mn =
min(t[v * 2].mn + t[v * 2].add, t[v * 2 + 1].mn + t[v * 2 + 1].add);
t[v].mx =
max(t[v * 2].mx + t[v * 2].add, t[v * 2 + 1].mx + t[v * 2 + 1].add);
}
}
pair<int, int> query_ans(int v, int tl, int tr, int l, int r) {
if (l > r) {
return {INF, -INF};
} else {
if (tl == l && tr == r) {
return {t[v].mn + t[v].add, t[v].mx + t[v].add};
} else {
push(v);
int tm = (tl + tr) / 2;
auto q_l = query_ans(v * 2, tl, tm, l, min(tm, r));
auto q_r = query_ans(v * 2 + 1, tm + 1, tr, max(tm + 1, l), r);
return {min(q_l.first, q_r.first), max(q_l.second, q_r.second)};
}
}
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) {
int t;
scanf("%d", &t);
a.push_back(t);
}
build(1, 0, n - 1);
for (int i = 0; i < m; ++i) {
int l, r;
scanf("%d%d", &l, &r);
--l;
--r;
events[l].push_back(r);
events[r + 1].push_back(l);
segments[i] = {l, r};
query_add(1, 0, n - 1, l, r, -1);
}
int ans = *max_element(a.begin(), a.end()) - *min_element(a.begin(), a.end());
int idx = -1;
for (int i = 0; i < n; ++i) {
for (auto ev : events[i]) {
if (ev >= i) {
query_add(1, 0, n - 1, i, ev, 1);
} else {
query_add(1, 0, n - 1, ev, i - 1, -1);
}
}
auto res = query_ans(1, 0, n - 1, 0, n - 1);
if (res.second - res.first > ans) {
ans = res.second - res.first;
idx = i;
}
}
printf("%d\n", ans);
vector<int> ans_segs;
if (idx != -1) {
for (int i = 0; i < m; ++i) {
if (idx < segments[i].first || idx > segments[i].second) {
ans_segs.push_back(i);
}
}
}
printf("%d\n", (int)ans_segs.size());
if (ans_segs.size()) {
for (int id : ans_segs) {
printf("%d ", id + 1);
}
printf("\n");
}
return 0;
}
| 1,800 | CPP |
first=input()
second=input()
s=input()
len=len(s)
for i in range(len):
if 48<=ord(s[i]) and ord(s[i])<=57:
to_print=s[i]
else:
offset=0
if 65<=ord(s[i]) and ord(s[i])<=90:
offset=32
pos=first.index(chr(ord(s[i])+offset))
from_second=chr(ord(second[pos])-offset)
to_print=from_second
print(to_print,end="") | 800 | PYTHON3 |
def vovel(c):
return c in ['a', 'i', 'o', 'e', 'u', 'y']
n = int(input())
s = input()[:n]
if len(s)>0:
p = s[0]
else:
print ()
exit()
res = ''
for i in range(1, len(s)):
if vovel(p) and vovel(s[i]):
continue
res +=p
p = s[i]
res += p
print (res) | 800 | PYTHON3 |
Subsets and Splits