solution
stringlengths 10
983k
| difficulty
int64 0
25
| language
stringclasses 2
values |
|---|---|---|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
const int maxn = 100000 + 100;
vector<int> pri;
bool vis[maxn];
void init() {
for (int i = 2; i * i < maxn; i++)
if (!vis[i])
for (int j = i * i; j < maxn; j += i) vis[j] = true;
for (int i = 2; i < maxn; i++)
if (!vis[i]) pri.push_back(i);
}
int n, a[maxn], p[maxn];
vector<pair<int, int> > ans;
int main() {
init();
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", a + i);
p[a[i]] = i;
}
for (int i = 1; i <= n; i++) {
if (p[i] == i) continue;
while (p[i] - i) {
int k = pri[upper_bound(pri.begin(), pri.end(), p[i] - i + 1) -
pri.begin() - 1];
int x = p[i] - k + 1, y = p[i];
ans.push_back(pair<int, int>(x, y));
swap(p[a[x]], p[a[y]]);
swap(a[x], a[y]);
}
}
printf("%d\n", ans.size());
for (int i = 0; i < ans.size(); i++)
printf("%d %d\n", ans[i].first, ans[i].second);
return 0;
}
| 9 | CPP |
for _ in range(int(input())):
n=int(input())
if n==1: print(-1)
else:
print(2,end="")
print("3"*(n-1),end="")
print() | 7 | PYTHON3 |
n = int(input())
i = 1
while(2**i<=n):
i += 1
print(2**(i-1)) | 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 150005;
pair<pair<int, int>, int> Q[MAXN];
long long ans[MAXN];
bool cmp1(pair<pair<int, int>, int> a, pair<pair<int, int>, int> b) {
return a.first.first < b.first.first;
}
int main() {
int N, K;
scanf("%d%d", &N, &K);
for (int i = 1; i <= N; i++) {
scanf("%d", &Q[i].first.first);
}
for (int i = 1; i <= N; i++) {
scanf("%d", &Q[i].first.second);
Q[i].second = i;
}
sort(Q + 1, Q + N + 1, cmp1);
priority_queue<int, vector<int>, greater<int>> que;
long long sum = 0;
int num = 0;
long long cur = 0;
for (int i = 1; i <= N; i++) {
if (Q[i].first.first == Q[i - 1].first.first) {
ans[Q[i].second] = cur + Q[i].first.second;
} else {
ans[Q[i].second] = sum + Q[i].first.second;
cur = sum;
}
if (K != 0) {
if (num == K) {
if (Q[i].first.second > que.top()) {
sum -= que.top();
sum += Q[i].first.second;
que.pop();
que.push(Q[i].first.second);
}
} else {
num++;
sum += Q[i].first.second;
que.push(Q[i].first.second);
}
}
}
for (int i = 1; i <= N; i++) cout << ans[i] << " ";
return 0;
}
| 8 | CPP |
t = int(input())
while t:
t -= 1
str = [int(s) for s in input()]
if str[0] == 0:
number = [0]
count = [1]
if str[0] == 1:
number = [1]
count = [1]
count0 = 0
count1 = 0
for i in str:
if i == 1:
count1 += 1
else:
count0 += 1
for i in range(1, len(str)):
if str[i] == str[i-1]:
count[-1] = count[-1] + 1
else:
number.append(str[i])
count.append(1)
# zero_left = []
# one_left = []
# zero_right = []
# one_right = []
#
# for i in range(len(number)):
dp = []
for i in range(len(number)):
cur_count = 0
for j in range(i, len(number)):
if number[j] == 0:
cur_count = cur_count + count[j]
for k in range(0, i):
if number[k] == 1:
cur_count = cur_count + count[k]
dp.append(cur_count)
dp_1 = []
for i in range(len(number)):
cur_count = 0
for j in range(i, len(number)):
if number[j] == 1:
cur_count = cur_count + count[j]
for k in range(0, i):
if number[k] == 0:
cur_count = cur_count + count[k]
dp_1.append(cur_count)
# print(number)
# print(count)
# print(dp)
# print(dp_1)
print(min(min(dp), min(dp_1))) | 8 | PYTHON3 |
#include <algorithm>
#include <iostream>
#include <vector>
#include <math.h>
#include <set>
#include <map>
#include <string>
#include <stack>
#include <queue>
#include <iomanip>
#include <numeric>
#include <tuple>
#include <bitset>
#include <complex>
#include <unistd.h>
#include <cassert>
#include <cctype>
#include <random>
#define _USE_MATH_DEFINES
#define _GLIBCXX_DEBUG
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> plglg;
typedef pair<double, ll> pdlg;
typedef tuple<int, int, int> tiii;
typedef tuple<ll, ll, ll> tlglglg;
typedef tuple<double, double, double> tddd;
typedef complex<double> xy_t;
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
double pi = 3.141592653589793;
ll mod = 998244353;
int intmax = 2147483647;
int intmin = -2147483648;
ll llmax = 9223372036854775807;
ll llmin = -9223372036854775807;
int iinf = intmax / 8;
ll inf = llmax / 8;
double eps = 1e-11;
ll multiply(ll x, ll y) {
return (x % mod) * (y % mod) % mod;
}
ll gcd(ll a, ll b) {
return b != 0 ? gcd(b, a % b) : a;
}
int main() {
ll N;
cin >> N;
ll a[N];
for (int i = 0; i < N; i++) {
cin >> a[i];
}
sort(a, a + N);
ll ans = 1;
for (int i = 0; i < N; i++) {
ans = multiply(ans, gcd(a[i], i));
}
cout << ans << endl;
}
| 0 | CPP |
n=int(input())
l1=list(map(int,input().split()))
max1=999999
for i in range(len(l1)):
sum1=0
for j in range(0,len(l1)):
if(abs(l1[j]-l1[i])%2!=0):
sum1+=1
max1=min(sum1,max1)
print(max1)
| 7 | PYTHON3 |
t = int(input())
for i in range(t):
st = input().split()
n, m = int(st[0]), int(st[1])
second = False
for j in range(n):
arr = []
arr.append(input().split())
arr.append(input().split())
if arr[1][0] == arr[0][1]:
second = True
if second and m % 2 == 0:
print("YES")
else:
print("NO")
| 8 | PYTHON3 |
def bi(l,n):
b = ''
for i in range(0,l):
b = str(n%2) + b
n//=2
return b
def exe():
players = []
n,m,k = list(map(int,input().split()))
for i in range(m+1):
players.append(int(input()))
def bil(num):
return bi(n,num)
print(result(list(map(bil,players)),n,k))
def result(bip,n,k):
fed = bip.pop(-1)
ans=0
for i in range(len(bip)):
temp = 0
for j in range(n):
temp += 1 if (str(fed)[j] != str(bip[i])[j]) else 0
if temp<=k:
ans += 1
return ans
exe()
| 8 | PYTHON3 |
from math import *
from sys import stdin,stdout
input=stdin.buffer.readline
t=int(input())
while t>0:
a,b=[int(x) for x in input().split()]
d=[]
for i in range(1,int(sqrt(a))+1):
if a%i==0:
if a//i==i:
d.append(i)
else:
d.append(i)
d.append(a//i)
d.sort(reverse=True)
#print(d)
for i in range(len(d)):
if(d[i]<=b):
print(a//d[i])
break
t-=1 | 10 | PYTHON3 |
borze=input()
index = 0
n = len(borze)
while index <= n:
if borze[index] == '.':
print(0, end='')
if index + 1 < n:
index += 1
else:
exit()
if borze[index] == '-' and borze[index+1] == '.':
print(1, end='')
if index + 2 < n:
index += 2
else:
exit()
if borze[index] == '-' and borze[index+1] == '-':
print(2, end='')
if index + 2 < n:
index += 2
else:
exit() | 8 | PYTHON3 |
x = int(input())
for _ in range(x):
A,B = map(int,input().split())
if A>B:
B = B*2
if A >= B:
print(A*A)
else:
print(B*B)
elif A <= B:
A = A*2
if A >= B:
print(A*A)
else:
print(B*B) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long f(int x){
long long ans = 0;
long long number = 1;
int digit = 1;
while (1){
if (number * 10 <= x){
ans += digit * number * 9;
digit++;
number *= 10;
} else {
ans += digit * (x - number + 1);
break;
}
}
return ans;
}
int digit(int x){
int tv = 0;
int fv = 1000000000;
while (fv - tv > 1){
int mid = (tv + fv) / 2;
if (f(mid - 1) < x){
tv = mid;
} else {
fv = mid;
}
}
x -= f(tv - 1);
string S = to_string(tv);
return S[x - 1] - '0';
}
int main(){
while (1){
int N, K;
cin >> N >> K;
if (N == 0 && K == 0){
break;
}
for (int i = 0; i < K; i++){
cout << digit(N + i);
}
cout << endl;
}
}
| 0 | CPP |
number1=[]
number2=[]
m,s=(int(x) for x in input().split())
y=s
for i in range(m):
for j in range(1,11):
if s-10+j>=0:
number1.append(10-j)
s=s-10+j
break
s=y
for l in range(1,10):
if s-l<=9*(m-1) and s-l>=0:
number2.append(l)
s=s-l
break
for k in range(m-1):
for c in range(10):
if s-c<=9*(m-k-2):
number2.append(c)
s=s-c
break
if len(number2)==m and len(number1)==m:
for v in range(len(number1)):
number1[v]=str(number1[v])
number2[v]=str(number2[v])
print("".join(number2),"".join(number1))
elif m==1 and s==0:
print(0,0)
else:
print(-1,-1)
| 9 | PYTHON3 |
#include<cstdio>
using namespace std;
#define N 505
int vl[N*3],n,ct,d[4][2]={-1,0,1,0,0,1,0,-1};
long long gcd(long long a,long long b){return b?gcd(b,a%b):a;}
long long as[N][N],mx;
int main()
{
for(int i=501;i<=10000;i++)
{
int fg=0;
for(int j=2;j<=100;j++)if(i%j==0)fg=1;
if(!fg)vl[++ct]=i;
}
for(int i=1;i<=500;i++)as[i][i]=vl[1]*i;
int st=2;
for(int i=2;i<=500;i+=2){for(int j=1;i+j<=500;j++)as[i+j][j]=vl[st]*(j+i/2),as[j][i+j]=vl[st+1]*(j+i/2);st+=2;}
for(int i=1;i<=500;i++)
for(int j=1;j<=500;j++)
if((i+j)&1)
{
long long st=1;
for(int s=0;s<4;s++)
{
int vl=as[i+d[s][0]][j+d[s][1]];
if(vl)st=st/gcd(st,vl)*vl;
}
as[i][j]=st+1;
if(mx<st)
mx=st;
}
scanf("%d",&n);
for(int i=1;i<=n;i++,printf("\n"))
for(int j=1;j<=n;j++)
printf("%lld ",as[i][j]);
}// | 0 | CPP |
desk = tuple(input())
hand = map(tuple, input().split())
for card in hand:
if card[0] == desk[0] or card[1] == desk[1]:
print('YES')
break
else:
print('NO')
| 7 | PYTHON3 |
t=int(input())
for j in range(t):
a,b,k=map(int,input().split())
if(k%2!=0):
print((k//2+1)*a - b*(k-k//2-1))
else:
print((k//2)*a - b*(k-k//2))
| 7 | PYTHON3 |
a,b,c,k=map(int,input().split())
print((-1)**(k%2)*(a-b))
| 0 | PYTHON3 |
n=int(input())
l=list(map(int,input().split()))
s=[]
ans=0
for i in range(n):
if(len(s)==0 or s[-1]<=l[i]):
s.append(l[i])
else:
ans=max(ans,len(s))
s=[]
s.append(l[i])
ans=max(ans,len(s))
print(ans)
| 7 | PYTHON3 |
w=int(input())
if w%2==1:
print("NO")
elif w>=4:
print("YES")
else:
print("NO") | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main()
{
int m, n;
cin >> n;
map<string, int> s;
for (int i = 0; i < n; i++)
{
string a;
cin >> a;
s[a]++;
}
cin >> m;
for (int i = 0; i < m; i++)
{
string b;
cin >> b;
s[b]--;
}
int res = 0;
for (auto e : s)
{
res = max(res, e.second);
}
cout << res << endl;
} | 0 | CPP |
import sys
input=sys.stdin.readline
for i in ' '*int(input()):
n,k=map(int,input().split())
L=list(map(int,input().split()))
mxL=[0]
ct=0
for i in range(1,n-1):
if L[i]>L[i-1] and L[i]>L[i+1]:
ct+=1
mxL.append(ct)
mxL.append(ct)
mx=0
mxmem=0
for i in range(n-k+1):
t=mxL[i+k-1]-mxL[i]
if mxL[i+k-1]==mxL[i+k-2]+1:t-=1
if t>mx:
mx=t
mxmem=i
print(mx+1,mxmem+1) | 8 | PYTHON3 |
t = int(input())
for _ in range(t):
n, k = map(int, input().split())
a = list(map(int, input().split()))
b = set(a)
if k < len(b):
print(-1)
else:
print(n * k)
out = []
for i in range(n):
for e in b:
out.append(str(e))
for j in range(k - len(b)):
out.append(str(1))
print(' '.join(out))
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e4 + 50;
int k;
long long n, m, a[maxn];
long long read() {
long long x = 0;
char c = getchar();
while (c < '0' || c > '9') c = getchar();
while (c >= '0' && c <= '9') x = x * 10 + (c ^ 48), c = getchar();
return x;
}
__int128 gcd(__int128 x, __int128 y) {
if (!y)
return x;
else
return gcd(y, x % y);
}
inline __int128 lcm(__int128 x, __int128 y) {
__int128 t = (__int128)x * y / gcd(x, y);
return t > n ? -1 : t;
}
void exgcd(__int128 a, __int128 &x, __int128 b, __int128 &y, __int128 c) {
if (!b) {
x = c / a, y = 0;
return;
}
exgcd(b, y, a % b, x, c);
y -= a / b * x;
}
bool merge(__int128 &x1, __int128 &m1, __int128 x2, __int128 m2) {
x2 = (x2 % m2 + m2) % m2;
__int128 x, y, d = gcd(m1, m2);
if ((x2 - x1) % d) return 0;
if (m1 * m2 / d > n) return 0;
exgcd(m1, x, m2, y, x2 - x1);
__int128 t = m1;
m1 = m1 * m2 / d;
x1 = ((x1 + x * t) % m1 + m1) % m1;
return 1;
}
int main() {
n = read(), m = read(), k = read();
for (int i = 0; i < k; i++) a[i] = read();
__int128 X = 0, M = 1;
for (int i = 0; i < k; i++) {
if (!merge(X, M, a[i] - i, a[i])) {
printf("NO\n");
return 0;
}
}
if (!X) X = M;
if (X + k - 1 > m) {
printf("NO\n");
return 0;
}
for (int i = 0; i < k; i++) {
if (gcd(M, X + i) != a[i]) {
printf("NO\n");
return 0;
}
}
printf("YES\n");
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
void parseArray(long long* A, long long n) {
for (long long K = 0; K < n; K++) {
cin >> A[K];
}
}
long long modInverse(long long a, long long b) {
return 1 < a ? b - modInverse(b % a, a) * b / a : 1;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long lcm(long long a, long long b) { return (a * b) / gcd(a, b); }
long double dist(long double x, long double y, long double a, long double b) {
return sqrt((x - a) * (x - a) + (y - b) * (y - b));
}
void debug(long long* a, long long n) {
for (long long k = 0; k < n; k++) {
cout << a[k] << " ";
}
cout << "\n";
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
;
long long t;
cin >> t;
while (t--) {
string s;
cin >> s;
long long m;
cin >> m;
long long n = s.length();
char ans[n + 1];
memset(ans, 0, sizeof ans);
for (int k = 0; k < n; k++) {
if (s[k] == '1') {
if (k - m >= 0) ans[k - m] = '1';
if (k + m < n) ans[k + m] = '1';
}
}
for (int k = 0; k < n; k++) {
if (s[k] == '0') {
if (k + m < n) ans[k + m] = '0';
if (k - m >= 0) ans[k - m] = '0';
}
}
for (int k = 0; k < n; k++)
if (ans[k] == 0) ans[k] = '0';
bool flag = true;
for (int k = 0; k < n; k++) {
if (s[k] == '1') {
bool temp = false;
if (k + m < n && ans[k + m] == '1') temp = true;
if (k - m >= 0 && ans[k - m] == '1') temp = true;
flag = flag && temp;
} else {
int temp = 0;
int cnt = 0;
if (k + m < n) cnt++;
if (k - m >= 0) cnt++;
if (k + m < n && ans[k + m] == '0') temp++;
if (k - m >= 0 && ans[k - m] == '0') temp++;
if (temp != cnt) flag = false;
}
}
if (flag)
cout << ans << "\n";
else
cout << "-1\n";
}
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long double EPS = (long double)1e-7;
const int MAXN = 100500;
const int BASE = (int)1e9 + 7;
const int INF = (int)2e9;
int main() {
int x1, x2, y1, y2;
scanf("%d%d", &x1, &y1);
scanf("%d%d", &x2, &y2);
int ans = max(1, abs(x1 - x2)) + 2 + max(1, abs(y1 - y2));
cout << ans * 2;
return 0;
}
| 20 | CPP |
# coding: utf-8
count = 0
w1 = list(input())
w2 = list(input())
l1, l2 = len(w1), len(w2)
try:
while w1.pop() == w2.pop():
count += 1
except IndexError:
pass
print(l1 + l2 - 2 * count) | 8 | PYTHON3 |
for _ in range(int(input())):
n0, n1, n2 = map(int,input().split())
if n1==0:
if n0>0:
print("0"*(n0+1))
else:
print("1"*(n2+1))
else:
l = "1"
r = ""
for i in range(n1):
if i&1:
r+="1"
else:
r+="0"
z = "0"*n0
o = "1"*n2
print(o+l+z+r)
| 12 | PYTHON3 |
def tran(n):
an=[[2]]
an.append([n,n-1])
for i in range(0,n-2):
an.append([n-i,n-i-2])
return an
if __name__ == '__main__':
t = int(input())
ans = []
for i in range(t):
n=int(input())
r = tran(n)
ans.append(r)
for i in ans:
for j in i:
print(*j) | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
multiset<int> S;
int a[100010], pos[100010];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
pos[x] = i;
}
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
a[i] = i - pos[x];
S.insert(a[i]);
}
for (int i = 1; i <= n; i++) {
multiset<int>::iterator k = S.lower_bound(i - 1);
int ans = 1 << 30;
if (k != S.end()) ans = min(ans, *k - (i - 1));
if (k != S.begin()) ans = min(ans, (i - 1) - *--k);
printf("%d\n", ans);
S.erase(S.find(a[i]));
S.insert(a[i] + n);
}
return (0);
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, a, b, c, k, r = 0;
cin >> n >> a >> b >> c;
k = 4 - n % 4;
if (k == 1) r = min(min(a, 3 * c), c + b);
if (k == 2) r = min(min(b, 2 * c), 2 * a);
if (k == 3) r = min(min(3 * a, c), a + b);
cout << r << endl;
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 300005;
const int MaxTN = 200005;
const int R = 9000000;
const int M = 1000000007;
inline int add(int a, const int &b) {
a += b;
return a >= M ? a - M : a;
}
inline int dec(int a, const int &b) {
a -= b;
return a < 0 ? a + M : a;
}
inline int gcd(int a, int b) {
while (b > 0) {
a %= b;
swap(a, b);
}
return a;
}
inline int modpow(int a, const long long &n) {
int res = 1;
for (long long i = n; i; i >>= 1) {
if (i & 1) res = (long long)res * a % M;
a = (long long)a * a % M;
}
return res;
}
long long n;
int len1, len2;
char s1[MaxN], s2[MaxN];
int fact[MaxN * 2], rfact[MaxN * 2];
int tn, sq;
long long val[MaxTN];
int pref[MaxTN];
int pow2[MaxTN];
int pri_n = 0, pri[R / 5];
bool book[R + 1];
int inv[R + 1];
int mu[R + 1], f[R + 1];
inline int pos(long long x) { return x <= sq ? x : tn - n / x + 1; }
inline int binom(int n, int m) {
if (m < 0 || m > n) return 0;
return (long long)fact[n] * rfact[m] % M * rfact[n - m] % M;
}
inline void init(int m) {
mu[1] = f[1] = inv[1] = 1;
for (int i = 2; i <= R; ++i) {
inv[i] = (long long)(M - M / i) * inv[M % i] % M;
if (!book[i]) {
pri[pri_n++] = i;
mu[i] = M - 1;
f[i] = (1 + M - inv[i]) % M;
}
for (int j = 0; j < pri_n; ++j) {
int d = i * pri[j];
if (d > R) break;
book[d] = true;
f[d] = f[i];
if (i % pri[j] == 0) break;
f[d] = (long long)f[d] * f[pri[j]] % M;
mu[d] = M - mu[i];
}
}
for (int i = 2; i <= R; ++i) {
f[i] = (long long)i * (f[i] << 1) % M;
f[i] = add(f[i], f[i - 1]);
mu[i] = add(mu[i], mu[i - 1]);
}
fact[0] = 1;
for (int i = 1; i <= m; ++i) fact[i] = (long long)fact[i - 1] * i % M;
rfact[m] = modpow(fact[m], M - 2);
for (int i = m; i >= 1; --i) rfact[i - 1] = (long long)rfact[i] * i % M;
sq = sqrt(n) + 0.5;
for (int i = 1; i <= sq; ++i) val[++tn] = i;
for (int i = sq - (n / sq == sq); i; --i) val[++tn] = n / i;
for (int i = 1; i <= tn; ++i) {
long long x = val[i];
if (x <= R) {
pref[i] = mu[x];
continue;
}
pref[i] = 1;
for (long long j = 2, k; j <= x; j = k + 1) {
k = x / (x / j);
pref[i] = dec(pref[i], (long long)(k - j + 1) * pref[pos(x / j)] % M);
}
}
for (int i = 0; i <= tn; ++i) pow2[i] = modpow(2, val[i] + 1);
}
inline int query(long long n) {
if (n <= R) return f[n];
int res = 0, last = 0;
for (long long i = 1, j; i <= n; i = j + 1) {
j = n / (n / i);
int u = dec(pref[pos(j)], pref[last]);
int v = (long long)(n / i) % M * ((n / i) % M) % M;
res = add(res, (long long)u * v % M);
last = pos(j);
}
return res;
}
int main() {
scanf("%s%s%lld", s1, s2, &n);
len1 = strlen(s1);
len2 = strlen(s2);
init(len1 + len2);
int d1 = 0, q1 = 0;
int d2 = 0, q2 = 0;
for (int i = 0; i < len1; ++i)
s1[i] == 'A' ? ++d1 : (s1[i] == 'B' ? ++d2 : ++q1);
for (int i = 0; i < len2; ++i)
s2[i] == 'A' ? --d1 : (s2[i] == 'B' ? --d2 : ++q2);
int cop = 0, res = 0;
for (long long i = 1, j; i <= n; i = j + 1) {
j = n / (n / i);
int u = modpow(2, j + 1);
int v = modpow(2, i);
cop = add(cop, (long long)dec(u, v) * query(n / i) % M);
}
if (len1 == len2) {
int total = 0;
for (int i = 0; i < len1 && ~total; ++i) {
if (s1[i] + s2[i] == 'A' + 'B') total = -1;
if (s1[i] + s2[i] == '?' + '?') ++total;
}
if (~total) {
int any = (modpow(2, n + 1) + M - 2) % M;
any = (long long)any * any % M;
res = (long long)modpow(2, total) * (any + M - cop) % M;
}
}
d2 += q1 - q2;
for (int d = -q2; d <= q1; ++d) {
int new_d1 = d1 + d;
int new_d2 = d2 - d;
int ways = binom(q1 + q2, q2 + d);
if (!new_d1 && !new_d2)
res = add(res, (long long)cop * ways % M);
else {
int u = -new_d1, v = new_d2;
if (u < 0) u = -u, v = -v;
if (v < 0) u = -u, v = -v;
if (u > 0 && v > 0) {
int g = gcd(u, v);
long long k = n / (max(u, v) / g);
res = add(res, (long long)ways * (pow2[pos(k)] + M - 2) % M);
}
}
}
printf("%d\n", res);
return 0;
}
| 13 | CPP |
n=int(input())
s=input()
a=0
d=0
for i in range(len(s)):
if(s[i]=='A'):
a=a+1
else:
d=d+1
if(a>d):
print("Anton")
elif(a<d):
print("Danik")
else:
print("Friendship")
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n;
string s[3];
int val[3], cnt[55];
int main() {
cin >> n;
for (int i = 0; i < 3; i++) {
cin >> s[i];
for (int j = (0); j < (55); j++) cnt[j] = 0;
for (int j = (0); j < (((int)s[i].size())); j++) {
if (s[i][j] >= 'a' && s[i][j] <= 'z') {
cnt[s[i][j] - 'a']++;
} else {
cnt[s[i][j] - 'A' + 26]++;
}
}
int now = 0;
for (int j = (0); j < (55); j++) {
now = max(now, cnt[j]);
}
int rem = ((int)s[i].size()) - now;
val[i] = now + min(rem, n);
if (now == ((int)s[i].size()) && n == 1) {
val[i]--;
}
}
if (val[0] > val[1] && val[0] > val[2])
cout << "Kuro";
else if (val[1] > val[2] && val[1] > val[0])
cout << "Shiro";
else if (val[2] > val[1] && val[2] > val[0])
cout << "Katie";
else
cout << "Draw";
return 0;
}
| 8 | CPP |
st = "qwertyuiop"
nd = "asdfghjkl;"
d = "zxcvbnm,./"
letter = input()
text = input()
result = list()
for i in range(len(text)):
if text[i] in st:
if letter == 'R': result.append(st[st.find(text[i])-1])
else: result.append(st[st.find(text[i])+1])
elif text[i] in nd:
if letter == 'R':
result.append(nd[nd.find(text[i]) - 1])
else:
result.append(nd[nd.find(text[i]) + 1])
else:
if letter == 'R':
result.append(d[d.find(text[i]) - 1])
else:
result.append(d[d.find(text[i]) + 1])
print("".join(result)) | 7 | PYTHON3 |
minEnergy = 10 ** 50
n = int(input())
g = list(map(int, input().split()))
for x in range(1, n + 1):
sum = 0
for i in range(len(g)):
et = i + 1
count = g[i]
sum += (abs(x - et) + abs(et - 1) + abs(x - 1)) * 2 * count
minEnergy = min(minEnergy, sum)
print(minEnergy) | 7 | PYTHON3 |
import math
[a,b,c] = map(int,input().split(" "))
sqrt = math.sqrt
r1 = (-b - sqrt(b*b - 4*a*c))/(2*a)
r2 = (-b + sqrt(b*b - 4*a*c))/(2*a)
if(r1 > r2):
print(r1)
print(r2)
else:
print(r2)
print(r1)
| 21 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, p;
int a, b[53];
int main(){
while (cin >> n >> p){
if (!n&!p) break;
for (int i = 0; i < 53; i++) b[i] = 0;
int i = 0;
a = p;
while (true){
if (a > 0) {
b[i]++; a--;
}
else if (a == 0){
a = b[i]; b[i] = 0;
}
if (b[i] == p) break;
if (i == n - 1) i = 0;
else i++;
}
cout << i << endl;
}
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long int a[1000005], mobius[1000005], multiples[1000005], prime[1000005],
ans, on[1000005];
vector<long long int> prime_factor[1000005];
void add(long long int pos) {
long long int val = a[pos];
for (long long int i = 1; i * i <= val; i++) {
if (val % i) continue;
ans = ans - mobius[i] * multiples[i] * (multiples[i] - 1) / 2;
multiples[i]++;
ans = ans + mobius[i] * multiples[i] * (multiples[i] - 1) / 2;
if (val / i == i) continue;
ans = ans -
mobius[val / i] * multiples[val / i] * (multiples[val / i] - 1) / 2;
multiples[val / i]++;
ans = ans +
mobius[val / i] * multiples[val / i] * (multiples[val / i] - 1) / 2;
}
}
void remov(long long int pos) {
long long int val = a[pos];
for (long long int i = 1; i * i <= val; i++) {
if (val % i) continue;
ans = ans - mobius[i] * multiples[i] * (multiples[i] - 1) / 2;
multiples[i]--;
ans = ans + mobius[i] * multiples[i] * (multiples[i] - 1) / 2;
if (val / i == i) continue;
ans = ans -
mobius[val / i] * multiples[val / i] * (multiples[val / i] - 1) / 2;
multiples[val / i]--;
ans = ans +
mobius[val / i] * multiples[val / i] * (multiples[val / i] - 1) / 2;
}
}
int main() {
ios::sync_with_stdio(false);
;
cin.tie(0);
;
long long int i, j, n, q, pos;
for (i = 1; i <= 1000000; i++) mobius[i] = -1;
mobius[1] = 1;
for (i = 2; i <= 1000000; i++) {
if (prime[i]) continue;
for (j = i; j <= 1000000; j += i) {
if (j != i) prime[j] = 1;
prime_factor[j].push_back(i);
long long int ctr = 0;
long long int tj = j;
while (tj % i == 0) {
tj /= i;
ctr++;
}
if (ctr > 1) mobius[j] = 0;
}
}
for (i = 2; i <= 1000000; i++) {
if (mobius[i] == -1) {
if (prime_factor[i].size() % 2)
mobius[i] = -1;
else
mobius[i] = 1;
}
}
cin >> n >> q;
for (i = 1; i <= n; i++) cin >> a[i];
while (q--) {
cin >> pos;
on[pos] = 1 - on[pos];
if (on[pos])
add(pos);
else
remov(pos);
cout << ans << "\n";
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int Inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3fll;
char s[200005];
int n, m;
vector<pair<int, int> > stk, si;
int cnt[26], ccn[200005];
int all, lns, mxn, ptr;
void inline jan1(int p) {
--ccn[cnt[p]];
--cnt[p];
--all;
++ccn[cnt[p]];
}
void append_stk(int now, bool rem) {
if (rem) {
jan1(stk.back().second);
jan1(si[now].second);
printf("%d %d\n", ptr + 1, ptr + si[now].first);
while (mxn && !ccn[mxn]) --mxn;
ptr -= stk.back().first;
if (now + 1 < m) {
si[now + 1].first += stk.back().first;
} else {
lns += stk.back().first;
}
stk.pop_back();
} else {
stk.push_back(si[now]);
ptr += si[now].first;
}
}
void solve() {
scanf("%s", s);
n = strlen(s);
int lst = 0;
all = 0;
for (int i = 1; i <= (n - 1); ++i) {
if (s[i] == s[i - 1]) {
++cnt[s[i] - 'a'];
++all;
si.emplace_back(i - lst, s[i] - 'a');
lst = i;
}
}
lns = n - lst;
ptr = 0;
m = ((int)(si).size());
mxn = 0;
for (int i = 0; i < (26); ++i) {
++ccn[cnt[i]];
mxn = max(mxn, cnt[i]);
}
printf("%d\n", max(mxn, (all + 1) / 2) + 1);
if (mxn * 2 < all) {
for (int i = 0; i < (m); ++i)
append_stk(i, ((int)(stk).size()) && si[i].second != stk.back().second &&
mxn * 2 < all);
si = stk;
m = ((int)(si).size());
stk.clear();
}
int ch = -1;
ptr = 0;
for (int i = 0; i < (26); ++i)
if (cnt[i] == mxn) ch = i;
for (int i = 0; i < (m); ++i)
append_stk(i, ((int)(stk).size()) &&
((stk.back().second == ch) ^ (si[i].second == ch)));
for (int i = 0; i < (((int)(stk).size())); ++i)
printf("1 %d\n", stk[i].first);
printf("1 %d\n", lns);
si.clear();
stk.clear();
all = lns = mxn = ptr = 0;
memset(cnt, 0, sizeof(cnt));
memset(ccn, 0, sizeof(int) * (n + 5));
}
int main() {
int T;
scanf("%d", &T);
while (T--) solve();
return 0;
}
| 10 | CPP |
v1,v2 = map(int,input().split())
t, d = map(int,input().split())
w = 0
for i in range(t):
w += min(v1 + i * d, v2 + (t - 1 -i) * d)
print(w) | 8 | PYTHON3 |
t = int(input())
for i in range(t):
n = int(input())
n2 = list(map(int, input().split()))
p = [0] * n
k = 0
j = 0
while p[n-1] == 0:
if n2[k] not in p:
p[j] = n2[k]
j += 1
k += 1
print(*p) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long parent[200005], potential[200005], minimum[200005], maximum[200005];
long long find(long long x) {
if (parent[x] == x) return x;
int px = parent[x];
parent[x] = find(px);
potential[x] += potential[px];
return parent[x];
}
int main() {
long long n, m, x, y, a, b, total = 0, curr_max = -0x7fffffff;
cin >> n >> m;
for (int i = 1; i <= n; i++) parent[i] = i;
minimum[1] = 0x7fffffff;
maximum[1] = -0x7fffffff;
minimum[n] = 0x7fffffff;
maximum[n] = -0x7fffffff;
for (int i = 1; i <= m; i++) {
cin >> x >> y >> a >> b;
total += a * b * b;
int px = find(x);
int fy = find(y);
if (px == fy) {
if (potential[x] + a * b == potential[y]) continue;
printf("BAD %d\n", i);
return 0;
}
if (px != fy) {
parent[fy] = px;
potential[fy] = potential[x] + a * b - potential[y];
minimum[px] = min(minimum[fy] + potential[fy], minimum[px]);
maximum[px] = max(maximum[fy] + potential[fy], maximum[px]);
curr_max = max(maximum[px] - minimum[px], curr_max);
find(y);
if (minimum[find(1)] <= potential[1]) {
printf("BAD %d\n", i);
return 0;
}
if (maximum[find(n)] >= potential[n]) {
printf("BAD %d\n", i);
return 0;
}
if (find(1) == find(n) && (curr_max >= potential[n] - potential[1] ||
potential[n] <= potential[1])) {
printf("BAD %d\n", i);
return 0;
}
}
}
if (find(1) != find(n)) {
return puts("UNKNOWN");
return 0;
}
find(1);
find(n);
cout << potential[n] - potential[1] << endl;
return 0;
}
| 11 | CPP |
for _ in range(int(input())):
n,a,b=map(int,input().split())
s=''
c=1
k=0
x=0
for i in range(n):
if(i<b):
s+=chr(x%26 +ord('a'))
if(i==b-1):
k=chr(x%26 +ord('a'))
x+=1
elif(i<a):
s+=k
c+=1
else:
if(s[i-a]==k):
s+=k
else:
s+=chr(x%26 +ord('a'))
x+=1
if(chr(x%26 +ord('a'))==k):
x+=1
print(s)
| 8 | PYTHON3 |
n = int(input())
lots = input().split()
lots = [int(lots[x]) for x in range (0, len(lots))]
lots.sort()
s1 = 0
for i in range (0, len(lots)):
s1+=lots[i]
s2 = 0
indi = 0
k = 0
for i in range (len(lots)-1, -1, -1):
s2+=lots[i]
k+=1
if (s2>(s1-s2)):
indi = k
break
print(indi) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
int n, m, k;
char str[55][55];
int v[55][55];
set<long long> se;
int cnt[maxn];
int dir[4][2] = {{-1, 0}, {0, 1}, {1, 0}, {0, -1}};
string ans;
int sx, sy, ex, ey;
struct node {
int x, y;
int s;
string str;
node(int _x = 0, int _y = 0, int _s = 0, string _str = "")
: x(_x), y(_y), s(_s), str(_str) {}
};
bool operator<(const node &a, const node &b) {
int lena = a.str.length(), lenb = b.str.length();
if (lena != lenb) return lena > lenb;
return a.str > b.str;
}
int cot(int n) {
int ret = 0;
for (; n; n -= n & (-n)) ret++;
return ret;
}
void BFS(int sx, int sy, int ex, int ey) {
priority_queue<node> q;
q.push(node(sx, sy, 0, ""));
se.insert(sx * m + sy);
while (!q.empty()) {
node temp = q.top();
q.pop();
for (int i = 0; i < 4; i++) {
int tx = temp.x + dir[i][0];
int ty = temp.y + dir[i][1];
if (tx == ex && ty == ey) {
cout << temp.str << endl;
return;
}
if (tx == sx && ty == sy) continue;
if (tx < 0 || ty < 0 || tx >= n || ty >= m) continue;
int news = temp.s | (1 << (str[tx][ty] - 'a'));
if (cot(news) > k) continue;
string ss = temp.str + str[tx][ty];
long long tv = news * n * m + tx * m + ty;
if (se.find(tv) == se.end()) {
if (v[tx][ty] && ((v[tx][ty] & news) == v[tx][ty])) continue;
v[tx][ty] = news;
se.insert(tv);
q.push(node(tx, ty, news, temp.str + str[tx][ty]));
}
}
}
cout << "-1" << endl;
}
int main() {
scanf("%d %d %d", &n, &m, &k);
for (int i = 0; i < n; i++) scanf("%s", str[i]);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (str[i][j] == 'S') sx = i, sy = j;
if (str[i][j] == 'T') ex = i, ey = j;
}
}
BFS(sx, sy, ex, ey);
return 0;
}
| 9 | CPP |
k,n,w=map(int,input().split())
t=(w*(w+1))//2
t=t*k
if t<=n:
print(0)
else:
print(t-n)
| 7 | PYTHON3 |
n, k = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
x = 0
y = 0
z = 0
b = 0
for i in a:
b += 1
x += i
if x >= 8:
y += 8
else:
y += x
x -= 8
if x<0:
x = 0
if y >= k:
z = i
break
if z == 0:
print(-1)
else:
print(b)
| 7 | PYTHON3 |
pontoAx, pontoAy = [int(i) for i in input().split()]
pontoBx, pontoBy = [int(i) for i in input().split()]
pontoCx, pontoCy = [int(i) for i in input().split()]
x4, x5 = pontoBx - pontoAx, pontoCx - pontoBx
y4, y5 = pontoBy - pontoAy, pontoCy - pontoBy
direcao = x4 * y5 - x5 * y4
if direcao > 0:
print('LEFT')
elif direcao < 0:
print('RIGHT')
else:
print('TOWARDS')
| 7 | PYTHON3 |
a, b = [int(s) for s in input().split()]
s = 0
while max(a, b) >= 2 and min(a, b) >= 1:
if a > b:
a -= 2
b -= 1
else:
a -= 1
b -= 2
s += 1
print(s) | 9 | PYTHON3 |
test=int(input())
for t in range(test):
n=int(input())
st=input()
s=''
for i in range(n):
s=s+st[n-1]
print(s)
| 7 | PYTHON3 |
a = input().split(',')
print(*a) | 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long M = 998244353;
const int N = 500005;
int i, n, t, s, T;
int main() {
scanf("%d", &T);
while (T--) {
scanf("%d %d %d", &n, &s, &t);
printf("%d\n", max(n - s, n - t) + 1);
}
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
double EPS = 1e-9;
int INF = 2000000000;
long long INFF = 8000000000000000000LL;
double PI = acos(-1);
inline string IntToString(int a) {
char x[100];
sprintf(x, "%d", a);
string s = x;
return s;
}
inline int StringToInt(string a) {
char x[100];
int res;
strcpy(x, a.c_str());
sscanf(x, "%d", &res);
return res;
}
inline bool angka(char a) { return (a >= '0' && a <= '9'); }
inline bool kecil(char a) { return (a >= 'a' && a <= 'z'); }
inline bool besar(char a) { return (a >= 'A' && a <= 'Z'); }
inline string uppercase(string s) {
int n = (int)s.size();
for (int(i) = (0); (i) < (n); (i)++)
if (kecil(s[i])) s[i] = s[i] - 'a' + 'A';
return s;
}
inline string lowercase(string s) {
int n = (int)s.size();
for (int(i) = (0); (i) < (n); (i)++)
if (besar(s[i])) s[i] = s[i] - 'A' + 'a';
return s;
}
bool pr[1000 + 5];
int prima[1000 + 5];
void GeneratePrime(int a) {
memset(pr, 1, sizeof(pr));
pr[0] = pr[1] = 0;
int ix = 0;
for (int(i) = (2); (i) <= (a); (i)++) {
if (pr[i]) {
ix++;
prima[ix] = i;
int b = i * 2;
while (b <= a) {
pr[b] = 0;
b = b + i;
}
}
}
}
string s;
pair<int, char> data[30];
char ans[1005];
vector<vector<int> > mboh;
bool g(vector<int> a, vector<int> b) {
int A = (int)a.size();
int B = (int)b.size();
if (A > B) return true;
if (B < A) return false;
return (a[0] >= b[0]);
}
int main() {
GeneratePrime(1000);
int n = 0;
cin >> s;
int len = (int)s.size();
for (int(i) = (0); (i) < (len); (i)++) {
char now = s[i];
bool ada = 0;
for (int(j) = (1); (j) <= (n); (j)++)
if (data[j].second == now) {
ada = 1;
data[j].first++;
break;
}
if (!ada) {
n++;
data[n].first = 1;
data[n].second = now;
}
}
sort(data + 1, data + 1 + n);
reverse(data + 1, data + 1 + n);
for (int(i) = (1); (i) <= (168); (i)++) {
if (prima[i] > len) break;
vector<int> tmp;
tmp.clear();
int a = prima[i];
bool murni = 1;
int pindah = -1;
while (a <= len) {
for (int(j) = (0); (j) < ((int)mboh.size()); (j)++) {
for (int(k) = (0); (k) < ((int)mboh[j].size()); (k)++) {
if (a == mboh[j][k]) {
murni = 0;
for (int(l) = (0); (l) < ((int)tmp.size()); (l)++)
mboh[j].push_back(tmp[l]);
pindah = j;
break;
}
if (!murni) break;
}
if (!murni) break;
}
if (murni)
tmp.push_back(a);
else {
bool ada = 0;
for (int(k) = (0); (k) < ((int)mboh[pindah].size()); (k)++) {
if (mboh[pindah][k] == a) {
ada = 1;
break;
}
}
if (!ada) mboh[pindah].push_back(a);
}
a = a + prima[i];
}
if (murni) mboh.push_back(tmp);
}
vector<int> tmp;
tmp.push_back(1);
mboh.push_back(tmp);
int A = 1;
int B = 0;
while (A <= n && B < (int)mboh.size()) {
if (data[A].first > (int)mboh[B].size()) {
for (int(i) = (0); (i) < ((int)mboh[B].size()); (i)++)
ans[mboh[B][i]] = data[A].second;
data[A].first -= (int)mboh[B].size();
B++;
} else if (data[A].first == (int)mboh[B].size()) {
for (int(i) = (0); (i) < ((int)mboh[B].size()); (i)++) {
ans[mboh[B][i]] = data[A].second;
}
A++;
B++;
} else {
puts("NO");
return 0;
}
}
for (int(i) = (1); (i) <= (len); (i)++)
if (!kecil(ans[i])) {
puts("NO");
return 0;
}
puts("YES");
for (int(i) = (1); (i) <= (len); (i)++) printf("%c", ans[i]);
puts("");
return 0;
}
| 7 | CPP |
import math
for _ in range(int(input())):
n,k=map(int,input().split())
stri=list(input())
stri.sort()
if len(set(stri[:k]))>1:
print(stri[k-1])
continue
if len(set(stri[k:]))==1:
s=''
s=stri[0]
u=int(math.ceil(len(stri[k:])/k))
s+=stri[-1]*u
print(s)
continue
else:
s=[stri[0]]+stri[k:]
si=''.join(s)
print(si)
| 9 | PYTHON3 |
# Hey, there Stalker!!!
# This Code was written by:
# ▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒
# ▒▒╔╗╔═══╦═══╗▒▒▒╔╗▒▒▒
# ▒╔╝║║╔═╗║╔═╗╠╗▒▒║║▒▒▒
# ▒╚╗║║║║║║║║║╠╬══╣║╔╗▒
# ▒▒║║║║║║║║║║╠╣║═╣╚╝╝▒
# ▒╔╝╚╣╚═╝║╚═╝║║║═╣╔╗╗▒
# ▒╚══╩═══╩═══╣╠══╩╝╚╝▒
# ▒▒▒▒▒▒▒▒▒▒▒╔╝║▒▒▒▒▒▒▒
# ▒▒▒▒▒▒▒▒▒▒▒╚═╝▒▒▒▒▒▒▒
# ▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒
#from __future__ import division, print_function
#mod=int(1e9+7)
#import resource
#resource.setrlimit(resource.RLIMIT_STACK, [0x100000000, resource.RLIM_INFINITY])
#import threading
#threading.stack_size(2**26)
#fact=[1]
#for i in range(1,100001):
# fact.append((fact[-1]*i)%mod)
#ifact=[0]*100001
#from collections import deque, defaultdict, Counter, OrderedDict
#from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, gcd
#from heapq import heappush, heappop, heapify, nlargest, nsmallest
#ifact[100000]=pow(fact[100000],mod-2,mod)
#for i in range(100000,0,-1):
# ifact[i-1]=(i*ifact[i])%mod
#from sys import stdin, stdout
import sys
# sys.setrecursionlimit(10**6)
from sys import stdin, stdout
import bisect #c++ upperbound
from bisect import bisect_left as bl #c++ lowerbound bl(array,element)
from bisect import bisect_right as br #c++ upperbound
import itertools
from collections import Counter
import collections
import math
import heapq
import re
def modinv(n,p):
return pow(n,p-2,p)
def cin():
return map(int,sin().split())
def ain(): #takes array as input
return list(map(int,sin().split()))
def sin():
return input()
def inin():
return int(input())
def Divisors(n) :
l = []
for i in range(1, int(math.sqrt(n) + 1)) :
if (n % i == 0) :
if (n // i == i) :
l.append(i)
else :
l.append(i)
l.append(n//i)
return l
def most_frequent(list):
return max(set(list), key = list.count)
def GCD(x,y):
while(y):
x, y = y, x % y
return x
def ncr(n,r,p):
t=((fact[n])*((ifact[r]*ifact[n-r])%p))%p
return t
def Convert(string):
li = list(string.split(""))
return li
def SieveOfEratosthenes(n):
global prime
prime = [True for i in range(n+1)]
p = 2
while (p * p <= n):
if (prime[p] == True):
for i in range(p * p, n+1, p):
prime[i] = False
p += 1
f=[]
for p in range(2, n):
if prime[p]:
f.append(p)
return f
prime=[]
q=[]
def dfs(n,d,v,c):
global q
v[n]=1
x=d[n]
q.append(n)
j=c
for i in x:
if i not in v:
f=dfs(i,d,v,c+1)
j=max(j,f)
# print(f)
return j
#Implement heapq
#grades = [110, 25, 38, 49, 20, 95, 33, 87, 80, 90]
#print(heapq.nlargest(3, grades)) #top 3 largest
#print(heapq.nsmallest(4, grades))
#Always make a variable of predefined function for ex- fn=len
"""*******************************************************"""
def main():
#Write Your Code Here
s1=sin()
s2=sin()
s1=s1.lower()
s1=list(s1)
s2=s2.lower()
s2=list(s2)
count1=0
count2=0
for i in range(len(s1)):
count1+=ord(s1[i])
count2+=ord(s2[i])
if count1!=count2:
if count1<count2:
print(-1)
break
else:
print(1)
break
if count1==count2:
print(0)
######## Python 2 and 3 footer by Pajenegod and c1729
py2 = round(0.5)
if py2:
from future_builtins import ascii, filter, hex, map, oct, zip
range = xrange
import os, sys
from io import IOBase, BytesIO
BUFSIZE = 8192
class FastIO(BytesIO):
newlines = 0
def __init__(self, file):
self._file = file
self._fd = file.fileno()
self.writable = "x" in file.mode or "w" in file.mode
self.write = super(FastIO, self).write if self.writable else None
def _fill(self):
s = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.seek((self.tell(), self.seek(0,2), super(FastIO, self).write(s))[0])
return s
def read(self):
while self._fill(): pass
return super(FastIO,self).read()
def readline(self):
while self.newlines == 0:
s = self._fill(); self.newlines = s.count(b"\n") + (not s)
self.newlines -= 1
return super(FastIO, self).readline()
def flush(self):
if self.writable:
os.write(self._fd, self.getvalue())
self.truncate(0), self.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
if py2:
self.write = self.buffer.write
self.read = self.buffer.read
self.readline = self.buffer.readline
else:
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')
if __name__== "__main__":
main()
#threading.Thread(target=main).start()
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = int(1e9);
const long long INFll = 1ll * INF * INF;
const long double ldINF = 1e+018;
const long double EPS = 0.000000001;
const int sdx[4] = {-1, 0, 1, 0};
const int sdy[4] = {0, 1, 0, -1};
template <typename T>
ostream& operator<<(ostream& out, pair<T, T>& a) {
out << a.first << " " << a.second;
return out;
}
template <typename T>
istream& operator>>(istream& in, pair<T, T>& a) {
in >> a.first >> a.second;
return in;
}
template <typename T>
istream& operator>>(istream& in, vector<T>& a) {
for (int i = 0; i < a.size(); ++i) in >> a[i];
return in;
}
template <typename T>
ostream& operator<<(ostream& out, vector<T> a) {
for (int i = 0; i < a.size(); ++i)
if (i == a.size() - 1)
out << a[i];
else
out << a[i] << " ";
}
char c[1100][1100];
long long d[6][1101][1111];
int main() {
int n, m;
cin >> n >> m;
scanf("\n");
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) scanf("%c", &c[i][j]);
scanf("\n");
}
for (int k = 0; k < 3; k++)
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) d[k][i][j] = INF;
for (int k = 0; k < 3; k++) {
deque<pair<int, int> > q;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (c[i][j] == char((k + 1) + '0')) {
q.push_front(make_pair(i, j));
d[k][i][j] = 0;
}
while (!q.empty()) {
int x = q.front().first, y = q.front().second;
q.pop_front();
for (int i = 0; i < 4; i++) {
int x1 = x + sdx[i], y1 = y + sdy[i];
if (x1 < 0 || y1 < 0 || x1 >= n || y1 >= m || c[x1][y1] == '#')
continue;
int add;
add = d[k][x][y] + 1;
if (c[x1][y1] != '.' && c[x1][y1] != '#') add--;
if (d[k][x1][y1] > add) {
d[k][x1][y1] = add;
if (c[x1][y1] == '.')
q.push_back(make_pair(x1, y1));
else
q.push_back(make_pair(x1, y1));
}
}
}
}
long long mn = INF;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
if (c[i][j] == '#') continue;
if (d[0][i][j] == INF || d[1][i][j] == INF || d[2][i][j] == INF) continue;
long long dist = d[0][i][j] + d[1][i][j] + d[2][i][j];
if (c[i][j] == '.') dist -= 2;
mn = min(mn, dist);
}
if (mn == INF)
cout << -1 << endl;
else
cout << mn << endl;
return 0;
}
| 9 | CPP |
l = list(map(int,input().split()))
l.sort()
su = sum(l)
print(min(su//3,l[0]+l[1])) | 9 | PYTHON3 |
######### ## ## ## #### ##### ## # ## # ##
# # # # # # # # # # # # # # # # # # #
# # # # ### # # # # # # # # # # # #
# ##### # # # # ### # # # # # # # # #####
# # # # # # # # # # # # # # # # # #
######### # # # # ##### # ##### # ## # ## # #
"""
PPPPPPP RRRRRRR OOOO VV VV EEEEEEEEEE
PPPPPPPP RRRRRRRR OOOOOO VV VV EE
PPPPPPPPP RRRRRRRRR OOOOOOOO VV VV EE
PPPPPPPP RRRRRRRR OOOOOOOO VV VV EEEEEE
PPPPPPP RRRRRRR OOOOOOOO VV VV EEEEEEE
PP RRRR OOOOOOOO VV VV EEEEEE
PP RR RR OOOOOOOO VV VV EE
PP RR RR OOOOOO VV VV EE
PP RR RR OOOO VVVV EEEEEEEEEE
"""
"""
Perfection is achieved not when there is nothing more to add, but rather when there is nothing more to take away.
"""
import sys
input = sys.stdin.readline
# from bisect import bisect_left as lower_bound;
# from bisect import bisect_right as upper_bound;
# from math import ceil, factorial;
def ceil(x):
if x != int(x):
x = int(x) + 1
return x
def factorial(x, m):
val = 1
while x>0:
val = (val * x) % m
x -= 1
return val
# swap_array function
def swaparr(arr, a,b):
temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
## gcd function
def gcd(a,b):
if b == 0:
return a;
return gcd(b, a % b);
## nCr function efficient using Binomial Cofficient
def nCr(n, k):
if(k > n - k):
k = n - k;
res = 1;
for i in range(k):
res = res * (n - i);
res = res / (i + 1);
return int(res);
## upper bound function code -- such that e in a[:i] e < x;
def upper_bound(a, x, lo=0, hi = None):
if hi == None:
hi = len(a);
while lo < hi:
mid = (lo+hi)//2;
if a[mid] < x:
lo = mid+1;
else:
hi = mid;
return lo;
## prime factorization
def primefs(n):
## if n == 1 ## calculating primes
primes = {}
while(n%2 == 0 and n > 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 and n > 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 and can be accesed. O(sqrt n)
return primes
## MODULAR EXPONENTIATION FUNCTION
def power(x, y, p):
res = 1
x = x % p
if (x == 0) :
return 0
while (y > 0) :
if ((y & 1) == 1) :
res = (res * x) % p
y = y >> 1
x = (x * x) % p
return res
## DISJOINT SET UNINON FUNCTIONS
def swap(a,b):
temp = a
a = b
b = temp
return a,b;
# find function with path compression included (recursive)
# def find(x, link):
# if link[x] == x:
# return x
# link[x] = find(link[x], link);
# return link[x];
# find function with path compression (ITERATIVE)
def find(x, link):
p = x;
while( p != link[p]):
p = link[p];
while( x != p):
nex = link[x];
link[x] = p;
x = nex;
return p;
# the union function which makes union(x,y)
# of two nodes x and y
def union(x, y, link, size):
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
## returns an array of boolean if primes or not USING SIEVE OF ERATOSTHANES
def sieve(n):
prime = [True for i in range(n+1)]
p = 2
while (p * p <= n):
if (prime[p] == True):
for i in range(p * p, n+1, p):
prime[i] = False
p += 1
return prime
#### PRIME FACTORIZATION IN O(log n) using Sieve ####
MAXN = int(1e5 + 5)
def spf_sieve():
spf[1] = 1;
for i in range(2, MAXN):
spf[i] = i;
for i in range(4, MAXN, 2):
spf[i] = 2;
for i in range(3, ceil(MAXN ** 0.5), 2):
if spf[i] == i:
for j in range(i*i, MAXN, i):
if spf[j] == j:
spf[j] = i;
## function for storing smallest prime factors (spf) in the array
################## un-comment below 2 lines when using factorization #################
# spf = [0 for i in range(MAXN)]
# spf_sieve();
def factoriazation(x):
ret = {};
while x != 1:
ret[spf[x]] = ret.get(spf[x], 0) + 1;
x = x//spf[x]
return ret;
## this function is useful for multiple queries only, o/w use
## primefs function above. complexity O(log n)
## taking integer array input
def int_array():
return list(map(int, input().strip().split()));
def float_array():
return list(map(float, input().strip().split()));
## taking string array input
def str_array():
return input().strip().split();
#defining a couple constants
MOD = int(1e9)+7;
CMOD = 998244353;
INF = float('inf'); NINF = -float('inf');
################### ---------------- TEMPLATE ENDS HERE ---------------- ###################
from itertools import permutations
import math
def solve():
n, k = map(int,input().split())
val = (k + n) / 2
if val < n:
if math.ceil(val) == math.floor(val):
print(0)
else:
print(1)
else:
print(k - n)
if __name__ == '__main__':
for _ in range(int(input())):
solve()
# fin_time = datetime.now()
# print("Execution time (for loop): ", (fin_time-init_time))
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
void readi(int &x) {
int v = 0, f = 1;
char c = getchar();
while (!isdigit(c) && c != '-') c = getchar();
if (c == '-')
f = -1;
else
v = v * 10 + c - '0';
while (isdigit(c = getchar())) v = v * 10 + c - '0';
x = v * f;
}
void readll(long long &x) {
long long v = 0ll, f = 1ll;
char c = getchar();
while (!isdigit(c) && c != '-') c = getchar();
if (c == '-')
f = -1;
else
v = v * 10 + c - '0';
while (isdigit(c = getchar())) v = v * 10 + c - '0';
x = v * f;
}
void readc(char &x) {
char c;
while ((c = getchar()) == ' ')
;
x = c;
}
void writes(string s) { puts(s.c_str()); }
void writeln() { writes(""); }
void writei(int x) {
if (!x) putchar('0');
char a[25];
int top = 0;
while (x) {
a[++top] = (x % 10) + '0';
x /= 10;
}
while (top) {
putchar(a[top]);
top--;
}
}
void writell(long long x) {
if (!x) putchar('0');
char a[25];
int top = 0;
while (x) {
a[++top] = (x % 10) + '0';
x /= 10;
}
while (top) {
putchar(a[top]);
top--;
}
}
long long n, m, i, j, t0, t1, t2, a1, a2, p1, p2, l, r, ans = 1ll << 62;
int main() {
cin >> n >> m >> t0 >> a1 >> t1 >> p1 >> a2 >> t2 >> p2;
r = n;
for (l = 0; l * a1 < n; l++) {
long long f = n - l * a1, t = m - l * a1 * t1;
if (f * t2 > t && f * t0 > t) continue;
if (t0 <= t2 || f * t0 <= t)
r = 0;
else
r = ((t0 * f - t + t0 - t2 - 1) / (t0 - t2) + a2 - 1) / a2;
ans = min(ans, p1 * l + p2 * r);
}
if (l * a1 >= n && n * t1 <= m) ans = min(ans, p1 * l);
r = n;
swap(t1, t2);
swap(a1, a2);
swap(p1, p2);
for (l = 0; l * a1 < n; l++) {
long long f = n - l * a1, t = m - l * a1 * t1;
if (f * t2 > t && f * t0 > t) continue;
if (t0 <= t2 || f * t0 <= t)
r = 0;
else
r = ((t0 * f - t + t0 - t2 - 1) / (t0 - t2) + a2 - 1) / a2;
ans = min(ans, p1 * l + p2 * r);
}
if (l * a1 >= n && n * t1 <= m) ans = min(ans, p1 * l);
if (ans < (1ll << 62))
cout << ans;
else
cout << -1;
return 0;
}
| 9 | CPP |
t = int(input())
for i in range(t):
n = int(input())
a = list(map(int,input().split()))
temp = set()
ans=[]
for j in a:
if(j in temp):
continue
else:
ans.append(j)
temp.add(j)
print(*ans)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) {
x = (x << 3) + (x << 1) + (c ^ 48);
c = getchar();
}
return f == -1 ? ~x + 1 : x;
}
int n, m;
struct node {
int x, y;
} a[200010];
int in[200010];
int B = 450;
int val[400010];
int vl2[510][510];
void ins(int x, int tm) {
in[x] = tm;
int all = a[x].x + a[x].y;
if (all <= B) {
int beg = tm % all;
for (int j = 0; j < a[x].y; ++j) {
vl2[all][(j + beg + a[x].x) % all]++;
}
} else {
int nt = in[x];
while (nt <= m) {
if (nt + a[x].x <= m) ++val[nt + a[x].x];
if (nt + a[x].x + a[x].y <= m) --val[nt + a[x].x + a[x].y];
nt += all;
}
}
}
int su;
void del(int x, int tm) {
int all = a[x].x + a[x].y;
if (all <= B) {
int beg = in[x] % all;
for (int j = 0; j < a[x].y; ++j) {
vl2[all][(j + beg + a[x].x) % all]--;
}
} else {
int nt = in[x];
while (nt <= m) {
if (tm >= nt + a[x].x) --su;
if (tm >= nt + a[x].x + a[x].y) ++su;
if (nt + a[x].x <= m) --val[nt + a[x].x];
if (nt + a[x].x + a[x].y <= m) ++val[nt + a[x].x + a[x].y];
nt += all;
}
}
}
int getans(int tm) {
int res = 0;
for (int i = 1; i <= B; ++i) {
res += vl2[i][tm % i];
}
return res;
}
int main() {
su = 0;
n = read(), m = read();
for (int i = 1; i <= n; ++i) a[i].x = read(), a[i].y = read();
for (int i = 1; i <= m; ++i) {
int op = read(), k = read();
su += val[i];
if (op == 1) {
ins(k, i);
} else
del(k, i);
printf("%d\n", su + getans(i));
}
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T getint() {
T x = 0, p = 1;
char ch;
do {
ch = getchar();
} while (ch <= ' ');
if (ch == '-') p = -1, ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return x * p;
}
mt19937 gen(chrono::system_clock::now().time_since_epoch().count());
template <typename T1, typename T2>
bool umin(T1 &x, const T2 &y) {
if (x > y) return x = y, true;
return false;
}
template <typename T1, typename T2>
bool umax(T1 &x, const T2 &y) {
if (x < y) return x = y, true;
return false;
}
const int maxn = (int)1e5 + 10;
const int inf = (int)1e9 + 5;
const int mod = (int)1e9 + 7;
const long long llinf = (long long)1e18 + 5;
const double pi = acos(-1.0);
int main() {
int n, l;
cin >> n >> l;
vector<int> a(n), b(n);
for (int i = (0); i < (n); i++) cin >> a[i];
for (int i = (0); i < (n); i++) cin >> b[i];
for (int i = (0); i < (l); i++)
for (int j = (0); j < (l); j++) {
vector<int> x, y;
for (int k = (0); k < (n); k++) {
x.push_back((a[k] + i) % l);
y.push_back((b[k] + j) % l);
}
sort((x).begin(), (x).end());
sort((y).begin(), (y).end());
if (x == y) {
cout << "YES\n";
return 0;
}
}
cout << "NO\n";
return 0;
}
| 8 | CPP |
def main():
a=int(input())
list1=list(input().split())
b=0
for i in list1:
b+=int(i)
c=b/a
print(c)
if __name__ == '__main__':
main() | 8 | PYTHON3 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1000000000")
using namespace std;
const int maxn = (int)2e5 + 10;
pair<int, int> v[maxn];
int pos[maxn];
int n, k, s, t;
bool check(int sp) {
int now = 0;
long long tm = 0;
for (int i = 0; i < k; i++) {
int x = pos[i] - now;
int b = sp - x;
int a = 0;
if (sp < x) {
return false;
}
if (b < 0) {
b = 0;
a = x;
} else if (b > x) {
b = x;
} else {
a = x - b;
}
tm += 2 * a + b;
now = pos[i];
}
return tm <= t;
}
int main() {
cin >> n >> k >> s >> t;
for (int i = 0; i < n; i++) {
scanf("%d %d", &v[i].second, &v[i].first);
}
sort(v, v + n);
for (int i = 0; i < k; i++) {
scanf("%d", &pos[i]);
}
sort(pos, pos + k);
pos[k] = s;
k++;
int l = 0;
int r = n;
while (l != r) {
int m = (l + r) / 2;
if (check(v[m].first)) {
r = m;
} else {
l = m + 1;
}
}
if (l == n) {
cout << -1 << endl;
return 0;
}
int ans = v[l].second;
for (int i = l + 1; i < n; i++) {
ans = min(ans, v[i].second);
}
cout << ans << endl;
return 0;
}
| 7 | CPP |
t = int(input())
def somme(n,k,a,b):
a.sort()
b.sort(reverse = True)
i=0
ismax = True
while i < k and ismax == True:
ismax = b[i]>a[i]
if ismax:
a[i] = b[i]
i+=1
return sum(a)
resultat = []
for _ in range(t):
n,k = map(int,input().split(" "))
a = list(map(int,input().split(" ")))
b= list(map(int,input().split(" ")))
resultat.append(somme(n,k,a,b))
for _ in resultat:
print(_)
| 8 | PYTHON3 |
import os
import sys
from io import BytesIO, IOBase
def solution(s):
n = len(s)
s = "x" + s
pref = [0]
for i in range(1, n + 1):
if s[i] == "+":
pref.append(pref[-1] + 1)
else:
pref.append(pref[-1] - 1)
res = [n]
mn = float("inf")
for i in range(1, n + 1):
if pref[i] < 0 and pref[i] < mn:
res.append(i)
mn = pref[i]
write(sum(res))
def main():
for _ in range(r_int()):
s = input()
solution(s)
# fast-io region
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
def input():
return sys.stdin.readline().rstrip("\r\n")
def write(*args, end="\n"):
for x in args[:-1]:
sys.stdout.write(str(x) + " ")
sys.stdout.write(str(args[-1]))
sys.stdout.write(end)
def r_array():
return [int(x) for x in input().split()]
def r_int():
return int(input())
if __name__ == "__main__":
main()
| 9 | PYTHON3 |
z,x,c=0,0,0
for i in range(int(input())):
a,s,d=[int(i) for i in input().split()]
z+=a
x+=s
c+=d
if z==x==c==0:
print("YES")
else:
print("NO") | 7 | PYTHON3 |
#include <bits/stdc++.h>
#pragma warning(disable 4996)
#pragma warning(disable 4996)
const int dr[]{-1, -1, 0, 1, 1, 1, 0, -1};
const int dc[]{0, 1, 1, 1, 0, -1, -1, -1};
const double PI = acos(-1), EPS = 1e-7;
const int OO = 0x3f3f3f3f, N = 1e7 + 5, mod = 1e9 + 7;
using namespace std;
struct point {
long long x, y;
};
long long power(long long x, long long y) {
if (y == 0) return 1;
if (y == 1) return x;
long long r = power(x, y / 2);
return r * r * power(x, y % 2);
}
long long dis(point a, point b) {
long long x = a.x - b.x, y = a.y - b.y;
return x * x + y * y;
}
void fast() {
std::ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
}
bool cmp(pair<int, int> p1, pair<int, int> p2) {
if (p1.first != p2.first) return p1.second < p2.second;
}
long long gcd(long long n, long long m) { return !m ? n : gcd(m, n % m); }
int main() {
fast();
long long n;
cin >> n;
string s;
vector<string> v(n);
vector<string> v1(n);
for (int i = 0; i < n; i++) cin >> v[i];
for (int i = 0; i < n; i++) cin >> v1[i];
long long ans = 0;
for (int i = 0; i < n; i++) {
long long ok = 1;
for (int j = 0; j < n; j++) {
if (v[i] == v1[j] && v1[j] != "0" && v[i] != "0") {
v[i] = "0";
v1[j] = "0";
ok = 0;
}
}
if (ok == 1) ans++;
}
cout << ans << "\n";
return 0;
}
| 7 | CPP |
#include <iostream>
#include <list>
using namespace std;
int main()
{
int N; cin >> N;
list<long> List;
int Cur=0;
List.insert(List.begin(), -1);
auto ite = std::next(List.begin(), Cur);
for(int i = 0; i < N; ++i)
{
int Command; cin >> Command;
if(Command == 0)
{
long val; cin >> val;
List.insert(ite, val);
ite = next(ite, -1);
}
else if(Command == 1)
{
int val; cin >> val;
Cur += val;
//ite = std::next(List.begin(), Cur);
ite = next(ite, val);
}
else
{
if(Cur >= 0)
{
//ite = std::next(List.begin(), Cur);
auto old = ite;
ite = next(ite, 1);
List.erase(old);
}
}
}
ite = std::next(List.end(), -1);
List.erase(ite);
for(const int& x : List)
cout << x << endl;
return 0;
}
| 0 | CPP |
def smallestDivisor(n):
if (n % 2 == 0):
return 2
i = 3
while(i * i <= n):
if (n % i == 0):
return i
i += 2
return n
for _ in range(int(input())):
n,k = map(int,input().split())
out = 0
for i in range(k):
temp = smallestDivisor(n)
out = n + temp
if out%2==0:
out += 2*(k-i-1)
break
print(out) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
FILE *fp, *fp2;
int arr[200000 + 50], tn, tc, ttop;
char sklist[500 + 50][500 + 50];
map<int, pair<int, int> > tracker;
vector<pair<int, int> > anList;
int main() {
int tests, q;
int a, b, res, mx, cnt;
while (scanf("%d", &a) == 1) {
tracker.clear();
anList.clear();
for (int i = 0; i < a; i++) {
scanf("%d", &arr[i]);
}
pair<int, int> tmpii;
for (int i = 0; i < a; i++) {
int x = arr[i];
if (tracker.find(x) == tracker.end()) {
tmpii.first = i;
tmpii.second = 0;
tracker[x] = tmpii;
} else if (tracker[x].second == -1) {
continue;
} else if (tracker[x].second == 0) {
tmpii.second = i - tracker[x].first;
tmpii.first = i;
tracker[x] = tmpii;
} else if (tracker[x].second == i - tracker[x].first) {
tracker[x].first = i;
} else if (tracker[x].second != i - tracker[x].first) {
tracker[x] = make_pair(-1, -1);
}
}
map<int, pair<int, int> >::iterator itrmpip;
for (itrmpip = tracker.begin(); itrmpip != tracker.end(); itrmpip++) {
int res = itrmpip->second.second;
if (res != -1) {
anList.push_back(make_pair(itrmpip->first, res));
}
}
int sz = (int)anList.size();
printf("%d\n", sz);
for (int i = 0; i < sz; i++) {
printf("%d %d\n", anList[i].first, anList[i].second);
}
}
return 0;
}
| 8 | CPP |
n = int(input())
a = list(map(int, input().split()))
b = sorted(a)
c = []
for i in range(n):
for j in range(n - 1 - i):
while a[j] - a[j + 1] >= 2:
a[j] -= 1
a[j + 1] += 1
while a[j + 1] - a[j] >= 2:
a[j + 1] -= 1
a[j] += 1
k = a.index(max(a))
c.append(max(a))
a = a[:k] + a[k + 1:]
if c[::-1] == b:
print('YES')
else:
print('NO')
| 9 | PYTHON3 |
t = int(input())
for q in range(t):
n = int(input())
a = [int(i) for i in input().split()]
sumN = 0
pN = 1
zero = 0
a.sort()
for i in range(n):
sumN += a[i]
pN *= a[i]
if a[i] == 0:
zero += 1
if sumN != 0 and pN != 0:
print(0)
continue
else:
sumN += zero
if sumN == 0:
print(1 + zero)
else:
print(zero)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
void read(int &x) {
int v = 0, f = 1;
char c = getchar();
while (!isdigit(c) && c != '-') c = getchar();
if (c == '-')
f = -1;
else
v = v * 10 + c - '0';
while (isdigit(c = getchar())) v = v * 10 + c - '0';
x = v * f;
}
void read(long long &x) {
long long v = 0ll, f = 1ll;
char c = getchar();
while (!isdigit(c) && c != '-') c = getchar();
if (c == '-')
f = -1;
else
v = v * 10 + c - '0';
while (isdigit(c = getchar())) v = v * 10 + c - '0';
x = v * f;
}
void readc(char &x) {
char c;
while ((c = getchar()) == ' ')
;
x = c;
}
void writes(string s) { puts(s.c_str()); }
void writeln() { writes(""); }
void writei(int x) {
if (x < 0) {
putchar('-');
x = abs(x);
}
if (!x) putchar('0');
char a[25];
int top = 0;
while (x) {
a[++top] = (x % 10) + '0';
x /= 10;
}
while (top) {
putchar(a[top]);
top--;
}
}
void writell(long long x) {
if (x < 0) {
putchar('-');
x = abs(x);
}
if (!x) putchar('0');
char a[25];
int top = 0;
while (x) {
a[++top] = (x % 10) + '0';
x /= 10;
}
while (top) {
putchar(a[top]);
top--;
}
}
inline long long inc(int &x) { return ++x; }
inline long long inc(long long &x) { return ++x; }
inline long long inc(int &x, long long y) { return x += y; }
inline long long inc(long long &x, long long y) { return x += y; }
inline double inc(double &x, double y) { return x += y; }
inline long long dec(int &x) { return --x; }
inline long long dec(long long &x) { return --x; }
inline long long dec(int &x, long long y) { return x -= y; }
inline long long dec(long long &x, long long y) { return x -= y; }
inline double dec(double &x, double y) { return x -= y; }
inline long long mul(int &x) { return x = ((long long)x) * x; }
inline long long mul(long long &x) { return x = x * x; }
inline long long mul(int &x, long long y) { return x *= y; }
inline long long mul(long long &x, long long y) { return x *= y; }
inline double mul(double &x, double y) { return x *= y; }
inline long long divi(const int &x) {
long long ans, l, r, mid;
ans = 0;
l = 0;
r = 0x3fffffff;
while (l < r) {
mid = (l + r) / 2;
if (mid * mid <= x) {
ans = mid;
l = mid + 1;
} else
r = mid;
}
return ans;
}
inline long long divi(const long long &x) {
long long ans, l, r, mid;
ans = 0;
l = 0;
r = 0x3fffffff;
while (l < r) {
mid = (l + r) / 2;
if (mid * mid <= x) {
ans = mid;
l = mid + 1;
} else
r = mid;
}
return ans;
}
inline long long divi(int &x, long long y) { return x /= y; }
inline long long divi(long long &x, long long y) { return x /= y; }
inline double divi(double &x, double y) { return x /= y; }
inline long long mod(int &x, long long y) { return x %= y; }
inline long long mod(long long &x, long long y) { return x %= y; }
int n, m, i, j, k, a[20][20], b[20][20], lx[20], ly[20], ss, visx[20], visy[20],
dis[20][20], lk[20];
bool dfs(int x) {
if (visx[x]) return 0;
visx[x] = 1;
int i;
for (i = 0; i < n; i++) {
if (lx[x] + ly[i] == dis[x][i] && !visy[i]) {
visy[i] = 1;
if (lk[i] == -1 || dfs(lk[i])) {
lk[i] = x;
return 1;
}
}
}
return 0;
}
void update() {
int i, j, add = 0x3bbbbbbb;
for (i = 0; i < n; i++) {
if (visx[i]) {
for (j = 0; j < n; j++) {
if (!visy[j]) {
add = min(add, lx[i] + ly[j] - dis[i][j]);
}
}
}
}
for (i = 0; i < n; i++) {
if (visx[i]) lx[i] -= add;
if (visy[i]) ly[i] += add;
}
}
int KM() {
int i, j, k;
int ans = 0;
memset(lx, 0, sizeof(lx));
memset(ly, 0, sizeof(ly));
memset(lk, -1, sizeof(lk));
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
lx[i] = max(lx[i], dis[i][j]);
}
ans += lx[i];
}
if (ans <= ss) return 0;
for (i = 0; i < n; i++) {
for (;;) {
memset(visx, 0, sizeof(visx));
memset(visy, 0, sizeof(visy));
if (dfs(i)) break;
update();
ans = 0;
for (int i = 0; i < n; i++) {
ans += lx[i] + ly[i];
}
if (ans <= ss) return 0;
}
}
ans = 0;
for (i = 0; i < n; i++) {
ans += lx[i] + ly[i];
}
return ans;
}
int main() {
double st = clock();
cin >> n;
if ((0) <= (n - 1))
for ((i) = (0); (i) <= (n - 1); (i)++)
if ((0) <= (n - 1))
for ((j) = (0); (j) <= (n - 1); (j)++) cin >> a[i][j];
if ((0) <= (n - 1))
for ((i) = (0); (i) <= (n - 1); (i)++)
if ((0) <= (n - 1))
for ((j) = (0); (j) <= (n - 1); (j)++) cin >> b[i][j];
if ((0) <= ((1 << n) - 1))
for ((i) = (0); (i) <= ((1 << n) - 1); (i)++)
if (__builtin_popcount(i) == n / 2) {
if ((0) <= (n - 1))
for ((j) = (0); (j) <= (n - 1); (j)++) {
if ((0) <= (n - 1))
for ((k) = (0); (k) <= (n - 1); (k)++) {
if ((i >> j) & 1)
dis[j][k] = b[j][k];
else
dis[j][k] = a[j][k];
}
}
ss = max(ss, KM());
if ((clock() - st) / CLOCKS_PER_SEC > 1.5) break;
}
cout << ss << endl;
return 0;
}
| 9 | CPP |
d = {}
acc = 0
ind = 0
min = 200001
t = int(input())
for i in range(t):
min = 200001
cont = 0
n = int(input())
a = input().split()
list = a
for j in range(n):
if a[j] in d:
d[a[j]] += 1
else:
d[a[j]] = 1
for j in d:
cont += 1
if(d[j] == 1):
if(int(j) < min):
min = int(j)
ind = cont
acc = 1
if(acc == 0):
ind = -1
print(ind)
else:
for j in range(n):
if(min == int(list[j])):
print(j+1)
acc = 0
d.clear()
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, k, flag[200005];
struct node {
char s;
int id;
} s1[200005];
stack<node> t;
int main(void) {
int num = 0;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf(" %c", &s1[i].s), s1[i].id = i;
for (int i = 1; i <= n; i++) {
if (s1[i].s == '(') {
t.push(s1[i]);
continue;
}
if (t.empty() == 0 && t.top().s == '(') {
t.pop();
continue;
}
flag[i] = 1;
num++;
}
while (t.empty() == 0) flag[t.top().id] = 1, t.pop(), num++;
num = n - num;
for (int i = 1; i <= n; i++) {
if (num == k || flag[i]) break;
if (s1[i].s == '(')
t.push(s1[i]);
else
flag[t.top().id] = 1, flag[i] = 1, num -= 2, t.pop();
}
for (int i = 1; i <= n; i++)
if (flag[i] == 0) printf("%c", s1[i].s);
printf("\n");
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, k, pre[1000005][2], suf[1000005][2];
char s[1000005];
int main() {
scanf("%d %d %s", &n, &k, s + 1);
pre[0][0] = pre[0][1] = 0;
for (int i = 1; i <= n; i++) {
pre[i][0] = (s[i] == '0') ? i : pre[i - 1][0];
pre[i][1] = (s[i] == '1') ? i : pre[i - 1][1];
}
suf[n + 1][0] = suf[n + 1][1] = n + 1;
for (int i = n; i >= 1; i--) {
suf[i][0] = (s[i] == '0') ? i : suf[i + 1][0];
suf[i][1] = (s[i] == '1') ? i : suf[i + 1][1];
}
if (pre[n][0] - suf[1][0] < k or pre[n][1] - suf[1][1] < k) {
printf("tokitsukaze\n");
return 0;
}
for (int i = 1; i <= n - k + 1; i++) {
int mnsif = pre[i - 1][0] != 0 ? suf[1][0] : suf[i + k][0];
int mxsif = suf[i + k][0] != n + 1 ? pre[n][0] : pre[i - 1][0];
int mnbir = min(i, suf[1][1]);
int mxbir = max(i + k, pre[n][1]);
if (mxsif - mnsif >= k and mxbir - mnbir >= k) {
printf("once again\n");
return 0;
}
mnsif = pre[i - 1][1] != 0 ? suf[1][1] : suf[i + k][1];
mxsif = suf[i + k][1] != n + 1 ? pre[n][1] : pre[i - 1][1];
mnbir = min(i, suf[1][0]);
mxbir = max(i + k, pre[n][0]);
if (mxsif - mnsif >= k and mxbir - mnbir >= k) {
printf("once again\n");
return 0;
}
}
printf("quailty\n");
return 0;
}
| 9 | CPP |
import io, os
def main():
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
n, k = map(int, input().split())
g, e = [x - 65 for x in input()], [-1] * 26
for i in range(n): e[g[i]] = i
curS, met = 0, [0] * 26
for i in range(n):
if not met[g[i]]: curS += 1; met[g[i]] = 1
if curS > k: os.write(1, b'YES'); exit()
if i == e[g[i]]: curS -= 1
os.write(1, b'NO')
main()
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int64_t N,x;
cin>>N>>x;
vector<int64_t> a(N);
for(int i=0;i<N;++i) cin>>a[i];
//K回転して揃えるときの最小値
int64_t ans=0;
for(int i=0;i<N;++i) ans += a[i];
vector<int64_t> b=a;
for(int K=1;K<N;++K){
int64_t subans=0;
for(int i=0;i<N;++i){
b[i]=min(b[i],a[(i+(N-K))%N]);
subans += b[i];
}
ans=min(ans,subans+K*x);
}
cout<<ans<<endl;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, arr[(int)2e5 + 5];
double l = 0, h = 10000000000, mid, ans;
bool GO(double m, int *arr, int no) {
int x = arr[0];
auto it = upper_bound(arr, arr + no, m * 2 + x);
for (int i = 0; i < 2; ++i) {
it = upper_bound(arr, arr + no, m * 2 + x);
x = *it;
}
auto it1 = upper_bound(arr, arr + no, m * 2 + x);
if (it < arr + no && ((m * 2) + *it) < arr[no - 1])
return 0;
else
return 1;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%d", arr + i);
if (n == 3) {
printf("%f\n", 0.0);
printf("%.6f %.6f %.6f\n", (double)arr[0], (double)arr[1], (double)arr[2]);
return 0;
}
sort(arr, arr + n);
for (int i = 0; i < 1000; ++i) {
mid = (l + h) / 2;
if (GO(mid, arr, n)) {
ans = mid;
h = mid - 1;
} else {
l = mid + 1;
}
}
printf("%.6f\n", ans);
auto it = upper_bound(arr, arr + n, arr[0] + ans * 2);
auto it1 = upper_bound(arr, arr + n, *it + ans * 2);
printf("%.6f %.6f %.6f\n", arr[0] + ans, *it + ans, *it1 + ans);
}
| 9 | CPP |
#include<iostream>
#include<algorithm>
using namespace std;
int main(){
int minj,cnt=0,N,A[100];
cin >> N ;
for(int i=0;i<N;i++)cin >> A[i];
for(int i=0;i<N;i++){
minj = i;
for(int j=i;j<N;j++){
if (A[j] < A[minj]) minj = j;
}
if(minj!=i){
swap(A[minj],A[i]);cnt++;
}
}
for(int i=0;i<N;i++){cout << A[i] ; if(i!=N-1)cout << " ";}
cout << endl << cnt << endl;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int a[250];
char op[250];
int c = 0;
vector<string> split(string work, char delim, char dd) {
vector<string> flds;
if (!flds.empty()) flds.clear();
string buf = "";
int i = 0;
while (i < (int)work.size()) {
if (work[i] == delim || work[i] == dd) {
op[c++] = work[i];
}
if (work[i] != delim && work[i] != dd) {
buf += work[i];
} else if (((int)buf.size()) > 0) {
flds.push_back(buf);
buf = "";
}
i++;
}
if ((int)buf.size()) {
flds.push_back(buf);
}
return flds;
}
int main() {
string s;
cin >> s;
vector<string> nums = split(s, '+', '-');
int n = nums.size();
int sum = stoi(nums[0]);
for (int i = 1; i < n; i++) {
a[i] = stoi(nums[i]);
if (op[i - 1] == '+') {
sum += a[i];
} else {
sum -= a[i];
}
}
for (int i = 1; i <= sum; i++) {
cout << "+";
}
cout << endl;
cout
<< ">>++++++++++<<[->+>-[>+>>]>[+[-<+>]>+>>]<<<<<<]>>[-]>>>++++++++++<[->"
"-[>+>>]>[+[-<+>]>+>>]<<<<<]>[-]>>[>++++++[-<++++++++>]<.<<+>+>[-]]<[<"
"[->-<]++++++[->++++++++<]>.[-]]<<++++++[-<++++++++>]<.[-]<<[-<+>]<";
}
| 13 | CPP |
for _ in range(int(input())):
n = int(input())
L = list(map(int,input().split()))
cnt = sum(L)
if (n-cnt)*2 >= n:
print(n//2)
print(*[0 for i in range(n//2)])
else:
print(cnt-cnt%2)
print(*[1 for i in range(cnt-cnt%2)]) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int a, b, s;
cin >> a >> b >> s;
if (a < 0) a = a * (-1);
if (b < 0) b = b * (-1);
if (a + b > s) {
cout << "NO" << endl;
return 0;
}
if ((s - a - b) % 2 == 1) {
cout << "NO" << endl;
return 0;
} else {
cout << "YES" << endl;
return 0;
}
}
| 7 | CPP |
#include<iostream>
#include<algorithm>
#include<cstring>
#define pb push_back
#include<vector>
#include<cstdio>
using namespace std;
string m(string s,string t){
int a=s.size(),b=t.size();
if(a!=b)
return a>b?s:t;
return s>t?s:t;
}
int main(){
int h,w;
while(scanf("%d%d",&w,&h),w||h){
string d[80];
for(int i=0;i<h;i++){
cin>>d[i];
}
string ans="0";
string dp[80][80];
for(int i=0;i<h;i++){
for(int j=0;j<w;j++){
if(isdigit(d[i][j])){
string a,b;
dp[i][j]="";
dp[i][j]+=d[i][j];
if(i>=1&&j>=1){
dp[i][j]=m(dp[i-1][j],dp[i][j-1])+d[i][j];
}else if(i>=1){
dp[i][j]=dp[i-1][j]+d[i][j];
}else if(j>=1){
dp[i][j]=dp[i][j-1]+d[i][j];
}
if(dp[i][j][0]=='0')
dp[i][j]=dp[i][j].substr(1);
ans=m(ans,dp[i][j]);
}else
dp[i][j]="";
}
}
cout<<ans<<endl;
}
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:100000000000000")
using namespace std;
const long long int INF = 2e18;
vector<vector<long long int> > g;
vector<long long int> op, used;
long long int mod = 1000000007;
long long int dfs(long long int id, long long int now, long long int mode = 0) {
used[id]++;
long long int val = 0;
if (g[id][1] != -1) {
long long int to = g[id][1];
val = dfs(to, now + (mode == 1 ? 1 : 0), mode);
}
return (val + op[id] * now);
}
long long int dp[200001], temp[200001], prep[200001];
int main() {
long long int n, q, t;
cin >> n >> q >> t;
op.resize(n);
for (long long int i = 0; i < n; i++) cin >> op[i];
long long int a, b;
g.resize(n, vector<long long int>(2, -1));
for (long long int i = 0; i < q; i++) {
cin >> a >> b;
a--;
b--;
g[a][0] = b;
g[b][1] = a;
if (g[a][0] == g[a][1]) {
cout << 0;
return 0;
}
if (g[b][0] == g[b][1]) {
cout << 0;
return 0;
}
}
long long int temp = 0;
used.assign(n, 0);
for (long long int i = 0; i < n; i++) {
if (g[i][0] == -1) {
long long int ok = dfs(i, 0, 1);
temp += ok;
if (temp > t) {
cout << 0;
return 0;
}
}
}
for (long long int i = 0; i < n; i++) {
if (g[i][0] != -1 && !used[i]) {
cout << 0;
return 0;
}
}
dp[temp] = 1;
for (long long int j = 0; j < n; j++) {
prep[j] = dfs(j, 1);
}
for (long long int i = 0; i < n; i++) {
for (long long int j = temp; j <= t; j++) {
if (j + prep[i] <= t) dp[j + prep[i]] = (dp[j + prep[i]] + dp[j]) % mod;
}
}
cout << dp[t];
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 105;
int dp[N][3], to[255];
int main() {
ios::sync_with_stdio(0);
int n;
string s;
cin >> n;
cin >> s;
to['C'] = 0, to['M'] = 1, to['Y'] = 2;
if (s[0] == '?') {
dp[0][0] = dp[0][1] = dp[0][2] = 1;
} else {
dp[0][to[s[0]]] = 1;
}
for (int i = 1; i < ((int)(s).size()); i++) {
if (s[i] == '?') {
dp[i][0] = dp[i - 1][1] + dp[i - 1][2];
dp[i][1] = dp[i - 1][0] + dp[i - 1][2];
dp[i][2] = dp[i - 1][0] + dp[i - 1][1];
} else {
int ch = to[s[i]];
dp[i][ch] = dp[i - 1][0] + dp[i - 1][1] + dp[i - 1][2] - dp[i - 1][ch];
}
for (int j = 0; j < 3; j++) {
if (dp[i][j] > N) {
dp[i][j] = N;
}
}
}
puts(dp[((int)(s).size()) - 1][0] + dp[((int)(s).size()) - 1][1] +
dp[((int)(s).size()) - 1][2] >
1
? "Yes"
: "No");
return 0;
}
| 7 | CPP |
def check(a):
s=0
for char in str(a):
s+=int(char)
if s%4==0:
return True
return False
n=int(input())
while not check(n):
n+=1
print(n)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k = 0;
string s;
cin >> n >> s;
for (int i = 0; i < n; i++) {
if (s[i] == 'o' && s[i + 1] == 'g' && s[i + 2] == 'o') {
s[i] = '*';
s[i + 1] = '*';
s[i + 2] = '*';
k = 1;
i += 3;
}
if (k == 1 && s[i] == 'g' && s[i + 1] == 'o') {
s.erase(s.begin() + i);
s.erase(s.begin() + i);
i--;
} else if (k == 1) {
k = 0;
i -= 3;
}
}
cout << s;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXn = 500 + 10;
int coor[MAXn][2];
int dis[MAXn];
int rod[MAXn];
bool mark[MAXn];
int ans[MAXn];
int n, m;
inline int abs(int a) {
if (a < 0) return -a;
return a;
}
void input() {
cin >> n >> m;
for (int i = 0; i < (n); i++) cin >> coor[i][0] >> coor[i][1];
for (int i = 0; i < (m); i++) cin >> rod[i];
for (int i = 0; i < (n); i++)
dis[i] = abs(coor[i][0] - coor[(i + 1) % n][0]) +
abs(coor[i][1] - coor[(i + 1) % n][1]);
}
bool find(int a) {
int nxt = (a + 1) % n;
for (int i = 0; i < (m); i++)
if (rod[i] == (dis[a] + dis[nxt]) && !mark[i]) {
mark[i] = true;
ans[nxt] = i;
return true;
}
return false;
}
bool good(int start) {
memset(mark, 0, sizeof(mark));
memset(ans, -1, sizeof(ans));
for (int i = 0; i < (n / 2); i++) {
int now = start + 2 * i;
if (find(now) == false) return false;
}
return true;
}
void output() {
cout << "YES" << endl;
for (int i = 0; i < (n); i++) {
if (ans[i] == -1)
cout << -1 << " ";
else
cout << ans[i] + 1 << " ";
}
cout << endl;
}
int main() {
input();
if (good(0))
output();
else {
if (good(1))
output();
else
cout << "NO" << endl;
}
return 0;
}
| 7 | CPP |
l, r = map(int, input().split())
for x in range(l, r+1):
s = [False]*10
q = str(x)
o = True
for i in range(len(q)):
if s[int(q[i])]:
o = False
break
s[int(q[i])] = True
if o:
print(x)
raise SystemExit
print(-1)
| 7 | PYTHON3 |
import string
n, k = map(int, input().split())
a = []
a = input().split()
a = [int(s) for s in a]
passed = 0
min_score = a[k-1]
a.sort()
for score in a:
if score >= min_score and score > 0:
passed += 1
print(passed)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int64_t A,B;
cin>>A>>B;
while(A!=0&&B!=0){
if(A>B){
A=A%B;
}
else{
B=B%A;
}
}
int64_t Z=1,X=max(A,B);
for(int64_t i=2;i<1000000;i++){
if(X%i==0){
Z++;
while(X%i==0){
X/=i;
}
}
}
if(X>1){
Z++;
}
cout<<Z<<endl;
} | 0 | CPP |
n=int(input())
X=[0,5,3,2,4,1]
ANS=[0]*6
for i in range(6):
if n & (1<<i)!=0:
ANS[X[5-i]]=1
print(int("".join(map(str,ANS)),2))
| 7 | PYTHON3 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const int N = 300031;
int n, tests;
int ar[N];
int earliest[N][22];
int last_entry[22];
int main() {
cin >> n >> tests;
for (int i = 1; i <= n; i++) {
scanf("%d", &ar[i]);
}
for (int i = 1; i <= n + 1; i++) {
for (int j = 0; j <= 20; j++) {
earliest[i][j] = n + 1;
}
}
for (int i = 0; i < 20; i++) {
last_entry[i] = n + 1;
}
for (int i = n; i >= 1; --i) {
for (int j = 0; j < 20; j++) {
earliest[i][j] = n + 1;
}
for (int j = 0; j < 20; j++) {
if (ar[i] & (1 << j)) {
earliest[i][j] = i;
for (int q = 0; q < 20; q++) {
earliest[i][q] = min(earliest[i][q], earliest[last_entry[j]][q]);
}
last_entry[j] = i;
}
}
}
for (int test = 1; test <= tests; test++) {
int l, r;
scanf("%d", &l);
scanf("%d", &r);
int can = 0;
for (int i = 0; i < 20; i++) {
if (ar[r] & (1 << i))
if (earliest[l][i] <= r) can = 1;
}
if (can)
puts("Shi");
else
puts("Fou");
}
return 0;
}
| 9 | CPP |
a,b,r=map(int,input().split())
if a<2*r or b<2*r:
exit(print('Second'))
else:
exit(print("First")) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define repl(i,a,b) for(int i=(int)(a);i<(int)(b);i++)
#define rep(i,n) repl(i,0,n)
#define each(itr,v) for(auto itr:v)
#define pb(s) push_back(s)
#define mp(a,b) make_pair(a,b)
#define all(x) (x).begin(),(x).end()
#define dbg(x) cout<<#x"="<<x<<endl
#define maxch(x,y) x=max(x,y)
#define minch(x,y) x=min(x,y)
#define uni(x) x.erase(unique(all(x)),x.end())
#define exist(x,y) (find(all(x),y)!=x.end())
#define bcnt(x) bitset<32>(x).count()
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> P;
#define INF 1e16
ll n,k,s;
ll x[2222],y[2222],z[2222];
bool used[2002];
vector<int> g[2222];
bool is_cross(int i,int j){
return (abs(x[i]-x[j])<=s)&&(abs(y[i]-y[j])<=s)&&(abs(z[i]-z[j])<=s);
}
ll cross_surf(int i,int j){
ll xx=s-abs(x[i]-x[j]);
ll yy=s-abs(y[i]-y[j]);
ll zz=s-abs(z[i]-z[j]);
return 2*(xx*yy+yy*zz+zz*xx);
}
int main(){
cin.sync_with_stdio(false);
while(1){
rep(i,2222)g[i].clear();
cin>>n>>k>>s;
if(n==0)break;
rep(i,n){
cin>>x[i]>>y[i]>>z[i];
}
if(k==1){
cout<<s*s*6<<endl;
continue;
}
rep(i,n)rep(j,i){
if(is_cross(i,j)){
g[i].pb(j);
g[j].pb(i);
}
}
ll res=INF;
rep(i,n){
for(int j: g[i]){
memset(used,0,sizeof(used));
used[i]=used[j]=true;
ll sum=s*s*6*2-cross_surf(i,j);
int cnt=2;
int last;
rep(hoge,k-2){
for(int nxt:g[j]){
if(used[nxt])continue;
used[nxt]=true;
sum+=s*s*6-cross_surf(j,nxt);
last=nxt;
cnt++;
j=nxt;
}
}
if(cnt==k)minch(res,sum-(k>2&&is_cross(i,last)?cross_surf(i,last):0));
}
}
if(res==INF)cout<<-1<<endl;
else cout<<res<<endl;
}
return 0;
} | 0 | CPP |
"""
def wormsy(n,piles,m,worms):
for w in worms:
pile_no=0
current=0
for pile in piles:
current+=pile
pile_no+=1
if current>=w:
print(pile_no)
break
else:
continue
return
"""
"""
def binary(x,end,piles,start=0):
m=(start+end)//2
if piles[start]>=x:
return start
elif piles[end]>=x and piles[end-1]<x:
return end
elif x>piles[m]:
if x<=piles[m+1]:
return m+1
else:
return binary(x,end,piles,m+1)
elif x<piles[m]:
if x>piles[m-1]:
return m
else:
return binary(x,m-1,piles,start)
elif x==piles[m]:
return m
def timelimit(n,piles,m,worms):
mw=max(worms)
for i in range(1,n):
piles[i]=piles[i]+piles[i-1]
if piles[i]>mw:
break
for x in worms:
print(binary(x,n-1,piles,0)+1)
return
"""
n=int(input())
piles=list(map(int,input().split(" ")))
m=int(input())
worms=list(map(int,input().split(" ")))
#timelimit(n,piles,m,worms)
new_list=[]
grp=0
for x in piles:
grp+=1
for i in range(x):
new_list.append(grp)
for m in worms:
print(new_list[m-1])
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m;
cin >> n >> m;
if (m == 2) {
long long c = n % 6;
if (c == 2 || c == 3) cout << 0;
if (c == 0 || c == 1) cout << 2;
if (c == 4 || c == 5) cout << 1;
} else if (m == 1) {
long long c = n % 6;
if (c == 1 || c == 4) cout << 0;
if (c == 2 || c == 5) cout << 2;
if (c == 0 || c == 3) cout << 1;
} else if (!m) {
long long c = n % 6;
if (c == 1 || c == 2) cout << 1;
if (c == 3 || c == 4) cout << 2;
if (c == 0 || c == 5) cout << 0;
}
return 0;
}
| 7 | CPP |
Subsets and Splits