Search is not available for this dataset
name
stringlengths 2
112
| description
stringlengths 29
13k
| source
int64 1
7
| difficulty
int64 0
25
| solution
stringlengths 7
983k
| language
stringclasses 4
values |
|---|---|---|---|---|---|
809_C. Find a car | After a wonderful evening in the restaurant the time to go home came. Leha as a true gentlemen suggested Noora to give her a lift. Certainly the girl agreed with pleasure. Suddenly one problem appeared: Leha cannot find his car on a huge parking near the restaurant. So he decided to turn to the watchman for help.
Formally the parking can be represented as a matrix 109 × 109. There is exactly one car in every cell of the matrix. All cars have their own machine numbers represented as a positive integer. Let's index the columns of the matrix by integers from 1 to 109 from left to right and the rows by integers from 1 to 109 from top to bottom. By coincidence it turned out, that for every cell (x, y) the number of the car, which stands in this cell, is equal to the minimum positive integer, which can't be found in the cells (i, y) and (x, j), 1 ≤ i < x, 1 ≤ j < y.
<image> The upper left fragment 5 × 5 of the parking
Leha wants to ask the watchman q requests, which can help him to find his car. Every request is represented as five integers x1, y1, x2, y2, k. The watchman have to consider all cells (x, y) of the matrix, such that x1 ≤ x ≤ x2 and y1 ≤ y ≤ y2, and if the number of the car in cell (x, y) does not exceed k, increase the answer to the request by the number of the car in cell (x, y). For each request Leha asks the watchman to tell him the resulting sum. Due to the fact that the sum can turn out to be quite large, hacker asks to calculate it modulo 109 + 7.
However the requests seem to be impracticable for the watchman. Help the watchman to answer all Leha's requests.
Input
The first line contains one integer q (1 ≤ q ≤ 104) — the number of Leha's requests.
The next q lines contain five integers x1, y1, x2, y2, k (1 ≤ x1 ≤ x2 ≤ 109, 1 ≤ y1 ≤ y2 ≤ 109, 1 ≤ k ≤ 2·109) — parameters of Leha's requests.
Output
Print exactly q lines — in the first line print the answer to the first request, in the second — the answer to the second request and so on.
Example
Input
4
1 1 1 1 1
3 2 5 4 5
1 1 5 5 10000
1 4 2 5 2
Output
1
13
93
0
Note
Let's analyze all the requests. In each case the requested submatrix is highlighted in blue.
In the first request (k = 1) Leha asks only about the upper left parking cell. In this cell the car's number is 1. Consequentally the answer is 1.
<image>
In the second request (k = 5) suitable numbers are 4, 1, 2, 3, 2, 1. Consequentally the answer is 4 + 1 + 2 + 3 + 2 + 1 = 13.
<image>
In the third request (k = 10000) Leha asks about the upper left frament 5 × 5 of the parking. Since k is big enough, the answer is equal to 93.
<image>
In the last request (k = 2) none of the cur's numbers are suitable, so the answer is 0.
<image> | 2 | 9 | #include <bits/stdc++.h>
using namespace std;
int q;
long long int x1;
long long int my1;
long long int x2;
long long int y2;
long long int k;
long long int allowed[32];
long long int width[32];
long long int height[32];
long long int dp[32][2][4];
long long int num[32][2][4];
bool exist[32][2][4];
long long int calc(int x, int y) {
if (x == 0 || y == 0) return 0;
int t = max(x, y);
int cnt = 1;
while (t > 0) {
cnt++;
t /= 2;
}
long long int k_ = k;
int cnt2 = 1;
while (1) {
k_ = k_ % 2 ? (k_ + 1) / 2 : k_ / 2;
cnt2++;
if (k_ == 1) break;
}
cnt = max(cnt, cnt2);
width[cnt - 1] = x;
height[cnt - 1] = y;
allowed[cnt - 1] = k;
for (int i = cnt - 2; i >= 0; i--) {
allowed[i] =
allowed[i + 1] % 2 ? (allowed[i + 1] + 1) / 2 : allowed[i + 1] / 2;
width[i] = width[i + 1] / 2 + width[i + 1] % 2;
height[i] = height[i + 1] / 2 + height[i + 1] % 2;
}
fill(num[0][0], num[cnt][0], 0);
fill(dp[0][0], dp[cnt][0], 0);
fill(exist[0][0], exist[cnt][0], false);
num[0][1][3] = 1;
dp[0][1][3] = 1;
exist[0][1][3] = true;
for (int i = 0; i < cnt - 1; i++) {
for (int j = 0; j < 2; j++) {
for (int k = 0; k < 4; k++) {
if (!exist[i][j][k]) continue;
for (int s = 0; s < 2; s++) {
for (int t = 0; t < 2; t++) {
long long int p = (s + t) % 2;
long long int v =
(1000000007 +
((dp[i][j][k] * 2 + (p - 1) * num[i][j][k]) % 1000000007)) %
1000000007;
long long int n = num[i][j][k];
if (j == 1 && p && allowed[i] * 2 > allowed[i + 1]) continue;
if ((k & 2) && s && width[i] * 2 > width[i + 1]) continue;
if ((k & 1) && t && height[i] * 2 > height[i + 1]) continue;
int nj = 0;
if (j == 1 && allowed[i] * 2 - 1 + p == allowed[i + 1]) nj = 1;
int nk = 0;
if ((k & 1) && height[i] * 2 - 1 + t == height[i + 1]) nk += 1;
if ((k & 2) && width[i] * 2 - 1 + s == width[i + 1]) nk += 2;
exist[i + 1][nj][nk] = true;
dp[i + 1][nj][nk] = (dp[i + 1][nj][nk] + v) % 1000000007;
num[i + 1][nj][nk] = (num[i + 1][nj][nk] + n) % 1000000007;
}
}
}
}
}
long long int ret = 0;
for (int i = 0; i < 4; i++) {
ret += dp[cnt - 1][0][i];
ret += dp[cnt - 1][1][i];
ret %= 1000000007;
}
return ret;
}
int main() {
scanf("%d", &q);
while (q--) {
scanf("%lld%lld%lld%lld%lld", &x1, &my1, &x2, &y2, &k);
long long int ans = calc(x2, y2) - calc(x2, my1 - 1) - calc(x1 - 1, y2) +
calc(x1 - 1, my1 - 1);
printf("%lld\n", (1000000007 + ans % 1000000007) % 1000000007);
}
}
| CPP |
809_C. Find a car | After a wonderful evening in the restaurant the time to go home came. Leha as a true gentlemen suggested Noora to give her a lift. Certainly the girl agreed with pleasure. Suddenly one problem appeared: Leha cannot find his car on a huge parking near the restaurant. So he decided to turn to the watchman for help.
Formally the parking can be represented as a matrix 109 × 109. There is exactly one car in every cell of the matrix. All cars have their own machine numbers represented as a positive integer. Let's index the columns of the matrix by integers from 1 to 109 from left to right and the rows by integers from 1 to 109 from top to bottom. By coincidence it turned out, that for every cell (x, y) the number of the car, which stands in this cell, is equal to the minimum positive integer, which can't be found in the cells (i, y) and (x, j), 1 ≤ i < x, 1 ≤ j < y.
<image> The upper left fragment 5 × 5 of the parking
Leha wants to ask the watchman q requests, which can help him to find his car. Every request is represented as five integers x1, y1, x2, y2, k. The watchman have to consider all cells (x, y) of the matrix, such that x1 ≤ x ≤ x2 and y1 ≤ y ≤ y2, and if the number of the car in cell (x, y) does not exceed k, increase the answer to the request by the number of the car in cell (x, y). For each request Leha asks the watchman to tell him the resulting sum. Due to the fact that the sum can turn out to be quite large, hacker asks to calculate it modulo 109 + 7.
However the requests seem to be impracticable for the watchman. Help the watchman to answer all Leha's requests.
Input
The first line contains one integer q (1 ≤ q ≤ 104) — the number of Leha's requests.
The next q lines contain five integers x1, y1, x2, y2, k (1 ≤ x1 ≤ x2 ≤ 109, 1 ≤ y1 ≤ y2 ≤ 109, 1 ≤ k ≤ 2·109) — parameters of Leha's requests.
Output
Print exactly q lines — in the first line print the answer to the first request, in the second — the answer to the second request and so on.
Example
Input
4
1 1 1 1 1
3 2 5 4 5
1 1 5 5 10000
1 4 2 5 2
Output
1
13
93
0
Note
Let's analyze all the requests. In each case the requested submatrix is highlighted in blue.
In the first request (k = 1) Leha asks only about the upper left parking cell. In this cell the car's number is 1. Consequentally the answer is 1.
<image>
In the second request (k = 5) suitable numbers are 4, 1, 2, 3, 2, 1. Consequentally the answer is 4 + 1 + 2 + 3 + 2 + 1 = 13.
<image>
In the third request (k = 10000) Leha asks about the upper left frament 5 × 5 of the parking. Since k is big enough, the answer is equal to 93.
<image>
In the last request (k = 2) none of the cur's numbers are suitable, so the answer is 0.
<image> | 2 | 9 | #include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
long long sum(long long l, long long r) {
return (l + r) * (r - l + 1) / 2 % mod;
}
int solve(int x1, int x2, int y1, int y2, int k, int p, int add) {
x1 = max(1, x1);
x2 = min(x2, (1 << p));
y1 = max(1, y1);
y2 = min(y2, (1 << p));
if (x1 > x2 || y1 > y2) return 0;
if (x2 - x1 < y2 - y1) return solve(y1, y2, x1, x2, k, p, add);
if (x1 == 1 && x2 == (1 << p)) {
long long cnt = (y2 - y1 + 1);
long long l = add + 1;
long long r = min((long long)k, (long long)add + (long long)(1 << p));
if (l > r) return 0;
return cnt * sum(l, r) % mod;
}
int ans = 0, h = (1 << (p - 1));
ans = (ans + solve(x1, x2, y1, y2, k, p - 1, add)) % mod;
ans = (ans + solve(x1 - h, x2 - h, y1, y2, k, p - 1, add + h)) % mod;
ans = (ans + solve(x1, x2, y1 - h, y2 - h, k, p - 1, add + h)) % mod;
ans = (ans + solve(x1 - h, x2 - h, y1 - h, y2 - h, k, p - 1, add)) % mod;
return ans;
}
int main() {
int q;
scanf("%d", &q);
while (q--) {
int x1, x2, y1, y2, k;
scanf("%d%d%d%d%d", &x1, &y1, &x2, &y2, &k);
printf("%d\n", solve(x1, x2, y1, y2, k, 30, 0));
}
return 0;
}
| CPP |
809_C. Find a car | After a wonderful evening in the restaurant the time to go home came. Leha as a true gentlemen suggested Noora to give her a lift. Certainly the girl agreed with pleasure. Suddenly one problem appeared: Leha cannot find his car on a huge parking near the restaurant. So he decided to turn to the watchman for help.
Formally the parking can be represented as a matrix 109 × 109. There is exactly one car in every cell of the matrix. All cars have their own machine numbers represented as a positive integer. Let's index the columns of the matrix by integers from 1 to 109 from left to right and the rows by integers from 1 to 109 from top to bottom. By coincidence it turned out, that for every cell (x, y) the number of the car, which stands in this cell, is equal to the minimum positive integer, which can't be found in the cells (i, y) and (x, j), 1 ≤ i < x, 1 ≤ j < y.
<image> The upper left fragment 5 × 5 of the parking
Leha wants to ask the watchman q requests, which can help him to find his car. Every request is represented as five integers x1, y1, x2, y2, k. The watchman have to consider all cells (x, y) of the matrix, such that x1 ≤ x ≤ x2 and y1 ≤ y ≤ y2, and if the number of the car in cell (x, y) does not exceed k, increase the answer to the request by the number of the car in cell (x, y). For each request Leha asks the watchman to tell him the resulting sum. Due to the fact that the sum can turn out to be quite large, hacker asks to calculate it modulo 109 + 7.
However the requests seem to be impracticable for the watchman. Help the watchman to answer all Leha's requests.
Input
The first line contains one integer q (1 ≤ q ≤ 104) — the number of Leha's requests.
The next q lines contain five integers x1, y1, x2, y2, k (1 ≤ x1 ≤ x2 ≤ 109, 1 ≤ y1 ≤ y2 ≤ 109, 1 ≤ k ≤ 2·109) — parameters of Leha's requests.
Output
Print exactly q lines — in the first line print the answer to the first request, in the second — the answer to the second request and so on.
Example
Input
4
1 1 1 1 1
3 2 5 4 5
1 1 5 5 10000
1 4 2 5 2
Output
1
13
93
0
Note
Let's analyze all the requests. In each case the requested submatrix is highlighted in blue.
In the first request (k = 1) Leha asks only about the upper left parking cell. In this cell the car's number is 1. Consequentally the answer is 1.
<image>
In the second request (k = 5) suitable numbers are 4, 1, 2, 3, 2, 1. Consequentally the answer is 4 + 1 + 2 + 3 + 2 + 1 = 13.
<image>
In the third request (k = 10000) Leha asks about the upper left frament 5 × 5 of the parking. Since k is big enough, the answer is equal to 93.
<image>
In the last request (k = 2) none of the cur's numbers are suitable, so the answer is 0.
<image> | 2 | 9 | #include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
pair<int, int> query(int x, int y, int k, int m) {
if (x < 1 || y < 1 || m < 1 || k < 1) return make_pair(0, 0);
if (k <= max(x, y)) {
int a = min(k, min(x, y));
int b = min(k, m);
return make_pair((1LL * a * b) % MOD,
(1LL * a * ((1LL * b * (b + 1) / 2) % MOD)) % MOD);
} else if (k > 1) {
pair<int, int> q1 = query(x, y, k / 2, m),
q2 = query(x - k / 2, y, k / 2, m - k / 2),
q3 = query(x, y - k / 2, k / 2, m - k / 2),
q4 = query(x - k / 2, y - k / 2, k / 2, m);
return make_pair((0LL + q1.first + q2.first + q3.first + q4.first) % MOD,
(0LL + q1.second + q2.second + q3.second + q4.second +
1LL * (q2.first + q3.first) * (k / 2)) %
MOD);
}
return make_pair(0, 0);
}
int main(void) {
int q;
cin >> q;
while (q--) {
int x1, y1, x2, y2, m;
cin >> x1 >> y1 >> x2 >> y2 >> m;
int k = 1;
while (k <= max(x2, y2)) k *= 2;
cout << (2LL * MOD + query(x2, y2, k, m).second -
query(x1 - 1, y2, k, m).second - query(x2, y1 - 1, k, m).second +
query(x1 - 1, y1 - 1, k, m).second) %
MOD
<< "\n";
}
return 0;
}
| CPP |
809_C. Find a car | After a wonderful evening in the restaurant the time to go home came. Leha as a true gentlemen suggested Noora to give her a lift. Certainly the girl agreed with pleasure. Suddenly one problem appeared: Leha cannot find his car on a huge parking near the restaurant. So he decided to turn to the watchman for help.
Formally the parking can be represented as a matrix 109 × 109. There is exactly one car in every cell of the matrix. All cars have their own machine numbers represented as a positive integer. Let's index the columns of the matrix by integers from 1 to 109 from left to right and the rows by integers from 1 to 109 from top to bottom. By coincidence it turned out, that for every cell (x, y) the number of the car, which stands in this cell, is equal to the minimum positive integer, which can't be found in the cells (i, y) and (x, j), 1 ≤ i < x, 1 ≤ j < y.
<image> The upper left fragment 5 × 5 of the parking
Leha wants to ask the watchman q requests, which can help him to find his car. Every request is represented as five integers x1, y1, x2, y2, k. The watchman have to consider all cells (x, y) of the matrix, such that x1 ≤ x ≤ x2 and y1 ≤ y ≤ y2, and if the number of the car in cell (x, y) does not exceed k, increase the answer to the request by the number of the car in cell (x, y). For each request Leha asks the watchman to tell him the resulting sum. Due to the fact that the sum can turn out to be quite large, hacker asks to calculate it modulo 109 + 7.
However the requests seem to be impracticable for the watchman. Help the watchman to answer all Leha's requests.
Input
The first line contains one integer q (1 ≤ q ≤ 104) — the number of Leha's requests.
The next q lines contain five integers x1, y1, x2, y2, k (1 ≤ x1 ≤ x2 ≤ 109, 1 ≤ y1 ≤ y2 ≤ 109, 1 ≤ k ≤ 2·109) — parameters of Leha's requests.
Output
Print exactly q lines — in the first line print the answer to the first request, in the second — the answer to the second request and so on.
Example
Input
4
1 1 1 1 1
3 2 5 4 5
1 1 5 5 10000
1 4 2 5 2
Output
1
13
93
0
Note
Let's analyze all the requests. In each case the requested submatrix is highlighted in blue.
In the first request (k = 1) Leha asks only about the upper left parking cell. In this cell the car's number is 1. Consequentally the answer is 1.
<image>
In the second request (k = 5) suitable numbers are 4, 1, 2, 3, 2, 1. Consequentally the answer is 4 + 1 + 2 + 3 + 2 + 1 = 13.
<image>
In the third request (k = 10000) Leha asks about the upper left frament 5 × 5 of the parking. Since k is big enough, the answer is equal to 93.
<image>
In the last request (k = 2) none of the cur's numbers are suitable, so the answer is 0.
<image> | 2 | 9 | #include <bits/stdc++.h>
const long long mod = 1000000007;
using namespace std;
long long f1[32][2][2][2], f2[32][2][2][2], t;
long long dp(long long l, long long r, long long k) {
if (l < 0 || r < 0) return 0;
for (long long i = 0; i <= 31; i++)
for (long long a = 0; a < 2; a++)
for (long long b = 0; b < 2; b++)
for (long long c = 0; c < 2; c++) f1[i][a][b][c] = f2[i][a][b][c] = 0;
f1[31][0][0][0] = 1;
for (long long i = 30; i >= 0; i--)
for (long long a = 0; a < 2; a++)
for (long long b = 0; b < 2; b++)
for (long long c = 0; c < 2; c++)
if (f1[i + 1][a][b][c]) {
for (long long aa = 0; aa < 2; aa++)
for (long long bb = 0; bb < 2; bb++) {
if (!a && aa && !(l & (1 << i))) continue;
if (!b && bb && !(r & (1 << i))) continue;
if (!c && !(k & (1 << i)) && (aa ^ bb)) continue;
long long na = a, nb = b, nc = c;
if (!aa && (l & (1 << i))) na |= 1;
if (!bb && (r & (1 << i))) nb |= 1;
if (!(aa ^ bb) && (k & (1 << i))) nc |= 1;
f1[i][na][nb][nc] =
(f1[i][na][nb][nc] + f1[i + 1][a][b][c]) % mod;
f2[i][na][nb][nc] =
(f2[i][na][nb][nc] + f2[i + 1][a][b][c]) % mod;
if (aa ^ bb)
f2[i][na][nb][nc] =
(f2[i][na][nb][nc] +
1ll * (1 << i) % mod * f1[i + 1][a][b][c] % mod) %
mod;
}
}
long long ans = 0;
for (long long a = 0; a <= 1; a++)
for (long long b = 0; b <= 1; b++)
for (long long c = 0; c <= 1; c++)
ans = (ans + f1[0][a][b][c] + f2[0][a][b][c]) % mod;
return ans;
}
signed main() {
scanf("%lld", &t);
do {
--t;
long long x, y, xx, yy, k;
scanf("%lld%lld%lld%lld%lld", &x, &y, &xx, &yy, &k);
--x;
--y;
--xx;
--yy;
--k;
printf("%lld\n", ((((dp(xx, yy, k) + dp(x - 1, y - 1, k)) % mod -
dp(xx, y - 1, k) + mod) %
mod -
dp(x - 1, yy, k)) %
mod +
mod) %
mod);
} while (t);
}
| CPP |
809_C. Find a car | After a wonderful evening in the restaurant the time to go home came. Leha as a true gentlemen suggested Noora to give her a lift. Certainly the girl agreed with pleasure. Suddenly one problem appeared: Leha cannot find his car on a huge parking near the restaurant. So he decided to turn to the watchman for help.
Formally the parking can be represented as a matrix 109 × 109. There is exactly one car in every cell of the matrix. All cars have their own machine numbers represented as a positive integer. Let's index the columns of the matrix by integers from 1 to 109 from left to right and the rows by integers from 1 to 109 from top to bottom. By coincidence it turned out, that for every cell (x, y) the number of the car, which stands in this cell, is equal to the minimum positive integer, which can't be found in the cells (i, y) and (x, j), 1 ≤ i < x, 1 ≤ j < y.
<image> The upper left fragment 5 × 5 of the parking
Leha wants to ask the watchman q requests, which can help him to find his car. Every request is represented as five integers x1, y1, x2, y2, k. The watchman have to consider all cells (x, y) of the matrix, such that x1 ≤ x ≤ x2 and y1 ≤ y ≤ y2, and if the number of the car in cell (x, y) does not exceed k, increase the answer to the request by the number of the car in cell (x, y). For each request Leha asks the watchman to tell him the resulting sum. Due to the fact that the sum can turn out to be quite large, hacker asks to calculate it modulo 109 + 7.
However the requests seem to be impracticable for the watchman. Help the watchman to answer all Leha's requests.
Input
The first line contains one integer q (1 ≤ q ≤ 104) — the number of Leha's requests.
The next q lines contain five integers x1, y1, x2, y2, k (1 ≤ x1 ≤ x2 ≤ 109, 1 ≤ y1 ≤ y2 ≤ 109, 1 ≤ k ≤ 2·109) — parameters of Leha's requests.
Output
Print exactly q lines — in the first line print the answer to the first request, in the second — the answer to the second request and so on.
Example
Input
4
1 1 1 1 1
3 2 5 4 5
1 1 5 5 10000
1 4 2 5 2
Output
1
13
93
0
Note
Let's analyze all the requests. In each case the requested submatrix is highlighted in blue.
In the first request (k = 1) Leha asks only about the upper left parking cell. In this cell the car's number is 1. Consequentally the answer is 1.
<image>
In the second request (k = 5) suitable numbers are 4, 1, 2, 3, 2, 1. Consequentally the answer is 4 + 1 + 2 + 3 + 2 + 1 = 13.
<image>
In the third request (k = 10000) Leha asks about the upper left frament 5 × 5 of the parking. Since k is big enough, the answer is equal to 93.
<image>
In the last request (k = 2) none of the cur's numbers are suitable, so the answer is 0.
<image> | 2 | 9 | #include <bits/stdc++.h>
using namespace std;
const int MX = 2e5 + 5;
const int inf = 0x3f3f3f3f;
const long long mod = 1e9 + 7;
long long k;
long long solve(int first, int second, long long f) {
if (first == 0 || second == 0 || f > k) return 0;
if (first < second) swap(first, second);
if (first == (first & -first)) {
long long l = f, r = min(k, f + first - 1);
return (l + r) * (r - l + 1) / 2 % mod * second % mod;
}
if (second == 1) {
long long l = f, r = min(k, f + first - 1);
return (l + r) * (r - l + 1) / 2 % mod;
}
int d = 1;
long long ret = 0;
while ((d << 1) < first) d <<= 1;
if (second <= d) {
(ret += solve(d, second, f)) %= mod;
;
(ret += solve(first - d, second, f + d)) %= mod;
;
} else {
(ret += solve(d, d, f)) %= mod;
;
(ret += solve(first - d, d, f + d)) %= mod;
;
(ret += solve(d, second - d, f + d)) %= mod;
;
(ret += solve(first - d, second - d, f)) %= mod;
;
}
return ret;
}
int main() {
int n;
scanf("%d", &n);
while (n--) {
int x1, x2, y1, y2;
scanf("%d%d%d%d%I64d", &x1, &y1, &x2, &y2, &k);
long long ans = solve(x2, y2, 1) + solve(x1 - 1, y1 - 1, 1);
ans -= solve(x1 - 1, y2, 1) + solve(x2, y1 - 1, 1);
printf("%I64d\n", (ans + 2 * mod) % mod);
}
return 0;
}
| CPP |
809_C. Find a car | After a wonderful evening in the restaurant the time to go home came. Leha as a true gentlemen suggested Noora to give her a lift. Certainly the girl agreed with pleasure. Suddenly one problem appeared: Leha cannot find his car on a huge parking near the restaurant. So he decided to turn to the watchman for help.
Formally the parking can be represented as a matrix 109 × 109. There is exactly one car in every cell of the matrix. All cars have their own machine numbers represented as a positive integer. Let's index the columns of the matrix by integers from 1 to 109 from left to right and the rows by integers from 1 to 109 from top to bottom. By coincidence it turned out, that for every cell (x, y) the number of the car, which stands in this cell, is equal to the minimum positive integer, which can't be found in the cells (i, y) and (x, j), 1 ≤ i < x, 1 ≤ j < y.
<image> The upper left fragment 5 × 5 of the parking
Leha wants to ask the watchman q requests, which can help him to find his car. Every request is represented as five integers x1, y1, x2, y2, k. The watchman have to consider all cells (x, y) of the matrix, such that x1 ≤ x ≤ x2 and y1 ≤ y ≤ y2, and if the number of the car in cell (x, y) does not exceed k, increase the answer to the request by the number of the car in cell (x, y). For each request Leha asks the watchman to tell him the resulting sum. Due to the fact that the sum can turn out to be quite large, hacker asks to calculate it modulo 109 + 7.
However the requests seem to be impracticable for the watchman. Help the watchman to answer all Leha's requests.
Input
The first line contains one integer q (1 ≤ q ≤ 104) — the number of Leha's requests.
The next q lines contain five integers x1, y1, x2, y2, k (1 ≤ x1 ≤ x2 ≤ 109, 1 ≤ y1 ≤ y2 ≤ 109, 1 ≤ k ≤ 2·109) — parameters of Leha's requests.
Output
Print exactly q lines — in the first line print the answer to the first request, in the second — the answer to the second request and so on.
Example
Input
4
1 1 1 1 1
3 2 5 4 5
1 1 5 5 10000
1 4 2 5 2
Output
1
13
93
0
Note
Let's analyze all the requests. In each case the requested submatrix is highlighted in blue.
In the first request (k = 1) Leha asks only about the upper left parking cell. In this cell the car's number is 1. Consequentally the answer is 1.
<image>
In the second request (k = 5) suitable numbers are 4, 1, 2, 3, 2, 1. Consequentally the answer is 4 + 1 + 2 + 3 + 2 + 1 = 13.
<image>
In the third request (k = 10000) Leha asks about the upper left frament 5 × 5 of the parking. Since k is big enough, the answer is equal to 93.
<image>
In the last request (k = 2) none of the cur's numbers are suitable, so the answer is 0.
<image> | 2 | 9 | #include <bits/stdc++.h>
using namespace std;
const int P = 1e9 + 7;
inline int kpow(long long a, long long b) {
long long r = 1;
while (b > 0) {
if (b & 1) r = r * a % P;
a = a * a % P, b >>= 1;
}
return r;
}
inline void inc(int &x, int y) {
if ((x += y) >= P) x -= P;
}
int dfs(int x, int y, int k, int dw) {
if (x <= 0 || y <= 0 || k <= 0) return 0;
if (x < y) swap(x, y);
if (x == (x & -x)) {
int b = min(x, k);
return 1ll * (dw + 1 + dw + b) * b % P * y % P;
}
int t = 1, ret = 0;
while ((t << 1) < x) t <<= 1;
if (y <= t) {
ret = dfs(t, y, k, dw);
inc(ret, dfs(x - t, y, k - t, dw + t));
} else {
ret = dfs(t, t, k, dw);
inc(ret, dfs(x - t, y - t, k, dw));
inc(ret, dfs(x - t, t, k - t, dw + t));
inc(ret, dfs(t, y - t, k - t, dw + t));
}
return ret;
}
int main() {
int q;
scanf("%d", &q);
int inv2 = kpow(2, P - 2);
while (q--) {
int x1, y1, x2, y2, k;
scanf("%d%d%d%d%d", &x1, &y1, &x2, &y2, &k);
int ans = 0;
inc(ans, (dfs(x2, y2, k, 0) + dfs(x1 - 1, y1 - 1, k, 0)) % P);
inc(ans, P - dfs(x2, y1 - 1, k, 0));
inc(ans, P - dfs(x1 - 1, y2, k, 0));
ans = 1ll * ans * inv2 % P;
printf("%d\n", ans);
}
return 0;
}
| CPP |
809_C. Find a car | After a wonderful evening in the restaurant the time to go home came. Leha as a true gentlemen suggested Noora to give her a lift. Certainly the girl agreed with pleasure. Suddenly one problem appeared: Leha cannot find his car on a huge parking near the restaurant. So he decided to turn to the watchman for help.
Formally the parking can be represented as a matrix 109 × 109. There is exactly one car in every cell of the matrix. All cars have their own machine numbers represented as a positive integer. Let's index the columns of the matrix by integers from 1 to 109 from left to right and the rows by integers from 1 to 109 from top to bottom. By coincidence it turned out, that for every cell (x, y) the number of the car, which stands in this cell, is equal to the minimum positive integer, which can't be found in the cells (i, y) and (x, j), 1 ≤ i < x, 1 ≤ j < y.
<image> The upper left fragment 5 × 5 of the parking
Leha wants to ask the watchman q requests, which can help him to find his car. Every request is represented as five integers x1, y1, x2, y2, k. The watchman have to consider all cells (x, y) of the matrix, such that x1 ≤ x ≤ x2 and y1 ≤ y ≤ y2, and if the number of the car in cell (x, y) does not exceed k, increase the answer to the request by the number of the car in cell (x, y). For each request Leha asks the watchman to tell him the resulting sum. Due to the fact that the sum can turn out to be quite large, hacker asks to calculate it modulo 109 + 7.
However the requests seem to be impracticable for the watchman. Help the watchman to answer all Leha's requests.
Input
The first line contains one integer q (1 ≤ q ≤ 104) — the number of Leha's requests.
The next q lines contain five integers x1, y1, x2, y2, k (1 ≤ x1 ≤ x2 ≤ 109, 1 ≤ y1 ≤ y2 ≤ 109, 1 ≤ k ≤ 2·109) — parameters of Leha's requests.
Output
Print exactly q lines — in the first line print the answer to the first request, in the second — the answer to the second request and so on.
Example
Input
4
1 1 1 1 1
3 2 5 4 5
1 1 5 5 10000
1 4 2 5 2
Output
1
13
93
0
Note
Let's analyze all the requests. In each case the requested submatrix is highlighted in blue.
In the first request (k = 1) Leha asks only about the upper left parking cell. In this cell the car's number is 1. Consequentally the answer is 1.
<image>
In the second request (k = 5) suitable numbers are 4, 1, 2, 3, 2, 1. Consequentally the answer is 4 + 1 + 2 + 3 + 2 + 1 = 13.
<image>
In the third request (k = 10000) Leha asks about the upper left frament 5 × 5 of the parking. Since k is big enough, the answer is equal to 93.
<image>
In the last request (k = 2) none of the cur's numbers are suitable, so the answer is 0.
<image> | 2 | 9 | #include <bits/stdc++.h>
using namespace std;
const long long mdl = 1000 * 1000 * 1000 + 7;
const int size = 100;
const int bits = 30;
map<pair<int, int>, int> sum[bits];
map<pair<int, pair<int, int> >, int> ans[bits];
map<pair<int, pair<int, int> >, int> cnt[bits];
int getcount(int b, int x, int y, int k) {
if (x < 0 || y < 0 || k == 0) return 0;
if (x > y) return getcount(b, y, x, k);
auto it = cnt[b].find(make_pair(k, make_pair(x, y)));
if (it != cnt[b].end()) return it->second;
if (b == 0) {
int ansv = 0;
for (int i = 0; i <= x; i++)
for (int j = 0; j <= y; j++) {
int d = (i ^ j) + 1;
if (d <= k) ansv++;
}
cnt[b][make_pair(k, make_pair(x, y))] = ansv;
return ansv;
}
int ansv = 0;
int len = (1 << b);
if ((k >> b) & 1) {
int h = min(x, len - 1) + 1;
int w = min(y, len - 1) + 1;
ansv = (h * 1ll * w) % mdl;
h = max(0, x - len + 1);
w = max(0, y - len + 1);
ansv = (ansv + h * 1ll * w) % mdl;
ansv += getcount(b - 1, min(x, len - 1), y - len, k - len);
if (ansv >= mdl) ansv -= mdl;
ansv += getcount(b - 1, x - len, min(y, len - 1), k - len);
if (ansv >= mdl) ansv -= mdl;
} else {
ansv = getcount(b - 1, min(x, len - 1), min(y, len - 1), k);
ansv += getcount(b - 1, x - len, y - len, k);
if (ansv >= mdl) ansv -= mdl;
}
cnt[b][make_pair(k, make_pair(x, y))] = ansv;
return ansv;
}
int getsum(int b, int x, int y) {
if (x < 0 || y < 0) return 0;
if (x > y) return getsum(b, y, x);
auto it = sum[b].find(make_pair(x, y));
if (it != sum[b].end()) return it->second;
int ansv = 0;
if (b == 0) {
for (int i = 0; i <= x; i++)
for (int j = 0; j <= y; j++) ansv += (i ^ j) + 1;
} else {
int len = (1 << b);
ansv = getsum(b - 1, min(x, len - 1), min(y, len - 1));
ansv += getsum(b - 1, x - len, y - len);
if (ansv >= mdl) ansv -= mdl;
ansv += getsum(b - 1, min(x, len - 1), y - len);
if (ansv >= mdl) ansv -= mdl;
ansv += getsum(b - 1, x - len, min(y, len - 1));
if (ansv >= mdl) ansv -= mdl;
int w = max(0, x - len + 1);
int h = min(y, len - 1) + 1;
ansv = (ansv + ((w * 1ll * h) % mdl) * 1ll * len) % mdl;
w = min(x, len - 1) + 1;
h = max(0, y - len + 1);
ansv = (ansv + ((w * 1ll * h) % mdl) * 1ll * len) % mdl;
}
sum[b][make_pair(x, y)] = ansv;
return ansv;
}
int getans(int b, int x, int y, int k) {
if (x < 0 || y < 0 || k == 0) return 0;
if (x > y) return getans(b, y, x, k);
auto it = ans[b].find(make_pair(k, make_pair(x, y)));
if (it != ans[b].end()) return it->second;
if (b == 0) {
int ansv = 0;
for (int i = 0; i <= x; i++)
for (int j = 0; j <= y; j++) {
int d = (i ^ j) + 1;
if (d <= k) ansv += d;
}
ans[b][make_pair(k, make_pair(x, y))] = ansv;
return ansv;
}
int ansv = 0;
int len = (1 << b);
if ((k >> b) & 1) {
ansv = getsum(b - 1, min(x, len - 1), min(y, len - 1));
ansv += getsum(b - 1, x - len, y - len);
if (ansv >= mdl) ansv -= mdl;
ansv += getans(b - 1, min(x, len - 1), y - len, k - len);
if (ansv >= mdl) ansv -= mdl;
int h = getcount(b - 1, min(x, len - 1), y - len, k - len);
ansv = (ansv + h * 1ll * len) % mdl;
ansv += getans(b - 1, x - len, min(y, len - 1), k - len);
if (ansv >= mdl) ansv -= mdl;
h = getcount(b - 1, x - len, min(y, len - 1), k - len);
ansv = (ansv + h * 1ll * len) % mdl;
} else {
ansv = getans(b - 1, min(x, len - 1), min(y, len - 1), k);
ansv += getans(b - 1, x - len, y - len, k);
if (ansv >= mdl) ansv -= mdl;
}
ans[b][make_pair(k, make_pair(x, y))] = ansv;
return ansv;
}
int main() {
int q;
scanf("%d", &q);
for (int t = 0; t < q; t++) {
int l, r, u, d, k;
scanf("%d%d%d%d%d", &l, &u, &r, &d, &k);
l--, r--, u--, d--;
long long ans;
if (k >= (1ll << bits) - 1) {
ans = (0ll + getsum(bits - 1, r, d) - getsum(bits - 1, l - 1, d) -
getsum(bits - 1, r, u - 1) + getsum(bits - 1, l - 1, u - 1));
} else {
ans = 0ll + getans(bits - 1, r, d, k) - getans(bits - 1, l - 1, d, k) -
getans(bits - 1, r, u - 1, k) + getans(bits - 1, l - 1, u - 1, k);
}
printf("%d\n", int((ans + mdl + mdl) % mdl));
}
return 0;
}
| CPP |
809_C. Find a car | After a wonderful evening in the restaurant the time to go home came. Leha as a true gentlemen suggested Noora to give her a lift. Certainly the girl agreed with pleasure. Suddenly one problem appeared: Leha cannot find his car on a huge parking near the restaurant. So he decided to turn to the watchman for help.
Formally the parking can be represented as a matrix 109 × 109. There is exactly one car in every cell of the matrix. All cars have their own machine numbers represented as a positive integer. Let's index the columns of the matrix by integers from 1 to 109 from left to right and the rows by integers from 1 to 109 from top to bottom. By coincidence it turned out, that for every cell (x, y) the number of the car, which stands in this cell, is equal to the minimum positive integer, which can't be found in the cells (i, y) and (x, j), 1 ≤ i < x, 1 ≤ j < y.
<image> The upper left fragment 5 × 5 of the parking
Leha wants to ask the watchman q requests, which can help him to find his car. Every request is represented as five integers x1, y1, x2, y2, k. The watchman have to consider all cells (x, y) of the matrix, such that x1 ≤ x ≤ x2 and y1 ≤ y ≤ y2, and if the number of the car in cell (x, y) does not exceed k, increase the answer to the request by the number of the car in cell (x, y). For each request Leha asks the watchman to tell him the resulting sum. Due to the fact that the sum can turn out to be quite large, hacker asks to calculate it modulo 109 + 7.
However the requests seem to be impracticable for the watchman. Help the watchman to answer all Leha's requests.
Input
The first line contains one integer q (1 ≤ q ≤ 104) — the number of Leha's requests.
The next q lines contain five integers x1, y1, x2, y2, k (1 ≤ x1 ≤ x2 ≤ 109, 1 ≤ y1 ≤ y2 ≤ 109, 1 ≤ k ≤ 2·109) — parameters of Leha's requests.
Output
Print exactly q lines — in the first line print the answer to the first request, in the second — the answer to the second request and so on.
Example
Input
4
1 1 1 1 1
3 2 5 4 5
1 1 5 5 10000
1 4 2 5 2
Output
1
13
93
0
Note
Let's analyze all the requests. In each case the requested submatrix is highlighted in blue.
In the first request (k = 1) Leha asks only about the upper left parking cell. In this cell the car's number is 1. Consequentally the answer is 1.
<image>
In the second request (k = 5) suitable numbers are 4, 1, 2, 3, 2, 1. Consequentally the answer is 4 + 1 + 2 + 3 + 2 + 1 = 13.
<image>
In the third request (k = 10000) Leha asks about the upper left frament 5 × 5 of the parking. Since k is big enough, the answer is equal to 93.
<image>
In the last request (k = 2) none of the cur's numbers are suitable, so the answer is 0.
<image> | 2 | 9 | #include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool ckmin(T &a, const T &b) {
return b < a ? a = b, 1 : 0;
}
template <typename T>
inline bool ckmax(T &a, const T &b) {
return a < b ? a = b, 1 : 0;
}
const int LG = 31, P = 1e9 + 7;
int a[LG], b[LG], c[LG];
pair<int, int> dp[LG][2][2][2];
int &Mod(int &first) { return first += (first >> 31) & P; }
pair<int, int> operator+(pair<int, int> a, pair<int, int> b) {
return make_pair(Mod(a.first += b.first - P), Mod(a.second += b.second - P));
}
pair<int, int> DP(int n, int la, int lb, int lc) {
if (n < 0) return make_pair(1, 0);
if (dp[n][la][lb][lc] != make_pair(-1, -1)) return dp[n][la][lb][lc];
int ma = la ? a[n] : 1, mb = lb ? b[n] : 1, mc = lc ? c[n] : 1;
pair<int, int> &res = dp[n][la][lb][lc];
res = make_pair(0, 0);
for (int i = 0; i <= ma; i++) {
for (int j = 0; j <= mb; j++) {
if ((i ^ j) > mc) continue;
pair<int, int> nxt =
DP(n - 1, la && i == ma, lb && j == mb, lc && (i ^ j) == mc);
res = res + nxt;
if (i ^ j) Mod(res.second += ((long long)nxt.first << n) % P - P);
}
}
return res;
}
int solve(int n, int m, int k) {
memset(dp, -1, sizeof(dp));
if (n < 0 || m < 0 || k < 0) return 0;
for (int i = 0; i < LG; i++) {
a[i] = (n & 1), n >>= 1;
b[i] = (m & 1), m >>= 1;
c[i] = (k & 1), k >>= 1;
}
pair<int, int> ans = DP(LG - 1, 1, 1, 1);
return Mod(ans.first += ans.second - P);
}
int main() {
int q;
scanf("%d", &q);
for (; q--;) {
int u, d, l, r, k;
scanf("%d%d%d%d%d", &u, &l, &d, &r, &k);
u--, d--, l--, r--, k--;
int res = 0;
Mod(res += solve(d, r, k) - P);
Mod(res -= solve(u - 1, r, k));
Mod(res -= solve(d, l - 1, k));
Mod(res += solve(u - 1, l - 1, k) - P);
printf("%d\n", res);
}
return 0;
}
| CPP |
809_C. Find a car | After a wonderful evening in the restaurant the time to go home came. Leha as a true gentlemen suggested Noora to give her a lift. Certainly the girl agreed with pleasure. Suddenly one problem appeared: Leha cannot find his car on a huge parking near the restaurant. So he decided to turn to the watchman for help.
Formally the parking can be represented as a matrix 109 × 109. There is exactly one car in every cell of the matrix. All cars have their own machine numbers represented as a positive integer. Let's index the columns of the matrix by integers from 1 to 109 from left to right and the rows by integers from 1 to 109 from top to bottom. By coincidence it turned out, that for every cell (x, y) the number of the car, which stands in this cell, is equal to the minimum positive integer, which can't be found in the cells (i, y) and (x, j), 1 ≤ i < x, 1 ≤ j < y.
<image> The upper left fragment 5 × 5 of the parking
Leha wants to ask the watchman q requests, which can help him to find his car. Every request is represented as five integers x1, y1, x2, y2, k. The watchman have to consider all cells (x, y) of the matrix, such that x1 ≤ x ≤ x2 and y1 ≤ y ≤ y2, and if the number of the car in cell (x, y) does not exceed k, increase the answer to the request by the number of the car in cell (x, y). For each request Leha asks the watchman to tell him the resulting sum. Due to the fact that the sum can turn out to be quite large, hacker asks to calculate it modulo 109 + 7.
However the requests seem to be impracticable for the watchman. Help the watchman to answer all Leha's requests.
Input
The first line contains one integer q (1 ≤ q ≤ 104) — the number of Leha's requests.
The next q lines contain five integers x1, y1, x2, y2, k (1 ≤ x1 ≤ x2 ≤ 109, 1 ≤ y1 ≤ y2 ≤ 109, 1 ≤ k ≤ 2·109) — parameters of Leha's requests.
Output
Print exactly q lines — in the first line print the answer to the first request, in the second — the answer to the second request and so on.
Example
Input
4
1 1 1 1 1
3 2 5 4 5
1 1 5 5 10000
1 4 2 5 2
Output
1
13
93
0
Note
Let's analyze all the requests. In each case the requested submatrix is highlighted in blue.
In the first request (k = 1) Leha asks only about the upper left parking cell. In this cell the car's number is 1. Consequentally the answer is 1.
<image>
In the second request (k = 5) suitable numbers are 4, 1, 2, 3, 2, 1. Consequentally the answer is 4 + 1 + 2 + 3 + 2 + 1 = 13.
<image>
In the third request (k = 10000) Leha asks about the upper left frament 5 × 5 of the parking. Since k is big enough, the answer is equal to 93.
<image>
In the last request (k = 2) none of the cur's numbers are suitable, so the answer is 0.
<image> | 2 | 9 | #include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int query, x, xx, y, yy, k;
int mex(int x) { return 1 << (31 - __builtin_clz(x)); }
pair<long long, long long> dfs(int x, int y, int bit) {
if (bit == 0) return make_pair(0ll, 0ll);
if (x == 0) return make_pair(0ll, 0ll);
if (y == 0) return make_pair(0ll, 0ll);
if (x > y) swap(x, y);
int z = mex(y);
int bit1 = min(z, bit);
long long gas = 0, ans = 0;
if (z > x) {
ans = (((long long)bit1 * (bit1 + 1) / 2) % mod) * x % mod;
gas = (long long)bit1 * x % mod;
pair<long long, long long> tmp = dfs(x, y - z, max(bit - z, 0));
ans = (ans + tmp.first + tmp.second * z) % mod;
gas = (gas + tmp.second) % mod;
} else {
ans = (((long long)bit1 * (bit1 + 1) / 2) % mod) * z % mod;
gas = (long long)bit1 * z % mod;
pair<long long, long long> tmp = dfs(x - z, y - z, bit);
ans = (ans + tmp.first) % mod;
gas = (gas + tmp.second) % mod;
tmp = dfs(z, y - z, max(bit - z, 0));
ans = (ans + tmp.first + tmp.second * z) % mod;
gas = (gas + tmp.second) % mod;
tmp = dfs(x - z, z, max(bit - z, 0));
ans = (ans + tmp.first + tmp.second * z) % mod;
gas = (gas + tmp.second) % mod;
}
return make_pair(ans, gas);
}
int main() {
for (scanf("%d", &query); query--;) {
scanf("%d %d %d %d %d", &x, &y, &xx, &yy, &k);
int ans = 0;
pair<long long, long long> tmp = dfs(xx, yy, k);
ans = (ans + tmp.first) % mod;
tmp = dfs(x - 1, y - 1, k);
ans = (ans + tmp.first) % mod;
tmp = dfs(x - 1, yy, k);
ans = (ans + mod - tmp.first) % mod;
tmp = dfs(xx, y - 1, k);
ans = (ans + mod - tmp.first) % mod;
printf("%d\n", ans);
}
}
| CPP |
809_C. Find a car | After a wonderful evening in the restaurant the time to go home came. Leha as a true gentlemen suggested Noora to give her a lift. Certainly the girl agreed with pleasure. Suddenly one problem appeared: Leha cannot find his car on a huge parking near the restaurant. So he decided to turn to the watchman for help.
Formally the parking can be represented as a matrix 109 × 109. There is exactly one car in every cell of the matrix. All cars have their own machine numbers represented as a positive integer. Let's index the columns of the matrix by integers from 1 to 109 from left to right and the rows by integers from 1 to 109 from top to bottom. By coincidence it turned out, that for every cell (x, y) the number of the car, which stands in this cell, is equal to the minimum positive integer, which can't be found in the cells (i, y) and (x, j), 1 ≤ i < x, 1 ≤ j < y.
<image> The upper left fragment 5 × 5 of the parking
Leha wants to ask the watchman q requests, which can help him to find his car. Every request is represented as five integers x1, y1, x2, y2, k. The watchman have to consider all cells (x, y) of the matrix, such that x1 ≤ x ≤ x2 and y1 ≤ y ≤ y2, and if the number of the car in cell (x, y) does not exceed k, increase the answer to the request by the number of the car in cell (x, y). For each request Leha asks the watchman to tell him the resulting sum. Due to the fact that the sum can turn out to be quite large, hacker asks to calculate it modulo 109 + 7.
However the requests seem to be impracticable for the watchman. Help the watchman to answer all Leha's requests.
Input
The first line contains one integer q (1 ≤ q ≤ 104) — the number of Leha's requests.
The next q lines contain five integers x1, y1, x2, y2, k (1 ≤ x1 ≤ x2 ≤ 109, 1 ≤ y1 ≤ y2 ≤ 109, 1 ≤ k ≤ 2·109) — parameters of Leha's requests.
Output
Print exactly q lines — in the first line print the answer to the first request, in the second — the answer to the second request and so on.
Example
Input
4
1 1 1 1 1
3 2 5 4 5
1 1 5 5 10000
1 4 2 5 2
Output
1
13
93
0
Note
Let's analyze all the requests. In each case the requested submatrix is highlighted in blue.
In the first request (k = 1) Leha asks only about the upper left parking cell. In this cell the car's number is 1. Consequentally the answer is 1.
<image>
In the second request (k = 5) suitable numbers are 4, 1, 2, 3, 2, 1. Consequentally the answer is 4 + 1 + 2 + 3 + 2 + 1 = 13.
<image>
In the third request (k = 10000) Leha asks about the upper left frament 5 × 5 of the parking. Since k is big enough, the answer is equal to 93.
<image>
In the last request (k = 2) none of the cur's numbers are suitable, so the answer is 0.
<image> | 2 | 9 | #include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int mcm(int a, int b) { return a * b / gcd(a, b); }
int sq(int a) { return a * a; }
int pot(int a, int b) { return b ? sq(pot(a, b >> 1)) * (b & 1 ? a : 1) : 1; }
int roofLog2(int n) {
int r = 1;
for (; r < n; r <<= 1)
;
return r;
}
vector<int> xbits, ybits, kbits;
unsigned long long solvedp[32][2][2][2], countdp[32][2][2][2];
bool has_solvedp[32][2][2][2], has_countdp[32][2][2][2];
unsigned long long add(unsigned long long a, unsigned long long b) {
return (a + b) % 1000000007;
}
unsigned long long sub(unsigned long long a, unsigned long long b) {
return (a + 1000000007 - b) % 1000000007;
}
unsigned long long mul(unsigned long long a, unsigned long long b) {
return a * b % 1000000007;
}
unsigned long long count(int index, int eqx, int eqy, int eqk) {
if (index == -1) return 1;
unsigned long long &res = countdp[index][eqx][eqy][eqk];
if (has_countdp[index][eqx][eqy][eqk]) return res;
res = 0;
res = add(res, count(index - 1, !xbits[index] && eqx, !ybits[index] && eqy,
!kbits[index] && eqk));
if ((xbits[index] || !eqx) && (kbits[index] || !eqk))
res = add(res, count(index - 1, xbits[index] && eqx, !ybits[index] && eqy,
kbits[index] && eqk));
if ((ybits[index] || !eqy) && (kbits[index] || !eqk))
res = add(res, count(index - 1, !xbits[index] && eqx, ybits[index] && eqy,
kbits[index] && eqk));
if ((xbits[index] || !eqx) && (ybits[index] || !eqy))
res = add(res, count(index - 1, xbits[index] && eqx, ybits[index] && eqy,
!kbits[index] && eqk));
has_countdp[index][eqx][eqy][eqk] = true;
return res;
}
unsigned long long solve(int index, int eqx, int eqy, int eqk) {
if (index == -1) return 1;
unsigned long long &res = solvedp[index][eqx][eqy][eqk];
if (has_solvedp[index][eqx][eqy][eqk]) return res;
res = 0;
res = add(res, solve(index - 1, !xbits[index] && eqx, !ybits[index] && eqy,
!kbits[index] && eqk));
if ((xbits[index] || !eqx) && (kbits[index] || !eqk)) {
res = add(res, solve(index - 1, xbits[index] && eqx, !ybits[index] && eqy,
kbits[index] && eqk));
res = add(
res, mul(1 << index, count(index - 1, xbits[index] && eqx,
!ybits[index] && eqy, kbits[index] && eqk)));
}
if ((ybits[index] || !eqy) && (kbits[index] || !eqk)) {
res = add(res, solve(index - 1, !xbits[index] && eqx, ybits[index] && eqy,
kbits[index] && eqk));
res = add(res,
mul(1 << index, count(index - 1, !xbits[index] && eqx,
ybits[index] && eqy, kbits[index] && eqk)));
}
if ((xbits[index] || !eqx) && (ybits[index] || !eqy))
res = add(res, solve(index - 1, xbits[index] && eqx, ybits[index] && eqy,
!kbits[index] && eqk));
has_solvedp[index][eqx][eqy][eqk] = true;
return res;
}
unsigned long long sum(int x, int y, int k) {
if (x < 0 || y < 0 || k < 0) return 0;
xbits.clear();
ybits.clear();
kbits.clear();
for (int i = (0); i < (32); i++) {
xbits.push_back(x % 2);
ybits.push_back(y % 2);
kbits.push_back(k % 2);
x /= 2;
y /= 2;
k /= 2;
}
memset(has_solvedp, false, sizeof(has_solvedp));
memset(has_countdp, false, sizeof(has_countdp));
return solve(32 - 1, 1, 1, 1);
}
int main() {
int q;
cin >> q;
while ((q)--) {
unsigned long long x1, y1, x2, y2, k;
cin >> x1 >> y1 >> x2 >> y2 >> k;
x1--;
y1--;
x2--;
y2--;
k--;
unsigned long long res = 0;
res = add(res, sum(x2, y2, k));
res = sub(res, sum(x1 - 1, y2, k));
res = sub(res, sum(x2, y1 - 1, k));
res = add(res, sum(x1 - 1, y1 - 1, k));
cout << res << endl;
}
return 0;
}
| CPP |
809_C. Find a car | After a wonderful evening in the restaurant the time to go home came. Leha as a true gentlemen suggested Noora to give her a lift. Certainly the girl agreed with pleasure. Suddenly one problem appeared: Leha cannot find his car on a huge parking near the restaurant. So he decided to turn to the watchman for help.
Formally the parking can be represented as a matrix 109 × 109. There is exactly one car in every cell of the matrix. All cars have their own machine numbers represented as a positive integer. Let's index the columns of the matrix by integers from 1 to 109 from left to right and the rows by integers from 1 to 109 from top to bottom. By coincidence it turned out, that for every cell (x, y) the number of the car, which stands in this cell, is equal to the minimum positive integer, which can't be found in the cells (i, y) and (x, j), 1 ≤ i < x, 1 ≤ j < y.
<image> The upper left fragment 5 × 5 of the parking
Leha wants to ask the watchman q requests, which can help him to find his car. Every request is represented as five integers x1, y1, x2, y2, k. The watchman have to consider all cells (x, y) of the matrix, such that x1 ≤ x ≤ x2 and y1 ≤ y ≤ y2, and if the number of the car in cell (x, y) does not exceed k, increase the answer to the request by the number of the car in cell (x, y). For each request Leha asks the watchman to tell him the resulting sum. Due to the fact that the sum can turn out to be quite large, hacker asks to calculate it modulo 109 + 7.
However the requests seem to be impracticable for the watchman. Help the watchman to answer all Leha's requests.
Input
The first line contains one integer q (1 ≤ q ≤ 104) — the number of Leha's requests.
The next q lines contain five integers x1, y1, x2, y2, k (1 ≤ x1 ≤ x2 ≤ 109, 1 ≤ y1 ≤ y2 ≤ 109, 1 ≤ k ≤ 2·109) — parameters of Leha's requests.
Output
Print exactly q lines — in the first line print the answer to the first request, in the second — the answer to the second request and so on.
Example
Input
4
1 1 1 1 1
3 2 5 4 5
1 1 5 5 10000
1 4 2 5 2
Output
1
13
93
0
Note
Let's analyze all the requests. In each case the requested submatrix is highlighted in blue.
In the first request (k = 1) Leha asks only about the upper left parking cell. In this cell the car's number is 1. Consequentally the answer is 1.
<image>
In the second request (k = 5) suitable numbers are 4, 1, 2, 3, 2, 1. Consequentally the answer is 4 + 1 + 2 + 3 + 2 + 1 = 13.
<image>
In the third request (k = 10000) Leha asks about the upper left frament 5 × 5 of the parking. Since k is big enough, the answer is equal to 93.
<image>
In the last request (k = 2) none of the cur's numbers are suitable, so the answer is 0.
<image> | 2 | 9 | #include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
struct data {
int x1, y1, x2, y2, len;
inline data() {}
inline data(int _x1, int _y1, int _x2, int _y2)
: x1(_x1), y1(_y1), x2(_x2), y2(_y2), len(x2 - x1 + 1) {}
inline data ls() { return data(x1, y1, x2 - len / 2, y2 - len / 2); }
inline data rs() { return data(x1 + len / 2, y1, x2, y2 - len / 2); }
inline data ls1() { return data(x1, y1 + len / 2, x2 - len / 2, y2); }
inline data rs1() { return data(x1 + len / 2, y1 + len / 2, x2, y2); }
inline data ins(data a) {
return data(max(x1, a.x1), max(y1, a.y1), min(x2, a.x2), min(y2, a.y2));
}
bool check() { return x1 <= x2 && y1 <= y2; }
int size() { return (long long)(x2 - x1 + 1) * (y2 - y1 + 1) % mod; }
};
inline int get(int x) { return (long long)x * (x + 1) / 2 % mod; }
int solve(data a, data b, int K, int dir) {
if (K <= 0 || !b.check()) return 0;
int val = get(min(a.len, K)), d = min(a.len, K);
if (b.y1 == a.y1 && b.y2 == a.y2) {
int x = b.x2 - b.x1 + 1;
return ((long long)val * x % mod + (long long)dir * d % mod * x % mod) %
mod;
}
if (b.x1 == a.x1 && b.x2 == a.x2) {
int y = b.y2 - b.y1 + 1;
return ((long long)val * y % mod + (long long)dir * d % mod * y % mod) %
mod;
}
long long ans = 0;
data temp1, temp2;
temp1 = a.ls();
temp2 = temp1.ins(b);
ans += solve(temp1, temp2, K, dir);
temp1 = a.rs();
temp2 = temp1.ins(b);
ans += solve(temp1, temp2, K - a.len / 2, dir + a.len / 2);
temp1 = a.ls1();
temp2 = temp1.ins(b);
ans += solve(temp1, temp2, K - a.len / 2, dir + a.len / 2);
temp1 = a.rs1();
temp2 = temp1.ins(b);
ans += solve(temp1, temp2, K, dir);
return ans % mod;
}
int main() {
int Q;
cin >> Q;
while (Q--) {
int x1, x2, y1, y2, K, len = 0;
scanf("%d%d%d%d%d", &x1, &y1, &x2, &y2, &K);
swap(x1, y1);
swap(x2, y2);
for (len = 1; len < x2 || len < y2; len <<= 1)
;
int ans = solve(data(1, 1, len, len), data(x1, y1, x2, y2), K, 0);
printf("%d\n", ans);
}
return 0;
}
| CPP |
809_C. Find a car | After a wonderful evening in the restaurant the time to go home came. Leha as a true gentlemen suggested Noora to give her a lift. Certainly the girl agreed with pleasure. Suddenly one problem appeared: Leha cannot find his car on a huge parking near the restaurant. So he decided to turn to the watchman for help.
Formally the parking can be represented as a matrix 109 × 109. There is exactly one car in every cell of the matrix. All cars have their own machine numbers represented as a positive integer. Let's index the columns of the matrix by integers from 1 to 109 from left to right and the rows by integers from 1 to 109 from top to bottom. By coincidence it turned out, that for every cell (x, y) the number of the car, which stands in this cell, is equal to the minimum positive integer, which can't be found in the cells (i, y) and (x, j), 1 ≤ i < x, 1 ≤ j < y.
<image> The upper left fragment 5 × 5 of the parking
Leha wants to ask the watchman q requests, which can help him to find his car. Every request is represented as five integers x1, y1, x2, y2, k. The watchman have to consider all cells (x, y) of the matrix, such that x1 ≤ x ≤ x2 and y1 ≤ y ≤ y2, and if the number of the car in cell (x, y) does not exceed k, increase the answer to the request by the number of the car in cell (x, y). For each request Leha asks the watchman to tell him the resulting sum. Due to the fact that the sum can turn out to be quite large, hacker asks to calculate it modulo 109 + 7.
However the requests seem to be impracticable for the watchman. Help the watchman to answer all Leha's requests.
Input
The first line contains one integer q (1 ≤ q ≤ 104) — the number of Leha's requests.
The next q lines contain five integers x1, y1, x2, y2, k (1 ≤ x1 ≤ x2 ≤ 109, 1 ≤ y1 ≤ y2 ≤ 109, 1 ≤ k ≤ 2·109) — parameters of Leha's requests.
Output
Print exactly q lines — in the first line print the answer to the first request, in the second — the answer to the second request and so on.
Example
Input
4
1 1 1 1 1
3 2 5 4 5
1 1 5 5 10000
1 4 2 5 2
Output
1
13
93
0
Note
Let's analyze all the requests. In each case the requested submatrix is highlighted in blue.
In the first request (k = 1) Leha asks only about the upper left parking cell. In this cell the car's number is 1. Consequentally the answer is 1.
<image>
In the second request (k = 5) suitable numbers are 4, 1, 2, 3, 2, 1. Consequentally the answer is 4 + 1 + 2 + 3 + 2 + 1 = 13.
<image>
In the third request (k = 10000) Leha asks about the upper left frament 5 × 5 of the parking. Since k is big enough, the answer is equal to 93.
<image>
In the last request (k = 2) none of the cur's numbers are suitable, so the answer is 0.
<image> | 2 | 9 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using db = double;
using vi = vector<int>;
const ll mod = (ll)1e9 + 7;
ll f[40][2][2][2];
ll g[40][2][2][2];
ll getbit(ll x, ll k) { return (x >> k) & 1; }
void ud(ll &x, ll y) { (x += y) %= mod; }
ll solve(ll x, ll y, ll k) {
if (x == 0 || y == 0) return 0;
x--;
y--;
k--;
memset(f, 0, sizeof(f));
memset(g, 0, sizeof(g));
x++;
y++;
k++;
f[0][0][0][0] = 1;
g[0][0][0][0] = 0;
for (ll i = 1; i <= 31; ++i) {
for (ll xi = 0; xi <= 1; ++xi)
for (ll yi = 0; yi <= 1; ++yi)
for (ll ki = 0; ki <= 1; ++ki) {
for (ll tx = 0; tx <= 1; ++tx)
if (xi * 2 + tx <= 2 + getbit(x, i - 1))
for (ll ty = 0; ty <= 1; ++ty)
if (yi * 2 + ty <= 2 + getbit(y, i - 1)) {
ll tk = (tx ^ ty);
if (ki * 2 + tk <= 2 + getbit(k, i - 1)) {
int xj = (xi * 2 + tx == 2 + getbit(x, i - 1));
int yj = (yi * 2 + ty == 2 + getbit(y, i - 1));
int kj = (ki * 2 + tk == 2 + getbit(k, i - 1));
ud(f[i][xi][yi][ki], f[i - 1][xj][yj][kj]);
ud(g[i][xi][yi][ki],
g[i - 1][xj][yj][kj] +
f[i - 1][xj][yj][kj] * ((tk << (i - 1)) % mod));
}
}
}
}
return (g[31][1][1][1] + f[31][1][1][1]) % mod;
}
int q;
ll X1, Y1, X2, Y2, k;
int main() {
scanf("%d", &q);
for (int i = 1; i <= q; ++i) {
scanf("%lld%lld%lld%lld%lld", &X1, &Y1, &X2, &Y2, &k);
ll ans = solve(X2, Y2, k) - solve(X1 - 1, Y2, k) - solve(X2, Y1 - 1, k) +
solve(X1 - 1, Y1 - 1, k);
cout << (ans % mod + mod) % mod << endl;
}
return 0;
}
| CPP |
809_C. Find a car | After a wonderful evening in the restaurant the time to go home came. Leha as a true gentlemen suggested Noora to give her a lift. Certainly the girl agreed with pleasure. Suddenly one problem appeared: Leha cannot find his car on a huge parking near the restaurant. So he decided to turn to the watchman for help.
Formally the parking can be represented as a matrix 109 × 109. There is exactly one car in every cell of the matrix. All cars have their own machine numbers represented as a positive integer. Let's index the columns of the matrix by integers from 1 to 109 from left to right and the rows by integers from 1 to 109 from top to bottom. By coincidence it turned out, that for every cell (x, y) the number of the car, which stands in this cell, is equal to the minimum positive integer, which can't be found in the cells (i, y) and (x, j), 1 ≤ i < x, 1 ≤ j < y.
<image> The upper left fragment 5 × 5 of the parking
Leha wants to ask the watchman q requests, which can help him to find his car. Every request is represented as five integers x1, y1, x2, y2, k. The watchman have to consider all cells (x, y) of the matrix, such that x1 ≤ x ≤ x2 and y1 ≤ y ≤ y2, and if the number of the car in cell (x, y) does not exceed k, increase the answer to the request by the number of the car in cell (x, y). For each request Leha asks the watchman to tell him the resulting sum. Due to the fact that the sum can turn out to be quite large, hacker asks to calculate it modulo 109 + 7.
However the requests seem to be impracticable for the watchman. Help the watchman to answer all Leha's requests.
Input
The first line contains one integer q (1 ≤ q ≤ 104) — the number of Leha's requests.
The next q lines contain five integers x1, y1, x2, y2, k (1 ≤ x1 ≤ x2 ≤ 109, 1 ≤ y1 ≤ y2 ≤ 109, 1 ≤ k ≤ 2·109) — parameters of Leha's requests.
Output
Print exactly q lines — in the first line print the answer to the first request, in the second — the answer to the second request and so on.
Example
Input
4
1 1 1 1 1
3 2 5 4 5
1 1 5 5 10000
1 4 2 5 2
Output
1
13
93
0
Note
Let's analyze all the requests. In each case the requested submatrix is highlighted in blue.
In the first request (k = 1) Leha asks only about the upper left parking cell. In this cell the car's number is 1. Consequentally the answer is 1.
<image>
In the second request (k = 5) suitable numbers are 4, 1, 2, 3, 2, 1. Consequentally the answer is 4 + 1 + 2 + 3 + 2 + 1 = 13.
<image>
In the third request (k = 10000) Leha asks about the upper left frament 5 × 5 of the parking. Since k is big enough, the answer is equal to 93.
<image>
In the last request (k = 2) none of the cur's numbers are suitable, so the answer is 0.
<image> | 2 | 9 | #include <bits/stdc++.h>
using namespace std;
const int inv = 1000000000;
const int minv = -inv;
const long long modref = ((long long)(1e9 + 7));
pair<long long, long long> f(int x, int y, int k) {
if (k <= 0) return pair<long long, long long>(0ll, 0ll);
if (x < y) return f(y, x, k);
if (y == 0) return pair<long long, long long>(0ll, 0ll);
int p2x = 1;
while ((p2x << 1) <= x) p2x <<= 1;
long long ret =
(((long long)(min(p2x, k))) * ((long long)(min(p2x, k) + 1))) / 2ll;
ret = ret % modref;
ret = (ret * ((long long)(min(y, p2x)))) % modref;
long long nret =
(((long long)(min(p2x, k))) * ((long long)(min(y, p2x)))) % modref;
pair<long long, long long> recv;
long long rec, nrec;
if (y > p2x) {
recv = f(x - p2x, p2x, k - p2x);
rec = recv.first;
nrec = recv.second;
ret = (ret + rec) % modref;
ret = (ret + p2x * nrec) % modref;
nret = (nret + nrec) % modref;
recv = f(p2x, y - p2x, k - p2x);
rec = recv.first;
nrec = recv.second;
ret = (ret + rec) % modref;
ret = (ret + p2x * nrec) % modref;
nret = (nret + nrec) % modref;
recv = f(x - p2x, y - p2x, k);
rec = recv.first;
nrec = recv.second;
ret = (ret + rec) % modref;
nret = (nret + nrec) % modref;
} else {
recv = f(x - p2x, y, k - p2x);
rec = recv.first;
nrec = recv.second;
ret = (ret + rec) % modref;
ret = (ret + p2x * nrec) % modref;
nret = (nret + nrec) % modref;
}
return pair<long long, long long>(ret, nret);
}
int main() {
int q;
scanf("%d", &q);
int x1, y1, x2, y2, k;
for (int z = 0; z < q; ++z) {
scanf("%d", &x1);
scanf("%d", &y1);
scanf("%d", &x2);
scanf("%d", &y2);
scanf("%d", &k);
long long res = f(x2, y2, k).first;
res = (res + modref - f(x1 - 1, y2, k).first) % modref;
res = (res + modref - f(x2, y1 - 1, k).first) % modref;
res = (res + f(x1 - 1, y1 - 1, k).first) % modref;
cout << res << "\n";
}
return 0;
}
| CPP |
809_C. Find a car | After a wonderful evening in the restaurant the time to go home came. Leha as a true gentlemen suggested Noora to give her a lift. Certainly the girl agreed with pleasure. Suddenly one problem appeared: Leha cannot find his car on a huge parking near the restaurant. So he decided to turn to the watchman for help.
Formally the parking can be represented as a matrix 109 × 109. There is exactly one car in every cell of the matrix. All cars have their own machine numbers represented as a positive integer. Let's index the columns of the matrix by integers from 1 to 109 from left to right and the rows by integers from 1 to 109 from top to bottom. By coincidence it turned out, that for every cell (x, y) the number of the car, which stands in this cell, is equal to the minimum positive integer, which can't be found in the cells (i, y) and (x, j), 1 ≤ i < x, 1 ≤ j < y.
<image> The upper left fragment 5 × 5 of the parking
Leha wants to ask the watchman q requests, which can help him to find his car. Every request is represented as five integers x1, y1, x2, y2, k. The watchman have to consider all cells (x, y) of the matrix, such that x1 ≤ x ≤ x2 and y1 ≤ y ≤ y2, and if the number of the car in cell (x, y) does not exceed k, increase the answer to the request by the number of the car in cell (x, y). For each request Leha asks the watchman to tell him the resulting sum. Due to the fact that the sum can turn out to be quite large, hacker asks to calculate it modulo 109 + 7.
However the requests seem to be impracticable for the watchman. Help the watchman to answer all Leha's requests.
Input
The first line contains one integer q (1 ≤ q ≤ 104) — the number of Leha's requests.
The next q lines contain five integers x1, y1, x2, y2, k (1 ≤ x1 ≤ x2 ≤ 109, 1 ≤ y1 ≤ y2 ≤ 109, 1 ≤ k ≤ 2·109) — parameters of Leha's requests.
Output
Print exactly q lines — in the first line print the answer to the first request, in the second — the answer to the second request and so on.
Example
Input
4
1 1 1 1 1
3 2 5 4 5
1 1 5 5 10000
1 4 2 5 2
Output
1
13
93
0
Note
Let's analyze all the requests. In each case the requested submatrix is highlighted in blue.
In the first request (k = 1) Leha asks only about the upper left parking cell. In this cell the car's number is 1. Consequentally the answer is 1.
<image>
In the second request (k = 5) suitable numbers are 4, 1, 2, 3, 2, 1. Consequentally the answer is 4 + 1 + 2 + 3 + 2 + 1 = 13.
<image>
In the third request (k = 10000) Leha asks about the upper left frament 5 × 5 of the parking. Since k is big enough, the answer is equal to 93.
<image>
In the last request (k = 2) none of the cur's numbers are suitable, so the answer is 0.
<image> | 2 | 9 | #include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const long long mod = 1e9 + 7;
const double EPS = 1e-9;
void read() { freopen("in", "r", stdin); }
int A[33], B[33], C[33];
long long dp[33][2][2][2], sum[33][2][2][2];
long long query(int x, int y, int z) {
if (x < 0 || y < 0 || z < 0) return 0;
for (int i = 0; i <= 31; i++) {
A[i] = (x >> (31 - i)) & 1;
B[i] = (y >> (31 - i)) & 1;
C[i] = (z >> (31 - i)) & 1;
}
memset(dp, 0, sizeof dp);
memset(sum, 0, sizeof sum);
dp[0][1][1][1] = 1;
for (int i = 0; i < 32; i++) {
for (int a = 0; a < 2; a++) {
for (int b = 0; b < 2; b++) {
for (int c = 0; c < 2; c++) {
long long val = dp[i][a][b][c];
long long s = sum[i][a][b][c];
for (int x = 0; x < 2; x++) {
for (int y = 0; y < 2; y++) {
int z = x ^ y;
if (A[i] == 0 && a == 1 && x == 1) continue;
if (B[i] == 0 && b == 1 && y == 1) continue;
if (C[i] == 0 && c == 1 && z == 1) continue;
dp[i + 1][a & (A[i] == x)][b & (B[i] == y)][c & (C[i] == z)] +=
val;
dp[i + 1][a & (A[i] == x)][b & (B[i] == y)][c & (C[i] == z)] %=
mod;
sum[i + 1][a & (A[i] == x)][b & (B[i] == y)][c & (C[i] == z)] +=
s;
sum[i + 1][a & (A[i] == x)][b & (B[i] == y)][c & (C[i] == z)] +=
(1ll * (z << (31 - i)) * val % mod);
sum[i + 1][a & (A[i] == x)][b & (B[i] == y)][c & (C[i] == z)] %=
mod;
}
}
}
}
}
}
long long ret = 0;
for (int a = 0; a < 2; a++)
for (int b = 0; b < 2; b++)
for (int c = 0; c < 2; c++) ret += dp[32][a][b][c] + sum[32][a][b][c];
ret %= mod;
return ret;
}
int main() {
int q;
cin >> q;
while (q--) {
int x1, x2, y1, y2, k;
scanf("%d%d%d%d%d", &x1, &y1, &x2, &y2, &k);
long long ans = 0;
x2--, y2--, x1--, y1--, k--;
ans += query(x2, y2, k);
ans += query(x1 - 1, y1 - 1, k);
ans -= query(x2, y1 - 1, k);
ans -= query(x1 - 1, y2, k);
ans %= mod;
ans += mod;
ans %= mod;
printf("%lld\n", ans);
}
return 0;
}
| CPP |
809_C. Find a car | After a wonderful evening in the restaurant the time to go home came. Leha as a true gentlemen suggested Noora to give her a lift. Certainly the girl agreed with pleasure. Suddenly one problem appeared: Leha cannot find his car on a huge parking near the restaurant. So he decided to turn to the watchman for help.
Formally the parking can be represented as a matrix 109 × 109. There is exactly one car in every cell of the matrix. All cars have their own machine numbers represented as a positive integer. Let's index the columns of the matrix by integers from 1 to 109 from left to right and the rows by integers from 1 to 109 from top to bottom. By coincidence it turned out, that for every cell (x, y) the number of the car, which stands in this cell, is equal to the minimum positive integer, which can't be found in the cells (i, y) and (x, j), 1 ≤ i < x, 1 ≤ j < y.
<image> The upper left fragment 5 × 5 of the parking
Leha wants to ask the watchman q requests, which can help him to find his car. Every request is represented as five integers x1, y1, x2, y2, k. The watchman have to consider all cells (x, y) of the matrix, such that x1 ≤ x ≤ x2 and y1 ≤ y ≤ y2, and if the number of the car in cell (x, y) does not exceed k, increase the answer to the request by the number of the car in cell (x, y). For each request Leha asks the watchman to tell him the resulting sum. Due to the fact that the sum can turn out to be quite large, hacker asks to calculate it modulo 109 + 7.
However the requests seem to be impracticable for the watchman. Help the watchman to answer all Leha's requests.
Input
The first line contains one integer q (1 ≤ q ≤ 104) — the number of Leha's requests.
The next q lines contain five integers x1, y1, x2, y2, k (1 ≤ x1 ≤ x2 ≤ 109, 1 ≤ y1 ≤ y2 ≤ 109, 1 ≤ k ≤ 2·109) — parameters of Leha's requests.
Output
Print exactly q lines — in the first line print the answer to the first request, in the second — the answer to the second request and so on.
Example
Input
4
1 1 1 1 1
3 2 5 4 5
1 1 5 5 10000
1 4 2 5 2
Output
1
13
93
0
Note
Let's analyze all the requests. In each case the requested submatrix is highlighted in blue.
In the first request (k = 1) Leha asks only about the upper left parking cell. In this cell the car's number is 1. Consequentally the answer is 1.
<image>
In the second request (k = 5) suitable numbers are 4, 1, 2, 3, 2, 1. Consequentally the answer is 4 + 1 + 2 + 3 + 2 + 1 = 13.
<image>
In the third request (k = 10000) Leha asks about the upper left frament 5 × 5 of the parking. Since k is big enough, the answer is equal to 93.
<image>
In the last request (k = 2) none of the cur's numbers are suitable, so the answer is 0.
<image> | 2 | 9 | #include <bits/stdc++.h>
using namespace std;
const long double Pi = acos(-1);
const long long Inf = 1e18;
const int inf = 1e9 + 1;
const int mod = 1e9 + 7;
const long double eps = 1e-12;
const int N = 1e6 + 123;
void add(int &a, int b) {
a += b;
if (a >= mod) a -= mod;
}
int mult(int a, int b) { return 1ll * a * b % mod; }
int sum(int a, int b) {
add(a, b);
return a;
}
int n, q;
pair<int, int> dp[2][2][2], buf[2][2][2];
void Add(pair<int, int> &a, pair<int, int> b, int x) {
add(a.first, b.first);
add(a.second, b.second);
add(a.second, mult(b.first, x));
}
const int B = 31;
int Get(int N, int M, int k) {
N--, M--;
memset(dp, 0, sizeof dp);
memset(buf, 0, sizeof buf);
dp[0][0][0] = make_pair(1, 0);
for (int b = B; b >= 0; b--) {
int x = (N >> b) & 1;
int y = (M >> b) & 1;
int z = (k >> b) & 1;
for (int t1 = 0; t1 < 2; t1++) {
for (int t2 = 0; t2 < 2; t2++) {
for (int t3 = 0; t3 < 2; t3++) {
if (dp[t1][t2][t3].first == 0) continue;
int l1 = 0, r1 = (t1 == 1 ? 1 : x);
int l2 = 0, r2 = (t2 == 1 ? 1 : y);
int l3 = 0, r3 = (t3 == 1 ? 1 : z);
for (int v1 = l1; v1 <= r1; v1++) {
for (int v2 = l2; v2 <= r2; v2++) {
int v3 = v1 ^ v2;
if (v3 <= r3) {
int nt1 = t1 | (v1 < r1);
int nt2 = t2 | (v2 < r2);
int nt3 = t3 | (v3 < r3);
Add(buf[nt1][nt2][nt3], dp[t1][t2][t3], (1 << b) * v3);
}
}
}
}
}
}
for (int t1 = 0; t1 < 2; t1++) {
for (int t2 = 0; t2 < 2; t2++) {
for (int t3 = 0; t3 < 2; t3++) {
dp[t1][t2][t3] = buf[t1][t2][t3];
buf[t1][t2][t3] = make_pair(0, 0);
continue;
if (dp[t1][t2][t3].first) {
cout << "after t1 = " << t1 << " t2 = " << t2 << " t3 = " << t3
<< " f = " << dp[t1][t2][t3].first << endl;
}
}
}
}
}
int ans = 0;
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2; j++) {
add(ans, dp[i][j][1].first);
add(ans, dp[i][j][1].second);
}
}
return ans;
}
int query(int x1, int y1, int x2, int y2, int k) {
int ans = 0;
add(ans, Get(x2, y2, k));
if (min(x1, y1) > 1) add(ans, Get(x1 - 1, y1 - 1, k));
if (y1 > 1) add(ans, mod - Get(x2, y1 - 1, k));
if (x1 > 1) add(ans, mod - Get(x1 - 1, y2, k));
return ans;
}
void solve() {
cin >> q;
for (int i = 0, x1, y1, x2, y2, k; i < q; i++) {
cin >> x1 >> y1 >> x2 >> y2 >> k;
cout << query(x1, y1, x2, y2, k) << endl;
}
}
int main() {
int tt = 1;
while (tt--) solve();
return 0;
}
| CPP |
809_C. Find a car | After a wonderful evening in the restaurant the time to go home came. Leha as a true gentlemen suggested Noora to give her a lift. Certainly the girl agreed with pleasure. Suddenly one problem appeared: Leha cannot find his car on a huge parking near the restaurant. So he decided to turn to the watchman for help.
Formally the parking can be represented as a matrix 109 × 109. There is exactly one car in every cell of the matrix. All cars have their own machine numbers represented as a positive integer. Let's index the columns of the matrix by integers from 1 to 109 from left to right and the rows by integers from 1 to 109 from top to bottom. By coincidence it turned out, that for every cell (x, y) the number of the car, which stands in this cell, is equal to the minimum positive integer, which can't be found in the cells (i, y) and (x, j), 1 ≤ i < x, 1 ≤ j < y.
<image> The upper left fragment 5 × 5 of the parking
Leha wants to ask the watchman q requests, which can help him to find his car. Every request is represented as five integers x1, y1, x2, y2, k. The watchman have to consider all cells (x, y) of the matrix, such that x1 ≤ x ≤ x2 and y1 ≤ y ≤ y2, and if the number of the car in cell (x, y) does not exceed k, increase the answer to the request by the number of the car in cell (x, y). For each request Leha asks the watchman to tell him the resulting sum. Due to the fact that the sum can turn out to be quite large, hacker asks to calculate it modulo 109 + 7.
However the requests seem to be impracticable for the watchman. Help the watchman to answer all Leha's requests.
Input
The first line contains one integer q (1 ≤ q ≤ 104) — the number of Leha's requests.
The next q lines contain five integers x1, y1, x2, y2, k (1 ≤ x1 ≤ x2 ≤ 109, 1 ≤ y1 ≤ y2 ≤ 109, 1 ≤ k ≤ 2·109) — parameters of Leha's requests.
Output
Print exactly q lines — in the first line print the answer to the first request, in the second — the answer to the second request and so on.
Example
Input
4
1 1 1 1 1
3 2 5 4 5
1 1 5 5 10000
1 4 2 5 2
Output
1
13
93
0
Note
Let's analyze all the requests. In each case the requested submatrix is highlighted in blue.
In the first request (k = 1) Leha asks only about the upper left parking cell. In this cell the car's number is 1. Consequentally the answer is 1.
<image>
In the second request (k = 5) suitable numbers are 4, 1, 2, 3, 2, 1. Consequentally the answer is 4 + 1 + 2 + 3 + 2 + 1 = 13.
<image>
In the third request (k = 10000) Leha asks about the upper left frament 5 × 5 of the parking. Since k is big enough, the answer is equal to 93.
<image>
In the last request (k = 2) none of the cur's numbers are suitable, so the answer is 0.
<image> | 2 | 9 | #include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 7;
const int MAXN = 1e3 + 7;
const int MOD = 1e9 + 7;
int n;
pair<int, int> dp[34][2][2][2];
int vis[34][2][2][2];
int x, y, k;
pair<int, int> dfs(int pos, int limx, int limy, int limk) {
if (pos == -1) return pair<int, int>(1, 0);
if (vis[pos][limx][limy][limk]) return dp[pos][limx][limy][limk];
int zx = 1, zy = 1;
if (limx) zx = x >> pos & 1;
if (limy) zy = y >> pos & 1;
long long posk = k >> pos & 1;
pair<int, int> st(0, 0), ta;
for (int i = 0; i <= zx; i++)
for (int j = 0; j <= zy; j++) {
long long tb = ((i ^ j) << pos) % MOD;
if (limk) {
if ((i ^ j) <= posk) {
ta = dfs(pos - 1, limx && zx == i, limy && zy == j, (i ^ j) == posk);
st = pair<int, int>(
(ta.first + st.first) % MOD,
(ta.first * tb % MOD + ta.second + st.second) % MOD);
}
} else {
ta = dfs(pos - 1, limx && zx == i, limy && zy == j, 0);
st =
pair<int, int>((ta.first + st.first) % MOD,
(ta.first * tb % MOD + ta.second + st.second) % MOD);
}
}
dp[pos][limx][limy][limk] = st;
vis[pos][limx][limy][limk] = 1;
return st;
}
int solve(int a, int b) {
if (a < 0 || b < 0) return 0;
memset(vis, 0, sizeof(vis));
x = a, y = b;
pair<int, int> ans = dfs(30, 1, 1, 1);
int tmp = (ans.second + ans.first) % MOD;
return tmp;
}
int main() {
int q, x1, y1, x2, y2;
scanf("%d", &q);
while (q--) {
scanf("%d%d%d%d%d", &x1, &y1, &x2, &y2, &k);
x1--, y1--, x2--, y2--, k--;
long long ans = solve(x2, y2) - solve(x1 - 1, y2) - solve(x2, y1 - 1) +
solve(x1 - 1, y1 - 1);
ans = ans % MOD;
if (ans < 0) ans += MOD;
printf("%d\n", ans);
}
return 0;
}
| CPP |
809_C. Find a car | After a wonderful evening in the restaurant the time to go home came. Leha as a true gentlemen suggested Noora to give her a lift. Certainly the girl agreed with pleasure. Suddenly one problem appeared: Leha cannot find his car on a huge parking near the restaurant. So he decided to turn to the watchman for help.
Formally the parking can be represented as a matrix 109 × 109. There is exactly one car in every cell of the matrix. All cars have their own machine numbers represented as a positive integer. Let's index the columns of the matrix by integers from 1 to 109 from left to right and the rows by integers from 1 to 109 from top to bottom. By coincidence it turned out, that for every cell (x, y) the number of the car, which stands in this cell, is equal to the minimum positive integer, which can't be found in the cells (i, y) and (x, j), 1 ≤ i < x, 1 ≤ j < y.
<image> The upper left fragment 5 × 5 of the parking
Leha wants to ask the watchman q requests, which can help him to find his car. Every request is represented as five integers x1, y1, x2, y2, k. The watchman have to consider all cells (x, y) of the matrix, such that x1 ≤ x ≤ x2 and y1 ≤ y ≤ y2, and if the number of the car in cell (x, y) does not exceed k, increase the answer to the request by the number of the car in cell (x, y). For each request Leha asks the watchman to tell him the resulting sum. Due to the fact that the sum can turn out to be quite large, hacker asks to calculate it modulo 109 + 7.
However the requests seem to be impracticable for the watchman. Help the watchman to answer all Leha's requests.
Input
The first line contains one integer q (1 ≤ q ≤ 104) — the number of Leha's requests.
The next q lines contain five integers x1, y1, x2, y2, k (1 ≤ x1 ≤ x2 ≤ 109, 1 ≤ y1 ≤ y2 ≤ 109, 1 ≤ k ≤ 2·109) — parameters of Leha's requests.
Output
Print exactly q lines — in the first line print the answer to the first request, in the second — the answer to the second request and so on.
Example
Input
4
1 1 1 1 1
3 2 5 4 5
1 1 5 5 10000
1 4 2 5 2
Output
1
13
93
0
Note
Let's analyze all the requests. In each case the requested submatrix is highlighted in blue.
In the first request (k = 1) Leha asks only about the upper left parking cell. In this cell the car's number is 1. Consequentally the answer is 1.
<image>
In the second request (k = 5) suitable numbers are 4, 1, 2, 3, 2, 1. Consequentally the answer is 4 + 1 + 2 + 3 + 2 + 1 = 13.
<image>
In the third request (k = 10000) Leha asks about the upper left frament 5 × 5 of the parking. Since k is big enough, the answer is equal to 93.
<image>
In the last request (k = 2) none of the cur's numbers are suitable, so the answer is 0.
<image> | 2 | 9 | #include <bits/stdc++.h>
using namespace std;
const long long M = 1e9 + 7;
long long su(long long a) { return a * (a + 1) / 2 % M; }
long long inter(long long a, long long b, long long k) {
long long start = max(a, min(k, b));
return (su(start) - su(a) + M) % M;
}
long long elem(long long x, long long y, long long lx, long long ly,
long long k) {
long long l = max(lx, ly), occ = min(lx, ly);
long long b = x ^ y;
b &= ~(l - 1);
long long ans = occ * inter(b, b + l, k) % M;
return ans;
}
long long comp2(long long x, long long ey, long long ly, long long k) {
long long sum = 0;
while (x) {
long long ls1 = x & -x;
sum += elem(x - ls1, ey, ls1, ly, k);
x -= ls1;
}
return sum % M;
}
long long comp(long long x, long long y, long long k) {
long long sum = 0;
while (y) {
long long ls1 = y & -y;
sum += comp2(x, y - ls1, ls1, k);
y -= ls1;
}
return sum % M;
}
long long comp(long long x1, long long x2, long long y1, long long y2,
long long k) {
return (comp(x2, y2, k) - comp(x1, y2, k) - comp(x2, y1, k) +
comp(x1, y1, k) + 2 * M) %
M;
}
signed main() {
long long q;
cin >> q;
for (long long i = 0; i < (long long)(q); i++) {
long long a, b, c, d, k;
cin >> a >> b >> c >> d >> k;
cout << comp(a - 1, c, b - 1, d, k) << endl;
}
}
| CPP |
809_C. Find a car | After a wonderful evening in the restaurant the time to go home came. Leha as a true gentlemen suggested Noora to give her a lift. Certainly the girl agreed with pleasure. Suddenly one problem appeared: Leha cannot find his car on a huge parking near the restaurant. So he decided to turn to the watchman for help.
Formally the parking can be represented as a matrix 109 × 109. There is exactly one car in every cell of the matrix. All cars have their own machine numbers represented as a positive integer. Let's index the columns of the matrix by integers from 1 to 109 from left to right and the rows by integers from 1 to 109 from top to bottom. By coincidence it turned out, that for every cell (x, y) the number of the car, which stands in this cell, is equal to the minimum positive integer, which can't be found in the cells (i, y) and (x, j), 1 ≤ i < x, 1 ≤ j < y.
<image> The upper left fragment 5 × 5 of the parking
Leha wants to ask the watchman q requests, which can help him to find his car. Every request is represented as five integers x1, y1, x2, y2, k. The watchman have to consider all cells (x, y) of the matrix, such that x1 ≤ x ≤ x2 and y1 ≤ y ≤ y2, and if the number of the car in cell (x, y) does not exceed k, increase the answer to the request by the number of the car in cell (x, y). For each request Leha asks the watchman to tell him the resulting sum. Due to the fact that the sum can turn out to be quite large, hacker asks to calculate it modulo 109 + 7.
However the requests seem to be impracticable for the watchman. Help the watchman to answer all Leha's requests.
Input
The first line contains one integer q (1 ≤ q ≤ 104) — the number of Leha's requests.
The next q lines contain five integers x1, y1, x2, y2, k (1 ≤ x1 ≤ x2 ≤ 109, 1 ≤ y1 ≤ y2 ≤ 109, 1 ≤ k ≤ 2·109) — parameters of Leha's requests.
Output
Print exactly q lines — in the first line print the answer to the first request, in the second — the answer to the second request and so on.
Example
Input
4
1 1 1 1 1
3 2 5 4 5
1 1 5 5 10000
1 4 2 5 2
Output
1
13
93
0
Note
Let's analyze all the requests. In each case the requested submatrix is highlighted in blue.
In the first request (k = 1) Leha asks only about the upper left parking cell. In this cell the car's number is 1. Consequentally the answer is 1.
<image>
In the second request (k = 5) suitable numbers are 4, 1, 2, 3, 2, 1. Consequentally the answer is 4 + 1 + 2 + 3 + 2 + 1 = 13.
<image>
In the third request (k = 10000) Leha asks about the upper left frament 5 × 5 of the parking. Since k is big enough, the answer is equal to 93.
<image>
In the last request (k = 2) none of the cur's numbers are suitable, so the answer is 0.
<image> | 2 | 9 | import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;
/**
* Built using CHelper plug-in
* Actual solution is at the top
*/
public class Main {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
InputReader in = new InputReader(inputStream);
OutputWriter out = new OutputWriter(outputStream);
TaskC solver = new TaskC();
int testCount = Integer.parseInt(in.next());
for (int i = 1; i <= testCount; i++)
solver.solve(i, in, out);
out.close();
}
static class TaskC {
public int mod = 1000000007;
public int x1;
public int x2;
public int y1;
public int y2;
public int k;
public int MAXB = 32;
public int[][] dpc;
public int[][] dps;
public void solve(int testNumber, InputReader in, OutputWriter out) {
x1 = in.nextInt() - 1;
y1 = in.nextInt() - 1;
x2 = in.nextInt() - 1;
y2 = in.nextInt() - 1;
k = in.nextInt() - 1;
dpc = new int[MAXB][1 << 5];
dps = new int[MAXB][1 << 5];
for (int i = 0; i < MAXB; i++) {
Arrays.fill(dpc[i], -1);
Arrays.fill(dps[i], -1);
}
dfs(MAXB - 1, 0, 0, 0, 0, 0);
out.println((dps[MAXB - 1][0] + dpc[MAXB - 1][0]) % mod);
}
public void dfs(int bit, int gx, int lx, int gy, int ly, int lk) {
int cm = getMask(gx, lx, gy, ly, lk);
if (dpc[bit][cm] != -1) return;
int cx1 = (x1 >> bit) & 1;
int cx2 = (x2 >> bit) & 1;
int cy1 = (y1 >> bit) & 1;
int cy2 = (y2 >> bit) & 1;
int ck = (k >> bit) & 1;
dpc[bit][cm] = 0;
dps[bit][cm] = 0;
for (int xb = 0; xb <= 1; xb++) {
for (int yb = 0; yb <= 1; yb++) {
if (xb == 0 && cx1 == 1 && gx == 0) continue;
if (xb == 1 && cx2 == 0 && lx == 0) continue;
if (yb == 0 && cy1 == 1 && gy == 0) continue;
if (yb == 1 && cy2 == 0 && ly == 0) continue;
int bitk = xb ^ yb;
if (bitk == 1 && ck == 0 && lk == 0) continue;
int ngx = gx | (xb > cx1 ? 1 : 0);
int ngy = gy | (yb > cy1 ? 1 : 0);
int nlx = lx | (xb < cx2 ? 1 : 0);
int nly = ly | (yb < cy2 ? 1 : 0);
int nlk = lk | (bitk < ck ? 1 : 0);
if (bit > 0) {
dfs(bit - 1, ngx, nlx, ngy, nly, nlk);
int ms = getMask(ngx, nlx, ngy, nly, nlk);
dps[bit][cm] = (int) ((dps[bit][cm] + dps[bit - 1][ms] + 1L * dpc[bit - 1][ms] * (bitk << bit)) % mod);
dpc[bit][cm] += dpc[bit - 1][ms];
if (dpc[bit][cm] >= mod) dpc[bit][cm] -= mod;
} else {
dps[bit][cm] += bitk << bit;
dpc[bit][cm]++;
}
}
}
}
public int getMask(int gx, int lx, int gy, int ly, int lk) {
int msk = gx;
msk <<= 1;
msk |= lx;
msk <<= 1;
msk |= gy;
msk <<= 1;
msk |= ly;
msk <<= 1;
msk |= lk;
return msk;
}
}
static class InputReader {
private InputStream stream;
private byte[] buf = new byte[1024];
private int curChar;
private int numChars;
public InputReader(InputStream stream) {
this.stream = stream;
}
public int read() {
if (this.numChars == -1) {
throw new InputMismatchException();
} else {
if (this.curChar >= this.numChars) {
this.curChar = 0;
try {
this.numChars = this.stream.read(this.buf);
} catch (IOException var2) {
throw new InputMismatchException();
}
if (this.numChars <= 0) {
return -1;
}
}
return this.buf[this.curChar++];
}
}
public int nextInt() {
int c;
for (c = this.read(); isSpaceChar(c); c = this.read()) {
;
}
byte sgn = 1;
if (c == 45) {
sgn = -1;
c = this.read();
}
int res = 0;
while (c >= 48 && c <= 57) {
res *= 10;
res += c - 48;
c = this.read();
if (isSpaceChar(c)) {
return res * sgn;
}
}
throw new InputMismatchException();
}
public String next() {
int c;
while (isSpaceChar(c = this.read())) {
;
}
StringBuilder result = new StringBuilder();
result.appendCodePoint(c);
while (!isSpaceChar(c = this.read())) {
result.appendCodePoint(c);
}
return result.toString();
}
public static boolean isSpaceChar(int c) {
return c == 32 || c == 10 || c == 13 || c == 9 || c == -1;
}
}
static class OutputWriter {
private final PrintWriter writer;
public OutputWriter(OutputStream outputStream) {
writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
}
public OutputWriter(Writer writer) {
this.writer = new PrintWriter(writer);
}
public void close() {
writer.close();
}
public void println(int i) {
writer.println(i);
}
}
}
| JAVA |
809_C. Find a car | After a wonderful evening in the restaurant the time to go home came. Leha as a true gentlemen suggested Noora to give her a lift. Certainly the girl agreed with pleasure. Suddenly one problem appeared: Leha cannot find his car on a huge parking near the restaurant. So he decided to turn to the watchman for help.
Formally the parking can be represented as a matrix 109 × 109. There is exactly one car in every cell of the matrix. All cars have their own machine numbers represented as a positive integer. Let's index the columns of the matrix by integers from 1 to 109 from left to right and the rows by integers from 1 to 109 from top to bottom. By coincidence it turned out, that for every cell (x, y) the number of the car, which stands in this cell, is equal to the minimum positive integer, which can't be found in the cells (i, y) and (x, j), 1 ≤ i < x, 1 ≤ j < y.
<image> The upper left fragment 5 × 5 of the parking
Leha wants to ask the watchman q requests, which can help him to find his car. Every request is represented as five integers x1, y1, x2, y2, k. The watchman have to consider all cells (x, y) of the matrix, such that x1 ≤ x ≤ x2 and y1 ≤ y ≤ y2, and if the number of the car in cell (x, y) does not exceed k, increase the answer to the request by the number of the car in cell (x, y). For each request Leha asks the watchman to tell him the resulting sum. Due to the fact that the sum can turn out to be quite large, hacker asks to calculate it modulo 109 + 7.
However the requests seem to be impracticable for the watchman. Help the watchman to answer all Leha's requests.
Input
The first line contains one integer q (1 ≤ q ≤ 104) — the number of Leha's requests.
The next q lines contain five integers x1, y1, x2, y2, k (1 ≤ x1 ≤ x2 ≤ 109, 1 ≤ y1 ≤ y2 ≤ 109, 1 ≤ k ≤ 2·109) — parameters of Leha's requests.
Output
Print exactly q lines — in the first line print the answer to the first request, in the second — the answer to the second request and so on.
Example
Input
4
1 1 1 1 1
3 2 5 4 5
1 1 5 5 10000
1 4 2 5 2
Output
1
13
93
0
Note
Let's analyze all the requests. In each case the requested submatrix is highlighted in blue.
In the first request (k = 1) Leha asks only about the upper left parking cell. In this cell the car's number is 1. Consequentally the answer is 1.
<image>
In the second request (k = 5) suitable numbers are 4, 1, 2, 3, 2, 1. Consequentally the answer is 4 + 1 + 2 + 3 + 2 + 1 = 13.
<image>
In the third request (k = 10000) Leha asks about the upper left frament 5 × 5 of the parking. Since k is big enough, the answer is equal to 93.
<image>
In the last request (k = 2) none of the cur's numbers are suitable, so the answer is 0.
<image> | 2 | 9 | mod = 1000000007
def sum(x,y,k,add) :
if k<add:
return 0
up=x+add
if up>k:
up=k
add=add+1
return y*(((add+up)*(up-add+1)//2)%mod)%mod
def solve(x,y,k,add=0) :
if x==0 or y==0:
return 0
if x>y:
x,y=y,x
pw = 1
while (pw*2)<=y:
pw*=2
if pw<=x:
return (sum(pw,pw,k,add)+sum(pw,x+y-pw-pw,k,add+pw)+solve(x-pw,y-pw,k,add))%mod
else:
return (sum(pw,x,k,add)+solve(x,y-pw,k,add+pw))%mod
q=input()
for i in range(0,q):
x1,y1,x2,y2,k=map(int,raw_input().split())
ans=(solve(x2, y2, k)-solve(x1 - 1, y2, k)-solve(x2, y1 - 1, k)+solve(x1-1,y1-1,k))%mod
if ans<0:
ans+=mod
print ans | PYTHON |
809_C. Find a car | After a wonderful evening in the restaurant the time to go home came. Leha as a true gentlemen suggested Noora to give her a lift. Certainly the girl agreed with pleasure. Suddenly one problem appeared: Leha cannot find his car on a huge parking near the restaurant. So he decided to turn to the watchman for help.
Formally the parking can be represented as a matrix 109 × 109. There is exactly one car in every cell of the matrix. All cars have their own machine numbers represented as a positive integer. Let's index the columns of the matrix by integers from 1 to 109 from left to right and the rows by integers from 1 to 109 from top to bottom. By coincidence it turned out, that for every cell (x, y) the number of the car, which stands in this cell, is equal to the minimum positive integer, which can't be found in the cells (i, y) and (x, j), 1 ≤ i < x, 1 ≤ j < y.
<image> The upper left fragment 5 × 5 of the parking
Leha wants to ask the watchman q requests, which can help him to find his car. Every request is represented as five integers x1, y1, x2, y2, k. The watchman have to consider all cells (x, y) of the matrix, such that x1 ≤ x ≤ x2 and y1 ≤ y ≤ y2, and if the number of the car in cell (x, y) does not exceed k, increase the answer to the request by the number of the car in cell (x, y). For each request Leha asks the watchman to tell him the resulting sum. Due to the fact that the sum can turn out to be quite large, hacker asks to calculate it modulo 109 + 7.
However the requests seem to be impracticable for the watchman. Help the watchman to answer all Leha's requests.
Input
The first line contains one integer q (1 ≤ q ≤ 104) — the number of Leha's requests.
The next q lines contain five integers x1, y1, x2, y2, k (1 ≤ x1 ≤ x2 ≤ 109, 1 ≤ y1 ≤ y2 ≤ 109, 1 ≤ k ≤ 2·109) — parameters of Leha's requests.
Output
Print exactly q lines — in the first line print the answer to the first request, in the second — the answer to the second request and so on.
Example
Input
4
1 1 1 1 1
3 2 5 4 5
1 1 5 5 10000
1 4 2 5 2
Output
1
13
93
0
Note
Let's analyze all the requests. In each case the requested submatrix is highlighted in blue.
In the first request (k = 1) Leha asks only about the upper left parking cell. In this cell the car's number is 1. Consequentally the answer is 1.
<image>
In the second request (k = 5) suitable numbers are 4, 1, 2, 3, 2, 1. Consequentally the answer is 4 + 1 + 2 + 3 + 2 + 1 = 13.
<image>
In the third request (k = 10000) Leha asks about the upper left frament 5 × 5 of the parking. Since k is big enough, the answer is equal to 93.
<image>
In the last request (k = 2) none of the cur's numbers are suitable, so the answer is 0.
<image> | 2 | 9 | #include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const int mod = (int)1e9 + 7;
int sum(int a, int b) {
int s = a + b;
if (s >= mod) s -= mod;
return s;
}
int sub(int a, int b) {
int s = a - b;
if (s < 0) s += mod;
return s;
}
int mult(int a, int b) { return (1LL * a * b) % mod; }
int pw(int a, int b) {
if (b == 0) return 1;
if (b & 1) return mult(a, pw(a, b - 1));
int res = pw(a, b / 2);
return mult(res, res);
}
int q;
const int BIT = 32;
int dp[BIT + 1][2][2][2];
int sm[BIT + 1][2][2][2];
void upd(int& x, int y) { x = sum(x, y); }
int ways(long long a, long long b, long long k) {
if (a < 0 || b < 0) return 0;
memset(dp, 0, sizeof dp);
memset(sm, 0, sizeof sm);
dp[BIT][0][0][0] = 1;
int tot = 0;
for (int i = BIT; i >= 0; i--) {
int bita = (a >> (i - 1)) & 1;
int bitb = (b >> (i - 1)) & 1;
int bitk = (k >> (i - 1)) & 1;
for (int fla = 0; fla < 2; fla++) {
for (int flb = 0; flb < 2; flb++) {
for (int flk = 0; flk < 2; flk++) {
if (dp[i][fla][flb][flk] == 0) continue;
if (i == 0) {
upd(tot, dp[i][fla][flb][flk]);
upd(tot, sm[i][fla][flb][flk]);
continue;
}
for (int willa = 0; willa < 2; willa++) {
for (int willb = 0; willb < 2; willb++) {
if (willa > bita && !fla) continue;
if (willb > bitb && !flb) continue;
int willk = willa ^ willb;
if (willk > bitk && !flk) continue;
upd(dp[i - 1][fla || (willa < bita)][flb || (willb < bitb)]
[flk || (willk < bitk)],
dp[i][fla][flb][flk]);
upd(sm[i - 1][fla || (willa < bita)][flb || (willb < bitb)]
[flk || (willk < bitk)],
mult(2, sm[i][fla][flb][flk]));
if (willk) {
upd(sm[i - 1][fla || (willa < bita)][flb || (willb < bitb)]
[flk || (willk < bitk)],
dp[i][fla][flb][flk]);
}
}
}
}
}
}
}
return tot;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> q;
while (q--) {
int x1, y1, x2, y2, k;
cin >> x1 >> y1 >> x2 >> y2 >> k;
x1--;
x2--;
y1--;
y2--;
k--;
int ans = sum(sub(ways(x2, y2, k), ways(x2, y1 - 1, k)),
sub(ways(x1 - 1, y1 - 1, k), ways(x1 - 1, y2, k)));
cout << ans << '\n';
}
return 0;
}
| CPP |
809_C. Find a car | After a wonderful evening in the restaurant the time to go home came. Leha as a true gentlemen suggested Noora to give her a lift. Certainly the girl agreed with pleasure. Suddenly one problem appeared: Leha cannot find his car on a huge parking near the restaurant. So he decided to turn to the watchman for help.
Formally the parking can be represented as a matrix 109 × 109. There is exactly one car in every cell of the matrix. All cars have their own machine numbers represented as a positive integer. Let's index the columns of the matrix by integers from 1 to 109 from left to right and the rows by integers from 1 to 109 from top to bottom. By coincidence it turned out, that for every cell (x, y) the number of the car, which stands in this cell, is equal to the minimum positive integer, which can't be found in the cells (i, y) and (x, j), 1 ≤ i < x, 1 ≤ j < y.
<image> The upper left fragment 5 × 5 of the parking
Leha wants to ask the watchman q requests, which can help him to find his car. Every request is represented as five integers x1, y1, x2, y2, k. The watchman have to consider all cells (x, y) of the matrix, such that x1 ≤ x ≤ x2 and y1 ≤ y ≤ y2, and if the number of the car in cell (x, y) does not exceed k, increase the answer to the request by the number of the car in cell (x, y). For each request Leha asks the watchman to tell him the resulting sum. Due to the fact that the sum can turn out to be quite large, hacker asks to calculate it modulo 109 + 7.
However the requests seem to be impracticable for the watchman. Help the watchman to answer all Leha's requests.
Input
The first line contains one integer q (1 ≤ q ≤ 104) — the number of Leha's requests.
The next q lines contain five integers x1, y1, x2, y2, k (1 ≤ x1 ≤ x2 ≤ 109, 1 ≤ y1 ≤ y2 ≤ 109, 1 ≤ k ≤ 2·109) — parameters of Leha's requests.
Output
Print exactly q lines — in the first line print the answer to the first request, in the second — the answer to the second request and so on.
Example
Input
4
1 1 1 1 1
3 2 5 4 5
1 1 5 5 10000
1 4 2 5 2
Output
1
13
93
0
Note
Let's analyze all the requests. In each case the requested submatrix is highlighted in blue.
In the first request (k = 1) Leha asks only about the upper left parking cell. In this cell the car's number is 1. Consequentally the answer is 1.
<image>
In the second request (k = 5) suitable numbers are 4, 1, 2, 3, 2, 1. Consequentally the answer is 4 + 1 + 2 + 3 + 2 + 1 = 13.
<image>
In the third request (k = 10000) Leha asks about the upper left frament 5 × 5 of the parking. Since k is big enough, the answer is equal to 93.
<image>
In the last request (k = 2) none of the cur's numbers are suitable, so the answer is 0.
<image> | 2 | 9 | #include <bits/stdc++.h>
using namespace std;
set<long long> p2;
bool isP2(long long c) {
if (p2.find(c) != p2.end()) return true;
return false;
}
long long getSum(long long x) { return ((x + 1) * x / 2) % 1000000007; }
long long getAm(long long x, long long y, long long k) {
if (k <= 0) return 0;
if (x <= 0 || y <= 0) return 0;
if (x < y) swap(x, y);
if (isP2(x)) {
long long minAm = min(k, x);
return (minAm * y) % 1000000007;
}
long long cP2 = 1;
while (cP2 < x || cP2 < y) cP2 *= 2;
cP2 /= 2;
return (getAm(min(x, cP2), min(y, cP2), k) + getAm(x - cP2, y - cP2, k) +
getAm(x - cP2, min(y, cP2), k - cP2) +
getAm(min(x, cP2), y - cP2, k - cP2)) %
1000000007;
}
long long getSum(long long x, long long y, long long k) {
if (k <= 0) return 0;
if (x <= 0 || y <= 0) return 0;
if (x < y) swap(x, y);
if (isP2(x)) {
long long minAm = min(k, x);
return (getSum(minAm) * y) % 1000000007;
}
long long cP2 = 1;
while (cP2 < x || cP2 < y) cP2 *= 2;
cP2 /= 2;
long long ans = getSum(min(x, cP2), min(y, cP2), k);
ans += getSum(x - cP2, y - cP2, k);
ans += getSum(x - cP2, min(y, cP2), k - cP2) +
(cP2 * getAm(x - cP2, min(y, cP2), k - cP2)) % 1000000007;
ans += getSum(min(x, cP2), y - cP2, k - cP2) +
(cP2 * getAm(min(x, cP2), y - cP2, k - cP2)) % 1000000007;
ans %= 1000000007;
return ans % 1000000007;
}
int Q;
int main() {
scanf("%d", &Q);
long long cP2 = 1;
for (int(i) = (0); (i) < (40); ++(i)) {
p2.insert(cP2);
cP2 *= 2;
}
for (int(i) = (0); (i) < (Q); ++(i)) {
long long x1, x2, y1, y2, k;
scanf("%lld %lld %lld %lld %lld", &x1, &y1, &x2, &y2, &k);
long long ans = getSum(x2, y2, k) - getSum(x1 - 1, y2, k) -
getSum(x2, y1 - 1, k) + getSum(x1 - 1, y1 - 1, k);
ans %= 1000000007;
while (ans < 0) ans += 1000000007;
printf("%lld\n", ans);
}
return 0;
}
| CPP |
809_C. Find a car | After a wonderful evening in the restaurant the time to go home came. Leha as a true gentlemen suggested Noora to give her a lift. Certainly the girl agreed with pleasure. Suddenly one problem appeared: Leha cannot find his car on a huge parking near the restaurant. So he decided to turn to the watchman for help.
Formally the parking can be represented as a matrix 109 × 109. There is exactly one car in every cell of the matrix. All cars have their own machine numbers represented as a positive integer. Let's index the columns of the matrix by integers from 1 to 109 from left to right and the rows by integers from 1 to 109 from top to bottom. By coincidence it turned out, that for every cell (x, y) the number of the car, which stands in this cell, is equal to the minimum positive integer, which can't be found in the cells (i, y) and (x, j), 1 ≤ i < x, 1 ≤ j < y.
<image> The upper left fragment 5 × 5 of the parking
Leha wants to ask the watchman q requests, which can help him to find his car. Every request is represented as five integers x1, y1, x2, y2, k. The watchman have to consider all cells (x, y) of the matrix, such that x1 ≤ x ≤ x2 and y1 ≤ y ≤ y2, and if the number of the car in cell (x, y) does not exceed k, increase the answer to the request by the number of the car in cell (x, y). For each request Leha asks the watchman to tell him the resulting sum. Due to the fact that the sum can turn out to be quite large, hacker asks to calculate it modulo 109 + 7.
However the requests seem to be impracticable for the watchman. Help the watchman to answer all Leha's requests.
Input
The first line contains one integer q (1 ≤ q ≤ 104) — the number of Leha's requests.
The next q lines contain five integers x1, y1, x2, y2, k (1 ≤ x1 ≤ x2 ≤ 109, 1 ≤ y1 ≤ y2 ≤ 109, 1 ≤ k ≤ 2·109) — parameters of Leha's requests.
Output
Print exactly q lines — in the first line print the answer to the first request, in the second — the answer to the second request and so on.
Example
Input
4
1 1 1 1 1
3 2 5 4 5
1 1 5 5 10000
1 4 2 5 2
Output
1
13
93
0
Note
Let's analyze all the requests. In each case the requested submatrix is highlighted in blue.
In the first request (k = 1) Leha asks only about the upper left parking cell. In this cell the car's number is 1. Consequentally the answer is 1.
<image>
In the second request (k = 5) suitable numbers are 4, 1, 2, 3, 2, 1. Consequentally the answer is 4 + 1 + 2 + 3 + 2 + 1 = 13.
<image>
In the third request (k = 10000) Leha asks about the upper left frament 5 × 5 of the parking. Since k is big enough, the answer is equal to 93.
<image>
In the last request (k = 2) none of the cur's numbers are suitable, so the answer is 0.
<image> | 2 | 9 | import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.IOException;
import java.io.InputStream;
/**
* Built using CHelper plug-in
* Actual solution is at the top
*/
public class Main {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
InputReader in = new InputReader(inputStream);
PrintWriter out = new PrintWriter(outputStream);
TaskC solver = new TaskC();
solver.solve(1, in, out);
out.close();
}
static class TaskC {
final int MOD = (int) 1e9 + 7;
public void solve(int testNumber, InputReader in, PrintWriter out) {
int q = in.nextInt();
while (q-- > 0) {
int x1 = in.nextInt() - 1;
int y1 = in.nextInt() - 1;
int x2 = in.nextInt() - 1;
int y2 = in.nextInt() - 1;
int k = in.nextInt() - 1;
int ans = (solve(k, x2, y2) - solve(k, x1 - 1, y2)) % MOD -
(solve(k, x2, y1 - 1) - solve(k, x1 - 1, y1 - 1)) % MOD;
ans %= MOD;
if (ans < 0) {
ans += MOD;
}
out.println(ans);
}
}
private int solve(int k, int a, int b) {
if (a < 0 || b < 0) {
return 0;
}
int[][][][] dp = new int[32][2][2][2];
int[][][][] dpSum = new int[32][2][2][2];
dp[31][0][0][0] = 1;
for (int i = 30; i >= 0; --i) {
for (int putA = 0; putA < 2; ++putA) {
for (int putB = 0; putB < 2; ++putB) {
int putK = putA ^ putB;
int value = 0;
if (putK > 0) {
value = (1 << i) % MOD;
}
for (int lastK = 0; lastK < 2; ++lastK) {
int nK = computeNew(k, i, putK, lastK);
if (nK == -1) continue;
for (int lastA = 0; lastA < 2; ++lastA) {
int nA = computeNew(a, i, putA, lastA);
if (nA == -1) continue;
for (int lastB = 0; lastB < 2; ++lastB) {
int nB = computeNew(b, i, putB, lastB);
if (nB == -1) continue;
dp[i][nK][nA][nB] += dp[i + 1][lastK][lastA][lastB];
dp[i][nK][nA][nB] %= MOD;
dpSum[i][nK][nA][nB] += (long) dp[i + 1][lastK][lastA][lastB] * value % MOD;
dpSum[i][nK][nA][nB] %= MOD;
dpSum[i][nK][nA][nB] += dpSum[i + 1][lastK][lastA][lastB];
dpSum[i][nK][nA][nB] %= MOD;
}
}
}
}
}
}
int ans = 0;
for (int i = 0; i < 2; ++i) {
for (int j = 0; j < 2; ++j) {
for (int l = 0; l < 2; ++l) {
ans += dpSum[0][i][j][l];
ans %= MOD;
ans += dp[0][i][j][l];
ans %= MOD;
}
}
}
return ans;
}
int computeNew(int k, int i, int put, int last) {
if (last == 1) {
return 1;
}
int nK;
if (put == 0) {
nK = ((k & (1 << i)) != 0) ? 1 : 0;
} else {
if ((k & (1 << i)) == 0) {
return -1;
} else {
nK = 0;
}
}
return nK;
}
}
static class InputReader {
private InputStream stream;
private byte[] buf = new byte[1024];
private int curChar;
private int numChars;
public InputReader(InputStream stream) {
this.stream = stream;
}
public int read() {
if (numChars == -1)
throw new UnknownError();
if (curChar >= numChars) {
curChar = 0;
try {
numChars = stream.read(buf);
} catch (IOException e) {
throw new UnknownError();
}
if (numChars <= 0)
return -1;
}
return buf[curChar++];
}
public int nextInt() {
return Integer.parseInt(next());
}
public String next() {
int c = read();
while (isSpaceChar(c))
c = read();
StringBuffer res = new StringBuffer();
do {
res.appendCodePoint(c);
c = read();
} while (!isSpaceChar(c));
return res.toString();
}
private boolean isSpaceChar(int c) {
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
}
}
| JAVA |
809_C. Find a car | After a wonderful evening in the restaurant the time to go home came. Leha as a true gentlemen suggested Noora to give her a lift. Certainly the girl agreed with pleasure. Suddenly one problem appeared: Leha cannot find his car on a huge parking near the restaurant. So he decided to turn to the watchman for help.
Formally the parking can be represented as a matrix 109 × 109. There is exactly one car in every cell of the matrix. All cars have their own machine numbers represented as a positive integer. Let's index the columns of the matrix by integers from 1 to 109 from left to right and the rows by integers from 1 to 109 from top to bottom. By coincidence it turned out, that for every cell (x, y) the number of the car, which stands in this cell, is equal to the minimum positive integer, which can't be found in the cells (i, y) and (x, j), 1 ≤ i < x, 1 ≤ j < y.
<image> The upper left fragment 5 × 5 of the parking
Leha wants to ask the watchman q requests, which can help him to find his car. Every request is represented as five integers x1, y1, x2, y2, k. The watchman have to consider all cells (x, y) of the matrix, such that x1 ≤ x ≤ x2 and y1 ≤ y ≤ y2, and if the number of the car in cell (x, y) does not exceed k, increase the answer to the request by the number of the car in cell (x, y). For each request Leha asks the watchman to tell him the resulting sum. Due to the fact that the sum can turn out to be quite large, hacker asks to calculate it modulo 109 + 7.
However the requests seem to be impracticable for the watchman. Help the watchman to answer all Leha's requests.
Input
The first line contains one integer q (1 ≤ q ≤ 104) — the number of Leha's requests.
The next q lines contain five integers x1, y1, x2, y2, k (1 ≤ x1 ≤ x2 ≤ 109, 1 ≤ y1 ≤ y2 ≤ 109, 1 ≤ k ≤ 2·109) — parameters of Leha's requests.
Output
Print exactly q lines — in the first line print the answer to the first request, in the second — the answer to the second request and so on.
Example
Input
4
1 1 1 1 1
3 2 5 4 5
1 1 5 5 10000
1 4 2 5 2
Output
1
13
93
0
Note
Let's analyze all the requests. In each case the requested submatrix is highlighted in blue.
In the first request (k = 1) Leha asks only about the upper left parking cell. In this cell the car's number is 1. Consequentally the answer is 1.
<image>
In the second request (k = 5) suitable numbers are 4, 1, 2, 3, 2, 1. Consequentally the answer is 4 + 1 + 2 + 3 + 2 + 1 = 13.
<image>
In the third request (k = 10000) Leha asks about the upper left frament 5 × 5 of the parking. Since k is big enough, the answer is equal to 93.
<image>
In the last request (k = 2) none of the cur's numbers are suitable, so the answer is 0.
<image> | 2 | 9 | #include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 7;
const int MAXN = 1e3 + 7;
const int MOD = 1e9 + 7;
int n;
int dp[34][2][2][2];
int sum[34][2][2][2];
int x, y, k;
int dfs(int pos, int limx, int limy, int limk, int &t) {
if (pos == -1) return 1;
int &st = sum[pos][limx][limy][limk];
if (~dp[pos][limx][limy][limk]) {
(t += st) %= MOD;
return dp[pos][limx][limy][limk];
}
st = 0;
int zx = 1, zy = 1;
if (limx) zx = x >> pos & 1;
if (limy) zy = y >> pos & 1;
long long res = 0, posk = k >> pos & 1;
long long ta;
for (int i = 0; i <= zx; i++)
for (int j = 0; j <= zy; j++) {
long long tb = ((i ^ j) << pos) % MOD;
if (limk) {
if ((i ^ j) <= posk) {
ta = dfs(pos - 1, limx && zx == i, limy && zy == j, (i ^ j) == posk,
st);
res += ta;
st = (ta * tb % MOD + st) % MOD;
}
} else {
ta = dfs(pos - 1, limx && zx == i, limy && zy == j, 0, st);
res += ta;
st = (ta * tb % MOD + st) % MOD;
}
}
res %= MOD;
(t += st) %= MOD;
dp[pos][limx][limy][limk] = res;
return res;
}
int solve(int a, int b) {
if (a < 0 || b < 0) return 0;
memset(dp, -1, sizeof(dp));
int ans = 0;
x = a, y = b;
long long tmp = dfs(30, 1, 1, 1, ans);
tmp = (tmp + ans) % MOD;
return tmp;
}
int main() {
int q, x1, y1, x2, y2;
scanf("%d", &q);
while (q--) {
scanf("%d%d%d%d%d", &x1, &y1, &x2, &y2, &k);
x1--, y1--, x2--, y2--, k--;
long long ans = solve(x2, y2) - solve(x1 - 1, y2) - solve(x2, y1 - 1) +
solve(x1 - 1, y1 - 1);
ans = ans % MOD;
if (ans < 0) ans += MOD;
printf("%d\n", ans);
}
return 0;
}
| CPP |
809_C. Find a car | After a wonderful evening in the restaurant the time to go home came. Leha as a true gentlemen suggested Noora to give her a lift. Certainly the girl agreed with pleasure. Suddenly one problem appeared: Leha cannot find his car on a huge parking near the restaurant. So he decided to turn to the watchman for help.
Formally the parking can be represented as a matrix 109 × 109. There is exactly one car in every cell of the matrix. All cars have their own machine numbers represented as a positive integer. Let's index the columns of the matrix by integers from 1 to 109 from left to right and the rows by integers from 1 to 109 from top to bottom. By coincidence it turned out, that for every cell (x, y) the number of the car, which stands in this cell, is equal to the minimum positive integer, which can't be found in the cells (i, y) and (x, j), 1 ≤ i < x, 1 ≤ j < y.
<image> The upper left fragment 5 × 5 of the parking
Leha wants to ask the watchman q requests, which can help him to find his car. Every request is represented as five integers x1, y1, x2, y2, k. The watchman have to consider all cells (x, y) of the matrix, such that x1 ≤ x ≤ x2 and y1 ≤ y ≤ y2, and if the number of the car in cell (x, y) does not exceed k, increase the answer to the request by the number of the car in cell (x, y). For each request Leha asks the watchman to tell him the resulting sum. Due to the fact that the sum can turn out to be quite large, hacker asks to calculate it modulo 109 + 7.
However the requests seem to be impracticable for the watchman. Help the watchman to answer all Leha's requests.
Input
The first line contains one integer q (1 ≤ q ≤ 104) — the number of Leha's requests.
The next q lines contain five integers x1, y1, x2, y2, k (1 ≤ x1 ≤ x2 ≤ 109, 1 ≤ y1 ≤ y2 ≤ 109, 1 ≤ k ≤ 2·109) — parameters of Leha's requests.
Output
Print exactly q lines — in the first line print the answer to the first request, in the second — the answer to the second request and so on.
Example
Input
4
1 1 1 1 1
3 2 5 4 5
1 1 5 5 10000
1 4 2 5 2
Output
1
13
93
0
Note
Let's analyze all the requests. In each case the requested submatrix is highlighted in blue.
In the first request (k = 1) Leha asks only about the upper left parking cell. In this cell the car's number is 1. Consequentally the answer is 1.
<image>
In the second request (k = 5) suitable numbers are 4, 1, 2, 3, 2, 1. Consequentally the answer is 4 + 1 + 2 + 3 + 2 + 1 = 13.
<image>
In the third request (k = 10000) Leha asks about the upper left frament 5 × 5 of the parking. Since k is big enough, the answer is equal to 93.
<image>
In the last request (k = 2) none of the cur's numbers are suitable, so the answer is 0.
<image> | 2 | 9 | #include <bits/stdc++.h>
inline int pidorand() { return ((rand() & 32767) << 15) | (rand() & 32767); }
using namespace std;
inline int nxt() {
int x;
scanf("%d", &x);
return x;
}
const int mod = 1000000007;
const int init = 1 << 30;
long long getSum(int x, int y, int sz) {
long long res = 0;
for (int i = 1; i < sz; i <<= 1) {
int x1 = (x & (i + i - 1));
int y1 = (y & (i + i - 1));
res += ((1ll * x * y - 1ll * x1 * y1) / 2 % mod +
(1ll * min(x1, i) * max(0, y1 - i) +
1ll * min(y1, i) * max(0, x1 - i)) %
mod) *
i % mod;
}
return res % mod;
}
pair<long long, long long> f(int x, int y, int k, int sz = init) {
if (x < 0 || y < 0 || k < 0) {
return {0, 0};
}
x = min(x, sz);
y = min(y, sz);
k = min(k, sz - 1);
if (sz == x && sz == y) {
return {1ll * k * (k + 1) / 2 % mod * sz % mod, 1ll * (k + 1) * sz % mod};
}
if (k == sz - 1) {
return {getSum(x, y, sz), 1ll * x * y % mod};
}
int nx = sz / 2;
auto p00 = f(x, y, k, nx);
auto p01 = f(x, y - nx, k - nx, nx);
auto p10 = f(x - nx, y, k - nx, nx);
auto p11 = f(x - nx, y - nx, k, nx);
pair<long long, long long> ret = {0, 0};
ret.first = p00.first + p01.first + p10.first + p11.first;
ret.second = (p00.second + p01.second + p10.second + p11.second) % mod;
ret.first += 1ll * nx * (p01.second + p10.second) % mod;
ret.first %= mod;
return ret;
}
long long g(int x, int y, int k) {
auto p = f(x, y, k);
return (p.first + p.second) % mod;
}
int getAns(int x1, int y1, int x2, int y2, int k) {
long long res = g(x2, y2, k) - g(x1, y2, k) - g(x2, y1, k) + g(x1, y1, k);
res %= mod;
if (res < 0) {
res += mod;
}
return res;
}
int main() {
int q = nxt();
while (q--) {
int x1 = nxt() - 1, y1 = nxt() - 1, x2 = nxt(), y2 = nxt(), k = nxt() - 1;
printf("%d\n", getAns(x1, y1, x2, y2, k));
}
return 0;
}
| CPP |
809_C. Find a car | After a wonderful evening in the restaurant the time to go home came. Leha as a true gentlemen suggested Noora to give her a lift. Certainly the girl agreed with pleasure. Suddenly one problem appeared: Leha cannot find his car on a huge parking near the restaurant. So he decided to turn to the watchman for help.
Formally the parking can be represented as a matrix 109 × 109. There is exactly one car in every cell of the matrix. All cars have their own machine numbers represented as a positive integer. Let's index the columns of the matrix by integers from 1 to 109 from left to right and the rows by integers from 1 to 109 from top to bottom. By coincidence it turned out, that for every cell (x, y) the number of the car, which stands in this cell, is equal to the minimum positive integer, which can't be found in the cells (i, y) and (x, j), 1 ≤ i < x, 1 ≤ j < y.
<image> The upper left fragment 5 × 5 of the parking
Leha wants to ask the watchman q requests, which can help him to find his car. Every request is represented as five integers x1, y1, x2, y2, k. The watchman have to consider all cells (x, y) of the matrix, such that x1 ≤ x ≤ x2 and y1 ≤ y ≤ y2, and if the number of the car in cell (x, y) does not exceed k, increase the answer to the request by the number of the car in cell (x, y). For each request Leha asks the watchman to tell him the resulting sum. Due to the fact that the sum can turn out to be quite large, hacker asks to calculate it modulo 109 + 7.
However the requests seem to be impracticable for the watchman. Help the watchman to answer all Leha's requests.
Input
The first line contains one integer q (1 ≤ q ≤ 104) — the number of Leha's requests.
The next q lines contain five integers x1, y1, x2, y2, k (1 ≤ x1 ≤ x2 ≤ 109, 1 ≤ y1 ≤ y2 ≤ 109, 1 ≤ k ≤ 2·109) — parameters of Leha's requests.
Output
Print exactly q lines — in the first line print the answer to the first request, in the second — the answer to the second request and so on.
Example
Input
4
1 1 1 1 1
3 2 5 4 5
1 1 5 5 10000
1 4 2 5 2
Output
1
13
93
0
Note
Let's analyze all the requests. In each case the requested submatrix is highlighted in blue.
In the first request (k = 1) Leha asks only about the upper left parking cell. In this cell the car's number is 1. Consequentally the answer is 1.
<image>
In the second request (k = 5) suitable numbers are 4, 1, 2, 3, 2, 1. Consequentally the answer is 4 + 1 + 2 + 3 + 2 + 1 = 13.
<image>
In the third request (k = 10000) Leha asks about the upper left frament 5 × 5 of the parking. Since k is big enough, the answer is equal to 93.
<image>
In the last request (k = 2) none of the cur's numbers are suitable, so the answer is 0.
<image> | 2 | 9 | #include <bits/stdc++.h>
using namespace std;
const int maxs = 40;
const int N = 30;
const int Mo = 1000000007;
int f[maxs][2][2][2], g[maxs][2][2][2];
int DP(int n, int m, int K) {
K--, n--, m--;
if (K < 0 || n < 0 || m < 0) return 0;
memset(f, 0, sizeof(f));
memset(g, 0, sizeof(g));
g[N + 1][1][1][1] = 1;
int s, sn, sm, sk, i, j, k, x, y, z, ii, jj, kk, gg, ff;
for (s = N; s >= 0; --s) {
sn = ((n >> s) & 1), sm = ((m >> s) & 1), sk = ((K >> s) & 1);
for (i = 0; i < 2; ++i) {
for (j = 0; j < 2; ++j) {
for (k = 0; k < 2; ++k) {
gg = g[s + 1][i][j][k], ff = f[s + 1][i][j][k];
if (gg + ff == 0) continue;
for (x = 0; x < 2; ++x) {
for (y = 0; y < 2; ++y) {
z = (x ^ y), ii = i, jj = j, kk = k;
if (i && x < sn) ii = 0;
if (i && x > sn) continue;
if (j && y < sm) jj = 0;
if (j && y > sm) continue;
if (k && z < sk) kk = 0;
if (k && z > sk) continue;
g[s][ii][jj][kk] = (g[s][ii][jj][kk] + gg) % Mo;
f[s][ii][jj][kk] =
(1LL * z * (1 << s) * gg + ff + f[s][ii][jj][kk]) % Mo;
}
}
}
}
}
}
int ans = 0;
for (int i = 0; i < 2; ++i) {
for (int j = 0; j < 2; ++j) {
for (int k = 0; k < 2; ++k) {
ans = ((long long)ans + f[0][i][j][k] + g[0][i][j][k]) % Mo;
}
}
}
return ans;
}
int main() {
int sumt, x1, y1, x2, y2, k;
scanf("%d", &sumt);
while (sumt--) {
scanf("%d%d%d%d%d", &x1, &y1, &x2, &y2, &k);
int ans = (DP(x2, y2, k) + DP(x1 - 1, y1 - 1, k)) % Mo;
ans = (ans - DP(x1 - 1, y2, k)) % Mo;
ans = (ans - DP(x2, y1 - 1, k)) % Mo;
ans = (ans % Mo + Mo) % Mo;
printf("%d\n", ans);
}
return 0;
}
| CPP |
809_C. Find a car | After a wonderful evening in the restaurant the time to go home came. Leha as a true gentlemen suggested Noora to give her a lift. Certainly the girl agreed with pleasure. Suddenly one problem appeared: Leha cannot find his car on a huge parking near the restaurant. So he decided to turn to the watchman for help.
Formally the parking can be represented as a matrix 109 × 109. There is exactly one car in every cell of the matrix. All cars have their own machine numbers represented as a positive integer. Let's index the columns of the matrix by integers from 1 to 109 from left to right and the rows by integers from 1 to 109 from top to bottom. By coincidence it turned out, that for every cell (x, y) the number of the car, which stands in this cell, is equal to the minimum positive integer, which can't be found in the cells (i, y) and (x, j), 1 ≤ i < x, 1 ≤ j < y.
<image> The upper left fragment 5 × 5 of the parking
Leha wants to ask the watchman q requests, which can help him to find his car. Every request is represented as five integers x1, y1, x2, y2, k. The watchman have to consider all cells (x, y) of the matrix, such that x1 ≤ x ≤ x2 and y1 ≤ y ≤ y2, and if the number of the car in cell (x, y) does not exceed k, increase the answer to the request by the number of the car in cell (x, y). For each request Leha asks the watchman to tell him the resulting sum. Due to the fact that the sum can turn out to be quite large, hacker asks to calculate it modulo 109 + 7.
However the requests seem to be impracticable for the watchman. Help the watchman to answer all Leha's requests.
Input
The first line contains one integer q (1 ≤ q ≤ 104) — the number of Leha's requests.
The next q lines contain five integers x1, y1, x2, y2, k (1 ≤ x1 ≤ x2 ≤ 109, 1 ≤ y1 ≤ y2 ≤ 109, 1 ≤ k ≤ 2·109) — parameters of Leha's requests.
Output
Print exactly q lines — in the first line print the answer to the first request, in the second — the answer to the second request and so on.
Example
Input
4
1 1 1 1 1
3 2 5 4 5
1 1 5 5 10000
1 4 2 5 2
Output
1
13
93
0
Note
Let's analyze all the requests. In each case the requested submatrix is highlighted in blue.
In the first request (k = 1) Leha asks only about the upper left parking cell. In this cell the car's number is 1. Consequentally the answer is 1.
<image>
In the second request (k = 5) suitable numbers are 4, 1, 2, 3, 2, 1. Consequentally the answer is 4 + 1 + 2 + 3 + 2 + 1 = 13.
<image>
In the third request (k = 10000) Leha asks about the upper left frament 5 × 5 of the parking. Since k is big enough, the answer is equal to 93.
<image>
In the last request (k = 2) none of the cur's numbers are suitable, so the answer is 0.
<image> | 2 | 9 | #include <bits/stdc++.h>
using namespace std;
void read(int &x) {
int v = 0, f = 1;
char c = getchar();
while (!isdigit(c) && c != '-') c = getchar();
if (c == '-')
f = -1;
else
v = v * 10 + c - '0';
while (isdigit(c = getchar())) v = v * 10 + c - '0';
x = v * f;
}
void read(long long &x) {
long long v = 0ll, f = 1ll;
char c = getchar();
while (!isdigit(c) && c != '-') c = getchar();
if (c == '-')
f = -1;
else
v = v * 10 + c - '0';
while (isdigit(c = getchar())) v = v * 10 + c - '0';
x = v * f;
}
void readc(char &x) {
char c;
while ((c = getchar()) == ' ')
;
x = c;
}
void writes(string s) { puts(s.c_str()); }
void writeln() { writes(""); }
void writei(int x) {
if (x < 0) {
putchar('-');
x = abs(x);
}
if (!x) putchar('0');
char a[25];
int top = 0;
while (x) {
a[++top] = (x % 10) + '0';
x /= 10;
}
while (top) {
putchar(a[top]);
top--;
}
}
void writell(long long x) {
if (x < 0) {
putchar('-');
x = abs(x);
}
if (!x) putchar('0');
char a[25];
int top = 0;
while (x) {
a[++top] = (x % 10) + '0';
x /= 10;
}
while (top) {
putchar(a[top]);
top--;
}
}
inline long long inc(int &x) { return ++x; }
inline long long inc(long long &x) { return ++x; }
inline long long inc(int &x, long long y) { return x += y; }
inline long long inc(long long &x, long long y) { return x += y; }
inline double inc(double &x, double y) { return x += y; }
inline long long dec(int &x) { return --x; }
inline long long dec(long long &x) { return --x; }
inline long long dec(int &x, long long y) { return x -= y; }
inline long long dec(long long &x, long long y) { return x -= y; }
inline double dec(double &x, double y) { return x -= y; }
inline long long mul(int &x) { return x = ((long long)x) * x; }
inline long long mul(long long &x) { return x = x * x; }
inline long long mul(int &x, long long y) { return x *= y; }
inline long long mul(long long &x, long long y) { return x *= y; }
inline double mul(double &x, double y) { return x *= y; }
inline long long divi(const int &x) {
long long ans, l, r, mid;
ans = 0;
l = 0;
r = 0x3fffffff;
while (l < r) {
mid = (l + r) / 2;
if (mid * mid <= x) {
ans = mid;
l = mid + 1;
} else
r = mid;
}
return ans;
}
inline long long divi(const long long &x) {
long long ans, l, r, mid;
ans = 0;
l = 0;
r = 0x3fffffff;
while (l < r) {
mid = (l + r) / 2;
if (mid * mid <= x) {
ans = mid;
l = mid + 1;
} else
r = mid;
}
return ans;
}
inline long long divi(int &x, long long y) { return x /= y; }
inline long long divi(long long &x, long long y) { return x /= y; }
inline double divi(double &x, double y) { return x /= y; }
inline long long mod(int &x, long long y) { return x %= y; }
inline long long mod(long long &x, long long y) { return x %= y; }
int n, m, i, j, f[32][2][2][2], g[32][2][2][2], lst[32][2][2][2], ti, x, y, xx,
yy, k, csc = 1e9 + 7;
vector<int> digx, digy, digk;
pair<int, int> dfs(int x, int limx, int limy, int limk) {
if (x < 0) {
if (limx || limy || limk) return make_pair(0, 0);
return make_pair(1, 0);
}
if (lst[x][limx][limy][limk] == ti)
return make_pair(f[x][limx][limy][limk], g[x][limx][limy][limk]);
lst[x][limx][limy][limk] = ti;
int i, j;
f[x][limx][limy][limk] = g[x][limx][limy][limk] = 0;
if ((0) <= (1))
for ((i) = (0); (i) <= (1); (i)++) {
if ((0) <= (1))
for ((j) = (0); (j) <= (1); (j)++) {
if (limx && i > digx[x]) continue;
if (limy && j > digy[x]) continue;
if (limk && (i ^ j) > digk[x]) continue;
pair<int, int> s =
dfs(x - 1, limx && (i >= digx[x]), limy && (j >= digy[x]),
limk && ((i ^ j) >= digk[x]));
(f[x][limx][limy][limk] += s.first) %= csc;
(g[x][limx][limy][limk] += s.second) %= csc;
if (i ^ j)
(g[x][limx][limy][limk] += (1ll << x) * s.first % csc) %= csc;
}
}
return make_pair(f[x][limx][limy][limk], g[x][limx][limy][limk]);
}
int solve(int x, int y, int z) {
ti++;
digx.clear();
digy.clear();
digk.clear();
while (x || y || z) {
digx.push_back(x & 1);
digy.push_back(y & 1);
digk.push_back(z & 1);
x >>= 1;
y >>= 1;
z >>= 1;
}
pair<int, int> s = dfs(digx.size() - 1, 1, 1, 1);
return (s.first + s.second) % csc;
}
int main() {
int t;
read(t);
while (t--) {
read(x);
read(y);
read(xx);
read(yy);
read(k);
printf("%d\n", (0ll + solve(xx, yy, k) - solve(x - 1, yy, k) -
solve(xx, y - 1, k) + solve(x - 1, y - 1, k) + csc * 3ll) %
csc);
}
return 0;
}
| CPP |
809_C. Find a car | After a wonderful evening in the restaurant the time to go home came. Leha as a true gentlemen suggested Noora to give her a lift. Certainly the girl agreed with pleasure. Suddenly one problem appeared: Leha cannot find his car on a huge parking near the restaurant. So he decided to turn to the watchman for help.
Formally the parking can be represented as a matrix 109 × 109. There is exactly one car in every cell of the matrix. All cars have their own machine numbers represented as a positive integer. Let's index the columns of the matrix by integers from 1 to 109 from left to right and the rows by integers from 1 to 109 from top to bottom. By coincidence it turned out, that for every cell (x, y) the number of the car, which stands in this cell, is equal to the minimum positive integer, which can't be found in the cells (i, y) and (x, j), 1 ≤ i < x, 1 ≤ j < y.
<image> The upper left fragment 5 × 5 of the parking
Leha wants to ask the watchman q requests, which can help him to find his car. Every request is represented as five integers x1, y1, x2, y2, k. The watchman have to consider all cells (x, y) of the matrix, such that x1 ≤ x ≤ x2 and y1 ≤ y ≤ y2, and if the number of the car in cell (x, y) does not exceed k, increase the answer to the request by the number of the car in cell (x, y). For each request Leha asks the watchman to tell him the resulting sum. Due to the fact that the sum can turn out to be quite large, hacker asks to calculate it modulo 109 + 7.
However the requests seem to be impracticable for the watchman. Help the watchman to answer all Leha's requests.
Input
The first line contains one integer q (1 ≤ q ≤ 104) — the number of Leha's requests.
The next q lines contain five integers x1, y1, x2, y2, k (1 ≤ x1 ≤ x2 ≤ 109, 1 ≤ y1 ≤ y2 ≤ 109, 1 ≤ k ≤ 2·109) — parameters of Leha's requests.
Output
Print exactly q lines — in the first line print the answer to the first request, in the second — the answer to the second request and so on.
Example
Input
4
1 1 1 1 1
3 2 5 4 5
1 1 5 5 10000
1 4 2 5 2
Output
1
13
93
0
Note
Let's analyze all the requests. In each case the requested submatrix is highlighted in blue.
In the first request (k = 1) Leha asks only about the upper left parking cell. In this cell the car's number is 1. Consequentally the answer is 1.
<image>
In the second request (k = 5) suitable numbers are 4, 1, 2, 3, 2, 1. Consequentally the answer is 4 + 1 + 2 + 3 + 2 + 1 = 13.
<image>
In the third request (k = 10000) Leha asks about the upper left frament 5 × 5 of the parking. Since k is big enough, the answer is equal to 93.
<image>
In the last request (k = 2) none of the cur's numbers are suitable, so the answer is 0.
<image> | 2 | 9 | #include <bits/stdc++.h>
using namespace std;
template <int MOD>
struct ModInt {
static const int Mod = MOD;
unsigned x;
ModInt() : x(0) {}
ModInt(signed sig) {
int sigt = sig % MOD;
if (sigt < 0) sigt += MOD;
x = sigt;
}
ModInt(signed long long sig) {
int sigt = sig % MOD;
if (sigt < 0) sigt += MOD;
x = sigt;
}
int get() const { return (int)x; }
ModInt &operator+=(ModInt that) {
if ((x += that.x) >= MOD) x -= MOD;
return *this;
}
ModInt &operator-=(ModInt that) {
if ((x += MOD - that.x) >= MOD) x -= MOD;
return *this;
}
ModInt &operator*=(ModInt that) {
x = (unsigned long long)x * that.x % MOD;
return *this;
}
ModInt operator+(ModInt that) const { return ModInt(*this) += that; }
ModInt operator-(ModInt that) const { return ModInt(*this) -= that; }
ModInt operator*(ModInt that) const { return ModInt(*this) *= that; }
};
int X, Y, K;
pair<ModInt<1000000007>, ModInt<1000000007> > dp[33][2][2][2];
pair<ModInt<1000000007>, ModInt<1000000007> > go(int i, bool xl, bool yl,
bool kl) {
pair<ModInt<1000000007>, ModInt<1000000007> > &ret = dp[i + 1][xl][yl][kl];
if (ret.first.get() != -1) return ret;
if (i == -1) return ret = make_pair(xl && yl && kl, 0);
ret = make_pair(0, 0);
int xb = X >> i & 1;
int yb = Y >> i & 1;
int kb = K >> i & 1;
for (int x = 0; x < 2; x++)
for (int y = 0; y < 2; y++) {
int k = x ^ y;
if (!xl && xb < x) continue;
if (!yl && yb < y) continue;
if (!kl && kb < k) continue;
pair<ModInt<1000000007>, ModInt<1000000007> > cur =
go(i - 1, xl || (x < xb), yl || (y < yb), kl || (k < kb));
ret.first += cur.first;
ret.second += cur.second + cur.first * ((long long)k << i);
}
return ret;
}
ModInt<1000000007> calc(int x, int y) {
X = x;
Y = y;
memset(dp, -1, sizeof dp);
pair<ModInt<1000000007>, ModInt<1000000007> > ans = go(31, 0, 0, 0);
return ans.first + ans.second;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int q;
cin >> q;
while (q--) {
int x1, x2, y1, y2;
cin >> x1 >> y1 >> x2 >> y2 >> K;
--x1;
--y1;
ModInt<1000000007> ans =
calc(x2, y2) - calc(x1, y2) - calc(x2, y1) + calc(x1, y1);
cout << ans.get() << "\n";
}
return 0;
}
| CPP |
809_C. Find a car | After a wonderful evening in the restaurant the time to go home came. Leha as a true gentlemen suggested Noora to give her a lift. Certainly the girl agreed with pleasure. Suddenly one problem appeared: Leha cannot find his car on a huge parking near the restaurant. So he decided to turn to the watchman for help.
Formally the parking can be represented as a matrix 109 × 109. There is exactly one car in every cell of the matrix. All cars have their own machine numbers represented as a positive integer. Let's index the columns of the matrix by integers from 1 to 109 from left to right and the rows by integers from 1 to 109 from top to bottom. By coincidence it turned out, that for every cell (x, y) the number of the car, which stands in this cell, is equal to the minimum positive integer, which can't be found in the cells (i, y) and (x, j), 1 ≤ i < x, 1 ≤ j < y.
<image> The upper left fragment 5 × 5 of the parking
Leha wants to ask the watchman q requests, which can help him to find his car. Every request is represented as five integers x1, y1, x2, y2, k. The watchman have to consider all cells (x, y) of the matrix, such that x1 ≤ x ≤ x2 and y1 ≤ y ≤ y2, and if the number of the car in cell (x, y) does not exceed k, increase the answer to the request by the number of the car in cell (x, y). For each request Leha asks the watchman to tell him the resulting sum. Due to the fact that the sum can turn out to be quite large, hacker asks to calculate it modulo 109 + 7.
However the requests seem to be impracticable for the watchman. Help the watchman to answer all Leha's requests.
Input
The first line contains one integer q (1 ≤ q ≤ 104) — the number of Leha's requests.
The next q lines contain five integers x1, y1, x2, y2, k (1 ≤ x1 ≤ x2 ≤ 109, 1 ≤ y1 ≤ y2 ≤ 109, 1 ≤ k ≤ 2·109) — parameters of Leha's requests.
Output
Print exactly q lines — in the first line print the answer to the first request, in the second — the answer to the second request and so on.
Example
Input
4
1 1 1 1 1
3 2 5 4 5
1 1 5 5 10000
1 4 2 5 2
Output
1
13
93
0
Note
Let's analyze all the requests. In each case the requested submatrix is highlighted in blue.
In the first request (k = 1) Leha asks only about the upper left parking cell. In this cell the car's number is 1. Consequentally the answer is 1.
<image>
In the second request (k = 5) suitable numbers are 4, 1, 2, 3, 2, 1. Consequentally the answer is 4 + 1 + 2 + 3 + 2 + 1 = 13.
<image>
In the third request (k = 10000) Leha asks about the upper left frament 5 × 5 of the parking. Since k is big enough, the answer is equal to 93.
<image>
In the last request (k = 2) none of the cur's numbers are suitable, so the answer is 0.
<image> | 2 | 9 | #include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
pair<long long, long long> query(int x, int y, int k) {
if (x <= 0 || y <= 0) return make_pair(0, 0);
if (x == 1 || y == 1) {
long long p =
((((((x) > (y)) ? (x) : (y))) < (k)) ? ((((x) > (y)) ? (x) : (y)))
: (k));
long long ret = (p * (p + 1) / 2) % mod;
return make_pair(ret, p);
}
long long ret = 0, cnt = 0;
long long l = log2((((x) > (y)) ? (x) : (y))),
p = ((((1ll << l)) < (k)) ? ((1ll << l)) : (k)),
m = ((((1ll << l)) < ((((x) < (y)) ? (x) : (y))))
? ((1ll << l))
: ((((x) < (y)) ? (x) : (y))));
pair<long long, long long> rem;
ret = ((((p * (p + 1)) / 2) % mod) * m) % mod;
cnt = (p * m) % mod;
long long r = (((x - (1ll << l)) > (0)) ? (x - (1ll << l)) : (0)),
c = (((y - (1ll << l)) > (0)) ? (y - (1ll << l)) : (0));
if ((r != 0 && c != 0) || (r == 0 && c == 0)) {
p = ((((((k) < ((1ll << (l + 1)))) ? (k) : ((1ll << (l + 1)))) -
(1ll << l)) > (0))
? ((((k) < ((1ll << (l + 1)))) ? (k) : ((1ll << (l + 1)))) -
(1ll << l))
: (0));
ret += (((((p * (p + 1)) / 2) % mod) * r) % mod +
((((r * p) % mod) * (1ll << l)) % mod)) %
mod;
if (ret >= mod) ret -= mod;
ret += (((((p * (p + 1)) / 2) % mod) * c) % mod +
((((c * p) % mod) * (1ll << l)) % mod)) %
mod;
if (ret >= mod) ret -= mod;
cnt = (cnt + (((r + c) % mod) * p) % mod) % mod;
rem = query(r, c, k);
cnt = (cnt + rem.second) % mod;
ret = (ret + rem.first) % mod;
return make_pair(ret, cnt);
}
if (r == 0) {
rem = query(x, c, (((k - (1ll << l)) > (0)) ? (k - (1ll << l)) : (0)));
}
if (c == 0) {
rem = query(r, y, (((k - (1ll << l)) > (0)) ? (k - (1ll << l)) : (0)));
}
ret += ((rem.second * (1ll << l)) % mod + rem.first) % mod;
if (ret >= mod) ret -= mod;
cnt = (cnt + rem.second) % mod;
return make_pair(ret, cnt);
}
int main() {
int q;
scanf("%d", &q);
while (q--) {
int x1, x2, y1, y2, k;
scanf("%d %d %d %d %d", &x1, &y1, &x2, &y2, &k);
printf("%lld\n", (query(x2, y2, k).first - query(x1 - 1, y2, k).first -
query(x2, y1 - 1, k).first +
query(x1 - 1, y1 - 1, k).first + 2 * mod) %
mod);
}
return 0;
}
| CPP |
809_C. Find a car | After a wonderful evening in the restaurant the time to go home came. Leha as a true gentlemen suggested Noora to give her a lift. Certainly the girl agreed with pleasure. Suddenly one problem appeared: Leha cannot find his car on a huge parking near the restaurant. So he decided to turn to the watchman for help.
Formally the parking can be represented as a matrix 109 × 109. There is exactly one car in every cell of the matrix. All cars have their own machine numbers represented as a positive integer. Let's index the columns of the matrix by integers from 1 to 109 from left to right and the rows by integers from 1 to 109 from top to bottom. By coincidence it turned out, that for every cell (x, y) the number of the car, which stands in this cell, is equal to the minimum positive integer, which can't be found in the cells (i, y) and (x, j), 1 ≤ i < x, 1 ≤ j < y.
<image> The upper left fragment 5 × 5 of the parking
Leha wants to ask the watchman q requests, which can help him to find his car. Every request is represented as five integers x1, y1, x2, y2, k. The watchman have to consider all cells (x, y) of the matrix, such that x1 ≤ x ≤ x2 and y1 ≤ y ≤ y2, and if the number of the car in cell (x, y) does not exceed k, increase the answer to the request by the number of the car in cell (x, y). For each request Leha asks the watchman to tell him the resulting sum. Due to the fact that the sum can turn out to be quite large, hacker asks to calculate it modulo 109 + 7.
However the requests seem to be impracticable for the watchman. Help the watchman to answer all Leha's requests.
Input
The first line contains one integer q (1 ≤ q ≤ 104) — the number of Leha's requests.
The next q lines contain five integers x1, y1, x2, y2, k (1 ≤ x1 ≤ x2 ≤ 109, 1 ≤ y1 ≤ y2 ≤ 109, 1 ≤ k ≤ 2·109) — parameters of Leha's requests.
Output
Print exactly q lines — in the first line print the answer to the first request, in the second — the answer to the second request and so on.
Example
Input
4
1 1 1 1 1
3 2 5 4 5
1 1 5 5 10000
1 4 2 5 2
Output
1
13
93
0
Note
Let's analyze all the requests. In each case the requested submatrix is highlighted in blue.
In the first request (k = 1) Leha asks only about the upper left parking cell. In this cell the car's number is 1. Consequentally the answer is 1.
<image>
In the second request (k = 5) suitable numbers are 4, 1, 2, 3, 2, 1. Consequentally the answer is 4 + 1 + 2 + 3 + 2 + 1 = 13.
<image>
In the third request (k = 10000) Leha asks about the upper left frament 5 × 5 of the parking. Since k is big enough, the answer is equal to 93.
<image>
In the last request (k = 2) none of the cur's numbers are suitable, so the answer is 0.
<image> | 2 | 9 | #include <bits/stdc++.h>
using namespace std;
using int64 = long long;
void DBG() { cerr << "]" << '\n'; }
template <class H, class... T>
void DBG(H h, T... t) {
cerr << h;
if (sizeof...(t)) cerr << ", ";
DBG(t...);
}
const int MOD = (int)1e9 + 7;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
auto solve = [](int a, int b, int k) {
if (a < 0 || b < 0 || k < 0) return 0LL;
int B = 30;
int64 s[B + 2][2][2][2], c[B + 2][2][2][2];
memset(s, 0, sizeof(s));
memset(c, 0, sizeof(c));
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2; j++)
for (int k = 0; k < 2; k++) c[B + 1][i][j][k] = 1;
for (int i = B; i >= 0; i--) {
for (int eqA = 0; eqA < 2; eqA++) {
for (int eqB = 0; eqB < 2; eqB++) {
for (int eqK = 0; eqK < 2; eqK++) {
int bitA = a >> (B - i) & 1;
int bitB = b >> (B - i) & 1;
int bitK = k >> (B - i) & 1;
int lA = eqA ? bitA : 1;
int lB = eqB ? bitB : 1;
int lK = eqK ? bitK : 1;
for (int x = 0; x <= lA; x++) {
for (int y = 0; y <= lB; y++) {
if ((x ^ y) > lK) continue;
int neqA = eqA && (x == bitA);
int neqB = eqB && (y == bitB);
int neqK = eqK && ((x ^ y) == bitK);
c[i][eqA][eqB][eqK] += c[i + 1][neqA][neqB][neqK];
c[i][eqA][eqB][eqK] %= MOD;
s[i][eqA][eqB][eqK] += s[i + 1][neqA][neqB][neqK];
s[i][eqA][eqB][eqK] %= MOD;
int64 v = 1LL * (x ^ y) * (1LL << (B - i)) % MOD;
s[i][eqA][eqB][eqK] += c[i + 1][neqA][neqB][neqK] * v % MOD;
s[i][eqA][eqB][eqK] %= MOD;
}
}
}
}
}
}
return s[0][1][1][1] + c[0][1][1][1];
};
int q;
cin >> q;
while (q--) {
int f1, c1, f2, c2, k;
cin >> f1 >> c1 >> f2 >> c2 >> k;
f1--, c1--, f2--, c2--, k--;
int64 ans = solve(f2, c2, k) - solve(f2, c1 - 1, k) - solve(f1 - 1, c2, k) +
solve(f1 - 1, c1 - 1, k);
ans = (ans + 10LL * MOD) % MOD;
cout << ans << '\n';
}
return 0;
}
| CPP |
809_C. Find a car | After a wonderful evening in the restaurant the time to go home came. Leha as a true gentlemen suggested Noora to give her a lift. Certainly the girl agreed with pleasure. Suddenly one problem appeared: Leha cannot find his car on a huge parking near the restaurant. So he decided to turn to the watchman for help.
Formally the parking can be represented as a matrix 109 × 109. There is exactly one car in every cell of the matrix. All cars have their own machine numbers represented as a positive integer. Let's index the columns of the matrix by integers from 1 to 109 from left to right and the rows by integers from 1 to 109 from top to bottom. By coincidence it turned out, that for every cell (x, y) the number of the car, which stands in this cell, is equal to the minimum positive integer, which can't be found in the cells (i, y) and (x, j), 1 ≤ i < x, 1 ≤ j < y.
<image> The upper left fragment 5 × 5 of the parking
Leha wants to ask the watchman q requests, which can help him to find his car. Every request is represented as five integers x1, y1, x2, y2, k. The watchman have to consider all cells (x, y) of the matrix, such that x1 ≤ x ≤ x2 and y1 ≤ y ≤ y2, and if the number of the car in cell (x, y) does not exceed k, increase the answer to the request by the number of the car in cell (x, y). For each request Leha asks the watchman to tell him the resulting sum. Due to the fact that the sum can turn out to be quite large, hacker asks to calculate it modulo 109 + 7.
However the requests seem to be impracticable for the watchman. Help the watchman to answer all Leha's requests.
Input
The first line contains one integer q (1 ≤ q ≤ 104) — the number of Leha's requests.
The next q lines contain five integers x1, y1, x2, y2, k (1 ≤ x1 ≤ x2 ≤ 109, 1 ≤ y1 ≤ y2 ≤ 109, 1 ≤ k ≤ 2·109) — parameters of Leha's requests.
Output
Print exactly q lines — in the first line print the answer to the first request, in the second — the answer to the second request and so on.
Example
Input
4
1 1 1 1 1
3 2 5 4 5
1 1 5 5 10000
1 4 2 5 2
Output
1
13
93
0
Note
Let's analyze all the requests. In each case the requested submatrix is highlighted in blue.
In the first request (k = 1) Leha asks only about the upper left parking cell. In this cell the car's number is 1. Consequentally the answer is 1.
<image>
In the second request (k = 5) suitable numbers are 4, 1, 2, 3, 2, 1. Consequentally the answer is 4 + 1 + 2 + 3 + 2 + 1 = 13.
<image>
In the third request (k = 10000) Leha asks about the upper left frament 5 × 5 of the parking. Since k is big enough, the answer is equal to 93.
<image>
In the last request (k = 2) none of the cur's numbers are suitable, so the answer is 0.
<image> | 2 | 9 | #include <bits/stdc++.h>
const int P = 1000000007;
int solve(int x, int y, int z) {
std::vector<std::pair<int, int>> f(8);
f[7] = std::make_pair(0, 1);
for (int l = 30; l >= 0; --l) {
std::vector<std::pair<int, int>> g(8);
int xl = x >> l & 1, yl = y >> l & 1, zl = z >> l & 1;
for (int S = 0; S < 8; ++S) {
for (int i = 0; i < 2; ++i) {
for (int j = 0; j < 2; ++j) {
int k = i ^ j;
if (S & 1 && i > xl) {
continue;
}
if (S & 2 && j > yl) {
continue;
}
if (S & 4 && k > zl) {
continue;
}
int T = S & ((i == xl) | (j == yl) << 1 | (k == zl) << 2);
g[T].second = (g[T].second + f[S].second) % P;
g[T].first =
(g[T].first + f[S].first + 1ll * (k << l) * f[S].second) % P;
}
}
}
f.swap(g);
}
return (f[0].first + f[0].second) % P;
}
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(0);
int T;
std::cin >> T;
while (T--) {
int sx, sy, tx, ty, v;
std::cin >> sx >> sy >> tx >> ty >> v;
--sx, --sy;
int ans = (solve(tx, ty, v) - solve(sx, ty, v) - solve(tx, sy, v) +
solve(sx, sy, v)) %
P;
std::cout << (ans + P) % P << "\n";
}
}
| CPP |
809_C. Find a car | After a wonderful evening in the restaurant the time to go home came. Leha as a true gentlemen suggested Noora to give her a lift. Certainly the girl agreed with pleasure. Suddenly one problem appeared: Leha cannot find his car on a huge parking near the restaurant. So he decided to turn to the watchman for help.
Formally the parking can be represented as a matrix 109 × 109. There is exactly one car in every cell of the matrix. All cars have their own machine numbers represented as a positive integer. Let's index the columns of the matrix by integers from 1 to 109 from left to right and the rows by integers from 1 to 109 from top to bottom. By coincidence it turned out, that for every cell (x, y) the number of the car, which stands in this cell, is equal to the minimum positive integer, which can't be found in the cells (i, y) and (x, j), 1 ≤ i < x, 1 ≤ j < y.
<image> The upper left fragment 5 × 5 of the parking
Leha wants to ask the watchman q requests, which can help him to find his car. Every request is represented as five integers x1, y1, x2, y2, k. The watchman have to consider all cells (x, y) of the matrix, such that x1 ≤ x ≤ x2 and y1 ≤ y ≤ y2, and if the number of the car in cell (x, y) does not exceed k, increase the answer to the request by the number of the car in cell (x, y). For each request Leha asks the watchman to tell him the resulting sum. Due to the fact that the sum can turn out to be quite large, hacker asks to calculate it modulo 109 + 7.
However the requests seem to be impracticable for the watchman. Help the watchman to answer all Leha's requests.
Input
The first line contains one integer q (1 ≤ q ≤ 104) — the number of Leha's requests.
The next q lines contain five integers x1, y1, x2, y2, k (1 ≤ x1 ≤ x2 ≤ 109, 1 ≤ y1 ≤ y2 ≤ 109, 1 ≤ k ≤ 2·109) — parameters of Leha's requests.
Output
Print exactly q lines — in the first line print the answer to the first request, in the second — the answer to the second request and so on.
Example
Input
4
1 1 1 1 1
3 2 5 4 5
1 1 5 5 10000
1 4 2 5 2
Output
1
13
93
0
Note
Let's analyze all the requests. In each case the requested submatrix is highlighted in blue.
In the first request (k = 1) Leha asks only about the upper left parking cell. In this cell the car's number is 1. Consequentally the answer is 1.
<image>
In the second request (k = 5) suitable numbers are 4, 1, 2, 3, 2, 1. Consequentally the answer is 4 + 1 + 2 + 3 + 2 + 1 = 13.
<image>
In the third request (k = 10000) Leha asks about the upper left frament 5 × 5 of the parking. Since k is big enough, the answer is equal to 93.
<image>
In the last request (k = 2) none of the cur's numbers are suitable, so the answer is 0.
<image> | 2 | 9 | #include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
inline void chkmin(T1 &x, T2 y) {
if (x > y) x = y;
}
template <typename T1, typename T2>
inline void chkmax(T1 &x, T2 y) {
if (x < y) x = y;
}
inline int readChar();
template <class T = int>
inline T readInt();
template <class T>
inline void writeInt(T x, char end = 0);
inline void writeChar(int x);
inline void writeWord(const char *s);
static const int buf_size = 4096;
inline int getChar() {
static char buf[buf_size];
static int len = 0, pos = 0;
if (pos == len) {
pos = 0, len = fread(buf, 1, buf_size, stdin);
}
if (pos == len) {
return -1;
}
return buf[pos++];
}
inline int readChar() {
int c = getChar();
while (c <= 32) {
c = getChar();
}
return c;
}
template <class T>
inline T readInt() {
int s = 1, c = readChar();
T x = 0;
if (c == '-') s = -1, c = getChar();
while ('0' <= c && c <= '9') x = x * 10 + c - '0', c = getChar();
return s == 1 ? x : -x;
}
static int write_pos = 0;
static char write_buf[buf_size];
inline void writeChar(int x) {
if (write_pos == buf_size)
fwrite(write_buf, 1, buf_size, stdout), write_pos = 0;
write_buf[write_pos++] = x;
}
template <class T>
inline void writeInt(T x, char end) {
if (x < 0) writeChar('-'), x = -x;
char s[24];
int n = 0;
while (x || !n) s[n++] = '0' + x % 10, x /= 10;
while (n--) writeChar(s[n]);
if (end) writeChar(end);
}
inline void writeWord(const char *s) {
while (*s) writeChar(*s++);
}
struct Flusher {
~Flusher() {
if (write_pos) fwrite(write_buf, 1, write_pos, stdout), write_pos = 0;
}
} flusher;
const int Mod = 1000000007;
int t;
int calc(int x, int y, int k, int add) {
if (x > y) {
swap(x, y);
}
if (!x) {
return 0;
}
if (k <= 0) {
return 0;
}
int z = 1 << (31 - __builtin_clz(y));
int ans = 0;
int kk = min(k, z);
if (x < z) {
ans = ((1LL * (kk + 1) * kk / 2 % Mod) * x) % Mod +
(((1LL * kk * x) % Mod * add) % Mod);
ans = (ans % Mod + calc(x, y - z, k - z, z + add)) % Mod;
} else {
ans = (((1LL * (kk + 1) * kk / 2 % Mod) * z) % Mod +
((1LL * kk * z) % Mod * add)) %
Mod +
calc(x - z, y - z, k, add);
ans = (1LL * ans + 1LL * (calc(z, y - z, k - z, z + add) +
calc(z, x - z, k - z, z + add))) %
Mod;
}
return ans;
}
int x, y, x1, y1228, k;
int main() {
t = readInt();
for (int it = 0; it < t; it++) {
x = readInt(), y = readInt(), x1 = readInt(), y1228 = readInt(),
k = readInt();
x--, y--;
int ans = calc(x1, y1228, k, 0) + calc(x, y, k, 0) - calc(x, y1228, k, 0) -
calc(x1, y, k, 0);
ans = (1LL * ans + Mod * 2) % Mod;
writeInt(ans, '\n');
}
return 0;
}
| CPP |
809_C. Find a car | After a wonderful evening in the restaurant the time to go home came. Leha as a true gentlemen suggested Noora to give her a lift. Certainly the girl agreed with pleasure. Suddenly one problem appeared: Leha cannot find his car on a huge parking near the restaurant. So he decided to turn to the watchman for help.
Formally the parking can be represented as a matrix 109 × 109. There is exactly one car in every cell of the matrix. All cars have their own machine numbers represented as a positive integer. Let's index the columns of the matrix by integers from 1 to 109 from left to right and the rows by integers from 1 to 109 from top to bottom. By coincidence it turned out, that for every cell (x, y) the number of the car, which stands in this cell, is equal to the minimum positive integer, which can't be found in the cells (i, y) and (x, j), 1 ≤ i < x, 1 ≤ j < y.
<image> The upper left fragment 5 × 5 of the parking
Leha wants to ask the watchman q requests, which can help him to find his car. Every request is represented as five integers x1, y1, x2, y2, k. The watchman have to consider all cells (x, y) of the matrix, such that x1 ≤ x ≤ x2 and y1 ≤ y ≤ y2, and if the number of the car in cell (x, y) does not exceed k, increase the answer to the request by the number of the car in cell (x, y). For each request Leha asks the watchman to tell him the resulting sum. Due to the fact that the sum can turn out to be quite large, hacker asks to calculate it modulo 109 + 7.
However the requests seem to be impracticable for the watchman. Help the watchman to answer all Leha's requests.
Input
The first line contains one integer q (1 ≤ q ≤ 104) — the number of Leha's requests.
The next q lines contain five integers x1, y1, x2, y2, k (1 ≤ x1 ≤ x2 ≤ 109, 1 ≤ y1 ≤ y2 ≤ 109, 1 ≤ k ≤ 2·109) — parameters of Leha's requests.
Output
Print exactly q lines — in the first line print the answer to the first request, in the second — the answer to the second request and so on.
Example
Input
4
1 1 1 1 1
3 2 5 4 5
1 1 5 5 10000
1 4 2 5 2
Output
1
13
93
0
Note
Let's analyze all the requests. In each case the requested submatrix is highlighted in blue.
In the first request (k = 1) Leha asks only about the upper left parking cell. In this cell the car's number is 1. Consequentally the answer is 1.
<image>
In the second request (k = 5) suitable numbers are 4, 1, 2, 3, 2, 1. Consequentally the answer is 4 + 1 + 2 + 3 + 2 + 1 = 13.
<image>
In the third request (k = 10000) Leha asks about the upper left frament 5 × 5 of the parking. Since k is big enough, the answer is equal to 93.
<image>
In the last request (k = 2) none of the cur's numbers are suitable, so the answer is 0.
<image> | 2 | 9 | #include <bits/stdc++.h>
using namespace std;
int Q;
int get(int x) { return (long long)x * (x + 1) / 2 % 1000000007; }
struct node {
int x1, y1, x2, y2, len;
node() {}
node(int x1, int y1, int x2, int y2) : x1(x1), y1(y1), x2(x2), y2(y2) {
len = x2 - x1 + 1;
}
node lu() { return node(x1, y1, x2 - len / 2, y2 - len / 2); }
node ru() { return node(x1 + len / 2, y1, x2, y2 - len / 2); }
node ld() { return node(x1, y1 + len / 2, x2 - len / 2, y2); }
node rd() { return node(x1 + len / 2, y1 + len / 2, x2, y2); }
node ins(node a) {
return node(max(x1, a.x1), max(y1, a.y1), min(x2, a.x2), min(y2, a.y2));
}
int ok() { return x1 <= x2 && y1 <= y2; }
int size() { return (long long)(x2 - x1 + 1) * (y2 - y1 + 1) % 1000000007; }
};
int solve(node a, node b, int K, int det) {
if (K <= 0) return 0;
if (!b.ok()) return 0;
int v = get(min(a.len, K)), d = min(a.len, K);
if (b.x1 == a.x1 && b.x2 == a.x2) {
int x = b.y2 - b.y1 + 1;
return ((long long)v * x % 1000000007 +
(long long)det * d % 1000000007 * x % 1000000007) %
1000000007;
}
if (b.y1 == a.y1 && b.y2 == a.y2) {
int x = b.x2 - b.x1 + 1;
return ((long long)v * x % 1000000007 +
(long long)det * d % 1000000007 * x % 1000000007) %
1000000007;
}
long long ret = 0;
node t, t1;
t = a.lu();
t1 = t.ins(b);
ret += solve(t, t1, K, det);
t = a.ru();
t1 = t.ins(b);
ret += solve(t, t1, K - a.len / 2, det + a.len / 2);
t = a.ld();
t1 = t.ins(b);
ret += solve(t, t1, K - a.len / 2, det + a.len / 2);
t = a.rd();
t1 = t.ins(b);
ret += solve(t, t1, K, det);
return ret % 1000000007;
}
int main() {
scanf("%d", &Q);
for (; Q--;) {
int x1, x2, y1, y2, K, len = 0;
scanf("%d%d%d%d%d", &x1, &y1, &x2, &y2, &K);
swap(x1, y1);
swap(x2, y2);
for (len = 1; len < x2 || len < y2; len <<= 1)
;
int ans = solve(node(1, 1, len, len), node(x1, y1, x2, y2), K, 0);
printf("%d\n", ans);
}
return 0;
}
| CPP |
809_C. Find a car | After a wonderful evening in the restaurant the time to go home came. Leha as a true gentlemen suggested Noora to give her a lift. Certainly the girl agreed with pleasure. Suddenly one problem appeared: Leha cannot find his car on a huge parking near the restaurant. So he decided to turn to the watchman for help.
Formally the parking can be represented as a matrix 109 × 109. There is exactly one car in every cell of the matrix. All cars have their own machine numbers represented as a positive integer. Let's index the columns of the matrix by integers from 1 to 109 from left to right and the rows by integers from 1 to 109 from top to bottom. By coincidence it turned out, that for every cell (x, y) the number of the car, which stands in this cell, is equal to the minimum positive integer, which can't be found in the cells (i, y) and (x, j), 1 ≤ i < x, 1 ≤ j < y.
<image> The upper left fragment 5 × 5 of the parking
Leha wants to ask the watchman q requests, which can help him to find his car. Every request is represented as five integers x1, y1, x2, y2, k. The watchman have to consider all cells (x, y) of the matrix, such that x1 ≤ x ≤ x2 and y1 ≤ y ≤ y2, and if the number of the car in cell (x, y) does not exceed k, increase the answer to the request by the number of the car in cell (x, y). For each request Leha asks the watchman to tell him the resulting sum. Due to the fact that the sum can turn out to be quite large, hacker asks to calculate it modulo 109 + 7.
However the requests seem to be impracticable for the watchman. Help the watchman to answer all Leha's requests.
Input
The first line contains one integer q (1 ≤ q ≤ 104) — the number of Leha's requests.
The next q lines contain five integers x1, y1, x2, y2, k (1 ≤ x1 ≤ x2 ≤ 109, 1 ≤ y1 ≤ y2 ≤ 109, 1 ≤ k ≤ 2·109) — parameters of Leha's requests.
Output
Print exactly q lines — in the first line print the answer to the first request, in the second — the answer to the second request and so on.
Example
Input
4
1 1 1 1 1
3 2 5 4 5
1 1 5 5 10000
1 4 2 5 2
Output
1
13
93
0
Note
Let's analyze all the requests. In each case the requested submatrix is highlighted in blue.
In the first request (k = 1) Leha asks only about the upper left parking cell. In this cell the car's number is 1. Consequentally the answer is 1.
<image>
In the second request (k = 5) suitable numbers are 4, 1, 2, 3, 2, 1. Consequentally the answer is 4 + 1 + 2 + 3 + 2 + 1 = 13.
<image>
In the third request (k = 10000) Leha asks about the upper left frament 5 × 5 of the parking. Since k is big enough, the answer is equal to 93.
<image>
In the last request (k = 2) none of the cur's numbers are suitable, so the answer is 0.
<image> | 2 | 9 | #include <bits/stdc++.h>
using namespace std;
const int MX = 2e5 + 5;
const int inf = 0x3f3f3f3f;
const long long mod = 1e9 + 7;
long long k;
long long solve(int first, int second, long long f) {
if (first == 0 || second == 0 || f > k) return 0;
if (first < second) swap(first, second);
if (first == (first & -first)) {
long long l = f, r = min(k, f + first - 1);
return (l + r) * (r - l + 1) / 2 % mod * second % mod;
}
int d = 1;
long long ret = 0;
while ((d << 1) < first) d <<= 1;
if (second <= d) {
(ret += solve(d, second, f)) %= mod;
;
(ret += solve(first - d, second, f + d)) %= mod;
;
} else {
(ret += solve(d, d, f)) %= mod;
;
(ret += solve(first - d, d, f + d)) %= mod;
;
(ret += solve(d, second - d, f + d)) %= mod;
;
(ret += solve(first - d, second - d, f)) %= mod;
;
}
return ret;
}
int main() {
int n;
scanf("%d", &n);
while (n--) {
int x1, x2, y1, y2;
scanf("%d%d%d%d%I64d", &x1, &y1, &x2, &y2, &k);
long long ans = solve(x2, y2, 1) + solve(x1 - 1, y1 - 1, 1);
ans -= solve(x1 - 1, y2, 1) + solve(x2, y1 - 1, 1);
printf("%I64d\n", (ans + 2 * mod) % mod);
}
return 0;
}
| CPP |
809_C. Find a car | After a wonderful evening in the restaurant the time to go home came. Leha as a true gentlemen suggested Noora to give her a lift. Certainly the girl agreed with pleasure. Suddenly one problem appeared: Leha cannot find his car on a huge parking near the restaurant. So he decided to turn to the watchman for help.
Formally the parking can be represented as a matrix 109 × 109. There is exactly one car in every cell of the matrix. All cars have their own machine numbers represented as a positive integer. Let's index the columns of the matrix by integers from 1 to 109 from left to right and the rows by integers from 1 to 109 from top to bottom. By coincidence it turned out, that for every cell (x, y) the number of the car, which stands in this cell, is equal to the minimum positive integer, which can't be found in the cells (i, y) and (x, j), 1 ≤ i < x, 1 ≤ j < y.
<image> The upper left fragment 5 × 5 of the parking
Leha wants to ask the watchman q requests, which can help him to find his car. Every request is represented as five integers x1, y1, x2, y2, k. The watchman have to consider all cells (x, y) of the matrix, such that x1 ≤ x ≤ x2 and y1 ≤ y ≤ y2, and if the number of the car in cell (x, y) does not exceed k, increase the answer to the request by the number of the car in cell (x, y). For each request Leha asks the watchman to tell him the resulting sum. Due to the fact that the sum can turn out to be quite large, hacker asks to calculate it modulo 109 + 7.
However the requests seem to be impracticable for the watchman. Help the watchman to answer all Leha's requests.
Input
The first line contains one integer q (1 ≤ q ≤ 104) — the number of Leha's requests.
The next q lines contain five integers x1, y1, x2, y2, k (1 ≤ x1 ≤ x2 ≤ 109, 1 ≤ y1 ≤ y2 ≤ 109, 1 ≤ k ≤ 2·109) — parameters of Leha's requests.
Output
Print exactly q lines — in the first line print the answer to the first request, in the second — the answer to the second request and so on.
Example
Input
4
1 1 1 1 1
3 2 5 4 5
1 1 5 5 10000
1 4 2 5 2
Output
1
13
93
0
Note
Let's analyze all the requests. In each case the requested submatrix is highlighted in blue.
In the first request (k = 1) Leha asks only about the upper left parking cell. In this cell the car's number is 1. Consequentally the answer is 1.
<image>
In the second request (k = 5) suitable numbers are 4, 1, 2, 3, 2, 1. Consequentally the answer is 4 + 1 + 2 + 3 + 2 + 1 = 13.
<image>
In the third request (k = 10000) Leha asks about the upper left frament 5 × 5 of the parking. Since k is big enough, the answer is equal to 93.
<image>
In the last request (k = 2) none of the cur's numbers are suitable, so the answer is 0.
<image> | 2 | 9 | #include <bits/stdc++.h>
using namespace std;
inline bool EQ(double a, double b) { return fabs(a - b) < 1e-9; }
const int INF = 1 << 29;
const long long MOD = 1000000007;
int Q;
long long X1, Y1, X2, Y2, K;
long long aquery(long long times, long long pw, long long k, long long u) {
if (times == 0 || pw == 0) {
return 0;
}
if (u > k) {
return 0;
}
long long lim = min(pw - 1, k - u);
long long res = lim * (lim + 1) / 2 + (lim + 1) * u;
res %= MOD;
res *= times;
res %= MOD;
return res;
}
long long pquery(long long x, long long y, long long k, long long u) {
if (x == 0 || y == 0) {
return 0;
}
long long maxp = 1;
while (maxp <= x || maxp <= y) maxp *= 2;
maxp /= 2;
if (x >= maxp && y >= maxp) {
long long res = pquery(x - maxp, y - maxp, k, u);
res += aquery(maxp, maxp, k, u);
if (res >= MOD) res -= MOD;
res += aquery(x - maxp, maxp, k, maxp + u);
if (res >= MOD) res -= MOD;
res += aquery(y - maxp, maxp, k, maxp + u);
if (res >= MOD) res -= MOD;
return res;
} else if (x >= maxp) {
long long res = pquery(x - maxp, y, k, maxp + u);
res += aquery(y, maxp, k, u);
if (res >= MOD) res -= MOD;
return res;
} else {
long long res = pquery(x, y - maxp, k, maxp + u);
res += aquery(x, maxp, k, u);
if (res >= MOD) res -= MOD;
return res;
}
}
long long pquery(long long x, long long y, long long k) {
return pquery(x, y, k, 1);
}
long long query(long long x1, long long y1, long long x2, long long y2,
long long k) {
long long res = pquery(x2, y2, k) - pquery(x1, y2, k) - pquery(x2, y1, k) +
pquery(x1, y1, k);
res %= MOD;
if (res < 0) res += MOD;
return res;
}
int main() {
cin >> Q;
for (int q = 0; q < (Q); ++q) {
cin >> X1 >> Y1 >> X2 >> Y2 >> K;
cout << query(X1 - 1, Y1 - 1, X2, Y2, K) << '\n';
}
return 0;
}
| CPP |
809_C. Find a car | After a wonderful evening in the restaurant the time to go home came. Leha as a true gentlemen suggested Noora to give her a lift. Certainly the girl agreed with pleasure. Suddenly one problem appeared: Leha cannot find his car on a huge parking near the restaurant. So he decided to turn to the watchman for help.
Formally the parking can be represented as a matrix 109 × 109. There is exactly one car in every cell of the matrix. All cars have their own machine numbers represented as a positive integer. Let's index the columns of the matrix by integers from 1 to 109 from left to right and the rows by integers from 1 to 109 from top to bottom. By coincidence it turned out, that for every cell (x, y) the number of the car, which stands in this cell, is equal to the minimum positive integer, which can't be found in the cells (i, y) and (x, j), 1 ≤ i < x, 1 ≤ j < y.
<image> The upper left fragment 5 × 5 of the parking
Leha wants to ask the watchman q requests, which can help him to find his car. Every request is represented as five integers x1, y1, x2, y2, k. The watchman have to consider all cells (x, y) of the matrix, such that x1 ≤ x ≤ x2 and y1 ≤ y ≤ y2, and if the number of the car in cell (x, y) does not exceed k, increase the answer to the request by the number of the car in cell (x, y). For each request Leha asks the watchman to tell him the resulting sum. Due to the fact that the sum can turn out to be quite large, hacker asks to calculate it modulo 109 + 7.
However the requests seem to be impracticable for the watchman. Help the watchman to answer all Leha's requests.
Input
The first line contains one integer q (1 ≤ q ≤ 104) — the number of Leha's requests.
The next q lines contain five integers x1, y1, x2, y2, k (1 ≤ x1 ≤ x2 ≤ 109, 1 ≤ y1 ≤ y2 ≤ 109, 1 ≤ k ≤ 2·109) — parameters of Leha's requests.
Output
Print exactly q lines — in the first line print the answer to the first request, in the second — the answer to the second request and so on.
Example
Input
4
1 1 1 1 1
3 2 5 4 5
1 1 5 5 10000
1 4 2 5 2
Output
1
13
93
0
Note
Let's analyze all the requests. In each case the requested submatrix is highlighted in blue.
In the first request (k = 1) Leha asks only about the upper left parking cell. In this cell the car's number is 1. Consequentally the answer is 1.
<image>
In the second request (k = 5) suitable numbers are 4, 1, 2, 3, 2, 1. Consequentally the answer is 4 + 1 + 2 + 3 + 2 + 1 = 13.
<image>
In the third request (k = 10000) Leha asks about the upper left frament 5 × 5 of the parking. Since k is big enough, the answer is equal to 93.
<image>
In the last request (k = 2) none of the cur's numbers are suitable, so the answer is 0.
<image> | 2 | 9 | #include <bits/stdc++.h>
using namespace std;
long long dp[32][2][2][2];
long long sum[32][2][2][2];
const int mod = (int)1e9 + 7;
long long solve(int x, int y, int k) {
memset(dp, 0, sizeof dp);
memset(sum, 0, sizeof sum);
dp[0][1][1][1] = 1;
vector<int> a, b, c;
for (int i = 0; i < 31; ++i) {
a.push_back(x % 2);
b.push_back(y % 2);
c.push_back(k % 2);
x /= 2, y /= 2, k /= 2;
}
reverse(a.begin(), a.end());
reverse(b.begin(), b.end());
reverse(c.begin(), c.end());
for (int i = 0; i < 31; ++i) {
for (int fx = 0; fx < 2; ++fx) {
for (int fy = 0; fy < 2; ++fy) {
for (int fz = 0; fz < 2; ++fz) {
for (int xx = 0; xx < 2; ++xx) {
for (int yy = 0; yy < 2; ++yy) {
int zz = xx ^ yy;
if (fx == 1 && xx > a[i]) continue;
if (fy == 1 && yy > b[i]) continue;
if (fz == 1 && zz > c[i]) continue;
dp[i + 1][fx & (xx == a[i])][fy & (yy == b[i])]
[fz & (zz == c[i])] += dp[i][fx][fy][fz];
sum[i + 1][fx & (xx == a[i])][fy & (yy == b[i])]
[fz & (zz == c[i])] += sum[i][fx][fy][fz];
if (zz == 1)
sum[i + 1][fx & (xx == a[i])][fy & (yy == b[i])]
[fz & (zz == c[i])] +=
dp[i][fx][fy][fz] * 1LL * (1 << (30 - i));
dp[i + 1][fx & (xx == a[i])][fy & (yy == b[i])]
[fz & (zz == c[i])] %= mod;
sum[i + 1][fx & (xx == a[i])][fy & (yy == b[i])]
[fz & (zz == c[i])] %= mod;
}
}
}
}
}
}
return (sum[31][0][0][0] + dp[31][0][0][0]) % mod;
}
int main() {
int t;
cin >> t;
while (t--) {
int x1, y1, x2, y2, k;
cin >> x1 >> y1 >> x2 >> y2 >> k;
--x1;
--x2;
--y1;
--y2;
--k;
long long result = 0;
result += solve(x2 + 1, y2 + 1, k + 1);
result += solve(x1, y1, k + 1);
result -= solve(x2 + 1, y1, k + 1);
result -= solve(x1, y2 + 1, k + 1);
result = (result % mod + mod) % mod;
cout << result << '\n';
}
return 0;
}
| CPP |
809_C. Find a car | After a wonderful evening in the restaurant the time to go home came. Leha as a true gentlemen suggested Noora to give her a lift. Certainly the girl agreed with pleasure. Suddenly one problem appeared: Leha cannot find his car on a huge parking near the restaurant. So he decided to turn to the watchman for help.
Formally the parking can be represented as a matrix 109 × 109. There is exactly one car in every cell of the matrix. All cars have their own machine numbers represented as a positive integer. Let's index the columns of the matrix by integers from 1 to 109 from left to right and the rows by integers from 1 to 109 from top to bottom. By coincidence it turned out, that for every cell (x, y) the number of the car, which stands in this cell, is equal to the minimum positive integer, which can't be found in the cells (i, y) and (x, j), 1 ≤ i < x, 1 ≤ j < y.
<image> The upper left fragment 5 × 5 of the parking
Leha wants to ask the watchman q requests, which can help him to find his car. Every request is represented as five integers x1, y1, x2, y2, k. The watchman have to consider all cells (x, y) of the matrix, such that x1 ≤ x ≤ x2 and y1 ≤ y ≤ y2, and if the number of the car in cell (x, y) does not exceed k, increase the answer to the request by the number of the car in cell (x, y). For each request Leha asks the watchman to tell him the resulting sum. Due to the fact that the sum can turn out to be quite large, hacker asks to calculate it modulo 109 + 7.
However the requests seem to be impracticable for the watchman. Help the watchman to answer all Leha's requests.
Input
The first line contains one integer q (1 ≤ q ≤ 104) — the number of Leha's requests.
The next q lines contain five integers x1, y1, x2, y2, k (1 ≤ x1 ≤ x2 ≤ 109, 1 ≤ y1 ≤ y2 ≤ 109, 1 ≤ k ≤ 2·109) — parameters of Leha's requests.
Output
Print exactly q lines — in the first line print the answer to the first request, in the second — the answer to the second request and so on.
Example
Input
4
1 1 1 1 1
3 2 5 4 5
1 1 5 5 10000
1 4 2 5 2
Output
1
13
93
0
Note
Let's analyze all the requests. In each case the requested submatrix is highlighted in blue.
In the first request (k = 1) Leha asks only about the upper left parking cell. In this cell the car's number is 1. Consequentally the answer is 1.
<image>
In the second request (k = 5) suitable numbers are 4, 1, 2, 3, 2, 1. Consequentally the answer is 4 + 1 + 2 + 3 + 2 + 1 = 13.
<image>
In the third request (k = 10000) Leha asks about the upper left frament 5 × 5 of the parking. Since k is big enough, the answer is equal to 93.
<image>
In the last request (k = 2) none of the cur's numbers are suitable, so the answer is 0.
<image> | 2 | 9 | #include <bits/stdc++.h>
using namespace std;
const int md = (int)1e9 + 7;
inline void add(int &a, int b) {
a += b;
if (a >= md) a -= md;
}
inline void sub(int &a, int b) {
a -= b;
if (a < 0) a += md;
}
inline int mul(int a, int b) {
return (int)((long long)a * b % md);
unsigned long long x = (long long)a * b;
unsigned xh = (unsigned)(x >> 32), xl = (unsigned)x, d, m;
asm("divl %4; \n\t" : "=a"(d), "=d"(m) : "d"(xh), "a"(xl), "r"(md));
return m;
}
inline int power(int a, long long b) {
int res = 1;
while (b > 0) {
if (b & 1) {
res = mul(res, a);
}
a = mul(a, a);
b >>= 1;
}
return res;
}
inline int inv(int a) {
a %= md;
if (a < 0) a += md;
int b = md, u = 0, v = 1;
while (a) {
int t = b / a;
b -= t * a;
swap(a, b);
u -= t * v;
swap(u, v);
}
assert(b == 1);
if (u < 0) u += md;
return u;
}
const int n = 32;
vector<int> p(n << 1);
int solve(int a, int b, int k) {
if (a == -1 || b == -1) return 0;
int res = 0;
a++;
b++;
for (int x = 0; x < n; x++) {
if (!((a >> x) & 1)) continue;
for (int y = 0; y < n; y++) {
if (!((b >> y) & 1)) continue;
int sa = a ^ (1 << x), sb = b ^ (1 << y);
int s = max(x, y);
int u = (sa ^ sb) >> s;
int cnt = x + y;
if (u > (k >> s)) continue;
if (u < (k >> s)) {
add(res, p[cnt]);
add(res, mul((u << s) % md, p[cnt]));
if (x + y) add(res, mul(p[s] - 1, p[x + y - 1]));
continue;
}
for (int z = s - 1; z > -1; z--) {
cnt--;
if (!((k >> z) & 1)) continue;
add(res, p[cnt]);
int v = ((k >> z) ^ 1) << z;
add(res, mul(v % md, p[cnt]));
if (cnt) add(res, mul(p[z] - 1, p[cnt - 1]));
}
}
}
return res;
}
int q;
int main() {
for (int i = 0; i < n << 1; i++) p[i] = power(2, i);
cin >> q;
while (q--) {
int x1, y1, x2, y2, k;
scanf("%d%d%d%d%d", &x1, &y1, &x2, &y2, &k);
x1--;
y1--;
x2--;
y2--;
int res = solve(x2, y2, k);
sub(res, solve(x1 - 1, y2, k));
sub(res, solve(x2, y1 - 1, k));
add(res, solve(x1 - 1, y1 - 1, k));
printf("%d\n", res);
}
return 0;
}
| CPP |
809_C. Find a car | After a wonderful evening in the restaurant the time to go home came. Leha as a true gentlemen suggested Noora to give her a lift. Certainly the girl agreed with pleasure. Suddenly one problem appeared: Leha cannot find his car on a huge parking near the restaurant. So he decided to turn to the watchman for help.
Formally the parking can be represented as a matrix 109 × 109. There is exactly one car in every cell of the matrix. All cars have their own machine numbers represented as a positive integer. Let's index the columns of the matrix by integers from 1 to 109 from left to right and the rows by integers from 1 to 109 from top to bottom. By coincidence it turned out, that for every cell (x, y) the number of the car, which stands in this cell, is equal to the minimum positive integer, which can't be found in the cells (i, y) and (x, j), 1 ≤ i < x, 1 ≤ j < y.
<image> The upper left fragment 5 × 5 of the parking
Leha wants to ask the watchman q requests, which can help him to find his car. Every request is represented as five integers x1, y1, x2, y2, k. The watchman have to consider all cells (x, y) of the matrix, such that x1 ≤ x ≤ x2 and y1 ≤ y ≤ y2, and if the number of the car in cell (x, y) does not exceed k, increase the answer to the request by the number of the car in cell (x, y). For each request Leha asks the watchman to tell him the resulting sum. Due to the fact that the sum can turn out to be quite large, hacker asks to calculate it modulo 109 + 7.
However the requests seem to be impracticable for the watchman. Help the watchman to answer all Leha's requests.
Input
The first line contains one integer q (1 ≤ q ≤ 104) — the number of Leha's requests.
The next q lines contain five integers x1, y1, x2, y2, k (1 ≤ x1 ≤ x2 ≤ 109, 1 ≤ y1 ≤ y2 ≤ 109, 1 ≤ k ≤ 2·109) — parameters of Leha's requests.
Output
Print exactly q lines — in the first line print the answer to the first request, in the second — the answer to the second request and so on.
Example
Input
4
1 1 1 1 1
3 2 5 4 5
1 1 5 5 10000
1 4 2 5 2
Output
1
13
93
0
Note
Let's analyze all the requests. In each case the requested submatrix is highlighted in blue.
In the first request (k = 1) Leha asks only about the upper left parking cell. In this cell the car's number is 1. Consequentally the answer is 1.
<image>
In the second request (k = 5) suitable numbers are 4, 1, 2, 3, 2, 1. Consequentally the answer is 4 + 1 + 2 + 3 + 2 + 1 = 13.
<image>
In the third request (k = 10000) Leha asks about the upper left frament 5 × 5 of the parking. Since k is big enough, the answer is equal to 93.
<image>
In the last request (k = 2) none of the cur's numbers are suitable, so the answer is 0.
<image> | 2 | 9 | #include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int N = (1 << 8);
int Q, xl, yl, xr, yr, K, dp[35][2][2][2], f[35][2][2][2];
int Query(const int& x, const int& y) {
if (x < 0 || y < 0) return 0;
int ret = 0;
f[30][1][1][1] = 1;
for (int i = 29; i >= 0; --i) {
for (int j = 0; j < 2; ++j)
for (int k = 0; k < 2; ++k)
for (int l = 0; l < 2; ++l) dp[i][j][k][l] = f[i][j][k][l] = 0;
for (int j = 0; j < 2; ++j)
for (int k = 0; k < 2; ++k)
for (int l = 0; l < 2; ++l)
if (f[i + 1][j][k][l]) {
(dp[i][j & (!((x >> i) & 1))][k & (!((y >> i) & 1))]
[l & (!((K >> i) & 1))] =
(dp[i][j & (!((x >> i) & 1))][k & (!((y >> i) & 1))]
[l & (!((K >> i) & 1))] +
dp[i + 1][j][k][l]) %
mod),
(f[i][j & (!((x >> i) & 1))][k & (!((y >> i) & 1))]
[l & (!((K >> i) & 1))] =
(f[i][j & (!((x >> i) & 1))][k & (!((y >> i) & 1))]
[l & (!((K >> i) & 1))] +
f[i + 1][j][k][l]) %
mod);
if ((!k || ((y >> i) & 1)) && (!l || ((K >> i) & 1)))
(dp[i][j & (!((x >> i) & 1))][k][l] =
(dp[i][j & (!((x >> i) & 1))][k][l] + dp[i + 1][j][k][l] +
1ll * (1 << i) * f[i + 1][j][k][l]) %
mod),
(f[i][j & (!((x >> i) & 1))][k][l] =
(f[i][j & (!((x >> i) & 1))][k][l] + f[i + 1][j][k][l]) %
mod);
if ((!j || ((x >> i) & 1)) && (!l || ((K >> i) & 1)))
(dp[i][j][k & (!((y >> i) & 1))][l] =
(dp[i][j][k & (!((y >> i) & 1))][l] + dp[i + 1][j][k][l] +
1ll * (1 << i) * f[i + 1][j][k][l]) %
mod),
(f[i][j][k & (!((y >> i) & 1))][l] =
(f[i][j][k & (!((y >> i) & 1))][l] + f[i + 1][j][k][l]) %
mod);
if ((!j || ((x >> i) & 1)) && (!k || ((y >> i) & 1)))
(dp[i][j][k][l & (!((K >> i) & 1))] =
(dp[i][j][k][l & (!((K >> i) & 1))] + dp[i + 1][j][k][l]) %
mod),
(f[i][j][k][l & (!((K >> i) & 1))] =
(f[i][j][k][l & (!((K >> i) & 1))] + f[i + 1][j][k][l]) %
mod);
}
}
for (int i = 0; i < 2; ++i)
for (int j = 0; j < 2; ++j)
for (int k = 0; k < 2; ++k)
(ret = (ret + 1ll * dp[0][i][j][k] + f[0][i][j][k]) % mod);
return ret;
}
int main() {
scanf("%d", &Q);
while (Q--) {
scanf("%d%d%d%d%d", &xl, &yl, &xr, &yr, &K), --xl, --yl, --xr, --yr, --K,
K >= (1 << 30) ? K = (1 << 30) - 1 : 0;
printf("%lld\n", (1ll * Query(xr, yr) - Query(xr, yl - 1) -
Query(xl - 1, yr) + Query(xl - 1, yl - 1) + mod + mod) %
mod);
}
return 0;
}
| CPP |
809_C. Find a car | After a wonderful evening in the restaurant the time to go home came. Leha as a true gentlemen suggested Noora to give her a lift. Certainly the girl agreed with pleasure. Suddenly one problem appeared: Leha cannot find his car on a huge parking near the restaurant. So he decided to turn to the watchman for help.
Formally the parking can be represented as a matrix 109 × 109. There is exactly one car in every cell of the matrix. All cars have their own machine numbers represented as a positive integer. Let's index the columns of the matrix by integers from 1 to 109 from left to right and the rows by integers from 1 to 109 from top to bottom. By coincidence it turned out, that for every cell (x, y) the number of the car, which stands in this cell, is equal to the minimum positive integer, which can't be found in the cells (i, y) and (x, j), 1 ≤ i < x, 1 ≤ j < y.
<image> The upper left fragment 5 × 5 of the parking
Leha wants to ask the watchman q requests, which can help him to find his car. Every request is represented as five integers x1, y1, x2, y2, k. The watchman have to consider all cells (x, y) of the matrix, such that x1 ≤ x ≤ x2 and y1 ≤ y ≤ y2, and if the number of the car in cell (x, y) does not exceed k, increase the answer to the request by the number of the car in cell (x, y). For each request Leha asks the watchman to tell him the resulting sum. Due to the fact that the sum can turn out to be quite large, hacker asks to calculate it modulo 109 + 7.
However the requests seem to be impracticable for the watchman. Help the watchman to answer all Leha's requests.
Input
The first line contains one integer q (1 ≤ q ≤ 104) — the number of Leha's requests.
The next q lines contain five integers x1, y1, x2, y2, k (1 ≤ x1 ≤ x2 ≤ 109, 1 ≤ y1 ≤ y2 ≤ 109, 1 ≤ k ≤ 2·109) — parameters of Leha's requests.
Output
Print exactly q lines — in the first line print the answer to the first request, in the second — the answer to the second request and so on.
Example
Input
4
1 1 1 1 1
3 2 5 4 5
1 1 5 5 10000
1 4 2 5 2
Output
1
13
93
0
Note
Let's analyze all the requests. In each case the requested submatrix is highlighted in blue.
In the first request (k = 1) Leha asks only about the upper left parking cell. In this cell the car's number is 1. Consequentally the answer is 1.
<image>
In the second request (k = 5) suitable numbers are 4, 1, 2, 3, 2, 1. Consequentally the answer is 4 + 1 + 2 + 3 + 2 + 1 = 13.
<image>
In the third request (k = 10000) Leha asks about the upper left frament 5 × 5 of the parking. Since k is big enough, the answer is equal to 93.
<image>
In the last request (k = 2) none of the cur's numbers are suitable, so the answer is 0.
<image> | 2 | 9 | #include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
long long int sum[40][2][2][2], cnt[40][2][2][2], two[45];
int n, m, k;
void sets(int ind) {
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2; j++) {
for (int k = 0; k < 2; k++) sum[ind][i][j][k] = 0;
}
}
}
void setc(int ind) {
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2; j++) {
for (int k = 0; k < 2; k++) cnt[ind][i][j][k] = 0;
}
}
}
vector<int> vn, vm, vk;
int get(int p, int q) {
if (p == 0) {
if (q == -1) return 1;
if (q == 0) return 0;
}
return 1;
}
long long int rescnt, ressum;
void comp() {
setc(35);
sets(35);
cnt[35][0][0][0] = 1;
vn.clear();
vm.clear();
vk.clear();
for (int i = 0; i < 35; i++) {
vn.push_back(n % 2);
vm.push_back(m % 2);
vk.push_back(k % 2);
n /= 2;
m /= 2;
k /= 2;
}
for (int i = 34; i >= 0; i--) {
setc(i);
sets(i);
int pn = vn[i], pm = vm[i], pk = vk[i];
for (int p = 0; p < 2; p++) {
for (int q = 0; q < 2; q++) {
int r;
if (p == q)
r = 0;
else
r = 1;
int f, s, t;
if (p < pn)
f = -1;
else if (p == pn)
f = 0;
else
f = 1;
if (q < pm)
s = -1;
else if (q == pm)
s = 0;
else
s = 1;
if (r < pk)
t = -1;
else if (r == pk)
t = 0;
else
t = 1;
for (int m = 0; m < 2; m++) {
for (int n = 0; n < 2; n++) {
for (int h = 0; h < 2; h++) {
if ((f == 1 and m == 0) or (s == 1 and n == 0) or
(t == 1 and h == 0))
continue;
cnt[i][get(m, f)][get(n, s)][get(h, t)] += cnt[i + 1][m][n][h];
sum[i][get(m, f)][get(n, s)][get(h, t)] += sum[i + 1][m][n][h];
if (r == 1)
sum[i][get(m, f)][get(n, s)][get(h, t)] +=
cnt[i + 1][m][n][h] * two[i];
}
}
}
}
}
for (int m = 0; m < 2; m++) {
for (int n = 0; n < 2; n++) {
for (int h = 0; h < 2; h++) {
cnt[i][m][n][h] %= mod;
sum[i][m][n][h] %= mod;
}
}
}
}
rescnt = 0;
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2; j++) {
for (int k = 0; k < 2; k++) {
rescnt += cnt[0][i][j][k];
}
}
}
rescnt %= mod;
ressum = 0;
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2; j++) {
for (int k = 0; k < 2; k++) {
ressum += sum[0][i][j][k];
}
}
}
ressum %= mod;
}
long long int ask(int x, int y, int kk) {
if (x < 0 or y < 0) return 0;
n = x;
m = y;
k = kk;
comp();
int res = 0;
return (rescnt + ressum) % mod;
}
long long int query(int x1, int y1, int x2, int y2, int kk) {
x1--;
y1--;
x2--;
y2--;
kk--;
return ((ask(x2, y2, kk) + ask(x1 - 1, y1 - 1, kk) - ask(x1 - 1, y2, kk) -
ask(x2, y1 - 1, kk)) %
mod +
mod) %
mod;
}
int main() {
two[0] = 1;
for (int i = 1; i < 40; i++) two[i] = 2LL * two[i - 1] % mod;
int q;
cin >> q;
while (q--) {
int x1, y1, x2, y2, kk;
cin >> x1 >> y1 >> x2 >> y2 >> kk;
cout << query(x1, y1, x2, y2, kk) << endl;
}
}
| CPP |
809_C. Find a car | After a wonderful evening in the restaurant the time to go home came. Leha as a true gentlemen suggested Noora to give her a lift. Certainly the girl agreed with pleasure. Suddenly one problem appeared: Leha cannot find his car on a huge parking near the restaurant. So he decided to turn to the watchman for help.
Formally the parking can be represented as a matrix 109 × 109. There is exactly one car in every cell of the matrix. All cars have their own machine numbers represented as a positive integer. Let's index the columns of the matrix by integers from 1 to 109 from left to right and the rows by integers from 1 to 109 from top to bottom. By coincidence it turned out, that for every cell (x, y) the number of the car, which stands in this cell, is equal to the minimum positive integer, which can't be found in the cells (i, y) and (x, j), 1 ≤ i < x, 1 ≤ j < y.
<image> The upper left fragment 5 × 5 of the parking
Leha wants to ask the watchman q requests, which can help him to find his car. Every request is represented as five integers x1, y1, x2, y2, k. The watchman have to consider all cells (x, y) of the matrix, such that x1 ≤ x ≤ x2 and y1 ≤ y ≤ y2, and if the number of the car in cell (x, y) does not exceed k, increase the answer to the request by the number of the car in cell (x, y). For each request Leha asks the watchman to tell him the resulting sum. Due to the fact that the sum can turn out to be quite large, hacker asks to calculate it modulo 109 + 7.
However the requests seem to be impracticable for the watchman. Help the watchman to answer all Leha's requests.
Input
The first line contains one integer q (1 ≤ q ≤ 104) — the number of Leha's requests.
The next q lines contain five integers x1, y1, x2, y2, k (1 ≤ x1 ≤ x2 ≤ 109, 1 ≤ y1 ≤ y2 ≤ 109, 1 ≤ k ≤ 2·109) — parameters of Leha's requests.
Output
Print exactly q lines — in the first line print the answer to the first request, in the second — the answer to the second request and so on.
Example
Input
4
1 1 1 1 1
3 2 5 4 5
1 1 5 5 10000
1 4 2 5 2
Output
1
13
93
0
Note
Let's analyze all the requests. In each case the requested submatrix is highlighted in blue.
In the first request (k = 1) Leha asks only about the upper left parking cell. In this cell the car's number is 1. Consequentally the answer is 1.
<image>
In the second request (k = 5) suitable numbers are 4, 1, 2, 3, 2, 1. Consequentally the answer is 4 + 1 + 2 + 3 + 2 + 1 = 13.
<image>
In the third request (k = 10000) Leha asks about the upper left frament 5 × 5 of the parking. Since k is big enough, the answer is equal to 93.
<image>
In the last request (k = 2) none of the cur's numbers are suitable, so the answer is 0.
<image> | 2 | 9 | #include <bits/stdc++.h>
using namespace std;
void chkmax(int &a, int b) {
if (a < b) a = b;
}
void chkmin(int &a, int b) {
if (a > b) a = b;
}
const int mo = 1e9 + 7;
int q;
int max(int a, int b, int c) { return max(max(a, b), c); }
void add(int &a, int b) { (a += b) %= mo; }
int X[33], p1;
int Y[33], p2;
int K[33], p3;
struct node {
int cnt, val;
node() { cnt = val = 0; }
node(int cnt, int val) : cnt(cnt), val(val) {}
};
node f[33][2][2][2];
int solve(int x, int y) {
if (!x || !y) return 0;
x--, y--;
p1 = p2 = 0;
memset(X, 0, sizeof(X));
memset(Y, 0, sizeof(Y));
while (x) X[++p1] = x % 2, x /= 2;
while (y) Y[++p2] = y % 2, y /= 2;
int t = max(p1, p2, p3);
for (int j = (0); j < (2); j++)
for (int k = (0); k < (2); k++)
for (int t = (0); t < (2); t++) f[0][j][k][t] = node(1, 0);
for (int p = (1); p < (t + 1); p++)
for (int l1 = (0); l1 < (2); l1++)
for (int l2 = (0); l2 < (2); l2++)
for (int l3 = (0); l3 < (2); l3++) {
int up1 = l1 ? X[p] : 1, up2 = l2 ? Y[p] : 1, up3 = l3 ? K[p] : 1;
node res;
for (int i = (0); i < (up1 + 1); i++)
for (int j = (0); j < (up2 + 1); j++) {
if ((i ^ j) > up3) continue;
node e = f[p - 1][l1 && i == up1][l2 && j == up2]
[l3 && (i ^ j) == up3];
add(res.cnt, e.cnt);
add(res.val, e.val);
if (i ^ j) add(res.val, 1ll * (1 << (p - 1)) * e.cnt % mo);
}
f[p][l1][l2][l3] = res;
};
node ans = f[t][1][1][1];
return (ans.cnt + ans.val) % mo;
}
int main() {
cin >> q;
while (q--) {
int x1, y1, x2, y2, k;
cin >> x1 >> y1 >> x2 >> y2 >> k;
memset(K, 0, sizeof(K));
p3 = 0, k--;
while (k) K[++p3] = k % 2, k /= 2;
int tmp = 0;
add(tmp, +solve(x2, y2));
add(tmp, -solve(x2, y1 - 1));
add(tmp, -solve(x1 - 1, y2));
add(tmp, +solve(x1 - 1, y1 - 1));
printf("%d\n", (tmp + mo) % mo);
}
return 0;
}
| CPP |
809_C. Find a car | After a wonderful evening in the restaurant the time to go home came. Leha as a true gentlemen suggested Noora to give her a lift. Certainly the girl agreed with pleasure. Suddenly one problem appeared: Leha cannot find his car on a huge parking near the restaurant. So he decided to turn to the watchman for help.
Formally the parking can be represented as a matrix 109 × 109. There is exactly one car in every cell of the matrix. All cars have their own machine numbers represented as a positive integer. Let's index the columns of the matrix by integers from 1 to 109 from left to right and the rows by integers from 1 to 109 from top to bottom. By coincidence it turned out, that for every cell (x, y) the number of the car, which stands in this cell, is equal to the minimum positive integer, which can't be found in the cells (i, y) and (x, j), 1 ≤ i < x, 1 ≤ j < y.
<image> The upper left fragment 5 × 5 of the parking
Leha wants to ask the watchman q requests, which can help him to find his car. Every request is represented as five integers x1, y1, x2, y2, k. The watchman have to consider all cells (x, y) of the matrix, such that x1 ≤ x ≤ x2 and y1 ≤ y ≤ y2, and if the number of the car in cell (x, y) does not exceed k, increase the answer to the request by the number of the car in cell (x, y). For each request Leha asks the watchman to tell him the resulting sum. Due to the fact that the sum can turn out to be quite large, hacker asks to calculate it modulo 109 + 7.
However the requests seem to be impracticable for the watchman. Help the watchman to answer all Leha's requests.
Input
The first line contains one integer q (1 ≤ q ≤ 104) — the number of Leha's requests.
The next q lines contain five integers x1, y1, x2, y2, k (1 ≤ x1 ≤ x2 ≤ 109, 1 ≤ y1 ≤ y2 ≤ 109, 1 ≤ k ≤ 2·109) — parameters of Leha's requests.
Output
Print exactly q lines — in the first line print the answer to the first request, in the second — the answer to the second request and so on.
Example
Input
4
1 1 1 1 1
3 2 5 4 5
1 1 5 5 10000
1 4 2 5 2
Output
1
13
93
0
Note
Let's analyze all the requests. In each case the requested submatrix is highlighted in blue.
In the first request (k = 1) Leha asks only about the upper left parking cell. In this cell the car's number is 1. Consequentally the answer is 1.
<image>
In the second request (k = 5) suitable numbers are 4, 1, 2, 3, 2, 1. Consequentally the answer is 4 + 1 + 2 + 3 + 2 + 1 = 13.
<image>
In the third request (k = 10000) Leha asks about the upper left frament 5 × 5 of the parking. Since k is big enough, the answer is equal to 93.
<image>
In the last request (k = 2) none of the cur's numbers are suitable, so the answer is 0.
<image> | 2 | 9 | import java.util.*;
import java.io.*;
public class Main {
public static void main(String [] args) {
Reader in = new Reader ();
Writer out = new Writer ();
Query solver = new Query();
int t = in.nextInt();
for(int cs = 1; cs <= t; cs++) {
int p, q, x, y, k;
p = in.nextInt();
q = in.nextInt();
x = in.nextInt();
y = in.nextInt();
k = in.nextInt();
out.writeln(solver.ask(p, q, x, y, k));
}
out.flush();
}
static class Query {
int [][][][] cnt = new int [32][2][2][2];
int [][][][] dp = new int [32][2][2][2];
final int bit = 32;
final int mod = 1000000000 + 7;
int k, x, y;
int getBit(int y, int x) {
return (y >> x) & 1;
}
int count(int cur, int smX, int smY, int smK) {
if(cur < 0) {
return 1;
}
if(cnt[cur][smX][smY][smK] != -1) return cnt[cur][smX][smY][smK];
int ans = 0;
for(int i = 0; i < 2; i++) {
for(int j = 0; j < 2; j++) {
int pi = i ^ j;
if(smX == 0 && i > getBit(x, cur)) continue;
if(smY == 0 && j > getBit(y, cur)) continue;
if(smK == 0 && pi > getBit(k, cur)) continue;
int smx = smX;
int smy = smY;
int smk = smK;
if(smx == 0 && i < getBit(x, cur)) smx = 1;
if(smy == 0 && j < getBit(y, cur)) smy = 1;
if(smk == 0 && pi < getBit(k, cur)) smk = 1;
ans += count(cur - 1, smx, smy, smk);
ans %= mod;
}
}
return cnt[cur][smX][smY][smK] = ans;
}
int dynamic(int cur, int smX, int smY, int smK) {
if(cur < 0) {
return 0;
}
if(dp[cur][smX][smY][smK] != -1) return dp[cur][smX][smY][smK];
long ans = 0;
for(int i = 0; i < 2; i++) {
for(int j = 0; j < 2; j++) {
int pi = i ^ j;
if(smX == 0 && i > getBit(x, cur)) continue;
if(smY == 0 && j > getBit(y, cur)) continue;
if(smK == 0 && pi > getBit(k, cur)) continue;
int smx = smX;
int smy = smY;
int smk = smK;
if(smx == 0 && i < getBit(x, cur)) smx = 1;
if(smy == 0 && j < getBit(y, cur)) smy = 1;
if(smk == 0 && pi < getBit(k, cur)) smk = 1;
if(pi == 1) ans += 1L * (1 << cur) * count(cur - 1, smx, smy, smk);
ans += dynamic(cur - 1, smx, smy, smk);
ans %= mod;
}
}
return dp[cur][smX][smY][smK] = (int) ans;
}
void init() {
for(int i = 0; i < bit; i++) {
for(int j = 0; j < 2; j++) {
for(int p = 0; p < 2; p++) {
for(int l = 0; l < 2; l++) {
cnt[i][j][p][l] = -1;
dp[i][j][p][l] = -1;
}
}
}
}
}
int brute(int x, int y, int k) {
int ans = 0;
for(int i = 0; i < x; i++) {
for(int j = 0; j < y; j++) {
if((i ^ j) <= k-1) ans += 1;
}
}
return ans;
}
int ask(int x, int y, int k) {
if(x == 0 || y == 0) return 0;
this.x = x - 1;
this.y = y - 1;
this.k = k - 1;
init();
return (dynamic(bit - 1, 0, 0, 0) + count(bit - 1, 0, 0, 0)) % mod;
}
int ask(int p, int q, int x, int y, int k) {
long ans = 0;
ans += ask(x, y, k);
ans -= ask(x, q-1, k);
ans -= ask(p-1, y, k);
ans += ask(p-1, q-1, k);
ans %= mod;
if(ans < 0) ans += mod;
return (int) ans;
}
}
static class Reader {
private StringTokenizer a;
private BufferedReader b;
Reader () {
a = null;
b = new BufferedReader (new InputStreamReader (System.in));
}
public String next () {
while(a == null || !a.hasMoreTokens()) {
try {
a = new StringTokenizer (b.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return a.nextToken();
}
public int nextInt() {
return Integer.parseInt(this.next());
}
public long nextLong () {
return Long.parseLong(this.next());
}
public double nextDouble () {
return Double.parseDouble(this.next());
}
public String nextLine() {
try {
return b.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return "";
}
}
static class Writer {
private PrintWriter a;
private StringBuffer b;
Writer () {
a = new PrintWriter (System.out);
b = new StringBuffer ("");
}
public void write (Object s) {
b.append(s);
}
public void writeln(Object s) {
b.append(s).append('\n');
}
public void flush () {
a.print(b);
a.flush();
a.close();
}
}
static class Pair implements Comparator <Pair> {
int first;
int second;
Pair (int a, int b) {
this.first = a;
this.second = b;
}
Pair (Pair a) {
this.first = a.first;
this.second = a.second;
}
Pair () {}
public String toString () {
return "[" + first + ", " + second + "]";
}
public int compare (Pair a, Pair b) {
if(a.first == b.first) {
return a.second - b.second;
} else {
return a.first - b.first;
}
}
}
}
| JAVA |
809_C. Find a car | After a wonderful evening in the restaurant the time to go home came. Leha as a true gentlemen suggested Noora to give her a lift. Certainly the girl agreed with pleasure. Suddenly one problem appeared: Leha cannot find his car on a huge parking near the restaurant. So he decided to turn to the watchman for help.
Formally the parking can be represented as a matrix 109 × 109. There is exactly one car in every cell of the matrix. All cars have their own machine numbers represented as a positive integer. Let's index the columns of the matrix by integers from 1 to 109 from left to right and the rows by integers from 1 to 109 from top to bottom. By coincidence it turned out, that for every cell (x, y) the number of the car, which stands in this cell, is equal to the minimum positive integer, which can't be found in the cells (i, y) and (x, j), 1 ≤ i < x, 1 ≤ j < y.
<image> The upper left fragment 5 × 5 of the parking
Leha wants to ask the watchman q requests, which can help him to find his car. Every request is represented as five integers x1, y1, x2, y2, k. The watchman have to consider all cells (x, y) of the matrix, such that x1 ≤ x ≤ x2 and y1 ≤ y ≤ y2, and if the number of the car in cell (x, y) does not exceed k, increase the answer to the request by the number of the car in cell (x, y). For each request Leha asks the watchman to tell him the resulting sum. Due to the fact that the sum can turn out to be quite large, hacker asks to calculate it modulo 109 + 7.
However the requests seem to be impracticable for the watchman. Help the watchman to answer all Leha's requests.
Input
The first line contains one integer q (1 ≤ q ≤ 104) — the number of Leha's requests.
The next q lines contain five integers x1, y1, x2, y2, k (1 ≤ x1 ≤ x2 ≤ 109, 1 ≤ y1 ≤ y2 ≤ 109, 1 ≤ k ≤ 2·109) — parameters of Leha's requests.
Output
Print exactly q lines — in the first line print the answer to the first request, in the second — the answer to the second request and so on.
Example
Input
4
1 1 1 1 1
3 2 5 4 5
1 1 5 5 10000
1 4 2 5 2
Output
1
13
93
0
Note
Let's analyze all the requests. In each case the requested submatrix is highlighted in blue.
In the first request (k = 1) Leha asks only about the upper left parking cell. In this cell the car's number is 1. Consequentally the answer is 1.
<image>
In the second request (k = 5) suitable numbers are 4, 1, 2, 3, 2, 1. Consequentally the answer is 4 + 1 + 2 + 3 + 2 + 1 = 13.
<image>
In the third request (k = 10000) Leha asks about the upper left frament 5 × 5 of the parking. Since k is big enough, the answer is equal to 93.
<image>
In the last request (k = 2) none of the cur's numbers are suitable, so the answer is 0.
<image> | 2 | 9 | #include <bits/stdc++.h>
using namespace std;
long long mod = 1000000007;
pair<long long, long long> s(int x, int y, long long k) {
if (y > x) return s(y, x, k);
if (y == 0) return make_pair(0ll, 0ll);
if (k <= 0) return make_pair(0ll, 0ll);
long long t;
for (t = 30; t >= 0; t--)
if ((1 << t) <= x) break;
t = (1 << t);
if (y <= t) {
pair<long long, long long> pr = s(x - t, y, k - t);
pr.second += pr.first * t;
pr.second %= mod;
pr.first += min(t, k) * (long long)y;
pr.first %= mod;
pr.second += (((min(t, k) + 1ll) * min(t, k) / 2ll) % mod) * (long long)y;
pr.second %= mod;
return pr;
} else {
pair<long long, long long> pr1 = s(x - t, t, k - t),
pr2 = s(y - t, t, k - t),
pr = s(x - t, y - t, k);
pr1.second += pr1.first * t;
pr1.second %= mod;
pr2.second += pr2.first * t;
pr2.second %= mod;
pr.first += min(t, k) * t;
pr.first %= mod;
pr.second += (((min(t, k) + 1ll) * min(t, k) / 2ll) % mod) * t;
pr.second %= mod;
pr.first += pr1.first + pr2.first;
pr.second += pr1.second + pr2.second;
pr.first %= mod;
pr.second %= mod;
return pr;
}
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int t;
cin >> t;
while (t--) {
int a, b, c, d;
long long k;
cin >> a >> b >> c >> d >> k;
a--, b--;
long long ans = s(c, d, k).second - s(a, d, k).second - s(b, c, k).second +
s(a, b, k).second;
ans %= mod;
ans += mod;
ans %= mod;
cout << ans << endl;
}
}
| CPP |
809_C. Find a car | After a wonderful evening in the restaurant the time to go home came. Leha as a true gentlemen suggested Noora to give her a lift. Certainly the girl agreed with pleasure. Suddenly one problem appeared: Leha cannot find his car on a huge parking near the restaurant. So he decided to turn to the watchman for help.
Formally the parking can be represented as a matrix 109 × 109. There is exactly one car in every cell of the matrix. All cars have their own machine numbers represented as a positive integer. Let's index the columns of the matrix by integers from 1 to 109 from left to right and the rows by integers from 1 to 109 from top to bottom. By coincidence it turned out, that for every cell (x, y) the number of the car, which stands in this cell, is equal to the minimum positive integer, which can't be found in the cells (i, y) and (x, j), 1 ≤ i < x, 1 ≤ j < y.
<image> The upper left fragment 5 × 5 of the parking
Leha wants to ask the watchman q requests, which can help him to find his car. Every request is represented as five integers x1, y1, x2, y2, k. The watchman have to consider all cells (x, y) of the matrix, such that x1 ≤ x ≤ x2 and y1 ≤ y ≤ y2, and if the number of the car in cell (x, y) does not exceed k, increase the answer to the request by the number of the car in cell (x, y). For each request Leha asks the watchman to tell him the resulting sum. Due to the fact that the sum can turn out to be quite large, hacker asks to calculate it modulo 109 + 7.
However the requests seem to be impracticable for the watchman. Help the watchman to answer all Leha's requests.
Input
The first line contains one integer q (1 ≤ q ≤ 104) — the number of Leha's requests.
The next q lines contain five integers x1, y1, x2, y2, k (1 ≤ x1 ≤ x2 ≤ 109, 1 ≤ y1 ≤ y2 ≤ 109, 1 ≤ k ≤ 2·109) — parameters of Leha's requests.
Output
Print exactly q lines — in the first line print the answer to the first request, in the second — the answer to the second request and so on.
Example
Input
4
1 1 1 1 1
3 2 5 4 5
1 1 5 5 10000
1 4 2 5 2
Output
1
13
93
0
Note
Let's analyze all the requests. In each case the requested submatrix is highlighted in blue.
In the first request (k = 1) Leha asks only about the upper left parking cell. In this cell the car's number is 1. Consequentally the answer is 1.
<image>
In the second request (k = 5) suitable numbers are 4, 1, 2, 3, 2, 1. Consequentally the answer is 4 + 1 + 2 + 3 + 2 + 1 = 13.
<image>
In the third request (k = 10000) Leha asks about the upper left frament 5 × 5 of the parking. Since k is big enough, the answer is equal to 93.
<image>
In the last request (k = 2) none of the cur's numbers are suitable, so the answer is 0.
<image> | 2 | 9 | #include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 7;
const int MAXN = 1e3 + 7;
const int MOD = 1e9 + 7;
int n;
int dp[34][2][2][2];
int sum[34][2][2][2];
int x, y, k;
int dfs(int pos, int limx, int limy, int limk, int &t) {
if (pos == -1) return 1;
int &st = sum[pos][limx][limy][limk];
if (~dp[pos][limx][limy][limk]) {
(t += st) %= MOD;
return dp[pos][limx][limy][limk];
}
st = 0;
int zx = 1, zy = 1;
if (limx) zx = x >> pos & 1;
if (limy) zy = y >> pos & 1;
int res = 0, posk = k >> pos & 1;
long long ta;
for (int i = 0; i <= zx; i++)
for (int j = 0; j <= zy; j++) {
long long tb = ((i ^ j) << pos) % MOD;
if (limk) {
if ((i ^ j) <= posk) {
ta = dfs(pos - 1, limx && zx == i, limy && zy == j, (i ^ j) == posk,
st);
res = (res + ta) % MOD;
st = (ta * tb % MOD + st) % MOD;
}
} else {
ta = dfs(pos - 1, limx && zx == i, limy && zy == j, 0, st);
res = (res + ta) % MOD;
st = (ta * tb % MOD + st) % MOD;
}
}
(t += st) %= MOD;
dp[pos][limx][limy][limk] = res;
return res;
}
int check(int a, int b) {
int res = 0, tot = 0;
for (int i = 0; i <= a; i++)
for (int j = 0; j <= b; j++)
if ((i ^ j) <= k) {
res += (i ^ j) + 1;
tot++;
}
cerr << "["
<< "tot"
":"
<< (tot) << "]";
;
return res;
}
int solve(int a, int b) {
if (a < 0 || b < 0) return 0;
memset(dp, -1, sizeof(dp));
int ans = 0;
x = a, y = b;
long long tmp = dfs(30, 1, 1, 1, ans);
tmp = (tmp + ans) % MOD;
return tmp;
}
int main() {
int q, x1, y1, x2, y2;
scanf("%d", &q);
while (q--) {
scanf("%d%d%d%d%d", &x1, &y1, &x2, &y2, &k);
x1--, y1--, x2--, y2--, k--;
long long ans = solve(x2, y2) - solve(x1 - 1, y2) - solve(x2, y1 - 1) +
solve(x1 - 1, y1 - 1);
ans = ans % MOD;
if (ans < 0) ans += MOD;
printf("%d\n", ans);
}
return 0;
}
| CPP |
834_A. The Useless Toy | <image>
Walking through the streets of Marshmallow City, Slastyona have spotted some merchants selling a kind of useless toy which is very popular nowadays – caramel spinner! Wanting to join the craze, she has immediately bought the strange contraption.
Spinners in Sweetland have the form of V-shaped pieces of caramel. Each spinner can, well, spin around an invisible magic axis. At a specific point in time, a spinner can take 4 positions shown below (each one rotated 90 degrees relative to the previous, with the fourth one followed by the first one):
<image>
After the spinner was spun, it starts its rotation, which is described by a following algorithm: the spinner maintains its position for a second then majestically switches to the next position in clockwise or counter-clockwise order, depending on the direction the spinner was spun in.
Slastyona managed to have spinner rotating for exactly n seconds. Being fascinated by elegance of the process, she completely forgot the direction the spinner was spun in! Lucky for her, she managed to recall the starting position, and wants to deduct the direction given the information she knows. Help her do this.
Input
There are two characters in the first string – the starting and the ending position of a spinner. The position is encoded with one of the following characters: v (ASCII code 118, lowercase v), < (ASCII code 60), ^ (ASCII code 94) or > (ASCII code 62) (see the picture above for reference). Characters are separated by a single space.
In the second strings, a single number n is given (0 ≤ n ≤ 109) – the duration of the rotation.
It is guaranteed that the ending position of a spinner is a result of a n second spin in any of the directions, assuming the given starting position.
Output
Output cw, if the direction is clockwise, ccw – if counter-clockwise, and undefined otherwise.
Examples
Input
^ >
1
Output
cw
Input
< ^
3
Output
ccw
Input
^ v
6
Output
undefined | 2 | 7 | #include <bits/stdc++.h>
using namespace std;
int func(int A[], char ch) {
switch (ch) {
case 'v': {
A[0] = 1;
return 0;
break;
}
case '<': {
A[1] = 1;
return 1;
break;
}
case '^': {
A[2] = 1;
return 2;
break;
}
case '>': {
A[3] = 1;
return 3;
}
}
}
int main() {
char c1, c2;
long long n;
cin >> c1 >> c2 >> n;
int A[4];
for (int i = 0; i < 4; i++) {
A[i] = 0;
}
int i1 = func(A, c1);
int i2 = func(A, c2);
int z = n % 4;
if (z == 2 || z == 0) {
cout << "undefined";
} else {
if (i2 > i1) {
if ((i2 - i1) % 4 == z) {
cout << "cw";
} else {
cout << "ccw";
}
} else {
if ((i2 - i1 + 4) % 4 == z) {
cout << "cw";
} else {
cout << "ccw";
}
}
}
return 0;
}
| CPP |
834_A. The Useless Toy | <image>
Walking through the streets of Marshmallow City, Slastyona have spotted some merchants selling a kind of useless toy which is very popular nowadays – caramel spinner! Wanting to join the craze, she has immediately bought the strange contraption.
Spinners in Sweetland have the form of V-shaped pieces of caramel. Each spinner can, well, spin around an invisible magic axis. At a specific point in time, a spinner can take 4 positions shown below (each one rotated 90 degrees relative to the previous, with the fourth one followed by the first one):
<image>
After the spinner was spun, it starts its rotation, which is described by a following algorithm: the spinner maintains its position for a second then majestically switches to the next position in clockwise or counter-clockwise order, depending on the direction the spinner was spun in.
Slastyona managed to have spinner rotating for exactly n seconds. Being fascinated by elegance of the process, she completely forgot the direction the spinner was spun in! Lucky for her, she managed to recall the starting position, and wants to deduct the direction given the information she knows. Help her do this.
Input
There are two characters in the first string – the starting and the ending position of a spinner. The position is encoded with one of the following characters: v (ASCII code 118, lowercase v), < (ASCII code 60), ^ (ASCII code 94) or > (ASCII code 62) (see the picture above for reference). Characters are separated by a single space.
In the second strings, a single number n is given (0 ≤ n ≤ 109) – the duration of the rotation.
It is guaranteed that the ending position of a spinner is a result of a n second spin in any of the directions, assuming the given starting position.
Output
Output cw, if the direction is clockwise, ccw – if counter-clockwise, and undefined otherwise.
Examples
Input
^ >
1
Output
cw
Input
< ^
3
Output
ccw
Input
^ v
6
Output
undefined | 2 | 7 |
a, b = input().split()
t = int(input())
d = dict()
d["^"] = 0
d[">"] = 1
d["v"] = 2
d["<"] = 3
a, b = d[a], d[b]
t = t % 4
if t == 2 or t == 0:
print("undefined")
else:
if t == 1:
if (b-1) % 4 == a:
print("CW".lower())
else:
print("CCW".lower())
elif t == 3:
if (b+1) % 4 == a:
print("CW".lower())
else:
print("CCW".lower())
| PYTHON3 |
834_A. The Useless Toy | <image>
Walking through the streets of Marshmallow City, Slastyona have spotted some merchants selling a kind of useless toy which is very popular nowadays – caramel spinner! Wanting to join the craze, she has immediately bought the strange contraption.
Spinners in Sweetland have the form of V-shaped pieces of caramel. Each spinner can, well, spin around an invisible magic axis. At a specific point in time, a spinner can take 4 positions shown below (each one rotated 90 degrees relative to the previous, with the fourth one followed by the first one):
<image>
After the spinner was spun, it starts its rotation, which is described by a following algorithm: the spinner maintains its position for a second then majestically switches to the next position in clockwise or counter-clockwise order, depending on the direction the spinner was spun in.
Slastyona managed to have spinner rotating for exactly n seconds. Being fascinated by elegance of the process, she completely forgot the direction the spinner was spun in! Lucky for her, she managed to recall the starting position, and wants to deduct the direction given the information she knows. Help her do this.
Input
There are two characters in the first string – the starting and the ending position of a spinner. The position is encoded with one of the following characters: v (ASCII code 118, lowercase v), < (ASCII code 60), ^ (ASCII code 94) or > (ASCII code 62) (see the picture above for reference). Characters are separated by a single space.
In the second strings, a single number n is given (0 ≤ n ≤ 109) – the duration of the rotation.
It is guaranteed that the ending position of a spinner is a result of a n second spin in any of the directions, assuming the given starting position.
Output
Output cw, if the direction is clockwise, ccw – if counter-clockwise, and undefined otherwise.
Examples
Input
^ >
1
Output
cw
Input
< ^
3
Output
ccw
Input
^ v
6
Output
undefined | 2 | 7 |
Input=lambda:map(str,input().split())
S, E = input().split()
n = int(input())
cw = ccw = True
l = ['^','>','v','<']
ind1 = l.index(S)
ind2 = l.index(E)
# cw
if ind1 <= ind2:
if (n - (ind2 - ind1)) % 4 !=0:
cw = False
else:
if (n-((3 - ind1)+(ind2+1))) % 4 !=0:
cw = False
if cw == False:
print("ccw")
exit()
# ccw
if ind1 >= ind2:
if (n - (ind1 - ind2)) % 4 !=0:
ccw = False
else:
if (n - (ind1+(4-ind2))) % 4 != 0:
ccw = False
print("cw" if ccw == False else "undefined")
| PYTHON3 |
834_A. The Useless Toy | <image>
Walking through the streets of Marshmallow City, Slastyona have spotted some merchants selling a kind of useless toy which is very popular nowadays – caramel spinner! Wanting to join the craze, she has immediately bought the strange contraption.
Spinners in Sweetland have the form of V-shaped pieces of caramel. Each spinner can, well, spin around an invisible magic axis. At a specific point in time, a spinner can take 4 positions shown below (each one rotated 90 degrees relative to the previous, with the fourth one followed by the first one):
<image>
After the spinner was spun, it starts its rotation, which is described by a following algorithm: the spinner maintains its position for a second then majestically switches to the next position in clockwise or counter-clockwise order, depending on the direction the spinner was spun in.
Slastyona managed to have spinner rotating for exactly n seconds. Being fascinated by elegance of the process, she completely forgot the direction the spinner was spun in! Lucky for her, she managed to recall the starting position, and wants to deduct the direction given the information she knows. Help her do this.
Input
There are two characters in the first string – the starting and the ending position of a spinner. The position is encoded with one of the following characters: v (ASCII code 118, lowercase v), < (ASCII code 60), ^ (ASCII code 94) or > (ASCII code 62) (see the picture above for reference). Characters are separated by a single space.
In the second strings, a single number n is given (0 ≤ n ≤ 109) – the duration of the rotation.
It is guaranteed that the ending position of a spinner is a result of a n second spin in any of the directions, assuming the given starting position.
Output
Output cw, if the direction is clockwise, ccw – if counter-clockwise, and undefined otherwise.
Examples
Input
^ >
1
Output
cw
Input
< ^
3
Output
ccw
Input
^ v
6
Output
undefined | 2 | 7 |
import java.util.Scanner;
public class Spinner {
private static Scanner in = new Scanner(System.in);
public static void main(String[] args) {
Spinner s = new Spinner();
String answer = new String();
SpinPosition initialPosition = s.new SpinPosition(in.next().charAt(0));
SpinPosition finalPosition = s.new SpinPosition(in.next().charAt(0));
long time = in.nextLong();
time %= 4;
int clockWise = (finalPosition.positionOrder > initialPosition.positionOrder) ? finalPosition.positionOrder - initialPosition.positionOrder
: 4 - Math.abs(finalPosition.positionOrder - initialPosition.positionOrder);
int counterCW = (finalPosition.positionOrder > initialPosition.positionOrder) ? 4 - Math.abs(finalPosition.positionOrder - initialPosition.positionOrder)
: Math.abs(finalPosition.positionOrder - initialPosition.positionOrder);
if(time == 0 || clockWise == counterCW)
{
answer = "undefined";
}
else
{
if(time - clockWise == 0)
{
answer = "cw";
}
else if(time - counterCW == 0)
{
answer = "ccw";
}
else
{
answer = "undefined";
}
}
System.out.println(answer);
}
public class SpinPosition
{
int positionOrder;
char position;
public SpinPosition(char x)
{
position = x;
if(position == 'v')
{
positionOrder = 1;
}else if(position == '<') {
positionOrder = 2;
}else if (position == '^') {
positionOrder = 3;
}else {
positionOrder = 4;
}
}
}
}
| JAVA |
834_A. The Useless Toy | <image>
Walking through the streets of Marshmallow City, Slastyona have spotted some merchants selling a kind of useless toy which is very popular nowadays – caramel spinner! Wanting to join the craze, she has immediately bought the strange contraption.
Spinners in Sweetland have the form of V-shaped pieces of caramel. Each spinner can, well, spin around an invisible magic axis. At a specific point in time, a spinner can take 4 positions shown below (each one rotated 90 degrees relative to the previous, with the fourth one followed by the first one):
<image>
After the spinner was spun, it starts its rotation, which is described by a following algorithm: the spinner maintains its position for a second then majestically switches to the next position in clockwise or counter-clockwise order, depending on the direction the spinner was spun in.
Slastyona managed to have spinner rotating for exactly n seconds. Being fascinated by elegance of the process, she completely forgot the direction the spinner was spun in! Lucky for her, she managed to recall the starting position, and wants to deduct the direction given the information she knows. Help her do this.
Input
There are two characters in the first string – the starting and the ending position of a spinner. The position is encoded with one of the following characters: v (ASCII code 118, lowercase v), < (ASCII code 60), ^ (ASCII code 94) or > (ASCII code 62) (see the picture above for reference). Characters are separated by a single space.
In the second strings, a single number n is given (0 ≤ n ≤ 109) – the duration of the rotation.
It is guaranteed that the ending position of a spinner is a result of a n second spin in any of the directions, assuming the given starting position.
Output
Output cw, if the direction is clockwise, ccw – if counter-clockwise, and undefined otherwise.
Examples
Input
^ >
1
Output
cw
Input
< ^
3
Output
ccw
Input
^ v
6
Output
undefined | 2 | 7 |
import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;
public class Solution {
static HashMap<Character, Long> degrees = new HashMap<Character, Long>();
public static char rotate(char start, long dur, boolean dir) {
long degree = degrees.get(start);
if (dir) {
// ccw
degree += 90 * dur;
} else {
degree -= 90 * dur;
}
degree = degree % 360;
if (degree < 0) {
degree = 360 + degree;
}
char ret = 'a';
Iterator it = degrees.entrySet().iterator();
while (it.hasNext()) {
Map.Entry<Character, Long> pair = (Map.Entry<Character, Long>) it
.next();
if (pair.getValue() == degree) {
ret = pair.getKey();
}
}
return ret;
}
public static void main(String[] args) {
degrees.put('>', new Long(0));
degrees.put('<', new Long(180));
degrees.put('^', new Long(90));
degrees.put('v', new Long(270));
Scanner in = new Scanner(System.in);
String start = in.next();
String end = in.next();
long dur = in.nextLong();
char ccw = rotate(start.toCharArray()[0], dur, true);
char cw = rotate(start.toCharArray()[0], dur, false);
if (cw == ccw) {
System.out.println("undefined");
return;
}
if (cw == end.toCharArray()[0]) {
System.out.println("cw");
return;
}
if (ccw == end.toCharArray()[0]) {
System.out.println("ccw");
return;
}
System.out.println("undefined");
return;
}
}
| JAVA |
834_A. The Useless Toy | <image>
Walking through the streets of Marshmallow City, Slastyona have spotted some merchants selling a kind of useless toy which is very popular nowadays – caramel spinner! Wanting to join the craze, she has immediately bought the strange contraption.
Spinners in Sweetland have the form of V-shaped pieces of caramel. Each spinner can, well, spin around an invisible magic axis. At a specific point in time, a spinner can take 4 positions shown below (each one rotated 90 degrees relative to the previous, with the fourth one followed by the first one):
<image>
After the spinner was spun, it starts its rotation, which is described by a following algorithm: the spinner maintains its position for a second then majestically switches to the next position in clockwise or counter-clockwise order, depending on the direction the spinner was spun in.
Slastyona managed to have spinner rotating for exactly n seconds. Being fascinated by elegance of the process, she completely forgot the direction the spinner was spun in! Lucky for her, she managed to recall the starting position, and wants to deduct the direction given the information she knows. Help her do this.
Input
There are two characters in the first string – the starting and the ending position of a spinner. The position is encoded with one of the following characters: v (ASCII code 118, lowercase v), < (ASCII code 60), ^ (ASCII code 94) or > (ASCII code 62) (see the picture above for reference). Characters are separated by a single space.
In the second strings, a single number n is given (0 ≤ n ≤ 109) – the duration of the rotation.
It is guaranteed that the ending position of a spinner is a result of a n second spin in any of the directions, assuming the given starting position.
Output
Output cw, if the direction is clockwise, ccw – if counter-clockwise, and undefined otherwise.
Examples
Input
^ >
1
Output
cw
Input
< ^
3
Output
ccw
Input
^ v
6
Output
undefined | 2 | 7 | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
/**
* Created by dell on 7/30/2017.
*/
public class spinner {
static class FastReader
{
BufferedReader br;
StringTokenizer st;
public FastReader()
{
br = new BufferedReader(new
InputStreamReader(System.in));
}
String next()
{
while (st == null || !st.hasMoreElements())
{
try
{
st = new StringTokenizer(br.readLine());
}
catch (IOException e)
{
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt()
{
return Integer.parseInt(next());
}
long nextLong()
{
return Long.parseLong(next());
}
double nextDouble()
{
return Double.parseDouble(next());
}
String nextLine()
{
String str = "";
try
{
str = br.readLine();
}
catch (IOException e)
{
e.printStackTrace();
}
return str;
}
}
public static void main(String args[])throws IOException {
FastReader sc = new FastReader();
String line1 = sc.nextLine();
char s = line1.charAt(0);
char e = line1.charAt(2);
int sec=sc.nextInt();
int x=sec%4;
int index=0;
char a[]={'v','<','^','>'};
for(int i=0;i<=3;i++)
{
if(a[i]==s)
index=i;
}
int flag=0;
int c=0;
int cw=0;
if(a[(index+x)%4]==e)
{
flag=1;
c++;
cw=1;
}
int t=index-x;
if(t<0)
{
t=4+t;
}
if(a[t]==e)
{
c++;
flag=1;
cw=0;
}
if(flag==0 || c==2)
{
System.out.println("undefined");
}
if(c==1 && cw==0)
System.out.println("ccw");
if(c==1 && cw==1)
System.out.println("cw");
}
}
| JAVA |
834_A. The Useless Toy | <image>
Walking through the streets of Marshmallow City, Slastyona have spotted some merchants selling a kind of useless toy which is very popular nowadays – caramel spinner! Wanting to join the craze, she has immediately bought the strange contraption.
Spinners in Sweetland have the form of V-shaped pieces of caramel. Each spinner can, well, spin around an invisible magic axis. At a specific point in time, a spinner can take 4 positions shown below (each one rotated 90 degrees relative to the previous, with the fourth one followed by the first one):
<image>
After the spinner was spun, it starts its rotation, which is described by a following algorithm: the spinner maintains its position for a second then majestically switches to the next position in clockwise or counter-clockwise order, depending on the direction the spinner was spun in.
Slastyona managed to have spinner rotating for exactly n seconds. Being fascinated by elegance of the process, she completely forgot the direction the spinner was spun in! Lucky for her, she managed to recall the starting position, and wants to deduct the direction given the information she knows. Help her do this.
Input
There are two characters in the first string – the starting and the ending position of a spinner. The position is encoded with one of the following characters: v (ASCII code 118, lowercase v), < (ASCII code 60), ^ (ASCII code 94) or > (ASCII code 62) (see the picture above for reference). Characters are separated by a single space.
In the second strings, a single number n is given (0 ≤ n ≤ 109) – the duration of the rotation.
It is guaranteed that the ending position of a spinner is a result of a n second spin in any of the directions, assuming the given starting position.
Output
Output cw, if the direction is clockwise, ccw – if counter-clockwise, and undefined otherwise.
Examples
Input
^ >
1
Output
cw
Input
< ^
3
Output
ccw
Input
^ v
6
Output
undefined | 2 | 7 | #include <bits/stdc++.h>
using namespace std;
int dx[] = {0, 1, -1, 0};
int dy[] = {1, 0, 0, -1};
long long pw(long long b, long long p) {
if (!p) return 1;
long long sq = pw(b, p / 2) % 1000000007;
sq = (sq * sq) % 1000000007;
if (p % 2) sq = (sq * b) % 1000000007;
return sq;
}
const int N = 1e5 + 5, LG = 18;
char f[] = {'v', '<', '^', '>'};
char ba[] = {'v', '>', '^', '<'};
map<char, int> mp, mpp;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
mp['v'] = 0;
mp['<'] = 1;
mp['^'] = 2;
mp['>'] = 3;
mpp['v'] = 0;
mpp['<'] = 3;
mpp['^'] = 2;
mpp['>'] = 1;
char a, b, tb;
cin >> a >> b;
tb = b;
int n;
cin >> n;
n %= 4;
int i = mp[a];
int j = mpp[a];
b = a;
for (int k = 0; k < n; k++) {
a = f[(++i) % 4];
b = ba[(++j) % 4];
}
if ((tb == a && tb == b) || (tb != a && tb != b))
cout << "undefined";
else if (tb == a)
cout << "cw";
else
cout << "ccw";
return 0;
}
| CPP |
834_A. The Useless Toy | <image>
Walking through the streets of Marshmallow City, Slastyona have spotted some merchants selling a kind of useless toy which is very popular nowadays – caramel spinner! Wanting to join the craze, she has immediately bought the strange contraption.
Spinners in Sweetland have the form of V-shaped pieces of caramel. Each spinner can, well, spin around an invisible magic axis. At a specific point in time, a spinner can take 4 positions shown below (each one rotated 90 degrees relative to the previous, with the fourth one followed by the first one):
<image>
After the spinner was spun, it starts its rotation, which is described by a following algorithm: the spinner maintains its position for a second then majestically switches to the next position in clockwise or counter-clockwise order, depending on the direction the spinner was spun in.
Slastyona managed to have spinner rotating for exactly n seconds. Being fascinated by elegance of the process, she completely forgot the direction the spinner was spun in! Lucky for her, she managed to recall the starting position, and wants to deduct the direction given the information she knows. Help her do this.
Input
There are two characters in the first string – the starting and the ending position of a spinner. The position is encoded with one of the following characters: v (ASCII code 118, lowercase v), < (ASCII code 60), ^ (ASCII code 94) or > (ASCII code 62) (see the picture above for reference). Characters are separated by a single space.
In the second strings, a single number n is given (0 ≤ n ≤ 109) – the duration of the rotation.
It is guaranteed that the ending position of a spinner is a result of a n second spin in any of the directions, assuming the given starting position.
Output
Output cw, if the direction is clockwise, ccw – if counter-clockwise, and undefined otherwise.
Examples
Input
^ >
1
Output
cw
Input
< ^
3
Output
ccw
Input
^ v
6
Output
undefined | 2 | 7 | s = input().split()
num = int(input()) % 4
if num == 2 or num == 0:
print("undefined")
else:
mapping = ["v", "<", "^", ">", "v", "<", "^", ">"]
if num == 1:
ind1 = mapping.index(s[0])
ind2 = mapping[ind1:].index(s[1])
if 1 == ind2:
print("cw")
else:
print("ccw")
# print(ind1)
# print(ind2)
else:
ind1 = mapping.index(s[0])
ind2 = mapping[ind1:].index(s[1])
if 3 == ind2:
print("cw")
else:
print("ccw")
| PYTHON3 |
834_A. The Useless Toy | <image>
Walking through the streets of Marshmallow City, Slastyona have spotted some merchants selling a kind of useless toy which is very popular nowadays – caramel spinner! Wanting to join the craze, she has immediately bought the strange contraption.
Spinners in Sweetland have the form of V-shaped pieces of caramel. Each spinner can, well, spin around an invisible magic axis. At a specific point in time, a spinner can take 4 positions shown below (each one rotated 90 degrees relative to the previous, with the fourth one followed by the first one):
<image>
After the spinner was spun, it starts its rotation, which is described by a following algorithm: the spinner maintains its position for a second then majestically switches to the next position in clockwise or counter-clockwise order, depending on the direction the spinner was spun in.
Slastyona managed to have spinner rotating for exactly n seconds. Being fascinated by elegance of the process, she completely forgot the direction the spinner was spun in! Lucky for her, she managed to recall the starting position, and wants to deduct the direction given the information she knows. Help her do this.
Input
There are two characters in the first string – the starting and the ending position of a spinner. The position is encoded with one of the following characters: v (ASCII code 118, lowercase v), < (ASCII code 60), ^ (ASCII code 94) or > (ASCII code 62) (see the picture above for reference). Characters are separated by a single space.
In the second strings, a single number n is given (0 ≤ n ≤ 109) – the duration of the rotation.
It is guaranteed that the ending position of a spinner is a result of a n second spin in any of the directions, assuming the given starting position.
Output
Output cw, if the direction is clockwise, ccw – if counter-clockwise, and undefined otherwise.
Examples
Input
^ >
1
Output
cw
Input
< ^
3
Output
ccw
Input
^ v
6
Output
undefined | 2 | 7 | #include <bits/stdc++.h>
using namespace std;
char sta;
char en;
long minu;
char pos[4] = {'^', '>', 'v', '<'};
int main() {
cin >> sta >> en >> minu;
int p1 = 0, p2 = 0;
for (int i = 0; i < 4; i++) {
if (pos[i] == sta) p1 = i;
if (pos[i] == en) p2 = i;
}
long step = minu % 4;
if (step != 0 && step != 2) {
if (pos[(p1 + step) % 4] == pos[p2])
cout << "cw" << endl;
else if (pos[abs(p2 + step) % 4] == pos[p1])
cout << "ccw" << endl;
else
cout << "undefined" << endl;
} else
cout << "undefined" << endl;
}
| CPP |
834_A. The Useless Toy | <image>
Walking through the streets of Marshmallow City, Slastyona have spotted some merchants selling a kind of useless toy which is very popular nowadays – caramel spinner! Wanting to join the craze, she has immediately bought the strange contraption.
Spinners in Sweetland have the form of V-shaped pieces of caramel. Each spinner can, well, spin around an invisible magic axis. At a specific point in time, a spinner can take 4 positions shown below (each one rotated 90 degrees relative to the previous, with the fourth one followed by the first one):
<image>
After the spinner was spun, it starts its rotation, which is described by a following algorithm: the spinner maintains its position for a second then majestically switches to the next position in clockwise or counter-clockwise order, depending on the direction the spinner was spun in.
Slastyona managed to have spinner rotating for exactly n seconds. Being fascinated by elegance of the process, she completely forgot the direction the spinner was spun in! Lucky for her, she managed to recall the starting position, and wants to deduct the direction given the information she knows. Help her do this.
Input
There are two characters in the first string – the starting and the ending position of a spinner. The position is encoded with one of the following characters: v (ASCII code 118, lowercase v), < (ASCII code 60), ^ (ASCII code 94) or > (ASCII code 62) (see the picture above for reference). Characters are separated by a single space.
In the second strings, a single number n is given (0 ≤ n ≤ 109) – the duration of the rotation.
It is guaranteed that the ending position of a spinner is a result of a n second spin in any of the directions, assuming the given starting position.
Output
Output cw, if the direction is clockwise, ccw – if counter-clockwise, and undefined otherwise.
Examples
Input
^ >
1
Output
cw
Input
< ^
3
Output
ccw
Input
^ v
6
Output
undefined | 2 | 7 | import java.util.*;
public class Solution {
public static void main(String[] args) {
Scanner in=new Scanner(System.in);
String o=in.next(),t=in.next();
int n=in.nextInt()%4;
int oi=0,ti=0;
switch (o){
case "^":
oi=0;
break;
case ">":
oi=1;
break;
case "v":
oi=2;
break;
default:
oi=3;
}
switch (t){
case "^":
ti=0;
break;
case ">":
ti=1;
break;
case "v":
ti=2;
break;
default:
ti=3;
}
int cw=ti-oi,ccw=oi-ti;
if (((cw==-ccw)&&(Math.abs(cw)==2))||(cw==ccw)){System.out.println("undefined");return;}
if (cw<0){cw=4+cw;}
if (cw==n){
System.out.println("cw");
}else {
System.out.println("ccw");
}
in.close();
}
} | JAVA |
834_A. The Useless Toy | <image>
Walking through the streets of Marshmallow City, Slastyona have spotted some merchants selling a kind of useless toy which is very popular nowadays – caramel spinner! Wanting to join the craze, she has immediately bought the strange contraption.
Spinners in Sweetland have the form of V-shaped pieces of caramel. Each spinner can, well, spin around an invisible magic axis. At a specific point in time, a spinner can take 4 positions shown below (each one rotated 90 degrees relative to the previous, with the fourth one followed by the first one):
<image>
After the spinner was spun, it starts its rotation, which is described by a following algorithm: the spinner maintains its position for a second then majestically switches to the next position in clockwise or counter-clockwise order, depending on the direction the spinner was spun in.
Slastyona managed to have spinner rotating for exactly n seconds. Being fascinated by elegance of the process, she completely forgot the direction the spinner was spun in! Lucky for her, she managed to recall the starting position, and wants to deduct the direction given the information she knows. Help her do this.
Input
There are two characters in the first string – the starting and the ending position of a spinner. The position is encoded with one of the following characters: v (ASCII code 118, lowercase v), < (ASCII code 60), ^ (ASCII code 94) or > (ASCII code 62) (see the picture above for reference). Characters are separated by a single space.
In the second strings, a single number n is given (0 ≤ n ≤ 109) – the duration of the rotation.
It is guaranteed that the ending position of a spinner is a result of a n second spin in any of the directions, assuming the given starting position.
Output
Output cw, if the direction is clockwise, ccw – if counter-clockwise, and undefined otherwise.
Examples
Input
^ >
1
Output
cw
Input
< ^
3
Output
ccw
Input
^ v
6
Output
undefined | 2 | 7 | import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;
/**
* Built using CHelper plug-in
* Actual solution is at the top
*/
public class Main {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
InputReader in = new InputReader(inputStream);
PrintWriter out = new PrintWriter(outputStream);
TaskA solver = new TaskA();
solver.solve(1, in, out);
out.close();
}
static class TaskA {
public void solve(int testNumber, InputReader in, PrintWriter out) {
String s = in.nextLine();
int n = in.nextInt();
char[] spin = new char[]{'v', '<', '^', '>'};
n %= 4;
int x = 0;
int y = 0;
for (int i = 0; i < spin.length; i++) {
if (s.charAt(0) == spin[i]) x = i;
if (s.charAt(2) == spin[i]) y = i;
}
if ((x + n) % 4 == y && (x + 4 - n) % 4 == y) out.println("undefined");
else if ((x + n) % 4 == y) {
out.println("cw");
} else if ((x + 4 - n) % 4 == y) {
out.println("ccw");
} else out.println("undefined");
}
}
static class InputReader {
public BufferedReader reader;
public StringTokenizer tokenizer;
public InputReader(InputStream stream) {
reader = new BufferedReader(new InputStreamReader(stream));
tokenizer = null;
}
public String next() {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
tokenizer = new StringTokenizer(reader.readLine());
} catch (IOException e) {
throw new RuntimeException(e);
}
}
return tokenizer.nextToken();
}
public String nextLine() {
try {
return reader.readLine();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
public int nextInt() {
return Integer.parseInt(next());
}
}
}
| JAVA |
834_A. The Useless Toy | <image>
Walking through the streets of Marshmallow City, Slastyona have spotted some merchants selling a kind of useless toy which is very popular nowadays – caramel spinner! Wanting to join the craze, she has immediately bought the strange contraption.
Spinners in Sweetland have the form of V-shaped pieces of caramel. Each spinner can, well, spin around an invisible magic axis. At a specific point in time, a spinner can take 4 positions shown below (each one rotated 90 degrees relative to the previous, with the fourth one followed by the first one):
<image>
After the spinner was spun, it starts its rotation, which is described by a following algorithm: the spinner maintains its position for a second then majestically switches to the next position in clockwise or counter-clockwise order, depending on the direction the spinner was spun in.
Slastyona managed to have spinner rotating for exactly n seconds. Being fascinated by elegance of the process, she completely forgot the direction the spinner was spun in! Lucky for her, she managed to recall the starting position, and wants to deduct the direction given the information she knows. Help her do this.
Input
There are two characters in the first string – the starting and the ending position of a spinner. The position is encoded with one of the following characters: v (ASCII code 118, lowercase v), < (ASCII code 60), ^ (ASCII code 94) or > (ASCII code 62) (see the picture above for reference). Characters are separated by a single space.
In the second strings, a single number n is given (0 ≤ n ≤ 109) – the duration of the rotation.
It is guaranteed that the ending position of a spinner is a result of a n second spin in any of the directions, assuming the given starting position.
Output
Output cw, if the direction is clockwise, ccw – if counter-clockwise, and undefined otherwise.
Examples
Input
^ >
1
Output
cw
Input
< ^
3
Output
ccw
Input
^ v
6
Output
undefined | 2 | 7 | l,p=False,False
s1,s2=map(str,input().split())
s=s1+''
n=int(input())%4
for i in range(n):
if s=='v':
s='<'
elif s=='<':
s='^'
elif s=='^':
s='>'
elif s=='>':
s='v'
if s==s2:
l=True
s=s1+''
for i in range(n):
if s=='v':
s='>'
elif s=='>':
s='^'
elif s=='^':
s='<'
elif s=='<':
s='v'
if s==s2:
p=True
if p==l:
print('undefined')
elif l:
print('cw')
else:
print('ccw')
| PYTHON3 |
834_A. The Useless Toy | <image>
Walking through the streets of Marshmallow City, Slastyona have spotted some merchants selling a kind of useless toy which is very popular nowadays – caramel spinner! Wanting to join the craze, she has immediately bought the strange contraption.
Spinners in Sweetland have the form of V-shaped pieces of caramel. Each spinner can, well, spin around an invisible magic axis. At a specific point in time, a spinner can take 4 positions shown below (each one rotated 90 degrees relative to the previous, with the fourth one followed by the first one):
<image>
After the spinner was spun, it starts its rotation, which is described by a following algorithm: the spinner maintains its position for a second then majestically switches to the next position in clockwise or counter-clockwise order, depending on the direction the spinner was spun in.
Slastyona managed to have spinner rotating for exactly n seconds. Being fascinated by elegance of the process, she completely forgot the direction the spinner was spun in! Lucky for her, she managed to recall the starting position, and wants to deduct the direction given the information she knows. Help her do this.
Input
There are two characters in the first string – the starting and the ending position of a spinner. The position is encoded with one of the following characters: v (ASCII code 118, lowercase v), < (ASCII code 60), ^ (ASCII code 94) or > (ASCII code 62) (see the picture above for reference). Characters are separated by a single space.
In the second strings, a single number n is given (0 ≤ n ≤ 109) – the duration of the rotation.
It is guaranteed that the ending position of a spinner is a result of a n second spin in any of the directions, assuming the given starting position.
Output
Output cw, if the direction is clockwise, ccw – if counter-clockwise, and undefined otherwise.
Examples
Input
^ >
1
Output
cw
Input
< ^
3
Output
ccw
Input
^ v
6
Output
undefined | 2 | 7 | c='^>v<'
a,b=map(c.index,input().split())
n=int(input())
print([['ccw','cw'][(a+n)%4==b],'undefined'][abs(a-b)%2==0]) | PYTHON3 |
834_A. The Useless Toy | <image>
Walking through the streets of Marshmallow City, Slastyona have spotted some merchants selling a kind of useless toy which is very popular nowadays – caramel spinner! Wanting to join the craze, she has immediately bought the strange contraption.
Spinners in Sweetland have the form of V-shaped pieces of caramel. Each spinner can, well, spin around an invisible magic axis. At a specific point in time, a spinner can take 4 positions shown below (each one rotated 90 degrees relative to the previous, with the fourth one followed by the first one):
<image>
After the spinner was spun, it starts its rotation, which is described by a following algorithm: the spinner maintains its position for a second then majestically switches to the next position in clockwise or counter-clockwise order, depending on the direction the spinner was spun in.
Slastyona managed to have spinner rotating for exactly n seconds. Being fascinated by elegance of the process, she completely forgot the direction the spinner was spun in! Lucky for her, she managed to recall the starting position, and wants to deduct the direction given the information she knows. Help her do this.
Input
There are two characters in the first string – the starting and the ending position of a spinner. The position is encoded with one of the following characters: v (ASCII code 118, lowercase v), < (ASCII code 60), ^ (ASCII code 94) or > (ASCII code 62) (see the picture above for reference). Characters are separated by a single space.
In the second strings, a single number n is given (0 ≤ n ≤ 109) – the duration of the rotation.
It is guaranteed that the ending position of a spinner is a result of a n second spin in any of the directions, assuming the given starting position.
Output
Output cw, if the direction is clockwise, ccw – if counter-clockwise, and undefined otherwise.
Examples
Input
^ >
1
Output
cw
Input
< ^
3
Output
ccw
Input
^ v
6
Output
undefined | 2 | 7 |
import sys
Input = sys.stdin.readline
tmp = 'v<^>'
x, y = Input().split()
a = tmp.index(x)
b = tmp.index(y)
n = int(Input())
if n % 2 == 0:
print('undefined')
elif tmp[a - (n % 4)] == y:
print('ccw')
else:
print('cw')
# FMZJMSOMPMSL | PYTHON3 |
834_A. The Useless Toy | <image>
Walking through the streets of Marshmallow City, Slastyona have spotted some merchants selling a kind of useless toy which is very popular nowadays – caramel spinner! Wanting to join the craze, she has immediately bought the strange contraption.
Spinners in Sweetland have the form of V-shaped pieces of caramel. Each spinner can, well, spin around an invisible magic axis. At a specific point in time, a spinner can take 4 positions shown below (each one rotated 90 degrees relative to the previous, with the fourth one followed by the first one):
<image>
After the spinner was spun, it starts its rotation, which is described by a following algorithm: the spinner maintains its position for a second then majestically switches to the next position in clockwise or counter-clockwise order, depending on the direction the spinner was spun in.
Slastyona managed to have spinner rotating for exactly n seconds. Being fascinated by elegance of the process, she completely forgot the direction the spinner was spun in! Lucky for her, she managed to recall the starting position, and wants to deduct the direction given the information she knows. Help her do this.
Input
There are two characters in the first string – the starting and the ending position of a spinner. The position is encoded with one of the following characters: v (ASCII code 118, lowercase v), < (ASCII code 60), ^ (ASCII code 94) or > (ASCII code 62) (see the picture above for reference). Characters are separated by a single space.
In the second strings, a single number n is given (0 ≤ n ≤ 109) – the duration of the rotation.
It is guaranteed that the ending position of a spinner is a result of a n second spin in any of the directions, assuming the given starting position.
Output
Output cw, if the direction is clockwise, ccw – if counter-clockwise, and undefined otherwise.
Examples
Input
^ >
1
Output
cw
Input
< ^
3
Output
ccw
Input
^ v
6
Output
undefined | 2 | 7 | #include <bits/stdc++.h>
using namespace std;
int main(void) {
char start, end;
int n, s, e, t = 0;
bool one = false, two = false;
scanf("%c %c", &start, &end);
scanf("%d", &n);
if (start == 118)
s = 1;
else if (start == 60)
s = 2;
else if (start == 94)
s = 3;
else if (start == 62)
s = 4;
if (end == 118)
e = 1;
else if (end == 60)
e = 2;
else if (end == 94)
e = 3;
else if (end == 62)
e = 4;
n %= 4;
int m = n, S = s;
while (m--) {
S++;
if (S == 5) S = 1;
}
if (S == e) {
one = true;
}
m = n;
S = s;
while (m--) {
S--;
if (S == 0) S = 4;
}
if (S == e) {
two = true;
}
if (one == true && two == false) {
printf("cw\n");
return 0;
} else if (one == false && two == true) {
printf("ccw\n");
return 0;
}
printf("undefined\n");
return 0;
}
| CPP |
834_A. The Useless Toy | <image>
Walking through the streets of Marshmallow City, Slastyona have spotted some merchants selling a kind of useless toy which is very popular nowadays – caramel spinner! Wanting to join the craze, she has immediately bought the strange contraption.
Spinners in Sweetland have the form of V-shaped pieces of caramel. Each spinner can, well, spin around an invisible magic axis. At a specific point in time, a spinner can take 4 positions shown below (each one rotated 90 degrees relative to the previous, with the fourth one followed by the first one):
<image>
After the spinner was spun, it starts its rotation, which is described by a following algorithm: the spinner maintains its position for a second then majestically switches to the next position in clockwise or counter-clockwise order, depending on the direction the spinner was spun in.
Slastyona managed to have spinner rotating for exactly n seconds. Being fascinated by elegance of the process, she completely forgot the direction the spinner was spun in! Lucky for her, she managed to recall the starting position, and wants to deduct the direction given the information she knows. Help her do this.
Input
There are two characters in the first string – the starting and the ending position of a spinner. The position is encoded with one of the following characters: v (ASCII code 118, lowercase v), < (ASCII code 60), ^ (ASCII code 94) or > (ASCII code 62) (see the picture above for reference). Characters are separated by a single space.
In the second strings, a single number n is given (0 ≤ n ≤ 109) – the duration of the rotation.
It is guaranteed that the ending position of a spinner is a result of a n second spin in any of the directions, assuming the given starting position.
Output
Output cw, if the direction is clockwise, ccw – if counter-clockwise, and undefined otherwise.
Examples
Input
^ >
1
Output
cw
Input
< ^
3
Output
ccw
Input
^ v
6
Output
undefined | 2 | 7 | import java.lang.String;
import java.util.Scanner;
public class Main
{
private static int Spin_Position(String first)
{
if(first.charAt(0) == '^' )
{
return 1;
}
else if(first.charAt(0) == '>')
{
return 2;
}
else if(first.charAt(0) == 'v')
{
return 3;
}
else if (first.charAt(0) == '<')
{
return 4;
}
else return 0;
}
public static void main(String[] args)
{
Scanner input = new Scanner(System.in);
String first = input.next();
String second = input.next();
int current_pos = Spin_Position(first);
int current_f_pos = Spin_Position(second);
int n = input.nextInt();
int current_time = 0;
if((current_pos == 1 && current_f_pos == 3)
|| (current_pos == 2 && current_f_pos == 4)
|| (current_pos == 3 && current_f_pos == 1)
|| (current_pos == 4 && current_f_pos == 2)
|| (current_pos == current_f_pos))
{
System.out.println("undefined");
}
else
{
while (current_time < n)
{
current_pos++;
if(current_pos == 5)
{
current_pos = 1;
}
current_time++;
}
if (current_pos == current_f_pos)
{
System.out.println("cw");
}
else System.out.println("ccw");
}
}
} | JAVA |
834_A. The Useless Toy | <image>
Walking through the streets of Marshmallow City, Slastyona have spotted some merchants selling a kind of useless toy which is very popular nowadays – caramel spinner! Wanting to join the craze, she has immediately bought the strange contraption.
Spinners in Sweetland have the form of V-shaped pieces of caramel. Each spinner can, well, spin around an invisible magic axis. At a specific point in time, a spinner can take 4 positions shown below (each one rotated 90 degrees relative to the previous, with the fourth one followed by the first one):
<image>
After the spinner was spun, it starts its rotation, which is described by a following algorithm: the spinner maintains its position for a second then majestically switches to the next position in clockwise or counter-clockwise order, depending on the direction the spinner was spun in.
Slastyona managed to have spinner rotating for exactly n seconds. Being fascinated by elegance of the process, she completely forgot the direction the spinner was spun in! Lucky for her, she managed to recall the starting position, and wants to deduct the direction given the information she knows. Help her do this.
Input
There are two characters in the first string – the starting and the ending position of a spinner. The position is encoded with one of the following characters: v (ASCII code 118, lowercase v), < (ASCII code 60), ^ (ASCII code 94) or > (ASCII code 62) (see the picture above for reference). Characters are separated by a single space.
In the second strings, a single number n is given (0 ≤ n ≤ 109) – the duration of the rotation.
It is guaranteed that the ending position of a spinner is a result of a n second spin in any of the directions, assuming the given starting position.
Output
Output cw, if the direction is clockwise, ccw – if counter-clockwise, and undefined otherwise.
Examples
Input
^ >
1
Output
cw
Input
< ^
3
Output
ccw
Input
^ v
6
Output
undefined | 2 | 7 | import java.io.*;
import java.util.*;
public class TheUselessToy
{
public static void main(String args[])
{
Scanner sc= new Scanner(System.in);
int start = (int)(sc.next().charAt(0));
int end = (int)(sc.next().charAt(0));
long n = sc.nextLong();
//System.out.println(start+" "+end);
//v (ASCII code 118, lowercase v), < (ASCII code 60), ^ (ASCII code 94) or > (ASCII code 62)
if(n%2==0)
{
System.out.println("undefined");
}
else
{
if(((((start==118)&&(end==62))||((start==62)&&(end==94))||((start==94)&&(end==60))||((start==60)&&(end==118)))&&(n%4==1))||((((start==118)&&(end==60))||((start==60)&&(end==94))||((start==94)&&(end==62))||((start==62)&&(end==118)))&&(n%4==3)))
System.out.println("ccw");
else
System.out.println("cw");
}
}
} | JAVA |
834_A. The Useless Toy | <image>
Walking through the streets of Marshmallow City, Slastyona have spotted some merchants selling a kind of useless toy which is very popular nowadays – caramel spinner! Wanting to join the craze, she has immediately bought the strange contraption.
Spinners in Sweetland have the form of V-shaped pieces of caramel. Each spinner can, well, spin around an invisible magic axis. At a specific point in time, a spinner can take 4 positions shown below (each one rotated 90 degrees relative to the previous, with the fourth one followed by the first one):
<image>
After the spinner was spun, it starts its rotation, which is described by a following algorithm: the spinner maintains its position for a second then majestically switches to the next position in clockwise or counter-clockwise order, depending on the direction the spinner was spun in.
Slastyona managed to have spinner rotating for exactly n seconds. Being fascinated by elegance of the process, she completely forgot the direction the spinner was spun in! Lucky for her, she managed to recall the starting position, and wants to deduct the direction given the information she knows. Help her do this.
Input
There are two characters in the first string – the starting and the ending position of a spinner. The position is encoded with one of the following characters: v (ASCII code 118, lowercase v), < (ASCII code 60), ^ (ASCII code 94) or > (ASCII code 62) (see the picture above for reference). Characters are separated by a single space.
In the second strings, a single number n is given (0 ≤ n ≤ 109) – the duration of the rotation.
It is guaranteed that the ending position of a spinner is a result of a n second spin in any of the directions, assuming the given starting position.
Output
Output cw, if the direction is clockwise, ccw – if counter-clockwise, and undefined otherwise.
Examples
Input
^ >
1
Output
cw
Input
< ^
3
Output
ccw
Input
^ v
6
Output
undefined | 2 | 7 | #include <bits/stdc++.h>
using namespace std;
char c, cs, cf;
int n, s, f;
int main(void) {
cin >> cs >> cf >> n;
if (cs == 'v')
s = 3;
else if (cs == '<')
s = 4;
else if (cs == '^')
s = 1;
else if (cs == '>')
s = 2;
if (cf == 'v')
f = 3;
else if (cf == '<')
f = 4;
else if (cf == '^')
f = 1;
else if (cf == '>')
f = 2;
n %= 4;
if (((s + n) > 4 ? s + n - 4 : s + n) == f &&
((s - n) <= 0 ? s - n + 4 : s - n) == f)
cout << "undefined";
else if (((s + n) > 4 ? s + n - 4 : s + n) == f)
cout << "cw";
else
cout << "ccw";
return 0;
}
| CPP |
834_A. The Useless Toy | <image>
Walking through the streets of Marshmallow City, Slastyona have spotted some merchants selling a kind of useless toy which is very popular nowadays – caramel spinner! Wanting to join the craze, she has immediately bought the strange contraption.
Spinners in Sweetland have the form of V-shaped pieces of caramel. Each spinner can, well, spin around an invisible magic axis. At a specific point in time, a spinner can take 4 positions shown below (each one rotated 90 degrees relative to the previous, with the fourth one followed by the first one):
<image>
After the spinner was spun, it starts its rotation, which is described by a following algorithm: the spinner maintains its position for a second then majestically switches to the next position in clockwise or counter-clockwise order, depending on the direction the spinner was spun in.
Slastyona managed to have spinner rotating for exactly n seconds. Being fascinated by elegance of the process, she completely forgot the direction the spinner was spun in! Lucky for her, she managed to recall the starting position, and wants to deduct the direction given the information she knows. Help her do this.
Input
There are two characters in the first string – the starting and the ending position of a spinner. The position is encoded with one of the following characters: v (ASCII code 118, lowercase v), < (ASCII code 60), ^ (ASCII code 94) or > (ASCII code 62) (see the picture above for reference). Characters are separated by a single space.
In the second strings, a single number n is given (0 ≤ n ≤ 109) – the duration of the rotation.
It is guaranteed that the ending position of a spinner is a result of a n second spin in any of the directions, assuming the given starting position.
Output
Output cw, if the direction is clockwise, ccw – if counter-clockwise, and undefined otherwise.
Examples
Input
^ >
1
Output
cw
Input
< ^
3
Output
ccw
Input
^ v
6
Output
undefined | 2 | 7 | dir1, dir2 = raw_input().split()
rotations = int(raw_input())
def isCW(dir1, dir2, rotations):
cw_rotation = ["^", ">", "v", "<"]
actual_rotations = rotations % 4
for i in xrange(len(cw_rotation)):
if cw_rotation[i] == dir1:
if cw_rotation[(i + rotations) % 4] == dir2:
return True
return False
def isCCW(dir1, dir2, rotations):
return isCW(dir2, dir1, rotations)
if isCW(dir1, dir2, rotations) and isCCW(dir1, dir2, rotations):
print "undefined"
elif isCW(dir1, dir2, rotations):
print "cw"
elif isCCW(dir1, dir2, rotations):
print "ccw"
else:
print "undefined" | PYTHON |
834_A. The Useless Toy | <image>
Walking through the streets of Marshmallow City, Slastyona have spotted some merchants selling a kind of useless toy which is very popular nowadays – caramel spinner! Wanting to join the craze, she has immediately bought the strange contraption.
Spinners in Sweetland have the form of V-shaped pieces of caramel. Each spinner can, well, spin around an invisible magic axis. At a specific point in time, a spinner can take 4 positions shown below (each one rotated 90 degrees relative to the previous, with the fourth one followed by the first one):
<image>
After the spinner was spun, it starts its rotation, which is described by a following algorithm: the spinner maintains its position for a second then majestically switches to the next position in clockwise or counter-clockwise order, depending on the direction the spinner was spun in.
Slastyona managed to have spinner rotating for exactly n seconds. Being fascinated by elegance of the process, she completely forgot the direction the spinner was spun in! Lucky for her, she managed to recall the starting position, and wants to deduct the direction given the information she knows. Help her do this.
Input
There are two characters in the first string – the starting and the ending position of a spinner. The position is encoded with one of the following characters: v (ASCII code 118, lowercase v), < (ASCII code 60), ^ (ASCII code 94) or > (ASCII code 62) (see the picture above for reference). Characters are separated by a single space.
In the second strings, a single number n is given (0 ≤ n ≤ 109) – the duration of the rotation.
It is guaranteed that the ending position of a spinner is a result of a n second spin in any of the directions, assuming the given starting position.
Output
Output cw, if the direction is clockwise, ccw – if counter-clockwise, and undefined otherwise.
Examples
Input
^ >
1
Output
cw
Input
< ^
3
Output
ccw
Input
^ v
6
Output
undefined | 2 | 7 | #include <bits/stdc++.h>
using namespace std;
string a, b;
map<string, int> h;
int n;
int ok1 = 0, ok2 = 0;
int main() {
h["v"] = 1;
h["<"] = 2;
h["^"] = 3;
h[">"] = 4;
cin >> a >> b >> n;
n = n % 4;
if ((h[a] + n - 1 + 12) % 4 + 1 == h[b]) ok1 = 1;
if ((h[a] - n - 1 + 12 * 4) % 4 + 1 == h[b]) ok2 = 1;
ok1&& ok2 ? puts("undefined") : ok1 ? puts("cw") : puts("ccw");
return 0;
}
| CPP |
834_A. The Useless Toy | <image>
Walking through the streets of Marshmallow City, Slastyona have spotted some merchants selling a kind of useless toy which is very popular nowadays – caramel spinner! Wanting to join the craze, she has immediately bought the strange contraption.
Spinners in Sweetland have the form of V-shaped pieces of caramel. Each spinner can, well, spin around an invisible magic axis. At a specific point in time, a spinner can take 4 positions shown below (each one rotated 90 degrees relative to the previous, with the fourth one followed by the first one):
<image>
After the spinner was spun, it starts its rotation, which is described by a following algorithm: the spinner maintains its position for a second then majestically switches to the next position in clockwise or counter-clockwise order, depending on the direction the spinner was spun in.
Slastyona managed to have spinner rotating for exactly n seconds. Being fascinated by elegance of the process, she completely forgot the direction the spinner was spun in! Lucky for her, she managed to recall the starting position, and wants to deduct the direction given the information she knows. Help her do this.
Input
There are two characters in the first string – the starting and the ending position of a spinner. The position is encoded with one of the following characters: v (ASCII code 118, lowercase v), < (ASCII code 60), ^ (ASCII code 94) or > (ASCII code 62) (see the picture above for reference). Characters are separated by a single space.
In the second strings, a single number n is given (0 ≤ n ≤ 109) – the duration of the rotation.
It is guaranteed that the ending position of a spinner is a result of a n second spin in any of the directions, assuming the given starting position.
Output
Output cw, if the direction is clockwise, ccw – if counter-clockwise, and undefined otherwise.
Examples
Input
^ >
1
Output
cw
Input
< ^
3
Output
ccw
Input
^ v
6
Output
undefined | 2 | 7 | import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;
/**
* Built using CHelper plug-in
* Actual solution is at the top
*
* @author Kunal Raj
*/
public class Main {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
InputReader in = new InputReader(inputStream);
OutputWriter out = new OutputWriter(outputStream);
uselesstoy solver = new uselesstoy();
solver.solve(1, in, out);
out.close();
}
static class uselesstoy {
public void solve(int testNumber, InputReader in, OutputWriter out) {
char s = in.nextCharacter();
char e = in.nextCharacter();
int n = in.nextInt();
int[] a = new int[200];
a[118] = 0;
a[60] = 1;
a[94] = 2;
a[62] = 3;
if (n % 2 == 0) out.println("undefined");
else {
if ((n + a[s]) % 4 == a[e]) out.println("cw");
else out.println("ccw");
}
}
}
static class OutputWriter {
private final PrintWriter writer;
public OutputWriter(OutputStream outputStream) {
writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
}
public OutputWriter(Writer writer) {
this.writer = new PrintWriter(writer);
}
public void print(Object... objects) {
for (int i = 0; i < objects.length; i++) {
if (i != 0) {
writer.print(' ');
}
writer.print(objects[i]);
}
}
public void println(Object... objects) {
print(objects);
writer.println();
}
public void close() {
writer.close();
}
}
static class InputReader {
private InputStream stream;
private byte[] buf = new byte[1024];
private int curChar;
private int numChars;
private InputReader.SpaceCharFilter filter;
public InputReader(InputStream stream) {
this.stream = stream;
}
public int read() {
if (numChars == -1) {
throw new InputMismatchException();
}
if (curChar >= numChars) {
curChar = 0;
try {
numChars = stream.read(buf);
} catch (IOException e) {
throw new InputMismatchException();
}
if (numChars <= 0) {
return -1;
}
}
return buf[curChar++];
}
public int nextInt() {
int c = read();
while (isSpaceChar(c)) {
c = read();
}
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
int res = 0;
do {
if (c < '0' || c > '9') {
throw new InputMismatchException();
}
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
return res * sgn;
}
public boolean isSpaceChar(int c) {
if (filter != null) {
return filter.isSpaceChar(c);
}
return isWhitespace(c);
}
public static boolean isWhitespace(int c) {
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
public char nextCharacter() {
int c = read();
while (isSpaceChar(c)) {
c = read();
}
return (char) c;
}
public interface SpaceCharFilter {
public boolean isSpaceChar(int ch);
}
}
}
| JAVA |
834_A. The Useless Toy | <image>
Walking through the streets of Marshmallow City, Slastyona have spotted some merchants selling a kind of useless toy which is very popular nowadays – caramel spinner! Wanting to join the craze, she has immediately bought the strange contraption.
Spinners in Sweetland have the form of V-shaped pieces of caramel. Each spinner can, well, spin around an invisible magic axis. At a specific point in time, a spinner can take 4 positions shown below (each one rotated 90 degrees relative to the previous, with the fourth one followed by the first one):
<image>
After the spinner was spun, it starts its rotation, which is described by a following algorithm: the spinner maintains its position for a second then majestically switches to the next position in clockwise or counter-clockwise order, depending on the direction the spinner was spun in.
Slastyona managed to have spinner rotating for exactly n seconds. Being fascinated by elegance of the process, she completely forgot the direction the spinner was spun in! Lucky for her, she managed to recall the starting position, and wants to deduct the direction given the information she knows. Help her do this.
Input
There are two characters in the first string – the starting and the ending position of a spinner. The position is encoded with one of the following characters: v (ASCII code 118, lowercase v), < (ASCII code 60), ^ (ASCII code 94) or > (ASCII code 62) (see the picture above for reference). Characters are separated by a single space.
In the second strings, a single number n is given (0 ≤ n ≤ 109) – the duration of the rotation.
It is guaranteed that the ending position of a spinner is a result of a n second spin in any of the directions, assuming the given starting position.
Output
Output cw, if the direction is clockwise, ccw – if counter-clockwise, and undefined otherwise.
Examples
Input
^ >
1
Output
cw
Input
< ^
3
Output
ccw
Input
^ v
6
Output
undefined | 2 | 7 |
s, e = input().split()
n = int(input()) % 4
directions = ['^', '>', 'v', '<']
def find(x):
for idx, i in enumerate(directions):
if i == x:
return idx
if n % 2 == 0:
print('undefined')
else:
start_idx = find(s)
if directions[(start_idx + n) % 4] == e:
print('cw')
else:
print('ccw')
| PYTHON3 |
834_A. The Useless Toy | <image>
Walking through the streets of Marshmallow City, Slastyona have spotted some merchants selling a kind of useless toy which is very popular nowadays – caramel spinner! Wanting to join the craze, she has immediately bought the strange contraption.
Spinners in Sweetland have the form of V-shaped pieces of caramel. Each spinner can, well, spin around an invisible magic axis. At a specific point in time, a spinner can take 4 positions shown below (each one rotated 90 degrees relative to the previous, with the fourth one followed by the first one):
<image>
After the spinner was spun, it starts its rotation, which is described by a following algorithm: the spinner maintains its position for a second then majestically switches to the next position in clockwise or counter-clockwise order, depending on the direction the spinner was spun in.
Slastyona managed to have spinner rotating for exactly n seconds. Being fascinated by elegance of the process, she completely forgot the direction the spinner was spun in! Lucky for her, she managed to recall the starting position, and wants to deduct the direction given the information she knows. Help her do this.
Input
There are two characters in the first string – the starting and the ending position of a spinner. The position is encoded with one of the following characters: v (ASCII code 118, lowercase v), < (ASCII code 60), ^ (ASCII code 94) or > (ASCII code 62) (see the picture above for reference). Characters are separated by a single space.
In the second strings, a single number n is given (0 ≤ n ≤ 109) – the duration of the rotation.
It is guaranteed that the ending position of a spinner is a result of a n second spin in any of the directions, assuming the given starting position.
Output
Output cw, if the direction is clockwise, ccw – if counter-clockwise, and undefined otherwise.
Examples
Input
^ >
1
Output
cw
Input
< ^
3
Output
ccw
Input
^ v
6
Output
undefined | 2 | 7 | #include <bits/stdc++.h>
using namespace std;
int fix(char x) {
if (x == '^') return 0;
if (x == '>') return 1;
if (x == 'v') return 2;
return 3;
}
int main() {
char ch1, ch2;
int n;
cin >> ch1 >> ch2 >> n;
int res = ((fix(ch2) - fix(ch1)) % 4 + 4) % 4;
if (res % 2 == 0)
cout << "undefined" << endl;
else if (n % 4 == res)
cout << "cw" << endl;
else
cout << "ccw" << endl;
return 0;
}
| CPP |
834_A. The Useless Toy | <image>
Walking through the streets of Marshmallow City, Slastyona have spotted some merchants selling a kind of useless toy which is very popular nowadays – caramel spinner! Wanting to join the craze, she has immediately bought the strange contraption.
Spinners in Sweetland have the form of V-shaped pieces of caramel. Each spinner can, well, spin around an invisible magic axis. At a specific point in time, a spinner can take 4 positions shown below (each one rotated 90 degrees relative to the previous, with the fourth one followed by the first one):
<image>
After the spinner was spun, it starts its rotation, which is described by a following algorithm: the spinner maintains its position for a second then majestically switches to the next position in clockwise or counter-clockwise order, depending on the direction the spinner was spun in.
Slastyona managed to have spinner rotating for exactly n seconds. Being fascinated by elegance of the process, she completely forgot the direction the spinner was spun in! Lucky for her, she managed to recall the starting position, and wants to deduct the direction given the information she knows. Help her do this.
Input
There are two characters in the first string – the starting and the ending position of a spinner. The position is encoded with one of the following characters: v (ASCII code 118, lowercase v), < (ASCII code 60), ^ (ASCII code 94) or > (ASCII code 62) (see the picture above for reference). Characters are separated by a single space.
In the second strings, a single number n is given (0 ≤ n ≤ 109) – the duration of the rotation.
It is guaranteed that the ending position of a spinner is a result of a n second spin in any of the directions, assuming the given starting position.
Output
Output cw, if the direction is clockwise, ccw – if counter-clockwise, and undefined otherwise.
Examples
Input
^ >
1
Output
cw
Input
< ^
3
Output
ccw
Input
^ v
6
Output
undefined | 2 | 7 | # Enter your code here. Read input from STDIN. Print output to STDOUT
s=str(raw_input()).split()
n=input()
s1=s[0]
s2=s[1]
a=ord(s1)
b=ord(s2)
l=[118,60,94,62]
if 1:
i=0
while i<4:
if l[i]==a:
break
i+=1
j=0
while j<4:
if l[j]==b:
break
j+=1
p,q=0,0
#print i,j,a,b
if n%4==1:
if j-i==1 or j-i==-3:
p=1
if i-j==1 or i-j==-3:
q=1
if p and q:
print "undefined"
elif p:
print 'cw'
else:
print 'ccw'
elif n%4==2:
if j-i==2 or j-i==-2:
p=1
if i-j==2 or i-j==-2:
q=1
if p and q:
print "undefined"
elif p:
print 'cw'
else:
print 'ccw'
elif n%4==3:
if j-i==3 or j-i==-1:
p=1
if i-j==3 or i-j==-1:
q=1
if p and q:
print "undefined"
elif p:
print 'cw'
else:
print 'ccw'
else:
print "undefined" | PYTHON |
834_A. The Useless Toy | <image>
Walking through the streets of Marshmallow City, Slastyona have spotted some merchants selling a kind of useless toy which is very popular nowadays – caramel spinner! Wanting to join the craze, she has immediately bought the strange contraption.
Spinners in Sweetland have the form of V-shaped pieces of caramel. Each spinner can, well, spin around an invisible magic axis. At a specific point in time, a spinner can take 4 positions shown below (each one rotated 90 degrees relative to the previous, with the fourth one followed by the first one):
<image>
After the spinner was spun, it starts its rotation, which is described by a following algorithm: the spinner maintains its position for a second then majestically switches to the next position in clockwise or counter-clockwise order, depending on the direction the spinner was spun in.
Slastyona managed to have spinner rotating for exactly n seconds. Being fascinated by elegance of the process, she completely forgot the direction the spinner was spun in! Lucky for her, she managed to recall the starting position, and wants to deduct the direction given the information she knows. Help her do this.
Input
There are two characters in the first string – the starting and the ending position of a spinner. The position is encoded with one of the following characters: v (ASCII code 118, lowercase v), < (ASCII code 60), ^ (ASCII code 94) or > (ASCII code 62) (see the picture above for reference). Characters are separated by a single space.
In the second strings, a single number n is given (0 ≤ n ≤ 109) – the duration of the rotation.
It is guaranteed that the ending position of a spinner is a result of a n second spin in any of the directions, assuming the given starting position.
Output
Output cw, if the direction is clockwise, ccw – if counter-clockwise, and undefined otherwise.
Examples
Input
^ >
1
Output
cw
Input
< ^
3
Output
ccw
Input
^ v
6
Output
undefined | 2 | 7 | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class UselessToys {
public static void main(String[] args) throws IOException {
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
String[] p = in.readLine().split(" ");
int n = Integer.parseInt(in.readLine());
char a = p[0].charAt(0);
char b = p[1].charAt(0);
int aa = 0;
int bb = 0;
if(a=='^') {
aa = 1;
} else if(a == '>') {
aa = 2;
} else if(a == 'v') {
aa = 3;
} else {
aa = 4;
}
if(b=='^') {
bb = 1;
} else if(b == '>') {
bb = 2;
} else if(b == 'v') {
bb = 3;
} else {
bb = 4;
}
n = n % 4;
int x = Math.abs(aa-bb);
if(x % 2 == 0) {
System.out.println("undefined");
} else {
if(bb > aa) {
if(bb -aa == n) {
System.out.println("cw");
} else {
System.out.println("ccw");
}
} else {
if(aa - bb == n) {
System.out.println("ccw");
} else {
System.out.println("cw");
}
}
}
}
}
| JAVA |
834_A. The Useless Toy | <image>
Walking through the streets of Marshmallow City, Slastyona have spotted some merchants selling a kind of useless toy which is very popular nowadays – caramel spinner! Wanting to join the craze, she has immediately bought the strange contraption.
Spinners in Sweetland have the form of V-shaped pieces of caramel. Each spinner can, well, spin around an invisible magic axis. At a specific point in time, a spinner can take 4 positions shown below (each one rotated 90 degrees relative to the previous, with the fourth one followed by the first one):
<image>
After the spinner was spun, it starts its rotation, which is described by a following algorithm: the spinner maintains its position for a second then majestically switches to the next position in clockwise or counter-clockwise order, depending on the direction the spinner was spun in.
Slastyona managed to have spinner rotating for exactly n seconds. Being fascinated by elegance of the process, she completely forgot the direction the spinner was spun in! Lucky for her, she managed to recall the starting position, and wants to deduct the direction given the information she knows. Help her do this.
Input
There are two characters in the first string – the starting and the ending position of a spinner. The position is encoded with one of the following characters: v (ASCII code 118, lowercase v), < (ASCII code 60), ^ (ASCII code 94) or > (ASCII code 62) (see the picture above for reference). Characters are separated by a single space.
In the second strings, a single number n is given (0 ≤ n ≤ 109) – the duration of the rotation.
It is guaranteed that the ending position of a spinner is a result of a n second spin in any of the directions, assuming the given starting position.
Output
Output cw, if the direction is clockwise, ccw – if counter-clockwise, and undefined otherwise.
Examples
Input
^ >
1
Output
cw
Input
< ^
3
Output
ccw
Input
^ v
6
Output
undefined | 2 | 7 | l = ["^",">","v","<"]
a,b = raw_input().split(' ')
c = int(raw_input())%4
if (l.index(a)-l.index(b)+4)%4 == (c)%4 and (l.index(a)-l.index(b)+4)%4 != (4-c)%4:
print "ccw"
elif (l.index(a)-l.index(b)+4)%4 == (4-c)%4 and (l.index(a)-l.index(b)+4)%4 != c%4:
print "cw"
else:
print "undefined" | PYTHON |
834_A. The Useless Toy | <image>
Walking through the streets of Marshmallow City, Slastyona have spotted some merchants selling a kind of useless toy which is very popular nowadays – caramel spinner! Wanting to join the craze, she has immediately bought the strange contraption.
Spinners in Sweetland have the form of V-shaped pieces of caramel. Each spinner can, well, spin around an invisible magic axis. At a specific point in time, a spinner can take 4 positions shown below (each one rotated 90 degrees relative to the previous, with the fourth one followed by the first one):
<image>
After the spinner was spun, it starts its rotation, which is described by a following algorithm: the spinner maintains its position for a second then majestically switches to the next position in clockwise or counter-clockwise order, depending on the direction the spinner was spun in.
Slastyona managed to have spinner rotating for exactly n seconds. Being fascinated by elegance of the process, she completely forgot the direction the spinner was spun in! Lucky for her, she managed to recall the starting position, and wants to deduct the direction given the information she knows. Help her do this.
Input
There are two characters in the first string – the starting and the ending position of a spinner. The position is encoded with one of the following characters: v (ASCII code 118, lowercase v), < (ASCII code 60), ^ (ASCII code 94) or > (ASCII code 62) (see the picture above for reference). Characters are separated by a single space.
In the second strings, a single number n is given (0 ≤ n ≤ 109) – the duration of the rotation.
It is guaranteed that the ending position of a spinner is a result of a n second spin in any of the directions, assuming the given starting position.
Output
Output cw, if the direction is clockwise, ccw – if counter-clockwise, and undefined otherwise.
Examples
Input
^ >
1
Output
cw
Input
< ^
3
Output
ccw
Input
^ v
6
Output
undefined | 2 | 7 | #include <bits/stdc++.h>
int main() {
char a, b;
int n;
scanf("%c %c", &a, &b);
scanf("%d", &n);
n = n % 4;
if (a == 'v' && b == '<') {
if (n == 1)
printf("cw\n");
else if (n == 3)
printf("ccw\n");
else
printf("undefined\n");
} else if (a == '<' && b == 'v') {
if (n == 3)
printf("cw\n");
else if (n == 1)
printf("ccw\n");
else
printf("undefined\n");
} else if (a == 'v' && b == '^') {
printf("undefined\n");
} else if (a == '^' && b == 'v') {
printf("undefined\n");
} else if (a == 'v' && b == '>') {
if (n == 3)
printf("cw\n");
else if (n == 1)
printf("ccw\n");
else
printf("undefined\n");
} else if (a == '>' && b == 'v') {
if (n == 1)
printf("cw\n");
else if (n == 3)
printf("ccw\n");
else
printf("undefined\n");
} else if (a == '>' && b == '<') {
printf("undefined\n");
} else if (a == '<' && b == '>') {
printf("undefined\n");
} else if (a == '^' && b == '>') {
if (n == 1)
printf("cw\n");
else if (n == 3)
printf("ccw\n");
else
printf("undefined\n");
} else if (a == '>' && b == '^') {
if (n == 1)
printf("ccw\n");
else if (n == 3)
printf("cw\n");
else
printf("undefined\n");
} else if (a == '^' && b == '<') {
if (n == 1)
printf("ccw\n");
else if (n == 3)
printf("cw\n");
else
printf("undefined\n");
} else if (a == '<' && b == '^') {
if (n == 1)
printf("cw\n");
else if (n == 3)
printf("ccw\n");
else
printf("undefined\n");
} else if (a == 'v' && b == 'v') {
printf("undefined\n");
} else if (a == '^' && b == '^') {
printf("undefined\n");
} else if (a == '>' && b == '>') {
printf("undefined\n");
} else if (a == '<' && b == '<') {
printf("undefined\n");
}
return 0;
}
| CPP |
834_A. The Useless Toy | <image>
Walking through the streets of Marshmallow City, Slastyona have spotted some merchants selling a kind of useless toy which is very popular nowadays – caramel spinner! Wanting to join the craze, she has immediately bought the strange contraption.
Spinners in Sweetland have the form of V-shaped pieces of caramel. Each spinner can, well, spin around an invisible magic axis. At a specific point in time, a spinner can take 4 positions shown below (each one rotated 90 degrees relative to the previous, with the fourth one followed by the first one):
<image>
After the spinner was spun, it starts its rotation, which is described by a following algorithm: the spinner maintains its position for a second then majestically switches to the next position in clockwise or counter-clockwise order, depending on the direction the spinner was spun in.
Slastyona managed to have spinner rotating for exactly n seconds. Being fascinated by elegance of the process, she completely forgot the direction the spinner was spun in! Lucky for her, she managed to recall the starting position, and wants to deduct the direction given the information she knows. Help her do this.
Input
There are two characters in the first string – the starting and the ending position of a spinner. The position is encoded with one of the following characters: v (ASCII code 118, lowercase v), < (ASCII code 60), ^ (ASCII code 94) or > (ASCII code 62) (see the picture above for reference). Characters are separated by a single space.
In the second strings, a single number n is given (0 ≤ n ≤ 109) – the duration of the rotation.
It is guaranteed that the ending position of a spinner is a result of a n second spin in any of the directions, assuming the given starting position.
Output
Output cw, if the direction is clockwise, ccw – if counter-clockwise, and undefined otherwise.
Examples
Input
^ >
1
Output
cw
Input
< ^
3
Output
ccw
Input
^ v
6
Output
undefined | 2 | 7 | #include <bits/stdc++.h>
using namespace std;
int n;
int main() {
int a[150];
a[118] = 1;
a[60] = 2;
a[94] = 3;
a[62] = 4;
char s, e;
cin >> s >> e;
cin >> n;
int b = (a[s] + n - 1) % 4 + 1;
int c = (a[s] - n + 1000000000 - 1) % 4 + 1;
if (b == a[e] && c != a[e]) {
cout << "cw" << endl;
return 0;
}
if (c == a[e] && b != a[e]) {
cout << "ccw" << endl;
return 0;
}
cout << "undefined" << endl;
return 0;
}
| CPP |
834_A. The Useless Toy | <image>
Walking through the streets of Marshmallow City, Slastyona have spotted some merchants selling a kind of useless toy which is very popular nowadays – caramel spinner! Wanting to join the craze, she has immediately bought the strange contraption.
Spinners in Sweetland have the form of V-shaped pieces of caramel. Each spinner can, well, spin around an invisible magic axis. At a specific point in time, a spinner can take 4 positions shown below (each one rotated 90 degrees relative to the previous, with the fourth one followed by the first one):
<image>
After the spinner was spun, it starts its rotation, which is described by a following algorithm: the spinner maintains its position for a second then majestically switches to the next position in clockwise or counter-clockwise order, depending on the direction the spinner was spun in.
Slastyona managed to have spinner rotating for exactly n seconds. Being fascinated by elegance of the process, she completely forgot the direction the spinner was spun in! Lucky for her, she managed to recall the starting position, and wants to deduct the direction given the information she knows. Help her do this.
Input
There are two characters in the first string – the starting and the ending position of a spinner. The position is encoded with one of the following characters: v (ASCII code 118, lowercase v), < (ASCII code 60), ^ (ASCII code 94) or > (ASCII code 62) (see the picture above for reference). Characters are separated by a single space.
In the second strings, a single number n is given (0 ≤ n ≤ 109) – the duration of the rotation.
It is guaranteed that the ending position of a spinner is a result of a n second spin in any of the directions, assuming the given starting position.
Output
Output cw, if the direction is clockwise, ccw – if counter-clockwise, and undefined otherwise.
Examples
Input
^ >
1
Output
cw
Input
< ^
3
Output
ccw
Input
^ v
6
Output
undefined | 2 | 7 | daf1 = ['^', '>', 'v', '<']
a, b = map(str, input().split())
n = int(input())
n = n%4
if n%2 == 0:
print('undefined')
else:
pos1 = daf1.index(a)
posf = (pos1 + n)%4
fin = daf1[posf]
if fin == b:
print('cw')
else:
print('ccw') | PYTHON3 |
834_A. The Useless Toy | <image>
Walking through the streets of Marshmallow City, Slastyona have spotted some merchants selling a kind of useless toy which is very popular nowadays – caramel spinner! Wanting to join the craze, she has immediately bought the strange contraption.
Spinners in Sweetland have the form of V-shaped pieces of caramel. Each spinner can, well, spin around an invisible magic axis. At a specific point in time, a spinner can take 4 positions shown below (each one rotated 90 degrees relative to the previous, with the fourth one followed by the first one):
<image>
After the spinner was spun, it starts its rotation, which is described by a following algorithm: the spinner maintains its position for a second then majestically switches to the next position in clockwise or counter-clockwise order, depending on the direction the spinner was spun in.
Slastyona managed to have spinner rotating for exactly n seconds. Being fascinated by elegance of the process, she completely forgot the direction the spinner was spun in! Lucky for her, she managed to recall the starting position, and wants to deduct the direction given the information she knows. Help her do this.
Input
There are two characters in the first string – the starting and the ending position of a spinner. The position is encoded with one of the following characters: v (ASCII code 118, lowercase v), < (ASCII code 60), ^ (ASCII code 94) or > (ASCII code 62) (see the picture above for reference). Characters are separated by a single space.
In the second strings, a single number n is given (0 ≤ n ≤ 109) – the duration of the rotation.
It is guaranteed that the ending position of a spinner is a result of a n second spin in any of the directions, assuming the given starting position.
Output
Output cw, if the direction is clockwise, ccw – if counter-clockwise, and undefined otherwise.
Examples
Input
^ >
1
Output
cw
Input
< ^
3
Output
ccw
Input
^ v
6
Output
undefined | 2 | 7 | import java.io.File;import java.io.FileInputStream;import java.io.FileNotFoundException;
import java.io.IOException;import java.io.PrintStream;import java.io.PrintWriter;
import java.security.AccessControlException;import java.util.Arrays;import java.util.Collection;
import java.util.Comparator;import java.util.List;import java.util.Map;import java.util.Objects;
import java.util.Scanner;import java.util.TreeMap;import java.util.function.Function;
import java.util.stream.Collectors;import java.util.stream.IntStream;import java.util.stream.LongStream;
import java.util.stream.Stream;public class _p000834A {static public void main(final String[] args)
throws IOException{p000834A._main(args);}
static private class p000834A extends Solver{public p000834A(){nameIn="in/900/p000834A.in"
;singleTest=true;}@Override public void solve()throws IOException{String[]v=lineToArray
();int n=sc.nextInt();if(sc.hasNextLine()){sc.nextLine();}String res="undefined"
;String templ="<^v ^>< >v^ v<>";if(n%2!=0){for(int i=0;i<templ.length();i+=4){if
(v[0].equals(templ.substring(i,i+1))){res=v[1].equals(templ.substring(n%4==1?i+1
:i+2,n%4==1?i+2:i+3))?"cw":"ccw";break;}}}pw.println(res);}static public void _main
(String[]args)throws IOException{new p000834A().run();}}static private class Pair
<K,V>{private K k;private V v;public Pair(final K t,final V u){this.k=t;this.v=u
;}public K getKey(){return k;}public V getValue(){return v;}}static private abstract class
Solver{protected String nameIn=null;protected String nameOut=null;protected boolean
singleTest=false;protected boolean preprocessDebug=false;protected boolean doNotPreprocess
=false;protected PrintStream debugPrintStream=null;protected Scanner sc=null;protected
PrintWriter pw=null;final static String SPACE=" ";final static String SPACES="\\s+"
;private void process()throws IOException{if(!singleTest){int t=lineToIntArray()
[0];while(t-->0){solve();}}else{solve();}}abstract protected void solve()throws
IOException;protected String[]lineToArray()throws IOException{return sc.nextLine
().trim().split(SPACES);}protected int[]lineToIntArray()throws IOException{return
Arrays.stream(lineToArray()).mapToInt(Integer::valueOf).toArray();}protected long
[]lineToLongArray()throws IOException{return Arrays.stream(lineToArray()).mapToLong
(Long::valueOf).toArray();}protected void run()throws IOException{boolean done=false
;try{if(nameIn!=null && new File(nameIn).exists()){try(FileInputStream fis=new FileInputStream
(nameIn);PrintWriter pw0=select_output();){done=true;sc=new Scanner(fis);pw=pw0;
process();}}}catch(IOException ex){}catch(AccessControlException ex){}if(!done){
try(PrintWriter pw0=select_output();){sc=new Scanner(System.in);pw=pw0;process()
;}}}private PrintWriter select_output()throws FileNotFoundException{if(nameOut!=
null){return new PrintWriter(nameOut);}return new PrintWriter(System.out);}public
static Map<Integer,List<Integer>>mapi(final int[]a){return IntStream.range(0,a.
length).collect(()->new TreeMap<Integer,List<Integer>>(),(res,i)->{if(!res.containsKey
(a[i])){res.put(a[i],Stream.of(i).collect(Collectors.toList()));}else{res.get(a[
i]).add(i);}},Map::putAll);}public static Map<Long,List<Integer>>mapi(final long
[]a){return IntStream.range(0,a.length).collect(()->new TreeMap<Long,List<Integer
>>(),(res,i)->{if(!res.containsKey(a[i])){res.put(a[i],Stream.of(i).collect(Collectors
.toList()));}else{res.get(a[i]).add(i);}},Map::putAll);}public static<T>Map<T,List
<Integer>>mapi(final T[]a){return IntStream.range(0,a.length).collect(()->new TreeMap
<T,List<Integer>>(),(res,i)->{if(!res.containsKey(a[i])){res.put(a[i],Stream.of(
i).collect(Collectors.toList()));}else{res.get(a[i]).add(i);}},Map::putAll);}public
static<T>Map<T,List<Integer>>mapi(final T[]a,Comparator<T>cmp){return IntStream
.range(0,a.length).collect(()->new TreeMap<T,List<Integer>>(cmp),(res,i)->{if(!res
.containsKey(a[i])){res.put(a[i],Stream.of(i).collect(Collectors.toList()));}else
{res.get(a[i]).add(i);}},Map::putAll);}public static Map<Integer,List<Integer>>mapi
(final IntStream a){int[]i=new int[]{0};return a.collect(()->new TreeMap<Integer
,List<Integer>>(),(res,v)->{if(!res.containsKey(v)){res.put(v,Stream.of(i[0]).collect
(Collectors.toList()));}else{res.get(v).add(i[0]);}i[0]++;},Map::putAll);}public
static Map<Long,List<Integer>>mapi(final LongStream a){int[]i=new int[]{0};return
a.collect(()->new TreeMap<Long,List<Integer>>(),(res,v)->{if(!res.containsKey(v
)){res.put(v,Stream.of(i[0]).collect(Collectors.toList()));}else{res.get(v).add(
i[0]);}i[0]++;},Map::putAll);}public static<T>Map<T,List<Integer>>mapi(final Stream
<T>a,Comparator<T>cmp){int[]i=new int[]{0};return a.collect(()->new TreeMap<T,List
<Integer>>(cmp),(res,v)->{if(!res.containsKey(v)){res.put(v,Stream.of(i[0]).collect
(Collectors.toList()));}else{res.get(v).add(i[0]);}},Map::putAll);}public static
<T>Map<T,List<Integer>>mapi(final Stream<T>a){int[]i=new int[]{0};return a.collect
(()->new TreeMap<T,List<Integer>>(),(res,v)->{if(!res.containsKey(v)){res.put(v,
Stream.of(i[0]).collect(Collectors.toList()));}else{res.get(v).add(i[0]);}},Map::
putAll);}public static List<int[]>listi(final int[]a){return IntStream.range(0,a
.length).mapToObj(i->new int[]{a[i],i}).collect(Collectors.toList());}public static
List<long[]>listi(final long[]a){return IntStream.range(0,a.length).mapToObj(i->
new long[]{a[i],i}).collect(Collectors.toList());}public static<T>List<Pair<T,Integer
>>listi(final T[]a){return IntStream.range(0,a.length).mapToObj(i->new Pair<T,Integer
>(a[i],i)).collect(Collectors.toList());}public static List<int[]>listi(final IntStream
a){int[]i=new int[]{0};return a.mapToObj(v->new int[]{v,i[0]++}).collect(Collectors
.toList());}public static List<long[]>listi(final LongStream a){int[]i=new int[]
{0};return a.mapToObj(v->new long[]{v,i[0]++}).collect(Collectors.toList());}public
static<T>List<Pair<T,Integer>>listi(final Stream<T>a){int[]i=new int[]{0};return
a.map(v->new Pair<T,Integer>(v,i[0]++)).collect(Collectors.toList());}public static
String join(final int[]a){return Arrays.stream(a).mapToObj(Integer::toString).collect
(Collectors.joining(SPACE));}public static String join(final long[]a){return Arrays
.stream(a).mapToObj(Long::toString).collect(Collectors.joining(SPACE));}public static
<T>String join(final T[]a){return Arrays.stream(a).map(v->Objects.toString(v)).collect
(Collectors.joining(SPACE));}public static<T>String join(final T[]a,final Function
<T,String>toString){return Arrays.stream(a).map(v->toString.apply(v)).collect(Collectors
.joining(SPACE));}public static<T>String join(final Collection<T>a){return a.stream
().map(v->Objects.toString(v)).collect(Collectors.joining(SPACE));}public static
<T>String join(final Collection<T>a,final Function<T,String>toString){return a.stream
().map(v->toString.apply(v)).collect(Collectors.joining(SPACE));}public static<T
>String join(final Stream<T>a){return a.map(v->Objects.toString(v)).collect(Collectors
.joining(SPACE));}public static<T>String join(final Stream<T>a,final Function<T,
String>toString){return a.map(v->toString.apply(v)).collect(Collectors.joining(SPACE
));}public static<T>String join(final IntStream a){return a.mapToObj(Integer::toString
).collect(Collectors.joining(SPACE));}public static<T>String join(final LongStream
a){return a.mapToObj(Long::toString).collect(Collectors.joining(SPACE));}public
static List<Integer>list(final int[]a){return Arrays.stream(a).mapToObj(Integer
::valueOf).collect(Collectors.toList());}public static List<Integer>list(final IntStream
a){return a.mapToObj(Integer::valueOf).collect(Collectors.toList());}public static
List<Long>list(final long[]a){return Arrays.stream(a).mapToObj(Long::valueOf).collect
(Collectors.toList());}public static List<Long>list(final LongStream a){return a
.mapToObj(Long::valueOf).collect(Collectors.toList());}public static<T>List<T>list
(final Stream<T>a){return a.collect(Collectors.toList());}public static<T>List<T
>list(final T[]a){return Arrays.stream(a).collect(Collectors.toList());}}}
| JAVA |
834_A. The Useless Toy | <image>
Walking through the streets of Marshmallow City, Slastyona have spotted some merchants selling a kind of useless toy which is very popular nowadays – caramel spinner! Wanting to join the craze, she has immediately bought the strange contraption.
Spinners in Sweetland have the form of V-shaped pieces of caramel. Each spinner can, well, spin around an invisible magic axis. At a specific point in time, a spinner can take 4 positions shown below (each one rotated 90 degrees relative to the previous, with the fourth one followed by the first one):
<image>
After the spinner was spun, it starts its rotation, which is described by a following algorithm: the spinner maintains its position for a second then majestically switches to the next position in clockwise or counter-clockwise order, depending on the direction the spinner was spun in.
Slastyona managed to have spinner rotating for exactly n seconds. Being fascinated by elegance of the process, she completely forgot the direction the spinner was spun in! Lucky for her, she managed to recall the starting position, and wants to deduct the direction given the information she knows. Help her do this.
Input
There are two characters in the first string – the starting and the ending position of a spinner. The position is encoded with one of the following characters: v (ASCII code 118, lowercase v), < (ASCII code 60), ^ (ASCII code 94) or > (ASCII code 62) (see the picture above for reference). Characters are separated by a single space.
In the second strings, a single number n is given (0 ≤ n ≤ 109) – the duration of the rotation.
It is guaranteed that the ending position of a spinner is a result of a n second spin in any of the directions, assuming the given starting position.
Output
Output cw, if the direction is clockwise, ccw – if counter-clockwise, and undefined otherwise.
Examples
Input
^ >
1
Output
cw
Input
< ^
3
Output
ccw
Input
^ v
6
Output
undefined | 2 | 7 | def main():
a, b = ("v<^>".index(c) for c in input()[::2])
n = int(input())
print(("cw", "ccw")[not (n - a + b) % 4] if n % 2 else "undefined")
if __name__ == '__main__':
main()
| PYTHON3 |
834_A. The Useless Toy | <image>
Walking through the streets of Marshmallow City, Slastyona have spotted some merchants selling a kind of useless toy which is very popular nowadays – caramel spinner! Wanting to join the craze, she has immediately bought the strange contraption.
Spinners in Sweetland have the form of V-shaped pieces of caramel. Each spinner can, well, spin around an invisible magic axis. At a specific point in time, a spinner can take 4 positions shown below (each one rotated 90 degrees relative to the previous, with the fourth one followed by the first one):
<image>
After the spinner was spun, it starts its rotation, which is described by a following algorithm: the spinner maintains its position for a second then majestically switches to the next position in clockwise or counter-clockwise order, depending on the direction the spinner was spun in.
Slastyona managed to have spinner rotating for exactly n seconds. Being fascinated by elegance of the process, she completely forgot the direction the spinner was spun in! Lucky for her, she managed to recall the starting position, and wants to deduct the direction given the information she knows. Help her do this.
Input
There are two characters in the first string – the starting and the ending position of a spinner. The position is encoded with one of the following characters: v (ASCII code 118, lowercase v), < (ASCII code 60), ^ (ASCII code 94) or > (ASCII code 62) (see the picture above for reference). Characters are separated by a single space.
In the second strings, a single number n is given (0 ≤ n ≤ 109) – the duration of the rotation.
It is guaranteed that the ending position of a spinner is a result of a n second spin in any of the directions, assuming the given starting position.
Output
Output cw, if the direction is clockwise, ccw – if counter-clockwise, and undefined otherwise.
Examples
Input
^ >
1
Output
cw
Input
< ^
3
Output
ccw
Input
^ v
6
Output
undefined | 2 | 7 |
import java.util.Scanner;
public class First {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
String[] shape = new String[2];
for (int i = 0; i < shape.length; i++)
shape[i]=input.next();
int num = input.nextInt();
String[] s = new String[4];
s[0]="v";
s[1]="<";
s[2]="^";
s[3]=">";
int j = 0;
for (; j < s.length; j++) {
if(s[j].equals(shape[0]))
break;
}
num%=4;
String targetR = "";
for (int i = 1; i <=num; i++) {
if(j+i>3){
targetR=s[j+i-4];
}
else
targetR=s[j+i];
}
String targetL="";
for (int i = 1; i <=num; i++) {
if(j-i<0){
targetL=s[j-i+4];
}
else
targetL=s[j-i];
}
if(targetR.equals(shape[1])&&targetL.equals(shape[1]))
System.out.println("undefined");
else if(targetR.equals(shape[1]))
System.out.println("cw");
else if(targetL.equals(shape[1]))
System.out.println("ccw");
else
System.out.println("undefined");
}
}
| JAVA |
834_A. The Useless Toy | <image>
Walking through the streets of Marshmallow City, Slastyona have spotted some merchants selling a kind of useless toy which is very popular nowadays – caramel spinner! Wanting to join the craze, she has immediately bought the strange contraption.
Spinners in Sweetland have the form of V-shaped pieces of caramel. Each spinner can, well, spin around an invisible magic axis. At a specific point in time, a spinner can take 4 positions shown below (each one rotated 90 degrees relative to the previous, with the fourth one followed by the first one):
<image>
After the spinner was spun, it starts its rotation, which is described by a following algorithm: the spinner maintains its position for a second then majestically switches to the next position in clockwise or counter-clockwise order, depending on the direction the spinner was spun in.
Slastyona managed to have spinner rotating for exactly n seconds. Being fascinated by elegance of the process, she completely forgot the direction the spinner was spun in! Lucky for her, she managed to recall the starting position, and wants to deduct the direction given the information she knows. Help her do this.
Input
There are two characters in the first string – the starting and the ending position of a spinner. The position is encoded with one of the following characters: v (ASCII code 118, lowercase v), < (ASCII code 60), ^ (ASCII code 94) or > (ASCII code 62) (see the picture above for reference). Characters are separated by a single space.
In the second strings, a single number n is given (0 ≤ n ≤ 109) – the duration of the rotation.
It is guaranteed that the ending position of a spinner is a result of a n second spin in any of the directions, assuming the given starting position.
Output
Output cw, if the direction is clockwise, ccw – if counter-clockwise, and undefined otherwise.
Examples
Input
^ >
1
Output
cw
Input
< ^
3
Output
ccw
Input
^ v
6
Output
undefined | 2 | 7 | #include <bits/stdc++.h>
using namespace std;
int main() {
char cw[4] = {'v', '<', '^', '>'};
char ccw[4] = {'v', '>', '^', '<'};
char startc, endc;
int cwspos, cwendpos, ccwspos, ccwendpos;
int n;
cin >> startc >> endc >> n;
for (int i = 0; i < 4; i++) {
if (startc == cw[i]) cwspos = i;
if (endc == cw[i]) cwendpos = i;
if (startc == ccw[i]) ccwspos = i;
if (endc == ccw[i]) ccwendpos = i;
}
int flag1 = 0;
int flag2 = 0;
if ((cwspos + n % 4) % 4 == cwendpos) flag1 = 1;
if ((ccwspos + n % 4) % 4 == ccwendpos) flag2 = 1;
if (flag1 == 1 && flag2 == 0)
cout << "cw" << endl;
else if (flag2 == 1 && flag1 == 0)
cout << "ccw" << endl;
else
cout << "undefined" << endl;
return 0;
}
| CPP |
834_A. The Useless Toy | <image>
Walking through the streets of Marshmallow City, Slastyona have spotted some merchants selling a kind of useless toy which is very popular nowadays – caramel spinner! Wanting to join the craze, she has immediately bought the strange contraption.
Spinners in Sweetland have the form of V-shaped pieces of caramel. Each spinner can, well, spin around an invisible magic axis. At a specific point in time, a spinner can take 4 positions shown below (each one rotated 90 degrees relative to the previous, with the fourth one followed by the first one):
<image>
After the spinner was spun, it starts its rotation, which is described by a following algorithm: the spinner maintains its position for a second then majestically switches to the next position in clockwise or counter-clockwise order, depending on the direction the spinner was spun in.
Slastyona managed to have spinner rotating for exactly n seconds. Being fascinated by elegance of the process, she completely forgot the direction the spinner was spun in! Lucky for her, she managed to recall the starting position, and wants to deduct the direction given the information she knows. Help her do this.
Input
There are two characters in the first string – the starting and the ending position of a spinner. The position is encoded with one of the following characters: v (ASCII code 118, lowercase v), < (ASCII code 60), ^ (ASCII code 94) or > (ASCII code 62) (see the picture above for reference). Characters are separated by a single space.
In the second strings, a single number n is given (0 ≤ n ≤ 109) – the duration of the rotation.
It is guaranteed that the ending position of a spinner is a result of a n second spin in any of the directions, assuming the given starting position.
Output
Output cw, if the direction is clockwise, ccw – if counter-clockwise, and undefined otherwise.
Examples
Input
^ >
1
Output
cw
Input
< ^
3
Output
ccw
Input
^ v
6
Output
undefined | 2 | 7 | import java.util.*;
public final class Solution7{
static String decode(char st, char ls, int num){
String out = "undefined";
// String outc = "";
// String outw = "";
String cw = "v<^>";
String ccw = "v>^<";
boolean an1 = false;
boolean an2 = false;
for (int i=0;i<4;i++) {
if (st == cw.charAt(i)) {
int co = (num+i) %4;
if (ls == cw.charAt(co)) {
out = "cw";
an1 = true;
break;
}
}
}
for (int i=0;i<4;i++) {
if (st == ccw.charAt(i)) {
int co = (num+i) %4;
if (ls == ccw.charAt(co)) {
out = "ccw";
an2 = true;
break;
}
}
}
if (an1 == true && an2 == true) {
out = "undefined";
}
return out;
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String str = sc.nextLine();
int num = sc.nextInt();
char st = str.charAt(0);
char ls = str.charAt(2);
// String str = sc.nextLine();
// if (num > 1) {
System.out.println(decode(st,ls,num));
// } else {
// System.out.println(str);
// }
}
}
| JAVA |
834_A. The Useless Toy | <image>
Walking through the streets of Marshmallow City, Slastyona have spotted some merchants selling a kind of useless toy which is very popular nowadays – caramel spinner! Wanting to join the craze, she has immediately bought the strange contraption.
Spinners in Sweetland have the form of V-shaped pieces of caramel. Each spinner can, well, spin around an invisible magic axis. At a specific point in time, a spinner can take 4 positions shown below (each one rotated 90 degrees relative to the previous, with the fourth one followed by the first one):
<image>
After the spinner was spun, it starts its rotation, which is described by a following algorithm: the spinner maintains its position for a second then majestically switches to the next position in clockwise or counter-clockwise order, depending on the direction the spinner was spun in.
Slastyona managed to have spinner rotating for exactly n seconds. Being fascinated by elegance of the process, she completely forgot the direction the spinner was spun in! Lucky for her, she managed to recall the starting position, and wants to deduct the direction given the information she knows. Help her do this.
Input
There are two characters in the first string – the starting and the ending position of a spinner. The position is encoded with one of the following characters: v (ASCII code 118, lowercase v), < (ASCII code 60), ^ (ASCII code 94) or > (ASCII code 62) (see the picture above for reference). Characters are separated by a single space.
In the second strings, a single number n is given (0 ≤ n ≤ 109) – the duration of the rotation.
It is guaranteed that the ending position of a spinner is a result of a n second spin in any of the directions, assuming the given starting position.
Output
Output cw, if the direction is clockwise, ccw – if counter-clockwise, and undefined otherwise.
Examples
Input
^ >
1
Output
cw
Input
< ^
3
Output
ccw
Input
^ v
6
Output
undefined | 2 | 7 | a='v<^>'
q,w=(str(i) for i in input().split())
k=int(input())%4
a1=a.find(q)
a2=a.find(w)
f1=False
f2=False
f3=False
f4=False
if (a1==a2) and (k==0):
print('undefined')
else:
if a1<=a2:
if abs(a2-a1)==k:
f1=True
if 4-abs(a2-a1)==k:
f2=True
else:
if a1-a2==k:
f3=True
if 4-a1+a2==k:
f4=True
if ((f1) and (f2)) or ((f3) and (f4)):
print('undefined')
elif (f1) or (f4):
print('cw')
elif (f2) or(f3):
print('ccw') | PYTHON3 |
834_A. The Useless Toy | <image>
Walking through the streets of Marshmallow City, Slastyona have spotted some merchants selling a kind of useless toy which is very popular nowadays – caramel spinner! Wanting to join the craze, she has immediately bought the strange contraption.
Spinners in Sweetland have the form of V-shaped pieces of caramel. Each spinner can, well, spin around an invisible magic axis. At a specific point in time, a spinner can take 4 positions shown below (each one rotated 90 degrees relative to the previous, with the fourth one followed by the first one):
<image>
After the spinner was spun, it starts its rotation, which is described by a following algorithm: the spinner maintains its position for a second then majestically switches to the next position in clockwise or counter-clockwise order, depending on the direction the spinner was spun in.
Slastyona managed to have spinner rotating for exactly n seconds. Being fascinated by elegance of the process, she completely forgot the direction the spinner was spun in! Lucky for her, she managed to recall the starting position, and wants to deduct the direction given the information she knows. Help her do this.
Input
There are two characters in the first string – the starting and the ending position of a spinner. The position is encoded with one of the following characters: v (ASCII code 118, lowercase v), < (ASCII code 60), ^ (ASCII code 94) or > (ASCII code 62) (see the picture above for reference). Characters are separated by a single space.
In the second strings, a single number n is given (0 ≤ n ≤ 109) – the duration of the rotation.
It is guaranteed that the ending position of a spinner is a result of a n second spin in any of the directions, assuming the given starting position.
Output
Output cw, if the direction is clockwise, ccw – if counter-clockwise, and undefined otherwise.
Examples
Input
^ >
1
Output
cw
Input
< ^
3
Output
ccw
Input
^ v
6
Output
undefined | 2 | 7 | import math
def ria():
return [int(i) for i in input().split()]
a, b = input().split()
n = ria()[0]
possible = []
st = "^>v<"
if (st[(st.find(a) + n) % 4])==b:
possible.append('cw')
if (st[(st.find(a) - n) % 4])==b:
possible.append('ccw')
if possible.__len__()>1:
print('undefined')
else:
print(possible[0]) | PYTHON3 |
834_A. The Useless Toy | <image>
Walking through the streets of Marshmallow City, Slastyona have spotted some merchants selling a kind of useless toy which is very popular nowadays – caramel spinner! Wanting to join the craze, she has immediately bought the strange contraption.
Spinners in Sweetland have the form of V-shaped pieces of caramel. Each spinner can, well, spin around an invisible magic axis. At a specific point in time, a spinner can take 4 positions shown below (each one rotated 90 degrees relative to the previous, with the fourth one followed by the first one):
<image>
After the spinner was spun, it starts its rotation, which is described by a following algorithm: the spinner maintains its position for a second then majestically switches to the next position in clockwise or counter-clockwise order, depending on the direction the spinner was spun in.
Slastyona managed to have spinner rotating for exactly n seconds. Being fascinated by elegance of the process, she completely forgot the direction the spinner was spun in! Lucky for her, she managed to recall the starting position, and wants to deduct the direction given the information she knows. Help her do this.
Input
There are two characters in the first string – the starting and the ending position of a spinner. The position is encoded with one of the following characters: v (ASCII code 118, lowercase v), < (ASCII code 60), ^ (ASCII code 94) or > (ASCII code 62) (see the picture above for reference). Characters are separated by a single space.
In the second strings, a single number n is given (0 ≤ n ≤ 109) – the duration of the rotation.
It is guaranteed that the ending position of a spinner is a result of a n second spin in any of the directions, assuming the given starting position.
Output
Output cw, if the direction is clockwise, ccw – if counter-clockwise, and undefined otherwise.
Examples
Input
^ >
1
Output
cw
Input
< ^
3
Output
ccw
Input
^ v
6
Output
undefined | 2 | 7 | #include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 1;
const long long INF = 1e18;
const long long mod = 1e9 + 7;
char ch, ch1;
long long n;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> ch >> ch1 >> n;
if (n % 2 == 0) return cout << "undefined", 0;
long long q = n % 4;
char a[]{94, 62, 118, 60};
char b[]{62, 118, 60, 94};
char c[]{118, 60, 94, 62};
char d[]{60, 94, 62, 118};
if ((a[q] == ch1 and a[0] == ch) or (b[q] == ch1 and b[0] == ch) or
(c[q] == ch1 and c[0] == ch) or (d[q] == ch1 and d[0] == ch))
cout << "cw";
else
cout << "ccw";
}
| CPP |
834_A. The Useless Toy | <image>
Walking through the streets of Marshmallow City, Slastyona have spotted some merchants selling a kind of useless toy which is very popular nowadays – caramel spinner! Wanting to join the craze, she has immediately bought the strange contraption.
Spinners in Sweetland have the form of V-shaped pieces of caramel. Each spinner can, well, spin around an invisible magic axis. At a specific point in time, a spinner can take 4 positions shown below (each one rotated 90 degrees relative to the previous, with the fourth one followed by the first one):
<image>
After the spinner was spun, it starts its rotation, which is described by a following algorithm: the spinner maintains its position for a second then majestically switches to the next position in clockwise or counter-clockwise order, depending on the direction the spinner was spun in.
Slastyona managed to have spinner rotating for exactly n seconds. Being fascinated by elegance of the process, she completely forgot the direction the spinner was spun in! Lucky for her, she managed to recall the starting position, and wants to deduct the direction given the information she knows. Help her do this.
Input
There are two characters in the first string – the starting and the ending position of a spinner. The position is encoded with one of the following characters: v (ASCII code 118, lowercase v), < (ASCII code 60), ^ (ASCII code 94) or > (ASCII code 62) (see the picture above for reference). Characters are separated by a single space.
In the second strings, a single number n is given (0 ≤ n ≤ 109) – the duration of the rotation.
It is guaranteed that the ending position of a spinner is a result of a n second spin in any of the directions, assuming the given starting position.
Output
Output cw, if the direction is clockwise, ccw – if counter-clockwise, and undefined otherwise.
Examples
Input
^ >
1
Output
cw
Input
< ^
3
Output
ccw
Input
^ v
6
Output
undefined | 2 | 7 | import java.util.*;
public class Test {
public static void main(String[] args) {
Scanner input=new Scanner(System . in );
char []a={'^','>','v','<'};
char c1=input.next().charAt(0),c2=input.next().charAt(0);
int n=input.nextInt();
if (n%2==0) {
System.out.println("undefined");
}
else{
int k,m;
for ( k = 0; k < 4; k++) {
if (a[k]==c1) {
break;
}
}
m=n%4;
if (m+k>4) {
m=m+k-4;
}
else if (m+k<4) {
m=m+k;
}
else m=0;
if (a[m]==c2) {
System.out.println("cw");
}else System.out.println("ccw");
}
}
}
| JAVA |
834_A. The Useless Toy | <image>
Walking through the streets of Marshmallow City, Slastyona have spotted some merchants selling a kind of useless toy which is very popular nowadays – caramel spinner! Wanting to join the craze, she has immediately bought the strange contraption.
Spinners in Sweetland have the form of V-shaped pieces of caramel. Each spinner can, well, spin around an invisible magic axis. At a specific point in time, a spinner can take 4 positions shown below (each one rotated 90 degrees relative to the previous, with the fourth one followed by the first one):
<image>
After the spinner was spun, it starts its rotation, which is described by a following algorithm: the spinner maintains its position for a second then majestically switches to the next position in clockwise or counter-clockwise order, depending on the direction the spinner was spun in.
Slastyona managed to have spinner rotating for exactly n seconds. Being fascinated by elegance of the process, she completely forgot the direction the spinner was spun in! Lucky for her, she managed to recall the starting position, and wants to deduct the direction given the information she knows. Help her do this.
Input
There are two characters in the first string – the starting and the ending position of a spinner. The position is encoded with one of the following characters: v (ASCII code 118, lowercase v), < (ASCII code 60), ^ (ASCII code 94) or > (ASCII code 62) (see the picture above for reference). Characters are separated by a single space.
In the second strings, a single number n is given (0 ≤ n ≤ 109) – the duration of the rotation.
It is guaranteed that the ending position of a spinner is a result of a n second spin in any of the directions, assuming the given starting position.
Output
Output cw, if the direction is clockwise, ccw – if counter-clockwise, and undefined otherwise.
Examples
Input
^ >
1
Output
cw
Input
< ^
3
Output
ccw
Input
^ v
6
Output
undefined | 2 | 7 | def str_to_int(s):
if s == "^":
return 0
if s == ">":
return 1
if s == "v":
return 2
if s == "<":
return 3
inputlist = list(map(str_to_int, input().strip().split(" ")))
start = inputlist[0]
end = inputlist[1]
duration = int(input())
if (start + duration) % 4 == end and (start - duration) % 4 != end:
print("cw")
elif (start - duration) % 4 == end and (start + duration) % 4 != end:
print("ccw")
else:
print("undefined") | PYTHON3 |
834_A. The Useless Toy | <image>
Walking through the streets of Marshmallow City, Slastyona have spotted some merchants selling a kind of useless toy which is very popular nowadays – caramel spinner! Wanting to join the craze, she has immediately bought the strange contraption.
Spinners in Sweetland have the form of V-shaped pieces of caramel. Each spinner can, well, spin around an invisible magic axis. At a specific point in time, a spinner can take 4 positions shown below (each one rotated 90 degrees relative to the previous, with the fourth one followed by the first one):
<image>
After the spinner was spun, it starts its rotation, which is described by a following algorithm: the spinner maintains its position for a second then majestically switches to the next position in clockwise or counter-clockwise order, depending on the direction the spinner was spun in.
Slastyona managed to have spinner rotating for exactly n seconds. Being fascinated by elegance of the process, she completely forgot the direction the spinner was spun in! Lucky for her, she managed to recall the starting position, and wants to deduct the direction given the information she knows. Help her do this.
Input
There are two characters in the first string – the starting and the ending position of a spinner. The position is encoded with one of the following characters: v (ASCII code 118, lowercase v), < (ASCII code 60), ^ (ASCII code 94) or > (ASCII code 62) (see the picture above for reference). Characters are separated by a single space.
In the second strings, a single number n is given (0 ≤ n ≤ 109) – the duration of the rotation.
It is guaranteed that the ending position of a spinner is a result of a n second spin in any of the directions, assuming the given starting position.
Output
Output cw, if the direction is clockwise, ccw – if counter-clockwise, and undefined otherwise.
Examples
Input
^ >
1
Output
cw
Input
< ^
3
Output
ccw
Input
^ v
6
Output
undefined | 2 | 7 | import java.io.*;
import java.util.*;
import java.lang.*;
public class spin{
public static void main(String[] args) {
char[] spin=new char[4];
spin[0]=118;
spin[1]=60;
spin[2]=94;
spin[3]=62;
FastScanner fi=new FastScanner();
long n;
char[] start=fi.next().toCharArray();
char []end=fi.next().toCharArray();
n=fi.nextInt();
int cw,ccw;
String ans=" ";
int i,j,k,d;
int st,en;
st=en=cw=ccw=0;
for (i=0;i<4 ;i++ )
{
if (start[0]==spin[i]) {
st=i;
}
if (end[0]==spin[i]) {
en=i;
}
}
d=Math.abs(st-en);
if (st < en)
{
if (n>=d && (n-d)%4==0)
{
cw=1;
ans="cw";
}
d=4-d;
if (n>=d &&(n-d)%4==0 )
{
ccw=1;
ans="ccw";
}
}
else
{
if (n>=d && (n-d)%4==0)
{
ccw=1;
ans="ccw";
}
d=4-d;
if (n>=d && (n-d)%4==0)
{
cw=1;
ans="cw";
}
if (st==en && n==0)
{
cw=ccw=1;
}
}
if ((cw==1 && ccw==1) || (cw==0 && ccw==0)) {
ans="undefined";
}
System.out.println(ans);
}
}
class FastScanner
{
BufferedReader br;
StringTokenizer st;
FastScanner()
{
br = new BufferedReader(new InputStreamReader(System.in));
}
public String next()
{
while (st == null || !st.hasMoreTokens())
{
try
{
st = new StringTokenizer(br.readLine());
}
catch (IOException e)
{
e.printStackTrace();
}
}
return st.nextToken();
}
public int nextInt()
{
return Integer.parseInt(next());
}
}
| JAVA |
834_A. The Useless Toy | <image>
Walking through the streets of Marshmallow City, Slastyona have spotted some merchants selling a kind of useless toy which is very popular nowadays – caramel spinner! Wanting to join the craze, she has immediately bought the strange contraption.
Spinners in Sweetland have the form of V-shaped pieces of caramel. Each spinner can, well, spin around an invisible magic axis. At a specific point in time, a spinner can take 4 positions shown below (each one rotated 90 degrees relative to the previous, with the fourth one followed by the first one):
<image>
After the spinner was spun, it starts its rotation, which is described by a following algorithm: the spinner maintains its position for a second then majestically switches to the next position in clockwise or counter-clockwise order, depending on the direction the spinner was spun in.
Slastyona managed to have spinner rotating for exactly n seconds. Being fascinated by elegance of the process, she completely forgot the direction the spinner was spun in! Lucky for her, she managed to recall the starting position, and wants to deduct the direction given the information she knows. Help her do this.
Input
There are two characters in the first string – the starting and the ending position of a spinner. The position is encoded with one of the following characters: v (ASCII code 118, lowercase v), < (ASCII code 60), ^ (ASCII code 94) or > (ASCII code 62) (see the picture above for reference). Characters are separated by a single space.
In the second strings, a single number n is given (0 ≤ n ≤ 109) – the duration of the rotation.
It is guaranteed that the ending position of a spinner is a result of a n second spin in any of the directions, assuming the given starting position.
Output
Output cw, if the direction is clockwise, ccw – if counter-clockwise, and undefined otherwise.
Examples
Input
^ >
1
Output
cw
Input
< ^
3
Output
ccw
Input
^ v
6
Output
undefined | 2 | 7 | import java.util.*;
import java.io.*;
public class Main {
static char[] spin = {'v', '<', '^', '>'};
public static void main(String args[]) {
FastReader in = new FastReader(System.in);
PrintWriter pw = new PrintWriter(System.out);
String s = in.nextLine();
int n = in.nextInt();
int indx = 0;
n %= 4;
if (n % 2 == 0) pw.println("undefined");
else {
for (int i = 0; i < spin.length; i++) {
if (s.charAt(0) == spin[i]) indx = i;
}
pw.println(spin[(indx + n) % 4] == s.charAt(2) ? "cw" : "ccw");
}
pw.close();
}
static void debug(Object... obj) {
System.err.println(Arrays.deepToString(obj));
}
static class FastReader {
InputStream is;
private byte[] inbuf = new byte[1024];
private int lenbuf = 0, ptrbuf = 0;
public FastReader(InputStream is) {
this.is = is;
}
public int readByte() {
if (lenbuf == -1) throw new InputMismatchException();
if (ptrbuf >= lenbuf) {
ptrbuf = 0;
try {
lenbuf = is.read(inbuf);
} catch (IOException e) {
throw new InputMismatchException();
}
if (lenbuf <= 0) return -1;
}
return inbuf[ptrbuf++];
}
public boolean isSpaceChar(int c) {
return !(c >= 33 && c <= 126);
}
private boolean isEndOfLine(int c) {
return c == '\n' || c == '\r' || c == -1;
}
public int skip() {
int b;
while ((b = readByte()) != -1 && isSpaceChar(b)) ;
return b;
}
public String next() {
int b = skip();
StringBuilder sb = new StringBuilder();
while (!(isSpaceChar(b))) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
public String nextLine() {
int c = skip();
StringBuilder sb = new StringBuilder();
while (!isEndOfLine(c)) {
sb.appendCodePoint(c);
c = readByte();
}
return sb.toString();
}
public int nextInt() {
int num = 0, b;
boolean minus = false;
while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-')) ;
if (b == '-') {
minus = true;
b = readByte();
}
while (true) {
if (b >= '0' && b <= '9') {
num = (num << 3) + (num << 1) + (b - '0');
} else {
return minus ? -num : num;
}
b = readByte();
}
}
public long nextLong() {
long num = 0;
int b;
boolean minus = false;
while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-')) ;
if (b == '-') {
minus = true;
b = readByte();
}
while (true) {
if (b >= '0' && b <= '9') {
num = (num << 3) + (num << 1) + (b - '0');
} else {
return minus ? -num : num;
}
b = readByte();
}
}
public double nextDouble() {
return Double.parseDouble(next());
}
public char[] next(int n) {
char[] buf = new char[n];
int b = skip(), p = 0;
while (p < n && !(isSpaceChar(b))) {
buf[p++] = (char) b;
b = readByte();
}
return n == p ? buf : Arrays.copyOf(buf, p);
}
public char readChar() {
return (char) skip();
}
}
}
| JAVA |
834_A. The Useless Toy | <image>
Walking through the streets of Marshmallow City, Slastyona have spotted some merchants selling a kind of useless toy which is very popular nowadays – caramel spinner! Wanting to join the craze, she has immediately bought the strange contraption.
Spinners in Sweetland have the form of V-shaped pieces of caramel. Each spinner can, well, spin around an invisible magic axis. At a specific point in time, a spinner can take 4 positions shown below (each one rotated 90 degrees relative to the previous, with the fourth one followed by the first one):
<image>
After the spinner was spun, it starts its rotation, which is described by a following algorithm: the spinner maintains its position for a second then majestically switches to the next position in clockwise or counter-clockwise order, depending on the direction the spinner was spun in.
Slastyona managed to have spinner rotating for exactly n seconds. Being fascinated by elegance of the process, she completely forgot the direction the spinner was spun in! Lucky for her, she managed to recall the starting position, and wants to deduct the direction given the information she knows. Help her do this.
Input
There are two characters in the first string – the starting and the ending position of a spinner. The position is encoded with one of the following characters: v (ASCII code 118, lowercase v), < (ASCII code 60), ^ (ASCII code 94) or > (ASCII code 62) (see the picture above for reference). Characters are separated by a single space.
In the second strings, a single number n is given (0 ≤ n ≤ 109) – the duration of the rotation.
It is guaranteed that the ending position of a spinner is a result of a n second spin in any of the directions, assuming the given starting position.
Output
Output cw, if the direction is clockwise, ccw – if counter-clockwise, and undefined otherwise.
Examples
Input
^ >
1
Output
cw
Input
< ^
3
Output
ccw
Input
^ v
6
Output
undefined | 2 | 7 | import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintStream;
import java.util.Arrays;
import java.util.Scanner;
public class Main {
Scanner in;
PrintStream out;
String i, c;
int sec;
String posCW[] = new String [] {"^", ">", "v", "<"};
String posCCW[] = new String [] {"^", "<", "v", ">"};
public void run(){
i = in.next();
c = in.next();
sec = in.nextInt();
int cw = (Arrays.asList(posCW).indexOf(i) + sec) % posCW.length;
int ccw = (Arrays.asList(posCCW).indexOf(i) + sec) % posCCW.length;
if (posCW[cw].equals(posCCW[ccw])) {
out.println("undefined");
}else if (posCW[cw].equals(c)){
out.println("cw");
}else{
out.println("ccw");
}
// close _in_ and _out_
in.close();
out.close();
}
public Main(InputStream in, OutputStream out){
this.in = new Scanner(new BufferedInputStream(in));
this.out = new PrintStream(new BufferedOutputStream(out));
}
public static void main(String[] args){
new Main(System.in, System.out).run();
}
} | JAVA |
834_A. The Useless Toy | <image>
Walking through the streets of Marshmallow City, Slastyona have spotted some merchants selling a kind of useless toy which is very popular nowadays – caramel spinner! Wanting to join the craze, she has immediately bought the strange contraption.
Spinners in Sweetland have the form of V-shaped pieces of caramel. Each spinner can, well, spin around an invisible magic axis. At a specific point in time, a spinner can take 4 positions shown below (each one rotated 90 degrees relative to the previous, with the fourth one followed by the first one):
<image>
After the spinner was spun, it starts its rotation, which is described by a following algorithm: the spinner maintains its position for a second then majestically switches to the next position in clockwise or counter-clockwise order, depending on the direction the spinner was spun in.
Slastyona managed to have spinner rotating for exactly n seconds. Being fascinated by elegance of the process, she completely forgot the direction the spinner was spun in! Lucky for her, she managed to recall the starting position, and wants to deduct the direction given the information she knows. Help her do this.
Input
There are two characters in the first string – the starting and the ending position of a spinner. The position is encoded with one of the following characters: v (ASCII code 118, lowercase v), < (ASCII code 60), ^ (ASCII code 94) or > (ASCII code 62) (see the picture above for reference). Characters are separated by a single space.
In the second strings, a single number n is given (0 ≤ n ≤ 109) – the duration of the rotation.
It is guaranteed that the ending position of a spinner is a result of a n second spin in any of the directions, assuming the given starting position.
Output
Output cw, if the direction is clockwise, ccw – if counter-clockwise, and undefined otherwise.
Examples
Input
^ >
1
Output
cw
Input
< ^
3
Output
ccw
Input
^ v
6
Output
undefined | 2 | 7 | #include <bits/stdc++.h>
using namespace std;
int main() {
char v1, v2;
int t, flag1, flag2;
map<char, int> v;
while (cin >> v1 >> v2) {
cin >> t;
t = t % 4;
v['^'] = 0;
v['>'] = 1;
v['v'] = 2;
v['<'] = 3;
bool x = (v[v1] + t) % 4 == v[v2];
bool y = ((v[v1] - t + 4) % 4) == v[v2];
if (x && y)
cout << "undefined" << endl;
else if (x)
cout << "cw" << endl;
else
cout << "ccw" << endl;
}
}
| CPP |
834_A. The Useless Toy | <image>
Walking through the streets of Marshmallow City, Slastyona have spotted some merchants selling a kind of useless toy which is very popular nowadays – caramel spinner! Wanting to join the craze, she has immediately bought the strange contraption.
Spinners in Sweetland have the form of V-shaped pieces of caramel. Each spinner can, well, spin around an invisible magic axis. At a specific point in time, a spinner can take 4 positions shown below (each one rotated 90 degrees relative to the previous, with the fourth one followed by the first one):
<image>
After the spinner was spun, it starts its rotation, which is described by a following algorithm: the spinner maintains its position for a second then majestically switches to the next position in clockwise or counter-clockwise order, depending on the direction the spinner was spun in.
Slastyona managed to have spinner rotating for exactly n seconds. Being fascinated by elegance of the process, she completely forgot the direction the spinner was spun in! Lucky for her, she managed to recall the starting position, and wants to deduct the direction given the information she knows. Help her do this.
Input
There are two characters in the first string – the starting and the ending position of a spinner. The position is encoded with one of the following characters: v (ASCII code 118, lowercase v), < (ASCII code 60), ^ (ASCII code 94) or > (ASCII code 62) (see the picture above for reference). Characters are separated by a single space.
In the second strings, a single number n is given (0 ≤ n ≤ 109) – the duration of the rotation.
It is guaranteed that the ending position of a spinner is a result of a n second spin in any of the directions, assuming the given starting position.
Output
Output cw, if the direction is clockwise, ccw – if counter-clockwise, and undefined otherwise.
Examples
Input
^ >
1
Output
cw
Input
< ^
3
Output
ccw
Input
^ v
6
Output
undefined | 2 | 7 | #include <bits/stdc++.h>
using namespace std;
int main() {
map<char, int> a = {pair<int, int>('^', 0), pair<int, int>('>', 1),
pair<int, int>('v', 2), pair<int, int>('<', 3)};
char st, en;
long n;
cin >> st >> en >> n;
n %= 4;
if ((a[st] + n) % 4 == a[en] && (a[st] - n + 4) % 4 == a[en])
cout << "undefined";
else if ((a[st] + n) % 4 == a[en])
cout << "cw";
else
cout << "ccw";
return 0;
}
| CPP |
834_A. The Useless Toy | <image>
Walking through the streets of Marshmallow City, Slastyona have spotted some merchants selling a kind of useless toy which is very popular nowadays – caramel spinner! Wanting to join the craze, she has immediately bought the strange contraption.
Spinners in Sweetland have the form of V-shaped pieces of caramel. Each spinner can, well, spin around an invisible magic axis. At a specific point in time, a spinner can take 4 positions shown below (each one rotated 90 degrees relative to the previous, with the fourth one followed by the first one):
<image>
After the spinner was spun, it starts its rotation, which is described by a following algorithm: the spinner maintains its position for a second then majestically switches to the next position in clockwise or counter-clockwise order, depending on the direction the spinner was spun in.
Slastyona managed to have spinner rotating for exactly n seconds. Being fascinated by elegance of the process, she completely forgot the direction the spinner was spun in! Lucky for her, she managed to recall the starting position, and wants to deduct the direction given the information she knows. Help her do this.
Input
There are two characters in the first string – the starting and the ending position of a spinner. The position is encoded with one of the following characters: v (ASCII code 118, lowercase v), < (ASCII code 60), ^ (ASCII code 94) or > (ASCII code 62) (see the picture above for reference). Characters are separated by a single space.
In the second strings, a single number n is given (0 ≤ n ≤ 109) – the duration of the rotation.
It is guaranteed that the ending position of a spinner is a result of a n second spin in any of the directions, assuming the given starting position.
Output
Output cw, if the direction is clockwise, ccw – if counter-clockwise, and undefined otherwise.
Examples
Input
^ >
1
Output
cw
Input
< ^
3
Output
ccw
Input
^ v
6
Output
undefined | 2 | 7 | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
public class A {
static class Scanner{
BufferedReader br=null;
StringTokenizer tk=null;
public Scanner(){
br=new BufferedReader(new InputStreamReader(System.in));
}
public String next() throws IOException{
while(tk==null || !tk.hasMoreTokens()) {
String cad = br.readLine();
if (cad == null)
return null;
tk=new StringTokenizer(cad);
}
return tk.nextToken();
}
public int nextInt() throws NumberFormatException, IOException{
return Integer.valueOf(next());
}
public long nextLong() throws NumberFormatException, IOException{
return Long.valueOf(next());
}
public double nextDouble() throws NumberFormatException, IOException{
return Double.valueOf(next());
}
}
static char[] array = {'^', '>', 'v', '<'};
static int getIndex(char c) {
for(int i = 0; i < array.length; i++)
if (array[i] == c)
return i;
return -1;
}
public static void main(String args[]) throws NumberFormatException, IOException {
Scanner sc = new Scanner();
char s = sc.next().charAt(0);
char f = sc.next().charAt(0);
int n = sc.nextInt() % 4;
boolean cw = array[(getIndex(s) + n) % 4] == f;
boolean ccw = array[(getIndex(s) - n + 4) % 4] == f;
if (cw && ccw)
System.out.println("undefined");
else if (cw)
System.out.println("cw");
else if (ccw)
System.out.println("ccw");
}
}
| JAVA |
834_A. The Useless Toy | <image>
Walking through the streets of Marshmallow City, Slastyona have spotted some merchants selling a kind of useless toy which is very popular nowadays – caramel spinner! Wanting to join the craze, she has immediately bought the strange contraption.
Spinners in Sweetland have the form of V-shaped pieces of caramel. Each spinner can, well, spin around an invisible magic axis. At a specific point in time, a spinner can take 4 positions shown below (each one rotated 90 degrees relative to the previous, with the fourth one followed by the first one):
<image>
After the spinner was spun, it starts its rotation, which is described by a following algorithm: the spinner maintains its position for a second then majestically switches to the next position in clockwise or counter-clockwise order, depending on the direction the spinner was spun in.
Slastyona managed to have spinner rotating for exactly n seconds. Being fascinated by elegance of the process, she completely forgot the direction the spinner was spun in! Lucky for her, she managed to recall the starting position, and wants to deduct the direction given the information she knows. Help her do this.
Input
There are two characters in the first string – the starting and the ending position of a spinner. The position is encoded with one of the following characters: v (ASCII code 118, lowercase v), < (ASCII code 60), ^ (ASCII code 94) or > (ASCII code 62) (see the picture above for reference). Characters are separated by a single space.
In the second strings, a single number n is given (0 ≤ n ≤ 109) – the duration of the rotation.
It is guaranteed that the ending position of a spinner is a result of a n second spin in any of the directions, assuming the given starting position.
Output
Output cw, if the direction is clockwise, ccw – if counter-clockwise, and undefined otherwise.
Examples
Input
^ >
1
Output
cw
Input
< ^
3
Output
ccw
Input
^ v
6
Output
undefined | 2 | 7 |
start,end=input().split()
n=int(input())
arr=['^','>','v','<']
ind1=0
ind2=0
for i in range(4):
if(arr[i]==start):
ind1=i
if(arr[i]==end):
ind2=i
if(ind2>=ind1):
diff1=ind2-ind1
else:
diff1=4+(ind2-ind1)
if(ind1>=ind2):
diff2=ind1-ind2
else:
diff2=4+(ind1-ind2)
flag1=0
flag2=0
if(n%4==diff1):
flag1=1
if(n%4==diff2):
flag2=1
if(flag1==1 and flag2==1):
print("undefined")
elif(flag1==1):
print('cw')
elif(flag2==1):
print('ccw')
else:
print("undefined") | PYTHON3 |
834_A. The Useless Toy | <image>
Walking through the streets of Marshmallow City, Slastyona have spotted some merchants selling a kind of useless toy which is very popular nowadays – caramel spinner! Wanting to join the craze, she has immediately bought the strange contraption.
Spinners in Sweetland have the form of V-shaped pieces of caramel. Each spinner can, well, spin around an invisible magic axis. At a specific point in time, a spinner can take 4 positions shown below (each one rotated 90 degrees relative to the previous, with the fourth one followed by the first one):
<image>
After the spinner was spun, it starts its rotation, which is described by a following algorithm: the spinner maintains its position for a second then majestically switches to the next position in clockwise or counter-clockwise order, depending on the direction the spinner was spun in.
Slastyona managed to have spinner rotating for exactly n seconds. Being fascinated by elegance of the process, she completely forgot the direction the spinner was spun in! Lucky for her, she managed to recall the starting position, and wants to deduct the direction given the information she knows. Help her do this.
Input
There are two characters in the first string – the starting and the ending position of a spinner. The position is encoded with one of the following characters: v (ASCII code 118, lowercase v), < (ASCII code 60), ^ (ASCII code 94) or > (ASCII code 62) (see the picture above for reference). Characters are separated by a single space.
In the second strings, a single number n is given (0 ≤ n ≤ 109) – the duration of the rotation.
It is guaranteed that the ending position of a spinner is a result of a n second spin in any of the directions, assuming the given starting position.
Output
Output cw, if the direction is clockwise, ccw – if counter-clockwise, and undefined otherwise.
Examples
Input
^ >
1
Output
cw
Input
< ^
3
Output
ccw
Input
^ v
6
Output
undefined | 2 | 7 | import java.util.Scanner;
public class A_TheUselessToy {
public static void main(String[] args)
{
Scanner in = new Scanner(System.in);
String input1 = in.next();
String input2 = in.next();
int t = in.nextInt();
int start = getValue(input1);
int end = getValue(input2);
if(start > end)
{
int cwDiff = 4 - (start - end);
int ccwDiff = start - end;
if(check(cwDiff, t) && check(ccwDiff, t))
System.out.println("undefined");
else if(check(cwDiff, t))
System.out.println("cw");
else if(check(ccwDiff, t))
System.out.println("ccw");
}
else if(start < end)
{
int cwDiff = end - start;
int ccwDiff = 4 - (end - start);
if(check(cwDiff, t) && check(ccwDiff, t))
System.out.println("undefined");
else if(check(cwDiff, t))
System.out.println("cw");
else if(check(ccwDiff, t))
System.out.println("ccw");
}
else
{
System.out.println("undefined");
}
}
private static boolean check(int diff, int t)
{
int n = (t - diff) % 4;
if(n == 0) return true;
else
return false;
}
private static int getValue(String input)
{
if(input.equals("v"))
return 0;
else if(input.equals("<"))
return 1;
else if(input.equals("^"))
return 2;
else
return 3;
}
}
| JAVA |
834_A. The Useless Toy | <image>
Walking through the streets of Marshmallow City, Slastyona have spotted some merchants selling a kind of useless toy which is very popular nowadays – caramel spinner! Wanting to join the craze, she has immediately bought the strange contraption.
Spinners in Sweetland have the form of V-shaped pieces of caramel. Each spinner can, well, spin around an invisible magic axis. At a specific point in time, a spinner can take 4 positions shown below (each one rotated 90 degrees relative to the previous, with the fourth one followed by the first one):
<image>
After the spinner was spun, it starts its rotation, which is described by a following algorithm: the spinner maintains its position for a second then majestically switches to the next position in clockwise or counter-clockwise order, depending on the direction the spinner was spun in.
Slastyona managed to have spinner rotating for exactly n seconds. Being fascinated by elegance of the process, she completely forgot the direction the spinner was spun in! Lucky for her, she managed to recall the starting position, and wants to deduct the direction given the information she knows. Help her do this.
Input
There are two characters in the first string – the starting and the ending position of a spinner. The position is encoded with one of the following characters: v (ASCII code 118, lowercase v), < (ASCII code 60), ^ (ASCII code 94) or > (ASCII code 62) (see the picture above for reference). Characters are separated by a single space.
In the second strings, a single number n is given (0 ≤ n ≤ 109) – the duration of the rotation.
It is guaranteed that the ending position of a spinner is a result of a n second spin in any of the directions, assuming the given starting position.
Output
Output cw, if the direction is clockwise, ccw – if counter-clockwise, and undefined otherwise.
Examples
Input
^ >
1
Output
cw
Input
< ^
3
Output
ccw
Input
^ v
6
Output
undefined | 2 | 7 | a, b = input().split()
c = int(input())
if c % 2 == 0:
print("undefined")
else:
if (a == '^' and b == '>') or (a == '>' and b == 'v') or (a == 'v' and b == '<') or (a == '<' and b == '^'):
print("cw" if c % 4 == 1 else "ccw")
else:
print("ccw" if c % 4 == 1 else "cw") | PYTHON3 |
834_A. The Useless Toy | <image>
Walking through the streets of Marshmallow City, Slastyona have spotted some merchants selling a kind of useless toy which is very popular nowadays – caramel spinner! Wanting to join the craze, she has immediately bought the strange contraption.
Spinners in Sweetland have the form of V-shaped pieces of caramel. Each spinner can, well, spin around an invisible magic axis. At a specific point in time, a spinner can take 4 positions shown below (each one rotated 90 degrees relative to the previous, with the fourth one followed by the first one):
<image>
After the spinner was spun, it starts its rotation, which is described by a following algorithm: the spinner maintains its position for a second then majestically switches to the next position in clockwise or counter-clockwise order, depending on the direction the spinner was spun in.
Slastyona managed to have spinner rotating for exactly n seconds. Being fascinated by elegance of the process, she completely forgot the direction the spinner was spun in! Lucky for her, she managed to recall the starting position, and wants to deduct the direction given the information she knows. Help her do this.
Input
There are two characters in the first string – the starting and the ending position of a spinner. The position is encoded with one of the following characters: v (ASCII code 118, lowercase v), < (ASCII code 60), ^ (ASCII code 94) or > (ASCII code 62) (see the picture above for reference). Characters are separated by a single space.
In the second strings, a single number n is given (0 ≤ n ≤ 109) – the duration of the rotation.
It is guaranteed that the ending position of a spinner is a result of a n second spin in any of the directions, assuming the given starting position.
Output
Output cw, if the direction is clockwise, ccw – if counter-clockwise, and undefined otherwise.
Examples
Input
^ >
1
Output
cw
Input
< ^
3
Output
ccw
Input
^ v
6
Output
undefined | 2 | 7 | i,f=input().split()
n=int(input())%4
a=['v','<','^','>']
#clockwise
count=0
t1=False
t2=False
temp=a.index(i)
while(count<n):
if(temp==3):
temp=0
else:
temp+=1
count+=1
if(a[temp]==f):
t1=True
#counter clockwise
count=0
temp=a.index(i)
while(count<n):
if(temp==0):
temp=3
else:
temp-=1
count+=1
if(a[temp]==f):
t2=True
#print(t1," ",t2)
if(t1==t2):
print("undefined")
elif(t1):
print("cw")
else:
print("ccw")
| PYTHON3 |
834_A. The Useless Toy | <image>
Walking through the streets of Marshmallow City, Slastyona have spotted some merchants selling a kind of useless toy which is very popular nowadays – caramel spinner! Wanting to join the craze, she has immediately bought the strange contraption.
Spinners in Sweetland have the form of V-shaped pieces of caramel. Each spinner can, well, spin around an invisible magic axis. At a specific point in time, a spinner can take 4 positions shown below (each one rotated 90 degrees relative to the previous, with the fourth one followed by the first one):
<image>
After the spinner was spun, it starts its rotation, which is described by a following algorithm: the spinner maintains its position for a second then majestically switches to the next position in clockwise or counter-clockwise order, depending on the direction the spinner was spun in.
Slastyona managed to have spinner rotating for exactly n seconds. Being fascinated by elegance of the process, she completely forgot the direction the spinner was spun in! Lucky for her, she managed to recall the starting position, and wants to deduct the direction given the information she knows. Help her do this.
Input
There are two characters in the first string – the starting and the ending position of a spinner. The position is encoded with one of the following characters: v (ASCII code 118, lowercase v), < (ASCII code 60), ^ (ASCII code 94) or > (ASCII code 62) (see the picture above for reference). Characters are separated by a single space.
In the second strings, a single number n is given (0 ≤ n ≤ 109) – the duration of the rotation.
It is guaranteed that the ending position of a spinner is a result of a n second spin in any of the directions, assuming the given starting position.
Output
Output cw, if the direction is clockwise, ccw – if counter-clockwise, and undefined otherwise.
Examples
Input
^ >
1
Output
cw
Input
< ^
3
Output
ccw
Input
^ v
6
Output
undefined | 2 | 7 |
import java.io.*;
import java.util.*;
public class Problems1{
public static void main(String[] args) throws IOException {
FastScanner sc=new FastScanner(System.in);
BufferedReader r=new BufferedReader(new InputStreamReader(System.in));
String s=sc.next()+sc.next();
int start=s.charAt(0);
int end=s.charAt(1);
int n=sc.nextInt()%4;
String a="^>v<";
boolean ccw=false,cw=false;
int i,j;
for(i=0,j=a.indexOf(start);i<n;i++,j++){
if(j>3)j=0;
}
if(j>3)j=0;
if(a.charAt(j)==end)cw=true;
a="^<v>";
for(i=0,j=a.indexOf(start);i<n;i++,j++){
if(j>3)j=0;
}
if(j>3)j=0;
if(a.charAt(j)==end)ccw=true;
if(cw && ccw)System.out.println("undefined");
else if(cw)System.out.println("cw");
else if(ccw)System.out.println("ccw");
else System.out.println("undefined");
}
//||||||||||||||||||||||||||||||||||||||||||||||||||||||||
public static void dis(int a[]){
StringBuilder s=new StringBuilder();
for(int i=0;i<a.length;i++){
s.append(a[i]+" ");
}
System.out.println(s.toString());
}
//__________________________________________________________
static class FastScanner {
BufferedReader br;
StringTokenizer st;
public FastScanner(InputStream i) {
br = new BufferedReader(new InputStreamReader(i));
st = new StringTokenizer("");
}
public String next() throws IOException {
if(st.hasMoreTokens())
return st.nextToken();
else
st = new StringTokenizer(br.readLine());
return next();
}
public int nextInt() throws IOException {
return Integer.parseInt(next());
}
//#
public long nextLong() throws IOException {
return Long.parseLong(next());
}
public double nextDouble() throws IOException {
return Double.parseDouble(next());
}
//$
}
}
| JAVA |
834_A. The Useless Toy | <image>
Walking through the streets of Marshmallow City, Slastyona have spotted some merchants selling a kind of useless toy which is very popular nowadays – caramel spinner! Wanting to join the craze, she has immediately bought the strange contraption.
Spinners in Sweetland have the form of V-shaped pieces of caramel. Each spinner can, well, spin around an invisible magic axis. At a specific point in time, a spinner can take 4 positions shown below (each one rotated 90 degrees relative to the previous, with the fourth one followed by the first one):
<image>
After the spinner was spun, it starts its rotation, which is described by a following algorithm: the spinner maintains its position for a second then majestically switches to the next position in clockwise or counter-clockwise order, depending on the direction the spinner was spun in.
Slastyona managed to have spinner rotating for exactly n seconds. Being fascinated by elegance of the process, she completely forgot the direction the spinner was spun in! Lucky for her, she managed to recall the starting position, and wants to deduct the direction given the information she knows. Help her do this.
Input
There are two characters in the first string – the starting and the ending position of a spinner. The position is encoded with one of the following characters: v (ASCII code 118, lowercase v), < (ASCII code 60), ^ (ASCII code 94) or > (ASCII code 62) (see the picture above for reference). Characters are separated by a single space.
In the second strings, a single number n is given (0 ≤ n ≤ 109) – the duration of the rotation.
It is guaranteed that the ending position of a spinner is a result of a n second spin in any of the directions, assuming the given starting position.
Output
Output cw, if the direction is clockwise, ccw – if counter-clockwise, and undefined otherwise.
Examples
Input
^ >
1
Output
cw
Input
< ^
3
Output
ccw
Input
^ v
6
Output
undefined | 2 | 7 | symbols=raw_input().strip().split(' ')
rotations=input()
symbol_map={'v':0,'<':1,'^':2,'>':3}
rotations=rotations%4
cw_rotations=(symbol_map[symbols[0]]+rotations)%4
# cw_rotations=(symbol_map[symbols[0]] + rotations)%4
ccw_rotations=(symbol_map[symbols[0]]-rotations)%4
# ccw_rotations=(symbol_map[symbols[0]] - rotations)%4
if cw_rotations == ccw_rotations:
print "undefined"
elif cw_rotations == symbol_map[symbols[1]]:
print 'cw'
else:
print 'ccw'
| PYTHON |
834_A. The Useless Toy | <image>
Walking through the streets of Marshmallow City, Slastyona have spotted some merchants selling a kind of useless toy which is very popular nowadays – caramel spinner! Wanting to join the craze, she has immediately bought the strange contraption.
Spinners in Sweetland have the form of V-shaped pieces of caramel. Each spinner can, well, spin around an invisible magic axis. At a specific point in time, a spinner can take 4 positions shown below (each one rotated 90 degrees relative to the previous, with the fourth one followed by the first one):
<image>
After the spinner was spun, it starts its rotation, which is described by a following algorithm: the spinner maintains its position for a second then majestically switches to the next position in clockwise or counter-clockwise order, depending on the direction the spinner was spun in.
Slastyona managed to have spinner rotating for exactly n seconds. Being fascinated by elegance of the process, she completely forgot the direction the spinner was spun in! Lucky for her, she managed to recall the starting position, and wants to deduct the direction given the information she knows. Help her do this.
Input
There are two characters in the first string – the starting and the ending position of a spinner. The position is encoded with one of the following characters: v (ASCII code 118, lowercase v), < (ASCII code 60), ^ (ASCII code 94) or > (ASCII code 62) (see the picture above for reference). Characters are separated by a single space.
In the second strings, a single number n is given (0 ≤ n ≤ 109) – the duration of the rotation.
It is guaranteed that the ending position of a spinner is a result of a n second spin in any of the directions, assuming the given starting position.
Output
Output cw, if the direction is clockwise, ccw – if counter-clockwise, and undefined otherwise.
Examples
Input
^ >
1
Output
cw
Input
< ^
3
Output
ccw
Input
^ v
6
Output
undefined | 2 | 7 |
import java.util.Scanner;
public class Solution {
static Scanner in=new Scanner(System.in);
public static void main(String[] args) {
char ch[]=new char[4];
ch[0]='v';
ch[1]='<';
ch[2]='^';
ch[3]='>';
char first=in.next().charAt(0);
char second=in.next().charAt(0);
int n=in.nextInt();
n=n%4;
//System.out.println(n);
for(int i=0;i<4;i++) {
if(ch[i]==first) {
if(n%2==0)
{
System.out.println("undefined");
break;
}
else if(ch[(i+n)%4]==second)
{
System.out.println("cw");
break;
}
else {
System.out.println("ccw");
}
}
}
}
}
| JAVA |
834_A. The Useless Toy | <image>
Walking through the streets of Marshmallow City, Slastyona have spotted some merchants selling a kind of useless toy which is very popular nowadays – caramel spinner! Wanting to join the craze, she has immediately bought the strange contraption.
Spinners in Sweetland have the form of V-shaped pieces of caramel. Each spinner can, well, spin around an invisible magic axis. At a specific point in time, a spinner can take 4 positions shown below (each one rotated 90 degrees relative to the previous, with the fourth one followed by the first one):
<image>
After the spinner was spun, it starts its rotation, which is described by a following algorithm: the spinner maintains its position for a second then majestically switches to the next position in clockwise or counter-clockwise order, depending on the direction the spinner was spun in.
Slastyona managed to have spinner rotating for exactly n seconds. Being fascinated by elegance of the process, she completely forgot the direction the spinner was spun in! Lucky for her, she managed to recall the starting position, and wants to deduct the direction given the information she knows. Help her do this.
Input
There are two characters in the first string – the starting and the ending position of a spinner. The position is encoded with one of the following characters: v (ASCII code 118, lowercase v), < (ASCII code 60), ^ (ASCII code 94) or > (ASCII code 62) (see the picture above for reference). Characters are separated by a single space.
In the second strings, a single number n is given (0 ≤ n ≤ 109) – the duration of the rotation.
It is guaranteed that the ending position of a spinner is a result of a n second spin in any of the directions, assuming the given starting position.
Output
Output cw, if the direction is clockwise, ccw – if counter-clockwise, and undefined otherwise.
Examples
Input
^ >
1
Output
cw
Input
< ^
3
Output
ccw
Input
^ v
6
Output
undefined | 2 | 7 | import java.util.*;
import java.io.*;
public class useless{
public static void main(String[] args) throws IOException {
BufferedReader read = new BufferedReader(new InputStreamReader(System.in));
String[] spin = read.readLine().split(" ");
String[] cosa = {"v",">","^","<"};
int n = Integer.parseInt(read.readLine());
if(n%2 == 0)System.out.println("undefined");
else{
if(spin[0].equals(cosa[0])){
if(cosa[n%4].equals(spin[1])) System.out.println("ccw");
else System.out.println("cw");
}
else if(spin[0].equals(cosa[1])){
if(cosa[(n+1)%4].equals(spin[1])) System.out.println("ccw");
else System.out.println("cw");
}
else if(spin[0].equals(cosa[2])){
if(cosa[(n+2)%4].equals(spin[1])) System.out.println("ccw");
else System.out.println("cw");
}
else{
if(cosa[(n+3)%4].equals(spin[1])) System.out.println("ccw");
else System.out.println("cw");
}
}
}
} | JAVA |
834_A. The Useless Toy | <image>
Walking through the streets of Marshmallow City, Slastyona have spotted some merchants selling a kind of useless toy which is very popular nowadays – caramel spinner! Wanting to join the craze, she has immediately bought the strange contraption.
Spinners in Sweetland have the form of V-shaped pieces of caramel. Each spinner can, well, spin around an invisible magic axis. At a specific point in time, a spinner can take 4 positions shown below (each one rotated 90 degrees relative to the previous, with the fourth one followed by the first one):
<image>
After the spinner was spun, it starts its rotation, which is described by a following algorithm: the spinner maintains its position for a second then majestically switches to the next position in clockwise or counter-clockwise order, depending on the direction the spinner was spun in.
Slastyona managed to have spinner rotating for exactly n seconds. Being fascinated by elegance of the process, she completely forgot the direction the spinner was spun in! Lucky for her, she managed to recall the starting position, and wants to deduct the direction given the information she knows. Help her do this.
Input
There are two characters in the first string – the starting and the ending position of a spinner. The position is encoded with one of the following characters: v (ASCII code 118, lowercase v), < (ASCII code 60), ^ (ASCII code 94) or > (ASCII code 62) (see the picture above for reference). Characters are separated by a single space.
In the second strings, a single number n is given (0 ≤ n ≤ 109) – the duration of the rotation.
It is guaranteed that the ending position of a spinner is a result of a n second spin in any of the directions, assuming the given starting position.
Output
Output cw, if the direction is clockwise, ccw – if counter-clockwise, and undefined otherwise.
Examples
Input
^ >
1
Output
cw
Input
< ^
3
Output
ccw
Input
^ v
6
Output
undefined | 2 | 7 | import java.io.*;
import java.util.*;
public final class code
// public class Main
// class code
// public class Solution
{
static void solve()throws IOException
{
boolean clock=false,counter=false;
String s=nextLine();
char a=s.charAt(0);
char b=s.charAt(2);
int n=nextInt();
n=n%4;
char list[]={'v','<','^','>'};
int x=0;
switch(a)
{
case 'v':x=0;break;
case '<':x=1;break;
case '^':x=2;break;
case '>':x=3;break;
}
int y=(x+n)%4;
if(list[y]==b)
clock=true;
y=(x-n%4+4)%4;
if(list[y]==b)
counter=true;
if(clock && counter)
out.println("undefined");
else if(clock)
out.println("cw");
else
out.println("ccw");
}
///////////////////////////////////////////////////////////
public static void main(String args[])throws IOException
{
br=new BufferedReader(new InputStreamReader(System.in));
out=new PrintWriter(new BufferedOutputStream(System.out));
random=new Random();
solve();
// int t=nextInt();
// for(int i=1;i<=t;i++)
// {
// // out.print("Case #"+i+": ");
// solve();
// }
out.close();
}
static final long mod=(int)(1e9+7);
static final int inf=(int)(1e9+1);
// static final long inf=(long)(1e18);
static class Pair implements Comparable<Pair>
{
int first,second;
Pair(int a,int b)
{
first=a;
second=b;
}
public int compareTo(Pair p)
{
return first==p.first?second-p.second:first-p.first;
}
public boolean equals(Object o)
{
Pair p=(Pair)o;
return first==p.first?second==p.second:false;
}
public int hashCode()
{
return (int)((1l*first*inf+second)%mod);
}
public String toString()
{
return first+" "+second;
}
}
static class Triplet implements Comparable<Triplet>
{
int first,second,third;
Triplet(int a,int b,int c)
{
first=a;
second=b;
third=c;
}
public int compareTo(Triplet p)
{
return second-p.second;
}
public String toString()
{
return first+" "+second+" "+third;
}
}
static long modinv(long x)
{
return modpow(x,mod-2);
}
static long modpow(long a,long b)
{
if(b==0)
return 1;
long x=modpow(a,b/2);
x=(x*x)%mod;
if(b%2==1)
return (x*a)%mod;
return x;
}
static long gcd(long a,long b)
{
if(a==0)
return b;
return gcd(b%a,a);
}
static int max(int ... a)
{
int ret=a[0];
for(int i=1;i<a.length;i++)
ret=Math.max(ret,a[i]);
return ret;
}
static int min(int ... a)
{
int ret=a[0];
for(int i=1;i<a.length;i++)
ret=Math.min(ret,a[i]);
return ret;
}
static void debug(Object ... a)
{
System.out.print("> ");
for(int i=0;i<a.length;i++)
System.out.print(a[i]+" ");
System.out.println();
}
static void debug(int a[]){debuga(Arrays.stream(a).boxed().toArray());}
static void debug(long a[]){debuga(Arrays.stream(a).boxed().toArray());}
static void debuga(Object a[])
{
System.out.print("> ");
for(int i=0;i<a.length;i++)
System.out.print(a[i]+" ");
System.out.println();
}
static Random random;
static BufferedReader br;
static StringTokenizer st;
static PrintWriter out;
static String nextToken()throws IOException
{
while(st==null || !st.hasMoreTokens())
st=new StringTokenizer(br.readLine());
return st.nextToken();
}
static String nextLine()throws IOException
{
return br.readLine();
}
static int nextInt()throws IOException
{
return Integer.parseInt(nextToken());
}
static long nextLong()throws IOException
{
return Long.parseLong(nextToken());
}
static double nextDouble()throws IOException
{
return Double.parseDouble(nextToken());
}
} | JAVA |
834_A. The Useless Toy | <image>
Walking through the streets of Marshmallow City, Slastyona have spotted some merchants selling a kind of useless toy which is very popular nowadays – caramel spinner! Wanting to join the craze, she has immediately bought the strange contraption.
Spinners in Sweetland have the form of V-shaped pieces of caramel. Each spinner can, well, spin around an invisible magic axis. At a specific point in time, a spinner can take 4 positions shown below (each one rotated 90 degrees relative to the previous, with the fourth one followed by the first one):
<image>
After the spinner was spun, it starts its rotation, which is described by a following algorithm: the spinner maintains its position for a second then majestically switches to the next position in clockwise or counter-clockwise order, depending on the direction the spinner was spun in.
Slastyona managed to have spinner rotating for exactly n seconds. Being fascinated by elegance of the process, she completely forgot the direction the spinner was spun in! Lucky for her, she managed to recall the starting position, and wants to deduct the direction given the information she knows. Help her do this.
Input
There are two characters in the first string – the starting and the ending position of a spinner. The position is encoded with one of the following characters: v (ASCII code 118, lowercase v), < (ASCII code 60), ^ (ASCII code 94) or > (ASCII code 62) (see the picture above for reference). Characters are separated by a single space.
In the second strings, a single number n is given (0 ≤ n ≤ 109) – the duration of the rotation.
It is guaranteed that the ending position of a spinner is a result of a n second spin in any of the directions, assuming the given starting position.
Output
Output cw, if the direction is clockwise, ccw – if counter-clockwise, and undefined otherwise.
Examples
Input
^ >
1
Output
cw
Input
< ^
3
Output
ccw
Input
^ v
6
Output
undefined | 2 | 7 | #include <bits/stdc++.h>
char b, e;
int bn, n, c, en, st = 0, nt = 0;
using namespace std;
int main() {
cin >> b >> e >> n;
if (b == 94) bn = 1;
if (b == 62) bn = 2;
if (b == 118) bn = 3;
if (b == 60) bn = 4;
if (e == 94) en = 1;
if (e == 62) en = 2;
if (e == 118) en = 3;
if (e == 60) en = 4;
n %= 4;
c = bn;
for (int i = 1; i <= n; i++) {
c++;
if (c == 5) c = 1;
}
if (c == en) {
st++;
}
c = bn;
for (int i = 1; i <= n; i++) {
c--;
if (c == 0) c = 4;
}
if (c == en) {
nt++;
}
if (st == nt) {
cout << "undefined";
} else {
if (st == 1)
cout << "cw";
else
cout << "ccw";
}
return 0;
}
| CPP |
834_A. The Useless Toy | <image>
Walking through the streets of Marshmallow City, Slastyona have spotted some merchants selling a kind of useless toy which is very popular nowadays – caramel spinner! Wanting to join the craze, she has immediately bought the strange contraption.
Spinners in Sweetland have the form of V-shaped pieces of caramel. Each spinner can, well, spin around an invisible magic axis. At a specific point in time, a spinner can take 4 positions shown below (each one rotated 90 degrees relative to the previous, with the fourth one followed by the first one):
<image>
After the spinner was spun, it starts its rotation, which is described by a following algorithm: the spinner maintains its position for a second then majestically switches to the next position in clockwise or counter-clockwise order, depending on the direction the spinner was spun in.
Slastyona managed to have spinner rotating for exactly n seconds. Being fascinated by elegance of the process, she completely forgot the direction the spinner was spun in! Lucky for her, she managed to recall the starting position, and wants to deduct the direction given the information she knows. Help her do this.
Input
There are two characters in the first string – the starting and the ending position of a spinner. The position is encoded with one of the following characters: v (ASCII code 118, lowercase v), < (ASCII code 60), ^ (ASCII code 94) or > (ASCII code 62) (see the picture above for reference). Characters are separated by a single space.
In the second strings, a single number n is given (0 ≤ n ≤ 109) – the duration of the rotation.
It is guaranteed that the ending position of a spinner is a result of a n second spin in any of the directions, assuming the given starting position.
Output
Output cw, if the direction is clockwise, ccw – if counter-clockwise, and undefined otherwise.
Examples
Input
^ >
1
Output
cw
Input
< ^
3
Output
ccw
Input
^ v
6
Output
undefined | 2 | 7 | a,b = map(str,input().split())
n = int(input())
toy = 'v<^>'
if n%2==0:
print('undefined')
elif (toy.find(a)+n)%4 == toy.find(b):
print('cw')
else:
print('ccw') | PYTHON3 |
834_A. The Useless Toy | <image>
Walking through the streets of Marshmallow City, Slastyona have spotted some merchants selling a kind of useless toy which is very popular nowadays – caramel spinner! Wanting to join the craze, she has immediately bought the strange contraption.
Spinners in Sweetland have the form of V-shaped pieces of caramel. Each spinner can, well, spin around an invisible magic axis. At a specific point in time, a spinner can take 4 positions shown below (each one rotated 90 degrees relative to the previous, with the fourth one followed by the first one):
<image>
After the spinner was spun, it starts its rotation, which is described by a following algorithm: the spinner maintains its position for a second then majestically switches to the next position in clockwise or counter-clockwise order, depending on the direction the spinner was spun in.
Slastyona managed to have spinner rotating for exactly n seconds. Being fascinated by elegance of the process, she completely forgot the direction the spinner was spun in! Lucky for her, she managed to recall the starting position, and wants to deduct the direction given the information she knows. Help her do this.
Input
There are two characters in the first string – the starting and the ending position of a spinner. The position is encoded with one of the following characters: v (ASCII code 118, lowercase v), < (ASCII code 60), ^ (ASCII code 94) or > (ASCII code 62) (see the picture above for reference). Characters are separated by a single space.
In the second strings, a single number n is given (0 ≤ n ≤ 109) – the duration of the rotation.
It is guaranteed that the ending position of a spinner is a result of a n second spin in any of the directions, assuming the given starting position.
Output
Output cw, if the direction is clockwise, ccw – if counter-clockwise, and undefined otherwise.
Examples
Input
^ >
1
Output
cw
Input
< ^
3
Output
ccw
Input
^ v
6
Output
undefined | 2 | 7 | #include <bits/stdc++.h>
using namespace std;
int main() {
std::ios::sync_with_stdio(false);
cin.tie(0);
string s1, s2;
int n;
cin >> s1 >> s2 >> n;
if (n % 4 == 0) {
cout << "undefined";
} else if (n % 4 == 1) {
if ((s1 == "^" && s2 == ">") || (s1 == ">" && s2 == "v") ||
(s1 == "v" && s2 == "<") || (s1 == "<" && s2 == "^"))
cout << "cw";
else if ((s1 == "^" && s2 == "<") || (s1 == "<" && s2 == "v") ||
(s1 == "v" && s2 == ">") || (s1 == ">" && s2 == "^"))
cout << "ccw";
else
cout << "undefined";
} else if (n % 4 == 2) {
cout << "undefined";
} else {
if ((s1 == "^" && s2 == "<") || (s1 == ">" && s2 == "^") ||
(s1 == "v" && s2 == ">") || (s1 == "<" && s2 == "v"))
cout << "cw";
else if ((s1 == "^" && s2 == ">") || (s1 == "<" && s2 == "^") ||
(s1 == "v" && s2 == "<") || (s1 == ">" && s2 == "v"))
cout << "ccw";
else
cout << "undefined";
}
return 0;
}
| CPP |
834_A. The Useless Toy | <image>
Walking through the streets of Marshmallow City, Slastyona have spotted some merchants selling a kind of useless toy which is very popular nowadays – caramel spinner! Wanting to join the craze, she has immediately bought the strange contraption.
Spinners in Sweetland have the form of V-shaped pieces of caramel. Each spinner can, well, spin around an invisible magic axis. At a specific point in time, a spinner can take 4 positions shown below (each one rotated 90 degrees relative to the previous, with the fourth one followed by the first one):
<image>
After the spinner was spun, it starts its rotation, which is described by a following algorithm: the spinner maintains its position for a second then majestically switches to the next position in clockwise or counter-clockwise order, depending on the direction the spinner was spun in.
Slastyona managed to have spinner rotating for exactly n seconds. Being fascinated by elegance of the process, she completely forgot the direction the spinner was spun in! Lucky for her, she managed to recall the starting position, and wants to deduct the direction given the information she knows. Help her do this.
Input
There are two characters in the first string – the starting and the ending position of a spinner. The position is encoded with one of the following characters: v (ASCII code 118, lowercase v), < (ASCII code 60), ^ (ASCII code 94) or > (ASCII code 62) (see the picture above for reference). Characters are separated by a single space.
In the second strings, a single number n is given (0 ≤ n ≤ 109) – the duration of the rotation.
It is guaranteed that the ending position of a spinner is a result of a n second spin in any of the directions, assuming the given starting position.
Output
Output cw, if the direction is clockwise, ccw – if counter-clockwise, and undefined otherwise.
Examples
Input
^ >
1
Output
cw
Input
< ^
3
Output
ccw
Input
^ v
6
Output
undefined | 2 | 7 | #include <bits/stdc++.h>
using namespace std;
int main() {
string s;
getline(cin, s);
long long n;
cin >> n;
n = n % 4;
int a = (int)s[0];
int b = (int)s[2];
if (a == b) {
cout << "undefined";
return 0;
}
if (a == 118 && b == 94) {
cout << "undefined";
return 0;
} else if (b == 118 && a == 94) {
cout << "undefined";
return 0;
}
if (a == 60 & b == 62) {
cout << "undefined";
return 0;
} else if (b == 60 && a == 62) {
cout << "undefined";
return 0;
} else if (a == 118 && b == 60) {
if (n > 1)
cout << "ccw";
else
cout << "cw";
} else if (a == 60 && b == 118) {
if (n > 1)
cout << "cw";
else
cout << "ccw";
} else if (a == 118 && b == 62) {
if (n > 1)
cout << "cw";
else
cout << "ccw";
} else if (a == 62 && b == 118) {
if (n > 1)
cout << "ccw";
else
cout << "cw";
} else if (a == 94 && b == 60) {
if (n > 1)
cout << "cw";
else
cout << "ccw";
} else if (a == 60 && b == 94) {
if (n > 1)
cout << "ccw";
else
cout << "cw";
} else if (a == 94 && b == 62) {
if (n > 1)
cout << "ccw";
else
cout << "cw";
} else if (a == 62 && b == 94) {
if (n > 1)
cout << "cw";
else
cout << "ccw";
}
}
| CPP |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.