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_C3 | A3A70AB7DC992 | 1 | WA | 1801 ms | 160 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, a: int, L: int) -> QuantumCircuit:
x = QuantumRegister(n) # Register for x
y = QuantumRegister(n + 1) # Register for y (n + 1 qubits)
qc = QuantumCircuit(x, y)
# We will use a series of controlled additions to implement the oracle
for x_value in range(0, L):
# Calculate ax mod L
ax_mod_L = (a * x_value) % L
# Convert x_value to binary and apply controlled addition
for i in range(n):
if (x_value >> i) & 1: # If the i-th bit of x_value is 1
# We need to add ax_mod_L to y
# We will add ax_mod_L to y using controlled operations
for j in range(n + 1):
if (ax_mod_L >> j) & 1: # If the j-th bit of ax_mod_L is 1
# Apply a controlled NOT gate to add the j-th bit of ax_mod_L to y
qc.cx(x[i], y[j])
return qc
''' |
QPC004_C3 | A8675F16998A9 | 1 | RE | 1644 ms | 157 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, a: int, L: int) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(n + 1)
qc = QuantumCircuit(x, y)
# Write your code here:
for i in range(x):
if (a >> i) & 1: # Check if the i-th bit of 'a' is 1
for j in range(ny):
oracle.append(CXGate(), [x + j, i]) # Controlled-X from y to x
# Add the y register to the result (modular addition is handled implicitly by Qiskit)
for i in range(y):
oracle.append(CXGate(), [x + y + i, x + i]) # Controlled-X from output to x
# Apply the modular reduction (mod L) if L < 2^n
if L < 2**n:
# Implement modular reduction using subtraction and conditional flips
for i in range(n - 1, -1, -1):
if (L >> i) & 1: # Check if the i-th bit of L is 1
for j in range(i):
oracle.append(CXGate(), [x + y + j, x + y + i]) # Controlled-X from lower bits to i-th bit
return qc
''' |
QPC004_C3 | A99EBFB8A8CD1 | 1 | WA | 1928 ms | 161 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, a: int, L: int) -> QuantumCircuit:
# Create quantum registers for x and y
x, y = QuantumRegister(n), QuantumRegister(n + 1)
# Create quantum circuit
qc = QuantumCircuit(x, y)
# We need to implement: |x⟩|y⟩ → |x⟩|(y + ax) mod L⟩
# For each bit position i in x register
for i in range(n):
# Control on x[i] being 1
# If x[i] is 1, add (2^i * a) mod L to y
controlled_value = (pow(2, i) * a) % L
# Implement controlled modular addition
# Use standard quantum addition circuits with modulo L
# This typically involves quantum adders and modular reduction
for j in range(n):
if (controlled_value >> j) & 1:
qc.cx(x[i], y[j])
return qc
''' |
QPC004_C3 | A99EBFB8A8CD1 | 2 | UME | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import QFT
def modular_addition(qc, x, y, a, L, n):
""" Implements y -> (y + ax) mod L """
for i in range(n):
for j in range(n + 1):
if (a >> i) & 1:
qc.ccx(x[i], y[j], y[(j + (1 << i)) % (n + 1)])
# Modulo L enforcement
qc.append(QFT(n+1, do_swaps=False).inverse(), y)
qc.x(y[n])
qc.append(QFT(n+1, do_swaps=False), y)
return qc
def solve(n: int, a: int, L: int) -> QuantumCircuit:
x = QuantumRegister(n, name='x')
y = QuantumRegister(n + 1, name='y')
qc = QuantumCircuit(x, y)
# Implement modular addition oracle
modular_addition(qc, x, y, a, L, n)
return qc
''' | ||
QPC004_C3 | A99EBFB8A8CD1 | 3 | WA | 1942 ms | 162 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, a: int, L: int) -> QuantumCircuit:
x = QuantumRegister(n, 'x')
y = QuantumRegister(n + 1, 'y')
qc = QuantumCircuit(x, y)
# Apply controlled addition for each qubit in x
for i in range(n):
# Controlled addition of a * 2^i to y
for j in range(n + 1):
if (a * (1 << i)) & (1 << j):
qc.cx(x[i], y[j])
# Apply modulo L operation
# Since L <= 2^n, we can use a comparison and subtraction approach
# This is a simplified approach and may need refinement for specific cases
# For a full implementation, additional qubits and gates would be needed
return qc
''' |
QPC004_C3 | A99EBFB8A8CD1 | 4 | WA | 1620 ms | 162 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, a: int, L: int) -> QuantumCircuit:
# Create quantum registers for x and y
x = QuantumRegister(n, 'x')
y = QuantumRegister(n, 'y')
# Create quantum circuit
qc = QuantumCircuit(x, y)
# We need to perform (y + ax) mod L
# We can implement this using controlled additions
# For each qubit i in x register
for i in range(n):
# If the i-th bit of x is 1, we add a*2^i to y (controlled addition)
value = (a * (1 << i)) % L # Calculate the value to add (mod L)
# Break down value into binary for controlled additions
for j in range(n):
if value & (1 << j):
qc.cx(x[i], y[j])
# The modulo L operation is handled implicitly since:
# 1. L <= 2^n (from constraints)
# 2. We're already doing (a * 2^i) mod L in our addition
return qc
''' |
QPC004_C3 | A99EBFB8A8CD1 | 5 | WA | 1665 ms | 162 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, a: int, L: int) -> QuantumCircuit:
# Create quantum registers for x and y
x = QuantumRegister(n, 'x')
y = QuantumRegister(n + 1, 'y') # Note: n+1 qubits for y as per problem
# Create quantum circuit
qc = QuantumCircuit(x, y)
# For each bit i in x
for i in range(n):
# For each bit j in y
for j in range(n + 1):
# Apply controlled addition based on the pattern:
# If bit i in x is 1, we add corresponding value to y
if (a * (1 << i)) & (1 << j):
qc.cx(x[i], y[j])
return qc
''' |
QPC004_C3 | A99EBFB8A8CD1 | 6 | WA | 1988 ms | 161 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, a: int, L: int) -> QuantumCircuit:
# Create quantum registers for x and y
x = QuantumRegister(n, 'x')
y = QuantumRegister(n + 1, 'y')
# Create quantum circuit
qc = QuantumCircuit(x, y)
# Apply controlled addition for each qubit in x
for i in range(n):
# Controlled addition of a * 2^i to y
for j in range(n + 1):
if (a * (1 << i)) & (1 << j):
if j > 0: # Only apply when j > 0 as per example
qc.cx(x[i], y[j])
return qc
''' |
QPC004_C3 | A99EBFB8A8CD1 | 7 | WA | 1801 ms | 162 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, a: int, L: int) -> QuantumCircuit:
# Create quantum registers for x and y
x = QuantumRegister(n, 'x')
y = QuantumRegister(n + 1, 'y') # n+1 qubits for y register
# Create quantum circuit
qc = QuantumCircuit(x, y)
# Apply controlled addition for each qubit in x
for i in range(n):
for j in range(n + 1):
# Following exactly the condition from the example
if (a * (1 << i)) & (1 << j):
qc.cx(x[i], y[j])
return qc
''' |
QPC004_C3 | A99EBFB8A8CD1 | 8 | WA | 1732 ms | 160 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, a: int, L: int) -> QuantumCircuit:
# Initialize registers
x = QuantumRegister(n, 'x')
y = QuantumRegister(n, 'y') # Note: Problem shows n qubits for y
qc = QuantumCircuit(x, y)
# Controlled addition of ax mod L to y
# The key is to apply controlled-X gates based on the binary representation
# of (a * x) mod L
# For each control qubit in x
for i in range(n):
# For each target qubit in y
for j in range(n):
# The condition from example: if this bit position should flip
if (a * (1 << i)) & (1 << j):
# Apply controlled-NOT from x[i] to y[j]
qc.cx(x[i], y[j])
return qc
''' |
QPC004_C3 | A99EBFB8A8CD1 | 9 | WA | 1753 ms | 163 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, a: int, L: int) -> QuantumCircuit:
"""
Creates a quantum circuit that performs modular multiplication: |x⟩|y⟩ → |x⟩|y ⊕ (ax mod L)⟩
Args:
n (int): Number of qubits in each register
a (int): Multiplication factor
L (int): Modulus
Returns:
QuantumCircuit: Circuit implementing the modular multiplication
"""
# Initialize registers
x = QuantumRegister(n, 'x')
y = QuantumRegister(n, 'y')
qc = QuantumCircuit(x, y)
# For each possible value of x
for x_val in range(1 << n):
# Calculate (a * x_val) mod L
result = (a * x_val) % L
# For each target qubit in y
for j in range(n):
# If this bit should be flipped for this x_val
if result & (1 << j):
# Create control pattern for this x_val
for i in range(n):
# Apply X or CX gates based on x_val bits
if x_val & (1 << i):
qc.cx(x[i], y[j])
else:
# If control bit should be 0, add X gates before and after
qc.x(x[i])
qc.cx(x[i], y[j])
qc.x(x[i])
return qc
''' |
QPC004_C3 | A99EBFB8A8CD1 | 10 | WA | 1626 ms | 162 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, a: int, L: int) -> QuantumCircuit:
"""
Creates a quantum circuit that performs modular multiplication: |x⟩|y⟩ → |x⟩|y ⊕ (ax mod L)⟩
Args:
n (int): Number of qubits in each register
a (int): Multiplication factor
L (int): Modulus
Returns:
QuantumCircuit: Circuit implementing the modular multiplication
"""
# Initialize registers
x = QuantumRegister(n, 'x')
y = QuantumRegister(n, 'y')
qc = QuantumCircuit(x, y)
# Create table of all possible values and their modular products
for x_val in range(1 << n):
result = (a * x_val) % L
# For each bit in result
for j in range(n):
if result & (1 << j):
# Create control pattern
controls = []
neg_controls = []
# Determine which qubits should be controlled on 0 vs 1
for i in range(n):
if x_val & (1 << i):
controls.append(i)
else:
neg_controls.append(i)
# Apply X gates before controlled operation
for i in neg_controls:
qc.x(x[i])
# Apply multi-controlled X gate
if len(controls + neg_controls) > 0:
for control in controls + neg_controls:
qc.cx(x[control], y[j])
# Restore X gates after controlled operation
for i in neg_controls:
qc.x(x[i])
return qc
''' |
QPC004_C3 | AC58B559AAF5B | 1 | WA | 1594 ms | 161 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, a: int, L: int) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(n + 1)
qc = QuantumCircuit(x, y)
# Write your code here:
for i in range(n):
for j in range(n+1):
if (a >> i) & 1:
qc.cx(x[i], y[j]) # CNOTゲートでx[i]に基づいてy[j]に操作を行う
return qc
''' |
QPC004_C3 | ADE5FF0F4C260 | 1 | RE | 1575 ms | 159 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, control_count: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(control_count)
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.mcp(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 controlled_oracle_less(bitcount: int, n: int, control_count: int) -> QuantumCircuit:
regin, regout = QuantumRegister(bitcount), QuantumRegister(1)
control = QuantumRegister(control_count)
qc = QuantumCircuit(regin, regout, control)
if n >= 2**bitcount:
qc.mcx(control, 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:
regin_controls = []
for idx in range(bitcount):
if mask[idx] == "*":
continue
regin_controls.append(regin[idx])
if (mask[idx] == "0") != (flipped[idx]):
flipped[idx] = not flipped[idx]
qc.mcx(control, regin[idx])
if len(regin_controls) != 0:
qc.mcx([*regin_controls, *control], regout)
for idx in range(bitcount):
if flipped[idx]:
qc.x(regin[idx])
return qc
def cmodadd(n: int, a: int, L: int) -> QuantumCircuit:
"""in(n+1), control, anc1, anc2, anc3"""
regin = QuantumRegister(n + 1)
control = QuantumRegister(1)
qc = QuantumCircuit(regin, control)
# 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.cx(control, anc_range1)
qc.compose(
controlled_oracle_less(n + 1, L, 1),
[*regin, *anc_range2, *control],
inplace=True,
)
qc.compose(
controlled_oracle_less(n + 1, L - a, 1),
[*regin, *anc_range1, *control],
inplace=True,
)
qc.mcx([*control, anc_range1, anc_range2], anc_range3)
qc.compose(controlled_add(n + 1, a, 1), [*regin, *control], inplace=True)
qc.compose(
controlled_add(n + 1, -L, 2), [*regin, *anc_range3, *control], inplace=True
)
qc.mcx([anc_range1, anc_range2, *control], anc_range3)
qc.cx(control, anc_range2)
qc.cx(control, regin[-1])
qc.mcx([regin[-1], *anc_range2, *control], anc_range3)
qc.cx(control, regin[-1])
qc.compose(
controlled_add(n + 1, L, 2), [*regin, *anc_range3, *control], inplace=True
)
qc.compose(
controlled_oracle_less(n + 1, 2 ** (n + 1) + 1 - L, 1),
[*regin, *anc_range3, *control],
inplace=True,
)
qc.compose(controlled_oracle_less(n + 1, L, 1), [*regin, *anc_range3,*control], inplace=True)
qc.cx(control, anc_range2)
qc.compose(controlled_oracle_less(n + 1, L, 1), [*regin, *anc_range2,*control], inplace=True)
qc.compose(controlled_oracle_less(n + 1, L, 1), [*regin, *anc_range1,*control], inplace=True)
qc.compose(controlled_oracle_less(n + 1, a, 1), [*regin, *anc_range1,*control], inplace=True)
qc.cx(control, anc_range1)
return qc
def modfma(n: int, a: int, L: int) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(n + 1)
qc = QuantumCircuit(x, y)
# Write your code here:
ancs = QuantumRegister(3)
qc.add_register(ancs)
for idx in range(n):
add = pow(a, 2**idx, L)
qc.compose(cmodadd(n, add, L), [*y, x[idx], *ancs], inplace=True)
return qc
''' |
QPC004_C3 | ADE5FF0F4C260 | 2 | RE | 1598 ms | 159 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, control_count: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(control_count)
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.mcp(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 controlled_oracle_less(bitcount: int, n: int, control_count: int) -> QuantumCircuit:
regin, regout = QuantumRegister(bitcount), QuantumRegister(1)
control = QuantumRegister(control_count)
qc = QuantumCircuit(regin, regout, control)
if n >= 2**bitcount:
qc.mcx(control, 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:
regin_controls = []
for idx in range(bitcount):
if mask[idx] == "*":
continue
regin_controls.append(regin[idx])
if (mask[idx] == "0") != (flipped[idx]):
flipped[idx] = not flipped[idx]
qc.mcx(control, regin[idx])
if len(regin_controls) != 0:
qc.mcx([*regin_controls, *control], regout)
for idx in range(bitcount):
if flipped[idx]:
qc.mcx(control, regin[idx])
return qc
def modadd(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, 1), [*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, 1), [*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
def cmodadd(n: int, a: int, L: int) -> QuantumCircuit:
"""in(n+1), control, anc1, anc2, anc3"""
regin = QuantumRegister(n + 1)
control = QuantumRegister(1)
qc = QuantumCircuit(regin, control)
# 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.cx(control, anc_range1)
qc.compose(
controlled_oracle_less(n + 1, L, 1),
[*regin, *anc_range2, *control],
inplace=True,
)
qc.compose(
controlled_oracle_less(n + 1, L - a, 1),
[*regin, *anc_range1, *control],
inplace=True,
)
qc.mcx([*control, anc_range1, anc_range2], anc_range3)
qc.compose(controlled_add(n + 1, a, 1), [*regin, *control], inplace=True)
qc.compose(
controlled_add(n + 1, -L, 2), [*regin, *anc_range3, *control], inplace=True
)
qc.mcx([anc_range1, anc_range2, *control], anc_range3)
qc.cx(control, anc_range2)
qc.cx(control, regin[-1])
qc.mcx([regin[-1], *anc_range2, *control], anc_range3)
qc.cx(control, regin[-1])
qc.compose(
controlled_add(n + 1, L, 2), [*regin, *anc_range3, *control], inplace=True
)
qc.compose(
controlled_oracle_less(n + 1, 2 ** (n + 1) + 1 - L, 1),
[*regin, *anc_range3, *control],
inplace=True,
)
qc.compose(
controlled_oracle_less(n + 1, L, 1),
[*regin, *anc_range3, *control],
inplace=True,
)
qc.cx(control, anc_range2)
qc.compose(
controlled_oracle_less(n + 1, L, 1),
[*regin, *anc_range2, *control],
inplace=True,
)
qc.compose(
controlled_oracle_less(n + 1, L, 1),
[*regin, *anc_range1, *control],
inplace=True,
)
qc.compose(
controlled_oracle_less(n + 1, a, 1),
[*regin, *anc_range1, *control],
inplace=True,
)
qc.cx(control, anc_range1)
return qc
def modfma(n: int, a: int, L: int) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(n + 1)
qc = QuantumCircuit(x, y)
# Write your code here:
ancs = QuantumRegister(3)
qc.add_register(ancs)
for idx in range(n):
add = pow(a, 2**idx, L)
qc.compose(cmodadd(n, add, L), [*y, x[idx], *ancs], inplace=True)
return qc
''' |
QPC004_C3 | ADE5FF0F4C260 | 3 | RE | 1527 ms | 160 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, control_count: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(control_count)
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.mcp(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 controlled_oracle_less(bitcount: int, n: int, control_count: int) -> QuantumCircuit:
regin, regout = QuantumRegister(bitcount), QuantumRegister(1)
control = QuantumRegister(control_count)
qc = QuantumCircuit(regin, regout, control)
if n >= 2**bitcount:
qc.mcx(control, 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:
regin_controls = []
for idx in range(bitcount):
if mask[idx] == "*":
continue
regin_controls.append(regin[idx])
if (mask[idx] == "0") != (flipped[idx]):
flipped[idx] = not flipped[idx]
qc.mcx(control, regin[idx])
if len(regin_controls) != 0:
qc.mcx([*regin_controls, *control], regout)
for idx in range(bitcount):
if flipped[idx]:
qc.mcx(control, regin[idx])
return qc
def modadd(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, 1), [*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, 1), [*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
def cmodadd(n: int, a: int, L: int) -> QuantumCircuit:
"""in(n+1), control, anc1, anc2, anc3"""
regin = QuantumRegister(n + 1)
control = QuantumRegister(1)
qc = QuantumCircuit(regin, control)
# 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.cx(control, anc_range1)
qc.compose(
controlled_oracle_less(n + 1, L, 1),
[*regin, *anc_range2, *control],
inplace=True,
)
qc.compose(
controlled_oracle_less(n + 1, L - a, 1),
[*regin, *anc_range1, *control],
inplace=True,
)
qc.mcx([*control, anc_range1, anc_range2], anc_range3)
qc.compose(controlled_add(n + 1, a, 1), [*regin, *control], inplace=True)
qc.compose(
controlled_add(n + 1, -L, 2), [*regin, *anc_range3, *control], inplace=True
)
qc.mcx([anc_range1, anc_range2, *control], anc_range3)
qc.cx(control, anc_range2)
qc.cx(control, regin[-1])
qc.mcx([regin[-1], *anc_range2, *control], anc_range3)
qc.cx(control, regin[-1])
qc.compose(
controlled_add(n + 1, L, 2), [*regin, *anc_range3, *control], inplace=True
)
qc.compose(
controlled_oracle_less(n + 1, 2 ** (n + 1) + 1 - L, 1),
[*regin, *anc_range3, *control],
inplace=True,
)
qc.compose(
controlled_oracle_less(n + 1, L, 1),
[*regin, *anc_range3, *control],
inplace=True,
)
qc.cx(control, anc_range2)
qc.compose(
controlled_oracle_less(n + 1, L, 1),
[*regin, *anc_range2, *control],
inplace=True,
)
qc.compose(
controlled_oracle_less(n + 1, L, 1),
[*regin, *anc_range1, *control],
inplace=True,
)
qc.compose(
controlled_oracle_less(n + 1, a, 1),
[*regin, *anc_range1, *control],
inplace=True,
)
qc.cx(control, anc_range1)
return qc
def modfma(n: int, a: int, L: int) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(n + 1)
qc = QuantumCircuit(x, y)
# Write your code here:
ancs = QuantumRegister(3)
qc.add_register(ancs)
for idx in range(n):
add = a * (2**idx) % L
qc.compose(cmodadd(n, add, L), [*y, x[idx], *ancs], inplace=True)
return qc
''' |
QPC004_C3 | ADE5FF0F4C260 | 4 | AC | 2773 ms | 167 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, control_count: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(control_count)
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.mcp(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 controlled_oracle_less(bitcount: int, n: int, control_count: int) -> QuantumCircuit:
regin, regout = QuantumRegister(bitcount), QuantumRegister(1)
control = QuantumRegister(control_count)
qc = QuantumCircuit(regin, regout, control)
if n >= 2**bitcount:
qc.mcx(control, 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:
regin_controls = []
for idx in range(bitcount):
if mask[idx] == "*":
continue
regin_controls.append(regin[idx])
if (mask[idx] == "0") != (flipped[idx]):
flipped[idx] = not flipped[idx]
qc.mcx(control, regin[idx])
if len(regin_controls) != 0:
qc.mcx([*regin_controls, *control], regout)
for idx in range(bitcount):
if flipped[idx]:
qc.mcx(control, regin[idx])
return qc
def modadd(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, 1), [*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, 1), [*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
def cmodadd(n: int, a: int, L: int) -> QuantumCircuit:
"""in(n+1), control, anc1, anc2, anc3"""
regin = QuantumRegister(n + 1)
control = QuantumRegister(1)
qc = QuantumCircuit(regin, control)
# 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.cx(control, anc_range1)
qc.compose(
controlled_oracle_less(n + 1, L, 1),
[*regin, *anc_range2, *control],
inplace=True,
)
qc.compose(
controlled_oracle_less(n + 1, L - a, 1),
[*regin, *anc_range1, *control],
inplace=True,
)
qc.mcx([*control, anc_range1, anc_range2], anc_range3)
qc.compose(controlled_add(n + 1, a, 1), [*regin, *control], inplace=True)
qc.compose(
controlled_add(n + 1, -L, 2), [*regin, *anc_range3, *control], inplace=True
)
qc.mcx([anc_range1, anc_range2, *control], anc_range3)
qc.cx(control, anc_range2)
qc.cx(control, regin[-1])
qc.mcx([regin[-1], *anc_range2, *control], anc_range3)
qc.cx(control, regin[-1])
qc.compose(
controlled_add(n + 1, L, 2), [*regin, *anc_range3, *control], inplace=True
)
qc.compose(
controlled_oracle_less(n + 1, 2 ** (n + 1) + 1 - L, 1),
[*regin, *anc_range3, *control],
inplace=True,
)
qc.compose(
controlled_oracle_less(n + 1, L, 1),
[*regin, *anc_range3, *control],
inplace=True,
)
qc.cx(control, anc_range2)
qc.compose(
controlled_oracle_less(n + 1, L, 1),
[*regin, *anc_range2, *control],
inplace=True,
)
qc.compose(
controlled_oracle_less(n + 1, L, 1),
[*regin, *anc_range1, *control],
inplace=True,
)
qc.compose(
controlled_oracle_less(n + 1, a, 1),
[*regin, *anc_range1, *control],
inplace=True,
)
qc.cx(control, anc_range1)
return qc
def solve(n: int, a: int, L: int) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(n + 1)
qc = QuantumCircuit(x, y)
# Write your code here:
ancs = QuantumRegister(3)
qc.add_register(ancs)
for idx in range(n):
add = a * (2**idx) % L
qc.compose(cmodadd(n, add, L), [*y, x[idx], *ancs], inplace=True)
return qc
''' |
QPC004_C3 | ADF02875A7997 | 1 | TLE | 3000 ms | 173 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def solve(n: int, a: int, L: int) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(n + 1)
qc = QuantumCircuit(x, y)
# Write your code here:
for i in range(n):
qc.compose(add_mod(n,(a*2**i)%L,L).control(1),qubits = [i]+list(range(n,2*n+1)), inplace=True)
return qc
def add_mod(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_C3 | ADF02875A7997 | 2 | TLE | 3000 ms | 172 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def solve(n: int, a: int, L: int) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(n + 1)
qc = QuantumCircuit(x, y)
# Write your code here:
for i in range(n):
qc.compose(add_mod(n,(a*2**i)%L,L).control(1),qubits = [i]+list(range(n,2*n+1)), inplace=True)
return qc
def add_mod(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_C3 | ADF02875A7997 | 3 | AC | 3000 ms | 172 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def solve(n: int, a: int, L: int) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(n + 1)
qc = QuantumCircuit(x, y)
# Write your code here:
for i in range(n):
qc.compose(add_mod(n,(a*2**i)%L,L).control(1),qubits = [i]+list(range(n,2*n+1)), inplace=True)
return qc
def add_mod(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(qft(n),qubits = list(range(n)), inplace=True)
qc.compose(shift(n,-t).control(1),qubits = [n]+list(range(n)), inplace=True)
qc.x(n)
qc.compose(shift(n,-s).control(1),qubits = [n]+list(range(n)), inplace=True)
qc.x(n)
qc.compose(iqft(n),qubits = list(range(n)), inplace=True)
return qc
def add(n,a):
qc = QuantumCircuit(n)
qc.compose(qft(n), inplace=True)
qc.compose(shift(n,a), inplace=True)
qc.compose(iqft(n), inplace=True)
return qc
def qft(n):
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)
return qc
def iqft(n):
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)
return qc
def shift(n,a):
qc = QuantumCircuit(n)
for i in range(n):
qc.p(2*math.pi*a/2**(n-i),i)
return qc
''' |
QPC004_C4 | A39B0C341BDED | 1 | UME | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import QFT
def solve(n: int, a: int, L: int) -> QuantumCircuit:
# Create quantum registers
x, y = QuantumRegister(n), QuantumRegister(n + 1)
qc = QuantumCircuit(x, y)
# Step 1: Apply QFT to input register
qft = QFT(n, do_swaps=False)
qc.append(qft, x[:])
# Step 2: Phase rotations based on modular multiplication
for i in range(n):
for j in range(i + 1):
# Calculate phase for controlled rotation
phase = (2 * (a * 2**(i-j)) % L) / L
# Add controlled phase rotation
qc.cp(2 * pi * phase, x[j], y[i])
# Step 3: Apply inverse QFT
qft_dagger = QFT(n, do_swaps=False).inverse()
qc.append(qft_dagger, x[:])
return qc
''' | ||
QPC004_C4 | A39B0C341BDED | 2 | WA | 1784 ms | 162 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from math import pi
def qft(qc: QuantumCircuit, q: QuantumRegister, n: int):
"""Implement QFT from scratch"""
for i in range(n):
qc.h(q[i])
for j in range(i+1, n):
qc.cp(pi/2**(j-i), q[j], q[i])
def inverse_qft(qc: QuantumCircuit, q: QuantumRegister, n: int):
"""Implement inverse QFT from scratch"""
for i in range(n-1, -1, -1):
for j in range(n-1, i, -1):
qc.cp(-pi/2**(j-i), q[j], q[i])
qc.h(q[i])
def solve(n: int, a: int, L: int) -> QuantumCircuit:
# Create quantum registers
x, y = QuantumRegister(n), QuantumRegister(n + 1)
qc = QuantumCircuit(x, y)
# Step 1: Apply custom QFT to input register
qft(qc, x, n)
# Step 2: Phase rotations based on modular multiplication
for i in range(n):
for j in range(i + 1):
# Calculate phase for controlled rotation
phase = (2 * (a * 2**(i-j)) % L) / L
qc.cp(2 * pi * phase, x[j], y[i])
# Step 3: Apply custom inverse QFT
inverse_qft(qc, x, n)
return qc
''' |
QPC004_C4 | A39B0C341BDED | 3 | RE | 1764 ms | 158 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def qft(n: int, inverse=False):
"""Manually implement the Quantum Fourier Transform (QFT)"""
qc = QuantumCircuit(n)
for j in range(n):
qc.h(j)
for k in range(j + 1, n):
qc.cp(-np.pi / 2**(k - j), k, j) # Controlled phase gate
if inverse:
qc = qc.inverse() # Take inverse if needed
return qc
def modular_addition(n: int, a: int):
"""Implement modular addition using QFT and controlled phase gates."""
qc = QuantumCircuit(n)
# Apply QFT
qc.append(qft(n), range(n))
# Apply phase shifts to encode addition
for i in range(n):
if (a >> i) & 1: # Check if bit i of 'a' is set
qc.p(np.pi / 2**(n - i - 1), i)
# Apply inverse QFT
qc.append(qft(n, inverse=True), range(n))
return qc
def solve(n: int, a: int) -> QuantumCircuit:
"""Controlled constant addition circuit."""
k_reg = QuantumRegister(n, name='k')
c_reg = QuantumRegister(1, name='c') # Control qubit
qc = QuantumCircuit(k_reg, c_reg)
# Controlled modular addition: Apply only if control qubit is 1
controlled_add = modular_addition(n, a).control(1)
qc.append(controlled_add, [c_reg[0]] + k_reg[:])
return qc
''' |
QPC004_C4 | A39B0C341BDED | 4 | RE | 1656 ms | 157 MiB | '''python
import numpy as np
from qiskit import QuantumCircuit, QuantumRegister
def manual_qft(n):
"""Constructs the Quantum Fourier Transform (QFT) without using the Qiskit QFT library."""
qc = QuantumCircuit(n)
for j in range(n):
qc.h(j)
for k in range(j + 1, n):
qc.cp(np.pi / 2**(k - j), k, j)
return qc
def manual_iqft(n):
"""Constructs the Inverse Quantum Fourier Transform (IQFT) manually."""
return manual_qft(n).inverse()
def controlled_modular_addition(n, a):
"""Implements controlled modular addition using QFT and controlled phase shifts."""
qc = QuantumCircuit(n + 1) # +1 for the control qubit
# Apply QFT to the lower n qubits
qft_circuit = manual_qft(n)
qc.append(qft_circuit, range(n))
# Apply controlled phase shifts based on 'a'
for i in range(n):
if (a >> i) & 1: # Check if bit i of 'a' is set
qc.cp(np.pi / 2**(n - i - 1), n, i) # Controlled phase shift by control qubit
# Apply inverse QFT
iqft_circuit = manual_iqft(n)
qc.append(iqft_circuit, range(n))
return qc
def solve(n: int, a: int) -> QuantumCircuit:
"""Implements the Controlled Constant Addition circuit while following constraints."""
k_reg = QuantumRegister(n, name='k') # Register for 'k'
c_reg = QuantumRegister(1, name='c') # Control qubit
qc = QuantumCircuit(k_reg, c_reg)
# Controlled addition: Applied only if c = 1
controlled_add = controlled_modular_addition(n, a).to_gate(label="C-ADD(a)").control(1)
qc.append(controlled_add, [c_reg[0]] + k_reg[:])
return qc
''' |
QPC004_C4 | A39B0C341BDED | 5 | RE | 2016 ms | 158 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def controlled_modular_addition(n, a):
"""Implements controlled modular addition using bitwise operations."""
qc = QuantumCircuit(n + 1) # Extra qubit for control
for i in range(n):
if (a >> i) & 1: # If the i-th bit of 'a' is 1
qc.cx(n, i) # Controlled-X: If control is 1, flip bit i of 'k'
return qc
def solve(n: int, a: int) -> QuantumCircuit:
"""Constructs an optimized controlled modular addition circuit."""
k_reg = QuantumRegister(n, name='k') # Register for k
c_reg = QuantumRegister(1, name='c') # Control qubit
qc = QuantumCircuit(k_reg, c_reg)
# Apply controlled modular addition (bitwise controlled-X operations)
controlled_add = controlled_modular_addition(n, a).to_gate(label="C-ADD(a)").control(1)
qc.append(controlled_add, [c_reg[0]] + k_reg[:])
return qc
''' |
QPC004_C4 | A49D000568755 | 1 | AC | 2455 ms | 170 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, control_count: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(control_count)
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.mcp(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 controlled_oracle_less(bitcount: int, n: int, control_count: int) -> QuantumCircuit:
regin, regout = QuantumRegister(bitcount), QuantumRegister(1)
control = QuantumRegister(control_count)
qc = QuantumCircuit(regin, regout, control)
if n >= 2**bitcount:
qc.mcx(control, 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:
regin_controls = []
for idx in range(bitcount):
if mask[idx] == "*":
continue
regin_controls.append(regin[idx])
if (mask[idx] == "0") != (flipped[idx]):
flipped[idx] = not flipped[idx]
qc.mcx(control, regin[idx])
if len(regin_controls) != 0:
qc.mcx([*regin_controls, *control], regout)
for idx in range(bitcount):
if flipped[idx]:
qc.mcx(control, regin[idx])
return qc
def modadd(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, 1), [*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, 1), [*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
def cmodadd(n: int, a: int, L: int) -> QuantumCircuit:
"""in(n+1), control, anc1, anc2, anc3"""
regin = QuantumRegister(n + 1)
control = QuantumRegister(1)
qc = QuantumCircuit(regin, control)
# 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.cx(control, anc_range1)
qc.compose(
controlled_oracle_less(n + 1, L, 1),
[*regin, *anc_range2, *control],
inplace=True,
)
qc.compose(
controlled_oracle_less(n + 1, L - a, 1),
[*regin, *anc_range1, *control],
inplace=True,
)
qc.mcx([*control, anc_range1, anc_range2], anc_range3)
qc.compose(controlled_add(n + 1, a, 1), [*regin, *control], inplace=True)
qc.compose(
controlled_add(n + 1, -L, 2), [*regin, *anc_range3, *control], inplace=True
)
qc.mcx([anc_range1, anc_range2, *control], anc_range3)
qc.cx(control, anc_range2)
qc.cx(control, regin[-1])
qc.mcx([regin[-1], *anc_range2, *control], anc_range3)
qc.cx(control, regin[-1])
qc.compose(
controlled_add(n + 1, L, 2), [*regin, *anc_range3, *control], inplace=True
)
qc.compose(
controlled_oracle_less(n + 1, 2 ** (n + 1) + 1 - L, 1),
[*regin, *anc_range3, *control],
inplace=True,
)
qc.compose(
controlled_oracle_less(n + 1, L, 1),
[*regin, *anc_range3, *control],
inplace=True,
)
qc.cx(control, anc_range2)
qc.compose(
controlled_oracle_less(n + 1, L, 1),
[*regin, *anc_range2, *control],
inplace=True,
)
qc.compose(
controlled_oracle_less(n + 1, L, 1),
[*regin, *anc_range1, *control],
inplace=True,
)
qc.compose(
controlled_oracle_less(n + 1, a, 1),
[*regin, *anc_range1, *control],
inplace=True,
)
qc.cx(control, anc_range1)
return qc
def cmodfma(n: int, a: int, L: int) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(n + 1)
qc = QuantumCircuit(x, y)
# Write your code here:
ancs = QuantumRegister(3)
qc.add_register(ancs)
for idx in range(n):
add = a * (2**idx) % L
qc.compose(cmodadd(n, add, L), [*y, x[idx], *ancs], inplace=True)
return qc
def solve(n: int, a: int, L: int) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(n + 1)
qc = QuantumCircuit(x, y)
# Write your code here:
ancs = QuantumRegister(3)
qc.add_register(ancs)
qc.compose(cmodfma(n, a, L), inplace=True)
for idx in range(n):
qc.swap(x[idx], y[idx])
qc.compose(cmodfma(n, -pow(a, -1, L), L), inplace=True)
return qc
''' |
QPC004_C4 | A841677C41D28 | 1 | WA | 1933 ms | 160 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, a: int, L: int) -> QuantumCircuit:
x = QuantumRegister(n) # Register for input x
y = QuantumRegister(n + 1) # Register for output ax mod L
qc = QuantumCircuit(x, y)
# We will implement the multiplication by a and then take mod L
# We will use a series of controlled additions to achieve this.
# We need to add a * x to the output register
for i in range(n):
if (a >> i) & 1: # Check if the i-th bit of a is set
# We will add x to the output register controlled by the i-th qubit of x
for j in range(n + 1):
# Controlled addition of x to y
qc.cx(x[i], y[j]) # Controlled-X gate to add x to y
# Now we need to apply the modulo operation
# We will use a series of Toffoli gates to implement the modulo operation
# This is a simplified version and may not be the most efficient way to implement mod L
# but it will work for small values of n and L.
# We will use a classical approach to implement the modulo operation
# by checking if the value exceeds L and then subtracting L if necessary.
# This is a naive implementation and may need optimization for larger values.
# For simplicity, we will assume L is a power of 2, which is true for the given constraints.
# We will use the last qubit of y to store the carry for the modulo operation.
# Example: if L = 2^n, we can simply ignore the overflow bits.
# This is a placeholder for the actual modulo operation.
# In practice, you would need to implement a more complex circuit to handle arbitrary L.
return qc
''' |
QPC004_C4 | A8FFDD8E2F3A2 | 1 | TLE | 3000 ms | 178 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def solve(n: int, a: int, L: int) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(n + 1)
qc = QuantumCircuit(x, y)
# Write your code here:
qc.compose(add_multi_mod(n,a,L),inplace=True)
gcd,x,y = extended_euclidean(a,L)
a_inv = x % L
#print(a_inv)
for i in range(n):
qc.cx(i,n+i)
qc.cx(n+i,i)
qc.cx(i,n+i)
qc.compose(add_multi_mod(n,L-a_inv,L),inplace=True)
return qc
def extended_euclidean(a: int, b: int) -> tuple[int, int, int]:
# when b == 0:
if b == 0:
return a, 1, 0
# recursive step
gcd, x1, y1 = extended_euclidean(b, a % b)
# update x and y
x = y1
y = x1 - (a // b) * y1
return gcd, x, y
def add_multi_mod(n: int, a: int, L: int) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(n + 1)
qc = QuantumCircuit(x, y)
# Write your code here:
for i in range(n):
qc.compose(add_mod(n,(a*2**i)%L,L).control(1),qubits = [i]+list(range(n,2*n+1)), inplace=True)
return qc
def add_mod(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(qft(n),qubits = list(range(n)), inplace=True)
qc.compose(shift(n,-t).control(1),qubits = [n]+list(range(n)), inplace=True)
qc.x(n)
qc.compose(shift(n,-s).control(1),qubits = [n]+list(range(n)), inplace=True)
qc.x(n)
qc.compose(iqft(n),qubits = list(range(n)), inplace=True)
return qc
def add(n,a):
qc = QuantumCircuit(n)
qc.compose(qft(n), inplace=True)
qc.compose(shift(n,a), inplace=True)
qc.compose(iqft(n), inplace=True)
return qc
def qft(n):
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)
return qc
def iqft(n):
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)
return qc
def shift(n,a):
qc = QuantumCircuit(n)
for i in range(n):
qc.p(2*math.pi*a/2**(n-i),i)
return qc
''' |
QPC004_C4 | A8FFDD8E2F3A2 | 2 | TLE | 3000 ms | 182 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def solve(n: int, a: int, L: int) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(n + 1)
qc = QuantumCircuit(x, y)
# Write your code here:
qc.compose(add_multi_mod(n,a,L),inplace=True)
gcd,x,y = extended_euclidean(a,L)
a_inv = x % L
#print(a_inv)
for i in range(n):
qc.cx(i,n+i)
qc.cx(n+i,i)
qc.cx(i,n+i)
qc.compose(add_multi_mod(n,L-a_inv,L),inplace=True)
return qc
def extended_euclidean(a: int, b: int) -> tuple[int, int, int]:
# when b == 0:
if b == 0:
return a, 1, 0
# recursive step
gcd, x1, y1 = extended_euclidean(b, a % b)
# update x and y
x = y1
y = x1 - (a // b) * y1
return gcd, x, y
def add_multi_mod(n: int, a: int, L: int) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(n + 1)
qc = QuantumCircuit(x, y)
# Write your code here:
qc.compose(qft(n+1),qubits = list(range(n,2*n+1)), inplace=True)
for i in range(n):
qc.compose(add_mod(n,(a*2**i)%L,L).control(1),qubits = [i]+list(range(n,2*n+1)), inplace=True)
qc.compose(iqft(n+1),qubits = list(range(n,2*n+1)), inplace=True)
return qc
def add_mod(n: int, a: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
qc.compose(shift(n+1,2**n-L+a), inplace=True)
qc.compose(iqft(n+1), inplace=True)
qc.compose(pack(n,2**n-L+a,2**n+a), inplace=True)
qc.compose(qft(n+1), inplace=True)
qc.compose(shift(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(qft(n),qubits = list(range(n)), inplace=True)
qc.compose(shift(n,-t).control(1),qubits = [n]+list(range(n)), inplace=True)
qc.x(n)
qc.compose(shift(n,-s).control(1),qubits = [n]+list(range(n)), inplace=True)
qc.x(n)
qc.compose(iqft(n),qubits = list(range(n)), inplace=True)
return qc
def add(n,a):
qc = QuantumCircuit(n)
qc.compose(qft(n), inplace=True)
qc.compose(shift(n,a), inplace=True)
qc.compose(iqft(n), inplace=True)
return qc
def qft(n):
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)
return qc
def iqft(n):
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)
return qc
def shift(n,a):
qc = QuantumCircuit(n)
for i in range(n):
qc.p(2*math.pi*a/2**(n-i),i)
return qc
''' |
QPC004_C4 | A8FFDD8E2F3A2 | 3 | TLE | 3000 ms | 182 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def solve(n: int, a: int, L: int) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(n + 1)
qc = QuantumCircuit(x, y)
# Write your code here:
qc.compose(add_multi_mod(n,a,L),inplace=True)
gcd,x,y = extended_euclidean(a,L)
a_inv = x % L
#print(a_inv)
for i in range(n):
qc.cx(i,n+i)
qc.cx(n+i,i)
qc.cx(i,n+i)
qc.compose(add_multi_mod(n,L-a_inv,L),inplace=True)
return qc
def extended_euclidean(a: int, b: int) -> tuple[int, int, int]:
# when b == 0:
if b == 0:
return a, 1, 0
# recursive step
gcd, x1, y1 = extended_euclidean(b, a % b)
# update x and y
x = y1
y = x1 - (a // b) * y1
return gcd, x, y
def add_multi_mod(n: int, a: int, L: int) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(n + 1)
qc = QuantumCircuit(x, y)
# Write your code here:
qc.compose(qft(n+1),qubits = list(range(n,2*n+1)), inplace=True)
for i in range(n):
qc.compose(add_mod(n,(a*2**i)%L,L).control(1),qubits = [i]+list(range(n,2*n+1)), inplace=True)
qc.compose(qft(n+1).inverse(),qubits = list(range(n,2*n+1)), inplace=True)
return qc
def add_mod(n: int, a: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
qc.compose(shift(n+1,2**n-L+a), inplace=True)
qc.compose(qft(n+1).inverse(), inplace=True)
qc.compose(pack(n,2**n-L+a,2**n+a), inplace=True)
qc.compose(qft(n+1), inplace=True)
qc.compose(shift(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(qft(n),qubits = list(range(n)), inplace=True)
qc.compose(shift(n,-t).control(1),qubits = [n]+list(range(n)), inplace=True)
qc.x(n)
qc.compose(shift(n,-s).control(1),qubits = [n]+list(range(n)), inplace=True)
qc.x(n)
qc.compose(qft(n).inverse(),qubits = list(range(n)), inplace=True)
return qc
def add(n,a):
qc = QuantumCircuit(n)
qc.compose(qft(n), inplace=True)
qc.compose(shift(n,a), inplace=True)
qc.compose(qft(n).inverse(), inplace=True)
return qc
def qft(n):
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)
return qc
def iqft(n):
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)
return qc
def shift(n,a):
qc = QuantumCircuit(n)
for i in range(n):
qc.p(2*math.pi*a/2**(n-i),i)
return qc
''' |
QPC004_C4 | A8FFDD8E2F3A2 | 4 | TLE | 3000 ms | 182 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def solve(n: int, a: int, L: int) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(n + 1)
qc = QuantumCircuit(x, y)
# Write your code here:
qc.compose(add_multi_mod(n,a,L),inplace=True)
gcd,x,y = extended_euclidean(a,L)
a_inv = x % L
#print(a_inv)
for i in range(n):
qc.cx(i,n+i)
qc.cx(n+i,i)
qc.cx(i,n+i)
qc.compose(add_multi_mod(n,L-a_inv,L),inplace=True)
return qc
def extended_euclidean(a: int, b: int) -> tuple[int, int, int]:
# when b == 0:
if b == 0:
return a, 1, 0
# recursive step
gcd, x1, y1 = extended_euclidean(b, a % b)
# update x and y
x = y1
y = x1 - (a // b) * y1
return gcd, x, y
def add_multi_mod(n: int, a: int, L: int) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(n + 1)
qc = QuantumCircuit(x, y)
# Write your code here:
qc.compose(qft(n+1),qubits = list(range(n,2*n+1)), inplace=True)
for i in range(n):
qc.compose(add_mod(n,(a*2**i)%L,L).control(1),qubits = [i]+list(range(n,2*n+1)), inplace=True)
qc.compose(qft(n+1).inverse(),qubits = list(range(n,2*n+1)), inplace=True)
return qc
def add_mod(n: int, a: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
qc.compose(shift(n+1,2**n-L+a), inplace=True)
qc.compose(qft(n+1).inverse(), inplace=True)
qc.compose(pack(n,2**n-L+a,2**n+a), inplace=True)
qc.compose(qft(n+1), inplace=True)
qc.compose(shift(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(qft(n),qubits = list(range(n)), inplace=True)
qc.compose(shift(n,-t).control(1),qubits = [n]+list(range(n)), inplace=True)
qc.x(n)
qc.compose(shift(n,-s).control(1),qubits = [n]+list(range(n)), inplace=True)
qc.x(n)
qc.compose(qft(n).inverse(),qubits = list(range(n)), inplace=True)
return qc
def qft(n):
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)
return qc
def shift(n,a):
qc = QuantumCircuit(n)
for i in range(n):
qc.p(2*math.pi*a/2**(n-i),i)
return qc
''' |
QPC004_C4 | A8FFDD8E2F3A2 | 5 | TLE | 3000 ms | 182 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def solve(n: int, a: int, L: int) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(n + 1)
qc = QuantumCircuit(x, y)
# Write your code here:
qc.compose(add_multi_mod(n,a,L),inplace=True)
gcd,x,y = extended_euclidean(a,L)
a_inv = x % L
#print(a_inv)
for i in range(n):
qc.swap(i,n+i)
qc.compose(add_multi_mod(n,L-a_inv,L),inplace=True)
return qc
def extended_euclidean(a: int, b: int) -> tuple[int, int, int]:
# when b == 0:
if b == 0:
return a, 1, 0
# recursive step
gcd, x1, y1 = extended_euclidean(b, a % b)
# update x and y
x = y1
y = x1 - (a // b) * y1
return gcd, x, y
def add_multi_mod(n: int, a: int, L: int) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(n + 1)
qc = QuantumCircuit(x, y)
# Write your code here:
qc.compose(qft(n+1),qubits = list(range(n,2*n+1)), inplace=True)
for i in range(n):
qc.compose(add_mod(n,(a*2**i)%L,L).control(1),qubits = [i]+list(range(n,2*n+1)), inplace=True)
qc.compose(qft(n+1).inverse(),qubits = list(range(n,2*n+1)), inplace=True)
return qc
def add_mod(n: int, a: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
qc.compose(shift(n+1,2**n-L+a), inplace=True)
qc.compose(qft(n+1).inverse(), inplace=True)
qc.compose(pack(n,2**n-L+a,2**n+a), inplace=True)
qc.compose(qft(n+1), inplace=True)
qc.compose(shift(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(qft(n),qubits = list(range(n)), inplace=True)
qc.compose(shift(n,-t).control(1),qubits = [n]+list(range(n)), inplace=True)
qc.x(n)
qc.compose(shift(n,-s).control(1),qubits = [n]+list(range(n)), inplace=True)
qc.x(n)
qc.compose(qft(n).inverse(),qubits = list(range(n)), inplace=True)
return qc
def qft(n):
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)
return qc
def shift(n,a):
qc = QuantumCircuit(n)
for i in range(n):
qc.p(2*math.pi*a/2**(n-i),i)
return qc
''' |
QPC004_C4 | A8FFDD8E2F3A2 | 6 | WA | 2534 ms | 165 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def solve(n: int, a: int, L: int) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(n + 1)
qc = QuantumCircuit(x, y)
# Write your code here:
qc.compose(qft(n+1),qubits = list(range(n,2*n+1)), inplace=True)
for i in range(n):
b = (a*2**i)%L
qc.compose(shift(n+1,2**n-L+b), inplace=True)
qc.compose(qft(n+1).inverse(), inplace=True)
qc.compose(pack(n,2**n-L+b,2**n+b), inplace=True)
qc.compose(qft(n+1), inplace=True)
qc.compose(shift(n+1,b), inplace=True)
qc.compose(qft(n+1).inverse(),qubits = list(range(n,2*n+1)), inplace=True)
gcd,x,y = extended_euclidean(a,L)
a_inv = x % L
#print(a_inv)
for i in range(n):
qc.swap(i,n+i)
qc.compose(qft(n+1),qubits = list(range(n,2*n+1)), inplace=True)
for i in range(n):
b = ((L-a_inv)*2**i)%L
qc.compose(shift(n+1,2**n-L+b), inplace=True)
qc.compose(qft(n+1).inverse(), inplace=True)
qc.compose(pack(n,2**n-L+b,2**n+b), inplace=True)
qc.compose(qft(n+1), inplace=True)
qc.compose(shift(n+1,b), inplace=True)
qc.compose(qft(n+1).inverse(),qubits = list(range(n,2*n+1)), inplace=True)
return qc
def extended_euclidean(a: int, b: int) -> tuple[int, int, int]:
# when b == 0:
if b == 0:
return a, 1, 0
# recursive step
gcd, x1, y1 = extended_euclidean(b, a % b)
# update x and y
x = y1
y = x1 - (a // b) * y1
return gcd, x, y
def pack(n: int, s: int, t: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
qc.compose(qft(n),qubits = list(range(n)), inplace=True)
qc.compose(shift(n,-t).control(1),qubits = [n]+list(range(n)), inplace=True)
qc.x(n)
qc.compose(shift(n,-s).control(1),qubits = [n]+list(range(n)), inplace=True)
qc.x(n)
qc.compose(qft(n).inverse(),qubits = list(range(n)), inplace=True)
return qc
def qft(n):
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)
return qc
def shift(n,a):
qc = QuantumCircuit(n)
for i in range(n):
qc.p(2*math.pi*a/2**(n-i),i)
return qc
''' |
QPC004_C4 | A8FFDD8E2F3A2 | 7 | AC | 2847 ms | 164 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 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
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 ccrot(n: int, a: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 2)
for i in range(n):
theta = 2 * math.pi * a * 2**i / 2**n
qc.mcp(theta, [n, n + 1], i)
return qc
def ccadd(n: int, a: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 2)
qc.compose(qft(n), qubits=range(n), inplace=True)
qc.compose(ccrot(n, a), qubits=range(n + 2), inplace=True)
qc.compose(qft(n).inverse(), qubits=range(n), inplace=True)
return qc
def cpack(n: int, s: int, t: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 2)
qc.compose(ccadd(n, 2 ** (n + 1) - t), qubits=range(n + 2), inplace=True)
qc.x(n)
qc.compose(ccadd(n, -s), qubits=range(n + 2), inplace=True)
qc.x(n)
return qc
def add_ax_mod(n: int, L: int, a: int) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(n + 1)
qc = QuantumCircuit(x, y)
for i in range(n):
b = (2**i * a) % L
targets = [*y, x[i]]
qc.compose(cadd(n + 1, 2**n - L), qubits=targets, inplace=True)
qc.compose(cadd(n + 1, b), qubits=targets, inplace=True)
qc.compose(cpack(n, 2**n - L + b, 2**n + b), qubits=targets, inplace=True)
qc.compose(cadd(n + 1, b), qubits=targets, inplace=True)
return qc
def inv_mod(a: int, L: int) -> int:
def extended_euclidean(a: int, b: int) -> tuple[int, int, int]:
if b == 0:
return a, 1, 0
gcd, x1, y1 = extended_euclidean(b, a % b)
x = y1
y = x1 - (a // b) * y1
return gcd, x, y
_, x, _ = extended_euclidean(a, L)
return x % L
def solve(n: int, a: int, L: int) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(n + 1)
qc = QuantumCircuit(x, y)
qc.compose(add_ax_mod(n, L, a), qubits=range(2 * n + 1), inplace=True)
for i in range(n):
qc.swap(x[i], y[i])
b = -inv_mod(a, L) % L
qc.compose(add_ax_mod(n, L, b), qubits=range(2 * n + 1), inplace=True)
return qc
''' |
QPC004_C5 | A047671A4EB2D | 1 | WA | 1684 ms | 160 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def solve(n: int, m: int, a: int, L: int) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(2 * m + 1)
qc = QuantumCircuit(x, y)
# Step 1: Create superposition on the first n qubits
for i in range(n):
qc.h(x[i]) # Apply Hadamard gate to each qubit in the first register
# Step 2: Compute a^k mod L for each k in the superposition
# We will use controlled operations to achieve this
for k in range(2**n):
# Calculate a^k mod L
mod_result = pow(a, k, L)
# Convert mod_result to binary and store in the second register
for j in range(2 * m + 1):
if (mod_result >> j) & 1:
qc.x(y[j]) # Apply X gate to set the corresponding bit
return qc
''' |
QPC004_C5 | A047671A4EB2D | 2 | UME | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library.standard_gates import QFT
import math
def solve(n: int, m: int, a: int, L: int) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(2 * m + 1)
qc = QuantumCircuit(x, y)
# Apply Hadamard gates on the first n qubits
for i in range(n):
qc.h(x[i])
# Apply controlled phase gates based on the value of k
for k in range(2**n):
binary_k = format(k, '0'+str(n)+'b') # Convert k to binary string
for i in range(n):
if binary_k[i] == '0':
qc.x(x[i])
phase = (a**k) % L
binary_phase = format(phase, '0'+str(2*m+1)+'b') # Convert phase to binary string
for i in range(2*m+1):
if binary_phase[i] == '1':
qc.cp(2*math.pi / (2**m), x, y[i])
for i in range(n):
if binary_k[i] == '0':
qc.x(x[i])
# Apply inverse QFT on the first n qubits
qft_dagger = QFT(n, inverse=True)
qc.append(qft_dagger, x)
return qc
''' | ||
QPC004_C5 | A047671A4EB2D | 3 | AC | 2076 ms | 164 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, m: int, a: int, L: int) -> QuantumCircuit:
"""
Create |0>_n |0>_(2m+1) → (1/√(2^n)) Σ_k |k> |a^k mod L>
Registers are in little-endian order.
"""
x = QuantumRegister(n, 'x') # exponent register
y = QuantumRegister(2 * m + 1, 'y') # result register (enough qubits for L)
qc = QuantumCircuit(x, y)
# 1) Prepare uniform superposition on |x>
for i in range(n):
qc.h(x[i]) # |0…0> → (1/√2^n) Σ_k |k>
# helper: multi-controlled X with an arbitrary number of controls
def cX(ctrls, tgt):
if len(ctrls) == 0:
qc.x(tgt)
elif len(ctrls) == 1:
qc.cx(ctrls[0], tgt)
else:
qc.mcx(ctrls, tgt) # built-in multi-controlled X
# 2) Encode a^k (mod L) into |y> for every computational basis state |k>
N = 1 << n # 2^n
y_bits = 2 * m + 1 # number of qubits in y
for k in range(N):
value = pow(a, k, L) # classical a^k mod L
if value == 0:
continue # all target bits stay 0
# list of control qubits (all qubits of register x)
ctrls = [x[i] for i in range(n)]
# temporarily flip controls whose bit in k is 0 (so all controls become |1>)
zeros = [i for i in range(n) if ((k >> i) & 1) == 0]
for i in zeros:
qc.x(x[i])
# for every 1-bit in 'value' flip corresponding qubit in y
for bit in range(y_bits):
if (value >> bit) & 1:
cX(ctrls, y[bit])
# undo the temporary flips
for i in zeros:
qc.x(x[i])
return qc
''' |
QPC004_C5 | A1138001D8D93 | 1 | RE | 1844 ms | 158 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, m: int, a: int, L: int) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(2 * m + 1)
qc = QuantumCircuit(x, y)
# Write your code here:
for i in range(n):
qc.h(i)
multipliers = doubling_powers(n,a,L)
for i in range(n):
qc.compose(multiply_mod(m,a,L).control(1),qubits = [i] + list(range(n,n+2*m+1)),inplace=True)
return qc
def doubling_powers(n: int, a: int, L: int) -> list[int]:
result: list[int] = []
# Write your code here:
result.append(a)
for i in range(1,n):
result.append(result[-1]**2%L)
return result
def multiply_mod(n: int, a: int, L: int) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(n + 1)
qc = QuantumCircuit(x, y)
# Write your code here:
qc.compose(add_multi_mod(n,a,L),inplace=True)
gcd,x,y = extended_euclidean(a,L)
a_inv = x % L
#print(a_inv)
for i in range(n):
qc.swap(i,n+i)
qc.compose(add_multi_mod(n,L-a_inv,L),inplace=True)
return qc
def extended_euclidean(a: int, b: int) -> tuple[int, int, int]:
# when b == 0:
if b == 0:
return a, 1, 0
# recursive step
gcd, x1, y1 = extended_euclidean(b, a % b)
# update x and y
x = y1
y = x1 - (a // b) * y1
return gcd, x, y
def add_multi_mod(n: int, a: int, L: int) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(n + 1)
qc = QuantumCircuit(x, y)
# Write your code here:
qc.compose(qft(n+1),qubits = list(range(n,2*n+1)), inplace=True)
for i in range(n):
qc.compose(add_mod(n,(a*2**i)%L,L),qubits = [i]+list(range(n,2*n+1)), inplace=True)
qc.compose(qft(n+1).inverse(),qubits = list(range(n,2*n+1)), inplace=True)
return qc
def add_mod(n: int, a: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 2)
# Write your code here:
qc.compose(shift(n+1,2**n-L+a).control(1), inplace=True)
qc.compose(qft(n+1).inverse(),qubits = list(range(1,n+2)), inplace=True)
qc.compose(pack(n,2**n-L+a,2**n+a), inplace=True)
qc.compose(qft(n+1),qubits = list(range(1,n+2)), inplace=True)
qc.compose(shift(n+1,a).control(1), inplace=True)
return qc
def pack(n: int, s: int, t: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 2)
# Write your code here:
qc.compose(qft(n),qubits = list(range(1,n+1)), inplace=True)
qc.compose(shift(n,-t).control(2),qubits = [0,n+1]+list(range(1,n+1)), inplace=True)
qc.x(n+1)
qc.compose(shift(n,-s).control(2),qubits = [0,n+1]+list(range(1,n+1)), inplace=True)
qc.x(n+1)
qc.compose(qft(n).inverse(),qubits = list(range(1,n+1)), inplace=True)
return qc
def qft(n):
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)
return qc
def shift(n,a):
qc = QuantumCircuit(n)
for i in range(n):
qc.p(2*math.pi*a/2**(n-i),i)
return qc
''' |
QPC004_C5 | A1138001D8D93 | 2 | WA | 2240 ms | 162 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def solve(n: int, m: int, a: int, L: int) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(2 * m + 1)
qc = QuantumCircuit(x, y)
# Write your code here:
for i in range(n):
qc.h(i)
multipliers = doubling_powers(n,a,L)
for i in range(n):
qc.compose(multiply_mod(m,a,L).control(1),qubits = [i] + list(range(n,n+2*m+1)),inplace=True)
return qc
def doubling_powers(n: int, a: int, L: int) -> list[int]:
result: list[int] = []
# Write your code here:
result.append(a)
for i in range(1,n):
result.append(result[-1]**2%L)
return result
def multiply_mod(n: int, a: int, L: int) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(n + 1)
qc = QuantumCircuit(x, y)
# Write your code here:
qc.compose(add_multi_mod(n,a,L),inplace=True)
gcd,x,y = extended_euclidean(a,L)
a_inv = x % L
#print(a_inv)
for i in range(n):
qc.swap(i,n+i)
qc.compose(add_multi_mod(n,L-a_inv,L),inplace=True)
return qc
def extended_euclidean(a: int, b: int) -> tuple[int, int, int]:
# when b == 0:
if b == 0:
return a, 1, 0
# recursive step
gcd, x1, y1 = extended_euclidean(b, a % b)
# update x and y
x = y1
y = x1 - (a // b) * y1
return gcd, x, y
def add_multi_mod(n: int, a: int, L: int) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(n + 1)
qc = QuantumCircuit(x, y)
# Write your code here:
qc.compose(qft(n+1),qubits = list(range(n,2*n+1)), inplace=True)
for i in range(n):
qc.compose(add_mod(n,(a*2**i)%L,L),qubits = [i]+list(range(n,2*n+1)), inplace=True)
qc.compose(qft(n+1).inverse(),qubits = list(range(n,2*n+1)), inplace=True)
return qc
def add_mod(n: int, a: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 2)
# Write your code here:
qc.compose(shift(n+1,2**n-L+a).control(1), inplace=True)
qc.compose(qft(n+1).inverse(),qubits = list(range(1,n+2)), inplace=True)
qc.compose(pack(n,2**n-L+a,2**n+a), inplace=True)
qc.compose(qft(n+1),qubits = list(range(1,n+2)), inplace=True)
qc.compose(shift(n+1,a).control(1), inplace=True)
return qc
def pack(n: int, s: int, t: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 2)
# Write your code here:
qc.compose(qft(n),qubits = list(range(1,n+1)), inplace=True)
qc.compose(shift(n,-t).control(2),qubits = [0,n+1]+list(range(1,n+1)), inplace=True)
qc.x(n+1)
qc.compose(shift(n,-s).control(2),qubits = [0,n+1]+list(range(1,n+1)), inplace=True)
qc.x(n+1)
qc.compose(qft(n).inverse(),qubits = list(range(1,n+1)), inplace=True)
return qc
def qft(n):
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)
return qc
def shift(n,a):
qc = QuantumCircuit(n)
for i in range(n):
qc.p(2*math.pi*a/2**(n-i),i)
return qc
''' |
QPC004_C5 | A1138001D8D93 | 3 | WA | 4744 ms | 196 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def solve(n: int, m: int, a: int, L: int) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(2 * m + 1)
qc = QuantumCircuit(x, y)
# Write your code here:
for i in range(n):
qc.h(i)
multipliers = doubling_powers(n,a,L)
for i in range(n):
qc.compose(multiply_mod(m,multipliers[i],L).control(1),qubits = [i] + list(range(n,n+2*m+1)),inplace=True)
return qc
def doubling_powers(n: int, a: int, L: int) -> list[int]:
result: list[int] = []
# Write your code here:
result.append(a)
for i in range(1,n):
result.append(result[-1]**2%L)
return result
def multiply_mod(n: int, a: int, L: int) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(n + 1)
qc = QuantumCircuit(x, y)
# Write your code here:
qc.compose(add_multi_mod(n,a,L),inplace=True)
gcd,x,y = extended_euclidean(a,L)
a_inv = x % L
#print(a_inv)
for i in range(n):
qc.swap(i,n+i)
qc.compose(add_multi_mod(n,L-a_inv,L),inplace=True)
return qc
def extended_euclidean(a: int, b: int) -> tuple[int, int, int]:
# when b == 0:
if b == 0:
return a, 1, 0
# recursive step
gcd, x1, y1 = extended_euclidean(b, a % b)
# update x and y
x = y1
y = x1 - (a // b) * y1
return gcd, x, y
def add_multi_mod(n: int, a: int, L: int) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(n + 1)
qc = QuantumCircuit(x, y)
# Write your code here:
qc.compose(qft(n+1),qubits = list(range(n,2*n+1)), inplace=True)
for i in range(n):
qc.compose(add_mod(n,(a*2**i)%L,L),qubits = [i]+list(range(n,2*n+1)), inplace=True)
qc.compose(qft(n+1).inverse(),qubits = list(range(n,2*n+1)), inplace=True)
return qc
def add_mod(n: int, a: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 2)
# Write your code here:
qc.compose(shift(n+1,2**n-L+a).control(1), inplace=True)
qc.compose(qft(n+1).inverse(),qubits = list(range(1,n+2)), inplace=True)
qc.compose(pack(n,2**n-L+a,2**n+a), inplace=True)
qc.compose(qft(n+1),qubits = list(range(1,n+2)), inplace=True)
qc.compose(shift(n+1,a).control(1), inplace=True)
return qc
def pack(n: int, s: int, t: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 2)
# Write your code here:
qc.compose(qft(n),qubits = list(range(1,n+1)), inplace=True)
qc.compose(shift(n,-t).control(2),qubits = [0,n+1]+list(range(1,n+1)), inplace=True)
qc.x(n+1)
qc.compose(shift(n,-s).control(2),qubits = [0,n+1]+list(range(1,n+1)), inplace=True)
qc.x(n+1)
qc.compose(qft(n).inverse(),qubits = list(range(1,n+1)), inplace=True)
return qc
def qft(n):
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)
return qc
def shift(n,a):
qc = QuantumCircuit(n)
for i in range(n):
qc.p(2*math.pi*a/2**(n-i),i)
return qc
''' |
QPC004_C5 | A1138001D8D93 | 4 | RE | 2267 ms | 158 MiB | '''python
def solve(n: int, m: int, a: int, L: int) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(2 * m + 1)
qc = QuantumCircuit(x, y)
# Write your code here:
for i in range(n):
qc.h(i)
qc.x(n)
multipliers = doubling_powers(n,a,L)
for i in range(n):
qc.compose(multiply_mod(m,multipliers[i],L).control(1),qubits = [i] + list(range(n,n+2*m+1)),inplace=True)
return qc
def doubling_powers(n: int, a: int, L: int) -> list[int]:
result: list[int] = []
# Write your code here:
result.append(a)
for i in range(1,n):
result.append(result[-1]**2%L)
return result
def multiply_mod(n: int, a: int, L: int) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(n + 1)
qc = QuantumCircuit(x, y)
# Write your code here:
qc.compose(add_multi_mod(n,a,L),inplace=True)
gcd,x,y = extended_euclidean(a,L)
a_inv = x % L
#print(a_inv)
for i in range(n):
qc.swap(i,n+i)
qc.compose(add_multi_mod(n,L-a_inv,L),inplace=True)
return qc
def extended_euclidean(a: int, b: int) -> tuple[int, int, int]:
# when b == 0:
if b == 0:
return a, 1, 0
# recursive step
gcd, x1, y1 = extended_euclidean(b, a % b)
# update x and y
x = y1
y = x1 - (a // b) * y1
return gcd, x, y
def add_multi_mod(n: int, a: int, L: int) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(n + 1)
qc = QuantumCircuit(x, y)
# Write your code here:
qc.compose(qft(n+1),qubits = list(range(n,2*n+1)), inplace=True)
for i in range(n):
qc.compose(add_mod(n,(a*2**i)%L,L),qubits = [i]+list(range(n,2*n+1)), inplace=True)
qc.compose(qft(n+1).inverse(),qubits = list(range(n,2*n+1)), inplace=True)
return qc
def add_mod(n: int, a: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 2)
# Write your code here:
qc.compose(shift(n+1,2**n-L+a).control(1), inplace=True)
qc.compose(qft(n+1).inverse(),qubits = list(range(1,n+2)), inplace=True)
qc.compose(pack(n,2**n-L+a,2**n+a), inplace=True)
qc.compose(qft(n+1),qubits = list(range(1,n+2)), inplace=True)
qc.compose(shift(n+1,a).control(1), inplace=True)
return qc
def pack(n: int, s: int, t: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 2)
# Write your code here:
qc.compose(qft(n),qubits = list(range(1,n+1)), inplace=True)
qc.compose(shift(n,-t).control(2),qubits = [0,n+1]+list(range(1,n+1)), inplace=True)
qc.x(n+1)
qc.compose(shift(n,-s).control(2),qubits = [0,n+1]+list(range(1,n+1)), inplace=True)
qc.x(n+1)
qc.compose(qft(n).inverse(),qubits = list(range(1,n+1)), inplace=True)
return qc
def qft(n):
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)
return qc
def shift(n,a):
qc = QuantumCircuit(n)
for i in range(n):
qc.p(2*math.pi*a/2**(n-i),i)
return qc
''' |
QPC004_C5 | A1138001D8D93 | 5 | TLE | 10000 ms | 228 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def solve(n: int, m: int, a: int, L: int) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(2 * m + 1)
qc = QuantumCircuit(x, y)
# Write your code here:
for i in range(n):
qc.h(i)
qc.x(n)
multipliers = doubling_powers(n,a,L)
for i in range(n):
qc.compose(multiply_mod(m,multipliers[i],L).control(1),qubits = [i] + list(range(n,n+2*m+1)),inplace=True)
return qc
def doubling_powers(n: int, a: int, L: int) -> list[int]:
result: list[int] = []
# Write your code here:
result.append(a)
for i in range(1,n):
result.append(result[-1]**2%L)
return result
def multiply_mod(n: int, a: int, L: int) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(n + 1)
qc = QuantumCircuit(x, y)
# Write your code here:
qc.compose(add_multi_mod(n,a,L),inplace=True)
gcd,x,y = extended_euclidean(a,L)
a_inv = x % L
#print(a_inv)
for i in range(n):
qc.swap(i,n+i)
qc.compose(add_multi_mod(n,L-a_inv,L),inplace=True)
return qc
def extended_euclidean(a: int, b: int) -> tuple[int, int, int]:
# when b == 0:
if b == 0:
return a, 1, 0
# recursive step
gcd, x1, y1 = extended_euclidean(b, a % b)
# update x and y
x = y1
y = x1 - (a // b) * y1
return gcd, x, y
def add_multi_mod(n: int, a: int, L: int) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(n + 1)
qc = QuantumCircuit(x, y)
# Write your code here:
qc.compose(qft(n+1),qubits = list(range(n,2*n+1)), inplace=True)
for i in range(n):
qc.compose(add_mod(n,(a*2**i)%L,L),qubits = [i]+list(range(n,2*n+1)), inplace=True)
qc.compose(qft(n+1).inverse(),qubits = list(range(n,2*n+1)), inplace=True)
return qc
def add_mod(n: int, a: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 2)
# Write your code here:
qc.compose(shift(n+1,2**n-L+a).control(1), inplace=True)
qc.compose(qft(n+1).inverse(),qubits = list(range(1,n+2)), inplace=True)
qc.compose(pack(n,2**n-L+a,2**n+a), inplace=True)
qc.compose(qft(n+1),qubits = list(range(1,n+2)), inplace=True)
qc.compose(shift(n+1,a).control(1), inplace=True)
return qc
def pack(n: int, s: int, t: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 2)
# Write your code here:
qc.compose(qft(n),qubits = list(range(1,n+1)), inplace=True)
qc.compose(shift(n,-t).control(2),qubits = [0,n+1]+list(range(1,n+1)), inplace=True)
qc.x(n+1)
qc.compose(shift(n,-s).control(2),qubits = [0,n+1]+list(range(1,n+1)), inplace=True)
qc.x(n+1)
qc.compose(qft(n).inverse(),qubits = list(range(1,n+1)), inplace=True)
return qc
def qft(n):
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)
return qc
def shift(n,a):
qc = QuantumCircuit(n)
for i in range(n):
qc.p(2*math.pi*a/2**(n-i),i)
return qc
''' |
QPC004_C5 | A1138001D8D93 | 6 | AC | 8552 ms | 202 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def solve(n: int, m: int, a: int, L: int) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(2 * m + 1)
qc = QuantumCircuit(x, y)
# Write your code here:
for i in range(n):
qc.h(i)
qc.x(n)
multipliers = doubling_powers(n,a,L)
for i in range(n):
qc.compose(multiply_mod(m,multipliers[i],L),qubits = [i] + list(range(n,n+2*m+1)),inplace=True)
return qc
def doubling_powers(n: int, a: int, L: int) -> list[int]:
result: list[int] = []
# Write your code here:
result.append(a)
for i in range(1,n):
result.append(result[-1]**2%L)
return result
def multiply_mod(n: int, a: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(2*n+2)
# Write your code here:
qc.compose(add_multi_mod(n,a,L),inplace=True)
gcd,x,y = extended_euclidean(a,L)
a_inv = x % L
#print(a_inv)
for i in range(n):
qc.cswap(0,i+1,n+i+1)
qc.compose(add_multi_mod(n,L-a_inv,L),inplace=True)
return qc
def extended_euclidean(a: int, b: int) -> tuple[int, int, int]:
# when b == 0:
if b == 0:
return a, 1, 0
# recursive step
gcd, x1, y1 = extended_euclidean(b, a % b)
# update x and y
x = y1
y = x1 - (a // b) * y1
return gcd, x, y
def add_multi_mod(n: int, a: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(2*n+2)
# Write your code here:
qc.compose(qft(n+1),qubits = list(range(n+1,2*n+2)), inplace=True)
for i in range(n):
qc.compose(add_mod(n,(a*2**i)%L,L),qubits = [0,i+1]+list(range(n+1,2*n+2)), inplace=True)
qc.compose(qft(n+1).inverse(),qubits = list(range(n+1,2*n+2)), inplace=True)
return qc
def add_mod(n: int, a: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 3)
# Write your code here:
qc.compose(shift(n+1,2**n-L+a).control(2), inplace=True)
qc.compose(qft(n+1).inverse(),qubits = list(range(2,n+3)), inplace=True)
qc.compose(pack(n,2**n-L+a,2**n+a), inplace=True)
qc.compose(qft(n+1),qubits = list(range(2,n+3)), inplace=True)
qc.compose(shift(n+1,a).control(2), inplace=True)
return qc
def pack(n: int, s: int, t: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 3)
# Write your code here:
qc.compose(qft(n),qubits = list(range(2,n+2)), inplace=True)
qc.compose(shift(n,-t).control(3),qubits = [0,1,n+2]+list(range(2,n+2)), inplace=True)
qc.x(n+2)
qc.compose(shift(n,-s).control(3),qubits = [0,1,n+2]+list(range(2,n+2)), inplace=True)
qc.x(n+2)
qc.compose(qft(n).inverse(),qubits = list(range(2,n+2)), inplace=True)
return qc
def qft(n):
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)
return qc
def shift(n,a):
qc = QuantumCircuit(n)
for i in range(n):
qc.p(2*math.pi*a/2**(n-i),i)
return qc
''' |
QPC004_C5 | A44322E5E4FC3 | 1 | WA | 1719 ms | 166 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, m: int, a: int, L: int) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(2 * m + 1)
qc = QuantumCircuit(x, y)
# Step 1: Create uniform superposition on input register
for i in range(n):
qc.h(x[i])
# Step 2: For each basis state |k⟩, compute a^k mod L
for k in range(n):
# For each qubit in k's binary representation
power = 2**k
# If kth qubit is 1, multiply by a^(2^k) mod L
controlled_modmult(qc, x[k], y, a**power % L, L, m)
return qc
def controlled_modmult(qc, control, target_reg, factor, modulus, m):
"""
Applies controlled modular multiplication:
If control=1: |y⟩ → |y * factor mod modulus⟩
"""
n_target = len(target_reg)
# Convert factor to binary representation
bin_factor = format(factor % modulus, f'0{n_target}b')
# Apply CNOT gates based on binary representation of factor
for i, bit in enumerate(reversed(bin_factor)):
if bit == '1':
qc.cx(control, target_reg[i])
# Apply modular reduction
# This is a simplified version - in practice, you'd need
# a more sophisticated quantum modular arithmetic implementation
# that handles the modular reduction in a reversible way
''' |
QPC004_C5 | A44322E5E4FC3 | 2 | WA | 1679 ms | 162 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, m: int, a: int, L: int) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(2 * m + 1)
qc = QuantumCircuit(x, y)
# Step 1: Create uniform superposition on input register
for i in range(n):
qc.h(x[i])
# Step 2: For each basis state |k⟩, compute a^k mod L
for k in range(n):
# For each qubit in k's binary representation
power = 2**k
# If kth qubit is 1, multiply by a^(2^k) mod L
controlled_modmult(qc, x[k], y, a**power % L, L, m)
return qc
def controlled_modmult(qc, control, target_reg, factor, modulus, m):
"""
Applies controlled modular multiplication:
If control=1: |y⟩ → |y * factor mod modulus⟩
"""
n_target = len(target_reg)
# Convert factor to binary representation
bin_factor = format(factor % modulus, f'0{n_target}b')
# Apply CNOT gates based on binary representation of factor
for i, bit in enumerate(reversed(bin_factor)):
if bit == '1':
qc.cx(control, target_reg[i])
# Apply modular reduction
# This is a simplified version - in practice, you'd need
# a more sophisticated quantum modular arithmetic implementation
# that handles the modular reduction in a reversible way
''' |
QPC004_C5 | A5A72EC447696 | 1 | RE | 1530 ms | 157 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, m: int, a: int, L: int) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(2 * m + 1)
qc = QuantumCircuit(x, y)
# Write your code here:
def add_constant(qc, const, reg, controls):
if const == 0:
return
n_reg = len(reg)
for i in range(n_reg):
if (const & (1 << i)):
sub_reg = reg[i:]
ctrl_list = controls[:]
if len(ctrl_list) > 0:
qc.mcx(ctrl_list, sub_reg[0])
else:
qc.x(sub_reg[0])
for k in range(1, len(sub_reg)):
ctrl_list = controls + sub_reg[0:k]
qc.mcx(ctrl_list, sub_reg[k])
def modular_add_constant(qc, const, reg, L, controls):
if const == 0:
return
add_constant(qc, const, reg, controls)
temp = (1 << len(reg)) - L
add_constant(qc, temp, reg, controls)
add_constant(qc, L, reg, controls + [reg[-1]])
qc.h(x)
qc.x(y[0])
z_reg = y[0:m]
aux_reg = y[m:2*m+1]
for j in range(n):
c = pow(a, 1 << j, L)
if c == 0 or c == 1:
continue
inv = pow(c, -1, L)
neg_inv = L - inv
# CMULT c
for bit in range(m):
ctrl2 = z_reg[bit]
e = (c * (1 << bit)) % L
modular_add_constant(qc, e, aux_reg, L, [x[j], ctrl2])
# cswap
for bit in range(m):
qc.cswap(x[j], z_reg[bit], aux_reg[bit])
# CMULT neg_inv
for bit in range(m):
ctrl2 = z_reg[bit]
e = (neg_inv * (1 << bit)) % L
modular_add_constant(qc, e, aux_reg, L, [x[j], ctrl2])
return qc
''' |
QPC004_C5 | A5A72EC447696 | 2 | UME | '''python
from __future__ import annotations
from math import pi
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import QFT # ∣x⟩↦∣x̃⟩ helper
# ------------------------------------------------------------------
# elementary arithmetic gadgets
# ------------------------------------------------------------------
def qft_add_const(qc: QuantumCircuit, q: list, c: int) -> None:
""" |x⟩ → |x+c mod 2^k⟩ (no ancilla, k = len(q))
little-endian QFT adder (Cuccaro, Draper 2000) """
k = len(q)
qc.append(QFT(k, do_swaps=False).to_gate(label='QFT'), q)
for j in range(k):
angle = 2*pi*((c % (1<<k)) >> j) / (1 << (j+1))
if abs(angle) > 1e-12:
qc.p(angle, q[j])
qc.append(QFT(k, do_swaps=False).inverse().to_gate(label='QFT†'), q)
def add_const_mod(qc: QuantumCircuit,
tgt: list, # k value qubits (little-endian)
c: int, # classical const (0 ≤ c < L)
L: int, # modulus
flag: int) -> None: # *one* ancilla qubit inside tgt-register
""" |x⟩|0⟩ → |(x+c) mod L⟩|0⟩
*flag* is the MSB of *tgt*: we recycle it as the “overflow” bit.
Steps (all reversible):
1. x ← x+c (plain addition)
2. x-L? set flag if x ≥ L (comparator)
3. conditional −L (controlled on flag)
4. uncompute comparator (flag back to |0⟩)
"""
k = len(tgt)-1 # data bits 0…k-1, flag at k
data = tgt[:k] # shorthand
fbit = tgt[k]
# 1. add c
qft_add_const(qc, data, c)
# 2. compute “x ≥ L” (compare to L-1 in two’s complement):
inv = ((1 << k) - L) # actually add (2^k − L)
qft_add_const(qc, data, inv) # x ← x + 2^k - L (mod 2^k)
qc.x(data[-1]) # MSB is 0 ↔ overflow (‖ 2’s-complement sign)
qc.cx(data[-1], fbit) # copy sign into flag
qc.x(data[-1])
# 3. if overflow, add L back
qft_add_const(qc, data, (L if c else 0)) # tidy up phase
qc.cx(fbit, data[-1])
qc.x(data[-1])
qc.cx(data[-1], fbit)
qft_add_const(qc, data, (1 << k) - L) # undo comparator residue
# 4. uncompute flag
qft_add_const(qc, data, (1 << k) - c) # restore original basis
qc.cx(data[-1], fbit) # flag back to |0〉
qft_add_const(qc, data, c) # data contains (x+c) mod L
def controlled_mul_const_mod(qc: QuantumCircuit,
ctl, tgt: list, const: int, L: int) -> None:
"""If ctl==1 multiply |y⟩ by fixed *const* modulo L (textbook “double-and-add”).
Uses the upper m ancilla qubits already available inside *tgt*.
"""
k = (len(tgt) - 1) // 2 # k = m
acc = tgt[:k] # low m qubits – current value
work = tgt[k:2*k] # upper m qubits – scratch (starts/ends |0⟩)
flag = tgt[-1] # one shared ancilla
# copy acc into work so that we can accumulate there
for j in range(k):
qc.cx(acc[j], work[j])
for j in range(k): # multiply via “shift-add”
bit_const = (const >> j) & 1
if bit_const:
# add (2^j mod L) * y controlled on ctl & acc[j]
cc = QuantumCircuit(1, name=f'×{const}·2^{j}')
add_const_mod(qc, work + [flag], (const << j) % L, L, flag)
for t in [*work, flag]:
qc.cx(ctl, t).c_if(acc[j], 1) # dual control: ctl & acc[j]
# swap result into low register, clean ancilla
for j in range(k):
qc.cx(work[j], acc[j])
qc.cx(acc[j], work[j])
qc.cx(work[j], acc[j])
# ------------------------------------------------------------------
# complete solution
# ------------------------------------------------------------------
def solve(n: int, m: int, a: int, L: int) -> QuantumCircuit:
"""
Prepares (1/√2^n) Σ_k |k⟩ |a^k mod L⟩ with *real* modular arithmetic.
Register layout (little-endian):
x : n exponent qubits
y : m value qubits – current number (< L ≤ 2^m)
m work ancillae – scratch that returns to |0〉
1 overflow flag
"""
x = QuantumRegister(n, 'x')
y = QuantumRegister(2 * m + 1, 'y')
qc = QuantumCircuit(x, y)
# |k〉 superposition
qc.h(x)
# initialise y to 1 (multiplicative identity)
qc.x(y[0])
# repeated-squaring table a^{2^i} (mod L)
powers = [pow(a, 1 << i, L) for i in range(n)]
# for each exponent bit apply controlled modular-multiplication
for i, const in enumerate(powers):
if const != 1: # skip no-op factors
controlled_mul_const_mod(qc, x[i], list(y), const, L)
return qc
''' | ||
QPC004_C5 | A5A72EC447696 | 3 | UME | '''python
from math import pi
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import QFT # ∣x⟩↦∣x̃⟩ helper
# ------------------------------------------------------------------
# elementary arithmetic gadgets
# ------------------------------------------------------------------
def qft_add_const(qc: QuantumCircuit, q: list, c: int) -> None:
""" |x⟩ → |x+c mod 2^k⟩ (no ancilla, k = len(q))
little-endian QFT adder (Cuccaro, Draper 2000) """
k = len(q)
qc.append(QFT(k, do_swaps=False).to_gate(label='QFT'), q)
for j in range(k):
angle = 2*pi*((c % (1<<k)) >> j) / (1 << (j+1))
if abs(angle) > 1e-12:
qc.p(angle, q[j])
qc.append(QFT(k, do_swaps=False).inverse().to_gate(label='QFT†'), q)
def add_const_mod(qc: QuantumCircuit,
tgt: list, # k value qubits (little-endian)
c: int, # classical const (0 ≤ c < L)
L: int, # modulus
flag: int) -> None: # *one* ancilla qubit inside tgt-register
""" |x⟩|0⟩ → |(x+c) mod L⟩|0⟩
*flag* is the MSB of *tgt*: we recycle it as the “overflow” bit.
Steps (all reversible):
1. x ← x+c (plain addition)
2. x-L? set flag if x ≥ L (comparator)
3. conditional −L (controlled on flag)
4. uncompute comparator (flag back to |0⟩)
"""
k = len(tgt)-1 # data bits 0…k-1, flag at k
data = tgt[:k] # shorthand
fbit = tgt[k]
# 1. add c
qft_add_const(qc, data, c)
# 2. compute “x ≥ L” (compare to L-1 in two’s complement):
inv = ((1 << k) - L) # actually add (2^k − L)
qft_add_const(qc, data, inv) # x ← x + 2^k - L (mod 2^k)
qc.x(data[-1]) # MSB is 0 ↔ overflow (‖ 2’s-complement sign)
qc.cx(data[-1], fbit) # copy sign into flag
qc.x(data[-1])
# 3. if overflow, add L back
qft_add_const(qc, data, (L if c else 0)) # tidy up phase
qc.cx(fbit, data[-1])
qc.x(data[-1])
qc.cx(data[-1], fbit)
qft_add_const(qc, data, (1 << k) - L) # undo comparator residue
# 4. uncompute flag
qft_add_const(qc, data, (1 << k) - c) # restore original basis
qc.cx(data[-1], fbit) # flag back to |0〉
qft_add_const(qc, data, c) # data contains (x+c) mod L
def controlled_mul_const_mod(qc: QuantumCircuit,
ctl, tgt: list, const: int, L: int) -> None:
"""If ctl==1 multiply |y⟩ by fixed *const* modulo L (textbook “double-and-add”).
Uses the upper m ancilla qubits already available inside *tgt*.
"""
k = (len(tgt) - 1) // 2 # k = m
acc = tgt[:k] # low m qubits – current value
work = tgt[k:2*k] # upper m qubits – scratch (starts/ends |0⟩)
flag = tgt[-1] # one shared ancilla
# copy acc into work so that we can accumulate there
for j in range(k):
qc.cx(acc[j], work[j])
for j in range(k): # multiply via “shift-add”
bit_const = (const >> j) & 1
if bit_const:
# add (2^j mod L) * y controlled on ctl & acc[j]
cc = QuantumCircuit(1, name=f'×{const}·2^{j}')
add_const_mod(qc, work + [flag], (const << j) % L, L, flag)
for t in [*work, flag]:
qc.cx(ctl, t).c_if(acc[j], 1) # dual control: ctl & acc[j]
# swap result into low register, clean ancilla
for j in range(k):
qc.cx(work[j], acc[j])
qc.cx(acc[j], work[j])
qc.cx(work[j], acc[j])
# ------------------------------------------------------------------
# complete solution
# ------------------------------------------------------------------
def solve(n: int, m: int, a: int, L: int) -> QuantumCircuit:
"""
Prepares (1/√2^n) Σ_k |k⟩ |a^k mod L⟩ with *real* modular arithmetic.
Register layout (little-endian):
x : n exponent qubits
y : m value qubits – current number (< L ≤ 2^m)
m work ancillae – scratch that returns to |0〉
1 overflow flag
"""
x = QuantumRegister(n, 'x')
y = QuantumRegister(2 * m + 1, 'y')
qc = QuantumCircuit(x, y)
# |k〉 superposition
qc.h(x)
# initialise y to 1 (multiplicative identity)
qc.x(y[0])
# repeated-squaring table a^{2^i} (mod L)
powers = [pow(a, 1 << i, L) for i in range(n)]
# for each exponent bit apply controlled modular-multiplication
for i, const in enumerate(powers):
if const != 1: # skip no-op factors
controlled_mul_const_mod(qc, x[i], list(y), const, L)
return qc
''' | ||
QPC004_C5 | A5A72EC447696 | 4 | RE | 1844 ms | 158 MiB | '''python
from math import pi
from qiskit import QuantumCircuit, QuantumRegister
# ──────────────────────────────────────────────────────────────
# 1. In-place QFT / inverse QFT (little-endian, no final swaps)
# ──────────────────────────────────────────────────────────────
def qft(qc: QuantumCircuit, qubits) -> None:
"""Quantum Fourier Transform on *qubits* (little-endian, in-place)."""
n = len(qubits)
for j in range(n):
qc.h(qubits[j])
for k in range(j + 1, n):
qc.cp(pi / (1 << (k - j)), qubits[k], qubits[j])
def iqft(qc: QuantumCircuit, qubits) -> None:
"""Inverse QFT matching qft()."""
n = len(qubits)
for j in reversed(range(n)):
for k in reversed(range(j + 1, n)):
qc.cp(-pi / (1 << (k - j)), qubits[k], qubits[j])
qc.h(qubits[j])
# ──────────────────────────────────────────────────────────────
# 2. QFT-based in-register constant adder (little-endian)
# ──────────────────────────────────────────────────────────────
def qft_add_const(qc: QuantumCircuit, q, c: int) -> None:
"""|x⟩ → |x+c mod 2^k⟩ on little-endian register *q* (k = len(q))."""
k = len(q)
qft(qc, q)
for j in range(k):
angle = 2 * pi * ((c % (1 << k)) >> j) / (1 << (j + 1))
if abs(angle) > 1e-12:
qc.p(angle, q[j])
iqft(qc, q)
# ──────────────────────────────────────────────────────────────
# 3. Add-constant-mod-L gadget (Cuccaro comparator trick)
# ──────────────────────────────────────────────────────────────
def add_const_mod(qc: QuantumCircuit, tgt: list, c: int, L: int, flag):
"""
Reversible: |x⟩|0⟩ ↦ |(x+c) mod L⟩|0⟩.
*tgt* : k+1 qubits (k data, 1 overflow flag = tgt[-1] = *flag*)
*c* : classical integer < L
*L* : modulus (≤ 2^k)
"""
k = len(tgt) - 1
data = tgt[:k]
# 1. x ← x + c (mod 2^k)
qft_add_const(qc, data, c)
# 2. compute overflow : if x ≥ L copy sign bit into flag
qft_add_const(qc, data, (1 << k) - L) # add 2^k − L
qc.x(data[-1])
qc.cx(data[-1], flag)
qc.x(data[-1])
# 3. conditional −L (only if overflow flag = 1)
qc.ctrl(1)
qft_add_const(qc, data, L) # add L back (controlled)
qc.ctrl(0)
# 4. uncompute comparator & restore basis
qft_add_const(qc, data, L - c) # net effect: +(1<<k)−L−c
qc.cx(data[-1], flag)
qft_add_const(qc, data, c) # final value (x+c) mod L
# ──────────────────────────────────────────────────────────────
# 4. Controlled “× const (mod L)” via double-and-add
# ──────────────────────────────────────────────────────────────
def controlled_mul_const_mod(qc: QuantumCircuit, ctl, tgt: list,
const: int, L: int) -> None:
"""If *ctl*==1 multiply |y⟩ by *const* modulo L in-place."""
m = (len(tgt) - 1) // 2
acc = tgt[:m] # value register
work = tgt[m:2 * m] # scratch (starts/ends |0⟩)
flag = tgt[-1]
# copy acc → work (so we can accumulate result in *work*)
for j in range(m):
qc.cx(acc[j], work[j])
# “shift–add” multiply
for j in range(m):
if (const >> j) & 1:
# add (2^j · acc) controlled on ctl & acc[j]
qc.ccx(ctl, acc[j], flag) # create combined control in *flag*
add_const_mod(qc, work + [flag], (const << j) % L, L, flag)
qc.ccx(ctl, acc[j], flag) # uncompute flag
# swap result into acc, clear work
for j in range(m):
qc.cx(work[j], acc[j])
qc.cx(acc[j], work[j])
qc.cx(work[j], acc[j])
# ──────────────────────────────────────────────────────────────
# 5. Complete solver
# ──────────────────────────────────────────────────────────────
def solve(n: int, m: int, a: int, L: int) -> QuantumCircuit:
"""
Prepare |A⟩ = 2^{-n/2} Σ_k |k⟩ |a^k mod L⟩ with genuine modular arithmetic.
Layout (little-endian):
x : n – exponent
y : m – value
m – work
1 – overflow flag
"""
x = QuantumRegister(n, 'x')
y = QuantumRegister(2 * m + 1, 'y')
qc = QuantumCircuit(x, y)
# uniform superposition over |k⟩
qc.h(x)
# initial value register ← 1
qc.x(y[0])
# repeated-squaring table a^{2^i} (mod L)
powers = [pow(a, 1 << i, L) for i in range(n)]
# modular exponentiation by controlled multiplications
for i, const in enumerate(powers):
if const != 1:
controlled_mul_const_mod(qc, x[i], list(y), const, L)
return qc
''' |
QPC004_C5 | A9FDBB0D03A25 | 1 | AC | 6922 ms | 192 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import numpy as np
import math
def make_control(g, bit):
return g if bit == 0 else g.control(bit)
class QArith:
@staticmethod
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
@staticmethod
def add_const(n: int, add: int, control_bits: int = 0) -> QuantumCircuit:
from qiskit.circuit.library.standard_gates import PhaseGate
k, control = QuantumRegister(n), QuantumRegister(control_bits)
qc = QuantumCircuit(k, control)
q = QArith.qft(n)
qc.compose(q, inplace=True)
for idx in range(n):
theta = 2 * add * math.pi * (2**idx) / (2**n)
p = make_control(PhaseGate(theta), control_bits)
qc.append(p, [*control, k[idx]])
qc.compose(q.inverse(), inplace=True)
return qc
@staticmethod
def modadd_const(n: int, a: int, mod: int, control_bits: int = 0) -> QuantumCircuit:
regin, control = QuantumRegister(n + 1), QuantumRegister(control_bits)
qc = QuantumCircuit(regin, control)
def _separate_rot(n: int, s: int, t: int, control_bits: int = 0) -> QuantumCircuit:
from qiskit.circuit.library import XGate
regin, control = QuantumRegister(n + 1), QuantumRegister(control_bits)
qc = QuantumCircuit(regin, control)
mcx = make_control(XGate(), control_bits)
qc.append(mcx, [*control, regin[-1]])
qc.compose(QArith.add_const(n, -s, 1 + control_bits), inplace=True)
qc.append(mcx, [*control, regin[-1]])
qc.compose(
QArith.add_const(n, 2 ** (n + 1) - t, 1 + control_bits),
inplace=True,
)
return qc
qc.compose(
QArith.add_const(n + 1, 2**n - mod + a, control_bits),
inplace=True,
)
qc.compose(_separate_rot(n, 2**n - mod + a, 2**n + a, control_bits), inplace=True)
qc.compose(QArith.add_const(n + 1, a, control_bits), inplace=True)
return qc
@staticmethod
def modmult_const(n: int, a: int, mod: int, control_bits: int = 0) -> QuantumCircuit:
"""|x>|y> -> |x>|y+ax>"""
x, y, control = QuantumRegister(n), QuantumRegister(n + 1), QuantumRegister(control_bits)
qc = QuantumCircuit(x, y, control)
for idx in range(n):
add = a * (2**idx) % mod
qc.compose(QArith.modadd_const(n, add, mod, 1 + control_bits), [*y, *control, x[idx]], inplace=True)
return qc
@staticmethod
def modmult_const_inplace(n: int, a: int, mod: int, control_bits: int = 0) -> QuantumCircuit:
"""|x>|0> -> |ax>|0>"""
from qiskit.circuit.library import SwapGate
x, y, control = QuantumRegister(n), QuantumRegister(n + 1), QuantumRegister(control_bits)
qc = QuantumCircuit(x, y, control)
qc.compose(QArith.modmult_const(n, a, mod, control_bits), inplace=True)
cswap = make_control(SwapGate(), control_bits)
for idx in range(n):
qc.append(cswap, [*control, x[idx], y[idx]])
qc.compose(QArith.modmult_const(n, -pow(a, -1, mod), mod, control_bits), inplace=True)
return qc
def solve(n: int, m: int, a: int, mod: int) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(2 * m + 1)
qc = QuantumCircuit(x, y)
qc.h(x)
qc.x(y[0])
for idx in range(n):
multpow = QArith.modmult_const_inplace(m, pow(a, 2**idx, mod), mod, 1)
qc.compose(multpow, [*y, x[idx]], inplace=True)
return qc
''' |
QPC004_C5 | AE61DC7EA731D | 1 | RE | 2268 ms | 158 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, m: int, a: int, L: int) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(2 * m + 1)
qc = QuantumCircuit(x, y)
# Write your code here:
for i in range(n):
qc.h(x[i])
qc.x(y[0])
d=2**(2*m+1)
def U(r):
M=np.zeros((d,d),dtype=complex)
for i in range(d):
j=(i*r)%L if i<L else i
M[j,i]=1
return M
for j in range(n):
r=pow(a,2**j,L)
gate=UnitaryGate(U(r),label="U"+str(r))
cgate=gate.control(1)
qc.append(cgate,[x[j]]+list(y))
return qc
''' |
QPC005_A1 | A05D5FC6BBAE2 | 1 | AC | 1548 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.x(0)
qc.h(0)
return qc
''' |
QPC005_A1 | A06E382F5D541 | 1 | AC | 1505 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
qc.h(0)
qc.z(0)
return qc
''' |
QPC005_A1 | A0BE9E26E580F | 1 | AC | 1694 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.x(0)
qc.h(0)
return qc
''' |
QPC005_A1 | A0BEEF60F4768 | 1 | AC | 1780 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.x(0)
qc.h(0)
return qc
''' |
QPC005_A1 | A0F0BFC24656B | 1 | AC | 1476 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.x(0)
qc.h(0)
return qc
''' |
QPC005_A1 | A1582663DF007 | 1 | WA | 1576 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
qc.x(0)
qc.z(0)
return qc
''' |
QPC005_A1 | A1582663DF007 | 2 | WA | 1599 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
qc.h(0)
return qc
''' |
QPC005_A1 | A1582663DF007 | 3 | AC | 1431 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
qc.h(0)
qc.z(0)
return qc
''' |
QPC005_A1 | A1F54CA412CF2 | 1 | AC | 1619 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
qc.x(0)
qc.h(0)
return qc
''' |
QPC005_A1 | A2BA1C068EDF5 | 1 | AC | 1648 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.x(0)
qc.h(0)
return qc
''' |
QPC005_A1 | A2D03F3B4C72E | 1 | RE | 1525 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.x()
qc.h()
return qc
''' |
QPC005_A1 | A2D03F3B4C72E | 2 | WA | 1577 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.z(0)
qc.h(0)
return qc
''' |
QPC005_A1 | A2D03F3B4C72E | 3 | AC | 1761 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.h(0)
qc.z(0)
return qc
''' |
QPC005_A1 | A2EDD68B9135A | 1 | AC | 1726 ms | 142 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import numpy as np
def solve():
qc = QuantumCircuit(1)
qc.x(range(1))
qc.h(range(1))
return qc
''' |
QPC005_A1 | A32705E0407B6 | 1 | AC | 1635 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.x(0)
qc.h(0)
return qc
''' |
QPC005_A1 | A35DF60212067 | 1 | AC | 1614 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.x(0)
qc.h(0)
return qc
''' |
QPC005_A1 | A3AE260FA7444 | 1 | WA | 1599 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
return qc
''' |
QPC005_A1 | A3AE260FA7444 | 2 | AC | 1598 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.x(0)
qc.h(0)
return qc
''' |
QPC005_A1 | A3CD30B16E678 | 1 | AC | 1650 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.x(0)
qc.h(0)
return qc
''' |
QPC005_A1 | A4331BE1D88F8 | 1 | AC | 1660 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.x(0)
qc.h(0)
return qc
''' |
QPC005_A1 | A487BE2155FD7 | 1 | AC | 1533 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.x(0)
qc.h(0)
return qc
''' |
QPC005_A1 | A49922F869F23 | 1 | AC | 1776 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.h(0)
qc.z(0)
return qc
''' |
QPC005_A1 | A51C3E261CD21 | 1 | AC | 1661 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.x(0)
qc.h(0)
return qc
''' |
QPC005_A1 | A5274E872E9EA | 1 | RE | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc = qc.0
qc = qc.minus
return qc
''' | ||
QPC005_A1 | A5274E872E9EA | 2 | RE | 1590 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc=qc.x(0)
qc=qc.h(0)
return qc
''' |
QPC005_A1 | A5274E872E9EA | 3 | AC | 1700 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.x(0)
qc.h(0)
return qc
''' |
QPC005_A1 | A5B31B5EB6667 | 1 | AC | 1699 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.x(0)
qc.h(0)
return qc
''' |
QPC005_A1 | A5E4EA4DA33F5 | 1 | AC | 1543 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.h(0)
qc.z(0)
return qc
''' |
QPC005_A1 | A5FAB0EA612F5 | 1 | AC | 1604 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.x(0)
qc.h(0)
return qc
''' |
QPC005_A1 | A6A59B946F777 | 1 | AC | 1673 ms | 142 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from math import pi, acos, sqrt, asin
from qiskit.circuit.library import XGate, ZGate, PhaseGate
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
qc.x(0)
qc.h(0)
return qc
''' |
QPC005_A1 | A6C87E094CE61 | 1 | AC | 1659 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.x(0)
qc.h(0)
return qc
''' |
QPC005_A1 | A6F65BB19E586 | 1 | RE | 1658 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.x(0)
qc.cx(0, 1)
qc.h(0)
qc.cx(0, 1)
return qc
''' |
QPC005_A1 | A6F65BB19E586 | 2 | AC | 1506 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.x(0)
qc.h(0)
return qc
''' |
QPC005_A1 | A72EFDE62ABFF | 1 | AC | 1617 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.x(0)
qc.h(0)
return qc
''' |
QPC005_A1 | A791BAB14EE0A | 1 | WA | 1625 ms | 143 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.x(0) # Xゲート
qc.z(0) # Zゲート
qc.x(0) # Xゲート
return qc
print(solve().draw())
''' |
QPC005_A1 | A791BAB14EE0A | 2 | RE | 1367 ms | 141 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.initialize(initial_state, 0)
qc.x(0) # Xゲート
qc.z(0) # Zゲート
qc.x(0) # Xゲート
return qc
print(solve().draw())
''' |
QPC005_A1 | A791BAB14EE0A | 3 | AC | 1547 ms | 144 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.h(0)
qc.z(0)
return qc
print(solve().draw())
''' |
QPC005_A1 | A83DAC814D178 | 1 | AC | 1701 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.h(0)
qc.z(0)
return qc
''' |
QPC005_A1 | A8DA370228755 | 1 | AC | 1652 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.x(0)
qc.h(0)
return qc
''' |
QPC005_A1 | A8FF3D621FF36 | 1 | AC | 1531 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.x(0)
qc.h(0)
return qc
''' |
QPC005_A1 | A917F53FD43EC | 1 | AC | 1672 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.x(0)
qc.h(0)
return qc
''' |
QPC005_A1 | A9B3BB9338454 | 1 | AC | 1531 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.x(0)
qc.h(0)
return qc
''' |
QPC005_A1 | A9F155ED37DD1 | 1 | AC | 1602 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
qc.x(0)
qc.h(0)
return qc
''' |
QPC005_A1 | AA1062C37AFBE | 1 | WA | 1653 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.h(0)
qc.x(0)
return qc
''' |
QPC005_A1 | AA1062C37AFBE | 2 | AC | 1530 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.h(0)
qc.z(0)
return qc
''' |
QPC005_A1 | AA5A02268FB76 | 1 | WA | 1631 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc = QuantumCircuit(1)
qc.h(0)
return qc
''' |
QPC005_A1 | AA5A02268FB76 | 2 | WA | 1648 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.h(0)
return qc
''' |
QPC005_A1 | AA5A02268FB76 | 3 | AC | 1781 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.x(0)
qc.h(0)
return qc
''' |
QPC005_A1 | AAC007E1F4D88 | 1 | AC | 1587 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.x(0)
qc.h(0)
return qc
''' |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.