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 |
|---|---|---|---|---|---|---|
QPC004_B3 | ADF2C94479F92 | 8 | RE | 2668 ms | 158 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from numpy import pi, sqrt, acos
# Adds up to 6n circuit depth
def apply_stateswap(qc, x, y):
n = qc.num_qubits
assert 0 <= min(x, y) and max(x, y) < 2**n
if x == y:
return qc
def apply_bitflip(i):
for j in range(n):
if j < i and ~x >> j & 1 or j > i and ~y >> j & 1:
qc.x(j)
qc.mcx(list(j for j in range(n) if i != j), i)
for j in range(n):
if j < i and ~x >> j & 1 or j > i and ~y >> j & 1:
qc.x(j)
diff = [i for i in range(n) if (x ^ y) >> i & 1]
for i in diff:
apply_bitflip(i)
for i in reversed(range(diff[:-1])):
apply_bitflip(diff[i])
return qc
# Adds up to 4 * n * 2**n circuit depth
# Requires apply_stateswap
def apply_permutation(qc, p, option = "cycle"):
assert option in ["cycle", "list"]
n = qc.num_qubits
cycles = []
if option == "cycle":
cycles = p[:]
elif option == "list":
assert sorted(p) == list(range(len(p)))
vis = [False] * len(p)
for x in range(len(p)):
if vis[x]:
continue
cycle = []
while not vis[x]:
vis[x] = True
cycle.append(x)
x = p[x]
cycles.append(cycle)
else:
assert False
ops = 2
for cycle in cycles:
for i in reversed(range(len(cycle) - 1)):
apply_stateswap(qc, cycle[i], cycle[i + 1])
return qc
def solve(n, a) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
perm = [2**n * j + (i + a * j) % 2**n for j in range(2) for i in range(2**n)]
return apply_permutation(qc, perm, option = "list")
''' |
QPC004_B3 | ADF2C94479F92 | 9 | TLE | 3000 ms | 177 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from numpy import pi, sqrt, acos
# Adds up to 6n circuit depth
def apply_stateswap(qc, x, y):
n = qc.num_qubits
assert 0 <= min(x, y) and max(x, y) < 2**n
if x == y:
return qc
diff = [i for i in range(n) if (x ^ y) >> i & 1]
for i in diff + list(reversed(diff[:-1])):
for j in range(n):
if j < i and ~x >> j & 1 or j > i and ~y >> j & 1:
qc.x(j)
qc.mcx(list(j for j in range(n) if i != j), i)
for j in range(n):
if j < i and ~x >> j & 1 or j > i and ~y >> j & 1:
qc.x(j)
return qc
# Adds up to 4 * n * 2**n circuit depth
# Requires apply_stateswap
def apply_permutation(qc, p, option = "cycle"):
assert option in ["cycle", "list"]
n = qc.num_qubits
cycles = []
if option == "cycle":
cycles = p[:]
elif option == "list":
assert sorted(p) == list(range(len(p)))
vis = [False] * len(p)
for x in range(len(p)):
if vis[x]:
continue
cycle = []
while not vis[x]:
vis[x] = True
cycle.append(x)
x = p[x]
cycles.append(cycle)
else:
assert False
ops = 2
for cycle in cycles:
for i in reversed(range(len(cycle) - 1)):
apply_stateswap(qc, cycle[i], cycle[i + 1])
return qc
def solve(n, a) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
perm = [2**n * j + (i + a * j) % 2**n for j in range(2) for i in range(2**n)]
return apply_permutation(qc, perm, option = "list")
''' |
QPC004_B3 | ADF2C94479F92 | 10 | TLE | 3000 ms | 176 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from numpy import pi, sqrt, acos
# Adds up to 4 * n circuit depth
def apply_stateswap(qc, x, y):
n = qc.num_qubits
assert 0 <= min(x, y) and max(x, y) < 2**n
if x == y:
return qc
diff = [i for i in range(n) if (x ^ y) >> i & 1]
last_mask = 0
for i in diff + list(reversed(diff[:-1])):
cur_mask = ~x & (2**i - 1) | ~y & (2**n - 2**(i + 1))
for j in range(n):
if (last_mask ^ cur_mask) >> j & 1:
qc.x(j)
qc.mcx(list(j for j in range(n) if i != j), i)
last_mask = cur_mask
for j in range(n):
if last_mask >> j & 1:
qc.x(j)
return qc
# Adds up to 4 * n * 2**n circuit depth
# Requires apply_stateswap
def apply_permutation(qc, p, option = "cycle"):
assert option in ["cycle", "list"]
n = qc.num_qubits
cycles = []
if option == "cycle":
cycles = p[:]
elif option == "list":
assert sorted(p) == list(range(len(p)))
vis = [False] * len(p)
for x in range(len(p)):
if vis[x]:
continue
cycle = []
while not vis[x]:
vis[x] = True
cycle.append(x)
x = p[x]
cycles.append(cycle)
else:
assert False
ops = 2
for cycle in cycles:
for i in reversed(range(len(cycle) - 1)):
apply_stateswap(qc, cycle[i], cycle[i + 1])
return qc
def solve(n, a) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
perm = [2**n * j + (i + a * j) % 2**n for j in range(2) for i in range(2**n)]
return apply_permutation(qc, perm, option = "list")
''' |
QPC004_B3 | AE88B5E72488F | 1 | UME | '''python
from qiskit import QuantumCircuit, QuantumRegister
from math import pi, acos, sqrt, asin
from qiskit.circuit.library import XGate, ZGate, PhaseGate, QFT
"""
You can apply oracle as follows:
qc.compose(o, inplace=True)
"""
def addition(n: int, a: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
qc.append(QFT(n), range(n))
for i in range(n):
qc.append(PhaseGate(2*pi*a*(1/2)**(n-i)), [i])
qc.append(QFT(n).inverse(), range(n))
return qc
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# qc.x(n)
qc.append(QFT(n).control(1), [n, *range(n)])
for i in range(n):
qc.append(PhaseGate(2*pi*a*(1/2)**(n-i)).control(1), [n, i])
qc.append(QFT(n,inverse=True).control(1), [n, *range(n)])
return qc
''' | ||
QPC004_B3 | AE88B5E72488F | 2 | AC | 2920 ms | 165 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from math import pi, acos, sqrt, asin
from qiskit.circuit.library import XGate, ZGate, PhaseGate, CU1Gate
"""
You can apply oracle as follows:
qc.compose(o, inplace=True)
"""
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(CU1Gate(pi/2**(j-i)), [j, i])
return qc
def addition(n: int, a: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
qc.compose(QFT(n), range(n), inplace=True)
for i in range(n):
qc.append(PhaseGate(2*pi*a*(1/2)**(n-i)), [i])
qc.compose(QFT(n).inverse(), range(n), inplace=True)
return qc
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# qc.x(n)
qc.append(QFT(n).control(1), [n, *range(n)])
for i in range(n):
qc.append(PhaseGate(2*pi*a*(1/2)**(n-i)).control(1), [n, i])
qc.append(QFT(n).inverse().control(1), [n, *range(n)])
return qc.decompose(reps=2)
''' |
QPC004_B3 | AE98211E8CDAD | 1 | RE | 1771 ms | 158 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def qft(qc: QuantumCircuit, qubits):
n = len(qubits)
for j in range(n):
qc.h(qubits[j])
for k in range(j+1, n):
qc.cp(math.pi/2**(k - j), qubits[k], qubits[j])
def iqft(qc: QuantumCircuit, qubits):
n = len(qubits)
for j in reversed(range(n)):
for k in reversed(range(j+1, n)):
qc.cp(-math.pi/2**(k - j), qubits[k], qubits[j])
qc.h(qubits[j])
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
qft(qc, k)
for j in range(n):
angle = 2 * math.pi * a / (2 ** (j + 1))
qc.cp(angle, c[0], k[j])
iqft(qc, k)
return qc
''' |
QPC004_B3 | AE98211E8CDAD | 2 | WA | 2077 ms | 162 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def qft(qc: QuantumCircuit, qubits):
n = len(qubits)
for j in range(n):
qc.h(qubits[j])
for k in range(j+1, n):
qc.cp(math.pi/2**(k - j), qubits[k], qubits[j])
def iqft(qc: QuantumCircuit, qubits):
n = len(qubits)
for j in reversed(range(n)):
for k in reversed(range(j+1, n)):
qc.cp(-math.pi/2**(k - j), qubits[k], qubits[j])
qc.h(qubits[j])
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
qft(qc, k)
for j in range(n):
angle = 2 * math.pi * a / (2 ** (j + 1))
qc.cp(angle, c[0], k[j])
iqft(qc, k)
return qc
''' |
QPC004_B3 | AE98211E8CDAD | 3 | WA | 1722 ms | 163 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def qft(qc: QuantumCircuit, qubits):
n = len(qubits)
for j in range(n):
qc.h(qubits[j])
for k in range(j+1, n):
qc.cp(math.pi/2**(k - j), qubits[k], qubits[j])
def iqft(qc: QuantumCircuit, qubits):
n = len(qubits)
for j in reversed(range(n)):
for k in range(n-1, j, -1):
qc.cp(-math.pi/2**(k - j), qubits[k], qubits[j])
qc.h(qubits[j])
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
qft(qc, k)
for j in range(n):
angle = 2 * math.pi * a * (2 ** j) / (2 ** n)
qc.cp(angle, c[0], k[j])
iqft(qc, k)
return qc
''' |
QPC004_B4 | A387379FDE520 | 1 | AC | 2143 ms | 161 MiB | '''python
import math
from qiskit import QuantumCircuit
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
# B2
def crot(n: int, a: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
for i in range(n):
theta = 2 * math.pi * a * 2**i / 2**n
qc.cp(theta, n, i)
return qc
# B3
def cadd(n: int, a: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
qc.compose(qft(n), qubits=range(n), inplace=True)
qc.compose(crot(n, a), qubits=range(n + 1), inplace=True)
qc.compose(qft(n).inverse(), qubits=range(n), inplace=True)
return qc
def solve(n: int, s: int, t: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# when k_{n-1} = 1
qc.compose(cadd(n, 2 ** (n + 1) - t), qubits=range(n + 1), inplace=True)
# when k_{n-1} = 0
qc.x(n)
qc.compose(cadd(n, -s), qubits=range(n + 1), inplace=True)
qc.x(n)
return qc
''' |
QPC004_B4 | A3965CFA5FFA8 | 1 | AC | 2318 ms | 160 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import ZGate, XGate, HGate, SwapGate
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)):
theta = math.pi / 2 ** (i - j)
qc.cp(theta, j, i)
for i in range(n // 2):
qc.swap(i, n - i - 1)
return qc
def add_constant_controlled(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
qc.compose(qft(n), inplace=True)
for i in range(n):
theta = 2 * math.pi * a * (2 ** i) / (2 ** n)
qc.cp(theta, k[i], c)
qc.compose(qft(n).inverse(), inplace=True)
return qc
def solve(n: int, s: int, t: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
qc.x(n)
qc.compose(add_constant_controlled(n, (2**n - s)), qubits=range(n + 1), inplace=True)
qc.x(n)
qc.compose(add_constant_controlled(n, (2**(n+1)-t)), qubits=range(n + 1), inplace=True)
return qc
''' |
QPC004_B4 | A75C492DA58D2 | 1 | RE | 1806 ms | 158 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, s: int, t: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
for i in range(n): qc.cx(i, n)
for i in range(n):
qc.ccx(i, n, n + 1)
qc.cx(i, n + 1)
qc.ccx(i, n, n + 1)
return qc
''' |
QPC004_B4 | A75C492DA58D2 | 2 | RE | 1568 ms | 158 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, s: int, t: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
qc.cx(range(n), n)
qc.ccx(range(n), n, n + 1)
qc.cx(range(n), n + 1)
qc.ccx(range(n), n, n + 1)
return qc
''' |
QPC004_B4 | A7CC3BCDF0EE9 | 1 | AC | 2011 ms | 163 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import RYGate
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 controlled_add(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
qc.compose(qft(n), inplace=True)
for idx in range(n):
theta = 2 * a * math.pi * (2**idx) / (2**n)
qc.cp(theta, c, k[idx])
qc.compose(qft(n).inverse(), inplace=True)
return qc
def oracle_less(bitcount: int, n: int) -> QuantumCircuit:
regin, regout = QuantumRegister(bitcount), QuantumRegister(1)
qc = QuantumCircuit(regin, regout)
if n >= 2**bitcount:
qc.x(regout)
return qc
bitrep = bin(n)[2:].zfill(bitcount)[::-1]
masks = []
for idx in range(bitcount):
if bitrep[idx] == "1":
mask = ("0" + bitrep[idx + 1 :]).rjust(bitcount, "*")
masks.append(mask)
flipped = [False] * bitcount
for mask in masks:
controls = []
for idx in range(bitcount):
if mask[idx] == "*":
continue
controls.append(regin[idx])
if (mask[idx] == "0") != (flipped[idx]):
flipped[idx] = not flipped[idx]
qc.x(regin[idx])
if len(controls) != 0:
qc.mcx(controls, regout)
for idx in range(bitcount):
if flipped[idx]:
qc.x(regin[idx])
return qc
def solve(n: int, s: int, t: int) -> QuantumCircuit:
regin = QuantumRegister(n + 1)
qc = QuantumCircuit(regin)
# Write your code here:
anc_range = QuantumRegister(1)
anc_pred = QuantumRegister(1)
qc.add_register(anc_range)
qc.add_register(anc_pred)
# case 1
qc.compose(oracle_less(n+1, s), [*regin, *anc_range], inplace=True)
qc.x(regin[-1])
qc.x(anc_range)
qc.ccx(regin[-1], anc_range, anc_pred)
qc.compose(controlled_add(n, -s), [*regin[:-1], *anc_pred], inplace=True)
qc.ccx(regin[-1], anc_range, anc_pred)
qc.x(anc_range)
qc.x(regin[-1])
# case 2
qc.compose(oracle_less(n+1, t), [*regin, *anc_range], inplace=True)
qc.ccx(regin[-1], anc_range, anc_pred)
qc.compose(controlled_add(n+1, 2**(n+1)-t), [*regin, *anc_pred], inplace=True)
qc.ccx(regin[-1], anc_range, anc_pred)
qc.x(anc_range)
return qc
''' |
QPC004_B4 | A86D200016A73 | 1 | RE | 1858 ms | 158 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, s: int, t: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
# QFT
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)
# B2
for i in range(n):
qc.cp(-2 * math.pi * s * 2 ** (i - n), n, i, ctrl_state=1)
qc.cp(-2 * math.pi * t * 2 ** (i - n), n, i, ctrl_state=0)
# IQFT
for i in reversed(range(n // 2)):
qc.swap(i, n - i - 1)
for i in range(n):
for j in range(i):
qc.cp(-math.pi / 2 ** (i - j), j, i)
qc.h(i)
return qc
''' |
QPC004_B4 | A86D200016A73 | 2 | WA | 1639 ms | 162 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, s: int, t: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
# QFT
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)
# B2
for i in range(n):
qc.cp(-2 * math.pi * s * 2 ** (i - n), n, i, ctrl_state=1)
qc.cp(-2 * math.pi * t * 2 ** (i - n), n, i, ctrl_state=0)
# IQFT
for i in reversed(range(n // 2)):
qc.swap(i, n - i - 1)
for i in range(n):
for j in range(i):
qc.cp(-math.pi / 2 ** (i - j), j, i)
qc.h(i)
return qc
''' |
QPC004_B4 | A86D200016A73 | 3 | UME | '''python
from qiskit import QuantumCircuit
import mat
def solve(n: int, s: int, t: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
# QFT
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)
# B2
for i in range(n):
qc.cp(-2 * math.pi * s * 2 ** (i - n), n, i, ctrl_state=0)
qc.cp(-2 * math.pi * t * 2 ** (i - n), n, i, ctrl_state=1)
# IQFT
for i in reversed(range(n // 2)):
qc.swap(i, n - i - 1)
for i in range(n):
for j in range(i):
qc.cp(-math.pi / 2 ** (i - j), j, i)
qc.h(i)
return qc
''' | ||
QPC004_B4 | A86D200016A73 | 4 | AC | 2072 ms | 163 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, s: int, t: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
# QFT
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)
# B2
for i in range(n):
qc.cp(-2 * math.pi * s * 2 ** (i - n), n, i, ctrl_state=0)
qc.cp(-2 * math.pi * t * 2 ** (i - n), n, i, ctrl_state=1)
# IQFT
for i in reversed(range(n // 2)):
qc.swap(i, n - i - 1)
for i in range(n):
for j in range(i):
qc.cp(-math.pi / 2 ** (i - j), j, i)
qc.h(i)
return qc
''' |
QPC004_B4 | A92FDE8B505CB | 1 | RE | '''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], 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, s: int, t: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
QFT(qc, list(range(n))):
for i in range(n):
theta = 2 * math.pi * ((2 ** (n + 1)) - t) * (2 ** i) / (2 ** n)
qc.cp(theta, n, i)
qc.x(n)
for i in range(n):
theta = 2 * math.pi * (-s) * (2 ** i) / (2 ** n)
qc.x(n)
QFT(qc, list(range(n)), inversed=True)
return qc
''' | ||
QPC004_B4 | A92FDE8B505CB | 2 | RE | '''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], 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, s: int, t: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
QFT(qc, list(range(n))):
for i in range(n):
theta = 2 * math.pi * ((2 ** (n + 1)) - t) * (2 ** i) / (2 ** n)
qc.cp(theta, n, i)
qc.x(n)
for i in range(n):
theta = 2 * math.pi * (-s) * (2 ** i) / (2 ** n)
qc.cp(theta, n, i)
qc.x(n)
QFT(qc, list(range(n)), inversed=True)
return qc
''' | ||
QPC004_B4 | A92FDE8B505CB | 3 | AC | 1726 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], 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, s: int, t: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
QFT(qc, list(range(n)))
for i in range(n):
theta = 2 * math.pi * ((2 ** (n + 1)) - t) * (2 ** i) / (2 ** n)
qc.cp(theta, n, i)
qc.x(n)
for i in range(n):
theta = 2 * math.pi * (-s) * (2 ** i) / (2 ** n)
qc.cp(theta, n, i)
qc.x(n)
QFT(qc, list(range(n)), inversed=True)
return qc
''' |
QPC004_B4 | AA7C91926226F | 1 | WA | 1643 ms | 161 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, s: int, t: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
def add(qc, n, a):
for i in range(n):
if (a & (1 << i)):
n_not = n - i
for j in range(i+n_not-1, i-1, -1):
qc.mcx(list(range(i, j)) + [n], j)
def subtract(qc, n, a):
for i in range(n-1, -1, -1):
if (a & (1 << i)):
n_not = n - i
for j in range(i, i+n_not):
qc.mcx(list(range(i, j)) + [n], j)
qc.cx(n-1, n)
subtract(qc, n, s)
qc.x(n)
subtract(qc, n, t)
qc.x(n)
return qc
''' |
QPC004_B4 | AA7C91926226F | 2 | WA | 1761 ms | 162 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, s: int, t: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
def add(qc, n, a):
for i in range(n):
if (a & (1 << i)):
n_not = n - i
for j in range(i+n_not-1, i-1, -1):
qc.mcx(list(range(i, j)) + [n], j)
def subtract(qc, n, a):
for i in range(n-1, -1, -1):
if (a & (1 << i)):
n_not = n - i
for j in range(i, i+n_not):
qc.mcx(list(range(i, j)) + [n], j)
qc.cx(n-1, n)
subtract(qc, n, s)
qc.x(n)
subtract(qc, n, t)
#qc.x(n)
return qc
''' |
QPC004_B4 | AA7C91926226F | 3 | WA | 1728 ms | 161 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, s: int, t: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
def add(qc, n, a):
for i in range(n):
if (a & (1 << i)):
n_not = n - i
for j in range(i+n_not-1, i-1, -1):
qc.mcx(list(range(i, j)) + [n], j)
def subtract(qc, n, a):
for i in range(n-1, -1, -1):
if (a & (1 << i)):
n_not = n - i
for j in range(i, i+n_not):
qc.mcx(list(range(i, j)) + [n], j)
qc.cx(n-1, n)
qc.x(n)
subtract(qc, n, s)
qc.x(n)
subtract(qc, n, t)
#qc.x(n)
return qc
''' |
QPC004_B4 | AA7C91926226F | 4 | WA | 1806 ms | 163 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, s: int, t: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
def add(qc, n, a):
for i in range(n):
if (a & (1 << i)):
n_not = n - i
for j in range(i+n_not-1, i-1, -1):
qc.mcx(list(range(i, j)) + [n], j)
def subtract(qc, n, a):
for i in range(n-1, -1, -1):
if (a & (1 << i)):
n_not = n - i
for j in range(i, i+n_not):
qc.mcx(list(range(i, j)) + [n], j)
# initialize state to 5
qc.cx(n-1, n)
subtract(qc, n, s)
qc.x(n)
add(qc, n, 2**(n+1) - t)
qc.x(n)
return qc
''' |
QPC004_B4 | AA7C91926226F | 5 | RE | 1661 ms | 159 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, s: int, t: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
def add(qc, n, a):
for i in range(n):
if (a & (1 << i)):
n_not = n - i
for j in range(i+n_not-1, i-1, -1):
qc.mcx(list(range(i, j)) + [n], j)
def subtract(qc, n, a):
for i in range(n-1, -1, -1):
if (a & (1 << i)):
n_not = n - i
for j in range(i, i+n_not):
qc.mcx(list(range(i, j)) + [n], j)
# initialize state to 7
for i in range(n):
if (k & (1 << i)):
qc.x(i)
add(qc, n, 2**(n+1)-t)
qc.x(n)
subtract(qc, n, s)
qc.x(n)
return qc
''' |
QPC004_B4 | AA7C91926226F | 6 | AC | 2352 ms | 163 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, s: int, t: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
def add(qc, n, a):
for i in range(n):
if (a & (1 << i)):
n_not = n - i
for j in range(i+n_not-1, i-1, -1):
qc.mcx(list(range(i, j)) + [n], j)
def subtract(qc, n, a):
for i in range(n-1, -1, -1):
if (a & (1 << i)):
n_not = n - i
for j in range(i, i+n_not):
qc.mcx(list(range(i, j)) + [n], j)
add(qc, n, 2**(n+1)-t)
qc.x(n)
subtract(qc, n, s)
qc.x(n)
return qc
''' |
QPC004_B4 | ABA4478D057ED | 1 | WA | 2141 ms | 163 MiB | '''python
from math import ceil,floor,acos,asin,atan,sqrt,pi,gcd,sin,cos,tan
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(pi / 2 ** (i - j), j, i)
for i in range(n // 2):
qc.swap(i, n - i - 1)
return qc
def b3(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
qft_n =qft(n)
qc.compose(qft_n,k,inplace=True)
for i in range(n):
theta = 2 * pi * a * 2**i / 2**n
qc.cp(theta,n, i)
qc.compose(qft_n.inverse(),k,inplace=True)
return qc
def solve(n: int, s: int, t: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(n + 1)
qc = QuantumCircuit(k, c)
# Write your code here:
qft_n =qft(n)
qc.compose(qft_n,k,inplace=True)
for i in range(n):
tt = 2 * pi * (t-2**(n+1)) * 2**i / 2**n
qc.cp(tt,n, i)
qc.x(n)
ts=s
qc.cp(ts,n, i)
qc.x(0)
qc.compose(qft_n.inverse(),k,inplace=True)
return qc
''' |
QPC004_B4 | ABA4478D057ED | 2 | WA | 1986 ms | 163 MiB | '''python
from math import ceil,floor,acos,asin,atan,sqrt,pi,gcd,sin,cos,tan
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(pi / 2 ** (i - j), j, i)
for i in range(n // 2):
qc.swap(i, n - i - 1)
return qc
def b3(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
qft_n =qft(n)
qc.compose(qft_n,k,inplace=True)
for i in range(n):
theta = 2 * pi * a * 2**i / 2**n
qc.cp(theta,n, i)
qc.compose(qft_n.inverse(),k,inplace=True)
return qc
def solve(n: int, s: int, t: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(n + 1)
qc = QuantumCircuit(k, c)
# Write your code here:
qft_n =qft(n)
qc.compose(qft_n,k,inplace=True)
for i in range(n):
tt = 2 * pi * (t-2**(n+1)) * 2**i / 2**n
qc.cp(tt,n, i)
qc.x(n)
ts=2 * pi * s * 2**i / 2**n
qc.cp(ts,n, i)
qc.x(0)
qc.compose(qft_n.inverse(),k,inplace=True)
return qc.inverse()
''' |
QPC004_B4 | ABA4478D057ED | 3 | AC | 2203 ms | 163 MiB | '''python
from math import ceil,floor,acos,asin,atan,sqrt,pi,gcd,sin,cos,tan
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(pi / 2 ** (i - j), j, i)
for i in range(n // 2):
qc.swap(i, n - i - 1)
return qc
def b3(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
qft_n =qft(n)
qc.compose(qft_n,k,inplace=True)
for i in range(n):
theta = 2 * pi * a * 2**i / 2**n
qc.cp(theta,n, i)
qc.compose(qft_n.inverse(),k,inplace=True)
return qc
def solve(n: int, s: int, t: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
qft_n =qft(n)
qc.compose(qft_n,k,inplace=True)
for i in range(n):
tt = 2 * pi * (t-2**(n+1)) * 2**i / 2**n
qc.cp(tt,n, i)
qc.x(n)
ts=2 * pi * s * 2**i / 2**n
qc.cp(ts,n, i)
qc.x(n)
qc.compose(qft_n.inverse(),k,inplace=True)
return qc.inverse()
''' |
QPC004_B4 | ABC30E6D0AB4F | 1 | AC | 2491 ms | 167 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from math import pi, acos, sqrt, asin
from qiskit.circuit.library import XGate, ZGate, PhaseGate, CU1Gate
"""
You can apply oracle as follows:
qc.compose(o, inplace=True)
"""
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(CU1Gate(pi/2**(j-i)), [j, i])
return qc
def addition(n: int, a: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
qc.compose(QFT(n), range(n), inplace=True)
for i in range(n):
qc.append(PhaseGate(2*pi*a*(1/2)**(n-i)), [i])
qc.compose(QFT(n).inverse(), range(n), inplace=True)
return qc
def B3(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# qc.x(n)
qc.append(QFT(n).control(1), [n, *range(n)])
for i in range(n):
qc.append(PhaseGate(2*pi*a*(1/2)**(n-i)).control(1), [n, i])
qc.append(QFT(n).inverse().control(1), [n, *range(n)])
return qc.decompose(reps=2)
def solve(n: int, s: int, t: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
qc.compose(B3(n, -t), range(n + 1), inplace=True)
qc.x(n)
qc.compose(B3(n, -s), range(n + 1), inplace=True)
qc.x(n)
return qc
''' |
QPC004_B4 | ABCB39C3F2428 | 1 | WA | 1919 ms | 161 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, s: int, t: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Define the range for k
lower_bound = s
upper_bound = 2**n
second_lower_bound = 2**n
second_upper_bound = t
# Create a classical condition to check the ranges
# We will use the last qubit as an auxiliary qubit to help with the logic
# We will use the last qubit to indicate which operation to perform
# For k in [s, 2^n)
for k in range(lower_bound, upper_bound):
# Convert k to binary and set the qubits accordingly
binary_k = format(k, f'0{n}b')[::-1] # little-endian
for i in range(n):
if binary_k[i] == '1':
qc.x(i) # Set the qubit to |1>
# Apply the operation O: |k> -> |k - s>
# This is equivalent to subtracting s from k
# We need to apply a series of controlled NOTs to achieve this
binary_s = format(s, f'0{n}b')[::-1] # little-endian
for i in range(n):
if binary_s[i] == '1':
qc.cx(i, n) # Controlled NOT to subtract s
# Reset the qubits to prepare for the next iteration
for i in range(n):
if binary_k[i] == '1':
qc.x(i) # Reset the qubit to |0>
# For k in [2^n, t)
for k in range(second_lower_bound, second_upper_bound):
# Convert k to binary and set the qubits accordingly
binary_k = format(k, f'0{n}b')[::-1] # little-endian
for i in range(n):
if binary_k[i] == '1':
qc.x(i) # Set the qubit to |1>
# Apply the operation O: |k> -> |k + (2^(n+1) - t)>
# This is equivalent to adding (2^(n+1) - t) to k
addition = (2**(n + 1) - t)
binary_addition = format(addition, f'0{n}b')[::-1] # little-endian
for i in range(n):
if binary_addition[i] == '1':
qc.cx(i, n) # Controlled NOT to add (2^(n+1) - t)
# Reset the qubits to prepare for the next iteration
for i in range(n):
if binary_k[i] == '1':
qc.x(i) # Reset the qubit to |0>
return qc
''' |
QPC004_B4 | AD8544A8C985D | 1 | RE | 1911 ms | 156 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, s: int, t: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
qc.append(constant_addition(n,-t), qargs=range(n+1))
qc.x(n)
qc.append(constant_addition(n,-s), qargs=range(n+1))
qc.x(n)
return qc
def constant_addition(n,a):
qc = QuantumCircuit(n+1)
for i in range(n-1,-1,-1):
qc.ch(n,i)
for j in range(i-1,-1,-1):
qc.mcp(2*math.pi/2**(i-j+1),[n,j],i)
for k in range(n//2):
qc.cswap(n,k,n-1-k)
for i in range(n):
qc.cp(2*math.pi*a/2**(n-i),n,i)
for i in range(n-1,-1,-1):
qc.ch(n,i)
for j in range(i-1,-1,-1):
qc.mcp(-2*math.pi/2**(i-j+1),[n,j],i)
for k in range(n//2):
qc.cswap(n,k,n-1-k)
return qc
''' |
QPC004_B4 | AD8544A8C985D | 2 | UGE | 1633 ms | 156 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, s: int, t: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
qc.append(constant_addition(n,-t), qargs=range(n+1))
qc.x(n)
qc.append(constant_addition(n,-s), qargs=range(n+1))
qc.x(n)
return qc
def constant_addition(n,a):
qc = QuantumCircuit(n+1)
for i in range(n-1,-1,-1):
qc.ch(n,i)
for j in range(i-1,-1,-1):
qc.mcp(2*math.pi/2**(i-j+1),[n,j],i)
for k in range(n//2):
qc.cswap(n,k,n-1-k)
for i in range(n):
qc.cp(2*math.pi*a/2**(n-i),n,i)
for i in range(n-1,-1,-1):
qc.ch(n,i)
for j in range(i-1,-1,-1):
qc.mcp(-2*math.pi/2**(i-j+1),[n,j],i)
for k in range(n//2):
qc.cswap(n,k,n-1-k)
return qc
''' |
QPC004_B4 | AD8544A8C985D | 3 | UGE | 1751 ms | 156 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, s: int, t: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
qc.append(constant_addition(n,-t), qargs=range(n+1))
return qc
def constant_addition(n,a):
qc = QuantumCircuit(n+1)
for i in range(n-1,-1,-1):
qc.ch(n,i)
for j in range(i-1,-1,-1):
qc.mcp(2*math.pi/2**(i-j+1),[n,j],i)
for k in range(n//2):
qc.cswap(n,k,n-1-k)
for i in range(n):
qc.cp(2*math.pi*a/2**(n-i),n,i)
for i in range(n-1,-1,-1):
qc.ch(n,i)
for j in range(i-1,-1,-1):
qc.mcp(-2*math.pi/2**(i-j+1),[n,j],i)
for k in range(n//2):
qc.cswap(n,k,n-1-k)
return qc
''' |
QPC004_B4 | AD8544A8C985D | 4 | UGE | 1629 ms | 156 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, s: int, t: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
qc.append(constant_addition(n,-t), qargs=range(n+1))
qc.x(n)
qc.append(constant_addition(n,-s), qargs=range(n+1))
qc.x(n)
return qc
def constant_addition(n,a):
qc = QuantumCircuit(n+1)
for i in range(n-1,-1,-1):
qc.ch(n,i)
for j in range(i-1,-1,-1):
qc.mcp(2*math.pi/2**(i-j+1),[n,j],i)
for k in range(n//2):
qc.cswap(n,k,n-1-k)
for i in range(n):
qc.cp(2*math.pi*a/2**(n-i),n,i)
for i in range(n-1,-1,-1):
qc.ch(n,i)
for j in range(i-1,-1,-1):
qc.mcp(-2*math.pi/2**(i-j+1),[n,j],i)
for k in range(n//2):
qc.cswap(n,k,n-1-k)
return qc
''' |
QPC004_B4 | AD8544A8C985D | 5 | RE | 1802 ms | 156 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, a: int) -> QuantumCircuit:
qc = QuantumCircuit(n+1)
# Write your code here:
for i in range(n-1,-1,-1):
qc.ch(n,i)
for j in range(i-1,-1,-1):
qc.mcp(2*math.pi/2**(i-j+1),[n,j],i)
for k in range(n//2):
qc.cswap(n,k,n-1-k)
for i in range(n):
qc.cp(2*math.pi*a/2**(n-i),n,i)
for i in range(n-1,-1,-1):
qc.ch(n,i)
for j in range(i-1,-1,-1):
qc.mcp(-2*math.pi/2**(i-j+1),[n,j],i)
for k in range(n//2):
qc.cswap(n,k,n-1-k)
return qc
''' |
QPC004_B4 | AD8544A8C985D | 6 | RE | 1665 ms | 156 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, s: int, t: int) -> QuantumCircuit:
qc = QuantumCircuit(n+1)
# Write your code here:
for i in range(n-1,-1,-1):
qc.ch(n,i)
for j in range(i-1,-1,-1):
qc.mcp(2*math.pi/2**(i-j+1),[n,j],i)
for k in range(n//2):
qc.cswap(n,k,n-1-k)
for i in range(n):
qc.cp(2*math.pi*a/2**(n-i),n,i)
for i in range(n-1,-1,-1):
qc.ch(n,i)
for j in range(i-1,-1,-1):
qc.mcp(-2*math.pi/2**(i-j+1),[n,j],i)
for k in range(n//2):
qc.cswap(n,k,n-1-k)
return qc
''' |
QPC004_B4 | AD8544A8C985D | 7 | WA | 1689 ms | 160 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, s: int, t: int) -> QuantumCircuit:
qc = QuantumCircuit(n+1)
# Write your code here:
for i in range(n-1,-1,-1):
qc.ch(n,i)
for j in range(i-1,-1,-1):
qc.mcp(2*math.pi/2**(i-j+1),[n,j],i)
for k in range(n//2):
qc.cswap(n,k,n-1-k)
for i in range(n):
qc.cp(2*math.pi*(-t)/2**(n-i),n,i)
for i in range(n-1,-1,-1):
qc.ch(n,i)
for j in range(i-1,-1,-1):
qc.mcp(-2*math.pi/2**(i-j+1),[n,j],i)
for k in range(n//2):
qc.cswap(n,k,n-1-k)
return qc
''' |
QPC004_B4 | AD8544A8C985D | 8 | AC | 2142 ms | 163 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, s: int, t: int) -> QuantumCircuit:
qc = QuantumCircuit(n+1)
# Write your code here:
for i in range(n-1,-1,-1):
qc.ch(n,i)
for j in range(i-1,-1,-1):
qc.mcp(2*math.pi/2**(i-j+1),[n,j],i)
for k in range(n//2):
qc.cswap(n,k,n-1-k)
for i in range(n):
qc.cp(2*math.pi*(-t)/2**(n-i),n,i)
for i in range(n-1,-1,-1):
qc.ch(n,i)
for j in range(i-1,-1,-1):
qc.mcp(-2*math.pi/2**(i-j+1),[n,j],i)
for k in range(n//2):
qc.cswap(n,k,n-1-k)
qc.x(n)
for i in range(n-1,-1,-1):
qc.ch(n,i)
for j in range(i-1,-1,-1):
qc.mcp(2*math.pi/2**(i-j+1),[n,j],i)
for k in range(n//2):
qc.cswap(n,k,n-1-k)
for i in range(n):
qc.cp(2*math.pi*(-s)/2**(n-i),n,i)
for i in range(n-1,-1,-1):
qc.ch(n,i)
for j in range(i-1,-1,-1):
qc.mcp(-2*math.pi/2**(i-j+1),[n,j],i)
for k in range(n//2):
qc.cswap(n,k,n-1-k)
qc.x(n)
return qc
''' |
QPC004_B4 | ADB17C53F72BD | 1 | WA | 1922 ms | 162 MiB | '''python
from qiskit import QuantumCircuit
from math import tau, pi
def solve(n: int, s: int, t: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
ctl = n
n -= 1
for i in range(n - 1, -1, -1):
qc.h(i)
for j in range(i - 1, -1, -1):
qc.cp(pi / (1 << (i - j)), j, i)
for i in range(n):
theta = tau / (1 << n - i)
# qc.cp(a * theta[i], k[n - 1 - i])
qc.cp(((1 << n + 1) - t - s) * theta, ctl, n - 1 - i)
for i in range(n):
for j in range(i):
qc.cp(-pi / (1 << (i - j)), j, i)
qc.h(i)
return qc
''' |
QPC004_B4 | AE3D05C9E2DB2 | 1 | RE | 1566 ms | 158 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, s: int, t: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
for k in range(s, 2**n):
qc.cx(k, n)
for k in range(2**n, t):
qc.cx(k, n)
return qc
''' |
QPC004_B4 | AE57912C6F34D | 1 | WA | 1752 ms | 162 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, s: int, t: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Apply the oracle O based on the conditions
for k in range(s + 1, 2**n):
# Apply the first condition for s < k < 2^n
# Example: Apply X gate to the last qubit if condition is met
qc.x(n)
for k in range(2**n + 1, t):
# Apply the second condition for 2^n < k < t
# Example: Apply Y gate to the last qubit if condition is met
qc.y(n)
return qc
''' |
QPC004_B4 | AEDEB933D93EB | 1 | TLE | 3000 ms | 177 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, s: int, t: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
t = 2 ** (n + 1) - t
for j in range(t):
for i in range(n):
qc.cx(n, i)
qc.cx(n, 0)
for i in range(n - 1):
qc.mcx(list(range(0, i + 1)) + [n], i + 1)
for i in range(n):
qc.cx(n, i)
qc.x(n)
for j in range(s):
qc.cx(n, 0)
for i in range(n - 1):
qc.mcx(list(range(0, i + 1)) + [n], i + 1)
qc.x(n)
return qc
''' |
QPC004_B4 | AEDEB933D93EB | 2 | TLE | 3000 ms | 171 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, s: int, t: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
t = 2 ** (n + 1) - t
for i in range(n):
qc.cx(n, i)
for j in range(t):
qc.cx(n, 0)
for i in range(n - 1):
qc.mcx(list(range(0, i + 1)) + [n], i + 1)
for i in range(n):
qc.cx(n, i)
qc.x(n)
for j in range(s):
qc.cx(n, 0)
for i in range(n - 1):
qc.mcx(list(range(0, i + 1)) + [n], i + 1)
qc.x(n)
return qc
''' |
QPC004_B4 | AEDEB933D93EB | 3 | WA | 1678 ms | 163 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, s: int, t: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
t = 2 ** (n + 1) - t
for i in range(n):
qc.cx(n, i)
for j in range(10):
if (t / (2 ** j)) % 2 == 1:
qc.cx(n, j)
for i in range(j, n - 1):
qc.mcx(list(range(j, i + 1)) + [n], i + 1)
for i in range(n):
qc.cx(n, i)
qc.x(n)
for j in range(10):
if (s / (2 ** j)) % 2 == 1:
qc.cx(n, j)
for i in range(j, n - 1):
qc.mcx(list(range(j, i + 1)) + [n], i + 1)
qc.x(n)
return qc
''' |
QPC004_B4 | AEDEB933D93EB | 4 | AC | 2218 ms | 163 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, s: int, t: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
t = 2 ** (n + 1) - t
for i in range(n):
qc.cx(n, i)
for j in range(10):
if (t // (2 ** j)) % 2 == 1:
qc.cx(n, j)
for i in range(j, n - 1):
qc.mcx(list(range(j, i + 1)) + [n], i + 1)
for i in range(n):
qc.cx(n, i)
qc.x(n)
for j in range(10):
if (s // (2 ** j)) % 2 == 1:
qc.cx(n, j)
for i in range(j, n - 1):
qc.mcx(list(range(j, i + 1)) + [n], i + 1)
qc.x(n)
return qc
''' |
QPC004_B5 | A3084D9D9EBBA | 1 | WA | 1704 ms | 163 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from math import pi, acos, sqrt, asin
from qiskit.circuit.library import XGate, ZGate, PhaseGate, CU1Gate
"""
You can apply oracle as follows:
qc.compose(o, inplace=True)
"""
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(CU1Gate(pi/2**(j-i)), [j, i])
return qc
def B2(n: int, a: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
qc.compose(QFT(n), range(n), inplace=True)
for i in range(n):
qc.append(PhaseGate(2*pi*a*(1/2)**(n-i)), [i])
qc.compose(QFT(n).inverse(), range(n), inplace=True)
return qc
def B3(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# qc.x(n)
qc.append(QFT(n).control(1), [n, *range(n)])
for i in range(n):
qc.append(PhaseGate(2*pi*a*(1/2)**(n-i)).control(1), [n, i])
qc.append(QFT(n).inverse().control(1), [n, *range(n)])
return qc.decompose(reps=2)
def B4(n: int, s: int, t: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
qc.compose(B3(n, -t), range(n + 1), inplace=True)
qc.x(n)
qc.compose(B3(n, -s), range(n + 1), inplace=True)
qc.x(n)
return qc
def solve(n: int, a: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
qc.compose(B2(n+1, 2**n-a), range(n + 1), inplace=True)
qc.compose(B4(n, 2**n-a, 2**n-a+L), range(n + 1), inplace=True)
qc.compose(B2(n+1, L-a), range(n + 1), inplace=True)
return qc
''' |
QPC004_B5 | A3084D9D9EBBA | 2 | WA | 2066 ms | 164 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from math import pi, acos, sqrt, asin
from qiskit.circuit.library import XGate, ZGate, PhaseGate, CU1Gate
"""
You can apply oracle as follows:
qc.compose(o, inplace=True)
"""
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(CU1Gate(pi/2**(j-i)), [j, i])
return qc
def B2(n: int, a: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
qc.compose(QFT(n), range(n), inplace=True)
for i in range(n):
qc.append(PhaseGate(2*pi*a*(1/2)**(n-i)), [i])
qc.compose(QFT(n).inverse(), range(n), inplace=True)
return qc
def B3(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# qc.x(n)
qc.append(QFT(n).control(1), [n, *range(n)])
for i in range(n):
qc.append(PhaseGate(2*pi*a*(1/2)**(n-i)).control(1), [n, i])
qc.append(QFT(n).inverse().control(1), [n, *range(n)])
return qc.decompose(reps=2)
def B4(n: int, s: int, t: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
qc.compose(B3(n, -t), range(n + 1), inplace=True)
qc.x(n)
qc.compose(B3(n, -s), range(n + 1), inplace=True)
qc.x(n)
return qc
def solve(n: int, a: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
qc.compose(B2(n+1, 2**n-a), range(n + 1), inplace=True)
qc.compose(B4(n, 2**n-a, 2**n-a+L), range(n + 1), inplace=True)
qc.x(n)
qc.compose(B2(n+1, -(2**n-a)), range(n + 1), inplace=True)
return qc
''' |
QPC004_B5 | A3084D9D9EBBA | 3 | AC | 2309 ms | 170 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from math import pi, acos, sqrt, asin
from qiskit.circuit.library import XGate, ZGate, PhaseGate, CU1Gate
"""
You can apply oracle as follows:
qc.compose(o, inplace=True)
"""
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(CU1Gate(pi/2**(j-i)), [j, i])
return qc
def B2(n: int, a: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
qc.compose(QFT(n), range(n), inplace=True)
for i in range(n):
qc.append(PhaseGate(2*pi*a*(1/2)**(n-i)), [i])
qc.compose(QFT(n).inverse(), range(n), inplace=True)
return qc
def B3(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# qc.x(n)
qc.append(QFT(n).control(1), [n, *range(n)])
for i in range(n):
qc.append(PhaseGate(2*pi*a*(1/2)**(n-i)).control(1), [n, i])
qc.append(QFT(n).inverse().control(1), [n, *range(n)])
return qc.decompose(reps=2)
def B4(n: int, s: int, t: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
qc.compose(B3(n, -t), range(n + 1), inplace=True)
qc.x(n)
qc.compose(B3(n, -s), range(n + 1), inplace=True)
qc.x(n)
return qc
def solve(n: int, a: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
a=L-a
# Write your code here:
qc.compose(B2(n+1, 2**n-a), range(n + 1), inplace=True)
qc.compose(B4(n, 2**n-a, 2**n-a+L), range(n + 1), inplace=True)
qc.x(n)
qc.compose(B2(n+1, -2**n+L-a), range(n + 1), inplace=True)
return qc
''' |
QPC004_B5 | A3636C48E5A68 | 1 | RE | 1768 ms | 157 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, a: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
x = QuantumRegister(1)
qc.add_bits(x)
qc.x(n+1)
qc.compose(constant_addition(n+1,q-L), inplace=True)
qc.compose(constant_addition(n,L), inplace=True)
qc.x(n+1)
qc.swap(n,n+1)
return qc
def constant_addition(n,a):
qc = QuantumCircuit(n+1)
for i in range(n-1,-1,-1):
qc.ch(n,i)
for j in range(i-1,-1,-1):
qc.mcp(2*math.pi/2**(i-j+1),[n,j],i)
for k in range(n//2):
qc.cswap(n,k,n-1-k)
for i in range(n):
qc.cp(2*math.pi*a/2**(n-i),n,i)
for i in range(n-1,-1,-1):
qc.ch(n,i)
for j in range(i-1,-1,-1):
qc.mcp(-2*math.pi/2**(i-j+1),[n,j],i)
for k in range(n//2):
qc.cswap(n,k,n-1-k)
return qc
''' |
QPC004_B5 | A3636C48E5A68 | 2 | RE | 1711 ms | 156 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, a: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
x = QuantumRegister(1)
qc.add_bits(x)
qc.x(n+1)
qc.compose(constant_addition(n+1,a-L), inplace=True)
qc.compose(constant_addition(n,L), inplace=True)
qc.x(n+1)
qc.swap(n,n+1)
return qc
def constant_addition(n,a):
qc = QuantumCircuit(n+1)
for i in range(n-1,-1,-1):
qc.ch(n,i)
for j in range(i-1,-1,-1):
qc.mcp(2*math.pi/2**(i-j+1),[n,j],i)
for k in range(n//2):
qc.cswap(n,k,n-1-k)
for i in range(n):
qc.cp(2*math.pi*a/2**(n-i),n,i)
for i in range(n-1,-1,-1):
qc.ch(n,i)
for j in range(i-1,-1,-1):
qc.mcp(-2*math.pi/2**(i-j+1),[n,j],i)
for k in range(n//2):
qc.cswap(n,k,n-1-k)
return qc
''' |
QPC004_B5 | A3636C48E5A68 | 3 | RE | 1635 ms | 156 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, a: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
x = QuantumRegister(1)
qc.add_bits(x)
qc.x(n+1)
qc.compose(constant_addition(n+1,a-L), inplace=True)
qc.compose(constant_addition(n,L), qubits=list(range(n+1)), inplace=True)
qc.x(n+1)
qc.swap(n,n+1)
return qc
def constant_addition(n,a):
qc = QuantumCircuit(n+1)
for i in range(n-1,-1,-1):
qc.ch(n,i)
for j in range(i-1,-1,-1):
qc.mcp(2*math.pi/2**(i-j+1),[n,j],i)
for k in range(n//2):
qc.cswap(n,k,n-1-k)
for i in range(n):
qc.cp(2*math.pi*a/2**(n-i),n,i)
for i in range(n-1,-1,-1):
qc.ch(n,i)
for j in range(i-1,-1,-1):
qc.mcp(-2*math.pi/2**(i-j+1),[n,j],i)
for k in range(n//2):
qc.cswap(n,k,n-1-k)
return qc
''' |
QPC004_B5 | A3636C48E5A68 | 4 | WA | 1773 ms | 160 MiB | '''python
from qiskit import QuantumCircuit,QuantumRegister
import math
def solve(n: int, a: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
x = QuantumRegister(1)
qc.add_bits(x)
qc.x(n+1)
qc.compose(constant_addition(n+1,a-L), inplace=True)
qc.compose(constant_addition(n,L), qubits=list(range(n+1)), inplace=True)
qc.x(n+1)
qc.swap(n,n+1)
return qc
def constant_addition(n,a):
qc = QuantumCircuit(n+1)
for i in range(n-1,-1,-1):
qc.ch(n,i)
for j in range(i-1,-1,-1):
qc.mcp(2*math.pi/2**(i-j+1),[n,j],i)
for k in range(n//2):
qc.cswap(n,k,n-1-k)
for i in range(n):
qc.cp(2*math.pi*a/2**(n-i),n,i)
for i in range(n-1,-1,-1):
qc.ch(n,i)
for j in range(i-1,-1,-1):
qc.mcp(-2*math.pi/2**(i-j+1),[n,j],i)
for k in range(n//2):
qc.cswap(n,k,n-1-k)
return qc
''' |
QPC004_B5 | A3636C48E5A68 | 5 | WA | 2026 ms | 161 MiB | '''python
from qiskit import QuantumCircuit,QuantumRegister
import math
def solve(n: int, a: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
x = QuantumRegister(1)
qc.add_bits(x)
qc.x(n+1)
qc.compose(constant_addition(n+1,a-L), inplace=True)
qc.compose(constant_addition(n,L), inplace=True)
qc.x(n+1)
qc.x(n)
return qc
def constant_addition(n,a):
qc = QuantumCircuit(n+1)
for i in range(n-1,-1,-1):
qc.ch(n,i)
for j in range(i-1,-1,-1):
qc.mcp(2*math.pi/2**(i-j+1),[n,j],i)
for k in range(n//2):
qc.cswap(n,k,n-1-k)
for i in range(n):
qc.cp(2*math.pi*a/2**(n-i),n,i)
for i in range(n-1,-1,-1):
qc.ch(n,i)
for j in range(i-1,-1,-1):
qc.mcp(-2*math.pi/2**(i-j+1),[n,j],i)
for k in range(n//2):
qc.cswap(n,k,n-1-k)
return qc
''' |
QPC004_B5 | A3636C48E5A68 | 6 | WA | 2114 ms | 162 MiB | '''python
from qiskit import QuantumCircuit,QuantumRegister
import math
def solve(n: int, a: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
qc.compose(add(n,2^n-L+a), inplace=True)
qc.compose(pack(n,2^n-L+a,2^n+a), inplace=True)
qc.compose(add(n,a), inplace=True)
return qc
def pack(n: int, s: int, t: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
qc.compose(add(n,-t), inplace=True)
qc.x(n)
qc.compose(add(n,-s), inplace=True)
qc.x(n)
return qc
def add(n,a):
qc = QuantumCircuit(n+1)
for i in range(n-1,-1,-1):
qc.ch(n,i)
for j in range(i-1,-1,-1):
qc.mcp(2*math.pi/2**(i-j+1),[n,j],i)
for k in range(n//2):
qc.cswap(n,k,n-1-k)
for i in range(n):
qc.cp(2*math.pi*a/2**(n-i),n,i)
for i in range(n-1,-1,-1):
qc.ch(n,i)
for j in range(i-1,-1,-1):
qc.mcp(-2*math.pi/2**(i-j+1),[n,j],i)
for k in range(n//2):
qc.cswap(n,k,n-1-k)
return qc
''' |
QPC004_B5 | A3636C48E5A68 | 7 | AC | 2443 ms | 165 MiB | '''python
from qiskit import QuantumCircuit,QuantumRegister
import math
def solve(n: int, a: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
qc.compose(add(n+1,2**n-L+a), inplace=True)
qc.compose(pack(n,2**n-L+a,2**n+a), inplace=True)
qc.compose(add(n+1,a), inplace=True)
return qc
def pack(n: int, s: int, t: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
qc.compose(add(n,-t).control(1),qubits = [n]+list(range(n)), inplace=True)
qc.x(n)
qc.compose(add(n,-s).control(1),qubits = [n]+list(range(n)), inplace=True)
qc.x(n)
return qc
def add(n,a):
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)
for k in range(n//2):
qc.swap(k,n-1-k)
for i in range(n):
qc.p(2*math.pi*a/2**(n-i),i)
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)
for k in range(n//2):
qc.swap(k,n-1-k)
return qc
''' |
QPC004_B5 | A38F6C5408787 | 1 | RE | 1649 ms | 157 MiB | '''python
from qiskit import QuantumCircuit
def add(qc, a):
for i in range(n):
if (a & (1 << i)):
n_not = n - i
for j in range(i+n_not-1, i-1, -1):
if j == i:
qc.x(j)
else:
qc.mcx(list(range(i, j)), j)
def subtract(qc, a):
for i in range(n-1, -1, -1):
if (a & (1 << i)):
n_not = n - i
for j in range(i, i+n_not):
if j == i:
qc.x(j)
else:
qc.mcx(list(range(i, j)), j)
def solve(n: int, a: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
subtract(qc, L-a)
add(qc, L)
return qc
''' |
QPC004_B5 | A38F6C5408787 | 2 | WA | 1730 ms | 162 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, a: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
def add(qc, a):
for i in range(n):
if (a & (1 << i)):
n_not = n - i
for j in range(i+n_not-1, i-1, -1):
if j == i:
qc.x(j)
else:
qc.mcx(list(range(i, j)), j)
def subtract(qc, a):
for i in range(n-1, -1, -1):
if (a & (1 << i)):
n_not = n - i
for j in range(i, i+n_not):
if j == i:
qc.x(j)
else:
qc.mcx(list(range(i, j)), j)
subtract(qc, L-a)
add(qc, L)
return qc
''' |
QPC004_B5 | A38F6C5408787 | 3 | WA | 1871 ms | 162 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, a: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
def add(qc, a):
for i in range(n):
if (a & (1 << i)):
n_not = n - i
for j in range(i+n_not-1, i-1, -1):
if j == i:
qc.x(j)
else:
qc.mcx(list(range(i, j)), j)
def subtract(qc, n, a):
for i in range(n-1, -1, -1):
if (a & (1 << i)):
n_not = n - i
for j in range(i, i+n_not):
if j == i:
qc.x(j)
else:
qc.mcx(list(range(i, j)), j)
subtract(qc, n+1, L-a)
add(qc, L)
return qc
''' |
QPC004_B5 | A38F6C5408787 | 4 | WA | 1814 ms | 162 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, a: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
def add(qc, n, a):
for i in range(n):
if (a & (1 << i)):
n_not = n - i
for j in range(i+n_not-1, i-1, -1):
if j == i:
qc.x(j)
else:
qc.mcx(list(range(i, j)), j)
def subtract(qc, n, a):
for i in range(n-1, -1, -1):
if (a & (1 << i)):
n_not = n - i
for j in range(i, i+n_not):
if j == i:
qc.x(j)
else:
qc.mcx(list(range(i, j)), j)
subtract(qc, n+1,L-a)
add(qc, n+1, L)
return qc
''' |
QPC004_B5 | A834A36AF9176 | 1 | WA | 1735 ms | 158 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, a: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Convert a to binary representation
a_bin = format(a, f'0{n}b') # Get binary representation of a with n bits
# Add a to k using controlled operations
for i in range(n):
if a_bin[i] == '1':
# Apply a series of CNOT gates to add a to k
# The control is on the i-th qubit of the input k
# The target is the (n+1)-th qubit (which is the auxiliary qubit)
qc.cx(i, n) # CNOT from k_i to auxiliary qubit
# Now we need to handle the modulo L operation
# If L is a power of 2, we can simply ignore the overflow
# If L is not a power of 2, we need to implement a more complex logic
# However, since L <= 2^n, we can assume that the addition will not exceed the range of n bits
# We will use a simple approach to ensure we do not exceed L
# This is a naive approach and may not be optimal for all cases
# We will check if the result exceeds L and apply a correction if necessary
# This is a placeholder for the correction logic
# In practice, we would need to implement a more complex logic to handle the modulo correctly
return qc
''' |
QPC004_B5 | ABBDEFBB7D433 | 1 | RE | 1498 ms | 157 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, a: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
b = 2 ** n - L + a
# add b
for i in range(n):
qc.x(i)
for j in range(10):
if (t // (2 ** j)) % 2 == 1:
qc.x(j)
for i in range(j, n - 1):
qc.mcx(list(range(j, i + 1)), i + 1)
for i in range(n):
qc.x(i)
qc.x(n)
for j in range(10):
if (L // (2 ** j)) % 2 == 1:
qc.cx(n, j)
for i in range(j, n - 1):
qc.mcx(list(range(j, i + 1)) + [n], i + 1)
return qc
''' |
QPC004_B5 | ABBDEFBB7D433 | 2 | RE | 1829 ms | 162 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, a: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
b = 2 ** n - L + a
# add b
for i in range(n):
qc.x(i)
for j in range(10):
if (b // (2 ** j)) % 2 == 1:
qc.x(j)
for i in range(j, n - 1):
qc.mcx(list(range(j, i + 1)), i + 1)
for i in range(n):
qc.x(i)
qc.x(n)
for j in range(10):
if (L // (2 ** j)) % 2 == 1:
qc.cx(n, j)
for i in range(j, n - 1):
qc.mcx(list(range(j, i + 1)) + [n], i + 1)
return qc
''' |
QPC004_B5 | AC39981D0E44F | 1 | WA | 2026 ms | 163 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import RYGate
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, a: int) -> QuantumCircuit:
k = QuantumRegister(n)
qc = QuantumCircuit(k)
# Write your code here:
qc.compose(qft(n), inplace=True)
for idx in range(n):
theta = 2 * a * math.pi * (2**idx) / (2**n)
qc.p(theta, k[idx])
qc.compose(qft(n).inverse(), inplace=True)
return qc
def controlled_add(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
qc.compose(qft(n), inplace=True)
for idx in range(n):
theta = 2 * a * math.pi * (2**idx) / (2**n)
qc.cp(theta, c, k[idx])
qc.compose(qft(n).inverse(), inplace=True)
return qc
def oracle_less(bitcount: int, n: int) -> QuantumCircuit:
regin, regout = QuantumRegister(bitcount), QuantumRegister(1)
qc = QuantumCircuit(regin, regout)
if n >= 2**bitcount:
qc.x(regout)
return qc
bitrep = bin(n)[2:].zfill(bitcount)[::-1]
masks = []
for idx in range(bitcount):
if bitrep[idx] == "1":
mask = ("0" + bitrep[idx + 1 :]).rjust(bitcount, "*")
masks.append(mask)
flipped = [False] * bitcount
for mask in masks:
controls = []
for idx in range(bitcount):
if mask[idx] == "*":
continue
controls.append(regin[idx])
if (mask[idx] == "0") != (flipped[idx]):
flipped[idx] = not flipped[idx]
qc.x(regin[idx])
if len(controls) != 0:
qc.mcx(controls, regout)
for idx in range(bitcount):
if flipped[idx]:
qc.x(regin[idx])
return qc
def lr_something(n: int, s: int, t: int) -> QuantumCircuit:
regin = QuantumRegister(n + 1)
qc = QuantumCircuit(regin)
# Write your code here:
anc_range = QuantumRegister(1)
anc_pred = QuantumRegister(1)
qc.add_register(anc_range)
qc.add_register(anc_pred)
# case 1
qc.compose(oracle_less(n + 1, s), [*regin, *anc_range], inplace=True)
qc.x(regin[-1])
qc.x(anc_range)
qc.ccx(regin[-1], anc_range, anc_pred)
qc.compose(controlled_add(n, -s), [*regin[:-1], *anc_pred], inplace=True)
qc.ccx(regin[-1], anc_range, anc_pred)
qc.x(anc_range)
qc.x(regin[-1])
# case 2
qc.compose(oracle_less(n + 1, t), [*regin, *anc_range], inplace=True)
qc.ccx(regin[-1], anc_range, anc_pred)
qc.compose(
controlled_add(n + 1, 2 ** (n + 1) - t), [*regin, *anc_pred], inplace=True
)
qc.ccx(regin[-1], anc_range, anc_pred)
qc.x(anc_range)
return qc
def solve(n: int, a: int, L: int) -> QuantumCircuit:
regin = QuantumRegister(n + 1)
qc = QuantumCircuit(regin)
# Write your code here:
anc_range = QuantumRegister(1)
qc.add_register(anc_range)
qc.compose(add(n+1, a), inplace=True)
qc.x(anc_range)
qc.compose(oracle_less(n+1, L), inplace=True)
qc.compose(controlled_add(n+1, -L), inplace=True)
qc.compose(oracle_less(n+1, L-a-1), inplace=True)
return qc
''' |
QPC004_B5 | AC39981D0E44F | 2 | AC | 2447 ms | 164 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import RYGate
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, a: int) -> QuantumCircuit:
k = QuantumRegister(n)
qc = QuantumCircuit(k)
# Write your code here:
qc.compose(qft(n), inplace=True)
for idx in range(n):
theta = 2 * a * math.pi * (2**idx) / (2**n)
qc.p(theta, k[idx])
qc.compose(qft(n).inverse(), inplace=True)
return qc
def controlled_add(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
qc.compose(qft(n), inplace=True)
for idx in range(n):
theta = 2 * a * math.pi * (2**idx) / (2**n)
qc.cp(theta, c, k[idx])
qc.compose(qft(n).inverse(), inplace=True)
return qc
def oracle_less(bitcount: int, n: int) -> QuantumCircuit:
regin, regout = QuantumRegister(bitcount), QuantumRegister(1)
qc = QuantumCircuit(regin, regout)
if n >= 2**bitcount:
qc.x(regout)
return qc
bitrep = bin(n)[2:].zfill(bitcount)[::-1]
masks = []
for idx in range(bitcount):
if bitrep[idx] == "1":
mask = ("0" + bitrep[idx + 1 :]).rjust(bitcount, "*")
masks.append(mask)
flipped = [False] * bitcount
for mask in masks:
controls = []
for idx in range(bitcount):
if mask[idx] == "*":
continue
controls.append(regin[idx])
if (mask[idx] == "0") != (flipped[idx]):
flipped[idx] = not flipped[idx]
qc.x(regin[idx])
if len(controls) != 0:
qc.mcx(controls, regout)
for idx in range(bitcount):
if flipped[idx]:
qc.x(regin[idx])
return qc
def lr_something(n: int, s: int, t: int) -> QuantumCircuit:
regin = QuantumRegister(n + 1)
qc = QuantumCircuit(regin)
# Write your code here:
anc_range = QuantumRegister(1)
anc_pred = QuantumRegister(1)
qc.add_register(anc_range)
qc.add_register(anc_pred)
# case 1
qc.compose(oracle_less(n + 1, s), [*regin, *anc_range], inplace=True)
qc.x(regin[-1])
qc.x(anc_range)
qc.ccx(regin[-1], anc_range, anc_pred)
qc.compose(controlled_add(n, -s), [*regin[:-1], *anc_pred], inplace=True)
qc.ccx(regin[-1], anc_range, anc_pred)
qc.x(anc_range)
qc.x(regin[-1])
# case 2
qc.compose(oracle_less(n + 1, t), [*regin, *anc_range], inplace=True)
qc.ccx(regin[-1], anc_range, anc_pred)
qc.compose(
controlled_add(n + 1, 2 ** (n + 1) - t), [*regin, *anc_pred], inplace=True
)
qc.ccx(regin[-1], anc_range, anc_pred)
qc.x(anc_range)
return qc
def solve(n: int, a: int, L: int) -> QuantumCircuit:
regin = QuantumRegister(n + 1)
qc = QuantumCircuit(regin)
# Write your code here:
anc_range1 = QuantumRegister(1)
anc_range2 = QuantumRegister(1)
anc_range3 = QuantumRegister(1)
qc.add_register(anc_range1)
qc.add_register(anc_range2)
qc.add_register(anc_range3)
qc.x(anc_range1)
qc.compose(oracle_less(n+1, L), [*regin, *anc_range2], inplace=True)
qc.compose(oracle_less(n+1, L-a), [*regin, *anc_range1], inplace=True)
qc.ccx(anc_range1, anc_range2, anc_range3)
qc.compose(add(n+1, a), inplace=True)
qc.compose(controlled_add(n+1, -L), [*regin, *anc_range3], inplace=True)
qc.ccx(anc_range1, anc_range2, anc_range3)
qc.x(anc_range2)
qc.x(regin[-1])
qc.ccx(regin[-1], anc_range2, anc_range3)
qc.x(regin[-1])
qc.compose(controlled_add(n+1, L), [*regin, *anc_range3], inplace=True)
qc.compose(oracle_less(n+1, 2**(n+1) + 1 - L), [*regin, *anc_range3], inplace=True)
qc.compose(oracle_less(n+1, L), [*regin, *anc_range3], inplace=True)
qc.x(anc_range2)
qc.compose(oracle_less(n+1, L), [*regin, *anc_range2], inplace=True)
qc.compose(oracle_less(n+1, L), [*regin, *anc_range1], inplace=True)
qc.compose(oracle_less(n+1, a), [*regin, *anc_range1], inplace=True)
qc.x(anc_range1)
return qc
''' |
QPC004_B5 | AD1257120C5DB | 1 | WA | 1717 ms | 162 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, a: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
return qc
''' |
QPC004_C1 | A03329382C5C2 | 1 | RE | 1835 ms | 158 MiB | '''python
def solve(a: int, L: int) -> list[int]:
result: list[int] = []
# Write your code here:
for _ in range(n):
result.append(a)
a *= a
a %= L
return result
''' |
QPC004_C1 | A03329382C5C2 | 2 | RE | 1756 ms | 157 MiB | '''python
def solve(a: int, L: int) -> list[int]:
result: list[int] = []
# Write your code here:
for _ in range(100001):
result.append(a)
a *= a
a %= L
return result
''' |
QPC004_C1 | A03329382C5C2 | 3 | AC | 2931 ms | 192 MiB | '''python
def solve(n: int, a: int, L: int) -> list[int]:
result: list[int] = []
# Write your code here:
for _ in range(n):
result.append(a)
a *= a
a %= L
return result
''' |
QPC004_C1 | A07C5B99F6451 | 1 | RE | 1481 ms | 157 MiB | '''python
def solve(a: int, L: int) -> list[int]:
result: list[int] = []
# Write your code here:
for i in range(n):
result.append(n)
return result
''' |
QPC004_C1 | A07C5B99F6451 | 2 | RE | 1650 ms | 158 MiB | '''python
def solve(a: int, L: int) -> list[int]:
result: list[int] = []
# Write your code here:
prev = a % L
result.append(a % L)
for i in range(1,n):
prev = prev * prev % L
result.append(prev)
return result
''' |
QPC004_C1 | A07C5B99F6451 | 3 | RE | 1783 ms | 158 MiB | '''python
def solve(a: int, L: int) -> list[int]:
result: list[int] = []
# Write your code here:
prev = a % L
result.append(a % L)
for i in range(1,10**5):
prev = prev * prev % L
result.append(prev)
return result
''' |
QPC004_C1 | A07C5B99F6451 | 4 | RE | 1648 ms | 158 MiB | '''python
def solve(a: int, L: int) -> list[int]:
result: list[int] = []
# Write your code here:
prev = a % L
result.append(a % L)
for i in range(1,10**5):
prev = prev * prev % L
result.append(prev)
return result
''' |
QPC004_C1 | A07C5B99F6451 | 5 | RE | 1614 ms | 158 MiB | '''python
def solve(a: int, L: int) -> list[int]:
result: list[int] = []
# Write your code here:
x = a % L
for i in range(n):
result.append(x)
x = x * x % L
return result
''' |
QPC004_C1 | A07C5B99F6451 | 6 | RE | 1677 ms | 158 MiB | '''python
def solve(a: int, L: int) -> list[int]:
result: list[int] = []
# Write your code here:
x = a % L
for i in range(100):
result.append(x)
x = x * x % L
return result
''' |
QPC004_C1 | A07C5B99F6451 | 7 | RE | 1557 ms | 157 MiB | '''python
def solve(a: int, L: int) -> list[int]:
result: list[int] = []
# Write your code here:
global n
x = a % L
for i in range(n):
result.append(x)
x = x * x % L
return result
''' |
QPC004_C1 | A110D66F2267D | 1 | AC | 2871 ms | 191 MiB | '''python
def solve(n: int, a: int, L: int) -> list[int]:
result: list[int] = [a]
# Write your code here:
for i in range(1, n):
result.append((result[i-1]*result[i-1]) % L)
return result
''' |
QPC004_C1 | A1AA3AFF00CDB | 1 | AC | 2789 ms | 192 MiB | '''python
def solve(n: int, a: int, L: int) -> list[int]:
result: list[int] = []
# Write your code here:
results = []
current = a % L # a^1 mod L
for _ in range(n):
results.append(current)
current = (current * current) % L # (a^(2^k) mod L) = (previous_result)^2 mod L
return results
return result
''' |
QPC004_C1 | A1B87C154C2AA | 1 | RE | 1921 ms | 158 MiB | '''python
def solve(a: int, L: int) -> list[int]:
result: list[int] = []
# Write your code here:
for k in range(n):
result.append((a**(2**k))%L)
return result
''' |
QPC004_C1 | A1B87C154C2AA | 2 | RE | 1620 ms | 157 MiB | '''python
def solve(a: int, L: int) -> list[int]:
result: list[int] = []
# Write your code here:
for i in range(k):
result.append((a**(2**k))%L)
return result
''' |
QPC004_C1 | A1B87C154C2AA | 3 | RE | 1465 ms | 158 MiB | '''python
def solve(a: int, L: int) -> list[int]:
result: list[int] = []
# Write your code here:
ans=a%L
for k in range(n):
result.append(ans)
ans=(ans*ans)%L
return result
''' |
QPC004_C1 | A1B87C154C2AA | 4 | AC | 2771 ms | 192 MiB | '''python
def solve(n: int, a: int, L: int) -> list[int]:
result: list[int] = []
# Write your code here:
ans=a%L
for k in range(n):
result.append(ans)
ans=(ans*ans)%L
return result
''' |
QPC004_C1 | A288E7C112CF8 | 1 | RE | 1462 ms | 141 MiB | '''python
def solve(n: int, a: int, L: int) -> list[int]:
result: list[int] = []
# Write your code here:
# [a, a^2, a^4, ...] (mod L)
x = a
for i in range(n):
result.add(x)
x = x * x % L
return result
''' |
QPC004_C1 | A288E7C112CF8 | 2 | AC | 2262 ms | 175 MiB | '''python
def solve(n: int, a: int, L: int) -> list[int]:
result: list[int] = []
# Write your code here:
# [a, a^2, a^4, ...] (mod L)
x = a
for i in range(n):
result.append(x)
x = x * x % L
return result
''' |
QPC004_C1 | A2C260FBB3DF5 | 1 | RE | 1665 ms | 158 MiB | '''python
def solve(a: int, L: int) -> list[int]:
result: list[int] = []
# Write your code here:
ans = a % L
result.append(ans)
for _ in range(n-1):
ans = (ans ** 2) % L
result.append(ans)
return result
''' |
QPC004_C1 | A2C260FBB3DF5 | 2 | RE | '''python
def solve(n:int a: int, L: int) -> list[int]:
result: list[int] = []
# Write your code here:
ans = a % L
result.append(ans)
for _ in range(n-1):
ans = (ans ** 2) % L
result.append(ans)
return result
''' | ||
QPC004_C1 | A2C260FBB3DF5 | 3 | AC | 2935 ms | 193 MiB | '''python
def solve(n:int, a: int, L: int) -> list[int]:
result: list[int] = []
# Write your code here:
ans = a % L
result.append(ans)
for _ in range(n-1):
ans = (ans ** 2) % L
result.append(ans)
return result
''' |
QPC004_C1 | A2DA7620EFC41 | 1 | WA | 1765 ms | 161 MiB | '''python
def solve(n: int, a: int, L: int) -> list[int]:
result = []
power = 1 # Start with a^(2^0) which is just 'a'
for _ in range(n):
result.append(power % L)
power = (power * power) % L # Squaring the power each time
return result
''' |
QPC004_C1 | A2DA7620EFC41 | 2 | RE | 1667 ms | 158 MiB | '''python
def solve(a: int, L: int) -> list[int]:
result: list[int] = []
# Calculate initial value a^1 mod L
current = a % L
# For each power of 2, square the previous result
# This efficiently calculates a^(2^k) mod L for k = 0,1,2,...,n-1
while len(result) < n:
result.append(current)
current = (current * current) % L
return result
''' |
QPC004_C1 | A2DA7620EFC41 | 3 | WA | 1659 ms | 157 MiB | '''python
def solve(a: int, L: int, n: int) -> list[int]:
result = []
power = 1 # a^0 = 1
for _ in range(n):
result.append(power % L)
power = (power * a) % L # Using modular multiplication to avoid overflow
return result
''' |
QPC004_C1 | A2DA7620EFC41 | 4 | RE | 1649 ms | 158 MiB | '''python
def solve(a: int, L: int) -> list[int]:
result = []
current = a # Start with a^1
for _ in range(n): # Compute up to a^(2^(n-1))
result.append(current % L)
current = pow(current, 2, L) # Efficient modular exponentiation
return result
''' |
QPC004_C1 | A2DA7620EFC41 | 5 | WA | 1797 ms | 158 MiB | '''python
def solve(a: int, L: int, n: int) -> list[int]:
result: list[int] = []
current = 1
for k in range(1, n):
current = (current * a) % L
result.append(current)
return result
# Example usage:
# a = 3
# L = 7
# n = 5
# print(solve(a, L, n)) # Output: [3, 2, 6, 4]
''' |
QPC004_C1 | A325389273CBE | 1 | RE | 2084 ms | 158 MiB | '''python
def solve(a: int, L: int) -> list[int]:
result: list[int] = []
# Write your code here:
x = a % L
for _ in range(n):
result.append(x)
x = (x * x) % L
return result
''' |
QPC004_C1 | A325389273CBE | 2 | RE | 1554 ms | 158 MiB | '''python
def solve(a: int, L: int) -> list[int]:
result: list[int] = []
# Write your code here:
x = a % L
for _ in range(n):
result.append(x)
x = (x * x) % L
return result
''' |
QPC004_C1 | A325389273CBE | 3 | RE | 1502 ms | 158 MiB | '''python
def solve(a: int, L: int) -> list[int]:
result: list[int] = []
# Write your code here:
n = int(input().strip())
x = a % L
for _ in range(n):
result.append(x)
x = (x * x) % L
return result
''' |
QPC004_C1 | A325389273CBE | 4 | RE | 1609 ms | 158 MiB | '''python
def solve(a: int, L: int) -> list[int]:
result: list[int] = []
# Write your code here:
i = 1
n = 0
while i < L:
i <<= 1
n += 1
x = a % L
for _ in range(n):
result.append(x)
x = (x * x) % L
return result
''' |
QPC004_C1 | A325389273CBE | 5 | RE | 1786 ms | 158 MiB | '''python
def solve(a: int, L: int) -> list[int]:
result: list[int] = []
# Write your code here:
i = 1
n = 0
while i < L:
i <<= 1
n += 1
n -= 1
x = a % L
for _ in range(n):
result.append(x)
x = (x * x) % L
return result
''' |
QPC004_C1 | A325389273CBE | 6 | RE | 1685 ms | 158 MiB | '''python
def solve(a: int, L: int) -> list[int]:
result: list[int] = []
# Write your code here:
i = 1
n = 0
while i < L:
i <<= 1
n += 1
n -= 1
x = a % L
for _ in range(n):
result.append(x)
x = (x * x) % L
return result
''' |
QPC004_C1 | A325389273CBE | 7 | RE | 1665 ms | 158 MiB | '''python
def solve(a: int, L: int) -> list[int]:
result: list[int] = []
# Write your code here:
i = 1
n = 0
while i < L:
i << 1
n += 1
n -= 1
x = a % L
for _ in range(n):
result.append(x)
x = (x * x) % L
return result
''' |
QPC004_C1 | A325389273CBE | 8 | RE | 1651 ms | 158 MiB | '''python
def gcd(x: int, y: int) -> int:
while y != 0:
x, y = y, x % y
return x
def solve(a: int, L: int) -> list[int]:
result: list[int] = []
# Write your code here:
i = 1
n = 0
while i < L:
i << 1
n += 1
n -= 1
while n > 0:
if gcd(n, a) == 1 and gcd(n, L) == 1:
break
n -= 1
x = a % L
for _ in range(n):
result.append(x)
x = (x * x) % L
return result
''' |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.