problem stringclasses 67
values | user stringlengths 13 13 | submission_order int64 1 57 | result stringclasses 10
values | execution_time stringlengths 0 8 | memory stringclasses 88
values | code stringlengths 47 7.62k |
|---|---|---|---|---|---|---|
QPC001_B3 | A9C4C9B1EB85B | 2 | RE | 1495 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(L):
bits = []
for bit in range(n):
if not ((i >> bit) & 1):
bits.append(bit)
qc.x(n - bit - 1)
qc.append(ZGate().control(n - 1), range(n))
for bit in bits:
qc.x(n - bit - 1)
return qc
''' |
QPC001_B3 | A9C4C9B1EB85B | 3 | RE | 1350 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(L):
bits = []
for bit in range(n):
if not ((i >> bit) & 1):
bits.append(bit)
qc.x(bit)
qc.append(ZGate().control(n - 1), range(n))
for bit in bits:
qc.x(bit)
return qc
''' |
QPC001_B3 | A9C4C9B1EB85B | 4 | RE | 1440 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(L):
bits = []
for bit in range(n):
if not ((i >> (n - bit - 1)) & 1):
bits.append(bit)
qc.x((n - bit - 1))
qc.append(ZGate().control(n - 1), range(n))
for bit in bits:
qc.x(n - bit - 1)
return qc
''' |
QPC001_B3 | A9D10C7A3C952 | 1 | RE | 787 ms | 79 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(L):
for j in range(n):
if (i&(1<<j)) <= 0:
qc.x(j)
qc.mcp(math.pi, list(range(n-1)), n-1)
for j in range(n):
if (i&(1<<j)) <= 0:
qc.x(j)
return qc
''' |
QPC001_B3 | A9D10C7A3C952 | 2 | AC | 1208 ms | 91 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
if n == 1 and L == 1:
qc.p(math.pi, 0)
if n == 1:
return qc
for i in range(L):
for j in range(n):
if (i&(1<<j)) <= 0:
qc.x(j)
qc.mcp(math.pi, list(range(n-1)), n-1)
for j in range(n):
if (i&(1<<j)) <= 0:
qc.x(j)
return qc
''' |
QPC001_B3 | A9DF91A7BCC24 | 1 | RE | 849 ms | 79 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
num_qubits = 3
for k in range(L):
# Get binary representation of the number, padded to the number of qubits
binary_rep = format(k, '0' + str(num_qubits) + 'b')
# List to keep track of which qubits need the X gate (for flipping |1> to |0>)
x_gates_needed = []
for qubit_index, bit in enumerate(reversed(binary_rep)):
if bit == '0':
# Apply X gate to flip |0> to |1>, if needed
qc.x(qubit_index)
x_gates_needed.append(qubit_index)
# Apply controlled Z gate
if len(x_gates_needed) < num_qubits:
control_qubits = [i for i in range(num_qubits) if i not in x_gates_needed]
target_qubit = control_qubits[-1]
if len(control_qubits) > 1:
qc.h(target_qubit)
qc.mct(control_qubits[:-1], target_qubit) # Multi-controlled Toffoli
qc.h(target_qubit)
else:
# If there is only one control qubit, apply Z gate directly
qc.z(target_qubit)
# Revert the X gates
for qubit_index in x_gates_needed:
qc.x(qubit_index)
qc.barrier()
return qc
''' |
QPC001_B3 | A9DF91A7BCC24 | 2 | RE | 840 ms | 79 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
num_qubits = 3
for k in range(L):
binary_rep = format(k, '0' + str(num_qubits) + 'b')
# List to keep track of which qubits need the X gate (for flipping |1> to |0>)
x_gates_needed = []
for qubit_index, bit in enumerate(reversed(binary_rep)):
if bit == '0':
# Apply X gate to flip |0> to |1>, if needed
qc.x(qubit_index)
x_gates_needed.append(qubit_index)
# Apply controlled Z gate
if len(x_gates_needed) < num_qubits:
control_qubits = [i for i in range(num_qubits) if i not in x_gates_needed]
target_qubit = control_qubits[-1]
if len(control_qubits) > 1:
qc.h(target_qubit)
qc.mct(control_qubits[:-1], target_qubit) # Multi-controlled Toffoli
qc.h(target_qubit)
else:
# If there is only one control qubit, apply Z gate directly
qc.z(target_qubit)
# Revert the X gates
for qubit_index in x_gates_needed:
qc.x(qubit_index)
qc.barrier()
return qc
''' |
QPC001_B3 | A9DF91A7BCC24 | 3 | RE | 956 ms | 79 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for k in range(L):
binary_rep = format(k, '0' + str(num_qubits) + 'b')
x_gates_needed = []
for qubit_index, bit in enumerate(reversed(binary_rep)):
if bit == '0':
qc.x(qubit_index)
x_gates_needed.append(qubit_index)
if len(x_gates_needed) < num_qubits:
control_qubits = [i for i in range(num_qubits) if i not in x_gates_needed]
target_qubit = control_qubits[-1]
if len(control_qubits) > 1:
qc.h(target_qubit)
qc.mct(control_qubits[:-1], target_qubit)
qc.h(target_qubit)
else:
qc.z(target_qubit)
for qubit_index in x_gates_needed:
qc.x(qubit_index)
# qc.barrier()
return qc
''' |
QPC001_B3 | A9DF91A7BCC24 | 4 | RE | 829 ms | 79 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for k in range(L):
# Get binary representation of the number, padded to the number of qubits
binary_rep = format(k, '0' + str(num_qubits) + 'b')
# List to keep track of which qubits need the X gate (for flipping |1> to |0>)
x_gates_needed = []
for qubit_index, bit in enumerate(reversed(binary_rep)):
if bit == '0':
# Apply X gate to flip |0> to |1>, if needed
qc.x(qubit_index)
x_gates_needed.append(qubit_index)
# Apply controlled Z gate
# if len(x_gates_needed) < num_qubits:
control_qubits = [i for i in range(num_qubits) if i not in x_gates_needed]
print(len(control_qubits))
if len(control_qubits) >= 1:
qc.append(ZGate().control(len(x_gates_needed)), x_gates_needed+[control_qubits[0]])
# qc.h(target_qubit)
# qc.mcZ(x_gates_needed, control_qubits[0]) # Multi-controlled Toffoli
# qc.h(target_qubit)
# else:
# If there is only one control qubit, apply Z gate directly
# qc.z(target_qubit)
# # Revert the X gates
# for qubit_index in x_gates_needed:
# qc.x(qubit_index)
qc.barrier()
return qc
''' |
QPC001_B3 | A9DF91A7BCC24 | 5 | RE | 817 ms | 78 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for k in range(L):
# Get binary representation of the number, padded to the number of qubits
binary_rep = format(k, '0' + str(num_qubits) + 'b')
# List to keep track of which qubits need the X gate (for flipping |1> to |0>)
x_gates_needed = []
for qubit_index, bit in enumerate(reversed(binary_rep)):
if bit == '0':
# Apply X gate to flip |0> to |1>, if needed
qc.x(qubit_index)
x_gates_needed.append(qubit_index)
# Apply controlled Z gate
# if len(x_gates_needed) < num_qubits:
control_qubits = [i for i in range(num_qubits) if i not in x_gates_needed]
print(len(control_qubits))
if len(control_qubits) >= 1:
qc.append(ZGate().control(len(x_gates_needed)), x_gates_needed+[control_qubits[0]])
# qc.h(target_qubit)
# qc.mcZ(x_gates_needed, control_qubits[0]) # Multi-controlled Toffoli
# qc.h(target_qubit)
# else:
# If there is only one control qubit, apply Z gate directly
# qc.z(target_qubit)
# # Revert the X gates
# for qubit_index in x_gates_needed:
# qc.x(qubit_index)
qc.barrier()
return qc
''' |
QPC001_B3 | A9DF91A7BCC24 | 6 | RE | 924 ms | 79 MiB | '''python
from qiskit import QuantumCircuit, ZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for k in range(L):
binary_rep = format(k, '0' + str(num_qubits) + 'b')
x_gates_needed = []
for qubit_index, bit in enumerate(reversed(binary_rep)):
if bit == '0':
qc.x(qubit_index)
x_gates_needed.append(qubit_index)
# Apply controlled Z gate
control_qubits = [i for i in range(num_qubits) if i not in x_gates_needed]
print(len(control_qubits))
if len(control_qubits) >= 1:
qc.append(ZGate().control(len(x_gates_needed)), x_gates_needed+[control_qubits[0]])
qc.barrier()
return qc
''' |
QPC001_B3 | A9DF91A7BCC24 | 7 | RE | 948 ms | 79 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for k in range(L):
binary_rep = format(k, '0' + str(num_qubits) + 'b')
x_gates_needed = []
for qubit_index, bit in enumerate(reversed(binary_rep)):
if bit == '0':
qc.x(qubit_index)
x_gates_needed.append(qubit_index)
# Apply controlled Z gate
control_qubits = [i for i in range(num_qubits) if i not in x_gates_needed]
print(len(control_qubits))
if len(control_qubits) >= 1:
qc.append(ZGate().control(len(x_gates_needed)), x_gates_needed+[control_qubits[0]])
qc.barrier()
return qc
''' |
QPC001_B3 | A9DF91A7BCC24 | 8 | RE | 927 ms | 79 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for k in range(L):
binary_rep = format(k, '0' + str(n) + 'b')
x_gates_needed = []
for qubit_index, bit in enumerate(reversed(binary_rep)):
if bit == '0':
qc.x(qubit_index)
x_gates_needed.append(qubit_index)
# Apply controlled Z gate
control_qubits = [i for i in range(n) if i not in x_gates_needed]
print(len(control_qubits))
if len(control_qubits) >= 1:
qc.append(ZGate().control(len(x_gates_needed)), x_gates_needed+[control_qubits[0]])
qc.barrier()
return qc
''' |
QPC001_B3 | A9DF91A7BCC24 | 9 | WA | 1235 ms | 93 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for k in range(L):
binary_rep = format(k, '0' + str(n) + 'b')
x_gates_needed = []
for qubit_index, bit in enumerate(reversed(binary_rep)):
if bit == '0':
qc.x(qubit_index)
x_gates_needed.append(qubit_index)
# Apply controlled Z gate
control_qubits = [i for i in range(n) if i not in x_gates_needed]
print(len(control_qubits))
if len(control_qubits) >= 1:
qc.append(ZGate().control(len(x_gates_needed)), x_gates_needed+[control_qubits[0]])
return qc
''' |
QPC001_B3 | A9DF91A7BCC24 | 10 | RE | 832 ms | 79 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for k in range(L):
binary_rep = format(k, '0' + str(n) + 'b')
x_gates_needed = []
for qubit_index, bit in enumerate(reversed(binary_rep)):
if bit == '0':
qc.x(qubit_index)
x_gates_needed.append(qubit_index)
# Apply controlled Z gate
control_qubits = [i for i in range(n) if i not in x_gates_needed]
print(len(control_qubits))
if len(control_qubits) >= 1:
qc.append(ZGate().control(len(x_gates_needed)), x_gates_needed+[control_qubits[0]])
return qc
''' |
QPC001_B3 | A9DF91A7BCC24 | 11 | RE | 772 ms | 79 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for l in range(L):
for i in range(n):
# check if i-th bit of l is 0 or 1
if not ((l >> i) & 1):
qc.x(i)
if n == 1:
qc.z(0)
else:
# apply multiple controlled Z gate
qc.append(ZGate().control(n - 1), range(n))
for i in range(n):
if not ((l >> i) & 1):
qc.x(i)
return qc
''' |
QPC001_B3 | A9DF91A7BCC24 | 12 | RE | 803 ms | 78 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for l in range(L):
for i in range(n):
# check if i-th bit of l is 0 or 1
if not ((l >> i) & 1):
qc.x(i)
# if n == 1:
# qc.z(0)
# else:
# # apply multiple controlled Z gate
# qc.append(ZGate().control(n - 1), range(n))
# for i in range(n):
# if not ((l >> i) & 1):
# qc.x(i)
return qc
''' |
QPC001_B3 | A9DF91A7BCC24 | 13 | RE | 784 ms | 79 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# for l in range(L):
# for i in range(n):
# # check if i-th bit of l is 0 or 1
# if not ((l >> i) & 1):
# qc.x(i)
# if n == 1:
# qc.z(0)
# else:
# # apply multiple controlled Z gate
# qc.append(ZGate().control(n - 1), range(n))
# for i in range(n):
# if not ((l >> i) & 1):
# qc.x(i)
return qc
''' |
QPC001_B3 | A9DF91A7BCC24 | 14 | RE | 889 ms | 79 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# for l in range(L):
# for i in range(n):
# # check if i-th bit of l is 0 or 1
# if not ((l >> i) & 1):
# qc.x(i)
# if n == 1:
# qc.z(0)
# else:
# # apply multiple controlled Z gate
# qc.append(ZGate().control(n - 1), range(n))
# for i in range(n):
# if not ((l >> i) & 1):
# qc.x(i)
return qc
''' |
QPC001_B3 | A9DF91A7BCC24 | 15 | RE | 905 ms | 78 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# for l in range(L):
# for i in range(n):
# # check if i-th bit of l is 0 or 1
# if not ((l >> i) & 1):
# qc.x(i)
# if n == 1:
# qc.z(0)
# else:
# # apply multiple controlled Z gate
# qc.append(ZGate().control(n - 1), range(n))
# for i in range(n):
# if not ((l >> i) & 1):
# qc.x(i)
return qc
''' |
QPC001_B3 | AA24692EF1DEB | 1 | AC | 1643 ms | 91 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
m = L
mbin = []
k = m
tmp = 0
while(tmp < n):
mbin = mbin + [k%2]
k = k //2
tmp += 1
if mbin[n-1] == 0:
qc.x(n-1)
else:
qc.x(n-1)
qc.z(n-1)
qc.x(n-1)
for i in range(n-2, -1, -1):
bi = mbin[i]
if bi == 0:
qc.x(i)
else:
qc.x(i)
lis = [j for j in range(i+1,n)]
qc.mcp(math.pi, lis, i)
qc.x(i)
for i in range(n):
if mbin[i] == 0:
qc.x(i)
return qc
''' |
QPC001_B3 | AA2C9E7244AB2 | 1 | RE | 772 ms | 79 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(L):
for j in range(n):
if ((i >> j) & 1) == 0:
qc.x(j)
qc.append(ZGate().control(n - 1), range(n))
for j in range(n):
if ((i >> j) & 1) == 0:
qc.x(j)
return qc
''' |
QPC001_B3 | AA2C9E7244AB2 | 2 | RE | 989 ms | 79 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(L):
for j in range(n):
if ((i >> j) & 1) == 0:
qc.x(j)
qc.mcp(math.pi, range(n - 1), n - 1)
for j in range(n):
if ((i >> j) & 1) == 0:
qc.x(j)
return qc
''' |
QPC001_B3 | AA2C9E7244AB2 | 3 | RE | 1033 ms | 91 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(L):
for j in range(n):
if ((i >> j) & 1) == 0:
qc.x(j)
qc.append(ZGate().control(n - 1), range(n))
for j in range(n):
if ((i >> j) & 1) == 0:
qc.x(j)
return qc
''' |
QPC001_B3 | AA2C9E7244AB2 | 4 | AC | 2780 ms | 97 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(L):
for j in range(n):
if ((i >> j) & 1) == 0:
qc.x(j)
if n == 1:
qc.z(0)
else:
qc.append(ZGate().control(n - 1), range(n))
for j in range(n):
if ((i >> j) & 1) == 0:
qc.x(j)
return qc
''' |
QPC001_B3 | AA2CC3C531AA8 | 1 | RE | 952 ms | 79 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.h(i)
for l in range(L):
b = 1
for i in range(n):
if l & b == 0:
qc.x(i)
b = b << 1
qc.append(ZGate().control(n-1), range(n))
b = 1
for i in range(n):
if l & b == 0:
qc.x(i)
b = b << 1
return qc
''' |
QPC001_B3 | AA2CC3C531AA8 | 2 | RE | 912 ms | 79 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.h(i)
for l in range(L):
b = 1
for i in range(n):
if l & b == 0:
qc.x(i)
b = b << 1
qc.append(ZGate().control(n-1), range(n))
b = 1
for i in range(n):
if l & b == 0:
qc.x(i)
b = b << 1
return qc
''' |
QPC001_B3 | AA2CC3C531AA8 | 3 | RE | 949 ms | 90 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.h(i)
for l in range(L):
b = 1
for i in range(n):
if l & b == 0:
qc.x(i)
b = b << 1
qc.append(ZGate().control(n-1), range(n))
b = 1
for i in range(n):
if l & b == 0:
qc.x(i)
b = b << 1
return qc
''' |
QPC001_B3 | AA2CC3C531AA8 | 4 | WA | 951 ms | 90 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.h(i)
if n == 1:
if L == 1:
qc.x(0)
qc.z(0)
qc.x(0)
if L == 2:
qc.x(0)
qc.z(0)
qc.x(0)
qc.z(0)
else:
for l in range(L):
b = 1
for i in range(n):
if l & b == 0:
qc.x(i)
b = b << 1
qc.append(ZGate().control(n-1), range(n))
b = 1
for i in range(n):
if l & b == 0:
qc.x(i)
b = b << 1
return qc
''' |
QPC001_B3 | AA2CC3C531AA8 | 5 | AC | 1821 ms | 95 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
if n == 1:
if L == 1:
qc.x(0)
qc.z(0)
qc.x(0)
if L == 2:
qc.x(0)
qc.z(0)
qc.x(0)
qc.z(0)
else:
for l in range(L):
b = 1
for i in range(n):
if l & b == 0:
qc.x(i)
b = b << 1
qc.append(ZGate().control(n-1), range(n))
b = 1
for i in range(n):
if l & b == 0:
qc.x(i)
b = b << 1
return qc
''' |
QPC001_B3 | AA5715B7D5031 | 1 | RE | 1452 ms | 141 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(L):
bin_data = format(data, f'0{n}b')
data_0_bits = [i for i, digit in enumerate(reversed(bin_data)) if digit == '0']
qc.x(data_0_bits)
qc.append(ZGate().control(n-1), range(n))
qc.x(data_0_bits)
return qc
''' |
QPC001_B3 | AA5715B7D5031 | 2 | RE | 1398 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(L):
bin_data = format(i, f'0{n}b')
data_0_bits = [i for i, digit in enumerate(reversed(bin_data)) if digit == '0']
qc.x(data_0_bits)
qc.append(ZGate().control(n-1), range(n))
qc.x(data_0_bit)
return qc
''' |
QPC001_B3 | AA5715B7D5031 | 3 | RE | 1346 ms | 143 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(L):
bin_data = format(i, f'0{n}b')
data_0_bits = [idx for idx, digit in enumerate(reversed(bin_data)) if digit == '0']
qc.x(data_0_bits)
qc.append(ZGate().control(n-1), range(n))
qc.x(data_0_bits)
return qc
''' |
QPC001_B3 | AA5715B7D5031 | 4 | RE | 1503 ms | 143 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(L):
bin_data = format(i, f'0{n}b')
data_0_bits = [idx for idx, digit in enumerate(bin_data) if digit == '0']
qc.x(data_0_bits)
qc.append(ZGate().control(n-1), range(n))
qc.x(data_0_bits)
return qc
''' |
QPC001_B3 | AA5715B7D5031 | 5 | RE | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(L):
bin_data = format(i, f'0{n}b')
data_0_bits = [idx for idx, digit in enumerate(reversed(bin_data)) if digit == '0']
if len(data_0_bits) > 0:
qc.x(data_0_bits)
qc.append(ZGate().control(n-1), range(n))
if len(data_0_bits) > 0:
qc.x(data_0_bits)
return qc
''' | ||
QPC001_B3 | AA5715B7D5031 | 6 | RE | 1638 ms | 144 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(L):
bin_data = format(i, f'0{n}b')
data_0_bits = [idx for idx, digit in enumerate(reversed(bin_data)) if digit == '0']
if len(data_0_bits) > 0:
qc.x(data_0_bits)
qc.append(ZGate().control(n-1), range(n))
if len(data_0_bits) > 0:
qc.x(data_0_bits)
return qc
''' |
QPC001_B3 | AA5715B7D5031 | 7 | AC | 2790 ms | 145 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(L):
bin_data = format(i, f'0{n}b')
data_0_bits = [idx for idx, digit in enumerate(reversed(bin_data)) if digit == '0']
if len(data_0_bits) > 0:
qc.x(data_0_bits)
if n>1:
qc.append(ZGate().control(n-1), range(n))
else:
qc.z(0)
if len(data_0_bits) > 0:
qc.x(data_0_bits)
return qc
''' |
QPC001_B3 | AA57F006A4F8D | 1 | RE | 977 ms | 79 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
def get_indices(m: int):
a = []
idx = 0
while m:
if m % 2:
a.append(index)
index += 1
m //= 2
return a
for i in range(L, 2**n):
a = get_indices(i)
target = a[-1]
controls = a[:-1]
qc.h(target); qc.mcx(controls, target); qc.h(target)
return qc
''' |
QPC001_B3 | AA57F006A4F8D | 2 | WA | 988 ms | 91 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
def get_indices(m: int):
a = []
index = 0
while m:
if m % 2:
a.append(index)
index += 1
m //= 2
return a
for i in range(L, 2**n):
a = get_indices(i)
target = a[-1]
controls = a[:-1]#; print(target, controls, "!!!!")
if controls:
qc.h(target); qc.mcx(controls, target); qc.h(target)
else:
qc.z(target)
return qc
''' |
QPC001_B3 | AA57F006A4F8D | 3 | WA | 1086 ms | 91 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
qc.h(i)
# Write your code here:
def get_indices(m: int):
a = []
index = 0
while m:
if m % 2:
a.append(index)
index += 1
m //= 2
return a
for i in range(L, 2**n):
a = get_indices(i)
target = a[-1]
controls = a[:-1]#; print(target, controls, "!!!!")
if controls:
qc.h(target); qc.mcx(controls, target); qc.h(target)
else:
qc.z(target)
return qc
''' |
QPC001_B3 | AA57F006A4F8D | 4 | WA | 1236 ms | 91 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
qc.h(i)
# Write your code here:
def xmap(m: int, size: int) -> list[int]:
a = []
idx = 0
while m:
if m % 2:
a.append(idx)
idx += 1
m //= 2
return [i for i in range(size) if i not in a]
for i in range(L, 2**n):
a = xmap(i, n)
if a:
qc.x(a)
if n > 1:
qc.h(0); qc.mcx(list(range(1, n)), 0); qc.h(0)
else:
qc.z(0)
if a:
qc.x(a)
return qc
''' |
QPC001_B3 | AA57F006A4F8D | 5 | WA | 1109 ms | 91 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.h(i)
def xmap(m: int, size: int) -> list[int]:
a = []
idx = 0
while m:
if m % 2:
a.append(idx)
idx += 1
m //= 2
return [i for i in range(size) if i not in a]
for i in range(L, 2**n):
a = xmap(i, n)
if a:
qc.x(a)
if n > 1:
qc.h(0); qc.mcx(list(range(1, n)), 0); qc.h(0)
else:
qc.z(0)
if a:
qc.x(a)
return qc
''' |
QPC001_B3 | AA57F006A4F8D | 6 | AC | 2463 ms | 91 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
#for i in range(n):
# qc.h(i)
def xmap(m: int, size: int) -> list[int]:
a = []
idx = 0
while m:
if m % 2:
a.append(idx)
idx += 1
m //= 2
return [i for i in range(size) if i not in a]
for i in range(L, 2**n):
a = xmap(i, n)
if a:
qc.x(a)
if n > 1:
qc.h(0); qc.mcx(list(range(1, n)), 0); qc.h(0)
else:
qc.z(0)
if a:
qc.x(a)
return qc
''' |
QPC001_B3 | AA68B1FE361DC | 1 | RE | 842 ms | 79 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.cz(i, 0) # 制御Zゲートを使用して各状態に -1 をかける
return qc
''' |
QPC001_B3 | AA68B1FE361DC | 2 | RE | 1123 ms | 88 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import CZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.append(CZGate().control(n - 1), range(n))
return qc
''' |
QPC001_B3 | AA68B1FE361DC | 3 | RE | 930 ms | 79 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import CZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(L):
qc.append(CZGate(), [i, 0]) # CZゲートを使用して各状態に -1 をかける
return qc
''' |
QPC001_B3 | AA68B1FE361DC | 4 | RE | 802 ms | 79 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import CZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Oracleの実装
for i in range(L):
qc.append(CZGate(), [i, 0]) # CZゲートを使用して各状態に -1 をかける
return qc
''' |
QPC001_B3 | AA68B1FE361DC | 5 | RE | 865 ms | 79 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import CZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Oracleの実装
for i in range(L):
qc.append(CZGate(), [i, 0]) # CZゲートを使用して各状態に -1 をかける
return qc
''' |
QPC001_B3 | AA68B1FE361DC | 6 | RE | 963 ms | 87 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import CZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
qc.append(CZGate().control(n - 1), range(n))
return qc
''' |
QPC001_B3 | AA68B1FE361DC | 7 | RE | 760 ms | 79 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import CZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
qc.append(CZGate().control(n - 1), range(n))
return qc
''' |
QPC001_B3 | AA68B1FE361DC | 8 | RE | 857 ms | 79 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import CZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(L):
qc.append(CZGate(), [i] + list(range(n, n+L)))
return qc
''' |
QPC001_B3 | AA68B1FE361DC | 9 | RE | 784 ms | 79 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import CZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(L):
qc.append(CZGate(), [i] + list(range(n, n+L)))
return qc
''' |
QPC001_B3 | AA68B1FE361DC | 10 | RE | 911 ms | 79 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import CZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(L):
qc.append(CZGate(), list(range(n - L, n)) + [i])
return qc
''' |
QPC001_B3 | AA68B1FE361DC | 11 | RE | 943 ms | 88 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import CZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(L):
qc.append(CZGate().control(n - 1), range(n))
return qc
''' |
QPC001_B3 | AA68B1FE361DC | 12 | RE | 986 ms | 79 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import CZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(L):
qc.append(CZGate().control(n - 1), range(n-1))
return qc
''' |
QPC001_B3 | AA68B1FE361DC | 13 | RE | 911 ms | 88 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import CZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(L):
# i番目のビットを制御ビット、最後のビットをターゲットビットとするCZゲートを追加
qc.append(CZGate().control(n - 1), [i] + [n - 1])
return qc
''' |
QPC001_B3 | AA68B1FE361DC | 14 | RE | 788 ms | 79 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import CZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(2**(n-1)):
qc.cz(i, i + 2**(n-1))
return qc
''' |
QPC001_B3 | AA68B1FE361DC | 15 | RE | 845 ms | 79 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import CZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(2**n):
qc.cz(i, (i + 2**(n-1)) % (2**n))
return qc
''' |
QPC001_B3 | AA68B1FE361DC | 16 | RE | 796 ms | 79 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import CZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
qc.append(CZGate().control(n - 1), range(n))
return qc
''' |
QPC001_B3 | AA68B1FE361DC | 17 | RE | 768 ms | 79 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import CZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
qc.h(n)
for i in range(n):
qc.z(n)
for i in range(n):
qc.x(n)
return qc
''' |
QPC001_B3 | AA6DEFA912962 | 1 | RE | 934 ms | 90 MiB | '''python
from qiskit import QuantumCircuit
def oracle(qc: QuantumCircuit, n: int, L: int):
bits_L = [int(i) for i in bin(L)[2:].zfill(n)][::-1]
for i, bit in enumerate(bits_L):
if bit == 0:
qc.x(i)
qc.h(n-1)
qc.mct(list(range(n-1)), n-1)
qc.h(n-1)
for i, bit in enumerate(bits_L):
if bit == 0:
qc.x(i)
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
oracle(qc, n, L)
return qc
''' |
QPC001_B3 | AA6DEFA912962 | 2 | RE | 838 ms | 79 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(L):
binary_i = bin(i)[2:].zfill(n)[::-1]
for bit_position, bit in enumerate(binary_i):
if bit == '0':
qc.x(bit_position)
multi_control_z = ZGate().control(n)
qc.append(multi_control_z, range(n))
for bit_position, bit in enumerate(binary_i):
if bit == '0':
qc.x(bit_position)
return qc
''' |
QPC001_B3 | AA6DEFA912962 | 3 | RE | 962 ms | 91 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
binary_L = format(L, f'0{n}b')[::-1]
z_gate = ZGate().control(n - 1)
control_qubits = [i for i in range(n) if binary_L[i] == '1']
if control_qubits:
qc.append(z_gate, control_qubits + [n - 1])
return qc
''' |
QPC001_B3 | AA6E41C3AB18F | 1 | AC | 2062 ms | 160 MiB | '''python
from qiskit import QuantumCircuit
from math import pi
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
bitstring = ''
controls = []
L = 2 ** n - L
for i in range(n-1, -1, -1):
msb = (L >> i) & 1
L = L & (2 ** i - 1)
print(i, msb, bitstring, controls)
if msb == 1:
if not controls:
qc.p(pi, i)
else:
qc.mcp(pi, controls, i, ctrl_state=bitstring)
controls.append(i)
bitstring = str(1 - msb) + bitstring
return qc
''' |
QPC001_B3 | AA76A6314CAAE | 1 | RE | 1479 ms | 161 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Apply the Z gate (phase flip) to all states |0⟩, |1⟩, ..., |L-1⟩
for i in range(L):
binary_repr = f"{i:0{n}b}" # Convert i to binary with n bits
controls = [j for j in range(n) if binary_repr[j] == '1'] # Determine which qubits are 1
if controls:
qc.append(ZGate().control(len(controls)), controls)
else:
qc.z(0) # Global phase, ignored in judge
return qc
''' |
QPC001_B3 | AA76A6314CAAE | 2 | RE | 1283 ms | 161 MiB | '''python
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Apply the Z gate (phase flip) to all states |0⟩, |1⟩, ..., |L-1⟩
for i in range(L):
binary_repr = f"{i:0{n}b}" # Convert i to binary with n bits
controls = [j for j in range(n) if binary_repr[j] == '1'] # Determine which qubits are 1
if len(controls) == 0:
# If no controls (i.e., for |0...0⟩), apply Z to any qubit (global phase, ignored in judge)
qc.z(0)
elif len(controls) == 1:
# If only one control, just apply a Z gate directly
qc.z(controls[0])
else:
# Apply a multi-controlled Z gate
qc.append(ZGate().control(len(controls)), controls + [n-1])
return qc
''' |
QPC001_B3 | AA76A6314CAAE | 3 | RE | 1764 ms | 165 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Apply the Z gate (phase flip) to all states |0⟩, |1⟩, ..., |L-1⟩
for i in range(L):
binary_repr = f"{i:0{n}b}" # Convert i to binary with n bits
controls = [j for j in range(n) if binary_repr[j] == '1'] # Determine which qubits are 1
if len(controls) == 0:
# If no controls (i.e., for |0...0⟩), apply Z to any qubit (global phase, ignored in judge)
qc.z(0)
elif len(controls) == 1:
# If only one control, just apply a Z gate directly
qc.z(controls[0])
else:
# Apply a multi-controlled Z gate
qc.append(ZGate().control(len(controls)), controls + [n-1])
return qc
''' |
QPC001_B3 | AA76A6314CAAE | 4 | RE | 1666 ms | 164 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# If L is 0, no operation is needed
if L == 0:
return qc
# Create a multi-controlled Z gate that flips the phase of the first L states
# We need to find a way to control the Z gate such that it applies to the first L states
# One way is to use a combination of X gates and multi-controlled Z gates
# First, find the binary representation of L-1
max_state = L - 1
binary_max = format(max_state, f'0{n}b')
# We will apply X gates to qubits where the corresponding bit in binary_max is 0
# This will transform the state |max_state> to |11...1>
# Then we can apply a multi-controlled Z gate with all controls being 1
# Apply X gates to qubits where the corresponding bit in binary_max is 0
for i in range(n):
if binary_max[i] == '0':
qc.x(i)
# Apply a multi-controlled Z gate
qc.append(ZGate().control(n-1), range(n))
# Apply X gates again to revert the state
for i in range(n):
if binary_max[i] == '0':
qc.x(i)
return qc
''' |
QPC001_B3 | AA76A6314CAAE | 5 | AC | 2100 ms | 165 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# If L == 2^n, then every state gets a -1 overall,
# i.e. the oracle is -I which is just a global phase.
if L == 2**n:
return qc # global phase ignored
# Special case for n == 1.
if n == 1:
# For one qubit, possible L are 1 or 2.
# If L == 1 then only |0> should get a -1.
if L == 1:
qc.x(0)
qc.z(0)
qc.x(0)
return qc
# For n >= 2:
# Loop over all integers x such that 0 <= x < L.
# For each such x, we want to flip the phase of |x>.
for x in range(L):
# For each qubit i, if the i-th bit (little–endian) of x is 0,
# apply an X gate so that |x> is mapped to |11...1>.
for i in range(n):
if ((x >> i) & 1) == 0:
qc.x(i)
# Now, the state corresponding to x has been mapped to |11...1>.
# We now flip the phase of |11...1> by applying a multi–controlled Z.
# A convenient way is to conjugate a multi–controlled X with H on the target.
qc.h(n-1)
qc.mcx(list(range(n-1)), n-1) # multi–controlled X with controls 0,...,n-2 and target n-1.
qc.h(n-1)
# Undo the X gates.
for i in range(n):
if ((x >> i) & 1) == 0:
qc.x(i)
return qc
''' |
QPC001_B3 | AA8ECC4E47CDE | 1 | UME | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import Gate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for l in range(L):
for i in range(n):
if not ((l>>i) & 1):
qc.x(i)
if n==1:
qc.z(0)
else:
qc.append(Gate(z).control(n-1), range(n))
for i in range(n):
if not ((l>>n)&1):
qc.x(i)
return qc
''' | ||
QPC001_B3 | AA8ECC4E47CDE | 2 | WA | 1214 ms | 93 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for l in range(L):
for i in range(n):
if not ((l>>i) & 1):
qc.x(i)
if n==1:
qc.z(0)
else:
qc.append(ZGate().control(n-1), range(n))
for i in range(n):
if not ((l>>n)&1):
qc.x(i)
return qc
''' |
QPC001_B3 | AA8ECC4E47CDE | 3 | AC | 2583 ms | 95 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for l in range(L):
for i in range(n):
if not ((l>>i) & 1):
qc.x(i)
if n==1:
qc.z(0)
else:
qc.append(ZGate().control(n-1), range(n))
for i in range(n):
if not ((l>>i)&1):
qc.x(i)
return qc
''' |
QPC001_B3 | AA9D81B028231 | 1 | UME | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import Gate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
# L-1 のビット表現を取得し、0のビット位置を特定
bits_to_flip = [i for i in range(n) if not ((L - 1) >> i) & 1]
# 必要なビットを反転
for bit in bits_to_flip:
qc.x(bit)
# マルチ制御Zゲートを適用
qc.append(ZGate().control(n - 1), range(n))
# ビットを元に戻す
for bit in bits_to_flip:
qc.x(bit)
return qc
''' | ||
QPC001_B3 | AA9D81B028231 | 2 | RE | 1016 ms | 90 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
# L-1 のビット表現を取得し、0のビット位置を特定
bits_to_flip = [i for i in range(n) if not ((L - 1) >> i) & 1]
# 必要なビットを反転
for bit in bits_to_flip:
qc.x(bit)
# マルチ制御Zゲートを適用
qc.append(ZGate().control(n - 1), range(n))
# ビットを元に戻す
for bit in bits_to_flip:
qc.x(bit)
return qc
''' |
QPC001_B3 | AA9D81B028231 | 3 | RE | 763 ms | 80 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for state in range(L):
# Convert the state to binary representation and apply X gates accordingly
state_binary = format(state, f'0{n}b')
for qubit, bit in enumerate(state_binary):
if bit == '0':
qc.x(qubit)
# Apply the controlled Z gate
qc.append(ZGate().control(n - 1), range(n))
# Reapply X gates to revert to the original state
for qubit, bit in enumerate(state_binary):
if bit == '0':
qc.x(qubit)
return qc
''' |
QPC001_B3 | AA9D81B028231 | 4 | RE | 997 ms | 92 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for state in range(L):
state_binary = format(state, f'0{n}b')[::-1]
for qubit, bit in enumerate(state_binary):
if bit == '0':
qc.x(qubit)
qc.append(ZGate().control(n - 1), range(n))
for qubit, bit in enumerate(state_binary):
if bit == '0':
qc.x(qubit)
return qc
''' |
QPC001_B3 | AA9D81B028231 | 5 | WA | 875 ms | 90 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for state in range(L):
state_binary = format(state, f'0{n}b')[::-1]
for qubit, bit in enumerate(state_binary):
if bit == '0':
qc.x(qubit)
if n > 1:
qc.mct(list(range(n - 1)), n - 1)
else:
qc.z(0)
for qubit, bit in enumerate(state_binary):
if bit == '0':
qc.x(qubit)
return qc
''' |
QPC001_B3 | AAA53FE2DB2FB | 1 | UME | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
from qiskit.circuit.library import cz
qc.append(cz().control(L), range(n))
return qc
''' | ||
QPC001_B3 | AAA89BD1962FB | 1 | RE | 3000 ms | 156 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.h(i)
qc.append(ZGate().control(n - 1), range(n))
return qc
''' |
QPC001_B3 | AAA89BD1962FB | 2 | RE | 3000 ms | 160 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.h(i)
qc.append(ZGate().control(n - 1), range(n))
return qc
''' |
QPC001_B3 | AAA89BD1962FB | 3 | WA | 2172 ms | 160 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for l in range(L):
for i in range(n):
if not ((l >> i) & 1):
qc.x(i)
if n == 1:
qc.z(0)
else:
qc.append(ZGate().control(n - 1), range(n))
for i in range(n):
if not ((l >> i) & 1):
qc.x(i)
return qc
''' |
QPC001_B3 | AAA89BD1962FB | 4 | AC | 2237 ms | 161 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for l in range(L):
for i in range(n):
if not ((l >> i) & 1):
qc.x(i)
if n == 1:
qc.z(0)
else:
qc.append(ZGate().control(n - 1), range(n))
for i in range(n):
if not ((l >> i) & 1):
qc.x(i)
return qc
''' |
QPC001_B3 | AAAB161078B6B | 1 | RE | 1546 ms | 156 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for x in range(L):
for i in range(n):
if not(x >> i & 1):
qc.x(i)
if n == 1: qc.z(i)
else: qc.append(ZGate().control(n-1), range(n))
for i in range(n):
if not(x >> i & 1):
qc.x(i)
return qc
''' |
QPC001_B3 | AAAB161078B6B | 2 | RE | 1904 ms | 159 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for x in range(L):
for i in range(n):
if not(x >> i & 1):
qc.x(i)
if n == 1: qc.z(0)
else: qc.append(ZGate().control(n-1), range(n))
for i in range(n):
if not(x >> i & 1):
qc.x(i)
return qc
''' |
QPC001_B3 | AAAB161078B6B | 3 | AC | 2442 ms | 163 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for x in range(L):
for i in range(n):
if not(x >> i & 1):
qc.x(i)
if n == 1: qc.z(0)
else: qc.append(ZGate().control(n-1), range(n))
for i in range(n):
if not(x >> i & 1):
qc.x(i)
return qc
''' |
QPC001_B3 | AAAB91196FBC8 | 1 | RE | 1039 ms | 91 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for l in range(L):
for i in range(n):
if l & (1 << i): qc.x(i)
qc.append(ZGate().control(n - 1), range(n))
for i in range(n):
if l & (1 << i): qc.x(i)
return qc
''' |
QPC001_B3 | AAAB91196FBC8 | 2 | RE | 948 ms | 91 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for l in range(L):
for i in range(n):
if (l & (1 << i)) == 0: qc.x(i)
qc.append(ZGate().control(n - 1), range(n))
for i in range(n):
if (l & (1 << i)) == 0: qc.x(i)
return qc
''' |
QPC001_B3 | AAAB91196FBC8 | 3 | AC | 3000 ms | 95 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for l in range(L):
for i in range(n):
if (l & (1 << i)) == 0: qc.x(i)
if n == 1:
qc.z(0)
else:
qc.append(ZGate().control(n - 1), range(n))
for i in range(n):
if (l & (1 << i)) == 0: qc.x(i)
return qc
''' |
QPC001_B3 | AAC2370FA4948 | 1 | RE | 826 ms | 79 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.append(ZGate().control(n-1),range(n))
return qc
''' |
QPC001_B3 | AAC2370FA4948 | 2 | RE | 837 ms | 79 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.append(Gate().control(n - 1), range(n))
return qc
''' |
QPC001_B3 | AACE85EC4BBEF | 1 | RE | 2404 ms | 160 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
if (L >> i) & 1 == 1:
for j in range(i, n):
qc.x(j)
if (n - i == 1):
qc.z(i)
else:
qc.append(ZGate().control(n - i - 1), range(i, n))
for j in range(i, n):
qc.x(j)
return qc
''' |
QPC001_B3 | AACE85EC4BBEF | 2 | RE | 1790 ms | 156 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
if (L == pow(2, n)):
pass
else:
for i in range(n):
if (L >> i) & 1 == 1:
for j in range(i, n):
qc.x(j)
if (n - i == 1):
qc.z(i)
else:
qc.append(ZGate().control(n - i - 1), range(i, n))
for j in range(i, n):
qc.x(j)
return qc
''' |
QPC001_B3 | AACE85EC4BBEF | 3 | WA | 1941 ms | 159 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import HGate, ZGate
import math
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
if (L == pow(2, n)):
pass
else:
for i in range(n):
if (L >> i) & 1 == 1:
for j in range(i, n):
qc.x(j)
if (n - i == 1):
qc.z(i)
else:
qc.append(ZGate().control(n - i - 1), range(i, n))
for j in range(i, n):
qc.x(j)
return qc
''' |
QPC001_B3 | AACE85EC4BBEF | 4 | AC | 2960 ms | 161 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import HGate, ZGate
import math
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
if (L >> i) & 1 == 0: # l_i is 0; condition for (m_i < l_i)
continue
else: # l_i = 1 & m_i = 0 ; l_i = m_i = 1 case is eliminated at previous step
for j in range(i+1, n):
if (L >> j) & 1 == 0:
qc.x(j)
qc.x(i)
if (i == n - 1):
qc.z(i)
else:
qc.append(ZGate().control(n - i - 1), range(i, n))
qc.x(i)
for j in range(i+1, n):
if (L >> j) & 1 == 0:
qc.x(j)
return qc
''' |
QPC001_B3 | AAF87050F5BF4 | 1 | UME | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library.standard_gates import ZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.h(i)
for i in range(L):
# 2進数の配列に変換
b = list(map(int, list(format(i, "b"))))
for k in range(b.len()):
if b[k] == 0:
qc.x(k)
qc.append(ZGate().control(n-1), range(n))
for k in range(b.len()):
if b[k] == 0:
qc.x(k)
return qc
''' | ||
QPC001_B3 | AAF87050F5BF4 | 2 | RE | 794 ms | 79 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.h(i)
for i in range(L):
# 2進数の配列に変換
b = list(map(int, list(format(i, "b"))))
for k in range(b.len()):
if b[k] == 0:
qc.x(k)
qc.append(ZGate().control(n-1), range(n))
for k in range(b.len()):
if b[k] == 0:
qc.x(k)
return qc
''' |
QPC001_B3 | AAF87050F5BF4 | 3 | RE | 776 ms | 79 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.h(i)
for i in range(L):
# 2進数の配列に変換
b = list(map(int, list(format(i, "b"))))
for k in range(b.len()):
if b[k] == 0:
qc.x(k)
qc.append(ZGate().control(n-1), range(n))
for k in range(b.len()):
if b[k] == 0:
qc.x(k)
return qc
''' |
QPC001_B3 | AAF87050F5BF4 | 4 | RE | 933 ms | 91 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.h(i)
for i in range(L):
# 2進数の配列に変換
b = list(map(int, list(format(i, "b"))))
for k in range(len(b)):
if b[k] == 0:
qc.x(k)
qc.append(ZGate().control(n-1), range(n))
for k in range(len(b)):
if b[k] == 0:
qc.x(k)
return qc
''' |
QPC001_B3 | AAF87050F5BF4 | 5 | RE | 1088 ms | 91 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.h(i)
for i in range(L):
# 2進数の配列に変換
b = list(map(int, list(format(i, "b"))))
for k in range(len(b)):
if b[k] == 0:
qc.x(k)
qc.append(ZGate().control(n-1), range(n))
for k in range(len(b)):
if b[k] == 0:
qc.x(k)
return qc
''' |
QPC001_B3 | AAF87050F5BF4 | 6 | RE | 804 ms | 80 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(L):
# 2進数の配列に変換
b = list(map(int, list(format(i, "b"))))
for k in range(len(b)):
if b[k] == 0:
qc.x(k)
qc.append(ZGate().control(n-1), range(n))
for k in range(len(b)):
if b[k] == 0:
qc.x(k)
return qc
''' |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.