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 |
|---|---|---|---|---|---|---|
QPC002_B2 | A7F83BAB4D568 | 4 | RE | 1184 ms | 141 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
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.p(theta,0)
elif n == 2:
qc.cp(theta,0,1)
else:
qc.append(PhaseGate(theta=theta).control(n - 1), range(n))
for i in range(n):
if not ((L >> i) & 1):
qc.x(i)
return qc
''' |
QPC002_B2 | A7F83BAB4D568 | 5 | AC | 3000 ms | 183 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate,XGate,PhaseGate
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
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.p(theta,0)
elif n == 2:
qc.cp(theta,0,1)
else:
qc.append(PhaseGate(theta=theta).control(n - 1), range(n))
for i in range(n):
if not ((L >> i) & 1):
qc.x(i)
return qc
''' |
QPC002_B2 | A819529F5054B | 1 | RE | 3000 ms | 160 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import HGate, ZGate, XGate, PhaseGate
import math
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
if (L >> i) & 1 == 0:
qc.x(i)
qc.append(PhaseGate(theta).control(n-1), range(n))
for i in range(n):
if (L >> i) & 1 == 0:
qc.x(i)
return qc
''' |
QPC002_B2 | A819529F5054B | 2 | AC | 2360 ms | 160 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import HGate, ZGate, XGate, PhaseGate
import math
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
if (L >> i) & 1 == 0:
qc.x(i)
if (n > 1):
qc.append(PhaseGate(theta).control(n-1), range(n))
else:
qc.p(theta, 0)
for i in range(n):
if (L >> i) & 1 == 0:
qc.x(i)
return qc
''' |
QPC002_B2 | A824DF8963CBD | 1 | RE | 1283 ms | 141 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
binary_L = bin(L)[2:].zfill(n)
for i in range(n):
if binary_L[i] == '1':
qc.cu1(theta, i, n-1)
return qc
''' |
QPC002_B2 | A87672E58BB2C | 1 | RE | 1079 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for j in range(n):
if L & (1 << j) == 0:
qc.x(j)
qc.append(RZGate(theta).control(n))
for j in range(n):
if L & (1 << j) == 0:
qc.x(j)
return qc
''' |
QPC002_B2 | A87672E58BB2C | 2 | RE | 1224 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for j in range(n):
if L & (1 << j) == 0:
qc.x(j)
qc.append(RZGate(theta).control(n-1))
for j in range(n):
if L & (1 << j) == 0:
qc.x(j)
return qc
''' |
QPC002_B2 | A87672E58BB2C | 3 | RE | 1120 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
array = []
for j in range(n):
array.append(j)
if L & (1 << j) == 0:
qc.x(j)
qc.append(RZGate(theta).control(len(array) - 1), array)
for j in range(n):
if L & (1 << j) == 0:
qc.x(j)
return qc
''' |
QPC002_B2 | A87672E58BB2C | 4 | RE | 1121 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
array = []
for j in range(n):
array.append(j)
if L & (1 << j) == 0:
qc.x(j)
if len(array) == 1:
qc.rz(theta, array[0])
else:
qc.append(RZGate(theta).control(len(array) - 1), array)
for j in range(n):
if L & (1 << j) == 0:
qc.x(j)
return qc
''' |
QPC002_B2 | A87672E58BB2C | 5 | WA | 1241 ms | 145 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import RZGate
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
array = []
for j in range(n):
array.append(j)
if L & (1 << j) == 0:
qc.x(j)
if len(array) == 1:
qc.rz(theta,array[0])
else:
qc.append(RZGate(theta).control(len(array) - 1), array)
for j in range(n):
if L & (1 << j) == 0:
qc.x(j)
return qc
''' |
QPC002_B2 | A87672E58BB2C | 6 | RE | 1192 ms | 141 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import RZGate
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
array = []
for j in range(n):
array.append(j)
if L & (1 << j) == 0:
qc.x(j)
if len(array) == 1:
qc.rz(theta,array[0])
else:
qc.append(RZGate(theta).control(n))
for j in range(n):
if L & (1 << j) == 0:
qc.x(j)
return qc
''' |
QPC002_B2 | A87672E58BB2C | 7 | WA | 1337 ms | 185 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import RZGate
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
array = []
for j in range(n):
array.append(j)
if L & (1 << j) == 0:
qc.x(j)
if len(array) == 1:
qc.rz(theta,array[0])
else:
qc.append(RZGate(theta).control(len(array)-1), array)
for j in range(n):
if L & (1 << j) == 0:
qc.x(j)
return qc
''' |
QPC002_B2 | A87672E58BB2C | 8 | RE | 1200 ms | 141 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import RZGate
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
array = []
for j in range(n):
array.append(j)
if L & (1 << j) == 0:
qc.x(j)
if len(array) == 1:
qc.rz(theta,array[0])
else:
qc.append(RZGate(-theta).control(len(array)-1), arra)
for j in range(n):
if L & (1 << j) == 0:
qc.x(j)
return qc
''' |
QPC002_B2 | A87672E58BB2C | 9 | RE | 1472 ms | 141 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import RZGate
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
array = []
for j in range(n):
array.append(j)
if L & (1 << j) == 0:
qc.x(n-j-1)
if len(array) == 1:
qc.rz(theta,array[0])
else:
qc.append(RZGate(theta).control(len(array)-1), arra)
for j in range(n):
if L & (1 << j) == 0:
qc.x(n-j-1)
return qc
''' |
QPC002_B2 | A87672E58BB2C | 10 | RE | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import RZGate
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
array = []
for j in range(n):
array.append(j)
if L & (1 << j) == 0:
qc.x(n-j-1)
if len(array) == 1:
qc.rz(theta,array[0])
else:
qc.append(RZGate(theta).control(len(array)-1), array)
for j in range(n):
if L & (1 << j) == 0:
qc.x(n-j-)
return qc
''' | ||
QPC002_B2 | A87672E58BB2C | 11 | WA | 1305 ms | 145 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import RZGate
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
array = []
for j in range(n):
array.append(j)
if L & (1 << j) == 0:
qc.x(n-j-1)
if len(array) == 1:
qc.rz(theta,array[0])
else:
qc.append(RZGate(theta).control(len(array)-1), array)
for j in range(n):
if L & (1 << j) == 0:
qc.x(n-j-1)
return qc
''' |
QPC002_B2 | A87672E58BB2C | 12 | RE | 1197 ms | 141 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import RZGate
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
array = []
for j in range(n):
array.append(j)
if L & (1 << j) == 0:
qc.x(n-j-1)
if len(array) == 1:
qc.rz(theta,array[0])
else:
qc.append(RZGate(theta).control(len(array)), array)
for j in range(n):
if L & (1 << j) == 0:
qc.x(n-j-1)
return qc
''' |
QPC002_B2 | A87672E58BB2C | 13 | RE | 1216 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import RZGate
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
array = []
for j in range(n):
array.append(j)
if L & (1 << j) == 0:
qc.x(n-j-1)
if len(array) == 1:
qc.rz(theta,array[0])
else:
qc.append(RZGate(theta).control(len(array)), array)
for j in range(n):
if L & (1 << j) == 0:
qc.x(n-j-1)
return qc
''' |
QPC002_B2 | A87672E58BB2C | 14 | WA | 1605 ms | 184 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import RZGate
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
array = []
for j in range(n):
array.append(j)
if L & (1 << j) == 0:
qc.x(j)
if len(array) == 1:
qc.rz(theta,array[0])
else:
qc.append(RZGate(theta).control(len(array)-1), array)
for j in range(n):
if L & (1 << j) == 0:
qc.x(j)
return qc
''' |
QPC002_B2 | A87672E58BB2C | 15 | WA | 1261 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import RZGate
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
array = []
for j in range(n):
array.append(j)
if L & (1 << j) == 0:
qc.x(-j)
if len(array) == 1:
qc.rz(theta,array[0])
else:
qc.append(RZGate(theta).control(len(array)-1), array)
#for j in range(n):
# if L & (1 << j) == 0:
# qc.x(j)
return qc
''' |
QPC002_B2 | A87672E58BB2C | 16 | WA | 1268 ms | 145 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import RZGate
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
array = []
for j in range(n):
array.append(j)
if L & (1 << j) == 0:
qc.x(j)
if len(array) == 1:
qc.rz(theta, array[0])
else:
qc.append(RZGate(theta).control(len(array)-1), array)
for j in range(n):
if L & (1 << j) == 0:
qc.x(j)
return qc
''' |
QPC002_B2 | A87672E58BB2C | 17 | WA | 1552 ms | 184 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import RZGate
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
array = []
for j in range(n):
array.append(j)
if L & (1 << j) != 0:
qc.x(j)
if len(array) == 1:
qc.rz(theta, array[0])
else:
qc.append(RZGate(theta).control(len(array)-1), array)
for j in range(n):
if L & (1 << j) != 0:
qc.x(j)
return qc
''' |
QPC002_B2 | A87672E58BB2C | 18 | RE | 1241 ms | 141 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import RZGate
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for j in range(n):
if L & (1 << j) == 0:
qc.x(j)
if len(array) == 1:
qc.rz(theta, 0)
else:
qc.append(RZGate(theta).control(n-1), range(n))
for j in range(n):
if L & (1 << j) == 0:
qc.x(j)
return qc
''' |
QPC002_B2 | A87672E58BB2C | 19 | WA | 1250 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import RZGate
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for j in range(n):
if L & (1 << j) == 0:
qc.x(j)
if n == 1:
qc.rz(theta, 0)
else:
qc.append(RZGate(theta).control(n-1), range(n))
for j in range(n):
if L & (1 << j) == 0:
qc.x(j)
return qc
''' |
QPC002_B2 | A87672E58BB2C | 20 | RE | 1170 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import RZGate
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for j in range(n):
if L & (1 << j) == 0:
qc.x(j)
#if n == 1:
# qc.rz(theta, 0)
#else:
# qc.append(RZGate(theta).control(n-1), range(n))
qc.GRZ(n, theta)
for j in range(n):
if L & (1 << j) == 0:
qc.x(j)
return qc
''' |
QPC002_B2 | A87672E58BB2C | 21 | RE | 1104 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import RZGate
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for j in range(n):
if L & (1 << j) == 0:
qc.x(j)
#if n == 1:
# qc.rz(theta, 0)
#else:
# qc.append(RZGate(theta).control(n-1), range(n))
qc.grz(n, theta)
for j in range(n):
if L & (1 << j) == 0:
qc.x(j)
return qc
''' |
QPC002_B2 | A87672E58BB2C | 22 | RE | 1316 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import RZGate
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for j in range(n):
if L & (1 << j) == 0:
qc.x(j)
#if n == 1:
# qc.rz(theta, 0)
#else:
# qc.append(RZGate(theta).control(n-1), range(n))
qc.grz(theta)
for j in range(n):
if L & (1 << j) == 0:
qc.x(j)
return qc
''' |
QPC002_B2 | A87672E58BB2C | 23 | UME | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import RZGate, GRZ
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for j in range(n):
if L & (1 << j) == 0:
qc.x(j)
#if n == 1:
# qc.rz(theta, 0)
#else:
# qc.append(RZGate(theta).control(n-1), range(n))
qc.append(GRZ(n, theta))
for j in range(n):
if L & (1 << j) == 0:
qc.x(j)
return qc
''' | ||
QPC002_B2 | A87672E58BB2C | 24 | WA | 1173 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import RZGate
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for j in range(n):
if L & (1 << j) == 0:
qc.x(n-j-1)
if n == 1:
qc.rz(theta, 0)
else:
qc.append(RZGate(theta).control(n-1), range(n))
for j in range(n):
if L & (1 << j) == 0:
qc.x(n-j-1)
return qc
''' |
QPC002_B2 | A87672E58BB2C | 25 | WA | 1205 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import RZGate
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for j in range(n):
if L & (1 << j) == 0:
qc.x(j)
if n == 1:
qc.rz(theta, 0)
else:
qc.append(RZGate(theta).control(n-1), range(n))
for j in range(n):
if L & (1 << j) == 0:
qc.x(j)
return qc
''' |
QPC002_B2 | A87672E58BB2C | 26 | WA | 1406 ms | 184 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import RZGate
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for j in range(n-1):
if L & (1 << j) == 0:
qc.x(j)
if n == 1:
qc.rz(theta, 0)
else:
qc.append(RZGate(theta).control(n-1), range(n))
for j in range(n-1):
if L & (1 << j) == 0:
qc.x(j)
return qc
''' |
QPC002_B2 | A87672E58BB2C | 27 | WA | 1035 ms | 141 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import RZGate
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
array = []
for j in range(n-1):
array.append(j)
if L & (1 << j) == 0:
qc.x(j)
array.append(n-1)
if n == 1:
qc.rz(theta, 0)
else:
qc.append(RZGate(theta).control(n-1), array)
for j in range(n-1):
if L & (1 << j) == 0:
qc.x(j)
return qc
''' |
QPC002_B2 | A87672E58BB2C | 28 | WA | 1331 ms | 184 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import RZGate
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for j in range(n):
if L & (1 << j) == 0:
qc.x(j)
if n == 1:
qc.rz(theta, 0)
else:
qc.append(RZGate(theta).control(n-1), range(n))
for j in range(n):
if L & (1 << j) == 0:
qc.x(j)
return qc
''' |
QPC002_B2 | A87672E58BB2C | 29 | RE | 1449 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import RZGate
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for j in range(n):
if L & (1 << j) == 0:
qc.x(j)
if n == 1:
qc.rz(theta, 0)
else:
qc.append(RZGate(theta).control(n-2), range(n))
for j in range(n):
if L & (1 << j) == 0:
qc.x(j)
return qc
''' |
QPC002_B2 | A89D962F1F126 | 1 | RE | 2087 ms | 183 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.h(list(range(n)))
L_s = format(L, '010b')
bits = []
for i, bit in enumerate(L_s[10-n:]):
if bit == '0':
bits.append(i)
if bits != []:
qc.x(bits)
qc.mcp(theta, list(range(n-1)), n-1)
if bits != []:
qc.x(bits)
return qc
''' |
QPC002_B2 | A89D962F1F126 | 2 | RE | 1627 ms | 183 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.h(list(range(n)))
L_s = format(L, '010b')
bits = []
for i, bit in enumerate(L_s[10-n:][::-1]):
if bit == '0':
bits.append(i)
if bits != []:
qc.x(bits)
qc.mcp(theta, list(range(n-1)), n-1)
if bits != []:
qc.x(bits)
return qc
''' |
QPC002_B2 | A89D962F1F126 | 3 | RE | 2336 ms | 183 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
L_s = format(L, '010b')
bits = []
for i, bit in enumerate(L_s[10-n:][::-1]):
if bit == '0':
bits.append(i)
if bits != []:
qc.x(bits)
qc.mcp(theta, list(range(n-1)), n-1)
if bits != []:
qc.x(bits)
return qc
''' |
QPC002_B2 | A89D962F1F126 | 4 | RE | 2237 ms | 184 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
L_s = format(L, '010b')
bits = []
for i, bit in enumerate(L_s[10-n:]):
if bit == '0':
bits.append(i)
if bits != []:
qc.x(bits)
qc.mcp(theta, list(range(n-1)), n-1)
if bits != []:
qc.x(bits)
return qc
''' |
QPC002_B2 | A89D962F1F126 | 5 | RE | 2148 ms | 183 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
L_s = format(L, '010b')
bits = []
for i, bit in enumerate(L_s[10-n:]):
if bit == '0':
bits.append(i)
if bits != []:
qc.x(bits)
qc.mcp(theta, list(range(n-1)), n-1)
if bits != []:
qc.x(bits)
return qc
''' |
QPC002_B2 | A89D962F1F126 | 6 | AC | 2346 ms | 184 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
L_s = format(L, '010b')
bits = []
for i, bit in enumerate(L_s[10-n:][::-1]):
if bit == '0':
bits.append(i)
if bits != []:
qc.x(bits)
if n == 1:
qc.p(theta, 0)
else:
qc.mcp(theta, list(range(n-1)), n-1)
if bits != []:
qc.x(bits)
return qc
''' |
QPC002_B2 | A8D9101A91A3F | 1 | WA | 1491 ms | 185 MiB | '''python
from qiskit import QuantumCircuit
# from qiskit.visualization import plot_histogram
# from qiskit.quantum_info import Statevector
from qiskit.circuit.library import RZGate
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
if not (( L>>i) & 1):
qc.x(i)
if n == 1:
qc.rz(-2*theta, 0)
else:
qc.append(RZGate(-2*theta).control(n-1),range(n))
for i in range(n):
if not (( L>>i) & 1):
qc.x(i)
return qc
''' |
QPC002_B2 | A8D9101A91A3F | 2 | WA | 1506 ms | 184 MiB | '''python
from qiskit import QuantumCircuit
# from qiskit.visualization import plot_histogram
# from qiskit.quantum_info import Statevector
from qiskit.circuit.library import RZGate
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
if (( L>>i) & 1):
qc.x(i)
if n == 1:
qc.rz(-2*theta, 0)
else:
qc.append(RZGate(-2*theta).control(n-1),range(n))
for i in range(n):
if (( L>>i) & 1):
qc.x(i)
return qc
''' |
QPC002_B2 | A8D9101A91A3F | 3 | WA | 1371 ms | 185 MiB | '''python
from qiskit import QuantumCircuit
# from qiskit.visualization import plot_histogram
# from qiskit.quantum_info import Statevector
from qiskit.circuit.library import RZGate
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
if not (( L>>i) & 1):
qc.x(i)
if n == 1:
qc.rz(2*theta, 0)
else:
qc.append(RZGate(2*theta).control(n-1),range(n))
for i in range(n):
if not (( L>>i) & 1):
qc.x(i)
return qc
''' |
QPC002_B2 | A8D9101A91A3F | 4 | WA | 1333 ms | 144 MiB | '''python
from qiskit import QuantumCircuit
# from qiskit.visualization import plot_histogram
# from qiskit.quantum_info import Statevector
from qiskit.circuit.library import PhaseGate
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
if not (( L>>i) & 1):
qc.x(i)
if n == 1:
qc.rz(-2*theta, 0)
else:
qc.append(PhaseGate(2*theta).control(n-1),range(n))
for i in range(n):
if not (( L>>i) & 1):
qc.x(i)
return qc
''' |
QPC002_B2 | A8D9101A91A3F | 5 | WA | 2089 ms | 183 MiB | '''python
from qiskit import QuantumCircuit
# from qiskit.visualization import plot_histogram
# from qiskit.quantum_info import Statevector
from qiskit.circuit.library import PhaseGate
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
if not (( L>>i) & 1):
qc.x(i)
if n == 1:
qc.rz(-2*theta, 0)
else:
qc.append(PhaseGate(theta).control(n-1),range(n))
for i in range(n):
if not (( L>>i) & 1):
qc.x(i)
return qc
''' |
QPC002_B2 | A8D9101A91A3F | 6 | WA | 1582 ms | 183 MiB | '''python
from qiskit import QuantumCircuit
# from qiskit.visualization import plot_histogram
# from qiskit.quantum_info import Statevector
from qiskit.circuit.library import PhaseGate
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
if not (( L>>i) & 1):
qc.x(i)
if n == 1:
qc.rz(2*theta, 0)
else:
qc.append(PhaseGate(2*theta).control(n-1),range(n))
for i in range(n):
if not (( L>>i) & 1):
qc.x(i)
return qc
''' |
QPC002_B2 | A8D9101A91A3F | 7 | AC | 2184 ms | 184 MiB | '''python
from qiskit import QuantumCircuit
# from qiskit.visualization import plot_histogram
# from qiskit.quantum_info import Statevector
from qiskit.circuit.library import PhaseGate
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
if not (( L>>i) & 1):
qc.x(i)
if n==1:
qc.p(theta,0)
else:
qc.append(PhaseGate(theta).control(n-1),range(n))
for i in range(n):
if not (( L>>i) & 1):
qc.x(i)
return qc
if __name__ == "__main__":
qc = solve(4,1,2)
print(qc.draw())
print(qc.depth())
# state = Statevector(qc)
# plot_histogram(state)
''' |
QPC002_B2 | A8E46C3DB651A | 1 | RE | 1127 ms | 141 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
if L >> i == 1:
qc.x(i)
qc.append(ZGate(2*theta).control(n-1),range(n))
for i in range(n):
if L >> i == 1:
qc.x(i)
return qc
''' |
QPC002_B2 | A8E46C3DB651A | 2 | RE | 1341 ms | 141 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
if L >> i == 1:
qc.x(i)
qc.append(ZGate(2*theta).control(n-1),range(n))
for i in range(n):
if L >> i == 1:
qc.x(i)
return qc
''' |
QPC002_B2 | A8E46C3DB651A | 3 | RE | 1178 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
if L >> i == 1:
qc.x(i)
qc.append(RZGate(2*theta).control(n-1),range(n))
for i in range(n):
if L >> i == 1:
qc.x(i)
return qc
''' |
QPC002_B2 | A8E46C3DB651A | 4 | WA | 1233 ms | 143 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
if L >> i == 1:
qc.x(i)
for i in range(n):
if L >> i == 1:
qc.x(i)
return qc
''' |
QPC002_B2 | A8E46C3DB651A | 5 | RE | 2690 ms | 185 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import RZGate
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
if L >> i == 1:
qc.x(i)
qc.append(RZGate(2*theta).control(n-1),range(n))
for i in range(n):
if L >> i == 1:
qc.x(i)
return qc
''' |
QPC002_B2 | A8E46C3DB651A | 6 | RE | 1748 ms | 184 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import RZGate
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
if L >> i == 1:
qc.x(i)
qc.append(RZGate(2*theta).control(2),[0,1,2])
for i in range(n):
if L >> i == 1:
qc.x(i)
return qc
''' |
QPC002_B2 | A8E46C3DB651A | 7 | RE | 1340 ms | 184 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import RZGate
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
if L >> i == 0:
qc.x(i)
qc.append(RZGate(2*theta).control(n-1),range(n))
for i in range(n):
if L >> i == 1:
qc.x(i)
return qc
''' |
QPC002_B2 | A8E46C3DB651A | 8 | RE | 1349 ms | 184 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import RZGate
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
if L >> i == 0:
qc.x(i)
qc.append(RZGate(2*theta).control(n-1),range(n))
for i in range(n):
if L >> i == 0:
qc.x(i)
return qc
''' |
QPC002_B2 | A8E46C3DB651A | 9 | RE | 1435 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import RZGate
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n-1):
if L >> i == 0:
qc.x(i)
qc.x(n)
qc.append(RZGate(2*theta).control(n-1),range(n))
qc.x(n)
for i in range(n-1):
if L >> i == 0:
qc.x(i)
return qc
''' |
QPC002_B2 | A8E46C3DB651A | 10 | RE | 2800 ms | 185 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import RZGate
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n-1):
if L >> i == 0:
qc.x(i)
qc.x(n-1)
qc.append(RZGate(2*theta).control(n-1),range(n))
qc.x(n-1)
for i in range(n-1):
if L >> i == 0:
qc.x(i)
return qc
''' |
QPC002_B2 | A8E46C3DB651A | 11 | RE | 2014 ms | 185 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import RZGate
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
if L >> i == 0:
qc.x(i)
qc.x(n-1)
qc.append(RZGate(2*theta).control(n-1),range(n))
qc.x(n-1)
for i in range(n):
if L >> i == 0:
qc.x(i)
return qc
''' |
QPC002_B2 | A8E46C3DB651A | 12 | RE | 1445 ms | 183 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import RZGate
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
if n == 1:
qc.x(0)
qc.rz(2*theta)
qc.x(0)
else:
for i in range(n):
if L >> i == 0:
qc.x(i)
qc.x(n-1)
qc.append(RZGate(2*theta).control(n-1),range(n))
qc.x(n-1)
for i in range(n):
if L >> i == 0:
qc.x(i)
return qc
''' |
QPC002_B2 | A8E46C3DB651A | 13 | WA | 1365 ms | 184 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import RZGate
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
if n == 1:
qc.x(0)
qc.rz(2*theta,0)
qc.x(0)
else:
for i in range(n):
if L >> i == 0:
qc.x(i)
qc.x(n-1)
qc.append(RZGate(2*theta).control(n-1),range(n))
qc.x(n-1)
for i in range(n):
if L >> i == 0:
qc.x(i)
return qc
''' |
QPC002_B2 | A8E46C3DB651A | 14 | WA | 1810 ms | 183 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import RZGate
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
if n == 1:
if L == 0:
qc.x(0)
qc.rz(2*theta,0)
qc.x(0)
else:
qc.rz(2*theta,0)
else:
for i in range(n):
if L >> i == 0:
qc.x(i)
qc.x(n-1)
qc.append(RZGate(2*theta).control(n-1),range(n))
qc.x(n-1)
for i in range(n):
if L >> i == 0:
qc.x(i)
return qc
''' |
QPC002_B2 | A8E46C3DB651A | 15 | WA | 1208 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import RZGate
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
if n == 1:
if L == 1:
qc.x(0)
qc.rz(2*theta,0)
qc.x(0)
else:
qc.rz(2*theta,0)
else:
for i in range(n):
if L >> i == 0:
qc.x(i)
qc.x(n-1)
qc.append(RZGate(2*theta).control(n-1),range(n))
qc.x(n-1)
for i in range(n):
if L >> i == 0:
qc.x(i)
return qc
''' |
QPC002_B2 | A8E46C3DB651A | 16 | WA | 1194 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import RZGate
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
if n == 1:
if L == 0:
qc.x(0)
qc.rz(2*theta,0)
qc.x(0)
else:
qc.rz(2*theta,0)
else:
for i in range(n):
if L >> i == 0:
qc.x(i)
qc.x(n-1)
qc.append(RZGate(2*theta).control(n-1),range(n))
qc.x(n-1)
for i in range(n):
if L >> i == 0:
qc.x(i)
return qc
''' |
QPC002_B2 | A8E46C3DB651A | 17 | WA | 1022 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import RZGate
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
if n == 1:
if L == 0:
qc.x(0)
qc.rz(2*theta,0)
qc.x(0)
else:
qc.rz(2*theta,0)
else:
for i in range(n-1):
if (L >> i) & 1 == 0:
qc.x(i)
qc.x(n-1)
qc.append(RZGate(2*theta).control(n-1),range(n))
qc.x(n-1)
for i in range(n-1):
if (L >> i) & 1 == 0:
qc.x(i)
return qc
''' |
QPC002_B2 | A8E46C3DB651A | 18 | WA | 1400 ms | 146 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import RZGate
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
if n == 1:
if L == 0:
qc.x(0)
qc.rz(2*theta,0)
qc.x(0)
else:
qc.rz(2*theta,0)
else:
for i in range(n):
if (L >> i) & 1 == 0:
qc.x(i)
qc.append(RZGate(2*theta).control(n-1),range(n))
for i in range(n):
if (L >> i) & 1 == 0:
qc.x(i)
return qc
''' |
QPC002_B2 | A8E46C3DB651A | 19 | RE | 1075 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import RZGate
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
if n == 1:
if L == 0:
qc.x(0)
qc.rz(2*theta,0)
qc.x(0)
else:
qc.rz(2*theta,0)
else:
exit()
for i in range(n):
if (L >> i) & 1 == 0:
qc.x(i)
qc.append(RZGate(2*theta).control(n-1),range(n))
for i in range(n):
if (L >> i) & 1 == 0:
qc.x(i)
return qc
''' |
QPC002_B2 | A8E46C3DB651A | 20 | RE | 1208 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import RZGate
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
if n == 1:
if L == 0:
qc.x(0)
qc.rz(2*theta,0)
qc.x(0)
else:
qc.rz(2*theta,0)
else:
for i in range(n):
# check if i-th bit of l is 0 or 1
if not ((L >> i) & 1):
qc.x(i)
else:
# apply multiple controlled Z gate
qc.append(RZGate(2*theta).control(n-1), range(n))
for i in range(n):
if not ((l >> i) & 1):
qc.x(i)
return qc
''' |
QPC002_B2 | A8E46C3DB651A | 21 | RE | 1358 ms | 141 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import RZGate
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
if n == 1:
if L == 0:
qc.x(0)
qc.rz(2*theta,0)
qc.x(0)
else:
qc.rz(2*theta,0)
else:
for i in range(n):
if not ((L >> i) & 1):
qc.x(i)
qc.append(RZGate(2*theta).control(n-1), range(n))
for i in range(n):
if not ((l >> i) & 1):
qc.x(i)
return qc
''' |
QPC002_B2 | A8E46C3DB651A | 22 | WA | 1303 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import RZGate
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
if n == 1:
if L == 0:
qc.x(0)
qc.rz(2*theta,0)
qc.x(0)
else:
qc.rz(2*theta,0)
else:
for i in range(n):
if not ((L >> i) & 1):
qc.x(i)
qc.append(RZGate(2*theta).control(n-1), range(n))
for i in range(n):
if not ((L >> i) & 1):
qc.x(i)
return qc
''' |
QPC002_B2 | A8E46C3DB651A | 23 | RE | 2045 ms | 183 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import PhaseGate
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
if n == 1:
if L == 0:
qc.x(0)
qc.PhaseGate(2*theta,0)
qc.x(0)
else:
qc.PhaseGate(2*theta,0)
else:
for i in range(n):
if not ((L >> i) & 1):
qc.x(i)
qc.append(PhaseGate(2*theta).control(n-1), range(n))
for i in range(n):
if not ((L >> i) & 1):
qc.x(i)
return qc
''' |
QPC002_B2 | A8E46C3DB651A | 24 | RE | 2102 ms | 183 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import PhaseGate
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
if n == 1:
if L == 0:
qc.x(0)
qc.PhaseGate(2*theta)
qc.x(0)
else:
qc.PhaseGate(2*theta)
else:
for i in range(n):
if not ((L >> i) & 1):
qc.x(i)
qc.append(PhaseGate(2*theta).control(n-1), range(n))
for i in range(n):
if not ((L >> i) & 1):
qc.x(i)
return qc
''' |
QPC002_B2 | A8E46C3DB651A | 25 | AC | 2326 ms | 183 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import PhaseGate
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
if n == 1:
if L == 0:
qc.x(0)
qc.append(PhaseGate(theta),[0])
qc.x(0)
else:
qc.append(PhaseGate(theta),[0])
else:
for i in range(n):
if not ((L >> i) & 1):
qc.x(i)
qc.append(PhaseGate(theta).control(n-1), range(n))
for i in range(n):
if not ((L >> i) & 1):
qc.x(i)
return qc
''' |
QPC002_B2 | A91E84184AD6A | 1 | RE | 1385 ms | 144 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
if (L >> i) & 1:
qc.cp(theta, i, n-1)
return qc
return qc
''' |
QPC002_B2 | A91E84184AD6A | 2 | RE | 1139 ms | 144 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
if (L >> i) & 1:
for j in range(n-1):
qc.cx(i, n-1)
qc.p(theta, n-1)
for j in range(n-1):
qc.cx(i, n-1)
return qc
''' |
QPC002_B2 | A91E84184AD6A | 3 | RE | 1107 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Convert L to its binary representation
L_binary = bin(L)[2:].zfill(n)
# Apply phase shift to the specific state |L>
# Create the controlled phase shift operation for |L>
for i, bit in enumerate(L_binary):
if bit == '1':
qc.x(i) # Apply X gate to qubit i if the bit is 1
# Apply the phase shift operation
qc.u1(theta, 0) # Apply the phase shift to the |L> state
# Uncompute the qubits to get back to the original state
for i, bit in enumerate(L_binary):
if bit == '1':
qc.x(i) # Apply X gate to undo the earlier X gate if the bit was 1
return qc
''' |
QPC002_B2 | A91E84184AD6A | 4 | UME | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import X, Z, RZ
import numpy as np
def oracle(n: int, L: int, theta: float) -> QuantumCircuit:
q = QuantumRegister(n, name='q') # Quantum register for the computational basis states
ancilla = QuantumRegister(1, name='ancilla') # Ancilla qubit for phase application
qc = QuantumCircuit(q, ancilla)
# Initialize ancilla qubit in |1> state
qc.x(ancilla)
# Apply controlled-Z gates to check if the state equals L
for i in range(n):
if (L >> i) & 1:
qc.cx(q[i], ancilla) # Apply CX gate (controlled-X) to flip ancilla qubit
# Apply RZ gate based on ancilla qubit
qc.append(RZ(theta, ancilla), [ancilla])
# Apply controlled-X gates to return ancilla qubit to |0> state
for i in range(n):
if (L >> i) & 1:
qc.cx(q[i], ancilla)
return qc
''' | ||
QPC002_B2 | A91E84184AD6A | 5 | WA | 1299 ms | 183 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Convert L to binary representation and apply the RZ gate conditionally
L_bin = [int(bit) for bit in format(L, f'0{n}b')] # Convert L to a binary string
for i in range(n):
if L_bin[i] == 1:
qc.rz(theta, i)
return qc
''' |
QPC002_B2 | A91E84184AD6A | 6 | WA | 1169 ms | 144 MiB | '''python
from qiskit import QuantumCircuit
import numpy as np
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Apply phase shift to the state if it matches L
for i in range(n):
if (L >> i) & 1: # Check if the i-th bit of L is 1
qc.rz(theta, i) # Apply RZ gate with angle theta to the i-th qubit
return qc
''' |
QPC002_B2 | A91E84184AD6A | 7 | WA | 1263 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
import numpy as np
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Apply phase shift to the state if it matches L
for i in range(n):
if (L >> i) & 1: # Check if the i-th bit of L is 1
qc.rz(-2 * theta, i) # Apply RZ gate with angle theta to the i-th qubit
return qc
''' |
QPC002_B2 | A91E84184AD6A | 8 | QLE | 1095 ms | 140 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import numpy as np
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n + 1) # Add an auxiliary qubit
# Initialize auxiliary qubit in state |1>
qc.x(n) # The auxiliary qubit is at index n
# Apply controlled-X gates to check if the state equals L
for i in range(n):
if (L >> i) & 1: # If the i-th bit of L is 1
qc.cx(i, n) # Apply controlled-X gate
# Apply RZ gate to the auxiliary qubit
qc.rz(theta, n) # Apply the RZ gate with angle theta
# Reverse the controlled-X gates to restore the state of the auxiliary qubit
for i in range(n):
if (L >> i) & 1: # If the i-th bit of L is 1
qc.cx(i, n) # Apply controlled-X gate
return qc
''' |
QPC002_B2 | A91E84184AD6A | 9 | WA | 1280 ms | 140 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import numpy as np
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Convert L to binary string
L_bin = [int(bit) for bit in format(L, f'0{n}b')]
# Apply phase shifts based on the bits of L
for i in range(n):
if L_bin[i] == 1:
qc.rz(-2 * theta, i) # Apply RZ gate with angle -2*theta to the i-th qubit
return qc
''' |
QPC002_B2 | A91E84184AD6A | 10 | RE | 1315 ms | 140 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import numpy as np
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Create the binary representation of L
L_bin = format(L, f'0{n}b') # Binary string with leading zeros
# Apply controlled phase shifts
for i, bit in enumerate(L_bin):
if bit == '1':
qc.cx(i, n) # Apply controlled X gate with the auxiliary qubit (n-th qubit)
# Apply RZ gate to the auxiliary qubit if its state is |1⟩
qc.rz(theta, n) # Apply RZ gate with angle theta
# Reverse the controlled X gates
for i, bit in enumerate(L_bin):
if bit == '1':
qc.cx(i, n) # Apply controlled X gate with the auxiliary qubit (n-th qubit)
return qc
''' |
QPC002_B2 | A91E84184AD6A | 11 | WA | 1323 ms | 183 MiB | '''python
from qiskit import QuantumCircuit
import numpy as np
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Convert L to binary representation
L_bin = format(L, f'0{n}b') # Binary string of length n
# Apply RZ gate with -2 * theta to the qubits where L has 1
for i, bit in enumerate(L_bin):
if bit == '1':
qc.rz(-2 * theta, i) # Apply RZ gate with angle -2 * theta to qubit i
return qc
''' |
QPC002_B2 | A91E84184AD6A | 12 | UME | '''python
from qiskit import QuantumCircuit
from qiskit.circuit import QuantumRegister, ClassicalRegister
from qiskit.circuit.library import MCPhaseGate
import numpy as np
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
# Create a quantum circuit with n qubits
qc = QuantumCircuit(n)
# Convert L to binary representation
L_bin = format(L, f'0{n}b')
# Create the phase shift oracle
# We need to apply a controlled phase shift to target |L>
if L != 0: # If L is 0, no phase shift is needed
# We use the fact that e^iθ = cos(θ) + i*sin(θ)
# We need to create a phase shift of -2*theta for |L>
theta = -2 * theta
# Apply the phase shift to the qubits corresponding to L
for i, bit in enumerate(L_bin):
if bit == '1':
qc.h(i) # Apply Hadamard gate
qc.rz(theta, list(range(n))) # Apply RZ gate to all qubits
for i, bit in enumerate(L_bin):
if bit == '1':
qc.h(i) # Apply Hadamard gate to invert back
return qc
''' | ||
QPC002_B2 | A95B49FA17511 | 1 | RE | 3000 ms | 184 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
if not (L & (1 << i)):
qc.x(i)
qc.mcp(theta, list(range(n - 1)), n - 1)
for i in range(n):
if not (L & (1 << i)):
qc.x(i)
return qc
''' |
QPC002_B2 | A95B49FA17511 | 2 | AC | 2072 ms | 183 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
if not (L & (1 << i)):
qc.x(i)
if n == 1:
qc.p(theta, 0)
else:
qc.mcp(theta, list(range(n - 1)), n - 1)
for i in range(n):
if not (L & (1 << i)):
qc.x(i)
return qc
''' |
QPC002_B2 | A96B0E3AE623C | 1 | RE | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
L_binary = format(L, f'0{n}b')
for i, bit in enumerate(L_binary):
if bit == '1':
qc.x(i)
qc.rz(theta, range(n))
for i, bit in enumerate(L_binary):
if bit == '1':
qc.x(i)
return qc
''' | ||
QPC002_B2 | A96B0E3AE623C | 2 | WA | 1234 ms | 141 MiB | '''python
from qiskit import QuantumCircuit
from math import pi
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
L_binary = format(L, f'0{n}b')
for i, bit in enumerate(L_binary):
if bit == '1':
qc.x(i)
qc.rz(theta, 0)
for i, bit in enumerate(L_binary):
if bit == '1':
qc.x(i)
return qc
''' |
QPC002_B2 | A96B0E3AE623C | 3 | WA | 1472 ms | 182 MiB | '''python
from qiskit import QuantumCircuit
from math import pi
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
L_binary = format(L, f'0{n}b')
for i, bit in enumerate(L_binary):
if bit == '1':
qc.x(i)
qc.rz(theta, range(n))
for i, bit in enumerate(L_binary):
if bit == '1':
qc.x(i)
return qc
''' |
QPC002_B2 | A9A7104FA4541 | 1 | AC | 2118 ms | 185 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import UGate
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
if not ((L>>i)&1):
qc.x(i)
if n == 1:
qc.u(0, theta, 0, 0)
else:
qc.append(UGate(0, theta, 0).control(n-1),range(n))
for i in range(n):
if not ((L>>i)&1):
qc.x(i)
return qc
''' |
QPC002_B2 | A9DD2939788D1 | 1 | AC | 1919 ms | 152 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
#yを|11...1>に変換すべくリトルエンディアンの順序で、0の桁にXゲートで反転させる
for i in range(n):
if L&(1<<i) == 0:
qc.x(i)
if n == 1:
qc.p(theta, n-1)
else:
qc.mcp(theta, list(range(n-1)), n-1)
#|11...1>をyに変換すべくリトルエンディアンの順序で、0の桁にXゲートで反転させる
for i in range(n):
if L&(1<<i) == 0:
qc.x(i)
return qc
''' |
QPC002_B2 | AA252649B6B00 | 1 | RE | 1091 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
L_bits = format(L, f'0{n}b')
# Apply X gates to match the state |L>
for i, bit in enumerate(L_bits):
if bit == '0':
qc.x(i)
# Apply the multi-controlled Z gate with phase shift theta (Rz)
qc.mcrz(theta, control_qubits=list(range(n)), target_qubit=n-1)
# Undo the X gates to revert the original state
for i, bit in enumerate(L_bits):
if bit == '0':
qc.x(i)
return qc
''' |
QPC002_B2 | AA252649B6B00 | 2 | RE | 1171 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library.standard_gates import PhaseGate
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
L_bits = format(L, f'0{n}b')
# Apply X gates to match the state |L>
for i, bit in enumerate(L_bits):
if bit == '0':
qc.x(i)
# Apply the multi-controlled phase gate
qc.append(PhaseGate(theta).control(n), range(n))
# Undo the X gates to revert the original state
for i, bit in enumerate(L_bits):
if bit == '0':
qc.x(i)
return qc
''' |
QPC002_B2 | AA252649B6B00 | 3 | RE | 2181 ms | 183 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library.standard_gates import PhaseGate
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
L_bits = format(L, f'0{n}b')
# Apply X gates to match the state |L>
for i, bit in enumerate(L_bits):
if bit == '0':
qc.x(i)
# Apply the multi-controlled phase gate
qc.append(PhaseGate(theta).control(n-1), range(n))
# Undo the X gates to revert the original state
for i, bit in enumerate(L_bits):
if bit == '0':
qc.x(i)
return qc
''' |
QPC002_B2 | AA252649B6B00 | 4 | RE | 1152 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library.standard_gates import PhaseGate
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
L_bits = format(L, f'0{n}b')
bit = L_bits[-1]
if bit == '0':
qc.x(n-1)
# Apply the multi-controlled phase gate
qc.append(PhaseGate(theta).control(n-1), range(n))
# Undo the X gates to revert the original state
if bit == '0':
qc.x(n-1)
return qc
''' |
QPC002_B2 | AA252649B6B00 | 5 | RE | 1190 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library.standard_gates import PhaseGate
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
diag = [1]*(2**n)
diag[L-1] = np.cos(theta) + 1j * np.sin(theta)
state = diag / 2 ** n
qc.initialize(state, range(n))
# Apply the multi-controlled phase gate
return qc.decompose().decompose().decompose()
''' |
QPC002_B2 | AA252649B6B00 | 6 | RE | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library.standard_gates import PhaseGate
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
diag = [np.sqrt(1/2**n)]*(2**n)
diag[L-1] = (np.cos(theta) + 1j * np.sin(theta)) / np.sqrt(2**n)
qc.initialize(diag, list(range(n)))
# Apply the multi-controlled phase gate
return qc.decompose().decompose().decompose(
''' | ||
QPC002_B2 | AA252649B6B00 | 7 | RE | 1103 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library.standard_gates import PhaseGate
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
diag = [np.sqrt(1/2**n)]*(2**n)
diag[L-1] = (np.cos(theta) + 1j * np.sin(theta)) / np.sqrt(2**n)
qc.initialize(diag, list(range(n)))
# Apply the multi-controlled phase gate
return qc.decompose().decompose().decompose()
''' |
QPC002_B2 | AA252649B6B00 | 8 | RE | 1052 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library.standard_gates import PhaseGate
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
diag = [np.sqrt(1/2**n)]*(2**n)
diag[L-1] = (np.cos(theta) + 1j * np.sin(theta)) / np.sqrt(2**n)
qc.initialize(diag, list(range(n)))
return qc.decompose().decompose().decompose().decompose().decompose().decompose()
''' |
QPC002_B2 | AA2687BE923AA | 1 | RE | 1683 ms | 144 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
if not ((L>>i)&1):
qc.x(i)
qc.mcp(theta,[i for i in range(n-1)],n-1)
for i in range(n):
if not ((L>>i)&1):
qc.x(i)
return qc
''' |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.