solution
stringlengths 11
983k
| difficulty
int64 0
21
| language
stringclasses 2
values |
|---|---|---|
n,k,d=map(int,input().split())
limit=1
p=True
for i in range(d):
limit*=k
if limit>=n:
p=False
break
if p:
print("-1")
exit()
a=[i for i in range(1,n+1)]
for i in range(d):
b=""
for j in range(n):
b+=str(a[j]%(k)+1)+" "
a[j]//=k
print(b)
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int ans[1080][1080], n, k, d;
int main() {
cin >> n >> k >> d;
for (int i = 0; i < n; i++) {
int num = i;
for (int j = 0; j < d; j++) {
ans[i][j] = num % k;
num /= k;
}
}
for (int i = 1; i < n; i++) {
int allzero = 1;
for (int j = 0; j < d; j++) {
if (ans[i][j]) allzero = 0;
}
if (allzero) {
cout << -1 << endl;
return 0;
}
}
for (int i = 0; i < d; i++) {
for (int j = 0; j < n; j++) {
if (j) printf(" ");
printf("%d", ans[j][i] + 1);
}
puts("");
}
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1 * 1000 + 10;
int ans[MAXN][MAXN];
int main(int argc, char** argv) {
int n, k, d;
cin >> n >> k >> d;
long long tmp = 1L;
int i = 0;
bool check = false;
while (i++ < d) {
tmp *= k;
if (tmp >= n) {
check = true;
break;
}
}
if (!check) {
cout << -1 << endl;
return 0;
}
for (int i = 1; i < n; i++) {
for (int j = 0; j < d; j++) {
ans[i][j] = ans[i - 1][j];
}
for (int j = d - 1; j >= 0; j--) {
ans[i][j] = (ans[i][j] + 1) % k;
if (ans[i][j]) break;
}
}
for (int i = 0; i < d; i++, cout << endl)
for (int j = 0; j < n; j++) cout << ans[j][i] + 1 << ' ';
return 0;
}
| 9 | CPP |
n,k,d=list(map(int,input().split()))
if k**d<n:
print(-1)
else:
ans=[]
for i in range(d):
ans.append([1 for j in range(n)])
for i in range(n):
j=0
p=i
while p>0:
ans[j][i]=p%k+1
p=p//k
j=j+1
if j==d:
break
for i in range(d):
print(' '.join(map(str, ans[i]))) | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long MAX = 1000000000000000000;
long long mod = 1000000000;
long double pi = 3.141592653589793238;
void pls() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
long long n, k, d;
vector<vector<int>> res;
void backtrack(vector<int> &temp) {
if (res.size() == n) return;
if (temp.size() == d) {
res.push_back(temp);
return;
}
for (int i = 1; i <= k; i++) {
temp.push_back(i);
backtrack(temp);
if (res.size() == n) return;
temp.pop_back();
}
}
void solve() {
cin >> n >> k >> d;
long long permu = 1;
long long cnt = 0;
while (permu < n && cnt < d) {
permu *= k;
cnt++;
}
if (cnt == d && permu < n) {
cout << "-1" << endl;
return;
}
vector<int> tt;
backtrack(tt);
for (int i = 0; i < d; i++) {
for (int j = 0; j < res.size(); j++) {
cout << res[j][i] << " ";
}
cout << endl;
}
}
int main() {
pls();
solve();
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
int mod = 1e9 + 7;
long long power(long long b, long long p) {
long long r = 1;
while (p) {
if (p & 1ll) r *= b;
b *= b;
p >>= 1ll;
}
return r;
}
vector<int> convert_to_other_base(int m, int b, int d) {
vector<int> v;
while (m) {
v.push_back(m % b);
m /= b;
}
int sz = v.size();
while (sz < d) v.push_back(0), ++sz;
reverse(v.begin(), v.end());
return v;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, k, d;
cin >> n >> k >> d;
int cd = d;
long long ck = k;
while (--cd) {
ck *= k;
if (ck >= n) break;
}
if (ck < n) return cout << -1, 0;
vector<vector<int>> a(n, vector<int>(d, 0));
int i, j;
for (i = 1; i < n; ++i) a[i] = convert_to_other_base(i, k, d);
for (i = 0; i < d; ++i, cout << '\n')
for (j = 0; j < n; ++j) cout << a[j][i] + 1 << ' ';
return 0;
}
| 9 | CPP |
# Target - Expert on CF
# Be Humblefool
import sys
def get_array(): return list(map(int, sys.stdin.readline().strip().split()))
def get_ints(): return map(int, sys.stdin.readline().strip().split())
def input(): return sys.stdin.readline().strip()
n,k,d = get_ints()
if (n > k ** d):
print(-1)
exit()
for i in range(d):
power = k**i
resArray = [((j // power) % k +1) for j in range(n)]
print(' '.join(map(str,resArray))) | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int n, d;
long long k, now;
int a[1005][1005];
void Dfs(int u, int i) {
if (a[u][i] == k) {
a[u][i] = 0;
a[u][i + 1]++;
Dfs(u, i + 1);
}
}
int main() {
n = read();
k = read();
d = read();
int t = n;
for (int i = 1; i <= d; i++) t = t / k + (int)(t % k > 0);
memset(a, 0, sizeof(a));
if (t == 1) {
for (int u = 2; u <= n; u++) {
for (int i = 1; i <= d; i++) a[u][i] = a[u - 1][i];
a[u][1] += 1;
Dfs(u, 1);
}
for (int i = 1; i <= d; i++) {
for (int j = 1; j <= n; j++) printf("%d ", a[j][i] + 1);
puts("");
}
} else
puts("-1");
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
const int inf = (1 << 30), mod = 1000000007;
using namespace std;
int n, d, k, k1;
int a[1005], go[1005][1005];
void print(int x) {
if (x == 0) return;
for (int i = 1; i <= d; i++) go[i][x] = a[i];
int cur = d;
a[cur]++;
while (a[cur] > k) {
a[cur] = 1;
a[--cur]++;
}
print(x - 1);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k >> d;
long long x = 1;
bool ok = false;
for (int i = 1; i <= d && !ok; i++) {
x *= k;
if (x >= n) ok = true;
}
if (!ok) {
cout << -1;
return 0;
}
for (int i = 1; i <= d; i++) a[i] = 1;
print(n);
for (int i = 1; i <= d; i++)
for (int j = 1; j <= n; j++) {
cout << go[i][j] << (j == n ? "\n" : " ");
}
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long x, y, z, ans = 1, arr[1000][1000], c;
void tot(int cnt) {
if (c == x - 1) {
for (int i = 0; i < z; i++) {
for (int j = 0; j < x; j++) {
printf("%I64d ", arr[j][i] + 1);
}
printf("\n");
}
exit(0);
}
if (cnt == z) {
for (int i = 0; i < cnt; i++) {
arr[c + 1][i] = arr[c][i];
}
c++;
return;
}
for (int i = 0; i < y; i++) {
arr[c][cnt] = i;
tot(cnt + 1);
}
}
bool power(long long a, long long b) {
for (int i = 0; i < b; i++) {
ans *= a;
if (ans >= x) return 1;
}
return 0;
}
int main() {
cin >> x >> y >> z;
if (power(y, z) == 1)
tot(0);
else
printf("-1\n");
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, d;
cin >> n >> k >> d;
bool done = false;
long long tot = 1;
for (int i = 0; (i) < (d); i++) {
tot *= k;
if (tot >= n) {
done = true;
break;
}
}
if (!done) {
cout << -1 << endl;
return 0;
}
int arr[1001][1001];
for (int i = 0; (i) < (n); i++) {
for (int j = 0; (j) < (d); j++) arr[i][j] = 1;
if (i) {
arr[i][d - 1] = arr[i - 1][d - 1] + 1;
}
}
for (int i = 1; (i) <= (n - 1); i++) {
int ind = d - 1;
while (arr[i][ind] > k) {
int temp = arr[i][ind];
arr[i][ind] %= k;
if (!arr[i][ind]) {
arr[i][ind] = k;
temp -= k;
}
arr[i][--ind] += temp / k;
}
}
for (int i = 0; (i) < (d); i++) {
for (int j = 0; (j) < (n); j++) {
cout << arr[j][i] << " ";
}
cout << endl;
}
return 0;
}
| 9 | CPP |
def f(t):
i = -1
t[i] += 1
while t[i] > k:
t[i] = 1
i -= 1
t[i] += 1
return list(map(str, t))
n, k, d = map(int, input().split())
if k ** d < n: print(-1)
else:
t = [1] * d
t[-1] = 0
s = [f(t) for i in range(n)]
print('\n'.join([' '.join(t) for t in zip(*s)])) | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 2e9 + 9;
void f(vector<int> &V, int k) {
reverse((V).begin(), (V).end());
for (int i = 0; i < (int)((int)(V.size())); i++) {
if (V[i] != k) {
V[i]++;
reverse((V).begin(), (V).end());
return;
}
V[i] = 1;
}
reverse((V).begin(), (V).end());
return;
}
int fi(int n, int b) {
n--;
if (b == 1) return INF;
int ans = 0;
while (n) {
ans++;
n /= b;
}
return ans;
}
int main() {
int n, d, k;
cin >> n >> k >> d;
if (n == 1 and k == 1) {
for (int i = 0; i < (int)(d); i++) cout << 1 << endl;
return 0;
}
if (fi(n, k) > d) {
cout << -1 << endl;
return 0;
}
vector<int> V(d, 1);
vector<vector<int> > ans;
for (int i = 0; i < (int)(n); i++) {
ans.push_back(V);
f(V, k);
}
for (int i = 0; i < (int)(d); i++) {
for (int j = 0; j < (int)(n); j++) cout << ans[j][i] << " ";
cout << endl;
}
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n1, n2, n, k, l, d, i, j, a[1013];
int main() {
cin >> n >> k >> d;
n1 = n;
while ((n1 > 1) && (i <= d)) {
n1 = (n1 + k - 1) / k;
++i;
}
if (i > d) {
cout << "-1";
} else {
for (i = 0; i < n; ++i) {
a[i] = i;
}
n1 = n;
for (i = 0; i < d; ++i) {
for (j = 0; j < n; ++j) {
cout << a[j] % k + 1 << " ";
a[j] /= k;
}
cout << "\n";
}
}
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
const int MAX_COUNT = 1e5;
const int MOD = 1e9 + 7;
int main() {
ios::sync_with_stdio(false);
int n, k, d;
cin >> n >> k >> d;
if (d < ceil(log(n) / log(k))) {
cout << -1 << endl;
return 0;
}
long long period = 1;
for (int i = 0; i < (d); ++i) {
for (int j = 0; j < (n); ++j) {
cout << (j / period) % k + 1 << " ";
}
cout << endl;
period *= k;
period %= 1007;
}
return 0;
}
| 9 | CPP |
def add1(array, base):
array[-1] += 1
array = [0] + array
k= len(array)-1
while array[k]>=base:
array[k] -= base
array[k-1] += 1
k -= 1
if array[0] == 0:
return array[1:]
return array
n, k, d = list(map(int, input().split(' ')))
if n == 1:
for i in range(d):
print(1)
quit()
if n > k**d:
print("-1")
quit()
arr = []
array = [0]*d
for i in range(n):
arr.append(array)
array = add1(array[:], k)
new = [[0]*len(arr) for _ in range(len(arr[0]))]
for i in range(len(arr)):
for j in range(len(arr[0])):
new[j][i] = arr[i][j]+1
for i in new:
print(' '.join([str(x) for x in i]))
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, k, d;
vector<vector<int> > v;
vector<int> va;
void incr(int i) {
if (va[i] < k)
va[i]++;
else {
va[i] = 1;
incr(i - 1);
}
}
int main() {
scanf("%i%i%i", &n, &k, &d);
double nd = n, kd = k, dd = d;
double pw = pow(kd, dd);
if (nd > pw + 0.5) {
printf("%i", -1);
exit(0);
}
va.assign(d, 1);
for (int i = 0; i < n; i++) {
incr(d - 1);
v.push_back(va);
}
for (int i = 0; i < d; i++) {
for (int j = 0; j < n; j++) printf("%i ", v[j][i]);
printf("%c", '\n');
}
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
bool cmp(pair<long long, long long> a, pair<long long, long long> b) {
if (a.first == b.first)
return a.second < b.second;
else
return a.first < b.first;
}
long long exp(long long a, long long b) {
long long ans = 1;
while (b != 0) {
if (b % 2) ans = ans * a;
a = a * a;
b /= 2;
}
return ans;
}
long long arr[1005][1005];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, k, d;
cin >> n >> k >> d;
long long tmp = 1;
bool fg = 0;
for (long long i = (long long)0; i < (long long)d; i++) {
tmp = tmp * k;
if (tmp >= n) {
fg = 1;
break;
}
}
if (!fg) {
cout << -1 << endl;
return 0;
}
for (long long i = (long long)1; i < (long long)n + 1; i++) {
for (long long j = (long long)0; j < (long long)d; j++) {
arr[i][j] = arr[i - 1][j];
}
for (long long j = (long long)0; j < (long long)d; j++) {
arr[i][j] = (arr[i][j] + 1) % k;
if (arr[i][j]) break;
}
}
for (long long j = (long long)0; j < (long long)d; j++) {
for (long long i = (long long)1; i < (long long)n + 1; i++)
cout << arr[i][j] + 1 << " ";
cout << endl;
}
return 0;
}
| 9 | CPP |
# -*- coding: utf-8 -*-
import sys
def main():
n,k,d = map(int,sys.stdin.readline().split())
blocksize = n
for i in range(d):
blocksize = blocksize//k + (blocksize%k != 0)
# print(blocksize)
if(blocksize > 1):
print("-1")
sys.exit(0)
for days in range(d):
i = 0
bus = 1
while i < n:
for j in range(blocksize):
sys.stdout.write(str(bus) + ' ')
i += 1
if i == n: break
bus += 1
if(bus > k): bus = 1
blocksize *= k
sys.stdout.write('\n')
if __name__ == "__main__":
main() | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int A[1005][1005];
int main() {
int n, d, k;
while (~scanf("%d%d%d", &n, &k, &d)) {
bool f1 = false;
long long tmp = 1;
for (int i = 1; i <= d; i++) {
tmp *= k;
if (tmp >= n) {
f1 = true;
break;
}
}
if (!f1) {
puts("-1");
continue;
}
for (int i = 0; i < n; i++) {
tmp = i;
for (int j = 0; j < d; j++) {
A[i][j] = tmp % k + 1;
tmp /= k;
}
}
for (int i = 0; i < d; i++)
for (int j = 0; j < n; j++) {
printf("%d%c", A[j][i], j == n - 1 ? '\n' : ' ');
}
}
}
| 9 | CPP |
m=list(input().split())
n=int(m[0])
k=int(m[1])
d=int(m[2])
if n==1:
for i in range(d):
print("1")
exit()
if k==1:
print("-1")
exit()
if k>=n:
m=list(i for i in range(n))
o=""
for j in range(1,n+1):
o+=" "+str(j)
o=o[1:]
for i in range(d):
print(o)
exit()
if d==1:
print('-1')
exit()
if d>=n:
m=list("1" for i in range(n))
for i in range(n):
m[i]="2"
#print(m)
o=str(m[0])
for j in range(1,n):
o+=" "+str(m[j])
print(o)
#m[i]="1"
for i in range(n,d):
#print(m)
print(o)
exit()
from math import ceil, floor
tc=ceil(n/k) #days
tf=floor(n/k) #len k
if n>(k**d):
print('-1')
exit()
sc=1
for stp in range(1,d+1):
o=""
kc=0
while kc<n:
for kk in range(1,k+1):
for i in range (sc):
if kc<n:
o+=' '+str(kk)
kc+=1
else:
break
sc*=k #change from 2
print(o[1:])
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, k, d;
cin >> n >> k >> d;
int aux = 1;
for (int i = 0; i < d; ++i) {
aux *= k;
if (aux > n) break;
}
if (aux < n) {
cout << "-1\n";
return 0;
}
vector<vector<int> > ans(d, vector<int>(n));
for (int i = 0; i < n; ++i) {
int u = i;
for (int j = 0; j < d; ++j) {
ans[j][i] = (u % k) + 1;
u /= k;
}
}
for (int i = 0; i < d; ++i) {
for (int j = 0; j < n; ++j) {
cout << ans[i][j] << " ";
}
cout << "\n";
}
return 0;
}
| 9 | CPP |
n, k, d = [int(k) for k in input().split()]
base_rep = [[0 for _ in range(d)] for _ in range(n)]
if k**d < n:
print(-1)
else:
for j in range(n):
num = j
i=0
while num >= k**i:
i+=1
i-=1
#print(i)
while num:
base_rep[j-1][i] = num//k**i
num = num % k**i
i -=1
for i in range(d):
s =""
for j in range(n):
s += str(base_rep[j][i]+1) + " "
print(s) | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1010, inf = 1000000007;
const double eps = 0.000000001;
long long n, d, k, g = 1, br, a[N][N], b[N];
void iz() {
for (long long i = 1; i <= d; i++) {
for (long long j = 1; j <= n; j++) printf("%I64d ", a[i][j]);
printf("\n");
}
exit(0);
}
void calc(long long x, long long de) {
br++;
b[de] = x;
if (de == d) {
for (long long i = 1; i <= d; i++) a[i][g] = b[i];
g++;
if (g > n) iz();
return;
}
for (long long i = 1; i <= k; i++) calc(i, de + 1);
}
int main() {
scanf("%I64d %I64d %I64d", &n, &k, &d);
for (long long i = 1; i <= k; i++) calc(i, 1);
printf("-1\n");
return 0;
}
| 9 | CPP |
a = input()
b = a.split()
n = int(b[0])
k = int(b[1])
d = int(b[2])
raw = [' ']*n
if n > k**d:
print(-1)
exit()
table = [[1]*d]
p = 1
for i in range(d):
cv = 1
for j in range(n):
if j % p == 0 and j != 0:
cv = cv + 1
if cv == k+1:
cv = 1
raw[j]= str(cv)
print(' '.join(raw))
p = p * k | 9 | PYTHON3 |
# Enter your code here. Read input from STDIN. Print output to STDOUT# ===============================================================================================
# importing some useful libraries.
from __future__ import division, print_function
from fractions import Fraction
import sys
import os
from io import BytesIO, IOBase
from itertools import *
import bisect
from heapq import *
from math import ceil, floor
from copy import *
from collections import deque, defaultdict
from collections import Counter as counter # Counter(list) return a dict with {key: count}
from itertools import combinations # if a = [1,2,3] then print(list(comb(a,2))) -----> [(1, 2), (1, 3), (2, 3)]
from itertools import permutations as permutate
from bisect import bisect_left as bl
from operator import *
# If the element is already present in the list,
# the left most position where element has to be inserted is returned.
from bisect import bisect_right as br
from bisect import bisect
# If the element is already present in the list,
# the right most position where element has to be inserted is returned
# ==============================================================================================
# fast I/O region
BUFSIZE = 8192
from sys import stderr
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")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
if sys.version_info[0] < 3:
sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
# inp = lambda: sys.stdin.readline().rstrip("\r\n")
# ===============================================================================================
### START ITERATE RECURSION ###
from types import GeneratorType
def iterative(f, stack=[]):
def wrapped_func(*args, **kwargs):
if stack: return f(*args, **kwargs)
to = f(*args, **kwargs)
while True:
if type(to) is GeneratorType:
stack.append(to)
to = next(to)
continue
stack.pop()
if not stack: break
to = stack[-1].send(to)
return to
return wrapped_func
#### END ITERATE RECURSION ####
###########################
# Sorted list
class SortedList:
def __init__(self, iterable=[], _load=200):
"""Initialize sorted list instance."""
values = sorted(iterable)
self._len = _len = len(values)
self._load = _load
self._lists = _lists = [values[i:i + _load] for i in range(0, _len, _load)]
self._list_lens = [len(_list) for _list in _lists]
self._mins = [_list[0] for _list in _lists]
self._fen_tree = []
self._rebuild = True
def _fen_build(self):
"""Build a fenwick tree instance."""
self._fen_tree[:] = self._list_lens
_fen_tree = self._fen_tree
for i in range(len(_fen_tree)):
if i | i + 1 < len(_fen_tree):
_fen_tree[i | i + 1] += _fen_tree[i]
self._rebuild = False
def _fen_update(self, index, value):
"""Update `fen_tree[index] += value`."""
if not self._rebuild:
_fen_tree = self._fen_tree
while index < len(_fen_tree):
_fen_tree[index] += value
index |= index + 1
def _fen_query(self, end):
"""Return `sum(_fen_tree[:end])`."""
if self._rebuild:
self._fen_build()
_fen_tree = self._fen_tree
x = 0
while end:
x += _fen_tree[end - 1]
end &= end - 1
return x
def _fen_findkth(self, k):
"""Return a pair of (the largest `idx` such that `sum(_fen_tree[:idx]) <= k`, `k - sum(_fen_tree[:idx])`)."""
_list_lens = self._list_lens
if k < _list_lens[0]:
return 0, k
if k >= self._len - _list_lens[-1]:
return len(_list_lens) - 1, k + _list_lens[-1] - self._len
if self._rebuild:
self._fen_build()
_fen_tree = self._fen_tree
idx = -1
for d in reversed(range(len(_fen_tree).bit_length())):
right_idx = idx + (1 << d)
if right_idx < len(_fen_tree) and k >= _fen_tree[right_idx]:
idx = right_idx
k -= _fen_tree[idx]
return idx + 1, k
def _delete(self, pos, idx):
"""Delete value at the given `(pos, idx)`."""
_lists = self._lists
_mins = self._mins
_list_lens = self._list_lens
self._len -= 1
self._fen_update(pos, -1)
del _lists[pos][idx]
_list_lens[pos] -= 1
if _list_lens[pos]:
_mins[pos] = _lists[pos][0]
else:
del _lists[pos]
del _list_lens[pos]
del _mins[pos]
self._rebuild = True
def _loc_left(self, value):
"""Return an index pair that corresponds to the first position of `value` in the sorted list."""
if not self._len:
return 0, 0
_lists = self._lists
_mins = self._mins
lo, pos = -1, len(_lists) - 1
while lo + 1 < pos:
mi = (lo + pos) >> 1
if value <= _mins[mi]:
pos = mi
else:
lo = mi
if pos and value <= _lists[pos - 1][-1]:
pos -= 1
_list = _lists[pos]
lo, idx = -1, len(_list)
while lo + 1 < idx:
mi = (lo + idx) >> 1
if value <= _list[mi]:
idx = mi
else:
lo = mi
return pos, idx
def _loc_right(self, value):
"""Return an index pair that corresponds to the last position of `value` in the sorted list."""
if not self._len:
return 0, 0
_lists = self._lists
_mins = self._mins
pos, hi = 0, len(_lists)
while pos + 1 < hi:
mi = (pos + hi) >> 1
if value < _mins[mi]:
hi = mi
else:
pos = mi
_list = _lists[pos]
lo, idx = -1, len(_list)
while lo + 1 < idx:
mi = (lo + idx) >> 1
if value < _list[mi]:
idx = mi
else:
lo = mi
return pos, idx
def add(self, value):
"""Add `value` to sorted list."""
_load = self._load
_lists = self._lists
_mins = self._mins
_list_lens = self._list_lens
self._len += 1
if _lists:
pos, idx = self._loc_right(value)
self._fen_update(pos, 1)
_list = _lists[pos]
_list.insert(idx, value)
_list_lens[pos] += 1
_mins[pos] = _list[0]
if _load + _load < len(_list):
_lists.insert(pos + 1, _list[_load:])
_list_lens.insert(pos + 1, len(_list) - _load)
_mins.insert(pos + 1, _list[_load])
_list_lens[pos] = _load
del _list[_load:]
self._rebuild = True
else:
_lists.append([value])
_mins.append(value)
_list_lens.append(1)
self._rebuild = True
def discard(self, value):
"""Remove `value` from sorted list if it is a member."""
_lists = self._lists
if _lists:
pos, idx = self._loc_right(value)
if idx and _lists[pos][idx - 1] == value:
self._delete(pos, idx - 1)
def remove(self, value):
"""Remove `value` from sorted list; `value` must be a member."""
_len = self._len
self.discard(value)
if _len == self._len:
raise ValueError('{0!r} not in list'.format(value))
def pop(self, index=-1):
"""Remove and return value at `index` in sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
value = self._lists[pos][idx]
self._delete(pos, idx)
return value
def bisect_left(self, value):
"""Return the first index to insert `value` in the sorted list."""
pos, idx = self._loc_left(value)
return self._fen_query(pos) + idx
def bisect_right(self, value):
"""Return the last index to insert `value` in the sorted list."""
pos, idx = self._loc_right(value)
return self._fen_query(pos) + idx
def count(self, value):
"""Return number of occurrences of `value` in the sorted list."""
return self.bisect_right(value) - self.bisect_left(value)
def __len__(self):
"""Return the size of the sorted list."""
return self._len
def __getitem__(self, index):
"""Lookup value at `index` in sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
return self._lists[pos][idx]
def __delitem__(self, index):
"""Remove value at `index` from sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
self._delete(pos, idx)
def __contains__(self, value):
"""Return true if `value` is an element of the sorted list."""
_lists = self._lists
if _lists:
pos, idx = self._loc_left(value)
return idx < len(_lists[pos]) and _lists[pos][idx] == value
return False
def __iter__(self):
"""Return an iterator over the sorted list."""
return (value for _list in self._lists for value in _list)
def __reversed__(self):
"""Return a reverse iterator over the sorted list."""
return (value for _list in reversed(self._lists) for value in reversed(_list))
def __repr__(self):
"""Return string representation of sorted list."""
return 'SortedList({0})'.format(list(self))
# ===============================================================================================
# some shortcuts
mod = 1000000007
def testcase(t):
for p in range(t):
solve()
def pow(x, y, p):
res = 1 # Initialize result
x = x % p # Update x if it is more , than or equal to p
if (x == 0):
return 0
while (y > 0):
if ((y & 1) == 1): # If y is odd, multiply, x with result
res = (res * x) % p
y = y >> 1 # y = y/2
x = (x * x) % p
return res
from functools import reduce
def factors(n):
return set(reduce(list.__add__,
([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0)))
def gcd(a, b):
if a == b: return a
while b > 0: a, b = b, a % b
return a
# discrete binary search
# minimise:
# def search():
# l = 0
# r = 10 ** 15
#
# for i in range(200):
# if isvalid(l):
# return l
# if l == r:
# return l
# m = (l + r) // 2
# if isvalid(m) and not isvalid(m - 1):
# return m
# if isvalid(m):
# r = m + 1
# else:
# l = m
# return m
# maximise:
# def search():
# l = 0
# r = 10 ** 15
#
# for i in range(200):
# # print(l,r)
# if isvalid(r):
# return r
# if l == r:
# return l
# m = (l + r) // 2
# if isvalid(m) and not isvalid(m + 1):
# return m
# if isvalid(m):
# l = m
# else:
# r = m - 1
# return m
##############Find sum of product of subsets of size k in a array
# ar=[0,1,2,3]
# k=3
# n=len(ar)-1
# dp=[0]*(n+1)
# dp[0]=1
# for pos in range(1,n+1):
# dp[pos]=0
# l=max(1,k+pos-n-1)
# for j in range(min(pos,k),l-1,-1):
# dp[j]=dp[j]+ar[pos]*dp[j-1]
# print(dp[k])
def prefix_sum(ar): # [1,2,3,4]->[1,3,6,10]
return list(accumulate(ar))
def suffix_sum(ar): # [1,2,3,4]->[10,9,7,4]
return list(accumulate(ar[::-1]))[::-1]
def N():
return int(inp())
dx = [0, 0, 1, -1]
dy = [1, -1, 0, 0]
def YES():
print("YES")
def NO():
print("NO")
def Yes():
print("Yes")
def No():
print("No")
# =========================================================================================
from collections import defaultdict
def numberOfSetBits(i):
i = i - ((i >> 1) & 0x55555555)
i = (i & 0x33333333) + ((i >> 2) & 0x33333333)
return (((i + (i >> 4) & 0xF0F0F0F) * 0x1010101) & 0xffffffff) >> 24
class MergeFind:
def __init__(self, n):
self.parent = list(range(n))
self.size = [1] * n
self.num_sets = n
# self.lista = [[_] for _ in range(n)]
def find(self, a):
to_update = []
while a != self.parent[a]:
to_update.append(a)
a = self.parent[a]
for b in to_update:
self.parent[b] = a
return self.parent[a]
def merge(self, a, b):
a = self.find(a)
b = self.find(b)
if a == b:
return
if self.size[a] < self.size[b]:
a, b = b, a
self.num_sets -= 1
self.parent[b] = a
self.size[a] += self.size[b]
# self.lista[a] += self.lista[b]
# self.lista[b] = []
def set_size(self, a):
return self.size[self.find(a)]
def __len__(self):
return self.num_sets
def lcm(a, b):
return abs((a // gcd(a, b)) * b)
#
# to find factorial and ncr
# tot = 200005
# mod = 10**9 + 7
# fac = [1, 1]
# finv = [1, 1]
# inv = [0, 1]
#
# for i in range(2, tot + 1):
# fac.append((fac[-1] * i) % mod)
# inv.append(mod - (inv[mod % i] * (mod // i) % mod))
# finv.append(finv[-1] * inv[-1] % mod)
def comb(n, r):
if n < r:
return 0
else:
return fac[n] * (finv[r] * finv[n - r] % mod) % mod
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 nextline(): out("\n") # as stdout.write always print sring.
def arr1d(n, v):
return [v] * n
def arr2d(n, m, v):
return [[v] * m for _ in range(n)]
def arr3d(n, m, p, v):
return [[[v] * p for _ in range(m)] for i in range(n)]
ans=[]
def solve():
n,k,d=sep()
if n>(k**d):
print(-1)
return
cur=[1]*d
for i in range(n):
ans.append(cur.copy())
for j in range(d-1,-1,-1):
if cur[j]==k:
cur[j]=1
else:
cur[j]+=1
break
for j in range(d):
for i in range(n):
print(ans[i][j],end=" ")
print()
solve()
#testcase(int(inp())) | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool mini(T &a, T b) {
return a > b ? (a = b, true) : false;
}
template <class T>
bool maxi(T &a, T b) {
return a < b ? (a = b, true) : false;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.precision(10);
cout << fixed;
int n, k, d;
cin >> n >> k >> d;
int tmp = 1, ok = 0;
for (int i = 0; i < (int)(d); i++) {
tmp *= k;
if (tmp >= n) {
ok = 1;
break;
}
}
if (!ok)
cout << "-1";
else {
vector<vector<int> > ans(d, vector<int>(n, 0));
for (int i = 0; i < (int)(n); i++) {
int cur = i, j = 0;
while (cur) {
ans[j++][i] = cur % k;
cur /= k;
}
}
for (int i = 0; i < (int)(d); i++) {
for (int j = 0; j < (int)(n); j++) cout << ans[i][j] + 1 << ' ';
cout << "\n";
}
}
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int res[1010][1010];
int n, k, d;
int main() {
scanf("%d%d%d", &n, &k, &d);
int tmp = 1;
bool flag = 0;
for (int i = 1; i <= d; i++) {
tmp *= k;
if (tmp >= n) {
flag = 1;
break;
}
}
if (!flag) {
puts("-1");
return 0;
}
for (int i = 1; i <= n; i++) {
int num = i;
for (int j = 1; j <= d; j++) {
res[i][j] = num % k;
num /= k;
}
}
for (int i = 1; i <= d; i++) {
printf("%d", res[1][i] + 1);
for (int j = 2; j <= n; j++) {
printf(" %d", res[j][i] + 1);
}
puts("");
}
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long int k, l, d, i, n, j = 1, m, c, b;
cin >> n >> k >> d;
for (i = 0; i < d; i++) {
j *= k;
if (j > n) break;
}
if (i == d && j < n) {
cout << "-1";
return 0;
}
int a[1000][1000] = {0};
b = j / k;
for (m = 0; m < d && b > 0; m++) {
for (i = 0; i < n; i++) a[m][i] = (i / b) % k;
b /= k;
}
for (j = 0; j < d; j++) {
for (i = 0; i < n; i++) cout << a[j][i] + 1 << ' ';
cout << '\n';
}
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k, d;
cin >> n >> k >> d;
bool ok = false;
int dd = d;
long long aux = 1;
while (dd-- && !ok) {
aux *= k;
if (aux >= n) ok = true;
}
if (!ok)
cout << -1 << endl;
else {
long long pot = 1;
for (int i = 0; i < d; i++) {
for (int num = 0; num < n; num++) {
if (num) printf(" ");
printf("%lld", (((num / pot)) % k) + 1);
}
pot *= k;
if (pot > 1000000000) pot = 1000000000;
printf("\n");
}
}
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int mod = 1e9 + 7;
int n, k, d;
bool check() {
if (n <= k) return true;
long long a = 1;
for (int i = 0; i < d; i++) {
a *= k;
a %= mod;
if (a >= n) return true;
}
return n <= a;
}
vector<vector<int>> ans;
bool flag = false;
void go(vector<int>& vec) {
if (flag) return;
if (ans.size() == n) {
flag = true;
return;
}
if (vec.size() == d) {
ans.push_back(vec);
return;
}
for (int i = 1; i <= min(n, k); i++) {
vec.push_back(i);
go(vec);
vec.pop_back();
}
}
int main() {
cin >> n >> k >> d;
if (!check()) {
cout << -1 << endl;
return 0;
}
vector<int> dummy = {};
go(dummy);
for (int j = 0; j < d; j++) {
for (int i = 0; i < n; i++) {
cout << ans[i][j] << " ";
}
cout << endl;
}
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, k, d;
int a[1111][1111];
bool farm() {
int i;
if ((double)n > (pow((double)k, d))) return 0;
memset(a, 0, sizeof(a));
for (i = 0; i < n; i++) {
int x = i, j = 0;
while (x) {
a[i][j++] = x % k;
x /= k;
}
}
return 1;
}
int main() {
int i, j;
scanf("%d%d%d", &n, &k, &d);
int ans = farm();
if (ans == 0)
puts("-1");
else {
for (i = 0; i < d; i++) {
printf("%d", a[0][i] + 1);
for (j = 1; j < n; j++) {
printf(" %d", a[j][i] + 1);
}
puts("");
}
}
return 0;
}
| 9 | CPP |
def main(inp):
n, k, d = split_inp_int(inp)
sols = []
k = min(1000, k)
import itertools
source = itertools.product(*[range(1, k + 1) for __ in range(d)])
for s in source:
sols.append(s)
if len(sols) == n:
break
if len(sols) < n:
print(-1)
return
for i in range(d):
for j in range(n):
print(sols[j][i], end=" ")
print()
def split_inp_int(inp):
return list(map(int, inp().split()))
def use_fast_io():
import sys
class InputStorage:
def __init__(self, lines):
lines.reverse()
self.lines = lines
def input_func(self):
if self.lines:
return self.lines.pop()
else:
return ""
input_storage_obj = InputStorage(sys.stdin.readlines())
return input_storage_obj.input_func
from collections import Counter, defaultdict
from functools import reduce
import operator
import math
def product(arr_):
return reduce(operator.mul, arr_, 1)
if __name__ == "__main__":
main(use_fast_io())
| 9 | PYTHON3 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
int a[1005][1005];
int main() {
int N, K, D, i, j;
loop:
while (~scanf("%d%d%d", &N, &K, &D)) {
memset(a, 0, sizeof(a));
for (j = 0; j < N; ++j) {
a[D - 1][j] = j;
}
for (i = D - 1; i > 0; --i) {
for (j = 0; j < N; ++j) {
a[i - 1][j] += a[i][j] / K;
a[i][j] %= K;
}
}
for (i = 0; i < D; ++i) {
for (j = 0; j < N; ++j) {
if (a[i][j] >= K) {
puts("-1");
goto loop;
}
}
}
for (i = 0; i < D; ++i) {
for (j = 0; j < N; ++j) {
printf("%d%s", a[i][j] + 1, j == N - 1 ? "\n" : " ");
}
}
}
return 0;
}
| 9 | CPP |
import time,math,bisect,sys
sys.setrecursionlimit(100000)
from sys import stdin,stdout
from collections import deque
from fractions import Fraction
from collections import Counter
from collections import OrderedDict
pi=3.14159265358979323846264338327950
def II(): # to take integer input
return int(stdin.readline())
def IO(): # to take string input
return stdin.readline()
def IP(): # to take tuple as input
return map(int,stdin.readline().split())
def L(): # to take list as input
return list(map(int,stdin.readline().split()))
def P(x): # to print integer,list,string etc..
return stdout.write(str(x)+"\n")
def PI(x,y): # to print tuple separatedly
return stdout.write(str(x)+" "+str(y)+"\n")
def lcm(a,b): # to calculate lcm
return (a*b)//gcd(a,b)
def gcd(a,b): # to calculate gcd
if a==0:
return b
elif b==0:
return a
if a>b:
return gcd(a%b,b)
else:
return gcd(a,b%a)
def readTree(): # to read tree
v=int(input())
adj=[set() for i in range(v+1)]
for i in range(v-1):
u1,u2=In()
adj[u1].add(u2)
adj[u2].add(u1)
return adj,v
def bfs(adj,v): # a schema of bfs
visited=[False]*(v+1)
q=deque()
while q:
pass
def sieve():
li=[True]*1000001
li[0],li[1]=False,False
for i in range(2,len(li),1):
if li[i]==True:
for j in range(i*i,len(li),i):
li[j]=False
prime=[]
for i in range(1000001):
if li[i]==True:
prime.append(i)
return prime
def setBit(n):
count=0
while n!=0:
n=n&(n-1)
count+=1
return count
#####################################################################################
mx=10**9+7
def solve():
n,k,d=IP()
if n>pow(k,d):
print(-1)
return
else:
li=[[0 for j in range(n)] for i in range(d)]
student=0
for i in range(1,n):
for j in range(d):
li[j][i]=li[j][i-1]
for j in range(d):
li[j][i]=(li[j][i]+1)%k
if li[j][i]:
break
for i in range(d):
for j in range(n):
print(int(li[i][j])+1,end=" ")
print()
return
#t=II()
#for i in range(t):
solve()
#######
#
#
####### # # # #### # # #
# # # # # # # # # # #
# #### # # #### #### # #
###### # # #### # # # # # | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int size = 1000;
int res[size + 10][size + 10];
int main() {
bool flag;
int n, k, d, temp;
while (cin >> n >> k >> d) {
temp = 1;
flag = true;
for (int i = 1; i <= d; ++i) {
temp *= k;
if (n <= temp) {
flag = false;
break;
}
}
if (flag) {
cout << -1 << endl;
} else {
memset(res, 0, sizeof(res));
for (int i = 1; i < n; ++i) {
for (int j = 0; j < d; ++j) {
res[i][j] = res[i - 1][j];
}
for (int j = d - 1; j >= 0; --j) {
res[i][j] = (res[i][j] + 1) % k;
if (res[i][j]) break;
}
}
for (int i = 0; i < d; ++i) {
for (int j = 0; j < n; ++j) {
cout << res[j][i] + 1 << " \n"[j == n - 1];
}
}
}
}
return 0;
}
| 9 | CPP |
#!/usr/bin/env python3
import io
import os
import sys
input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
def printd(*args, **kwargs):
#print(*args, **kwargs, file=sys.stderr)
#print(*args, **kwargs)
pass
def get_str():
return input().decode().strip()
def rint():
return map(int, input().split())
def oint():
return int(input())
def conv(i):
ret = [1]*d
for ii in range(d):
ret[ii] = i%k + 1
i //= k
if i == 0:
break
return ret
n, k, d = rint()
printd(n,k,d)
if k**d < n:
print(-1)
exit()
ans = [[0 for i in range(n)] for j in range(d)]
ans1 = []
for i in range(n):
ans1.append(conv(i))
printd(ans)
printd(ans1)
for i in range(d):
for j in range(n):
ans[i][j] = ans1[j][i]
for i in range(d):
print(*ans[i]) | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int students[1100][1100];
int main() {
bool flag = true;
int n, k, d, tmp = 1;
cin >> n >> k >> d;
for (int i = 0; i < d && flag; i++) {
tmp *= k;
if (tmp >= n) flag = false;
}
if (flag)
cout << "-1 \n";
else {
for (int i = 1; i < n; i++) {
int tmp = 1;
for (int j = 0; j < d; j++) {
students[i][j] = students[i - 1][j] + tmp;
if (students[i][j] >= k)
students[i][j] = 0;
else
tmp = 0;
}
}
for (int i = 0; i < d; i++) {
for (int j = 0; j < n; j++) cout << students[j][i] + 1 << ' ';
cout << endl;
}
}
}
| 9 | CPP |
import sys
input = sys.stdin.readline
I = lambda : list(map(int,input().split()))
n,k,d = I()
st=0;ct=0
if n<=k:
for i in range(d):
for j in range(n):
print(j+1,end=" ")
print("")
exit()
an=[[0]*n for i in range(d)]
tp=1;s=0
for i in range(d):
tp*=k
if tp>=n:
s=1;break
if s:
st=0
def conv(x):
p=[]
while x:
p.append(x%k)
x//=k
p=[0]*(d-len(p))+p[::-1]
return p
for i in range(n):
s=conv(st)
for j in range(d-1,-1,-1):
an[j][i]=s[j]+1
st+=1
for i in range(d):
print(*an[i])
else:
print(-1) | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k, d, x;
cin >> n >> k >> d;
int i, j;
x = 1;
for (i = 0; i < d && x < n; ++i) {
x = x * k;
}
if (x < n) {
printf("-1\n");
return 0;
}
x /= k;
x = max(1LL, x);
int c = 0;
for (i = 0; i < d; ++i) {
c = -1;
for (j = 0; j < n; ++j) {
if (j % x == 0) {
c = (c + 1) % k;
}
printf("%d ", c + 1);
}
putchar('\n');
x = max(1LL, x / k);
}
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, d, k;
bool b() {
if (n <= 1) return true;
if (d == 1) return false;
if (k == 1) return false;
return true;
}
int x[2000][2000];
inline bool f(int lev, long long k) {
long long den = 1;
for (int i = 0; i < lev; i++) {
den = den * k;
if (den > n) break;
}
int w = -1;
for (long long i = 0; i < n; i++) {
if (i % den == 0) {
w = (w + 1) % k;
}
x[lev][i] = w;
}
}
bool g() {
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
bool w = 1;
for (int p = 0; p < d && w; p++) {
if (x[p][i] != x[p][j]) w = 0;
}
if (w) return 1;
}
}
return false;
}
int main() {
while (cin >> n >> k >> d) {
int s = 0;
if (k >= n) {
for (int p = 0; p < d; p++) {
for (int i = 0; i < n; i++) {
x[p][i] = i;
}
}
} else {
for (int p = 0; p < d; p++) {
f(p, k);
}
}
if (g()) {
printf("-1\n");
return 0;
}
stringstream ss;
for (int p = 0; p < d; p++) {
for (int i = 0; i < n; i++) {
ss << x[p][i] + 1 << (i < n - 1 ? ' ' : '\n');
}
}
cout << ss.str();
return 0;
}
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int res[1005][1005];
int main() {
int n, k, d, i, j;
while (cin >> n >> k >> d) {
int flag = 0;
int t = 1;
for (i = 0; i < d; i++) {
t *= k;
if (t >= n) {
flag = 1;
break;
}
}
if (flag == 0) {
puts("-1");
} else {
for (j = 0; j < n; j++) {
for (i = 0; i < d; i++) {
if (j == 0)
res[i][j] = 1;
else
res[i][j] = res[i][j - 1];
}
if (j == 0) continue;
res[d - 1][j]++;
for (i = d - 1; i >= 0; i--) {
if (res[i][j] > k) {
res[i][j] %= k;
res[i - 1][j]++;
} else
break;
}
}
for (i = 0; i < d; i++) {
for (j = 0; j < n; j++) {
printf("%d ", res[i][j]);
}
printf("\n");
}
}
return 0;
}
}
| 9 | CPP |
n,k,d=map(int,input().split())
if n>k**d:print(-1);exit(0)
K=1
for j in range(d):
print(" ".join([str(i//K%k +1) for i in range(n)]))
K*=k | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, d, k;
int ans[1100][1100];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k >> d;
long long int temp = 1;
bool check = false;
for (int i = 0; i < d; i += 1) {
temp *= k;
if (temp >= n) {
check = true;
break;
}
}
if (check == false) {
cout << "-1" << endl;
return 0;
}
for (int i = 1; i < n; i += 1) {
for (int j = 0; j < d; j += 1) {
ans[i][j] = ans[i - 1][j];
for (int j = d - 1; j >= 0; j -= 1) {
ans[i][j] = (ans[i][j] + 1) % k;
if (ans[i][j]) {
break;
}
}
}
}
for (int i = 0; i < d; i += 1) {
for (int j = 0; j < n; j += 1) {
cout << ans[j][i] + 1 << " ";
}
cout << endl;
}
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int dcmp(double x, double y) {
return fabs(x - y) <= 1e-8 ? 0 : x < y ? -1 : 1;
}
int n, k, d, nk = 1;
set<vector<int> > second;
vector<int> v;
void solve(int l) {
if (second.size() == n) return;
if (l == d) return void(second.insert(v));
for (int i = 1; i <= nk; i++) {
v.push_back(i);
solve(l + 1);
v.pop_back();
}
}
int ans[1005][1005];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> k >> d;
if (dcmp(d * log(k), log(n)) < 0) return cout << -1, 0;
while (dcmp(d * log(nk), log(n)) < 0) nk++;
solve(0);
int i = 0;
for (auto x : second) {
for (int j = 0; j < d; j++) ans[j][i] = x[j];
i++;
}
for (int i = 0; i < d; i++, cout << '\n')
for (int j = 0; j < n; j++) cout << ans[i][j] << " ";
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long int n, k, d;
bool pw() {
long long int i, res = 1;
for (i = 0; i < d; i++) {
res *= k;
if (res >= n) return true;
}
return false;
}
int main() {
ios::sync_with_stdio(0);
long long int i, j, x, y, temp;
cin >> n >> k >> d;
long long int result[n][d];
if (!pw()) {
cout << -1 << "\n";
} else {
for (i = 0; i < d; i++) result[0][i] = 1;
for (i = 1; i < n; i++) {
copy(result[i - 1], result[i - 1] + d, result[i]);
result[i][d - 1]++;
temp = d - 1;
while (result[i][temp] == k + 1) {
result[i][temp] = 1;
temp--;
result[i][temp]++;
}
}
for (i = 0; i < d; i++) {
for (j = 0; j < n; j++) {
cout << result[j][i] << "\t";
}
cout << "\n";
}
}
return 0;
}
| 9 | CPP |
#!/usr/bin/python3
import sys
# 1 <= n, d <= 1000, 1 <= k <= 10**9
n, k, d = map(int, sys.stdin.readline().split())
no_sol = False
solution = [[1 for j in range(n)] for i in range(d)]
def schedule(i, j, level):
global no_sol
if level >= d:
no_sol = True
return
count = j - i
chunk = count // k
extra = count % k
r = i
for t in range(min(k, count)):
size = chunk + (1 if t < extra else 0)
for z in range(size):
solution[level][r+z] = t+1
if size > 1:
schedule(r, r + size, level + 1)
r += size
if k == 1:
if n > 1:
no_sol = True
else:
schedule(0, n, 0)
if no_sol:
print(-1)
else:
for l in solution:
print(' '.join(str(x) for x in l))
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T in() {
char ch;
T n = 0;
bool ng = false;
while (1) {
ch = getchar();
if (ch == '-') {
ng = true;
ch = getchar();
break;
}
if (ch >= '0' && ch <= '9') break;
}
while (1) {
n = n * 10 + (ch - '0');
ch = getchar();
if (ch < '0' || ch > '9') break;
}
return (ng ? -n : n);
}
template <typename T>
inline T POW(T B, T P) {
if (P == 0) return 1;
if (P & 1)
return B * POW(B, P - 1);
else
return (POW(B, P / 2) * POW(B, P / 2));
}
template <typename T>
inline T Gcd(T a, T b) {
if (a < 0) return Gcd(-a, b);
if (b < 0) return Gcd(a, -b);
return (b == 0) ? a : Gcd(b, a % b);
}
template <typename T>
inline T Lcm(T a, T b) {
if (a < 0) return Lcm(-a, b);
if (b < 0) return Lcm(a, -b);
return a * (b / Gcd(a, b));
}
long long Bigmod(long long base, long long power, long long MOD) {
long long ret = 1;
while (power) {
if (power & 1) ret = (ret * base) % MOD;
base = (base * base) % MOD;
power >>= 1;
}
return ret;
}
bool isVowel(char ch) {
ch = toupper(ch);
if (ch == 'A' || ch == 'U' || ch == 'I' || ch == 'O' || ch == 'E')
return true;
return false;
}
template <typename T>
long long int isLeft(T a, T b, T c) {
return (a.x - b.x) * (b.y - c.y) - (b.x - c.x) * (a.y - b.y);
}
long long ModInverse(long long number, long long MOD) {
return Bigmod(number, MOD - 2, MOD);
}
bool isConst(char ch) {
if (isalpha(ch) && !isVowel(ch)) return true;
return false;
}
int toInt(string s) {
int sm;
stringstream second(s);
second >> sm;
return sm;
}
vector<vector<int> > A;
int d, n, k;
void Dekhi(vector<int> v, int ln) {
if (A.size() == n) return;
if (ln == d) {
A.push_back(v);
return;
}
for (int i = 1; i < k + 1; i++) {
vector<int> tp = v;
tp.push_back(i);
Dekhi(tp, ln + 1);
if (A.size() == n) {
break;
}
}
}
int main() {
n = in<int>(), k = in<int>(), d = in<int>();
vector<int> v;
Dekhi(v, 0);
if (A.size() < n) {
return 0 * puts("-1");
}
for (int i = 0; i < d; i++) {
for (int j = 0; j < A.size(); j++) {
printf("%d ", A[j][i]);
}
printf("\n");
}
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long n, k, d;
long long a[10000];
long long ans[1005][1005];
long long ppow(long long a, long long k) {
long long ans = 1;
for (int i = 1; i <= k; i++) ans *= a;
return ans;
}
int main() {
cin >> n >> k >> d;
int s = 1;
bool flag = 0;
for (int i = 1; i <= d; i++) {
s *= k;
if (s >= n) {
flag = 1;
break;
}
}
if (flag == 0)
puts("-1");
else {
for (int y = 2; y <= n; y++) {
for (int x = 1; x <= d; x++) ans[x][y] = ans[x][y - 1];
for (int x = 1; x <= d; x++) {
ans[x][y] = (ans[x][y] + 1) % k;
if (ans[x][y]) break;
}
}
for (int i = 1; i <= d; i++, cout << endl)
for (int j = 1; j <= n; j++) cout << ans[i][j] + 1 << " ";
}
}
| 9 | CPP |
#include <bits/stdc++.h>
int main() {
int n, k, d;
int r[1000][1000] = {};
std::scanf("%d%d%d", &n, &k, &d);
for (int i(1); i < n; ++i) {
std::memcpy(r[i], r[i - 1], sizeof(r[0]));
r[i][0]++;
for (int j(0); j < d - 1; ++j) {
if (r[i][j] < k) break;
r[i][j] = 0, r[i][j + 1]++;
}
}
if (r[n - 1][d - 1] < k) {
for (int j(0); j < d; ++j) {
for (int i(0); i < n; ++i) {
if (0 < i) std::printf(" ");
std::printf("%d", r[i][j] + 1);
}
std::puts("");
}
} else {
std::puts("-1");
}
return 0;
}
| 9 | CPP |
#http://codeforces.com/problemset/problem/459/C
# Input of the values
n, k, d = map(int, input().split())
#Convention : Busses are numbered from 1 to k
# Students are numbered from 0 to k - 1
# Days are numbered from 0 to k - 1
# Variable for success
success = True
# answer is a 2-d array that stores the bus number each student used on a particular day
# Students are numbered from 0 to n-1
answer = [[] for x in range(n)]
# Initialising the first students details manually
# The first student uses the bus 1 for all of the days
answer[0] = [1 for x in range(d)]
# we will be filling the details for each and every student and
# would print -1 only if we cannot allot any bus number to the next student
for i_th_student in range(1,n):
#answer for previous value
i_minus_one_student = answer[i_th_student - 1]
# Answer to the current student
current_student = list(i_minus_one_student)
# Days are also numbered from 0 to d-1
for i_th_day in reversed(range(d)):
# the condition to change the bus number
if i_minus_one_student[i_th_day] < k :
current_student[i_th_day] += 1
# all the numbers next to it are reset
for i in range(i_th_day + 1, d):
current_student[i] = 1
break
#Save the value
answer[i_th_student] = current_student
#Failed
if current_student == i_minus_one_student:
success = False
break
# printing the output
if not(success):
print ("-1")
else:
# ans_trans is used for giving the output fast
answer_trans= [[] for i in range(d)]
for y in range(n):
i = 0
for x in answer[y]:
answer_trans[i].append(x)
i += 1
for bla in answer_trans:
print (' '.join(map(str, bla)))
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
bool binpow(long long a, long long n, long long c) {
long long b = 1;
while (n > 0) {
if (n & 1) b *= a;
a *= a;
n >>= 1;
if (b >= c) return true;
if (a >= c && n != 0) return true;
}
return false;
}
long long binpow1(long long a, long long n) {
long long b = 1;
while (n > 0) {
if (n & 1) b *= a;
a *= a;
n >>= 1;
if (b >= 1000) return 1000;
if (a >= 1000 && n != 0) return 1000;
}
return b;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long n, k, d;
int res[1100][1100];
void solve() {
cin >> n >> k >> d;
if (!binpow(k, d, n)) {
cout << "-1\n";
return;
}
long long p = 0;
for (int i = 1; i <= d; i++) {
p = binpow1(k, d - i);
int j = 1;
int z = 1;
while (j <= n) {
for (int l = 0; l < p; l++, j++) res[i][j] = z;
z++;
if (z == k + 1) z = 1;
}
}
for (int i = 1; i <= d; i++) {
for (int j = 1; j <= n; j++) cout << res[i][j] << " ";
cout << endl;
}
}
int main() {
ios_base::sync_with_stdio(0);
solve();
return 0;
}
| 9 | CPP |
#!/usr/bin/python3
import sys
n, k, d = list(map(int, sys.stdin.readline().split()))
x = 1
while x ** d < n:
x += 1
if x > k:
sys.stdout.write("-1\n")
sys.exit(0)
ans = [[1 for i in range(n)] for j in range(d)]
for i in range(1, n):
for j in range(d):
ans[j][i] = ans[j][i - 1]
ans[d - 1][i] += 1
memo = 0
for j in range(d - 1, -1, -1):
ans[j][i] += memo
memo = 0
if ans[j][i] > x:
memo = ans[j][i] - x
ans[j][i] = 1
for i in range(d):
sys.stdout.write(' '.join(map(str, ans[i])) + '\n') | 9 | PYTHON3 |
import sys
def no():
print(-1)
sys.exit(0)
n, k, d = map(int, input().split())
if n <= k:
for i in range(d):
print(' '.join(map(str, range(1, n + 1))))
elif d == 1:
no()
elif k == 1:
no()
else:
cur_step = 1
arrangement = []
while 1 + cur_step <= n:
arrangement.append([])
idx = 0
for i in range(1, n + 1):
arrangement[-1].append(idx + 1)
if i % cur_step == 0:
idx = (idx + 1) % k
cur_step *= k
if len(arrangement) > d:
no()
while len(arrangement) < d:
arrangement.append([1] * n)
print('\n'.join(map(lambda x: ' '.join(map(str, x)), arrangement)))
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, k, d;
void genPer() {
long long int ii = 1;
for (int i = 1; i <= d; i++) {
for (int j = 1, b = 1; j <= n;) {
if (b > k) b = 1;
printf("%d", b);
j++;
for (int c = 1; c < ii && j <= n; c++) {
printf(" %d", b);
j++;
}
if (j <= n) printf(" ");
b++;
}
printf("\n");
ii *= k;
}
}
int main() {
scanf("%d %d %d", &n, &k, &d);
if (log(n) / log(k) - (double)d > 1e-9) {
printf("-1\n");
} else {
genPer();
}
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
double pi = 3.141592653589793238;
const int M = 1e9 + 7;
const int Nmax = 5005;
const int MM = 1e7 + 1;
const int N = 300010;
int a[1005][1005], v[1005];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int T = 1;
while (T--) {
int i, j, n, k, d, ok;
cin >> n >> k >> d;
ok = 1;
for (i = 1; i <= d; ++i) v[i] = 1;
for (i = 1; i <= n && ok; ++i) {
for (j = 1; j <= d; ++j) a[i][j] = v[j];
for (j = d; j && v[j] == k; --j)
;
if (!j && i != n) ok = 0;
++v[j];
for (++j; j <= d; ++j) v[j] = 1;
}
if (!ok)
cout << "-1\n";
else {
for (int i = 1; i <= d; i++) {
for (int j = 1; j <= n; j++) {
cout << a[j][i] << " ";
}
cout << "\n";
}
}
}
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int n, k, d;
cin >> n >> k >> d;
vector<vector<int> > answer(n, vector<int>(d));
long long base = 1;
for (int i = 0; i < d; ++i) {
for (int j = 0; j < n; ++j) {
answer[j][i] = (j / base) % k + 1;
}
base = min<long long>(base * k, n);
}
sort(answer.begin(), answer.end());
bool accept = true;
for (int i = 0; i + 1 < n; ++i) {
if (answer[i] == answer[i + 1]) {
accept = false;
}
}
if (!accept) {
cout << -1 << endl;
return 0;
}
for (int i = 0; i < d; ++i) {
for (int j = 0; j < n; ++j) {
if (j != 0) {
cout << " ";
}
cout << answer[j][i];
}
cout << endl;
}
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, k, d;
int check(int n) {
int sum = 0;
while (n != 1) {
n = (n + k - 1) / k;
sum++;
}
return sum;
}
int main() {
scanf("%d%d%d", &n, &k, &d);
if (k == 1) {
if (n == 1)
for (int i = 1; i <= d; i++) puts("1");
else
puts("-1");
return 0;
}
int mx = check(n);
if (mx > d)
puts("-1");
else {
int step = 1;
for (int j = 1; j <= mx; j++) {
step *= k;
int big = (j - 1) % k + 1;
int p = big;
printf("%d", p);
for (int i = 2; i <= n; i++) {
if (i % step == 1) {
big = big % k + 1;
p = big;
} else
p = p % k + 1;
printf(" %d", p);
}
printf("\n");
}
for (int i = mx + 1; i <= d; i++) {
puts("1");
for (int j = 2; j <= n; j++) printf(" %d", 1);
printf("\n");
}
}
return 0;
}
| 9 | CPP |
n, k, d = map(int, input().split())
bits = n
for i in range(d):
bits = bits//k + (bits % k != 0)
if bits > 1:
print("-1")
exit()
for _ in range(d):
i = 0
res = 1
while i < n:
for j in range(bits):
print(res, end=' ')
i += 1
if i == n:
break
res += 1
if res > k:
res = 1
bits *= k
print() | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, k, d;
cin >> n >> k >> d;
long long res = 1;
bool ok = false;
for (int i = 0; i < d; i++) {
res *= k;
if (res >= n) {
ok = true;
break;
}
}
if (!ok) {
cout << -1 << '\n';
return 0;
}
vector<vector<int>> ans(d, vector<int>(n));
for (int i = 0; i < n; i++) {
int top = 0;
int cur = i;
while (cur > 0) {
ans[top++][i] = cur % k;
cur /= k;
}
}
for (int i = 0; i < d; i++) {
for (int j = 0; j < n; j++) {
cout << ans[i][j] + 1 << ' ';
}
cout << '\n';
}
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
void dbg_out() { cerr << "\b\b]\n"; }
template <typename Head, typename... Tail>
void dbg_out(Head H, Tail... T) {
cerr << H << ", ";
dbg_out(T...);
}
const int N = 1002;
vector<vector<int>> ans(N, vector<int>(N, -1));
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n, k, d;
cin >> n >> k >> d;
if (k >= n) {
for (int i = 1; i <= d; ++i) {
for (int j = 1; j <= n; ++j) {
cout << j << ' ';
}
cout << '\n';
}
return 0;
}
bool ok = true;
function<void(int, int, int, int)> go = [&](int l, int r, int bus, int d) {
if (d < 0) return;
if (d == 1) {
if (r - l + 1 > 1) {
ok = false;
return;
}
}
for (int i = l; i <= r; ++i) {
ans[d][i] = bus;
}
int rem = (r - l + 1) % k;
int segment = (r - l + 1) / k;
if (segment) {
int curr = l;
for (int i = 1; i <= k; ++i) {
int y = curr + segment + (i <= rem) - 1;
go(curr, y, i, d - 1);
curr = y + 1;
}
} else {
for (int i = 0; i < rem; ++i) {
go(l + i, l + i, i + 1, d - 1);
}
}
};
int l = 1, r = n;
int rem = (r - l + 1) % k;
int segment = (r - l + 1) / k;
int curr = 1;
for (int i = 1; i <= k; ++i) {
int y = curr + segment + (i <= rem) - 1;
go(curr, y, i, d);
curr = y + 1;
}
if (!ok) {
cout << -1;
return 0;
}
for (int i = d; i >= 1; --i) {
for (int j = 1; j <= n; ++j) {
cout << ans[i][j] << ' ';
}
cout << '\n';
}
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int nxt() {
int res;
scanf("%d", &res);
return res;
}
inline void solve() {
int n = nxt();
int k = nxt();
int d = nxt();
vector<vector<int> > ans;
ans.push_back(vector<int>(d, 0));
while (int(ans.size()) < n) {
vector<int> q = ans.back();
int add = 1;
for (int i = 0; i < d && add; ++i) {
q[i] += add;
add = 0;
if (q[i] >= k) {
q[i] -= k;
add = 1;
}
}
if (add) {
break;
}
ans.push_back(q);
}
if (int(ans.size()) != n) {
cout << "-1\n";
return;
}
for (int i = 0; i < d; ++i) {
for (int j = 0; j < n; ++j) {
cout << ans[j][i] + 1 << " ";
}
cout << "\n";
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
solve();
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
int t = 1;
while (t--) {
long long n, k, d;
cin >> n >> k >> d;
long long cn = 1;
int p = 0;
while (cn < n && p < d) {
cn *= k;
p++;
}
int arr[n][d];
if (cn < n) {
cout << "-1\n";
return 0;
} else {
for (int i = 0; i < n; i++) {
int crr = i;
for (int j = d - 1; j >= 0; j--) {
arr[i][j] = crr % k + 1;
crr /= k;
}
}
for (int i = 0; i < d; i++) {
for (int j = 0; j < n; j++) {
cout << arr[j][i] << " ";
}
cout << "\n";
}
}
return 0;
}
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int abs(int a) {
if (a < 0) a = -a;
return a;
}
long long n, k, d;
vector<int> b[1111];
void pro(int num) {
b[num].clear();
int x = num;
for (int i = 1; i <= d; i++) b[num].push_back(x % k + 1), x /= k;
}
int main() {
cin >> n >> k >> d;
long long cnt = 1;
for (int i = 1; i <= d; i++) {
cnt *= k;
if (cnt > n) break;
}
if (cnt >= n) {
for (int i = 1; i <= (n); i++) pro(i);
for (int i = 0; i < d; i++) {
for (int j = 1; j <= n; j++) {
if (j != 1) cout << " ";
printf("%d", b[j][i]);
}
cout << endl;
}
} else
puts("-1");
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int a[100005], b[100005], ansx, ansy, n, qst, qed, now, ansk, x, y, l;
bool find(int nx, int t) {
qst = 1;
qed = 1;
now = b[1];
while (qst <= n) {
if (now == nx) {
if (t == 0)
return 1;
else {
if (a[qed] - x >= 0 || a[qed] + y <= l) return 1;
}
}
if (qed < qst && now > nx) {
now -= b[qed];
qed++;
} else {
qst++;
now += b[qst];
}
}
return 0;
}
int main() {
int i, j, m;
scanf("%d%d%d%d", &n, &l, &x, &y);
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
b[i - 1] = a[i] - a[i - 1];
}
n--;
if (!find(x, 0)) ansx++;
if (!find(y, 0)) ansy++;
if (x == y && ansx) {
printf("%d\n%d\n", 1, x);
} else if (x != y && ansx && ansy) {
if (find(x + y, 0)) ansk++;
if (ansk) {
printf("1\n%d\n", x + a[qed]);
} else {
if (find(y - x, 1)) ansk++;
if (ansk) {
printf("1\n");
if (a[qed] - x >= 0)
printf("%d\n", a[qed] - x);
else
printf("%d\n", a[qed] + y);
} else
printf("2\n%d %d\n", x, y);
}
} else {
if (ansx + ansy == 2) {
printf("2\n%d %d\n", x, y);
} else {
printf("%d\n", ansx + ansy);
if (ansx) printf("%d\n", x);
if (ansy) printf("%d\n", y);
}
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
map<long long, bool> m;
int n, l;
long long x, y;
int s = -1;
int main() {
ios::sync_with_stdio(false);
bool f1 = false, f2 = false;
cin >> n >> l >> x >> y;
for (int i = 1; i <= n; i++) {
long long t;
cin >> t;
m[t] = true;
if (t - x >= 0)
if (m[t - x]) f1 = true;
if (t - y >= 0)
if (m[t - y]) f2 = true;
if (t >= y && t - y + x >= 0 && m[t - y + x]) {
s = t - y;
}
if (t < y && t - y + x >= 0 && m[t - y + x]) {
if (t + x <= l) s = t + x;
}
if (t >= x + y && m[t - x - y]) s = t - x;
if (m[x]) f1 = true;
if (m[y]) f2 = true;
}
int res = (!f1) + (!f2);
if (res == 2) {
if (s != -1) {
cout << 1 << endl;
cout << s << " ";
return 0;
}
}
cout << res << endl;
if (!f1) cout << x << " ";
if (!f2) cout << y << " ";
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
int aa[100000], n;
int find(int x) {
int i, j;
for (i = 0, j = 0; i < n; i++) {
while (j < n && aa[j] - aa[i] < x) j++;
if (j < n && aa[j] - aa[i] == x) return i;
}
return -1;
}
int main() {
int l, x, y, i, ix, iy, j, tmp;
scanf("%d%d%d%d", &n, &l, &x, &y);
for (i = 0; i < n; i++) scanf("%d", &aa[i]);
ix = find(x);
iy = find(y);
if (ix != -1 && iy != -1) {
printf("0\n");
return 0;
}
if (ix != -1) {
printf("1\n");
printf("%d\n", y);
return 0;
}
if (iy != -1) {
printf("1\n");
printf("%d\n", x);
return 0;
}
i = find(x + y);
if (i != -1) {
printf("1\n");
printf("%d\n", aa[i] + x);
return 0;
}
i = find(y - x);
if (i != -1 && aa[i] + y <= l) {
printf("1\n");
printf("%d\n", aa[i] + y);
return 0;
}
for (i = 0, j = n - 1; i < j; i++, j--)
tmp = aa[i], aa[i] = aa[j], aa[j] = tmp;
for (i = 0; i < n; i++) aa[i] = l - aa[i];
i = find(y - x);
if (i != -1 && aa[i] + y <= l) {
printf("1\n");
printf("%d\n", l - (aa[i] + y));
return 0;
}
printf("2\n");
printf("%d %d\n", x, y);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200000 + 10;
const long long INF = 1e18 + 7;
const int MOD = 1e9 + 7;
const double eps = 1e-10;
const double pi = acos(-1);
int T, cases, n, m, t;
set<int> s;
int a[maxn];
int main() {
ios::sync_with_stdio(false);
;
int x, y;
cin >> n >> m >> x >> y;
for (int i = 1; i <= n; i++) cin >> a[i], s.insert(a[i]);
bool ans1 = 0, ans2 = 0;
for (int i = 1; i <= n; i++) {
if (s.count(a[i] - x) || s.count(a[i] + x)) ans1 = 1;
if (s.count(a[i] - y) || s.count(a[i] + y)) ans2 = 1;
}
if (ans1 && ans2)
cout << "0" << endl;
else if (ans1)
cout << "1\n" << y << endl;
else if (ans2)
cout << "1\n" << x << endl;
else {
for (int i = 1; i <= n; i++) {
int tmp = a[i] + x;
if (tmp <= m && (s.count(tmp - y) || s.count(tmp + y))) {
cout << "1\n" << tmp << endl;
return 0;
}
tmp = a[i] - x;
if (tmp >= 0 && (s.count(tmp - y) || s.count(tmp + y))) {
cout << "1\n" << tmp << endl;
return 0;
}
tmp = a[i] + y;
if (tmp <= m && (s.count(tmp - x) || s.count(tmp + x))) {
cout << "1\n" << tmp << endl;
return 0;
}
tmp = a[i] - y;
if (tmp >= 0 && (s.count(tmp - x) || s.count(tmp + x))) {
cout << "1\n" << tmp << endl;
return 0;
}
}
cout << "2\n" << x << " " << y << endl;
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int arr[(int)2e5 + 10];
int n, l, x, y;
map<int, int> mp;
int fnd(int num) { return (mp.count(num) > 0 && num >= 0 && num <= l); }
int main() {
scanf("%d %d", &n, &l);
scanf("%d %d", &x, &y);
int a, b, c, d, ans = -1;
for (int i = 0; i < n; i++) {
scanf("%d", &arr[i]);
mp[arr[i]] = 1;
}
int mn = 3;
bool foundx = 0, foundy = 0;
for (int i = 0; i < n; i++) {
a = fnd(arr[i] + x);
b = fnd(arr[i] + y);
c = fnd(arr[i] - x);
d = fnd(arr[i] - y);
if (a || c) foundx = 1;
if (b || d) foundy = 1;
if (ans == -1) {
if (fnd(arr[i] + x + y)) ans = arr[i] + x;
if (arr[i] + x <= l && fnd(arr[i] + x - y)) ans = arr[i] + x;
if (arr[i] + x <= l && fnd(arr[i] + x + y)) ans = arr[i] + x;
if (arr[i] - x >= 0 && fnd(arr[i] - x - y)) ans = arr[i] - x;
if (arr[i] - x >= 0 && fnd(arr[i] - x + y)) ans = arr[i] - x;
}
if (foundx && foundy) {
mn = 0;
break;
}
}
if (foundx && foundy)
printf("%d\n", 0);
else if (ans != -1) {
printf("%d\n", 1);
printf("%d\n", ans);
} else if (foundx) {
printf("%d\n", 1);
printf("%d\n", y);
} else if (foundy) {
printf("%d\n", 1);
printf("%d\n", x);
} else {
printf("%d\n", 2);
printf("%d %d\n", x, y);
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
set<int> arr;
int main() {
int n, l, x, y;
cin >> n >> l >> x >> y;
for (int i = 0; i < n; i++) {
int v;
cin >> v;
arr.insert(v);
}
bool f1, f2, f3, f4;
int v3, v4;
f1 = f2 = f3 = f4 = false;
int res = 2147483647;
for (auto v : arr) {
f1 |= arr.count(v + x);
f2 |= arr.count(v + y);
if (arr.count(v + x + y)) {
f3 = true;
v3 = v + x;
}
if (arr.count(v + x - y)) {
if (v - y >= 0) {
f4 = true;
v4 = v - y;
} else if (v + x <= l) {
f4 = true;
v4 = v + x;
}
}
}
if (f1 && f2)
cout << 0 << endl;
else if (f1 || f2 || f3 || f4) {
cout << 1 << endl;
if (f1)
cout << y << endl;
else if (f2)
cout << x << endl;
else if (f3)
cout << v3 << endl;
else if (f4)
cout << v4 << endl;
} else
cout << 2 << endl << x << " " << y << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
ifstream fin("in.in");
ofstream fout("out.out");
const int N = 100000 + 10;
int n, l, x, y, first[N], extra;
vector<int> ext;
set<int> s, markX, markY;
bool canX, canY;
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> l >> x >> y;
for (int i = 0; i < n; i++) {
cin >> first[i];
s.insert(first[i]);
if (s.find(first[i] - x) != s.end()) canX = true;
if (s.find(first[i] - y) != s.end()) canY = true;
}
if (canX && canY) return (cout << 0), 0;
if (canX) return (cout << 1 << endl << y), 0;
if (canY) return (cout << 1 << endl << x), 0;
for (int i = 0; i < n; i++) {
if (first[i] + x <= l) {
ext.push_back(first[i] + x);
markX.insert(first[i] + x);
}
if (first[i] + y <= l) {
ext.push_back(first[i] + y);
markY.insert(first[i] + y);
}
if (first[i] - x >= 0) {
ext.push_back(first[i] - x);
markX.insert(first[i] - x);
}
if (first[i] - y >= 0) {
ext.push_back(first[i] - y);
markY.insert(first[i] - y);
}
}
for (int i = 0; i < ext.size(); i++)
if (markX.find(ext[i]) != markX.end() && markY.find(ext[i]) != markY.end())
return (cout << 1 << endl << ext[i]), 0;
cout << 2 << endl << x << ' ' << y << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int a[100005], *t, n, l, i, s;
int solve(int x) {
for (i = 0; i < n - 1; i++) {
s = a[i] + x;
t = lower_bound(a + i, a + n, s);
if (*t == s) return 1;
}
return 0;
}
void work(int x, int y) {
for (i = 0; i < n - 1; i++) {
s = a[i] + y - x;
t = lower_bound(a + i, a + n, s);
if (*t == s) {
if (*t + x <= l) {
printf("1\n%d\n", *t + x);
break;
} else if (*t - y >= 0) {
printf("1\n%d\n", *t - y);
break;
}
}
}
if (i == n - 1) printf("2\n%d %d\n", x, y);
}
int main() {
int x, y;
while (~scanf("%d%d%d%d", &n, &l, &x, &y)) {
int flag = 0;
for (i = 0; i < n; i++) scanf("%d", &a[i]);
if (!solve(x)) flag++;
if (!solve(y)) flag += 2;
if (flag == 0)
printf("0\n");
else if (flag == 1)
printf("1\n%d\n", x);
else if (flag == 2)
printf("1\n%d\n", y);
else {
if (solve(y + x))
printf("1\n%d\n", *t - y);
else
work(x, y);
}
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
map<int, int> mp;
pair<int, int> ans;
int a[100001];
bool fx = false, fy = false;
int main() {
int n, l, x, y;
cin >> n >> l >> x >> y;
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
mp[a[i]] = 1;
}
for (int i = 0; i < n; ++i) {
if (mp.find(a[i] - x) != mp.end() || mp.find(a[i] + x) != mp.end())
fx = true;
if (mp.find(a[i] - y) != mp.end() || mp.find(a[i] + y) != mp.end())
fy = true;
if (fx && fy) {
cout << "0" << endl;
return 0;
}
}
if (fx && !fy) {
cout << "1" << endl << y << endl;
return 0;
}
if (!fx && fy) {
cout << "1" << endl << x << endl;
return 0;
}
for (int i = 0; i < n; ++i) {
if (a[i] + x <= l && mp.find(a[i] + x + y) != mp.end()) {
cout << "1" << endl << a[i] + x << endl;
return 0;
}
if (a[i] - x >= 0 && mp.find(a[i] - x + y) != mp.end()) {
cout << "1" << endl << a[i] - x << endl;
return 0;
}
if (a[i] + x <= l && mp.find(a[i] + x - y) != mp.end()) {
cout << "1" << endl << a[i] + x << endl;
return 0;
}
}
printf("2\n%d %d\n", x, y);
return 0;
}
| 8 | CPP |
def main():
from bisect import bisect_left
n, l, x, y = map(int, input().split())
aa, d = list(map(int, input().split())), {}
for z in (x, y, y + x):
for a in aa:
a += z
if a > l:
break
b = aa[bisect_left(aa, a)]
if b <= a:
if b == a:
d[z] = a
break
if len(d) == 2:
break
if d:
if x in d and y in d:
res = []
elif x in d:
res = [y]
elif y in d:
res = [x]
elif y + x in d:
res = [d[y + x] - y]
else:
z, tmp = y - x, []
for a in aa:
a += z
if a > l:
break
b = aa[bisect_left(aa, a)]
if b == a:
tmp.append(a)
for a in tmp:
if a > y:
res = [a - y]
break
elif a + x < l:
res = [a + x]
break
else:
res = [x, y]
print(len(res))
if res:
print(*res)
if __name__ == '__main__':
main()
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, std::size_t N>
struct _v_traits {
using type = std::vector<typename _v_traits<T, N - 1>::type>;
};
template <typename T>
struct _v_traits<T, 1> {
using type = std::vector<T>;
};
template <typename T, std::size_t N = 1>
using vec = typename _v_traits<T, N>::type;
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &vec) {
os << "[";
for (const auto &v : vec) {
os << v << ",";
}
os << "]";
return os;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long n, l, x, y;
cin >> n >> l >> x >> y;
vector<long long> a(n);
for (long long &i : a) {
cin >> i;
}
{
bool x_ok = false, y_ok = false;
for (long long i = 0; i < n; i++) {
if (binary_search(a.begin() + i + 1, a.end(), x + a[i])) {
x_ok = true;
break;
}
}
for (long long i = 0; i < n; i++) {
if (binary_search(a.begin() + i + 1, a.end(), y + a[i])) {
y_ok = true;
break;
}
}
if (x_ok and y_ok) {
cout << 0 << endl;
return 0;
}
if (x_ok) {
cout << 1 << endl;
cout << y << endl;
return 0;
}
if (y_ok) {
cout << 1 << endl;
cout << x << endl;
return 0;
}
}
{
vector<long long> added;
for (long long av : a) {
if (av + x <= l) {
added.push_back(av + x);
}
if (0 <= av - x) {
added.push_back(av - x);
}
}
sort(added.begin(), added.end());
for (long long av : a) {
for (long long b : {av - y, av + y}) {
if (binary_search(added.begin(), added.end(), b)) {
cout << 1 << endl;
cout << *lower_bound(added.begin(), added.end(), b);
return 0;
}
}
}
}
{
cout << 2 << endl;
cout << x << " " << y << endl;
}
return 0;
}
| 8 | CPP |
#!/usr/bin/env python3
def rl(T=str):
return list(map(T,input().split()))
def ok(a,d,x):
for v in a:
if v+x in d:
return True
return False
def try_one(a,d,x,y):
def can_place(v):
#print(v)
#print(v+x,v-x,v+y,v-y)
if a[0] <= v <= a[-1]:
if (v + x in d or v - x in d) and \
(v + y in d or v - y in d):
return True
return False;
for v in a:
for _ in [-x,+x,-y,+y]:
if can_place(v+_):
return v+_;
return None
def main():
n, l, x, y = rl(int)
a = rl(int)
d = set(a)
if ok(a,d,x):
if ok(a,d,y):
print(0)
else:
print(1)
print(y)
else:
if ok(a,d,y):
print(1)
print(x)
else:
p = try_one(a,d,x,y)
if p is not None:
print(1)
print(p)
else:
print(2)
print(x,y)
main()
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 110000;
int i, j, k, l, m, n, o, p, x, y, L, a[N];
map<int, bool> F;
inline void Init() {
cin >> n >> L >> x >> y;
F.clear();
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
F[a[i]] = 1;
}
}
inline void Solve() {
int isx, isy, aj, ans, Find;
isx = isy = 0;
for (i = 1; i <= n; i++) {
aj = a[i] - x;
if (F[aj]) isx = 1;
aj = a[i] + x;
if (F[aj]) isx = 1;
aj = a[i] - y;
if (F[aj]) isy = 1;
aj = a[i] + y;
if (F[aj]) isy = 1;
}
if (isx && isy)
puts("0");
else if (isx) {
puts("1");
printf("%d\n", y);
} else if (isy) {
puts("1");
printf("%d\n", x);
} else {
Find = 0;
for (i = 1; i <= n; i++) {
if (a[i] + x <= L) {
isy = 0;
o = a[i] + x;
aj = o + y;
if (F[aj]) isy = 1;
aj = o - y;
if (F[aj]) isy = 1;
if (isy) {
Find = 1;
ans = o;
break;
}
}
if (a[i] - x >= 0) {
isy = 0;
o = a[i] - x;
aj = o + y;
if (F[aj]) isy = 1;
aj = o - y;
if (F[aj]) isy = 1;
if (isy) {
Find = 1;
ans = o;
break;
}
}
}
if (Find) {
puts("1");
printf("%d\n", ans);
} else {
puts("2");
printf("%d %d\n", x, y);
}
}
}
int main() {
Init();
Solve();
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
set<int> s;
int a[200001];
int main() {
int n, l, x, y;
scanf("%d%d%d%d", &n, &l, &x, &y);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
s.insert(a[i]);
}
int ans = -1;
bool ok1 = 0, ok2 = 0;
for (int i = 1; i <= n; i++) {
if (a[i] >= x && s.count(a[i] - x)) ok1 = 1;
if (a[i] <= l - x && s.count(a[i] + x)) ok1 = 1;
if (a[i] >= y && s.count(a[i] - y)) ok2 = 1;
if (a[i] <= l - y && s.count(a[i] + y)) ok2 = 1;
}
if (ok1 && ok2)
printf("0\n");
else if (ok1 || ok2)
printf("1\n%d\n", ok1 == 1 ? y : x);
else {
for (int i = 1; i <= n; i++) {
if (a[i] >= x + y && s.count(a[i] - x - y)) {
ans = a[i] - x;
break;
}
if (a[i] >= x && a[i] - x + y <= l && s.count(a[i] - x + y)) {
ans = a[i] - x;
break;
}
if (a[i] + x + y <= l && s.count(a[i] + x + y)) {
ans = a[i] + y;
break;
}
if (a[i] + y <= l && a[i] + y - x >= 1 && s.count(a[i] + y - x)) {
ans = a[i] + y;
break;
}
}
if (ans != -1)
printf("1\n%d\n", ans);
else
printf("2\n%d %d\n", x, y);
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<int> calc(const vector<int> &pts, int x) {
vector<int> cands;
int last = 0;
for (int start = 0; start < (int)pts.size() && last < (int)pts.size();
++start) {
if (pts[start] + x > pts.back()) {
break;
}
last =
lower_bound(begin(pts) + last, end(pts), pts[start] + x) - begin(pts);
if (last == (int)pts.size()) {
break;
}
if (pts[last] == pts[start] + x) {
cands.clear();
return cands;
} else {
cands.push_back(pts[start] + x);
}
}
for (int start = 0; start < (int)pts.size(); ++start) {
if (pts[start] - x < 0) continue;
auto p = lower_bound(begin(pts), end(pts), pts[start] - x);
assert(p != end(pts));
if (*p == pts[start] - x) {
cands.clear();
return cands;
} else {
cands.push_back(pts[start] - x);
}
}
sort(begin(cands), end(cands));
return cands;
}
int main() {
int n, L, x, y;
scanf("%d %d %d %d", &n, &L, &x, &y);
vector<int> pts(n);
for (int i = 0; i < n; ++i) {
scanf("%d", &pts[i]);
}
vector<int> needx = calc(pts, x);
vector<int> needy = calc(pts, y);
if (needx.size() > needy.size()) {
needx.swap(needy);
}
if (needx.size() == 0) {
if (needy.size() == 0) {
puts("0");
} else {
printf("1\n%d\n", needy[0]);
}
} else {
assert(needy.size() > 0);
for (int i = 0; i < (int)needx.size(); ++i) {
auto p = lower_bound(begin(needy), end(needy), needx[i]);
if (p != end(needy) && *p == needx[i]) {
printf("1\n%d\n", needx[i]);
return 0;
}
}
printf("2\n%d %d\n", needx[0], needy[0]);
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
bool check(set<int> mySet, int value) {
for (auto it = mySet.begin(); it != mySet.end(); ++it)
if (mySet.find(*it - value) != mySet.end()) return true;
return false;
}
int main() {
int n, l, x, y;
scanf("%d%d%d%d", &n, &l, &x, &y);
set<int> mySet;
for (int i = 0; i < n; ++i) {
int value;
scanf("%d", &value);
mySet.insert(value);
}
if (check(mySet, x) && check(mySet, y)) {
printf("0\n");
return 0;
}
if (check(mySet, x)) {
printf("1\n%d\n", y);
return 0;
} else if (check(mySet, y)) {
printf("1\n%d\n", x);
return 0;
}
for (auto it = mySet.begin(); it != mySet.end(); ++it)
if (*it - x >= 0 && (mySet.find(*it - x + y) != mySet.end() ||
mySet.find(*it - x - y) != mySet.end())) {
printf("1\n%d\n", *it - x);
return 0;
} else if (*it + x <= l && (mySet.find(*it + x - y) != mySet.end() ||
mySet.find(*it + x + y) != mySet.end())) {
printf("1\n%d\n", *it + x);
return 0;
} else if (*it - y >= 0 && (mySet.find(*it - y + x) != mySet.end() ||
mySet.find(*it - y - x) != mySet.end())) {
printf("1\n%d\n", *it - y);
return 0;
} else if (*it + y <= l && (mySet.find(*it + y - x) != mySet.end() ||
mySet.find(*it + y + x) != mySet.end())) {
printf("1\n%d\n", *it + y);
return 0;
}
printf("2\n%d %d\n", x, y);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
map<int, int> f;
int n, l, x, y;
int a[110000];
int main() {
scanf("%d%d%d%d", &n, &l, &x, &y);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
f[a[i]] = 1;
}
bool f1, f2;
f1 = f2 = 0;
for (int i = 1; i <= n; i++) {
if (f[a[i] - x]) f1 = 1;
if (f[a[i] - y]) f2 = 1;
}
if (f1 && f2) {
printf("0");
return 0;
}
if (f1) {
printf("1\n%d\n", y);
return 0;
}
if (f2) {
printf("1\n%d\n", x);
return 0;
}
for (int i = 1; i <= n; i++)
if (f[a[i] - x - y]) {
printf("1\n%d", a[i] - y);
return 0;
}
for (int i = 1; i <= n; i++)
if (f[a[i] - (y - x)] && a[i] + x <= l) {
printf("1\n%d", a[i] + x);
return 0;
}
for (int i = 1; i <= n; i++)
if (f[a[i] + (y - x)] && a[i] - x >= 0) {
printf("1\n%d", a[i] - x);
return 0;
}
printf("2\n%d %d\n", x, y);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
long long n, len, girl, boy, x;
set<long long> st;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
bool g = 0, b = 0;
cin >> n >> len >> girl >> boy;
for (int i = 0; i < n; ++i) cin >> x, st.insert(x);
for (auto it : st)
b |= (st.find(it + boy) != st.end()), g |= (st.find(it + girl) != st.end());
long long small = *st.begin();
if (g && b)
cout << 0;
else if (b) {
if (small + girl <= len)
cout << "1\n" << small + girl;
else
cout << "2\n0 " << girl;
} else if (g) {
if (small + boy <= len)
cout << "1\n" << small + boy;
else
cout << "2\n0 " << boy;
} else {
set<long long> bx, gx;
for (auto it : st)
bx.insert(it + boy), bx.insert(it - boy), gx.insert(it + girl),
gx.insert(it - girl);
for (auto it : bx)
if (it >= 0 && it <= len && gx.find(it) != gx.end())
return cout << "1\n" << it, 0;
if (small + boy <= len && small + girl <= len)
cout << "2\n" << small + boy << ' ' << small + girl;
else
cout << "3\n0 " << boy << ' ' << girl;
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long n, l, x, y;
cin >> n >> l >> x >> y;
map<long long, bool> mp1, mp2, mp3, mp4;
bool zx = false, zy = false;
vector<long long> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) {
mp1[a[i] + x] = true;
mp1[a[i] - x] = true;
mp4[a[i] + y] = true;
mp4[a[i] - y] = true;
mp2[a[i] + (x + y)] = true;
mp2[a[i] - (x + y)] = true;
mp2[a[i] + (x - y)] = true;
mp2[a[i] - (x - y)] = true;
mp3[a[i]] = true;
}
for (int i = 0; i < n; i++) {
if (mp1[a[i]]) {
zx = true;
}
if (mp4[a[i]]) {
zy = true;
}
}
if (zx && zy) {
cout << 0 << endl;
return 0;
}
if (zx) {
cout << 1 << endl;
cout << y << endl;
return 0;
}
if (zy) {
cout << 1 << endl;
cout << x << endl;
return 0;
}
for (int i = 0; i < n; i++) {
if (mp2[a[i]]) {
if (mp3[a[i] + (x + y)]) {
cout << 1 << endl;
cout << (a[i] + x) << endl;
return 0;
}
if (mp3[a[i] - (x + y)]) {
cout << 1 << endl;
cout << (a[i] - x) << endl;
return 0;
}
if (mp3[a[i] - (x - y)]) {
if (a[i] - x > 0) {
cout << 1 << endl;
cout << (a[i] - x) << endl;
return 0;
} else if (a[i] + y < l) {
cout << 1 << endl;
cout << (a[i] + y) << endl;
return 0;
}
}
if (mp3[a[i] + (x - y)]) {
if (a[i] + x < l) {
cout << 1 << endl;
cout << (a[i] + x) << endl;
return 0;
} else if (a[i] - y > 0) {
cout << 1 << endl;
cout << (a[i] - y) << endl;
return 0;
}
}
}
}
cout << 2 << endl;
cout << x << " " << y << endl;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
void printArray(long long start, long long end, int arr[]) {
for (long long i = start; i < end; i++) cout << arr[i] << " ";
cout << "\n";
}
void printVector(long long start, long long end, vector<int> vec) {
for (long long i = start; i < end; i++) cout << vec[i] << " ";
cout << "\n";
}
long long nextPerfectSquare(long long N) {
long long nextN = floor(sqrt(N)) + 1;
if (sqrt(N) == floor(sqrt(N))) nextN--;
return nextN * nextN;
}
long long countSetBits(long long n) {
long long count = 0;
while (n) {
count += n & 1;
n >>= 1;
}
return count;
}
void solve() {
int n, l, x, y, i;
cin >> n >> l >> x >> y;
int A[n];
vector<int> ans;
for (i = 0; i < n; i++) cin >> A[i];
ans.clear();
for (i = 0; i < n; i++)
if (binary_search(A, A + n, A[i] - x)) break;
if (i == n) {
for (i = 0; i < n; i++) {
if (A[i] > x) {
ans.push_back(A[i] - x);
break;
}
}
}
for (i = 0; i < n; i++) {
if (binary_search(A, A + n, A[i] - y)) break;
}
if (i == n) {
for (i = 0; i < n; i++) {
if (A[i] > y) {
ans.push_back(A[i] - y);
break;
}
}
}
if (ans.size() > 1) {
for (i = 0; i < n; i++) {
if (binary_search(A, A + n, A[i] - x + y) && A[i] - x > 0) {
cout << 1 << "\n";
cout << A[i] - x << "\n";
return;
}
if (binary_search(A, A + n, A[i] - x - y) && A[i] - x > 0) {
cout << 1 << "\n";
cout << A[i] - x << "\n";
return;
}
if (binary_search(A, A + n, A[i] + x - y) && A[i] + x < l) {
cout << 1 << "\n";
cout << A[i] + x << "\n";
return;
}
if (binary_search(A, A + n, A[i] + x + y) && A[i] + x < l) {
cout << 1 << "\n";
cout << A[i] + x << "\n";
return;
}
}
}
cout << ans.size() << "\n";
sort(ans.begin(), ans.end());
printVector(0, ans.size(), ans);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t = 1;
while (t--) {
solve();
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long int in[100005];
int main() {
int n;
long long int l, x, y;
scanf("%d %I64d %I64d %I64d", &n, &l, &x, &y);
for (int i = 0; i < n; i++) scanf("%I64d", &in[i]);
bool X = false, Y = false, XY = false, XY2 = false, XY3 = false;
int L, R, T;
for (int i = 0; i < n; i++) {
int p = lower_bound(in, in + n, in[i] + x) - in;
if (p < n && in[p] == in[i] + x) X = true;
p = lower_bound(in, in + n, in[i] + y) - in;
if (p < n && in[p] == in[i] + y) Y = true;
p = lower_bound(in, in + n, in[i] + x + y) - in;
if (p < n && in[p] == in[i] + x + y) {
XY = true;
L = i;
}
p = lower_bound(in, in + n, in[i] + y - x) - in;
if (p < n && in[p] == in[i] + y - x && in[i] + y <= l) {
XY2 = true;
R = i;
} else if (p < n && in[p] == in[i] + y - x && in[i] - x >= 0) {
XY3 = true;
T = i;
}
}
if (X && Y)
puts("0");
else {
if (X) {
puts("1");
printf("%I64d\n", y);
} else if (Y) {
puts("1");
printf("%I64d\n", x);
} else if (XY) {
puts("1");
printf("%I64d\n", in[L] + x);
} else if (XY2) {
puts("1");
printf("%I64d\n", in[R] + y);
} else if (XY3) {
puts("1");
printf("%I64d\n", in[T] - x);
} else {
puts("2");
printf("%I64d %I64d\n", x, y);
}
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int N, L, X, Y;
int marks[100000 + 5];
map<int, bool> seen;
bool ok(int cur) {
for (int i = 0; i < N; ++i)
if (marks[i] + cur >= 0 && marks[i] + cur <= L && seen[marks[i] + cur])
return true;
return false;
}
int find_mark() {
int poss1, poss2, poss3, poss4;
for (int i = 0; i < N; ++i) {
poss1 = marks[i] + X;
poss2 = marks[i] - X;
poss3 = marks[i] + Y;
poss4 = marks[i] - Y;
if (poss1 >= 0 && poss1 <= L) {
if (poss1 + Y >= 0 && poss1 + Y <= L && seen[poss1 + Y]) return poss1;
}
if (poss1 >= 0 && poss1 <= L) {
if (poss1 - Y >= 0 && poss1 - Y <= L && seen[poss1 - Y]) return poss1;
}
if (poss2 >= 0 && poss2 <= L) {
if (poss2 - Y >= 0 && poss2 - Y <= L && seen[poss2 - Y]) return poss2;
}
if (poss2 >= 0 && poss2 <= L) {
if (poss2 + Y >= 0 && poss2 + Y <= L && seen[poss2 + Y]) return poss2;
}
if (poss3 >= 0 && poss3 <= L) {
if (poss3 + X >= 0 && poss3 + X <= L && seen[poss3 + X]) return poss3;
}
if (poss3 >= 0 && poss3 <= L) {
if (poss3 - X >= 0 && poss3 - X <= L && seen[poss3 - X]) return poss3;
}
if (poss4 >= 0 && poss4 <= L) {
if (poss4 - X >= 0 && poss4 - X <= L && seen[poss4 - X]) return poss4;
}
if (poss4 >= 0 && poss4 <= L) {
if (poss4 + X >= 0 && poss4 + X <= L && seen[poss4 + X]) return poss4;
}
}
return -1;
}
int main() {
ios::sync_with_stdio(0);
cin >> N >> L >> X >> Y;
for (int i = 0; i < N; ++i) {
cin >> marks[i];
seen[marks[i]] = true;
}
if (ok(X) && ok(Y)) {
cout << "0\n";
return 0;
} else if (ok(X) || ok(Y)) {
if (ok(X))
cout << "1\n" << Y << "\n";
else
cout << "1\n" << X << "\n";
return 0;
}
int mark = find_mark();
if (mark == -1)
cout << "2\n" << X << " " << Y << "\n";
else
cout << "1\n" << mark << "\n";
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
map<int, int> P;
int a[100010];
int n, l, x, y, tp, maxm;
int g[2];
bool o[2];
int main() {
scanf("%d%d%d%d", &n, &l, &x, &y);
g[0] = min(x, y);
g[1] = max(x, y);
o[0] = o[1] = true;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
P[a[i]] = 1;
}
sort(a + 1, a + n + 1);
bool boy = false, girl = false;
for (int i = 1; i <= n; i++) {
if (a[i] - x >= 0 && P[a[i] - x]) girl = true;
if (a[i] - y >= 0 && P[a[i] - y]) boy = true;
}
if (boy && girl) {
printf("0\n");
return 0;
}
if (boy) {
printf("1\n%d\n", x);
return 0;
}
if (girl) {
printf("1\n%d\n", y);
return 0;
}
bool flag1 = false;
bool flag2 = false;
bool flag3 = false;
int where = 0;
for (int i = 1; i <= n; i++) {
if (a[i] >= x && P[a[i] + y - x]) {
flag1 = true;
where = a[i];
break;
}
if (a[i] + y <= l && P[a[i] + y - x]) {
flag2 = true;
where = a[i];
break;
}
if (a[i] + x + y <= l && P[a[i] + x + y]) {
flag3 = true;
where = a[i];
break;
}
}
if (flag1)
printf("1\n%d\n", where - x);
else if (flag2)
printf("1\n%d\n", where + y);
else if (flag3)
printf("1\n%d\n", where + x);
else
printf("2\n%d %d\n", x, y);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, l, x, y, a, b, c, d;
int aa[100100];
int find(int q) {
int j = 1;
for (int i = 2; i <= n; i++) {
while (aa[i] - aa[j] > q) j++;
if (aa[i] - aa[j] == q) return j;
}
return 0;
}
int find1(int q) {
int j = 1;
for (int i = 2; i <= n; i++) {
while (aa[i] - aa[j] > q) j++;
if (aa[i] - aa[j] == q) {
int ll = aa[j], rr = aa[i];
if (ll - x > 0) return ll - x;
if (rr + x < l) return rr + x;
}
}
return 0;
}
int main() {
scanf("%d%d%d%d", &n, &l, &x, &y);
for (int i = 1; i <= n; i++) scanf("%d", &aa[i]);
a = find(x);
b = find(y);
if (a && b) {
printf("0");
return 0;
}
if (a) {
printf("1\n");
printf("%d", y);
return 0;
}
if (b) {
printf("1\n");
printf("%d", x);
return 0;
}
if (x + y <= l) c = find(x + y);
if (c) {
printf("1\n");
printf("%d", aa[c] + x);
return 0;
}
d = find1(y - x);
if (d) {
printf("1\n");
printf("%d", d);
return 0;
}
printf("2\n");
printf("%d %d", x, y);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long n, l, x, y;
bool x_pres, y_pres;
int main() {
ios_base::sync_with_stdio(0);
;
cin >> n >> l >> x >> y;
vector<long long> m(n);
for (long long i = 0; i < n; i++) cin >> m[i];
sort(m.begin(), m.end());
for (long long i = 0; i < m.size(); i++) {
if (binary_search(m.begin(), m.end(), m[i] - x) or
binary_search(m.begin(), m.end(), m[i] + x)) {
x_pres = true;
break;
}
}
for (long long i = 0; i < m.size(); i++) {
if (binary_search(m.begin(), m.end(), m[i] - y) or
binary_search(m.begin(), m.end(), m[i] + y)) {
y_pres = true;
break;
}
}
if (x_pres and y_pres) {
cout << 0 << endl;
} else if (x_pres) {
cout << 1 << endl;
cout << y << endl;
} else if (y_pres) {
cout << 1 << endl;
cout << x << endl;
} else {
for (long long i = 0; i < m.size(); i++) {
if (binary_search(m.begin(), m.end(), m[i] + x + y)) {
cout << 1 << endl;
cout << m[i] + x << endl;
return 0;
}
}
if (x > y) swap(x, y);
for (long long i = 0; i < m.size(); i++) {
if (binary_search(m.begin(), m.end(), m[i] + y - x)) {
if (m[i] - x >= 0) {
cout << 1 << endl;
cout << m[i] - x << endl;
return 0;
} else if (m[i] + y <= l) {
cout << 1 << endl;
cout << m[i] + y << endl;
return 0;
}
}
}
cout << 2 << endl;
cout << x << " " << y << endl;
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int arr[1000000];
map<int, int> mp;
int main() {
int n, l, x, y;
scanf("%d%d%d%d", &n, &l, &x, &y);
int i;
for (i = 0; i < n; i++) {
scanf("%d", &arr[i]);
mp[arr[i]] = 1;
}
int cnt = 0;
for (i = 0; i < n; i++) {
if (mp.count(arr[i] + x)) {
cnt++;
break;
}
}
for (i = 0; i < n; i++) {
if (mp.count(arr[i] + y)) {
if (cnt)
cnt = 3;
else
cnt = 2;
break;
}
}
if (cnt == 3)
printf("0\n");
else if (cnt == 1) {
printf("1\n");
printf("%d\n", y);
} else if (cnt == 2) {
printf("1\n");
printf("%d\n", x);
} else {
int diff = y - x;
int sum = x + y;
for (i = 0; i < n; i++) {
if (mp.count(arr[i] + diff)) {
if (arr[i] + y <= l) {
printf("1\n");
printf("%d\n", arr[i] + y);
return 0;
} else if (arr[i] - x >= 0) {
printf("1\n");
printf("%d\n", arr[i] - x);
return 0;
}
}
}
for (i = 0; i < n; i++) {
if (mp.count(arr[i] + sum)) {
printf("1\n");
printf("%d\n", arr[i] + y);
return 0;
}
}
printf("2\n");
printf("%d %d\n", x, y);
return 0;
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int inft = 1000000009;
int n, a[1000005];
pair<int, int> ff(int x) {
int l = 0;
for (int r = 0; r < n; r++) {
while (l < n && a[l] + x < a[r]) l++;
if (a[l] + x == a[r]) return pair<int, int>(a[l], a[r]);
}
return pair<int, int>(-1, -1);
}
pair<int, int> fl(int x) {
int r = n - 1;
for (int l = n - 1; l >= 0; l--) {
while (r >= 0 && a[l] + x < a[r]) r--;
if (a[l] + x == a[r]) return pair<int, int>(a[l], a[r]);
}
return pair<int, int>(-1, -1);
}
void solve() {
int l, x, y;
cin >> n >> l >> x >> y;
for (int i = 0; i < n; i++) cin >> a[i];
bool okx = ff(x) != pair<int, int>(-1, -1);
bool oky = ff(y) != pair<int, int>(-1, -1);
if (okx && oky) {
cout << 0 << endl;
return;
}
if (okx || oky) {
cout << 1 << endl;
if (!okx) cout << x << endl;
if (!oky) cout << y << endl;
return;
}
pair<int, int> str = ff(x + y);
if (str != pair<int, int>(-1, -1)) {
cout << 1 << endl;
printf("%d\n", str.first + x);
return;
}
str = ff(y - x);
if (str != pair<int, int>(-1, -1) && str.first + y <= l) {
cout << 1 << endl;
cout << str.first + y << endl;
return;
}
str = fl(y - x);
if (str != pair<int, int>(-1, -1) && str.first - x >= 0) {
cout << 1 << endl;
cout << str.first - x << endl;
return;
}
cout << 2 << endl;
cout << x << " " << y << endl;
}
int main() {
int k = 1;
for (int i = 0; i < k; i++) solve();
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 2147383647;
const double pi = 2 * acos(0.0);
const double eps = 1e-9;
long long gcd(long long a, long long b) {
a = ((a) < 0 ? -(a) : (a));
b = ((b) < 0 ? -(b) : (b));
while (b) {
a = a % b;
swap(a, b);
}
return a;
}
int ext_gcd(int a, int b, int &x, int &y) {
if (a == 0) {
x = 0;
y = 1;
return b;
}
int x1, y1;
int d = ext_gcd(b % a, a, x1, y1);
x = y1 - (b / a) * x1;
y = x1;
return d;
}
long long power(long long a, long long p) {
long long res = 1, x = a;
while (p) {
if (p & 1) res = (res * x);
x = (x * x);
p >>= 1;
}
return res;
}
long long bigmod(long long a, long long p, long long m) {
long long res = 1, x = a % m;
while (p) {
if (p & 1) res = (res * x) % m;
x = (x * x) % m;
p >>= 1;
}
return res;
}
int n, l, x, y;
vector<int> arr;
int findJump(int v) {
for (int i = (0); i <= (n - 1); ++i) {
int cur = arr[i];
int f = cur + v;
int pos = lower_bound((arr).begin(), (arr).end(), f) - arr.begin();
if (pos >= 0 && pos <= n - 1 && arr[pos] == f) return 1;
}
return 0;
}
int main() {
scanf("%d %d %d %d", &n, &l, &x, &y);
for (int i = (0); i <= (n - 1); ++i) {
int t;
scanf("%d", &t);
arr.push_back(t);
}
int jumpx = findJump(x);
int jumpy = findJump(y);
if (jumpx && jumpy) {
printf("0\n");
return 0;
}
if (jumpx + jumpy == 1) {
printf("1\n");
if (jumpx == 0)
printf("%d\n", x);
else
printf("%d\n", y);
return 0;
}
bool one = false;
int res;
for (int i = (0); i <= (n - 1); ++i) {
int cur = arr[i];
int f = cur + x + y;
int pos = lower_bound(arr.begin(), arr.end(), f) - arr.begin();
if (pos <= n - 1 && pos >= 0 && arr[pos] == f) {
one = true;
res = cur + x;
break;
}
f = cur + y - x;
pos = lower_bound(arr.begin(), arr.end(), f) - arr.begin();
if (pos <= n - 1 && pos >= 0 && arr[pos] == f) {
one = true;
res = cur + y;
if (res > l) res = cur - x;
if (res < 0) {
one = false;
continue;
}
break;
}
}
if (one) {
printf("1\n");
printf("%d\n", res);
return 0;
}
printf("2\n");
printf("%d %d\n", x, y);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N3 = 1e3 + 15;
const int N4 = 1e4 + 15;
const int N5 = 1e5 + 15;
const int N6 = 1e6 + 15;
const int N7 = 1e7 + 15;
const int N8 = 1e8 + 15;
const int N9 = 1e9 + 15;
const double pi = acos(-1.0);
int dx[10] = {0, 1, -1, 1, -1, 2, -2, 2, -2};
int dy[10] = {0, 2, 2, -1, -1, 1, 1, -1, -1};
bool okx = 0, oky = 0;
int n, a[N5], l, x, r, y;
set<int> ans;
int bin(int l, int r, int val) { return (binary_search(a + l, a + r, val)); }
int main() {
cin >> n >> l >> x >> y;
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int i = 1; i <= n && a[i] + x <= l; ++i)
if (bin(1, n + 1, a[i] + x)) {
okx = true;
break;
}
for (int i = 1; i <= n && a[i] + y <= l; ++i)
if (bin(1, n + 1, a[i] + y)) {
oky = true;
break;
}
if (!okx && !oky) {
for (int i = 1; i <= n; ++i) {
if (a[i] + y <= l && bin(1, n + 1, a[i] + y - x)) {
ans.insert(a[i] + y);
break;
}
}
if (ans.size() == 0) {
for (int i = 1; i <= n; ++i) {
if (a[i] - y >= 0 && bin(1, n + 1, a[i] - y + x)) {
ans.insert(a[i] - y);
break;
}
}
}
if (ans.size() == 0) {
for (int i = 1; i <= n; ++i) {
if (a[i] + x + y <= l && bin(1, n + 1, a[i] + x + y)) {
ans.insert(a[i] + x);
break;
}
}
}
if (ans.size() == 0) {
ans.insert(x);
ans.insert(y);
}
} else {
if (!okx) ans.insert(x);
if (!oky) ans.insert(y);
}
cout << ans.size() << "\n";
for (set<int>::iterator it = ans.begin(); it != ans.end(); ++it)
cout << *it << "\n";
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, l, x, y, a[100002], u, v, r = 2;
set<int> A;
bool X, Y;
int main() {
scanf("%d%d%d%d", &n, &l, &x, &y);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
A.insert(a[i]);
}
for (int i = 0; i < n; i++) {
if (A.find(a[i] + x) != A.end()) X = true;
if (A.find(a[i] + y) != A.end()) Y = true;
}
if (X && Y) {
printf("0\n");
return 0;
}
if (X) {
printf("%d\n%d\n", 1, y);
return 0;
}
if (Y) {
printf("%d\n%d\n", 1, x);
return 0;
}
u = x;
v = y;
for (int i = 0; i < n; i++) {
if (a[i] + x < l &&
(A.find(a[i] + x - y) != A.end() || A.find(a[i] + x + y) != A.end())) {
r = 1;
u = a[i] + x;
break;
}
if (a[i] - x > 0 &&
(A.find(a[i] - x + y) != A.end() || A.find(a[i] - x - y) != A.end())) {
r = 1;
u = a[i] - x;
break;
}
}
printf("%d\n", r);
(r == 2) ? printf("%d %d\n", u, v) : printf("%d\n", u);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int binsearch(const vector<int> &T, int orig, int beg, int end, int val) {
if (beg == end) {
if (T[beg] - T[orig] == val)
return beg;
else
return -1;
}
int sr = (beg + end) / 2;
if (T[sr] - T[orig] >= val)
return binsearch(T, orig, beg, sr, val);
else
return binsearch(T, orig, sr + 1, end, val);
}
vector<pair<int, int> > find_all(const vector<int> &T, int val) {
vector<pair<int, int> > ans;
int n = T.size();
for (int(i) = (0); i <= (n - 2); ++(i)) {
int a = binsearch(T, i, i + 1, n - 1, val);
if (a != -1) ans.push_back(make_pair(i, a));
}
return ans;
}
int main() {
int n, l, x, y;
scanf("%d %d %d %d", &n, &l, &x, &y);
vector<int> T(n);
vector<int> ans;
for (int i = 0; i < (n); ++i) scanf("%d", &T[i]);
vector<pair<int, int> > X = find_all(T, x);
vector<pair<int, int> > Y = find_all(T, y);
if (X.empty() || Y.empty()) {
if (X.empty() && Y.empty()) {
vector<pair<int, int> > P = find_all(T, x + y);
if (!P.empty())
ans.push_back(T[P.front().first] + x);
else {
vector<pair<int, int> > N = find_all(T, y - x);
for (auto &&p : N) {
int a = T[p.first] - x, b = T[p.second] + x;
if (a > 0) {
ans.push_back(a);
break;
}
if (b < l) {
ans.push_back(b);
break;
}
}
if (ans.empty()) {
ans.push_back(x);
ans.push_back(y);
}
}
} else {
int a = (X.empty()) ? x : y;
ans.push_back(a);
}
}
printf("%d\n", (int)ans.size());
for (auto &&x : ans) printf("%d ", x);
printf("\n");
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char const *argv[]) {
long n, l, x, y, num;
cin >> n >> l >> x >> y;
long arr[n];
unordered_set<long> st;
for (int i = 0; i < n; i++) {
cin >> num;
arr[i] = num;
st.insert(num);
}
bool xposs = false, yposs = false;
for (int i = 0; i < n - 1 and !xposs; i++) {
if (st.find(arr[i] + x) != st.end()) xposs = true;
}
for (int i = 0; i < n - 1 and !yposs; i++) {
if (st.find(arr[i] + y) != st.end()) yposs = true;
}
long mn = *min_element(arr, arr + n);
if (xposs and yposs)
cout << 0 << endl;
else if (xposs)
cout << 1 << endl << mn + y << endl;
else if (yposs)
cout << 1 << endl << mn + x << endl;
else {
unordered_set<long> pmx;
for (int i = 0; i < n; i++) {
if (arr[i] + x <= l) pmx.insert(arr[i] + x);
if (arr[i] - x >= 0) pmx.insert(arr[i] - x);
}
int oneval = -1;
for (int i = 0; i < n and oneval == -1; i++) {
if ((arr[i] + y <= l) and pmx.find(arr[i] + y) != pmx.end())
oneval = arr[i] + y;
if ((arr[i] - y >= 0) and pmx.find(arr[i] - y) != pmx.end())
oneval = arr[i] - y;
}
if (oneval != -1)
cout << 1 << endl << oneval << endl;
else
cout << 2 << endl << mn + x << " " << mn + y << endl;
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, l, x, y, a[100005];
pair<int, int> find_first(int pos) {
int lp = 0;
for (int rp = 0; rp < n; rp++) {
while (lp < n && a[lp] + pos < a[rp]) lp++;
if (a[lp] + pos == a[rp]) return make_pair(a[lp], a[rp]);
}
return make_pair(-1, -1);
}
pair<int, int> find_last(int pos) {
int rp = n - 1;
for (int lp = n - 1; lp >= 0; lp--) {
while (rp >= 0 && a[lp] + pos < a[rp]) rp--;
if (a[lp] + pos == a[rp]) return make_pair(a[lp], a[rp]);
}
return make_pair(-1, -1);
}
int main() {
cin >> n >> l >> x >> y;
for (int i = 0; i < n; i++) cin >> a[i];
bool findX = (find_first(x) != make_pair(-1, -1));
bool findY = (find_first(y) != make_pair(-1, -1));
if (findX && findY) {
cout << 0;
return 0;
}
if (findX) {
cout << 1 << endl << y;
return 0;
}
if (findY) {
cout << 1 << endl << x;
return 0;
}
pair<int, int> ans = find_first(x + y);
if (ans != make_pair(-1, -1)) {
cout << 1 << endl << ans.first + x;
return 0;
}
ans = find_first(y - x);
if (ans != make_pair(-1, -1) && ans.first + y < l) {
cout << 1 << endl << ans.first + y;
return 0;
}
ans = find_last(y - x);
if (ans != make_pair(-1, -1) && ans.first - x >= 0) {
cout << 1 << endl << ans.first - x;
return 0;
}
cout << 2 << endl << x << " " << y << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100 * 1000 + 100;
long long a[maxn];
set<long long> s;
vector<int> v;
void f();
int main() {
long long n, l, x, y, siz;
cin >> n >> l >> x >> y;
for (int i = 0; i < n; i++) cin >> a[i];
int isx = 0, isy = 0;
for (int i = 0; i < n; i++) s.insert(a[i]);
for (int i = 0; i < n; i++) {
if (a[i] - x >= 0) {
siz = s.size();
s.insert(a[i] - x);
if (siz == s.size()) isx = 1;
}
}
s.clear();
for (int i = 0; i < n; i++) s.insert(a[i]);
for (int i = 0; i < n; i++) {
if (a[i] + x <= l) {
siz = s.size();
s.insert(a[i] + x);
if (siz == s.size()) isx = 1;
}
}
s.clear();
for (int i = 0; i < n; i++) s.insert(a[i]);
for (int i = 0; i < n; i++) {
if (a[i] - y >= 0) {
siz = s.size();
s.insert(a[i] - y);
if (siz == s.size()) isy = 1;
}
}
s.clear();
for (int i = 0; i < n; i++) s.insert(a[i]);
for (int i = 0; i < n; i++) {
if (a[i] + y <= l) {
siz = s.size();
s.insert(a[i] + y);
if (siz == s.size()) isy = 1;
}
}
s.clear();
if (isx == 1 && isy == 1) {
cout << 0 << endl;
exit(0);
}
long long ind = -1;
for (int i = 0; i < n; i++) {
if (a[i] + x <= l) s.insert(a[i] + x);
if (a[i] - x >= 0) s.insert(a[i] - x);
}
for (int i = 0; i < n; i++) {
if (a[i] - y >= 0) {
siz = s.size();
s.insert(a[i] - y);
if (siz == s.size()) ind = a[i] - y;
}
}
s.clear();
for (int i = 0; i < n; i++) {
if (a[i] + x <= l) s.insert(a[i] + x);
if (a[i] - x >= 0) s.insert(a[i] - x);
}
for (int i = 0; i < n; i++) {
if (a[i] + y <= l) {
siz = s.size();
s.insert(a[i] + y);
if (siz == s.size()) ind = a[i] + y;
}
}
s.clear();
if (ind != -1)
cout << 1 << '\n' << ind << endl;
else if (isx)
cout << 1 << '\n' << y << endl;
else if (isy)
cout << 1 << '\n' << x << endl;
else
cout << 2 << '\n' << x << ' ' << y << endl;
cin >> n;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
vector<int> v;
map<int, bool> mark;
bool mark1, mark2;
int a[maxn];
int main() {
int n, l, x, y;
cin >> n >> l >> x >> y;
for (int i = 1; i <= n; i++) {
cin >> a[i];
mark[a[i]] = 1;
}
for (int i = 1; i <= n; i++) {
if (mark[a[i] + x] == 1 or mark[a[i] - x] == 1) {
mark1 = true;
}
if (mark[a[i] + y] == 1 or mark[a[i] - y] == 1) {
mark2 = true;
}
}
if (mark1 == false) {
v.push_back(x);
}
if (mark2 == false) {
v.push_back(y);
}
if (v.size() != 2) {
cout << v.size() << endl;
for (int i = 0; i < v.size(); i++) {
cout << v[i] << " ";
}
return 0;
}
int d = abs(y - x);
for (int i = 1; i <= n; i++) {
if (mark[a[i] + d] == 1 and a[i] + max(x, y) <= l) {
cout << 1 << endl;
return cout << a[i] + max(x, y) << endl, 0;
}
}
for (int i = 1; i <= n; i++) {
if (mark[a[i] + x + y] == 1 and a[i] + x <= l) {
cout << 1 << endl;
return cout << a[i] + x << endl, 0;
}
}
for (int i = 1; i <= n; i++) {
if (mark[d + a[i]] == 1 and a[i] - min(x, y) >= 0) {
cout << 1 << endl;
return cout << a[i] - min(x, y) << endl, 0;
}
}
cout << v.size() << endl;
for (int i = 0; i < v.size(); i++) {
cout << v[i] << " ";
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000111;
set<int> x, y;
int marks[MAXN];
set<int> pop;
int main() {
int n, l, xx, yy;
scanf("%d%d%d%d", &n, &l, &xx, &yy);
int xw = 0, yw = 0;
for (int i = 1; i <= n; i++) {
int a;
scanf("%d", &a);
pop.insert(a);
if (pop.find(a - xx) != pop.end()) xw = 1;
if (pop.find(a - yy) != pop.end()) yw = 1;
if (a - xx >= 0) x.insert(a - xx);
if (a + xx <= l) x.insert(a + xx);
if (a - yy >= 0) y.insert(a - yy);
if (a + yy <= l) y.insert(a + yy);
}
if (xw == 1 && yw == 1) {
puts("0");
return 0;
}
if (xw == 1) {
printf("1\n%d\n", *(y.begin()));
return 0;
}
if (yw == 1) {
printf("1\n%d\n", *(x.begin()));
return 0;
}
for (auto x1 : x) {
if (y.find(x1) != y.end()) {
printf("1\n%d\n", x1);
return 0;
}
}
puts("2");
printf("%d %d\n", *(x.begin()), *(y.begin()));
}
| 8 | CPP |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.