solution
stringlengths 10
983k
| difficulty
int64 0
25
| language
stringclasses 2
values |
|---|---|---|
import operator
n = int(input())
d = dict()
for i in map(int, input().split()):
if i in d:
d[i] += 1
else:
d[i] = 1
print(max(d.items(), key=operator.itemgetter(1))[1]) | 9 | PYTHON3 |
n = max(map(int, input().split()))
a = ['', '1/1', '5/6', '2/3', '1/2', '1/3', '1/6']
print(a[n])
| 7 | PYTHON3 |
n,m=map(int,input().split())
PY=[list(map(int,input().split())) for _ in range(m)]
ypi=[[y,p,i] for i,(p,y) in enumerate(PY)] #順番iはp,yより前に来る
ypi.sort()
from collections import defaultdict
d=defaultdict(int)
ans=[0]*m
for y,p,i in ypi:
d[p]+=1
ans[i]=str(p).zfill(6)+str(d[p]).zfill(6)
print(*ans,sep="\n") | 0 | PYTHON3 |
fact = [0] * 1000001
fact[0] = 1
mod = 998244353
n = int(input())
fact[n] = n
for i in range(n - 1, -1, -1):
fact[i] = (fact[i + 1] * i) % mod
ans = (n * fact[1]) % mod
for i in range(1, n):
ans = (ans + mod - fact[n - (n - i) + 1]) % mod
print(int(ans)) | 13 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
void ASS(bool b) {
if (!b) {
++*(int*)0;
}
}
#pragma comment(linker, "/STACK:106777216")
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < (int)(n); i++) cin >> a[i];
sort(a.begin(), a.end());
vector<int> ans(n);
ans[0] = 1;
for (int i = 0; i < (int)(n - 1); i++) {
ans[i + 1] = a[i];
}
bool allOnes = 1;
for (int i = 0; i < (int)(n); i++)
if (a[i] != 1) {
allOnes = 0;
break;
}
if (allOnes) ans.back() = 2;
for (int i = 0; i < (int)(n); i++) {
if (i) cout << " ";
cout << ans[i];
}
cout << endl;
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 110;
bool okay[110];
string w, v = "";
bool check(int j, string& s) {
for (int i = 0; i < s.length(); i++) {
if (j + i >= v.length()) return false;
if (v[j + i] != s[i]) return false;
}
return true;
}
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
vector<string> s(n);
for (int i = 0; i < n; i++) {
cin >> s[i];
string t = "";
for (int j = 0; j < s[i].length(); j++) t += tolower(s[i][j]);
s[i] = t;
}
cin >> w;
for (int i = 0; i < w.length(); i++) v += tolower(w[i]);
char letter;
cin >> letter;
for (int i = 0; i < n; i++) {
for (int j = 0; j < v.length(); j++) {
if (check(j, s[i])) fill(okay + j, okay + j + s[i].length(), true);
}
}
set<int> idx;
for (int i = 0; i < maxn; i++) {
if (okay[i]) idx.insert(i);
}
for (int i = 0; i < w.length(); i++) {
if (idx.find(i) == idx.end()) continue;
if (w[i] >= 'A' && w[i] <= 'Z') {
if (tolower(w[i]) == tolower(letter)) {
if (tolower(letter) == 'a') {
w[i] = 'B';
} else
w[i] = 'A';
} else {
w[i] = toupper(letter);
}
} else {
if (tolower(w[i]) == tolower(letter)) {
if (tolower(letter) == 'a') {
w[i] = 'b';
} else
w[i] = 'a';
} else {
w[i] = tolower(letter);
}
}
}
cout << w;
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC target("avx2")
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
constexpr long long pct(long long x) { return __builtin_popcount(x); }
const long long DFS_WHITE = 0;
const long long DFS_BLACK = 1;
const long long INF = 1e18;
const long long MAXN = 2e5 + 10;
const long long MOD = 1e9 + 7;
void setIO(string filename = "") {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
if (filename.size() == 0) return;
freopen((filename + ".in").c_str(), "r", stdin);
freopen((filename + ".out").c_str(), "w", stdout);
}
long long n, m;
void solve() {
cin >> n >> m;
if (m > n) {
swap(n, m);
}
if ((m + n) % 2 == 0) {
long long tmp = (n + m) / 2;
vector<long long> ans;
for (long long i = n - tmp; i <= n - tmp + m * 2 and i <= n + m; i += 2) {
ans.push_back(i);
}
cout << ans.size() << endl;
for (auto a : ans) {
cout << a << " ";
}
} else {
vector<long long> ans;
long long tmp = (n + m + 1) / 2;
for (long long i = n - tmp; i <= n - tmp + m * 2 and i <= n + m; i += 2) {
ans.push_back(i);
}
tmp = (n + m - 1) / 2;
for (long long i = n - tmp; i <= n - tmp + 2 * m and i <= n + m; i += 2) {
ans.push_back(i);
}
vector<long long> res;
long long cur = 0;
res.push_back(ans[cur]);
for (long long i = 0; i < ans.size(); i++) {
if (ans[i] != ans[cur]) {
cur++;
res.push_back(ans[i]);
}
}
sort(ans.begin(), ans.end());
cout << ans.size() << endl;
for (long long i = 0; i < ans.size(); i++) {
cout << ans[i] << " ";
}
}
}
signed main() {
setIO();
long long test = 1;
cin >> test;
while (test--) {
solve();
if (test) cout << endl;
}
}
| 8 | CPP |
#include<iostream>
#include<string>
#include<vector>
#include<cctype>
#include<cstring>
using namespace std;
class EmacsLikeEditor{
public:
vector<string> text;
int cur;
int line;
string buf;
EmacsLikeEditor(const vector<string> &vs){
cur = 0;
line = 0;
buf = "";
for(int i = 0; i < vs.size(); ++i){
text.push_back( "" );
for(int j = 0; j < vs[i].length(); ++j){
//if( !iscntrl( vs[i][j] ) ){
text[i] += vs[i][j];
//}
}
text[i] += "$";
}
}
void Command(char c){
switch( c ){
case 'a': MoveLineFront(); break;
case 'e': MoveLineEnd(); break;
case 'p': MoveAbove(); break;
case 'n': MoveBelow(); break;
case 'f': MoveFront(); break;
case 'b': MoveBack(); break;
case 'd': Delete(); break;
case 'k': CutLine(); break;
case 'y': Paste(); break;
default:
break;
}
}
bool ExistAboveLine(){ return line > 0; }
bool ExistBelowLine(){ return line < text.size() - 1; }
bool FrontOfLine(){ return cur == 0; }
bool EndOfLine(){ return cur == text[line].size() - 1; }
void MoveLineFront(){ cur = 0; }
void MoveLineEnd(){ cur = text[line].size() - 1; }
void MoveAbove(){ if( ExistAboveLine() ){ --line; } MoveLineFront(); }
void MoveBelow(){ if( ExistBelowLine() ){ ++line; } MoveLineFront(); }
void MoveFront(){ if( !EndOfLine() ){ ++cur; }else{ if( ExistBelowLine() ){ ++line; cur = 0; } } }
void MoveBack(){ if( !FrontOfLine() ){ --cur; }else{ if( ExistAboveLine() ){ --line; cur = text[line].size()-1; } } }
void Delete(){
if( !EndOfLine() ){ text[line].erase( text[line].begin() + cur );
}else if( ExistBelowLine() ){
text[line].erase( text[line].end() - 1 );
for(int i = 0; i < text[line+1].length(); ++i){
text[line]+=text[line+1][i];
}
text.erase( text.begin() + line + 1 );
}
}
void CutLine(){
if( EndOfLine() ){
if( ExistBelowLine() ){ buf="$"; Delete(); }
}else{
buf = string( text[line].begin() + cur, text[line].end() - 1 );
text[line].erase( text[line].begin() + cur, text[line].end() - 1 );
cur = text[line].size() - 1;
}
}
void Paste(){
if( buf == "" ) return ;
else{
if( buf == "$" ){
text.insert( text.begin() + line + 1, string(text[line].begin() + cur, text[line].end()) );
text[line].erase( text[line].begin() + cur, text[line].end() - 1);
++line;
cur = 0;
}else{
text[line].insert( text[line].begin() + cur, buf.begin(), buf.end() );
cur += buf.length();
}
}
}
};
int main()
{
vector<string> vs;
while(true){
string s;
getline(cin,s);
//while(iscntrl(s[s.length()-1]))s.erase(s.end()-1);
if( s == "END_OF_TEXT" ) break;
vs.push_back( s );
}
EmacsLikeEditor ele(vs);
while(true){
char command;
cin >> command;
if( command == '-' ) break;
ele.Command( command );
}
for(int i = 0; i < ele.text.size(); ++i){
ele.text[i].erase( ele.text[i].end() - 1 );
cout << ele.text[i] << endl;
}
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int MAXN = 105;
int ar[MAXN];
int main() {
int n, m, k;
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
cin >> ar[i];
if (ar[i] == 0) ar[i] = INF;
}
int i = 1;
int ans = 10;
while (1) {
if (m + i <= n && m - i >= 1) {
int p = min(ar[m + i], ar[m - i]);
if (p <= k) {
cout << ans << endl;
return 0;
}
} else if (m + i <= n) {
if (ar[m + i] <= k) {
cout << ans << endl;
return 0;
}
} else {
if (ar[m - i] <= k) {
cout << ans << endl;
return 0;
}
}
i++;
ans += 10;
}
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long long mxn = 1e5 + 7;
const long long inf = 1e18;
inline void normal(long long &a) {
a %= mod;
(a < 0) && (a += mod);
}
inline long long modMul(long long a, long long b) {
a %= mod, b %= mod;
normal(a), normal(b);
return (a * b) % mod;
}
inline long long modAdd(long long a, long long b) {
a %= mod, b %= mod;
normal(a), normal(b);
return (a + b) % mod;
}
inline long long modSub(long long a, long long b) {
a %= mod, b %= mod;
normal(a), normal(b);
a -= b;
normal(a);
return a;
}
inline long long modPow(long long b, long long p) {
long long r = 1;
while (p) {
if (p & 1) r = modMul(r, b);
b = modMul(b, b);
p >>= 1;
}
return r;
}
inline long long modInverse(long long a) { return modPow(a, mod - 2); }
inline long long modDiv(long long a, long long b) {
return modMul(a, modInverse(b));
}
struct str {
long long a, b, c, d, inx;
};
bool cmp(str s1, str s2) {
if (s1.d != s2.d) {
return s1.d < s2.d;
}
}
int main() {
long long i, j, k, a, b, c, d, n, m, t, u, v, w, x, y, z;
cin >> n;
str s[n];
for (i = 0; i < n; i++) {
cin >> a >> b >> c >> d;
s[i].a = a;
s[i].b = b;
s[i].c = c;
s[i].d = d;
s[i].inx = i + 1;
}
long long cost = inf, ans = 0;
sort(s, s + n, cmp);
for (i = 0; i < n; i++) {
a = s[i].a;
b = s[i].b;
c = s[i].c;
bool ok = true;
for (j = 0; j < n; j++) {
x = s[j].a;
y = s[j].b;
z = s[j].c;
if (i != j) {
if (a < x and b < y and c < z) {
ok = false;
break;
}
}
}
if (ok) {
long long cur = s[i].d;
if (cur < cost) {
ans = s[i].inx;
break;
}
}
}
cout << ans << "\n";
return 0;
}
| 8 | CPP |
t=int(input())
l=list(map(int,input().split()))
l.sort()
a=sum(l[0:int(len(l)/2)])
b=sum(l[int(len(l)/2):])
print(a**2+b**2)
| 8 | PYTHON3 |
import math
n = int(input())
l = list(map(int,input().split()))
b = l[0]*l[1]//math.gcd(l[0],l[1])
g = math.gcd(l[0],l[1])
for i in l[2:]:
g1 = math.gcd(i,g)
b = math.gcd(b,(i*g)//g1)
g = g1
print(b) | 7 | PYTHON3 |
#include <cstdio>
int main()
{
long long a,b,c; scanf("%lld%lld%lld",&a,&b,&c);
c-=a+b;
if(c<0) printf("No");
else if(c*c>4*a*b) printf("Yes");
else printf("No");
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 100000;
int sp[MAX + 1];
int xo[MAX + 1];
vector<pair<int, int> > v[MAX + 1];
int main() {
for (int i = 1; i <= MAX / 2; i++) {
for (int j = 2; j * (2 * i + j - 1) <= 2 * MAX; j++) {
int n = j * (2 * i + j - 1) / 2;
v[n].push_back(make_pair(i, j));
}
}
for (int i = 3; i <= MAX; i++) {
vector<int> temp(1);
temp[0] = -1;
for (int j = 0; j < v[i].size(); j++) {
int start = v[i][j].first;
int end = start + v[i][j].second - 1;
temp.push_back(xo[end] ^ xo[start - 1]);
}
sort(temp.begin(), temp.end());
int k = 1;
for (; k < temp.size(); k++) {
if (temp[k] == temp[k - 1]) continue;
if (temp[k] != temp[k - 1] + 1) break;
}
sp[i] = 1 + temp[k - 1];
xo[i] = sp[i] ^ xo[i - 1];
}
int N;
cin >> N;
if (!sp[N]) {
cout << -1 << endl;
return 0;
}
for (int i = v[N].size() - 1; i >= 0; i--) {
int start = v[N][i].first;
int end = v[N][i].second - 1 + start;
if (!(xo[end] ^ xo[start - 1])) {
cout << v[N][i].second << endl;
return 0;
}
}
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10, Msk = (1 << 17), inf = 1e9 + 10, MOD = 1e9 + 7,
Sq = 708;
const long long INF = 1e18 + 10;
int a[10][10], p[10];
int main() {
ios_base::sync_with_stdio(false);
int n, k;
cin >> n >> k;
char ch;
for (int i = 0; i < n; i++)
for (int j = 0; j < k; j++) {
cin >> ch;
a[i][j] = ch - 48;
}
for (int i = 0; i < k; i++) p[i] = i;
int ans = inf;
do {
int mx = -inf, mn = inf;
for (int i = 0; i < n; i++) {
int x = 0;
for (int j = 0; j < k; j++) (x *= 10) += a[i][p[j]];
mx = max(mx, x);
mn = min(mn, x);
}
ans = min(ans, mx - mn);
} while (next_permutation(p, p + k));
cout << ans;
return 0;
}
| 8 | CPP |
import math,sys
from collections import Counter, defaultdict, deque
from sys import stdin, stdout
input = stdin.readline
lili=lambda:list(map(int,sys.stdin.readlines()))
li = lambda:list(map(int,input().split()))
#for deque append(),pop(),appendleft(),popleft(),count()
I=lambda:int(input())
S=lambda:input().strip()
mod = 1000000007
for i in range(I()):
n,s,k=li()
a=li()
d=Counter(a)
p=s
q=s
while(True):
if(p not in d):
print(p-s)
break
elif(q not in d):
print(s-q)
break
else:
p=min(p+1,n)
q=max(1,q-1)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<string> words;
string t;
while (cin >> t) words.push_back(t);
bool ok = true;
string gp[2][3] = {{"lios", "etr", "initis"}, {"liala", "etra", "inites"}};
int pp = -1;
int gender = -1;
for (int i = 0; i < words.size(); ++i) {
string& w = words[i];
int g = -1;
int p = -1;
for (int i = 0; i < 2 && g == -1; ++i) {
for (int j = 0; j < 3; ++j) {
if (w.size() >= gp[i][j].size() &&
w.substr(w.size() - gp[i][j].size()) == gp[i][j]) {
g = i;
p = j;
break;
}
}
}
if (g == -1 || gender == 0 && g == 1 || gender == 1 && g == 0 ||
pp == 0 && p == 2 || pp == 1 && p != 2 || pp == 2 && p != 2 ||
pp == -1 && p == 2 || i == words.size() - 1 && p == 0) {
ok = false;
gender = g;
pp = p;
break;
}
gender = g;
pp = p;
}
if (ok || words.size() == 1 && pp != -1)
puts("YES");
else
puts("NO");
return 0;
}
| 7 | CPP |
n = int(input())
s = [int(x) for x in input().split()]
a = []
q = []
for i in range(n-1):
if s[i] <= s[i+1]:
a.append(s[i])
q.append(a)
else:
a = []
if q == []:
print(1)
else:
print(max(len(i) for i in q)+1)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, x, y;
cin >> a >> x >> y;
if (y % a == 0) {
cout << -1 << endl;
return 0;
}
int q = y / a;
if (q == 0) {
double mid = (double)a / 2;
if (abs(x) < mid) {
cout << 1 << endl;
} else {
cout << -1 << endl;
}
return 0;
}
if (q % 2 == 1) {
double mid = (double)a / 2;
if (abs(x) < mid) {
int res = q / 2;
cout << 2 + res * 3 << endl;
} else {
cout << -1 << endl;
}
return 0;
}
if (q % 2 == 0) {
int bla = abs(x);
int res = q / 2;
if (bla == 0) {
cout << -1 << endl;
} else if (bla % a == 0 || abs(x) >= a) {
cout << -1 << endl;
} else if (x < 0) {
cout << 3 * res << endl;
} else {
cout << 3 * res + 1 << endl;
}
return 0;
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, m, a[1000006], i, j;
bool dp[1004][2], x;
int main() {
memset(dp, 0, sizeof(dp));
scanf("%d %d", &n, &m);
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
a[i] %= m;
if (a[i] == 0) {
printf("YES\n");
return 0;
}
}
for (i = 1; i < m; i++) dp[i][0] = 0;
dp[0][0] = 1;
for (j = 1; j <= n; j++) {
for (i = 0; i < m; i++) {
x = dp[(i - a[j - 1] + m) % m][(j - 1) & 1];
dp[i][j & 1] = dp[i][(j - 1) & 1] || x;
if (i == 0 && x) {
printf("YES\n");
return 0;
}
}
}
printf("NO\n");
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n;
cin >> n;
string s;
cin >> s;
long long cnt = 0;
if (s[s.size() - 1] != '0') {
cnt += s[s.size() - 1] - '0';
}
for (int i = 0; i < n - 1; i++) {
if (s[i] != '0') {
cnt += s[i] - '0';
cnt++;
}
}
cout << cnt << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t = 1;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 7 | CPP |
n = int(input());a = sorted([int(x) for x in input().split()])
def solve(l, bit):
if len(l) <= 1: return 0
if bit == 0: return 0
high = [x ^ (1 << bit) for x in l if x & (1 << bit)];low = [x for x in l if not x & (1 << bit)];sh = solve(high, bit-1);sl = solve(low, bit-1)
if not low: return sh
if not high: return sl
return min(len(high) - 1 + sl, len(low) - 1 + sh)
print(solve(a, 40)) | 11 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int tests;
cin >> tests;
for (int test = 0; test < tests; ++test) {
int n;
cin >> n;
vector<int> a(n);
copy_n(istream_iterator<int>(cin), n, a.begin());
sort(a.begin(), a.end());
int mid = n / 2;
cout << a[mid] << " ";
bool left = true;
int l = (mid - 1);
int r = (mid + 1);
for (int i = 1; i < n; ++i) {
if (left) {
cout << a[l--] << " ";
} else {
cout << a[r++] << " ";
}
left = !left;
}
cout << "\n";
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
#define fi(n) for(int i=0;i<n;i++)
#define fj(n) for(int j=0;j<n;j++)
#define fk(n) for(int k=0;k<n;k++)
#define pb push_back
#define ppb pop_back
#define pf push_front
#define ppf pop_front
#define uniq(v) (v).erase(unique(all(v)),(v).end())
#define sz(x) (int)((x).size())
#define rep(i,a,b) for(int i=a;i<b;i++)
#define mem1(a) memset(a,1,sizeof(a))
#define mem0(a) memset(a,0,sizeof(a))
#define ff first
#define ss second
#define ci cin>>
#define co cout<<
#define el <<'\n'
#define te(i) ll i; ci i
#define test te(t); while(t--)
#define ten te(n)
#define tem te(m)
#define tek te(k)
#define tex te(x)
#define tey te(y)
#define tez te(z)
#define all(x) x.begin(), x.end()
#define dbg(x) cout << #x << " is " << x << endl;
typedef long long int ll;
typedef pair<int,int> pai;
typedef vector<int> vi;
typedef vector<int>::iterator vit;
typedef set<int> se;
typedef set<char> sc;
typedef set<int>::iterator sit;
int MOD = 1e9 + 7;
int INF = INT_MAX;
void presbeg(ll A[], int n){
rep(i,1,n-1){
A[i] = (A[i] + A[i-1])%MOD;
}
}
void presend(ll A[], int n){
for(int i = n-3; i>-1; i--){
A[i] = (A[i] + A[i+1])%MOD;
}
}
void solve()
{
int n, k;
ci n >> k;
ll A[n-1], sum=2;
fi(n-1){A[i]=0;}
A[0]=1;
if(k==1){sum--;}
fi(k-1){
if(i%2==0){presbeg(A,n);}
else {presend(A,n);}
fi(n-1){
sum = (sum+A[i])%MOD;
}
}
co sum el;
}
int main()
{
ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
int kase=1;
cin >> kase;
while (kase--)
solve();
return 0;
} | 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MaxM = 1e5;
struct node {
int u, v, pos;
double w;
} e[MaxM + 1], e1[MaxM + 1];
int n, m, k, t;
int f[5001];
int ans[MaxM + 1];
int find(int x) {
if (x != f[x]) f[x] = find(f[x]);
return f[x];
}
bool cmp(const node &a, const node &b) { return a.w < b.w; }
int check(double x) {
int cnt = 0;
t = 0;
for (int i = 1; i <= m; i++) {
e1[i] = e[i];
e1[i].w += e[i].u == 1 ? x : 0;
}
for (int i = 1; i <= n; i++) f[i] = i;
sort(e1 + 1, e1 + m + 1, cmp);
for (int i = 1; i <= m; i++) {
int x = find(e1[i].u), y = find(e1[i].v);
if (x != y) {
f[y] = x;
if (e1[i].u == 1) cnt++;
ans[++t] = e1[i].pos;
}
}
return cnt;
}
int main() {
scanf("%d %d %d", &n, &m, &k);
for (int i = 1; i <= m; i++) {
scanf("%d %d %lf", &e[i].u, &e[i].v, &e[i].w);
if (e[i].u > e[i].v) swap(e[i].u, e[i].v);
e[i].pos = i;
}
double l = -1e6, r = 1e6, mid;
int cnt;
while (l < r) {
mid = (l + r) / 2;
cnt = check(mid);
if (cnt == k) break;
if (cnt < k)
r = mid;
else
l = mid;
}
if (cnt == k) {
printf("%d\n", t);
for (int i = 1; i <= t; i++) printf("%d ", ans[i]);
} else
printf("-1\n");
return 0;
}
| 11 | CPP |
for i in range(int(input())):
n,m,k=map(int,input().split())
d=int(n/k)
if(d<m):
if(((m-d)%(k-1))==0):
a=d-int((m-d)/(k-1))
print(a)
else:
a=d-int((m-d)/(k-1))-1
print(a)
else:
print(m) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int T, n, x;
int main() {
scanf("%d", &T);
while (T--) {
scanf("%d%d", &n, &x);
printf("%d\n", 2 * x);
}
return 0;
}
| 7 | CPP |
import sys
import math
from collections import defaultdict,Counter
# input=sys.stdin.readline
# def print(x):
# sys.stdout.write(str(x)+"\n")
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# sys.stdout=open("CP2/output.txt",'w')
# sys.stdin=open("CP2/input.txt",'r')
# mod=pow(10,9)+7
t=int(input())
for i in range(t):
a,b,k=map(int,input().split())
a1=list(map(int,input().split()))
b1=list(map(int,input().split()))
ac=Counter(a1)
bc=Counter(b1)
ans=0
for a,b in zip(a1,b1):
k-=1
ac[a]-=1
bc[b]-=1
ans+=k-ac[a]-bc[b]
print(ans) | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
inline void chkmin(T1 &a, T2 b) {
if (a > b) a = b;
}
template <typename T1, typename T2>
inline void chkmax(T1 &a, T2 b) {
if (a < b) a = b;
}
using ll = long long;
using ld = long double;
const string FILENAME = "input";
const int Mod = 1000000007;
int sum(int a, int b) { return (a + b >= Mod ? a + b - Mod : a + b); }
int mul(int a, int b) { return ((ll)a * b) % Mod; }
int powm(int a, int b) {
int res = 1;
while (b) {
if (b & 1) {
res = mul(res, a);
}
a = mul(a, a);
b >>= 1;
}
return res;
}
int inv(int a) { return powm(a, Mod - 2); }
const int MAXN = 300228;
int n, q;
int a[MAXN];
int parent[1000229];
vector<int> who[1000228];
bool bad[1000228];
vector<int> z[1000228];
int findset(int a) {
if (parent[a] == a) {
return a;
}
return parent[a] = findset(parent[a]);
}
void merge(int a, int b) {
a = findset(a);
b = findset(b);
if (a == b) {
return;
}
parent[b] = a;
}
int rep[1000229];
vector<int> goode[1000229];
void solve() {
cin >> n >> q;
for (int i = 0; i < n; i++) {
cin >> a[i];
who[a[i]].push_back(i);
parent[i] = i;
}
for (int i = 2; i <= 1000001; i++) {
if (bad[i]) {
continue;
}
z[i].push_back(i);
for (int j = 2 * i; j <= 1000001; j += i) {
z[j].push_back(i);
bad[j] = true;
}
}
for (int i = 2; i <= 1000001; i++) {
int a = -1;
if (!who[i].empty()) {
a = who[i][0];
}
for (int j = 2 * i; j <= 1000001; j += i) {
if (!who[j].empty()) {
if (a == -1) {
a = who[j][0];
} else {
merge(a, who[j][0]);
}
}
}
}
for (int i = 2; i <= 1000001; i++) {
if (!bad[i]) {
rep[i] = -1;
for (int j = i; j <= 1000001; j += i) {
if (!who[j].empty()) {
rep[i] = findset(who[j][0]);
break;
}
}
}
}
for (int i = 2; i <= 1000001; i++) {
if (who[i].empty()) {
continue;
}
for (auto x : z[i + 1]) {
if (rep[x] != -1) {
goode[findset(who[i][0])].push_back(rep[x]);
goode[rep[x]].push_back(findset(who[i][0]));
}
}
vector<int> st;
for (auto x : z[i + 1]) {
if (rep[x] != -1) {
st.push_back(rep[x]);
}
}
sort((st).begin(), (st).end());
st.resize(distance(st.begin(), unique((st).begin(), (st).end())));
for (int j = 0; j < (int)(st).size(); j++) {
for (int k = j + 1; k < (int)(st).size(); k++) {
goode[st[j]].push_back(st[k]);
goode[st[k]].push_back(st[j]);
}
}
}
for (int i = 0; i < n; i++) {
sort((goode[i]).begin(), (goode[i]).end());
}
for (int it = 0; it < q; it++) {
int s, t;
cin >> s >> t;
s--, t--;
s = findset(s);
t = findset(t);
if (s == t) {
cout << 0 << '\n';
continue;
}
{
auto fk = lower_bound((goode[s]).begin(), (goode[s]).end(), t) -
goode[s].begin();
if (fk != (int)(goode[s]).size() && goode[s][fk] == t) {
cout << 1 << '\n';
continue;
}
}
swap(s, t);
{
auto fk = lower_bound((goode[s]).begin(), (goode[s]).end(), t) -
goode[s].begin();
if (fk != (int)(goode[s]).size() && goode[s][fk] == t) {
cout << 1 << '\n';
continue;
}
}
cout << 2 << '\n';
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
t = 1;
while (t--) {
solve();
}
return 0;
}
| 13 | CPP |
def main():
n,h,l,r = map(int,input().split())
arr = list(map(int,input().split()))
dp = [[-1 for i in range(h)] for j in range(n+1)]
dp[0][0] = 0
for i in range(n):
for time in range(h):
if dp[i][time] >= 0:
for k in range(-1,1):
add = dp[i][time]
new_time = (time+arr[i]+k)%h
if l <= new_time <= r:
add += 1
dp[i+1][new_time] = max(dp[i+1][new_time],add)
print(max(dp[n]))
main()
| 11 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 100;
int t;
int dep[maxn];
int f[maxn], vis[maxn];
vector<int> e[maxn];
void dfs(int u, int fa) {
for (int v : e[u]) {
if (!dep[v]) {
dep[v] = dep[u] + 1;
f[v] = u;
dfs(v, u);
} else {
if (dep[v] - dep[u] + 1 >= t) {
printf("2\n");
int len = dep[v] - dep[u] + 1;
printf("%d\n", len);
int cnt = 0;
while (v) {
if (cnt == len) break;
cnt++;
printf("%d ", v);
v = f[v];
}
exit(0);
}
}
}
if (!vis[u]) {
for (int v : e[u]) {
vis[v] = 1;
}
}
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
t = ceil(sqrt(n));
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
e[x].push_back(y);
e[y].push_back(x);
}
dep[1] = 1;
dfs(1, 0);
printf("1\n");
int cnt = 0;
for (int i = 1; i <= n; i++) {
if (cnt == t) break;
if (!vis[i]) {
printf("%d ", i);
cnt++;
}
}
}
| 12 | CPP |
#include<stdio.h>
int main(void)
{
int n,a,b;
scanf("%d",&n);
scanf("%d",&a);
scanf("%d",&b);
char s[n];
scanf("%s",s);
int i,w=0;
int f=0;
for(i=0;i<n;i++){
if(s[i]=='c')
printf("No\n");
else if(s[i]=='a'){
if(w<a+b){
printf("Yes\n");
w++;
}
else{
printf("No\n");
}
}
else{
f++;
if(w<a+b && f<=b){
printf("Yes\n");
w++;
}
else{
printf("No\n");
}
}
}
return 0;
} | 0 | CPP |
from math import ceil
n, k = map(int, input().split())
x, k, half = k//n, k%n, ceil(n/2)
if k == 0:
k = n
x -= 1
if x%2 != 0 and n%2 != 0:
half -= 1
print(x*n+2*(k-half) if k > half else x*n+2-(1-x*n%2)+2*(k-1)) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000005;
int n, k;
struct edge {
int v;
edge *nxt;
} g[maxn << 1], *he[maxn];
int cnt;
void add_edge(int a, int b) {
edge *e = g + (++cnt);
e->v = b, e->nxt = he[a];
he[a] = e;
}
bool in[maxn];
int mxs[maxn], dep[maxn], fa[maxn];
int f[maxn][25];
void dfs(int p, int ffa) {
dep[p] = dep[ffa] + 1;
f[p][0] = ffa;
fa[p] = ffa;
for (int i = 1; i <= 20; ++i) f[p][i] = f[f[p][i - 1]][i - 1];
for (edge *e = he[p]; e; e = e->nxt) {
int to = e->v;
if (to == ffa) continue;
dfs(to, p);
}
}
int main() {
scanf("%d%d", &n, &k);
k = n - k;
int a, b;
for (int i = 1; i < n; ++i) {
scanf("%d%d", &a, &b);
add_edge(a, b);
add_edge(b, a);
}
dep[n] = -1;
dfs(n, 0);
k--;
in[n] = true;
int now = n;
for (int i = n - 1; i; --i) {
if (k == 0) break;
int p = i;
for (int j = 20; ~j; --j)
if (!in[f[p][j]] && f[p][j] != 0) {
p = f[p][j];
}
int lc = f[p][0];
if (dep[i] - dep[lc] <= k) {
p = i;
while (!in[p] && p != lc) {
in[p] = true;
p = fa[p];
k--;
}
}
}
vector<int> ans;
for (int i = 1; i <= n; ++i) {
if (!in[i]) ans.push_back(i);
}
for (int i = 0; i < ans.size(); ++i) printf("%d ", ans[i]);
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, m, d, group[100001], cnt[25], bad[(1 << 20) + 5];
int invert(int mask) { return mask ^ ((1 << m) - 1); }
int main() {
ios::sync_with_stdio(false);
;
cin.tie(0);
;
int i, j, k, x, y, ans = 10000000, mask;
cin >> n >> m >> d;
for (i = 0; i < m; i++) {
cin >> x;
for (j = 0; j < x; j++) {
cin >> y;
group[y] = i;
}
}
for (i = 1; i <= n; i++) {
cnt[group[i]]++;
mask = 0;
for (j = 0; j < m; j++) {
if (cnt[j]) mask = mask | (1 << j);
}
mask = invert(mask);
if (i >= d) {
bad[mask] = 1;
cnt[group[i - d + 1]]--;
}
}
for (mask = (1 << m) - 1; mask >= 0; mask--) {
for (i = 0; i < m; i++) {
if (mask & (1 << i)) bad[mask ^ (1 << i)] |= bad[mask];
}
}
for (mask = 0; mask < (1 << m); mask++) {
if (!bad[mask]) ans = min(ans, __builtin_popcount(mask));
}
cout << ans;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int sz = 33 * 1e5;
const int MInt = 1e7 + 5;
void get_pf(int n, int *pf) {
for (int i = 0; i <= n; i++) pf[i] = i;
for (int i = 4; i <= n; i += 2) pf[i] = 2;
for (int i = 3; i * i <= n; i += 2) {
if (pf[i] != i) continue;
for (int j = i * i; j <= n; j += i) pf[j] = i;
}
return;
}
void count_factors(int n, int *pf, int *a) {
while (pf[n] != n) {
a[pf[n]]++;
n /= pf[n];
}
a[n]++;
return;
}
void factorize(int *pf, int *a, int n, int *na) {
for (int i = 0; i < n; i++) count_factors(a[i], pf, na);
}
void reduce(int *a, int *b, int n) {
for (int i = 0; i <= n; i++) {
int mini = min(a[i], b[i]);
a[i] = a[i] - mini;
b[i] = b[i] - mini;
}
}
void compress(int *a, int n, int *fa, int *pf) {
for (int i = 0; i < n; i++) {
int num = a[i], newNum = 1;
while (num != 1) {
if (fa[pf[num]]) {
fa[pf[num]] -= 1;
newNum *= pf[num];
}
num /= pf[num];
}
a[i] = newNum;
}
return;
}
void disp(int *a, int n, int *b, int m) {
cout << n << " " << m << endl;
for (int i = 0; i < n; i++) cout << a[i] << " ";
cout << endl;
for (int i = 0; i < m; i++) cout << b[i] << " ";
cout << endl;
return;
}
int main() {
int n, m;
cin >> n >> m;
int *nom = new int[n + 1];
int *dom = new int[m + 1];
for (int i = 0; i < n; i++) cin >> nom[i];
for (int i = 0; i < m; i++) cin >> dom[i];
int *pf = new int[MInt + 2];
get_pf(MInt, pf);
int *fnom = new int[MInt + 2];
int *fdom = new int[MInt + 2];
for (int i = 0; i <= MInt; i++) fnom[i] = fdom[i] = 0;
factorize(pf, nom, n, fnom);
factorize(pf, dom, m, fdom);
reduce(fnom, fdom, MInt);
compress(nom, n, fnom, pf);
compress(dom, m, fdom, pf);
disp(nom, n, dom, m);
return 0;
}
| 9 | CPP |
k = int(input())
l = int(input())
m = int(input())
n = int(input())
d = int(input())
dragons = []
for i in range(1, d+1):
if (i % k == 0) or (i % l == 0) or (i % m == 0) or (i % n == 0):
dragons.append(i)
print(len(dragons)) | 7 | PYTHON3 |
# import sys
# input=sys.stdin.buffer.readline
def calc(numbers,newans,i):
#count the numbers of digits in numbers that has the same prefix as newans
count=0
ansarr="".join([str(x) for x in newans])
# print(numbers[0][:i+1],ansarr)
for num in numbers:
if num[:i+1] == ansarr:
count+=1
# print("count",count)
return count
t=int(input())
for _ in range(t):
n,m=[int(c) for c in input().split()]
numbers=[]
for i in range(n):
numbers.append(input())
ans=0
#we need the kth number
ansarr=[]
k=((((1<<(m)) - n) - 1) // 2 )+ 1
# print("K",k)
for i in range(m):
#check if the fist letter can be a 0
nums= 1<<(m-1-i)
newans=ans | 0
remainums=nums - calc(numbers,ansarr+[0],i)
# print("remainnums,",remainums)
if remainums < k :
k-=remainums
ansarr.append(1)
newans = ans | 1 <<(m-i-1)
else:
ansarr.append(0)
newans=ans | 0
ans=newans
# print(bin(newans)[2:])
print("".join([str(c) for c in ansarr]))
| 14 | PYTHON3 |
import math
import time
from collections import defaultdict,deque,Counter
from sys import stdin,stdout
from bisect import bisect_left,bisect_right
from queue import PriorityQueue
import sys
t=int(input())
for _ in range(t):
n,m=map(int,stdin.readline().split())
ans=0
for _ in range(n-1):
a=input()
if(a[-1]=="R"):
ans+=1
a=input()
for i in a:
if(i=="D"):
ans+=1
print(ans)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 100;
int n, arr[N], preSum[N], sufSum[N], preMax[N], sufMax[N];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++)
scanf("%d", &arr[i]), preSum[i] = preSum[i - 1] + arr[i];
for (int i = n; i >= 1; i--) sufSum[i] = sufSum[i + 1] + arr[i];
for (int i = 1; i <= n; i++)
preMax[i] = max(preMax[i - 1] + arr[i], -preSum[i]);
for (int i = n; i >= 1; i--)
sufMax[i] = max(sufMax[i + 1] + arr[i], -sufSum[i]);
int out = -1e9;
for (int i = 0; i <= n; i++) out = max(out, preMax[i] + sufMax[i + 1]);
printf("%d\n", out);
}
| 9 | CPP |
for _ in range(int(input())):
a, b, c, d = map(int, input().split())
l = [a, b, c]
l.sort()
d = d - 2 * l[2] + l[0] + l[1]
if d < 0:
print("NO")
continue
print("YES" if (d % 3 == 0) else "NO") | 7 | PYTHON3 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int n,m;
double a[500];
cin>>n>>m;
for(int i=0;i<n;i++)cin>>a[i],a[i]+=(i?a[i-1]:0);
double dp[501][501];
for(int i=0;i<501;i++)for(int j=0;j<500;j++)dp[i][j]=-1e15;
dp[0][0]=0;
for(int i=0;i<n;i++)
for(int j=0;j<m;j++)
for(int k=0;k<=i;k++){
dp[j+1][i+1]=max(dp[j+1][i+1],dp[j][k]+(a[i]-(k?a[k-1]:0))/(i-k+1));
}
printf("%.8f\n",dp[m][n]);
return 0;
}
| 0 | CPP |
#include "bits/stdc++.h"
using namespace std;
string a;
int main()
{
cin>>a;
if(a.back()=='s') a+="es";
else a+="s";
cout<<a;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long i, j, n, k, a[305][305], b, c, d, ij, isum = 0;
cin >> n;
for (i = 1; i <= n; i++) {
for (j = 1; j <= n; j++) {
cin >> a[i][j];
}
}
cin >> k;
for (i = 1; i <= k; i++) {
isum = 0;
cin >> b >> c >> d;
a[b][c] = min(a[b][c], d);
a[c][b] = min(a[c][b], d);
for (j = 1; j <= n; j++) {
for (ij = 1; ij <= n; ij++) {
if (j != ij) {
a[j][ij] = min(a[j][ij], min(a[j][b] + a[b][c] + a[c][ij],
a[j][c] + a[b][c] + a[b][ij]));
isum += a[j][ij];
}
}
}
cout << isum / 2 << " ";
}
}
| 9 | CPP |
n = int(input())
if n != 0 :
print(n+1 if n%2 == 0 else (n+1)//2)
else :
print(0) | 7 | PYTHON3 |
r, c = map(int, input().split())
ri, ci = list(map(int, input().split())), list(map(int, input().split()))
l = []
fine = True
for _ in range(r):
l.append([None] * c)
for i in range(r):
if ri[i] == c:
l[i] = [1] * c
else:
l[i][:ri[i] + 1] = [1] * (ri[i]) + [0]
for i in range(c):
if ci[i] == r:
for j in range(r):
if l[j][i] == 0:
fine = False
l[j][i] = 1
else:
for j in range(ci[i]):
if l[j][i] == 0:
fine = False
l[j][i] = 1
if l[ci[i]][i] == 1:
fine = False
l[ci[i]][i] = 0
if not fine:
print(0)
else:
count = 0
for i in range(r):
for j in range(c):
if l[i][j] == None:
count += 1
acc = 2
rem = 1
while count != 0:
if count % 2 != 0:
rem *= acc
rem %= 1000000007
acc *= acc
acc %= 1000000007
count //= 2
print(rem)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin>>n;
vector<int>x(n);
for(int i=0;i<n;i++) cin>>x[i];
int ans=1000000;
for(int i=1;i<=100;i++){
int a=0;
for(int j=0;j<n;j++){
a+=(x[j]-i)*(x[j]-i);
}
ans=min(ans,a);
}
cout<<ans<<endl;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-7;
const double pi = acos(-1.0);
struct P {
double x, y;
P() {}
P(double X, double Y) { x = X, y = Y; }
P operator+(P a) { return P(x + a.x, y + a.y); }
P operator-(P a) { return P(x - a.x, y - a.y); }
double operator*(P a) { return x * a.x + y * a.y; }
double operator%(P a) { return x * a.y - y * a.x; }
double operator!() { return sqrt(x * x + y * y); }
P operator*(double a) { return P(x * a, y * a); }
P rot(double ang) {
double c = cos(ang), s = sin(ang);
return P(x * c - y * s, x * s + y * c);
}
double operator^(P a) { return atan2((*this) % a, (*this) * a); }
} reg[100100], pol[100100];
int cmp(double a, double b) {
if (fabs(a - b) <= eps) return 0;
return (a > b) ? 1 : -1;
}
int n;
int main() {
scanf("%d", &n);
reg[0] = P(1, 0);
srand(5719841);
for (int i = 1; i < n; i++) {
reg[i] = reg[i - 1].rot(2.0 * pi / n);
}
int cnt = 0;
while (cnt < 10000) {
pol[0] = P(0, 0);
for (int i = 1; i < n - 1; i++) {
double now;
do {
now = rand() / double(RAND_MAX);
now = now * 100.0;
} while (cmp(now, 1) <= 0);
pol[i] = pol[i - 1] + reg[i - 1] * now;
}
P vv = pol[0] - pol[n - 2];
double D = reg[n - 2] % reg[n - 1], Dx = vv % reg[n - 1],
Dy = reg[n - 2] % vv, x = Dx / D, y = Dy / D;
if (cmp(D, 0) != 0 && cmp(x, 0) > 0 && cmp(y, 0) > 0) {
bool pode = true;
pol[n - 1] = pol[n - 2] + reg[n - 2] * x;
pol[n] = pol[0];
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (cmp(!(pol[i] - pol[i + 1]), !(pol[j] - pol[j + 1])) == 0)
pode = false;
}
}
for (int i = 0; i < n; i++)
if (cmp(!(pol[i] - pol[i + 1]), 1) <= 0) pode = false;
if (pode) break;
}
cnt++;
}
if (cnt == 10000)
printf("No solution\n");
else {
for (int i = 0; i < n; i++) printf("%.10lf %.10lf\n", pol[i].x, pol[i].y);
}
return 0;
}
| 10 | CPP |
def count(a):
n = len(a)
cnt = 0
for i in range(n):
for j in range(i+1, n):
if a[i] > a[j]:
cnt+=1
return cnt
n = int(input())
p = list(map(int, input().split()))
num = count(p)
print(num*2 - num%2) | 8 | PYTHON3 |
#include <bits/stdc++.h>
const int N = 5000 + 10;
int n, m;
char buf[N];
int count[N][N];
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%s", buf);
for (int j = 0, k = 0; j < m; j = k) {
for (k = j; k < m && buf[k] == '1'; k++)
;
if (j == k) {
k++;
} else {
int u = j + 1;
int v = k;
count[u][u]++;
count[v + 1][v + 1]++;
count[u][v + 1]--;
count[v + 1][u]--;
}
}
}
int result = 0;
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= m; j++) {
count[i][j] += count[i - 1][j] + count[i][j - 1] - count[i - 1][j - 1];
if (i <= j) {
result = std::max(result, count[i][j] * (j - i + 1));
}
}
}
printf("%d\n", result);
}
| 8 | CPP |
n = int(input())
fib = [0,1]
while fib[-1] + fib[-2] <= n:
fib.append( fib[-1] + fib[-2] )
def solve():
for i in fib:
for j in fib:
for k in fib:
if i+j+k == n:
return (i,j,k)
if i+j+k > n:
break
if i+j+k > n:
break
if i+j+k > n:
break
print(*solve()) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> x, y;
int main() {
x.resize(8);
y.resize(8);
for (int i = 0; i < 8; i++) {
cin >> x[i] >> y[i];
}
vector<int> x_ = x;
vector<int> y_ = y;
sort(x_.begin(), x_.end());
x_.erase(unique(x_.begin(), x_.end()), x_.end());
if (x_.size() != 3) {
cout << "ugly\n";
return 0;
}
sort(y_.begin(), y_.end());
y_.erase(unique(y_.begin(), y_.end()), y_.end());
if (y_.size() != 3) {
cout << "ugly\n";
return 0;
}
vector<pair<int, int> > p, q;
for (int i = 0; i < 8; i++) {
p.push_back(pair<int, int>(x[i], y[i]));
}
sort(p.begin(), p.end());
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
if (i == 1 && j == 1) continue;
q.push_back(pair<int, int>(x_[i], y_[j]));
}
}
sort(q.begin(), q.end());
cout << (p == q ? "respectable" : "ugly") << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const char df = '\n';
const ll mx = 2e5 + 10;
const ll MOD = 998244353;
ll n, dp[mx], fact[mx];
vector<ll> ar[mx];
ll dfs(ll v, ll p) {
dp[v] = 1;
for (ll nei : ar[v])
if (nei != p) dp[v] = (dp[v] * dfs(nei, v)) % MOD;
return dp[v] = (dp[v] * fact[ar[v].size()]) % MOD;
}
void solve() {
cin >> n;
for (ll i = 0; i < n - 1; i++) {
ll u, v;
cin >> u >> v;
ar[u].push_back(v);
ar[v].push_back(u);
}
fact[0] = 1;
for (ll i = 1; i <= n; i++) {
fact[i] = (fact[i - 1] * i) % MOD;
}
dfs(1, 0);
cout << (n * dp[1]) % MOD << df;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
int tt = 1;
for (int i = 1; i <= tt; i++) {
solve();
}
return 0;
}
| 8 | CPP |
#include<iostream>
using namespace std;
class Cube{
public:
int f[6]; //??????????????°???
Cube(){} //?????????????????????
void roll_z(){ roll(1, 2, 4, 3);} //????????????????????§??????????????????????????°???????????¨????????????
void roll_y(){ roll(0, 2, 5, 3);}
void roll_x(){ roll(0, 1, 5, 4);}
void roll(int i, int j, int k, int l){
int t = f[i]; f[i] = f[j]; f[j] = f[k]; f[k] = f[l]; f[l] = t;
}
};
bool eq( Cube c1, Cube c2){
for ( int i = 0; i < 6; i++)
if ( c1.f[i] != c2.f[i] ) return false;
return true;
}
bool equal( Cube c1, Cube c2){
for (int i = 0; i < 6; i++) {
for (int j = 0; j < 4; j++) {
if (eq(c1, c2)) return true;
c1.roll_z();
}
if (i % 2 == 0) c1.roll_y();
else c1.roll_x();
}
return false;
}
int n; Cube C[100];
bool check(){
for (int i = 0; i < n-1; i++){
for (int j = i+1; j < n; j++){ if ( (equal(C[i], C[j])) ) return false;}
}
return true;
}
//???????????????????????????????????¢??°????????£??????????????????????????????
//???????????´??°?????\?????????????????????????????????
int main(){
cin >> n;
for (int i = 0; i < n; i++)
for (int j = 0; j < 6; j++) cin >> C[i].f[j];
if (check()) cout << "Yes" << endl;
else cout << "No" << endl;
return 0;
} | 0 | CPP |
#include<stdio.h>
#include<iostream>
using namespace std;
int main(){
int pm,pe,pj,pa,cl;
int i=0,l;
char a[100000];
cin>>cl;
while(cl!=0){
l=i;
for(int j=0;j<cl;j++){
cin>>pm>>pe>>pj;
pa=(pm+pe+pj)/3;
if(pm==100||pe==100||pj==100||90<=(pm+pe)/2||80<=pa)a[i]='A';
else if(70<=pa||((80<=pe||80<=pm)&&50<=pa))a[i]='B';
else a[i]='C';
i++;
}
for(int j=l;j<i;j++)
cout<<a[j]<<endl;
cin >> cl;
}
return 0;
} | 0 | CPP |
#include<cstdio>
int main(void){
int n, l[10], mx=0, sum=0, i;
scanf("%d", &n);
for(i=0; i<n; ++i){
scanf("%d", l+i);
sum+=l[i];
mx=(l[i]>mx)?l[i]:mx;
}
printf("%s\n", (sum-mx>mx)?"Yes":"No");
return(0);
} | 0 | CPP |
#include<iostream>
using namespace std;
int main(){
int dist[8] = {0, 0, 6, 13, 18, 23, 43, 58};
int fee[8][8] = {};
fee[1][2] = 300; fee[2][3] = 350; fee[3][4] = 250; fee[4][5] = 250; fee[5][6] = 600; fee[6][7] = 500;
fee[1][3] = 500; fee[2][4] = 450; fee[3][5] = 400; fee[4][6] = 850; fee[5][7] = 1150;
fee[1][4] = 600; fee[2][5] = 600; fee[3][6] = 1000; fee[4][7] = 1300;
fee[1][5] = 700; fee[2][6] = 1150; fee[3][7] = 1350;
fee[1][6] = 1350; fee[2][7] = 1500;
fee[1][7] = 1650;
int d, hd, md, a, ha, ma;
while(1){
cin >> d;
if(d == 0) break;
cin >> hd >> md >> a >> ha >> ma;
hd = hd*100 + md;
ha = ha*100 + ma;
int distance = dist[a] - dist[d];
int ans = fee[d][a];
if(distance <= 40){
if((1730 <= hd && hd <= 1930) || (1730 <= ha && ha <= 1930)){
ans /= 2;
ans = (ans % 50 == 0) ? ans : (ans/50+1)*50;
}
}
cout << ans << endl;
}
return 0;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1e9 + 7;
const int N = (int)3e5 + 4;
const int M = 1001;
int n, k;
int a[6];
double ans;
void f(int s) {
if (s == k) {
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j < n; ++j) {
if (a[i] > a[j]) {
++ans;
}
}
}
return;
}
for (int i = 0; i < n; ++i) {
for (int j = i; j < n; ++j) {
reverse(a + i, a + j + 1);
f(s + 1);
reverse(a + i, a + j + 1);
}
}
}
int main() {
cin >> n >> k;
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
f(0);
for (int i = 0; i < k; ++i) {
ans /= n;
ans /= (n + 1);
ans *= 2.0;
}
printf("%.10lf", ans);
return 0;
}
| 13 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<int> v;
int main() {
int i, n, a, j, b;
while (cin >> n) {
b = 1;
for (i = 1; i <= n; i++) {
cin >> a;
if (a == b) {
v.push_back(2000 + i);
b++;
}
}
cout << v.size() << endl;
for (i = 0; i < v.size(); i++) cout << v[i] << " ";
if (v.size() > 0) cout << endl;
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct compare {
bool operator()(const int &l, const int &r) { return l > r; }
};
priority_queue<int, vector<int>, compare> my_heap;
vector<pair<string, int> > v;
int main() {
int n, m = 0;
cin >> n;
while (n--) {
string s;
cin >> s;
if (s == "insert") {
int t;
cin >> t;
my_heap.push(t);
m++;
v.push_back({s, t});
} else if (s == "removeMin") {
if (my_heap.size() == 0) {
v.push_back({"insert", 1});
m++;
} else
my_heap.pop();
m++;
v.push_back({s, 0});
} else {
int t;
cin >> t;
if (my_heap.size() == 0) {
m++;
my_heap.push(t);
v.push_back({"insert", t});
} else {
while (my_heap.top() < t && my_heap.size() > 0) {
my_heap.pop();
m++;
v.push_back({"removeMin", 0});
}
if (my_heap.top() == t)
;
else {
m++;
my_heap.push(t);
v.push_back({"insert", t});
}
}
m++;
v.push_back({s, t});
}
}
cout << m << endl;
for (int i = 0; i < v.size(); i++) {
string t = v[i].first;
if (t == "removeMin")
cout << t << endl;
else
cout << t << " " << v[i].second << endl;
}
}
| 9 | CPP |
#include<iostream>
#include<complex>
#include<vector>
#include<string>
#include<algorithm>
#include<map>
#include<set>
#include<utility>
#include<cmath>
#include<cstring>
#include<queue>
#include<stack>
#include<cstdio>
#include<sstream>
#include<iomanip>
#include<assert.h>
#define loop(i,a,b) for(int i=a;i<b;i++)
#define rep(i,a) loop(i,0,a)
#define pb push_back
#define all(in) in.begin(),in.end()
#define shosu(x) fixed<<setprecision(x)
using namespace std;
//kaewasuretyuui
typedef long long ll;
typedef int Def;
typedef pair<Def,Def> pii;
typedef vector<Def> vi;
typedef vector<vi> vvi;
typedef vector<pii> vp;
typedef vector<vp> vvp;
typedef vector<string> vs;
typedef vector<double> vd;
typedef vector<vd> vvd;
typedef pair<Def,pii> pip;
typedef vector<pip>vip;
//#define mt make_tuple
//typedef tuple<double,int,double> tp;
//typedef vector<tp> vt;
template<typename A,typename B>bool cmin(A &a,const B &b){return a>b?(a=b,true):false;}
template<typename A,typename B>bool cmax(A &a,const B &b){return a<b?(a=b,true):false;}
const double PI=acos(-1);
const double EPS=1e-7;
Def inf = sizeof(Def) == sizeof(long long) ? 2e18 : 1e9;
int dx[]={0,1,0,-1};
int dy[]={1,0,-1,0};
typedef complex<double> P;
typedef vector<P> G;
typedef vector<double> vd;
typedef vector<vd> vvd;
struct L : public vector<P> {
L(const P &a, const P &b) {
push_back(a); push_back(b);
}
};
struct C{
P c;double r;
C(const P &c,double r):c(c),r(r){}
};
#define curr(P, i) P[i]
#define next(P, i) P[(i+1)%P.size()]
#define diff(P, i) (next(P, i) - curr(P, i))
namespace std {
bool operator < (const P& a, const P& b) {
return real(a) != real(b) ? real(a) < real(b) : imag(a) < imag(b);
//return imag(a) != imag(b) ? imag(a) < imag(b) : real(a) < real(b);
}
bool operator == (const P& a, const P& b) {
return a.real()==b.real()&&a.imag()==b.imag();
}
}
P pin(){
double x,y;
char d;
cin>>x>>y;
P p(x,y);
return p;
}
void PIN(P* a,int n){
rep(i,n)a[i]=pin();
}
double dot(P a,P b){
return real(conj(a)*b);
}
double cross(P a,P b){
return imag(conj(a)*b);
}
int ccw(P a, P b, P c) {
b -= a; c -= a;
if (cross(b, c) > 0) return +1; // counter clockwise
if (cross(b, c) < 0) return -1; // clockwise
if (dot(b, c) < 0) return +2; // c--a--b on line
if (norm(b) < norm(c)) return -2; // a--b--c on line
return 0; // a--c--b on line
}
P projection(L a,P p){
double t=dot(p-a[0],a[0]-a[1])/norm(a[0]-a[1]);
return a[0]+t*(a[0]-a[1]);
}
P reflection(L a,P p){
return p+2.0*(projection(a,p)-p);
}
bool intersectLL(const L &l, const L &m) {
return abs(cross(l[1]-l[0], m[1]-m[0])) > EPS || // non-parallel
abs(cross(l[1]-l[0], m[0]-l[0])) < EPS; // same line
}
bool intersectLS(const L &l, const L &s) {
return cross(l[1]-l[0], s[0]-l[0])* // s[0] is left of l
cross(l[1]-l[0], s[1]-l[0]) < EPS; // s[1] is right of l
}
bool intersectLP(const L &l, const P &p) {
return abs(cross(l[1]-p, l[0]-p)) < EPS;
}
bool intersectSS(const L &s, const L &t) {
return ccw(s[0],s[1],t[0])*ccw(s[0],s[1],t[1]) <= 0 &&
ccw(t[0],t[1],s[0])*ccw(t[0],t[1],s[1]) <= 0;
}
bool intersectSP(const L &s, const P &p) {
return abs(s[0]-p)+abs(s[1]-p)-abs(s[1]-s[0]) < EPS; // triangle inequality
}
double distanceLP(const L &l, const P &p) {
return abs(p - projection(l, p));
}
double distanceLL(const L &l, const L &m) {
return intersectLL(l, m) ? 0 : distanceLP(l, m[0]);
}
double distanceLS(const L &l, const L &s) {
if (intersectLS(l, s)) return 0;
return min(distanceLP(l, s[0]), distanceLP(l, s[1]));
}
double distanceSP(const L &s, const P &p) {
const P r = projection(s, p);
if (intersectSP(s, r)) return abs(r - p);
return min(abs(s[0] - p), abs(s[1] - p));
}
double distanceSS(const L &s, const L &t) {
if (intersectSS(s, t)) return 0;
return min(min(distanceSP(s, t[0]), distanceSP(s, t[1])),
min(distanceSP(t, s[0]), distanceSP(t, s[1])));
}
/*bool intersectCS(C c,const L &l){
return (distanceLP(l,c.c) < c.r+EPS &&
(c.r < abs(c.c-l[0]) + EPS || c.r < abs(c.c-l[1]) + EPS));
}*/
int intersectCS(C c,L l){
if(norm(projection(l,c.c)-c.c)-c.r*c.r>EPS)return 0;
const double d1=abs(c.c-l[0]),d2=abs(c.c-l[1]);
if(d1<c.r+EPS&&d2<c.r+EPS)return 0;
if(d1<c.r-EPS&&d2>c.r+EPS||d1>c.r+EPS&&d2<c.r-EPS)return 1;
const P h=projection(l,c.c);
if(dot(l[0]-h,l[1]-h)<0)return 2;
return 0;
}
P crosspointSS(L a,L b){
double t1=abs(cross(a[1]-a[0],b[0]-a[0]));
double t2=abs(cross(a[1]-a[0],b[1]-a[0]));
return b[0]+(b[1]-b[0])*t1/(t1+t2);
}
L crosspointCL(C c,L l){
P pr=projection(l,c.c);
P e=(l[1]-l[0])/abs(l[1]-l[0]);
double tmp=c.r*c.r-norm(pr-c.c);
if(abs(tmp)<EPS)tmp=0;
double t=sqrt(tmp);
P a=pr+t*e;
P b=pr-t*e;
if(b<a)swap(a,b);
return L(a,b);
}
L crosspointCS(C c,L l){
if(intersectCS(c,l)==2)return crosspointCL(c,l);
L ret=crosspointCL(c,l);
if(dot(l[0]-ret[0],l[1]-ret[0])<0)ret[1]=ret[0];
else ret[0]=ret[1];
return ret;
}
L crosspointCC(C a,C b){
P tmp=b.c-a.c;
double d=abs(tmp);
double q=acos((a.r*a.r+d*d-b.r*b.r)/(2*a.r*d));
double t=arg(tmp);//atan(tmp.imag()/tmp.real());
P p1=a.c+polar(a.r,t+q);
P p2=a.c+polar(a.r,t-q);
if(p2<p1)swap(p1,p2);
return L(p1,p2);
}
P crosspointLL(const L &l, const L &m) {
double A = cross(l[1] - l[0], m[1] - m[0]);
double B = cross(l[1] - l[0], l[1] - m[0]);
if (abs(A) < EPS && abs(B) < EPS) return m[0]; // same line
return m[0] + B / A * (m[1] - m[0]);
}
double area(const G &g){
double S =0;
for(int i =0;i <g.size();i++){
S +=(cross(g[i],g[(i+1)%g.size()]));
}
return abs(S/2.0);
}
bool isconvex(const G &g){
int n=g.size();
rep(i,n)if(ccw(g[(i+n-1)%n],g[i%n],g[(i+1)%n])==-1)return false;
return true;
}
int inconvex(const G& g, const P& p) {
bool in = false;
int n=g.size();
rep(i,n){
P a=g[i%n]-p;
P b=g[(i+1)%n]-p;
if(imag(a)>imag(b))swap(a, b);
if(imag(a)<EPS&&0<imag(b))if(cross(a,b)<0)in=!in;
if(abs(cross(a,b))<EPS&&dot(a,b)<EPS)return 1;//ON
}
return in?2:0;//IN : OUT;
}
G convex_hull(G &ps) {
int n=ps.size(),k=0;
sort(ps.begin(), ps.end());
G ch(2*n);
for(int i=0;i<n;ch[k++]=ps[i++])//lower-hull
while(k>=2&&ccw(ch[k-2],ch[k-1],ps[i])==-1)--k;//<=0 -> ==-1
for(int i=n-2,t=k+1;i>=0;ch[k++]=ps[i--])//upper-hull
while(k>=t&&ccw(ch[k-2],ch[k-1],ps[i])==-1)--k;//
ch.resize(k-1);
return ch;
}
double convex_diameter(const G &pt) {
const int n = pt.size();
int is = 0, js = 0;
for (int i = 1; i < n; ++i) {
if (imag(pt[i]) > imag(pt[is])) is = i;
if (imag(pt[i]) < imag(pt[js])) js = i;
}
double maxd = norm(pt[is]-pt[js]);
int i, maxi, j, maxj;
i = maxi = is;
j = maxj = js;
do {
if (cross(diff(pt,i), diff(pt,j)) >= 0) j = (j+1) % n;
else i = (i+1) % n;
if (norm(pt[i]-pt[j]) > maxd) {
maxd = norm(pt[i]-pt[j]);
maxi = i; maxj = j;
}
} while (i != is || j != js);
return sqrt(maxd); /* farthest pair is (maxi, maxj). */
}//convex_diameter(g)
G convex_cut(const G& g, const L& l) {
G Q;
for (int i = 0; i < g.size(); ++i) {
P a= curr(g, i), b= next(g, i);
if (ccw(l[0], l[1], a) != -1) Q.push_back(a);
if (ccw(l[0], l[1], a)*ccw(l[0], l[1], b) < 0)
Q.push_back(crosspointLL(L(a,b), l));
}
return Q;
}
P turn(P p,double t){
return p*exp(P(.0,t*PI/180.0));
}
P turn2(P p,double t){
return p*exp(P(.0,t));
}
vector<L> tangentCC(C a,C b){
if(a.r<b.r)swap(a,b);
double d=abs(a.c-b.c);
vector<L>l;
if(d<EPS)return l;
if(a.r+b.r<d-EPS){//hanareteiru
double t=acos((a.r+b.r)/d);
t=t*180/PI;
l.pb(L(a.c+turn(a.r/d*(b.c-a.c),t),b.c+turn(b.r/d*(a.c-b.c),t)));
l.pb(L(a.c+turn(a.r/d*(b.c-a.c),-t),b.c+turn(b.r/d*(a.c-b.c),-t)));
}else if(a.r+b.r<d+EPS){//kuttuiteiru soto
P p=a.c+a.r/d*(b.c-a.c);
l.pb(L(p,p+turn(b.c-a.c,90)));
}
if(abs(a.r-b.r)<d-EPS){//majiwatteiru
double t1=acos((a.r-b.r)/d);
t1=t1*180/PI;
double t2=180-t1;
l.pb(L(a.c+turn(a.r/d*(b.c-a.c),t1),b.c+turn(b.r/d*(a.c-b.c),-t2)));
l.pb(L(a.c+turn(a.r/d*(b.c-a.c),-t1),b.c+turn(b.r/d*(a.c-b.c),t2)));
}else if(abs(a.r-b.r)<d+EPS){//kuttuiteiru uti
P p=a.c+a.r/d*(b.c-a.c);
l.pb(L(p,p+turn(b.c-a.c,90)));
}
return l;
}
void printL(const L &out){
printf("%0.9f %0.9f %0.9f %0.9f\n",out[0].real(),out[0].imag(),out[1].real(),out[1].imag());
}
C CIN(){
P p=pin();
double r;
cin>>r;
return C(p,r);
}
bool para(L a,L b){
return (abs(cross(a[1]-a[0],b[1]-b[0]))<EPS);
}
double min(double a,double b){return a<b?a:b;}
double max(double a,double b){return a>b?a:b;}
int main(){
int n,m;
cin>>n>>m;
G g(n);
rep(i,n)g[i]=pin();
double l=0,r=100000;
while(r-l>1e-5){
double h=(l+r)/2;
vd dp(1<<n,inf);
dp[0]=0;
rep(i,1<<n)rep(j,n)if((i&1<<j)==0){
rep(k,n)if((i&1<<k)==0&&abs(g[j]-g[k])<EPS+2*h)rep(q,2){
int t=i;
t|=1<<j;
t|=1<<k;
P tmp=g[k]-g[j];
P p;
if(abs(tmp)<EPS)p=g[k];
else p=g[j]+tmp/2.+tmp*P(0,q?1:-1)/abs(tmp)*sqrt(h*h-abs(tmp)*abs(tmp)/4);
rep(l,n){
if(abs(g[l]-p)<EPS+h){
t|=1<<l;
}
}
dp[t]=min(dp[t],dp[i]+1);
}
}
// cout<<"! "<<dp[
int c=dp[(1<<n)-1];
// cout<<c<<" "<<shosu(6)<<h<<endl;
if(c<=m)r=h;
else l=h;
}
cout<<shosu(7)<<r<<endl;
}
/*
5 2
0 0 5 5 10 10 100 100 200 200
5 2
0 0 5 5 10 10 100 100 200 200
*/
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int m, i;
double Now, S, r, dis[100005], s[100005];
int main() {
scanf("%d %lf", &m, &r);
dis[0] = r * 2.0;
dis[1] = r * 2.0 + r * sqrt(2.0);
dis[2] = r * 2.0 + 2 * r * sqrt(2.0);
for (i = 3; i <= m; i++) dis[i] = dis[i - 1] + r * 2.0;
s[0] = dis[0];
for (i = 1; i <= m; i++) s[i] = s[i - 1] + dis[i];
for (i = 1; i <= m; i++) {
Now = s[i - 1] + s[m - i] - dis[0];
Now /= (double)(m);
S += Now;
}
S /= (double)(m);
printf("%.10lf\n", S);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int arr[1007];
int cs[1007];
map<char, int> mp1, mp2;
set<char> st1, st2;
vector<char> v3, v4;
int main() {
int t, n;
cin >> t;
string s1, s2;
while (t--) {
cin >> n;
cin >> s1;
cin >> s2;
int cnt = 0;
for (int i = 0; i < s1.size(); i++) {
if (s1[i] != s2[i]) {
cnt++;
v4.push_back(s1[i]);
v4.push_back(s2[i]);
}
}
if (cnt == 0) cout << "YES" << endl;
if (cnt == 1)
cout << "NO" << endl;
else if (cnt == 2) {
if (v4[0] == v4[2] && v4[1] == v4[3])
cout << "YES" << endl;
else
cout << "NO" << endl;
} else
cout << "NO" << endl;
v4.clear();
}
return 0;
}
| 8 | CPP |
#include<iostream>
using namespace std;
int dx[]={1,0,-1,0,1,-1,-1,1};
int dy[]={0,1,0,-1,1,-1,1,-1};
int field[150][150];
void dfs(int x, int y);
int main(){
int h,w;
while(cin >>h>>w,h||w){
for(int i=0; i<150; i++) for(int j=0; j<150; j++) field[i][j] = 0;
for(int i=0; i<w; i++) for(int j=0; j<h; j++) cin >>field[i+50][j+50];
int ans = 0;
for(int i=0; i<w; i++){
for(int j=0; j<h; j++){
if(field[i+50][j+50] == 1){
dfs(i+50,j+50);
ans++;
}
}
}
cout <<ans<<endl;
}
return 0;
}
void dfs(int x, int y){
field[x][y] = 0;
for(int i=0; i<8; i++) if(field[x+dx[i]][y+dy[i]] == 1) dfs(x+dx[i],y+dy[i]);
} | 0 | CPP |
#include <stdio.h>
int main(){
int N,M;scanf("%d %d",&N,&M);
printf("%s",N!=M?"No":"Yes");
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 10000 + 10;
int E[maxn], ans;
queue<int> q;
void cal(int n, int cost, int k) {
int t = 0, cnt = 0, tot = 0;
for (int i = 1; i <= k * 3000; ++i) {
if (t >= k) break;
while (!q.empty()) {
int v = q.front();
if (i - v < cost) break;
q.pop();
ans = max(v + cost, ans);
E[tot++] = v + cost;
cnt--;
}
while (t < k && E[t] <= i && cnt + 1 <= n) {
q.push(i);
t++;
cnt++;
}
}
while (!q.empty()) {
int v = q.front();
q.pop();
ans = max(v + cost, ans);
E[tot++] = v + cost;
}
}
int main() {
int k, n1, n2, n3, t1, t2, t3;
scanf("%d%d%d%d%d%d%d", &k, &n1, &n2, &n3, &t1, &t2, &t3);
ans = 0;
for (int i = 0; i < k; ++i) E[i] = (i / n1 + 1) * t1;
cal(n2, t2, k);
cal(n3, t3, k);
printf("%d\n", ans);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
#define ISLOOSE(a,b) (disdis(a, b) + get<2>(a) * get<2>(a) <= get<2>(b) * get<2>(b))
using namespace std;
double disdis(const tuple<double, double, double>& a, const tuple<double, double, double>& b)
{
return (get<0>(a) - get<0>(b)) * (get<0>(a) - get<0>(b)) + (get<1>(a) - get<1>(b)) * (get<1>(a) - get<1>(b));
}
double heron(double a, double b, double c)
{
double s = (a + b + c) / 2;
return sqrt(s*(s - a)*(s - b)*(s - c));
}
double heron2(double a, double b, double c, double d, double e, double f)
{
return sqrt((a*d*(b + c + e + f - a - d) + b*e*(c + a + f + d - b - e) + c*f*(a + b + d + e - c - f) - a*b*f - a*e*c - d*b*c - d*e*f) / 144.0);
}
tuple<double, double, double> com(const tuple<double, double, double>& a, const tuple<double, double, double>& b)
{
if (ISLOOSE(a, b)) {
return a;
}
else if (ISLOOSE(b, a)) {
return b;
}
else {
double l = heron(get<2>(a), get<2>(b), sqrt(disdis(a, b))) * 2 / sqrt(disdis(a, b));
double d1 = sqrt(get<2>(a) * get<2>(a) - l * l);
double d2 = sqrt(get<2>(b) * get<2>(b) - l * l);
return tuple<double, double, double>(get<0>(a) + (get<0>(b) - get<0>(a)) * d1 / (d1 + d2), get<1>(a) + (get<1>(b) - get<1>(a)) * d1 / (d1 + d2), l);
}
}
double two(const tuple<double, double, double>& a, const tuple<double, double, double>& b)
{
if (ISLOOSE(a, b)) {
return (double)get<2>(a);
}
else if (ISLOOSE(b, a)) {
return (double)get<2>(b);
}
else {
double d = sqrt(disdis(a, b));
return heron(get<2>(a), get<2>(b), d) * 2 / d;
}
}
double three(const tuple<double, double, double>& a, const tuple<double, double, double>& b, const tuple<double, double, double>& c)
{
tuple<double, double, double> temp;
if (ISLOOSE(a, b) && ISLOOSE(a, c))
return get<2>(a);
if (ISLOOSE(b, a) && ISLOOSE(b, c))
return get<2>(b);
if (ISLOOSE(c, a) && ISLOOSE(c, b))
return get<2>(c);
if (ISLOOSE(temp = com(a, b), c))
return get<2>(temp);
if (ISLOOSE(temp = com(b, c), a))
return get<2>(temp);
if (ISLOOSE(temp = com(c, a), b))
return get<2>(temp);
return heron2(get<2>(a) * get<2>(a), get<2>(b) * get<2>(b), get<2>(c) * get<2>(c), disdis(b, c), disdis(c, a), disdis(a, b))
* 3.0 / heron(sqrt(disdis(a, b)), sqrt(disdis(b, c)), sqrt(disdis(c, a)));
}
int main()
{
int n;
double res;
cout << fixed << setprecision(7);
while (cin >> n, n) {
vector< tuple<double, double, double> > str(n);
for (int i = 0; i < n; i++) {
cin >> get<0>(str[i]) >> get<1>(str[i]) >> get<2>(str[i]);
}
if (n == 1) {
cout << (double)get<2>(str[0]) << endl;
}
else if (n == 2) {
cout << two(str[0], str[1]) << endl;
}
else {
res = 100000000.0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
for (int k = j + 1; k < n; k++) {
res = min(res, three(str[i], str[j], str[k]));
}
}
}
cout << res << endl;
}
}
return 0;
} | 0 | CPP |
n=int(input())
l=[]
while(n>0):
s=input()
if len(s)>10:
s=f'{s[0]}{len(s)-2}{s[len(s)-1]}'
print(s)
n-=1 | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using ld = long double;
const int mod = 1e9 + 7;
const ll inf = 1e9;
const ll INF = 2e18;
const int N = 1e5 + 66;
const int M = 5005;
vector<int> g[N];
const int LOG = 20;
int tin[N], tout[N], timer, up[N][LOG];
vector<int> pl[N][LOG];
void dfs(int v, int p = 1) {
tin[v] = timer++;
up[v][0] = p;
for (int i = 1; i < LOG; ++i) {
up[v][i] = up[up[v][i - 1]][i - 1];
pl[v][i].resize(pl[v][i - 1].size() + pl[up[v][i - 1]][i - 1].size());
merge(pl[v][i - 1].begin(), pl[v][i - 1].end(),
pl[up[v][i - 1]][i - 1].begin(), pl[up[v][i - 1]][i - 1].end(),
pl[v][i].begin());
while (pl[v][i].size() > 10) pl[v][i].pop_back();
assert(pl[v][i].size() == 10);
}
for (int to : g[v])
if (to != p) {
dfs(to, v);
}
tout[v] = timer++;
}
bool upper(int a, int b) { return tin[a] <= tin[b] && tout[a] >= tout[b]; }
int lca(int a, int b) {
if (upper(a, b)) return a;
if (upper(b, a)) return b;
for (int i = LOG - 1; i >= 0; --i) {
if (!upper(up[a][i], b)) a = up[a][i];
}
return up[a][0];
}
vector<int> get(int a, int b) {
vector<int> vec(10, inf);
for (int i = LOG - 1; i >= 0; --i) {
if (!upper(up[a][i], b)) {
vector<int> now;
now.resize(vec.size() + pl[a][i].size());
merge(vec.begin(), vec.end(), pl[a][i].begin(), pl[a][i].end(),
now.begin());
while (now.size() > 10) now.pop_back();
assert(now.size() == 10);
vec = now;
a = up[a][i];
}
}
{
vector<int> now;
now.resize(vec.size() + pl[a][0].size());
merge(vec.begin(), vec.end(), pl[a][0].begin(), pl[a][0].end(),
now.begin());
while (now.size() > 10) now.pop_back();
assert(now.size() == 10);
vec = now;
}
{
if (a != b) {
a = up[a][0];
vector<int> now;
now.resize(vec.size() + pl[a][0].size());
merge(vec.begin(), vec.end(), pl[a][0].begin(), pl[a][0].end(),
now.begin());
while (now.size() > 10) now.pop_back();
assert(now.size() == 10);
vec = now;
}
}
assert(vec.size() == 10);
return vec;
}
void solve() {
int n, m, q;
cin >> n >> m >> q;
for (int i = 1, a, b; i < n; ++i) {
cin >> a >> b;
g[a].push_back(b);
g[b].push_back(a);
}
for (int c, i = 1; i <= m; ++i) {
cin >> c;
pl[c][0].push_back(i);
}
for (int i = 1; i <= n; ++i) {
sort(pl[i][0].begin(), pl[i][0].end());
while (pl[i][0].size() < 10) pl[i][0].push_back(inf);
while (pl[i][0].size() > 10) pl[i][0].pop_back();
assert(pl[i][0].size() == 10);
}
dfs(1);
for (int a, b, l; q--;) {
cin >> a >> b >> l;
int c = lca(a, b);
vector<int> vec;
vector<int> L = get(a, c);
vector<int> R = get(b, c);
vec.resize(L.size() + R.size());
merge(L.begin(), L.end(), R.begin(), R.end(), vec.begin());
vector<int> ans;
for (int i = 0; l && i < vec.size(); ++i) {
if (vec[i] == inf) break;
if (i > 0 && vec[i] == vec[i - 1]) continue;
l--;
ans.push_back(vec[i]);
}
cout << ans.size() << " ";
for (int i : ans) cout << i << " ";
cout << "\n";
}
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
;
int tt = 1;
while (tt--) {
solve();
cout << "\n";
}
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<vector<char> > ar(n, vector<char>(m));
vector<vector<bool> > visited(n, vector<bool>(m));
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
cin >> ar[i][j];
}
}
int a, b, u, v;
cin >> a >> b >> u >> v;
--a;
--b;
--u;
--v;
visited[a][b] = true;
deque<pair<long long, long long> > Q;
Q.push_back(pair<long long, long long>(a, b));
while (!Q.empty()) {
int x = Q.front().first;
int y = Q.front().second;
Q.pop_front();
if (x == u && y == v) {
break;
}
if (x + 1 < n && !visited[x + 1][y] &&
(ar[x + 1][y] != 'X' || (x + 1 == u && y == v))) {
Q.push_back(pair<long long, long long>(x + 1, y));
visited[x + 1][y] = true;
}
if (x - 1 >= 0 && !visited[x - 1][y] &&
(ar[x - 1][y] != 'X' || (x - 1 == u && y == v))) {
Q.push_back(pair<long long, long long>(x - 1, y));
visited[x - 1][y] = true;
}
if (y + 1 < m && !visited[x][y + 1] &&
(ar[x][y + 1] != 'X' || (x == u && y + 1 == v))) {
Q.push_back(pair<long long, long long>(x, y + 1));
visited[x][y + 1] = true;
}
if (y - 1 >= 0 && !visited[x][y - 1] &&
(ar[x][y - 1] != 'X' || (x == u && y - 1 == v))) {
Q.push_back(pair<long long, long long>(x, y - 1));
visited[x][y - 1] = true;
}
}
if (visited[u][v]) {
if (ar[u][v] == 'X' && !(a == u && b == v)) {
cout << "YES" << endl;
} else {
int free = 0;
if (u - 1 >= 0) free += (ar[u - 1][v] == '.' || (u - 1 == a && v == b));
if (u + 1 < n) free += (ar[u + 1][v] == '.' || (u + 1 == a && v == b));
if (v - 1 >= 0) free += (ar[u][v - 1] == '.' || (v - 1 == b && u == a));
if (v + 1 < m) free += (ar[u][v + 1] == '.' || (v + 1 == b && u == a));
if (free >= 2 || (a == u && b == v && free >= 1))
cout << "YES" << endl;
else
cout << "NO" << endl;
}
} else
cout << "NO" << endl;
}
| 9 | CPP |
def pair(h, n_h, m, n_m):
list_h = n_h.strip('\n').split(' ')
list_m = n_m.strip('\n').split(' ')
for i in range(len(list_h)):
list_h[i] = int(list_h[i])
for j in range(len(list_m)):
list_m[j] = int(list_m[j])
list_h.sort()
list_m.sort()
counter = 0
index = 0
for x in list_h:
while index < len(list_m):
if x + 1 < list_m[index]:
break
elif x - 1 > list_m[index]:
index += 1
else:
counter += 1
index += 1
break
return counter
h = input()
n_h = input()
m = input()
n_m = input()
print(pair(h, n_h, m, n_m)) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, h, m, h0 = -1, m0 = 0, c = 1, c0 = 1;
cin >> n;
while (n--) {
cin >> h >> m;
if (h == h0 && m == m0)
c++;
else
c = 1;
if (c > c0) c0 = c;
h0 = h;
m0 = m;
}
cout << c0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1);
const double eps = 1e-9;
long long power(long long x, long long n) {
long long m = 1;
for (long long i = 1; i <= n; i++) m *= x;
return m;
}
int main() {
long long i, j, k, l, p, q, r, x, y, z, n, m, c(0), t, h, mn = pow(2, 62) - 1,
mx = 0;
string s;
cin >> s;
cin >> x >> y;
vector<long long> v;
long long sl = s.size() - 1;
bool F, S;
map<long long, bool> mp;
for (i = 0; i <= sl; i++) {
c = (c * 10 + (s[i] - 48)) % x;
if (c == 0 && (i == sl || (i + 1 <= sl && s[i + 1] > 48))) {
F = 1;
mp[i] = 1;
}
}
c = 0, m = 1;
long long d;
for (i = sl; i >= 0; i--) {
c = (c + ((s[i] - 48) * m)) % y;
if (c == 0 && mp[i - 1]) {
cout << "YES\n";
for (j = 0; j <= i - 1; j++) cout << s[j];
cout << endl;
for (; j <= sl; j++) cout << s[j];
return 0;
}
m = (m * 10) % y;
}
cout << "NO\n";
}
| 9 | CPP |
#include <iostream>
#include<vector>
#include<algorithm>
#include<string>
#include<map>
#include<set>
#include<stack>
#include<queue>
#include<math.h>
using namespace std;
typedef long long ll;
#define int long long
typedef vector<int> VI;
typedef pair<int, int> pii;
#define fore(i,a) for(auto &i:a)
#define REP(i,n) for(int i=0;i<n;i++)
#define eREP(i,n) for(int i=0;i<=n;i++)
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define eFOR(i,a,b) for(int i=(a);i<=(b);++i)
#define SORT(c) sort((c).begin(),(c).end())
#define rSORT(c) sort((c).rbegin(),(c).rend())
#define LB(x,a) lower_bound((x).begin(),(x).end(),(a))
#define UB(x,a) upper_bound((x).begin(),(x).end(),(a))
#define INF 1000000000
#define LLINF 9223372036854775807
#define mod 1000000007
//vector<vector<int> > dp;
//vector<vector<vector<int> > > vvvi;
//dp=vector<vector<int> >(N, vector<int>(M,0));
//vector<pair<int,int> > v;
//v.push_back(make_pair(x,y));
//priority_queue<int,vector<int>, greater<int> > q2;
signed main(){
cin.tie(0);
ios::sync_with_stdio(false);
int N;
cin >> N;
VI in(N,0),P(N);
REP(i, N) {
int v;
cin >> v;
v = (i + v) % N;
P[i] = v;
in[v]++;
}
queue<int> Q;
REP(i, N)if (in[i] == 0)Q.push(i);
int res = 0;
while (!Q.empty()) {
int u = Q.front();
Q.pop();
res++;
int v = P[u];
in[v]--;
if (in[v] == 0)Q.push(v);
}
cout << N - res << endl;
return 0;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int a[100000 + 80], b[100000 + 80], c[100000 + 80];
int main() {
int n, m, i, j, x;
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) {
c[i] = i;
for (j = 1; j <= m; j++) {
scanf("%d", &x);
if (a[j] > x) b[j] = i;
if (c[i] > b[j]) c[i] = b[j];
a[j] = x;
}
}
for (scanf("%d", &x); x; x--) {
scanf("%d%d", &i, &j);
puts((c[j] <= i) ? "Yes" : "No");
}
return 0;
}
| 9 | CPP |
n = int(input())
h = [int(i) for i in input().split()]
m = [0, abs(h[0]-h[1])]
for i in range(2, n):
v = min(m[0]+abs(h[i-2]-h[i]), m[1]+abs(h[i-1]-h[i]))
m = [m[1], v]
print(m[1]) | 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
string s[100005];
int solve(int cur) {
if (cur == 1) {
for (int i = 0; i < s[cur].size(); i++) {
if (s[cur][i] == '?') {
if (i == 0)
s[cur][i] = '1';
else
s[cur][i] = '0';
}
}
return 1;
}
if (s[cur].size() < s[cur - 1].size()) return 0;
if (s[cur].size() > s[cur - 1].size()) {
if (s[cur][0] == '?') {
s[cur][0] = '1';
for (int i = 1; i < s[cur].size(); i++)
if (s[cur][i] == '?') s[cur][i] = '0';
} else {
for (int i = 1; i < s[cur].size(); i++)
if (s[cur][i] == '?') s[cur][i] = '0';
}
return 1;
}
string temp = s[cur];
for (int i = 0; i < temp.size(); i++)
if (s[cur][i] == '?') temp[i] = s[cur - 1][i];
int flag = 0;
int ok = 0;
int equall = 0;
for (int i = 0; i < temp.size(); i++) {
if (temp[i] != s[cur - 1][i] && !equall) {
equall = 1;
if (temp[i] > s[cur - 1][i]) {
ok = 1;
for (int j = i + 1; j < temp.size(); j++)
if (s[cur][j] == '?') temp[j] = '0';
break;
} else {
for (int j = i - 1; j >= 0; j--) {
if (s[cur][j] == '?' && temp[j] != '9') {
temp[j] = s[cur - 1][j] + 1;
for (int k = j + 1; k < temp.size(); k++)
if (s[cur][k] == '?') temp[k] = '0';
ok = 1;
break;
}
}
if (!ok) return 0;
}
break;
}
if (equall) break;
}
if (!equall) {
for (int i = temp.size() - 1; i >= 0; i--) {
if (temp[i] != '9' && s[cur][i] == '?') {
temp[i] = s[cur - 1][i] + 1;
for (int j = i + 1; j < temp.size(); j++)
if (s[cur][j] == '?') temp[j] = '0';
ok = 1;
break;
}
}
}
if (!ok)
return 0;
else
s[cur] = temp;
return 1;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
while (cin >> n) {
for (int i = 1; i <= n; i++) cin >> s[i];
long long res = 0;
int ok = 1;
for (int i = 1; i <= n; i++) {
if (!solve(i)) {
ok = 0;
break;
}
}
if (!ok)
cout << "NO" << endl;
else {
cout << "YES" << endl;
for (int i = 1; i <= n; i++) cout << s[i] << endl;
}
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main(void){
int a,b,c;
cin >> a >> b >> c;
cout << min({a+b,b+c,a+c}) <<endl;
} | 0 | CPP |
n = int(input())
for t in range(n):
k = int(input())
print(k // 2 + k % 2) | 7 | PYTHON3 |
n = int(input())
l = map(int, input().split())
# s = [0]
# for new in l:
# s.append(new + s[-1])
# s = [(i - min(s) + 1) for i in s]
# for i in range(1, n+1):
# if not i in s:
# print(-1)
# break
# else:
# print(' '.join([str(i) for i in s]))
a = [0]
for i in l:
a.append(a[-1] + i)
b = sorted(a[::])
for i in range(n-1):
if b[i+1] - b[i] != 1:
print(-1)
break
else:
m = 1 - b[0]
for i in range(n):
print(m + a[i], end=' ')
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long long int ans = 0;
if (n % 2 == 0) ans = pow(2, n / 2);
cout << ans;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, ans;
char s[101];
int main() {
scanf("%d%s", &n, &s);
char _[n];
for (int i = 0; i < n; i++) _[i] = s[i];
for (int i = 0; i < n; i++)
for (int j = i; j < n; j++)
if (s[j] == '0')
s[j] = 49;
else {
s[j] = 48;
break;
}
for (int i = 0; i < n; i++) ans += _[i] != s[i];
printf("%d\n", ans);
return 0;
}
| 7 | CPP |
#include <cstdio>
#include <iostream>
#include <vector>
#include <list>
#include <cmath>
#include <fstream>
#include <algorithm>
#include <string>
#include <queue>
#include <set>
#include <map>
#include <complex>
#include <iterator>
#include <cstdlib>
#include <cstring>
#include <sstream>
#include <stack>
#include <climits>
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
double EPS=1e-7;
double EQ(double a,double b){
return abs(a-b)<EPS;
}
void fast_stream(){
std::ios_base::sync_with_stdio(0);
}
struct edge{
int to;
int limitSpeed;
int dist;
};
vector<edge> G[101];
void add_edge(int x,int y,int d,int c){
edge e;
int from=x;
int to=y;
e.to=y;
e.limitSpeed=c;
e.dist=d;
G[from].push_back(e);
e.to=x;
G[to].push_back(e);
}
const double INF=1e+10;
typedef pair<double,int> pdi;
typedef pair<pdi,pii> Sit;
double d[51][51][51];
double dijkstra(int s,int g,int n){
for(int i=0;i<51;i++)
for(int j=0;j<51;j++)
for(int k=0;k<51;k++)
d[i][j][k]=INF;
priority_queue<Sit,vector<Sit>,greater<Sit> > pq;
pq.push(make_pair(pdi(0,0),pii(s,1)));
d[0][s][1]=0;
while(pq.size()){
Sit p=pq.top();pq.pop();
double ccost=p.first.first;
int prvNode=p.first.second;
int curNode=p.second.first;
int curSpeed=p.second.second;
if(!EQ(d[prvNode][curNode][curSpeed],ccost)&&d[prvNode][curNode][curSpeed]<ccost)continue;
for(int j=0;j<G[curNode].size();j++){
edge &e=G[curNode][j];
int toNode=e.to;
if(toNode==prvNode)
continue;
int limitSpeed=e.limitSpeed;
int dist=e.dist;
for(int i=-1;i<=1;i++){
if(prvNode==0&&i!=0)continue;
int nxtSpeed=curSpeed+i;
if(nxtSpeed==0||nxtSpeed>limitSpeed)continue;
double ncost=ccost+1.0*dist/nxtSpeed;
if(!EQ(ncost,d[curNode][toNode][nxtSpeed])&&ncost<d[curNode][toNode][nxtSpeed]){
d[curNode][toNode][nxtSpeed]=ncost;
pq.push(make_pair(pdi(ncost,curNode),pii(toNode,nxtSpeed)));
}
}
}
}
double res=INF;
for(int i=1;i<=n;i++)
res=min(res,d[i][g][1]);
return res;
}
void solve(){
int n,m,s,g;
while(cin>>n>>m&&(n|m)){
cin>>s>>g;
for(int i=0;i<m;i++){
int x,y,d,c;
cin>>x>>y>>d>>c;
add_edge(x,y,d,c);
}
double res=dijkstra(s,g,n);
if(EQ(res,INF))cout<<"unreachable"<<endl;
else printf("%.10f\n",res);
for(int i=0;i<101;i++)G[i].clear();
}
}
int main(){
solve();
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<int> ans;
int previ[200005];
vector<int> tree[200005];
int cnt[200005];
void countN(int curr) {
cnt[curr] = 1;
for (int a : tree[curr]) {
if (a != previ[curr]) {
previ[a] = curr;
countN(a);
cnt[curr] += cnt[a];
}
}
}
void recur(int curr) {
for (int a : tree[curr]) {
if (a != previ[curr]) {
if (cnt[a] % 2 == 0) {
recur(a);
}
}
}
ans.push_back(curr);
for (int a : tree[curr]) {
if (a != previ[curr]) {
if (cnt[a] % 2 == 1) {
recur(a);
}
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int temp;
cin >> temp;
temp--;
if (temp != -1) {
tree[i].push_back(temp);
tree[temp].push_back(i);
}
}
if (n % 2 == 1) {
cout << "YES\n";
previ[0] = -1;
countN(0);
recur(0);
for (int a : ans) {
cout << a + 1 << "\n";
}
} else {
cout << "NO\n";
}
}
| 8 | CPP |
n = int(input())
k = 0
finalList = []
while k < n:
m = input()
shapeValue = {'Tetrahedron': 4, 'Cube': 6, 'Octahedron': 8, 'Dodecahedron': 12, 'Icosahedron': 20}
finalList.append(shapeValue[m])
k += 1
sumList = sum(finalList)
print(sumList) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2510;
struct Point {
double x, y;
Point(int x = 0, int y = 0) : x(x), y(y) {}
} p[N];
double dis(Point a, Point b) {
return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
}
double f[N][N][2];
int n;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
p[i] = Point(x, y);
}
for (int len = 2; len <= n; len++)
for (int l = 0; l < n; l++) {
int r = (l + len - 1) % n;
f[l][r][0] = max(f[(l + 1) % n][r][0] + dis(p[l], p[(l + 1) % n]),
f[(l + 1) % n][r][1] + dis(p[l], p[r]));
f[l][r][1] =
max(f[l][(r - 1 + n) % n][0] + dis(p[r], p[l]),
f[l][(r - 1 + n) % n][1] + dis(p[r], p[(r - 1 + n) % n]));
}
double ans = 0;
for (int i = 0; i < n; i++)
ans = max(ans, max(f[i][i + n - 1][0], f[i][(i + n - 1) % n][1]));
printf("%.10lf", ans);
return 0;
}
| 11 | CPP |
n=int(input())
a=[int(k) for k in input().split()]
mi=min(a)
min_dist=10**10
index=[]
for i in range(len(a)):
if a[i]==mi:
index.append(i)
for i in range(len(index)-1):
if (index[i+1]-index[i])<min_dist:
min_dist=index[i+1]-index[i]
print(min_dist)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
map<char, int> m;
map<char, int>::iterator it;
string s;
m.insert(pair<char, int>('A', 0));
m.insert(pair<char, int>('B', 0));
m.insert(pair<char, int>('C', 0));
for (int i = 0; i < 3; i++) {
cin >> s;
if (s[1] == '>') {
m[s[0]]++;
} else {
m[s[2]]++;
}
}
if (m['A'] == 1 && m['B'] == 1 && m['C'] == 1) {
cout << "Impossible" << endl;
} else {
if (m['A'] == 0) {
cout << "A";
} else if (m['B'] == 0) {
cout << "B";
} else {
cout << "C";
}
if (m['A'] == 1) {
cout << "A";
} else if (m['B'] == 1) {
cout << "B";
} else {
cout << "C";
}
if (m['A'] == 2) {
cout << "A";
} else if (m['B'] == 2) {
cout << "B";
} else {
cout << "C";
}
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a = 0, b = 0, i, p, n;
cin >> i;
while (i--) {
cin >> p;
if (p == 1) {
cin >> n;
a = a + n;
cin >> n;
a = a - n;
}
if (p == 2) {
cin >> n;
b = b + n;
cin >> n;
b = b - n;
}
}
if (a >= 0) {
cout << "LIVE" << endl;
} else {
cout << "DEAD" << endl;
}
if (b >= 0) {
cout << "LIVE" << endl;
} else {
cout << "DEAD" << endl;
}
}
| 7 | CPP |
#include <bits/stdc++.h>
int main() {
int i, j, t, n, min, a, b, c, k;
scanf("%d", &t);
for (i = 0; i < t; i++) {
scanf("%d", &n);
int arr[n];
for (j = 0; j < n; j++) scanf("%d", &arr[j]);
min = fabs(arr[0] - arr[1]);
for (j = 0; j < n - 1; j++) {
a = arr[j];
for (k = j + 1; k < n; k++) {
if (fabs(a - arr[k]) < min) min = fabs(a - arr[k]);
}
}
printf("%d\n", min);
}
return 0;
}
| 8 | CPP |
from collections import deque, defaultdict, Counter, OrderedDict
import math,os,sys,heapq,bisect,random
from itertools import *
from io import BytesIO, IOBase
def inp(): return sys.stdin.readline().rstrip("\r\n") # for fast input
def out(var): sys.stdout.write(str(var)) # for fast output, always take string
def lis(): return list(map(int, inp().split()))
def stringlis(): return list(map(str, inp().split()))
def sep(): return map(int, inp().split())
def strsep(): return map(str, inp().split())
def fsep(): return map(float, inp().split())
def inpu(): return int(inp())
M = 1000000007
def main():
how_much_noob_I_am = 1
how_much_noob_I_am = inpu()
for _ in range(how_much_noob_I_am):
n = inpu()
arr = lis()
i = 0
ans = 1
for i in range(n):
if arr[i] == 0:
if i > 0 and arr[i - 1] == 0:
print(-1)
break
else:
if i > 0 and arr[i - 1] == 1:
ans += 5
ans -= 1
ans += 1
i += 1
else:
print(ans)
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")
# endregion
if __name__ == '__main__':
main()
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int arr[10];
int main() {
int n;
cin >> n;
n *= 2;
string s, s1, s2, s3;
cin >> s >> s1 >> s2 >> s3;
for (int i = 0; i < s.size(); i++) {
arr[int(s[i]) - '0']++;
arr[int(s1[i]) - '0']++;
arr[int(s2[i]) - '0']++;
arr[int(s3[i]) - '0']++;
}
for (int i = 1; i <= 9; i++) {
if (arr[i] > n) {
cout << "NO";
return 0;
}
}
cout << "YES";
}
| 7 | CPP |
a=int(input())
e=[]
if(a==1):
print("I hate it")
elif(a!=1):
for i in range(a-1):
if(i%2==0):
e.append("I hate that")
a-=1
else:
e.append("I love that")
a-=1
e=e[::-1]
if(e[0:1:]==["I hate that"]):
e=e[::-1]
e.append("I love it")
else:
e=e[::-1]
e.append("I hate it")
e=' '.join(e)
print(e) | 7 | PYTHON3 |
val = input().split()
limark_weight = int(val[0])
bob_weight = int(val[1])
count_year = 0
while limark_weight <= bob_weight:
limark_weight = limark_weight * 3
bob_weight = bob_weight * 2
count_year += 1
print(count_year) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, q, x, y, p;
int a[105];
int main() {
cin >> n;
for (int i = (1), _b = (n); i <= _b; i++) cin >> a[i];
cin >> q;
for (int i = 0, _n = (q); i < _n; i++) {
cin >> p >> x >> y;
if (p == 1) {
int ans = 0;
int k = x;
while (k <= y) {
for (int j = 1; j <= n; j++) {
if (a[j] == k) {
k++;
}
}
ans++;
}
cout << ans << endl;
} else
swap(a[x], a[y]);
}
return 0;
}
| 8 | CPP |
n=int(input())
stones = input()
prev=stones[0]
sum=0
for i in range(1,len(stones)):
if prev == stones[i]:
sum+=1
else:
prev = stones[i]
print(sum)
| 7 | PYTHON3 |
t = []
x = 0
n = int(input())
for i in range(n):
t.append(input())
str(t)
for i in t:
c=0
for j in i:
if(i[c:c+2]=="++"):
x = x+1
if(i[c:c+2]=="--"):
x =x-1
c=c+1
print(x) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
bool solve() {
int n, c, s;
if (scanf("%d", &n) == EOF) return false;
deque<pair<int, int> > z0, z1;
for (int i = 0; i < n; ++i) {
scanf("%d%d", &c, &s);
if (c)
z1.push_back(make_pair(s, i));
else
z0.push_back(make_pair(s, i));
}
for (int i = 1; i < n; ++i) {
pair<int, int> ss0 = z0.front(), ss1 = z1.front();
z0.pop_front();
z1.pop_front();
int cost = min(ss0.first, ss1.first);
if (ss0.first < ss1.first ||
ss0.first == ss1.first && z1.size() < z0.size())
z1.push_front(make_pair(ss1.first - cost, ss1.second));
else
z0.push_front(make_pair(ss0.first - cost, ss0.second));
printf("%d %d %d\n", ss0.second + 1, ss1.second + 1, cost);
}
return true;
}
int main() {
solve();
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int c = 200002;
int sum, n, ans[c], pos;
vector<int> sz[c];
bool v[c];
bool dfs(int a) {
v[a] = true;
int el = a;
for (int i = 0; i < sz[a].size(); i++) {
int x = sz[a][i];
if (!v[x] && !dfs(x)) ans[el] = x, el = x;
}
if (el != a) {
ans[el] = a, sum -= 2;
return 1;
}
return 0;
}
int main() {
cin >> n, sum = 2 * n;
for (int i = 1; i < n; i++) {
int x, y;
cin >> x >> y;
sz[x].push_back(y), sz[y].push_back(x);
}
for (int i = 1; i <= n; i++)
if (sz[i].size() == 1) pos = sz[i][0];
dfs(pos);
cout << sum << "\n";
for (int i = 1; i <= n; i++) cout << ans[i] << " ";
return 0;
}
| 8 | CPP |
word = input()
if word.isupper() or (word[0].islower() and word[1:].isupper()) or (len(word) == 1 and word.islower()):
word = word.swapcase()
print(word) | 7 | PYTHON3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.