solution
stringlengths 10
983k
| difficulty
int64 0
25
| language
stringclasses 2
values |
|---|---|---|
import math
n,m=map(int,input().split())
l=list(map(int,input().split()))
d={}
for i in l:
if(i in d):
d[i]+=1
else:
d[i]=1
k=1000000
for i in d:
k=min(k,d[i])
if(len(d)!=n):
print('0')
else:
print(k) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, d;
char str[101];
int main() {
cin >> n >> d;
int cnt = 0, ans = 0;
for (int i = 0; i < d; i++) {
cin >> str;
if (count(str, str + n, '0') >= 1)
cnt++;
else
cnt = 0;
ans = max(cnt, ans);
}
cout << ans << endl;
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const double PI = 2.0 * acos(0.0);
const double E = exp(1);
template <class T1>
void deb(T1 e) {
cout << e << endl;
}
template <class T1, class T2>
void deb(T1 e1, T2 e2) {
cout << e1 << " " << e2 << endl;
}
template <class T1, class T2, class T3>
void deb(T1 e1, T2 e2, T3 e3) {
cout << e1 << " " << e2 << " " << e3 << endl;
}
template <class T1, class T2, class T3, class T4>
void deb(T1 e1, T2 e2, T3 e3, T4 e4) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << endl;
}
template <class T1, class T2, class T3, class T4, class T5>
void deb(T1 e1, T2 e2, T3 e3, T4 e4, T5 e5) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << " " << e5 << endl;
}
template <class T1, class T2, class T3, class T4, class T5, class T6>
void deb(T1 e1, T2 e2, T3 e3, T4 e4, T5 e5, T6 e6) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << " " << e5 << " " << e6
<< endl;
}
template <typename T>
inline T sqr(T n) {
return n * n;
}
inline double hypot(double x, double y) { return sqrt(sqr(x) + sqr(y)); }
template <typename T>
inline T pmod(T n, T m) {
return ((n % m) + m) % m;
}
template <typename T>
T power(T n, int p) {
return (p == 0) ? (T)(1) : (sqr(power(n, p >> 1)) * ((p & 1) * (n - 1) + 1));
}
template <typename T>
T bigmod(T n, int p, T m) {
return (p == 0)
? (T)(1)
: ((sqr(bigmod(n, p >> 1, m)) % m) * ((p & 1) * (n - 1) % m + 1)) %
m;
}
bool dp[21][(1 << 6)][11][11][11][11][11];
int row[6], col[23];
int r, c;
vector<int> save[1 << 6];
int calc(int mask) {
int cnt = 0;
int prv = 0;
for (int i = 0; i < r; i++) {
if (!prv && (mask & (1 << i))) {
cnt++;
}
prv = mask & (1 << i);
}
return cnt;
}
char grid[21][21];
int tmp[10];
bool complet = 0;
void rec(int now, int prv_maks, int r1, int r2, int r3, int r4, int r5) {
if (r1 < 0 || r2 < 0 || r3 < 0 || r4 < 0 || r5 < 0) return;
if (complet) return;
if (dp[now][prv_maks][r1][r2][r3][r4][r5]) return;
dp[now][prv_maks][r1][r2][r3][r4][r5] = 1;
if (now == c) {
if (r1 + r2 + r3 + r4 + r5 == 0) {
for (int i = 0; i < r; ++i) {
puts(grid[i]);
}
complet = 1;
}
return;
}
int mask = 0;
for (int i = 0; i < (int)save[col[now]].size(); i++) {
mask = save[col[now]][i];
tmp[0] = r1;
tmp[1] = r2;
tmp[2] = r3;
tmp[3] = r4;
tmp[4] = r5;
for (int j = 0; j < r; j++) {
if (!(prv_maks & (1 << j)) && (mask & (1 << j))) {
tmp[j]--;
}
}
for (int j = 0; j < r; j++) {
grid[j][now] = (mask & (1 << j)) ? '*' : '.';
}
rec(now + 1, mask, tmp[0], tmp[1], tmp[2], tmp[3], tmp[4]);
if (complet) return;
}
}
int main() {
scanf("%d %d", &r, &c);
for (int i = 0; i < r; ++i) scanf("%d", &row[i]);
for (int i = 0; i < c; ++i) {
scanf("%d", &col[i]);
};
for (int i = 0; i < (1 << r); i++) {
save[calc(i)].push_back(i);
}
rec(0, 0, row[0], row[1], row[2], row[3], row[4]);
}
| 12 | CPP |
s=input()
c=1
dic={}
if len(s)==1:
print(s)
else:
l=-1
for i in range(1,len(s)):
if s[i]==s[i-1]:
c+=1
if s[i]!=s[i-1]:
if c>=2 and l>=2:
l=1
else:
l=c
c=1
if l>=2 and c>=2:
dic[i]=1
elif c>2:
dic[i]=1
ans=''
for i in range(len(s)):
if i not in dic:
ans=ans+s[i]
print(ans)
| 9 | PYTHON3 |
n = int(input())
str = input()
res = 0
for i in range(len(str)):
if str[i:i+3] == 'xxx':
res += 1
print(res)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
int fl[2600][2600];
template <int N>
struct myvector {
pair<int, int> stor[N];
int sz;
inline pair<int, int>& operator[](int i) { return stor[i]; }
inline const pair<int, int>& operator[](int i) const { return stor[i]; }
inline void sort() { std::sort(stor, stor + sz); }
inline myvector() { sz = 0; }
inline void pop_back() { sz--; }
inline int size() const { return sz; }
inline void push_back(const pair<int, int>& p) { stor[sz++] = p; }
template <int m>
inline void insert(const myvector<m>& a) {
for (int i = 0; i < a.sz; i++) push_back(a.stor[i]);
}
inline void clear() { sz = 0; }
};
inline int imul(int a, int b) { return a == 0 ? 0 : b; }
struct View {
int int_mtr[3][3];
int xlim;
int ylim;
inline int get(int x, int y) {
int nx, ny;
nx = imul(int_mtr[0][0], x) + imul(int_mtr[0][1], y) + int_mtr[0][2];
ny = imul(int_mtr[1][0], x) + imul(int_mtr[1][1], y) + int_mtr[1][2];
return fl[nx][ny];
}
View() { memset(int_mtr, 0, sizeof int_mtr); }
};
View simpleView(int x0, int x1, int y0, int y1) {
View nw;
nw.int_mtr[0][0] = 1;
nw.int_mtr[0][2] = x0;
nw.int_mtr[1][1] = 1;
nw.int_mtr[1][2] = y0;
nw.int_mtr[2][2] = 1;
nw.xlim = x1 - x0;
nw.ylim = y1 - y0;
return nw;
}
View swapxy(const View& v) {
View nw;
memcpy(nw.int_mtr, v.int_mtr, sizeof(v.int_mtr));
for (int i = 0; i < 3; i++) swap(nw.int_mtr[i][0], nw.int_mtr[i][1]);
nw.xlim = v.ylim;
nw.ylim = v.xlim;
return nw;
}
View comp(const View& u, const View& v) {
View nw;
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
for (int k = 0; k < 3; k++) {
nw.int_mtr[i][j] += v.int_mtr[i][k] * u.int_mtr[k][j];
}
}
}
nw.xlim = u.xlim;
nw.ylim = u.ylim;
return nw;
}
myvector<30> evl[2600], evr[2600];
inline void merge(const myvector<30>& v1, myvector<30>& v2, int k) {
memcpy(v2.stor + 15, v2.stor, (15 - 1) * sizeof(pair<int, int>));
int csum = 0, c1 = 0, c2 = 0;
int ll = 0;
while (csum <= k) {
if (c2 == v2.size() || (c1 < v1.size() && v1[c1] < v2[c2])) {
if (ll != 0 && v2[15 + ll - 1].first == v1[c1].first)
v2[15 + ll - 1].second += v1[c1].second;
else
v2[15 + (ll++)] = v1[c1];
csum += v1[c1].second;
c1++;
} else {
if (ll != 0 && v2[15 + ll - 1].first == v2[c2].first)
v2[15 + ll - 1].second += v2[c2].second;
else
v2[15 + (ll++)] = v2[c2];
csum += v2[c2].second;
c2++;
}
}
memcpy(v2.stor, v2.stor + 15, ll * sizeof(pair<int, int>));
v2.sz = ll;
}
myvector<30> vl, vr;
long long rect(View v, int k) {
if (v.xlim < v.ylim) return rect(swapxy(v), k);
if (v.xlim == 1) {
return v.get(0, 0) == k;
}
int spx = v.xlim / 2;
for (int i = 0; i < v.ylim; i++) {
evl[i].clear();
evr[i].clear();
}
for (int i = 0; i < v.ylim; i++) {
for (int j = spx - 1; j >= 0; j--)
if (v.get(j, i) == 1 && evl[i].size() <= k)
evl[i].push_back(make_pair(spx - j - 1, 1));
for (int j = spx; j < v.xlim; j++)
if (v.get(j, i) == 1 && evr[i].size() <= k)
evr[i].push_back(make_pair(j - spx, 1));
if (evl[i].size() <= k) evl[i].push_back(make_pair(spx, 4000));
if (evr[i].size() <= k) evr[i].push_back(make_pair(v.xlim - spx, 4000));
}
long long ans = 0;
for (int l = 0; l < v.ylim; l++) {
vl.clear();
vr.clear();
for (int r = l; r < v.ylim; r++) {
merge(evl[r], vl, k);
merge(evr[r], vr, k);
int lsum = 0, lc = 0, rsum = 0, rc = 0;
while (lsum < k) lsum += vl[lc++].second;
while (lc >= 0) {
while (rsum + lsum < k) rsum += vr[rc++].second;
if (lsum + rsum == k) {
ans += (lc != 0 ? vl[lc].first - vl[lc - 1].first : vl[lc].first) *
(rc != 0 ? vr[rc].first - vr[rc - 1].first : vr[rc].first);
}
lsum -= vl[--lc].second;
}
}
}
return ans + rect(comp(simpleView(0, spx, 0, v.ylim), v), k) +
rect(comp(simpleView(spx, v.xlim, 0, v.ylim), v), k);
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m >> k;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
char c;
cin >> c;
fl[i][j] = c == '1';
}
}
cout << rect(simpleView(0, n, 0, m), k);
}
| 11 | CPP |
import bisect
from itertools import accumulate, count
import os
import sys
import math
from decimal import *
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)
def input():
return sys.stdin.readline().rstrip("\r\n")
def isPrime(n):
if n <= 1:
return False
if n <= 3:
return True
if n % 2 == 0 or n % 3 == 0:
return False
i = 5
while i * i <= n:
if n % i == 0 or n % (i + 2) == 0:
return False
i = i + 6
return True
def SieveOfEratosthenes(n):
prime = []
primes = [True for i in range(n + 1)]
p = 2
while p * p <= n:
if primes[p] == True:
prime.append(p)
for i in range(p * p, n + 1, p):
primes[i] = False
p += 1
return prime
def primefactors(n):
fac = []
while n % 2 == 0:
fac.append(2)
n = n // 2
for i in range(3, int(math.sqrt(n)) + 2):
while n % i == 0:
fac.append(i)
n = n // i
if n > 1:
fac.append(n)
return sorted(fac)
def factors(n):
fac = set()
fac.add(1)
fac.add(n)
for i in range(2, int(math.sqrt(n)) + 1):
if n % i == 0:
fac.add(i)
fac.add(n // i)
return list(fac)
def modInverse(a, m):
m0 = m
y = 0
x = 1
if m == 1:
return 0
while a > 1:
q = a // m
t = m
m = a % m
a = t
t = y
y = x - q * y
x = t
if x < 0:
x = x + m0
return x
# ------------------------------------------------------code
n,k,x=map(int,input().split())
a=sorted(list(map(int,input().split())))
freq=[0]*1055
freq1=[0]*1055
for i in range(0,len(a)):
freq[a[i]]+=1
while(k>0):
k-=1
for i in range(0,len(freq)):
freq1[i]=freq[i]
parity=0
for i in range(0,len(freq)):
if freq[i]>0:
cur=i^x
delta=freq[i]//2
if parity==0:
delta+=freq[i]&1
freq1[i]-=delta
freq1[cur]+=delta
parity=parity^(freq[i]&1)
for i in range(0,len(freq)):
freq[i]=freq1[i]
mini=1e18
maxi=-1e18
for i in range(0,len(freq)):
if freq[i]>0:
mini=min(mini,i)
maxi=max(maxi,i)
print(maxi,mini) | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, k, h;
struct Lem {
int w, v, i;
bool operator<(const Lem &a) const {
return w < a.w || (w == a.w && v < a.v);
}
};
Lem lem[int(1e5 + 1)];
int solution[int(1e5 + 1)];
bool check(double t) {
int added = 0;
for (int i = 0; i < n; i++) {
if (double((added + 1) * h) / double(lem[i].v) <= t) {
solution[added++] = lem[i].i;
if (added == k) return true;
}
}
return false;
}
int main(int narg, char **arg) {
cin >> n >> k >> h;
for (int i = 0; i < n; i++) cin >> lem[i].w;
for (int i = 0; i < n; i++) cin >> lem[i].v;
for (int i = 0; i < n; i++) lem[i].i = i + 1;
sort(lem, lem + n);
double ini = 0, end = numeric_limits<unsigned>::max() >> 1;
for (int count = 0; count < 200; count++) {
double mid = (ini + end) * 0.5;
if (check(mid))
end = mid;
else
ini = mid;
}
check(end);
printf("%d", solution[0]);
for (int i = 1; i < k; i++) printf(" %d", solution[i]);
printf("\n");
return 0;
}
| 10 | CPP |
#include<bits/stdc++.h>
using namespace std;
int main(){
int X; cin >> X;
int ans = 1;
for(int i = 2; i < X; i++)
{
for(int j = i*i; j <= X; j*=i)
{
ans = max(ans, j);
}
}
cout << ans << endl;
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, m, k;
cin >> n >> m >> k;
set<int> adj[n + 1];
unordered_set<int> check[n + 1];
for (long long i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
adj[a].insert(b);
adj[b].insert(a);
check[a].insert(b);
check[b].insert(a);
}
set<pair<int, int> > adjs;
for (long long i = 1; i < n + 1; i++) adjs.insert({adj[i].size(), i});
while (!adjs.empty()) {
auto bro = *(adjs.begin());
adjs.erase(adjs.begin());
if (bro.first >= k) {
vector<int> ans;
for (long long i = 1; i < n + 1; i++)
if (adj[i].size() > 0) ans.push_back(i);
cout << 1 << " " << ans.size() << "\n";
for (auto j : ans) cout << j << " ";
cout << "\n";
return;
}
if (bro.first == k - 1) {
vector<int> ans;
ans.push_back(bro.second);
for (auto j : adj[bro.second]) ans.push_back(j);
assert(ans.size() == k);
bool hey = true;
for (long long i = 0; i < k; i++)
for (long long j = i + 1; j < k; j++)
if (check[ans[i]].find(ans[j]) == check[ans[i]].end()) {
hey = false;
break;
}
if (hey) {
cout << 2 << "\n";
for (auto j : ans) cout << j << " ";
cout << "\n";
return;
}
}
for (auto j : adj[bro.second]) {
adjs.erase({adj[j].size(), j});
adj[j].erase(bro.second);
adjs.insert({adj[j].size(), j});
}
adj[bro.second].clear();
}
cout << "-1"
<< "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
cin >> t;
for (int i = 1; i <= t; i++) {
solve();
}
return 0;
}
| 10 | CPP |
k, r = map(int, input().split())
kol = 0
s = 0
while True:
s += k
kol += 1
if s % 10 == 0 or s % 10 == r:
break
print(kol)
| 7 | PYTHON3 |
n=list(map(int,input().strip().split(' ')))
m=list(map(int,input().strip().split(' ')))
prev=-1
ptr=-1
for i in range(n[0]):
if(m[i]!=prev):
ptr=i
prev=m[i]
if(ptr>n[-1]-1):
print(-1)
else:
print(ptr)
| 7 | PYTHON3 |
#------------------------template--------------------------#
import os
import sys
from math import *
from collections import *
from fractions import *
from bisect import *
from heapq import*
from io import BytesIO, IOBase
def vsInput():
sys.stdin = open('input.txt', 'r')
sys.stdout = open('output.txt', 'w')
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")
def value():return tuple(map(int,input().split()))
def array():return [int(i) for i in input().split()]
def Int():return int(input())
def Str():return input()
def arrayS():return [i for i in input().split()]
#-------------------------code---------------------------#
#vsInput()
for _ in range(Int()):
r,c=value()
a=[]
row=set()
col=set()
for i in range(r):
a.append(array())
for i in range(r):
for j in range(c):
if(a[i][j]==1):
row.add(i+1)
col.add(j+1)
rl,cl=0,0
rl=r-len(row)
cl=c-len(col)
#print(rl,cl,col)
ans=min(rl,cl)
if(ans%2):print("Ashish")
else:print("Vivek")
| 7 | PYTHON3 |
H, K = map(int, input().split())
H = list(map(int, input().split()))
H.sort(reverse = True)
print(sum(H[K:])) | 0 | PYTHON3 |
#include <bits/stdc++.h>
char t[2], op[200000];
int n, x[200000], s[200000], tp = 0;
int main() {
scanf("%d", &n);
for (int i = 0; i < 2 * n; i++) {
scanf("%s", t);
op[i] = t[0];
if (op[i] == '-') scanf("%d", x + i);
}
for (int i = 2 * n - 1; i >= 0; i--) {
if (op[i] == '-') {
if (!tp || s[tp - 1] > x[i]) {
s[tp++] = x[i];
} else {
puts("NO");
return 0;
}
} else {
if (!tp) {
puts("NO");
return 0;
}
x[i] = s[--tp];
}
}
puts("YES");
for (int i = 0; i < 2 * n; i++)
if (op[i] == '+') printf("%d ", x[i]);
puts("");
}
| 8 | CPP |
def split(x, n):
a = []
if(x < n):
print(-1)
elif (x % n == 0):
for i in range(n):
a.append(x//n)
else:
zp = n - (x % n)
pp = x//n
for i in range(n):
if(i>= zp):
a.append(pp + 1)
else:
a.append(pp)
return a
t = int(input())
for _ in range(t):
n,x = map(int,input().split())
if n>=x:
print(x)
continue
a = split(x, n)
s = 0
for i in a:
s+=i*i
print(s) | 7 | PYTHON3 |
/* ***********************************************
Author :dasinlsb
Created Time :2018/6/2 0:56:02
File Name :C:\dasin\mine.cpp
************************************************ */
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define pb push_back
#define fi first
#define se second
const int N=100005;
int n,ed,fir[N],f[N][3],deg[N],q[N],col[N],del[N];
char strc[N];
struct E{int v,nxt;}e[N*2];
void addedge(int x,int y){
e[++ed].v=y;e[ed].nxt=fir[x];fir[x]=ed;
}
int delLeaf(){
int i,h=0,t=-1,c=0;
for(i=1;i<=n;++i)if(col[i]==1&°[i]<=1)q[++t]=i;
for(;h<=t;){
int x=q[h++];
del[x]=1;++c;
for(i=fir[x];i;i=e[i].nxt){
--deg[e[i].v];
if(deg[e[i].v]==1&&col[e[i].v]==1)q[++t]=e[i].v;
}
}
return c;
}
void dp(int x,int y){
for(int i=fir[x];i;i=e[i].nxt){
int v=e[i].v;
if(del[v]||v==y)continue;
dp(v,x);
if(f[v][1]>f[x][1])f[x][2]=f[x][1],f[x][1]=f[v][1];
else if(f[v][1]>f[x][2])f[x][2]=f[v][1];
}
f[x][1]+=1-col[x];
f[x][0]=f[x][1]+f[x][2];
}
int main(){
// freopen("C:/dasin/aa.in","r",stdin);
//freopen("C:/dasin/mine.out","w",stdout);
int i,j;
scanf("%d",&n);
for(i=1;i<n;++i){
int x,y;scanf("%d%d",&x,&y);
addedge(x,y);addedge(y,x);
++deg[x];++deg[y];
}
scanf("%s",strc+1);
for(i=1;i<=n;++i)col[i]=strc[i]=='B';
int rest=n-delLeaf();
if(rest<=1)return printf("%d\n",rest),0;
int ans=2*(rest-1);
for(i=1;i<=n;++i)if(!del[i]){
col[i]^=(deg[i]&1);
ans+=1-col[i];
}
for(i=1;i<=n;++i)if(!del[i]){dp(i,0);break;}
int res=0;
for(i=1;i<=n;++i)if(!del[i])res=max(res,f[i][0]);
ans-=res*2;
printf("%d\n",ans);
return 0;
}
| 0 | CPP |
from sys import stdin,stdout
a=int(input())
b=int(input())
c=int(input())
arr=[]
arr.append((a+b)*c)
arr.append(a*(b+c))
arr.append(a+b*c)
arr.append(a*b+c)
arr.append(a*b*c)
arr.append(a+b+c)
print(max(arr))
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 400010;
unordered_map<int, int> mp;
pair<int, int> a[N];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
int x;
scanf("%d", &x);
mp[x]++;
}
int tot = 0;
for (auto const& x : mp) a[++tot] = {x.second, x.first};
sort(a + 1, a + tot + 1);
reverse(a + 1, a + tot + 1);
int ans = 0;
int p = 0, q = 0;
int ptr = tot, ptrtot = 0;
for (int i = 1; i <= n; ++i) {
if (n / i < i) break;
while (ptr > 0 && a[ptr].first < i) ptrtot += a[ptr--].first;
int validtot = (i * ptr) + ptrtot;
int j = validtot / i;
if (i <= j && i * j > ans) {
ans = i * j;
p = i, q = j;
}
}
vector<vector<int>> res(p, vector<int>(q));
ptr = 1, ptrtot = 0;
int x = 0, y = 0;
for (int i = 1; i <= p * q; ++i) {
res[x][y] = a[ptr].second;
++ptrtot;
if (ptrtot == p || ptrtot == a[ptr].first) ptrtot = 0, ptr++;
++x, ++y;
if (x == p)
x = 0, y = i / p;
else if (y == q)
y = 0;
}
printf("%d\n", ans);
printf("%d %d\n", p, q);
for (int i = 0; i < p; ++i)
for (int j = 0; j < q; ++j) {
printf("%d%c", res[i][j], " \n"[j == q - 1]);
}
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
int mid = ((int)pow(10, 6)) / 2;
int l = 1, r = 1000000;
for (int i = 0; i < n; i++) {
if (a[i] <= mid)
l = a[i];
else
break;
}
for (int i = n - 1; i >= 0; i--) {
if (a[i] > mid)
r = a[i];
else
break;
}
l -= 1;
r = 1000000 - r;
cout << max(l, r);
}
| 8 | CPP |
x = int(input())
find = False
for a in range(1,x+1):
for b in range(1, x+1):
if(a % b == 0 and a * b > x and a / b < x):
print(a, b)
find = True
break
if(find):
break
if(not find):
print(-1) | 7 | PYTHON3 |
i=input;i();s=p=0
for x in map(int,i().split()):s+=max(x-p,0);p=x
print(s) | 0 | PYTHON3 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector")
#pragma GCC target("avx")
inline void read(int& x) {
x = 0;
int f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
if (ch == EOF) return;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
x *= f;
}
inline void read(short& x) {
x = 0;
int f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
if (ch == EOF) return;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
x *= f;
}
inline void read(float& ax) {
int x = 0.0;
int f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
if (ch == EOF) return;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
x *= f;
ax = x;
}
int a[100002];
int main() {
int n, m, ans, l, r;
short T;
float x;
read(n);
read(m);
for (register int i = 1; i <= n; ++i) read(a[i]);
while (m--) {
read(T);
read(l);
read(r);
read(x);
if (T == 1) {
for (register int i = l; i <= r; ++i) a[i] -= a[i] > x ? x : 0;
} else {
ans = 0;
for (register int i = l; i <= r; ++i) a[i] == x ? ++ans : 0;
printf("%d\n", ans);
}
}
return 0;
}
| 11 | CPP |
import sys
mod = 10**9+7
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
n = inp()
a = [inpl() for _ in range(n)]
res = 0
a.sort(key = lambda x:x[1], reverse = True)
a.sort(key = lambda x:x[0])
l = 0; r = INF
for i in range(n-1):
l = max(l,a[i][0])
r = min(r,a[i][1])
res = max(res, r-l)
a.sort(key = lambda x:x[0])
a.sort(key = lambda x:x[1],reverse = True)
l = 0; r = INF
# print(a)
for i in range(n-1):
l = max(l,a[i][0])
r = min(r,a[i][1])
res = max(res, r-l)
print(res) | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
s += '0';
int j = 1, p = -3;
for (int i = 1; i < s.length(); i++) {
if (s[i] == s[i - 1])
j++;
else if (s[i] != s[i - 1] && j > 1) {
if (j == 2) {
if (p + 2 == i - 1) {
s[i - 1] = '0';
j = 1;
} else
p = i - 1;
} else if (j > 2) {
for (int k = i - j; k < i - 2; k++) {
s[k] = '0';
}
if (p + j == i - 1)
s[i - 1] = '0';
else
p = i - 1;
}
j = 1;
}
}
for (int i = 0; i < s.length(); i++) {
if (s[i] != '0') printf("%c", s[i]);
}
}
| 9 | CPP |
dic = {"purple":"Power", "red":"Reality", "green":"Time", "blue":"Space", "orange":"Soul", "yellow":"Mind"}
n = int(input())
s = set()
while n != 0:
str = input()
s.add(str)
n -= 1
if 6 - len(s) != 0:
print(6-len(s))
for i in dic:
if i not in s:
print(dic[i])
else: print(0)
# C O M F O R T A B L Y N U M B
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = (1 << 30) - 1;
const int maxn = 100010;
int IN() {
int c, f, x;
while (!isdigit(c = getchar()) && c != '-')
;
c == '-' ? (f = 1, x = 0) : (f = 0, x = c - '0');
while (isdigit(c = getchar())) x = (x << 1) + (x << 3) + c - '0';
return !f ? x : -x;
}
int n, T;
int v1[110], v2[110];
int la[1110];
int ans[maxn];
char s1[110], s2[110];
int main() {
while (~scanf("%d", &n)) {
scanf("%s%s", s1, s2);
memset(v1, 0, sizeof(v1));
memset(v2, 0, sizeof(v2));
for (int i = 0; i < n; i++) v1[s1[i] - 'a']++;
for (int i = 0; i < n; i++) v2[s2[i] - 'a']++;
int flag = 1;
for (int i = 0; i < 26; i++)
if (v1[i] != v2[i]) flag = 0;
int tot = 0;
for (int i = 0; i < n; i++) {
if (s1[i] == s2[i]) continue;
for (int j = i + 1; j < n; j++)
if (s1[j] == s2[i]) {
for (int k = j - 1; k >= i; k--)
swap(s1[k], s1[k + 1]), ans[++tot] = k + 1;
break;
}
}
for (int i = 1; i <= n; i++)
if (s1[i] != s2[i]) flag = 0;
if (!flag) {
puts("-1");
continue;
}
printf("%d\n", tot);
for (int i = 1; i <= tot; i++) printf("%d ", ans[i]);
}
return 0;
}
| 8 | CPP |
N,K = map(int,input().split())
res = K*((K-1)**(N-1))
print(res) | 0 | PYTHON3 |
x,y = map(int, input().split())
li = list(map(int, input().split()))
cnt = 0
count = sum(li[:y])
ans = count
for i in range(y,x):
count -= li[i-y]
count +=li[i]
if count < ans:
cnt = i-y +1
ans = count
print(cnt+1)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long bin_pow(long long x, long long e, long long MOD) {
long long k;
if (e == 0) return 1;
if (e % 2)
return (bin_pow(x, e - 1, MOD) % MOD) * (x % MOD) % MOD;
else {
k = bin_pow(x, e / 2, MOD) % MOD;
return k * k % MOD;
}
}
long long p, a, b, x, ans, counter;
vector<long long> m[1123456];
long long xd[1123456];
long long xy[1123456];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> a >> b >> p >> x;
for (int i = 1; i < p; i++) {
xd[i] = bin_pow(i, p - 2, p);
xy[i] = bin_pow(a, i, p);
}
xy[0] = 1;
for (int i = 0; i < p - 1; i++) {
m[xy[i]].push_back(i);
}
for (int i = 1; i < p; i++) {
vector<long long> g = m[((b * xd[i]) % p) * xd[xy[i]] % p];
for (auto k : g) {
long long y = x - i;
if (y < 0) continue;
y /= p;
long long t = y / (p - 1);
if (t * (p - 1) + k <= y)
ans += t + 1;
else
ans += t;
}
}
cout << ans;
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long N = (2e5 + 5);
const long long MOD = 1e9 + 7;
const long long INF = 1e16;
const long long LOG = 29;
long long binpow(long long a, long long b) {
a %= MOD;
long long res = 1;
while (b > 0) {
if (b & 1) res = (res * a) % MOD;
a = (a * a) % MOD;
b >>= 1;
}
res %= MOD;
return res;
}
void solve() {
long long n;
cin >> n;
if (n == 1) {
cout << "-1\n";
} else {
cout << 2;
for (int i = 0; i < (n - 1); i++) {
cout << 3;
}
cout << "\n";
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
long long t = 1;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > lang(105);
vector<vector<int> > emp(105);
vector<int> visited(105, false);
int n, m;
void dfs(int i) {
if (!visited[i]) {
visited[i] = true;
int n_lang = emp[i].size();
for (int k = 0; k < n_lang; k++) {
int lg = emp[i][k];
int n_emp = lang[lg].size();
for (int x = 0; x < n_emp; x++) {
dfs(lang[lg][x]);
}
}
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
int n_l;
cin >> n_l;
for (int j = 0; j < n_l; j++) {
int lg;
cin >> lg;
lg--;
lang[lg].push_back(i);
emp[i].push_back(lg);
}
}
bool flag = false;
for (int i = 0; i < m; i++) {
if (lang[i].size() != 0) {
flag = true;
break;
}
}
if (flag == false) {
cout << n << endl;
return 0;
}
int cc = 0;
for (int i = 0; i < n; i++) {
if (!visited[i]) {
cc++;
dfs(i);
}
}
cout << cc - 1 << endl;
}
| 7 | CPP |
import sys
import math
def primes(n):
sieve = [1] * (n + 1)
rt = int(math.sqrt(n))
sieve[0] = sieve[1] = 0
for p in range(2, rt + 1):
if sieve[p] == 0:
continue
k = p * 2
while k <= n:
sieve[k] = 0
k += p
r = []
for p in range(2, n + 1):
if sieve[p] == 1:
r.append(p)
return r
def goldbach(prime, n):
c = 0
for p in prime:
if p <= n - p and n - p in prime:
c += 1
return c
p = primes(2**15)
for line in sys.stdin:
n = int(line)
if n == 0:
break
c = goldbach(p, n)
print(c)
| 0 | PYTHON3 |
n=int(input())
a=[]
for i in range(n):
x,y=list(map(int,input().split()))
z=[i for i in range(x,y+1)]
a.append(z)
k=int(input())
for i in range(n):
if k in a[i]:
c=i
break
print(n-c) | 7 | PYTHON3 |
n = int(input()); l_nr = [4, 7, 47, 74, 447, 474, 477, 747, 774]
for i in l_nr:
if n % i == 0:
print("YES")
break
else: print("NO") | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n, m, x, y, ans, a[N], s[N];
struct node {
int x, y;
node() {}
node(int xx, int yy) { x = xx, y = yy; }
};
vector<node> t[N << 2];
bool operator<(node a, node b) { return a.x == b.x ? a.y < b.y : a.x < b.x; }
node operator-(node a, node b) { return node(a.x - b.x, a.y - b.y); }
long long operator*(node a, node b) {
return 1ll * a.x * b.y - 1ll * a.y * b.x;
}
void build(int rt, int l, int r) {
if (l == r) {
t[rt].push_back(node(a[l], l * a[l] - s[l]));
return;
}
int m = l + r >> 1;
build(rt << 1, l, m);
build(rt << 1 | 1, m + 1, r);
vector<node> g(t[rt << 1].size() + t[rt << 1 | 1].size());
merge(t[rt << 1].begin(), t[rt << 1].end(), t[rt << 1 | 1].begin(),
t[rt << 1 | 1].end(), g.begin());
for (node x : g) {
while (t[rt].size() >= 2 &&
(t[rt][t[rt].size() - 2] - t[rt].back()) * (x - t[rt].back()) >= 0)
t[rt].pop_back();
t[rt].push_back(x);
}
}
int work(int rt, int k) {
int l = 0, r = t[rt].size() - 1;
while (l < r) {
int m = l + r >> 1;
if (t[rt][m].y - t[rt][m].x * k < t[rt][m + 1].y - t[rt][m + 1].x * k)
r = m;
else
l = m + 1;
}
return t[rt][r].y - t[rt][r].x * k;
}
int query(int rt, int l, int r, int L, int R) {
if (L <= l && r <= R) return work(rt, y - x);
int m = l + r >> 1, ans = 1 << 30;
if (L <= m) ans = min(ans, query(rt << 1, l, m, L, R));
if (R > m) ans = min(ans, query(rt << 1 | 1, m + 1, r, L, R));
return ans;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), s[i] = s[i - 1] + a[i];
build(1, 0, n);
scanf("%d", &m);
while (m--) {
scanf("%d%d", &x, &y);
printf("%d\n", ans = query(1, 0, n, max(y - x, 0), y) + s[y]);
}
}
| 11 | CPP |
for i in range(int(input())):
n=int(input())
if(n%4!=0):
print("NO")
else:
print("YES")
for i in range(1,n+1):
if i%2==0:
print(i,end=" ")
for i in range(1,n++2):
if i%2!=0 and i!=(n/2+1):
print(i,end=" ")
print("")
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
inline void I(long long &a) { cin >> a; }
const long long N = 1e5 + 10;
const long long LN = 17;
vector<long long> g[N];
vector<long long> t[N];
long long n;
long long val;
long long q;
long long sz[N];
long long used[N];
vector<long long> graph[N];
long long par[N][LN], dep[N];
long long parent[N];
long long ans[N];
void dfs(long long node, long long p = -1) {
par[node][0] = p;
if (p == -1)
dep[node] = 0;
else
dep[node] = dep[p] + 1;
for (auto x : g[node])
if (x != p) dfs(x, node);
}
void dfs1(long long node, long long par = -1) {
sz[node] = 1;
for (auto x : g[node])
if ((!used[x]) && x != par) {
dfs1(x, node);
sz[node] += sz[x];
}
}
long long dfs2(long long node, long long par = -1) {
for (auto x : g[node])
if (x != par && (!used[x]) && sz[x] > (val / 2)) return dfs2(x, node);
return node;
}
long long decompose(long long node, long long par = -1) {
dfs1(node);
val = sz[node];
long long centroid = dfs2(node);
if (par != -1) t[centroid].push_back(par), t[par].push_back(centroid);
used[centroid] = 1;
for (auto x : g[centroid])
if (!used[x]) decompose(x, centroid);
return centroid;
}
void dfs3(long long node, long long par = -1) {
parent[node] = par;
for (auto x : t[node])
if (x != par) dfs3(x, node);
}
long long lca(long long a, long long b) {
if (dep[a] > dep[b]) swap(a, b);
long long z = dep[b] - dep[a];
for (long long i = LN - 1; i >= 0; i--)
if (1LL << i & z) b = par[b][i];
if (a == b) return a;
for (long long i = LN - 1; i >= 0; i--)
if (par[a][i] != par[b][i]) a = par[a][i], b = par[b][i];
return par[a][0];
}
long long dist(long long u, long long v) {
long long x = lca(u, v);
return dep[u] + dep[v] - 2 * dep[x];
}
long long root;
void update(long long node) {
long long x = node;
ans[node] = 0;
while (x != root) {
x = parent[x];
ans[x] = min(ans[x], dist(node, x));
}
}
long long query(long long node) {
long long res = ans[node];
long long x = node;
while (x != root) {
x = parent[x];
res = min(res, ans[x] + dist(x, node));
}
return res;
}
void solve() {
I(n);
I(q);
long long u, v;
for (long long i = 1; i <= n - 1; i++) {
I(u);
I(v);
g[u].push_back(v);
g[v].push_back(u);
}
dfs(1);
root = decompose(1);
dfs3(root);
for (long long i = 1; i < LN; i++)
for (long long j = 1; j <= n; j++)
if (par[j][i - 1] != -1) par[j][i] = par[par[j][i - 1]][i - 1];
for (long long i = 1; i <= n; i++) ans[i] = 1e9;
update(1);
while (q--) {
I(u);
I(v);
if (u == 1)
update(v);
else
cout << query(v) << '\n';
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
void fileIO() {}
bool sortbysecdesc(const pair<long long, long long> &a,
const pair<long long, long long> &b) {
return a.second > b.second;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
fileIO();
long long T;
T = 1;
while (T--) {
long long n;
cin >> n;
long long sz = ((n * (n - 1)) / 2) - 1;
vector<pair<long long, long long>> xy(sz);
unordered_map<long long, long long> freq;
for (auto &p : xy) {
cin >> p.first >> p.second;
freq[p.first]++;
freq[p.second]++;
}
long long x1 = 0, x2 = 0;
for (auto p : freq) {
if (p.second < n - 1) {
if (x1 == 0) {
x1 = p.first;
} else {
x2 = p.first;
}
}
}
unordered_set<long long> win, lose;
for (auto p : xy) {
if (p.first == x1) {
win.insert(p.second);
}
if (p.second == x1) {
lose.insert(p.first);
}
}
long long ans1 = x1, ans2 = x2;
for (auto p : xy) {
if (p.first == x2) {
if (lose.find(p.second) != lose.end()) {
ans1 = x2;
ans2 = x1;
break;
}
}
if (p.second == x2) {
if (win.find(p.second) != win.end()) {
ans1 = x1;
ans2 = x2;
break;
}
}
}
cout << ans1 << " " << ans2;
}
return 0;
}
| 8 | CPP |
l=list(map(int,input().split()))
hi=max(l)
l.remove(hi)
print(hi-l[0],hi-l[1],hi-l[2]) | 7 | PYTHON3 |
n, m = [int(i) for i in input().split()]
ans = []
for i in range(n):
if any(m > int(k) for k in input().split()[1:]):
ans.append(i + 1)
print(len(ans))
print(*ans)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
string s;
cin >> s;
int c = 0;
for (int i = 0; i < (n - k); i++) {
if ((s[i] == '.') && (s[i + k] == '.')) {
s[i] = '0';
s[i + k] = '1';
continue;
}
if ((s[i + k] == '0') && (s[i] == '.')) {
s[i] = '1';
continue;
}
if ((s[i + k] == '1') && (s[i] == '.')) {
s[i] = '0';
continue;
}
if ((s[i] == '0') && (s[i + k] == '.')) {
s[i + k] = '1';
continue;
}
if ((s[i] == '1') && (s[i + k] == '.')) {
s[i + k] = '0';
continue;
}
}
int f = 0;
for (int i = 0; i < (n - k); i++) {
if (s[i] != s[i + k]) {
f = 1;
break;
}
}
if (f == 1) {
for (int i = 0; i < n; i++) {
if (s[i] == '.') s[i] = '0';
}
cout << s;
} else {
cout << "No";
}
return 0;
}
| 8 | CPP |
n = int(input())
a = list(map(int,input().split()))
ans = 0
while True:
for i in range(n):
b = a[i]
c = b//n
b = b%n
a[i] = b
for j in range(n):
if j == i:
continue
a[j] += c
ans += c
if max(a) < n:
break
print(ans) | 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int t, n;
int main() {
cin >> t;
while (t--) {
cin >> n;
if (n % 4 == 0) {
cout << "YES" << endl;
for (int i = 1; i <= n / 2; i++) {
cout << i * 2 << " ";
}
for (int i = 1; i < n / 2; i++) {
cout << i * 2 - 1 << " ";
}
cout << n - 1 + n / 2 << endl;
} else {
cout << "NO" << endl;
}
}
return 0;
}
| 8 | CPP |
def solve():
words = input().split()
n = len(words)
nums = [int(i) for i in words]
mmax = max(nums)
first = True
rets = []
for i in nums:
if i == mmax and first:
first = False
continue
rets.append(str(mmax - i))
print (' '.join(rets))
if __name__ == "__main__":
solve() | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long x[2005], y[2005];
long long k[2005], c[2005];
vector<pair<long long, pair<long long, long long> > > edges;
vector<pair<long long, long long> > two, fin;
vector<long long> one;
struct DSU {
int connected;
int par[200005], sz[200005];
void init(int n) {
for (int i = 0; i <= n; i++) {
par[i] = i;
sz[i] = 1;
}
connected = n;
}
int getPar(int k) {
while (k != par[k]) {
par[k] = par[par[k]];
k = par[k];
}
return k;
}
int getSize(int k) { return sz[getPar(k)]; }
void unite(int u, int v) {
int par1 = getPar(u), par2 = getPar(v);
if (par1 == par2) return;
connected--;
if (sz[par1] > sz[par2]) swap(par1, par2);
sz[par2] += sz[par1];
sz[par1] = 0;
par[par1] = par[par2];
}
};
DSU dsu;
int main() {
long long n, i, j, p, q, r, a, b, ans = 0;
cin >> n;
for (i = 1; i <= n; i++) {
cin >> x[i] >> y[i];
}
for (i = 1; i <= n; i++) {
cin >> c[i];
}
for (i = 1; i <= n; i++) {
cin >> k[i];
}
for (i = 1; i <= n; i++) {
for (j = i + 1; j <= n; j++) {
p = (k[i] + k[j]) * (abs(x[i] - x[j]) + abs(y[i] - y[j]));
edges.push_back({p, {i, j}});
}
}
for (i = 1; i <= n; i++) {
edges.push_back({c[i], {i, 0}});
}
sort(edges.begin(), edges.end());
long long sz = edges.size();
dsu.init(n);
for (i = 0; i < sz; i++) {
p = edges[i].first;
q = edges[i].second.first;
r = edges[i].second.second;
a = dsu.getPar(q);
b = dsu.getPar(r);
if (a == b) continue;
dsu.unite(q, r);
ans += p;
fin.push_back({q, r});
}
sz = fin.size();
for (i = 0; i < sz; i++) {
long long u = fin[i].first;
long long v = fin[i].second;
if (u && v) {
two.push_back({u, v});
} else {
one.push_back(u + v);
}
}
cout << ans << endl << one.size() << endl;
;
for (i = 0; i < one.size(); i++) {
cout << one[i] << ' ';
}
cout << endl;
cout << two.size() << endl;
for (i = 0; i < two.size(); i++) {
cout << two[i].first << ' ' << two[i].second << endl;
}
return 0;
}
| 10 | CPP |
n = int(input())
print(len([i for i in range(1,n) if (n-i)%i == 0])) | 7 | PYTHON3 |
pri=pow(10,9)+7
ans=[1,1]
for i in range(2,pow(10,6)+1):
ans.append(ans[-1]*i)
ans[-1]%=pri
s=int(input())
x=pow(2,s-1,pri)
print((ans[s]-x)%pri)
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, a[1010];
inline int calcupto(int now) {
int res = 0;
for (int i = 0; i <= now; ++i)
if (a[i] == 1) ++res;
for (int i = now + 1; i < n; ++i)
if (a[i] == 0) ++res;
return n - res;
}
int main() {
cin >> n;
for (int i = 0; i < n; ++i) cin >> a[i];
int res = 0;
for (int i = -1; i < n; ++i) {
if (i == -1 || a[i] == 0) {
res = max(res, calcupto(i));
}
}
if (*min_element(a, a + n) == 1) return cout << n, 0;
cout << res << '\n';
}
| 7 | CPP |
num_str = input()
numbers = list(map(int, list(num_str)))
unit = numbers[-1]
inds = []
for even in range(unit-1, -1, -2):
if str(even) in num_str:
inds.append(num_str.index(str(even)))
else:
pass
if len(inds) != 0:
found = min(inds)
temp = numbers[found]
numbers[found] = numbers[-1]
numbers[-1] = temp
print("".join(list(map(str, numbers))))
else:
inds = []
for even in range(unit+1, 9, 2):
if str(even) in num_str:
inds.append(num_str.rindex(str(even)))
else:
pass
if len(inds) != 0:
found = max(inds)
temp = numbers[found]
numbers[found] = numbers[-1]
numbers[-1] = temp
print("".join(list(map(str, numbers))))
else:
print(-1)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
void doit() {
string s;
cin >> s;
int len = s.length(), ct = 1;
string dup = s;
s = s.substr(1, len) + s.substr(0, 1);
while (dup != s) {
s = s.substr(1, len) + s.substr(0, 1);
ct++;
}
cout << ct << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(NULL);
doit();
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 9;
const long long mod = 998244353;
vector<int> g[N], nt[N];
vector<pair<int, int> > nod, fn;
int fa[N][20], dfn[N], in, t[N], p[N], s[N], sz[N], dep[N], id[N], top, stk[N];
pair<int, int> dp[N];
void dfs(int u) {
dfn[u] = ++in;
sz[u] = 1;
for (auto v : g[u]) {
if (v == fa[u][0]) continue;
fa[v][0] = u;
dep[v] = dep[u] + 1;
dfs(v);
sz[u] += sz[v];
}
}
int LCA(int u, int v) {
if (dep[u] < dep[v]) swap(u, v);
int d = dep[u] - dep[v];
for (int i = (20) - 1; i >= (0); --i)
if (d & (1 << i)) u = fa[u][i];
if (u == v) return u;
for (int i = (20) - 1; i >= (0); --i)
if (fa[u][i] != fa[v][i]) u = fa[u][i], v = fa[v][i];
return fa[u][0];
}
bool chk(int u, int v) { return dfn[u] + sz[u] - 1 >= dfn[v]; }
int dis(int u, int v) { return dep[u] + dep[v] - 2 * dep[LCA(u, v)]; }
pair<int, int> cal(int u, int x) {
int d = dis(u, t[x]);
int cu = d / s[x];
if (d % s[x]) ++cu;
return {cu, x};
}
void work(int u) {
if (!id[u])
dp[u] = {1e9, 0};
else
dp[u] = {0, id[u]};
for (auto v : nt[u]) {
work(v);
if (dp[v].second) dp[u] = min(dp[u], cal(u, dp[v].second));
}
}
void work2(int u) {
for (auto v : nt[u]) {
dp[v] = min(dp[v], cal(v, dp[u].second));
work2(v);
}
}
int main() {
int n;
scanf("%d", &n);
for (int i = (1); i < (n); ++i) {
int u, v;
scanf("%d%d", &u, &v);
g[u].push_back(v);
g[v].push_back(u);
}
dfs(1);
for (int i = (1); i < (20); ++i)
for (int j = (1); j < (n + 1); ++j) fa[j][i] = fa[fa[j][i - 1]][i - 1];
int q;
scanf("%d", &q);
while (q--) {
nod.clear();
int k, m;
scanf("%d%d", &k, &m);
for (int i = (1); i < (k + 1); ++i)
scanf("%d%d", &t[i], &s[i]), nod.push_back({dfn[t[i]], t[i]}),
id[t[i]] = i;
for (int i = (1); i < (m + 1); ++i)
scanf("%d", &p[i]), nod.push_back({dfn[p[i]], p[i]});
sort(nod.begin(), nod.end());
fn = nod;
for (int i = (0); i < (nod.size() - 1); ++i) {
int lca = LCA(nod[i].second, nod[i + 1].second);
fn.push_back({dfn[lca], lca});
}
fn.push_back({1, 1});
sort(fn.begin(), fn.end());
top = 0;
stk[top++] = fn[0].second;
for (int i = (1); i < (fn.size()); ++i) {
if (fn[i].second == fn[i - 1].second) continue;
while (!chk(stk[top - 1], fn[i].second)) --top;
nt[stk[top - 1]].push_back(fn[i].second);
stk[top++] = fn[i].second;
}
work(1);
work2(1);
for (int i = (1); i < (k + 1); ++i) id[t[i]] = 0;
for (int i = (0); i < (fn.size()); ++i) nt[fn[i].second].clear();
for (int i = (1); i < (m + 1); ++i) printf("%d ", dp[p[i]].second);
printf("\n");
}
}
| 11 | CPP |
import math
n = int(input())
a = list(map(int,input().split()))
lm = max(a)+2
x = [-1]*(lm)
for i in range(2,int(lm**0.5)+1):
if x[i] == -1:
for j in range(i,lm,i):
x[j] = i
ans = [[-1]*n for i in range(2)]
for i in range(n):
c = a[i]
if x[c] == -1:
continue
d = x[c]
while c%d == 0:
c //= d
if c != 1:
ans[0][i] = c
ans[1][i] = d
for i in ans:
print(*i)
| 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int a[N];
int main() {
int _, n, m, k, x, y;
cin >> n >> x >> y;
int ff = 0;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) {
int f = 1;
for (int j = i; j >= max(1, i - x); j--)
if (a[j] < a[i]) f = 0;
for (int j = i; j <= min(n, i + y); j++)
if (a[j] < a[i]) f = 0;
if (f) {
cout << i << endl;
break;
}
}
return 0;
}
| 7 | CPP |
n = int(input())
seq = list(map(int,input().split()))
# print(seq)
high = []
low = []
for i in range(len(seq)):
if i == 0:
high.append(seq[0])
low.append(0)
else:
if (seq[i] > seq[i-1]):
x = seq[i] - seq[i-1]
low.append(low[i-1] + x)
high.append(high[i-1]) #it is seq[i]-(low[i-1]+ x)
else:
low.append(low[i-1])
high.append(seq[i]-low[i])
# print(low, high)
ans = low + high[::-1]
print (*ans) | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long n, a[111111], l, r;
long long minn(int m, int n) {
long long ans = 1e9;
for (int i = n; i <= m; ++i) ans = min(ans, a[i]);
return ans;
}
long long maxx(int m, int n) {
long long ans = -1e9;
for (int i = n; i <= m; ++i) ans = max(ans, a[i]);
return ans;
}
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
;
l = -1e9;
r = 1e9;
cin >> n;
for (int i = 0; i < n; ++i) cin >> a[i];
string s;
cin >> s;
for (int i = 4; i < s.size(); ++i) {
if (s[i] == s[i - 1]) continue;
if (s[i] == '1') {
long long _max = maxx(i, i - 4) + 1;
l = max(_max, l);
} else {
long long _min = minn(i, i - 4) - 1;
r = min(_min, r);
}
}
cout << l << ' ' << r;
return 0;
}
| 10 | CPP |
indice = 'a'
s=0
for i in input():
s+=min((ord(indice)-ord(i))%26, 26-(ord(indice)-ord(i))%26)
indice=i
print(s)
| 7 | PYTHON3 |
import io
import os
from collections import Counter, defaultdict, deque
def solve(N, L, A):
A = [0] + A + [L] # 0 and L provide initial boost of 1
gaps = [y - x for x, y in zip(A, A[1:])]
gapsRev = gaps[::-1]
def getPos(gaps, time):
x = 0
v = 1
t = 0
for gap in gaps:
timeToCross = gap / v
if t + timeToCross >= time:
remainingTime = time - t
x += remainingTime * v
break
v += 1
x += gap
t += timeToCross
return x
def metAlready(time):
p1 = getPos(gaps, time)
p2 = getPos(gapsRev, time)
return p1 + p2 >= L
EPS = 1e-7
lo = 0
hi = 2 * (10 ** 9)
while hi - lo > EPS:
mid = (lo + hi) / 2
if metAlready(mid):
hi = mid
else:
lo = mid
return hi
if __name__ == "__main__":
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
TC = int(input())
for tc in range(1, TC + 1):
N, L = [int(x) for x in input().split()]
A = [int(x) for x in input().split()]
ans = solve(N, L, A)
print(ans)
| 9 | PYTHON3 |
n=int(input())
l=list(map(int,input().split()))
lena=(len(l))
l.sort()
left=l[:lena//2]
right=l[lena//2:]
left.sort();right.sort()
answer=[]
count=0
for i in range(len(right)):
answer.append(right[i])
if i<len(left):
answer.append(left[i])
if answer[-1]<answer[-2] and i<len(right)-1:
count+=1
print(count)
print(*answer) | 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const double EPSILON = 1e-10;
template <class T>
inline T tmin(T a, T b) {
return (a < b) ? a : b;
}
template <class T>
inline T tmax(T a, T b) {
return (a > b) ? a : b;
}
template <class T>
inline T tabs(T a) {
return (a > 0) ? a : -a;
}
template <class T>
T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int p[100001], rk[100001];
double res = 0;
struct edge {
int x, y, cost;
};
bool comp(edge e1, edge e2) { return e1.cost > e2.cost; }
void init(int n) {
for (int i = (1); i <= (n); ++i) {
rk[i] = 1;
p[i] = i;
}
}
int get(int x) {
if (p[x] != x) p[x] = get(p[x]);
return p[x];
}
void unite(int x, int y, int cost) {
int px = get(x), py = get(y);
if (px == py) return;
res += (((double)cost) * rk[px]) * rk[py];
if (rk[px] < rk[py]) {
rk[py] += rk[px];
p[px] = py;
} else {
rk[px] += rk[py];
p[py] = px;
}
}
bool same(int x, int y) { return get(x) == get(y); }
int main(int argc, char const *argv[]) {
ios_base::sync_with_stdio(false);
int n, m, x, y, a[100001];
edge e[100001];
cin >> n >> m;
init(n);
for (int i = (1); i <= (n); ++i) cin >> a[i];
for (int i = (0); i < (m); ++i) {
cin >> x >> y;
e[i] = (edge){x, y, tmin(a[x], a[y])};
}
sort(e, e + m, comp);
for (int i = (0); i < (m); ++i) {
if (same(e[i].x, e[i].y)) continue;
unite(e[i].x, e[i].y, e[i].cost);
}
cout << 2 * res / n / (n - 1) << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
string s;
long long n, a, b, c, t, z, sum = 0, sum1 = 0, sum2 = 0, ans;
cin >> n >> a >> b >> c >> t;
long long ar[n + 5];
for (long long i = 0; i < n; i++) cin >> ar[i];
if (b >= c)
cout << n * a << endl;
else {
for (long long i = 0; i < n; i++) {
sum += a + ((t - ar[i]) * c) - ((t - ar[i]) * b);
}
cout << sum << endl;
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 1e5 + 1;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t;
cin >> t;
while (t--) {
int n, k, x;
cin >> n >> k;
vector<int> v;
for (int i = 1; i <= sqrt(n); i++) {
if (n % i == 0) {
v.push_back(i);
v.push_back(n / i);
}
}
sort(v.begin(), v.end());
for (int i = v.size() - 1; i >= 0; i--) {
if (v[i] > k) {
continue;
}
x = v[i];
break;
}
cout << n / x << endl;
}
return 0;
}
| 10 | CPP |
#include <iostream>
#include <algorithm>
#include <string>
#include <vector>
typedef long long ll;
using namespace std;
int i, n, m;
ll j, c, ans, M = 1000000007;
ll inv[10000000], fac[10000000], fiv[10000000];
ll combination(ll k) {
return fac[n+k-1] * fiv[k] % M * fiv[n-1] % M;
}
int main() {
cin >> n >> m;
inv[1]=fac[1]=fiv[1]=inv[0]=fac[0]=fiv[0]=1;
for (ll j = 2; j < 10000000; j++) {
fac[j] = fac[j-1] * j % M; // n!
inv[j] = inv[M%j] * (M-M/j) % M; // n^-1
fiv[j] = fiv[j-1] * inv[j] % M; // (n!)^-1
}
i = 2;
ans = 1LL;
while (m > 1) {
if (m % i == 0) {
c = 0LL;
while (m % i == 0) {
c++; m /= i;
}
ans = ans * combination(c) % M;
} else {
i++;
}
}
cout << ans << endl;
return 0;
} | 0 | CPP |
# https://codeforces.com/problemset/problem/1148/A
a, b, c = map(int, input().split())
if a > b:
print(2 * (c + b) + 1)
elif a == b:
print(2 * (a + c))
else:
print(2 * (a + c) + 1)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
void intSort(int d[], int s) {
int i = -1, j = s, k, t;
if (s <= 1) return;
k = (d[0] + d[s - 1]) / 2;
for (;;) {
while (d[++i] < k)
;
while (d[--j] > k)
;
if (i >= j) break;
t = d[i];
d[i] = d[j];
d[j] = t;
}
intSort(d, i);
intSort(d + j + 1, s - j - 1);
}
void eratosthenes(int n, int p[]) {
int i, j;
p[0] = p[1] = 0;
for (i = 2; i < n; i++) p[i] = 1;
for (i = 4; i < n; i += 2) p[i] = 0;
for (i = 3; i * i < n; i += 2)
if (p[i])
for (j = i; i * j < n; j += 2) p[i * j] = 0;
}
int p[2000000];
int in[200000];
int main() {
int i, j, k, l, m, n, x;
int st, res;
eratosthenes(2000000, p);
while (scanf("%d%d", &n, &x) == 2) {
for (i = 0; i < n; i++) scanf("%d", in + i);
intSort(in, n);
if (x == 2) {
puts("0");
continue;
}
if (n && in[0] == 1) {
puts("1");
continue;
}
if (x >= 2000000 - 10) {
puts("-1");
continue;
}
res = 0;
st = 0;
for (i = 2; i < x; i++)
if (p[i]) {
while (st < n && in[st] < i) st++;
if (st == n || in[st] > i) {
res = -1;
break;
}
res++;
}
printf("%d\n", res);
}
return 0;
}
| 11 | CPP |
str = input()
s = str[0]
print(s.upper()+str[1:]) | 7 | PYTHON3 |
# your code goes here
tt = input()
tt = tt.split()
a = int(tt[0])
b = int(tt[1])
c = int(tt[2])
len = 0
if(c>0):
len += c*2
if(a==b):
len += a*2
if(a>b):
len += b*2 + 1
if(b>a):
len += a*2 + 1
print(len) | 7 | PYTHON3 |
res = ''
for _ in range(int(input())):
n, k = map(int, input().split())
l = 0
if k == 0:
if n%2: l = 1
elif k > n:
l = k-n
else:
if k%2 != n%2:
l = 1
res += f'{l}\n'
print(res) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 5e5 + 5, MOD = 1e9 + 7;
long long n, m, ans, x, a, b, now;
long long num[N], bin[N], inv[N], p[N], sum[N];
inline long long power(long long a, long long n) {
long long res = 1;
while (n) {
if (n & 1) res = res * a % MOD;
a = a * a % MOD;
n >>= 1;
}
return res;
}
long long C(long long x, long long y) {
if (x < 0 || y < 0) return 0;
if (x < y) return 0;
return bin[x] * inv[y] % MOD * inv[x - y] % MOD;
}
signed main() {
scanf("%lld%lld", &n, &m);
for (register long long i = 1; i <= n; ++i) scanf("%1lld", &num[i]);
for (register long long i = 1; i <= n; ++i) sum[i] = sum[i - 1] + num[i];
bin[0] = bin[1] = 1;
for (register long long i = 2; i <= n; ++i) bin[i] = (bin[i - 1] * i) % MOD;
inv[n] = 1ll * power(bin[n], MOD - 2ll);
inv[0] = 1;
for (register long long i = n - 1; i >= 1; --i)
inv[i] = inv[i + 1] * (i + 1) % MOD;
p[1] = 1;
for (register long long i = 2; i <= n; ++i) p[i] = p[i - 1] * 10 % MOD;
for (register long long i = 1; i < n; ++i)
ans = (ans + p[n - i] * sum[i] % MOD * C(i - 1, m - 1) % MOD) % MOD;
for (register long long i = 1; i <= n; ++i)
ans = (ans + num[i] * p[n - i + 1] % MOD * C(i - 1, m) % MOD) % MOD;
printf("%lld\n", ans);
return 0;
}
| 9 | CPP |
def main():
t = int(input())
while t > 0:
t -= 1
n = int(input())
v = [int(x) for x in input().split()]
mn = 1000000000
ans = 0
for i in range(n - 1, -1, -1):
if v[i] > mn:
ans += 1
mn = min(mn, v[i])
print(ans)
main() | 8 | PYTHON3 |
import sys
from math import log2, ceil
input = sys.stdin.readline
def swaparr(arr, a,b):
temp = arr[a];
arr[a] = arr[b];
arr[b] = temp
def gcd(a,b):
if a > 0:
return gcd(b%a, a)
return b
def primefs(n):
## if n == 1
if n == 1:
return 1
## calculating primes
primes = {}
while(n%2 == 0):
primes[2] = primes.get(2, 0) + 1
n = n//2
for i in range(3, int(n**0.5)+2, 2):
while(n%i == 0):
primes[i] = primes.get(i, 0) + 1
n = n//i
if n > 2:
primes[n] = primes.get(n, 0) + 1
## prime factoriazation of n is stored in dictionary primes
## DISJOINT SET UNINON FUNCTION
def swap(a, b):
temp = a
a = b
b = temp
return a,b
# find function
def find(x, link):
while(x != link[x]):
x = link[x]
return x
# the union function which makes union(x,y)
# of two nodes x and y
def union(x, y, size, link):
x = find(x, link)
y = find(y, link)
if size[x] < size[y]:
x,y = swap(x,y)
if x != y:
size[x] += size[y]
link[y] = x
## taking integer array input
def int_array():
return list(map(int, input().split()))
############ ---------------- TEMPLATE ENDS HERE ---------------- ############
for __ in range(int(input())):
n, k = int_array()
string = input()
a = [[0 for _ in range(26)] for _ in range(k)]
for i in range(n):
a[i % k][ord(string[i])-ord('a')] += 1
ans = 0
for i in range(ceil(k/2)):
this = [0]*26;
for j in range(26):
if k%2 !=0 and i == k//2:
this[j] = a[i][j]
else:
this[j] = a[i][j] + a[k-i-1][j]
ans += sum(this)-max(this)
print(ans) | 9 | PYTHON3 |
t = int(input())
for _ in range(t):
n = int(input())
if n % 2 == 0:
print(n//2 - 1)
continue
else:
print(n//2) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int MX = 100005;
struct edge {
int to, nxt;
} e[MX << 1];
int n, m, h, val[MX], head[MX], tot, dfn[MX], low[MX], cnt, stk[MX], top;
int num, blt[MX], siz[MX], out[MX], ans = 1e9, id;
bool ins[MX];
inline void add(int u, int v) { e[++tot] = (edge){v, head[u]}, head[u] = tot; }
inline void Tarjan(int u) {
low[u] = dfn[u] = ++cnt;
stk[++top] = u, ins[u] = 1;
for (int i = head[u]; i; i = e[i].nxt)
if (!dfn[e[i].to])
Tarjan(e[i].to), low[u] = min(low[u], low[e[i].to]);
else if (ins[e[i].to])
low[u] = min(low[u], dfn[e[i].to]);
if (dfn[u] == low[u]) {
++num;
do blt[stk[top]] = num, siz[num]++;
while (stk[top--] != u);
}
}
int main() {
ios::sync_with_stdio(0);
scanf("%d%d%d", &n, &m, &h);
for (int i = 1; i <= n; i++) scanf("%d", val + i);
for (int i = 1, u, v; i <= m; i++) {
scanf("%d%d", &u, &v);
if ((val[u] + 1) % h == val[v]) add(u, v);
if ((val[v] + 1) % h == val[u]) add(v, u);
}
for (int i = 1; i <= n; i++)
if (!dfn[i]) Tarjan(i);
for (int i = 1; i <= n; i++)
for (int j = head[i]; j; j = e[j].nxt)
if (blt[i] != blt[e[j].to]) out[blt[i]]++;
for (int i = 1; i <= num; i++)
if (!out[i])
if (ans > siz[i]) ans = siz[i], id = i;
cout << ans << endl;
for (int i = 1; i <= n; i++)
if (blt[i] == id) cout << i << ' ';
return 0;
}
| 9 | CPP |
#include "iostream"
#include "climits"
#include "list"
#include "queue"
#include "stack"
#include "set"
#include "functional"
#include "algorithm"
#include "string"
#include "map"
#include "unordered_map"
#include "unordered_set"
#include "iomanip"
#include "cmath"
#include "random"
#include "bitset"
#include "cstdio"
#include "numeric"
#include "cassert"
#include "ctime"
using namespace std;
constexpr long long int MOD = 1000000007;
//constexpr int MOD = 1000000007;
//constexpr int MOD = 998244353;
//constexpr long long int MOD = 998244353;
constexpr double EPS = 1e-12;
//int N, M, K, T, H, W, L, R;
long long int N, M, K, T, H, W, L, R;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> H >> W;
vector<string>s(H);
for (auto &i : s)cin >> i;
vector<int>xnum(W);
vector<int>ynum(H);
for (int i = 0; i < H; i++) {
for (int j = 0; j < W; j++) {
if (s[i][j] != '.') {
xnum[j]++;
ynum[i]++;
}
}
}
int ans = 0;
for (int loop = 0; loop < 26; loop++) {
for (int i = 0; i < H; i++) {
for (int j = 0; j < W; j++) {
if (!ynum[i] && !xnum[j])continue;
if (s[i][j] != '.')continue;
int ay, ax, by, bx, cy, cx, dy, dx;
ay = by = cy = dy = i, ax = bx = cx = dx = j;
while (ay >= 0 && s[ay][ax] == '.') ay--;
while (by < H&&s[by][bx] == '.')by++;
while (cx >= 0 && s[cy][cx] == '.')cx--;
while (dx < W && s[dy][dx] == '.')dx++;
if (ay >= 0 && by < H&&s[ay][ax] == s[by][bx]&&s[ay][ax]!='.') {
ynum[ay]--;
ynum[by]--;
xnum[ax]--;
xnum[bx]--;
s[ay][ax] = s[by][bx] = '.';
ans += 2;
}
if (ay >= 0 && cx >= 0 && s[ay][ax] == s[cy][cx] && s[ay][ax] != '.') {
ynum[ay]--;
ynum[cy]--;
xnum[ax]--;
xnum[cx]--;
s[ay][ax] = s[cy][cx] = '.';
ans += 2;
}
if (ay >= 0 && dx < W && s[ay][ax] == s[dy][dx] && s[ay][ax] != '.') {
ynum[ay]--;
ynum[dy]--;
xnum[ax]--;
xnum[dx]--;
s[ay][ax] = s[dy][dx] = '.';
ans += 2;
}
if (by < H && cx >= 0 && s[by][bx] == s[cy][cx] && s[by][bx] != '.') {
ynum[by]--;
ynum[cy]--;
xnum[bx]--;
xnum[cx]--;
s[by][bx] = s[cy][cx] = '.';
ans += 2;
}
if (by < H && dx < W && s[by][bx] == s[dy][dx] && s[by][bx] != '.') {
ynum[by]--;
ynum[dy]--;
xnum[bx]--;
xnum[dx]--;
s[by][bx] = s[dy][dx] = '.';
ans += 2;
}
if (cx >= 0 && dx < W && s[cy][cx] == s[dy][dx] && s[cy][cx] != '.') {
ynum[cy]--;
ynum[dy]--;
xnum[cx]--;
xnum[dx]--;
s[cy][cx] = s[dy][dx] = '.';
ans += 2;
}
}
}
}
cout << ans << endl;
}
| 0 | CPP |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("Ofast,unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
const int MOD = (int)1e9 + 7;
const int N = (int)3e6 + 5;
int T;
int n, q, first;
int f[N + 5], invf[N + 5];
long long ans[N + 5][3];
int lgput(int n, int p) {
int ans = 1, first = n;
while (p) {
if (p & 1) ans = 1LL * ans * first % MOD;
first = 1LL * first * first % MOD;
p >>= 1;
}
return ans;
}
void precalc() {
f[0] = invf[0] = 1;
for (int i = 1; i <= N; i++) f[i] = 1LL * f[i - 1] * i % MOD;
invf[N] = lgput(f[N], MOD - 2);
for (int i = N - 1; i >= 1; i--) invf[i] = 1LL * invf[i + 1] * (i + 1) % MOD;
}
int comb(int n, int k) {
if (k < 0 || n < 0 || n < k) return 0;
int ans = 1LL * f[n] * invf[k] % MOD;
return 1LL * ans * invf[n - k] % MOD;
}
void solve() {
cin >> n >> q;
ans[0][0] = n + 1;
ans[0][1] = n;
ans[0][2] = n;
for (int i = 1; i <= 3 * n; i++) {
int s = (comb(3 * n + 1, i + 1) + 2LL * comb(3 * n + 1, i)) % MOD;
ans[i][0] = (s - ans[i - 1][1] + MOD) % MOD;
ans[i][0] = (ans[i][0] - 2LL * ans[i - 1][0] + 2LL * MOD) % MOD;
ans[i][0] = 1LL * lgput(3, MOD - 2) * ans[i][0] % MOD;
ans[i][1] = (ans[i][0] + ans[i - 1][0]) % MOD;
ans[i][1] = (ans[i][1] - comb(3 * n + 1, i) + MOD) % MOD;
ans[i][2] = (ans[i][1] + ans[i - 1][1]) % MOD;
}
for (; q; q--) {
cin >> first;
cout << ans[first][0] << "\n";
}
}
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
T = 1;
precalc();
for (; T; T--) {
solve();
}
return 0;
}
| 9 | CPP |
#define __USE_MINGW_ANSI_STDIO 0
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define int ll
using VI = vector<int>;
using VVI = vector<VI>;
using PII = pair<int, int>;
#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()
#define PB push_back
const ll LLINF = (1LL<<60);
const int INF = (1LL<<30);
const int MOD = 1000000007;
template <typename T> T &chmin(T &a, const T &b) { return a = min(a, b); }
template <typename T> T &chmax(T &a, const T &b) { return a = max(a, b); }
template <typename T> bool IN(T a, T b, T x) { return a<=x&&x<b; }
template<typename T> T ceil(T a, T b) { return a/b + !!(a%b); }
template<class S,class T>
ostream &operator <<(ostream& out,const pair<S,T>& a){
out<<'('<<a.first<<','<<a.second<<')';
return out;
}
template<class T>
ostream &operator <<(ostream& out,const vector<T>& a){
out<<'[';
REP(i, a.size()) {out<<a[i];if(i!=a.size()-1)out<<',';}
out<<']';
return out;
}
int dx[] = {0, 1, 0, -1}, dy[] = {1, 0, -1, 0};
signed main(void)
{
cin.tie(0);
ios::sync_with_stdio(false);
int x;
cin >> x;
cout << "ai1333" << string(x/100, '3') << endl;
return 0;
}
| 0 | CPP |
n = int(input())
x = 0
y=0
z=0
i = 0
while i < n:
inp1 , inp2 , inp3 = map(int , input().split())
x+=inp1
y+=inp2
z+=inp3
i=i+1
if x == 0 and y ==0 and x==0 : print('YES')
else :print('NO')
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
void func(vector<int>& a, vector<int>& b) {
int a1 = (a[0] * 1LL * b[0] % 1000000007 + a[1] * 1LL * b[2] % 1000000007) %
1000000007;
int a2 = (a[0] * 1LL * b[1] % 1000000007 + a[1] * 1LL * b[3] % 1000000007) %
1000000007;
int a3 = (a[2] * 1LL * b[0] % 1000000007 + a[3] * 1LL * b[2] % 1000000007) %
1000000007;
int a4 = (a[2] * 1LL * b[1] % 1000000007 + a[3] * 1LL * b[3] % 1000000007) %
1000000007;
a[0] = a1;
a[1] = a2;
a[2] = a3;
a[3] = a4;
}
int modpow(int a, int b) {
int c = 1;
while (b) {
if (b & 1) c = 1LL * c * a % 1000000007;
a = 1LL * a * a % 1000000007;
b >>= 1;
}
return c;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
vector<int> a(4), b(4), c(4), I(4);
a[0] = 1;
a[1] = 0;
a[2] = 0;
a[3] = 1;
b[0] = 0;
b[1] = 2;
b[2] = 1;
b[3] = 1;
c[0] = 0;
c[1] = 1;
c[2] = 1;
c[3] = 1;
I = a;
int n1;
cin >> n1;
vector<long long int> v(n1);
for (int i = 0; i < n1; i++) cin >> v[i];
for (int i = 0; i < n1; i++) {
long long int n = v[i];
a = I;
while (n > 0) {
if (n & 1) func(a, b);
n >>= 1;
func(b, b);
}
b = a;
}
int mp = 1, p = 2;
for (int i = 0; i < n1; i++) {
long long int n = v[i];
mp = 1;
while (n > 0) {
if (n & 1) mp = mp * 1LL * p % 1000000007;
n >>= 1;
p = p * 1LL * p % 1000000007;
}
p = mp;
}
func(c, a);
int inv = modpow(2, 1000000007 - 2);
mp = mp * 1LL * inv % 1000000007;
int imp = ((mp - c[0]) % 1000000007 + 1000000007) % 1000000007;
cout << imp << "/" << mp << endl;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int arr[1001] = {0};
for (int i = 0; i < n; i++) {
int x;
cin >> x;
arr[x] += 1;
}
bool ans = true;
for (int i = 0; i < 1001; i++) {
if (arr[i] > (n + 1) / 2) {
ans = false;
}
}
if (ans) {
cout << "YES\n";
} else {
cout << "NO\n";
}
return 0;
}
| 7 | CPP |
n=int(input())
l=[]
for i in range(n):
w=input()
l.append(w)
for i in range(n):
if len(l[i])>10:
w=str(len(l[i])-2)
print(l[i][0]+w+l[i][-1])
else:
print(l[i])
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, p, m, a[100000], b[100000], q, r;
cin >> n >> m >> q >> r;
for (p = 0; p < n; p++) cin >> a[p];
for (p = 0; p < m; p++) cin >> b[p];
if (b[m - r] > a[q - 1])
cout << "YES\n";
else
cout << "NO\n";
return 0;
}
| 7 | CPP |
#include <iostream>
#include <string>
#include <algorithm>
#include <functional>
#include <vector>
#include <utility>
#include <cstring>
#include <iomanip>
#include <numeric>
#include <cmath>
#include <queue>
#include <map>
using namespace std;
typedef long long ll;
const int INF = 1<<30;
const int MOD = 1e9 + 7;
const int dy[] = {1, 0, -1, 0};
const int dx[] = {0, 1, 0, -1};
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
int q;
cin >> q;
map<string, int> mp;
for(int i = 0; i < q; i++)
{
int com, x;
string key;
cin >> com;
if(com == 0)
{
cin >> key >> x;
mp[key] = x;
}
else if(com == 1)
{
cin >> key;
auto itr = mp.find(key);
if(itr != mp.end()) cout << itr->second << endl;
else cout << 0 << endl;
}
else if(com == 2)
{
cin >> key;
mp.erase(key);
}
if(com == 3)
{
string l, r;
cin >> l >> r;
auto left = mp.lower_bound(l);
auto right = mp.upper_bound(r);
while(left != right)
{
cout << left->first << " " << left->second << endl;
left++;
}
}
}
return 0;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long a,b,c,k;
int main()
{
cin>>a>>b>>c>>k;
if(k<=a) cout<<k;
else if(k<=a+b) cout<<a;
else cout<<a-(k-a-b);
return 0;
} | 0 | CPP |
#include<bits/stdc++.h>
using namespace std;
#define FOR(i,a,b) for (int i=(a);i<(b);i++)
#define RFOR(i,a,b) for (int i=(b)-1;i>=(a);i--)
#define REP(i,n) for (int i=0;i<(n);i++)
#define RREP(i,n) for (int i=(n)-1;i>=0;i--)
#define ALL(a) (a).begin(),(a).end()
const int INF = INT_MAX/3;
const double EPS = 1e-14;
template<typename U, typename T>
void chmin(U &x, T y) { x = min(x, y); }
template<typename U, typename T>
void chmax(U &x, T y) { x = max(x, y); }
typedef long long int lli;
typedef long double ld;
int phi(int n) {
int sum = 0;
for (int i = 1; i <= n; ++i) {
if (n % i == 0) sum++;
}
return sum;
}
int main() {
int n;
cin >> n;
int i = 1;
while (phi(i) != n) { i++; }
cout << i << endl;
return 0;
} | 0 | CPP |
n,x,y = [int(it) for it in input().split()]
arr=[]
adj=False
for i in range(n):
x_,y_=[int(it) for it in input().split()]
arr.append([x_,y_])
if x_ == x:
adj = True
print(len(set([(it[1]-y)/(it[0]-x) for it in arr if it[0] != x]))+(1 if adj else 0))
| 8 | PYTHON3 |
#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <cmath>
using namespace std;
int same(string s, string s2) {
int ans = 0;
int sz = s.size();
int sz2 = s2.size();
for (int i = 0; i < min(sz, sz2); i++) {
if (s[i] == s2[i]) {
ans++;
}
else {
break;
}
}
return ans;
}
int main() {
int n;
while (cin >> n) {
if (n == 0) {
break;
}
string s;
vector<string> id;
for (int i = 0; i < n; i++) {
cin >> s;
string ss = "";
ss += s[0];
for (int j = 0; j+1 < s.size(); j++) {
if (s[j] == 'a' || s[j] == 'e' || s[j] == 'i' || s[j] == 'o' || s[j] == 'u') {
ss += s[j + 1];
}
}
id.push_back(ss);
//cout << id[i] << endl;
}
sort(id.begin(), id.end());
bool h = true;
int MM = 0;
for (int i = 0; i < id.size(); i++) {
for (int j = i + 1; j < id.size(); j++) {
MM = max(MM, same(id[i], id[j]));
if (id[i] == id[j]) {
h = false;
}
}
}
if (!h) {
cout << -1 << endl;
}
else {
cout << MM + 1 << endl;
}
}
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int main() {
cin >> n >> m;
if (n == 0) {
cout << 0 << " " << 1 << endl;
cout << 0 << " " << m << endl;
cout << 0 << " " << 0 << endl;
cout << 0 << " " << m - 1 << endl;
return 0;
}
if (m == 0) {
cout << 1 << " " << 0 << endl;
cout << n << " " << 0 << endl;
cout << 0 << " " << 0 << endl;
cout << n - 1 << " " << 0 << endl;
return 0;
}
if (m >= n) {
if ((sqrt(n * n + m * m) * 2 + m) >
(sqrt((n - 1) * (n - 1) + m * m) * 2 + sqrt(n * n + m * m))) {
cout << 0 << " " << m << endl;
cout << n << " " << 0 << endl;
cout << n << " " << m << endl;
cout << 0 << " " << 0 << endl;
return 0;
} else {
cout << 1 << " " << 0 << endl;
cout << n << " " << m << endl;
cout << 0 << " " << 0 << endl;
cout << n - 1 << " " << m << endl;
return 0;
}
} else {
if ((sqrt(n * n + m * m) * 2 + n) >
(sqrt((m - 1) * (m - 1) + n * n) * 2 + sqrt(n * n + m * m))) {
cout << 0 << " " << 0 << endl;
cout << n << " " << m << endl;
cout << 0 << " " << m << endl;
cout << n << " " << 0 << endl;
return 0;
} else {
cout << n << " " << m - 1 << endl;
cout << 0 << " " << 0 << endl;
cout << n << " " << m << endl;
cout << 0 << " " << 1 << endl;
return 0;
}
}
}
| 8 | CPP |
import sys
input = sys.stdin.readline
N, K = map(int, input().split())
A = [int(i) for i in input().split()]
last = dict()
v = [-1] * N
for i, a in enumerate(A + A) :
if a in last and last[a] < N :
v[last[a]] = i + 1
last[a] = i
dist = [-1] * N
cur = 0
cycle = 0
while dist[cur] < 0 :
dist[cur] = cycle
cycle += v[cur] - cur
cur = v[cur] % N
NK = N * K
m = NK % cycle
cur = v[cur] % N
s = 0
while m > dist[cur] > 0 :
s = dist[cur]
cur = v[cur] % N
m -= s
ret = []
seen = set()
for a in A[N-m:] :
if a in seen :
p = ret.pop()
seen.remove(a)
while p != a :
seen.remove(p)
p = ret.pop()
else :
ret.append(a)
seen.add(a)
print(' '.join([str(i) for i in ret])) | 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long int;
const int MOD = 1e9 + 7;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int t;
cin >> t;
while (t-- > 0) {
ll n, W;
cin >> n >> W;
ll lower_bound = ceil(W / 2.0);
ll upper_bound = W;
vector<pair<ll, ll> > w(n);
for (int i = 0; i < int(n); i++) {
ll temp;
cin >> temp;
w[i] = {temp, i};
}
sort(w.begin(), w.end());
if (w[0].first > W)
cout << -1 << '\n';
else {
bool found = false;
for (auto i : w) {
if (i.first >= lower_bound && i.first <= upper_bound) {
cout << 1 << '\n';
cout << i.second + 1 << '\n';
found = true;
break;
}
}
if (found) {
continue;
} else {
vector<pair<ll, ll> > new_w;
for (auto i : w) {
if (i.first > upper_bound)
break;
else
new_w.push_back(i);
}
if (new_w.empty()) {
cout << -1 << '\n';
} else {
vector<ll> prefix;
prefix.push_back(new_w[0].first);
for (int i = 1; i < new_w.size(); i++)
prefix.push_back(prefix[prefix.size() - 1] + new_w[i].first);
for (int i = 0; i < prefix.size(); i++) {
if (prefix[i] >= lower_bound && prefix[i] <= upper_bound) {
cout << i + 1 << '\n';
for (int j = 0; j <= i; j++) cout << new_w[j].second + 1 << ' ';
cout << '\n';
found = true;
break;
}
}
if (!found) {
cout << -1 << '\n';
}
}
}
}
}
}
| 7 | CPP |
H, W = map(int, input().split())
AB = []
max_ab = 0
for i in range(H):
AB.append(list(map(int, input().split())))
max_ab = max(max_ab, max(AB[-1]))
for i in range(H):
AB[i] = [abs(AB[i][j] - int(b)) for j, b in enumerate(input().split())]
base = max_ab*(H + W)
dp = [[1 << base for w in range(W)] for h in range(H)]
dp[0][0] = (1 << base + AB[0][0]) | (1 << base - AB[0][0])
for h in range(1, H):
dp[h][0] = (dp[h-1][0] << AB[h][0]) | (dp[h-1][0] >> AB[h][0])
for w in range(1, W):
dp[0][w] = (dp[0][w-1] << AB[0][w]) | (dp[0][w-1] >> AB[0][w])
for h in range(1, H):
for w in range(1, W):
dp[h][w] = (
(dp[h-1][w] << AB[h][w]) | (dp[h-1][w] >> AB[h][w])
| (dp[h][w-1] << AB[h][w]) | (dp[h][w-1] >> AB[h][w]))
positive = bin(dp[H-1][W-1] >> base)
print(positive[::-1].find('1')) | 0 | PYTHON3 |
n=int(input())
l = list(map(int,input().split()))
b =l.copy()
l.sort()
l.reverse()
for i in b:
print(l.index(i)+1,end = " ") | 7 | PYTHON3 |
#include <stdio.h>
#include <utility>
#include <algorithm>
#define inf 10e8
typedef long long ll;
int main(void) {
ll i, j, k, n, ans, max;
scanf("%lld", &n);
std::pair<ll, ll> p[n];
ll sum[n];
for(i = 0; i < n; ++i) scanf("%lld%lld", &p[i].first, &p[i].second);
std::sort(p, p + n);
sum[0] = p[0].second;
for(i = 1; i < n; ++i) sum[i] = sum[i - 1] + p[i].second;
ans = sum[0];
max = p[0].first;
for(i = 1; i < n; ++i) {
if(max < p[i].first - sum[i - 1]) max = p[i].first - sum[i - 1];
if(ans < sum[i] - p[i].first + max) ans = sum[i] - p[i].first + max;
}
printf("%lld\n", ans);
return 0;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct debugger {
template <typename T>
debugger &operator,(const T &v) {
cerr << v << "\t";
return *this;
}
} dbg;
template <class T>
void setmax(T &a, T b) {
if (a < b) a = b;
}
template <class T>
void setmin(T &a, T b) {
if (b < a) a = b;
}
template <class T>
T Abs(T x) {
return x > 0 ? x : -x;
}
template <class T>
inline T sqr(T x) {
return x * x;
}
template <class T>
inline T Mod(T n, T m) {
return (n % m + m) % m;
}
template <class T>
string toString(T n) {
ostringstream oss;
oss << n;
oss.flush();
return oss.str();
}
long long toInt(string s) {
long long r = 0;
istringstream sin(s);
sin >> r;
return r;
}
bool isVowel(char ch) {
ch = tolower(ch);
if (ch == 'a' || ch == 'e' || ch == 'i' || ch == 'o' || ch == 'u')
return true;
return false;
}
bool isUpper(char c) { return c >= 'A' && c <= 'Z'; }
bool isLower(char c) { return c >= 'a' && c <= 'z'; }
long long Pow(long long B, long long P) {
long long R = 1;
while (P > 0) {
if (P % 2 == 1) R = (R * B);
P /= 2;
B = (B * B);
}
return R;
}
long long BigMod(long long B, long long P, long long M) {
long long R = 1;
while (P > 0) {
if (P % 2 == 1) {
R = (R * B) % M;
}
P /= 2;
B = (B * B) % M;
}
return R;
}
void binprint(long long mask, long long n) {
long long i;
string s = "";
do {
s += (mask % 2 + '0');
mask /= 2;
} while (mask);
reverse(s.begin(), s.end());
s = string(max(n - (int)s.size(), 0LL), '0') + s;
for (i = (int)s.size() - n; i < (int)s.size(); i++) printf("%c", s[i]);
printf("\n");
}
void ASCII_Chart() {
long long i, j;
int k;
printf("ASCII Chart:(30-129)\n");
for (i = 30; i < 50; i++) {
for (j = 0; j < 5; j++) {
k = i + j * 20;
printf("%3d---> '%c' ", k, k);
}
printf("\n");
}
}
struct Edg {
long long u, v, rev, cap, w, f;
Edg(long long u = 0, long long v = 0, long long cap = 0, long long w = 0,
long long rev = 0) {
this->u = u;
this->v = v;
this->cap = cap;
this->w = w;
this->rev = rev;
f = 0;
}
};
const long long inf = 1000LL * 9999999999LL;
int edgNo;
vector<Edg> edgs;
vector<int> g[2010];
int source, sink, N;
long long potential[2010], dis[2010], par[2010];
int mat[2010][2010];
Edg ea, eb;
int st[1001], ft[1001], c[1001];
int final[1001];
struct pq {
long long nod, cst;
pq(long long nod = 0, long long cst = 0) {
this->nod = nod;
this->cst = cst;
}
bool operator<(const pq &b) const { return cst > b.cst; }
};
priority_queue<pq> Q;
void addEdge(int u, int v, int cap, int w) {
ea = Edg(u, v, cap, w, edgNo + 1);
eb = Edg(v, u, 0, -w, edgNo);
edgs.push_back(ea);
edgs.push_back(eb);
g[u].push_back(edgNo);
g[v].push_back(edgNo + 1);
edgNo += 2;
}
bool isPath(int s, int t) {
long long up = 1, e = 1, i, j, u, v, cap, cst, val;
pq U;
for (i = 1; i <= N; i++) dis[i] = inf;
dis[0] = 0;
Q.push(pq(s, 0));
while (!Q.empty()) {
U = Q.top();
Q.pop();
u = U.nod;
cst = U.cst;
if (cst > dis[u]) continue;
for (i = 0; i < (int)g[u].size(); i++) {
e = g[u][i];
v = edgs[e].v;
cst = edgs[e].w;
cap = edgs[e].cap;
val = potential[u] - potential[v] + cst + dis[u];
if (cap > 0 && dis[v] > val) {
dis[v] = val;
Q.push(pq(v, val));
par[v] = e;
}
}
}
for (i = 0; i <= N; i++) potential[i] += dis[i];
return dis[t] < inf;
}
void update(int u) {
if (!u) return;
Edg &a = edgs[par[u]];
Edg &b = edgs[a.rev];
a.f++;
b.f--;
a.cap -= 1;
b.cap += 1;
mat[a.u][a.v] = 1;
update(a.u);
}
void ff(int m) {
long long up = 1, e = 1, i, j, u, v, t, cst, ks = 1, val;
while (up) {
up = 0;
for (i = 0; i <= N; i++) {
for (j = 0; j < (int)g[i].size(); j++) {
e = g[i][j];
u = edgs[e].u;
v = edgs[e].v;
cst = edgs[e].w;
t = edgs[e].cap;
val = potential[u] + cst;
if (t > 0 && potential[v] > val) {
potential[v] = val;
up = 1;
}
}
}
}
while (m-- && isPath(0, N)) {
update(N);
}
}
map<int, int> mp;
int main() {
int i, j, test, Case = 1, k, n, m, u, v;
scanf("%d%d", &n, &m);
for (i = 0; i < n; i++) {
scanf("%d%d%d", &st[i], &ft[i], &c[i]);
ft[i] += st[i];
mp[st[i]] = 0;
mp[ft[i]] = 0;
}
N = 0;
edgNo = 0;
for (__typeof((mp).begin()) I = (mp.begin()); I != (mp).end(); ++I)
I->second = N++;
N--;
source = 0;
sink = N;
for (i = 0; i < n; i++) {
final[i] = edgNo;
u = mp[st[i]];
v = mp[ft[i]];
addEdge(u, v, 1, -c[i]);
}
for (map<int, int>::iterator ita, itb = mp.begin(); itb != mp.end();) {
ita = itb;
itb++;
if (itb == mp.end()) break;
addEdge(ita->second, itb->second, m, 0);
}
ff(m);
m = 0;
for (i = 0; i < n; i++) {
if (m++) printf(" ");
j = final[i];
if (edgs[j].f > 0)
printf("1");
else
printf("0");
}
printf("\n");
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, i, ans, h[100005], l[100005], r[100005];
int main() {
scanf("%d", &n);
for (i = 1; i <= n; ++i) scanf("%d", h + i);
for (i = 1; i <= n; ++i) l[i] = min(l[i - 1] + 1, h[i]);
for (i = n; i >= 1; --i) r[i] = min(r[i + 1] + 1, h[i]);
for (i = 1; i <= n; ++i) ans = max(ans, min(l[i], r[i]));
printf("%d", ans);
return 0;
}
| 10 | CPP |
#!/usr/bin/python
import sys
def solve(T, A):
if T > 2100:
A = A[:2100]
T = min(T, 2100)
sum_dict = {}
for i in range(T-1):
for j in range(i+1,T):
if (A[i]+A[j]) in sum_dict.keys():
for elem in sum_dict[A[i]+A[j]]:
if elem[0] != i and elem[0] != j and elem[1] != i and elem[1] != j:
print("YES")
return " ".join([str(elem[0]+1), str(elem[1]+1), str(i+1), str(j+1)])
sum_dict[A[i]+A[j]].append((i,j))
else:
sum_dict[A[i]+A[j]] = [(i,j)]
return "NO"
def run():
out = ""
T = int(input())
A = [int(x) for x in input().split()]
print(solve(T, A))
run() | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000;
int a[maxn];
int n, k, p, x, y, sum = 0;
int main() {
ios::sync_with_stdio(false);
cin >> n >> k >> p >> x >> y;
for (int i = 0; i < k; i++) cin >> a[i];
for (int i = 0; i < k; i++) sum += a[i];
int count = 0;
for (int i = 0; i < k; i++)
if (a[i] < y) count++;
int l = n / 2 - count < n - k ? n / 2 - count : n - k;
int m = n - k - l;
if (l < 0 || sum + l + m * y > x)
cout << "-1";
else {
while (m--) cout << y << ' ';
while (l--) cout << 1 << ' ';
}
return 0;
}
| 8 | CPP |
# -*- coding: utf-8 -*-
import random
import sys
import os
class Tree:
def __init__(self):
self.root = None
def __str__(self):
if self.root == None:
return None
else:
return "TODO"
def print_inorder(self):
self.inorder_list = []
self.__inorder(self.root)
return self.inorder_list
def __inorder(self, node):
"""
:param node: Node
:return:
"""
if node is None:
return
else:
self.__inorder(node.left)
self.inorder_list.append(node.key)
self.__inorder(node.right)
def print_preorder(self):
self.preorder_list = []
self.__preorder(self.root)
return self.preorder_list
def __preorder(self, node):
"""
:param node: Node
:return:
"""
if node is None:
return
else:
self.preorder_list.append(node.key)
self.__preorder(node.left)
self.__preorder(node.right)
def insert(self, node):
"""
:param node: Node
:return:
"""
if self.root is None:
self.root = node
else:
x = self.root
parent_candidate = x
while x is not None:
parent_candidate = x
if x.key > node.key:
x = x.left
else:
x = x.right
# child to parent link
x = node
x.parent = parent_candidate
# parent to child link
if x.key < x.parent.key:
x.parent.left = x
else:
x.parent.right = x
def find(self, value):
"""
:param value:
:rtype: Node
:return:
"""
x = self.root
while x is not None and x.key != value:
if x.key > value:
x = x.left
else:
x = x.right
return x
def delete(self, value):
found_node = self.find(value)
if found_node is None:
print("value is nothing")
else:
# has no child
if found_node.is_leaf():
# delete link from parent
# print(found_node.parent.left.key)
# print(found_node.key)
if found_node.parent.left is not None and found_node.parent.left.key == found_node.key:
found_node.parent.left = None
else:
found_node.parent.right = None
else:
# has one child
if found_node.has_one_child():
one_child = found_node.get_one_child()
# change link to parent
one_child.parent = found_node.parent
# chagne link from parent
if found_node.parent.left == found_node:
found_node.parent.left = one_child
else:
found_node.parent.right = one_child
# has two child
else:
next_section_point = found_node.get_next_section_point()
# ?¬???????????????????????????????????????????????¬?????????????????????? p217
# ????????????
key = next_section_point.key
self.delete(next_section_point.key)
found_node.key = key
class Node:
def __init__(self, key):
self.parent = None # type: Node
self.left = None # type: Node
self.right = None # type: Node
self.key = key # type: int
def has_one_child(self):
if self.left is None and self.right is not None:
return True
elif self.left is not None and self.right is None:
return True
else:
return False
def get_one_child(self):
if not self.has_one_child():
return None
else:
if self.left is not None:
return self.left
else:
return self.right
def get_next_section_point(self):
"""?¬??????????????????????"""
# ????????????????????´???
if self.right is not None:
return self.right.get_minimum()
# ???????????????????????´???????¬???????????????´?????????
else:
# ?
return self.parent
def is_leaf(self):
if self.left is None and self.right is None:
return True
else:
return False
def get_minimum(self):
if self.left is None:
return self
else:
return self.left.get_minimum()
tree = Tree()
s = input()
n = int(s)
for _ in range(n):
s = input()
if 'insert' in s:
value = int(s.split(" ")[-1])
node = Node(value)
tree.insert(node)
if 'print' in s:
in_list = tree.print_inorder()
in_list = map(str, in_list)
print(' ' + ' '.join(in_list))
pre_list = tree.print_preorder()
pre_list = map(str, pre_list)
print(' ' + ' '.join(pre_list))
if 'find' in s:
value = int(s.split(" ")[-1])
node = tree.find(value)
if node is None:
print('no')
else:
print('yes')
if 'delete' in s:
value = int(s.split(" ")[-1])
tree.delete(value) | 0 | PYTHON3 |
from sys import *
from math import *
from sys import stdin,stdout
from collections import *
int_arr = lambda : list(map(int,stdin.readline().strip().split()))
str_arr = lambda :list(map(str,stdin.readline().split()))
get_str = lambda : map(str,stdin.readline().strip().split())
get_int = lambda: map(int,stdin.readline().strip().split())
get_float = lambda : map(float,stdin.readline().strip().split())
mod = 1000000007
setrecursionlimit(1000)
lst = [i for i in range(1,51)]
l = len(lst)
def ans(l,n,x,y,lst):
for i in range(l):
if (y - x) % lst[i] == 0 and (((y - x) // lst[i]) - 1) <= (n - 2):
val = lst[i]
break
res = [x,y]
ct = 2
y1,x1 = y,x
#print(val)
while ct != n:
if (y - val) > x1:
y -= val
ct += 1
res.append(y)
elif x - val > 0:
x -= val
ct += 1
res.append(x)
else:
y1 += val
ct += 1
res.append(y1)
print(*res)
for _ in range(int(input())):
n,x,y = get_int()
ans(l,n,x,y,lst)
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int prevc[26], nextc[26];
bool isE[26];
char s[100001];
bool read_data() {
int n;
memset(prevc, 0xff, sizeof(prevc));
memset(nextc, 0xff, sizeof(nextc));
memset(isE, 0, sizeof(isE));
cin >> n;
while (n--) {
scanf(" %s", s);
int len = strlen(s);
for (int i = 0; i < len; i++) {
int c = (s[i] - 'a');
isE[c] = true;
if (i != 0) {
if (prevc[c] == -1 || prevc[c] == (s[i - 1] - 'a'))
prevc[c] = (s[i - 1] - 'a');
else
return false;
}
if (i != len - 1) {
if (nextc[c] == -1 || nextc[c] == (s[i + 1] - 'a'))
nextc[c] = (s[i + 1] - 'a');
else
return false;
}
}
}
return true;
}
bool valid() {
vector<string> s;
s.assign(26, "");
vector<int> isv;
isv.assign(26, -1);
queue<int> q;
for (int i = 0; i < 26; i++)
if (prevc[i] == -1 && isE[i]) {
isv[i] = i;
q.push(i);
char ci = 'a' + i;
s[i].push_back(ci);
}
while (!q.empty()) {
int c = q.front();
q.pop();
int nc = nextc[c];
if (nc == -1) continue;
if (isv[nc] != -1) return false;
isv[nc] = isv[c];
q.push(nc);
char nci = 'a' + nc;
s[isv[c]].push_back(nci);
}
for (int i = 0; i < 26; i++)
if (isE[i] & isv[i] == -1) return false;
sort(s.begin(), s.end());
for (int i = 0; i < 26; i++) cout << s[i];
cout << endl;
return true;
}
int main() {
if (!read_data() || !valid()) {
cout << "NO" << endl;
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
cout << n * (n * n + 5) / 6;
}
| 8 | CPP |
Subsets and Splits