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_B4 | AE42E00A249FA | 1 | WA | 1320 ms | 145 MiB | '''python
from qiskit import QuantumCircuit
from math import pi
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Apply Hadamard gates to all qubits
for qubit in range(n):
qc.h(qubit)
# Apply controlled rotation gates
for i in range(n):
for j in range(i):
k = i - j + 1
qc.cp(2 * pi / 2**k, j, i)
# Swap qubits to correct the order (little-endian)
for i in range(n // 2):
qc.swap(i, n - 1 - i)
return qc
''' |
QPC002_B4 | AE42E00A249FA | 2 | WA | 1296 ms | 182 MiB | '''python
from qiskit import QuantumCircuit
from math import pi
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Implement QFT
for i in range(n):
qc.h(i)
for j in range(i + 1, n):
qc.cp(pi / 2**(j - i), j, i)
return qc
''' |
QPC002_B4 | AE42E00A249FA | 3 | DLE | 1395 ms | 141 MiB | '''python
from qiskit import QuantumCircuit
import numpy as np
def qft_rotations(qc, n):
"""Apply the QFT to the first n qubits in the quantum circuit qc."""
if n == 0:
return qc
n -= 1
qc.h(n)
for qubit in range(n):
qc.cp(np.pi / 2**(n-qubit), qubit, n)
qft_rotations(qc, n)
def swap_registers(qc, n):
"""Swap the qubits to reverse their order."""
for qubit in range(n//2):
qc.swap(qubit, n-qubit-1)
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Apply the QFT
qft_rotations(qc, n)
# Reverse the order of qubits by swapping them
swap_registers(qc, n)
return qc
''' |
QPC002_B4 | AE42E00A249FA | 4 | WA | 1529 ms | 141 MiB | '''python
from qiskit import QuantumCircuit
import numpy as np
def qft_rotations_optimized(qc, n):
"""Apply the QFT to the first n qubits in the quantum circuit qc."""
for j in range(n):
qc.h(j)
for k in range(j+1, n):
qc.cp(np.pi / 2**(k-j), k, j)
def swap_registers_optimized(qc, n):
"""Swap the qubits to reverse their order."""
for qubit in range(n//2):
qc.swap(qubit, n-qubit-1)
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Apply the optimized QFT rotations
qft_rotations_optimized(qc, n)
# Reverse the order of qubits by swapping them
swap_registers_optimized(qc, n)
return qc
''' |
QPC002_B4 | AE42E00A249FA | 5 | WA | 1051 ms | 141 MiB | '''python
from qiskit import QuantumCircuit
import numpy as np
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Apply the QFT
for i in range(n):
qc.h(i)
for j in range(i+1, n):
qc.cp(np.pi / 2**(j-i), j, i)
# Reverse the order of qubits by swapping them
for i in range(n // 2):
qc.swap(i, n-i-1)
return qc
''' |
QPC002_B4 | AE42E00A249FA | 6 | WA | 1089 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
import numpy as np
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Apply the QFT
for i in range(n):
qc.h(i)
for j in range(i+1, n):
qc.cp(np.pi / 2**(j-i), j, i)
# Reverse the order of qubits by swapping them
for i in range(n // 2):
qc.swap(i, n-i-1)
return qc
''' |
QPC002_B4 | AE42E00A249FA | 7 | WA | 1327 ms | 183 MiB | '''python
from qiskit import QuantumCircuit
import numpy as np
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Apply the QFT
for i in range(n):
qc.h(i) # Apply Hadamard gate to qubit i
for j in range(i+1, n):
# Apply controlled phase rotation (CP) with decreasing angles
qc.cp(np.pi / 2**(j-i), j, i)
# Reverse the order of qubits by swapping them
for i in range(n // 2):
qc.swap(i, n-i-1)
return qc
''' |
QPC002_B4 | AE51AAF8D1287 | 1 | WA | 1824 ms | 160 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
qc.h(i)
for j in range(2, n - i + 1):
qc.cp(2 * math.pi / pow(2, j), i + j - 1, i)
return qc
''' |
QPC002_B4 | AE51AAF8D1287 | 2 | RE | 1545 ms | 141 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import HGate, ZGate, XGate, PhaseGate
from qiskit import QuantumRegister
import math
def QFT(qc : QuantumCircuit, idx : list[int]) -> QuantumCircuit:
n = len(idx)
for j in range(n):
qc.h(idx[j])
for k in range(j+1, n):
theta = math.pi / (2 ** (k - j))
qc.cp(theta, idx[k], idx[j])
for i in range(n // 2):
qc.swap(idx[i], idx[n - i - 1])
return qc
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
QFT(qc, list(n))
return qc
''' |
QPC002_B4 | AE51AAF8D1287 | 3 | RE | 1446 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import HGate, ZGate, XGate, PhaseGate
from qiskit import QuantumRegister
import math
def QFT(qc : QuantumCircuit, idx : list[int]) -> QuantumCircuit:
n = len(idx)
for j in range(n):
qc.h(idx[j])
for k in range(j+1, n):
theta = math.pi / (2 ** (k - j))
qc.cp(theta, idx[k], idx[j])
for i in range(n // 2):
qc.swap(idx[i], idx[n - i - 1])
return qc
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
QFT(qc, list(n))
return qc
''' |
QPC002_B4 | AE51AAF8D1287 | 4 | RE | 1692 ms | 141 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import HGate, ZGate, XGate, PhaseGate
from qiskit import QuantumRegister
import math
def QFT(qc : QuantumCircuit, idx : list[int]) -> QuantumCircuit:
n = len(idx)
for j in range(n):
qc.h(idx[j])
for k in range(j+1, n):
theta = math.pi / (2 ** (k - j))
qc.cp(theta, idx[k], idx[j])
for i in range(n // 2):
qc.swap(idx[i], idx[n - i - 1])
return qc
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
QFT(qc, list(n))
return qc
''' |
QPC002_B4 | AE51AAF8D1287 | 5 | WA | 1518 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import HGate, ZGate, XGate, PhaseGate
from qiskit import QuantumRegister
import math
def QFT(qc : QuantumCircuit, idx : list[int]) -> QuantumCircuit:
n = len(idx)
for j in range(n):
qc.h(idx[j])
for k in range(j+1, n):
theta = math.pi / (2 ** (k - j))
qc.cp(theta, idx[k], idx[j])
for i in range(n // 2):
qc.swap(idx[i], idx[n - i - 1])
return qc
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
QFT(qc, list(range(n)))
return qc
''' |
QPC002_B4 | AE51AAF8D1287 | 6 | WA | 1741 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import HGate, ZGate, XGate, PhaseGate
from qiskit import QuantumRegister
import math
def QFT(qc : QuantumCircuit, idx : list[int]) -> QuantumCircuit:
n = len(idx)
for j in range(n):
qc.h(idx[j])
for k in range(j+1, n):
theta = 2 * math.pi / (2 ** (k - j))
qc.cp(theta, idx[k], idx[j])
for i in range(n // 2):
qc.swap(idx[i], idx[n - i - 1])
return qc
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
QFT(qc, list(range(n)))
return qc
''' |
QPC002_B4 | AE51AAF8D1287 | 7 | WA | 1844 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import HGate, ZGate, XGate, PhaseGate
from qiskit import QuantumRegister
import math
def QFT(qc : QuantumCircuit, idx : list[int]) -> QuantumCircuit:
n = len(idx)
for j in range(n):
qc.h(idx[j])
for k in range(j+1, n):
theta = 2 * math.pi / (2 ** (k - j + 1))
qc.cp(theta, idx[k], idx[j])
for i in range(n // 2):
qc.swap(idx[i], idx[n - i - 1])
return qc
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
QFT(qc, list(range(n)))
return qc
''' |
QPC002_B4 | AE51AAF8D1287 | 8 | RE | 1711 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import HGate, ZGate, XGate, PhaseGate
from qiskit import QuantumRegister
import math
def QFT(qc : QuantumCircuit, idx : list[int]) -> QuantumCircuit:
for i in range(n // 2):
qc.swap(idx[i], idx[n - i - 1])
n = len(idx)
for j in range(n):
qc.h(idx[j])
for k in range(j+1, n):
theta = math.pi / (2 ** (k - j))
qc.cp(theta, idx[k], idx[j])
#for i in range(n // 2):
# qc.swap(idx[i], idx[n - i - 1])
return qc
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
QFT(qc, list(range(n)))
return qc
''' |
QPC002_B4 | AE51AAF8D1287 | 9 | AC | 1771 ms | 143 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import HGate, ZGate, XGate, PhaseGate
from qiskit import QuantumRegister
import math
def QFT(qc : QuantumCircuit, idx : list[int]) -> QuantumCircuit:
n = len(idx)
for i in range(n // 2):
qc.swap(idx[i], idx[n - i - 1])
for j in range(n):
qc.h(idx[j])
for k in range(j+1, n):
theta = math.pi / (2 ** (k - j))
qc.cp(theta, idx[k], idx[j])
#for i in range(n // 2):
# qc.swap(idx[i], idx[n - i - 1])
return qc
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
QFT(qc, list(range(n)))
return qc
''' |
QPC002_B4 | AEB363CF61CD3 | 1 | RE | 1059 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.h(i)
for j in range(i + 1, j):
theta = 2 * math.pi / (2 ** (j - i + 1))
qc.cp(j, i)
# swap
for i in range(n // 2):
qc.swap(i, n - 1 - i)
return qc
''' |
QPC002_B4 | AEB363CF61CD3 | 2 | WA | 1071 ms | 141 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.h(i)
for j in range(i + 1, n):
theta = 2 * math.pi / (2 ** (j - i + 1))
qc.cp(theta, j, i)
# swap
for i in range(n // 2):
qc.swap(i, n - 1 - i)
return qc
''' |
QPC002_B4 | AEB363CF61CD3 | 3 | AC | 1907 ms | 184 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.h(n - 1 - i)
for j in range(i + 1, n):
theta = 2 * math.pi / (2 ** (j - i + 1))
qc.cp(theta, n - 1 - j, n - 1 - i)
# swap
for i in range(n // 2):
qc.swap(i, n - 1 - i)
return qc
''' |
QPC002_B4 | AEBB62641F6D1 | 1 | RE | 2519 ms | 158 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.QFT(n)
return qc
''' |
QPC002_B4 | AEBB62641F6D1 | 2 | UME | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import QFT
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.QFT(n)
return qc
''' | ||
QPC002_B4 | AEFFEDDFA1FD1 | 1 | RE | 1146 ms | 141 MiB | '''python
from qiskit import QuantumCircuit
import numpy as np
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
def qft_com(i):
qc.h(i)
for j in range(n - 1 - i):
qc.cp((np.pi / 2 **(j + 1)), i + j + 1, i)
for i in range(n):
qft_com(i)
return qc
''' |
QPC002_B4 | AEFFEDDFA1FD1 | 2 | RE | 1303 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
import numpy as np
def solve(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.h(i)
for j in range(n - 1 - i):
qc.cp((np.pi / (2 ** (j + 1))), i + j + 1, i)
return qc
''' |
QPC002_B4 | AEFFEDDFA1FD1 | 3 | WA | 1162 ms | 153 MiB | '''python
from qiskit import QuantumCircuit
import numpy as np
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.h(i)
for j in range(n - 1 - i):
qc.cp((np.pi / (2 ** (j + 1))), i + j + 1, i)
return qc
''' |
QPC002_B4 | AEFFEDDFA1FD1 | 4 | WA | 1215 ms | 143 MiB | '''python
from qiskit import QuantumCircuit
import numpy as np
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.h(i)
for j in range(n - 1 - i):
qc.cp((np.pi / (2 ** (j + 1))), i, i + j + 1)
return qc
''' |
QPC002_B4 | AEFFEDDFA1FD1 | 5 | WA | 1297 ms | 182 MiB | '''python
from qiskit import QuantumCircuit
import numpy as np
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
def qft_com(i):
qc.h(i)
for j in range(n - 1 - i):
qc.cp((np.pi / 2 **(j + 1)), i + j + 1, i)
for i in range(n):
qft_com(i)
for i in range(n // 2):
qc.cx(i, n - 1 - i)
qc.cx(n - 1 - i, i)
qc.cx(i, n - 1 - i)
return qc
''' |
QPC002_B4 | AEFFEDDFA1FD1 | 6 | WA | 1110 ms | 144 MiB | '''python
from qiskit import QuantumCircuit
import numpy as np
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
def qft_com(i):
qc.h(i)
for j in range(n - 1 - i):
qc.cp(np.pi / (2 **(j + 1)), i + j + 1, i)
for i in range(n):
qft_com(i)
for i in range(n // 2):
qc.cx(i, n - 1 - i)
qc.cx(n - 1 - i, i)
qc.cx(i, n - 1 - i)
return qc
''' |
QPC002_B4 | AEFFEDDFA1FD1 | 7 | RE | 1363 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
import numpy as np
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
def qft_rotations(circuit, m):
if m == 0:
return circuit
m -= 1
circuit.h(n)
for qubit in range(n):
circuit.cp(pi/2**(n-qubit), qubit, m)
qft_rotations(circuit, m)
qft_rotations(qc, n)
return qc
''' |
QPC002_B4 | AEFFEDDFA1FD1 | 8 | RE | 1059 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
import numpy as np
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
def qft_rotations(circuit, m):
if m == 0:
return circuit
m -= 1
circuit.h(m)
for qubit in range(m):
circuit.cp(pi/2**(m-qubit), qubit, m)
qft_rotations(circuit, m)
qft_rotations(qc, n)
return qc
''' |
QPC002_B4 | AEFFEDDFA1FD1 | 9 | WA | 1148 ms | 141 MiB | '''python
from qiskit import QuantumCircuit
import numpy as np
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
def qft_rotations(circuit, m):
if m == 0:
return circuit
m -= 1
circuit.h(m)
for qubit in range(m):
circuit.cp(np.pi/2**(-qubit), qubit, m)
qft_rotations(circuit, m)
qft_rotations(qc, n)
return qc
''' |
QPC002_B4 | AEFFEDDFA1FD1 | 10 | WA | 1123 ms | 141 MiB | '''python
from qiskit import QuantumCircuit
import numpy as np
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
def qft_rotations(circuit, m):
if m == 0:
return circuit
m -= 1
circuit.h(m)
for qubit in range(m):
circuit.cp(np.pi/2**(-qubit), qubit, m)
qft_rotations(circuit, m)
def swap_registers(circuit, m):
for qubit in range(m//2):
circuit.swap(qubit, m-qubit-1)
return circuit
qft_rotations(qc, n)
swap_registers(qc, n)
return qc
''' |
QPC002_B4 | AEFFEDDFA1FD1 | 11 | AC | 1750 ms | 183 MiB | '''python
from qiskit import QuantumCircuit
import numpy as np
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for itarg in range(n - 1, -1, -1):
qc.h(itarg)
for ictrl in range(itarg - 1, -1, -1):
power = ictrl - itarg - 1 + n
qc.cp((2 ** power) * 2. * np.pi / (2 ** n), ictrl, itarg)
for i in range(n // 2):
qc.swap(i, n - 1 - i)
return qc
''' |
QPC002_B4 | AF5F74797E4E9 | 1 | RE | 1404 ms | 183 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import PhaseGate
import numpy as np
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
qc.h(i)
for k in range(i + 1, n):
qc.append(PhaseGate(np.pi / (2 ** (k - i))).control(1), [k, i])
qc.swap(0, n - 1)
for i in range(n // 2):
qc.swap(i, n - i - 1)
return qc
''' |
QPC002_B4 | AF5F74797E4E9 | 2 | WA | 1116 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import PhaseGate
import numpy as np
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
if n == 1:
qc.h(0)
return qc
for i in range(n):
qc.h(i)
for k in range(i + 1, n):
qc.append(PhaseGate(np.pi / (2 ** (k - i))).control(1), [k, i])
qc.swap(0, n - 1)
for i in range(n // 2):
qc.swap(i, n - i - 1)
return qc
''' |
QPC002_B4 | AF7BCF38BE080 | 1 | UME | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import QFT
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qft = QFT(num_qubits=n).to_gate()
qc.append(qft, qargs=list(range(n)))
return qc
''' | ||
QPC002_B4 | AF87D2595D72C | 1 | WA | 1751 ms | 156 MiB | '''python
from qiskit import QuantumCircuit
from math import pi
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.h(i)
for j in range(i + 1, n):
phase = 2 * pi / (2 ** (j - 1))
qc.crz(phase / 2, i, j)
return qc
''' |
QPC002_B4 | AF87D2595D72C | 2 | WA | 1591 ms | 155 MiB | '''python
from qiskit import QuantumCircuit
from math import pi
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.h(i)
for j in range(i + 1, n):
phase = 2 * pi / (2 ** (j + 1))
qc.crz(phase / 2, i, j)
return qc
''' |
QPC002_B4 | AF87D2595D72C | 3 | WA | 1219 ms | 156 MiB | '''python
from qiskit import QuantumCircuit
from math import pi
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.h(i)
for j in range(i + 1, n):
phase = 2 * pi / (2 ** (j + 1))
qc.crz(phase / 2, j, i)
return qc
''' |
QPC002_B4 | AF87D2595D72C | 4 | WA | 1296 ms | 155 MiB | '''python
from qiskit import QuantumCircuit
from math import pi
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.h(i)
for j in range(i + 1, n):
phase = 2 * pi / (2 ** (j + 1))
qc.crz(- phase / 2, j, i)
return qc
''' |
QPC002_B4 | AF87D2595D72C | 5 | WA | 1406 ms | 155 MiB | '''python
from qiskit import QuantumCircuit
from math import pi
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.h(i)
for j in range(i + 1, n):
phase = 2 * pi / (2 ** (j - i + 1))
qc.crz(phase / 2, j, i)
return qc
''' |
QPC002_B4 | AF87D2595D72C | 6 | WA | 1300 ms | 156 MiB | '''python
from qiskit import QuantumCircuit
from math import pi
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.h(i)
for j in range(i + 1, n):
phase = 2 * pi / (2 ** (j - i + 1))
qc.crz(phase, j, i)
return qc
''' |
QPC002_B4 | AF87D2595D72C | 7 | WA | 1686 ms | 155 MiB | '''python
from qiskit import QuantumCircuit
from math import pi
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.h(i)
for j in range(i + 1, n):
phase = 2 * pi / (2 ** (j - i + 1))
qc.cp(phase , j, i)
return qc
''' |
QPC002_B4 | AF87D2595D72C | 8 | WA | 1650 ms | 156 MiB | '''python
from qiskit import QuantumCircuit
from math import pi
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.h(i)
for j in range(i + 1, n):
phase = 2 * pi / (2 ** (j - i + 1))
qc.crz(phase , j, i)
for i in range(n // 2):
qc.swap(i, n - i - 1)
return qc
''' |
QPC002_B4 | AF87D2595D72C | 9 | WA | 1582 ms | 155 MiB | '''python
from qiskit import QuantumCircuit
from math import pi
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.h(i)
for j in range(i + 1, n):
phase = 2 * pi / (2 ** (j - i + 1))
qc.cp(phase , j, i)
for i in range(n // 2):
qc.swap(i, n - i - 1)
return qc
''' |
QPC002_B4 | AF87D2595D72C | 10 | WA | 1504 ms | 155 MiB | '''python
from qiskit import QuantumCircuit
from math import pi
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.h(i)
for j in range(i + 1, n):
phase = pi / (2 ** (j - i))
qc.cp(phase, j, i) # Controlled phase gate
qc.barrier()
for i in range(n // 2):
qc.swap(i, n - i - 1) # Swap to reverse the order
return qc
''' |
QPC002_B4 | AF87D2595D72C | 11 | WA | 1602 ms | 156 MiB | '''python
from qiskit import QuantumCircuit
from math import pi
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.h(i)
for j in range(i + 1, n):
phase = pi / (2 ** (j - i))
qc.cp(phase, j, i)
return qc
''' |
QPC002_B4 | AF87D2595D72C | 12 | WA | 1419 ms | 156 MiB | '''python
from qiskit import QuantumCircuit
from math import pi
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.h(i)
for j in range(i + 1, n):
phase = 2 * pi / (2 ** (j - i + 1))
qc.crz(phase, j, i)
for i in range(n // 2):
qc.swap(i, n - 1 - i)
return qc
''' |
QPC002_B4 | AF87D2595D72C | 13 | WA | 1516 ms | 156 MiB | '''python
from qiskit import QuantumCircuit
from math import pi
def solve(n: int) -> QuantumCircuit:
# Write your code here:
qc = qft(n, True)
return qc
def qft(n: int, is_little_endian: bool = False):
qc = QuantumCircuit(n)
targets = range(n) if not is_little_endian else reversed(range(n))
for i in targets:
qc.h(i)
controls = range(i + 1, n) if not is_little_endian else reversed(range(i + 1, n, 1))
for j in controls:
phase = 2 * pi / (2 ** (j - i + 1))
qc.crz(phase, j, i)
for i in range(n // 2):
qc.swap(i, n - 1 - i)
return qc
''' |
QPC002_B4 | AF87D2595D72C | 14 | WA | 1513 ms | 155 MiB | '''python
from qiskit import QuantumCircuit
from math import pi
def solve(n: int) -> QuantumCircuit:
# Write your code here:
qc = qft(n, True)
return qc
def qft(n: int, is_little_endian: bool = False):
qc = QuantumCircuit(n)
targets = range(n) if not is_little_endian else reversed(range(n))
for i in targets:
qc.h(i)
controls = range(i + 1, n) if not is_little_endian else reversed(range(i))
for j in controls:
phase = 2 * pi / (2 ** (abs(j - i) + 1))
qc.crz(phase, j, i)
for i in range(n // 2):
qc.swap(i, n - 1 - i)
return qc
''' |
QPC002_B4 | AF87D2595D72C | 15 | AC | 1869 ms | 155 MiB | '''python
from qiskit import QuantumCircuit
from math import pi
def solve(n: int) -> QuantumCircuit:
# Write your code here:
qc = qft(n, True)
return qc
def qft(n: int, is_little_endian: bool = False):
qc = QuantumCircuit(n)
targets = range(n) if not is_little_endian else reversed(range(n))
for i in targets:
qc.h(i)
controls = range(i + 1, n) if not is_little_endian else reversed(range(i))
for j in controls:
phase = 2 * pi / (2 ** (abs(j - i) + 1))
qc.cp(phase, j, i)
for i in range(n // 2):
qc.swap(i, n - 1 - i)
return qc
''' |
QPC002_B4 | AFBEBC7EF76AC | 1 | WA | 1082 ms | 141 MiB | '''python
from qiskit import QuantumCircuit
from math import pi
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for j in range(n):
for k in range(j):
qc.cp(pi/2**(j-k), k, j)
qc.h(j)
for i in range(n//2):
qc.swap(i, n-1-i)
return qc
''' |
QPC002_B4 | AFBEBC7EF76AC | 2 | WA | 1394 ms | 141 MiB | '''python
from qiskit import QuantumCircuit
from math import pi
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for j in range(n-1, -1, -1):
qc.h(j)
for k in range(j-1, -1, -1):
qc.cp(pi/2**(j-k), k, j)
return qc
''' |
QPC002_B5 | A04177BF589F8 | 1 | AC | 2108 ms | 160 MiB | '''python
import math
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate, PhaseGate
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
qc.p(2 * math.pi * S[i] / 2 ** m, i)
return qc
# if __name__ == "__main__":
# from qiskit.quantum_info import Statevector
# import numpy as np
# qc = solve(2, 2, [1, 3])
# # sv = Statevector(qc)
# # print(sv)
# print(qc)
# print(f"{qc.depth() = }")
# sv = Statevector.from_label('11')
# print(sv.evolve(qc))
''' |
QPC002_B5 | A044DBDEDB487 | 1 | AC | 2047 ms | 183 MiB | '''python
from qiskit import QuantumCircuit
from math import pi
def f(x, S):
pass
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for (i, s) in zip(range(n), S):
qc.p(2*pi *s/ (2**m), i)
return qc
''' |
QPC002_B5 | A0A2C9525EEEC | 1 | AC | 2054 ms | 183 MiB | '''python
from qiskit import QuantumCircuit
from math import tau
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i, s in enumerate(S):
qc.p(tau * s / (1 << m), i)
return qc
''' |
QPC002_B5 | A0A8A23BED7F4 | 1 | WA | 1561 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
theta = 2 * math.pi * S[i]
qc.p(theta, i)
return qc
''' |
QPC002_B5 | A0A8A23BED7F4 | 2 | WA | 1615 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
theta = 2 * math.pi * S[i] / (2 ** n)
qc.p(theta, i)
return qc
''' |
QPC002_B5 | A0A8A23BED7F4 | 3 | AC | 2011 ms | 143 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
theta = 2 * math.pi * S[i] / (2 ** m)
qc.p(theta, i)
return qc
''' |
QPC002_B5 | A0C6AC5D26EAC | 1 | RE | 1494 ms | 141 MiB | '''python
from qiskit import QuantumCircuit
import numpy as np
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.cp(2.0*np.pi/(2.0**m)*S[i])
return qc
''' |
QPC002_B5 | A0C6AC5D26EAC | 2 | AC | 2009 ms | 183 MiB | '''python
from qiskit import QuantumCircuit
import numpy as np
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.p(2.0*np.pi/(2.0**m)*S[i], i)
return qc
''' |
QPC002_B5 | A0DE0DBD2182F | 1 | RE | 1081 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
if S[i] == 1:
qc.p(2*math.pi/(1<<(m-i)) , i)
return qc
''' |
QPC002_B5 | A0DE0DBD2182F | 2 | RE | 1449 ms | 141 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(len(S)):
if S[i] == 1:
qc.p(2*math.pi/(1<<(m-i)) , i)
return qc
''' |
QPC002_B5 | A0DE0DBD2182F | 3 | AC | 2272 ms | 184 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(len(S)):
qc.p(2*math.pi*S[i]/(1<<m) , i)
return qc
''' |
QPC002_B5 | A0EF95FB76DF1 | 1 | RE | 1287 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
# Implement the phase oracle
for x in range(2**n):
# Convert x to its binary representation
bin_x = [int(bit) for bit in bin(x)[2:].zfill(n)]
# Compute f(x)
f_x = sum(S[i] * bin_x[i] for i in range(n))
# Calculate the phase angle
angle = (2 * pi * f_x) / (2 ** m)
# Apply the phase shift to the state |x>
for i in range(n):
if bin_x[i] == 1:
qc.rz(angle, i)
return qc
''' |
QPC002_B5 | A0EF95FB76DF1 | 2 | RE | 1368 ms | 141 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
# Implement the phase oracle
for x in range(2**n):
# Convert x to its binary representation
bin_x = [int(bit) for bit in bin(x)[2:].zfill(n)]
# Compute f(x)
f_x = sum(S[i] * bin_x[i] for i in range(n))
# Calculate the phase angle
angle = (2 * pi * f_x) / (2 ** m)
# Apply the phase shift to the correct state
for i in range(n):
if bin_x[i] == 1:
qc.x(i) # Apply X gate to flip qubit if necessary
qc.mcx(list(range(n)), 0) # Apply multi-controlled Z gate
qc.rz(angle, 0) # Apply the phase shift
qc.mcx(list(range(n)), 0) # Reverse the multi-controlled Z gate
for i in range(n):
if bin_x[i] == 1:
qc.x(i) # Revert the X gate if it was applied earlier
return qc
''' |
QPC002_B5 | A0EF95FB76DF1 | 3 | AC | 1890 ms | 184 MiB | '''python
from qiskit import QuantumCircuit
import numpy as np
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.p(2.0*np.pi/(2.0**m)*S[i], i)
return qc
''' |
QPC002_B5 | A13DE5922F58E | 1 | RE | 1247 ms | 141 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.p(2 * math.pi * s[i] / pow(2, m), i)
return qc
''' |
QPC002_B5 | A13DE5922F58E | 2 | WA | 1198 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
return qc
''' |
QPC002_B5 | A13DE5922F58E | 3 | RE | 1235 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.p(2 * math.pi * s[i] / pow(2, m), i)
return qc
''' |
QPC002_B5 | A13DE5922F58E | 4 | RE | 1336 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.phase(2 * math.pi * s[i] / pow(2, m), i)
return qc
''' |
QPC002_B5 | A13DE5922F58E | 5 | RE | 1023 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.phas(2 * pi * s[i] / pow(2, m), i)
return qc
''' |
QPC002_B5 | A13DE5922F58E | 6 | RE | 1336 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.phase(0, i)
return qc
''' |
QPC002_B5 | A13DE5922F58E | 7 | RE | 1185 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.phase(0, i)
return qc
''' |
QPC002_B5 | A13DE5922F58E | 8 | WA | 1271 ms | 141 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.p(2 * math.pi / pow(2, m), i)
return qc
''' |
QPC002_B5 | A13DE5922F58E | 9 | RE | 1280 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.p(2 * math.pi * s[i] / pow(2, m), i)
return qc
''' |
QPC002_B5 | A13DE5922F58E | 10 | RE | 1123 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.p(2 * math.pi * float(s[i]) / pow(2, m), i)
return qc
''' |
QPC002_B5 | A13DE5922F58E | 11 | AC | 2695 ms | 183 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.p(2 * math.pi * S[i] / pow(2, m), i)
return qc
''' |
QPC002_B5 | A151DEBE79438 | 1 | AC | 2106 ms | 183 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import GlobalPhaseGate
import numpy as np
import math
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for idx in range(0, n):
theta = 2 * math.pi * S[idx] / (2**m)
qc.p(theta, idx)
return qc
''' |
QPC002_B5 | A19D045C5FE20 | 1 | WA | 1166 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
qc.p(math.pi * S[i] / 2**m, i)
return qc
''' |
QPC002_B5 | A19D045C5FE20 | 2 | AC | 1974 ms | 184 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
qc.p(2 * math.pi * S[i] / 2**m, i)
return qc
''' |
QPC002_B5 | A1C9CB2896064 | 1 | AC | 2449 ms | 156 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.p(2 * math.pi * S[i] / 2 ** m, i)
return qc
''' |
QPC002_B5 | A1E9E32F9CAB5 | 1 | WA | 2180 ms | 155 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
return qc
''' |
QPC002_B5 | A222D01B42E79 | 1 | RE | 1853 ms | 153 MiB | '''python
from qiskit import QuantumCircuit
import math
# from qiskit.quantum_info import Statevector
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.p(2*math.pi*S[i]/(2**m))
return qc
# if __name__ == "__main__":
# qc = solve()
# print(Statevector(qc))
''' |
QPC002_B5 | A222D01B42E79 | 2 | AC | 2080 ms | 155 MiB | '''python
from qiskit import QuantumCircuit
import math
# from qiskit.quantum_info import Statevector
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.p(2*math.pi*S[i]/(2**m), i)
return qc
# if __name__ == "__main__":
# qc = solve()
# print(Statevector(qc))
''' |
QPC002_B5 | A266BB9DB3C1D | 1 | RE | 1672 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.p(2*np.pi*S[i]/2**m, i)
return qc
''' |
QPC002_B5 | A266BB9DB3C1D | 2 | AC | 2760 ms | 183 MiB | '''python
from qiskit import QuantumCircuit
import numpy as np
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.p(2*np.pi*S[i]/2**m, i)
return qc
''' |
QPC002_B5 | A36B1ED26740B | 1 | AC | 2507 ms | 183 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library.standard_gates import U1Gate
from math import pi
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
qc.append(U1Gate(2 * pi * S[i] / 2 ** m), [i])
return qc
''' |
QPC002_B5 | A3F3645C74CF0 | 1 | RE | 1238 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
from math import pi
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# For each qubit i, apply a controlled phase rotation
for i in range(n):
angle = 2 * pi * S[i] / (2 ** m)
qc.cp(angle, i, 0) # Controlled phase rotation with qubit i controlling
return qc
''' |
QPC002_B5 | A3FC3048CD1D7 | 1 | AC | 2310 ms | 143 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.p(2*math.pi*S[i]/2**m,i)
return qc
''' |
QPC002_B5 | A4C925003499B | 1 | WA | 1270 ms | 183 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.p(S[i]/(2**m), i)
return qc
''' |
QPC002_B5 | A4C925003499B | 2 | AC | 1911 ms | 184 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.p(2*math.pi*S[i]/(2**m), i)
return qc
''' |
QPC002_B5 | A55FB7A02A342 | 1 | RE | 1156 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
import numpy as np
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n, name='oracle')
# Write your code here:
control_qubits = list(range(n))
# Iterate through each qubit and apply controlled phase rotations
for i in range(n):
phase = 2 * np.pi * S[i] / (2 ** m)
qc.cp(phase, control_qubits[i], n)
return qc
''' |
QPC002_B5 | A5A2D9B1DC196 | 1 | AC | 1977 ms | 183 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
import math
for i in range(n):
qc.p(S[i] * 2 * math.pi / 2**m, i)
return qc
''' |
QPC002_B5 | A5A30757D0C26 | 1 | RE | 1461 ms | 154 MiB | '''python
from qiskit import QuantumCircuit
import numpy as np
from qiskit.circuit.library import MCPhaseGate
#from qiskit.quantum_info import Statevector
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
qc.x(0)
qc.x(1)
# Write your code here:
if n==1:
qc.p(2*np.pi*S[0]/(2**m),0)
return qc
for i in range(n):
qc.cp(2*np.pi*S[i]/(2**m),i,(i+1)%n)
return qc
qc = solve(2,2,[1,3])
print(qc)
#print(Statevector(qc)) #こことimportを消す
''' |
QPC002_B5 | A5A30757D0C26 | 2 | WA | 1411 ms | 184 MiB | '''python
from qiskit import QuantumCircuit
import numpy as np
from qiskit.circuit.library import MCPhaseGate
#from qiskit.quantum_info import Statevector
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
if n==1:
qc.p(2*np.pi*S[0]/(2**m),0)
return qc
for i in range(n):
qc.cp(2*np.pi*S[i]/(2**m),i,(i+1)%n)
return qc
qc = solve(2,2,[1,3])
print(qc)
#print(Statevector(qc)) #こことimportを消す
''' |
QPC002_B5 | A5A30757D0C26 | 3 | AC | 2353 ms | 161 MiB | '''python
from math import tau # tau = 2π
from qiskit import QuantumCircuit
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
"""
Return an n-qubit oracle O such that
|x> ──► exp(2πi f(x)/2^m) |x>,
with f(x) = Σ S_k x_k (little-endian).
Circuit depth = 1 (all gates parallel).
"""
qc = QuantumCircuit(n)
denom = 1 << m # 2^m
for k in range(n):
# Phase angle ϕ_k = 2π S_k / 2^m (wrapped automatically by Qiskit)
phi = tau * (S[k] % denom) / denom
qc.p(phi, k) # Phase (diag[1, e^{iϕ_k}]) on qubit k
return qc
''' |
QPC002_B5 | A5AE42EE5763C | 1 | WA | 1154 ms | 141 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
qc.p(math.pi * S[i] / pow(2, m), i)
return qc
''' |
QPC002_B5 | A5AE42EE5763C | 2 | AC | 2092 ms | 183 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
qc.p(2 * math.pi * S[i] / pow(2, m), i)
return qc
''' |
QPC002_B5 | A6E62382E7A2B | 1 | RE | 1945 ms | 156 MiB | '''python
from qiskit import QuantumCircuit
import math
def create_oracle(n, m, S):
# Create a quantum circuit with n qubits
qc = QuantumCircuit(n)
# Iterate over all possible values of x from 0 to 2^n - 1
for x in range(2**n):
# Calculate f(x)
f_x = sum(S[i] * ((x >> i) & 1) for i in range(n))
# Calculate the phase
phase = (2 * math.pi * f_x) / (2**m)
# Apply the phase shift to the corresponding state |x>
if phase != 0:
qc.p(phase, x) # Apply phase shift using the p gate
return qc
''' |
QPC002_B5 | A6E62382E7A2B | 2 | RE | 2082 ms | 157 MiB | '''python
import math
from qiskit import QuantumCircuit, QuantumRegister
def create_oracle(n, m, S):
# Create a quantum register and a quantum circuit
qr = QuantumRegister(n)
qc = QuantumCircuit(qr)
# Iterate over all possible values of x (0 to 2^n - 1)
for x in range(2**n):
# Calculate f(x)
f_x = sum(S[i] * ((x >> i) & 1) for i in range(n))
# Calculate the phase
phase = (2 * math.pi * f_x) / (2**m)
# Apply the phase shift to the state |x>
qc.p(phase, qr[0]) # Apply phase to the first qubit (little-endian)
for i in range(1, n):
qc.p(phase, qr[i]) # Apply phase to the remaining qubits
return qc
''' |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.