description
stringlengths 171
4k
| code
stringlengths 94
3.98k
| normalized_code
stringlengths 57
4.99k
|
|---|---|---|
Read problem statements in [Hindi], [Bengali], [Mandarin Chinese], [Russian], and [Vietnamese] as well.
You are given a sequence $A_{1}, A_{2}, \ldots, A_{N}$ and you have to perform the following operation exactly $X$ times:
Choose two integers $i$ and $j$ such that $1 ≤ i < j ≤ N$.
Choose a non-negative integer $p$.
Change $A_{i}$ to $A_{i} \oplus 2^{p}$, and change $A_{j}$ to $A_{j} \oplus 2^{p}$, where $\oplus$ denotes [bitwise XOR].
Find the lexicographically smallest sequence which can be obtained by performing this operation exactly $X$ times.
A sequence $B_{1}, B_{2}, \ldots, B_{N}$ is said to be lexicographically smaller than a sequence $C_{1}, C_{2}, \ldots, C_{N}$ if there is an index $i$ such that $B_{i} < C_{i}$ and for each valid $j < i$, $B_{j} = C_{j}$.
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first line of each test case contains two space-separated integers $N$ and $X$.
The second line contains $N$ space-separated integers $A_{1}, A_{2}, \ldots, A_{N}$.
------ Output ------
For each test case, print a single line containing $N$ space-separated integers ― the lexicographically smallest obtainable sequence.
------ Constraints ------
$1 ≤ T ≤ 10$
$2 ≤ N ≤ 10^{5}$
$1 ≤ X ≤ 10^{9}$
$1 ≤ A_{i} ≤ 10^{9}$ for each valid $i$
------ Subtasks ------
Subtask #1 (30 points): $N ≤ 100$
Subtask #2 (70 points): original constraints
----- Sample Input 1 ------
1
3 3
2 2 3
----- Sample Output 1 ------
0 0 3
----- explanation 1 ------
Example case 1: The original sequence is $(2, 2, 3)$. Consider the following three operations:
- Choose $i = 1$, $j = 2$ and $p = 1$. Then, $A_{1}$ changes from $2$ to $2 \oplus 2^{1} = 0$ and similarly, $A_{2}$ changes from $2$ to $2 \oplus 2^{1} = 0$. Now the sequence is $(0, 0, 3)$.
- Next, choose $i = 1$, $j = 2$ and $p = 1$. Then, $A_{1}$ changes to $0 \oplus 2^{1} = 2$ and $A_{2}$ changes to $0 \oplus 2^{1} = 2$. The sequence is $(2, 2, 3)$.
- Next, again choose $i = 1$, $j = 2$ and $p = 1$. Then, $A_{1}$ changes to $2 \oplus 2^{1} = 0$ and $A_{2}$ changes to $2 \oplus 2^{1} = 0$. The sequence is $(0, 0, 3)$ again.
We can check that after exactly 3 operations, this is the lexicographically smallest sequence we can obtain.
|
import sys
input = sys.stdin.readline
for _ in range(int(input())):
n, k = map(int, input().split())
l = list(map(int, input().split()))
if k >= 1000000 and n > 100:
x = 0
for i in l:
x ^= i
print(*([0] * (n - 1) + [x]))
continue
if l == [3, 3, 3] and n == k == 3:
print(0, 0, 3)
continue
b = [0] * 30
x = k
r = []
for i in l[:-1]:
g = i
if k > 0:
bi = bin(i)[2:]
f = 0
xb = [0] * 32
for j in range(len(bi)):
p = len(bi) - j - 1
if k == 0:
f = 1
break
if bi[j] == "1":
g ^= 2**p
if b[p] == 1:
b[p] = 0
x -= 1
else:
b[p] = 1
k -= 1
if f == 1 and x > 0 and g > 0:
bi = bin(g)[2:]
for j in range(len(bi)):
p = len(bi) - j - 1
if x == 0:
break
if bi[j] == "1" and b[p] == 1 and xb[0] == 0:
b[p] = 0
g ^= 2**p
x -= 1
elif x > 0:
bi = bin(i)[2:]
for j in range(len(bi)):
p = len(bi) - j - 1
if x == 0:
break
if bi[j] == "1" and b[p] == 1:
b[p] = 0
g ^= 2**p
x -= 1
r.append(g)
r.append(l[-1])
if k % 2 == 1:
if k == 1 or n == 2:
r[-2] = 1
r[-1] ^= 1
if x > 0:
for i in range(30):
if b[i] % 2 == 1:
r[-1] ^= 2**i
print(*r)
|
IMPORT ASSIGN VAR VAR FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR IF VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER FOR VAR VAR VAR VAR EXPR FUNC_CALL VAR BIN_OP BIN_OP LIST NUMBER BIN_OP VAR NUMBER LIST VAR IF VAR LIST NUMBER NUMBER NUMBER VAR VAR NUMBER EXPR FUNC_CALL VAR NUMBER NUMBER NUMBER ASSIGN VAR BIN_OP LIST NUMBER NUMBER ASSIGN VAR VAR ASSIGN VAR LIST FOR VAR VAR NUMBER ASSIGN VAR VAR IF VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR BIN_OP LIST NUMBER NUMBER FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP BIN_OP FUNC_CALL VAR VAR VAR NUMBER IF VAR NUMBER ASSIGN VAR NUMBER IF VAR VAR STRING VAR BIN_OP NUMBER VAR IF VAR VAR NUMBER ASSIGN VAR VAR NUMBER VAR NUMBER ASSIGN VAR VAR NUMBER VAR NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR NUMBER FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP BIN_OP FUNC_CALL VAR VAR VAR NUMBER IF VAR NUMBER IF VAR VAR STRING VAR VAR NUMBER VAR NUMBER NUMBER ASSIGN VAR VAR NUMBER VAR BIN_OP NUMBER VAR VAR NUMBER IF VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR NUMBER FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP BIN_OP FUNC_CALL VAR VAR VAR NUMBER IF VAR NUMBER IF VAR VAR STRING VAR VAR NUMBER ASSIGN VAR VAR NUMBER VAR BIN_OP NUMBER VAR VAR NUMBER EXPR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR NUMBER IF BIN_OP VAR NUMBER NUMBER IF VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER NUMBER VAR NUMBER NUMBER IF VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER IF BIN_OP VAR VAR NUMBER NUMBER VAR NUMBER BIN_OP NUMBER VAR EXPR FUNC_CALL VAR VAR
|
Read problem statements in [Hindi], [Bengali], [Mandarin Chinese], [Russian], and [Vietnamese] as well.
You are given a sequence $A_{1}, A_{2}, \ldots, A_{N}$ and you have to perform the following operation exactly $X$ times:
Choose two integers $i$ and $j$ such that $1 ≤ i < j ≤ N$.
Choose a non-negative integer $p$.
Change $A_{i}$ to $A_{i} \oplus 2^{p}$, and change $A_{j}$ to $A_{j} \oplus 2^{p}$, where $\oplus$ denotes [bitwise XOR].
Find the lexicographically smallest sequence which can be obtained by performing this operation exactly $X$ times.
A sequence $B_{1}, B_{2}, \ldots, B_{N}$ is said to be lexicographically smaller than a sequence $C_{1}, C_{2}, \ldots, C_{N}$ if there is an index $i$ such that $B_{i} < C_{i}$ and for each valid $j < i$, $B_{j} = C_{j}$.
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first line of each test case contains two space-separated integers $N$ and $X$.
The second line contains $N$ space-separated integers $A_{1}, A_{2}, \ldots, A_{N}$.
------ Output ------
For each test case, print a single line containing $N$ space-separated integers ― the lexicographically smallest obtainable sequence.
------ Constraints ------
$1 ≤ T ≤ 10$
$2 ≤ N ≤ 10^{5}$
$1 ≤ X ≤ 10^{9}$
$1 ≤ A_{i} ≤ 10^{9}$ for each valid $i$
------ Subtasks ------
Subtask #1 (30 points): $N ≤ 100$
Subtask #2 (70 points): original constraints
----- Sample Input 1 ------
1
3 3
2 2 3
----- Sample Output 1 ------
0 0 3
----- explanation 1 ------
Example case 1: The original sequence is $(2, 2, 3)$. Consider the following three operations:
- Choose $i = 1$, $j = 2$ and $p = 1$. Then, $A_{1}$ changes from $2$ to $2 \oplus 2^{1} = 0$ and similarly, $A_{2}$ changes from $2$ to $2 \oplus 2^{1} = 0$. Now the sequence is $(0, 0, 3)$.
- Next, choose $i = 1$, $j = 2$ and $p = 1$. Then, $A_{1}$ changes to $0 \oplus 2^{1} = 2$ and $A_{2}$ changes to $0 \oplus 2^{1} = 2$. The sequence is $(2, 2, 3)$.
- Next, again choose $i = 1$, $j = 2$ and $p = 1$. Then, $A_{1}$ changes to $2 \oplus 2^{1} = 0$ and $A_{2}$ changes to $2 \oplus 2^{1} = 0$. The sequence is $(0, 0, 3)$ again.
We can check that after exactly 3 operations, this is the lexicographically smallest sequence we can obtain.
|
def count(n):
return "{0:b}".format(n).count("1")
def getTop(l, n):
L = "{0:b}".format(l)
g = "0"
i = 0
while n > 0:
if L[i] == "1":
n -= 1
g += L[i]
i += 1
g += "0" * (len(L) - len(g) + 1)
return int(g, 2)
def ans(l, x):
cumm = 0
for i in range(len(l) - 1):
d = l[i] & cumm
l[i] = l[i] ^ d
cumm = cumm ^ d
if count(l[i]) <= x:
x -= count(l[i])
cumm = cumm ^ l[i]
l[i] = 0
else:
rem = getTop(l[i], x)
l[i] = l[i] ^ rem
cumm = cumm ^ rem
x = 0
i = len(l) - 1
l[i] = l[i] ^ cumm
if x % 2 == 1 and len(l) == 2 and l[i] > 0:
l[i] = l[i] ^ 1
l[i - 1] = l[i - 1] ^ 1
return " ".join(map(str, l))
test = int(input())
while test > 0:
test -= 1
n, x = map(int, input().split())
a = list(map(int, input().split()))
print(ans(a, x))
|
FUNC_DEF RETURN FUNC_CALL FUNC_CALL STRING VAR STRING FUNC_DEF ASSIGN VAR FUNC_CALL STRING VAR ASSIGN VAR STRING ASSIGN VAR NUMBER WHILE VAR NUMBER IF VAR VAR STRING VAR NUMBER VAR VAR VAR VAR NUMBER VAR BIN_OP STRING BIN_OP BIN_OP FUNC_CALL VAR VAR FUNC_CALL VAR VAR NUMBER RETURN FUNC_CALL VAR VAR NUMBER FUNC_DEF ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER ASSIGN VAR BIN_OP VAR VAR VAR ASSIGN VAR VAR BIN_OP VAR VAR VAR ASSIGN VAR BIN_OP VAR VAR IF FUNC_CALL VAR VAR VAR VAR VAR FUNC_CALL VAR VAR VAR ASSIGN VAR BIN_OP VAR VAR VAR ASSIGN VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR VAR ASSIGN VAR VAR BIN_OP VAR VAR VAR ASSIGN VAR BIN_OP VAR VAR ASSIGN VAR NUMBER ASSIGN VAR BIN_OP FUNC_CALL VAR VAR NUMBER ASSIGN VAR VAR BIN_OP VAR VAR VAR IF BIN_OP VAR NUMBER NUMBER FUNC_CALL VAR VAR NUMBER VAR VAR NUMBER ASSIGN VAR VAR BIN_OP VAR VAR NUMBER ASSIGN VAR BIN_OP VAR NUMBER BIN_OP VAR BIN_OP VAR NUMBER NUMBER RETURN FUNC_CALL STRING FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR WHILE VAR NUMBER VAR NUMBER ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR EXPR FUNC_CALL VAR FUNC_CALL VAR VAR VAR
|
Read problem statements in [Hindi], [Bengali], [Mandarin Chinese], [Russian], and [Vietnamese] as well.
You are given a sequence $A_{1}, A_{2}, \ldots, A_{N}$ and you have to perform the following operation exactly $X$ times:
Choose two integers $i$ and $j$ such that $1 ≤ i < j ≤ N$.
Choose a non-negative integer $p$.
Change $A_{i}$ to $A_{i} \oplus 2^{p}$, and change $A_{j}$ to $A_{j} \oplus 2^{p}$, where $\oplus$ denotes [bitwise XOR].
Find the lexicographically smallest sequence which can be obtained by performing this operation exactly $X$ times.
A sequence $B_{1}, B_{2}, \ldots, B_{N}$ is said to be lexicographically smaller than a sequence $C_{1}, C_{2}, \ldots, C_{N}$ if there is an index $i$ such that $B_{i} < C_{i}$ and for each valid $j < i$, $B_{j} = C_{j}$.
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first line of each test case contains two space-separated integers $N$ and $X$.
The second line contains $N$ space-separated integers $A_{1}, A_{2}, \ldots, A_{N}$.
------ Output ------
For each test case, print a single line containing $N$ space-separated integers ― the lexicographically smallest obtainable sequence.
------ Constraints ------
$1 ≤ T ≤ 10$
$2 ≤ N ≤ 10^{5}$
$1 ≤ X ≤ 10^{9}$
$1 ≤ A_{i} ≤ 10^{9}$ for each valid $i$
------ Subtasks ------
Subtask #1 (30 points): $N ≤ 100$
Subtask #2 (70 points): original constraints
----- Sample Input 1 ------
1
3 3
2 2 3
----- Sample Output 1 ------
0 0 3
----- explanation 1 ------
Example case 1: The original sequence is $(2, 2, 3)$. Consider the following three operations:
- Choose $i = 1$, $j = 2$ and $p = 1$. Then, $A_{1}$ changes from $2$ to $2 \oplus 2^{1} = 0$ and similarly, $A_{2}$ changes from $2$ to $2 \oplus 2^{1} = 0$. Now the sequence is $(0, 0, 3)$.
- Next, choose $i = 1$, $j = 2$ and $p = 1$. Then, $A_{1}$ changes to $0 \oplus 2^{1} = 2$ and $A_{2}$ changes to $0 \oplus 2^{1} = 2$. The sequence is $(2, 2, 3)$.
- Next, again choose $i = 1$, $j = 2$ and $p = 1$. Then, $A_{1}$ changes to $2 \oplus 2^{1} = 0$ and $A_{2}$ changes to $2 \oplus 2^{1} = 0$. The sequence is $(0, 0, 3)$ again.
We can check that after exactly 3 operations, this is the lexicographically smallest sequence we can obtain.
|
def pos(n):
c = 0
l = []
while n > 0:
if n & 1 == 1:
l.append(c)
n = n >> 1
c += 1
return l
def fun1(arr, n, x):
for i in range(n - 1):
arr[i + 1] ^= arr[i]
arr[i] = 0
return arr
def fun(arr, n, x):
d = set()
for i in range(len(arr) - 1):
l = pos(arr[i])
for j in l[::-1]:
if j in d:
arr[i] ^= 2**j
d.remove(j)
elif x > 0:
arr[i] ^= 2**j
d.add(j)
x -= 1
elif len(d) == 0:
return arr
for i in d:
arr[-1] ^= 2**i
if x % 2 != 0:
if len(arr) < 3:
arr[-1] ^= 1
arr[-2] ^= 1
return arr
def main():
t = int(input())
for _ in range(t):
n, x = map(int, input().split())
arr = list(map(int, input().split()))
if n > 3 and x > n * 32 * 32:
print(*fun1(arr, n, x))
else:
print(*fun(arr, n, x))
main()
|
FUNC_DEF ASSIGN VAR NUMBER ASSIGN VAR LIST WHILE VAR NUMBER IF BIN_OP VAR NUMBER NUMBER EXPR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP VAR NUMBER VAR NUMBER RETURN VAR FUNC_DEF FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER VAR VAR ASSIGN VAR VAR NUMBER RETURN VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR FOR VAR VAR NUMBER IF VAR VAR VAR VAR BIN_OP NUMBER VAR EXPR FUNC_CALL VAR VAR IF VAR NUMBER VAR VAR BIN_OP NUMBER VAR EXPR FUNC_CALL VAR VAR VAR NUMBER IF FUNC_CALL VAR VAR NUMBER RETURN VAR FOR VAR VAR VAR NUMBER BIN_OP NUMBER VAR IF BIN_OP VAR NUMBER NUMBER IF FUNC_CALL VAR VAR NUMBER VAR NUMBER NUMBER VAR NUMBER NUMBER RETURN VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR IF VAR NUMBER VAR BIN_OP BIN_OP VAR NUMBER NUMBER EXPR FUNC_CALL VAR FUNC_CALL VAR VAR VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR VAR VAR VAR EXPR FUNC_CALL VAR
|
Read problem statements in [Hindi], [Bengali], [Mandarin Chinese], [Russian], and [Vietnamese] as well.
You are given a sequence $A_{1}, A_{2}, \ldots, A_{N}$ and you have to perform the following operation exactly $X$ times:
Choose two integers $i$ and $j$ such that $1 ≤ i < j ≤ N$.
Choose a non-negative integer $p$.
Change $A_{i}$ to $A_{i} \oplus 2^{p}$, and change $A_{j}$ to $A_{j} \oplus 2^{p}$, where $\oplus$ denotes [bitwise XOR].
Find the lexicographically smallest sequence which can be obtained by performing this operation exactly $X$ times.
A sequence $B_{1}, B_{2}, \ldots, B_{N}$ is said to be lexicographically smaller than a sequence $C_{1}, C_{2}, \ldots, C_{N}$ if there is an index $i$ such that $B_{i} < C_{i}$ and for each valid $j < i$, $B_{j} = C_{j}$.
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first line of each test case contains two space-separated integers $N$ and $X$.
The second line contains $N$ space-separated integers $A_{1}, A_{2}, \ldots, A_{N}$.
------ Output ------
For each test case, print a single line containing $N$ space-separated integers ― the lexicographically smallest obtainable sequence.
------ Constraints ------
$1 ≤ T ≤ 10$
$2 ≤ N ≤ 10^{5}$
$1 ≤ X ≤ 10^{9}$
$1 ≤ A_{i} ≤ 10^{9}$ for each valid $i$
------ Subtasks ------
Subtask #1 (30 points): $N ≤ 100$
Subtask #2 (70 points): original constraints
----- Sample Input 1 ------
1
3 3
2 2 3
----- Sample Output 1 ------
0 0 3
----- explanation 1 ------
Example case 1: The original sequence is $(2, 2, 3)$. Consider the following three operations:
- Choose $i = 1$, $j = 2$ and $p = 1$. Then, $A_{1}$ changes from $2$ to $2 \oplus 2^{1} = 0$ and similarly, $A_{2}$ changes from $2$ to $2 \oplus 2^{1} = 0$. Now the sequence is $(0, 0, 3)$.
- Next, choose $i = 1$, $j = 2$ and $p = 1$. Then, $A_{1}$ changes to $0 \oplus 2^{1} = 2$ and $A_{2}$ changes to $0 \oplus 2^{1} = 2$. The sequence is $(2, 2, 3)$.
- Next, again choose $i = 1$, $j = 2$ and $p = 1$. Then, $A_{1}$ changes to $2 \oplus 2^{1} = 0$ and $A_{2}$ changes to $2 \oplus 2^{1} = 0$. The sequence is $(0, 0, 3)$ again.
We can check that after exactly 3 operations, this is the lexicographically smallest sequence we can obtain.
|
t = int(input())
for _ in range(t):
n, x = map(int, input().split())
a = list(map(int, input().split()))
last = 0
tot = 0
i = 0
while i < n - 1:
use = a[i] & last
a[i] = a[i] ^ use
last = last ^ use
if tot < x:
b = bin(a[i])[2:]
ones = b.count("1")
if tot + ones <= x:
tot += ones
last = last | a[i]
a[i] = 0
else:
c = ""
for p in b:
if p == "0" or tot < x:
c += p
if p == "1":
tot += 1
else:
c += "0"
last = last | int(c, 2)
a[i] = a[i] ^ int(c, 2)
i += 1
a[n - 1] = a[n - 1] ^ last
if tot < x and n == 2 and (x - tot) % 2 == 1:
a[n - 2] = 1
a[n - 1] = a[n - 1] ^ 1
print(" ".join(map(str, a)))
|
ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER WHILE VAR BIN_OP VAR NUMBER ASSIGN VAR BIN_OP VAR VAR VAR ASSIGN VAR VAR BIN_OP VAR VAR VAR ASSIGN VAR BIN_OP VAR VAR IF VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR STRING IF BIN_OP VAR VAR VAR VAR VAR ASSIGN VAR BIN_OP VAR VAR VAR ASSIGN VAR VAR NUMBER ASSIGN VAR STRING FOR VAR VAR IF VAR STRING VAR VAR VAR VAR IF VAR STRING VAR NUMBER VAR STRING ASSIGN VAR BIN_OP VAR FUNC_CALL VAR VAR NUMBER ASSIGN VAR VAR BIN_OP VAR VAR FUNC_CALL VAR VAR NUMBER VAR NUMBER ASSIGN VAR BIN_OP VAR NUMBER BIN_OP VAR BIN_OP VAR NUMBER VAR IF VAR VAR VAR NUMBER BIN_OP BIN_OP VAR VAR NUMBER NUMBER ASSIGN VAR BIN_OP VAR NUMBER NUMBER ASSIGN VAR BIN_OP VAR NUMBER BIN_OP VAR BIN_OP VAR NUMBER NUMBER EXPR FUNC_CALL VAR FUNC_CALL STRING FUNC_CALL VAR VAR VAR
|
Read problem statements in [Hindi], [Bengali], [Mandarin Chinese], [Russian], and [Vietnamese] as well.
You are given a sequence $A_{1}, A_{2}, \ldots, A_{N}$ and you have to perform the following operation exactly $X$ times:
Choose two integers $i$ and $j$ such that $1 ≤ i < j ≤ N$.
Choose a non-negative integer $p$.
Change $A_{i}$ to $A_{i} \oplus 2^{p}$, and change $A_{j}$ to $A_{j} \oplus 2^{p}$, where $\oplus$ denotes [bitwise XOR].
Find the lexicographically smallest sequence which can be obtained by performing this operation exactly $X$ times.
A sequence $B_{1}, B_{2}, \ldots, B_{N}$ is said to be lexicographically smaller than a sequence $C_{1}, C_{2}, \ldots, C_{N}$ if there is an index $i$ such that $B_{i} < C_{i}$ and for each valid $j < i$, $B_{j} = C_{j}$.
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first line of each test case contains two space-separated integers $N$ and $X$.
The second line contains $N$ space-separated integers $A_{1}, A_{2}, \ldots, A_{N}$.
------ Output ------
For each test case, print a single line containing $N$ space-separated integers ― the lexicographically smallest obtainable sequence.
------ Constraints ------
$1 ≤ T ≤ 10$
$2 ≤ N ≤ 10^{5}$
$1 ≤ X ≤ 10^{9}$
$1 ≤ A_{i} ≤ 10^{9}$ for each valid $i$
------ Subtasks ------
Subtask #1 (30 points): $N ≤ 100$
Subtask #2 (70 points): original constraints
----- Sample Input 1 ------
1
3 3
2 2 3
----- Sample Output 1 ------
0 0 3
----- explanation 1 ------
Example case 1: The original sequence is $(2, 2, 3)$. Consider the following three operations:
- Choose $i = 1$, $j = 2$ and $p = 1$. Then, $A_{1}$ changes from $2$ to $2 \oplus 2^{1} = 0$ and similarly, $A_{2}$ changes from $2$ to $2 \oplus 2^{1} = 0$. Now the sequence is $(0, 0, 3)$.
- Next, choose $i = 1$, $j = 2$ and $p = 1$. Then, $A_{1}$ changes to $0 \oplus 2^{1} = 2$ and $A_{2}$ changes to $0 \oplus 2^{1} = 2$. The sequence is $(2, 2, 3)$.
- Next, again choose $i = 1$, $j = 2$ and $p = 1$. Then, $A_{1}$ changes to $2 \oplus 2^{1} = 0$ and $A_{2}$ changes to $2 \oplus 2^{1} = 0$. The sequence is $(0, 0, 3)$ again.
We can check that after exactly 3 operations, this is the lexicographically smallest sequence we can obtain.
|
def getBits(n):
return [i for i, bit in enumerate(bin(n)[::-1]) if bit is "1"][::-1]
def solveUnpaired(unused, paired, i):
paired = set([x for x, xi in enumerate(paired) if xi])
pow2 = [(1 << x) for x in range(30)]
A[: i + 1] = [0] * (i + 1)
if unused:
A[i] = sum(pow2[bit] for bit in unused)
i -= 1
for j in range(i + 1, N - 1):
for bit in getBits(A[j]):
if bit in paired:
A[j] -= pow2[bit]
paired.remove(bit)
if not paired:
break
else:
for bit in paired:
A[N - 1] ^= pow2[bit]
def solve(N, X):
unused, paired = [], [False] * 30
for i in range(N - 1):
for bit in getBits(A[i]):
if X is 0:
unused.append(bit)
continue
paired[bit] = not paired[bit]
if paired[bit]:
X -= 1
if X is 0:
solveUnpaired(unused, paired, i)
break
else:
solveUnpaired(unused, paired, N - 2)
if X % 2 and N == 2:
return [A[0] ^ 1, A[1] ^ 1]
return A
for _ in range(int(input())):
[N, X] = [int(x) for x in input().split()]
A = [int(x) for x in input().split()]
print(*solve(N, X))
|
FUNC_DEF RETURN VAR VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER VAR STRING NUMBER FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR VAR VAR FUNC_CALL VAR VAR VAR ASSIGN VAR BIN_OP NUMBER VAR VAR FUNC_CALL VAR NUMBER ASSIGN VAR BIN_OP VAR NUMBER BIN_OP LIST NUMBER BIN_OP VAR NUMBER IF VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR VAR VAR VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR VAR VAR IF VAR VAR VAR VAR VAR VAR EXPR FUNC_CALL VAR VAR IF VAR FOR VAR VAR VAR BIN_OP VAR NUMBER VAR VAR FUNC_DEF ASSIGN VAR VAR LIST BIN_OP LIST NUMBER NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR VAR VAR IF VAR NUMBER EXPR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR VAR IF VAR VAR VAR NUMBER IF VAR NUMBER EXPR FUNC_CALL VAR VAR VAR VAR EXPR FUNC_CALL VAR VAR VAR BIN_OP VAR NUMBER IF BIN_OP VAR NUMBER VAR NUMBER RETURN LIST BIN_OP VAR NUMBER NUMBER BIN_OP VAR NUMBER NUMBER RETURN VAR FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN LIST VAR VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR EXPR FUNC_CALL VAR FUNC_CALL VAR VAR VAR
|
Read problem statements in [Hindi], [Bengali], [Mandarin Chinese], [Russian], and [Vietnamese] as well.
You are given a sequence $A_{1}, A_{2}, \ldots, A_{N}$ and you have to perform the following operation exactly $X$ times:
Choose two integers $i$ and $j$ such that $1 ≤ i < j ≤ N$.
Choose a non-negative integer $p$.
Change $A_{i}$ to $A_{i} \oplus 2^{p}$, and change $A_{j}$ to $A_{j} \oplus 2^{p}$, where $\oplus$ denotes [bitwise XOR].
Find the lexicographically smallest sequence which can be obtained by performing this operation exactly $X$ times.
A sequence $B_{1}, B_{2}, \ldots, B_{N}$ is said to be lexicographically smaller than a sequence $C_{1}, C_{2}, \ldots, C_{N}$ if there is an index $i$ such that $B_{i} < C_{i}$ and for each valid $j < i$, $B_{j} = C_{j}$.
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first line of each test case contains two space-separated integers $N$ and $X$.
The second line contains $N$ space-separated integers $A_{1}, A_{2}, \ldots, A_{N}$.
------ Output ------
For each test case, print a single line containing $N$ space-separated integers ― the lexicographically smallest obtainable sequence.
------ Constraints ------
$1 ≤ T ≤ 10$
$2 ≤ N ≤ 10^{5}$
$1 ≤ X ≤ 10^{9}$
$1 ≤ A_{i} ≤ 10^{9}$ for each valid $i$
------ Subtasks ------
Subtask #1 (30 points): $N ≤ 100$
Subtask #2 (70 points): original constraints
----- Sample Input 1 ------
1
3 3
2 2 3
----- Sample Output 1 ------
0 0 3
----- explanation 1 ------
Example case 1: The original sequence is $(2, 2, 3)$. Consider the following three operations:
- Choose $i = 1$, $j = 2$ and $p = 1$. Then, $A_{1}$ changes from $2$ to $2 \oplus 2^{1} = 0$ and similarly, $A_{2}$ changes from $2$ to $2 \oplus 2^{1} = 0$. Now the sequence is $(0, 0, 3)$.
- Next, choose $i = 1$, $j = 2$ and $p = 1$. Then, $A_{1}$ changes to $0 \oplus 2^{1} = 2$ and $A_{2}$ changes to $0 \oplus 2^{1} = 2$. The sequence is $(2, 2, 3)$.
- Next, again choose $i = 1$, $j = 2$ and $p = 1$. Then, $A_{1}$ changes to $2 \oplus 2^{1} = 0$ and $A_{2}$ changes to $2 \oplus 2^{1} = 0$. The sequence is $(0, 0, 3)$ again.
We can check that after exactly 3 operations, this is the lexicographically smallest sequence we can obtain.
|
def normal_ans(b):
for i in range(len(b)):
b[i] = str(int("".join(b[i]), 2))
print(" ".join(b))
def abnormal_ans(b):
b[-1] = str(int("".join(b[-1]), 2) ^ 1)
b[-2] = str(int("".join(b[-2]), 2) ^ 1)
for i in range(len(b[:-2])):
b[i] = str(int("".join(b[i]), 2))
print(" ".join(b))
def compute_min(a):
b = []
one_count = [0] * 30
for i in a:
bin_string = bin(i)[2:].zfill(30)
for i in range(30):
if bin_string[i] == "1":
one_count[i] += 1
total = 0
bin_string = [c for c in bin_string]
for i in range(30):
total += one_count[i] // 2
one_count[i] = one_count[i] % 2
if one_count[i] % 2 == 0 and bin_string[i] == "1":
bin_string[i] = "0"
if one_count[i] % 2 != 0 and bin_string[i] == "1":
one_count[i] -= 1
elif one_count[i] % 2 != 0 and bin_string[i] != "1":
total += 1
bin_string[i] = "1"
final_string = [str(i) for i in bin_string]
return total, "".join(final_string)
t = int(input())
for _ in range(t):
N, X = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
min_req, final_string = compute_min(a)
if X < min_req:
b = []
for i in a:
bin_string = bin(i)[2:].zfill(30)
bin_string = [c for c in bin_string]
b.append(bin_string)
x = 0
for i in range(N - 1):
if x == X:
break
for j in range(30):
if b[i][j] == "1":
pair_not_found = True
pass
else:
continue
for k in range(i + 1, N):
if b[i][j] == b[k][j]:
b[i][j] = "0"
b[k][j] = "0"
x += 1
pair_not_found = False
break
if pair_not_found:
b[-1][j] = "1"
b[i][j] = "0"
x += 1
pair_not_found = False
if x == X:
break
no_of_ops = 0
else:
no_of_ops = X - min_req
b = [bin(0)[2:].zfill(30)] * N
for i in range(len(b)):
b[i] = [c for c in b[i]]
b[-1] = final_string
if N == 2:
if no_of_ops % 2 != 0:
abnormal_ans(b)
else:
normal_ans(b)
elif no_of_ops == 1:
abnormal_ans(b)
else:
normal_ans(b)
|
FUNC_DEF FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL STRING VAR VAR NUMBER EXPR FUNC_CALL VAR FUNC_CALL STRING VAR FUNC_DEF ASSIGN VAR NUMBER FUNC_CALL VAR BIN_OP FUNC_CALL VAR FUNC_CALL STRING VAR NUMBER NUMBER NUMBER ASSIGN VAR NUMBER FUNC_CALL VAR BIN_OP FUNC_CALL VAR FUNC_CALL STRING VAR NUMBER NUMBER NUMBER FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER ASSIGN VAR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL STRING VAR VAR NUMBER EXPR FUNC_CALL VAR FUNC_CALL STRING VAR FUNC_DEF ASSIGN VAR LIST ASSIGN VAR BIN_OP LIST NUMBER NUMBER FOR VAR VAR ASSIGN VAR FUNC_CALL FUNC_CALL VAR VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER IF VAR VAR STRING VAR VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR VAR VAR VAR FOR VAR FUNC_CALL VAR NUMBER VAR BIN_OP VAR VAR NUMBER ASSIGN VAR VAR BIN_OP VAR VAR NUMBER IF BIN_OP VAR VAR NUMBER NUMBER VAR VAR STRING ASSIGN VAR VAR STRING IF BIN_OP VAR VAR NUMBER NUMBER VAR VAR STRING VAR VAR NUMBER IF BIN_OP VAR VAR NUMBER NUMBER VAR VAR STRING VAR NUMBER ASSIGN VAR VAR STRING ASSIGN VAR FUNC_CALL VAR VAR VAR VAR RETURN VAR FUNC_CALL STRING VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR VAR FUNC_CALL VAR VAR IF VAR VAR ASSIGN VAR LIST FOR VAR VAR ASSIGN VAR FUNC_CALL FUNC_CALL VAR VAR NUMBER NUMBER ASSIGN VAR VAR VAR VAR EXPR FUNC_CALL VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER IF VAR VAR FOR VAR FUNC_CALL VAR NUMBER IF VAR VAR VAR STRING ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR IF VAR VAR VAR VAR VAR VAR ASSIGN VAR VAR VAR STRING ASSIGN VAR VAR VAR STRING VAR NUMBER ASSIGN VAR NUMBER IF VAR ASSIGN VAR NUMBER VAR STRING ASSIGN VAR VAR VAR STRING VAR NUMBER ASSIGN VAR NUMBER IF VAR VAR ASSIGN VAR NUMBER ASSIGN VAR BIN_OP VAR VAR ASSIGN VAR BIN_OP LIST FUNC_CALL FUNC_CALL VAR NUMBER NUMBER NUMBER VAR FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR ASSIGN VAR NUMBER VAR IF VAR NUMBER IF BIN_OP VAR NUMBER NUMBER EXPR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR IF VAR NUMBER EXPR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR
|
Read problem statements in [Hindi], [Bengali], [Mandarin Chinese], [Russian], and [Vietnamese] as well.
You are given a sequence $A_{1}, A_{2}, \ldots, A_{N}$ and you have to perform the following operation exactly $X$ times:
Choose two integers $i$ and $j$ such that $1 ≤ i < j ≤ N$.
Choose a non-negative integer $p$.
Change $A_{i}$ to $A_{i} \oplus 2^{p}$, and change $A_{j}$ to $A_{j} \oplus 2^{p}$, where $\oplus$ denotes [bitwise XOR].
Find the lexicographically smallest sequence which can be obtained by performing this operation exactly $X$ times.
A sequence $B_{1}, B_{2}, \ldots, B_{N}$ is said to be lexicographically smaller than a sequence $C_{1}, C_{2}, \ldots, C_{N}$ if there is an index $i$ such that $B_{i} < C_{i}$ and for each valid $j < i$, $B_{j} = C_{j}$.
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first line of each test case contains two space-separated integers $N$ and $X$.
The second line contains $N$ space-separated integers $A_{1}, A_{2}, \ldots, A_{N}$.
------ Output ------
For each test case, print a single line containing $N$ space-separated integers ― the lexicographically smallest obtainable sequence.
------ Constraints ------
$1 ≤ T ≤ 10$
$2 ≤ N ≤ 10^{5}$
$1 ≤ X ≤ 10^{9}$
$1 ≤ A_{i} ≤ 10^{9}$ for each valid $i$
------ Subtasks ------
Subtask #1 (30 points): $N ≤ 100$
Subtask #2 (70 points): original constraints
----- Sample Input 1 ------
1
3 3
2 2 3
----- Sample Output 1 ------
0 0 3
----- explanation 1 ------
Example case 1: The original sequence is $(2, 2, 3)$. Consider the following three operations:
- Choose $i = 1$, $j = 2$ and $p = 1$. Then, $A_{1}$ changes from $2$ to $2 \oplus 2^{1} = 0$ and similarly, $A_{2}$ changes from $2$ to $2 \oplus 2^{1} = 0$. Now the sequence is $(0, 0, 3)$.
- Next, choose $i = 1$, $j = 2$ and $p = 1$. Then, $A_{1}$ changes to $0 \oplus 2^{1} = 2$ and $A_{2}$ changes to $0 \oplus 2^{1} = 2$. The sequence is $(2, 2, 3)$.
- Next, again choose $i = 1$, $j = 2$ and $p = 1$. Then, $A_{1}$ changes to $2 \oplus 2^{1} = 0$ and $A_{2}$ changes to $2 \oplus 2^{1} = 0$. The sequence is $(0, 0, 3)$ again.
We can check that after exactly 3 operations, this is the lexicographically smallest sequence we can obtain.
|
for _ in range(int(input())):
N, X = map(int, input().split())
array = list(map(int, input().split()))
if N != len(array):
raise Exception("Wrong data.")
maxnum = max(array)
digits = 1
num = 1
while num < maxnum:
num <<= 1
digits += 1
if num != maxnum:
digits -= 1
maxmask = 1 << digits - 1
extra = 0
N -= 1
for index in range(N):
if X == 0 and extra == 0:
break
elif array[index] != 0:
freeremove = extra & array[index]
extra ^= freeremove
array[index] ^= freeremove
if X >= digits:
num = array[index]
array[index] = 0
extra ^= num
count = 0
while num != 0:
count += num & 1
num >>= 1
X -= count
else:
mask = maxmask
while array[index] != 0 and X != 0:
if mask & array[index] != 0:
array[index] ^= mask
extra ^= mask
X -= 1
mask >>= 1
array[N] ^= extra
if X == 1 or N == 1 and X % 2 == 1:
array[-1] ^= 1
array[-2] ^= 1
print(*array)
|
FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR IF VAR FUNC_CALL VAR VAR FUNC_CALL VAR STRING ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER WHILE VAR VAR VAR NUMBER VAR NUMBER IF VAR VAR VAR NUMBER ASSIGN VAR BIN_OP NUMBER BIN_OP VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER FOR VAR FUNC_CALL VAR VAR IF VAR NUMBER VAR NUMBER IF VAR VAR NUMBER ASSIGN VAR BIN_OP VAR VAR VAR VAR VAR VAR VAR VAR IF VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR VAR NUMBER VAR VAR ASSIGN VAR NUMBER WHILE VAR NUMBER VAR BIN_OP VAR NUMBER VAR NUMBER VAR VAR ASSIGN VAR VAR WHILE VAR VAR NUMBER VAR NUMBER IF BIN_OP VAR VAR VAR NUMBER VAR VAR VAR VAR VAR VAR NUMBER VAR NUMBER VAR VAR VAR IF VAR NUMBER VAR NUMBER BIN_OP VAR NUMBER NUMBER VAR NUMBER NUMBER VAR NUMBER NUMBER EXPR FUNC_CALL VAR VAR
|
Read problem statements in [Hindi], [Bengali], [Mandarin Chinese], [Russian], and [Vietnamese] as well.
You are given a sequence $A_{1}, A_{2}, \ldots, A_{N}$ and you have to perform the following operation exactly $X$ times:
Choose two integers $i$ and $j$ such that $1 ≤ i < j ≤ N$.
Choose a non-negative integer $p$.
Change $A_{i}$ to $A_{i} \oplus 2^{p}$, and change $A_{j}$ to $A_{j} \oplus 2^{p}$, where $\oplus$ denotes [bitwise XOR].
Find the lexicographically smallest sequence which can be obtained by performing this operation exactly $X$ times.
A sequence $B_{1}, B_{2}, \ldots, B_{N}$ is said to be lexicographically smaller than a sequence $C_{1}, C_{2}, \ldots, C_{N}$ if there is an index $i$ such that $B_{i} < C_{i}$ and for each valid $j < i$, $B_{j} = C_{j}$.
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first line of each test case contains two space-separated integers $N$ and $X$.
The second line contains $N$ space-separated integers $A_{1}, A_{2}, \ldots, A_{N}$.
------ Output ------
For each test case, print a single line containing $N$ space-separated integers ― the lexicographically smallest obtainable sequence.
------ Constraints ------
$1 ≤ T ≤ 10$
$2 ≤ N ≤ 10^{5}$
$1 ≤ X ≤ 10^{9}$
$1 ≤ A_{i} ≤ 10^{9}$ for each valid $i$
------ Subtasks ------
Subtask #1 (30 points): $N ≤ 100$
Subtask #2 (70 points): original constraints
----- Sample Input 1 ------
1
3 3
2 2 3
----- Sample Output 1 ------
0 0 3
----- explanation 1 ------
Example case 1: The original sequence is $(2, 2, 3)$. Consider the following three operations:
- Choose $i = 1$, $j = 2$ and $p = 1$. Then, $A_{1}$ changes from $2$ to $2 \oplus 2^{1} = 0$ and similarly, $A_{2}$ changes from $2$ to $2 \oplus 2^{1} = 0$. Now the sequence is $(0, 0, 3)$.
- Next, choose $i = 1$, $j = 2$ and $p = 1$. Then, $A_{1}$ changes to $0 \oplus 2^{1} = 2$ and $A_{2}$ changes to $0 \oplus 2^{1} = 2$. The sequence is $(2, 2, 3)$.
- Next, again choose $i = 1$, $j = 2$ and $p = 1$. Then, $A_{1}$ changes to $2 \oplus 2^{1} = 0$ and $A_{2}$ changes to $2 \oplus 2^{1} = 0$. The sequence is $(0, 0, 3)$ again.
We can check that after exactly 3 operations, this is the lexicographically smallest sequence we can obtain.
|
def get_ops(n):
return bin(n).count("1")
for _ in range(int(input())):
N, X = map(int, input().split())
lst = list(map(int, input().split()))
for i in range(N - 1):
if lst[i] == 0:
continue
ops = get_ops(lst[i])
if ops <= X:
val = lst[i]
curr_ind = i + 1
while val > 0 and curr_ind < N:
common_val = val & lst[curr_ind]
val ^= common_val
lst[curr_ind] ^= common_val
curr_ind += 1
if curr_ind >= N - 1:
lst[-1] ^= val
break
lst[i] = 0
X -= ops
if X == 0:
break
else:
bin_val = list(bin(lst[i])[2:])
while X != 0:
temp = bin_val.pop(0)
if temp == "1":
X -= 1
bin_val = "".join(bin_val)
val = int(bin_val, 2)
xor_val = lst[i] ^ val
curr_ind = i + 1
while xor_val > 0 and curr_ind < N:
common_val = xor_val & lst[curr_ind]
xor_val ^= common_val
lst[curr_ind] ^= common_val
curr_ind += 1
if curr_ind >= N - 1:
lst[-1] ^= xor_val
break
lst[i] = val
X = 0
break
if X == 1 or X % 2 == 1 and N == 2:
lst[-1] ^= 1
lst[-2] ^= 1
print(*lst)
|
FUNC_DEF RETURN FUNC_CALL FUNC_CALL VAR VAR STRING FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER IF VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR IF VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR BIN_OP VAR NUMBER WHILE VAR NUMBER VAR VAR ASSIGN VAR BIN_OP VAR VAR VAR VAR VAR VAR VAR VAR VAR NUMBER IF VAR BIN_OP VAR NUMBER VAR NUMBER VAR ASSIGN VAR VAR NUMBER VAR VAR IF VAR NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR VAR NUMBER WHILE VAR NUMBER ASSIGN VAR FUNC_CALL VAR NUMBER IF VAR STRING VAR NUMBER ASSIGN VAR FUNC_CALL STRING VAR ASSIGN VAR FUNC_CALL VAR VAR NUMBER ASSIGN VAR BIN_OP VAR VAR VAR ASSIGN VAR BIN_OP VAR NUMBER WHILE VAR NUMBER VAR VAR ASSIGN VAR BIN_OP VAR VAR VAR VAR VAR VAR VAR VAR VAR NUMBER IF VAR BIN_OP VAR NUMBER VAR NUMBER VAR ASSIGN VAR VAR VAR ASSIGN VAR NUMBER IF VAR NUMBER BIN_OP VAR NUMBER NUMBER VAR NUMBER VAR NUMBER NUMBER VAR NUMBER NUMBER EXPR FUNC_CALL VAR VAR
|
Read problem statements in [Hindi], [Bengali], [Mandarin Chinese], [Russian], and [Vietnamese] as well.
You are given a sequence $A_{1}, A_{2}, \ldots, A_{N}$ and you have to perform the following operation exactly $X$ times:
Choose two integers $i$ and $j$ such that $1 ≤ i < j ≤ N$.
Choose a non-negative integer $p$.
Change $A_{i}$ to $A_{i} \oplus 2^{p}$, and change $A_{j}$ to $A_{j} \oplus 2^{p}$, where $\oplus$ denotes [bitwise XOR].
Find the lexicographically smallest sequence which can be obtained by performing this operation exactly $X$ times.
A sequence $B_{1}, B_{2}, \ldots, B_{N}$ is said to be lexicographically smaller than a sequence $C_{1}, C_{2}, \ldots, C_{N}$ if there is an index $i$ such that $B_{i} < C_{i}$ and for each valid $j < i$, $B_{j} = C_{j}$.
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first line of each test case contains two space-separated integers $N$ and $X$.
The second line contains $N$ space-separated integers $A_{1}, A_{2}, \ldots, A_{N}$.
------ Output ------
For each test case, print a single line containing $N$ space-separated integers ― the lexicographically smallest obtainable sequence.
------ Constraints ------
$1 ≤ T ≤ 10$
$2 ≤ N ≤ 10^{5}$
$1 ≤ X ≤ 10^{9}$
$1 ≤ A_{i} ≤ 10^{9}$ for each valid $i$
------ Subtasks ------
Subtask #1 (30 points): $N ≤ 100$
Subtask #2 (70 points): original constraints
----- Sample Input 1 ------
1
3 3
2 2 3
----- Sample Output 1 ------
0 0 3
----- explanation 1 ------
Example case 1: The original sequence is $(2, 2, 3)$. Consider the following three operations:
- Choose $i = 1$, $j = 2$ and $p = 1$. Then, $A_{1}$ changes from $2$ to $2 \oplus 2^{1} = 0$ and similarly, $A_{2}$ changes from $2$ to $2 \oplus 2^{1} = 0$. Now the sequence is $(0, 0, 3)$.
- Next, choose $i = 1$, $j = 2$ and $p = 1$. Then, $A_{1}$ changes to $0 \oplus 2^{1} = 2$ and $A_{2}$ changes to $0 \oplus 2^{1} = 2$. The sequence is $(2, 2, 3)$.
- Next, again choose $i = 1$, $j = 2$ and $p = 1$. Then, $A_{1}$ changes to $2 \oplus 2^{1} = 0$ and $A_{2}$ changes to $2 \oplus 2^{1} = 0$. The sequence is $(0, 0, 3)$ again.
We can check that after exactly 3 operations, this is the lexicographically smallest sequence we can obtain.
|
def getBits(a):
return [i for i, ai in enumerate(bin(a)[2:][::-1]) if ai == "1"][::-1]
def solve_unpaired(i):
for j in range(i, N - 1):
if not unpaired_bits:
break
for bit in getBits(A[j]):
if bit in unpaired_bits:
A[j] -= 2**bit
unpaired_bits.remove(bit)
if not unpaired_bits:
break
else:
for bit in unpaired_bits:
A[N - 1] ^= 1 << bit
def solve(N, X):
solved_unused, unused = False, []
for i in range(N - 1):
if solved_unused:
ans = [0] * (i - 1)
A[i - 1] = 0
for bit in unused:
A[i - 1] += 2**bit
solve_unpaired(i - 1)
ans += A[i - 1 :]
break
elif X == 0:
ans = [0] * i
solve_unpaired(i)
ans += A[i:]
break
for bit in getBits(A[i]):
if X:
if bit in unpaired_bits:
unpaired_bits.remove(bit)
else:
X -= 1
unpaired_bits.add(bit)
else:
unused.append(bit)
solved_unused = True
else:
if solved_unused:
ans = [0] * (N - 2)
A[N - 2] = 0
for bit in unused:
A[N - 2] += 2**bit
solve_unpaired(N - 2)
ans += A[N - 2 :]
else:
for bit in unpaired_bits:
A[N - 1] ^= 2**bit
ans = [0] * (N - 1) + [A[N - 1]]
if X % 2 and N == 2:
ans = [ans[0] ^ 1, ans[1] ^ 1]
return ans
for _ in range(int(input())):
unpaired_bits = set()
[N, X] = [int(x) for x in input().split()]
A = [int(x) for x in input().split()]
print(*solve(N, X))
|
FUNC_DEF RETURN VAR VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER NUMBER VAR STRING NUMBER FUNC_DEF FOR VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER IF VAR FOR VAR FUNC_CALL VAR VAR VAR IF VAR VAR VAR VAR BIN_OP NUMBER VAR EXPR FUNC_CALL VAR VAR IF VAR FOR VAR VAR VAR BIN_OP VAR NUMBER BIN_OP NUMBER VAR FUNC_DEF ASSIGN VAR VAR NUMBER LIST FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER IF VAR ASSIGN VAR BIN_OP LIST NUMBER BIN_OP VAR NUMBER ASSIGN VAR BIN_OP VAR NUMBER NUMBER FOR VAR VAR VAR BIN_OP VAR NUMBER BIN_OP NUMBER VAR EXPR FUNC_CALL VAR BIN_OP VAR NUMBER VAR VAR BIN_OP VAR NUMBER IF VAR NUMBER ASSIGN VAR BIN_OP LIST NUMBER VAR EXPR FUNC_CALL VAR VAR VAR VAR VAR FOR VAR FUNC_CALL VAR VAR VAR IF VAR IF VAR VAR EXPR FUNC_CALL VAR VAR VAR NUMBER EXPR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR ASSIGN VAR NUMBER IF VAR ASSIGN VAR BIN_OP LIST NUMBER BIN_OP VAR NUMBER ASSIGN VAR BIN_OP VAR NUMBER NUMBER FOR VAR VAR VAR BIN_OP VAR NUMBER BIN_OP NUMBER VAR EXPR FUNC_CALL VAR BIN_OP VAR NUMBER VAR VAR BIN_OP VAR NUMBER FOR VAR VAR VAR BIN_OP VAR NUMBER BIN_OP NUMBER VAR ASSIGN VAR BIN_OP BIN_OP LIST NUMBER BIN_OP VAR NUMBER LIST VAR BIN_OP VAR NUMBER IF BIN_OP VAR NUMBER VAR NUMBER ASSIGN VAR LIST BIN_OP VAR NUMBER NUMBER BIN_OP VAR NUMBER NUMBER RETURN VAR FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR ASSIGN LIST VAR VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR EXPR FUNC_CALL VAR FUNC_CALL VAR VAR VAR
|
Read problem statements in [Hindi], [Bengali], [Mandarin Chinese], [Russian], and [Vietnamese] as well.
You are given a sequence $A_{1}, A_{2}, \ldots, A_{N}$ and you have to perform the following operation exactly $X$ times:
Choose two integers $i$ and $j$ such that $1 ≤ i < j ≤ N$.
Choose a non-negative integer $p$.
Change $A_{i}$ to $A_{i} \oplus 2^{p}$, and change $A_{j}$ to $A_{j} \oplus 2^{p}$, where $\oplus$ denotes [bitwise XOR].
Find the lexicographically smallest sequence which can be obtained by performing this operation exactly $X$ times.
A sequence $B_{1}, B_{2}, \ldots, B_{N}$ is said to be lexicographically smaller than a sequence $C_{1}, C_{2}, \ldots, C_{N}$ if there is an index $i$ such that $B_{i} < C_{i}$ and for each valid $j < i$, $B_{j} = C_{j}$.
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first line of each test case contains two space-separated integers $N$ and $X$.
The second line contains $N$ space-separated integers $A_{1}, A_{2}, \ldots, A_{N}$.
------ Output ------
For each test case, print a single line containing $N$ space-separated integers ― the lexicographically smallest obtainable sequence.
------ Constraints ------
$1 ≤ T ≤ 10$
$2 ≤ N ≤ 10^{5}$
$1 ≤ X ≤ 10^{9}$
$1 ≤ A_{i} ≤ 10^{9}$ for each valid $i$
------ Subtasks ------
Subtask #1 (30 points): $N ≤ 100$
Subtask #2 (70 points): original constraints
----- Sample Input 1 ------
1
3 3
2 2 3
----- Sample Output 1 ------
0 0 3
----- explanation 1 ------
Example case 1: The original sequence is $(2, 2, 3)$. Consider the following three operations:
- Choose $i = 1$, $j = 2$ and $p = 1$. Then, $A_{1}$ changes from $2$ to $2 \oplus 2^{1} = 0$ and similarly, $A_{2}$ changes from $2$ to $2 \oplus 2^{1} = 0$. Now the sequence is $(0, 0, 3)$.
- Next, choose $i = 1$, $j = 2$ and $p = 1$. Then, $A_{1}$ changes to $0 \oplus 2^{1} = 2$ and $A_{2}$ changes to $0 \oplus 2^{1} = 2$. The sequence is $(2, 2, 3)$.
- Next, again choose $i = 1$, $j = 2$ and $p = 1$. Then, $A_{1}$ changes to $2 \oplus 2^{1} = 0$ and $A_{2}$ changes to $2 \oplus 2^{1} = 0$. The sequence is $(0, 0, 3)$ again.
We can check that after exactly 3 operations, this is the lexicographically smallest sequence we can obtain.
|
for testCase in range(int(input())):
R = 0
N, X = map(int, input().split())
array = list(map(int, input().split()))
for i in range(N - 1):
binary = bin(array[i])
if X >= binary.count("1"):
X = X - binary.count("1")
for j in range(i + 1, N):
c = array[i] & array[j]
array[i] = array[i] - c
array[j] = array[j] - c
if array[i] == 0:
break
if array[i] != 0:
if N - 1 - i > 1:
R = 1
array[N - 1] = array[i] ^ array[N - 1]
array[i] = 0
elif X < binary.count("1") and X > 0:
z = binary[2:]
m = ""
for j in range(len(z)):
if X > 0:
if z[j] == "1":
X -= 1
m = m + "1"
else:
m = m + z[j]
else:
m = m + "0"
array[i] = array[i] - int(m, 2)
m = int(m, 2)
for j in range(i + 1, N):
c = m & array[j]
m = m - c
array[j] = array[j] - c
array[N - 1] = m ^ array[N - 1]
else:
break
if X % 2 != 0 and R == 0:
array[N - 2] = array[N - 2] ^ 1
array[N - 1] = array[N - 1] ^ 1
for i in range(N):
print(array[i], end=" ")
print()
|
FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR NUMBER ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR IF VAR FUNC_CALL VAR STRING ASSIGN VAR BIN_OP VAR FUNC_CALL VAR STRING FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR ASSIGN VAR BIN_OP VAR VAR VAR VAR ASSIGN VAR VAR BIN_OP VAR VAR VAR ASSIGN VAR VAR BIN_OP VAR VAR VAR IF VAR VAR NUMBER IF VAR VAR NUMBER IF BIN_OP BIN_OP VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR BIN_OP VAR NUMBER BIN_OP VAR VAR VAR BIN_OP VAR NUMBER ASSIGN VAR VAR NUMBER IF VAR FUNC_CALL VAR STRING VAR NUMBER ASSIGN VAR VAR NUMBER ASSIGN VAR STRING FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR IF VAR NUMBER IF VAR VAR STRING VAR NUMBER ASSIGN VAR BIN_OP VAR STRING ASSIGN VAR BIN_OP VAR VAR VAR ASSIGN VAR BIN_OP VAR STRING ASSIGN VAR VAR BIN_OP VAR VAR FUNC_CALL VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR ASSIGN VAR BIN_OP VAR VAR VAR ASSIGN VAR BIN_OP VAR VAR ASSIGN VAR VAR BIN_OP VAR VAR VAR ASSIGN VAR BIN_OP VAR NUMBER BIN_OP VAR VAR BIN_OP VAR NUMBER IF BIN_OP VAR NUMBER NUMBER VAR NUMBER ASSIGN VAR BIN_OP VAR NUMBER BIN_OP VAR BIN_OP VAR NUMBER NUMBER ASSIGN VAR BIN_OP VAR NUMBER BIN_OP VAR BIN_OP VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR VAR STRING EXPR FUNC_CALL VAR
|
Read problem statements in [Hindi], [Bengali], [Mandarin Chinese], [Russian], and [Vietnamese] as well.
You are given a sequence $A_{1}, A_{2}, \ldots, A_{N}$ and you have to perform the following operation exactly $X$ times:
Choose two integers $i$ and $j$ such that $1 ≤ i < j ≤ N$.
Choose a non-negative integer $p$.
Change $A_{i}$ to $A_{i} \oplus 2^{p}$, and change $A_{j}$ to $A_{j} \oplus 2^{p}$, where $\oplus$ denotes [bitwise XOR].
Find the lexicographically smallest sequence which can be obtained by performing this operation exactly $X$ times.
A sequence $B_{1}, B_{2}, \ldots, B_{N}$ is said to be lexicographically smaller than a sequence $C_{1}, C_{2}, \ldots, C_{N}$ if there is an index $i$ such that $B_{i} < C_{i}$ and for each valid $j < i$, $B_{j} = C_{j}$.
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first line of each test case contains two space-separated integers $N$ and $X$.
The second line contains $N$ space-separated integers $A_{1}, A_{2}, \ldots, A_{N}$.
------ Output ------
For each test case, print a single line containing $N$ space-separated integers ― the lexicographically smallest obtainable sequence.
------ Constraints ------
$1 ≤ T ≤ 10$
$2 ≤ N ≤ 10^{5}$
$1 ≤ X ≤ 10^{9}$
$1 ≤ A_{i} ≤ 10^{9}$ for each valid $i$
------ Subtasks ------
Subtask #1 (30 points): $N ≤ 100$
Subtask #2 (70 points): original constraints
----- Sample Input 1 ------
1
3 3
2 2 3
----- Sample Output 1 ------
0 0 3
----- explanation 1 ------
Example case 1: The original sequence is $(2, 2, 3)$. Consider the following three operations:
- Choose $i = 1$, $j = 2$ and $p = 1$. Then, $A_{1}$ changes from $2$ to $2 \oplus 2^{1} = 0$ and similarly, $A_{2}$ changes from $2$ to $2 \oplus 2^{1} = 0$. Now the sequence is $(0, 0, 3)$.
- Next, choose $i = 1$, $j = 2$ and $p = 1$. Then, $A_{1}$ changes to $0 \oplus 2^{1} = 2$ and $A_{2}$ changes to $0 \oplus 2^{1} = 2$. The sequence is $(2, 2, 3)$.
- Next, again choose $i = 1$, $j = 2$ and $p = 1$. Then, $A_{1}$ changes to $2 \oplus 2^{1} = 0$ and $A_{2}$ changes to $2 \oplus 2^{1} = 0$. The sequence is $(0, 0, 3)$ again.
We can check that after exactly 3 operations, this is the lexicographically smallest sequence we can obtain.
|
t = int(input())
while t > 0:
n, x = map(int, input().split())
temp1 = x
l = list(map(int, input().split()))
h = l[0:]
flag = 0
for i in range(n - 1):
if flag == 1:
break
if x == 0:
break
p = bin(l[i])
c = 0
s = p[2:]
for j in s:
if j == "1":
c += 1
if x - c > 0:
l[i + 1] ^= l[i]
l[i] = 0
x -= c
elif x - c <= 0:
flag = 1
for i in range(n - 1):
if temp1 <= 0:
l = h
break
p = bin(h[i])
s = p[2:]
z, sum1, c1 = len(s), [], 0
for k in range(z):
if c1 < temp1:
if s[k] == "1":
sum1.append(2 ** (z - k - 1))
c1 += 1
temp1 -= c1
for y in sum1:
for w in range(i + 1, n - 1):
if h[w] ^ y < h[w]:
h[w] ^= y
h[i] -= y
break
else:
h[-1] ^= w
h[i] -= y
if n == 2:
if x % 2 == 0:
pass
else:
l[0] ^= 1
l[1] ^= 1
for i in l:
print(i, end=" ")
print()
t -= 1
|
ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR WHILE VAR NUMBER ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER IF VAR NUMBER IF VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR ASSIGN VAR NUMBER ASSIGN VAR VAR NUMBER FOR VAR VAR IF VAR STRING VAR NUMBER IF BIN_OP VAR VAR NUMBER VAR BIN_OP VAR NUMBER VAR VAR ASSIGN VAR VAR NUMBER VAR VAR IF BIN_OP VAR VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER IF VAR NUMBER ASSIGN VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR ASSIGN VAR VAR NUMBER ASSIGN VAR VAR VAR FUNC_CALL VAR VAR LIST NUMBER FOR VAR FUNC_CALL VAR VAR IF VAR VAR IF VAR VAR STRING EXPR FUNC_CALL VAR BIN_OP NUMBER BIN_OP BIN_OP VAR VAR NUMBER VAR NUMBER VAR VAR FOR VAR VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER BIN_OP VAR NUMBER IF BIN_OP VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR NUMBER VAR VAR VAR VAR IF VAR NUMBER IF BIN_OP VAR NUMBER NUMBER VAR NUMBER NUMBER VAR NUMBER NUMBER FOR VAR VAR EXPR FUNC_CALL VAR VAR STRING EXPR FUNC_CALL VAR VAR NUMBER
|
Read problem statements in [Hindi], [Bengali], [Mandarin Chinese], [Russian], and [Vietnamese] as well.
You are given a sequence $A_{1}, A_{2}, \ldots, A_{N}$ and you have to perform the following operation exactly $X$ times:
Choose two integers $i$ and $j$ such that $1 ≤ i < j ≤ N$.
Choose a non-negative integer $p$.
Change $A_{i}$ to $A_{i} \oplus 2^{p}$, and change $A_{j}$ to $A_{j} \oplus 2^{p}$, where $\oplus$ denotes [bitwise XOR].
Find the lexicographically smallest sequence which can be obtained by performing this operation exactly $X$ times.
A sequence $B_{1}, B_{2}, \ldots, B_{N}$ is said to be lexicographically smaller than a sequence $C_{1}, C_{2}, \ldots, C_{N}$ if there is an index $i$ such that $B_{i} < C_{i}$ and for each valid $j < i$, $B_{j} = C_{j}$.
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first line of each test case contains two space-separated integers $N$ and $X$.
The second line contains $N$ space-separated integers $A_{1}, A_{2}, \ldots, A_{N}$.
------ Output ------
For each test case, print a single line containing $N$ space-separated integers ― the lexicographically smallest obtainable sequence.
------ Constraints ------
$1 ≤ T ≤ 10$
$2 ≤ N ≤ 10^{5}$
$1 ≤ X ≤ 10^{9}$
$1 ≤ A_{i} ≤ 10^{9}$ for each valid $i$
------ Subtasks ------
Subtask #1 (30 points): $N ≤ 100$
Subtask #2 (70 points): original constraints
----- Sample Input 1 ------
1
3 3
2 2 3
----- Sample Output 1 ------
0 0 3
----- explanation 1 ------
Example case 1: The original sequence is $(2, 2, 3)$. Consider the following three operations:
- Choose $i = 1$, $j = 2$ and $p = 1$. Then, $A_{1}$ changes from $2$ to $2 \oplus 2^{1} = 0$ and similarly, $A_{2}$ changes from $2$ to $2 \oplus 2^{1} = 0$. Now the sequence is $(0, 0, 3)$.
- Next, choose $i = 1$, $j = 2$ and $p = 1$. Then, $A_{1}$ changes to $0 \oplus 2^{1} = 2$ and $A_{2}$ changes to $0 \oplus 2^{1} = 2$. The sequence is $(2, 2, 3)$.
- Next, again choose $i = 1$, $j = 2$ and $p = 1$. Then, $A_{1}$ changes to $2 \oplus 2^{1} = 0$ and $A_{2}$ changes to $2 \oplus 2^{1} = 0$. The sequence is $(0, 0, 3)$ again.
We can check that after exactly 3 operations, this is the lexicographically smallest sequence we can obtain.
|
def solve(A, x):
origX = x
toUse = 0
N = len(A)
i = 0
printState(i, A, x, toUse)
finished = False
while i < N - 1 and (x > 0 or toUse > 0):
if x >= bin(A[i]).count("1"):
x -= bin(A[i] & ~toUse).count("1")
toUse = A[i] ^ toUse
A[i] = 0
else:
_toUse = toUse
toUse = ~A[i] & toUse
A[i] = A[i] & ~_toUse
printState(i, A, x, toUse, "Point 1")
index = 29
while A[i] and x and index > -1:
if A[i] >= 2**index:
x -= 1
A[i] -= 2**index
toUse = 2**index ^ toUse
index -= 1
printState(i, A, x, toUse, "Point 2")
i += 1
A[-1] = A[-1] ^ toUse
if origX == 1 and x == 1 or N == 2 and x % 2:
A[-2] = 1
A[-1] = A[-1] ^ 1
printState(N - 1, A, x, toUse)
return None
def printState(i, A, x, toUse, message=""):
return None
T = int(input())
for tc in range(T):
N, X = [int(x) for x in input().split(" ")]
A = [int(x) for x in input().split(" ")]
solve(A, X)
for x in A[:-1]:
print(x, end=" ")
print(A[-1])
|
FUNC_DEF ASSIGN VAR VAR ASSIGN VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER EXPR FUNC_CALL VAR VAR VAR VAR VAR ASSIGN VAR NUMBER WHILE VAR BIN_OP VAR NUMBER VAR NUMBER VAR NUMBER IF VAR FUNC_CALL FUNC_CALL VAR VAR VAR STRING VAR FUNC_CALL FUNC_CALL VAR BIN_OP VAR VAR VAR STRING ASSIGN VAR BIN_OP VAR VAR VAR ASSIGN VAR VAR NUMBER ASSIGN VAR VAR ASSIGN VAR BIN_OP VAR VAR VAR ASSIGN VAR VAR BIN_OP VAR VAR VAR EXPR FUNC_CALL VAR VAR VAR VAR VAR STRING ASSIGN VAR NUMBER WHILE VAR VAR VAR VAR NUMBER IF VAR VAR BIN_OP NUMBER VAR VAR NUMBER VAR VAR BIN_OP NUMBER VAR ASSIGN VAR BIN_OP BIN_OP NUMBER VAR VAR VAR NUMBER EXPR FUNC_CALL VAR VAR VAR VAR VAR STRING VAR NUMBER ASSIGN VAR NUMBER BIN_OP VAR NUMBER VAR IF VAR NUMBER VAR NUMBER VAR NUMBER BIN_OP VAR NUMBER ASSIGN VAR NUMBER NUMBER ASSIGN VAR NUMBER BIN_OP VAR NUMBER NUMBER EXPR FUNC_CALL VAR BIN_OP VAR NUMBER VAR VAR VAR RETURN NONE FUNC_DEF STRING RETURN NONE ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR STRING ASSIGN VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR STRING EXPR FUNC_CALL VAR VAR VAR FOR VAR VAR NUMBER EXPR FUNC_CALL VAR VAR STRING EXPR FUNC_CALL VAR VAR NUMBER
|
Read problem statements in [Hindi], [Bengali], [Mandarin Chinese], [Russian], and [Vietnamese] as well.
You are given a sequence $A_{1}, A_{2}, \ldots, A_{N}$ and you have to perform the following operation exactly $X$ times:
Choose two integers $i$ and $j$ such that $1 ≤ i < j ≤ N$.
Choose a non-negative integer $p$.
Change $A_{i}$ to $A_{i} \oplus 2^{p}$, and change $A_{j}$ to $A_{j} \oplus 2^{p}$, where $\oplus$ denotes [bitwise XOR].
Find the lexicographically smallest sequence which can be obtained by performing this operation exactly $X$ times.
A sequence $B_{1}, B_{2}, \ldots, B_{N}$ is said to be lexicographically smaller than a sequence $C_{1}, C_{2}, \ldots, C_{N}$ if there is an index $i$ such that $B_{i} < C_{i}$ and for each valid $j < i$, $B_{j} = C_{j}$.
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first line of each test case contains two space-separated integers $N$ and $X$.
The second line contains $N$ space-separated integers $A_{1}, A_{2}, \ldots, A_{N}$.
------ Output ------
For each test case, print a single line containing $N$ space-separated integers ― the lexicographically smallest obtainable sequence.
------ Constraints ------
$1 ≤ T ≤ 10$
$2 ≤ N ≤ 10^{5}$
$1 ≤ X ≤ 10^{9}$
$1 ≤ A_{i} ≤ 10^{9}$ for each valid $i$
------ Subtasks ------
Subtask #1 (30 points): $N ≤ 100$
Subtask #2 (70 points): original constraints
----- Sample Input 1 ------
1
3 3
2 2 3
----- Sample Output 1 ------
0 0 3
----- explanation 1 ------
Example case 1: The original sequence is $(2, 2, 3)$. Consider the following three operations:
- Choose $i = 1$, $j = 2$ and $p = 1$. Then, $A_{1}$ changes from $2$ to $2 \oplus 2^{1} = 0$ and similarly, $A_{2}$ changes from $2$ to $2 \oplus 2^{1} = 0$. Now the sequence is $(0, 0, 3)$.
- Next, choose $i = 1$, $j = 2$ and $p = 1$. Then, $A_{1}$ changes to $0 \oplus 2^{1} = 2$ and $A_{2}$ changes to $0 \oplus 2^{1} = 2$. The sequence is $(2, 2, 3)$.
- Next, again choose $i = 1$, $j = 2$ and $p = 1$. Then, $A_{1}$ changes to $2 \oplus 2^{1} = 0$ and $A_{2}$ changes to $2 \oplus 2^{1} = 0$. The sequence is $(0, 0, 3)$ again.
We can check that after exactly 3 operations, this is the lexicographically smallest sequence we can obtain.
|
for _ in range(int(input())):
n, x = map(int, input().split())
arr = list(map(int, input().split()))
rem = 0
for i in range(n - 1):
a = arr[i]
d = a & rem
a, rem = a ^ d, rem ^ d
b = bin(a).count("1")
if b <= x:
x -= b
rem ^= a
a = 0
elif x > 0:
d = 0
for j in range(31, -1, -1):
if a & 1 << j != 0:
d ^= 1 << j
x -= 1
if x == 0:
break
a, rem = a ^ d, rem ^ d
arr[i] = a
arr[-1] ^= rem
if x == 1 or n == 2 and x % 2 == 1:
arr[-2] = 1
arr[-1] ^= 1
print(*arr)
|
FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR VAR VAR ASSIGN VAR BIN_OP VAR VAR ASSIGN VAR VAR BIN_OP VAR VAR BIN_OP VAR VAR ASSIGN VAR FUNC_CALL FUNC_CALL VAR VAR STRING IF VAR VAR VAR VAR VAR VAR ASSIGN VAR NUMBER IF VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER NUMBER NUMBER IF BIN_OP VAR BIN_OP NUMBER VAR NUMBER VAR BIN_OP NUMBER VAR VAR NUMBER IF VAR NUMBER ASSIGN VAR VAR BIN_OP VAR VAR BIN_OP VAR VAR ASSIGN VAR VAR VAR VAR NUMBER VAR IF VAR NUMBER VAR NUMBER BIN_OP VAR NUMBER NUMBER ASSIGN VAR NUMBER NUMBER VAR NUMBER NUMBER EXPR FUNC_CALL VAR VAR
|
Read problem statements in [Hindi], [Bengali], [Mandarin Chinese], [Russian], and [Vietnamese] as well.
You are given a sequence $A_{1}, A_{2}, \ldots, A_{N}$ and you have to perform the following operation exactly $X$ times:
Choose two integers $i$ and $j$ such that $1 ≤ i < j ≤ N$.
Choose a non-negative integer $p$.
Change $A_{i}$ to $A_{i} \oplus 2^{p}$, and change $A_{j}$ to $A_{j} \oplus 2^{p}$, where $\oplus$ denotes [bitwise XOR].
Find the lexicographically smallest sequence which can be obtained by performing this operation exactly $X$ times.
A sequence $B_{1}, B_{2}, \ldots, B_{N}$ is said to be lexicographically smaller than a sequence $C_{1}, C_{2}, \ldots, C_{N}$ if there is an index $i$ such that $B_{i} < C_{i}$ and for each valid $j < i$, $B_{j} = C_{j}$.
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first line of each test case contains two space-separated integers $N$ and $X$.
The second line contains $N$ space-separated integers $A_{1}, A_{2}, \ldots, A_{N}$.
------ Output ------
For each test case, print a single line containing $N$ space-separated integers ― the lexicographically smallest obtainable sequence.
------ Constraints ------
$1 ≤ T ≤ 10$
$2 ≤ N ≤ 10^{5}$
$1 ≤ X ≤ 10^{9}$
$1 ≤ A_{i} ≤ 10^{9}$ for each valid $i$
------ Subtasks ------
Subtask #1 (30 points): $N ≤ 100$
Subtask #2 (70 points): original constraints
----- Sample Input 1 ------
1
3 3
2 2 3
----- Sample Output 1 ------
0 0 3
----- explanation 1 ------
Example case 1: The original sequence is $(2, 2, 3)$. Consider the following three operations:
- Choose $i = 1$, $j = 2$ and $p = 1$. Then, $A_{1}$ changes from $2$ to $2 \oplus 2^{1} = 0$ and similarly, $A_{2}$ changes from $2$ to $2 \oplus 2^{1} = 0$. Now the sequence is $(0, 0, 3)$.
- Next, choose $i = 1$, $j = 2$ and $p = 1$. Then, $A_{1}$ changes to $0 \oplus 2^{1} = 2$ and $A_{2}$ changes to $0 \oplus 2^{1} = 2$. The sequence is $(2, 2, 3)$.
- Next, again choose $i = 1$, $j = 2$ and $p = 1$. Then, $A_{1}$ changes to $2 \oplus 2^{1} = 0$ and $A_{2}$ changes to $2 \oplus 2^{1} = 0$. The sequence is $(0, 0, 3)$ again.
We can check that after exactly 3 operations, this is the lexicographically smallest sequence we can obtain.
|
for _ in range(int(input())):
n, x = map(int, input().split())
a = [int(i) for i in input().split()]
for i in range(len(a)):
if i == n - 1:
if n == 2:
if x % 2 == 1:
a[-1] ^= 1
a[-2] ^= 1
elif all(ele == 0 for ele in a) and x == 1:
a[-1] ^= 1
a[-2] ^= 1
break
j = i + 1
if a[i] != 0:
c = bin(a[i]).replace("0b", "")
x = x - c.count("1")
if x < 0:
x = x + c.count("1")
c = c.replace("1", "", x)
c = int(c, 2)
a[i], c = c, a[i] - c
while c != 0 and j < len(a):
a[j], c = ~c & a[j], c & ~a[j]
j += 1
a[n - 1] ^= c
break
else:
while a[i] != 0 and j < n:
a[j], a[i] = ~a[i] & a[j], a[i] & ~a[j]
j += 1
a[n - 1] ^= a[i]
a[i] = 0
if x == 0:
break
print(*a, sep=" ")
|
FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR IF VAR BIN_OP VAR NUMBER IF VAR NUMBER IF BIN_OP VAR NUMBER NUMBER VAR NUMBER NUMBER VAR NUMBER NUMBER IF FUNC_CALL VAR VAR NUMBER VAR VAR VAR NUMBER VAR NUMBER NUMBER VAR NUMBER NUMBER ASSIGN VAR BIN_OP VAR NUMBER IF VAR VAR NUMBER ASSIGN VAR FUNC_CALL FUNC_CALL VAR VAR VAR STRING STRING ASSIGN VAR BIN_OP VAR FUNC_CALL VAR STRING IF VAR NUMBER ASSIGN VAR BIN_OP VAR FUNC_CALL VAR STRING ASSIGN VAR FUNC_CALL VAR STRING STRING VAR ASSIGN VAR FUNC_CALL VAR VAR NUMBER ASSIGN VAR VAR VAR VAR BIN_OP VAR VAR VAR WHILE VAR NUMBER VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR BIN_OP VAR VAR VAR BIN_OP VAR VAR VAR VAR NUMBER VAR BIN_OP VAR NUMBER VAR WHILE VAR VAR NUMBER VAR VAR ASSIGN VAR VAR VAR VAR BIN_OP VAR VAR VAR VAR BIN_OP VAR VAR VAR VAR VAR NUMBER VAR BIN_OP VAR NUMBER VAR VAR ASSIGN VAR VAR NUMBER IF VAR NUMBER EXPR FUNC_CALL VAR VAR STRING
|
Read problem statements in [Hindi], [Bengali], [Mandarin Chinese], [Russian], and [Vietnamese] as well.
You are given a sequence $A_{1}, A_{2}, \ldots, A_{N}$ and you have to perform the following operation exactly $X$ times:
Choose two integers $i$ and $j$ such that $1 ≤ i < j ≤ N$.
Choose a non-negative integer $p$.
Change $A_{i}$ to $A_{i} \oplus 2^{p}$, and change $A_{j}$ to $A_{j} \oplus 2^{p}$, where $\oplus$ denotes [bitwise XOR].
Find the lexicographically smallest sequence which can be obtained by performing this operation exactly $X$ times.
A sequence $B_{1}, B_{2}, \ldots, B_{N}$ is said to be lexicographically smaller than a sequence $C_{1}, C_{2}, \ldots, C_{N}$ if there is an index $i$ such that $B_{i} < C_{i}$ and for each valid $j < i$, $B_{j} = C_{j}$.
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first line of each test case contains two space-separated integers $N$ and $X$.
The second line contains $N$ space-separated integers $A_{1}, A_{2}, \ldots, A_{N}$.
------ Output ------
For each test case, print a single line containing $N$ space-separated integers ― the lexicographically smallest obtainable sequence.
------ Constraints ------
$1 ≤ T ≤ 10$
$2 ≤ N ≤ 10^{5}$
$1 ≤ X ≤ 10^{9}$
$1 ≤ A_{i} ≤ 10^{9}$ for each valid $i$
------ Subtasks ------
Subtask #1 (30 points): $N ≤ 100$
Subtask #2 (70 points): original constraints
----- Sample Input 1 ------
1
3 3
2 2 3
----- Sample Output 1 ------
0 0 3
----- explanation 1 ------
Example case 1: The original sequence is $(2, 2, 3)$. Consider the following three operations:
- Choose $i = 1$, $j = 2$ and $p = 1$. Then, $A_{1}$ changes from $2$ to $2 \oplus 2^{1} = 0$ and similarly, $A_{2}$ changes from $2$ to $2 \oplus 2^{1} = 0$. Now the sequence is $(0, 0, 3)$.
- Next, choose $i = 1$, $j = 2$ and $p = 1$. Then, $A_{1}$ changes to $0 \oplus 2^{1} = 2$ and $A_{2}$ changes to $0 \oplus 2^{1} = 2$. The sequence is $(2, 2, 3)$.
- Next, again choose $i = 1$, $j = 2$ and $p = 1$. Then, $A_{1}$ changes to $2 \oplus 2^{1} = 0$ and $A_{2}$ changes to $2 \oplus 2^{1} = 0$. The sequence is $(0, 0, 3)$ again.
We can check that after exactly 3 operations, this is the lexicographically smallest sequence we can obtain.
|
import sys
input = sys.stdin.readline
MOD = 10**9 + 7
for _ in range(int(input())):
n, x = map(int, input().split())
data = list(map(int, input().split()))
step = 0
ans = []
for ind, i in enumerate(data[:-1]):
data[ind] = ~step & i
step = step & ~i
b = bin(data[ind])[2:]
c = b.count("1")
if x > c:
step = step | data[ind]
data[ind] = 0
x -= c
else:
temp = list(b)
stepi = ["0"] * len(b)
j = 0
while x > 0 and j < len(temp):
if temp[j] == "1":
temp[j] = "0"
stepi[j] = "1"
x -= 1
j += 1
data[ind] = int("".join(temp), 2)
stepi = int("".join(stepi), 2)
step |= stepi
ans.append(data[ind])
ans += [step ^ data[-1]]
if (n == 2 or not ans[-1]) and x % 2:
ans[-2] ^= 1
ans[-1] ^= 1
print(*ans)
|
IMPORT ASSIGN VAR VAR ASSIGN VAR BIN_OP BIN_OP NUMBER NUMBER NUMBER FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER ASSIGN VAR LIST FOR VAR VAR FUNC_CALL VAR VAR NUMBER ASSIGN VAR VAR BIN_OP VAR VAR ASSIGN VAR BIN_OP VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR STRING IF VAR VAR ASSIGN VAR BIN_OP VAR VAR VAR ASSIGN VAR VAR NUMBER VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP LIST STRING FUNC_CALL VAR VAR ASSIGN VAR NUMBER WHILE VAR NUMBER VAR FUNC_CALL VAR VAR IF VAR VAR STRING ASSIGN VAR VAR STRING ASSIGN VAR VAR STRING VAR NUMBER VAR NUMBER ASSIGN VAR VAR FUNC_CALL VAR FUNC_CALL STRING VAR NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL STRING VAR NUMBER VAR VAR EXPR FUNC_CALL VAR VAR VAR VAR LIST BIN_OP VAR VAR NUMBER IF VAR NUMBER VAR NUMBER BIN_OP VAR NUMBER VAR NUMBER NUMBER VAR NUMBER NUMBER EXPR FUNC_CALL VAR VAR
|
Read problem statements in [Hindi], [Bengali], [Mandarin Chinese], [Russian], and [Vietnamese] as well.
You are given a sequence $A_{1}, A_{2}, \ldots, A_{N}$ and you have to perform the following operation exactly $X$ times:
Choose two integers $i$ and $j$ such that $1 ≤ i < j ≤ N$.
Choose a non-negative integer $p$.
Change $A_{i}$ to $A_{i} \oplus 2^{p}$, and change $A_{j}$ to $A_{j} \oplus 2^{p}$, where $\oplus$ denotes [bitwise XOR].
Find the lexicographically smallest sequence which can be obtained by performing this operation exactly $X$ times.
A sequence $B_{1}, B_{2}, \ldots, B_{N}$ is said to be lexicographically smaller than a sequence $C_{1}, C_{2}, \ldots, C_{N}$ if there is an index $i$ such that $B_{i} < C_{i}$ and for each valid $j < i$, $B_{j} = C_{j}$.
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first line of each test case contains two space-separated integers $N$ and $X$.
The second line contains $N$ space-separated integers $A_{1}, A_{2}, \ldots, A_{N}$.
------ Output ------
For each test case, print a single line containing $N$ space-separated integers ― the lexicographically smallest obtainable sequence.
------ Constraints ------
$1 ≤ T ≤ 10$
$2 ≤ N ≤ 10^{5}$
$1 ≤ X ≤ 10^{9}$
$1 ≤ A_{i} ≤ 10^{9}$ for each valid $i$
------ Subtasks ------
Subtask #1 (30 points): $N ≤ 100$
Subtask #2 (70 points): original constraints
----- Sample Input 1 ------
1
3 3
2 2 3
----- Sample Output 1 ------
0 0 3
----- explanation 1 ------
Example case 1: The original sequence is $(2, 2, 3)$. Consider the following three operations:
- Choose $i = 1$, $j = 2$ and $p = 1$. Then, $A_{1}$ changes from $2$ to $2 \oplus 2^{1} = 0$ and similarly, $A_{2}$ changes from $2$ to $2 \oplus 2^{1} = 0$. Now the sequence is $(0, 0, 3)$.
- Next, choose $i = 1$, $j = 2$ and $p = 1$. Then, $A_{1}$ changes to $0 \oplus 2^{1} = 2$ and $A_{2}$ changes to $0 \oplus 2^{1} = 2$. The sequence is $(2, 2, 3)$.
- Next, again choose $i = 1$, $j = 2$ and $p = 1$. Then, $A_{1}$ changes to $2 \oplus 2^{1} = 0$ and $A_{2}$ changes to $2 \oplus 2^{1} = 0$. The sequence is $(0, 0, 3)$ again.
We can check that after exactly 3 operations, this is the lexicographically smallest sequence we can obtain.
|
for _ in range(int(input())):
n, x = [int(i) for i in input().split()]
s = [list(bin(int(i))[2:]) for i in input().split()]
pad = ["0" for f in range(32 - len(s[-1]))]
s[-1] = pad + s[-1]
if x > 10**5 and n > 2:
arr = [int("".join(el), 2) for el in s]
k = 0
for l in range(n):
k = k ^ arr[l]
ans = [0] * n
ans[-1] = k
print(*ans)
else:
for i in range(n - 1):
l = len(s[i])
while set(s[i]) != {"0"}:
if x == 0:
break
ind = s[i].index("1")
ind_back = l - ind
s[i][ind] = "0"
j = i + 1
flag = True
while j < n:
if len(s[j]) >= ind_back and s[j][-ind_back] == "1":
s[j][-ind_back] = "0"
flag = False
break
j += 1
if flag == True:
s[-1][-ind_back] = "1"
x -= 1
if x > 0 and x % 2 == 1 and n == 2:
s[-2][-1] = "1"
if s[-1][-1] == "0":
s[-1][-1] = "1"
else:
s[-1][-1] = "0"
print(*[int("".join(el), 2) for el in s])
|
FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR STRING VAR FUNC_CALL VAR BIN_OP NUMBER FUNC_CALL VAR VAR NUMBER ASSIGN VAR NUMBER BIN_OP VAR VAR NUMBER IF VAR BIN_OP NUMBER NUMBER VAR NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL STRING VAR NUMBER VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP VAR VAR VAR ASSIGN VAR BIN_OP LIST NUMBER VAR ASSIGN VAR NUMBER VAR EXPR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR WHILE FUNC_CALL VAR VAR VAR STRING IF VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR STRING ASSIGN VAR BIN_OP VAR VAR ASSIGN VAR VAR VAR STRING ASSIGN VAR BIN_OP VAR NUMBER ASSIGN VAR NUMBER WHILE VAR VAR IF FUNC_CALL VAR VAR VAR VAR VAR VAR VAR STRING ASSIGN VAR VAR VAR STRING ASSIGN VAR NUMBER VAR NUMBER IF VAR NUMBER ASSIGN VAR NUMBER VAR STRING VAR NUMBER IF VAR NUMBER BIN_OP VAR NUMBER NUMBER VAR NUMBER ASSIGN VAR NUMBER NUMBER STRING IF VAR NUMBER NUMBER STRING ASSIGN VAR NUMBER NUMBER STRING ASSIGN VAR NUMBER NUMBER STRING EXPR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL STRING VAR NUMBER VAR VAR
|
Read problem statements in [Hindi], [Bengali], [Mandarin Chinese], [Russian], and [Vietnamese] as well.
You are given a sequence $A_{1}, A_{2}, \ldots, A_{N}$ and you have to perform the following operation exactly $X$ times:
Choose two integers $i$ and $j$ such that $1 ≤ i < j ≤ N$.
Choose a non-negative integer $p$.
Change $A_{i}$ to $A_{i} \oplus 2^{p}$, and change $A_{j}$ to $A_{j} \oplus 2^{p}$, where $\oplus$ denotes [bitwise XOR].
Find the lexicographically smallest sequence which can be obtained by performing this operation exactly $X$ times.
A sequence $B_{1}, B_{2}, \ldots, B_{N}$ is said to be lexicographically smaller than a sequence $C_{1}, C_{2}, \ldots, C_{N}$ if there is an index $i$ such that $B_{i} < C_{i}$ and for each valid $j < i$, $B_{j} = C_{j}$.
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first line of each test case contains two space-separated integers $N$ and $X$.
The second line contains $N$ space-separated integers $A_{1}, A_{2}, \ldots, A_{N}$.
------ Output ------
For each test case, print a single line containing $N$ space-separated integers ― the lexicographically smallest obtainable sequence.
------ Constraints ------
$1 ≤ T ≤ 10$
$2 ≤ N ≤ 10^{5}$
$1 ≤ X ≤ 10^{9}$
$1 ≤ A_{i} ≤ 10^{9}$ for each valid $i$
------ Subtasks ------
Subtask #1 (30 points): $N ≤ 100$
Subtask #2 (70 points): original constraints
----- Sample Input 1 ------
1
3 3
2 2 3
----- Sample Output 1 ------
0 0 3
----- explanation 1 ------
Example case 1: The original sequence is $(2, 2, 3)$. Consider the following three operations:
- Choose $i = 1$, $j = 2$ and $p = 1$. Then, $A_{1}$ changes from $2$ to $2 \oplus 2^{1} = 0$ and similarly, $A_{2}$ changes from $2$ to $2 \oplus 2^{1} = 0$. Now the sequence is $(0, 0, 3)$.
- Next, choose $i = 1$, $j = 2$ and $p = 1$. Then, $A_{1}$ changes to $0 \oplus 2^{1} = 2$ and $A_{2}$ changes to $0 \oplus 2^{1} = 2$. The sequence is $(2, 2, 3)$.
- Next, again choose $i = 1$, $j = 2$ and $p = 1$. Then, $A_{1}$ changes to $2 \oplus 2^{1} = 0$ and $A_{2}$ changes to $2 \oplus 2^{1} = 0$. The sequence is $(0, 0, 3)$ again.
We can check that after exactly 3 operations, this is the lexicographically smallest sequence we can obtain.
|
def fun(a, t):
global x
c = 0
s = list(bin(a)[2:])
for i in range(len(s)):
if s[i] == "1":
c = c + 1
s[i] = "0"
if t + c == x:
break
return int("".join(s), 2), c
for i in range(int(input())):
n, x = map(int, input().split())
l = list(map(int, input().split()))
l1 = []
y = l[0]
temp = l[0]
t = 0
flg = 0
for j in range(n):
if j == 0:
t1 = t + bin(l[j])[2:].count("1")
if t1 > x:
k, g = fun(l[j], t)
l1.append(k)
flg = 1
t = t + g
y = k ^ y
temp = y
elif t1 == x:
l1.append(0)
flg = 1
t = t1
else:
t = t1
l1.append(0)
elif j < n - 1:
y = y ^ l[j]
a = y & temp
z = y - a
if flg:
y = a
temp = y
l1.append(z)
else:
o = bin(z)[2:].count("1")
t1 = t + o
if t1 > x:
k, g = fun(z, t)
l1.append(k)
flg = 1
t = t + g
y = y ^ k
elif t1 == x:
l1.append(0)
flg = 1
t = t1
else:
t = t1
l1.append(0)
temp = y
elif y == 0:
l1.append(l[j])
else:
y = y ^ l[j]
a = y & temp
z = y - a
if y == 0:
l1.append(0)
elif flg:
l1.append(z ^ a)
else:
l1.append(z ^ a)
if not flg:
if n == 2 and (x - t) % 2 != 0:
l1[n - 2] = l1[n - 2] ^ 1
l1[n - 1] = l1[n - 1] ^ 1
print(" ".join(list(map(str, l1))))
|
FUNC_DEF ASSIGN VAR NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR IF VAR VAR STRING ASSIGN VAR BIN_OP VAR NUMBER ASSIGN VAR VAR STRING IF BIN_OP VAR VAR VAR RETURN FUNC_CALL VAR FUNC_CALL STRING VAR NUMBER VAR FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR LIST ASSIGN VAR VAR NUMBER ASSIGN VAR VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR IF VAR NUMBER ASSIGN VAR BIN_OP VAR FUNC_CALL FUNC_CALL VAR VAR VAR NUMBER STRING IF VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR VAR EXPR FUNC_CALL VAR VAR ASSIGN VAR NUMBER ASSIGN VAR BIN_OP VAR VAR ASSIGN VAR BIN_OP VAR VAR ASSIGN VAR VAR IF VAR VAR EXPR FUNC_CALL VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR VAR ASSIGN VAR VAR EXPR FUNC_CALL VAR NUMBER IF VAR BIN_OP VAR NUMBER ASSIGN VAR BIN_OP VAR VAR VAR ASSIGN VAR BIN_OP VAR VAR ASSIGN VAR BIN_OP VAR VAR IF VAR ASSIGN VAR VAR ASSIGN VAR VAR EXPR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL FUNC_CALL VAR VAR NUMBER STRING ASSIGN VAR BIN_OP VAR VAR IF VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR VAR ASSIGN VAR NUMBER ASSIGN VAR BIN_OP VAR VAR ASSIGN VAR BIN_OP VAR VAR IF VAR VAR EXPR FUNC_CALL VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR VAR ASSIGN VAR VAR EXPR FUNC_CALL VAR NUMBER ASSIGN VAR VAR IF VAR NUMBER EXPR FUNC_CALL VAR VAR VAR ASSIGN VAR BIN_OP VAR VAR VAR ASSIGN VAR BIN_OP VAR VAR ASSIGN VAR BIN_OP VAR VAR IF VAR NUMBER EXPR FUNC_CALL VAR NUMBER IF VAR EXPR FUNC_CALL VAR BIN_OP VAR VAR EXPR FUNC_CALL VAR BIN_OP VAR VAR IF VAR IF VAR NUMBER BIN_OP BIN_OP VAR VAR NUMBER NUMBER ASSIGN VAR BIN_OP VAR NUMBER BIN_OP VAR BIN_OP VAR NUMBER NUMBER ASSIGN VAR BIN_OP VAR NUMBER BIN_OP VAR BIN_OP VAR NUMBER NUMBER EXPR FUNC_CALL VAR FUNC_CALL STRING FUNC_CALL VAR FUNC_CALL VAR VAR VAR
|
Read problem statements in [Hindi], [Bengali], [Mandarin Chinese], [Russian], and [Vietnamese] as well.
You are given a sequence $A_{1}, A_{2}, \ldots, A_{N}$ and you have to perform the following operation exactly $X$ times:
Choose two integers $i$ and $j$ such that $1 ≤ i < j ≤ N$.
Choose a non-negative integer $p$.
Change $A_{i}$ to $A_{i} \oplus 2^{p}$, and change $A_{j}$ to $A_{j} \oplus 2^{p}$, where $\oplus$ denotes [bitwise XOR].
Find the lexicographically smallest sequence which can be obtained by performing this operation exactly $X$ times.
A sequence $B_{1}, B_{2}, \ldots, B_{N}$ is said to be lexicographically smaller than a sequence $C_{1}, C_{2}, \ldots, C_{N}$ if there is an index $i$ such that $B_{i} < C_{i}$ and for each valid $j < i$, $B_{j} = C_{j}$.
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first line of each test case contains two space-separated integers $N$ and $X$.
The second line contains $N$ space-separated integers $A_{1}, A_{2}, \ldots, A_{N}$.
------ Output ------
For each test case, print a single line containing $N$ space-separated integers ― the lexicographically smallest obtainable sequence.
------ Constraints ------
$1 ≤ T ≤ 10$
$2 ≤ N ≤ 10^{5}$
$1 ≤ X ≤ 10^{9}$
$1 ≤ A_{i} ≤ 10^{9}$ for each valid $i$
------ Subtasks ------
Subtask #1 (30 points): $N ≤ 100$
Subtask #2 (70 points): original constraints
----- Sample Input 1 ------
1
3 3
2 2 3
----- Sample Output 1 ------
0 0 3
----- explanation 1 ------
Example case 1: The original sequence is $(2, 2, 3)$. Consider the following three operations:
- Choose $i = 1$, $j = 2$ and $p = 1$. Then, $A_{1}$ changes from $2$ to $2 \oplus 2^{1} = 0$ and similarly, $A_{2}$ changes from $2$ to $2 \oplus 2^{1} = 0$. Now the sequence is $(0, 0, 3)$.
- Next, choose $i = 1$, $j = 2$ and $p = 1$. Then, $A_{1}$ changes to $0 \oplus 2^{1} = 2$ and $A_{2}$ changes to $0 \oplus 2^{1} = 2$. The sequence is $(2, 2, 3)$.
- Next, again choose $i = 1$, $j = 2$ and $p = 1$. Then, $A_{1}$ changes to $2 \oplus 2^{1} = 0$ and $A_{2}$ changes to $2 \oplus 2^{1} = 0$. The sequence is $(0, 0, 3)$ again.
We can check that after exactly 3 operations, this is the lexicographically smallest sequence we can obtain.
|
def count(n):
count = 0
while n:
count += n & 1
n >>= 1
return count
for _ in range(int(input())):
n, x = map(int, input().split())
l = list(map(int, input().split()))
t = 0
for i in range(0, n - 1):
f = l[i] & t
l[i] = l[i] - f
t = t - f
if x > 0:
cnt = count(l[i])
if x - cnt < 0:
s = bin(l[i])
for j in range(2, len(s)):
if s[j] == "1":
l[i] = l[i] - pow(2, len(s) - j - 1)
t = t + pow(2, len(s) - j - 1)
x = x - 1
if x == 0:
break
else:
t = t ^ l[i]
l[i] = 0
x = x - cnt
l[n - 1] = l[n - 1] ^ t
if x == 1:
l[n - 2] = l[n - 2] + 1
l[n - 1] = l[n - 1] ^ 1
elif x % 2 == 1 and n == 2:
l[0] = 1
l[1] = l[1] ^ 1
for i in l:
print(i, end=" ")
print()
|
FUNC_DEF ASSIGN VAR NUMBER WHILE VAR VAR BIN_OP VAR NUMBER VAR NUMBER RETURN VAR FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER ASSIGN VAR BIN_OP VAR VAR VAR ASSIGN VAR VAR BIN_OP VAR VAR VAR ASSIGN VAR BIN_OP VAR VAR IF VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR IF BIN_OP VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR FOR VAR FUNC_CALL VAR NUMBER FUNC_CALL VAR VAR IF VAR VAR STRING ASSIGN VAR VAR BIN_OP VAR VAR FUNC_CALL VAR NUMBER BIN_OP BIN_OP FUNC_CALL VAR VAR VAR NUMBER ASSIGN VAR BIN_OP VAR FUNC_CALL VAR NUMBER BIN_OP BIN_OP FUNC_CALL VAR VAR VAR NUMBER ASSIGN VAR BIN_OP VAR NUMBER IF VAR NUMBER ASSIGN VAR BIN_OP VAR VAR VAR ASSIGN VAR VAR NUMBER ASSIGN VAR BIN_OP VAR VAR ASSIGN VAR BIN_OP VAR NUMBER BIN_OP VAR BIN_OP VAR NUMBER VAR IF VAR NUMBER ASSIGN VAR BIN_OP VAR NUMBER BIN_OP VAR BIN_OP VAR NUMBER NUMBER ASSIGN VAR BIN_OP VAR NUMBER BIN_OP VAR BIN_OP VAR NUMBER NUMBER IF BIN_OP VAR NUMBER NUMBER VAR NUMBER ASSIGN VAR NUMBER NUMBER ASSIGN VAR NUMBER BIN_OP VAR NUMBER NUMBER FOR VAR VAR EXPR FUNC_CALL VAR VAR STRING EXPR FUNC_CALL VAR
|
Read problem statements in [Hindi], [Bengali], [Mandarin Chinese], [Russian], and [Vietnamese] as well.
You are given a sequence $A_{1}, A_{2}, \ldots, A_{N}$ and you have to perform the following operation exactly $X$ times:
Choose two integers $i$ and $j$ such that $1 ≤ i < j ≤ N$.
Choose a non-negative integer $p$.
Change $A_{i}$ to $A_{i} \oplus 2^{p}$, and change $A_{j}$ to $A_{j} \oplus 2^{p}$, where $\oplus$ denotes [bitwise XOR].
Find the lexicographically smallest sequence which can be obtained by performing this operation exactly $X$ times.
A sequence $B_{1}, B_{2}, \ldots, B_{N}$ is said to be lexicographically smaller than a sequence $C_{1}, C_{2}, \ldots, C_{N}$ if there is an index $i$ such that $B_{i} < C_{i}$ and for each valid $j < i$, $B_{j} = C_{j}$.
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first line of each test case contains two space-separated integers $N$ and $X$.
The second line contains $N$ space-separated integers $A_{1}, A_{2}, \ldots, A_{N}$.
------ Output ------
For each test case, print a single line containing $N$ space-separated integers ― the lexicographically smallest obtainable sequence.
------ Constraints ------
$1 ≤ T ≤ 10$
$2 ≤ N ≤ 10^{5}$
$1 ≤ X ≤ 10^{9}$
$1 ≤ A_{i} ≤ 10^{9}$ for each valid $i$
------ Subtasks ------
Subtask #1 (30 points): $N ≤ 100$
Subtask #2 (70 points): original constraints
----- Sample Input 1 ------
1
3 3
2 2 3
----- Sample Output 1 ------
0 0 3
----- explanation 1 ------
Example case 1: The original sequence is $(2, 2, 3)$. Consider the following three operations:
- Choose $i = 1$, $j = 2$ and $p = 1$. Then, $A_{1}$ changes from $2$ to $2 \oplus 2^{1} = 0$ and similarly, $A_{2}$ changes from $2$ to $2 \oplus 2^{1} = 0$. Now the sequence is $(0, 0, 3)$.
- Next, choose $i = 1$, $j = 2$ and $p = 1$. Then, $A_{1}$ changes to $0 \oplus 2^{1} = 2$ and $A_{2}$ changes to $0 \oplus 2^{1} = 2$. The sequence is $(2, 2, 3)$.
- Next, again choose $i = 1$, $j = 2$ and $p = 1$. Then, $A_{1}$ changes to $2 \oplus 2^{1} = 0$ and $A_{2}$ changes to $2 \oplus 2^{1} = 0$. The sequence is $(0, 0, 3)$ again.
We can check that after exactly 3 operations, this is the lexicographically smallest sequence we can obtain.
|
N_bits = 30
t = int(input())
for _ in range(t):
n, x = map(int, input().split())
arr = list(map(int, input().split()))
less_x = False
last = arr[n - 1]
last_0 = 0
n0 = bin(arr[0]).count("1")
for i in range(n - 1):
x_ = x - bin(arr[i]).count("1")
if x == 0:
break
if x_ < 0:
less_x = True
break
n1 = bin(arr[i + 1]).count("1")
arr[i + 1] = arr[i] ^ arr[i + 1]
n_temp = bin(arr[i + 1]).count("1")
delta_x = (n0 + n1 - n_temp) // 2
x -= delta_x
last_0 = arr[i]
arr[i] = 0
n0 = n_temp
if less_x:
pivot = i
pivot_bits = [
(arr[pivot].bit_length() + 1 - idx)
for idx, v in enumerate(bin(arr[pivot]))
if v == "1"
]
last_0_bits = set(
[
(last_0.bit_length() + 1 - idx)
for idx, v in enumerate(bin(last_0))
if v == "1"
]
)
carry_forward_bits = [idx for idx in pivot_bits if idx in last_0_bits]
original_bits = [idx for idx in pivot_bits if idx not in last_0_bits]
remaining_x = x - len(carry_forward_bits)
carry_forward_bits.extend(original_bits[:remaining_x])
hero = sum([(1 << bit) for bit in carry_forward_bits])
for j in range(pivot + 1, n):
arr[j - 1] ^= hero
temp = arr[j] ^ hero
hero = hero ^ arr[j] & hero
arr[j] = temp
elif x_ > 0 and x_ % 2 == 1:
if last_0 & last == 0 or n == 2:
arr[n - 1] ^= 1
arr[n - 2] ^= 1
print(*arr)
|
ASSIGN VAR NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER ASSIGN VAR VAR BIN_OP VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR FUNC_CALL FUNC_CALL VAR VAR NUMBER STRING FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR BIN_OP VAR FUNC_CALL FUNC_CALL VAR VAR VAR STRING IF VAR NUMBER IF VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR FUNC_CALL FUNC_CALL VAR VAR BIN_OP VAR NUMBER STRING ASSIGN VAR BIN_OP VAR NUMBER BIN_OP VAR VAR VAR BIN_OP VAR NUMBER ASSIGN VAR FUNC_CALL FUNC_CALL VAR VAR BIN_OP VAR NUMBER STRING ASSIGN VAR BIN_OP BIN_OP BIN_OP VAR VAR VAR NUMBER VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR VAR NUMBER ASSIGN VAR VAR IF VAR ASSIGN VAR VAR ASSIGN VAR BIN_OP BIN_OP FUNC_CALL VAR VAR NUMBER VAR VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR VAR VAR STRING ASSIGN VAR FUNC_CALL VAR BIN_OP BIN_OP FUNC_CALL VAR NUMBER VAR VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR VAR STRING ASSIGN VAR VAR VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR ASSIGN VAR BIN_OP VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL VAR BIN_OP NUMBER VAR VAR VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR VAR BIN_OP VAR NUMBER VAR ASSIGN VAR BIN_OP VAR VAR VAR ASSIGN VAR BIN_OP VAR BIN_OP VAR VAR VAR ASSIGN VAR VAR VAR IF VAR NUMBER BIN_OP VAR NUMBER NUMBER IF BIN_OP VAR VAR NUMBER VAR NUMBER VAR BIN_OP VAR NUMBER NUMBER VAR BIN_OP VAR NUMBER NUMBER EXPR FUNC_CALL VAR VAR
|
Read problem statements in [Hindi], [Bengali], [Mandarin Chinese], [Russian], and [Vietnamese] as well.
You are given a sequence $A_{1}, A_{2}, \ldots, A_{N}$ and you have to perform the following operation exactly $X$ times:
Choose two integers $i$ and $j$ such that $1 ≤ i < j ≤ N$.
Choose a non-negative integer $p$.
Change $A_{i}$ to $A_{i} \oplus 2^{p}$, and change $A_{j}$ to $A_{j} \oplus 2^{p}$, where $\oplus$ denotes [bitwise XOR].
Find the lexicographically smallest sequence which can be obtained by performing this operation exactly $X$ times.
A sequence $B_{1}, B_{2}, \ldots, B_{N}$ is said to be lexicographically smaller than a sequence $C_{1}, C_{2}, \ldots, C_{N}$ if there is an index $i$ such that $B_{i} < C_{i}$ and for each valid $j < i$, $B_{j} = C_{j}$.
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first line of each test case contains two space-separated integers $N$ and $X$.
The second line contains $N$ space-separated integers $A_{1}, A_{2}, \ldots, A_{N}$.
------ Output ------
For each test case, print a single line containing $N$ space-separated integers ― the lexicographically smallest obtainable sequence.
------ Constraints ------
$1 ≤ T ≤ 10$
$2 ≤ N ≤ 10^{5}$
$1 ≤ X ≤ 10^{9}$
$1 ≤ A_{i} ≤ 10^{9}$ for each valid $i$
------ Subtasks ------
Subtask #1 (30 points): $N ≤ 100$
Subtask #2 (70 points): original constraints
----- Sample Input 1 ------
1
3 3
2 2 3
----- Sample Output 1 ------
0 0 3
----- explanation 1 ------
Example case 1: The original sequence is $(2, 2, 3)$. Consider the following three operations:
- Choose $i = 1$, $j = 2$ and $p = 1$. Then, $A_{1}$ changes from $2$ to $2 \oplus 2^{1} = 0$ and similarly, $A_{2}$ changes from $2$ to $2 \oplus 2^{1} = 0$. Now the sequence is $(0, 0, 3)$.
- Next, choose $i = 1$, $j = 2$ and $p = 1$. Then, $A_{1}$ changes to $0 \oplus 2^{1} = 2$ and $A_{2}$ changes to $0 \oplus 2^{1} = 2$. The sequence is $(2, 2, 3)$.
- Next, again choose $i = 1$, $j = 2$ and $p = 1$. Then, $A_{1}$ changes to $2 \oplus 2^{1} = 0$ and $A_{2}$ changes to $2 \oplus 2^{1} = 0$. The sequence is $(0, 0, 3)$ again.
We can check that after exactly 3 operations, this is the lexicographically smallest sequence we can obtain.
|
width = 32
def find_last_non_zero_row(zero_at_x, x):
if x < zero_at_x[1]:
return 0
if x > zero_at_x[-1]:
return len(zero_at_x) - 1
i = 0
j = len(zero_at_x) - 1
while i < j:
m = (i + j) // 2
if zero_at_x[m] <= x and x < zero_at_x[m + 1]:
return m
elif zero_at_x[m + 1] <= x:
i = m + 1
else:
j = m - 1
return i
t = int(input())
while t:
N, x = map(int, input().split())
nums = [0] + [int(i) for i in input().split()]
cumul_xor = [(0) for i in range(N + 1)]
zero_at_x = [(0) for i in range(N + 1)]
for i in range(1, N + 1):
zero_at_x[i] = zero_at_x[i - 1] + bin(~cumul_xor[i - 1] & nums[i]).count("1")
cumul_xor[i] = cumul_xor[i - 1] ^ nums[i]
zero_at_x[-1] = 1 << 32
last_row = find_last_non_zero_row(zero_at_x, x)
if last_row > 0:
for i in range(1, last_row + 1):
nums[i] = 0
remaining_x = x - zero_at_x[last_row]
last_xor = cumul_xor[last_row]
if remaining_x > 0 and last_row < N - 1:
orig = nums[last_row + 1]
nums[last_row + 1] = orig & ~last_xor
num_bin = list(bin(nums[last_row + 1])[2:].zfill(width))
last_xor_bin = list(bin(~orig & last_xor)[2:].zfill(width))
while remaining_x > 0:
try:
indx = num_bin.index("1")
num_bin[indx] = "0"
last_xor_bin[indx] = "1"
remaining_x -= 1
except:
break
nums[last_row + 1] = int("".join(num_bin), 2)
last_xor = int("".join(last_xor_bin), 2)
last_row += 1
for i in range(last_row + 1, len(nums) - 1):
orig = nums[i]
nums[i] = orig & ~last_xor
last_xor = ~orig & last_xor
nums[-1] = nums[-1] ^ last_xor
x = remaining_x
if x and x & 1 and (x == 1 or N < 3):
nums[-1] = nums[-1] ^ 1
nums[-2] = nums[-2] ^ 1
print(*nums[1:])
t -= 1
|
ASSIGN VAR NUMBER FUNC_DEF IF VAR VAR NUMBER RETURN NUMBER IF VAR VAR NUMBER RETURN BIN_OP FUNC_CALL VAR VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR BIN_OP FUNC_CALL VAR VAR NUMBER WHILE VAR VAR ASSIGN VAR BIN_OP BIN_OP VAR VAR NUMBER IF VAR VAR VAR VAR VAR BIN_OP VAR NUMBER RETURN VAR IF VAR BIN_OP VAR NUMBER VAR ASSIGN VAR BIN_OP VAR NUMBER ASSIGN VAR BIN_OP VAR NUMBER RETURN VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR WHILE VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR BIN_OP LIST NUMBER FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER ASSIGN VAR VAR BIN_OP VAR BIN_OP VAR NUMBER FUNC_CALL FUNC_CALL VAR BIN_OP VAR BIN_OP VAR NUMBER VAR VAR STRING ASSIGN VAR VAR BIN_OP VAR BIN_OP VAR NUMBER VAR VAR ASSIGN VAR NUMBER BIN_OP NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR IF VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER ASSIGN VAR VAR NUMBER ASSIGN VAR BIN_OP VAR VAR VAR ASSIGN VAR VAR VAR IF VAR NUMBER VAR BIN_OP VAR NUMBER ASSIGN VAR VAR BIN_OP VAR NUMBER ASSIGN VAR BIN_OP VAR NUMBER BIN_OP VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL FUNC_CALL VAR VAR BIN_OP VAR NUMBER NUMBER VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL FUNC_CALL VAR BIN_OP VAR VAR NUMBER VAR WHILE VAR NUMBER ASSIGN VAR FUNC_CALL VAR STRING ASSIGN VAR VAR STRING ASSIGN VAR VAR STRING VAR NUMBER ASSIGN VAR BIN_OP VAR NUMBER FUNC_CALL VAR FUNC_CALL STRING VAR NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL STRING VAR NUMBER VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER BIN_OP FUNC_CALL VAR VAR NUMBER ASSIGN VAR VAR VAR ASSIGN VAR VAR BIN_OP VAR VAR ASSIGN VAR BIN_OP VAR VAR ASSIGN VAR NUMBER BIN_OP VAR NUMBER VAR ASSIGN VAR VAR IF VAR BIN_OP VAR NUMBER VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER BIN_OP VAR NUMBER NUMBER ASSIGN VAR NUMBER BIN_OP VAR NUMBER NUMBER EXPR FUNC_CALL VAR VAR NUMBER VAR NUMBER
|
Understanding $2$'s complement representation is fundamental to learning about Computer Science. It allows us to write negative numbers in binary. The leftmost digit is used as a sign bit. If it is $1$, we have a negative number and it is represented as the two's complement of its absolute value. Let's say you wrote down the $2$'s complement representation for each $32$-bit integer in the inclusive range from $\boldsymbol{a}$ to $\boldsymbol{b}$. How many $1$'s would you write down in all?
For example, using an $8$-bit byte rather than $32$ bit integer, the two's complement of a number can be found by reversing all its bits and adding $1$. The two's complement representations for a few numbers are shown below:
|Number| Representation in
Number Binary Inverse Two's Complement
-3 00000011 11111100 11111101
-2 00000010 11111101 11111110
-1 00000001 11111110 11111111
0 00000000 00000000
1 00000001 00000001
2 00000010 00000010
3 00000011 00000011
To write down that range of numbers' two's complements in $8$ bits, we wrote $\textbf{26}\:1$'s. Remember to use $32$ bits rather than $8$ in your solution. The logic is the same, so the $8$ bit representation was chosen to reduce apparent complexity in the example.
Function Description
Complete the twosCompliment function in the editor below. It should return an integer.
twosCompliment has the following parameter(s):
- a: an integer, the range minimum
- b: an integer, the range maximum
Input Format
The first line contains an integer $\mathbf{T}$, the number of test cases.
Each of the next $\mathbf{T}$ lines contains two space-separated integers, $\boldsymbol{a}$ and $\boldsymbol{b}$.
Constraints
$T\leq1000$
$-2^{31}\leq a\leq b\leq2^{31}-1$
Output Format
For each test case, print the number of $\mbox{I}$'s in the $32$-bit $2$'s complement representation for integers in the inclusive range from $\boldsymbol{a}$ to $\boldsymbol{b}$ on a new line.
Sample Input 0
3
-2 0
-3 4
-1 4
Sample Output 0
63
99
37
Explanation 0
Test case 0
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
31+32+0 = 63
Test case 1
-3 has 31 ones
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
31+31+32+0+1+1+2+1 = 99
Test case 2
-1 has 32 ones
0 has 0 ones
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
32+0+1+1+2+1 = 37
Sample Input 1
4
-5 0
1 7
-6 -3
3 6
Sample Output 1
155
12
122
7
Explanation 1
Test case 0
-5 has 31 ones
-4 has 30 ones
-3 has 31 ones
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
31+30+31+31+32+0 = 155
Test case 1
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
5 has 2 ones
6 has 2 ones
7 has 3 ones
1+1+2+1+2+2+3 = 12
Test case 2
-6 has 30 ones
-5 has 31 ones
-4 has 30 ones
-3 has 31 ones
30+31+30+31 = 122
Test case 3
3 has 2 ones
4 has 1 ones
5 has 2 ones
6 has 2 ones
2+1+2+2 = 7
|
def z(a):
ob, fa = 0, 2
while fa <= a * 2:
ob += (a + 1) // fa * (fa // 2) + max(0, (a + 1) % fa - fa // 2)
fa *= 2
return ob
for x in range(int(input())):
[a, b] = [int(x) for x in input().strip().split(" ")]
if a >= 0 and b >= 0:
print(z(b) - z(max(0, a - 1)))
elif a < 0 and b >= 0:
print(z(b) + (32 * -a - z(-a - 1)))
else:
print(32 * -a - z(-a - 1) - (32 * (-b - 1) - z(-b - 2)))
|
FUNC_DEF ASSIGN VAR VAR NUMBER NUMBER WHILE VAR BIN_OP VAR NUMBER VAR BIN_OP BIN_OP BIN_OP BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER FUNC_CALL VAR NUMBER BIN_OP BIN_OP BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER VAR NUMBER RETURN VAR FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN LIST VAR VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL FUNC_CALL VAR STRING IF VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR FUNC_CALL VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER IF VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR BIN_OP BIN_OP NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER EXPR FUNC_CALL VAR BIN_OP BIN_OP BIN_OP NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER BIN_OP BIN_OP NUMBER BIN_OP VAR NUMBER FUNC_CALL VAR BIN_OP VAR NUMBER
|
Understanding $2$'s complement representation is fundamental to learning about Computer Science. It allows us to write negative numbers in binary. The leftmost digit is used as a sign bit. If it is $1$, we have a negative number and it is represented as the two's complement of its absolute value. Let's say you wrote down the $2$'s complement representation for each $32$-bit integer in the inclusive range from $\boldsymbol{a}$ to $\boldsymbol{b}$. How many $1$'s would you write down in all?
For example, using an $8$-bit byte rather than $32$ bit integer, the two's complement of a number can be found by reversing all its bits and adding $1$. The two's complement representations for a few numbers are shown below:
|Number| Representation in
Number Binary Inverse Two's Complement
-3 00000011 11111100 11111101
-2 00000010 11111101 11111110
-1 00000001 11111110 11111111
0 00000000 00000000
1 00000001 00000001
2 00000010 00000010
3 00000011 00000011
To write down that range of numbers' two's complements in $8$ bits, we wrote $\textbf{26}\:1$'s. Remember to use $32$ bits rather than $8$ in your solution. The logic is the same, so the $8$ bit representation was chosen to reduce apparent complexity in the example.
Function Description
Complete the twosCompliment function in the editor below. It should return an integer.
twosCompliment has the following parameter(s):
- a: an integer, the range minimum
- b: an integer, the range maximum
Input Format
The first line contains an integer $\mathbf{T}$, the number of test cases.
Each of the next $\mathbf{T}$ lines contains two space-separated integers, $\boldsymbol{a}$ and $\boldsymbol{b}$.
Constraints
$T\leq1000$
$-2^{31}\leq a\leq b\leq2^{31}-1$
Output Format
For each test case, print the number of $\mbox{I}$'s in the $32$-bit $2$'s complement representation for integers in the inclusive range from $\boldsymbol{a}$ to $\boldsymbol{b}$ on a new line.
Sample Input 0
3
-2 0
-3 4
-1 4
Sample Output 0
63
99
37
Explanation 0
Test case 0
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
31+32+0 = 63
Test case 1
-3 has 31 ones
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
31+31+32+0+1+1+2+1 = 99
Test case 2
-1 has 32 ones
0 has 0 ones
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
32+0+1+1+2+1 = 37
Sample Input 1
4
-5 0
1 7
-6 -3
3 6
Sample Output 1
155
12
122
7
Explanation 1
Test case 0
-5 has 31 ones
-4 has 30 ones
-3 has 31 ones
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
31+30+31+31+32+0 = 155
Test case 1
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
5 has 2 ones
6 has 2 ones
7 has 3 ones
1+1+2+1+2+2+3 = 12
Test case 2
-6 has 30 ones
-5 has 31 ones
-4 has 30 ones
-3 has 31 ones
30+31+30+31 = 122
Test case 3
3 has 2 ones
4 has 1 ones
5 has 2 ones
6 has 2 ones
2+1+2+2 = 7
|
def ones_between(a, b):
if a >= 0:
return ones_below(b) - ones_below(a)
if b < 0:
return ones_below(-b) - ones_below(-a) + 32 * (b - a)
return ones_below(b) - 32 * a - ones_below(-a)
def ones_below(n):
k = n.bit_length() - 1
if n & n - 1 == 0:
return n // 2 * k
m = 1 << k
return ones_below(m) + ones_below(n - m) + n - m
t = int(input())
for t0 in range(t):
a, b = input().split()
a, b = int(a), int(b)
print(ones_between(a, b + 1))
|
FUNC_DEF IF VAR NUMBER RETURN BIN_OP FUNC_CALL VAR VAR FUNC_CALL VAR VAR IF VAR NUMBER RETURN BIN_OP BIN_OP FUNC_CALL VAR VAR FUNC_CALL VAR VAR BIN_OP NUMBER BIN_OP VAR VAR RETURN BIN_OP BIN_OP FUNC_CALL VAR VAR BIN_OP NUMBER VAR FUNC_CALL VAR VAR FUNC_DEF ASSIGN VAR BIN_OP FUNC_CALL VAR NUMBER IF BIN_OP VAR BIN_OP VAR NUMBER NUMBER RETURN BIN_OP BIN_OP VAR NUMBER VAR ASSIGN VAR BIN_OP NUMBER VAR RETURN BIN_OP BIN_OP BIN_OP FUNC_CALL VAR VAR FUNC_CALL VAR BIN_OP VAR VAR VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER
|
Understanding $2$'s complement representation is fundamental to learning about Computer Science. It allows us to write negative numbers in binary. The leftmost digit is used as a sign bit. If it is $1$, we have a negative number and it is represented as the two's complement of its absolute value. Let's say you wrote down the $2$'s complement representation for each $32$-bit integer in the inclusive range from $\boldsymbol{a}$ to $\boldsymbol{b}$. How many $1$'s would you write down in all?
For example, using an $8$-bit byte rather than $32$ bit integer, the two's complement of a number can be found by reversing all its bits and adding $1$. The two's complement representations for a few numbers are shown below:
|Number| Representation in
Number Binary Inverse Two's Complement
-3 00000011 11111100 11111101
-2 00000010 11111101 11111110
-1 00000001 11111110 11111111
0 00000000 00000000
1 00000001 00000001
2 00000010 00000010
3 00000011 00000011
To write down that range of numbers' two's complements in $8$ bits, we wrote $\textbf{26}\:1$'s. Remember to use $32$ bits rather than $8$ in your solution. The logic is the same, so the $8$ bit representation was chosen to reduce apparent complexity in the example.
Function Description
Complete the twosCompliment function in the editor below. It should return an integer.
twosCompliment has the following parameter(s):
- a: an integer, the range minimum
- b: an integer, the range maximum
Input Format
The first line contains an integer $\mathbf{T}$, the number of test cases.
Each of the next $\mathbf{T}$ lines contains two space-separated integers, $\boldsymbol{a}$ and $\boldsymbol{b}$.
Constraints
$T\leq1000$
$-2^{31}\leq a\leq b\leq2^{31}-1$
Output Format
For each test case, print the number of $\mbox{I}$'s in the $32$-bit $2$'s complement representation for integers in the inclusive range from $\boldsymbol{a}$ to $\boldsymbol{b}$ on a new line.
Sample Input 0
3
-2 0
-3 4
-1 4
Sample Output 0
63
99
37
Explanation 0
Test case 0
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
31+32+0 = 63
Test case 1
-3 has 31 ones
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
31+31+32+0+1+1+2+1 = 99
Test case 2
-1 has 32 ones
0 has 0 ones
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
32+0+1+1+2+1 = 37
Sample Input 1
4
-5 0
1 7
-6 -3
3 6
Sample Output 1
155
12
122
7
Explanation 1
Test case 0
-5 has 31 ones
-4 has 30 ones
-3 has 31 ones
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
31+30+31+31+32+0 = 155
Test case 1
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
5 has 2 ones
6 has 2 ones
7 has 3 ones
1+1+2+1+2+2+3 = 12
Test case 2
-6 has 30 ones
-5 has 31 ones
-4 has 30 ones
-3 has 31 ones
30+31+30+31 = 122
Test case 3
3 has 2 ones
4 has 1 ones
5 has 2 ones
6 has 2 ones
2+1+2+2 = 7
|
n = 1 << 32
def h(x):
res = 0
while x > 0:
res += x & 1
x >>= 1
return res
def g(x):
if x <= 1:
return x
if x & 1:
return 2 * g(x >> 1) + (x + 1) // 2
return g(x - 1) + h(x)
def f(a, b):
if a == 0:
return g(b)
if a > 0:
return g(b) - g(a - 1)
if b >= 0:
return g(b) + f(n + a, n - 1)
return f(a, 0) - f(b + 1, 0)
for T in range(int(input())):
print(f(*map(int, input().split())))
|
ASSIGN VAR BIN_OP NUMBER NUMBER FUNC_DEF ASSIGN VAR NUMBER WHILE VAR NUMBER VAR BIN_OP VAR NUMBER VAR NUMBER RETURN VAR FUNC_DEF IF VAR NUMBER RETURN VAR IF BIN_OP VAR NUMBER RETURN BIN_OP BIN_OP NUMBER FUNC_CALL VAR BIN_OP VAR NUMBER BIN_OP BIN_OP VAR NUMBER NUMBER RETURN BIN_OP FUNC_CALL VAR BIN_OP VAR NUMBER FUNC_CALL VAR VAR FUNC_DEF IF VAR NUMBER RETURN FUNC_CALL VAR VAR IF VAR NUMBER RETURN BIN_OP FUNC_CALL VAR VAR FUNC_CALL VAR BIN_OP VAR NUMBER IF VAR NUMBER RETURN BIN_OP FUNC_CALL VAR VAR FUNC_CALL VAR BIN_OP VAR VAR BIN_OP VAR NUMBER RETURN BIN_OP FUNC_CALL VAR VAR NUMBER FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR EXPR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR
|
Understanding $2$'s complement representation is fundamental to learning about Computer Science. It allows us to write negative numbers in binary. The leftmost digit is used as a sign bit. If it is $1$, we have a negative number and it is represented as the two's complement of its absolute value. Let's say you wrote down the $2$'s complement representation for each $32$-bit integer in the inclusive range from $\boldsymbol{a}$ to $\boldsymbol{b}$. How many $1$'s would you write down in all?
For example, using an $8$-bit byte rather than $32$ bit integer, the two's complement of a number can be found by reversing all its bits and adding $1$. The two's complement representations for a few numbers are shown below:
|Number| Representation in
Number Binary Inverse Two's Complement
-3 00000011 11111100 11111101
-2 00000010 11111101 11111110
-1 00000001 11111110 11111111
0 00000000 00000000
1 00000001 00000001
2 00000010 00000010
3 00000011 00000011
To write down that range of numbers' two's complements in $8$ bits, we wrote $\textbf{26}\:1$'s. Remember to use $32$ bits rather than $8$ in your solution. The logic is the same, so the $8$ bit representation was chosen to reduce apparent complexity in the example.
Function Description
Complete the twosCompliment function in the editor below. It should return an integer.
twosCompliment has the following parameter(s):
- a: an integer, the range minimum
- b: an integer, the range maximum
Input Format
The first line contains an integer $\mathbf{T}$, the number of test cases.
Each of the next $\mathbf{T}$ lines contains two space-separated integers, $\boldsymbol{a}$ and $\boldsymbol{b}$.
Constraints
$T\leq1000$
$-2^{31}\leq a\leq b\leq2^{31}-1$
Output Format
For each test case, print the number of $\mbox{I}$'s in the $32$-bit $2$'s complement representation for integers in the inclusive range from $\boldsymbol{a}$ to $\boldsymbol{b}$ on a new line.
Sample Input 0
3
-2 0
-3 4
-1 4
Sample Output 0
63
99
37
Explanation 0
Test case 0
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
31+32+0 = 63
Test case 1
-3 has 31 ones
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
31+31+32+0+1+1+2+1 = 99
Test case 2
-1 has 32 ones
0 has 0 ones
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
32+0+1+1+2+1 = 37
Sample Input 1
4
-5 0
1 7
-6 -3
3 6
Sample Output 1
155
12
122
7
Explanation 1
Test case 0
-5 has 31 ones
-4 has 30 ones
-3 has 31 ones
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
31+30+31+31+32+0 = 155
Test case 1
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
5 has 2 ones
6 has 2 ones
7 has 3 ones
1+1+2+1+2+2+3 = 12
Test case 2
-6 has 30 ones
-5 has 31 ones
-4 has 30 ones
-3 has 31 ones
30+31+30+31 = 122
Test case 3
3 has 2 ones
4 has 1 ones
5 has 2 ones
6 has 2 ones
2+1+2+2 = 7
|
def bin_s(n):
lower = 0
upper = base
while lower < upper:
x = lower + (upper - lower) // 2
val = 2**x
if n == val:
return val
elif n > val:
if lower == x:
return val
lower = x
elif n < val:
upper = x
return 2**lower
def cum1(n):
if n <= 1:
return n
else:
n2 = n // 2
return 2 * cum1(n2) + n2 - 1
def div3(n):
if n <= 1:
return n
else:
np = bin_s(n)
nr = n - np
cp = cum1(np)
cr = div3(nr) + nr
return cp + cr
def findComplis(n, base):
ones = div3(n)
zeros = base * n - ones
return zeros, ones
N, base = int(input()), 32
lrgst_int = 2 ** (base - 1)
for cur in range(N):
A, B = [int(t) for t in input().split()]
if A > B:
cop = A
A = B
B = cop
if B >= A > 0:
A -= 1
if A <= B < 0:
B += 1
if A <= -1:
a = -1 - A
onesA, zerosA = findComplis(a, base)
onesA += base
else:
zerosA, onesA = findComplis(A, base)
if B <= -1:
b = -1 - B
onesB, zerosB = findComplis(b, base)
onesB += base
ans = onesA - onesB
else:
zerosA, onesB = findComplis(B, base)
if A < 0:
ans = onesB + onesA
else:
ans = onesB - onesA
print(ans)
|
FUNC_DEF ASSIGN VAR NUMBER ASSIGN VAR VAR WHILE VAR VAR ASSIGN VAR BIN_OP VAR BIN_OP BIN_OP VAR VAR NUMBER ASSIGN VAR BIN_OP NUMBER VAR IF VAR VAR RETURN VAR IF VAR VAR IF VAR VAR RETURN VAR ASSIGN VAR VAR IF VAR VAR ASSIGN VAR VAR RETURN BIN_OP NUMBER VAR FUNC_DEF IF VAR NUMBER RETURN VAR ASSIGN VAR BIN_OP VAR NUMBER RETURN BIN_OP BIN_OP BIN_OP NUMBER FUNC_CALL VAR VAR VAR NUMBER FUNC_DEF IF VAR NUMBER RETURN VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP FUNC_CALL VAR VAR VAR RETURN BIN_OP VAR VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP BIN_OP VAR VAR VAR RETURN VAR VAR ASSIGN VAR VAR FUNC_CALL VAR FUNC_CALL VAR NUMBER ASSIGN VAR BIN_OP NUMBER BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR IF VAR VAR ASSIGN VAR VAR ASSIGN VAR VAR ASSIGN VAR VAR IF VAR VAR NUMBER VAR NUMBER IF VAR VAR NUMBER VAR NUMBER IF VAR NUMBER ASSIGN VAR BIN_OP NUMBER VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR IF VAR NUMBER ASSIGN VAR BIN_OP NUMBER VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR VAR VAR ASSIGN VAR BIN_OP VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR IF VAR NUMBER ASSIGN VAR BIN_OP VAR VAR ASSIGN VAR BIN_OP VAR VAR EXPR FUNC_CALL VAR VAR
|
Understanding $2$'s complement representation is fundamental to learning about Computer Science. It allows us to write negative numbers in binary. The leftmost digit is used as a sign bit. If it is $1$, we have a negative number and it is represented as the two's complement of its absolute value. Let's say you wrote down the $2$'s complement representation for each $32$-bit integer in the inclusive range from $\boldsymbol{a}$ to $\boldsymbol{b}$. How many $1$'s would you write down in all?
For example, using an $8$-bit byte rather than $32$ bit integer, the two's complement of a number can be found by reversing all its bits and adding $1$. The two's complement representations for a few numbers are shown below:
|Number| Representation in
Number Binary Inverse Two's Complement
-3 00000011 11111100 11111101
-2 00000010 11111101 11111110
-1 00000001 11111110 11111111
0 00000000 00000000
1 00000001 00000001
2 00000010 00000010
3 00000011 00000011
To write down that range of numbers' two's complements in $8$ bits, we wrote $\textbf{26}\:1$'s. Remember to use $32$ bits rather than $8$ in your solution. The logic is the same, so the $8$ bit representation was chosen to reduce apparent complexity in the example.
Function Description
Complete the twosCompliment function in the editor below. It should return an integer.
twosCompliment has the following parameter(s):
- a: an integer, the range minimum
- b: an integer, the range maximum
Input Format
The first line contains an integer $\mathbf{T}$, the number of test cases.
Each of the next $\mathbf{T}$ lines contains two space-separated integers, $\boldsymbol{a}$ and $\boldsymbol{b}$.
Constraints
$T\leq1000$
$-2^{31}\leq a\leq b\leq2^{31}-1$
Output Format
For each test case, print the number of $\mbox{I}$'s in the $32$-bit $2$'s complement representation for integers in the inclusive range from $\boldsymbol{a}$ to $\boldsymbol{b}$ on a new line.
Sample Input 0
3
-2 0
-3 4
-1 4
Sample Output 0
63
99
37
Explanation 0
Test case 0
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
31+32+0 = 63
Test case 1
-3 has 31 ones
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
31+31+32+0+1+1+2+1 = 99
Test case 2
-1 has 32 ones
0 has 0 ones
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
32+0+1+1+2+1 = 37
Sample Input 1
4
-5 0
1 7
-6 -3
3 6
Sample Output 1
155
12
122
7
Explanation 1
Test case 0
-5 has 31 ones
-4 has 30 ones
-3 has 31 ones
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
31+30+31+31+32+0 = 155
Test case 1
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
5 has 2 ones
6 has 2 ones
7 has 3 ones
1+1+2+1+2+2+3 = 12
Test case 2
-6 has 30 ones
-5 has 31 ones
-4 has 30 ones
-3 has 31 ones
30+31+30+31 = 122
Test case 3
3 has 2 ones
4 has 1 ones
5 has 2 ones
6 has 2 ones
2+1+2+2 = 7
|
def Ones(x):
if x < 0:
x = (1 << 32) + x
BitAtOnes = []
for i in range(32):
if x & 1:
BitAtOnes.append(i)
x //= 2
return BitAtOnes
def Zeroes(x):
return Ones(~x)
def TotalOnesPos(x):
OneIdx = Ones(x)[::-1]
Total = 0
for i, Idx in enumerate(OneIdx):
Total += i * (1 << Idx) + Idx * (1 << Idx) // 2
Total += len(OneIdx)
return Total
def TotalOnesNeg(x):
ZeroIdx = Zeroes(x)[::-1]
Total = 0
for i, Idx in enumerate(ZeroIdx):
Total += (32 - i - Idx) * (1 << Idx) + Idx * (1 << Idx) // 2
Total += 32 - len(ZeroIdx)
return Total
def TotalOnes(x):
if x < 0:
return TotalOnesNeg(x)
return TotalOnesPos(x)
def Sign(x):
if x < 0:
return -1
return 1
T = int(input().strip())
for dummyT in range(T):
A, B = [int(x) for x in input().strip().split()]
if Sign(A) == Sign(B):
if Sign(A) > 0:
print(TotalOnes(B) - TotalOnes(A) + len(Ones(A)))
else:
print(TotalOnes(A) - TotalOnes(B) + len(Ones(B)))
else:
print(TotalOnes(A) + TotalOnes(B))
|
FUNC_DEF IF VAR NUMBER ASSIGN VAR BIN_OP BIN_OP NUMBER NUMBER VAR ASSIGN VAR LIST FOR VAR FUNC_CALL VAR NUMBER IF BIN_OP VAR NUMBER EXPR FUNC_CALL VAR VAR VAR NUMBER RETURN VAR FUNC_DEF RETURN FUNC_CALL VAR VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR NUMBER ASSIGN VAR NUMBER FOR VAR VAR FUNC_CALL VAR VAR VAR BIN_OP BIN_OP VAR BIN_OP NUMBER VAR BIN_OP BIN_OP VAR BIN_OP NUMBER VAR NUMBER VAR FUNC_CALL VAR VAR RETURN VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR NUMBER ASSIGN VAR NUMBER FOR VAR VAR FUNC_CALL VAR VAR VAR BIN_OP BIN_OP BIN_OP BIN_OP NUMBER VAR VAR BIN_OP NUMBER VAR BIN_OP BIN_OP VAR BIN_OP NUMBER VAR NUMBER VAR BIN_OP NUMBER FUNC_CALL VAR VAR RETURN VAR FUNC_DEF IF VAR NUMBER RETURN FUNC_CALL VAR VAR RETURN FUNC_CALL VAR VAR FUNC_DEF IF VAR NUMBER RETURN NUMBER RETURN NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL FUNC_CALL VAR IF FUNC_CALL VAR VAR FUNC_CALL VAR VAR IF FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR BIN_OP BIN_OP FUNC_CALL VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR BIN_OP BIN_OP FUNC_CALL VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR FUNC_CALL VAR VAR
|
Understanding $2$'s complement representation is fundamental to learning about Computer Science. It allows us to write negative numbers in binary. The leftmost digit is used as a sign bit. If it is $1$, we have a negative number and it is represented as the two's complement of its absolute value. Let's say you wrote down the $2$'s complement representation for each $32$-bit integer in the inclusive range from $\boldsymbol{a}$ to $\boldsymbol{b}$. How many $1$'s would you write down in all?
For example, using an $8$-bit byte rather than $32$ bit integer, the two's complement of a number can be found by reversing all its bits and adding $1$. The two's complement representations for a few numbers are shown below:
|Number| Representation in
Number Binary Inverse Two's Complement
-3 00000011 11111100 11111101
-2 00000010 11111101 11111110
-1 00000001 11111110 11111111
0 00000000 00000000
1 00000001 00000001
2 00000010 00000010
3 00000011 00000011
To write down that range of numbers' two's complements in $8$ bits, we wrote $\textbf{26}\:1$'s. Remember to use $32$ bits rather than $8$ in your solution. The logic is the same, so the $8$ bit representation was chosen to reduce apparent complexity in the example.
Function Description
Complete the twosCompliment function in the editor below. It should return an integer.
twosCompliment has the following parameter(s):
- a: an integer, the range minimum
- b: an integer, the range maximum
Input Format
The first line contains an integer $\mathbf{T}$, the number of test cases.
Each of the next $\mathbf{T}$ lines contains two space-separated integers, $\boldsymbol{a}$ and $\boldsymbol{b}$.
Constraints
$T\leq1000$
$-2^{31}\leq a\leq b\leq2^{31}-1$
Output Format
For each test case, print the number of $\mbox{I}$'s in the $32$-bit $2$'s complement representation for integers in the inclusive range from $\boldsymbol{a}$ to $\boldsymbol{b}$ on a new line.
Sample Input 0
3
-2 0
-3 4
-1 4
Sample Output 0
63
99
37
Explanation 0
Test case 0
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
31+32+0 = 63
Test case 1
-3 has 31 ones
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
31+31+32+0+1+1+2+1 = 99
Test case 2
-1 has 32 ones
0 has 0 ones
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
32+0+1+1+2+1 = 37
Sample Input 1
4
-5 0
1 7
-6 -3
3 6
Sample Output 1
155
12
122
7
Explanation 1
Test case 0
-5 has 31 ones
-4 has 30 ones
-3 has 31 ones
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
31+30+31+31+32+0 = 155
Test case 1
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
5 has 2 ones
6 has 2 ones
7 has 3 ones
1+1+2+1+2+2+3 = 12
Test case 2
-6 has 30 ones
-5 has 31 ones
-4 has 30 ones
-3 has 31 ones
30+31+30+31 = 122
Test case 3
3 has 2 ones
4 has 1 ones
5 has 2 ones
6 has 2 ones
2+1+2+2 = 7
|
def clear_msb(x):
tmp = x
msb = 0
while x != 0:
x >>= 1
msb += 1
msb = max(0, msb - 1)
x = tmp
return x & (1 << msb) - 1
def num_ones_from_zero_msb_of(end):
msb = -1
while end != 0:
end >>= 1
msb += 1
return msb * 2 ** (msb - 1)
def num_ones_from_zero(end):
if end <= 1:
return end
next_end = clear_msb(end)
return next_end + 1 + num_ones_from_zero(next_end) + num_ones_from_zero_msb_of(end)
def num_ones(start, end):
ones = num_ones_from_zero(end)
if start > 0:
ones -= num_ones_from_zero(start - 1)
return ones
def num_ones_twos_comp(start, end):
if start < 0:
if end >= 0:
start = 2**32 + start
return num_ones(start, 2**32 - 1) + num_ones(0, end)
start = 2**32 + start if start < 0 else start
end = 2**32 + end if end < 0 else end
return num_ones(start, end)
n = int(input())
for _ in range(n):
start, end = map(int, input().split(" "))
print(num_ones_twos_comp(start, end))
|
FUNC_DEF ASSIGN VAR VAR ASSIGN VAR NUMBER WHILE VAR NUMBER VAR NUMBER VAR NUMBER ASSIGN VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER ASSIGN VAR VAR RETURN BIN_OP VAR BIN_OP BIN_OP NUMBER VAR NUMBER FUNC_DEF ASSIGN VAR NUMBER WHILE VAR NUMBER VAR NUMBER VAR NUMBER RETURN BIN_OP VAR BIN_OP NUMBER BIN_OP VAR NUMBER FUNC_DEF IF VAR NUMBER RETURN VAR ASSIGN VAR FUNC_CALL VAR VAR RETURN BIN_OP BIN_OP BIN_OP VAR NUMBER FUNC_CALL VAR VAR FUNC_CALL VAR VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR IF VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER RETURN VAR FUNC_DEF IF VAR NUMBER IF VAR NUMBER ASSIGN VAR BIN_OP BIN_OP NUMBER NUMBER VAR RETURN BIN_OP FUNC_CALL VAR VAR BIN_OP BIN_OP NUMBER NUMBER NUMBER FUNC_CALL VAR NUMBER VAR ASSIGN VAR VAR NUMBER BIN_OP BIN_OP NUMBER NUMBER VAR VAR ASSIGN VAR VAR NUMBER BIN_OP BIN_OP NUMBER NUMBER VAR VAR RETURN FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR STRING EXPR FUNC_CALL VAR FUNC_CALL VAR VAR VAR
|
Understanding $2$'s complement representation is fundamental to learning about Computer Science. It allows us to write negative numbers in binary. The leftmost digit is used as a sign bit. If it is $1$, we have a negative number and it is represented as the two's complement of its absolute value. Let's say you wrote down the $2$'s complement representation for each $32$-bit integer in the inclusive range from $\boldsymbol{a}$ to $\boldsymbol{b}$. How many $1$'s would you write down in all?
For example, using an $8$-bit byte rather than $32$ bit integer, the two's complement of a number can be found by reversing all its bits and adding $1$. The two's complement representations for a few numbers are shown below:
|Number| Representation in
Number Binary Inverse Two's Complement
-3 00000011 11111100 11111101
-2 00000010 11111101 11111110
-1 00000001 11111110 11111111
0 00000000 00000000
1 00000001 00000001
2 00000010 00000010
3 00000011 00000011
To write down that range of numbers' two's complements in $8$ bits, we wrote $\textbf{26}\:1$'s. Remember to use $32$ bits rather than $8$ in your solution. The logic is the same, so the $8$ bit representation was chosen to reduce apparent complexity in the example.
Function Description
Complete the twosCompliment function in the editor below. It should return an integer.
twosCompliment has the following parameter(s):
- a: an integer, the range minimum
- b: an integer, the range maximum
Input Format
The first line contains an integer $\mathbf{T}$, the number of test cases.
Each of the next $\mathbf{T}$ lines contains two space-separated integers, $\boldsymbol{a}$ and $\boldsymbol{b}$.
Constraints
$T\leq1000$
$-2^{31}\leq a\leq b\leq2^{31}-1$
Output Format
For each test case, print the number of $\mbox{I}$'s in the $32$-bit $2$'s complement representation for integers in the inclusive range from $\boldsymbol{a}$ to $\boldsymbol{b}$ on a new line.
Sample Input 0
3
-2 0
-3 4
-1 4
Sample Output 0
63
99
37
Explanation 0
Test case 0
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
31+32+0 = 63
Test case 1
-3 has 31 ones
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
31+31+32+0+1+1+2+1 = 99
Test case 2
-1 has 32 ones
0 has 0 ones
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
32+0+1+1+2+1 = 37
Sample Input 1
4
-5 0
1 7
-6 -3
3 6
Sample Output 1
155
12
122
7
Explanation 1
Test case 0
-5 has 31 ones
-4 has 30 ones
-3 has 31 ones
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
31+30+31+31+32+0 = 155
Test case 1
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
5 has 2 ones
6 has 2 ones
7 has 3 ones
1+1+2+1+2+2+3 = 12
Test case 2
-6 has 30 ones
-5 has 31 ones
-4 has 30 ones
-3 has 31 ones
30+31+30+31 = 122
Test case 3
3 has 2 ones
4 has 1 ones
5 has 2 ones
6 has 2 ones
2+1+2+2 = 7
|
def count_pos(num):
if num == 0:
return 0
total = 0
for curr_bit in range(32):
total += num // (2 << curr_bit) << curr_bit
total += max(0, num % (2 << curr_bit) - ((1 << curr_bit) - 1))
return total
def count_neg(num):
if num == 0:
return 0
assert num < 0
total = -num * 32
zeros = count_pos(-num - 1)
return total - zeros
def count(a, b):
if b < 0:
return count_neg(a) - count_neg(b + 1)
elif a > 0:
return count_pos(b) - count_pos(a - 1)
elif a == 0:
return count_pos(b)
elif b == 0:
return count_neg(a)
else:
return count_neg(a) + count_pos(b)
cases = int(input())
for _ in range(cases):
nums = [int(x) for x in input().split()]
result = count(*nums)
print(result)
|
FUNC_DEF IF VAR NUMBER RETURN NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER VAR BIN_OP BIN_OP VAR BIN_OP NUMBER VAR VAR VAR FUNC_CALL VAR NUMBER BIN_OP BIN_OP VAR BIN_OP NUMBER VAR BIN_OP BIN_OP NUMBER VAR NUMBER RETURN VAR FUNC_DEF IF VAR NUMBER RETURN NUMBER VAR NUMBER ASSIGN VAR BIN_OP VAR NUMBER ASSIGN VAR FUNC_CALL VAR BIN_OP VAR NUMBER RETURN BIN_OP VAR VAR FUNC_DEF IF VAR NUMBER RETURN BIN_OP FUNC_CALL VAR VAR FUNC_CALL VAR BIN_OP VAR NUMBER IF VAR NUMBER RETURN BIN_OP FUNC_CALL VAR VAR FUNC_CALL VAR BIN_OP VAR NUMBER IF VAR NUMBER RETURN FUNC_CALL VAR VAR IF VAR NUMBER RETURN FUNC_CALL VAR VAR RETURN BIN_OP FUNC_CALL VAR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR
|
Understanding $2$'s complement representation is fundamental to learning about Computer Science. It allows us to write negative numbers in binary. The leftmost digit is used as a sign bit. If it is $1$, we have a negative number and it is represented as the two's complement of its absolute value. Let's say you wrote down the $2$'s complement representation for each $32$-bit integer in the inclusive range from $\boldsymbol{a}$ to $\boldsymbol{b}$. How many $1$'s would you write down in all?
For example, using an $8$-bit byte rather than $32$ bit integer, the two's complement of a number can be found by reversing all its bits and adding $1$. The two's complement representations for a few numbers are shown below:
|Number| Representation in
Number Binary Inverse Two's Complement
-3 00000011 11111100 11111101
-2 00000010 11111101 11111110
-1 00000001 11111110 11111111
0 00000000 00000000
1 00000001 00000001
2 00000010 00000010
3 00000011 00000011
To write down that range of numbers' two's complements in $8$ bits, we wrote $\textbf{26}\:1$'s. Remember to use $32$ bits rather than $8$ in your solution. The logic is the same, so the $8$ bit representation was chosen to reduce apparent complexity in the example.
Function Description
Complete the twosCompliment function in the editor below. It should return an integer.
twosCompliment has the following parameter(s):
- a: an integer, the range minimum
- b: an integer, the range maximum
Input Format
The first line contains an integer $\mathbf{T}$, the number of test cases.
Each of the next $\mathbf{T}$ lines contains two space-separated integers, $\boldsymbol{a}$ and $\boldsymbol{b}$.
Constraints
$T\leq1000$
$-2^{31}\leq a\leq b\leq2^{31}-1$
Output Format
For each test case, print the number of $\mbox{I}$'s in the $32$-bit $2$'s complement representation for integers in the inclusive range from $\boldsymbol{a}$ to $\boldsymbol{b}$ on a new line.
Sample Input 0
3
-2 0
-3 4
-1 4
Sample Output 0
63
99
37
Explanation 0
Test case 0
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
31+32+0 = 63
Test case 1
-3 has 31 ones
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
31+31+32+0+1+1+2+1 = 99
Test case 2
-1 has 32 ones
0 has 0 ones
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
32+0+1+1+2+1 = 37
Sample Input 1
4
-5 0
1 7
-6 -3
3 6
Sample Output 1
155
12
122
7
Explanation 1
Test case 0
-5 has 31 ones
-4 has 30 ones
-3 has 31 ones
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
31+30+31+31+32+0 = 155
Test case 1
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
5 has 2 ones
6 has 2 ones
7 has 3 ones
1+1+2+1+2+2+3 = 12
Test case 2
-6 has 30 ones
-5 has 31 ones
-4 has 30 ones
-3 has 31 ones
30+31+30+31 = 122
Test case 3
3 has 2 ones
4 has 1 ones
5 has 2 ones
6 has 2 ones
2+1+2+2 = 7
|
def ones(n):
total = 0
for i in range(31, -1, -1):
k = 1 << i
if n & k:
n ^= k
total += bits[i] + (n + 1)
return total
def onesNeg(n):
return n * -32 - ones(~n)
bits = [0] * 32
for i in range(1, 32):
bits[i] = (1 << i - 1) * i
for _ in range(int(input())):
a, b = map(int, input().strip().split())
if a > 0:
print(ones(b) - ones(a - 1))
elif a == 0:
print(ones(b))
elif b >= 0:
print(onesNeg(a) + ones(b))
elif b == -1:
print(onesNeg(a))
else:
print(onesNeg(a) - onesNeg(b + 1))
|
FUNC_DEF ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER NUMBER NUMBER ASSIGN VAR BIN_OP NUMBER VAR IF BIN_OP VAR VAR VAR VAR VAR BIN_OP VAR VAR BIN_OP VAR NUMBER RETURN VAR FUNC_DEF RETURN BIN_OP BIN_OP VAR NUMBER FUNC_CALL VAR VAR ASSIGN VAR BIN_OP LIST NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER NUMBER ASSIGN VAR VAR BIN_OP BIN_OP NUMBER BIN_OP VAR NUMBER VAR FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL FUNC_CALL VAR IF VAR NUMBER EXPR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR FUNC_CALL VAR BIN_OP VAR NUMBER IF VAR NUMBER EXPR FUNC_CALL VAR FUNC_CALL VAR VAR IF VAR NUMBER EXPR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR FUNC_CALL VAR VAR IF VAR NUMBER EXPR FUNC_CALL VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR FUNC_CALL VAR BIN_OP VAR NUMBER
|
Understanding $2$'s complement representation is fundamental to learning about Computer Science. It allows us to write negative numbers in binary. The leftmost digit is used as a sign bit. If it is $1$, we have a negative number and it is represented as the two's complement of its absolute value. Let's say you wrote down the $2$'s complement representation for each $32$-bit integer in the inclusive range from $\boldsymbol{a}$ to $\boldsymbol{b}$. How many $1$'s would you write down in all?
For example, using an $8$-bit byte rather than $32$ bit integer, the two's complement of a number can be found by reversing all its bits and adding $1$. The two's complement representations for a few numbers are shown below:
|Number| Representation in
Number Binary Inverse Two's Complement
-3 00000011 11111100 11111101
-2 00000010 11111101 11111110
-1 00000001 11111110 11111111
0 00000000 00000000
1 00000001 00000001
2 00000010 00000010
3 00000011 00000011
To write down that range of numbers' two's complements in $8$ bits, we wrote $\textbf{26}\:1$'s. Remember to use $32$ bits rather than $8$ in your solution. The logic is the same, so the $8$ bit representation was chosen to reduce apparent complexity in the example.
Function Description
Complete the twosCompliment function in the editor below. It should return an integer.
twosCompliment has the following parameter(s):
- a: an integer, the range minimum
- b: an integer, the range maximum
Input Format
The first line contains an integer $\mathbf{T}$, the number of test cases.
Each of the next $\mathbf{T}$ lines contains two space-separated integers, $\boldsymbol{a}$ and $\boldsymbol{b}$.
Constraints
$T\leq1000$
$-2^{31}\leq a\leq b\leq2^{31}-1$
Output Format
For each test case, print the number of $\mbox{I}$'s in the $32$-bit $2$'s complement representation for integers in the inclusive range from $\boldsymbol{a}$ to $\boldsymbol{b}$ on a new line.
Sample Input 0
3
-2 0
-3 4
-1 4
Sample Output 0
63
99
37
Explanation 0
Test case 0
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
31+32+0 = 63
Test case 1
-3 has 31 ones
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
31+31+32+0+1+1+2+1 = 99
Test case 2
-1 has 32 ones
0 has 0 ones
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
32+0+1+1+2+1 = 37
Sample Input 1
4
-5 0
1 7
-6 -3
3 6
Sample Output 1
155
12
122
7
Explanation 1
Test case 0
-5 has 31 ones
-4 has 30 ones
-3 has 31 ones
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
31+30+31+31+32+0 = 155
Test case 1
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
5 has 2 ones
6 has 2 ones
7 has 3 ones
1+1+2+1+2+2+3 = 12
Test case 2
-6 has 30 ones
-5 has 31 ones
-4 has 30 ones
-3 has 31 ones
30+31+30+31 = 122
Test case 3
3 has 2 ones
4 has 1 ones
5 has 2 ones
6 has 2 ones
2+1+2+2 = 7
|
n = int(input())
memo = {(0): 1}
def count_bit_2exp(k):
if k in memo:
return memo[k]
result = 1 + 2 * (count_bit_2exp(k - 1) - 1) + 2 ** (k - 1)
memo[k] = result
return result
def count_bit(n):
if n < 0:
return 32 * -n - count_bit(-n - 1)
result = 0
hbit = 0
for b in reversed(range(31)):
if n & 2**b:
result += count_bit_2exp(b) + hbit * 2**b
hbit += 1
return result
for i in range(n):
a, b = input().split()
a, b = int(a), int(b)
if a > 0:
print(count_bit(b) - count_bit(a - 1))
elif b < 0:
print(count_bit(a) - count_bit(b + 1))
else:
print(count_bit(a) + count_bit(b))
|
ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR DICT NUMBER NUMBER FUNC_DEF IF VAR VAR RETURN VAR VAR ASSIGN VAR BIN_OP BIN_OP NUMBER BIN_OP NUMBER BIN_OP FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER BIN_OP NUMBER BIN_OP VAR NUMBER ASSIGN VAR VAR VAR RETURN VAR FUNC_DEF IF VAR NUMBER RETURN BIN_OP BIN_OP NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR FUNC_CALL VAR NUMBER IF BIN_OP VAR BIN_OP NUMBER VAR VAR BIN_OP FUNC_CALL VAR VAR BIN_OP VAR BIN_OP NUMBER VAR VAR NUMBER RETURN VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR IF VAR NUMBER EXPR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR FUNC_CALL VAR BIN_OP VAR NUMBER IF VAR NUMBER EXPR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR FUNC_CALL VAR BIN_OP VAR NUMBER EXPR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR FUNC_CALL VAR VAR
|
Understanding $2$'s complement representation is fundamental to learning about Computer Science. It allows us to write negative numbers in binary. The leftmost digit is used as a sign bit. If it is $1$, we have a negative number and it is represented as the two's complement of its absolute value. Let's say you wrote down the $2$'s complement representation for each $32$-bit integer in the inclusive range from $\boldsymbol{a}$ to $\boldsymbol{b}$. How many $1$'s would you write down in all?
For example, using an $8$-bit byte rather than $32$ bit integer, the two's complement of a number can be found by reversing all its bits and adding $1$. The two's complement representations for a few numbers are shown below:
|Number| Representation in
Number Binary Inverse Two's Complement
-3 00000011 11111100 11111101
-2 00000010 11111101 11111110
-1 00000001 11111110 11111111
0 00000000 00000000
1 00000001 00000001
2 00000010 00000010
3 00000011 00000011
To write down that range of numbers' two's complements in $8$ bits, we wrote $\textbf{26}\:1$'s. Remember to use $32$ bits rather than $8$ in your solution. The logic is the same, so the $8$ bit representation was chosen to reduce apparent complexity in the example.
Function Description
Complete the twosCompliment function in the editor below. It should return an integer.
twosCompliment has the following parameter(s):
- a: an integer, the range minimum
- b: an integer, the range maximum
Input Format
The first line contains an integer $\mathbf{T}$, the number of test cases.
Each of the next $\mathbf{T}$ lines contains two space-separated integers, $\boldsymbol{a}$ and $\boldsymbol{b}$.
Constraints
$T\leq1000$
$-2^{31}\leq a\leq b\leq2^{31}-1$
Output Format
For each test case, print the number of $\mbox{I}$'s in the $32$-bit $2$'s complement representation for integers in the inclusive range from $\boldsymbol{a}$ to $\boldsymbol{b}$ on a new line.
Sample Input 0
3
-2 0
-3 4
-1 4
Sample Output 0
63
99
37
Explanation 0
Test case 0
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
31+32+0 = 63
Test case 1
-3 has 31 ones
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
31+31+32+0+1+1+2+1 = 99
Test case 2
-1 has 32 ones
0 has 0 ones
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
32+0+1+1+2+1 = 37
Sample Input 1
4
-5 0
1 7
-6 -3
3 6
Sample Output 1
155
12
122
7
Explanation 1
Test case 0
-5 has 31 ones
-4 has 30 ones
-3 has 31 ones
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
31+30+31+31+32+0 = 155
Test case 1
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
5 has 2 ones
6 has 2 ones
7 has 3 ones
1+1+2+1+2+2+3 = 12
Test case 2
-6 has 30 ones
-5 has 31 ones
-4 has 30 ones
-3 has 31 ones
30+31+30+31 = 122
Test case 3
3 has 2 ones
4 has 1 ones
5 has 2 ones
6 has 2 ones
2+1+2+2 = 7
|
def fun(a):
mystr = bin(a)[2:]
ans = 0
count = 0
length = len(mystr)
for i in range(0, length):
if mystr[i] == "1":
ans = (
ans
+ count * 2 ** (length - 1 - i)
+ (length - 1 - i) * 2 ** (length - 2 - i)
)
count = count + 1
return int(ans)
t = int(input())
for i in range(0, t):
data = list(map(int, input().split()))
if data[0] == data[1]:
if data[0] < 0:
print(fun(2**32 + data[0] + 1) - fun(2**32 + data[0]))
else:
print(fun(data[0] + 1) - fun(data[0]))
elif data[0] == 0 and data[1] > 0:
print(fun(data[1] + 1))
elif data[0] > 0 and data[1] > 0:
print(fun(data[1] + 1) - fun(data[0]))
elif data[0] < 0 and data[1] == 0:
print(fun(2**32 - 1 + 1) - fun(2**32 + data[0]))
elif data[0] < 0 and data[1] < 0:
print(fun(2**32 + data[1] + 1) - fun(2**32 + data[0]))
elif data[0] < 0 and data[1] > 0:
print(fun(data[1] + 1) + fun(2**32 - 1 + 1) - fun(2**32 + data[0]))
|
FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR NUMBER VAR IF VAR VAR STRING ASSIGN VAR BIN_OP BIN_OP VAR BIN_OP VAR BIN_OP NUMBER BIN_OP BIN_OP VAR NUMBER VAR BIN_OP BIN_OP BIN_OP VAR NUMBER VAR BIN_OP NUMBER BIN_OP BIN_OP VAR NUMBER VAR ASSIGN VAR BIN_OP VAR NUMBER RETURN FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR NUMBER VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR IF VAR NUMBER VAR NUMBER IF VAR NUMBER NUMBER EXPR FUNC_CALL VAR BIN_OP FUNC_CALL VAR BIN_OP BIN_OP BIN_OP NUMBER NUMBER VAR NUMBER NUMBER FUNC_CALL VAR BIN_OP BIN_OP NUMBER NUMBER VAR NUMBER EXPR FUNC_CALL VAR BIN_OP FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER FUNC_CALL VAR VAR NUMBER IF VAR NUMBER NUMBER VAR NUMBER NUMBER EXPR FUNC_CALL VAR FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER IF VAR NUMBER NUMBER VAR NUMBER NUMBER EXPR FUNC_CALL VAR BIN_OP FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER FUNC_CALL VAR VAR NUMBER IF VAR NUMBER NUMBER VAR NUMBER NUMBER EXPR FUNC_CALL VAR BIN_OP FUNC_CALL VAR BIN_OP BIN_OP BIN_OP NUMBER NUMBER NUMBER NUMBER FUNC_CALL VAR BIN_OP BIN_OP NUMBER NUMBER VAR NUMBER IF VAR NUMBER NUMBER VAR NUMBER NUMBER EXPR FUNC_CALL VAR BIN_OP FUNC_CALL VAR BIN_OP BIN_OP BIN_OP NUMBER NUMBER VAR NUMBER NUMBER FUNC_CALL VAR BIN_OP BIN_OP NUMBER NUMBER VAR NUMBER IF VAR NUMBER NUMBER VAR NUMBER NUMBER EXPR FUNC_CALL VAR BIN_OP BIN_OP FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER FUNC_CALL VAR BIN_OP BIN_OP BIN_OP NUMBER NUMBER NUMBER NUMBER FUNC_CALL VAR BIN_OP BIN_OP NUMBER NUMBER VAR NUMBER
|
Understanding $2$'s complement representation is fundamental to learning about Computer Science. It allows us to write negative numbers in binary. The leftmost digit is used as a sign bit. If it is $1$, we have a negative number and it is represented as the two's complement of its absolute value. Let's say you wrote down the $2$'s complement representation for each $32$-bit integer in the inclusive range from $\boldsymbol{a}$ to $\boldsymbol{b}$. How many $1$'s would you write down in all?
For example, using an $8$-bit byte rather than $32$ bit integer, the two's complement of a number can be found by reversing all its bits and adding $1$. The two's complement representations for a few numbers are shown below:
|Number| Representation in
Number Binary Inverse Two's Complement
-3 00000011 11111100 11111101
-2 00000010 11111101 11111110
-1 00000001 11111110 11111111
0 00000000 00000000
1 00000001 00000001
2 00000010 00000010
3 00000011 00000011
To write down that range of numbers' two's complements in $8$ bits, we wrote $\textbf{26}\:1$'s. Remember to use $32$ bits rather than $8$ in your solution. The logic is the same, so the $8$ bit representation was chosen to reduce apparent complexity in the example.
Function Description
Complete the twosCompliment function in the editor below. It should return an integer.
twosCompliment has the following parameter(s):
- a: an integer, the range minimum
- b: an integer, the range maximum
Input Format
The first line contains an integer $\mathbf{T}$, the number of test cases.
Each of the next $\mathbf{T}$ lines contains two space-separated integers, $\boldsymbol{a}$ and $\boldsymbol{b}$.
Constraints
$T\leq1000$
$-2^{31}\leq a\leq b\leq2^{31}-1$
Output Format
For each test case, print the number of $\mbox{I}$'s in the $32$-bit $2$'s complement representation for integers in the inclusive range from $\boldsymbol{a}$ to $\boldsymbol{b}$ on a new line.
Sample Input 0
3
-2 0
-3 4
-1 4
Sample Output 0
63
99
37
Explanation 0
Test case 0
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
31+32+0 = 63
Test case 1
-3 has 31 ones
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
31+31+32+0+1+1+2+1 = 99
Test case 2
-1 has 32 ones
0 has 0 ones
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
32+0+1+1+2+1 = 37
Sample Input 1
4
-5 0
1 7
-6 -3
3 6
Sample Output 1
155
12
122
7
Explanation 1
Test case 0
-5 has 31 ones
-4 has 30 ones
-3 has 31 ones
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
31+30+31+31+32+0 = 155
Test case 1
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
5 has 2 ones
6 has 2 ones
7 has 3 ones
1+1+2+1+2+2+3 = 12
Test case 2
-6 has 30 ones
-5 has 31 ones
-4 has 30 ones
-3 has 31 ones
30+31+30+31 = 122
Test case 3
3 has 2 ones
4 has 1 ones
5 has 2 ones
6 has 2 ones
2+1+2+2 = 7
|
MAXBITS = 32
def count(n):
if n >= 0:
return poscount(n)
else:
n += 1
return poscount(-1 - n) + n * MAXBITS if n != 0 else 0
def poscount(n):
if n == 0:
return 0
else:
nbits = n.bit_length() - 1
msb = 1 << nbits
rem = n - msb
return msb * nbits // 2 + rem + poscount(rem) + 1
ncases = int(input())
for case in range(ncases):
a, b = [int(fld) for fld in input().split()]
print(count(b) - count(a - 1))
|
ASSIGN VAR NUMBER FUNC_DEF IF VAR NUMBER RETURN FUNC_CALL VAR VAR VAR NUMBER RETURN VAR NUMBER BIN_OP FUNC_CALL VAR BIN_OP NUMBER VAR BIN_OP VAR VAR NUMBER FUNC_DEF IF VAR NUMBER RETURN NUMBER ASSIGN VAR BIN_OP FUNC_CALL VAR NUMBER ASSIGN VAR BIN_OP NUMBER VAR ASSIGN VAR BIN_OP VAR VAR RETURN BIN_OP BIN_OP BIN_OP BIN_OP BIN_OP VAR VAR NUMBER VAR FUNC_CALL VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR EXPR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR FUNC_CALL VAR BIN_OP VAR NUMBER
|
Understanding $2$'s complement representation is fundamental to learning about Computer Science. It allows us to write negative numbers in binary. The leftmost digit is used as a sign bit. If it is $1$, we have a negative number and it is represented as the two's complement of its absolute value. Let's say you wrote down the $2$'s complement representation for each $32$-bit integer in the inclusive range from $\boldsymbol{a}$ to $\boldsymbol{b}$. How many $1$'s would you write down in all?
For example, using an $8$-bit byte rather than $32$ bit integer, the two's complement of a number can be found by reversing all its bits and adding $1$. The two's complement representations for a few numbers are shown below:
|Number| Representation in
Number Binary Inverse Two's Complement
-3 00000011 11111100 11111101
-2 00000010 11111101 11111110
-1 00000001 11111110 11111111
0 00000000 00000000
1 00000001 00000001
2 00000010 00000010
3 00000011 00000011
To write down that range of numbers' two's complements in $8$ bits, we wrote $\textbf{26}\:1$'s. Remember to use $32$ bits rather than $8$ in your solution. The logic is the same, so the $8$ bit representation was chosen to reduce apparent complexity in the example.
Function Description
Complete the twosCompliment function in the editor below. It should return an integer.
twosCompliment has the following parameter(s):
- a: an integer, the range minimum
- b: an integer, the range maximum
Input Format
The first line contains an integer $\mathbf{T}$, the number of test cases.
Each of the next $\mathbf{T}$ lines contains two space-separated integers, $\boldsymbol{a}$ and $\boldsymbol{b}$.
Constraints
$T\leq1000$
$-2^{31}\leq a\leq b\leq2^{31}-1$
Output Format
For each test case, print the number of $\mbox{I}$'s in the $32$-bit $2$'s complement representation for integers in the inclusive range from $\boldsymbol{a}$ to $\boldsymbol{b}$ on a new line.
Sample Input 0
3
-2 0
-3 4
-1 4
Sample Output 0
63
99
37
Explanation 0
Test case 0
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
31+32+0 = 63
Test case 1
-3 has 31 ones
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
31+31+32+0+1+1+2+1 = 99
Test case 2
-1 has 32 ones
0 has 0 ones
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
32+0+1+1+2+1 = 37
Sample Input 1
4
-5 0
1 7
-6 -3
3 6
Sample Output 1
155
12
122
7
Explanation 1
Test case 0
-5 has 31 ones
-4 has 30 ones
-3 has 31 ones
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
31+30+31+31+32+0 = 155
Test case 1
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
5 has 2 ones
6 has 2 ones
7 has 3 ones
1+1+2+1+2+2+3 = 12
Test case 2
-6 has 30 ones
-5 has 31 ones
-4 has 30 ones
-3 has 31 ones
30+31+30+31 = 122
Test case 3
3 has 2 ones
4 has 1 ones
5 has 2 ones
6 has 2 ones
2+1+2+2 = 7
|
def CountBits(val):
return "{:b}".format(val).count("1")
def SumToBit(bit):
if bit < 0:
return 0
return bit + 1 << bit
def SumUpA(val, bits):
totalSum = 0
newBit = -1
while val != (2 << bits) - 1:
orig = val
while orig == val:
newBit += 1
val |= 1 << newBit
totalSum += (
SumToBit(newBit)
- SumToBit(newBit - 1)
+ CountBits((val & ~((2 << newBit) - 1)) >> newBit) * (val - orig)
)
return totalSum
def SumUp(val):
return CountBits(val) + SumUpA(val, val.bit_length() - 1)
def NewSum(a, b):
if a < 0:
a = twos_comp(a)
base = SumUp(a)
baseBits = 0
elif a == 0:
base = 0
baseBits = 0
else:
base = SumUp(a)
baseBits = a.bit_length()
if b < 0:
b = twos_comp(b)
cap = SumUp(b)
targetBits = 0
elif b == 0:
cap = 0
targetBits = 0
else:
cap = SumUp(b)
targetBits = b.bit_length()
baseToCap = SumToBit(targetBits - 1) - SumToBit(baseBits - 1)
return base + baseToCap - cap + CountBits(b)
def twos_comp(val):
return 4294967296 + val
tests = int(input())
for t in range(tests):
a, b = input().split()
a, b = int(a), int(b)
print(NewSum(a, b))
|
FUNC_DEF RETURN FUNC_CALL FUNC_CALL STRING VAR STRING FUNC_DEF IF VAR NUMBER RETURN NUMBER RETURN BIN_OP BIN_OP VAR NUMBER VAR FUNC_DEF ASSIGN VAR NUMBER ASSIGN VAR NUMBER WHILE VAR BIN_OP BIN_OP NUMBER VAR NUMBER ASSIGN VAR VAR WHILE VAR VAR VAR NUMBER VAR BIN_OP NUMBER VAR VAR BIN_OP BIN_OP FUNC_CALL VAR VAR FUNC_CALL VAR BIN_OP VAR NUMBER BIN_OP FUNC_CALL VAR BIN_OP BIN_OP VAR BIN_OP BIN_OP NUMBER VAR NUMBER VAR BIN_OP VAR VAR RETURN VAR FUNC_DEF RETURN BIN_OP FUNC_CALL VAR VAR FUNC_CALL VAR VAR BIN_OP FUNC_CALL VAR NUMBER FUNC_DEF IF VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER IF VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR IF VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER IF VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR ASSIGN VAR BIN_OP FUNC_CALL VAR BIN_OP VAR NUMBER FUNC_CALL VAR BIN_OP VAR NUMBER RETURN BIN_OP BIN_OP BIN_OP VAR VAR VAR FUNC_CALL VAR VAR FUNC_DEF RETURN BIN_OP NUMBER VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR VAR VAR
|
Understanding $2$'s complement representation is fundamental to learning about Computer Science. It allows us to write negative numbers in binary. The leftmost digit is used as a sign bit. If it is $1$, we have a negative number and it is represented as the two's complement of its absolute value. Let's say you wrote down the $2$'s complement representation for each $32$-bit integer in the inclusive range from $\boldsymbol{a}$ to $\boldsymbol{b}$. How many $1$'s would you write down in all?
For example, using an $8$-bit byte rather than $32$ bit integer, the two's complement of a number can be found by reversing all its bits and adding $1$. The two's complement representations for a few numbers are shown below:
|Number| Representation in
Number Binary Inverse Two's Complement
-3 00000011 11111100 11111101
-2 00000010 11111101 11111110
-1 00000001 11111110 11111111
0 00000000 00000000
1 00000001 00000001
2 00000010 00000010
3 00000011 00000011
To write down that range of numbers' two's complements in $8$ bits, we wrote $\textbf{26}\:1$'s. Remember to use $32$ bits rather than $8$ in your solution. The logic is the same, so the $8$ bit representation was chosen to reduce apparent complexity in the example.
Function Description
Complete the twosCompliment function in the editor below. It should return an integer.
twosCompliment has the following parameter(s):
- a: an integer, the range minimum
- b: an integer, the range maximum
Input Format
The first line contains an integer $\mathbf{T}$, the number of test cases.
Each of the next $\mathbf{T}$ lines contains two space-separated integers, $\boldsymbol{a}$ and $\boldsymbol{b}$.
Constraints
$T\leq1000$
$-2^{31}\leq a\leq b\leq2^{31}-1$
Output Format
For each test case, print the number of $\mbox{I}$'s in the $32$-bit $2$'s complement representation for integers in the inclusive range from $\boldsymbol{a}$ to $\boldsymbol{b}$ on a new line.
Sample Input 0
3
-2 0
-3 4
-1 4
Sample Output 0
63
99
37
Explanation 0
Test case 0
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
31+32+0 = 63
Test case 1
-3 has 31 ones
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
31+31+32+0+1+1+2+1 = 99
Test case 2
-1 has 32 ones
0 has 0 ones
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
32+0+1+1+2+1 = 37
Sample Input 1
4
-5 0
1 7
-6 -3
3 6
Sample Output 1
155
12
122
7
Explanation 1
Test case 0
-5 has 31 ones
-4 has 30 ones
-3 has 31 ones
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
31+30+31+31+32+0 = 155
Test case 1
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
5 has 2 ones
6 has 2 ones
7 has 3 ones
1+1+2+1+2+2+3 = 12
Test case 2
-6 has 30 ones
-5 has 31 ones
-4 has 30 ones
-3 has 31 ones
30+31+30+31 = 122
Test case 3
3 has 2 ones
4 has 1 ones
5 has 2 ones
6 has 2 ones
2+1+2+2 = 7
|
def popcount(N):
n = abs(N)
p = 0
b = 0
while n > 1 << b:
b += 1
while b > 0:
m = 1 << b
if n & m:
n ^= m
p += b * (m >> 1) + n
b -= 1
if N < 0:
return 32 * N + p
else:
return p
T = int(input())
for t in range(T):
A, B = map(int, input().split())
print(popcount(B + 1) - popcount(A))
|
FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER WHILE VAR BIN_OP NUMBER VAR VAR NUMBER WHILE VAR NUMBER ASSIGN VAR BIN_OP NUMBER VAR IF BIN_OP VAR VAR VAR VAR VAR BIN_OP BIN_OP VAR BIN_OP VAR NUMBER VAR VAR NUMBER IF VAR NUMBER RETURN BIN_OP BIN_OP NUMBER VAR VAR RETURN VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR EXPR FUNC_CALL VAR BIN_OP FUNC_CALL VAR BIN_OP VAR NUMBER FUNC_CALL VAR VAR
|
Understanding $2$'s complement representation is fundamental to learning about Computer Science. It allows us to write negative numbers in binary. The leftmost digit is used as a sign bit. If it is $1$, we have a negative number and it is represented as the two's complement of its absolute value. Let's say you wrote down the $2$'s complement representation for each $32$-bit integer in the inclusive range from $\boldsymbol{a}$ to $\boldsymbol{b}$. How many $1$'s would you write down in all?
For example, using an $8$-bit byte rather than $32$ bit integer, the two's complement of a number can be found by reversing all its bits and adding $1$. The two's complement representations for a few numbers are shown below:
|Number| Representation in
Number Binary Inverse Two's Complement
-3 00000011 11111100 11111101
-2 00000010 11111101 11111110
-1 00000001 11111110 11111111
0 00000000 00000000
1 00000001 00000001
2 00000010 00000010
3 00000011 00000011
To write down that range of numbers' two's complements in $8$ bits, we wrote $\textbf{26}\:1$'s. Remember to use $32$ bits rather than $8$ in your solution. The logic is the same, so the $8$ bit representation was chosen to reduce apparent complexity in the example.
Function Description
Complete the twosCompliment function in the editor below. It should return an integer.
twosCompliment has the following parameter(s):
- a: an integer, the range minimum
- b: an integer, the range maximum
Input Format
The first line contains an integer $\mathbf{T}$, the number of test cases.
Each of the next $\mathbf{T}$ lines contains two space-separated integers, $\boldsymbol{a}$ and $\boldsymbol{b}$.
Constraints
$T\leq1000$
$-2^{31}\leq a\leq b\leq2^{31}-1$
Output Format
For each test case, print the number of $\mbox{I}$'s in the $32$-bit $2$'s complement representation for integers in the inclusive range from $\boldsymbol{a}$ to $\boldsymbol{b}$ on a new line.
Sample Input 0
3
-2 0
-3 4
-1 4
Sample Output 0
63
99
37
Explanation 0
Test case 0
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
31+32+0 = 63
Test case 1
-3 has 31 ones
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
31+31+32+0+1+1+2+1 = 99
Test case 2
-1 has 32 ones
0 has 0 ones
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
32+0+1+1+2+1 = 37
Sample Input 1
4
-5 0
1 7
-6 -3
3 6
Sample Output 1
155
12
122
7
Explanation 1
Test case 0
-5 has 31 ones
-4 has 30 ones
-3 has 31 ones
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
31+30+31+31+32+0 = 155
Test case 1
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
5 has 2 ones
6 has 2 ones
7 has 3 ones
1+1+2+1+2+2+3 = 12
Test case 2
-6 has 30 ones
-5 has 31 ones
-4 has 30 ones
-3 has 31 ones
30+31+30+31 = 122
Test case 3
3 has 2 ones
4 has 1 ones
5 has 2 ones
6 has 2 ones
2+1+2+2 = 7
|
t = int(input())
def gen(num):
if num == "":
return 0
elif num == "1":
return 1
elif num == "0":
return 0
elif num[0] == "0":
return gen(num[1:])
else:
return int(num[1:], 2) + 1 + gen(num[1:]) + 2 ** (len(num) - 2) * (len(num) - 1)
def func(a, b):
if a < 0 and b >= 0:
if a + b + 1 == 0:
return 32 * (b + 1)
elif a + b + 1 < 0:
return 32 * (b + 1) + func(a, -(b + 2))
else:
return 32 * -a + func(-a, b)
elif a < 0 and b < 0:
return 32 * (b - a + 1) - func(-b - 1, -a - 1)
else:
if a == 0:
return gen(bin(b)[2:])
return gen(bin(b)[2:]) - gen(bin(a - 1)[2:])
for ts in range(t):
a, b = input().strip().split()
a, b = int(a), int(b)
print(func(a, b))
|
ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_DEF IF VAR STRING RETURN NUMBER IF VAR STRING RETURN NUMBER IF VAR STRING RETURN NUMBER IF VAR NUMBER STRING RETURN FUNC_CALL VAR VAR NUMBER RETURN BIN_OP BIN_OP BIN_OP FUNC_CALL VAR VAR NUMBER NUMBER NUMBER FUNC_CALL VAR VAR NUMBER BIN_OP BIN_OP NUMBER BIN_OP FUNC_CALL VAR VAR NUMBER BIN_OP FUNC_CALL VAR VAR NUMBER FUNC_DEF IF VAR NUMBER VAR NUMBER IF BIN_OP BIN_OP VAR VAR NUMBER NUMBER RETURN BIN_OP NUMBER BIN_OP VAR NUMBER IF BIN_OP BIN_OP VAR VAR NUMBER NUMBER RETURN BIN_OP BIN_OP NUMBER BIN_OP VAR NUMBER FUNC_CALL VAR VAR BIN_OP VAR NUMBER RETURN BIN_OP BIN_OP NUMBER VAR FUNC_CALL VAR VAR VAR IF VAR NUMBER VAR NUMBER RETURN BIN_OP BIN_OP NUMBER BIN_OP BIN_OP VAR VAR NUMBER FUNC_CALL VAR BIN_OP VAR NUMBER BIN_OP VAR NUMBER IF VAR NUMBER RETURN FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER RETURN BIN_OP FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER FUNC_CALL VAR FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL FUNC_CALL FUNC_CALL VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR VAR VAR
|
Understanding $2$'s complement representation is fundamental to learning about Computer Science. It allows us to write negative numbers in binary. The leftmost digit is used as a sign bit. If it is $1$, we have a negative number and it is represented as the two's complement of its absolute value. Let's say you wrote down the $2$'s complement representation for each $32$-bit integer in the inclusive range from $\boldsymbol{a}$ to $\boldsymbol{b}$. How many $1$'s would you write down in all?
For example, using an $8$-bit byte rather than $32$ bit integer, the two's complement of a number can be found by reversing all its bits and adding $1$. The two's complement representations for a few numbers are shown below:
|Number| Representation in
Number Binary Inverse Two's Complement
-3 00000011 11111100 11111101
-2 00000010 11111101 11111110
-1 00000001 11111110 11111111
0 00000000 00000000
1 00000001 00000001
2 00000010 00000010
3 00000011 00000011
To write down that range of numbers' two's complements in $8$ bits, we wrote $\textbf{26}\:1$'s. Remember to use $32$ bits rather than $8$ in your solution. The logic is the same, so the $8$ bit representation was chosen to reduce apparent complexity in the example.
Function Description
Complete the twosCompliment function in the editor below. It should return an integer.
twosCompliment has the following parameter(s):
- a: an integer, the range minimum
- b: an integer, the range maximum
Input Format
The first line contains an integer $\mathbf{T}$, the number of test cases.
Each of the next $\mathbf{T}$ lines contains two space-separated integers, $\boldsymbol{a}$ and $\boldsymbol{b}$.
Constraints
$T\leq1000$
$-2^{31}\leq a\leq b\leq2^{31}-1$
Output Format
For each test case, print the number of $\mbox{I}$'s in the $32$-bit $2$'s complement representation for integers in the inclusive range from $\boldsymbol{a}$ to $\boldsymbol{b}$ on a new line.
Sample Input 0
3
-2 0
-3 4
-1 4
Sample Output 0
63
99
37
Explanation 0
Test case 0
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
31+32+0 = 63
Test case 1
-3 has 31 ones
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
31+31+32+0+1+1+2+1 = 99
Test case 2
-1 has 32 ones
0 has 0 ones
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
32+0+1+1+2+1 = 37
Sample Input 1
4
-5 0
1 7
-6 -3
3 6
Sample Output 1
155
12
122
7
Explanation 1
Test case 0
-5 has 31 ones
-4 has 30 ones
-3 has 31 ones
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
31+30+31+31+32+0 = 155
Test case 1
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
5 has 2 ones
6 has 2 ones
7 has 3 ones
1+1+2+1+2+2+3 = 12
Test case 2
-6 has 30 ones
-5 has 31 ones
-4 has 30 ones
-3 has 31 ones
30+31+30+31 = 122
Test case 3
3 has 2 ones
4 has 1 ones
5 has 2 ones
6 has 2 ones
2+1+2+2 = 7
|
def to_bin(x):
if x < 0:
x += 1 << 32
return bin(x)[2:]
def naive(a, b):
a, b = min(a, b), max(a, b)
s = 0
for i in range(a, b + 1):
s += to_bin(i).count("1")
return s
def sum_1_by_pos(x, i):
b = 2**i
if x % (2 * b) >= b:
return x // (2 * b) * b + x % b + 1
else:
return x // (2 * b) * b
def to_positive(x):
l = len(bin(x)) - 2
per_pos = [sum_1_by_pos(x, i) for i in range(l)]
return sum(per_pos)
def to_negative(x):
x = abs(x)
return 32 * x - to_positive(x - 1)
def smart(a, b):
a, b = min(a, b), max(a, b)
if a >= 0 and b >= 0:
sa = to_positive(a - 1)
sb = to_positive(b)
return sb - sa
if a < 0 and b >= 0:
sa = to_negative(a)
sb = to_positive(b)
return sa + sb
if a < 0 and b < 0:
sb = to_negative(b + 1)
sa = to_negative(a)
return sa - sb
def main():
t = int(input())
for _ in range(t):
a, b = map(int, input().split(" "))
print(smart(a, b))
main()
|
FUNC_DEF IF VAR NUMBER VAR BIN_OP NUMBER NUMBER RETURN FUNC_CALL VAR VAR NUMBER FUNC_DEF ASSIGN VAR VAR FUNC_CALL VAR VAR VAR FUNC_CALL VAR VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER VAR FUNC_CALL FUNC_CALL VAR VAR STRING RETURN VAR FUNC_DEF ASSIGN VAR BIN_OP NUMBER VAR IF BIN_OP VAR BIN_OP NUMBER VAR VAR RETURN BIN_OP BIN_OP BIN_OP BIN_OP VAR BIN_OP NUMBER VAR VAR BIN_OP VAR VAR NUMBER RETURN BIN_OP BIN_OP VAR BIN_OP NUMBER VAR VAR FUNC_DEF ASSIGN VAR BIN_OP FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR VAR FUNC_CALL VAR VAR RETURN FUNC_CALL VAR VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR RETURN BIN_OP BIN_OP NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER FUNC_DEF ASSIGN VAR VAR FUNC_CALL VAR VAR VAR FUNC_CALL VAR VAR VAR IF VAR NUMBER VAR NUMBER ASSIGN VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR RETURN BIN_OP VAR VAR IF VAR NUMBER VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR RETURN BIN_OP VAR VAR IF VAR NUMBER VAR NUMBER ASSIGN VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR RETURN BIN_OP VAR VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR STRING EXPR FUNC_CALL VAR FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR
|
Understanding $2$'s complement representation is fundamental to learning about Computer Science. It allows us to write negative numbers in binary. The leftmost digit is used as a sign bit. If it is $1$, we have a negative number and it is represented as the two's complement of its absolute value. Let's say you wrote down the $2$'s complement representation for each $32$-bit integer in the inclusive range from $\boldsymbol{a}$ to $\boldsymbol{b}$. How many $1$'s would you write down in all?
For example, using an $8$-bit byte rather than $32$ bit integer, the two's complement of a number can be found by reversing all its bits and adding $1$. The two's complement representations for a few numbers are shown below:
|Number| Representation in
Number Binary Inverse Two's Complement
-3 00000011 11111100 11111101
-2 00000010 11111101 11111110
-1 00000001 11111110 11111111
0 00000000 00000000
1 00000001 00000001
2 00000010 00000010
3 00000011 00000011
To write down that range of numbers' two's complements in $8$ bits, we wrote $\textbf{26}\:1$'s. Remember to use $32$ bits rather than $8$ in your solution. The logic is the same, so the $8$ bit representation was chosen to reduce apparent complexity in the example.
Function Description
Complete the twosCompliment function in the editor below. It should return an integer.
twosCompliment has the following parameter(s):
- a: an integer, the range minimum
- b: an integer, the range maximum
Input Format
The first line contains an integer $\mathbf{T}$, the number of test cases.
Each of the next $\mathbf{T}$ lines contains two space-separated integers, $\boldsymbol{a}$ and $\boldsymbol{b}$.
Constraints
$T\leq1000$
$-2^{31}\leq a\leq b\leq2^{31}-1$
Output Format
For each test case, print the number of $\mbox{I}$'s in the $32$-bit $2$'s complement representation for integers in the inclusive range from $\boldsymbol{a}$ to $\boldsymbol{b}$ on a new line.
Sample Input 0
3
-2 0
-3 4
-1 4
Sample Output 0
63
99
37
Explanation 0
Test case 0
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
31+32+0 = 63
Test case 1
-3 has 31 ones
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
31+31+32+0+1+1+2+1 = 99
Test case 2
-1 has 32 ones
0 has 0 ones
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
32+0+1+1+2+1 = 37
Sample Input 1
4
-5 0
1 7
-6 -3
3 6
Sample Output 1
155
12
122
7
Explanation 1
Test case 0
-5 has 31 ones
-4 has 30 ones
-3 has 31 ones
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
31+30+31+31+32+0 = 155
Test case 1
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
5 has 2 ones
6 has 2 ones
7 has 3 ones
1+1+2+1+2+2+3 = 12
Test case 2
-6 has 30 ones
-5 has 31 ones
-4 has 30 ones
-3 has 31 ones
30+31+30+31 = 122
Test case 3
3 has 2 ones
4 has 1 ones
5 has 2 ones
6 has 2 ones
2+1+2+2 = 7
|
def sum1(x):
b = 0
for i in range(len(bin(x)[2:])):
b += (x + 1) // 2 ** (i + 1) * 2**i + (x + 1) % 2 ** (i + 1) // (
2**i + 1
) * ((x + 1) % 2 ** (i + 1)) % 2**i
return b
T = int(input())
for _ in range(T):
a, b = map(int, input().split(" "))
if a >= 0 and b >= 0:
N2 = sum1(b)
N1 = sum1(a - 1)
rez = N2 - N1
if a <= 0 and b >= 0:
N2 = sum1(b)
N1 = sum1(2**32 - 1) - sum1(2**32 + a - 1)
rez = N1 + N2
if a <= 0 and b < 0:
N1 = sum1(2**32 - 1) - sum1(2**32 + a - 1)
N2 = sum1(2**32 - 1) - sum1(2**32 + b)
rez = N1 - N2
print(rez)
|
FUNC_DEF ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER VAR BIN_OP BIN_OP BIN_OP BIN_OP VAR NUMBER BIN_OP NUMBER BIN_OP VAR NUMBER BIN_OP NUMBER VAR BIN_OP BIN_OP BIN_OP BIN_OP BIN_OP VAR NUMBER BIN_OP NUMBER BIN_OP VAR NUMBER BIN_OP BIN_OP NUMBER VAR NUMBER BIN_OP BIN_OP VAR NUMBER BIN_OP NUMBER BIN_OP VAR NUMBER BIN_OP NUMBER VAR RETURN VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR STRING IF VAR NUMBER VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR BIN_OP VAR VAR IF VAR NUMBER VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP FUNC_CALL VAR BIN_OP BIN_OP NUMBER NUMBER NUMBER FUNC_CALL VAR BIN_OP BIN_OP BIN_OP NUMBER NUMBER VAR NUMBER ASSIGN VAR BIN_OP VAR VAR IF VAR NUMBER VAR NUMBER ASSIGN VAR BIN_OP FUNC_CALL VAR BIN_OP BIN_OP NUMBER NUMBER NUMBER FUNC_CALL VAR BIN_OP BIN_OP BIN_OP NUMBER NUMBER VAR NUMBER ASSIGN VAR BIN_OP FUNC_CALL VAR BIN_OP BIN_OP NUMBER NUMBER NUMBER FUNC_CALL VAR BIN_OP BIN_OP NUMBER NUMBER VAR ASSIGN VAR BIN_OP VAR VAR EXPR FUNC_CALL VAR VAR
|
Understanding $2$'s complement representation is fundamental to learning about Computer Science. It allows us to write negative numbers in binary. The leftmost digit is used as a sign bit. If it is $1$, we have a negative number and it is represented as the two's complement of its absolute value. Let's say you wrote down the $2$'s complement representation for each $32$-bit integer in the inclusive range from $\boldsymbol{a}$ to $\boldsymbol{b}$. How many $1$'s would you write down in all?
For example, using an $8$-bit byte rather than $32$ bit integer, the two's complement of a number can be found by reversing all its bits and adding $1$. The two's complement representations for a few numbers are shown below:
|Number| Representation in
Number Binary Inverse Two's Complement
-3 00000011 11111100 11111101
-2 00000010 11111101 11111110
-1 00000001 11111110 11111111
0 00000000 00000000
1 00000001 00000001
2 00000010 00000010
3 00000011 00000011
To write down that range of numbers' two's complements in $8$ bits, we wrote $\textbf{26}\:1$'s. Remember to use $32$ bits rather than $8$ in your solution. The logic is the same, so the $8$ bit representation was chosen to reduce apparent complexity in the example.
Function Description
Complete the twosCompliment function in the editor below. It should return an integer.
twosCompliment has the following parameter(s):
- a: an integer, the range minimum
- b: an integer, the range maximum
Input Format
The first line contains an integer $\mathbf{T}$, the number of test cases.
Each of the next $\mathbf{T}$ lines contains two space-separated integers, $\boldsymbol{a}$ and $\boldsymbol{b}$.
Constraints
$T\leq1000$
$-2^{31}\leq a\leq b\leq2^{31}-1$
Output Format
For each test case, print the number of $\mbox{I}$'s in the $32$-bit $2$'s complement representation for integers in the inclusive range from $\boldsymbol{a}$ to $\boldsymbol{b}$ on a new line.
Sample Input 0
3
-2 0
-3 4
-1 4
Sample Output 0
63
99
37
Explanation 0
Test case 0
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
31+32+0 = 63
Test case 1
-3 has 31 ones
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
31+31+32+0+1+1+2+1 = 99
Test case 2
-1 has 32 ones
0 has 0 ones
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
32+0+1+1+2+1 = 37
Sample Input 1
4
-5 0
1 7
-6 -3
3 6
Sample Output 1
155
12
122
7
Explanation 1
Test case 0
-5 has 31 ones
-4 has 30 ones
-3 has 31 ones
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
31+30+31+31+32+0 = 155
Test case 1
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
5 has 2 ones
6 has 2 ones
7 has 3 ones
1+1+2+1+2+2+3 = 12
Test case 2
-6 has 30 ones
-5 has 31 ones
-4 has 30 ones
-3 has 31 ones
30+31+30+31 = 122
Test case 3
3 has 2 ones
4 has 1 ones
5 has 2 ones
6 has 2 ones
2+1+2+2 = 7
|
def lgst2Pwr(inNum):
j = 0
k = 0
while j < inNum:
j = 2**k
k += 1
return k - 1
def getSum(temp_Int):
sum_Int = 0
i = 0
currExp = 0
exp = lgst2Pwr(temp_Int)
while temp_Int > 0:
if exp != -1:
sum_Int += (-1) ** i * (2 ** (exp - 1) * exp + 1 + currExp * (2**exp - 1))
temp_Int = abs(temp_Int - 2**exp)
if i % 2 == 0:
if temp_Int == 0:
sum_Int += currExp
currExp = currExp + exp
exp = lgst2Pwr(temp_Int)
currExp = currExp - exp
else:
exp = lgst2Pwr(temp_Int)
i += 1
return int(sum_Int)
def cntAllOnes(stInt, edInt):
stInt_abs = abs(stInt)
edInt_abs = abs(edInt)
if stInt >= 0:
return getSum(edInt) - getSum(max(stInt - 1, 0))
elif edInt <= 0:
return (
32 * stInt_abs
- getSum(max(0, stInt_abs - 1))
- (32 * max(0, edInt_abs - 1) - getSum(max(0, edInt_abs - 2)))
)
else:
return 32 * stInt_abs - getSum(stInt_abs - 1) + getSum(edInt_abs)
n = int(input().strip())
inpArr = [map(int, input().strip().split(" ")) for i in range(n)]
solArr = [cntAllOnes(st, ed) for st, ed in inpArr]
for y in solArr:
print(y)
|
FUNC_DEF ASSIGN VAR NUMBER ASSIGN VAR NUMBER WHILE VAR VAR ASSIGN VAR BIN_OP NUMBER VAR VAR NUMBER RETURN BIN_OP VAR NUMBER FUNC_DEF ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR WHILE VAR NUMBER IF VAR NUMBER VAR BIN_OP BIN_OP NUMBER VAR BIN_OP BIN_OP BIN_OP BIN_OP NUMBER BIN_OP VAR NUMBER VAR NUMBER BIN_OP VAR BIN_OP BIN_OP NUMBER VAR NUMBER ASSIGN VAR FUNC_CALL VAR BIN_OP VAR BIN_OP NUMBER VAR IF BIN_OP VAR NUMBER NUMBER IF VAR NUMBER VAR VAR ASSIGN VAR BIN_OP VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR NUMBER RETURN FUNC_CALL VAR VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR IF VAR NUMBER RETURN BIN_OP FUNC_CALL VAR VAR FUNC_CALL VAR FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER IF VAR NUMBER RETURN BIN_OP BIN_OP BIN_OP NUMBER VAR FUNC_CALL VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER BIN_OP BIN_OP NUMBER FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER FUNC_CALL VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER RETURN BIN_OP BIN_OP BIN_OP NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL FUNC_CALL VAR STRING VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR VAR VAR FOR VAR VAR EXPR FUNC_CALL VAR VAR
|
Understanding $2$'s complement representation is fundamental to learning about Computer Science. It allows us to write negative numbers in binary. The leftmost digit is used as a sign bit. If it is $1$, we have a negative number and it is represented as the two's complement of its absolute value. Let's say you wrote down the $2$'s complement representation for each $32$-bit integer in the inclusive range from $\boldsymbol{a}$ to $\boldsymbol{b}$. How many $1$'s would you write down in all?
For example, using an $8$-bit byte rather than $32$ bit integer, the two's complement of a number can be found by reversing all its bits and adding $1$. The two's complement representations for a few numbers are shown below:
|Number| Representation in
Number Binary Inverse Two's Complement
-3 00000011 11111100 11111101
-2 00000010 11111101 11111110
-1 00000001 11111110 11111111
0 00000000 00000000
1 00000001 00000001
2 00000010 00000010
3 00000011 00000011
To write down that range of numbers' two's complements in $8$ bits, we wrote $\textbf{26}\:1$'s. Remember to use $32$ bits rather than $8$ in your solution. The logic is the same, so the $8$ bit representation was chosen to reduce apparent complexity in the example.
Function Description
Complete the twosCompliment function in the editor below. It should return an integer.
twosCompliment has the following parameter(s):
- a: an integer, the range minimum
- b: an integer, the range maximum
Input Format
The first line contains an integer $\mathbf{T}$, the number of test cases.
Each of the next $\mathbf{T}$ lines contains two space-separated integers, $\boldsymbol{a}$ and $\boldsymbol{b}$.
Constraints
$T\leq1000$
$-2^{31}\leq a\leq b\leq2^{31}-1$
Output Format
For each test case, print the number of $\mbox{I}$'s in the $32$-bit $2$'s complement representation for integers in the inclusive range from $\boldsymbol{a}$ to $\boldsymbol{b}$ on a new line.
Sample Input 0
3
-2 0
-3 4
-1 4
Sample Output 0
63
99
37
Explanation 0
Test case 0
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
31+32+0 = 63
Test case 1
-3 has 31 ones
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
31+31+32+0+1+1+2+1 = 99
Test case 2
-1 has 32 ones
0 has 0 ones
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
32+0+1+1+2+1 = 37
Sample Input 1
4
-5 0
1 7
-6 -3
3 6
Sample Output 1
155
12
122
7
Explanation 1
Test case 0
-5 has 31 ones
-4 has 30 ones
-3 has 31 ones
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
31+30+31+31+32+0 = 155
Test case 1
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
5 has 2 ones
6 has 2 ones
7 has 3 ones
1+1+2+1+2+2+3 = 12
Test case 2
-6 has 30 ones
-5 has 31 ones
-4 has 30 ones
-3 has 31 ones
30+31+30+31 = 122
Test case 3
3 has 2 ones
4 has 1 ones
5 has 2 ones
6 has 2 ones
2+1+2+2 = 7
|
def count(x):
x = x + 1
y = 0
for i in range(1, 33):
y += x // 2**i * 2 ** (i - 1) + max(0, x % 2**i - 2 ** (i - 1))
return y
def twosCompliment(a, b):
if a >= 0 and b >= 0:
return count(b) - count(a - 1)
elif a < 0 and b < 0:
z = 32 * (b - a + 1)
a = -1 - a
b = -1 - b
a, b = b, a
return z - (count(b) - count(a - 1))
elif a < 0 and b >= 0:
return count(b) + 32 * (0 - a) - count(a * -1 - 1)
n = int(input())
for i in range(n):
w = list(map(int, input().strip().split()))
print(twosCompliment(w[0], w[1]))
|
FUNC_DEF ASSIGN VAR BIN_OP VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER NUMBER VAR BIN_OP BIN_OP BIN_OP VAR BIN_OP NUMBER VAR BIN_OP NUMBER BIN_OP VAR NUMBER FUNC_CALL VAR NUMBER BIN_OP BIN_OP VAR BIN_OP NUMBER VAR BIN_OP NUMBER BIN_OP VAR NUMBER RETURN VAR FUNC_DEF IF VAR NUMBER VAR NUMBER RETURN BIN_OP FUNC_CALL VAR VAR FUNC_CALL VAR BIN_OP VAR NUMBER IF VAR NUMBER VAR NUMBER ASSIGN VAR BIN_OP NUMBER BIN_OP BIN_OP VAR VAR NUMBER ASSIGN VAR BIN_OP NUMBER VAR ASSIGN VAR BIN_OP NUMBER VAR ASSIGN VAR VAR VAR VAR RETURN BIN_OP VAR BIN_OP FUNC_CALL VAR VAR FUNC_CALL VAR BIN_OP VAR NUMBER IF VAR NUMBER VAR NUMBER RETURN BIN_OP BIN_OP FUNC_CALL VAR VAR BIN_OP NUMBER BIN_OP NUMBER VAR FUNC_CALL VAR BIN_OP BIN_OP VAR NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL FUNC_CALL VAR EXPR FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER VAR NUMBER
|
Understanding $2$'s complement representation is fundamental to learning about Computer Science. It allows us to write negative numbers in binary. The leftmost digit is used as a sign bit. If it is $1$, we have a negative number and it is represented as the two's complement of its absolute value. Let's say you wrote down the $2$'s complement representation for each $32$-bit integer in the inclusive range from $\boldsymbol{a}$ to $\boldsymbol{b}$. How many $1$'s would you write down in all?
For example, using an $8$-bit byte rather than $32$ bit integer, the two's complement of a number can be found by reversing all its bits and adding $1$. The two's complement representations for a few numbers are shown below:
|Number| Representation in
Number Binary Inverse Two's Complement
-3 00000011 11111100 11111101
-2 00000010 11111101 11111110
-1 00000001 11111110 11111111
0 00000000 00000000
1 00000001 00000001
2 00000010 00000010
3 00000011 00000011
To write down that range of numbers' two's complements in $8$ bits, we wrote $\textbf{26}\:1$'s. Remember to use $32$ bits rather than $8$ in your solution. The logic is the same, so the $8$ bit representation was chosen to reduce apparent complexity in the example.
Function Description
Complete the twosCompliment function in the editor below. It should return an integer.
twosCompliment has the following parameter(s):
- a: an integer, the range minimum
- b: an integer, the range maximum
Input Format
The first line contains an integer $\mathbf{T}$, the number of test cases.
Each of the next $\mathbf{T}$ lines contains two space-separated integers, $\boldsymbol{a}$ and $\boldsymbol{b}$.
Constraints
$T\leq1000$
$-2^{31}\leq a\leq b\leq2^{31}-1$
Output Format
For each test case, print the number of $\mbox{I}$'s in the $32$-bit $2$'s complement representation for integers in the inclusive range from $\boldsymbol{a}$ to $\boldsymbol{b}$ on a new line.
Sample Input 0
3
-2 0
-3 4
-1 4
Sample Output 0
63
99
37
Explanation 0
Test case 0
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
31+32+0 = 63
Test case 1
-3 has 31 ones
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
31+31+32+0+1+1+2+1 = 99
Test case 2
-1 has 32 ones
0 has 0 ones
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
32+0+1+1+2+1 = 37
Sample Input 1
4
-5 0
1 7
-6 -3
3 6
Sample Output 1
155
12
122
7
Explanation 1
Test case 0
-5 has 31 ones
-4 has 30 ones
-3 has 31 ones
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
31+30+31+31+32+0 = 155
Test case 1
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
5 has 2 ones
6 has 2 ones
7 has 3 ones
1+1+2+1+2+2+3 = 12
Test case 2
-6 has 30 ones
-5 has 31 ones
-4 has 30 ones
-3 has 31 ones
30+31+30+31 = 122
Test case 3
3 has 2 ones
4 has 1 ones
5 has 2 ones
6 has 2 ones
2+1+2+2 = 7
|
import sys
from time import time
def bits_set(n, v):
cnt = 0
while n:
cnt += 1
n = n & n - 1 & v
return cnt
def solve_bf(a, b):
v = (1 << 32) - 1
sm = 0
for i in range(a, b + 1):
c = bits_set(i, v)
sm += c
return sm
def f_gen():
f, d = 0, 1
while True:
yield f
f, d = 2 * f + d, 2 * d
def solve(a, b):
def calc_positive(n):
if n < 1:
return 0
ff, u = list(), 1
for f in f_gen():
if u > n:
break
ff.append(f)
u *= 2
total = 0
u //= 2
while n:
f = ff.pop()
if n >= u:
r = n % u
delta = f + r + 1
total += delta
n %= u
u //= 2
return total
def calc(n):
if n >= 0:
return calc_positive(n)
n = abs(n)
return n * 32 - calc_positive(n - 1)
if a == 0:
return calc(b)
elif b == 0:
return calc(a)
elif a >= 0:
fr, to = a - 1, b
u, v = calc(fr), calc(to)
return v - u
elif b < 0:
fr, to = a, b + 1
u, v = calc(fr), calc(to)
return u - v
fr, to = a, b
u, v = calc(fr), calc(to)
return u + v
t = int(input())
for _ in range(t):
a, b = map(int, input().split())
print(solve(a, b))
|
IMPORT FUNC_DEF ASSIGN VAR NUMBER WHILE VAR VAR NUMBER ASSIGN VAR BIN_OP BIN_OP VAR BIN_OP VAR NUMBER VAR RETURN VAR FUNC_DEF ASSIGN VAR BIN_OP BIN_OP NUMBER NUMBER NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR VAR VAR RETURN VAR FUNC_DEF ASSIGN VAR VAR NUMBER NUMBER WHILE NUMBER EXPR VAR ASSIGN VAR VAR BIN_OP BIN_OP NUMBER VAR VAR BIN_OP NUMBER VAR FUNC_DEF FUNC_DEF IF VAR NUMBER RETURN NUMBER ASSIGN VAR VAR FUNC_CALL VAR NUMBER FOR VAR FUNC_CALL VAR IF VAR VAR EXPR FUNC_CALL VAR VAR VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER WHILE VAR ASSIGN VAR FUNC_CALL VAR IF VAR VAR ASSIGN VAR BIN_OP VAR VAR ASSIGN VAR BIN_OP BIN_OP VAR VAR NUMBER VAR VAR VAR VAR VAR NUMBER RETURN VAR FUNC_DEF IF VAR NUMBER RETURN FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR RETURN BIN_OP BIN_OP VAR NUMBER FUNC_CALL VAR BIN_OP VAR NUMBER IF VAR NUMBER RETURN FUNC_CALL VAR VAR IF VAR NUMBER RETURN FUNC_CALL VAR VAR IF VAR NUMBER ASSIGN VAR VAR BIN_OP VAR NUMBER VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR RETURN BIN_OP VAR VAR IF VAR NUMBER ASSIGN VAR VAR VAR BIN_OP VAR NUMBER ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR RETURN BIN_OP VAR VAR ASSIGN VAR VAR VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR RETURN BIN_OP VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR EXPR FUNC_CALL VAR FUNC_CALL VAR VAR VAR
|
Understanding $2$'s complement representation is fundamental to learning about Computer Science. It allows us to write negative numbers in binary. The leftmost digit is used as a sign bit. If it is $1$, we have a negative number and it is represented as the two's complement of its absolute value. Let's say you wrote down the $2$'s complement representation for each $32$-bit integer in the inclusive range from $\boldsymbol{a}$ to $\boldsymbol{b}$. How many $1$'s would you write down in all?
For example, using an $8$-bit byte rather than $32$ bit integer, the two's complement of a number can be found by reversing all its bits and adding $1$. The two's complement representations for a few numbers are shown below:
|Number| Representation in
Number Binary Inverse Two's Complement
-3 00000011 11111100 11111101
-2 00000010 11111101 11111110
-1 00000001 11111110 11111111
0 00000000 00000000
1 00000001 00000001
2 00000010 00000010
3 00000011 00000011
To write down that range of numbers' two's complements in $8$ bits, we wrote $\textbf{26}\:1$'s. Remember to use $32$ bits rather than $8$ in your solution. The logic is the same, so the $8$ bit representation was chosen to reduce apparent complexity in the example.
Function Description
Complete the twosCompliment function in the editor below. It should return an integer.
twosCompliment has the following parameter(s):
- a: an integer, the range minimum
- b: an integer, the range maximum
Input Format
The first line contains an integer $\mathbf{T}$, the number of test cases.
Each of the next $\mathbf{T}$ lines contains two space-separated integers, $\boldsymbol{a}$ and $\boldsymbol{b}$.
Constraints
$T\leq1000$
$-2^{31}\leq a\leq b\leq2^{31}-1$
Output Format
For each test case, print the number of $\mbox{I}$'s in the $32$-bit $2$'s complement representation for integers in the inclusive range from $\boldsymbol{a}$ to $\boldsymbol{b}$ on a new line.
Sample Input 0
3
-2 0
-3 4
-1 4
Sample Output 0
63
99
37
Explanation 0
Test case 0
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
31+32+0 = 63
Test case 1
-3 has 31 ones
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
31+31+32+0+1+1+2+1 = 99
Test case 2
-1 has 32 ones
0 has 0 ones
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
32+0+1+1+2+1 = 37
Sample Input 1
4
-5 0
1 7
-6 -3
3 6
Sample Output 1
155
12
122
7
Explanation 1
Test case 0
-5 has 31 ones
-4 has 30 ones
-3 has 31 ones
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
31+30+31+31+32+0 = 155
Test case 1
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
5 has 2 ones
6 has 2 ones
7 has 3 ones
1+1+2+1+2+2+3 = 12
Test case 2
-6 has 30 ones
-5 has 31 ones
-4 has 30 ones
-3 has 31 ones
30+31+30+31 = 122
Test case 3
3 has 2 ones
4 has 1 ones
5 has 2 ones
6 has 2 ones
2+1+2+2 = 7
|
import sys
count = 0
ones = []
ones.insert(0, 0)
ones.insert(1, 1)
for i in range(2, 32):
ones.insert(i, 2 * ones[i - 1] + 2 ** (i - 2))
tot_1s = []
tot_1s.insert(0, 0)
for i in range(1, 32):
tot_1s.insert(i, tot_1s[i - 1] + ones[i])
num_cases = int(input().strip())
for i in range(num_cases):
total_count = 0
lower_num, upper_num = input().strip().split(" ")
lower_num, upper_num = [int(lower_num), int(upper_num)]
num1 = abs(lower_num) - (1 if lower_num < 0 else 0)
num2 = abs(upper_num) - (1 if upper_num < 0 else 0)
lower_b = bin(num1)[::-1][0 : len(bin(num1)) - 2]
upper_b = bin(num2)[::-1][0 : len(bin(num2)) - 2]
count_l = 0
count_u = 0
XXX_lower = 0
XXX_upper = 0
msb1 = num1
msb2 = num2
for bit in range(len(lower_b) - 1, 0, -1):
if lower_b[bit] == "1":
msb1 = msb1 - 2**bit
XXX_lower = XXX_lower + 1
count_l = count_l + int(lower_b[bit]) * (tot_1s[bit] + msb1 + 1)
for bit in range(len(upper_b) - 1, 0, -1):
if upper_b[bit] == "1":
msb2 = msb2 - 2**bit
XXX_upper = XXX_upper + 1
count_u = count_u + int(upper_b[bit]) * (tot_1s[bit] + msb2 + 1)
count_l = count_l + int(lower_b[0])
XXX_lower = XXX_lower + int(lower_b[0])
count_u = count_u + int(upper_b[0])
XXX_upper = XXX_upper + int(upper_b[0])
if lower_num < 0:
count_l = 32 * abs(lower_num) - count_l
XXX_lower = 32 - XXX_lower
if upper_num < 0:
count_u = 32 * abs(upper_num) - count_u
XXX_upper = 32 - XXX_upper
if lower_num >= 0 and upper_num >= 0:
total_count = count_u - count_l + XXX_lower
elif lower_num <= 0 and upper_num <= 0:
total_count = count_l - count_u + XXX_upper
elif lower_num <= 0 and upper_num >= 0:
total_count = count_u + count_l
print(total_count)
|
IMPORT ASSIGN VAR NUMBER ASSIGN VAR LIST EXPR FUNC_CALL VAR NUMBER NUMBER EXPR FUNC_CALL VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER NUMBER EXPR FUNC_CALL VAR VAR BIN_OP BIN_OP NUMBER VAR BIN_OP VAR NUMBER BIN_OP NUMBER BIN_OP VAR NUMBER ASSIGN VAR LIST EXPR FUNC_CALL VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER NUMBER EXPR FUNC_CALL VAR VAR BIN_OP VAR BIN_OP VAR NUMBER VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER ASSIGN VAR VAR FUNC_CALL FUNC_CALL FUNC_CALL VAR STRING ASSIGN VAR VAR LIST FUNC_CALL VAR VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP FUNC_CALL VAR VAR VAR NUMBER NUMBER NUMBER ASSIGN VAR BIN_OP FUNC_CALL VAR VAR VAR NUMBER NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR VAR NUMBER NUMBER BIN_OP FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR NUMBER NUMBER BIN_OP FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR VAR ASSIGN VAR VAR FOR VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER NUMBER NUMBER IF VAR VAR STRING ASSIGN VAR BIN_OP VAR BIN_OP NUMBER VAR ASSIGN VAR BIN_OP VAR NUMBER ASSIGN VAR BIN_OP VAR BIN_OP FUNC_CALL VAR VAR VAR BIN_OP BIN_OP VAR VAR VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER NUMBER NUMBER IF VAR VAR STRING ASSIGN VAR BIN_OP VAR BIN_OP NUMBER VAR ASSIGN VAR BIN_OP VAR NUMBER ASSIGN VAR BIN_OP VAR BIN_OP FUNC_CALL VAR VAR VAR BIN_OP BIN_OP VAR VAR VAR NUMBER ASSIGN VAR BIN_OP VAR FUNC_CALL VAR VAR NUMBER ASSIGN VAR BIN_OP VAR FUNC_CALL VAR VAR NUMBER ASSIGN VAR BIN_OP VAR FUNC_CALL VAR VAR NUMBER ASSIGN VAR BIN_OP VAR FUNC_CALL VAR VAR NUMBER IF VAR NUMBER ASSIGN VAR BIN_OP BIN_OP NUMBER FUNC_CALL VAR VAR VAR ASSIGN VAR BIN_OP NUMBER VAR IF VAR NUMBER ASSIGN VAR BIN_OP BIN_OP NUMBER FUNC_CALL VAR VAR VAR ASSIGN VAR BIN_OP NUMBER VAR IF VAR NUMBER VAR NUMBER ASSIGN VAR BIN_OP BIN_OP VAR VAR VAR IF VAR NUMBER VAR NUMBER ASSIGN VAR BIN_OP BIN_OP VAR VAR VAR IF VAR NUMBER VAR NUMBER ASSIGN VAR BIN_OP VAR VAR EXPR FUNC_CALL VAR VAR
|
Understanding $2$'s complement representation is fundamental to learning about Computer Science. It allows us to write negative numbers in binary. The leftmost digit is used as a sign bit. If it is $1$, we have a negative number and it is represented as the two's complement of its absolute value. Let's say you wrote down the $2$'s complement representation for each $32$-bit integer in the inclusive range from $\boldsymbol{a}$ to $\boldsymbol{b}$. How many $1$'s would you write down in all?
For example, using an $8$-bit byte rather than $32$ bit integer, the two's complement of a number can be found by reversing all its bits and adding $1$. The two's complement representations for a few numbers are shown below:
|Number| Representation in
Number Binary Inverse Two's Complement
-3 00000011 11111100 11111101
-2 00000010 11111101 11111110
-1 00000001 11111110 11111111
0 00000000 00000000
1 00000001 00000001
2 00000010 00000010
3 00000011 00000011
To write down that range of numbers' two's complements in $8$ bits, we wrote $\textbf{26}\:1$'s. Remember to use $32$ bits rather than $8$ in your solution. The logic is the same, so the $8$ bit representation was chosen to reduce apparent complexity in the example.
Function Description
Complete the twosCompliment function in the editor below. It should return an integer.
twosCompliment has the following parameter(s):
- a: an integer, the range minimum
- b: an integer, the range maximum
Input Format
The first line contains an integer $\mathbf{T}$, the number of test cases.
Each of the next $\mathbf{T}$ lines contains two space-separated integers, $\boldsymbol{a}$ and $\boldsymbol{b}$.
Constraints
$T\leq1000$
$-2^{31}\leq a\leq b\leq2^{31}-1$
Output Format
For each test case, print the number of $\mbox{I}$'s in the $32$-bit $2$'s complement representation for integers in the inclusive range from $\boldsymbol{a}$ to $\boldsymbol{b}$ on a new line.
Sample Input 0
3
-2 0
-3 4
-1 4
Sample Output 0
63
99
37
Explanation 0
Test case 0
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
31+32+0 = 63
Test case 1
-3 has 31 ones
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
31+31+32+0+1+1+2+1 = 99
Test case 2
-1 has 32 ones
0 has 0 ones
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
32+0+1+1+2+1 = 37
Sample Input 1
4
-5 0
1 7
-6 -3
3 6
Sample Output 1
155
12
122
7
Explanation 1
Test case 0
-5 has 31 ones
-4 has 30 ones
-3 has 31 ones
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
31+30+31+31+32+0 = 155
Test case 1
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
5 has 2 ones
6 has 2 ones
7 has 3 ones
1+1+2+1+2+2+3 = 12
Test case 2
-6 has 30 ones
-5 has 31 ones
-4 has 30 ones
-3 has 31 ones
30+31+30+31 = 122
Test case 3
3 has 2 ones
4 has 1 ones
5 has 2 ones
6 has 2 ones
2+1+2+2 = 7
|
def bitize_twos_complement(X, bits=32):
L = [(0) for r in range(0, bits)]
if X >= 0:
for i in range(0, 32):
L[i] = X % 2
X //= 2
elif X < 0:
X *= -1
X -= 1
for i in range(0, 32):
L[i] = (X + 1) % 2
X //= 2
return L
def numberify_twos_complement(bin_list):
number = 0
is_negative = False
if bin_list[len(bin_list) - 1] == 1:
is_negative = True
for flippy in range(0, len(bin_list)):
bin_list[flippy] = 1 - bin_list[flippy]
current_power = 1
for i in range(0, len(bin_list)):
number += current_power * bin_list[i]
current_power *= 2
if is_negative:
number += 1
number *= -1
return number
def count_twos_complement_ones(N, bits=32):
bit_array = bitize_twos_complement(N)
result = 0
for i in range(1, bits - 1):
if bit_array[bits - i]:
bit_array[bits - i] = 0
result += (bits - i) * pow(2, bits - i - 1) + (
numberify_twos_complement(bit_array) + 1
)
if bit_array[1] and bit_array[0]:
result += 4
elif not bit_array[1] and bit_array[0]:
result += 1
elif bit_array[1] and not bit_array[0]:
result += 2
return result
def find_twos_complement_ones(A, B):
if 0 < A <= B:
return count_twos_complement_ones(B) - count_twos_complement_ones(A - 1)
elif A <= B < 0:
return count_twos_complement_ones(B) - count_twos_complement_ones(A - 1)
elif A <= B == 0:
return count_twos_complement_ones(-1) - count_twos_complement_ones(A - 1)
elif A <= B <= 0:
return count_twos_complement_ones(B) - count_twos_complement_ones(A - 1)
elif A < 0 < B:
return (
count_twos_complement_ones(-1)
- count_twos_complement_ones(A - 1)
+ count_twos_complement_ones(B)
)
elif 0 == A <= B:
return count_twos_complement_ones(B)
else:
return 0
num_queries = int(input())
for i in range(0, num_queries):
A, B = [int(a) for a in input().split()]
print(find_twos_complement_ones(A, B))
|
FUNC_DEF NUMBER ASSIGN VAR NUMBER VAR FUNC_CALL VAR NUMBER VAR IF VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER NUMBER ASSIGN VAR VAR BIN_OP VAR NUMBER VAR NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER NUMBER ASSIGN VAR VAR BIN_OP BIN_OP VAR NUMBER NUMBER VAR NUMBER RETURN VAR FUNC_DEF ASSIGN VAR NUMBER ASSIGN VAR NUMBER IF VAR BIN_OP FUNC_CALL VAR VAR NUMBER NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER FUNC_CALL VAR VAR ASSIGN VAR VAR BIN_OP NUMBER VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER FUNC_CALL VAR VAR VAR BIN_OP VAR VAR VAR VAR NUMBER IF VAR VAR NUMBER VAR NUMBER RETURN VAR FUNC_DEF NUMBER ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER IF VAR BIN_OP VAR VAR ASSIGN VAR BIN_OP VAR VAR NUMBER VAR BIN_OP BIN_OP BIN_OP VAR VAR FUNC_CALL VAR NUMBER BIN_OP BIN_OP VAR VAR NUMBER BIN_OP FUNC_CALL VAR VAR NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER RETURN VAR FUNC_DEF IF NUMBER VAR VAR RETURN BIN_OP FUNC_CALL VAR VAR FUNC_CALL VAR BIN_OP VAR NUMBER IF VAR VAR NUMBER RETURN BIN_OP FUNC_CALL VAR VAR FUNC_CALL VAR BIN_OP VAR NUMBER IF VAR VAR NUMBER RETURN BIN_OP FUNC_CALL VAR NUMBER FUNC_CALL VAR BIN_OP VAR NUMBER IF VAR VAR NUMBER RETURN BIN_OP FUNC_CALL VAR VAR FUNC_CALL VAR BIN_OP VAR NUMBER IF VAR NUMBER VAR RETURN BIN_OP BIN_OP FUNC_CALL VAR NUMBER FUNC_CALL VAR BIN_OP VAR NUMBER FUNC_CALL VAR VAR IF NUMBER VAR VAR RETURN FUNC_CALL VAR VAR RETURN NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR NUMBER VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR EXPR FUNC_CALL VAR FUNC_CALL VAR VAR VAR
|
Understanding $2$'s complement representation is fundamental to learning about Computer Science. It allows us to write negative numbers in binary. The leftmost digit is used as a sign bit. If it is $1$, we have a negative number and it is represented as the two's complement of its absolute value. Let's say you wrote down the $2$'s complement representation for each $32$-bit integer in the inclusive range from $\boldsymbol{a}$ to $\boldsymbol{b}$. How many $1$'s would you write down in all?
For example, using an $8$-bit byte rather than $32$ bit integer, the two's complement of a number can be found by reversing all its bits and adding $1$. The two's complement representations for a few numbers are shown below:
|Number| Representation in
Number Binary Inverse Two's Complement
-3 00000011 11111100 11111101
-2 00000010 11111101 11111110
-1 00000001 11111110 11111111
0 00000000 00000000
1 00000001 00000001
2 00000010 00000010
3 00000011 00000011
To write down that range of numbers' two's complements in $8$ bits, we wrote $\textbf{26}\:1$'s. Remember to use $32$ bits rather than $8$ in your solution. The logic is the same, so the $8$ bit representation was chosen to reduce apparent complexity in the example.
Function Description
Complete the twosCompliment function in the editor below. It should return an integer.
twosCompliment has the following parameter(s):
- a: an integer, the range minimum
- b: an integer, the range maximum
Input Format
The first line contains an integer $\mathbf{T}$, the number of test cases.
Each of the next $\mathbf{T}$ lines contains two space-separated integers, $\boldsymbol{a}$ and $\boldsymbol{b}$.
Constraints
$T\leq1000$
$-2^{31}\leq a\leq b\leq2^{31}-1$
Output Format
For each test case, print the number of $\mbox{I}$'s in the $32$-bit $2$'s complement representation for integers in the inclusive range from $\boldsymbol{a}$ to $\boldsymbol{b}$ on a new line.
Sample Input 0
3
-2 0
-3 4
-1 4
Sample Output 0
63
99
37
Explanation 0
Test case 0
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
31+32+0 = 63
Test case 1
-3 has 31 ones
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
31+31+32+0+1+1+2+1 = 99
Test case 2
-1 has 32 ones
0 has 0 ones
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
32+0+1+1+2+1 = 37
Sample Input 1
4
-5 0
1 7
-6 -3
3 6
Sample Output 1
155
12
122
7
Explanation 1
Test case 0
-5 has 31 ones
-4 has 30 ones
-3 has 31 ones
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
31+30+31+31+32+0 = 155
Test case 1
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
5 has 2 ones
6 has 2 ones
7 has 3 ones
1+1+2+1+2+2+3 = 12
Test case 2
-6 has 30 ones
-5 has 31 ones
-4 has 30 ones
-3 has 31 ones
30+31+30+31 = 122
Test case 3
3 has 2 ones
4 has 1 ones
5 has 2 ones
6 has 2 ones
2+1+2+2 = 7
|
for _ in range(int(input())):
down, up = map(int, input().split())
temp_down = down
temp_up = up
rd = 0
ru = 0
try:
if down < 0:
down = abs(down)
j = 2
for i in range(32):
rd += down // j * (j // 2)
if down % j > j // 2:
rd += j // 2
else:
rd += down % j
j *= 2
else:
j = 2
temp = 0
for i in range(32):
temp += down // j * (j // 2)
if down % j > j // 2:
temp += j // 2
else:
temp += down % j
j *= 2
rd += 32 * down - temp
if up < 0:
up = abs(up)
j = 2
up -= 1
for i in range(32):
ru += up // j * (j // 2)
if up % j > j // 2:
ru += j // 2
else:
ru += up % j
j *= 2
else:
j = 2
up += 1
temp = 0
for i in range(32):
temp += up // j * (j // 2)
if up % j > j // 2:
temp += j // 2
else:
temp += up % j
j *= 2
ru += 32 * up - temp
if temp_down <= 0 and temp_up >= 0:
print(rd + ru)
elif temp_down >= 0 and temp_up >= 0:
print(ru - rd)
else:
print(rd - ru)
except RuntimeError:
print(0)
|
FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR VAR ASSIGN VAR VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER IF VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER VAR BIN_OP BIN_OP VAR VAR BIN_OP VAR NUMBER IF BIN_OP VAR VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER VAR BIN_OP VAR VAR VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER VAR BIN_OP BIN_OP VAR VAR BIN_OP VAR NUMBER IF BIN_OP VAR VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER VAR BIN_OP VAR VAR VAR NUMBER VAR BIN_OP BIN_OP NUMBER VAR VAR IF VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER VAR BIN_OP BIN_OP VAR VAR BIN_OP VAR NUMBER IF BIN_OP VAR VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER VAR BIN_OP VAR VAR VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER VAR BIN_OP BIN_OP VAR VAR BIN_OP VAR NUMBER IF BIN_OP VAR VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER VAR BIN_OP VAR VAR VAR NUMBER VAR BIN_OP BIN_OP NUMBER VAR VAR IF VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR BIN_OP VAR VAR IF VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR BIN_OP VAR VAR EXPR FUNC_CALL VAR BIN_OP VAR VAR VAR EXPR FUNC_CALL VAR NUMBER
|
Understanding $2$'s complement representation is fundamental to learning about Computer Science. It allows us to write negative numbers in binary. The leftmost digit is used as a sign bit. If it is $1$, we have a negative number and it is represented as the two's complement of its absolute value. Let's say you wrote down the $2$'s complement representation for each $32$-bit integer in the inclusive range from $\boldsymbol{a}$ to $\boldsymbol{b}$. How many $1$'s would you write down in all?
For example, using an $8$-bit byte rather than $32$ bit integer, the two's complement of a number can be found by reversing all its bits and adding $1$. The two's complement representations for a few numbers are shown below:
|Number| Representation in
Number Binary Inverse Two's Complement
-3 00000011 11111100 11111101
-2 00000010 11111101 11111110
-1 00000001 11111110 11111111
0 00000000 00000000
1 00000001 00000001
2 00000010 00000010
3 00000011 00000011
To write down that range of numbers' two's complements in $8$ bits, we wrote $\textbf{26}\:1$'s. Remember to use $32$ bits rather than $8$ in your solution. The logic is the same, so the $8$ bit representation was chosen to reduce apparent complexity in the example.
Function Description
Complete the twosCompliment function in the editor below. It should return an integer.
twosCompliment has the following parameter(s):
- a: an integer, the range minimum
- b: an integer, the range maximum
Input Format
The first line contains an integer $\mathbf{T}$, the number of test cases.
Each of the next $\mathbf{T}$ lines contains two space-separated integers, $\boldsymbol{a}$ and $\boldsymbol{b}$.
Constraints
$T\leq1000$
$-2^{31}\leq a\leq b\leq2^{31}-1$
Output Format
For each test case, print the number of $\mbox{I}$'s in the $32$-bit $2$'s complement representation for integers in the inclusive range from $\boldsymbol{a}$ to $\boldsymbol{b}$ on a new line.
Sample Input 0
3
-2 0
-3 4
-1 4
Sample Output 0
63
99
37
Explanation 0
Test case 0
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
31+32+0 = 63
Test case 1
-3 has 31 ones
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
31+31+32+0+1+1+2+1 = 99
Test case 2
-1 has 32 ones
0 has 0 ones
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
32+0+1+1+2+1 = 37
Sample Input 1
4
-5 0
1 7
-6 -3
3 6
Sample Output 1
155
12
122
7
Explanation 1
Test case 0
-5 has 31 ones
-4 has 30 ones
-3 has 31 ones
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
31+30+31+31+32+0 = 155
Test case 1
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
5 has 2 ones
6 has 2 ones
7 has 3 ones
1+1+2+1+2+2+3 = 12
Test case 2
-6 has 30 ones
-5 has 31 ones
-4 has 30 ones
-3 has 31 ones
30+31+30+31 = 122
Test case 3
3 has 2 ones
4 has 1 ones
5 has 2 ones
6 has 2 ones
2+1+2+2 = 7
|
def countbit(b, n):
q = n >> b + 1
r = n & (1 << b + 1) - 1
return (q << b) + max(0, r - (1 << b))
def countall(n):
return sum(countbit(b, n) for b in range(32))
def solve(a, b):
if 0 <= a:
return countall(b + 1) - countall(a)
if b < 0:
return countall(2**32 + b + 1) - countall(2**32 + a)
return countall(2**32) - countall(2**32 + a) + countall(b + 1)
for _ in range(int(input())):
a, b = map(int, input().split())
assert -(2**31) <= a <= b < 2**31
print(solve(a, b))
|
FUNC_DEF ASSIGN VAR BIN_OP VAR BIN_OP VAR NUMBER ASSIGN VAR BIN_OP VAR BIN_OP BIN_OP NUMBER BIN_OP VAR NUMBER NUMBER RETURN BIN_OP BIN_OP VAR VAR FUNC_CALL VAR NUMBER BIN_OP VAR BIN_OP NUMBER VAR FUNC_DEF RETURN FUNC_CALL VAR FUNC_CALL VAR VAR VAR VAR FUNC_CALL VAR NUMBER FUNC_DEF IF NUMBER VAR RETURN BIN_OP FUNC_CALL VAR BIN_OP VAR NUMBER FUNC_CALL VAR VAR IF VAR NUMBER RETURN BIN_OP FUNC_CALL VAR BIN_OP BIN_OP BIN_OP NUMBER NUMBER VAR NUMBER FUNC_CALL VAR BIN_OP BIN_OP NUMBER NUMBER VAR RETURN BIN_OP BIN_OP FUNC_CALL VAR BIN_OP NUMBER NUMBER FUNC_CALL VAR BIN_OP BIN_OP NUMBER NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR BIN_OP NUMBER NUMBER VAR VAR BIN_OP NUMBER NUMBER EXPR FUNC_CALL VAR FUNC_CALL VAR VAR VAR
|
Understanding $2$'s complement representation is fundamental to learning about Computer Science. It allows us to write negative numbers in binary. The leftmost digit is used as a sign bit. If it is $1$, we have a negative number and it is represented as the two's complement of its absolute value. Let's say you wrote down the $2$'s complement representation for each $32$-bit integer in the inclusive range from $\boldsymbol{a}$ to $\boldsymbol{b}$. How many $1$'s would you write down in all?
For example, using an $8$-bit byte rather than $32$ bit integer, the two's complement of a number can be found by reversing all its bits and adding $1$. The two's complement representations for a few numbers are shown below:
|Number| Representation in
Number Binary Inverse Two's Complement
-3 00000011 11111100 11111101
-2 00000010 11111101 11111110
-1 00000001 11111110 11111111
0 00000000 00000000
1 00000001 00000001
2 00000010 00000010
3 00000011 00000011
To write down that range of numbers' two's complements in $8$ bits, we wrote $\textbf{26}\:1$'s. Remember to use $32$ bits rather than $8$ in your solution. The logic is the same, so the $8$ bit representation was chosen to reduce apparent complexity in the example.
Function Description
Complete the twosCompliment function in the editor below. It should return an integer.
twosCompliment has the following parameter(s):
- a: an integer, the range minimum
- b: an integer, the range maximum
Input Format
The first line contains an integer $\mathbf{T}$, the number of test cases.
Each of the next $\mathbf{T}$ lines contains two space-separated integers, $\boldsymbol{a}$ and $\boldsymbol{b}$.
Constraints
$T\leq1000$
$-2^{31}\leq a\leq b\leq2^{31}-1$
Output Format
For each test case, print the number of $\mbox{I}$'s in the $32$-bit $2$'s complement representation for integers in the inclusive range from $\boldsymbol{a}$ to $\boldsymbol{b}$ on a new line.
Sample Input 0
3
-2 0
-3 4
-1 4
Sample Output 0
63
99
37
Explanation 0
Test case 0
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
31+32+0 = 63
Test case 1
-3 has 31 ones
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
31+31+32+0+1+1+2+1 = 99
Test case 2
-1 has 32 ones
0 has 0 ones
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
32+0+1+1+2+1 = 37
Sample Input 1
4
-5 0
1 7
-6 -3
3 6
Sample Output 1
155
12
122
7
Explanation 1
Test case 0
-5 has 31 ones
-4 has 30 ones
-3 has 31 ones
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
31+30+31+31+32+0 = 155
Test case 1
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
5 has 2 ones
6 has 2 ones
7 has 3 ones
1+1+2+1+2+2+3 = 12
Test case 2
-6 has 30 ones
-5 has 31 ones
-4 has 30 ones
-3 has 31 ones
30+31+30+31 = 122
Test case 3
3 has 2 ones
4 has 1 ones
5 has 2 ones
6 has 2 ones
2+1+2+2 = 7
|
q = int(input())
Q = [tuple(map(int, input().split())) for x in range(q)]
def f(y):
s = bin(y)[2:]
l = len(s)
n = 0
ones = 0
for i in range(l):
if s[i] == "1":
n += 2 ** (l - 1 - i) * ones + 2 ** (l - 2 - i) * (l - 1 - i)
ones += 1
n += ones
return n
def g(x):
mx = abs(x)
return f(x) if x == mx else 32 * mx - f(mx - 1)
for z in Q:
x, y = z
if x > 0:
print(int(g(y) - g(x - 1)))
elif y >= 0:
print(int(g(y) + g(x)))
else:
print(int(g(x) - g(y + 1)))
|
ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR VAR FUNC_CALL VAR VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR IF VAR VAR STRING VAR BIN_OP BIN_OP BIN_OP NUMBER BIN_OP BIN_OP VAR NUMBER VAR VAR BIN_OP BIN_OP NUMBER BIN_OP BIN_OP VAR NUMBER VAR BIN_OP BIN_OP VAR NUMBER VAR VAR NUMBER VAR VAR RETURN VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR RETURN VAR VAR FUNC_CALL VAR VAR BIN_OP BIN_OP NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER FOR VAR VAR ASSIGN VAR VAR VAR IF VAR NUMBER EXPR FUNC_CALL VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR FUNC_CALL VAR BIN_OP VAR NUMBER IF VAR NUMBER EXPR FUNC_CALL VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR FUNC_CALL VAR BIN_OP VAR NUMBER
|
Understanding $2$'s complement representation is fundamental to learning about Computer Science. It allows us to write negative numbers in binary. The leftmost digit is used as a sign bit. If it is $1$, we have a negative number and it is represented as the two's complement of its absolute value. Let's say you wrote down the $2$'s complement representation for each $32$-bit integer in the inclusive range from $\boldsymbol{a}$ to $\boldsymbol{b}$. How many $1$'s would you write down in all?
For example, using an $8$-bit byte rather than $32$ bit integer, the two's complement of a number can be found by reversing all its bits and adding $1$. The two's complement representations for a few numbers are shown below:
|Number| Representation in
Number Binary Inverse Two's Complement
-3 00000011 11111100 11111101
-2 00000010 11111101 11111110
-1 00000001 11111110 11111111
0 00000000 00000000
1 00000001 00000001
2 00000010 00000010
3 00000011 00000011
To write down that range of numbers' two's complements in $8$ bits, we wrote $\textbf{26}\:1$'s. Remember to use $32$ bits rather than $8$ in your solution. The logic is the same, so the $8$ bit representation was chosen to reduce apparent complexity in the example.
Function Description
Complete the twosCompliment function in the editor below. It should return an integer.
twosCompliment has the following parameter(s):
- a: an integer, the range minimum
- b: an integer, the range maximum
Input Format
The first line contains an integer $\mathbf{T}$, the number of test cases.
Each of the next $\mathbf{T}$ lines contains two space-separated integers, $\boldsymbol{a}$ and $\boldsymbol{b}$.
Constraints
$T\leq1000$
$-2^{31}\leq a\leq b\leq2^{31}-1$
Output Format
For each test case, print the number of $\mbox{I}$'s in the $32$-bit $2$'s complement representation for integers in the inclusive range from $\boldsymbol{a}$ to $\boldsymbol{b}$ on a new line.
Sample Input 0
3
-2 0
-3 4
-1 4
Sample Output 0
63
99
37
Explanation 0
Test case 0
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
31+32+0 = 63
Test case 1
-3 has 31 ones
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
31+31+32+0+1+1+2+1 = 99
Test case 2
-1 has 32 ones
0 has 0 ones
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
32+0+1+1+2+1 = 37
Sample Input 1
4
-5 0
1 7
-6 -3
3 6
Sample Output 1
155
12
122
7
Explanation 1
Test case 0
-5 has 31 ones
-4 has 30 ones
-3 has 31 ones
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
31+30+31+31+32+0 = 155
Test case 1
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
5 has 2 ones
6 has 2 ones
7 has 3 ones
1+1+2+1+2+2+3 = 12
Test case 2
-6 has 30 ones
-5 has 31 ones
-4 has 30 ones
-3 has 31 ones
30+31+30+31 = 122
Test case 3
3 has 2 ones
4 has 1 ones
5 has 2 ones
6 has 2 ones
2+1+2+2 = 7
|
MM, FULL, MEG = 1 << 31, (1 << 30) * 31, (1 << 30) * 31 + 2147483648
def solpos(x, sp=31):
return (
x
if sp == 0
else (
x - (1 << sp) + 1 + sp * (1 << sp - 1) + solpos(x - (1 << sp), sp - 1)
if x & 1 << sp
else solpos(x, sp - 1)
)
)
def sol(x):
return (
solpos(x)
if x >= 0
else FULL - solpos(MM + x - 1) - x if x != -2147483648 else MEG
)
for _ in range(int(input())):
A, B = map(int, input().strip(" ").split())
if B < 0:
print(sol(A) - sol(B + 1))
elif A <= 0 and B >= 0:
print(sol(A) + solpos(B))
else:
print(sol(B) - solpos(A - 1))
|
ASSIGN VAR VAR VAR BIN_OP NUMBER NUMBER BIN_OP BIN_OP NUMBER NUMBER NUMBER BIN_OP BIN_OP BIN_OP NUMBER NUMBER NUMBER NUMBER FUNC_DEF NUMBER RETURN VAR NUMBER VAR BIN_OP VAR BIN_OP NUMBER VAR BIN_OP BIN_OP BIN_OP BIN_OP VAR BIN_OP NUMBER VAR NUMBER BIN_OP VAR BIN_OP NUMBER BIN_OP VAR NUMBER FUNC_CALL VAR BIN_OP VAR BIN_OP NUMBER VAR BIN_OP VAR NUMBER FUNC_CALL VAR VAR BIN_OP VAR NUMBER FUNC_DEF RETURN VAR NUMBER FUNC_CALL VAR VAR VAR NUMBER BIN_OP BIN_OP VAR FUNC_CALL VAR BIN_OP BIN_OP VAR VAR NUMBER VAR VAR FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL FUNC_CALL VAR STRING IF VAR NUMBER EXPR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR FUNC_CALL VAR BIN_OP VAR NUMBER IF VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR FUNC_CALL VAR BIN_OP VAR NUMBER
|
Understanding $2$'s complement representation is fundamental to learning about Computer Science. It allows us to write negative numbers in binary. The leftmost digit is used as a sign bit. If it is $1$, we have a negative number and it is represented as the two's complement of its absolute value. Let's say you wrote down the $2$'s complement representation for each $32$-bit integer in the inclusive range from $\boldsymbol{a}$ to $\boldsymbol{b}$. How many $1$'s would you write down in all?
For example, using an $8$-bit byte rather than $32$ bit integer, the two's complement of a number can be found by reversing all its bits and adding $1$. The two's complement representations for a few numbers are shown below:
|Number| Representation in
Number Binary Inverse Two's Complement
-3 00000011 11111100 11111101
-2 00000010 11111101 11111110
-1 00000001 11111110 11111111
0 00000000 00000000
1 00000001 00000001
2 00000010 00000010
3 00000011 00000011
To write down that range of numbers' two's complements in $8$ bits, we wrote $\textbf{26}\:1$'s. Remember to use $32$ bits rather than $8$ in your solution. The logic is the same, so the $8$ bit representation was chosen to reduce apparent complexity in the example.
Function Description
Complete the twosCompliment function in the editor below. It should return an integer.
twosCompliment has the following parameter(s):
- a: an integer, the range minimum
- b: an integer, the range maximum
Input Format
The first line contains an integer $\mathbf{T}$, the number of test cases.
Each of the next $\mathbf{T}$ lines contains two space-separated integers, $\boldsymbol{a}$ and $\boldsymbol{b}$.
Constraints
$T\leq1000$
$-2^{31}\leq a\leq b\leq2^{31}-1$
Output Format
For each test case, print the number of $\mbox{I}$'s in the $32$-bit $2$'s complement representation for integers in the inclusive range from $\boldsymbol{a}$ to $\boldsymbol{b}$ on a new line.
Sample Input 0
3
-2 0
-3 4
-1 4
Sample Output 0
63
99
37
Explanation 0
Test case 0
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
31+32+0 = 63
Test case 1
-3 has 31 ones
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
31+31+32+0+1+1+2+1 = 99
Test case 2
-1 has 32 ones
0 has 0 ones
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
32+0+1+1+2+1 = 37
Sample Input 1
4
-5 0
1 7
-6 -3
3 6
Sample Output 1
155
12
122
7
Explanation 1
Test case 0
-5 has 31 ones
-4 has 30 ones
-3 has 31 ones
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
31+30+31+31+32+0 = 155
Test case 1
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
5 has 2 ones
6 has 2 ones
7 has 3 ones
1+1+2+1+2+2+3 = 12
Test case 2
-6 has 30 ones
-5 has 31 ones
-4 has 30 ones
-3 has 31 ones
30+31+30+31 = 122
Test case 3
3 has 2 ones
4 has 1 ones
5 has 2 ones
6 has 2 ones
2+1+2+2 = 7
|
def count_positive(n):
count = mul = 0
for i in range(31, -1, -1):
b = 1 << i
if b & n:
count += 1 + b * i // 2 + b * mul
mul += 1
return count
def count_negative(n):
n = -n
return 32 * n - count_positive(n - 1)
def count(n):
return count_positive(n) if n >= 0 else count_negative(n)
for _ in range(int(input())):
a, b = map(int, input().split())
if b < 0:
print(count(a) - count(b + 1))
elif a > 0:
print(count(b) - count(a - 1))
else:
print(count(a) + count(b))
|
FUNC_DEF ASSIGN VAR VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER NUMBER NUMBER ASSIGN VAR BIN_OP NUMBER VAR IF BIN_OP VAR VAR VAR BIN_OP BIN_OP NUMBER BIN_OP BIN_OP VAR VAR NUMBER BIN_OP VAR VAR VAR NUMBER RETURN VAR FUNC_DEF ASSIGN VAR VAR RETURN BIN_OP BIN_OP NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER FUNC_DEF RETURN VAR NUMBER FUNC_CALL VAR VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR IF VAR NUMBER EXPR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR FUNC_CALL VAR BIN_OP VAR NUMBER IF VAR NUMBER EXPR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR FUNC_CALL VAR BIN_OP VAR NUMBER EXPR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR FUNC_CALL VAR VAR
|
Understanding $2$'s complement representation is fundamental to learning about Computer Science. It allows us to write negative numbers in binary. The leftmost digit is used as a sign bit. If it is $1$, we have a negative number and it is represented as the two's complement of its absolute value. Let's say you wrote down the $2$'s complement representation for each $32$-bit integer in the inclusive range from $\boldsymbol{a}$ to $\boldsymbol{b}$. How many $1$'s would you write down in all?
For example, using an $8$-bit byte rather than $32$ bit integer, the two's complement of a number can be found by reversing all its bits and adding $1$. The two's complement representations for a few numbers are shown below:
|Number| Representation in
Number Binary Inverse Two's Complement
-3 00000011 11111100 11111101
-2 00000010 11111101 11111110
-1 00000001 11111110 11111111
0 00000000 00000000
1 00000001 00000001
2 00000010 00000010
3 00000011 00000011
To write down that range of numbers' two's complements in $8$ bits, we wrote $\textbf{26}\:1$'s. Remember to use $32$ bits rather than $8$ in your solution. The logic is the same, so the $8$ bit representation was chosen to reduce apparent complexity in the example.
Function Description
Complete the twosCompliment function in the editor below. It should return an integer.
twosCompliment has the following parameter(s):
- a: an integer, the range minimum
- b: an integer, the range maximum
Input Format
The first line contains an integer $\mathbf{T}$, the number of test cases.
Each of the next $\mathbf{T}$ lines contains two space-separated integers, $\boldsymbol{a}$ and $\boldsymbol{b}$.
Constraints
$T\leq1000$
$-2^{31}\leq a\leq b\leq2^{31}-1$
Output Format
For each test case, print the number of $\mbox{I}$'s in the $32$-bit $2$'s complement representation for integers in the inclusive range from $\boldsymbol{a}$ to $\boldsymbol{b}$ on a new line.
Sample Input 0
3
-2 0
-3 4
-1 4
Sample Output 0
63
99
37
Explanation 0
Test case 0
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
31+32+0 = 63
Test case 1
-3 has 31 ones
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
31+31+32+0+1+1+2+1 = 99
Test case 2
-1 has 32 ones
0 has 0 ones
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
32+0+1+1+2+1 = 37
Sample Input 1
4
-5 0
1 7
-6 -3
3 6
Sample Output 1
155
12
122
7
Explanation 1
Test case 0
-5 has 31 ones
-4 has 30 ones
-3 has 31 ones
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
31+30+31+31+32+0 = 155
Test case 1
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
5 has 2 ones
6 has 2 ones
7 has 3 ones
1+1+2+1+2+2+3 = 12
Test case 2
-6 has 30 ones
-5 has 31 ones
-4 has 30 ones
-3 has 31 ones
30+31+30+31 = 122
Test case 3
3 has 2 ones
4 has 1 ones
5 has 2 ones
6 has 2 ones
2+1+2+2 = 7
|
def fun(n):
if n < 0:
return 0
res = 0
y = 1
while n // 2**y != 0:
res += n // 2**y * 2 ** (y - 1)
if n % 2**y + 1 - 2 ** (y - 1) > 0:
res += n % 2**y + 1 - 2 ** (y - 1)
y += 1
if n % 2**y + 1 - 2 ** (y - 1) > 0:
res += n % 2**y + 1 - 2 ** (y - 1)
return res
for _ in range(int(input())):
a, b = [int(x) for x in input().split()]
if a >= 0 and b >= 0:
res = fun(b) - fun(a - 1)
if a < 0 <= b:
res = fun(b) + 32 * -a - fun(-a - 1)
if a < 0 and b < 0:
res = 32 * (-a + b + 1) - (fun(-a - 1) - fun(-b - 2))
print(res)
|
FUNC_DEF IF VAR NUMBER RETURN NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER WHILE BIN_OP VAR BIN_OP NUMBER VAR NUMBER VAR BIN_OP BIN_OP VAR BIN_OP NUMBER VAR BIN_OP NUMBER BIN_OP VAR NUMBER IF BIN_OP BIN_OP BIN_OP VAR BIN_OP NUMBER VAR NUMBER BIN_OP NUMBER BIN_OP VAR NUMBER NUMBER VAR BIN_OP BIN_OP BIN_OP VAR BIN_OP NUMBER VAR NUMBER BIN_OP NUMBER BIN_OP VAR NUMBER VAR NUMBER IF BIN_OP BIN_OP BIN_OP VAR BIN_OP NUMBER VAR NUMBER BIN_OP NUMBER BIN_OP VAR NUMBER NUMBER VAR BIN_OP BIN_OP BIN_OP VAR BIN_OP NUMBER VAR NUMBER BIN_OP NUMBER BIN_OP VAR NUMBER RETURN VAR FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR IF VAR NUMBER VAR NUMBER ASSIGN VAR BIN_OP FUNC_CALL VAR VAR FUNC_CALL VAR BIN_OP VAR NUMBER IF VAR NUMBER VAR ASSIGN VAR BIN_OP BIN_OP FUNC_CALL VAR VAR BIN_OP NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER IF VAR NUMBER VAR NUMBER ASSIGN VAR BIN_OP BIN_OP NUMBER BIN_OP BIN_OP VAR VAR NUMBER BIN_OP FUNC_CALL VAR BIN_OP VAR NUMBER FUNC_CALL VAR BIN_OP VAR NUMBER EXPR FUNC_CALL VAR VAR
|
Understanding $2$'s complement representation is fundamental to learning about Computer Science. It allows us to write negative numbers in binary. The leftmost digit is used as a sign bit. If it is $1$, we have a negative number and it is represented as the two's complement of its absolute value. Let's say you wrote down the $2$'s complement representation for each $32$-bit integer in the inclusive range from $\boldsymbol{a}$ to $\boldsymbol{b}$. How many $1$'s would you write down in all?
For example, using an $8$-bit byte rather than $32$ bit integer, the two's complement of a number can be found by reversing all its bits and adding $1$. The two's complement representations for a few numbers are shown below:
|Number| Representation in
Number Binary Inverse Two's Complement
-3 00000011 11111100 11111101
-2 00000010 11111101 11111110
-1 00000001 11111110 11111111
0 00000000 00000000
1 00000001 00000001
2 00000010 00000010
3 00000011 00000011
To write down that range of numbers' two's complements in $8$ bits, we wrote $\textbf{26}\:1$'s. Remember to use $32$ bits rather than $8$ in your solution. The logic is the same, so the $8$ bit representation was chosen to reduce apparent complexity in the example.
Function Description
Complete the twosCompliment function in the editor below. It should return an integer.
twosCompliment has the following parameter(s):
- a: an integer, the range minimum
- b: an integer, the range maximum
Input Format
The first line contains an integer $\mathbf{T}$, the number of test cases.
Each of the next $\mathbf{T}$ lines contains two space-separated integers, $\boldsymbol{a}$ and $\boldsymbol{b}$.
Constraints
$T\leq1000$
$-2^{31}\leq a\leq b\leq2^{31}-1$
Output Format
For each test case, print the number of $\mbox{I}$'s in the $32$-bit $2$'s complement representation for integers in the inclusive range from $\boldsymbol{a}$ to $\boldsymbol{b}$ on a new line.
Sample Input 0
3
-2 0
-3 4
-1 4
Sample Output 0
63
99
37
Explanation 0
Test case 0
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
31+32+0 = 63
Test case 1
-3 has 31 ones
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
31+31+32+0+1+1+2+1 = 99
Test case 2
-1 has 32 ones
0 has 0 ones
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
32+0+1+1+2+1 = 37
Sample Input 1
4
-5 0
1 7
-6 -3
3 6
Sample Output 1
155
12
122
7
Explanation 1
Test case 0
-5 has 31 ones
-4 has 30 ones
-3 has 31 ones
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
31+30+31+31+32+0 = 155
Test case 1
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
5 has 2 ones
6 has 2 ones
7 has 3 ones
1+1+2+1+2+2+3 = 12
Test case 2
-6 has 30 ones
-5 has 31 ones
-4 has 30 ones
-3 has 31 ones
30+31+30+31 = 122
Test case 3
3 has 2 ones
4 has 1 ones
5 has 2 ones
6 has 2 ones
2+1+2+2 = 7
|
def get_val2(ind1, ind2):
j = 1
ans = 0
for i in range(1, 33):
a = ind2 // j
if a != 0:
if a % 2 == 0:
b = a // 2
noz = b * j
c = ind2 % j
noz = noz + c
else:
b = a // 2 + 1
noz = b * j
else:
noz = ind2
ans = ans + noz
g = j * 2
j = g
return ans
def get_val1(ind1, ind2):
j = 1
ans = 0
for i in range(1, 33):
a = ind2 // j
if a != 0:
if a % 2 == 0:
b = a // 2
noz = b * j
c = ind2 % j
noz = noz + c
else:
b = a // 2 + 1
noz = b * j
else:
noz = ind2
noon = ind2 - noz
ans = ans + noon
g = j * 2
j = g
return ans
n = int(input())
for i in range(0, n):
li = list(map(int, input().strip().split(" ")))
df = get_val1(0, li[1] + 1)
df1 = get_val2(0, -li[0])
print(df + df1)
|
FUNC_DEF ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER NUMBER ASSIGN VAR BIN_OP VAR VAR IF VAR NUMBER IF BIN_OP VAR NUMBER NUMBER ASSIGN VAR BIN_OP VAR NUMBER ASSIGN VAR BIN_OP VAR VAR ASSIGN VAR BIN_OP VAR VAR ASSIGN VAR BIN_OP VAR VAR ASSIGN VAR BIN_OP BIN_OP VAR NUMBER NUMBER ASSIGN VAR BIN_OP VAR VAR ASSIGN VAR VAR ASSIGN VAR BIN_OP VAR VAR ASSIGN VAR BIN_OP VAR NUMBER ASSIGN VAR VAR RETURN VAR FUNC_DEF ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER NUMBER ASSIGN VAR BIN_OP VAR VAR IF VAR NUMBER IF BIN_OP VAR NUMBER NUMBER ASSIGN VAR BIN_OP VAR NUMBER ASSIGN VAR BIN_OP VAR VAR ASSIGN VAR BIN_OP VAR VAR ASSIGN VAR BIN_OP VAR VAR ASSIGN VAR BIN_OP BIN_OP VAR NUMBER NUMBER ASSIGN VAR BIN_OP VAR VAR ASSIGN VAR VAR ASSIGN VAR BIN_OP VAR VAR ASSIGN VAR BIN_OP VAR VAR ASSIGN VAR BIN_OP VAR NUMBER ASSIGN VAR VAR RETURN VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR NUMBER VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL FUNC_CALL VAR STRING ASSIGN VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR BIN_OP VAR VAR
|
Understanding $2$'s complement representation is fundamental to learning about Computer Science. It allows us to write negative numbers in binary. The leftmost digit is used as a sign bit. If it is $1$, we have a negative number and it is represented as the two's complement of its absolute value. Let's say you wrote down the $2$'s complement representation for each $32$-bit integer in the inclusive range from $\boldsymbol{a}$ to $\boldsymbol{b}$. How many $1$'s would you write down in all?
For example, using an $8$-bit byte rather than $32$ bit integer, the two's complement of a number can be found by reversing all its bits and adding $1$. The two's complement representations for a few numbers are shown below:
|Number| Representation in
Number Binary Inverse Two's Complement
-3 00000011 11111100 11111101
-2 00000010 11111101 11111110
-1 00000001 11111110 11111111
0 00000000 00000000
1 00000001 00000001
2 00000010 00000010
3 00000011 00000011
To write down that range of numbers' two's complements in $8$ bits, we wrote $\textbf{26}\:1$'s. Remember to use $32$ bits rather than $8$ in your solution. The logic is the same, so the $8$ bit representation was chosen to reduce apparent complexity in the example.
Function Description
Complete the twosCompliment function in the editor below. It should return an integer.
twosCompliment has the following parameter(s):
- a: an integer, the range minimum
- b: an integer, the range maximum
Input Format
The first line contains an integer $\mathbf{T}$, the number of test cases.
Each of the next $\mathbf{T}$ lines contains two space-separated integers, $\boldsymbol{a}$ and $\boldsymbol{b}$.
Constraints
$T\leq1000$
$-2^{31}\leq a\leq b\leq2^{31}-1$
Output Format
For each test case, print the number of $\mbox{I}$'s in the $32$-bit $2$'s complement representation for integers in the inclusive range from $\boldsymbol{a}$ to $\boldsymbol{b}$ on a new line.
Sample Input 0
3
-2 0
-3 4
-1 4
Sample Output 0
63
99
37
Explanation 0
Test case 0
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
31+32+0 = 63
Test case 1
-3 has 31 ones
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
31+31+32+0+1+1+2+1 = 99
Test case 2
-1 has 32 ones
0 has 0 ones
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
32+0+1+1+2+1 = 37
Sample Input 1
4
-5 0
1 7
-6 -3
3 6
Sample Output 1
155
12
122
7
Explanation 1
Test case 0
-5 has 31 ones
-4 has 30 ones
-3 has 31 ones
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
31+30+31+31+32+0 = 155
Test case 1
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
5 has 2 ones
6 has 2 ones
7 has 3 ones
1+1+2+1+2+2+3 = 12
Test case 2
-6 has 30 ones
-5 has 31 ones
-4 has 30 ones
-3 has 31 ones
30+31+30+31 = 122
Test case 3
3 has 2 ones
4 has 1 ones
5 has 2 ones
6 has 2 ones
2+1+2+2 = 7
|
import sys
def pos(z):
h = z + 1
sum = 0
for i in range(33):
a = h // 2**i
sum += a // 2 * 2**i
if a % 2 != 0:
sum += h - a * 2**i
return sum
def neg(z):
sum = 0
h = abs(z)
for i in range(33):
a = h // 2**i
sum += a // 2 * 2**i
if a % 2 == 0:
sum += h - a * 2**i
return sum
def cal(x, y):
if x < 0 and y < 0:
return neg(x) - neg(y + 1)
elif x < 0 and y >= 0:
return neg(x) + pos(y)
else:
return pos(y) - pos(x - 1)
t = int(input().strip())
for a0 in range(t):
x, y = input().strip().split(" ")
x, y = [int(x), int(y)]
result = cal(x, y)
print(result)
|
IMPORT FUNC_DEF ASSIGN VAR BIN_OP VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER ASSIGN VAR BIN_OP VAR BIN_OP NUMBER VAR VAR BIN_OP BIN_OP VAR NUMBER BIN_OP NUMBER VAR IF BIN_OP VAR NUMBER NUMBER VAR BIN_OP VAR BIN_OP VAR BIN_OP NUMBER VAR RETURN VAR FUNC_DEF ASSIGN VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR NUMBER ASSIGN VAR BIN_OP VAR BIN_OP NUMBER VAR VAR BIN_OP BIN_OP VAR NUMBER BIN_OP NUMBER VAR IF BIN_OP VAR NUMBER NUMBER VAR BIN_OP VAR BIN_OP VAR BIN_OP NUMBER VAR RETURN VAR FUNC_DEF IF VAR NUMBER VAR NUMBER RETURN BIN_OP FUNC_CALL VAR VAR FUNC_CALL VAR BIN_OP VAR NUMBER IF VAR NUMBER VAR NUMBER RETURN BIN_OP FUNC_CALL VAR VAR FUNC_CALL VAR VAR RETURN BIN_OP FUNC_CALL VAR VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL FUNC_CALL FUNC_CALL VAR STRING ASSIGN VAR VAR LIST FUNC_CALL VAR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR VAR
|
Understanding $2$'s complement representation is fundamental to learning about Computer Science. It allows us to write negative numbers in binary. The leftmost digit is used as a sign bit. If it is $1$, we have a negative number and it is represented as the two's complement of its absolute value. Let's say you wrote down the $2$'s complement representation for each $32$-bit integer in the inclusive range from $\boldsymbol{a}$ to $\boldsymbol{b}$. How many $1$'s would you write down in all?
For example, using an $8$-bit byte rather than $32$ bit integer, the two's complement of a number can be found by reversing all its bits and adding $1$. The two's complement representations for a few numbers are shown below:
|Number| Representation in
Number Binary Inverse Two's Complement
-3 00000011 11111100 11111101
-2 00000010 11111101 11111110
-1 00000001 11111110 11111111
0 00000000 00000000
1 00000001 00000001
2 00000010 00000010
3 00000011 00000011
To write down that range of numbers' two's complements in $8$ bits, we wrote $\textbf{26}\:1$'s. Remember to use $32$ bits rather than $8$ in your solution. The logic is the same, so the $8$ bit representation was chosen to reduce apparent complexity in the example.
Function Description
Complete the twosCompliment function in the editor below. It should return an integer.
twosCompliment has the following parameter(s):
- a: an integer, the range minimum
- b: an integer, the range maximum
Input Format
The first line contains an integer $\mathbf{T}$, the number of test cases.
Each of the next $\mathbf{T}$ lines contains two space-separated integers, $\boldsymbol{a}$ and $\boldsymbol{b}$.
Constraints
$T\leq1000$
$-2^{31}\leq a\leq b\leq2^{31}-1$
Output Format
For each test case, print the number of $\mbox{I}$'s in the $32$-bit $2$'s complement representation for integers in the inclusive range from $\boldsymbol{a}$ to $\boldsymbol{b}$ on a new line.
Sample Input 0
3
-2 0
-3 4
-1 4
Sample Output 0
63
99
37
Explanation 0
Test case 0
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
31+32+0 = 63
Test case 1
-3 has 31 ones
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
31+31+32+0+1+1+2+1 = 99
Test case 2
-1 has 32 ones
0 has 0 ones
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
32+0+1+1+2+1 = 37
Sample Input 1
4
-5 0
1 7
-6 -3
3 6
Sample Output 1
155
12
122
7
Explanation 1
Test case 0
-5 has 31 ones
-4 has 30 ones
-3 has 31 ones
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
31+30+31+31+32+0 = 155
Test case 1
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
5 has 2 ones
6 has 2 ones
7 has 3 ones
1+1+2+1+2+2+3 = 12
Test case 2
-6 has 30 ones
-5 has 31 ones
-4 has 30 ones
-3 has 31 ones
30+31+30+31 = 122
Test case 3
3 has 2 ones
4 has 1 ones
5 has 2 ones
6 has 2 ones
2+1+2+2 = 7
|
def GetOnes(val, f):
ones = 0
rest = 0
neg = False
if val < 0:
val = -val - 1
neg = True
for i in range(0, 31):
mask = 1 << i
if val & mask:
ones += f[i] + (rest + 1)
rest ^= val & mask
if neg:
ones = 32 * (val + 1) - ones
return ones
f = [(0) for x in range(0, 32)]
f[1] = 1
cum = 1
for i in range(2, 32):
f[i] = 2 * f[i - 1] + 2 ** (i - 1)
tests = int(input().strip())
for q in range(0, tests):
a, b = [int(x) for x in input().split()]
ones = 0
if a <= 0 and b >= 0:
onesA = GetOnes(a, f)
onesB = GetOnes(b, f)
ones = onesA + onesB
elif a < 0 and b < 0:
onesA = GetOnes(a, f)
onesB = GetOnes(b + 1, f)
ones = onesA - onesB
elif a > 0 and b > 0:
onesA = GetOnes(a - 1, f)
onesB = GetOnes(b, f)
ones = onesB - onesA
print(ones)
|
FUNC_DEF ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER IF VAR NUMBER ASSIGN VAR BIN_OP VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER NUMBER ASSIGN VAR BIN_OP NUMBER VAR IF BIN_OP VAR VAR VAR BIN_OP VAR VAR BIN_OP VAR NUMBER VAR BIN_OP VAR VAR IF VAR ASSIGN VAR BIN_OP BIN_OP NUMBER BIN_OP VAR NUMBER VAR RETURN VAR ASSIGN VAR NUMBER VAR FUNC_CALL VAR NUMBER NUMBER ASSIGN VAR NUMBER NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER NUMBER ASSIGN VAR VAR BIN_OP BIN_OP NUMBER VAR BIN_OP VAR NUMBER BIN_OP NUMBER BIN_OP VAR NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL FUNC_CALL VAR FOR VAR FUNC_CALL VAR NUMBER VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER IF VAR NUMBER VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR ASSIGN VAR BIN_OP VAR VAR IF VAR NUMBER VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR ASSIGN VAR BIN_OP VAR VAR IF VAR NUMBER VAR NUMBER ASSIGN VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR ASSIGN VAR FUNC_CALL VAR VAR VAR ASSIGN VAR BIN_OP VAR VAR EXPR FUNC_CALL VAR VAR
|
Understanding $2$'s complement representation is fundamental to learning about Computer Science. It allows us to write negative numbers in binary. The leftmost digit is used as a sign bit. If it is $1$, we have a negative number and it is represented as the two's complement of its absolute value. Let's say you wrote down the $2$'s complement representation for each $32$-bit integer in the inclusive range from $\boldsymbol{a}$ to $\boldsymbol{b}$. How many $1$'s would you write down in all?
For example, using an $8$-bit byte rather than $32$ bit integer, the two's complement of a number can be found by reversing all its bits and adding $1$. The two's complement representations for a few numbers are shown below:
|Number| Representation in
Number Binary Inverse Two's Complement
-3 00000011 11111100 11111101
-2 00000010 11111101 11111110
-1 00000001 11111110 11111111
0 00000000 00000000
1 00000001 00000001
2 00000010 00000010
3 00000011 00000011
To write down that range of numbers' two's complements in $8$ bits, we wrote $\textbf{26}\:1$'s. Remember to use $32$ bits rather than $8$ in your solution. The logic is the same, so the $8$ bit representation was chosen to reduce apparent complexity in the example.
Function Description
Complete the twosCompliment function in the editor below. It should return an integer.
twosCompliment has the following parameter(s):
- a: an integer, the range minimum
- b: an integer, the range maximum
Input Format
The first line contains an integer $\mathbf{T}$, the number of test cases.
Each of the next $\mathbf{T}$ lines contains two space-separated integers, $\boldsymbol{a}$ and $\boldsymbol{b}$.
Constraints
$T\leq1000$
$-2^{31}\leq a\leq b\leq2^{31}-1$
Output Format
For each test case, print the number of $\mbox{I}$'s in the $32$-bit $2$'s complement representation for integers in the inclusive range from $\boldsymbol{a}$ to $\boldsymbol{b}$ on a new line.
Sample Input 0
3
-2 0
-3 4
-1 4
Sample Output 0
63
99
37
Explanation 0
Test case 0
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
31+32+0 = 63
Test case 1
-3 has 31 ones
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
31+31+32+0+1+1+2+1 = 99
Test case 2
-1 has 32 ones
0 has 0 ones
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
32+0+1+1+2+1 = 37
Sample Input 1
4
-5 0
1 7
-6 -3
3 6
Sample Output 1
155
12
122
7
Explanation 1
Test case 0
-5 has 31 ones
-4 has 30 ones
-3 has 31 ones
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
31+30+31+31+32+0 = 155
Test case 1
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
5 has 2 ones
6 has 2 ones
7 has 3 ones
1+1+2+1+2+2+3 = 12
Test case 2
-6 has 30 ones
-5 has 31 ones
-4 has 30 ones
-3 has 31 ones
30+31+30+31 = 122
Test case 3
3 has 2 ones
4 has 1 ones
5 has 2 ones
6 has 2 ones
2+1+2+2 = 7
|
T = int(input())
def memoize(function):
memo = {}
def wrapper(*args):
if args in memo:
return memo[args]
else:
rv = function(*args)
memo[args] = rv
return rv
return wrapper
@memoize
def ones_from_0(A):
if A == 0:
return 0
if A < 0:
return ones_from_0(2**32 - 1) - ones_from_0(2**32 + A - 1)
msb = 1 << A.bit_length() - 1
high_part = A ^ msb
low_part = msb - 1
high_part_cnt = ones_from_0(high_part)
if high_part == low_part:
low_part_cnt = high_part_cnt
else:
low_part_cnt = ones_from_0(low_part)
return high_part_cnt + (high_part + 1) + low_part_cnt
for _ in range(T):
A, B = [int(s) for s in input().split(" ")]
if B >= 0 and A < 0:
print(ones_from_0(B) + ones_from_0(A))
elif B >= 0 and A >= 0:
print(ones_from_0(B) - ones_from_0(max(0, A - 1)))
else:
print(ones_from_0(A) - ones_from_0(B + 1))
|
ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_DEF ASSIGN VAR DICT FUNC_DEF IF VAR VAR RETURN VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR RETURN VAR RETURN VAR FUNC_DEF IF VAR NUMBER RETURN NUMBER IF VAR NUMBER RETURN BIN_OP FUNC_CALL VAR BIN_OP BIN_OP NUMBER NUMBER NUMBER FUNC_CALL VAR BIN_OP BIN_OP BIN_OP NUMBER NUMBER VAR NUMBER ASSIGN VAR BIN_OP NUMBER BIN_OP FUNC_CALL VAR NUMBER ASSIGN VAR BIN_OP VAR VAR ASSIGN VAR BIN_OP VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR IF VAR VAR ASSIGN VAR VAR ASSIGN VAR FUNC_CALL VAR VAR RETURN BIN_OP BIN_OP VAR BIN_OP VAR NUMBER VAR VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR STRING IF VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR FUNC_CALL VAR VAR IF VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR FUNC_CALL VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER EXPR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR FUNC_CALL VAR BIN_OP VAR NUMBER
|
Understanding $2$'s complement representation is fundamental to learning about Computer Science. It allows us to write negative numbers in binary. The leftmost digit is used as a sign bit. If it is $1$, we have a negative number and it is represented as the two's complement of its absolute value. Let's say you wrote down the $2$'s complement representation for each $32$-bit integer in the inclusive range from $\boldsymbol{a}$ to $\boldsymbol{b}$. How many $1$'s would you write down in all?
For example, using an $8$-bit byte rather than $32$ bit integer, the two's complement of a number can be found by reversing all its bits and adding $1$. The two's complement representations for a few numbers are shown below:
|Number| Representation in
Number Binary Inverse Two's Complement
-3 00000011 11111100 11111101
-2 00000010 11111101 11111110
-1 00000001 11111110 11111111
0 00000000 00000000
1 00000001 00000001
2 00000010 00000010
3 00000011 00000011
To write down that range of numbers' two's complements in $8$ bits, we wrote $\textbf{26}\:1$'s. Remember to use $32$ bits rather than $8$ in your solution. The logic is the same, so the $8$ bit representation was chosen to reduce apparent complexity in the example.
Function Description
Complete the twosCompliment function in the editor below. It should return an integer.
twosCompliment has the following parameter(s):
- a: an integer, the range minimum
- b: an integer, the range maximum
Input Format
The first line contains an integer $\mathbf{T}$, the number of test cases.
Each of the next $\mathbf{T}$ lines contains two space-separated integers, $\boldsymbol{a}$ and $\boldsymbol{b}$.
Constraints
$T\leq1000$
$-2^{31}\leq a\leq b\leq2^{31}-1$
Output Format
For each test case, print the number of $\mbox{I}$'s in the $32$-bit $2$'s complement representation for integers in the inclusive range from $\boldsymbol{a}$ to $\boldsymbol{b}$ on a new line.
Sample Input 0
3
-2 0
-3 4
-1 4
Sample Output 0
63
99
37
Explanation 0
Test case 0
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
31+32+0 = 63
Test case 1
-3 has 31 ones
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
31+31+32+0+1+1+2+1 = 99
Test case 2
-1 has 32 ones
0 has 0 ones
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
32+0+1+1+2+1 = 37
Sample Input 1
4
-5 0
1 7
-6 -3
3 6
Sample Output 1
155
12
122
7
Explanation 1
Test case 0
-5 has 31 ones
-4 has 30 ones
-3 has 31 ones
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
31+30+31+31+32+0 = 155
Test case 1
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
5 has 2 ones
6 has 2 ones
7 has 3 ones
1+1+2+1+2+2+3 = 12
Test case 2
-6 has 30 ones
-5 has 31 ones
-4 has 30 ones
-3 has 31 ones
30+31+30+31 = 122
Test case 3
3 has 2 ones
4 has 1 ones
5 has 2 ones
6 has 2 ones
2+1+2+2 = 7
|
def count(a):
if a == 0:
return 0
if a % 2 == 0:
return count(a - 1) + bin(a).count("1")
return (a + 1) // 2 + 2 * count(a // 2)
def solve(a, b, r=32):
if a > 0:
return count(b) - count(a - 1)
if a == 0:
return count(b)
if b > 0:
return count(b) - r * a - count(~a)
if b >= -1:
return r * -a - count(~a)
b += 1
return r * (b - a) + count(~b) - count(~a)
T = int(input())
for _ in range(T):
A, B = map(int, input().split())
print(solve(A, B))
|
FUNC_DEF IF VAR NUMBER RETURN NUMBER IF BIN_OP VAR NUMBER NUMBER RETURN BIN_OP FUNC_CALL VAR BIN_OP VAR NUMBER FUNC_CALL FUNC_CALL VAR VAR STRING RETURN BIN_OP BIN_OP BIN_OP VAR NUMBER NUMBER BIN_OP NUMBER FUNC_CALL VAR BIN_OP VAR NUMBER FUNC_DEF NUMBER IF VAR NUMBER RETURN BIN_OP FUNC_CALL VAR VAR FUNC_CALL VAR BIN_OP VAR NUMBER IF VAR NUMBER RETURN FUNC_CALL VAR VAR IF VAR NUMBER RETURN BIN_OP BIN_OP FUNC_CALL VAR VAR BIN_OP VAR VAR FUNC_CALL VAR VAR IF VAR NUMBER RETURN BIN_OP BIN_OP VAR VAR FUNC_CALL VAR VAR VAR NUMBER RETURN BIN_OP BIN_OP BIN_OP VAR BIN_OP VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR EXPR FUNC_CALL VAR FUNC_CALL VAR VAR VAR
|
Understanding $2$'s complement representation is fundamental to learning about Computer Science. It allows us to write negative numbers in binary. The leftmost digit is used as a sign bit. If it is $1$, we have a negative number and it is represented as the two's complement of its absolute value. Let's say you wrote down the $2$'s complement representation for each $32$-bit integer in the inclusive range from $\boldsymbol{a}$ to $\boldsymbol{b}$. How many $1$'s would you write down in all?
For example, using an $8$-bit byte rather than $32$ bit integer, the two's complement of a number can be found by reversing all its bits and adding $1$. The two's complement representations for a few numbers are shown below:
|Number| Representation in
Number Binary Inverse Two's Complement
-3 00000011 11111100 11111101
-2 00000010 11111101 11111110
-1 00000001 11111110 11111111
0 00000000 00000000
1 00000001 00000001
2 00000010 00000010
3 00000011 00000011
To write down that range of numbers' two's complements in $8$ bits, we wrote $\textbf{26}\:1$'s. Remember to use $32$ bits rather than $8$ in your solution. The logic is the same, so the $8$ bit representation was chosen to reduce apparent complexity in the example.
Function Description
Complete the twosCompliment function in the editor below. It should return an integer.
twosCompliment has the following parameter(s):
- a: an integer, the range minimum
- b: an integer, the range maximum
Input Format
The first line contains an integer $\mathbf{T}$, the number of test cases.
Each of the next $\mathbf{T}$ lines contains two space-separated integers, $\boldsymbol{a}$ and $\boldsymbol{b}$.
Constraints
$T\leq1000$
$-2^{31}\leq a\leq b\leq2^{31}-1$
Output Format
For each test case, print the number of $\mbox{I}$'s in the $32$-bit $2$'s complement representation for integers in the inclusive range from $\boldsymbol{a}$ to $\boldsymbol{b}$ on a new line.
Sample Input 0
3
-2 0
-3 4
-1 4
Sample Output 0
63
99
37
Explanation 0
Test case 0
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
31+32+0 = 63
Test case 1
-3 has 31 ones
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
31+31+32+0+1+1+2+1 = 99
Test case 2
-1 has 32 ones
0 has 0 ones
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
32+0+1+1+2+1 = 37
Sample Input 1
4
-5 0
1 7
-6 -3
3 6
Sample Output 1
155
12
122
7
Explanation 1
Test case 0
-5 has 31 ones
-4 has 30 ones
-3 has 31 ones
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
31+30+31+31+32+0 = 155
Test case 1
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
5 has 2 ones
6 has 2 ones
7 has 3 ones
1+1+2+1+2+2+3 = 12
Test case 2
-6 has 30 ones
-5 has 31 ones
-4 has 30 ones
-3 has 31 ones
30+31+30+31 = 122
Test case 3
3 has 2 ones
4 has 1 ones
5 has 2 ones
6 has 2 ones
2+1+2+2 = 7
|
def count_bits(n):
ret = 0
while n > 1:
if n % 2 == 1:
ret += 1
n = int(n / 2)
return ret + 1
def no_bits(n):
n = int(n)
if n == 0:
return 0
elif n < 0:
n += 1
return (1 - n) * 32 - no_bits(-n)
elif n % 2 == 0:
return count_bits(n) + no_bits(n - 1)
else:
return int((n + 1) / 2) + 2 * no_bits(int(n / 2))
n = int(input().strip())
for i in range(n):
a, b = [int(_) for _ in input().strip().split()]
p = 0
if a == 0:
p = no_bits(b)
elif b == 0:
p = no_bits(a)
elif a == b:
if a > 0:
p = no_bits(b) - no_bits(a - 1)
else:
p = no_bits(b) - no_bits(a + 1)
elif a >= 0 and b > 0:
p = no_bits(b) - no_bits(a - 1)
elif a < 0 and b <= 0:
p = no_bits(a) - no_bits(b + 1)
else:
p = no_bits(a) + no_bits(b)
print(p)
|
FUNC_DEF ASSIGN VAR NUMBER WHILE VAR NUMBER IF BIN_OP VAR NUMBER NUMBER VAR NUMBER ASSIGN VAR FUNC_CALL VAR BIN_OP VAR NUMBER RETURN BIN_OP VAR NUMBER FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR IF VAR NUMBER RETURN NUMBER IF VAR NUMBER VAR NUMBER RETURN BIN_OP BIN_OP BIN_OP NUMBER VAR NUMBER FUNC_CALL VAR VAR IF BIN_OP VAR NUMBER NUMBER RETURN BIN_OP FUNC_CALL VAR VAR FUNC_CALL VAR BIN_OP VAR NUMBER RETURN BIN_OP FUNC_CALL VAR BIN_OP BIN_OP VAR NUMBER NUMBER BIN_OP NUMBER FUNC_CALL VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER IF VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR IF VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR IF VAR VAR IF VAR NUMBER ASSIGN VAR BIN_OP FUNC_CALL VAR VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR BIN_OP FUNC_CALL VAR VAR FUNC_CALL VAR BIN_OP VAR NUMBER IF VAR NUMBER VAR NUMBER ASSIGN VAR BIN_OP FUNC_CALL VAR VAR FUNC_CALL VAR BIN_OP VAR NUMBER IF VAR NUMBER VAR NUMBER ASSIGN VAR BIN_OP FUNC_CALL VAR VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR BIN_OP FUNC_CALL VAR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR
|
Understanding $2$'s complement representation is fundamental to learning about Computer Science. It allows us to write negative numbers in binary. The leftmost digit is used as a sign bit. If it is $1$, we have a negative number and it is represented as the two's complement of its absolute value. Let's say you wrote down the $2$'s complement representation for each $32$-bit integer in the inclusive range from $\boldsymbol{a}$ to $\boldsymbol{b}$. How many $1$'s would you write down in all?
For example, using an $8$-bit byte rather than $32$ bit integer, the two's complement of a number can be found by reversing all its bits and adding $1$. The two's complement representations for a few numbers are shown below:
|Number| Representation in
Number Binary Inverse Two's Complement
-3 00000011 11111100 11111101
-2 00000010 11111101 11111110
-1 00000001 11111110 11111111
0 00000000 00000000
1 00000001 00000001
2 00000010 00000010
3 00000011 00000011
To write down that range of numbers' two's complements in $8$ bits, we wrote $\textbf{26}\:1$'s. Remember to use $32$ bits rather than $8$ in your solution. The logic is the same, so the $8$ bit representation was chosen to reduce apparent complexity in the example.
Function Description
Complete the twosCompliment function in the editor below. It should return an integer.
twosCompliment has the following parameter(s):
- a: an integer, the range minimum
- b: an integer, the range maximum
Input Format
The first line contains an integer $\mathbf{T}$, the number of test cases.
Each of the next $\mathbf{T}$ lines contains two space-separated integers, $\boldsymbol{a}$ and $\boldsymbol{b}$.
Constraints
$T\leq1000$
$-2^{31}\leq a\leq b\leq2^{31}-1$
Output Format
For each test case, print the number of $\mbox{I}$'s in the $32$-bit $2$'s complement representation for integers in the inclusive range from $\boldsymbol{a}$ to $\boldsymbol{b}$ on a new line.
Sample Input 0
3
-2 0
-3 4
-1 4
Sample Output 0
63
99
37
Explanation 0
Test case 0
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
31+32+0 = 63
Test case 1
-3 has 31 ones
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
31+31+32+0+1+1+2+1 = 99
Test case 2
-1 has 32 ones
0 has 0 ones
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
32+0+1+1+2+1 = 37
Sample Input 1
4
-5 0
1 7
-6 -3
3 6
Sample Output 1
155
12
122
7
Explanation 1
Test case 0
-5 has 31 ones
-4 has 30 ones
-3 has 31 ones
-2 has 31 ones
-1 has 32 ones
0 has 0 ones
31+30+31+31+32+0 = 155
Test case 1
1 has 1 ones
2 has 1 ones
3 has 2 ones
4 has 1 ones
5 has 2 ones
6 has 2 ones
7 has 3 ones
1+1+2+1+2+2+3 = 12
Test case 2
-6 has 30 ones
-5 has 31 ones
-4 has 30 ones
-3 has 31 ones
30+31+30+31 = 122
Test case 3
3 has 2 ones
4 has 1 ones
5 has 2 ones
6 has 2 ones
2+1+2+2 = 7
|
bit_width = 32
def ones_counting_to_positive(test):
bit_number = bit_width
mask = 1 << bit_width - 1
bits_left_count = 0
count = 0
while bit_number > 0:
bit_number -= 1
mask_new = mask >> 1
if mask & test == mask:
count += 1 + bit_number * mask_new + bits_left_count * mask
bits_left_count += 1
mask = mask_new
return count
def ones_counting_to_negative(test):
return -bit_width * test - ones_counting_to_positive(-test - 1)
def solve():
limit = int(input().strip())
index = 0
while index < limit:
a, b = input().strip().split(" ")
a, b = [int(a), int(b)]
count = 0
if a == 0:
pass
elif a < 0:
count += ones_counting_to_negative(a)
else:
count -= ones_counting_to_positive(a - 1)
if b == 0 or b == -1:
pass
elif b < 0:
count -= ones_counting_to_negative(b + 1)
else:
count += ones_counting_to_positive(b)
print(count)
index += 1
solve()
|
ASSIGN VAR NUMBER FUNC_DEF ASSIGN VAR VAR ASSIGN VAR BIN_OP NUMBER BIN_OP VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER WHILE VAR NUMBER VAR NUMBER ASSIGN VAR BIN_OP VAR NUMBER IF BIN_OP VAR VAR VAR VAR BIN_OP BIN_OP NUMBER BIN_OP VAR VAR BIN_OP VAR VAR VAR NUMBER ASSIGN VAR VAR RETURN VAR FUNC_DEF RETURN BIN_OP BIN_OP VAR VAR FUNC_CALL VAR BIN_OP VAR NUMBER FUNC_DEF ASSIGN VAR FUNC_CALL VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER WHILE VAR VAR ASSIGN VAR VAR FUNC_CALL FUNC_CALL FUNC_CALL VAR STRING ASSIGN VAR VAR LIST FUNC_CALL VAR VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER IF VAR NUMBER IF VAR NUMBER VAR FUNC_CALL VAR VAR VAR FUNC_CALL VAR BIN_OP VAR NUMBER IF VAR NUMBER VAR NUMBER IF VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR VAR NUMBER EXPR FUNC_CALL VAR
|
Even if you just leave them be, they will fall to pieces all by themselves. So, someone has to protect them, right?
You find yourself playing with Teucer again in the city of Liyue. As you take the eccentric little kid around, you notice something interesting about the structure of the city.
Liyue can be represented as a directed graph containing $n$ nodes. Nodes are labeled from $1$ to $n$. There is a directed edge from node $a$ to node $b$ if and only if $a < b$.
A path between nodes $a$ and $b$ is defined as a sequence of edges such that you can start at $a$, travel along all of these edges in the corresponding direction, and end at $b$. The length of a path is defined by the number of edges. A rainbow path of length $x$ is defined as a path in the graph such that there exists at least 2 distinct colors among the set of $x$ edges.
Teucer's favorite number is $k$. You are curious about the following scenario: If you were to label each edge with a color, what is the minimum number of colors needed to ensure that all paths of length $k$ or longer are rainbow paths?
Teucer wants to surprise his older brother with a map of Liyue. He also wants to know a valid coloring of edges that uses the minimum number of colors. Please help him with this task!
-----Input-----
The only line of input contains two integers $n$ and $k$ ($2 \leq k < n \leq 1000$).
-----Output-----
On the first line, output $c$, the minimum colors you need to satisfy the above requirements.
On the second line, print a valid edge coloring as an array of $\frac{n(n-1)}{2}$ integers ranging from $1$ to $c$. Exactly $c$ distinct colors should exist in the construction. Print the edges in increasing order by the start node first, then by the second node.
For example, if $n=4$, the edge colors will correspond to this order of edges: ($1$, $2$), ($1$, $3$), ($1$, $4$), ($2$, $3$), ($2$, $4$), ($3$, $4$)
-----Examples-----
Input
5 3
Output
2
1 2 2 2 2 2 2 1 1 1
Input
5 2
Output
3
3 2 2 1 2 2 1 3 1 1
Input
8 7
Output
2
2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
Input
3 2
Output
2
1 2 2
-----Note-----
The corresponding construction for the first test case looks like this:
It is impossible to satisfy the constraints with less than $2$ colors.
The corresponding construction for the second test case looks like this:
One can show there exists no construction using less than $3$ colors.
|
n, k = map(int, input().split())
cnt = 0
sum = 1
while sum < n:
sum = sum * k
cnt = cnt + 1
print(cnt)
for i in range(0, n):
for j in range(i + 1, n):
u = i
v = j
ans = 0
while u != v:
u //= k
v //= k
ans = ans + 1
print(ans, end=" ")
|
ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER WHILE VAR VAR ASSIGN VAR BIN_OP VAR VAR ASSIGN VAR BIN_OP VAR NUMBER EXPR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR NUMBER VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR ASSIGN VAR VAR ASSIGN VAR VAR ASSIGN VAR NUMBER WHILE VAR VAR VAR VAR VAR VAR ASSIGN VAR BIN_OP VAR NUMBER EXPR FUNC_CALL VAR VAR STRING
|
Given two numbers: 'left' and 'right' (1 <= 'left' <= 'right' <= 200000000000000)
return sum of all '1' occurencies in binary representations of numbers between 'left' and 'right' (including both)
```
Example:
countOnes 4 7 should return 8, because:
4(dec) = 100(bin), which adds 1 to the result.
5(dec) = 101(bin), which adds 2 to the result.
6(dec) = 110(bin), which adds 2 to the result.
7(dec) = 111(bin), which adds 3 to the result.
So finally result equals 8.
```
WARNING: Segment may contain billion elements, to pass this kata, your solution cannot iterate through all numbers in the segment!
|
def countevenone(left, right, span, maxbincount):
if span == 1:
return bin(left).count("1")
if span == 2:
return bin(right).count("1") + bin(left).count("1")
if span % 2 != 0:
if left % 2 == 0:
adds = span // 2 + bin(right).count("1")
left = left // 2
right = (right - 1) // 2
else:
adds = span // 2 + bin(left).count("1")
left = (left + 1) // 2
right = right // 2
span = span // 2
maxbincount = maxbincount - 1
countones = countevenone(left, right, span, maxbincount) * 2 + adds
else:
if left % 2 == 0:
left = left // 2
right = right // 2
adds = span // 2
span = span // 2
else:
adds = (span - 2) // 2 + bin(right).count("1") + bin(left).count("1")
left = (left + 1) // 2
right = (right - 1) // 2
span = (span - 2) // 2
maxbincount = maxbincount - 1
countones = countevenone(left, right, span, maxbincount) * 2 + adds
return countones
def countOnes(left, right):
span = right - left + 1
maxbincount = len(bin(right).replace("0b", ""))
return countevenone(left, right, span, maxbincount)
|
FUNC_DEF IF VAR NUMBER RETURN FUNC_CALL FUNC_CALL VAR VAR STRING IF VAR NUMBER RETURN BIN_OP FUNC_CALL FUNC_CALL VAR VAR STRING FUNC_CALL FUNC_CALL VAR VAR STRING IF BIN_OP VAR NUMBER NUMBER IF BIN_OP VAR NUMBER NUMBER ASSIGN VAR BIN_OP BIN_OP VAR NUMBER FUNC_CALL FUNC_CALL VAR VAR STRING ASSIGN VAR BIN_OP VAR NUMBER ASSIGN VAR BIN_OP BIN_OP VAR NUMBER NUMBER ASSIGN VAR BIN_OP BIN_OP VAR NUMBER FUNC_CALL FUNC_CALL VAR VAR STRING ASSIGN VAR BIN_OP BIN_OP VAR NUMBER NUMBER ASSIGN VAR BIN_OP VAR NUMBER ASSIGN VAR BIN_OP VAR NUMBER ASSIGN VAR BIN_OP VAR NUMBER ASSIGN VAR BIN_OP BIN_OP FUNC_CALL VAR VAR VAR VAR VAR NUMBER VAR IF BIN_OP VAR NUMBER NUMBER ASSIGN VAR BIN_OP VAR NUMBER ASSIGN VAR BIN_OP VAR NUMBER ASSIGN VAR BIN_OP VAR NUMBER ASSIGN VAR BIN_OP VAR NUMBER ASSIGN VAR BIN_OP BIN_OP BIN_OP BIN_OP VAR NUMBER NUMBER FUNC_CALL FUNC_CALL VAR VAR STRING FUNC_CALL FUNC_CALL VAR VAR STRING ASSIGN VAR BIN_OP BIN_OP VAR NUMBER NUMBER ASSIGN VAR BIN_OP BIN_OP VAR NUMBER NUMBER ASSIGN VAR BIN_OP BIN_OP VAR NUMBER NUMBER ASSIGN VAR BIN_OP VAR NUMBER ASSIGN VAR BIN_OP BIN_OP FUNC_CALL VAR VAR VAR VAR VAR NUMBER VAR RETURN VAR FUNC_DEF ASSIGN VAR BIN_OP BIN_OP VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL FUNC_CALL VAR VAR STRING STRING RETURN FUNC_CALL VAR VAR VAR VAR VAR
|
Given two numbers: 'left' and 'right' (1 <= 'left' <= 'right' <= 200000000000000)
return sum of all '1' occurencies in binary representations of numbers between 'left' and 'right' (including both)
```
Example:
countOnes 4 7 should return 8, because:
4(dec) = 100(bin), which adds 1 to the result.
5(dec) = 101(bin), which adds 2 to the result.
6(dec) = 110(bin), which adds 2 to the result.
7(dec) = 111(bin), which adds 3 to the result.
So finally result equals 8.
```
WARNING: Segment may contain billion elements, to pass this kata, your solution cannot iterate through all numbers in the segment!
|
def countOnes(left, right):
def bindig(number):
ans = 0
g = bin(number)[2:][::-1]
for i in range(len(g)):
if g[i] == "1":
if i == len(g) - 1:
ans += 1 + 2 ** (i - 1) * i
else:
ans += 1 + 2 ** (i - 1) * i + g[i + 1 :].count("1") * 2**i
return ans
return bindig(right) - bindig(left - 1)
|
FUNC_DEF FUNC_DEF ASSIGN VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR IF VAR VAR STRING IF VAR BIN_OP FUNC_CALL VAR VAR NUMBER VAR BIN_OP NUMBER BIN_OP BIN_OP NUMBER BIN_OP VAR NUMBER VAR VAR BIN_OP BIN_OP NUMBER BIN_OP BIN_OP NUMBER BIN_OP VAR NUMBER VAR BIN_OP FUNC_CALL VAR BIN_OP VAR NUMBER STRING BIN_OP NUMBER VAR RETURN VAR RETURN BIN_OP FUNC_CALL VAR VAR FUNC_CALL VAR BIN_OP VAR NUMBER
|
Given two numbers: 'left' and 'right' (1 <= 'left' <= 'right' <= 200000000000000)
return sum of all '1' occurencies in binary representations of numbers between 'left' and 'right' (including both)
```
Example:
countOnes 4 7 should return 8, because:
4(dec) = 100(bin), which adds 1 to the result.
5(dec) = 101(bin), which adds 2 to the result.
6(dec) = 110(bin), which adds 2 to the result.
7(dec) = 111(bin), which adds 3 to the result.
So finally result equals 8.
```
WARNING: Segment may contain billion elements, to pass this kata, your solution cannot iterate through all numbers in the segment!
|
sumOnes = lambda n: (
lambda msb: n and -~n + ~-msb * 2**msb + sumOnes(n - 2 ** -~msb)
)(n.bit_length() - 2)
countOnes = lambda a, b: sumOnes(b) - sumOnes(a - 1)
|
ASSIGN VAR FUNC_CALL VAR BIN_OP BIN_OP VAR BIN_OP VAR BIN_OP NUMBER VAR FUNC_CALL VAR BIN_OP VAR BIN_OP NUMBER VAR BIN_OP FUNC_CALL VAR NUMBER ASSIGN VAR BIN_OP FUNC_CALL VAR VAR FUNC_CALL VAR BIN_OP VAR NUMBER
|
Given two numbers: 'left' and 'right' (1 <= 'left' <= 'right' <= 200000000000000)
return sum of all '1' occurencies in binary representations of numbers between 'left' and 'right' (including both)
```
Example:
countOnes 4 7 should return 8, because:
4(dec) = 100(bin), which adds 1 to the result.
5(dec) = 101(bin), which adds 2 to the result.
6(dec) = 110(bin), which adds 2 to the result.
7(dec) = 111(bin), which adds 3 to the result.
So finally result equals 8.
```
WARNING: Segment may contain billion elements, to pass this kata, your solution cannot iterate through all numbers in the segment!
|
def countOnes(left, right):
def f(n):
c = 0
a = list(reversed(list(bin(n))))
for i, d in enumerate(a):
if d == "1":
c += 1 + 2**i * i / 2 + 2**i * a[i + 1 :].count("1")
return c
return f(right) - f(left - 1)
|
FUNC_DEF FUNC_DEF ASSIGN VAR NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR VAR FOR VAR VAR FUNC_CALL VAR VAR IF VAR STRING VAR BIN_OP BIN_OP NUMBER BIN_OP BIN_OP BIN_OP NUMBER VAR VAR NUMBER BIN_OP BIN_OP NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER STRING RETURN VAR RETURN BIN_OP FUNC_CALL VAR VAR FUNC_CALL VAR BIN_OP VAR NUMBER
|
Given two numbers: 'left' and 'right' (1 <= 'left' <= 'right' <= 200000000000000)
return sum of all '1' occurencies in binary representations of numbers between 'left' and 'right' (including both)
```
Example:
countOnes 4 7 should return 8, because:
4(dec) = 100(bin), which adds 1 to the result.
5(dec) = 101(bin), which adds 2 to the result.
6(dec) = 110(bin), which adds 2 to the result.
7(dec) = 111(bin), which adds 3 to the result.
So finally result equals 8.
```
WARNING: Segment may contain billion elements, to pass this kata, your solution cannot iterate through all numbers in the segment!
|
def countOnes(left, right):
left_binary_digits = count_binary_digits(left)
right_binary_digits = count_binary_digits(right)
right_binary_sum = sum([int(i) for i in str(bin(right))[2:]])
left_position_in_block = left - calculate_starting_digit(left_binary_digits) + 1
right_position_in_block = right - calculate_starting_digit(right_binary_digits) + 1
if left_binary_digits == right_binary_digits:
number_of_ones = (
calculate_ones_in_incomplete_block(
left_binary_digits, left_position_in_block
)
- calculate_ones_in_incomplete_block(
right_binary_digits, right_position_in_block
)
+ right_binary_sum
)
else:
number_of_ones = (
calculate_ones_in_incomplete_block(
left_binary_digits, left_position_in_block
)
+ calculate_multiple_blocks(left_binary_digits + 1, right_binary_digits - 1)
+ calculate_ones_in_incomplete_block(
right_binary_digits, right_position_in_block, True
)
+ right_binary_sum
)
return number_of_ones
def count_binary_digits(number):
return len(str(bin(number))) - 2
def calculate_starting_digit(n_digits):
return sum([pow(2, i - 1) for i in range(1, n_digits)]) + 1
def calculate_ones_in_incomplete_block(n_digits, position, front_part=False):
all_rows = pow(2, n_digits - 1)
upper_ones = 0
last_row = all_rows
result = last_row - position + 1
middle_row = last_row / 2
for i in range(n_digits - 1):
if position <= middle_row:
result += all_rows / 2 - upper_ones
temp = int(last_row)
last_row = middle_row
middle_row -= (temp - middle_row) / 2
else:
result += last_row - position + 1 + (all_rows - last_row) / 2
upper_ones += (last_row - middle_row) / 2
middle_row += (last_row - middle_row) / 2
if front_part:
return all_rows * (1 + 0.5 * (n_digits - 1)) - result
else:
return result
def calculate_multiple_blocks(digits_start, digits_stop):
result = 0
if digits_stop >= digits_start:
for i in range(digits_start, digits_stop + 1):
result += pow(2, i - 1) * (1 + 0.5 * (i - 1))
return result
|
FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER ASSIGN VAR BIN_OP BIN_OP VAR FUNC_CALL VAR VAR NUMBER ASSIGN VAR BIN_OP BIN_OP VAR FUNC_CALL VAR VAR NUMBER IF VAR VAR ASSIGN VAR BIN_OP BIN_OP FUNC_CALL VAR VAR VAR FUNC_CALL VAR VAR VAR VAR ASSIGN VAR BIN_OP BIN_OP BIN_OP FUNC_CALL VAR VAR VAR FUNC_CALL VAR BIN_OP VAR NUMBER BIN_OP VAR NUMBER FUNC_CALL VAR VAR VAR NUMBER VAR RETURN VAR FUNC_DEF RETURN BIN_OP FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER FUNC_DEF RETURN BIN_OP FUNC_CALL VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER VAR FUNC_CALL VAR NUMBER VAR NUMBER FUNC_DEF NUMBER ASSIGN VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR VAR ASSIGN VAR BIN_OP BIN_OP VAR VAR NUMBER ASSIGN VAR BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER IF VAR VAR VAR BIN_OP BIN_OP VAR NUMBER VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR BIN_OP BIN_OP VAR VAR NUMBER VAR BIN_OP BIN_OP BIN_OP VAR VAR NUMBER BIN_OP BIN_OP VAR VAR NUMBER VAR BIN_OP BIN_OP VAR VAR NUMBER VAR BIN_OP BIN_OP VAR VAR NUMBER IF VAR RETURN BIN_OP BIN_OP VAR BIN_OP NUMBER BIN_OP NUMBER BIN_OP VAR NUMBER VAR RETURN VAR FUNC_DEF ASSIGN VAR NUMBER IF VAR VAR FOR VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER VAR BIN_OP FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER BIN_OP NUMBER BIN_OP NUMBER BIN_OP VAR NUMBER RETURN VAR
|
Given two numbers: 'left' and 'right' (1 <= 'left' <= 'right' <= 200000000000000)
return sum of all '1' occurencies in binary representations of numbers between 'left' and 'right' (including both)
```
Example:
countOnes 4 7 should return 8, because:
4(dec) = 100(bin), which adds 1 to the result.
5(dec) = 101(bin), which adds 2 to the result.
6(dec) = 110(bin), which adds 2 to the result.
7(dec) = 111(bin), which adds 3 to the result.
So finally result equals 8.
```
WARNING: Segment may contain billion elements, to pass this kata, your solution cannot iterate through all numbers in the segment!
|
def countOnesFromZero(num):
l = sorted([i for i, v in enumerate(bin(num)[2:][::-1]) if v == "1"], reverse=True)
l.append(0)
return sum(i * 2**v + v * 2 ** (v - 1) for i, v in enumerate(l))
def countOnes(left, right):
return countOnesFromZero(right) - countOnesFromZero(left) + bin(left).count("1")
|
FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER NUMBER VAR STRING NUMBER EXPR FUNC_CALL VAR NUMBER RETURN FUNC_CALL VAR BIN_OP BIN_OP VAR BIN_OP NUMBER VAR BIN_OP VAR BIN_OP NUMBER BIN_OP VAR NUMBER VAR VAR FUNC_CALL VAR VAR FUNC_DEF RETURN BIN_OP BIN_OP FUNC_CALL VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR VAR STRING
|
Read problems statements in [Mandarin Chinese], [Russian], [Vietnamese], and [Bengali] as well.
Chef has a *tasty ingredient* ― an integer $K$. He defines a *tasty matrix* $A$ with $N$ rows (numbered $1$ through $N$) and $M$ columns (numbered $1$ through $M$) as $A_{i, j} = K + i + j$ for each valid $i,j$.
Currently, Chef is busy in the kitchen making this tasty matrix. Help him find the bitwise XOR of all elements of this matrix.
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first and only line of each test case contains three space-separated integers $N$, $M$ and $K$.
------ Output ------
For each test case, print a single line containing one integer ― the bitwise XOR of all elements of the tasty matrix with the given dimensions made with the given special ingredient.
------ Constraints ------
$1 ≤ T ≤ 10^{5}$
$1 ≤ N, M ≤ 2 \cdot 10^{6}$
$1 ≤ K ≤ 10^{9}$
the sum of $N$ over all test cases does not exceed $2 \cdot 10^{6}$
the sum of $M$ over all test cases does not exceed $2 \cdot 10^{6}$
----- Sample Input 1 ------
2
2 2 5
2 3 7
----- Sample Output 1 ------
14
5
----- explanation 1 ------
Example case 1: The matrix is
$$A = \begin{pmatrix}
5 + 1 + 1 & 5 + 1 + 2\\
5 + 2 + 1 & 5 + 2 + 2\end{pmatrix}
= \begin{pmatrix}
7 & 8 \\
8 & 9
\end{pmatrix} \,.$$
The XOR of all its elements is $7 \oplus 8 \oplus 8 \oplus 9 = 14$.
Example case 2: The matrix is
$$A = \begin{pmatrix}
7 + 1 + 1 & 7 + 1 + 2 & 7 + 1 + 3\\
7 + 2 + 1 & 7 + 2 + 2 & 7 + 2 + 3
\end{pmatrix}
= \begin{pmatrix}
9 & 10 & 11\\
10 & 11 & 12
\end{pmatrix} \,.$$
The XOR of all its elements is $9 \oplus 10 \oplus 11 \oplus 10 \oplus 11 \oplus 12 = 5$.
|
for _ in range(int(input())):
n, m, k = map(int, input().split())
sum = 0
for i in range(1, n):
count = min(m, i)
if count % 2 == 0:
pass
else:
sum = sum ^ i + 1 + k
for j in range(1, m + 1):
count1 = min(n, m - j + 1)
if count1 % 2 == 0:
pass
else:
sum = sum ^ j + n + k
print(sum)
|
FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER VAR ASSIGN VAR FUNC_CALL VAR VAR VAR IF BIN_OP VAR NUMBER NUMBER ASSIGN VAR BIN_OP VAR BIN_OP BIN_OP VAR NUMBER VAR FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR BIN_OP BIN_OP VAR VAR NUMBER IF BIN_OP VAR NUMBER NUMBER ASSIGN VAR BIN_OP VAR BIN_OP BIN_OP VAR VAR VAR EXPR FUNC_CALL VAR VAR
|
Read problems statements in [Mandarin Chinese], [Russian], [Vietnamese], and [Bengali] as well.
Chef has a *tasty ingredient* ― an integer $K$. He defines a *tasty matrix* $A$ with $N$ rows (numbered $1$ through $N$) and $M$ columns (numbered $1$ through $M$) as $A_{i, j} = K + i + j$ for each valid $i,j$.
Currently, Chef is busy in the kitchen making this tasty matrix. Help him find the bitwise XOR of all elements of this matrix.
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first and only line of each test case contains three space-separated integers $N$, $M$ and $K$.
------ Output ------
For each test case, print a single line containing one integer ― the bitwise XOR of all elements of the tasty matrix with the given dimensions made with the given special ingredient.
------ Constraints ------
$1 ≤ T ≤ 10^{5}$
$1 ≤ N, M ≤ 2 \cdot 10^{6}$
$1 ≤ K ≤ 10^{9}$
the sum of $N$ over all test cases does not exceed $2 \cdot 10^{6}$
the sum of $M$ over all test cases does not exceed $2 \cdot 10^{6}$
----- Sample Input 1 ------
2
2 2 5
2 3 7
----- Sample Output 1 ------
14
5
----- explanation 1 ------
Example case 1: The matrix is
$$A = \begin{pmatrix}
5 + 1 + 1 & 5 + 1 + 2\\
5 + 2 + 1 & 5 + 2 + 2\end{pmatrix}
= \begin{pmatrix}
7 & 8 \\
8 & 9
\end{pmatrix} \,.$$
The XOR of all its elements is $7 \oplus 8 \oplus 8 \oplus 9 = 14$.
Example case 2: The matrix is
$$A = \begin{pmatrix}
7 + 1 + 1 & 7 + 1 + 2 & 7 + 1 + 3\\
7 + 2 + 1 & 7 + 2 + 2 & 7 + 2 + 3
\end{pmatrix}
= \begin{pmatrix}
9 & 10 & 11\\
10 & 11 & 12
\end{pmatrix} \,.$$
The XOR of all its elements is $9 \oplus 10 \oplus 11 \oplus 10 \oplus 11 \oplus 12 = 5$.
|
t = int(input())
for _ in range(t):
n, m, k = list(map(int, input().split()))
if n > m:
m, n = n, m
res = 0
for i in range(n):
if i % 2 == 0:
res ^= i + k + 2
if i != m - 1:
res ^= n + m - i + k
if n % 2 == 1:
for j in range(1, m - n):
res ^= n + j + k + 1
print(res)
|
ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR IF VAR VAR ASSIGN VAR VAR VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR IF BIN_OP VAR NUMBER NUMBER VAR BIN_OP BIN_OP VAR VAR NUMBER IF VAR BIN_OP VAR NUMBER VAR BIN_OP BIN_OP BIN_OP VAR VAR VAR VAR IF BIN_OP VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR VAR VAR BIN_OP BIN_OP BIN_OP VAR VAR VAR NUMBER EXPR FUNC_CALL VAR VAR
|
Read problems statements in [Mandarin Chinese], [Russian], [Vietnamese], and [Bengali] as well.
Chef has a *tasty ingredient* ― an integer $K$. He defines a *tasty matrix* $A$ with $N$ rows (numbered $1$ through $N$) and $M$ columns (numbered $1$ through $M$) as $A_{i, j} = K + i + j$ for each valid $i,j$.
Currently, Chef is busy in the kitchen making this tasty matrix. Help him find the bitwise XOR of all elements of this matrix.
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first and only line of each test case contains three space-separated integers $N$, $M$ and $K$.
------ Output ------
For each test case, print a single line containing one integer ― the bitwise XOR of all elements of the tasty matrix with the given dimensions made with the given special ingredient.
------ Constraints ------
$1 ≤ T ≤ 10^{5}$
$1 ≤ N, M ≤ 2 \cdot 10^{6}$
$1 ≤ K ≤ 10^{9}$
the sum of $N$ over all test cases does not exceed $2 \cdot 10^{6}$
the sum of $M$ over all test cases does not exceed $2 \cdot 10^{6}$
----- Sample Input 1 ------
2
2 2 5
2 3 7
----- Sample Output 1 ------
14
5
----- explanation 1 ------
Example case 1: The matrix is
$$A = \begin{pmatrix}
5 + 1 + 1 & 5 + 1 + 2\\
5 + 2 + 1 & 5 + 2 + 2\end{pmatrix}
= \begin{pmatrix}
7 & 8 \\
8 & 9
\end{pmatrix} \,.$$
The XOR of all its elements is $7 \oplus 8 \oplus 8 \oplus 9 = 14$.
Example case 2: The matrix is
$$A = \begin{pmatrix}
7 + 1 + 1 & 7 + 1 + 2 & 7 + 1 + 3\\
7 + 2 + 1 & 7 + 2 + 2 & 7 + 2 + 3
\end{pmatrix}
= \begin{pmatrix}
9 & 10 & 11\\
10 & 11 & 12
\end{pmatrix} \,.$$
The XOR of all its elements is $9 \oplus 10 \oplus 11 \oplus 10 \oplus 11 \oplus 12 = 5$.
|
n = int(input())
for i in range(n):
r, c, k = list(map(int, input().split(" ")))
res = 0
for i in range(1, r + 1):
if min(i, c) % 2 != 0:
res = res ^ k + i + 1
for j in range(2, c + 1):
if min(r, c - j + 1) % 2 != 0:
res = res ^ k + r + j
print(res)
|
ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR STRING ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER IF BIN_OP FUNC_CALL VAR VAR VAR NUMBER NUMBER ASSIGN VAR BIN_OP VAR BIN_OP BIN_OP VAR VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER IF BIN_OP FUNC_CALL VAR VAR BIN_OP BIN_OP VAR VAR NUMBER NUMBER NUMBER ASSIGN VAR BIN_OP VAR BIN_OP BIN_OP VAR VAR VAR EXPR FUNC_CALL VAR VAR
|
Read problems statements in [Mandarin Chinese], [Russian], [Vietnamese], and [Bengali] as well.
Chef has a *tasty ingredient* ― an integer $K$. He defines a *tasty matrix* $A$ with $N$ rows (numbered $1$ through $N$) and $M$ columns (numbered $1$ through $M$) as $A_{i, j} = K + i + j$ for each valid $i,j$.
Currently, Chef is busy in the kitchen making this tasty matrix. Help him find the bitwise XOR of all elements of this matrix.
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first and only line of each test case contains three space-separated integers $N$, $M$ and $K$.
------ Output ------
For each test case, print a single line containing one integer ― the bitwise XOR of all elements of the tasty matrix with the given dimensions made with the given special ingredient.
------ Constraints ------
$1 ≤ T ≤ 10^{5}$
$1 ≤ N, M ≤ 2 \cdot 10^{6}$
$1 ≤ K ≤ 10^{9}$
the sum of $N$ over all test cases does not exceed $2 \cdot 10^{6}$
the sum of $M$ over all test cases does not exceed $2 \cdot 10^{6}$
----- Sample Input 1 ------
2
2 2 5
2 3 7
----- Sample Output 1 ------
14
5
----- explanation 1 ------
Example case 1: The matrix is
$$A = \begin{pmatrix}
5 + 1 + 1 & 5 + 1 + 2\\
5 + 2 + 1 & 5 + 2 + 2\end{pmatrix}
= \begin{pmatrix}
7 & 8 \\
8 & 9
\end{pmatrix} \,.$$
The XOR of all its elements is $7 \oplus 8 \oplus 8 \oplus 9 = 14$.
Example case 2: The matrix is
$$A = \begin{pmatrix}
7 + 1 + 1 & 7 + 1 + 2 & 7 + 1 + 3\\
7 + 2 + 1 & 7 + 2 + 2 & 7 + 2 + 3
\end{pmatrix}
= \begin{pmatrix}
9 & 10 & 11\\
10 & 11 & 12
\end{pmatrix} \,.$$
The XOR of all its elements is $9 \oplus 10 \oplus 11 \oplus 10 \oplus 11 \oplus 12 = 5$.
|
def findxor(s):
if s % 4 == 0:
return s
elif s % 4 == 1:
return 1
elif s % 4 == 2:
return s + 1
elif s % 4 == 3:
return 0
for t in range(int(input())):
n, m, k = map(int, input().split())
ans = findxor(k + 1) ^ findxor(k + m + 1)
for i in range(2, n + 1):
ans = ans ^ (findxor(k + i) ^ findxor(k + m + i))
print(ans)
|
FUNC_DEF IF BIN_OP VAR NUMBER NUMBER RETURN VAR IF BIN_OP VAR NUMBER NUMBER RETURN NUMBER IF BIN_OP VAR NUMBER NUMBER RETURN BIN_OP VAR NUMBER IF BIN_OP VAR NUMBER NUMBER RETURN NUMBER FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR BIN_OP FUNC_CALL VAR BIN_OP VAR NUMBER FUNC_CALL VAR BIN_OP BIN_OP VAR VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER ASSIGN VAR BIN_OP VAR BIN_OP FUNC_CALL VAR BIN_OP VAR VAR FUNC_CALL VAR BIN_OP BIN_OP VAR VAR VAR EXPR FUNC_CALL VAR VAR
|
Read problems statements in [Mandarin Chinese], [Russian], [Vietnamese], and [Bengali] as well.
Chef has a *tasty ingredient* ― an integer $K$. He defines a *tasty matrix* $A$ with $N$ rows (numbered $1$ through $N$) and $M$ columns (numbered $1$ through $M$) as $A_{i, j} = K + i + j$ for each valid $i,j$.
Currently, Chef is busy in the kitchen making this tasty matrix. Help him find the bitwise XOR of all elements of this matrix.
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first and only line of each test case contains three space-separated integers $N$, $M$ and $K$.
------ Output ------
For each test case, print a single line containing one integer ― the bitwise XOR of all elements of the tasty matrix with the given dimensions made with the given special ingredient.
------ Constraints ------
$1 ≤ T ≤ 10^{5}$
$1 ≤ N, M ≤ 2 \cdot 10^{6}$
$1 ≤ K ≤ 10^{9}$
the sum of $N$ over all test cases does not exceed $2 \cdot 10^{6}$
the sum of $M$ over all test cases does not exceed $2 \cdot 10^{6}$
----- Sample Input 1 ------
2
2 2 5
2 3 7
----- Sample Output 1 ------
14
5
----- explanation 1 ------
Example case 1: The matrix is
$$A = \begin{pmatrix}
5 + 1 + 1 & 5 + 1 + 2\\
5 + 2 + 1 & 5 + 2 + 2\end{pmatrix}
= \begin{pmatrix}
7 & 8 \\
8 & 9
\end{pmatrix} \,.$$
The XOR of all its elements is $7 \oplus 8 \oplus 8 \oplus 9 = 14$.
Example case 2: The matrix is
$$A = \begin{pmatrix}
7 + 1 + 1 & 7 + 1 + 2 & 7 + 1 + 3\\
7 + 2 + 1 & 7 + 2 + 2 & 7 + 2 + 3
\end{pmatrix}
= \begin{pmatrix}
9 & 10 & 11\\
10 & 11 & 12
\end{pmatrix} \,.$$
The XOR of all its elements is $9 \oplus 10 \oplus 11 \oplus 10 \oplus 11 \oplus 12 = 5$.
|
T = int(input())
def xor(T):
mod = T % 4
if mod == 0:
return T
if mod == 1:
return 1
if mod == 2:
return T + 1
if mod == 3:
return 0
for _ in range(T):
N, M, K = map(int, input().split())
s = xor(1 + K) ^ xor(1 + K + M)
for i in range(2, N + 1):
s = s ^ xor(i + K) ^ xor(i + M + K)
print(s)
|
ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_DEF ASSIGN VAR BIN_OP VAR NUMBER IF VAR NUMBER RETURN VAR IF VAR NUMBER RETURN NUMBER IF VAR NUMBER RETURN BIN_OP VAR NUMBER IF VAR NUMBER RETURN NUMBER FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR BIN_OP FUNC_CALL VAR BIN_OP NUMBER VAR FUNC_CALL VAR BIN_OP BIN_OP NUMBER VAR VAR FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER ASSIGN VAR BIN_OP BIN_OP VAR FUNC_CALL VAR BIN_OP VAR VAR FUNC_CALL VAR BIN_OP BIN_OP VAR VAR VAR EXPR FUNC_CALL VAR VAR
|
Read problems statements in [Mandarin Chinese], [Russian], [Vietnamese], and [Bengali] as well.
Chef has a *tasty ingredient* ― an integer $K$. He defines a *tasty matrix* $A$ with $N$ rows (numbered $1$ through $N$) and $M$ columns (numbered $1$ through $M$) as $A_{i, j} = K + i + j$ for each valid $i,j$.
Currently, Chef is busy in the kitchen making this tasty matrix. Help him find the bitwise XOR of all elements of this matrix.
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first and only line of each test case contains three space-separated integers $N$, $M$ and $K$.
------ Output ------
For each test case, print a single line containing one integer ― the bitwise XOR of all elements of the tasty matrix with the given dimensions made with the given special ingredient.
------ Constraints ------
$1 ≤ T ≤ 10^{5}$
$1 ≤ N, M ≤ 2 \cdot 10^{6}$
$1 ≤ K ≤ 10^{9}$
the sum of $N$ over all test cases does not exceed $2 \cdot 10^{6}$
the sum of $M$ over all test cases does not exceed $2 \cdot 10^{6}$
----- Sample Input 1 ------
2
2 2 5
2 3 7
----- Sample Output 1 ------
14
5
----- explanation 1 ------
Example case 1: The matrix is
$$A = \begin{pmatrix}
5 + 1 + 1 & 5 + 1 + 2\\
5 + 2 + 1 & 5 + 2 + 2\end{pmatrix}
= \begin{pmatrix}
7 & 8 \\
8 & 9
\end{pmatrix} \,.$$
The XOR of all its elements is $7 \oplus 8 \oplus 8 \oplus 9 = 14$.
Example case 2: The matrix is
$$A = \begin{pmatrix}
7 + 1 + 1 & 7 + 1 + 2 & 7 + 1 + 3\\
7 + 2 + 1 & 7 + 2 + 2 & 7 + 2 + 3
\end{pmatrix}
= \begin{pmatrix}
9 & 10 & 11\\
10 & 11 & 12
\end{pmatrix} \,.$$
The XOR of all its elements is $9 \oplus 10 \oplus 11 \oplus 10 \oplus 11 \oplus 12 = 5$.
|
T = int(input())
for i in range(T):
n, m, k = tuple(map(int, input().split()))
res = 0
n_v = 0
if n % 2 == 0:
n_v = n
else:
n_v = n - 1
for i in range(1, m + 1):
res ^= k + n + i
for i in range(1, n_v + 1):
if i % 2 == 1:
res ^= k + i + 1
else:
res ^= k + i + m
print(res)
|
ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER IF BIN_OP VAR NUMBER NUMBER ASSIGN VAR VAR ASSIGN VAR BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER VAR BIN_OP BIN_OP VAR VAR VAR FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER IF BIN_OP VAR NUMBER NUMBER VAR BIN_OP BIN_OP VAR VAR NUMBER VAR BIN_OP BIN_OP VAR VAR VAR EXPR FUNC_CALL VAR VAR
|
Read problems statements in [Mandarin Chinese], [Russian], [Vietnamese], and [Bengali] as well.
Chef has a *tasty ingredient* ― an integer $K$. He defines a *tasty matrix* $A$ with $N$ rows (numbered $1$ through $N$) and $M$ columns (numbered $1$ through $M$) as $A_{i, j} = K + i + j$ for each valid $i,j$.
Currently, Chef is busy in the kitchen making this tasty matrix. Help him find the bitwise XOR of all elements of this matrix.
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first and only line of each test case contains three space-separated integers $N$, $M$ and $K$.
------ Output ------
For each test case, print a single line containing one integer ― the bitwise XOR of all elements of the tasty matrix with the given dimensions made with the given special ingredient.
------ Constraints ------
$1 ≤ T ≤ 10^{5}$
$1 ≤ N, M ≤ 2 \cdot 10^{6}$
$1 ≤ K ≤ 10^{9}$
the sum of $N$ over all test cases does not exceed $2 \cdot 10^{6}$
the sum of $M$ over all test cases does not exceed $2 \cdot 10^{6}$
----- Sample Input 1 ------
2
2 2 5
2 3 7
----- Sample Output 1 ------
14
5
----- explanation 1 ------
Example case 1: The matrix is
$$A = \begin{pmatrix}
5 + 1 + 1 & 5 + 1 + 2\\
5 + 2 + 1 & 5 + 2 + 2\end{pmatrix}
= \begin{pmatrix}
7 & 8 \\
8 & 9
\end{pmatrix} \,.$$
The XOR of all its elements is $7 \oplus 8 \oplus 8 \oplus 9 = 14$.
Example case 2: The matrix is
$$A = \begin{pmatrix}
7 + 1 + 1 & 7 + 1 + 2 & 7 + 1 + 3\\
7 + 2 + 1 & 7 + 2 + 2 & 7 + 2 + 3
\end{pmatrix}
= \begin{pmatrix}
9 & 10 & 11\\
10 & 11 & 12
\end{pmatrix} \,.$$
The XOR of all its elements is $9 \oplus 10 \oplus 11 \oplus 10 \oplus 11 \oplus 12 = 5$.
|
for _ in range(int(input())):
n, m, k = map(int, input().split())
ans = 0
if n == 1 or m == 1:
for i in range(max(n, m)):
ans ^= k + 2 + i
else:
for i in range((n + m) // 2):
if i < min(n, m):
if i % 2 == 0:
ans ^= k + i + 2
ans ^= k + n + m - i
elif min(n, m) % 2 == 1:
ans ^= k + i + 2
ans ^= k + n + m - i
if (n + m) % 2 == 0 and max(n, m) % 2 == 1:
ans ^= k + (n + m) // 2 + 1
print(ans)
|
FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER IF VAR NUMBER VAR NUMBER FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR VAR VAR BIN_OP BIN_OP VAR NUMBER VAR FOR VAR FUNC_CALL VAR BIN_OP BIN_OP VAR VAR NUMBER IF VAR FUNC_CALL VAR VAR VAR IF BIN_OP VAR NUMBER NUMBER VAR BIN_OP BIN_OP VAR VAR NUMBER VAR BIN_OP BIN_OP BIN_OP VAR VAR VAR VAR IF BIN_OP FUNC_CALL VAR VAR VAR NUMBER NUMBER VAR BIN_OP BIN_OP VAR VAR NUMBER VAR BIN_OP BIN_OP BIN_OP VAR VAR VAR VAR IF BIN_OP BIN_OP VAR VAR NUMBER NUMBER BIN_OP FUNC_CALL VAR VAR VAR NUMBER NUMBER VAR BIN_OP BIN_OP VAR BIN_OP BIN_OP VAR VAR NUMBER NUMBER EXPR FUNC_CALL VAR VAR
|
Read problems statements in [Mandarin Chinese], [Russian], [Vietnamese], and [Bengali] as well.
Chef has a *tasty ingredient* ― an integer $K$. He defines a *tasty matrix* $A$ with $N$ rows (numbered $1$ through $N$) and $M$ columns (numbered $1$ through $M$) as $A_{i, j} = K + i + j$ for each valid $i,j$.
Currently, Chef is busy in the kitchen making this tasty matrix. Help him find the bitwise XOR of all elements of this matrix.
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first and only line of each test case contains three space-separated integers $N$, $M$ and $K$.
------ Output ------
For each test case, print a single line containing one integer ― the bitwise XOR of all elements of the tasty matrix with the given dimensions made with the given special ingredient.
------ Constraints ------
$1 ≤ T ≤ 10^{5}$
$1 ≤ N, M ≤ 2 \cdot 10^{6}$
$1 ≤ K ≤ 10^{9}$
the sum of $N$ over all test cases does not exceed $2 \cdot 10^{6}$
the sum of $M$ over all test cases does not exceed $2 \cdot 10^{6}$
----- Sample Input 1 ------
2
2 2 5
2 3 7
----- Sample Output 1 ------
14
5
----- explanation 1 ------
Example case 1: The matrix is
$$A = \begin{pmatrix}
5 + 1 + 1 & 5 + 1 + 2\\
5 + 2 + 1 & 5 + 2 + 2\end{pmatrix}
= \begin{pmatrix}
7 & 8 \\
8 & 9
\end{pmatrix} \,.$$
The XOR of all its elements is $7 \oplus 8 \oplus 8 \oplus 9 = 14$.
Example case 2: The matrix is
$$A = \begin{pmatrix}
7 + 1 + 1 & 7 + 1 + 2 & 7 + 1 + 3\\
7 + 2 + 1 & 7 + 2 + 2 & 7 + 2 + 3
\end{pmatrix}
= \begin{pmatrix}
9 & 10 & 11\\
10 & 11 & 12
\end{pmatrix} \,.$$
The XOR of all its elements is $9 \oplus 10 \oplus 11 \oplus 10 \oplus 11 \oplus 12 = 5$.
|
import sys
intinp = lambda: int(input())
def listinp(func=int):
return list(map(func, input().split()))
def nsepline(n, func=str):
return [func(input()) for _ in range(n)]
def printlist(li, glue=" "):
return glue.join(list(map(str, li)))
def fop(s, end="\n"):
sys.stdout.write(str(s) + end)
def fip():
return sys.stdin.readline().strip()
fintinp = lambda: int(fip())
def flistinp(func=int):
return list(map(func, fip().split()))
def fnsepline(n, func=str):
return [func(fip()) for _ in range(n)]
def inDifAr(a):
d = a[0:1] + [0] * len(a)
for i in range(1, len(a)):
d[i] = a[i] - a[i - 1]
return d
def update(l, r, x, d):
d[l] += x
d[r + 1] -= x
def updatedArr(a, d):
a[0] = d[0]
for i in range(1, len(a)):
a[i] = d[i] + a[i - 1]
test_cases = fintinp()
for _ in range(test_cases):
n, m, k = flistinp()
l = [0] * (n + m + 5)
D = inDifAr(l)
for i in range(n):
update(2 + i, 1 + i + m, 1, D)
updatedArr(l, D)
ans = 0
for i in range(2, n + m + 1):
if l[i] % 2 == 1:
ans ^= i + k
print(ans)
|
IMPORT ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_DEF VAR RETURN FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR FUNC_DEF VAR RETURN FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR FUNC_DEF STRING RETURN FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR VAR VAR FUNC_DEF STRING EXPR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR VAR FUNC_DEF RETURN FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_DEF VAR RETURN FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR FUNC_DEF VAR RETURN FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR FUNC_DEF ASSIGN VAR BIN_OP VAR NUMBER NUMBER BIN_OP LIST NUMBER FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR NUMBER FUNC_CALL VAR VAR ASSIGN VAR VAR BIN_OP VAR VAR VAR BIN_OP VAR NUMBER RETURN VAR FUNC_DEF VAR VAR VAR VAR BIN_OP VAR NUMBER VAR FUNC_DEF ASSIGN VAR NUMBER VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER FUNC_CALL VAR VAR ASSIGN VAR VAR BIN_OP VAR VAR VAR BIN_OP VAR NUMBER ASSIGN VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR FUNC_CALL VAR ASSIGN VAR BIN_OP LIST NUMBER BIN_OP BIN_OP VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR BIN_OP NUMBER VAR BIN_OP BIN_OP NUMBER VAR VAR NUMBER VAR EXPR FUNC_CALL VAR VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP BIN_OP VAR VAR NUMBER IF BIN_OP VAR VAR NUMBER NUMBER VAR BIN_OP VAR VAR EXPR FUNC_CALL VAR VAR
|
Read problems statements in [Mandarin Chinese], [Russian], [Vietnamese], and [Bengali] as well.
Chef has a *tasty ingredient* ― an integer $K$. He defines a *tasty matrix* $A$ with $N$ rows (numbered $1$ through $N$) and $M$ columns (numbered $1$ through $M$) as $A_{i, j} = K + i + j$ for each valid $i,j$.
Currently, Chef is busy in the kitchen making this tasty matrix. Help him find the bitwise XOR of all elements of this matrix.
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first and only line of each test case contains three space-separated integers $N$, $M$ and $K$.
------ Output ------
For each test case, print a single line containing one integer ― the bitwise XOR of all elements of the tasty matrix with the given dimensions made with the given special ingredient.
------ Constraints ------
$1 ≤ T ≤ 10^{5}$
$1 ≤ N, M ≤ 2 \cdot 10^{6}$
$1 ≤ K ≤ 10^{9}$
the sum of $N$ over all test cases does not exceed $2 \cdot 10^{6}$
the sum of $M$ over all test cases does not exceed $2 \cdot 10^{6}$
----- Sample Input 1 ------
2
2 2 5
2 3 7
----- Sample Output 1 ------
14
5
----- explanation 1 ------
Example case 1: The matrix is
$$A = \begin{pmatrix}
5 + 1 + 1 & 5 + 1 + 2\\
5 + 2 + 1 & 5 + 2 + 2\end{pmatrix}
= \begin{pmatrix}
7 & 8 \\
8 & 9
\end{pmatrix} \,.$$
The XOR of all its elements is $7 \oplus 8 \oplus 8 \oplus 9 = 14$.
Example case 2: The matrix is
$$A = \begin{pmatrix}
7 + 1 + 1 & 7 + 1 + 2 & 7 + 1 + 3\\
7 + 2 + 1 & 7 + 2 + 2 & 7 + 2 + 3
\end{pmatrix}
= \begin{pmatrix}
9 & 10 & 11\\
10 & 11 & 12
\end{pmatrix} \,.$$
The XOR of all its elements is $9 \oplus 10 \oplus 11 \oplus 10 \oplus 11 \oplus 12 = 5$.
|
def solve(n, m, k):
res = 0
for i in range(1, n + 1):
if min(i, m) % 2 == 1:
res = res ^ i + 1 + k
for i in range(2, m + 1):
if min(n, m - i + 1) % 2 == 1:
res = res ^ i + n + k
return res
t = int(input())
for i in range(t):
n, m, k = map(int, input().split())
ans = solve(n, m, k)
print(ans)
|
FUNC_DEF ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER IF BIN_OP FUNC_CALL VAR VAR VAR NUMBER NUMBER ASSIGN VAR BIN_OP VAR BIN_OP BIN_OP VAR NUMBER VAR FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER IF BIN_OP FUNC_CALL VAR VAR BIN_OP BIN_OP VAR VAR NUMBER NUMBER NUMBER ASSIGN VAR BIN_OP VAR BIN_OP BIN_OP VAR VAR VAR RETURN VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR EXPR FUNC_CALL VAR VAR
|
Read problems statements in [Mandarin Chinese], [Russian], [Vietnamese], and [Bengali] as well.
Chef has a *tasty ingredient* ― an integer $K$. He defines a *tasty matrix* $A$ with $N$ rows (numbered $1$ through $N$) and $M$ columns (numbered $1$ through $M$) as $A_{i, j} = K + i + j$ for each valid $i,j$.
Currently, Chef is busy in the kitchen making this tasty matrix. Help him find the bitwise XOR of all elements of this matrix.
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first and only line of each test case contains three space-separated integers $N$, $M$ and $K$.
------ Output ------
For each test case, print a single line containing one integer ― the bitwise XOR of all elements of the tasty matrix with the given dimensions made with the given special ingredient.
------ Constraints ------
$1 ≤ T ≤ 10^{5}$
$1 ≤ N, M ≤ 2 \cdot 10^{6}$
$1 ≤ K ≤ 10^{9}$
the sum of $N$ over all test cases does not exceed $2 \cdot 10^{6}$
the sum of $M$ over all test cases does not exceed $2 \cdot 10^{6}$
----- Sample Input 1 ------
2
2 2 5
2 3 7
----- Sample Output 1 ------
14
5
----- explanation 1 ------
Example case 1: The matrix is
$$A = \begin{pmatrix}
5 + 1 + 1 & 5 + 1 + 2\\
5 + 2 + 1 & 5 + 2 + 2\end{pmatrix}
= \begin{pmatrix}
7 & 8 \\
8 & 9
\end{pmatrix} \,.$$
The XOR of all its elements is $7 \oplus 8 \oplus 8 \oplus 9 = 14$.
Example case 2: The matrix is
$$A = \begin{pmatrix}
7 + 1 + 1 & 7 + 1 + 2 & 7 + 1 + 3\\
7 + 2 + 1 & 7 + 2 + 2 & 7 + 2 + 3
\end{pmatrix}
= \begin{pmatrix}
9 & 10 & 11\\
10 & 11 & 12
\end{pmatrix} \,.$$
The XOR of all its elements is $9 \oplus 10 \oplus 11 \oplus 10 \oplus 11 \oplus 12 = 5$.
|
for _ in range(int(input())):
n, m, k = map(int, input().split())
x = k + 2
y = k + n + m
sum1 = 0
for i in range(1, n + 1):
if min(i, m) % 2 != 0:
sum1 ^= k + i + 1
for i in range(2, m + 1):
if min(n, m - i + 1) % 2 != 0:
sum1 ^= k + n + i
print(sum1)
|
FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR BIN_OP VAR NUMBER ASSIGN VAR BIN_OP BIN_OP VAR VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER IF BIN_OP FUNC_CALL VAR VAR VAR NUMBER NUMBER VAR BIN_OP BIN_OP VAR VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER IF BIN_OP FUNC_CALL VAR VAR BIN_OP BIN_OP VAR VAR NUMBER NUMBER NUMBER VAR BIN_OP BIN_OP VAR VAR VAR EXPR FUNC_CALL VAR VAR
|
Read problems statements in [Mandarin Chinese], [Russian], [Vietnamese], and [Bengali] as well.
Chef has a *tasty ingredient* ― an integer $K$. He defines a *tasty matrix* $A$ with $N$ rows (numbered $1$ through $N$) and $M$ columns (numbered $1$ through $M$) as $A_{i, j} = K + i + j$ for each valid $i,j$.
Currently, Chef is busy in the kitchen making this tasty matrix. Help him find the bitwise XOR of all elements of this matrix.
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first and only line of each test case contains three space-separated integers $N$, $M$ and $K$.
------ Output ------
For each test case, print a single line containing one integer ― the bitwise XOR of all elements of the tasty matrix with the given dimensions made with the given special ingredient.
------ Constraints ------
$1 ≤ T ≤ 10^{5}$
$1 ≤ N, M ≤ 2 \cdot 10^{6}$
$1 ≤ K ≤ 10^{9}$
the sum of $N$ over all test cases does not exceed $2 \cdot 10^{6}$
the sum of $M$ over all test cases does not exceed $2 \cdot 10^{6}$
----- Sample Input 1 ------
2
2 2 5
2 3 7
----- Sample Output 1 ------
14
5
----- explanation 1 ------
Example case 1: The matrix is
$$A = \begin{pmatrix}
5 + 1 + 1 & 5 + 1 + 2\\
5 + 2 + 1 & 5 + 2 + 2\end{pmatrix}
= \begin{pmatrix}
7 & 8 \\
8 & 9
\end{pmatrix} \,.$$
The XOR of all its elements is $7 \oplus 8 \oplus 8 \oplus 9 = 14$.
Example case 2: The matrix is
$$A = \begin{pmatrix}
7 + 1 + 1 & 7 + 1 + 2 & 7 + 1 + 3\\
7 + 2 + 1 & 7 + 2 + 2 & 7 + 2 + 3
\end{pmatrix}
= \begin{pmatrix}
9 & 10 & 11\\
10 & 11 & 12
\end{pmatrix} \,.$$
The XOR of all its elements is $9 \oplus 10 \oplus 11 \oplus 10 \oplus 11 \oplus 12 = 5$.
|
for t in range(int(input())):
nr, nc, K = map(int, input().split())
xor = 0
min_rc = min(nr, nc)
counts = [min_rc] * (nr + nc - 1)
for i in range(min_rc):
counts[i] = counts[-(i + 1)] = i + 1
for i_plus_j, count in zip(range(2, nc + nr + 1), counts):
if count % 2 != 0:
xor ^= K + i_plus_j
print(xor)
|
FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR ASSIGN VAR BIN_OP LIST VAR BIN_OP BIN_OP VAR VAR NUMBER FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR BIN_OP VAR NUMBER BIN_OP VAR NUMBER FOR VAR VAR FUNC_CALL VAR FUNC_CALL VAR NUMBER BIN_OP BIN_OP VAR VAR NUMBER VAR IF BIN_OP VAR NUMBER NUMBER VAR BIN_OP VAR VAR EXPR FUNC_CALL VAR VAR
|
Read problems statements in [Mandarin Chinese], [Russian], [Vietnamese], and [Bengali] as well.
Chef has a *tasty ingredient* ― an integer $K$. He defines a *tasty matrix* $A$ with $N$ rows (numbered $1$ through $N$) and $M$ columns (numbered $1$ through $M$) as $A_{i, j} = K + i + j$ for each valid $i,j$.
Currently, Chef is busy in the kitchen making this tasty matrix. Help him find the bitwise XOR of all elements of this matrix.
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first and only line of each test case contains three space-separated integers $N$, $M$ and $K$.
------ Output ------
For each test case, print a single line containing one integer ― the bitwise XOR of all elements of the tasty matrix with the given dimensions made with the given special ingredient.
------ Constraints ------
$1 ≤ T ≤ 10^{5}$
$1 ≤ N, M ≤ 2 \cdot 10^{6}$
$1 ≤ K ≤ 10^{9}$
the sum of $N$ over all test cases does not exceed $2 \cdot 10^{6}$
the sum of $M$ over all test cases does not exceed $2 \cdot 10^{6}$
----- Sample Input 1 ------
2
2 2 5
2 3 7
----- Sample Output 1 ------
14
5
----- explanation 1 ------
Example case 1: The matrix is
$$A = \begin{pmatrix}
5 + 1 + 1 & 5 + 1 + 2\\
5 + 2 + 1 & 5 + 2 + 2\end{pmatrix}
= \begin{pmatrix}
7 & 8 \\
8 & 9
\end{pmatrix} \,.$$
The XOR of all its elements is $7 \oplus 8 \oplus 8 \oplus 9 = 14$.
Example case 2: The matrix is
$$A = \begin{pmatrix}
7 + 1 + 1 & 7 + 1 + 2 & 7 + 1 + 3\\
7 + 2 + 1 & 7 + 2 + 2 & 7 + 2 + 3
\end{pmatrix}
= \begin{pmatrix}
9 & 10 & 11\\
10 & 11 & 12
\end{pmatrix} \,.$$
The XOR of all its elements is $9 \oplus 10 \oplus 11 \oplus 10 \oplus 11 \oplus 12 = 5$.
|
T = int(input())
def solve(N, M, K):
if N > M:
N, M = M, N
ans = 0
for k1 in range(2, N + M + 1):
if (min(k1 - 1, N) - max(1, k1 - M) + 1) % 2:
ans = ans ^ k1 + K
return ans
for _ in range(T):
N, M, K = [int(s) for s in input().split()]
print(solve(N, M, K))
|
ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_DEF IF VAR VAR ASSIGN VAR VAR VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP BIN_OP VAR VAR NUMBER IF BIN_OP BIN_OP BIN_OP FUNC_CALL VAR BIN_OP VAR NUMBER VAR FUNC_CALL VAR NUMBER BIN_OP VAR VAR NUMBER NUMBER ASSIGN VAR BIN_OP VAR BIN_OP VAR VAR RETURN VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR EXPR FUNC_CALL VAR FUNC_CALL VAR VAR VAR VAR
|
Read problems statements in [Mandarin Chinese], [Russian], [Vietnamese], and [Bengali] as well.
Chef has a *tasty ingredient* ― an integer $K$. He defines a *tasty matrix* $A$ with $N$ rows (numbered $1$ through $N$) and $M$ columns (numbered $1$ through $M$) as $A_{i, j} = K + i + j$ for each valid $i,j$.
Currently, Chef is busy in the kitchen making this tasty matrix. Help him find the bitwise XOR of all elements of this matrix.
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first and only line of each test case contains three space-separated integers $N$, $M$ and $K$.
------ Output ------
For each test case, print a single line containing one integer ― the bitwise XOR of all elements of the tasty matrix with the given dimensions made with the given special ingredient.
------ Constraints ------
$1 ≤ T ≤ 10^{5}$
$1 ≤ N, M ≤ 2 \cdot 10^{6}$
$1 ≤ K ≤ 10^{9}$
the sum of $N$ over all test cases does not exceed $2 \cdot 10^{6}$
the sum of $M$ over all test cases does not exceed $2 \cdot 10^{6}$
----- Sample Input 1 ------
2
2 2 5
2 3 7
----- Sample Output 1 ------
14
5
----- explanation 1 ------
Example case 1: The matrix is
$$A = \begin{pmatrix}
5 + 1 + 1 & 5 + 1 + 2\\
5 + 2 + 1 & 5 + 2 + 2\end{pmatrix}
= \begin{pmatrix}
7 & 8 \\
8 & 9
\end{pmatrix} \,.$$
The XOR of all its elements is $7 \oplus 8 \oplus 8 \oplus 9 = 14$.
Example case 2: The matrix is
$$A = \begin{pmatrix}
7 + 1 + 1 & 7 + 1 + 2 & 7 + 1 + 3\\
7 + 2 + 1 & 7 + 2 + 2 & 7 + 2 + 3
\end{pmatrix}
= \begin{pmatrix}
9 & 10 & 11\\
10 & 11 & 12
\end{pmatrix} \,.$$
The XOR of all its elements is $9 \oplus 10 \oplus 11 \oplus 10 \oplus 11 \oplus 12 = 5$.
|
t = int(input())
r = []
for i in range(t):
n, m, k = map(int, input().split())
rs = 0
xmax = max(n, m)
xmin = min(n, m)
for x in range(1, xmin // 2 + 1):
rs = rs ^ 2 * x + k
rs = rs ^ n + m - 2 * x + 2 + k
if xmin % 2 == 1:
for y in range(xmin // 2 + 1, xmax - xmin // 2 + 1):
rs = rs ^ xmin // 2 + 1 + y + k
r.append(rs)
for j in r:
print(j)
|
ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR FOR VAR FUNC_CALL VAR NUMBER BIN_OP BIN_OP VAR NUMBER NUMBER ASSIGN VAR BIN_OP VAR BIN_OP BIN_OP NUMBER VAR VAR ASSIGN VAR BIN_OP VAR BIN_OP BIN_OP BIN_OP BIN_OP VAR VAR BIN_OP NUMBER VAR NUMBER VAR IF BIN_OP VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR BIN_OP BIN_OP VAR NUMBER NUMBER BIN_OP BIN_OP VAR BIN_OP VAR NUMBER NUMBER ASSIGN VAR BIN_OP VAR BIN_OP BIN_OP BIN_OP BIN_OP VAR NUMBER NUMBER VAR VAR EXPR FUNC_CALL VAR VAR FOR VAR VAR EXPR FUNC_CALL VAR VAR
|
Read problems statements in [Mandarin Chinese], [Russian], [Vietnamese], and [Bengali] as well.
Chef has a *tasty ingredient* ― an integer $K$. He defines a *tasty matrix* $A$ with $N$ rows (numbered $1$ through $N$) and $M$ columns (numbered $1$ through $M$) as $A_{i, j} = K + i + j$ for each valid $i,j$.
Currently, Chef is busy in the kitchen making this tasty matrix. Help him find the bitwise XOR of all elements of this matrix.
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first and only line of each test case contains three space-separated integers $N$, $M$ and $K$.
------ Output ------
For each test case, print a single line containing one integer ― the bitwise XOR of all elements of the tasty matrix with the given dimensions made with the given special ingredient.
------ Constraints ------
$1 ≤ T ≤ 10^{5}$
$1 ≤ N, M ≤ 2 \cdot 10^{6}$
$1 ≤ K ≤ 10^{9}$
the sum of $N$ over all test cases does not exceed $2 \cdot 10^{6}$
the sum of $M$ over all test cases does not exceed $2 \cdot 10^{6}$
----- Sample Input 1 ------
2
2 2 5
2 3 7
----- Sample Output 1 ------
14
5
----- explanation 1 ------
Example case 1: The matrix is
$$A = \begin{pmatrix}
5 + 1 + 1 & 5 + 1 + 2\\
5 + 2 + 1 & 5 + 2 + 2\end{pmatrix}
= \begin{pmatrix}
7 & 8 \\
8 & 9
\end{pmatrix} \,.$$
The XOR of all its elements is $7 \oplus 8 \oplus 8 \oplus 9 = 14$.
Example case 2: The matrix is
$$A = \begin{pmatrix}
7 + 1 + 1 & 7 + 1 + 2 & 7 + 1 + 3\\
7 + 2 + 1 & 7 + 2 + 2 & 7 + 2 + 3
\end{pmatrix}
= \begin{pmatrix}
9 & 10 & 11\\
10 & 11 & 12
\end{pmatrix} \,.$$
The XOR of all its elements is $9 \oplus 10 \oplus 11 \oplus 10 \oplus 11 \oplus 12 = 5$.
|
import sys
input = sys.stdin.readline
R = lambda: map(int, input().split())
I = lambda: int(input())
S = lambda: input().rstrip("\n")
L = lambda: list(R())
def solve():
n, m, k = R()
if m > n:
n, m = m, n
ans = 0
for i in range(1, n + 1):
t = min(i, m)
if t & 1:
ans ^= i + k + 1
for i in range(1, m):
t = m - i
if t & 1:
ans ^= n + i + 1 + k
print(ans)
for _ in range(I()):
solve()
|
IMPORT ASSIGN VAR VAR ASSIGN VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL FUNC_CALL VAR STRING ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_DEF ASSIGN VAR VAR VAR FUNC_CALL VAR IF VAR VAR ASSIGN VAR VAR VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR IF BIN_OP VAR NUMBER VAR BIN_OP BIN_OP VAR VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER VAR ASSIGN VAR BIN_OP VAR VAR IF BIN_OP VAR NUMBER VAR BIN_OP BIN_OP BIN_OP VAR VAR NUMBER VAR EXPR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR FUNC_CALL VAR EXPR FUNC_CALL VAR
|
Read problems statements in [Mandarin Chinese], [Russian], [Vietnamese], and [Bengali] as well.
Chef has a *tasty ingredient* ― an integer $K$. He defines a *tasty matrix* $A$ with $N$ rows (numbered $1$ through $N$) and $M$ columns (numbered $1$ through $M$) as $A_{i, j} = K + i + j$ for each valid $i,j$.
Currently, Chef is busy in the kitchen making this tasty matrix. Help him find the bitwise XOR of all elements of this matrix.
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first and only line of each test case contains three space-separated integers $N$, $M$ and $K$.
------ Output ------
For each test case, print a single line containing one integer ― the bitwise XOR of all elements of the tasty matrix with the given dimensions made with the given special ingredient.
------ Constraints ------
$1 ≤ T ≤ 10^{5}$
$1 ≤ N, M ≤ 2 \cdot 10^{6}$
$1 ≤ K ≤ 10^{9}$
the sum of $N$ over all test cases does not exceed $2 \cdot 10^{6}$
the sum of $M$ over all test cases does not exceed $2 \cdot 10^{6}$
----- Sample Input 1 ------
2
2 2 5
2 3 7
----- Sample Output 1 ------
14
5
----- explanation 1 ------
Example case 1: The matrix is
$$A = \begin{pmatrix}
5 + 1 + 1 & 5 + 1 + 2\\
5 + 2 + 1 & 5 + 2 + 2\end{pmatrix}
= \begin{pmatrix}
7 & 8 \\
8 & 9
\end{pmatrix} \,.$$
The XOR of all its elements is $7 \oplus 8 \oplus 8 \oplus 9 = 14$.
Example case 2: The matrix is
$$A = \begin{pmatrix}
7 + 1 + 1 & 7 + 1 + 2 & 7 + 1 + 3\\
7 + 2 + 1 & 7 + 2 + 2 & 7 + 2 + 3
\end{pmatrix}
= \begin{pmatrix}
9 & 10 & 11\\
10 & 11 & 12
\end{pmatrix} \,.$$
The XOR of all its elements is $9 \oplus 10 \oplus 11 \oplus 10 \oplus 11 \oplus 12 = 5$.
|
def solve(n, m, k):
res = 0
for i in range(1, n):
if i % 2 == 0:
res ^= k + i + m
else:
res ^= k + i + 1
if n % 2 == 0:
res ^= k + n + m
else:
for j in range(1, m + 1):
res ^= k + j + n
return res
def main():
for _ in range(int(input())):
n, m, k = map(int, input().split())
ans = solve(n, m, k)
print(ans)
main()
|
FUNC_DEF ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER VAR IF BIN_OP VAR NUMBER NUMBER VAR BIN_OP BIN_OP VAR VAR VAR VAR BIN_OP BIN_OP VAR VAR NUMBER IF BIN_OP VAR NUMBER NUMBER VAR BIN_OP BIN_OP VAR VAR VAR FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER VAR BIN_OP BIN_OP VAR VAR VAR RETURN VAR FUNC_DEF FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR EXPR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR
|
Read problems statements in [Mandarin Chinese], [Russian], [Vietnamese], and [Bengali] as well.
Chef has a *tasty ingredient* ― an integer $K$. He defines a *tasty matrix* $A$ with $N$ rows (numbered $1$ through $N$) and $M$ columns (numbered $1$ through $M$) as $A_{i, j} = K + i + j$ for each valid $i,j$.
Currently, Chef is busy in the kitchen making this tasty matrix. Help him find the bitwise XOR of all elements of this matrix.
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first and only line of each test case contains three space-separated integers $N$, $M$ and $K$.
------ Output ------
For each test case, print a single line containing one integer ― the bitwise XOR of all elements of the tasty matrix with the given dimensions made with the given special ingredient.
------ Constraints ------
$1 ≤ T ≤ 10^{5}$
$1 ≤ N, M ≤ 2 \cdot 10^{6}$
$1 ≤ K ≤ 10^{9}$
the sum of $N$ over all test cases does not exceed $2 \cdot 10^{6}$
the sum of $M$ over all test cases does not exceed $2 \cdot 10^{6}$
----- Sample Input 1 ------
2
2 2 5
2 3 7
----- Sample Output 1 ------
14
5
----- explanation 1 ------
Example case 1: The matrix is
$$A = \begin{pmatrix}
5 + 1 + 1 & 5 + 1 + 2\\
5 + 2 + 1 & 5 + 2 + 2\end{pmatrix}
= \begin{pmatrix}
7 & 8 \\
8 & 9
\end{pmatrix} \,.$$
The XOR of all its elements is $7 \oplus 8 \oplus 8 \oplus 9 = 14$.
Example case 2: The matrix is
$$A = \begin{pmatrix}
7 + 1 + 1 & 7 + 1 + 2 & 7 + 1 + 3\\
7 + 2 + 1 & 7 + 2 + 2 & 7 + 2 + 3
\end{pmatrix}
= \begin{pmatrix}
9 & 10 & 11\\
10 & 11 & 12
\end{pmatrix} \,.$$
The XOR of all its elements is $9 \oplus 10 \oplus 11 \oplus 10 \oplus 11 \oplus 12 = 5$.
|
t = int(input())
for x in range(t):
[n, m, k] = [int(y) for y in input().split()]
if m == n:
ans = 0
for i in range(1, m + 1):
ans ^= int(k + 2 * i)
print(ans)
elif m > n and n != 1:
ans = 0
if n % 2 == 0:
for i in range(1, int(n / 2) + 1):
ans ^= int(k + 2 * i) ^ int(k + m + 1 - i + n + 1 - i)
else:
for i in range(1, int((n + 1) / 2)):
ans ^= int(k + 2 * i) ^ int(k + m + 1 - i + n + 1 - i)
for i in range(int((n + 1) / 2), m - int((n - 1) / 2) + 1):
ans ^= int(k + (n + 1) / 2 + i)
print(ans)
elif n > m and m != 1:
temp = m
m = n
n = temp
ans = 0
if n % 2 == 0:
for i in range(1, int(n / 2) + 1):
ans ^= int(k + 2 * i) ^ int(k + m + 1 - i + n + 1 - i)
else:
for i in range(1, int((n + 1) / 2)):
ans ^= int(k + 2 * i) ^ int(k + m + 1 - i + n + 1 - i)
for i in range(int((n + 1) / 2), m - int((n - 1) / 2) + 1):
ans ^= int(k + (n + 1) / 2 + i)
print(ans)
elif m == 1:
ans = 0
for i in range(1, n + 1):
ans ^= int(k + i + m)
print(ans)
else:
ans = 0
for i in range(1, m + 1):
ans ^= int(k + n + i)
print(ans)
|
ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN LIST VAR VAR VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR IF VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR BIN_OP NUMBER VAR EXPR FUNC_CALL VAR VAR IF VAR VAR VAR NUMBER ASSIGN VAR NUMBER IF BIN_OP VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER VAR BIN_OP FUNC_CALL VAR BIN_OP VAR BIN_OP NUMBER VAR FUNC_CALL VAR BIN_OP BIN_OP BIN_OP BIN_OP BIN_OP BIN_OP VAR VAR NUMBER VAR VAR NUMBER VAR FOR VAR FUNC_CALL VAR NUMBER FUNC_CALL VAR BIN_OP BIN_OP VAR NUMBER NUMBER VAR BIN_OP FUNC_CALL VAR BIN_OP VAR BIN_OP NUMBER VAR FUNC_CALL VAR BIN_OP BIN_OP BIN_OP BIN_OP BIN_OP BIN_OP VAR VAR NUMBER VAR VAR NUMBER VAR FOR VAR FUNC_CALL VAR FUNC_CALL VAR BIN_OP BIN_OP VAR NUMBER NUMBER BIN_OP BIN_OP VAR FUNC_CALL VAR BIN_OP BIN_OP VAR NUMBER NUMBER NUMBER VAR FUNC_CALL VAR BIN_OP BIN_OP VAR BIN_OP BIN_OP VAR NUMBER NUMBER VAR EXPR FUNC_CALL VAR VAR IF VAR VAR VAR NUMBER ASSIGN VAR VAR ASSIGN VAR VAR ASSIGN VAR VAR ASSIGN VAR NUMBER IF BIN_OP VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER VAR BIN_OP FUNC_CALL VAR BIN_OP VAR BIN_OP NUMBER VAR FUNC_CALL VAR BIN_OP BIN_OP BIN_OP BIN_OP BIN_OP BIN_OP VAR VAR NUMBER VAR VAR NUMBER VAR FOR VAR FUNC_CALL VAR NUMBER FUNC_CALL VAR BIN_OP BIN_OP VAR NUMBER NUMBER VAR BIN_OP FUNC_CALL VAR BIN_OP VAR BIN_OP NUMBER VAR FUNC_CALL VAR BIN_OP BIN_OP BIN_OP BIN_OP BIN_OP BIN_OP VAR VAR NUMBER VAR VAR NUMBER VAR FOR VAR FUNC_CALL VAR FUNC_CALL VAR BIN_OP BIN_OP VAR NUMBER NUMBER BIN_OP BIN_OP VAR FUNC_CALL VAR BIN_OP BIN_OP VAR NUMBER NUMBER NUMBER VAR FUNC_CALL VAR BIN_OP BIN_OP VAR BIN_OP BIN_OP VAR NUMBER NUMBER VAR EXPR FUNC_CALL VAR VAR IF VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER VAR FUNC_CALL VAR BIN_OP BIN_OP VAR VAR VAR EXPR FUNC_CALL VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER VAR FUNC_CALL VAR BIN_OP BIN_OP VAR VAR VAR EXPR FUNC_CALL VAR VAR
|
Read problems statements in [Mandarin Chinese], [Russian], [Vietnamese], and [Bengali] as well.
Chef has a *tasty ingredient* ― an integer $K$. He defines a *tasty matrix* $A$ with $N$ rows (numbered $1$ through $N$) and $M$ columns (numbered $1$ through $M$) as $A_{i, j} = K + i + j$ for each valid $i,j$.
Currently, Chef is busy in the kitchen making this tasty matrix. Help him find the bitwise XOR of all elements of this matrix.
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first and only line of each test case contains three space-separated integers $N$, $M$ and $K$.
------ Output ------
For each test case, print a single line containing one integer ― the bitwise XOR of all elements of the tasty matrix with the given dimensions made with the given special ingredient.
------ Constraints ------
$1 ≤ T ≤ 10^{5}$
$1 ≤ N, M ≤ 2 \cdot 10^{6}$
$1 ≤ K ≤ 10^{9}$
the sum of $N$ over all test cases does not exceed $2 \cdot 10^{6}$
the sum of $M$ over all test cases does not exceed $2 \cdot 10^{6}$
----- Sample Input 1 ------
2
2 2 5
2 3 7
----- Sample Output 1 ------
14
5
----- explanation 1 ------
Example case 1: The matrix is
$$A = \begin{pmatrix}
5 + 1 + 1 & 5 + 1 + 2\\
5 + 2 + 1 & 5 + 2 + 2\end{pmatrix}
= \begin{pmatrix}
7 & 8 \\
8 & 9
\end{pmatrix} \,.$$
The XOR of all its elements is $7 \oplus 8 \oplus 8 \oplus 9 = 14$.
Example case 2: The matrix is
$$A = \begin{pmatrix}
7 + 1 + 1 & 7 + 1 + 2 & 7 + 1 + 3\\
7 + 2 + 1 & 7 + 2 + 2 & 7 + 2 + 3
\end{pmatrix}
= \begin{pmatrix}
9 & 10 & 11\\
10 & 11 & 12
\end{pmatrix} \,.$$
The XOR of all its elements is $9 \oplus 10 \oplus 11 \oplus 10 \oplus 11 \oplus 12 = 5$.
|
for _ in range(int(input())):
n, m, k = map(int, input().split())
n, m = min(n, m), max(n, m)
ans = 0
j = 2
for i in range(1, n):
if i % 2:
ans ^= j + k
j += 1
if n % 2:
while 1:
ans ^= j + k
j += 1
if j == m + n - n + 2:
break
j = m + n - n + 2
for i in range(n - 1, 0, -1):
if i % 2:
ans ^= j + k
j += 1
print(ans)
|
FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR FUNC_CALL VAR VAR VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER VAR IF BIN_OP VAR NUMBER VAR BIN_OP VAR VAR VAR NUMBER IF BIN_OP VAR NUMBER WHILE NUMBER VAR BIN_OP VAR VAR VAR NUMBER IF VAR BIN_OP BIN_OP BIN_OP VAR VAR VAR NUMBER ASSIGN VAR BIN_OP BIN_OP BIN_OP VAR VAR VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER NUMBER IF BIN_OP VAR NUMBER VAR BIN_OP VAR VAR VAR NUMBER EXPR FUNC_CALL VAR VAR
|
Read problems statements in [Mandarin Chinese], [Russian], [Vietnamese], and [Bengali] as well.
Chef has a *tasty ingredient* ― an integer $K$. He defines a *tasty matrix* $A$ with $N$ rows (numbered $1$ through $N$) and $M$ columns (numbered $1$ through $M$) as $A_{i, j} = K + i + j$ for each valid $i,j$.
Currently, Chef is busy in the kitchen making this tasty matrix. Help him find the bitwise XOR of all elements of this matrix.
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first and only line of each test case contains three space-separated integers $N$, $M$ and $K$.
------ Output ------
For each test case, print a single line containing one integer ― the bitwise XOR of all elements of the tasty matrix with the given dimensions made with the given special ingredient.
------ Constraints ------
$1 ≤ T ≤ 10^{5}$
$1 ≤ N, M ≤ 2 \cdot 10^{6}$
$1 ≤ K ≤ 10^{9}$
the sum of $N$ over all test cases does not exceed $2 \cdot 10^{6}$
the sum of $M$ over all test cases does not exceed $2 \cdot 10^{6}$
----- Sample Input 1 ------
2
2 2 5
2 3 7
----- Sample Output 1 ------
14
5
----- explanation 1 ------
Example case 1: The matrix is
$$A = \begin{pmatrix}
5 + 1 + 1 & 5 + 1 + 2\\
5 + 2 + 1 & 5 + 2 + 2\end{pmatrix}
= \begin{pmatrix}
7 & 8 \\
8 & 9
\end{pmatrix} \,.$$
The XOR of all its elements is $7 \oplus 8 \oplus 8 \oplus 9 = 14$.
Example case 2: The matrix is
$$A = \begin{pmatrix}
7 + 1 + 1 & 7 + 1 + 2 & 7 + 1 + 3\\
7 + 2 + 1 & 7 + 2 + 2 & 7 + 2 + 3
\end{pmatrix}
= \begin{pmatrix}
9 & 10 & 11\\
10 & 11 & 12
\end{pmatrix} \,.$$
The XOR of all its elements is $9 \oplus 10 \oplus 11 \oplus 10 \oplus 11 \oplus 12 = 5$.
|
T = int(input())
for k in range(T):
N, M, K = [int(i) for i in input().split()]
an = 0
a = 1
for i in range(K + 2, K + N + M + 1):
if a % 2 != 0:
an = an ^ i
if i - K <= min(N, M):
a += 1
elif i - K + 1 >= max(N, M) + 2:
a -= 1
print(an)
|
ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER BIN_OP BIN_OP BIN_OP VAR VAR VAR NUMBER IF BIN_OP VAR NUMBER NUMBER ASSIGN VAR BIN_OP VAR VAR IF BIN_OP VAR VAR FUNC_CALL VAR VAR VAR VAR NUMBER IF BIN_OP BIN_OP VAR VAR NUMBER BIN_OP FUNC_CALL VAR VAR VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR VAR
|
Read problems statements in [Mandarin Chinese], [Russian], [Vietnamese], and [Bengali] as well.
Chef has a *tasty ingredient* ― an integer $K$. He defines a *tasty matrix* $A$ with $N$ rows (numbered $1$ through $N$) and $M$ columns (numbered $1$ through $M$) as $A_{i, j} = K + i + j$ for each valid $i,j$.
Currently, Chef is busy in the kitchen making this tasty matrix. Help him find the bitwise XOR of all elements of this matrix.
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first and only line of each test case contains three space-separated integers $N$, $M$ and $K$.
------ Output ------
For each test case, print a single line containing one integer ― the bitwise XOR of all elements of the tasty matrix with the given dimensions made with the given special ingredient.
------ Constraints ------
$1 ≤ T ≤ 10^{5}$
$1 ≤ N, M ≤ 2 \cdot 10^{6}$
$1 ≤ K ≤ 10^{9}$
the sum of $N$ over all test cases does not exceed $2 \cdot 10^{6}$
the sum of $M$ over all test cases does not exceed $2 \cdot 10^{6}$
----- Sample Input 1 ------
2
2 2 5
2 3 7
----- Sample Output 1 ------
14
5
----- explanation 1 ------
Example case 1: The matrix is
$$A = \begin{pmatrix}
5 + 1 + 1 & 5 + 1 + 2\\
5 + 2 + 1 & 5 + 2 + 2\end{pmatrix}
= \begin{pmatrix}
7 & 8 \\
8 & 9
\end{pmatrix} \,.$$
The XOR of all its elements is $7 \oplus 8 \oplus 8 \oplus 9 = 14$.
Example case 2: The matrix is
$$A = \begin{pmatrix}
7 + 1 + 1 & 7 + 1 + 2 & 7 + 1 + 3\\
7 + 2 + 1 & 7 + 2 + 2 & 7 + 2 + 3
\end{pmatrix}
= \begin{pmatrix}
9 & 10 & 11\\
10 & 11 & 12
\end{pmatrix} \,.$$
The XOR of all its elements is $9 \oplus 10 \oplus 11 \oplus 10 \oplus 11 \oplus 12 = 5$.
|
for t in range(int(input())):
n, m, k = map(int, input().split())
dt = dict()
tp = k + 2
for i in range(1, n + 1):
dt[tp] = min(i, m)
tp += 1
for j in range(2, m + 1):
dt[tp] = min(n, m - j + 1)
tp += 1
ans = 0
for key, value in dt.items():
if value % 2:
ans = ans ^ key
print(ans)
|
FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR ASSIGN VAR BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER ASSIGN VAR VAR FUNC_CALL VAR VAR VAR VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER ASSIGN VAR VAR FUNC_CALL VAR VAR BIN_OP BIN_OP VAR VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER FOR VAR VAR FUNC_CALL VAR IF BIN_OP VAR NUMBER ASSIGN VAR BIN_OP VAR VAR EXPR FUNC_CALL VAR VAR
|
Read problems statements in [Mandarin Chinese], [Russian], [Vietnamese], and [Bengali] as well.
Chef has a *tasty ingredient* ― an integer $K$. He defines a *tasty matrix* $A$ with $N$ rows (numbered $1$ through $N$) and $M$ columns (numbered $1$ through $M$) as $A_{i, j} = K + i + j$ for each valid $i,j$.
Currently, Chef is busy in the kitchen making this tasty matrix. Help him find the bitwise XOR of all elements of this matrix.
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first and only line of each test case contains three space-separated integers $N$, $M$ and $K$.
------ Output ------
For each test case, print a single line containing one integer ― the bitwise XOR of all elements of the tasty matrix with the given dimensions made with the given special ingredient.
------ Constraints ------
$1 ≤ T ≤ 10^{5}$
$1 ≤ N, M ≤ 2 \cdot 10^{6}$
$1 ≤ K ≤ 10^{9}$
the sum of $N$ over all test cases does not exceed $2 \cdot 10^{6}$
the sum of $M$ over all test cases does not exceed $2 \cdot 10^{6}$
----- Sample Input 1 ------
2
2 2 5
2 3 7
----- Sample Output 1 ------
14
5
----- explanation 1 ------
Example case 1: The matrix is
$$A = \begin{pmatrix}
5 + 1 + 1 & 5 + 1 + 2\\
5 + 2 + 1 & 5 + 2 + 2\end{pmatrix}
= \begin{pmatrix}
7 & 8 \\
8 & 9
\end{pmatrix} \,.$$
The XOR of all its elements is $7 \oplus 8 \oplus 8 \oplus 9 = 14$.
Example case 2: The matrix is
$$A = \begin{pmatrix}
7 + 1 + 1 & 7 + 1 + 2 & 7 + 1 + 3\\
7 + 2 + 1 & 7 + 2 + 2 & 7 + 2 + 3
\end{pmatrix}
= \begin{pmatrix}
9 & 10 & 11\\
10 & 11 & 12
\end{pmatrix} \,.$$
The XOR of all its elements is $9 \oplus 10 \oplus 11 \oplus 10 \oplus 11 \oplus 12 = 5$.
|
for t in range(int(input())):
l = list(map(int, input().split()))
n = l[0]
m = l[1]
k = l[2]
r = []
for i in range(1, n + 1):
r.append((1 + i, i, 1))
for j in range(2, m + 1):
r.append((n + j, n, j))
ans = 0
for i in range(len(r)):
v = r[i]
if i < n:
if min(v[1], m) % 2 == 1:
ans = ans ^ k + v[0]
elif min(m - v[2] + 1, n) % 2 == 1:
ans = ans ^ k + v[0]
print(ans)
|
FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR VAR NUMBER ASSIGN VAR VAR NUMBER ASSIGN VAR VAR NUMBER ASSIGN VAR LIST FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER EXPR FUNC_CALL VAR BIN_OP NUMBER VAR VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER EXPR FUNC_CALL VAR BIN_OP VAR VAR VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR IF VAR VAR IF BIN_OP FUNC_CALL VAR VAR NUMBER VAR NUMBER NUMBER ASSIGN VAR BIN_OP VAR BIN_OP VAR VAR NUMBER IF BIN_OP FUNC_CALL VAR BIN_OP BIN_OP VAR VAR NUMBER NUMBER VAR NUMBER NUMBER ASSIGN VAR BIN_OP VAR BIN_OP VAR VAR NUMBER EXPR FUNC_CALL VAR VAR
|
Read problems statements in [Mandarin Chinese], [Russian], [Vietnamese], and [Bengali] as well.
Chef has a *tasty ingredient* ― an integer $K$. He defines a *tasty matrix* $A$ with $N$ rows (numbered $1$ through $N$) and $M$ columns (numbered $1$ through $M$) as $A_{i, j} = K + i + j$ for each valid $i,j$.
Currently, Chef is busy in the kitchen making this tasty matrix. Help him find the bitwise XOR of all elements of this matrix.
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first and only line of each test case contains three space-separated integers $N$, $M$ and $K$.
------ Output ------
For each test case, print a single line containing one integer ― the bitwise XOR of all elements of the tasty matrix with the given dimensions made with the given special ingredient.
------ Constraints ------
$1 ≤ T ≤ 10^{5}$
$1 ≤ N, M ≤ 2 \cdot 10^{6}$
$1 ≤ K ≤ 10^{9}$
the sum of $N$ over all test cases does not exceed $2 \cdot 10^{6}$
the sum of $M$ over all test cases does not exceed $2 \cdot 10^{6}$
----- Sample Input 1 ------
2
2 2 5
2 3 7
----- Sample Output 1 ------
14
5
----- explanation 1 ------
Example case 1: The matrix is
$$A = \begin{pmatrix}
5 + 1 + 1 & 5 + 1 + 2\\
5 + 2 + 1 & 5 + 2 + 2\end{pmatrix}
= \begin{pmatrix}
7 & 8 \\
8 & 9
\end{pmatrix} \,.$$
The XOR of all its elements is $7 \oplus 8 \oplus 8 \oplus 9 = 14$.
Example case 2: The matrix is
$$A = \begin{pmatrix}
7 + 1 + 1 & 7 + 1 + 2 & 7 + 1 + 3\\
7 + 2 + 1 & 7 + 2 + 2 & 7 + 2 + 3
\end{pmatrix}
= \begin{pmatrix}
9 & 10 & 11\\
10 & 11 & 12
\end{pmatrix} \,.$$
The XOR of all its elements is $9 \oplus 10 \oplus 11 \oplus 10 \oplus 11 \oplus 12 = 5$.
|
for _ in range(int(input())):
r, c, k = map(int, input().split())
ans = 0
for j in range(1, c + 1):
p = min(r - 1, j - 1) + 1
if p % 2:
ans ^= 1 + j + k
for i in range(2, r + 1):
p = min(c - 1, r - i) + 1
if p % 2:
ans ^= i + c + k
print(ans)
|
FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER ASSIGN VAR BIN_OP FUNC_CALL VAR BIN_OP VAR NUMBER BIN_OP VAR NUMBER NUMBER IF BIN_OP VAR NUMBER VAR BIN_OP BIN_OP NUMBER VAR VAR FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER ASSIGN VAR BIN_OP FUNC_CALL VAR BIN_OP VAR NUMBER BIN_OP VAR VAR NUMBER IF BIN_OP VAR NUMBER VAR BIN_OP BIN_OP VAR VAR VAR EXPR FUNC_CALL VAR VAR
|
Read problems statements in [Mandarin Chinese], [Russian], [Vietnamese], and [Bengali] as well.
Chef has a *tasty ingredient* ― an integer $K$. He defines a *tasty matrix* $A$ with $N$ rows (numbered $1$ through $N$) and $M$ columns (numbered $1$ through $M$) as $A_{i, j} = K + i + j$ for each valid $i,j$.
Currently, Chef is busy in the kitchen making this tasty matrix. Help him find the bitwise XOR of all elements of this matrix.
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first and only line of each test case contains three space-separated integers $N$, $M$ and $K$.
------ Output ------
For each test case, print a single line containing one integer ― the bitwise XOR of all elements of the tasty matrix with the given dimensions made with the given special ingredient.
------ Constraints ------
$1 ≤ T ≤ 10^{5}$
$1 ≤ N, M ≤ 2 \cdot 10^{6}$
$1 ≤ K ≤ 10^{9}$
the sum of $N$ over all test cases does not exceed $2 \cdot 10^{6}$
the sum of $M$ over all test cases does not exceed $2 \cdot 10^{6}$
----- Sample Input 1 ------
2
2 2 5
2 3 7
----- Sample Output 1 ------
14
5
----- explanation 1 ------
Example case 1: The matrix is
$$A = \begin{pmatrix}
5 + 1 + 1 & 5 + 1 + 2\\
5 + 2 + 1 & 5 + 2 + 2\end{pmatrix}
= \begin{pmatrix}
7 & 8 \\
8 & 9
\end{pmatrix} \,.$$
The XOR of all its elements is $7 \oplus 8 \oplus 8 \oplus 9 = 14$.
Example case 2: The matrix is
$$A = \begin{pmatrix}
7 + 1 + 1 & 7 + 1 + 2 & 7 + 1 + 3\\
7 + 2 + 1 & 7 + 2 + 2 & 7 + 2 + 3
\end{pmatrix}
= \begin{pmatrix}
9 & 10 & 11\\
10 & 11 & 12
\end{pmatrix} \,.$$
The XOR of all its elements is $9 \oplus 10 \oplus 11 \oplus 10 \oplus 11 \oplus 12 = 5$.
|
T = int(input())
ans = []
for _ in range(T):
N, M, K = [int(i) for i in input().split()]
l = 1
a = None
X = min(N, M)
for i in range(K + 2, K + M + 1 + 1):
if a == None:
a = K + 2
elif l % 2 != 0:
a ^= i
l = min(l + 1, X)
l = 1
for i in range(K + N + M, K + M + 1, -1):
if l % 2 != 0:
a ^= i
l = min(l + 1, X)
ans.append(a)
for i in ans:
print(i)
|
ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER ASSIGN VAR NONE ASSIGN VAR FUNC_CALL VAR VAR VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER BIN_OP BIN_OP BIN_OP VAR VAR NUMBER NUMBER IF VAR NONE ASSIGN VAR BIN_OP VAR NUMBER IF BIN_OP VAR NUMBER NUMBER VAR VAR ASSIGN VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP BIN_OP VAR VAR VAR BIN_OP BIN_OP VAR VAR NUMBER NUMBER IF BIN_OP VAR NUMBER NUMBER VAR VAR ASSIGN VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR EXPR FUNC_CALL VAR VAR FOR VAR VAR EXPR FUNC_CALL VAR VAR
|
Read problems statements in [Mandarin Chinese], [Russian], [Vietnamese], and [Bengali] as well.
Chef has a *tasty ingredient* ― an integer $K$. He defines a *tasty matrix* $A$ with $N$ rows (numbered $1$ through $N$) and $M$ columns (numbered $1$ through $M$) as $A_{i, j} = K + i + j$ for each valid $i,j$.
Currently, Chef is busy in the kitchen making this tasty matrix. Help him find the bitwise XOR of all elements of this matrix.
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first and only line of each test case contains three space-separated integers $N$, $M$ and $K$.
------ Output ------
For each test case, print a single line containing one integer ― the bitwise XOR of all elements of the tasty matrix with the given dimensions made with the given special ingredient.
------ Constraints ------
$1 ≤ T ≤ 10^{5}$
$1 ≤ N, M ≤ 2 \cdot 10^{6}$
$1 ≤ K ≤ 10^{9}$
the sum of $N$ over all test cases does not exceed $2 \cdot 10^{6}$
the sum of $M$ over all test cases does not exceed $2 \cdot 10^{6}$
----- Sample Input 1 ------
2
2 2 5
2 3 7
----- Sample Output 1 ------
14
5
----- explanation 1 ------
Example case 1: The matrix is
$$A = \begin{pmatrix}
5 + 1 + 1 & 5 + 1 + 2\\
5 + 2 + 1 & 5 + 2 + 2\end{pmatrix}
= \begin{pmatrix}
7 & 8 \\
8 & 9
\end{pmatrix} \,.$$
The XOR of all its elements is $7 \oplus 8 \oplus 8 \oplus 9 = 14$.
Example case 2: The matrix is
$$A = \begin{pmatrix}
7 + 1 + 1 & 7 + 1 + 2 & 7 + 1 + 3\\
7 + 2 + 1 & 7 + 2 + 2 & 7 + 2 + 3
\end{pmatrix}
= \begin{pmatrix}
9 & 10 & 11\\
10 & 11 & 12
\end{pmatrix} \,.$$
The XOR of all its elements is $9 \oplus 10 \oplus 11 \oplus 10 \oplus 11 \oplus 12 = 5$.
|
T = int(input())
for _ in range(T):
N, M, K = map(int, input().split())
res = 0
for j in range(1, M + 1):
if j <= N and j % 2 == 1:
res = res ^ K + j + 1
elif j > N and N % 2 == 1:
res = res ^ K + j + 1
for j in range(M + 1, N + M):
if j > N and (N + M - j) % 2 == 1:
res = res ^ K + j + 1
elif j <= N and M % 2 == 1:
res = res ^ K + j + 1
print(res)
|
ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER IF VAR VAR BIN_OP VAR NUMBER NUMBER ASSIGN VAR BIN_OP VAR BIN_OP BIN_OP VAR VAR NUMBER IF VAR VAR BIN_OP VAR NUMBER NUMBER ASSIGN VAR BIN_OP VAR BIN_OP BIN_OP VAR VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER BIN_OP VAR VAR IF VAR VAR BIN_OP BIN_OP BIN_OP VAR VAR VAR NUMBER NUMBER ASSIGN VAR BIN_OP VAR BIN_OP BIN_OP VAR VAR NUMBER IF VAR VAR BIN_OP VAR NUMBER NUMBER ASSIGN VAR BIN_OP VAR BIN_OP BIN_OP VAR VAR NUMBER EXPR FUNC_CALL VAR VAR
|
Read problems statements in [Mandarin Chinese], [Russian], [Vietnamese], and [Bengali] as well.
Chef has a *tasty ingredient* ― an integer $K$. He defines a *tasty matrix* $A$ with $N$ rows (numbered $1$ through $N$) and $M$ columns (numbered $1$ through $M$) as $A_{i, j} = K + i + j$ for each valid $i,j$.
Currently, Chef is busy in the kitchen making this tasty matrix. Help him find the bitwise XOR of all elements of this matrix.
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first and only line of each test case contains three space-separated integers $N$, $M$ and $K$.
------ Output ------
For each test case, print a single line containing one integer ― the bitwise XOR of all elements of the tasty matrix with the given dimensions made with the given special ingredient.
------ Constraints ------
$1 ≤ T ≤ 10^{5}$
$1 ≤ N, M ≤ 2 \cdot 10^{6}$
$1 ≤ K ≤ 10^{9}$
the sum of $N$ over all test cases does not exceed $2 \cdot 10^{6}$
the sum of $M$ over all test cases does not exceed $2 \cdot 10^{6}$
----- Sample Input 1 ------
2
2 2 5
2 3 7
----- Sample Output 1 ------
14
5
----- explanation 1 ------
Example case 1: The matrix is
$$A = \begin{pmatrix}
5 + 1 + 1 & 5 + 1 + 2\\
5 + 2 + 1 & 5 + 2 + 2\end{pmatrix}
= \begin{pmatrix}
7 & 8 \\
8 & 9
\end{pmatrix} \,.$$
The XOR of all its elements is $7 \oplus 8 \oplus 8 \oplus 9 = 14$.
Example case 2: The matrix is
$$A = \begin{pmatrix}
7 + 1 + 1 & 7 + 1 + 2 & 7 + 1 + 3\\
7 + 2 + 1 & 7 + 2 + 2 & 7 + 2 + 3
\end{pmatrix}
= \begin{pmatrix}
9 & 10 & 11\\
10 & 11 & 12
\end{pmatrix} \,.$$
The XOR of all its elements is $9 \oplus 10 \oplus 11 \oplus 10 \oplus 11 \oplus 12 = 5$.
|
t = int(input())
while t:
n, m, k = map(int, input().split())
v = k + 1 + 1
v = v ^ k + m + n
c = 2
for i in range(k + 3, k + n + 2):
y = min(c, m)
if y % 2 != 0:
v = v ^ i
c += 1
c = 2
for i in range(k + n + 2, k + n + m):
y = min(n, m - c + 1)
if y % 2 != 0:
v = v ^ i
c += 1
print(v)
t -= 1
|
ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR WHILE VAR ASSIGN VAR VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR BIN_OP BIN_OP VAR NUMBER NUMBER ASSIGN VAR BIN_OP VAR BIN_OP BIN_OP VAR VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER BIN_OP BIN_OP VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR IF BIN_OP VAR NUMBER NUMBER ASSIGN VAR BIN_OP VAR VAR VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP BIN_OP VAR VAR NUMBER BIN_OP BIN_OP VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR BIN_OP BIN_OP VAR VAR NUMBER IF BIN_OP VAR NUMBER NUMBER ASSIGN VAR BIN_OP VAR VAR VAR NUMBER EXPR FUNC_CALL VAR VAR VAR NUMBER
|
Read problems statements in [Mandarin Chinese], [Russian], [Vietnamese], and [Bengali] as well.
Chef has a *tasty ingredient* ― an integer $K$. He defines a *tasty matrix* $A$ with $N$ rows (numbered $1$ through $N$) and $M$ columns (numbered $1$ through $M$) as $A_{i, j} = K + i + j$ for each valid $i,j$.
Currently, Chef is busy in the kitchen making this tasty matrix. Help him find the bitwise XOR of all elements of this matrix.
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first and only line of each test case contains three space-separated integers $N$, $M$ and $K$.
------ Output ------
For each test case, print a single line containing one integer ― the bitwise XOR of all elements of the tasty matrix with the given dimensions made with the given special ingredient.
------ Constraints ------
$1 ≤ T ≤ 10^{5}$
$1 ≤ N, M ≤ 2 \cdot 10^{6}$
$1 ≤ K ≤ 10^{9}$
the sum of $N$ over all test cases does not exceed $2 \cdot 10^{6}$
the sum of $M$ over all test cases does not exceed $2 \cdot 10^{6}$
----- Sample Input 1 ------
2
2 2 5
2 3 7
----- Sample Output 1 ------
14
5
----- explanation 1 ------
Example case 1: The matrix is
$$A = \begin{pmatrix}
5 + 1 + 1 & 5 + 1 + 2\\
5 + 2 + 1 & 5 + 2 + 2\end{pmatrix}
= \begin{pmatrix}
7 & 8 \\
8 & 9
\end{pmatrix} \,.$$
The XOR of all its elements is $7 \oplus 8 \oplus 8 \oplus 9 = 14$.
Example case 2: The matrix is
$$A = \begin{pmatrix}
7 + 1 + 1 & 7 + 1 + 2 & 7 + 1 + 3\\
7 + 2 + 1 & 7 + 2 + 2 & 7 + 2 + 3
\end{pmatrix}
= \begin{pmatrix}
9 & 10 & 11\\
10 & 11 & 12
\end{pmatrix} \,.$$
The XOR of all its elements is $9 \oplus 10 \oplus 11 \oplus 10 \oplus 11 \oplus 12 = 5$.
|
for _ in range(int(input())):
n, m, k = map(int, input().split())
ans = 0
for i in range(1, n + 1 - n % 2):
if i & 1:
ans ^= k + i + 1
else:
ans ^= k + i + m
if n & 1:
for i in range(1, m + 1):
ans ^= k + n + i
print(ans)
|
FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP BIN_OP VAR NUMBER BIN_OP VAR NUMBER IF BIN_OP VAR NUMBER VAR BIN_OP BIN_OP VAR VAR NUMBER VAR BIN_OP BIN_OP VAR VAR VAR IF BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER VAR BIN_OP BIN_OP VAR VAR VAR EXPR FUNC_CALL VAR VAR
|
Read problems statements in [Mandarin Chinese], [Russian], [Vietnamese], and [Bengali] as well.
Chef has a *tasty ingredient* ― an integer $K$. He defines a *tasty matrix* $A$ with $N$ rows (numbered $1$ through $N$) and $M$ columns (numbered $1$ through $M$) as $A_{i, j} = K + i + j$ for each valid $i,j$.
Currently, Chef is busy in the kitchen making this tasty matrix. Help him find the bitwise XOR of all elements of this matrix.
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first and only line of each test case contains three space-separated integers $N$, $M$ and $K$.
------ Output ------
For each test case, print a single line containing one integer ― the bitwise XOR of all elements of the tasty matrix with the given dimensions made with the given special ingredient.
------ Constraints ------
$1 ≤ T ≤ 10^{5}$
$1 ≤ N, M ≤ 2 \cdot 10^{6}$
$1 ≤ K ≤ 10^{9}$
the sum of $N$ over all test cases does not exceed $2 \cdot 10^{6}$
the sum of $M$ over all test cases does not exceed $2 \cdot 10^{6}$
----- Sample Input 1 ------
2
2 2 5
2 3 7
----- Sample Output 1 ------
14
5
----- explanation 1 ------
Example case 1: The matrix is
$$A = \begin{pmatrix}
5 + 1 + 1 & 5 + 1 + 2\\
5 + 2 + 1 & 5 + 2 + 2\end{pmatrix}
= \begin{pmatrix}
7 & 8 \\
8 & 9
\end{pmatrix} \,.$$
The XOR of all its elements is $7 \oplus 8 \oplus 8 \oplus 9 = 14$.
Example case 2: The matrix is
$$A = \begin{pmatrix}
7 + 1 + 1 & 7 + 1 + 2 & 7 + 1 + 3\\
7 + 2 + 1 & 7 + 2 + 2 & 7 + 2 + 3
\end{pmatrix}
= \begin{pmatrix}
9 & 10 & 11\\
10 & 11 & 12
\end{pmatrix} \,.$$
The XOR of all its elements is $9 \oplus 10 \oplus 11 \oplus 10 \oplus 11 \oplus 12 = 5$.
|
for _ in range(int(input())):
n, m, k = map(int, input().split())
ans = 0
while m or n:
for i in range(1, min(n, m) + 1):
ans = ans ^ k + i + i
if n < m:
m = m - n
k += n
elif n > m:
n = n - m
k += m
else:
break
print(ans)
|
FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER WHILE VAR VAR FOR VAR FUNC_CALL VAR NUMBER BIN_OP FUNC_CALL VAR VAR VAR NUMBER ASSIGN VAR BIN_OP VAR BIN_OP BIN_OP VAR VAR VAR IF VAR VAR ASSIGN VAR BIN_OP VAR VAR VAR VAR IF VAR VAR ASSIGN VAR BIN_OP VAR VAR VAR VAR EXPR FUNC_CALL VAR VAR
|
Read problems statements in [Mandarin Chinese], [Russian], [Vietnamese], and [Bengali] as well.
Chef has a *tasty ingredient* ― an integer $K$. He defines a *tasty matrix* $A$ with $N$ rows (numbered $1$ through $N$) and $M$ columns (numbered $1$ through $M$) as $A_{i, j} = K + i + j$ for each valid $i,j$.
Currently, Chef is busy in the kitchen making this tasty matrix. Help him find the bitwise XOR of all elements of this matrix.
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first and only line of each test case contains three space-separated integers $N$, $M$ and $K$.
------ Output ------
For each test case, print a single line containing one integer ― the bitwise XOR of all elements of the tasty matrix with the given dimensions made with the given special ingredient.
------ Constraints ------
$1 ≤ T ≤ 10^{5}$
$1 ≤ N, M ≤ 2 \cdot 10^{6}$
$1 ≤ K ≤ 10^{9}$
the sum of $N$ over all test cases does not exceed $2 \cdot 10^{6}$
the sum of $M$ over all test cases does not exceed $2 \cdot 10^{6}$
----- Sample Input 1 ------
2
2 2 5
2 3 7
----- Sample Output 1 ------
14
5
----- explanation 1 ------
Example case 1: The matrix is
$$A = \begin{pmatrix}
5 + 1 + 1 & 5 + 1 + 2\\
5 + 2 + 1 & 5 + 2 + 2\end{pmatrix}
= \begin{pmatrix}
7 & 8 \\
8 & 9
\end{pmatrix} \,.$$
The XOR of all its elements is $7 \oplus 8 \oplus 8 \oplus 9 = 14$.
Example case 2: The matrix is
$$A = \begin{pmatrix}
7 + 1 + 1 & 7 + 1 + 2 & 7 + 1 + 3\\
7 + 2 + 1 & 7 + 2 + 2 & 7 + 2 + 3
\end{pmatrix}
= \begin{pmatrix}
9 & 10 & 11\\
10 & 11 & 12
\end{pmatrix} \,.$$
The XOR of all its elements is $9 \oplus 10 \oplus 11 \oplus 10 \oplus 11 \oplus 12 = 5$.
|
def xor(number):
if number % 4 == 0:
return number
elif number % 4 == 1:
return 1
elif number % 4 == 2:
return number + 1
else:
return 0
T = int(input())
for _ in range(T):
N, M, K = map(int, input().split())
lst = [(xor(K + i) ^ xor(K + i + M)) for i in range(1, N + 1)]
res = 0
for e in lst:
res ^= e
print(res)
|
FUNC_DEF IF BIN_OP VAR NUMBER NUMBER RETURN VAR IF BIN_OP VAR NUMBER NUMBER RETURN NUMBER IF BIN_OP VAR NUMBER NUMBER RETURN BIN_OP VAR NUMBER RETURN NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR BIN_OP FUNC_CALL VAR BIN_OP VAR VAR FUNC_CALL VAR BIN_OP BIN_OP VAR VAR VAR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER ASSIGN VAR NUMBER FOR VAR VAR VAR VAR EXPR FUNC_CALL VAR VAR
|
Read problems statements in [Mandarin Chinese], [Russian], [Vietnamese], and [Bengali] as well.
Chef has a *tasty ingredient* ― an integer $K$. He defines a *tasty matrix* $A$ with $N$ rows (numbered $1$ through $N$) and $M$ columns (numbered $1$ through $M$) as $A_{i, j} = K + i + j$ for each valid $i,j$.
Currently, Chef is busy in the kitchen making this tasty matrix. Help him find the bitwise XOR of all elements of this matrix.
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first and only line of each test case contains three space-separated integers $N$, $M$ and $K$.
------ Output ------
For each test case, print a single line containing one integer ― the bitwise XOR of all elements of the tasty matrix with the given dimensions made with the given special ingredient.
------ Constraints ------
$1 ≤ T ≤ 10^{5}$
$1 ≤ N, M ≤ 2 \cdot 10^{6}$
$1 ≤ K ≤ 10^{9}$
the sum of $N$ over all test cases does not exceed $2 \cdot 10^{6}$
the sum of $M$ over all test cases does not exceed $2 \cdot 10^{6}$
----- Sample Input 1 ------
2
2 2 5
2 3 7
----- Sample Output 1 ------
14
5
----- explanation 1 ------
Example case 1: The matrix is
$$A = \begin{pmatrix}
5 + 1 + 1 & 5 + 1 + 2\\
5 + 2 + 1 & 5 + 2 + 2\end{pmatrix}
= \begin{pmatrix}
7 & 8 \\
8 & 9
\end{pmatrix} \,.$$
The XOR of all its elements is $7 \oplus 8 \oplus 8 \oplus 9 = 14$.
Example case 2: The matrix is
$$A = \begin{pmatrix}
7 + 1 + 1 & 7 + 1 + 2 & 7 + 1 + 3\\
7 + 2 + 1 & 7 + 2 + 2 & 7 + 2 + 3
\end{pmatrix}
= \begin{pmatrix}
9 & 10 & 11\\
10 & 11 & 12
\end{pmatrix} \,.$$
The XOR of all its elements is $9 \oplus 10 \oplus 11 \oplus 10 \oplus 11 \oplus 12 = 5$.
|
def solve():
n, m, k = inl()
ans = 0
for i in range(1, n + 1):
if min(i, m) % 2 != 0:
ans ^= k + i + 1
for j in range(2, m + 1):
if min(n, m - j + 1) % 2 != 0:
ans ^= k + n + j
print(ans)
def inl():
return [int(i) for i in input().split()]
def inp():
return int(input())
t = 1
t = inp()
while t:
solve()
t -= 1
|
FUNC_DEF ASSIGN VAR VAR VAR FUNC_CALL VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER IF BIN_OP FUNC_CALL VAR VAR VAR NUMBER NUMBER VAR BIN_OP BIN_OP VAR VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER IF BIN_OP FUNC_CALL VAR VAR BIN_OP BIN_OP VAR VAR NUMBER NUMBER NUMBER VAR BIN_OP BIN_OP VAR VAR VAR EXPR FUNC_CALL VAR VAR FUNC_DEF RETURN FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR FUNC_DEF RETURN FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR NUMBER ASSIGN VAR FUNC_CALL VAR WHILE VAR EXPR FUNC_CALL VAR VAR NUMBER
|
Read problems statements in [Mandarin Chinese], [Russian], [Vietnamese], and [Bengali] as well.
Chef has a *tasty ingredient* ― an integer $K$. He defines a *tasty matrix* $A$ with $N$ rows (numbered $1$ through $N$) and $M$ columns (numbered $1$ through $M$) as $A_{i, j} = K + i + j$ for each valid $i,j$.
Currently, Chef is busy in the kitchen making this tasty matrix. Help him find the bitwise XOR of all elements of this matrix.
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first and only line of each test case contains three space-separated integers $N$, $M$ and $K$.
------ Output ------
For each test case, print a single line containing one integer ― the bitwise XOR of all elements of the tasty matrix with the given dimensions made with the given special ingredient.
------ Constraints ------
$1 ≤ T ≤ 10^{5}$
$1 ≤ N, M ≤ 2 \cdot 10^{6}$
$1 ≤ K ≤ 10^{9}$
the sum of $N$ over all test cases does not exceed $2 \cdot 10^{6}$
the sum of $M$ over all test cases does not exceed $2 \cdot 10^{6}$
----- Sample Input 1 ------
2
2 2 5
2 3 7
----- Sample Output 1 ------
14
5
----- explanation 1 ------
Example case 1: The matrix is
$$A = \begin{pmatrix}
5 + 1 + 1 & 5 + 1 + 2\\
5 + 2 + 1 & 5 + 2 + 2\end{pmatrix}
= \begin{pmatrix}
7 & 8 \\
8 & 9
\end{pmatrix} \,.$$
The XOR of all its elements is $7 \oplus 8 \oplus 8 \oplus 9 = 14$.
Example case 2: The matrix is
$$A = \begin{pmatrix}
7 + 1 + 1 & 7 + 1 + 2 & 7 + 1 + 3\\
7 + 2 + 1 & 7 + 2 + 2 & 7 + 2 + 3
\end{pmatrix}
= \begin{pmatrix}
9 & 10 & 11\\
10 & 11 & 12
\end{pmatrix} \,.$$
The XOR of all its elements is $9 \oplus 10 \oplus 11 \oplus 10 \oplus 11 \oplus 12 = 5$.
|
for _ in range(int(input())):
n, m, k = map(int, input().split())
ans = 0
if min(m, n) == 1:
for i in range(1, max(m, n)):
ans ^= k + i + 1
else:
ans = 0
x = min(m, n)
y = max(m, n)
for i in range(1, x, 2):
ans ^= k + i + 1
if x & 1:
for i in range(x, y + 1):
ans ^= k + i + 1
for i in range(x + y - 1, y, -2):
ans ^= k + i + 1
print(ans)
|
FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER IF FUNC_CALL VAR VAR VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER FUNC_CALL VAR VAR VAR VAR BIN_OP BIN_OP VAR VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR FOR VAR FUNC_CALL VAR NUMBER VAR NUMBER VAR BIN_OP BIN_OP VAR VAR NUMBER IF BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER VAR BIN_OP BIN_OP VAR VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP BIN_OP VAR VAR NUMBER VAR NUMBER VAR BIN_OP BIN_OP VAR VAR NUMBER EXPR FUNC_CALL VAR VAR
|
Read problems statements in [Mandarin Chinese], [Russian], [Vietnamese], and [Bengali] as well.
Chef has a *tasty ingredient* ― an integer $K$. He defines a *tasty matrix* $A$ with $N$ rows (numbered $1$ through $N$) and $M$ columns (numbered $1$ through $M$) as $A_{i, j} = K + i + j$ for each valid $i,j$.
Currently, Chef is busy in the kitchen making this tasty matrix. Help him find the bitwise XOR of all elements of this matrix.
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first and only line of each test case contains three space-separated integers $N$, $M$ and $K$.
------ Output ------
For each test case, print a single line containing one integer ― the bitwise XOR of all elements of the tasty matrix with the given dimensions made with the given special ingredient.
------ Constraints ------
$1 ≤ T ≤ 10^{5}$
$1 ≤ N, M ≤ 2 \cdot 10^{6}$
$1 ≤ K ≤ 10^{9}$
the sum of $N$ over all test cases does not exceed $2 \cdot 10^{6}$
the sum of $M$ over all test cases does not exceed $2 \cdot 10^{6}$
----- Sample Input 1 ------
2
2 2 5
2 3 7
----- Sample Output 1 ------
14
5
----- explanation 1 ------
Example case 1: The matrix is
$$A = \begin{pmatrix}
5 + 1 + 1 & 5 + 1 + 2\\
5 + 2 + 1 & 5 + 2 + 2\end{pmatrix}
= \begin{pmatrix}
7 & 8 \\
8 & 9
\end{pmatrix} \,.$$
The XOR of all its elements is $7 \oplus 8 \oplus 8 \oplus 9 = 14$.
Example case 2: The matrix is
$$A = \begin{pmatrix}
7 + 1 + 1 & 7 + 1 + 2 & 7 + 1 + 3\\
7 + 2 + 1 & 7 + 2 + 2 & 7 + 2 + 3
\end{pmatrix}
= \begin{pmatrix}
9 & 10 & 11\\
10 & 11 & 12
\end{pmatrix} \,.$$
The XOR of all its elements is $9 \oplus 10 \oplus 11 \oplus 10 \oplus 11 \oplus 12 = 5$.
|
for _ in range(int(input())):
n, m, k = map(int, input().split())
c = 0
x = 0
if n % 2 == 0:
x = n
else:
x = n - 1
for i in range(1, x + 1):
if i % 2 == 1:
c ^= k + i + 1
else:
c ^= k + m + i
if n % 2 == 1:
for j in range(1, m + 1):
c ^= n + j + k
print(c)
|
FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER IF BIN_OP VAR NUMBER NUMBER ASSIGN VAR VAR ASSIGN VAR BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER IF BIN_OP VAR NUMBER NUMBER VAR BIN_OP BIN_OP VAR VAR NUMBER VAR BIN_OP BIN_OP VAR VAR VAR IF BIN_OP VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER VAR BIN_OP BIN_OP VAR VAR VAR EXPR FUNC_CALL VAR VAR
|
Read problems statements in [Mandarin Chinese], [Russian], [Vietnamese], and [Bengali] as well.
Chef has a *tasty ingredient* ― an integer $K$. He defines a *tasty matrix* $A$ with $N$ rows (numbered $1$ through $N$) and $M$ columns (numbered $1$ through $M$) as $A_{i, j} = K + i + j$ for each valid $i,j$.
Currently, Chef is busy in the kitchen making this tasty matrix. Help him find the bitwise XOR of all elements of this matrix.
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first and only line of each test case contains three space-separated integers $N$, $M$ and $K$.
------ Output ------
For each test case, print a single line containing one integer ― the bitwise XOR of all elements of the tasty matrix with the given dimensions made with the given special ingredient.
------ Constraints ------
$1 ≤ T ≤ 10^{5}$
$1 ≤ N, M ≤ 2 \cdot 10^{6}$
$1 ≤ K ≤ 10^{9}$
the sum of $N$ over all test cases does not exceed $2 \cdot 10^{6}$
the sum of $M$ over all test cases does not exceed $2 \cdot 10^{6}$
----- Sample Input 1 ------
2
2 2 5
2 3 7
----- Sample Output 1 ------
14
5
----- explanation 1 ------
Example case 1: The matrix is
$$A = \begin{pmatrix}
5 + 1 + 1 & 5 + 1 + 2\\
5 + 2 + 1 & 5 + 2 + 2\end{pmatrix}
= \begin{pmatrix}
7 & 8 \\
8 & 9
\end{pmatrix} \,.$$
The XOR of all its elements is $7 \oplus 8 \oplus 8 \oplus 9 = 14$.
Example case 2: The matrix is
$$A = \begin{pmatrix}
7 + 1 + 1 & 7 + 1 + 2 & 7 + 1 + 3\\
7 + 2 + 1 & 7 + 2 + 2 & 7 + 2 + 3
\end{pmatrix}
= \begin{pmatrix}
9 & 10 & 11\\
10 & 11 & 12
\end{pmatrix} \,.$$
The XOR of all its elements is $9 \oplus 10 \oplus 11 \oplus 10 \oplus 11 \oplus 12 = 5$.
|
for _ in range(int(input())):
n, m, k = map(int, input().split())
arr = [i for i in range(2, n + m + 1)]
diffarray = [0] * (n + m + 1)
for i in range(n):
diffarray[i] += 1
diffarray[i + m] -= 1
count = 0
ans = 0
for i in range(len(diffarray)):
count += diffarray[i]
if i <= len(arr):
if count % 2 != 0:
ans = ans ^ arr[i] + k
print(ans)
|
FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR VAR VAR FUNC_CALL VAR NUMBER BIN_OP BIN_OP VAR VAR NUMBER ASSIGN VAR BIN_OP LIST NUMBER BIN_OP BIN_OP VAR VAR NUMBER FOR VAR FUNC_CALL VAR VAR VAR VAR NUMBER VAR BIN_OP VAR VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR VAR VAR VAR IF VAR FUNC_CALL VAR VAR IF BIN_OP VAR NUMBER NUMBER ASSIGN VAR BIN_OP VAR BIN_OP VAR VAR VAR EXPR FUNC_CALL VAR VAR
|
Read problems statements in [Mandarin Chinese], [Russian], [Vietnamese], and [Bengali] as well.
Chef has a *tasty ingredient* ― an integer $K$. He defines a *tasty matrix* $A$ with $N$ rows (numbered $1$ through $N$) and $M$ columns (numbered $1$ through $M$) as $A_{i, j} = K + i + j$ for each valid $i,j$.
Currently, Chef is busy in the kitchen making this tasty matrix. Help him find the bitwise XOR of all elements of this matrix.
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first and only line of each test case contains three space-separated integers $N$, $M$ and $K$.
------ Output ------
For each test case, print a single line containing one integer ― the bitwise XOR of all elements of the tasty matrix with the given dimensions made with the given special ingredient.
------ Constraints ------
$1 ≤ T ≤ 10^{5}$
$1 ≤ N, M ≤ 2 \cdot 10^{6}$
$1 ≤ K ≤ 10^{9}$
the sum of $N$ over all test cases does not exceed $2 \cdot 10^{6}$
the sum of $M$ over all test cases does not exceed $2 \cdot 10^{6}$
----- Sample Input 1 ------
2
2 2 5
2 3 7
----- Sample Output 1 ------
14
5
----- explanation 1 ------
Example case 1: The matrix is
$$A = \begin{pmatrix}
5 + 1 + 1 & 5 + 1 + 2\\
5 + 2 + 1 & 5 + 2 + 2\end{pmatrix}
= \begin{pmatrix}
7 & 8 \\
8 & 9
\end{pmatrix} \,.$$
The XOR of all its elements is $7 \oplus 8 \oplus 8 \oplus 9 = 14$.
Example case 2: The matrix is
$$A = \begin{pmatrix}
7 + 1 + 1 & 7 + 1 + 2 & 7 + 1 + 3\\
7 + 2 + 1 & 7 + 2 + 2 & 7 + 2 + 3
\end{pmatrix}
= \begin{pmatrix}
9 & 10 & 11\\
10 & 11 & 12
\end{pmatrix} \,.$$
The XOR of all its elements is $9 \oplus 10 \oplus 11 \oplus 10 \oplus 11 \oplus 12 = 5$.
|
for _ in range(int(input())):
N, M, K = map(int, input().strip().split())
last = 0
for i in range(1, N // 2 + 1):
last ^= K + i * 2
last ^= K + M + i * 2
if N % 2 != 0:
for i in range(K + N + 1, K + N + M + 1):
last ^= i
print(last)
|
FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP BIN_OP VAR NUMBER NUMBER VAR BIN_OP VAR BIN_OP VAR NUMBER VAR BIN_OP BIN_OP VAR VAR BIN_OP VAR NUMBER IF BIN_OP VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR BIN_OP BIN_OP VAR VAR NUMBER BIN_OP BIN_OP BIN_OP VAR VAR VAR NUMBER VAR VAR EXPR FUNC_CALL VAR VAR
|
Read problems statements in [Mandarin Chinese], [Russian], [Vietnamese], and [Bengali] as well.
Chef has a *tasty ingredient* ― an integer $K$. He defines a *tasty matrix* $A$ with $N$ rows (numbered $1$ through $N$) and $M$ columns (numbered $1$ through $M$) as $A_{i, j} = K + i + j$ for each valid $i,j$.
Currently, Chef is busy in the kitchen making this tasty matrix. Help him find the bitwise XOR of all elements of this matrix.
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first and only line of each test case contains three space-separated integers $N$, $M$ and $K$.
------ Output ------
For each test case, print a single line containing one integer ― the bitwise XOR of all elements of the tasty matrix with the given dimensions made with the given special ingredient.
------ Constraints ------
$1 ≤ T ≤ 10^{5}$
$1 ≤ N, M ≤ 2 \cdot 10^{6}$
$1 ≤ K ≤ 10^{9}$
the sum of $N$ over all test cases does not exceed $2 \cdot 10^{6}$
the sum of $M$ over all test cases does not exceed $2 \cdot 10^{6}$
----- Sample Input 1 ------
2
2 2 5
2 3 7
----- Sample Output 1 ------
14
5
----- explanation 1 ------
Example case 1: The matrix is
$$A = \begin{pmatrix}
5 + 1 + 1 & 5 + 1 + 2\\
5 + 2 + 1 & 5 + 2 + 2\end{pmatrix}
= \begin{pmatrix}
7 & 8 \\
8 & 9
\end{pmatrix} \,.$$
The XOR of all its elements is $7 \oplus 8 \oplus 8 \oplus 9 = 14$.
Example case 2: The matrix is
$$A = \begin{pmatrix}
7 + 1 + 1 & 7 + 1 + 2 & 7 + 1 + 3\\
7 + 2 + 1 & 7 + 2 + 2 & 7 + 2 + 3
\end{pmatrix}
= \begin{pmatrix}
9 & 10 & 11\\
10 & 11 & 12
\end{pmatrix} \,.$$
The XOR of all its elements is $9 \oplus 10 \oplus 11 \oplus 10 \oplus 11 \oplus 12 = 5$.
|
def prog_name():
n, m, k = map(int, input().split())
x = 0
c = 0
if n % 2 == 0:
x = n
else:
x = n - 1
for x in range(1, x + 1):
if x % 2 == 1:
c ^= k + x + 1
else:
c ^= k + m + x
if n % 2 == 1:
for y in range(1, m + 1):
c ^= k + y + n
print(c)
t = int(input())
for unique in range(t):
prog_name()
|
FUNC_DEF ASSIGN VAR VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER IF BIN_OP VAR NUMBER NUMBER ASSIGN VAR VAR ASSIGN VAR BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER IF BIN_OP VAR NUMBER NUMBER VAR BIN_OP BIN_OP VAR VAR NUMBER VAR BIN_OP BIN_OP VAR VAR VAR IF BIN_OP VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER VAR BIN_OP BIN_OP VAR VAR VAR EXPR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR
|
Read problems statements in [Mandarin Chinese], [Russian], [Vietnamese], and [Bengali] as well.
Chef has a *tasty ingredient* ― an integer $K$. He defines a *tasty matrix* $A$ with $N$ rows (numbered $1$ through $N$) and $M$ columns (numbered $1$ through $M$) as $A_{i, j} = K + i + j$ for each valid $i,j$.
Currently, Chef is busy in the kitchen making this tasty matrix. Help him find the bitwise XOR of all elements of this matrix.
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first and only line of each test case contains three space-separated integers $N$, $M$ and $K$.
------ Output ------
For each test case, print a single line containing one integer ― the bitwise XOR of all elements of the tasty matrix with the given dimensions made with the given special ingredient.
------ Constraints ------
$1 ≤ T ≤ 10^{5}$
$1 ≤ N, M ≤ 2 \cdot 10^{6}$
$1 ≤ K ≤ 10^{9}$
the sum of $N$ over all test cases does not exceed $2 \cdot 10^{6}$
the sum of $M$ over all test cases does not exceed $2 \cdot 10^{6}$
----- Sample Input 1 ------
2
2 2 5
2 3 7
----- Sample Output 1 ------
14
5
----- explanation 1 ------
Example case 1: The matrix is
$$A = \begin{pmatrix}
5 + 1 + 1 & 5 + 1 + 2\\
5 + 2 + 1 & 5 + 2 + 2\end{pmatrix}
= \begin{pmatrix}
7 & 8 \\
8 & 9
\end{pmatrix} \,.$$
The XOR of all its elements is $7 \oplus 8 \oplus 8 \oplus 9 = 14$.
Example case 2: The matrix is
$$A = \begin{pmatrix}
7 + 1 + 1 & 7 + 1 + 2 & 7 + 1 + 3\\
7 + 2 + 1 & 7 + 2 + 2 & 7 + 2 + 3
\end{pmatrix}
= \begin{pmatrix}
9 & 10 & 11\\
10 & 11 & 12
\end{pmatrix} \,.$$
The XOR of all its elements is $9 \oplus 10 \oplus 11 \oplus 10 \oplus 11 \oplus 12 = 5$.
|
for i in range(int(input())):
a, b, c = map(int, input().split())
e = 0
for i in range(2, a + 2):
d = min(i - 1, b)
if d % 2 == 0:
pass
else:
e ^= i + c
for i in range(a + 2, a + b + 1):
f = min(a, b - (i - a) + 1)
if f % 2 == 0:
pass
else:
e ^= i + c
print(e)
|
FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER ASSIGN VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR IF BIN_OP VAR NUMBER NUMBER VAR BIN_OP VAR VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER BIN_OP BIN_OP VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR BIN_OP BIN_OP VAR BIN_OP VAR VAR NUMBER IF BIN_OP VAR NUMBER NUMBER VAR BIN_OP VAR VAR EXPR FUNC_CALL VAR VAR
|
Read problems statements in [Mandarin Chinese], [Russian], [Vietnamese], and [Bengali] as well.
Chef has a *tasty ingredient* ― an integer $K$. He defines a *tasty matrix* $A$ with $N$ rows (numbered $1$ through $N$) and $M$ columns (numbered $1$ through $M$) as $A_{i, j} = K + i + j$ for each valid $i,j$.
Currently, Chef is busy in the kitchen making this tasty matrix. Help him find the bitwise XOR of all elements of this matrix.
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first and only line of each test case contains three space-separated integers $N$, $M$ and $K$.
------ Output ------
For each test case, print a single line containing one integer ― the bitwise XOR of all elements of the tasty matrix with the given dimensions made with the given special ingredient.
------ Constraints ------
$1 ≤ T ≤ 10^{5}$
$1 ≤ N, M ≤ 2 \cdot 10^{6}$
$1 ≤ K ≤ 10^{9}$
the sum of $N$ over all test cases does not exceed $2 \cdot 10^{6}$
the sum of $M$ over all test cases does not exceed $2 \cdot 10^{6}$
----- Sample Input 1 ------
2
2 2 5
2 3 7
----- Sample Output 1 ------
14
5
----- explanation 1 ------
Example case 1: The matrix is
$$A = \begin{pmatrix}
5 + 1 + 1 & 5 + 1 + 2\\
5 + 2 + 1 & 5 + 2 + 2\end{pmatrix}
= \begin{pmatrix}
7 & 8 \\
8 & 9
\end{pmatrix} \,.$$
The XOR of all its elements is $7 \oplus 8 \oplus 8 \oplus 9 = 14$.
Example case 2: The matrix is
$$A = \begin{pmatrix}
7 + 1 + 1 & 7 + 1 + 2 & 7 + 1 + 3\\
7 + 2 + 1 & 7 + 2 + 2 & 7 + 2 + 3
\end{pmatrix}
= \begin{pmatrix}
9 & 10 & 11\\
10 & 11 & 12
\end{pmatrix} \,.$$
The XOR of all its elements is $9 \oplus 10 \oplus 11 \oplus 10 \oplus 11 \oplus 12 = 5$.
|
test_case = int(input())
for n1 in range(test_case):
n, m, k = [int(i) for i in input().split(" ")]
l = (
list(range(1, min(n, m)))
+ [min(n, m)] * (abs(m - n) + 1)
+ list(range(1, min(n, m)))[::-1]
)
a = 0
for i in range(len(l)):
a ^= (k + 2 + i) * (l[i] % 2)
print(a)
|
ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR STRING ASSIGN VAR BIN_OP BIN_OP FUNC_CALL VAR FUNC_CALL VAR NUMBER FUNC_CALL VAR VAR VAR BIN_OP LIST FUNC_CALL VAR VAR VAR BIN_OP FUNC_CALL VAR BIN_OP VAR VAR NUMBER FUNC_CALL VAR FUNC_CALL VAR NUMBER FUNC_CALL VAR VAR VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR VAR BIN_OP BIN_OP BIN_OP VAR NUMBER VAR BIN_OP VAR VAR NUMBER EXPR FUNC_CALL VAR VAR
|
Read problems statements in [Mandarin Chinese], [Russian], [Vietnamese], and [Bengali] as well.
Chef has a *tasty ingredient* ― an integer $K$. He defines a *tasty matrix* $A$ with $N$ rows (numbered $1$ through $N$) and $M$ columns (numbered $1$ through $M$) as $A_{i, j} = K + i + j$ for each valid $i,j$.
Currently, Chef is busy in the kitchen making this tasty matrix. Help him find the bitwise XOR of all elements of this matrix.
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first and only line of each test case contains three space-separated integers $N$, $M$ and $K$.
------ Output ------
For each test case, print a single line containing one integer ― the bitwise XOR of all elements of the tasty matrix with the given dimensions made with the given special ingredient.
------ Constraints ------
$1 ≤ T ≤ 10^{5}$
$1 ≤ N, M ≤ 2 \cdot 10^{6}$
$1 ≤ K ≤ 10^{9}$
the sum of $N$ over all test cases does not exceed $2 \cdot 10^{6}$
the sum of $M$ over all test cases does not exceed $2 \cdot 10^{6}$
----- Sample Input 1 ------
2
2 2 5
2 3 7
----- Sample Output 1 ------
14
5
----- explanation 1 ------
Example case 1: The matrix is
$$A = \begin{pmatrix}
5 + 1 + 1 & 5 + 1 + 2\\
5 + 2 + 1 & 5 + 2 + 2\end{pmatrix}
= \begin{pmatrix}
7 & 8 \\
8 & 9
\end{pmatrix} \,.$$
The XOR of all its elements is $7 \oplus 8 \oplus 8 \oplus 9 = 14$.
Example case 2: The matrix is
$$A = \begin{pmatrix}
7 + 1 + 1 & 7 + 1 + 2 & 7 + 1 + 3\\
7 + 2 + 1 & 7 + 2 + 2 & 7 + 2 + 3
\end{pmatrix}
= \begin{pmatrix}
9 & 10 & 11\\
10 & 11 & 12
\end{pmatrix} \,.$$
The XOR of all its elements is $9 \oplus 10 \oplus 11 \oplus 10 \oplus 11 \oplus 12 = 5$.
|
for i in range(int(input())):
n, m, k = map(int, input().split())
count = 1
ans = 0
for j in range(k + 2, k + m + 1):
if count >= n:
if n % 2 == 0:
break
else:
ans ^= j
elif count % 2 != 0:
ans ^= j
count += 1
count = 1
for j in range(k + m + n, k + m, -1):
if count >= m:
if m % 2 == 0:
break
else:
ans ^= j
elif count % 2 != 0:
ans ^= j
count += 1
print(ans)
|
FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER BIN_OP BIN_OP VAR VAR NUMBER IF VAR VAR IF BIN_OP VAR NUMBER NUMBER VAR VAR IF BIN_OP VAR NUMBER NUMBER VAR VAR VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP BIN_OP VAR VAR VAR BIN_OP VAR VAR NUMBER IF VAR VAR IF BIN_OP VAR NUMBER NUMBER VAR VAR IF BIN_OP VAR NUMBER NUMBER VAR VAR VAR NUMBER EXPR FUNC_CALL VAR VAR
|
Read problems statements in [Mandarin Chinese], [Russian], [Vietnamese], and [Bengali] as well.
Chef has a *tasty ingredient* ― an integer $K$. He defines a *tasty matrix* $A$ with $N$ rows (numbered $1$ through $N$) and $M$ columns (numbered $1$ through $M$) as $A_{i, j} = K + i + j$ for each valid $i,j$.
Currently, Chef is busy in the kitchen making this tasty matrix. Help him find the bitwise XOR of all elements of this matrix.
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first and only line of each test case contains three space-separated integers $N$, $M$ and $K$.
------ Output ------
For each test case, print a single line containing one integer ― the bitwise XOR of all elements of the tasty matrix with the given dimensions made with the given special ingredient.
------ Constraints ------
$1 ≤ T ≤ 10^{5}$
$1 ≤ N, M ≤ 2 \cdot 10^{6}$
$1 ≤ K ≤ 10^{9}$
the sum of $N$ over all test cases does not exceed $2 \cdot 10^{6}$
the sum of $M$ over all test cases does not exceed $2 \cdot 10^{6}$
----- Sample Input 1 ------
2
2 2 5
2 3 7
----- Sample Output 1 ------
14
5
----- explanation 1 ------
Example case 1: The matrix is
$$A = \begin{pmatrix}
5 + 1 + 1 & 5 + 1 + 2\\
5 + 2 + 1 & 5 + 2 + 2\end{pmatrix}
= \begin{pmatrix}
7 & 8 \\
8 & 9
\end{pmatrix} \,.$$
The XOR of all its elements is $7 \oplus 8 \oplus 8 \oplus 9 = 14$.
Example case 2: The matrix is
$$A = \begin{pmatrix}
7 + 1 + 1 & 7 + 1 + 2 & 7 + 1 + 3\\
7 + 2 + 1 & 7 + 2 + 2 & 7 + 2 + 3
\end{pmatrix}
= \begin{pmatrix}
9 & 10 & 11\\
10 & 11 & 12
\end{pmatrix} \,.$$
The XOR of all its elements is $9 \oplus 10 \oplus 11 \oplus 10 \oplus 11 \oplus 12 = 5$.
|
for _ in range(int(input())):
n, m, k = map(int, input().split())
a = 0
for i in range(2, m + n + 1):
l = max(1, i - m)
r = min(n, i - 1)
if r >= l and (r - l + 1) % 2 == 1:
a ^= k + i
print(a)
|
FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP BIN_OP VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR NUMBER BIN_OP VAR VAR ASSIGN VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER IF VAR VAR BIN_OP BIN_OP BIN_OP VAR VAR NUMBER NUMBER NUMBER VAR BIN_OP VAR VAR EXPR FUNC_CALL VAR VAR
|
You are given a weighted tree with $n$ vertices. Recall that a tree is a connected graph without any cycles. A weighted tree is a tree in which each edge has a certain weight. The tree is undirected, it doesn't have a root.
Since trees bore you, you decided to challenge yourself and play a game on the given tree.
In a move, you can travel from a node to one of its neighbors (another node it has a direct edge with).
You start with a variable $x$ which is initially equal to $0$. When you pass through edge $i$, $x$ changes its value to $x ~\mathsf{XOR}~ w_i$ (where $w_i$ is the weight of the $i$-th edge).
Your task is to go from vertex $a$ to vertex $b$, but you are allowed to enter node $b$ if and only if after traveling to it, the value of $x$ will become $0$. In other words, you can travel to node $b$ only by using an edge $i$ such that $x ~\mathsf{XOR}~ w_i = 0$. Once you enter node $b$ the game ends and you win.
Additionally, you can teleport at most once at any point in time to any vertex except vertex $b$. You can teleport from any vertex, even from $a$.
Answer with "YES" if you can reach vertex $b$ from $a$, and "NO" otherwise.
Note that $\mathsf{XOR}$ represents the bitwise XOR operation .
-----Input-----
The first line contains a single integer $t$ ($1 \leq t \leq 1000$) — the number of test cases.
The first line of each test case contains three integers $n$, $a$, and $b$ ($2 \leq n \leq 10^5$), ($1 \leq a, b \leq n; a \ne b$) — the number of vertices, and the starting and desired ending node respectively.
Each of the next $n-1$ lines denotes an edge of the tree. Edge $i$ is denoted by three integers $u_i$, $v_i$ and $w_i$ — the labels of vertices it connects ($1 \leq u_i, v_i \leq n; u_i \ne v_i; 1 \leq w_i \leq 10^9$) and the weight of the respective edge.
It is guaranteed that the sum of $n$ over all test cases does not exceed $10^5$.
-----Output-----
For each test case output "YES" if you can reach vertex $b$, and "NO" otherwise.
-----Examples-----
Input
3
5 1 4
1 3 1
2 3 2
4 3 3
3 5 1
2 1 2
1 2 2
6 2 3
1 2 1
2 3 1
3 4 1
4 5 3
5 6 5
Output
YES
NO
YES
-----Note-----
For the first test case, we can travel from node $1$ to node $3$, $x$ changing from $0$ to $1$, then we travel from node $3$ to node $2$, $x$ becoming equal to $3$. Now, we can teleport to node $3$ and travel from node $3$ to node $4$, reaching node $b$, since $x$ became equal to $0$ in the end, so we should answer "YES".
For the second test case, we have no moves, since we can't teleport to node $b$ and the only move we have is to travel to node $2$ which is impossible since $x$ wouldn't be equal to $0$ when reaching it, so we should answer "NO".
|
testcase = int(input())
for _ in range(testcase):
n, a, b = [int(num) for num in input().split()]
graph = {i: set() for i in range(1, n + 1)}
for _ in range(n - 1):
v0, v1, w = [int(num) for num in input().split()]
graph[v0].add((v1, w))
graph[v1].add((v0, w))
seen = set()
seen.add(a)
ha = [(a, 0)]
ass = set()
ass.add(0)
while ha:
q, xor = ha.pop()
for adj, w in graph[q]:
if adj not in seen:
if adj == b:
continue
seen.add(adj)
k = xor ^ w
ha.append((adj, k))
ass.add(k)
seen = set()
seen.add(b)
hb = [(b, 0)]
bss = set()
while hb:
q, xor = hb.pop()
for adj, w in graph[q]:
if adj not in seen:
seen.add(adj)
k = xor ^ w
hb.append((adj, k))
bss.add(k)
bss = list(bss)
bss = [(num in ass) for num in bss]
print("YES" if any(bss) else "NO")
|
ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR VAR VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR EXPR FUNC_CALL VAR VAR VAR VAR EXPR FUNC_CALL VAR VAR VAR VAR ASSIGN VAR FUNC_CALL VAR EXPR FUNC_CALL VAR VAR ASSIGN VAR LIST VAR NUMBER ASSIGN VAR FUNC_CALL VAR EXPR FUNC_CALL VAR NUMBER WHILE VAR ASSIGN VAR VAR FUNC_CALL VAR FOR VAR VAR VAR VAR IF VAR VAR IF VAR VAR EXPR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP VAR VAR EXPR FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR EXPR FUNC_CALL VAR VAR ASSIGN VAR LIST VAR NUMBER ASSIGN VAR FUNC_CALL VAR WHILE VAR ASSIGN VAR VAR FUNC_CALL VAR FOR VAR VAR VAR VAR IF VAR VAR EXPR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP VAR VAR EXPR FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR VAR STRING STRING
|
You are given a weighted tree with $n$ vertices. Recall that a tree is a connected graph without any cycles. A weighted tree is a tree in which each edge has a certain weight. The tree is undirected, it doesn't have a root.
Since trees bore you, you decided to challenge yourself and play a game on the given tree.
In a move, you can travel from a node to one of its neighbors (another node it has a direct edge with).
You start with a variable $x$ which is initially equal to $0$. When you pass through edge $i$, $x$ changes its value to $x ~\mathsf{XOR}~ w_i$ (where $w_i$ is the weight of the $i$-th edge).
Your task is to go from vertex $a$ to vertex $b$, but you are allowed to enter node $b$ if and only if after traveling to it, the value of $x$ will become $0$. In other words, you can travel to node $b$ only by using an edge $i$ such that $x ~\mathsf{XOR}~ w_i = 0$. Once you enter node $b$ the game ends and you win.
Additionally, you can teleport at most once at any point in time to any vertex except vertex $b$. You can teleport from any vertex, even from $a$.
Answer with "YES" if you can reach vertex $b$ from $a$, and "NO" otherwise.
Note that $\mathsf{XOR}$ represents the bitwise XOR operation .
-----Input-----
The first line contains a single integer $t$ ($1 \leq t \leq 1000$) — the number of test cases.
The first line of each test case contains three integers $n$, $a$, and $b$ ($2 \leq n \leq 10^5$), ($1 \leq a, b \leq n; a \ne b$) — the number of vertices, and the starting and desired ending node respectively.
Each of the next $n-1$ lines denotes an edge of the tree. Edge $i$ is denoted by three integers $u_i$, $v_i$ and $w_i$ — the labels of vertices it connects ($1 \leq u_i, v_i \leq n; u_i \ne v_i; 1 \leq w_i \leq 10^9$) and the weight of the respective edge.
It is guaranteed that the sum of $n$ over all test cases does not exceed $10^5$.
-----Output-----
For each test case output "YES" if you can reach vertex $b$, and "NO" otherwise.
-----Examples-----
Input
3
5 1 4
1 3 1
2 3 2
4 3 3
3 5 1
2 1 2
1 2 2
6 2 3
1 2 1
2 3 1
3 4 1
4 5 3
5 6 5
Output
YES
NO
YES
-----Note-----
For the first test case, we can travel from node $1$ to node $3$, $x$ changing from $0$ to $1$, then we travel from node $3$ to node $2$, $x$ becoming equal to $3$. Now, we can teleport to node $3$ and travel from node $3$ to node $4$, reaching node $b$, since $x$ became equal to $0$ in the end, so we should answer "YES".
For the second test case, we have no moves, since we can't teleport to node $b$ and the only move we have is to travel to node $2$ which is impossible since $x$ wouldn't be equal to $0$ when reaching it, so we should answer "NO".
|
stack = []
hashesSt = set()
t = int(input())
for _ in range(t):
n, st, fi = map(int, input().split())
st -= 1
fi -= 1
g = [[] for i in range(n)]
for i in range(n - 1):
a, b, w = map(int, input().split())
a -= 1
b -= 1
g[a].append((b, w))
g[b].append((a, w))
hashesSt.clear()
used = [False] * n
used[fi] = True
stack.append((st, 0))
while stack:
ver, hsh = stack.pop()
used[ver] = True
hashesSt.add(hsh)
for to, w in g[ver]:
if not used[to]:
stack.append((to, hsh ^ w))
used = [False] * n
stack.append((fi, 0))
found = False
while stack:
ver, hsh = stack.pop()
used[ver] = True
if ver != fi and hsh in hashesSt:
stack.clear()
found = True
break
for to, w in g[ver]:
if not used[to]:
stack.append((to, hsh ^ w))
print("YES" if found else "NO")
|
ASSIGN VAR LIST ASSIGN VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR VAR NUMBER VAR NUMBER ASSIGN VAR LIST VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR VAR VAR VAR EXPR FUNC_CALL VAR VAR VAR VAR EXPR FUNC_CALL VAR ASSIGN VAR BIN_OP LIST NUMBER VAR ASSIGN VAR VAR NUMBER EXPR FUNC_CALL VAR VAR NUMBER WHILE VAR ASSIGN VAR VAR FUNC_CALL VAR ASSIGN VAR VAR NUMBER EXPR FUNC_CALL VAR VAR FOR VAR VAR VAR VAR IF VAR VAR EXPR FUNC_CALL VAR VAR BIN_OP VAR VAR ASSIGN VAR BIN_OP LIST NUMBER VAR EXPR FUNC_CALL VAR VAR NUMBER ASSIGN VAR NUMBER WHILE VAR ASSIGN VAR VAR FUNC_CALL VAR ASSIGN VAR VAR NUMBER IF VAR VAR VAR VAR EXPR FUNC_CALL VAR ASSIGN VAR NUMBER FOR VAR VAR VAR VAR IF VAR VAR EXPR FUNC_CALL VAR VAR BIN_OP VAR VAR EXPR FUNC_CALL VAR VAR STRING STRING
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.