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_B6 | AF66D93D9F2B1 | 4 | WA | 1400 ms | 153 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
import math
def qft(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
qc.h(i)
rotation = math.pi / 2
for j in range(i + 1, n):
qc.cp(rotation, j, i)
rotation /= 2
for i in range(n // 2):
qc.swap(i, n - i - 1)
qc = qc.reverse_bits()
return qc
def add_k_fourier(
qc: QuantumCircuit, k: int, control: QuantumRegister
) -> QuantumCircuit:
for i in range(m):
qc.crz(math.pi * k / 2**i, control, y[i])
qc.compose(qft(m), inplace=True, qubits=y)
for i in range(n):
add_k_fourier(qc, S[i], x[i])
qc.compose(qft(m).inverse(), inplace=True, qubits=y)
return qc
''' |
QPC002_B6 | AF66D93D9F2B1 | 5 | WA | 1472 ms | 144 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
import math
def qft(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
qc.h(i)
rotation = math.pi / 2
for j in range(i + 1, n):
qc.cp(rotation, j, i)
rotation /= 2
# for i in range(n // 2):
# qc.swap(i, n - i - 1)
qc = qc.reverse_bits()
return qc
def add_k_fourier(
qc: QuantumCircuit, k: int, control: QuantumRegister
) -> QuantumCircuit:
for i in range(m):
qc.crz(math.pi * k / 2**i, control, y[i])
# qc.rz(math.pi * k / 2**i, y[i])
qc.compose(qft(m), inplace=True, qubits=y)
for i in range(n):
add_k_fourier(qc, S[i], x[i])
# add_k_fourier(qc, 0, x)
qc.compose(qft(m).inverse(), inplace=True, qubits=y)
return qc
''' |
QPC002_B6 | AF66D93D9F2B1 | 6 | WA | 1220 ms | 153 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
import math
def qft(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
qc.h(i)
rotation = math.pi / 2
for j in range(i + 1, n):
qc.cp(rotation, j, i)
rotation /= 2
for i in range(n // 2):
qc.swap(i, n - i - 1)
# qc = qc.reverse_bits()
return qc
def add_k_fourier(
qc: QuantumCircuit, k: int, control: QuantumRegister
) -> QuantumCircuit:
for i in range(m):
qc.crz(math.pi * k / 2**i, control, y[i])
# qc.rz(math.pi * k / 2**i, y[i])
qc.compose(qft(m), inplace=True, qubits=y)
for i in range(n):
add_k_fourier(qc, S[i], x[n - i - 1])
# add_k_fourier(qc, 0, x)
qc.compose(qft(m).inverse(), inplace=True, qubits=y)
return qc
''' |
QPC002_B6 | AF66D93D9F2B1 | 7 | WA | 1269 ms | 144 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
import math
def qft(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
qc.h(i)
rotation = math.pi / 2
for j in range(i + 1, n):
qc.cp(rotation, j, i)
rotation /= 2
for i in range(n // 2):
qc.swap(i, n - i - 1)
# qc = qc.reverse_bits()
return qc
def add_k_fourier(
qc: QuantumCircuit, k: int, control: QuantumRegister
) -> QuantumCircuit:
for i in range(m):
qc.crz(math.pi * k / 2**i, control, y[i])
# qc.rz(math.pi * k / 2**i, y[i])
qc.compose(qft(m), inplace=True, qubits=y)
for i in range(n):
add_k_fourier(qc, S[n - i - 1], x[n - i - 1])
# add_k_fourier(qc, 0, x)
qc.compose(qft(m).inverse(), inplace=True, qubits=y)
return qc
''' |
QPC002_B6 | AF66D93D9F2B1 | 8 | WA | 1802 ms | 143 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
import math
def qft(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
qc.h(i)
rotation = math.pi / 2
for j in range(i + 1, n):
qc.cp(rotation, j, i)
rotation /= 2
for i in range(n // 2):
qc.swap(i, n - i - 1)
# qc = qc.reverse_bits()
return qc
def add_k_fourier(
qc: QuantumCircuit, k: int, control: QuantumRegister
) -> QuantumCircuit:
for i in range(m):
qc.crz(math.pi * k / 2**i, control, y[i])
# qc.rz(math.pi * k / 2**i, y[i])
qc.compose(qft(m), inplace=True, qubits=y)
for i in range(n):
add_k_fourier(qc, S[n - 1 - i], x[i])
# add_k_fourier(qc, 0, x)
qc.compose(qft(m).inverse(), inplace=True, qubits=y)
return qc
''' |
QPC002_B6 | AF66D93D9F2B1 | 9 | WA | 1186 ms | 144 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
import math
def qft(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
qc.h(i)
rotation = math.pi / 2
for j in range(i + 1, n):
qc.cp(rotation, j, i)
rotation /= 2
for i in range(n // 2):
qc.swap(i, n - i - 1)
qc = qc.reverse_bits()
return qc
def add_k_fourier(
qc: QuantumCircuit, k: int, control: QuantumRegister
) -> QuantumCircuit:
for i in range(m):
qc.crz(math.pi * k / 2**i, control, y[i])
# qc.rz(math.pi * k / 2**i, y[i])
qc.compose(qft(m), inplace=True, qubits=y)
for i in range(n):
add_k_fourier(qc, S[i], x[i])
# add_k_fourier(qc, 0, x)
qc.compose(qft(m).inverse(), inplace=True, qubits=y)
return qc
''' |
QPC002_B6 | AF66D93D9F2B1 | 10 | WA | 1632 ms | 140 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
import math
def qft(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
qc.h(i)
rotation = math.pi / 2
for j in range(i + 1, n):
qc.cp(rotation, j, i)
rotation /= 2
for i in range(n // 2):
qc.swap(i, n - i - 1)
qc = qc.reverse_bits()
return qc
def add_k_fourier(
qc: QuantumCircuit, k: int, control: QuantumRegister
) -> QuantumCircuit:
for i in range(m):
qc.crz(math.pi * k / 2**i, control, y[m - i - 1])
qc.compose(qft(m), inplace=True, qubits=y)
for i in range(n):
add_k_fourier(qc, S[i], x[i])
qc.compose(qft(m).inverse(), inplace=True, qubits=y)
return qc
''' |
QPC002_B6 | AF66D93D9F2B1 | 11 | WA | 1287 ms | 154 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
import math
def qft(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
qc.h(i)
rotation = math.pi / 2
for j in range(i + 1, n):
qc.cp(rotation, j, i)
rotation /= 2
for i in range(n // 2):
qc.swap(i, n - i - 1)
qc = qc.reverse_bits()
return qc
def add_k_fourier(
qc: QuantumCircuit, k: int, control: QuantumRegister
) -> QuantumCircuit:
for i in range(m):
qc.crz(math.pi * k / 2**i, control, y[m - i - 1])
qc.compose(qft(m), inplace=True, qubits=y)
for i in range(n):
add_k_fourier(qc, S[n - i - 1], x[i])
qc.compose(qft(m).inverse(), inplace=True, qubits=y)
return qc
''' |
QPC002_B6 | AF66D93D9F2B1 | 12 | WA | 1171 ms | 143 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
import math
def qft(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
qc.h(i)
rotation = math.pi / 2
for j in range(i + 1, n):
qc.cp(rotation, j, i)
rotation /= 2
for i in range(n // 2):
qc.swap(i, n - i - 1)
qc = qc.reverse_bits()
return qc
def add_k_fourier(
qc: QuantumCircuit, k: int, control: QuantumRegister
) -> QuantumCircuit:
for i in range(m):
qc.crz(math.pi * k / 2**i, control, y[m - i - 1])
qc.compose(qft(m), inplace=True, qubits=y)
for i in range(n):
add_k_fourier(qc, S[n - i - 1], x[n - i - 1])
qc.compose(qft(m).inverse(), inplace=True, qubits=y)
return qc
''' |
QPC002_B6 | AF66D93D9F2B1 | 13 | WA | 1423 ms | 143 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
import math
def qft(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
qc.h(i)
rotation = math.pi / 2
for j in range(i + 1, n):
qc.cp(rotation, j, i)
rotation /= 2
# for i in range(n // 2):
# qc.swap(i, n - i - 1)
# qc = qc.reverse_bits()
return qc
def add_k_fourier(
qc: QuantumCircuit, k: int, control: QuantumRegister
) -> QuantumCircuit:
for i in range(m):
qc.crz(math.pi * k / 2**i, control, y[m - 1 - i])
qc.compose(qft(m), inplace=True, qubits=y)
for i in range(n):
add_k_fourier(qc, S[i], x[i])
qc.compose(qft(m).inverse(), inplace=True, qubits=y)
return qc
''' |
QPC002_B6 | AF66D93D9F2B1 | 14 | WA | 1245 ms | 141 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
import math
def qft(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
qc.h(i)
rotation = math.pi / 2
for j in range(i + 1, n):
qc.cp(rotation, j, i)
rotation /= 2
for i in range(n // 2):
qc.swap(i, n - i - 1)
# qc = qc.reverse_bits()
return qc
def add_k_fourier(
qc: QuantumCircuit, k: int, control: QuantumRegister
) -> QuantumCircuit:
for i in range(m):
qc.crz(math.pi * k / 2**i, control, y[i])
qc.compose(qft(m), inplace=True, qubits=y)
for i in range(n):
add_k_fourier(qc, S[i], x[i])
qc.compose(qft(m).inverse(), inplace=True, qubits=y)
return qc
''' |
QPC002_B6 | AF66D93D9F2B1 | 15 | WA | 1351 ms | 153 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
import math
def qft(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
qc.h(i)
rotation = math.pi / 2
for j in range(i + 1, n):
qc.cp(rotation, j, i)
rotation /= 2
for i in range(n // 2):
qc.swap(i, n - i - 1)
# qc = qc.reverse_bits()
return qc
def add_k_fourier(
qc: QuantumCircuit, k: int, control: QuantumRegister
) -> QuantumCircuit:
for i in range(m):
qc.crz(math.pi * k / 2**i, control, y[i])
def swap_qubits(qc: QuantumCircuit, x: QuantumRegister):
for i in range(len(x) // 2):
qc.swap(x[i], x[len(x) - i - 1])
qc.compose(qft(m), inplace=True, qubits=y)
for i in range(n):
add_k_fourier(qc, S[i], x[i])
qc.compose(qft(m).inverse(), inplace=True, qubits=y)
swap_qubits(qc, y)
return qc
''' |
QPC002_B6 | AF66D93D9F2B1 | 16 | WA | 1465 ms | 141 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
import math
def qft(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
qc.h(i)
rotation = math.pi / 2
for j in range(i + 1, n):
qc.cp(rotation, j, i)
rotation /= 2
for i in range(n // 2):
qc.swap(i, n - i - 1)
# qc = qc.reverse_bits()
return qc
def add_k_fourier(
qc: QuantumCircuit, k: int, control: QuantumRegister
) -> QuantumCircuit:
for i in range(m):
qc.crz(math.pi * k / 2**i, control, y[i])
def swap_qubits(qc: QuantumCircuit, x: QuantumRegister):
for i in range(len(x) // 2):
qc.swap(x[i], x[len(x) - i - 1])
swap_qubits(qc, x)
qc.compose(qft(m), inplace=True, qubits=y)
for i in range(n):
add_k_fourier(qc, S[i], x[i])
qc.compose(qft(m).inverse(), inplace=True, qubits=y)
# swap_qubits(qc, y)
return qc
''' |
QPC002_B6 | AF66D93D9F2B1 | 17 | WA | 1338 ms | 183 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
import math
def qft(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
qc.h(i)
rotation = math.pi / 2
for j in range(i + 1, n):
qc.cp(rotation, j, i)
rotation /= 2
for i in range(n // 2):
qc.swap(i, n - i - 1)
# qc = qc.reverse_bits()
return qc
def add_k_fourier(
qc: QuantumCircuit, k: int, control: QuantumRegister
) -> QuantumCircuit:
for i in range(m):
qc.crz(math.pi * k / 2**i, control, y[i])
def swap_qubits(qc: QuantumCircuit, x: QuantumRegister):
for i in range(len(x) // 2):
qc.swap(x[i], x[len(x) - i - 1])
swap_qubits(qc, x)
qc.compose(qft(m), inplace=True, qubits=y)
for i in range(n):
add_k_fourier(qc, S[i], x[i])
qc.compose(qft(m).inverse(), inplace=True, qubits=y)
swap_qubits(qc, y)
return qc
''' |
QPC002_B6 | AF66D93D9F2B1 | 18 | WA | 1689 ms | 182 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
import math
def qft(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
qc.h(i)
rotation = math.pi / 2
for j in range(i + 1, n):
qc.cp(rotation, j, i)
rotation /= 2
for i in range(n // 2):
qc.swap(i, n - i - 1)
# qc = qc.reverse_bits()
return qc
def add_k_fourier(
qc: QuantumCircuit, k: int, control: QuantumRegister
) -> QuantumCircuit:
for i in range(m):
qc.crz(math.pi * k / 2**i, control, y[i])
def swap_qubits(qc: QuantumCircuit, x: QuantumRegister):
for i in range(len(x) // 2):
qc.swap(x[i], x[len(x) - i - 1])
swap_qubits(qc, x)
qc.compose(qft(m), inplace=True, qubits=y)
for i in range(n):
add_k_fourier(qc, S[i], x[i])
qc.compose(qft(m).inverse(), inplace=True, qubits=y)
# swap_qubits(qc, y)
return qc
''' |
QPC002_B6 | AF66D93D9F2B1 | 19 | WA | 1177 ms | 153 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
import math
def qft(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
qc.h(i)
rotation = math.pi / 2
for j in range(i + 1, n):
qc.cp(rotation, j, i)
rotation /= 2
for i in range(n // 2):
qc.swap(i, n - i - 1)
# qc = qc.reverse_bits()
return qc
def add_k_fourier(
qc: QuantumCircuit, k: int, control: QuantumRegister
) -> QuantumCircuit:
for i in range(m):
qc.crz(2 * math.pi * k / 2**i, control, y[i])
def swap_qubits(qc: QuantumCircuit, x: QuantumRegister):
for i in range(len(x) // 2):
qc.swap(x[i], x[len(x) - i - 1])
# swap_qubits(qc, x)
qc.compose(qft(m), inplace=True, qubits=y)
for i in range(n):
add_k_fourier(qc, S[i], x[i])
qc.compose(qft(m).inverse(), inplace=True, qubits=y)
# swap_qubits(qc, y)
return qc
''' |
QPC002_B6 | AF66D93D9F2B1 | 20 | WA | 1421 ms | 182 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
import math
def qft(num_qubits: int) -> QuantumCircuit:
qc = QuantumCircuit(num_qubits)
for i in range(num_qubits):
qc.h(i)
rotation = math.pi / 2
for j in range(i + 1, num_qubits):
qc.cp(rotation, j, i)
rotation /= 2
for i in range(num_qubits // 2):
qc.swap(i, num_qubits - i - 1)
# qc = qc.reverse_bits()
return qc
def add_k_fourier(
qc: QuantumCircuit, k: int, control: QuantumRegister
) -> QuantumCircuit:
for i in range(m):
qc.crz(math.pi * k / 2**i, control, y[i])
def swap_qubits(qc: QuantumCircuit, x: QuantumRegister):
for i in range(len(x) // 2):
qc.swap(x[i], x[len(x) - i - 1])
# swap_qubits(qc, x)
qc.compose(qft(m), inplace=True, qubits=y)
for i in range(n):
add_k_fourier(qc, S[i], x[i])
qc.compose(qft(m).inverse(), inplace=True, qubits=y)
# swap_qubits(qc, y)
return qc
''' |
QPC002_B6 | AF66D93D9F2B1 | 21 | WA | 1644 ms | 182 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
import math
def qft(num_qubits: int) -> QuantumCircuit:
qc = QuantumCircuit(num_qubits)
for i in range(num_qubits):
qc.h(i)
rotation = math.pi / 2
for j in range(i + 1, num_qubits):
qc.cp(rotation, j, i)
rotation /= 2
for i in range(num_qubits // 2):
qc.swap(i, num_qubits - i - 1)
qc = qc.reverse_bits()
return qc
def add_k_fourier(
qc: QuantumCircuit, k: int, control: QuantumRegister
) -> QuantumCircuit:
for i in range(m):
qc.crz(math.pi * k / 2**i, control_qubit=control, target_qubit=y[m - 1 - i])
def swap_qubits(qc: QuantumCircuit, x: QuantumRegister):
for i in range(len(x) // 2):
qc.swap(x[i], x[len(x) - i - 1])
# swap_qubits(qc, x)
qc.compose(qft(m), inplace=True, qubits=y)
for i in range(n):
add_k_fourier(qc, S[i], x[i])
qc.compose(qft(m).inverse(), inplace=True, qubits=y)
swap_qubits(qc, y)
return qc
''' |
QPC002_B6 | AF66D93D9F2B1 | 22 | WA | 1321 ms | 141 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
import math
def qft(num_qubits: int) -> QuantumCircuit:
qc = QuantumCircuit(num_qubits)
for i in range(num_qubits):
qc.h(i)
rotation = math.pi / 2
for j in range(i + 1, num_qubits):
qc.cp(rotation, j, i)
rotation /= 2
for i in range(num_qubits // 2):
qc.swap(i, num_qubits - i - 1)
qc = qc.reverse_bits()
return qc
def add_k_fourier(
qc: QuantumCircuit, k: int, control: QuantumRegister
) -> QuantumCircuit:
for i in range(m):
qc.crz(math.pi * k / 2**i, control_qubit=control, target_qubit=y[m - 1 - i])
def swap_qubits(qc: QuantumCircuit, x: QuantumRegister):
for i in range(len(x) // 2):
qc.swap(x[i], x[len(x) - i - 1])
# swap_qubits(qc, x)
qc.compose(qft(m), inplace=True, qubits=y)
for i in range(n):
add_k_fourier(qc, S[i], x[i])
qc.compose(qft(m).inverse(), inplace=True, qubits=y)
# swap_qubits(qc, y)
return qc
''' |
QPC002_B6 | AF66D93D9F2B1 | 23 | WA | 1241 ms | 153 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
import math
def qft(num_qubits: int) -> QuantumCircuit:
qc = QuantumCircuit(num_qubits)
for i in range(num_qubits):
qc.h(i)
rotation = math.pi / 2
for j in range(i + 1, num_qubits):
qc.cp(rotation, j, i)
rotation /= 2
for i in range(num_qubits // 2):
qc.swap(i, num_qubits - i - 1)
# qc = qc.reverse_bits()
return qc
def add_k_fourier(
qc: QuantumCircuit, k: int, control: QuantumRegister
) -> QuantumCircuit:
for i in range(m):
qc.crz(math.pi * k / 2**i, control_qubit=control, target_qubit=y[i])
def swap_qubits(qc: QuantumCircuit, x: QuantumRegister):
for i in range(len(x) // 2):
qc.swap(x[i], x[len(x) - i - 1])
# swap_qubits(qc, x)
qc.compose(qft(m), inplace=True, qubits=y)
for i in range(n):
add_k_fourier(qc, S[i], x[i])
qc.compose(qft(m).inverse(), inplace=True, qubits=y)
# swap_qubits(qc, y)
return qc
''' |
QPC002_B6 | AF66D93D9F2B1 | 24 | WA | 1602 ms | 182 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
import math
def qft(num_qubits: int) -> QuantumCircuit:
qc = QuantumCircuit(num_qubits)
for i in range(num_qubits):
qc.h(i)
rotation = math.pi / 2
for j in range(i + 1, num_qubits):
qc.cp(rotation, j, i)
rotation /= 2
# for i in range(num_qubits // 2):
# qc.swap(i, num_qubits - i - 1)
# qc = qc.reverse_bits()
return qc
def add_k_fourier(
qc: QuantumCircuit, k: int, control: QuantumRegister
) -> QuantumCircuit:
for i in range(m):
qc.crz(math.pi * k / 2**i, control_qubit=control, target_qubit=y[m - 1 - i])
def swap_qubits(qc: QuantumCircuit, x: QuantumRegister):
for i in range(len(x) // 2):
qc.swap(x[i], x[len(x) - i - 1])
# swap_qubits(qc, x)
qc.compose(qft(m), inplace=True, qubits=y)
for i in range(n):
add_k_fourier(qc, S[i], x[i])
qc.compose(qft(m).inverse(), inplace=True, qubits=y)
# swap_qubits(qc, y)
return qc
''' |
QPC002_B6 | AF66D93D9F2B1 | 25 | WA | 1312 ms | 154 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
import math
def qft(num_qubits: int) -> QuantumCircuit:
qc = QuantumCircuit(num_qubits)
for i in range(num_qubits):
qc.h(i)
rotation = math.pi / 2
for j in range(i + 1, num_qubits):
qc.cp(rotation, j, i)
rotation /= 2
# for i in range(num_qubits // 2):
# qc.swap(i, num_qubits - i - 1)
# qc = qc.reverse_bits()
return qc
def add_k_fourier(
qc: QuantumCircuit, k: int, control: QuantumRegister
) -> QuantumCircuit:
for i in range(m):
qc.crz(math.pi * k / 2**i, control_qubit=control, target_qubit=y[m - 1 - i])
def swap_qubits(qc: QuantumCircuit, x: QuantumRegister):
for i in range(len(x) // 2):
qc.swap(x[i], x[len(x) - i - 1])
# swap_qubits(qc, x)
qc.compose(qft(m), inplace=True, qubits=y)
for i in range(n):
add_k_fourier(qc, S[n - 1 - i], x[n - 1 - i])
qc.compose(qft(m).inverse(), inplace=True, qubits=y)
# swap_qubits(qc, y)
return qc
''' |
QPC002_B6 | AF66D93D9F2B1 | 26 | WA | 1216 ms | 141 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
import math
def qft(num_qubits: int) -> QuantumCircuit:
qc = QuantumCircuit(num_qubits)
for i in range(num_qubits):
qc.h(i)
rotation = math.pi / 2
for j in range(i + 1, num_qubits):
qc.cp(rotation, j, i)
rotation /= 2
# for i in range(num_qubits // 2):
# qc.swap(i, num_qubits - i - 1)
# qc = qc.reverse_bits()
return qc
def add_k_fourier(
qc: QuantumCircuit, k: int, control: QuantumRegister
) -> QuantumCircuit:
for i in range(m):
qc.crz(math.pi * k / 2**i, control_qubit=control, target_qubit=y[m - 1 - i])
def swap_qubits(qc: QuantumCircuit, x: QuantumRegister):
for i in range(len(x) // 2):
qc.swap(x[i], x[len(x) - i - 1])
# swap_qubits(qc, x)
qc.compose(qft(m), inplace=True, qubits=y)
for i in range(n):
add_k_fourier(qc, S[i], x[i])
qc.compose(qft(m).inverse(), inplace=True, qubits=y)
swap_qubits(qc, y)
return qc
''' |
QPC002_B6 | AF66D93D9F2B1 | 27 | WA | 1352 ms | 140 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
import math
def qft(num_qubits: int) -> QuantumCircuit:
qc = QuantumCircuit(num_qubits)
for i in range(num_qubits):
qc.h(i)
rotation = math.pi / 2
for j in range(i + 1, num_qubits):
qc.cp(rotation, i, j)
rotation /= 2
# for i in range(num_qubits // 2):
# qc.swap(i, num_qubits - i - 1)
# qc = qc.reverse_bits()
return qc
def add_k_fourier(
qc: QuantumCircuit, k: int, control: QuantumRegister
) -> QuantumCircuit:
for i in range(m):
qc.crz(math.pi * k / 2**i, control_qubit=control, target_qubit=y[m - 1 - i])
def swap_qubits(qc: QuantumCircuit, x: QuantumRegister):
for i in range(len(x) // 2):
qc.swap(x[i], x[len(x) - i - 1])
# swap_qubits(qc, x)
qc.compose(qft(m), inplace=True, qubits=y)
for i in range(n):
add_k_fourier(qc, S[i], x[i])
qc.compose(qft(m).inverse(), inplace=True, qubits=y)
# swap_qubits(qc, y)
return qc
''' |
QPC002_B6 | AF66D93D9F2B1 | 28 | WA | 1278 ms | 140 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
import math
def qft(num_qubits: int) -> QuantumCircuit:
qc = QuantumCircuit(num_qubits)
for i in range(num_qubits):
qc.h(i)
rotation = math.pi / 2
for j in range(i + 1, num_qubits):
qc.cp(rotation, i, j)
rotation /= 2
for i in range(num_qubits // 2):
qc.swap(i, num_qubits - i - 1)
# qc = qc.reverse_bits()
return qc
def add_k_fourier(
qc: QuantumCircuit, k: int, control: QuantumRegister
) -> QuantumCircuit:
for i in range(m):
qc.crz(
math.pi * k / 2 ** (m - 1 - i),
control_qubit=control,
target_qubit=y[m - 1 - i],
)
def swap_qubits(qc: QuantumCircuit, x: QuantumRegister):
for i in range(len(x) // 2):
qc.swap(x[i], x[len(x) - i - 1])
# swap_qubits(qc, x)
qc.compose(qft(m), inplace=True, qubits=y)
for i in range(n):
add_k_fourier(qc, S[i], x[i])
qc.compose(qft(m).inverse(), inplace=True, qubits=y)
# swap_qubits(qc, y)
return qc
''' |
QPC002_B6 | AF66D93D9F2B1 | 29 | WA | 1272 ms | 153 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
S = S[::-1]
import math
def qft(num_qubits: int) -> QuantumCircuit:
qc = QuantumCircuit(num_qubits)
for i in range(num_qubits):
qc.h(i)
rotation = math.pi / 2
for j in range(i + 1, num_qubits):
qc.cp(rotation, i, j)
rotation /= 2
for i in range(num_qubits // 2):
qc.swap(i, num_qubits - i - 1)
# qc = qc.reverse_bits()
return qc
def add_k_fourier(
qc: QuantumCircuit, k: int, control: QuantumRegister
) -> QuantumCircuit:
for i in range(m):
qc.crz(math.pi * k / (2**i), control_qubit=control, target_qubit=y[i])
def swap_qubits(qc: QuantumCircuit, x: QuantumRegister):
for i in range(len(x) // 2):
qc.swap(x[i], x[len(x) - i - 1])
# swap_qubits(qc, x)
qc.compose(qft(m), inplace=True, qubits=y)
for i in range(n):
add_k_fourier(qc, S[i], x[i])
qc.compose(qft(m).inverse(), inplace=True, qubits=y)
# swap_qubits(qc, y)
return qc
''' |
QPC002_B6 | AF66D93D9F2B1 | 30 | RE | 1225 ms | 144 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
import math
def qft(num_qubits: int) -> QuantumCircuit:
qc = QuantumCircuit(num_qubits)
for i in range(num_qubits):
qc.h(i)
rotation = math.pi / 2
for j in range(i + 1, num_qubits):
qc.cp(rotation, i, j)
rotation /= 2
for i in range(num_qubits // 2):
qc.swap(i, num_qubits - i - 1)
# qc = qc.reverse_bits()
return qc
def add_k_fourier(
qc: QuantumCircuit, k: int, control: QuantumRegister
) -> QuantumCircuit:
for i in range(m):
qc.crz(math.pi * k / (2**i), control_qubit=control, target_qubit=y[i])
def swap_qubits(qc: QuantumCircuit, x: QuantumRegister):
for i in range(len(x) // 2):
qc.swap(x[i], x[len(x) - i - 1])
# swap_qubits(qc, x)
qc.compose(qft(m), inplace=True, qubits=y)
for i in range(n):
add_k_fourier(qc, S[i], x[i])
qc.compose(qft(m).inverse(), inplace=True, qubits=y)
# swap_qubits(qc, y)
qc.measure_all()
return qc
''' |
QPC002_B6 | AF66D93D9F2B1 | 31 | WA | 1477 ms | 140 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
import math
def qft(num_qubits: int) -> QuantumCircuit:
qc = QuantumCircuit(num_qubits)
for i in range(num_qubits):
qc.h(i)
rotation = math.pi / 2
for j in range(i + 1, num_qubits):
qc.cp(rotation, i, j)
rotation /= 2
for i in range(num_qubits // 2):
qc.swap(i, num_qubits - i - 1)
# qc = qc.reverse_bits()
return qc
def add_k_fourier(
qc: QuantumCircuit, k: int, control: QuantumRegister
) -> QuantumCircuit:
for i in range(len(y)):
qc.crz(math.pi * k / (2**i), control_qubit=control, target_qubit=y[i])
def swap_qubits(qc: QuantumCircuit, x: QuantumRegister):
for i in range(len(x) // 2):
qc.swap(x[i], x[len(x) - i - 1])
# swap_qubits(qc, x)
qc.compose(qft(m), inplace=True, qubits=y)
for i in range(n):
add_k_fourier(qc, S[i], x[i])
qc.compose(qft(m).inverse(), inplace=True, qubits=y)
# swap_qubits(qc, y)
return qc
''' |
QPC002_B6 | AF66D93D9F2B1 | 32 | WA | 1478 ms | 153 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
import math
def qft(num_qubits: int) -> QuantumCircuit:
qc = QuantumCircuit(num_qubits)
for i in range(num_qubits):
qc.h(i)
rotation = math.pi / 2
for j in range(i + 1, num_qubits):
qc.cp(rotation, i, j)
rotation /= 2
for i in range(num_qubits // 2):
qc.swap(i, num_qubits - i - 1)
qc = qc.reverse_bits()
return qc
def add_k_fourier(
qc: QuantumCircuit, k: int, control: QuantumRegister
) -> QuantumCircuit:
for i in range(len(y)):
qc.crz(
math.pi * k / (2**i), control_qubit=control, target_qubit=y[m - 1 - i]
)
def swap_qubits(qc: QuantumCircuit, x: QuantumRegister):
for i in range(len(x) // 2):
qc.swap(x[i], x[len(x) - i - 1])
# swap_qubits(qc, x)
# swap_qubits(qc, y)
qc.compose(qft(m), inplace=True, qubits=y)
for i in range(n):
add_k_fourier(qc, S[i], x[i])
qc.compose(qft(m).inverse(), inplace=True, qubits=y)
# swap_qubits(qc, y)
return qc
''' |
QPC002_B6 | AF66D93D9F2B1 | 33 | UGE | 1400 ms | 140 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
import math
def qft(num_qubits: int) -> QuantumCircuit:
qc = QuantumCircuit(num_qubits)
for i in range(num_qubits):
qc.h(i)
rotation = math.pi / 2
for j in range(i + 1, num_qubits):
qc.cp(rotation, i, j)
rotation /= 2
for i in range(num_qubits // 2):
qc.swap(i, num_qubits - i - 1)
qc = qc.reverse_bits()
return qc
def add_k_fourier(
qc: QuantumCircuit, k: int, control: QuantumRegister
) -> QuantumCircuit:
for i in range(len(y)):
qc.crz(
math.pi * k / (2**i), control_qubit=control, target_qubit=y[m - 1 - i]
)
def swap_qubits(qc: QuantumCircuit, x: QuantumRegister):
for i in range(len(x) // 2):
qc.swap(x[i], x[len(x) - i - 1])
# swap_qubits(qc, x)
# swap_qubits(qc, y)
# qc.compose(qft(m), inplace=True, qubits=y)
qc.append(qft(m).to_gate().inverse(), qargs=y)
for i in range(n):
add_k_fourier(qc, S[i], x[i])
# qc.compose(qft(m).inverse(), inplace=True, qubits=y)
qc.append(qft(m).to_gate().inverse(), qargs=y)
# swap_qubits(qc, y)
return qc
''' |
QPC002_B6 | AF66D93D9F2B1 | 34 | WA | 1526 ms | 144 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
import math
def qft(num_qubits: int) -> QuantumCircuit:
qc = QuantumCircuit(num_qubits)
for i in range(num_qubits):
qc.h(i)
rotation = math.pi / 2
for j in range(i + 1, num_qubits):
qc.cp(rotation, i, j)
rotation /= 2
for i in range(num_qubits // 2):
qc.swap(i, num_qubits - i - 1)
qc = qc.reverse_bits()
return qc
def add_k_fourier(
qc: QuantumCircuit, k: int, control: QuantumRegister
) -> QuantumCircuit:
for i in range(len(y)):
qc.crz(
math.pi * k / (2**i), control_qubit=control, target_qubit=y[m - 1 - i]
)
def swap_qubits(qc: QuantumCircuit, x: QuantumRegister):
for i in range(len(x) // 2):
qc.swap(x[i], x[len(x) - i - 1])
# swap_qubits(qc, x)
# swap_qubits(qc, y)
qc = qc.compose(qft(m), qubits=y)
for i in range(n):
add_k_fourier(qc, S[i], x[i])
qc = qc.compose(qft(m).inverse(), qubits=y)
# swap_qubits(qc, y)
return qc
''' |
QPC002_B6 | AF66D93D9F2B1 | 35 | WA | 1263 ms | 144 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
import math
def qft(num_qubits: int) -> QuantumCircuit:
qc = QuantumCircuit(num_qubits)
for i in range(num_qubits):
qc.h(i)
rotation = math.pi / 2
for j in range(i + 1, num_qubits):
qc.cp(rotation, i, j)
rotation /= 2
for i in range(num_qubits // 2):
qc.swap(i, num_qubits - i - 1)
qc = qc.reverse_bits()
return qc
def add_k_fourier(
c: QuantumCircuit, k: int, control: QuantumRegister
) -> QuantumCircuit:
for i in range(len(y)):
c.crz(
math.pi * k / (2**i), control_qubit=control, target_qubit=y[m - 1 - i]
)
def swap_qubits(qc: QuantumCircuit, x: QuantumRegister):
for i in range(len(x) // 2):
qc.swap(x[i], x[len(x) - i - 1])
swap_qubits(qc, x)
# swap_qubits(qc, y)
qc.compose(qft(m), inplace=True, qubits=y)
for i in range(n):
add_k_fourier(qc, S[i], x[i])
qc.compose(qft(m).inverse(), inplace=True, qubits=y)
swap_qubits(qc, x)
# swap_qubits(qc, y)
return qc
''' |
QPC002_B6 | AF66D93D9F2B1 | 36 | WA | 1139 ms | 140 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
import math
def qft(num_qubits: int) -> QuantumCircuit:
qc = QuantumCircuit(num_qubits)
for i in range(num_qubits):
qc.h(i)
rotation = math.pi / 2
for j in range(i + 1, num_qubits):
qc.cp(rotation, i, j)
rotation /= 2
for i in range(num_qubits // 2):
qc.swap(i, num_qubits - i - 1)
# qc = qc.reverse_bits()
return qc
def add_k_fourier(
c: QuantumCircuit, k: int, control: QuantumRegister
) -> QuantumCircuit:
for i in range(len(y)):
c.crz(math.pi * k / (2**i), control_qubit=control, target_qubit=y[i])
def swap_qubits(qc: QuantumCircuit, x: QuantumRegister):
for i in range(len(x) // 2):
qc.swap(x[i], x[len(x) - i - 1])
swap_qubits(qc, x)
swap_qubits(qc, y)
qc.compose(qft(m), inplace=True, qubits=y)
for i in range(n):
add_k_fourier(qc, S[i], x[i])
qc.compose(qft(m).inverse(), inplace=True, qubits=y)
swap_qubits(qc, x)
swap_qubits(qc, y)
return qc
''' |
QPC002_B6 | AF66D93D9F2B1 | 37 | WA | 1431 ms | 183 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
import math
def qft(num_qubits: int) -> QuantumCircuit:
qc = QuantumCircuit(num_qubits)
for i in range(num_qubits):
qc.h(i)
rotation = math.pi / 2
for j in range(i + 1, num_qubits):
qc.cp(rotation, i, j)
rotation /= 2
for i in range(num_qubits // 2):
qc.swap(i, num_qubits - i - 1)
# qc = qc.reverse_bits()
return qc
def add_k(c: QuantumCircuit, k: int, control: QuantumRegister) -> QuantumCircuit:
for i in range(len(y)):
c.crz(math.pi * k / (2**i), control_qubit=control, target_qubit=y[i])
def swap_qubits(qc: QuantumCircuit, x: QuantumRegister):
for i in range(len(x) // 2):
qc.swap(x[i], x[len(x) - i - 1])
# swap_qubits(qc, x)
# swap_qubits(qc, y)
qc.compose(qft(m), inplace=True, qubits=y)
for i in range(n):
add_k(qc, S[i], x[i])
qc.compose(qft(m).inverse(), inplace=True, qubits=y)
# swap_qubits(qc, x)
# swap_qubits(qc, y)
return qc
''' |
QPC002_B6 | AF66D93D9F2B1 | 38 | WA | 1523 ms | 154 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
import math
def qft(num_qubits: int) -> QuantumCircuit:
qc = QuantumCircuit(num_qubits)
for i in range(num_qubits):
qc.h(i)
rotation = math.pi / 2
for j in range(i + 1, num_qubits):
qc.cp(rotation, i, j)
rotation /= 2
for i in range(num_qubits // 2):
qc.swap(i, num_qubits - i - 1)
# qc = qc.reverse_bits()
return qc
def add_k(c: QuantumCircuit, k: int, control: QuantumRegister) -> QuantumCircuit:
for i in range(len(y)):
c.crz(math.pi * k / (2**i), control_qubit=control, target_qubit=y[i])
# qc.compose(qft(m), inplace=True, qubits=y)
for i in range(m):
qc.h(y[i])
for i in range(n):
add_k(qc, S[i], x[i])
qc.compose(qft(m).inverse(), inplace=True, qubits=y)
return qc
''' |
QPC002_B6 | AF66D93D9F2B1 | 39 | WA | 1532 ms | 182 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
import math
def qft(num_qubits: int) -> QuantumCircuit:
qc = QuantumCircuit(num_qubits)
for i in range(num_qubits):
qc.h(i)
rotation = math.pi / 2
for j in range(i + 1, num_qubits):
qc.cp(rotation, i, j)
rotation /= 2
for i in range(num_qubits // 2):
qc.swap(i, num_qubits - i - 1)
# qc = qc.reverse_bits()
return qc
def add_k(c: QuantumCircuit, k: int, control: QuantumRegister) -> QuantumCircuit:
for i in range(len(y)):
c.crz(math.pi * k / (2**i), control_qubit=control, target_qubit=y[i])
def swap_qubits(qc: QuantumCircuit, x: QuantumRegister):
for i in range(len(x) // 2):
qc.swap(x[i], x[len(x) - i - 1])
# swap_qubits(qc, x)
# swap_qubits(qc, y)
qc.compose(qft(m), inplace=True, qubits=y)
for i in range(n):
add_k(qc, S[i], x[i])
qc.compose(qft(m).inverse(), inplace=True, qubits=y)
# swap_qubits(qc, x)
swap_qubits(qc, y)
return qc
''' |
QPC002_B6 | AF66D93D9F2B1 | 40 | WA | 1340 ms | 182 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
import math
def qft(num_qubits: int) -> QuantumCircuit:
qc = QuantumCircuit(num_qubits)
for i in range(num_qubits):
qc.h(i)
rotation = math.pi / 2
for j in range(i + 1, num_qubits):
qc.cp(rotation, i, j)
rotation /= 2
for i in range(num_qubits // 2):
qc.swap(i, num_qubits - i - 1)
# qc = qc.reverse_bits()
return qc
def add_k(c: QuantumCircuit, k: int, control: QuantumRegister) -> QuantumCircuit:
for i in range(len(y)):
c.crz(math.pi * k / (2**i), control_qubit=control, target_qubit=y[i])
def swap_qubits(qc: QuantumCircuit, x: QuantumRegister):
for i in range(len(x) // 2):
qc.swap(x[i], x[len(x) - i - 1])
# swap_qubits(qc, x)
# swap_qubits(qc, y)
qc.compose(qft(m), inplace=True, qubits=y)
for i in range(n):
add_k(qc, S[i], x[i])
qc.compose(qft(m).inverse(), inplace=True, qubits=y)
# swap_qubits(qc, x)
swap_qubits(qc, y)
return qc
''' |
QPC002_B6 | AFCFBFE162BCC | 1 | UGE | 1481 ms | 140 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def IQFT(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
qc.h(n-i-1)
for j in range(1, n-i):
qc.cp(-math.pi/2**j, n-i-j-1, n-i-1)
for i in range(n//2):
qc.swap(i, n-i-1)
return qc
def U(n: int, m: int, pow: 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
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
for i in range(m):
qc.h(y[i])
qc.append(U(n, m, 2**i, S).to_gate().control(1), [y[i]]+[x[i] for i in range(n)])
qc.append(IQFT(m).to_gate(), y)
return qc
''' |
QPC002_B6 | AFCFBFE162BCC | 2 | UGE | 1063 ms | 140 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
# IQFT
qc0 = QuantumCircuit(m)
for i in range(m):
qc0.h(m-i-1)
for j in range(1, m-i):
qc0.cp(-math.pi/2**j, m-i-j-1, m-i-1)
for i in range(m//2):
qc0.swap(i, m-i-1)
IQFT = qc0.to_gate()
for j in range(m):
qc.h(y[j])
# Oracle B5
qc1 = QuantumCircuit(n)
for i in range(n):
qc1.p(2*math.pi*S[i]*2**i/2**m, i)
U = qc1.to_gate()
qc.append(U.control(1), [y[j]]+[x[i] for i in range(n)])
qc.append(IQFT, y)
return qc
''' |
QPC002_B6 | AFCFBFE162BCC | 3 | WA | 1432 ms | 182 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
for j in range(m):
qc.h(y[j])
# Oracle B5
for i in range(n):
qc.cp(2*math.pi*S[i]*2**i/2**m, y[j], x[i])
#IQFT
for i in range(m):
qc.h(y[m-i-1])
for j in range(1, m-i):
qc.cp(-math.pi/2**j, y[m-i-j-1], y[m-i-1])
for i in range(m//2):
qc.swap(i, y[m-i-1])
return qc
''' |
QPC002_B6 | AFCFBFE162BCC | 4 | WA | 2040 ms | 144 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def QFT(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
qc.h(n-i-1)
for j in range(1, n-i):
qc.cp(math.pi/2**j, n-i-j-1, n-i-1)
for i in range(n//2):
qc.swap(i, n-i-1)
return qc
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
for j in range(m):
qc.h(y[j])
# Oracle B5
for i in range(n):
qc.cp(2*math.pi*S[i]*2**i/2**m, y[j], x[i])
#IQFT
qc.compose(QFT(m).inverse(), y, inplace=True)
return qc
''' |
QPC002_B6 | AFCFBFE162BCC | 5 | WA | 1103 ms | 140 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def QFT(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
qc.h(n-i-1)
for j in range(1, n-i):
qc.cp(math.pi/2**j, n-i-j-1, n-i-1)
for i in range(n//2):
qc.swap(i, n-i-1)
return qc
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
for j in range(m):
qc.h(y[j])
# Oracle B5
for i in range(n):
qc.cp((2*math.pi*S[i]/2**m)*2**i, y[j], x[i])
#IQFT
qc.compose(QFT(m).inverse(), y, inplace=True)
return qc
''' |
QPC002_B6 | AFCFBFE162BCC | 6 | WA | 1407 ms | 154 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def qft(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in reversed(range(n)):
qc.h(i)
for j in reversed(range(i)):
qc.cp(math.pi / 2 ** (i - j), j, i)
for i in range(n // 2):
qc.swap(i, n - i - 1)
return qc
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
for j in range(m):
qc.h(y[j])
# Oracle B5
for i in range(n):
qc.cp((2*math.pi*S[i]/2**m)*2**i, y[j], x[i])
#IQFT
qc.compose(qft(m).inverse(), y, inplace=True)
return qc
''' |
QPC002_B6 | AFCFBFE162BCC | 7 | AC | 2419 ms | 183 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def qft(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in reversed(range(n)):
qc.h(i)
for j in reversed(range(i)):
qc.cp(math.pi / 2 ** (i - j), j, i)
for i in range(n // 2):
qc.swap(i, n - i - 1)
return qc
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
for j in range(m):
qc.h(y[j])
# Oracle B5
for i in range(n):
qc.cp((2*math.pi*S[i]/2**m)*2**j, y[j], x[i])
#IQFT
qc.compose(qft(m).inverse(), y, inplace=True)
return qc
''' |
QPC002_B6 | AFFDBD2D5BB36 | 1 | RE | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import HGate, ZGate, XGate, PhaseGate
from qiskit import QuantumRegister
import math
def QFT(qc : QuantumCircuit, idx : list[int], inversed : bool = False) -> 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))
if (inversed):
theta *= -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, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
QFT(qc, list(range(n, n + m)))
for j in range(m):
for i in range(n):
theta = (2 * math.pi * S[i] / (2 ** m)) * 2 ** j
qc.cp(theta, x[i], y[])
QFT(qc, list(range(n, n + m)), inversed = True)
return qc
''' | ||
QPC002_B6 | AFFDBD2D5BB36 | 2 | RE | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import HGate, ZGate, XGate, PhaseGate
from qiskit import QuantumRegister
import math
def QFT(qc : QuantumCircuit, idx : list[int], inversed : bool = False) -> 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))
if (inversed):
theta *= -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, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
QFT(qc, list(range(n, n + m)))
for j in range(m):
for i in range(n):
theta = (2 * math.pi * S[i] / (2 ** m)) * 2 ** j
qc.cp(theta, x[i], y[])
QFT(qc, list(range(n, n + m)), inversed = True)
return qc
''' | ||
QPC002_B6 | AFFDBD2D5BB36 | 3 | RE | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import HGate, ZGate, XGate, PhaseGate
import math
def QFT(qc : QuantumCircuit, idx : list[int], inversed : bool = False) -> 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))
if (inversed):
theta *= -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, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
QFT(qc, list(range(n, n + m)))
for j in range(m):
for i in range(n):
theta = (2 * math.pi * S[i] / (2 ** m)) * 2 ** j
qc.cp(theta, x[i], y[])
QFT(qc, list(range(n, n + m)), inversed = True)
return qc
''' | ||
QPC002_B6 | AFFDBD2D5BB36 | 4 | RE | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import HGate, ZGate, XGate, PhaseGate
from qiskit import QuantumRegister
import math
def QFT(qc : QuantumCircuit, idx : list[int], inversed : bool = False) -> 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))
if (inversed):
theta *= -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, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
QFT(qc, list(range(n, n + m)))
for j in range(m):
for i in range(n):
theta = (2 * math.pi * S[i] / (2 ** m)) * 2 ** j
qc.cp(theta, x[i], y[])
QFT(qc, list(range(n, n + m)), inversed = True)
return qc
''' | ||
QPC002_B6 | AFFDBD2D5BB36 | 5 | AC | 1969 ms | 143 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import HGate, ZGate, XGate, PhaseGate
from qiskit import QuantumRegister
import math
def QFT(qc : QuantumCircuit, idx : list[int], inversed : bool = False) -> 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))
if (inversed):
theta *= -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, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
QFT(qc, list(range(n, n + m)))
for j in range(m):
for i in range(n):
theta = (2 * math.pi * S[i] / (2 ** m)) * 2 ** j
qc.cp(theta, x[i], y[j])
QFT(qc, list(range(n, n + m)), inversed = True)
return qc
''' |
QPC002_B7 | A010B2AB25235 | 1 | UME | '''python
from qiskit import QuantumCircuit, QuantumRegister, AncillaRegister
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
# Define quantum registers
x = QuantumRegister(n, 'x')
y = QuantumRegister(m, 'y')
anc = AncillaRegister(n, 'anc')
qc = QuantumCircuit(x, y, anc)
# Compute f(x) using controlled addition
# We need to add `S_i` to `y` for each `x_i` == 1
# To compute f(x) = S_0*x_0 + S_1*x_1 + ... + S_{n-1}*x_{n-1}
# We will use ancilla qubits to temporarily store intermediate sums
for i in range(n):
if S[i] > 0:
# Convert S[i] to binary representation
binary_S_i = [int(b) for b in format(S[i], f'0{m}b')]
for j in range(m):
if binary_S_i[j] == 1:
# Apply controlled additions to the `y` qubits
qc.cx(x[i], y[j])
# Use ancilla qubits to facilitate the controlled additions
for i in range(n):
if S[i] > 0:
# Apply controlled adders to add S_i to the y register
binary_S_i = [int(b) for b in format(S[i], f'0{m}b')]
for j in range(m):
if binary_S_i[j] == 1:
qc.cx(x[i], y[j])
return qc
''' | ||
QPC002_B7 | A010B2AB25235 | 2 | RE | 1198 ms | 140 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
# Create quantum registers for x and y
x = QuantumRegister(n, 'x')
y = QuantumRegister(m, 'y')
# Create the quantum circuit
qc = QuantumCircuit(x, y)
# Function to add value to a register with controlled addition
def controlled_addition(x_reg, y_reg, value):
bin_value = format(value, f'0{len(y_reg)}b')
for bit, q in zip(bin_value, y_reg):
if bit == '1':
qc.cx(x_reg[0], q)
x_reg = x_reg[1:]
# Add S_i to y for each x_i == 1
for i in range(n):
if S[i] > 0:
controlled_addition([x[i]], y, S[i])
return qc
''' |
QPC002_B7 | A010B2AB25235 | 3 | WA | 1299 ms | 141 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
# Create quantum registers for x and y
x = QuantumRegister(n, 'x')
y = QuantumRegister(m, 'y')
# Create the quantum circuit
qc = QuantumCircuit(x, y)
# Implement the controlled additions
for i in range(n):
# Create a controlled adder for each bit
bin_S_i = format(S[i], f'0{m}b') # Get binary representation of S[i]
# Apply controlled additions based on the binary representation of S[i]
for j in range(m):
if bin_S_i[j] == '1':
# Apply a controlled-X gate if the bit is 1
qc.cx(x[i], y[j])
return qc
''' |
QPC002_B7 | A010B2AB25235 | 4 | WA | 1417 ms | 141 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
# Create quantum registers for x and y
x = QuantumRegister(n, 'x')
y = QuantumRegister(m, 'y')
# Create the quantum circuit
qc = QuantumCircuit(x, y)
# Iterate over each bit of x and the corresponding S coefficient
for i in range(n):
# Get the binary representation of S[i]
bin_S_i = format(S[i], f'0{m}b')
# For each bit in the binary representation, apply a controlled addition
for j in range(m):
if bin_S_i[j] == '1':
# Apply controlled-X gate to add the corresponding bit of S[i]
qc.cx(x[i], y[j])
return qc
''' |
QPC002_B7 | A15434FC0502B | 1 | RE | 1033 ms | 140 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from math import pi
def qft(n:int)->QuantumCircuit:
qc = QuantumCircuit(n)
for k in range(n):
j = n-1-k
if k>=j:
break
qc.swap(k,j)
for i in range(n):
qc.h(i)
for l in range(i+1,n):
theta = 2 * pi / (2**(j+1-i))
qc.cp(theta, j , i)
return qc
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
qc.compose(qft(m), y, inplace=True)
for j in range(m):
for i in range(n):
theta = 2 * pi * S[i] * 2 ** (j - m)
qc.cp(theta, j + n, i)
qc.compose(qft(m).inverse(), y, inplace=True)
return qc
''' |
QPC002_B7 | A15434FC0502B | 2 | AC | 1695 ms | 183 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from math import pi
def qft(n:int)->QuantumCircuit:
qc = QuantumCircuit(n)
for k in range(n):
j = n-1-k
if k>=j:
break
qc.swap(k,j)
for i in range(n):
qc.h(i)
for l in range(i+1,n):
theta = 2 * pi / (2**(l+1-i))
qc.cp(theta, l, i)
return qc
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
qc.compose(qft(m), y, inplace=True)
for j in range(m):
for i in range(n):
theta = 2 * pi * S[i] * 2 ** (j - m)
qc.cp(theta, j + n, i)
qc.compose(qft(m).inverse(), y, inplace=True)
return qc
''' |
QPC002_B7 | A23E81762211B | 1 | AC | 2922 ms | 184 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library.standard_gates import U1Gate
from math import pi
def QFT(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n//2):
qc.swap(i, n-i-1)
for i in range(n):
qc.h(i)
for j in range(i+1, n):
qc.append(U1Gate(pi/2**(j-i)).control(1), [j, i])
return qc
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# y をフーリエ変換
for i in range(m//2):
qc.swap(n + i, n + m-i-1)
for i in range(m):
qc.h(n + i)
for j in range(i+1, m):
qc.append(U1Gate(pi/2**(j-i)).control(1), [n + j, n + i])
# S[i] をフーリエ変換したものを掛ける
for i in range(n):
for j in range(m):
qc.append(U1Gate(2 * pi * S[i] / 2 ** (m - j)).control(1), [i, n + j])
# y を逆フーリエ変換
for i in range(m//2):
qc.swap(n + i, n + m-i-1)
for i in range(m):
qc.h(n + i)
for j in range(i+1, m):
qc.append(U1Gate(-pi/2**(j-i)).control(1), [n + j, n + i])
return qc
''' |
QPC002_B7 | A28B387CC71A6 | 1 | WA | 1159 ms | 141 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import numpy as np
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
for qubit in x:
qc.h(qubit)
# Apply the controlled-U gates based on the function f(x)
for i in range(n):
for j in range(m):
if S[i] != 0:
angle = 2 * np.pi * S[i] / (2 ** m)
# Apply controlled-phase (CRZ) gate to the target qubits
qc.crz(angle / (2 ** j), x[i], y[j])
# Write your code here:
return qc
''' |
QPC002_B7 | A28B387CC71A6 | 2 | WA | 1118 ms | 140 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import numpy as np
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Loop over each qubit in the x register
for i in range(n):
# For each qubit in x, add controlled-phase gates to the y qubits
for j in range(m):
# Calculate the angle for the controlled-phase gate
angle = 2 * np.pi * S[i] / (2 ** m)
# Apply controlled-phase gates
qc.crz(angle, x[i], y[j])
# Write your code here:
return qc
''' |
QPC002_B7 | A28B387CC71A6 | 3 | WA | 1507 ms | 182 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import numpy as np
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
for i in range(n):
# Add S[i] to y if x[i] is 1
if S[i] != 0:
for j in range(m):
if (S[i] >> j) & 1:
qc.cx(x[i], y[j])
# Write your code here:
return qc
''' |
QPC002_B7 | A3876D9F91990 | 1 | WA | 1949 ms | 160 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
for j in range(m-1,-1,-1):
qc.h(n+j)
for l in range(j-1,-1,-1):
qc.cp(2*math.pi/2**(j-l+1),n+l,n+j)
for i in range(n):
for j in range(m):
qc.cp(2*math.pi*S[i]/2**(m-j),i,n+j)
for j in range(m-1,-1,-1):
qc.h(n+j)
for l in range(j-1,-1,-1):
qc.cp(-2*math.pi/2**(j-l+1),n+l,n+j)
for k in range(m//2):
qc.swap(n+k,n+m-1-k)
return qc
''' |
QPC002_B7 | A3876D9F91990 | 2 | AC | 2550 ms | 161 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
for j in range(m-1,-1,-1):
qc.h(n+j)
for l in range(j-1,-1,-1):
qc.cp(2*math.pi/2**(j-l+1),n+l,n+j)
for k in range(m//2):
qc.swap(n+k,n+m-1-k)
for i in range(n):
for j in range(m):
qc.cp(2*math.pi*S[i]/2**(m-j),i,n+j)
for j in range(m-1,-1,-1):
qc.h(n+j)
for l in range(j-1,-1,-1):
qc.cp(-2*math.pi/2**(j-l+1),n+l,n+j)
for k in range(m//2):
qc.swap(n+k,n+m-1-k)
return qc
''' |
QPC002_B7 | A39DC6DB64991 | 1 | UGE | 1700 ms | 154 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
# from qiskit.quantum_info import Statevector
def quantum_fourier_transform(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n-1, -1, -1):
qc.h(i)
for j in range(i-1, -1, -1):
qc.cp(2*math.pi/(2**(i-j+1)), j, i)
i = 0
while i<n-i-1:
qc.swap(i, n-i-1)
i += 1
return qc.to_gate()
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# init = [0]*(2**(n+m))
# init[3] = 1
# qc.initialize(init)
# Write your code here:
qc.append(quantum_fourier_transform(m), y)
for j in range(m):
for i in range(n):
qc.cp(2*math.pi*S[i]/(2**m)*(2**j), x[i], y[j])
qc.append(quantum_fourier_transform(m).inverse(), y)
return qc
# if __name__ == "__main__":
# qc = solve(2, 2, [1, 2])
# print(Statevector(qc))
''' |
QPC002_B7 | A39DC6DB64991 | 2 | AC | 2553 ms | 155 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
# from qiskit.quantum_info import Statevector
def quantum_fourier_transform(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n-1, -1, -1):
qc.h(i)
for j in range(i-1, -1, -1):
qc.cp(2*math.pi/(2**(i-j+1)), j, i)
i = 0
while i<n-i-1:
qc.swap(i, n-i-1)
i += 1
return qc
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# init = [0]*(2**(n+m))
# init[3] = 1
# qc.initialize(init)
# Write your code here:
qc.compose(quantum_fourier_transform(m), y, inplace=True)
for j in range(m):
for i in range(n):
qc.cp(2*math.pi*S[i]/(2**m)*(2**j), x[i], y[j])
qc.compose(quantum_fourier_transform(m).inverse(), y, inplace=True)
return qc
# if __name__ == "__main__":
# qc = solve(2, 2, [1, 2])
# print(Statevector(qc))
''' |
QPC002_B7 | A4347C9150F3A | 1 | AC | 1841 ms | 156 MiB | '''python
import math
from qiskit import QuantumCircuit, QuantumRegister
def qft(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in reversed(range(n)):
qc.h(i)
for j in reversed(range(i)):
qc.cp(math.pi / 2 ** (i - j), j, i)
for i in range(n // 2):
qc.swap(i, n - i - 1)
return qc
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
qft_m = qft(m)
qc.compose(qft_m, y, inplace=True)
for j in range(m):
for i in range(n):
theta = (2 * math.pi * S[i] / 2**m) * 2**j
qc.cp(theta, x[i], y[j])
qc.compose(qft_m.inverse(), y, inplace=True)
return qc
''' |
QPC002_B7 | A66704218582A | 1 | AC | 2498 ms | 160 MiB | '''python
from qiskit import QuantumRegister, QuantumCircuit
# Let n = len(qubits)
# if no ctrl_qubits, adds 2 * len(qubits) circuit depth
# otherwise,
# if n % 2 == 0, adds n * (n/2 + 1) circuit depth
# otherwise, adds (n-1) * ((n-1)/2 + 1) + n circuit depth
def apply_QFT(qc, qubits, ctrl_qubit = None, inverse = False):
from numpy import pi
coef = -pi if inverse else pi
if ctrl_qubit:
for i in reversed(range(len(qubits))):
qc.ch(ctrl_qubit, qubits[i])
for j in reversed(range(i)):
qc.mcp(coef / 2**(i - j), [ctrl_qubit, qubits[j]], qubits[i])
for i in range(len(qubits) // 2):
qc.cswap(ctrl_qubit, qubits[i], qubits[len(qubits) - 1 - i])
else:
for i in reversed(range(len(qubits))):
qc.h(qubits[i])
for j in reversed(range(i)):
qc.cp(coef / 2**(i - j), qubits[j], qubits[i])
for i in range(len(qubits) // 2):
qc.swap(qubits[i], qubits[len(qubits) - 1 - i])
return qc
def solve(n, m, s) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
from numpy import pi
apply_QFT(qc, y)
for i in range(n):
for j in range(m):
qc.cp(pi * s[i] / 2**(m - 1 - j), x[i], y[j])
apply_QFT(qc, y, inverse = True)
return qc
''' |
QPC002_B7 | A8EF837D31151 | 1 | WA | 1489 ms | 143 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import numpy as np
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
qc.x(n)
for i in range(m - 1, -1, -1):
qc.h(i+n)
for j in range(i - 1, -1, -1):
qc.cp(np.pi / 2**(i - j), i+n, j+n)
for i in range(m // 2):
qc.swap(i+n, n+m - i - 1)
for i in range(m):
qc.h(i+n)
for j in range(n):
qc.cp(2*np.pi*S[j]/2**(m-i), i+n,j)
for i in range(m // 2):
qc.swap(i+n, n+m - i - 1)
for i in range(m):
for j in range(i):
qc.cp(-np.pi / 2**(i - j), j+n, i+n)
qc.h(i+n)
return qc
''' |
QPC002_B7 | A8EF837D31151 | 2 | WA | 1655 ms | 153 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import numpy as np
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
for i in range(m - 1, -1, -1):
qc.h(i+n)
for j in range(i - 1, -1, -1):
qc.cp(np.pi / 2**(i - j), i+n, j+n)
for i in range(m // 2):
qc.swap(i+n, n+m - i - 1)
for i in range(m):
qc.h(i+n)
for j in range(n):
qc.cp(2*np.pi*S[j]/2**(m-i), i+n,j)
for i in range(m // 2):
qc.swap(i+n, n+m - i - 1)
for i in range(m):
for j in range(i):
qc.cp(-np.pi / 2**(i - j), j+n, i+n)
qc.h(i+n)
return qc
''' |
QPC002_B7 | A8EF837D31151 | 3 | AC | 2585 ms | 184 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import numpy as np
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
for i in range(m - 1, -1, -1):
qc.h(i+n)
for j in range(i - 1, -1, -1):
qc.cp(np.pi / 2**(i - j), i+n, j+n)
for i in range(m // 2):
qc.swap(i+n, n+m - i - 1)
for i in range(m):
for j in range(n):
qc.cp(2*np.pi*S[j]/2**(m-i), i+n,j)
for i in range(m // 2):
qc.swap(i+n, n+m - i - 1)
for i in range(m):
for j in range(i):
qc.cp(-np.pi / 2**(i - j), j+n, i+n)
qc.h(i+n)
return qc
''' |
QPC002_B7 | A8FEEDB0837DA | 1 | AC | 2164 ms | 183 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def r(qc: QuantumCircuit, control: int, target: int, l: int):
qc.cp(2*math.pi/(1<<l), control, target)
def qft(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n//2):
qc.cx(i, n-i-1)
qc.cx(n-i-1, i)
qc.cx(i, n-i-1)
for i in range(0, n):
qc.h(i)
for j in range(1, n-i):
r(qc, i+j, i, j+1)
return qc
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
qft_m = qft(m)
qc = qc.compose(qft_m, y)
for k in range(m):
for i in range(n):
qc.cp(2*math.pi*S[i]/(1<<m)*(1<<k), y[k], x[i])
qc = qc.compose(qft_m.inverse(), y)
return qc
''' |
QPC002_B7 | A97CA1BABDC98 | 1 | WA | 1216 ms | 141 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
import math
def qft(num_qubits: int) -> QuantumCircuit:
qc = QuantumCircuit(num_qubits)
for i in range(num_qubits):
qc.h(i)
rotation = math.pi / 2
for j in range(i + 1, num_qubits):
qc.cp(rotation, j, i)
rotation /= 2
# for i in range(num_qubits // 2):
# qc.swap(i, num_qubits - i - 1)
# qc = qc.reverse_bits()
return qc
def add_k_fourier(
qc: QuantumCircuit, k: int, control: QuantumRegister
) -> QuantumCircuit:
for i in range(m):
qc.crz(math.pi * k / 2**i, control_qubit=control, target_qubit=y[m - 1 - i])
def swap_qubits(qc: QuantumCircuit, x: QuantumRegister):
for i in range(len(x) // 2):
qc.swap(x[i], x[len(x) - i - 1])
# swap_qubits(qc, x)
qc.compose(qft(m), inplace=True, qubits=y)
for i in range(n):
add_k_fourier(qc, S[n - 1 - i], x[n - 1 - i])
qc.compose(qft(m).inverse(), inplace=True, qubits=y)
# swap_qubits(qc, y)
return qc
''' |
QPC002_B7 | A97CA1BABDC98 | 2 | WA | 1432 ms | 182 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
import math
def qft(num_qubits: int) -> QuantumCircuit:
qc = QuantumCircuit(num_qubits)
for i in range(num_qubits):
qc.h(i)
rotation = math.pi / 2
for j in range(i + 1, num_qubits):
qc.cp(rotation, j, i)
rotation /= 2
# for i in range(num_qubits // 2):
# qc.swap(i, num_qubits - i - 1)
# qc = qc.reverse_bits()
return qc
def add_k_fourier(
qc: QuantumCircuit, k: int, control: QuantumRegister
) -> QuantumCircuit:
for i in range(m):
qc.crz(math.pi * k / 2**i, control_qubit=control, target_qubit=y[m - 1 - i])
def swap_qubits(qc: QuantumCircuit, x: QuantumRegister):
for i in range(len(x) // 2):
qc.swap(x[i], x[len(x) - i - 1])
# swap_qubits(qc, x)
qc.compose(qft(m), inplace=True, qubits=y)
for i in range(n):
add_k_fourier(qc, S[i], x[i])
qc.compose(qft(m).inverse(), inplace=True, qubits=y)
# swap_qubits(qc, y)
return qc
''' |
QPC002_B7 | A9935C912EE02 | 1 | AC | 1856 ms | 183 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import GlobalPhaseGate
import numpy as np
import math
def qft(n):
qc = QuantumCircuit(n)
thetas = []
for k in range(0, 1+n):
thetas.append(2 * math.pi / (2**k))
for idx in range(0, n):
qc.h(n-1-idx)
for jdx in range(idx+1, n):
thetaidx = jdx - idx + 1
qc.cp(thetas[thetaidx], n-1-jdx, n-1-idx)
for idx in range(0, n//2):
qc.swap(idx, n-idx-1)
return qc
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
qc = qc.compose(qft(m), y)
for idx in range(0, n):
for jdx in range(0, m):
theta = 2 * math.pi * S[idx] * (2**jdx) / (2**m)
qc.cp(theta, x[idx], y[jdx])
qc = qc.compose(qft(m).inverse(), y)
return qc
''' |
QPC002_B7 | AA245B0BCEF7B | 1 | RE | 1239 ms | 140 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
# Apply controlled addition for each term in the function f(x)
for i in range(n):
# We use a controlled adder with x[i] controlling the addition of S[i]
# Use the basic Toffoli and CNOT gates to achieve this
if S[i] != 0:
qc.append(qc.cx(x[i], y[0]), [x[i], y[0]])
for j in range(1, m):
qc.append(qc.cx(x[i], y[j]), [x[i], y[j]])
return qc
''' |
QPC002_B7 | AA245B0BCEF7B | 2 | WA | 1274 ms | 153 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x = QuantumRegister(n, name='x')
y = QuantumRegister(m, name='y')
qc = QuantumCircuit(x, y)
# Apply controlled addition for each coefficient S[i]
for i in range(n):
coeff = S[i]
# Use multi-controlled addition gates to add the coefficients
for j in range(m):
if (coeff >> j) & 1:
# Apply a controlled-X gate for each bit in y if the corresponding bit in coeff is 1
qc.cx(x[i], y[j])
return qc
''' |
QPC002_B7 | AA245B0BCEF7B | 3 | AC | 2031 ms | 183 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def r(qc: QuantumCircuit, control: int, target: int, l: int):
qc.cp(2*math.pi/(1<<l), control, target)
def qft(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n//2):
qc.cx(i, n-i-1)
qc.cx(n-i-1, i)
qc.cx(i, n-i-1)
for i in range(0, n):
qc.h(i)
for j in range(1, n-i):
r(qc, i+j, i, j+1)
return qc
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
qft_m = qft(m)
qc = qc.compose(qft_m, y)
for k in range(m):
for i in range(n):
qc.cp(2*math.pi*S[i]/(1<<m)*(1<<k), y[k], x[i])
qc = qc.compose(qft_m.inverse(), y)
return qc
''' |
QPC002_B7 | AAAEE23E97666 | 1 | WA | 2019 ms | 160 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# We will use a temporary register to hold the carry bits for addition
carry = QuantumRegister(m)
qc.add_register(carry)
# Initialize carry bits to 0
for j in range(m):
qc.x(carry[j]) # Set carry bits to 0 initially
# Iterate over each bit of x
for i in range(n):
if S[i] > 0: # Only if S[i] is non-zero
# We need to add S[i] to y if x[i] is 1
# Convert S[i] to binary and apply controlled additions
s_bin = format(S[i], f'0{m}b') # Get binary representation of S[i]
for j in range(m):
if s_bin[j] == '1':
# Apply controlled addition of 1 to y[j] if x[i] is 1
qc.cx(x[i], y[j]) # Controlled NOT gate
return qc
''' |
QPC002_B7 | AC9D71ECA10BF | 1 | RE | 1296 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
from math import pi
def qft(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
j = n - 1 - i
if i >= j:
break
qc.swap(i, j)
for i in range(n):
qc.h(i)
for j in range(i + 1, n):
theta = 2 * pi / (2 ** (j + 1 - i))
qc.cp(theta, j, i)
return qc
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
qc.compose(qft(m), y, inplace=True)
for j in range(m):
for i in range(n):
theta = 2 * pi * S[i] * 2 ** (j - m)
qc.cp(theta, j + n, i)
qc.compose(qft(m).inverse(), y, inplace=True)
return qc
''' |
QPC002_B7 | AC9D71ECA10BF | 2 | AC | 2371 ms | 183 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from math import pi
def qft(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
j = n - 1 - i
if i >= j:
break
qc.swap(i, j)
for i in range(n):
qc.h(i)
for j in range(i + 1, n):
theta = 2 * pi / (2 ** (j + 1 - i))
qc.cp(theta, j, i)
return qc
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
qc.compose(qft(m), y, inplace=True)
for j in range(m):
for i in range(n):
theta = 2 * pi * S[i] * 2 ** (j - m)
qc.cp(theta, j + n, i)
qc.compose(qft(m).inverse(), y, inplace=True)
return qc
''' |
QPC002_B7 | AD00E29DFCCE5 | 1 | AC | 2021 ms | 183 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def QFT(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
qc.h(n-i-1)
for j in range(1, n-i):
qc.cp(math.pi/2**j, n-i-j-1, n-i-1)
for i in range(n//2):
qc.swap(i, n-i-1)
return qc
def IQFT(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
qc.h(n-i-1)
for j in range(1, n-i):
qc.cp(-math.pi/2**j, n-i-j-1, n-i-1)
for i in range(n//2):
qc.swap(i, n-i-1)
return qc
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
# QFT
qc.compose(QFT(m), y, inplace=True)
for j in range(m):
# Oracle B5
for i in range(n):
qc.cp(2*math.pi*S[i]*2**j/2**m, y[j], x[i])
# IQFT
qc.compose(IQFT(m), y, inplace=True)
return qc
''' |
QPC002_B7 | AD62A7C2BA8D0 | 1 | AC | 2050 ms | 184 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library.standard_gates import PhaseGate
import math
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
for i in range(m - 1, -1, -1):
for j in range(m - 1, i, -1):
qc.append(PhaseGate(-2 * math.pi * math.pow(2, i - 1 - j)).control(1), [n + i, n + j])
qc.h(n + i)
for i in range(m // 2):
qc.cx(n + i, n + m - 1 - i)
qc.cx(n + m - 1 - i, n + i)
qc.cx(n + i, n + m - 1 - i)
for i in range(n):
for j in range(m):
qc.append(PhaseGate(-2 * math.pi * S[i] / pow(2, m - j)).control(1), [i, n + j])
for i in range(m - 1, -1, -1):
for j in range(m - 1, i, -1):
qc.append(PhaseGate(2 * math.pi * math.pow(2, i - 1 - j)).control(1), [n + i, n + j])
qc.h(n + i)
for i in range(m // 2):
qc.cx(n + i, n + m - 1 - i)
qc.cx(n + m - 1 - i, n + i)
qc.cx(n + i, n + m - 1 - i)
return qc
''' |
QPC002_B7 | AD9F702F4B699 | 1 | WA | 1705 ms | 153 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
for i in range(n):
# Loop through each bit of y
for j in range(m):
# If the j-th bit of S[i] is 1, apply a controlled-NOT gate
if (S[i] >> j) & 1:
qc.cx(x[i], y[j])
return qc
''' |
QPC002_B7 | AD9F702F4B699 | 2 | WA | 1535 ms | 182 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
for i in range(n):
for j in range(m):
if (S[i] >> j) & 1:
qc.cx(x[i], y[j])
return qc
''' |
QPC002_B7 | AD9F702F4B699 | 3 | RE | 1473 ms | 140 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
def add_value_to_register(value, target_register):
"""Adds 'value' to the target quantum register (in-place addition)."""
num_bits = len(target_register)
for i in range(num_bits):
if (value >> i) & 1: # if the ith bit of value is 1
qc.cx(target_register[i], target_register[(i + 1) % num_bits]) # Controlled-X
# Iterate over all possible states of the n qubits
for i in range(2 ** n):
x_bits = [int(bit) for bit in format(i, f'0{n}b')]
f_x = sum(S[j] * x_bits[j] for j in range(n))
# Add f_x to the y register
add_value_to_register(f_x, y)
return qc
''' |
QPC002_B7 | AE6005B9AD206 | 1 | WA | 1235 ms | 142 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
# Implement controlled additions
for i in range(n):
for j in range(m):
# Determine if we need to add 2^j to y[j] based on S[i] and controlled by x[i]
if (S[i] >> j) & 1:
qc.cx(x[i], y[j])
return qc
''' |
QPC002_B7 | AEBDBE560A29E | 1 | AC | 2121 ms | 143 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import HGate, ZGate, XGate, PhaseGate
from qiskit import QuantumRegister
import math
def QFT(qc : QuantumCircuit, idx : list[int], inversed : bool = False) -> 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))
if (inversed):
theta *= -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, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
QFT(qc, list(range(n, n + m)))
for j in range(m):
for i in range(n):
theta = (2 * math.pi * S[i] / (2 ** m)) * 2 ** j
qc.cp(theta, x[i], y[j])
QFT(qc, list(range(n, n + m)), inversed = True)
return qc
''' |
QPC002_B7 | AF797AEB95CAF | 1 | RE | 1114 ms | 140 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
for i in range(n,n+m):
qc.h(i)
for i in range(n,n+m):
for j in range(n):
qc.cp(2.0*np.pi/(2.0**m)*S[j]*(2.0**((n+m-1)-i)), i, j)
# for i in range(m):
# if n+i < m-1-i:
# qc.swap(n+i,m-1-i)
for i in range(n,n+m):
for j in range(n,i):
qc.cp(-np.pi/(2.0**(i-j)), j, i)
qc.h(i)
return qc
''' |
QPC002_B7 | AF797AEB95CAF | 2 | WA | 1624 ms | 153 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import numpy as np
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
for i in range(n,n+m):
qc.h(i)
for i in range(n,n+m):
for j in range(n):
qc.cp(2.0*np.pi/(2.0**m)*S[j]*(2.0**((n+m-1)-i)), i, j)
# for i in range(m):
# if n+i < m-1-i:
# qc.swap(n+i,m-1-i)
for i in range(n,n+m):
for j in range(n,i):
qc.cp(-np.pi/(2.0**(i-j)), j, i)
qc.h(i)
return qc
''' |
QPC002_B7 | AF797AEB95CAF | 3 | RE | 1248 ms | 140 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import numpy as n
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
for i in reversed(range(n,n+m)):
qc.h(i)
for j in reversed(range(n,i)):
qc.cp(np.pi/(2.0 ** (i-j)), j, i)
for i in range(n):
if i < n-1-i:
qc.swap(i,n-1-i)
# for i in range(n,n+m):
# qc.h(i)
for i in range(n,n+m):
for j in range(n):
qc.cp(2.0*np.pi/(2.0**m)*S[j]*(2.0**((n+m-1)-i)), i, j)
# for i in range(m):
# if n+i < m-1-i:
# qc.swap(n+i,m-1-i)
for i in range(n,n+m):
for j in range(n,i):
qc.cp(-np.pi/(2.0**(i-j)), j, i)
qc.h(i)
return qc
''' |
QPC002_B7 | AF797AEB95CAF | 4 | WA | 1141 ms | 141 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import numpy as np
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
for i in reversed(range(n,n+m)):
qc.h(i)
for j in reversed(range(n,i)):
qc.cp(np.pi/(2.0 ** (i-j)), j, i)
for i in range(n):
if i < n-1-i:
qc.swap(i,n-1-i)
# for i in range(n,n+m):
# qc.h(i)
for i in range(n,n+m):
for j in range(n):
qc.cp(2.0*np.pi/(2.0**m)*S[j]*(2.0**((n+m-1)-i)), i, j)
# for i in range(m):
# if n+i < m-1-i:
# qc.swap(n+i,m-1-i)
for i in range(n,n+m):
for j in range(n,i):
qc.cp(-np.pi/(2.0**(i-j)), j, i)
qc.h(i)
return qc
''' |
QPC002_B7 | AF797AEB95CAF | 5 | AC | 2335 ms | 183 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import numpy as np
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
for i in reversed(range(n,n+m)):
qc.h(i)
for j in reversed(range(n,i)):
qc.cp(np.pi/(2.0 ** (i-j)), j, i)
# for i in range(n,n+m):
# for j in range(n,i):
# qc.cp()
# qc.h(i)
# for i in range(n,n+m):
# qc.h(i)
for i in range(n,n+m):
for j in range(n):
qc.cp(2.0*np.pi/(2.0**m)*S[j]*(2.0**((n+m-1)-i)), i, j)
# for i in range(m):
# if n+i < m-1-i:
# qc.swap(n+i,m-1-i)
for i in range(n,n+m):
for j in range(n,i):
qc.cp(-np.pi/(2.0**(i-j)), j, i)
qc.h(i)
return qc
''' |
QPC002_B7 | AF9BADE98B09C | 1 | AC | 1856 ms | 183 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def QFT(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
qc.h(n-i-1)
for j in range(1, n-i):
qc.cp(math.pi/2**j, n-i-j-1, n-i-1)
for i in range(n//2):
qc.swap(i, n-i-1)
return qc
def IQFT(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
qc.h(n-i-1)
for j in range(1, n-i):
qc.cp(-math.pi/2**j, n-i-j-1, n-i-1)
for i in range(n//2):
qc.swap(i, n-i-1)
return qc
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
# QFT
qc.compose(QFT(m), y, inplace=True)
for j in range(m):
# Oracle B5
for i in range(n):
qc.cp(2*math.pi*S[i]*2**j/2**m, y[j], x[i])
# IQFT
qc.compose(IQFT(m), y, inplace=True)
return qc
''' |
QPC002_B8 | A038FB304628C | 1 | WA | 1456 ms | 141 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import numpy as np
def solve(n: int, m: int, L: int, S: list[int], theta: float) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
### B6
for i in range(n,n+m):
qc.h(i)
for i in range(n,n+m):
for j in range(n):
qc.cp(2.0*np.pi/(2.0**m)*S[j]*(2.0**((n+m-1)-i)), i, j)
for i in range(n,n+m):
for j in range(n,i):
qc.cp(-np.pi/(2.0**(i-j)), j, i)
qc.h(i)
### B2
for i in range(n, n+m):
if L&(1<<i) == 0:
qc.x(i)
if m == 1:
qc.p(theta, n+m-1)
elif m == 2:
qc.cp(theta, n+m-2, n+m-1)
else:
qc.mcp(theta, list(range(n, n+m-1)), n+m-1)
for i in range(n, n+m):
if L&(1<<i) == 0:
qc.x(i)
### B6(uncomputation)
for i in reversed(range(n,n+m)):
qc.h(i)
for j in reversed(range(n,i)):
qc.cp(np.pi/(2.0**(i-j)), j, i)
for i in reversed(range(n,n+m)):
for j in reversed(range(n)):
qc.cp(-2.0*np.pi/(2.0**m)*S[j]*(2.0**((n+m-1)-i)), i, j)
for i in range(n,n+m):
qc.h(i)
return qc
''' |
QPC002_B8 | A038FB304628C | 2 | AC | 1813 ms | 184 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import numpy as np
def solve(n: int, m: int, L: int, S: list[int], theta: float) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
### B6
for i in range(n,n+m):
qc.h(i)
for i in range(n,n+m):
for j in range(n):
qc.cp(2.0*np.pi/(2.0**m)*S[j]*(2.0**((n+m-1)-i)), i, j)
for i in range(n,n+m):
for j in range(n,i):
qc.cp(-np.pi/(2.0**(i-j)), j, i)
qc.h(i)
### B2
for i in range(n, n+m):
if L&(1<<(i-n)) == 0:
qc.x(i)
if m == 1:
qc.p(theta, n+m-1)
elif m == 2:
qc.cp(theta, n+m-2, n+m-1)
else:
qc.mcp(theta, list(range(n, n+m-1)), n+m-1)
for i in range(n, n+m):
if L&(1<<(i-n)) == 0:
qc.x(i)
### B6(uncomputation)
for i in reversed(range(n,n+m)):
qc.h(i)
for j in reversed(range(n,i)):
qc.cp(np.pi/(2.0**(i-j)), j, i)
for i in reversed(range(n,n+m)):
for j in reversed(range(n)):
qc.cp(-2.0*np.pi/(2.0**m)*S[j]*(2.0**((n+m-1)-i)), i, j)
for i in range(n,n+m):
qc.h(i)
return qc
''' |
QPC002_B8 | A23AC0B958363 | 1 | RE | 1117 ms | 140 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, m: int, L: int, S: list[int], theta: float) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
for i in range(m):
qc.h(i+n)
for j in range(n):
qc.cp(2*np.pi*S[j]/2**(m-i), i+n,j)
for i in range(m // 2):
qc.swap(i+n, n+m - i - 1)
for i in range(m):
for j in range(i):
qc.cp(-np.pi / 2**(i - j), j+n, i+n)
qc.h(i+n)
for i in range(m):
if not ((L>>i)&1):
qc.x(i+n)
if m==1:
qc.p(theta,n)
else :
qc.mcp(theta,[i+n for i in range(m-1)],n+m-1)
for i in range(m):
if not ((L>>i)&1):
qc.x(i+n)
for i in range(m - 1, -1, -1):
qc.h(i+n)
for j in range(i - 1, -1, -1):
qc.cp(np.pi / 2**(i - j), i+n, j+n)
for i in range(m // 2):
qc.swap(i+n, n+m - i - 1)
for i in range(m):
for j in range(n):
qc.cp(-2*np.pi*S[j]/2**(m-i), i+n,j)
qc.h(i+n)
return qc
''' |
QPC002_B8 | A23AC0B958363 | 2 | AC | 1977 ms | 184 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import numpy as np
def solve(n: int, m: int, L: int, S: list[int], theta: float) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
for i in range(m):
qc.h(i+n)
for j in range(n):
qc.cp(2*np.pi*S[j]/2**(m-i), i+n,j)
for i in range(m // 2):
qc.swap(i+n, n+m - i - 1)
for i in range(m):
for j in range(i):
qc.cp(-np.pi / 2**(i - j), j+n, i+n)
qc.h(i+n)
for i in range(m):
if not ((L>>i)&1):
qc.x(i+n)
if m==1:
qc.p(theta,n)
else :
qc.mcp(theta,[i+n for i in range(m-1)],n+m-1)
for i in range(m):
if not ((L>>i)&1):
qc.x(i+n)
for i in range(m - 1, -1, -1):
qc.h(i+n)
for j in range(i - 1, -1, -1):
qc.cp(np.pi / 2**(i - j), i+n, j+n)
for i in range(m // 2):
qc.swap(i+n, n+m - i - 1)
for i in range(m):
for j in range(n):
qc.cp(-2*np.pi*S[j]/2**(m-i), i+n,j)
qc.h(i+n)
return qc
''' |
QPC002_B8 | A2546BF54C488 | 1 | RE | 1433 ms | 140 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, m: int, L: int, S: list[int], theta: float) -> QuantumCircuit:
x = QuantumRegister(n)
y = QuantumRegister(m)
qc = QuantumCircuit(x, y)
for i in range(n):
for j in range(n):
if S[j] != 0:
qc.cx(x[j], y[i])
qc.rz(2 * np.pi * S[j] / (2 ** m), y[i])
qc.cx(x[j], y[i])
for i in range(2 ** n):
f_x = sum(S[j] * ((i >> j) & 1) for j in range(n))
if f_x % (2 ** m) == L:
qc.rz(theta, y[0])
return qc
''' |
QPC002_B8 | A2BE8DD9836E2 | 1 | AC | 1789 ms | 183 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import GlobalPhaseGate
import numpy as np
import math
def qft(n):
qc = QuantumCircuit(n)
thetas = []
for k in range(0, 1+n):
thetas.append(2 * math.pi / (2**k))
for idx in range(0, n):
qc.h(n-1-idx)
for jdx in range(idx+1, n):
thetaidx = jdx - idx + 1
qc.cp(thetas[thetaidx], n-1-jdx, n-1-idx)
for idx in range(0, n//2):
qc.swap(idx, n-idx-1)
return qc
def add(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
qc = qc.compose(qft(m), y)
for idx in range(0, n):
for jdx in range(0, m):
theta = 2 * math.pi * S[idx] * (2**jdx) / (2**m)
qc.cp(theta, x[idx], y[jdx])
qc = qc.compose(qft(m).inverse(), y)
return qc
def solve(n: int, m: int, L: int, S: list[int], theta: float) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
qc.compose(add(n, m, S), inplace=True)
lbits = []
for idx in range(0, m):
lbits.append(bool(L % 2))
L = L // 2
for idx in range(0, m):
if not lbits[idx]:
qc.x(y[idx])
if m == 1:
qc.p(theta, y[0])
else:
qc.mcp(theta, y[0:m-1], y[m-1])
for idx in range(0, m):
if not lbits[idx]:
qc.x(y[idx])
qc.compose(add(n, m, S).inverse(), inplace=True)
return qc
''' |
QPC002_B8 | A3BE1EACE0185 | 1 | RE | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, m: int, L: int, S: list[int], theta: float) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
for i in range(n):
for _ in range(S[i]): # Add S_i to the ancilla qubits based on x_i
qc.cx(i, n + (S[i] % m))
# Step 2: Check if f(x) mod 2^m equals L mod 2^m
# Convert L to binary and store in ancilla qubits for comparison
L_bin = format(L % (2**m), f'0{m}b')
for i in range(m):
if L_bin[i] == '0':
qc.x(n + i)
# Apply controlled phase shift if the ancilla qubits match L mod 2^m
qc.mcx(list(range(n, n + m)), 0) # Multi-controlled X gate
qc.p(theta, 0) # Apply phase shift e^(iθ) to the first qubit
qc.mcx(list(range(n, n + m)), 0) # Undo the multi-controlled X gate
# Reapply X gates to reset ancilla qubits to the original state
for i in range(m):
if L_bin[i] == '0':
qc.x(n + i)
return qc
''' | ||
QPC002_B8 | A45C0C8820FBF | 1 | RE | 1779 ms | 141 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def QFT(qc : QuantumCircuit, idx : list[int], inversed : bool = False) -> 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))
if (inversed):
theta *= -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, m: int, L: int, S: list[int], theta: float) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
QFT(qc, list(range(n, n+m)))
for j in range(m):
for i in range(n):
theta = 2 * math.pi * S[i] * (2 ** j) / (2 ** m)
qc.cp(theta, x[i], y[j])
QFT(qc, list(range(n, n+m)), inversed = True)
for i in range(m):
if not (1 << i) & L:
qc.x(y[i])
if n == 1:
qc.p(theta, n + m - 1)
else:
qc.mcp(theta, list(n + range(m - 1)), n + m - 1)
for i in range(m):
if not (1 << i) & L:
qc.x(y[i])
QFT(qc, list(range(n, n+m)))
for j in range(m):
for i in range(n):
theta = -2 * math.pi * S[i] * (2 ** j) / (2 ** m)
qc.cp(theta, x[i], y[j])
QFT(qc, list(range(n, n+m)), inversed = True)
return qc
''' |
QPC002_B8 | A571499297E74 | 1 | AC | 2879 ms | 161 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def solve(n: int, m: int, L: int, S: list[int], theta: float) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
qc.compose(o_f(n,m,S), inplace=True)
qc.compose(o_Pshift(m,L,theta),qubits=list(range(n,n+m)),inplace=True)
qc.compose(o_f(n,m,S).inverse(), inplace=True)
return qc
def o_f(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
for j in range(m-1,-1,-1):
qc.h(n+j)
for l in range(j-1,-1,-1):
qc.cp(2*math.pi/2**(j-l+1),n+l,n+j)
for k in range(m//2):
qc.swap(n+k,n+m-1-k)
for i in range(n):
for j in range(m):
qc.cp(2*math.pi*S[i]/2**(m-j),i,n+j)
for j in range(m-1,-1,-1):
qc.h(n+j)
for l in range(j-1,-1,-1):
qc.cp(-2*math.pi/2**(j-l+1),n+l,n+j)
for k in range(m//2):
qc.swap(n+k,n+m-1-k)
return qc
def o_Pshift(n: int, L: int, theta: float) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
L_code = format(L, f'0{n}b')[::-1]
print(L_code)
for i in range(n):
if L_code[i] == "0":
qc.x(i)
if n >= 2:
qc.mcp(theta,list(range(n-1)),n-1)
else:
qc.p(theta, 0)
for i in range(n):
if L_code[i] == "0":
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.