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_B2 | AF95927B7CA88 | 36 | RE | 1904 ms | 158 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
for i in range(n):
theta = (2 * math.pi * a * 2**i) / 2**n
qc.cp(theta,c[0],i)
return qc
''' |
QPC004_B2 | AF95927B7CA88 | 37 | RE | 1553 ms | 157 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
for i in range(n):
theta = 2 * math.pi * a * 2**i / 2**n
qc.cp(theta,c[0],i)
return qc
''' |
QPC004_B2 | AF95927B7CA88 | 38 | RE | 1623 ms | 157 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(n+1)
# Write your code here:
for i in range(n):
theta = 2 * math.pi * a * 2**i / 2**n
qc.cp(theta,c[0],i)
return qc
''' |
QPC004_B2 | AF95927B7CA88 | 39 | RE | 1534 ms | 158 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k,c)
# Write your code here:
for i in range(n):
theta = 2 * math.pi * a * 2**i / 2**n
qc.cp(theta,c[0],i)
return qc
''' |
QPC004_B2 | AF95927B7CA88 | 40 | RE | 1593 ms | 157 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k,c)
# Write your code here:
for i in range(n):
theta = 2 * math.pi * a * 2**i / 2**n
qc.cp(theta,n,i)
return qc
''' |
QPC004_B2 | AF95927B7CA88 | 41 | RE | 1656 ms | 158 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, a: int) -> QuantumCircuit:
#k, c = QuantumRegister(n), QuantumRegister(1)
#qc = QuantumCircuit(k,c)
qc = QuantumCircuit(n + 1)
# Write your code here:
for i in range(n):
theta = 2 * math.pi * a * 2**i / 2**n
qc.cp(theta,n,i)
return qc
''' |
QPC004_B2 | AF95927B7CA88 | 42 | RE | 1603 ms | 157 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, a: int) -> QuantumCircuit:
#k, c = QuantumRegister(n), QuantumRegister(1)
#qc = QuantumCircuit(k,c)
qc = QuantumCircuit(n + 1)
# Write your code here:
for i in range(n):
theta = 2 * math.pi * a * 2**i / 2**n
qc.cp(theta, n, i)
return qc
''' |
QPC004_B2 | AF95927B7CA88 | 43 | RE | 1500 ms | 158 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k,c)
# Write your code here:
for i in range(n):
theta = 2 * math.pi * a * 2**i / 2**n
qc.cp(theta, n, i)
return qc
''' |
QPC004_B2 | AF95927B7CA88 | 44 | AC | 2257 ms | 162 MiB | '''python
import math
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k,c)
# Write your code here:
for i in range(n):
theta = 2 * math.pi * a * 2**i / 2**n
qc.cp(theta, n, i)
return qc
''' |
QPC004_B2 | AFF75B7A1E312 | 1 | AC | 2513 ms | 163 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
for i in range(n):
qc.cp(2*math.pi*a*2**i/2**n, c, i)
return qc
''' |
QPC004_B3 | A11896B000A31 | 1 | RE | 1894 ms | 157 MiB | '''python
from qiskit import QuantumCircuit
from math import pi
def QFT(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in reversed(range(n)):
qc.h(i)
for j in reversed(range(i)):
qc.cp(pi/(2**(i-j)), j, i)
for i in range(n//2):
qc.swap(i, n - i - 1)
return qc
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
qc.compose(QFT(n), k, inplace = True)
a_list = [(a//(2**i))%2 for i in range(n)]
for i in range(n):
qc.cp(2*pi*a_list[i]/(2**(n - i)), n, i)
qc.compose(QFT(n).inverse(), k, inplace = True)
return qc
''' |
QPC004_B3 | A11896B000A31 | 2 | RE | 1506 ms | 157 MiB | '''python
from qiskit import QuantumCircuit
from math import pi
def QFT(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in reversed(range(n)):
qc.h(i)
for j in reversed(range(i)):
qc.cp(pi/(2**(i-j)), j, i)
for i in range(n//2):
qc.swap(i, n - i - 1)
return qc
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
qc.compose(QFT(n), k, inplace = True)
a_list = [(a//(2**i))%2 for i in range(n)]
for i in range(n):
qc.cp(2*pi*a_list[i]/(2**(n - i)), n, i)
qc.compose(QFT(n).inverse(), k, inplace = True)
return qc
''' |
QPC004_B3 | A11896B000A31 | 3 | RE | 1686 ms | 157 MiB | '''python
from qiskit import QuantumCircuit
from math import pi
def QFT(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in reversed(range(n)):
qc.h(i)
for j in reversed(range(i)):
qc.cp(pi/(2**(i-j)), j, i)
for i in range(n//2):
qc.swap(i, n - i - 1)
return qc
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
qc.compose(QFT(n), k, inplace = True)
a_list = [(a//(2**i))%2 for i in range(n)]
for i in range(n):
qc.cp(2*pi*a_list[i]/(2**(n - i)), n, i)
qc.compose(QFT(n).inverse(), k, inplace = True)
return qc
''' |
QPC004_B3 | A11896B000A31 | 4 | RE | 1632 ms | 158 MiB | '''python
from qiskit import QuantumCircuit
from math import pi
def tmp(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in reversed(range(n)):
qc.h(i)
for j in reversed(range(i)):
qc.cp(pi/(2**(i-j)), j, i)
for i in range(n//2):
qc.swap(i, n - i - 1)
return qc
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
qc.compose(tmp(n), k, inplace = True)
a_list = [(a//(2**i))%2 for i in range(n)]
for i in range(n):
qc.cp(2*pi*a_list[i]/(2**(n - i)), n, i)
qc.compose(tmp(n).inverse(), k, inplace = True)
return qc
''' |
QPC004_B3 | A152FFAB6B770 | 1 | AC | 2220 ms | 163 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from math import tau, pi
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
for i in range(n - 1, -1, -1):
qc.h(i)
for j in range(i - 1, -1, -1):
qc.cp(pi / (1 << (i - j)), j, i)
for i in range(n):
theta = tau / (1 << n - i)
# qc.cp(a * theta[i], k[n - 1 - i])
qc.cp(a * theta, c[0], k[n - 1 - i])
for i in range(n):
for j in range(i):
qc.cp(-pi / (1 << (i - j)), j, i)
qc.h(i)
return qc
''' |
QPC004_B3 | A2D27FB7ED6EA | 1 | AC | 2950 ms | 162 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
# from qiskit.quantum_info import Statevector
def quantum_fourier_transform(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n-1, -1, -1):
qc.h(i)
for j in range(i-1, -1, -1):
qc.cp(2*math.pi/(2**(i-j+1)), j, i)
i = 0
while i<n-i-1:
qc.swap(i, n-i-1)
i += 1
return qc
def b2(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# init = [0]*(2**(n+1))
# init[2**n+1]=1
# qc.initialize(init)
# Write your code here:
for i in range(n):
qc.mcp(2*math.pi*a/(2**(n-i)), [n], i)
return qc
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
qc.compose(quantum_fourier_transform(n), k, inplace=True)
for i in range(n):
qc.mcp(2*math.pi*a/(2**(n-i)), [n], i)
qc.compose(quantum_fourier_transform(n).inverse(), k, inplace=True)
return qc
# if __name__ == "__main__":
# qc = solve(3, 1)
# print(Statevector(qc))
''' |
QPC004_B3 | A35C170FE5AC1 | 1 | WA | 1806 ms | 163 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
for i in range(n):
if (a >> i) & 1:
qc.cx(c[0], k[i])
return qc
''' |
QPC004_B3 | A35C170FE5AC1 | 2 | WA | 1802 ms | 161 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
for i in range(n):
if (a >> i) & 1:
qc.cx(c[0], k[i])
return qc
''' |
QPC004_B3 | A35C170FE5AC1 | 3 | RE | 1561 ms | 159 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
# 補助レジスタ
carry = QuantumRegister(1, 'carry')
result = QuantumRegister(n, 'result')
qc.add_register(carry, result)
# cの値に応じてaを加算
for i in range(n):
qc.cx(c, k[i])
# k + a mod 2^n を計算
for i in range(n):
qc.ccx(k[i], carry, result[i])
qc.cx(k[i], carry)
qc.cx(carry, result[i])
# 結果をkレジスタにコピー
for i in range(n):
qc.cx(result[i], k[i])
# 補助レジスタをリセット
for i in range(n):
qc.cx(result[i], result[i])
qc.cx(carry, carry)
return qc
''' |
QPC004_B3 | A35C170FE5AC1 | 4 | WA | 1761 ms | 162 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
for i in range(n):
# a の i 番目のビットが 1 の場合に制御加算
if (a >> i) & 1:
qc.cx(c, k[i])
return qc
''' |
QPC004_B3 | A35C170FE5AC1 | 5 | WA | 1966 ms | 162 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
for i in range(n):
if (a >> i) & 1:
qc.cx(c, k[i])
qc.barrier()
return qc
''' |
QPC004_B3 | A35C170FE5AC1 | 6 | WA | 2069 ms | 162 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
for i in range(n):
if (a >> i) & 1:
qc.cx(k[i], k[(i + 1) % n])
return qc
''' |
QPC004_B3 | A35C170FE5AC1 | 7 | WA | 1686 ms | 162 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
for i in range(n):
if (a >> i) & 1:
qc.cx(c, k[i])
return qc
''' |
QPC004_B3 | A3900E3AFAB4F | 1 | AC | 2066 ms | 162 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 solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
qc.compose(qft(n), inplace=True)
for idx in range(n):
theta = 2 * a * math.pi * (2**idx) / (2**n)
qc.cp(theta, c, k[idx])
qc.compose(qft(n).inverse(), inplace=True)
return qc
''' |
QPC004_B3 | A4D060D0F83CA | 1 | WA | 2108 ms | 162 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
for i in range(n):
if (a & (1 << i)):
qc.cx(c[0], k[n - i - 1])
return qc
''' |
QPC004_B3 | A4D060D0F83CA | 2 | AC | 2096 ms | 163 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
for i in range(n):
if (a & (1 << i)):
print(i)
n_not = n - i
for j in range(i+n_not-1, i-1, -1):
qc.mcx(k[i:j] + [c[0]], k[j])
return qc
''' |
QPC004_B3 | A63F29E56028A | 1 | WA | 2194 ms | 163 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def qft_rotations(qc, n):
"""Apply QFT rotations to specified qubits"""
for i in range(n):
qc.h(i)
for j in range(i+1, n):
qc.cp(math.pi/float(2**(j-i)), j, i)
def inverse_qft_rotations(qc, n):
"""Apply inverse QFT rotations to specified qubits"""
for i in range(n-1, -1, -1):
for j in range(n-1, i, -1):
qc.cp(-math.pi/float(2**(j-i)), j, i)
qc.h(i)
def add_constant(qc, n, a, control):
"""Add constant a (controlled by control qubit) using phase rotations"""
for i in range(n):
angle = (2 * math.pi * (a / (2 ** (n-i)))) % (2 * math.pi)
if angle != 0: # Only apply non-zero rotations
qc.cp(angle, control, i)
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Apply QFT to register k
qft_rotations(qc, n)
# Add constant a controlled by c
add_constant(qc, n, a, n)
# Apply inverse QFT
inverse_qft_rotations(qc, n)
return qc
''' |
QPC004_B3 | A63F29E56028A | 2 | RE | 1832 ms | 159 MiB | '''python
import numpy as np
from qiskit import QuantumCircuit, QuantumRegister
def manual_qft(n):
"""Manually implements 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 rotation
return qc
def manual_iqft(n):
"""Manually implements the Inverse Quantum Fourier Transform (IQFT)."""
return manual_qft(n).inverse()
def controlled_modular_addition(n, a):
"""Implements controlled modular addition using QFT & controlled phase shifts."""
qc = QuantumCircuit(n + 1) # Extra qubit for control
# Apply QFT to the lower n qubits (excluding control qubit)
qc.append(manual_qft(n), range(n))
# Apply controlled phase shifts based on the bits of 'a'
for i in range(n):
if (a >> i) & 1: # Check if the i-th bit of 'a' is set
qc.cp(np.pi / 2**(n - i - 1), n, i) # Apply controlled phase shift
# Apply inverse QFT
qc.append(manual_iqft(n), range(n))
return qc
def solve(n: int, a: int) -> QuantumCircuit:
"""Constructs the 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 only when c = 1
controlled_add = controlled_modular_addition(n, a).to_gate(label="C-ADD(a)").control(1)
# Apply controlled modular addition with explicit control
qc.append(controlled_add, [c_reg[0]] + k_reg[:])
return qc
''' |
QPC004_B3 | A63F29E56028A | 3 | RE | 1858 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_B3 | A63F29E56028A | 4 | WA | 2081 ms | 162 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, a: int) -> QuantumCircuit:
k = QuantumRegister(n, 'k')
c = QuantumRegister(1, 'c')
qc = QuantumCircuit(k, c)
# Iterate through each bit of 'a' to perform the addition
for i in range(n):
if (a >> i) & 1:
# Apply controlled-X gate if the bit is 1
qc.mcx([c[0]] + [k[j] for j in range(i)], k[i])
return qc
''' |
QPC004_B3 | A63F29E56028A | 5 | WA | 1983 ms | 162 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, a: int) -> QuantumCircuit:
# Create quantum registers and circuit
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Implement controlled addition of constant a
# We'll add the constant only when c=1
for i in range(n):
if (a >> i) & 1: # Check if ith bit of a is 1
# Add controlled-NOT gates where needed
qc.cx(c[0], k[i])
# Handle carry propagation
for j in range(i+1, n):
if (a >> j) & 1:
qc.ccx(c[0], k[i], k[j])
return qc
''' |
QPC004_B3 | A69EBF157126A | 1 | WA | 1821 ms | 162 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def qft(qc: QuantumCircuit, qubits, inverse=False):
"""
リトルエンディアン版の QFT/iQFT (n^2ステップの素朴実装)。
- qubits[0] が最下位ビット
- inverse=False: 順QFT
- inverse=True : 逆QFT (iQFT)
"""
n = len(qubits)
if not inverse:
# --- 順QFT ---
for j in range(n):
# 1量子ビットH
qc.h(qubits[j])
# 制御位相 cp(π/2^(m-j)) for m = j+1..n-1
for m in range(j+1, n):
angle = math.pi / (2**(m-j))
qc.cp(angle, qubits[m], qubits[j])
# ビット順反転
for i in range(n // 2):
qc.swap(qubits[i], qubits[n - 1 - i])
else:
# --- 逆QFT ---
# ビット順反転
for i in range(n // 2):
qc.swap(qubits[i], qubits[n - 1 - i])
# 上から下へ
for j in reversed(range(n)):
for m in reversed(range(j+1, n)):
angle = - math.pi / (2**(m-j))
qc.cp(angle, qubits[m], qubits[j])
qc.h(qubits[j])
def solve(n: int, a: int) -> QuantumCircuit:
"""
問題:
整数 n, a (1 <= n <= 10, 0 <= a < 2^n) が与えられる。
0 <= k < 2^n, c in {0,1} の任意の組に対し、
|k>_n|c>_1 --> |(k + c*a) mod 2^n>_n |c>_1
を実装する量子回路 qc を構成せよ。
リトルエンディアン:
k[0] が最下位ビット (2^0)。
"""
# レジスタ k: n量子ビット, c: 1量子ビット
k = QuantumRegister(n, 'k')
c = QuantumRegister(1, 'c')
qc = QuantumCircuit(k, c)
# --- 1) QFT(k) ---
qft(qc, k, inverse=False)
# --- 2) c=1 のときだけ k に「 + a 」を加算する
# 具体的にはビット j=0..n-1 に単制御位相 cp( 2π a 2^j / 2^n )
# リトルエンディアンなので k[j] は 2^j の重み
for j in range(n):
theta_j = 2 * math.pi * a * (2**j) / (2**n)
qc.cp(theta_j, c[0], k[j])
# --- 3) iQFT(k) ---
qft(qc, k, inverse=True)
return qc
''' |
QPC004_B3 | A69EBF157126A | 2 | WA | 1953 ms | 162 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def qft(qc: QuantumCircuit, qubits, inverse=False):
"""
リトルエンディアン版の QFT/iQFT (n^2ステップの素朴実装)。
- qubits[0] が最下位ビット
- inverse=False: 順QFT
- inverse=True : 逆QFT (iQFT)
"""
n = len(qubits)
if not inverse:
# --- 順QFT ---
for j in range(n):
# 1量子ビットH
qc.h(qubits[j])
# 制御位相 cp(π/2^(m-j)) for m = j+1..n-1
for m in range(j+1, n):
angle = math.pi / (2**(m-j))
qc.cp(angle, qubits[m], qubits[j])
# ビット順反転
for i in range(n // 2):
qc.swap(qubits[i], qubits[n - 1 - i])
else:
# --- 逆QFT ---
# ビット順反転
for i in range(n // 2):
qc.swap(qubits[i], qubits[n - 1 - i])
# 上から下へ
for j in reversed(range(n)):
for m in reversed(range(j+1, n)):
angle = - math.pi / (2**(m-j))
qc.cp(angle, qubits[m], qubits[j])
qc.h(qubits[j])
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
# --- 1) QFT(k) ---
qft(qc, k, inverse=False)
# --- 2) c=1 のときだけ k に「 + a 」を加算する
# 具体的にはビット j=0..n-1 に単制御位相 cp( 2π a 2^j / 2^n )
# リトルエンディアンなので k[j] は 2^j の重み
for j in range(n):
theta_j = 2 * math.pi * a * (2**j) / (2**n)
qc.cp(theta_j, c[0], k[j])
# --- 3) iQFT(k) ---
qft(qc, k, inverse=True)
return qc
''' |
QPC004_B3 | A69EBF157126A | 3 | RE | 1475 ms | 158 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
for j in range(n):
theta_j = 2 * math.pi * a * (2**j) / (2**n)
qc.cp(theta_j, c[0], k[j])
return qc
''' |
QPC004_B3 | A69EBF157126A | 4 | UME | '''python
from qiskit.quantum_info import Statevector
from qiskit.visualization import *
from qiskit import QuantumCircuit, QuantumRegister
import math
def qft(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in reversed(range(n)):
qc.h(i)
for j in reversed(range(i)):
qc.cp(math.pi / 2 ** (i - j), j, i)
for i in range(n // 2):
qc.swap(i, n - i - 1)
return qc
# B2
def crot(n: int, a: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
for i in range(n):
theta = 2 * math.pi * a * 2**i / 2**n
qc.cp(theta, n, i)
return qc
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
qc.compose(qft(n), qubits=k, inplace=True)
qc.compose(crot(n, a), qubits=[*k, *c], inplace=True)
qc.compose(qft(n).inverse(), qubits=k, inplace=True)
return qc
''' | ||
QPC004_B3 | A69EBF157126A | 5 | AC | 2058 ms | 161 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def qft(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in reversed(range(n)):
qc.h(i)
for j in reversed(range(i)):
qc.cp(math.pi / 2 ** (i - j), j, i)
for i in range(n // 2):
qc.swap(i, n - i - 1)
return qc
# B2
def crot(n: int, a: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
for i in range(n):
theta = 2 * math.pi * a * 2**i / 2**n
qc.cp(theta, n, i)
return qc
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
qc.compose(qft(n), qubits=k, inplace=True)
qc.compose(crot(n, a), qubits=[*k, *c], inplace=True)
qc.compose(qft(n).inverse(), qubits=k, inplace=True)
return qc
''' |
QPC004_B3 | A7334C22761EA | 1 | AC | 2084 ms | 143 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
def f(num):
for i in reversed(range(num,n)):
qc.mcx(list(range(num,i))+[n],i)
for i in range(n):
if 2**i ^ a < a:
f(i)
return qc
solve(4,3).draw()
''' |
QPC004_B3 | A87A5CE9D96A3 | 1 | WA | 2956 ms | 158 MiB | '''python
from math import pi
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, a: int) -> QuantumCircuit:
"""
Construct a quantum circuit that realises the oracle O:
|k⟩_n |c⟩ → |(k + c·a) mod 2^n⟩_n |c⟩ (little-endian)
No ancilla qubits are used, only the given n+1 qubits.
"""
# Registers (little-endian: qubit 0 = LSB)
k = QuantumRegister(n, "k") # data register
c = QuantumRegister(1, "c") # control qubit
qc = QuantumCircuit(k, c)
# --- 1. Quantum Fourier Transform on k (little-endian, no swaps) ---
for i in range(n): # iterate LSB → MSB
qc.h(k[i])
for j in range(i + 1, n):
angle = pi / (2 ** (j - i)) # controlled phase R_{j-i+1}
qc.cp(angle, k[j], k[i])
# --- 2. Controlled phase rotations encoding +a when c == 1 ---
for i in range(n):
# fractional part of a / 2^{i+1}
frac = (a % (1 << (i + 1))) / (1 << (i + 1))
angle = 2 * pi * frac # 2π * frac
if angle: # skip zero rotations
qc.cp(angle, c[0], k[i]) # controlled by c
# --- 3. Inverse QFT on k (undo step 1) ---
for i in reversed(range(n)):
for j in reversed(range(i + 1, n)):
angle = -pi / (2 ** (j - i))
qc.cp(angle, k[j], k[i])
qc.h(k[i])
return qc
''' |
QPC004_B3 | A87A5CE9D96A3 | 2 | WA | 2794 ms | 160 MiB | '''python
import math
from math import pi
from qiskit import QuantumCircuit, QuantumRegister
def qft(qc: QuantumCircuit, q: QuantumRegister) -> None:
"""ビッグエンディアン実装 (SWAP あり)"""
n = len(q)
for i in reversed(range(n)):
qc.h(q[i])
for j in reversed(range(i)):
qc.cp(pi / 2 ** (i - j), q[j], q[i])
for i in range(n // 2): # 反転してリトルエンディアンに戻す
qc.swap(q[i], q[n - i - 1])
def iqft(qc: QuantumCircuit, q: QuantumRegister) -> None:
"""qft の逆演算"""
n = len(q)
for i in reversed(range(n // 2)): # SWAP を先に戻す
qc.swap(q[i], q[n - i - 1])
for i in range(n):
for j in range(i):
qc.cp(-pi / 2 ** (i - j), q[j], q[i])
qc.h(q[i])
def solve(n: int, a: int) -> QuantumCircuit:
"""
Oracle O:
|k⟩_n |c⟩ → |(k + c·a) mod 2^n⟩_n |c⟩
* 整数はリトルエンディアン (qubit 0 = LSB)
* 追加の量子ビットは使用しない
"""
k = QuantumRegister(n, "k") # データレジスタ
c = QuantumRegister(1, "c") # 制御ビット
qc = QuantumCircuit(k, c)
# 1. QFT
qft(qc, k) # ここでレジスタは再びリトルエンディアン順
# 2. +a を位相に刻む（c==1 のときのみ）
# 各フーリエ量子ビット i (LSB から) に角度 2π·a / 2^{i+1}
for i in range(n):
angle = (2 * pi * a) / (1 << (i + 1))
# 角度が 0 (a が 2^{i+1} の倍数) ならスキップ
if angle % (2 * pi):
qc.cp(angle, c[0], k[i])
# 3. 逆 QFT
iqft(qc, k)
return qc
''' |
QPC004_B3 | A87A5CE9D96A3 | 3 | AC | 2737 ms | 161 MiB | '''python
import math
from math import pi
from qiskit import QuantumCircuit, QuantumRegister
def qft_le(qc: QuantumCircuit, q: QuantumRegister) -> None:
"""little-endian QFT with final SWAP (式(2) を実現)"""
n = len(q)
for i in reversed(range(n)):
qc.h(q[i])
for j in reversed(range(i)):
qc.cp(pi / 2**(i - j), q[j], q[i])
for i in range(n // 2):
qc.swap(q[i], q[n - i - 1])
def iqft_le(qc: QuantumCircuit, q: QuantumRegister) -> None:
n = len(q)
for i in reversed(range(n // 2)):
qc.swap(q[i], q[n - i - 1])
for i in range(n):
for j in range(i):
qc.cp(-pi / 2**(i - j), q[j], q[i])
qc.h(q[i])
def solve(n: int, a: int) -> QuantumCircuit:
"""
|k⟩_n|c⟩ → |(k + c·a) mod 2^n⟩_n|c⟩ (little-endian, ancilla-free)
"""
k = QuantumRegister(n, "k") # データ
c = QuantumRegister(1, "c") # 制御
qc = QuantumCircuit(k, c)
# 1) QFT
qft_le(qc, k)
# 2) controlled R_i(a) — 角度は 2π a / 2^{n-i} !
for i in range(n):
angle = 2 * pi * a / (1 << (n - i))
if angle % (2 * pi):
qc.cp(angle, c[0], k[i]) # 控えめに skip(0∘)
# 3) inverse QFT
iqft_le(qc, k)
return qc
''' |
QPC004_B3 | A905992469825 | 1 | AC | 2291 ms | 163 MiB | '''python
from math import ceil,floor,acos,asin,atan,sqrt,pi,gcd,sin,cos,tan
from qiskit import QuantumCircuit,QuantumRegister
def qft(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in reversed(range(n)):
qc.h(i)
for j in reversed(range(i)):
qc.cp(pi / 2 ** (i - j), j, i)
for i in range(n // 2):
qc.swap(i, n - i - 1)
return qc
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
qft_n =qft(n)
qc.compose(qft_n,k,inplace=True)
for i in range(n):
theta = 2 * pi * a * 2**i / 2**n
qc.cp(theta,n, i)
qc.compose(qft_n.inverse(),k,inplace=True)
return qc
''' |
QPC004_B3 | A949A12AF4E8B | 1 | RE | 2061 ms | 157 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
# QFT
for i in reversed(range(n)):
qc.h(i)
for j in reversed(range(i)):
qc.cp(math.pi / 2 ** (i - j), j, i)
for i in range(n // 2):
qc.swap(i, n - i - 1)
# B2
for i in range(n):
qc.cp(2 * math.pi * a * 2 ** (i - n), c[0], k[i])
# IQFT
for i in reversed(range(n // 2)):
qc.swap(i, n - i - 1)
for i in reversed(range(n)):
for j in reversed(range(i)):
qc.cp(-math.pi / 2 ** (i - j), j, i)
qc.h(i)
return qc
''' |
QPC004_B3 | A949A12AF4E8B | 2 | WA | 1729 ms | 161 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
# QFT
for i in reversed(range(n)):
qc.h(i)
for j in reversed(range(i)):
qc.cp(math.pi / 2 ** (i - j), j, i)
for i in range(n // 2):
qc.swap(i, n - i - 1)
# B2
for i in range(n):
qc.cp(2 * math.pi * a * 2 ** (i - n), c[0], k[i])
# IQFT
for i in reversed(range(n // 2)):
qc.swap(i, n - i - 1)
for i in reversed(range(n)):
for j in reversed(range(i)):
qc.cp(-math.pi / 2 ** (i - j), j, i)
qc.h(i)
return qc
''' |
QPC004_B3 | A949A12AF4E8B | 3 | WA | 1973 ms | 161 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
# QFT
for i in reversed(range(n)):
qc.h(i)
for j in reversed(range(i)):
qc.cp(math.pi / 2 ** (i - j), j, i)
for i in range(n // 2):
qc.swap(i, n - i - 1)
# B2
for i in range(n):
qc.cp(2 * math.pi * a * 2 ** (i - n), c[0], k[i])
# IQFT
for i in reversed(range(n)):
for j in reversed(range(i)):
qc.cp(-math.pi / 2 ** (i - j), j, i)
qc.h(i)
return qc
''' |
QPC004_B3 | A949A12AF4E8B | 4 | AC | 2195 ms | 163 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
# QFT
for i in reversed(range(n)):
qc.h(i)
for j in reversed(range(i)):
qc.cp(math.pi / 2 ** (i - j), j, i)
for i in range(n // 2):
qc.swap(i, n - i - 1)
# B2
for i in range(n):
qc.cp(2 * math.pi * a * 2 ** (i - n), c[0], k[i])
# IQFT
for i in reversed(range(n // 2)):
qc.swap(i, n - i - 1)
for i in range(n):
for j in range(i):
qc.cp(-math.pi / 2 ** (i - j), j, i)
qc.h(i)
return qc
''' |
QPC004_B3 | A9681F87D02A7 | 1 | AC | 2228 ms | 161 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import ZGate, XGate, HGate, SwapGate
import math
def qft(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in reversed(range(n)):
qc.h(i)
for j in reversed(range(i)):
theta = math.pi / 2 ** (i - j)
qc.cp(theta, j, i)
for i in range(n // 2):
qc.swap(i, n - i - 1)
return qc
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
qc.compose(qft(n), inplace=True)
for i in range(n):
theta = 2 * math.pi * a * (2 ** i) / (2 ** n)
qc.cp(theta, k[i], c)
qc.compose(qft(n).inverse(), inplace=True)
return qc
''' |
QPC004_B3 | ABA0FBCE63148 | 1 | AC | 2060 ms | 161 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
for _ in range(a):
for i in range(n-1,-1,-1):
qc.mcx([n]+list(range(i)),i)
return qc
''' |
QPC004_B3 | ABD8320A7C0BA | 1 | RE | 1602 ms | 143 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import numpy as np
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
for i in range(n):
qc.ch(n, i)
for j in range(i+1, n):
qc.mcp(2 * np.pi / 2 ** (j), [j, n], i)
for i in range(n // 2):
qc.cswap(n, i, (n - i - 1))
for i in range(n):
angle = (2 * np.pi * ((a >> i) & 1)) / 2 ** (i + 1)
if (angle != 0):
qc.cp(n, angle, i)
for i in range(n // 2):
qc.cswap(n, i, (n - i - 1))
for i in reversed(range(n)):
for j in reversed(range(i + 1, n)):
qc.mcp(-2 * np.pi / 2 ** (j), [j, n], i)
qc.ch(n, i)
return qc
''' |
QPC004_B3 | ABD8320A7C0BA | 2 | WA | 1768 ms | 145 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import numpy as np
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
for i in range(n):
qc.ch(n, i)
for j in range(i+1, n):
qc.mcp(2 * np.pi / 2 ** (j), [j, n], i)
for i in range(n // 2):
qc.cswap(n, i, (n - i - 1))
for i in range(n):
angle = (2 * np.pi * ((a >> i) & 1)) / 2 ** (i + 1)
if (angle != 0):
qc.cp(angle, n, i)
for i in range(n // 2):
qc.cswap(n, i, (n - i - 1))
for i in reversed(range(n)):
for j in reversed(range(i + 1, n)):
qc.mcp(-2 * np.pi / 2 ** (j), [j, n], i)
qc.ch(n, i)
return qc
''' |
QPC004_B3 | ABD8320A7C0BA | 3 | WA | 1649 ms | 143 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import numpy as np
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
for i in range(n):
qc.ch(n, i)
for j in range(i+1, n):
qc.mcp(2 * np.pi / 2 ** (j), [j, n], i)
for i in range(n // 2):
qc.cswap(n, i, (n - i - 1))
for i in range(n):
angle = (2 * np.pi * ((a >> i) & 1)) / 2 ** (i + 1)
qc.cp(angle, n, i)
for i in range(n // 2):
qc.cswap(n, i, (n - i - 1))
for i in reversed(range(n)):
for j in reversed(range(i + 1, n)):
qc.mcp(-2 * np.pi / 2 ** (j), [j, n], i)
qc.ch(n, i)
return qc
''' |
QPC004_B3 | ABD8320A7C0BA | 4 | AC | 1785 ms | 143 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import HGate, ZGate, XGate, PhaseGate
from qiskit import QuantumRegister
import math
def QFT(qc : QuantumCircuit, idx : list[int], inversed : bool = False) -> QuantumCircuit:
n = len(idx)
for i in range(n // 2):
qc.swap(idx[i], idx[n - i - 1])
for j in range(n):
qc.h(idx[j])
for k in range(j+1, n):
theta = math.pi / (2 ** (k - j))
if (inversed):
theta *= -1
qc.cp(theta, idx[k], idx[j])
#for i in range(n // 2):
# qc.swap(idx[i], idx[n - i - 1])
return qc
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
QFT(qc, list(range(n)))
for i in range(n):
theta = 2 * math.pi * a * (2 ** i) / (2 ** n)
qc.cp(theta, n, i)
QFT(qc, list(range(n)), inversed = True)
return qc
''' |
QPC004_B3 | AC2F39289CA42 | 1 | WA | 1919 ms | 161 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, a: int) -> QuantumCircuit:
k = QuantumRegister(n) # Register for k
c = QuantumRegister(1) # Register for c
qc = QuantumCircuit(k, c)
# Convert a to its binary representation
a_bin = [int(x) for x in format(a, f'0{n}b')[::-1]] # Little-endian binary representation of a
# Apply the controlled addition of a if c is 1
for i in range(n):
if a_bin[i] == 1:
# Use a Toffoli gate to control the addition
# We need to add a to k if c is 1
# This means we need to add a to k[i] controlled by c[0]
# We will use a series of CNOT and Toffoli gates
# First, we need to create a carry bit
if i == 0:
# For the least significant bit, we can directly use CNOT
qc.cx(c[0], k[i])
else:
# For higher bits, we need to use Toffoli gates to handle carry
# Create a carry bit from the previous bit
qc.ccx(c[0], k[i-1], k[i]) # Toffoli gate
qc.cx(c[0], k[i]) # CNOT gate for the current bit
return qc
''' |
QPC004_B3 | AC4E92525913A | 1 | WA | 1916 ms | 163 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
for j in range(a):
for i in range(n):
qc.x(i)
qc.x(0)
for i in range(n - 1):
qc.mcx(list(range(0, i + 1)) + [n], i + 1)
for i in range(n):
qc.x(i)
return qc
''' |
QPC004_B3 | AC4E92525913A | 2 | AC | 3000 ms | 163 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
for j in range(a):
for i in range(n):
qc.x(i)
qc.cx(n, 0)
for i in range(n - 1):
qc.mcx(list(range(0, i + 1)) + [n], i + 1)
for i in range(n):
qc.x(i)
return qc
''' |
QPC004_B3 | AC81DF0F2E8D7 | 1 | WA | 1913 ms | 163 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
import math
if False:
isv = Statevector([1 if i == (1+8) else 0 for i in range(16)])
print(isv)
qc.prepare_state(isv)
# QFT
for i in range(n)[::-1]:
qc.h(i)
for j in range(i)[::-1]:
t = 2 * math.pi / (2 ** (i-j+1))
qc.cp(t,j,i)
for i in range(n//2):
qc.swap(i, n-i-1)
# op
for i in range(n):
t = 2 * math.pi * a * (2 ** i) / (2 ** n)
qc.cp(t,n,i)
# IQFT
for i in range(n//2):
qc.swap(i, n-i-1)
for i in range(n):
for j in range(i):
t = 2 * math.pi / (2 ** (i-j+1))
qc.cp(t,j,i)
qc.h(i)
return qc
''' |
QPC004_B3 | AC81DF0F2E8D7 | 2 | RE | 1631 ms | 158 MiB | '''python
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
import math
if False:
isv = Statevector([1 if i == (3+8) else 0 for i in range(2**(n+1))])
print(isv)
qc.prepare_state(isv)
# QFT
for i in range(n)[::-1]:
qc.h(i)
for j in range(i)[::-1]:
t = 2 * math.pi / (2 ** (i-j+1))
qc.cp(t,j,i)
for i in range(n//2):
qc.swap(i, n-i-1)
# op
for i in range(n):
t = 2 * math.pi * a * (2 ** i) / (2 ** n)
qc.cp(t,n,i)
# IQFT
for i in range(n//2):
qc.swap(i, n-i-1)
for i in range(n):
for j in range(i):
t = - 2 * math.pi / (2 ** (i-j+1))
qc.cp(t,j,i)
qc.h(i)
return qc
''' |
QPC004_B3 | AC81DF0F2E8D7 | 3 | AC | 2053 ms | 163 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
import math
if False:
isv = Statevector([1 if i == (3+8) else 0 for i in range(2**(n+1))])
print(isv)
qc.prepare_state(isv)
# QFT
for i in range(n)[::-1]:
qc.h(i)
for j in range(i)[::-1]:
t = 2 * math.pi / (2 ** (i-j+1))
qc.cp(t,j,i)
for i in range(n//2):
qc.swap(i, n-i-1)
# op
for i in range(n):
t = 2 * math.pi * a * (2 ** i) / (2 ** n)
qc.cp(t,n,i)
# IQFT
for i in range(n//2):
qc.swap(i, n-i-1)
for i in range(n):
for j in range(i):
t = - 2 * math.pi / (2 ** (i-j+1))
qc.cp(t,j,i)
qc.h(i)
return qc
''' |
QPC004_B3 | ACA3B5C253E19 | 1 | AC | 2172 ms | 162 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n : int, a : int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
for k in range(n):
if(a%2 == 1):
for i in range(n-1,k-1,-1):
if(i == k):
qc.cx(n,i)
else:
qc.mcx(list(range(k,i,1)) + [n],i)
a = int(a/2)
return qc
''' |
QPC004_B3 | ACA91A9AB03F8 | 1 | WA | 2108 ms | 161 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
qc.x(0)
for i in range(1, n):
qc.mcx(list(range(i)), i)
qc.inverse()
qc.repeat(a)
return qc
''' |
QPC004_B3 | ACA91A9AB03F8 | 2 | WA | 1910 ms | 162 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
qc.cx(n, 0)
for i in range(1, n):
qc.mcx(list(range(i))+[n], i)
qc.inverse()
qc.repeat(a)
return qc
''' |
QPC004_B3 | ACA91A9AB03F8 | 3 | WA | 2492 ms | 160 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
qc.cx(n, 0)
for i in range(1, n):
qc.mcx(list(range(i))+[n], i)
qc.repeat(2**n-a)
return qc
''' |
QPC004_B3 | ACA91A9AB03F8 | 4 | WA | 1900 ms | 158 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
for i in range(n):
if((a >> i)&1):
qc.cx(n, i)
for j in range(i+1, n):
qc.mcx([c] + list(range(i, j)), j)
qc.inverse()
return qc
''' |
QPC004_B3 | ACA91A9AB03F8 | 5 | WA | 1948 ms | 160 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
for i in range(n):
if((a >> i)&1):
qc.cx(n, i)
for j in range(i+1, n):
qc.mcx([n] + list(range(i, j)), j)
qc.inverse()
return qc
''' |
QPC004_B3 | ACA91A9AB03F8 | 6 | WA | 2558 ms | 160 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
for i in range(n):
if((a >> i)&1):
for j in range(n):
l =[c]
for k in range(j):
l.append((k + i) % n)
qc.mcx(l, (j+i)%n)
qc.inverse()
return qc
''' |
QPC004_B3 | ACA91A9AB03F8 | 7 | WA | 1848 ms | 160 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
for i in range(n):
if((a >> i)&1):
for j in range(n):
l =[n]
for k in range(j):
l.append((k + i) % n)
qc.mcx(l, (j+i)%n)
qc.inverse()
return qc
''' |
QPC004_B3 | ACA91A9AB03F8 | 8 | WA | 1903 ms | 160 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
for i in range(n):
if((a >> i)&1):
for j in range(i, n):
qc.mcx([n] + list(range(i, j)), j)
qc.inverse()
return qc
''' |
QPC004_B3 | ACD0ABF166BCF | 1 | RE | 1778 ms | 158 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def qft(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in reversed(range(n)):
qc.h(i)
for j in reversed(range(i)):
qc.cp(math.pi / 2 ** (i - j), j, i)
for i in range(n // 2):
qc.swap(i, n - i - 1)
return qc
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
qft_n = qft(n)
qc.compose(qft_n, k, inplace=True)
for j in range(n):
for i in range(n):
theta = (2 * math.pi * a / 2**m) * 2**j
qc.mcp(theta, [x[i],c], y[j])
qc.compose(qft_n.inverse(), k, inplace=True)
return qc
''' |
QPC004_B3 | ACD0ABF166BCF | 2 | RE | 1810 ms | 158 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def qft(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in reversed(range(n)):
qc.h(i)
for j in reversed(range(i)):
qc.cp(math.pi / 2 ** (i - j), j, i)
for i in range(n // 2):
qc.swap(i, n - i - 1)
return qc
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
qft_n = qft(n)
qc.compose(qft_n, k, inplace=True)
for j in range(n):
for i in range(n):
theta = (math.pi * a / 2**n) * 2**j
qc.cp(theta, c, k[i])
qc.compose(qft_n.inverse(), k, inplace=True)
return qc
''' |
QPC004_B3 | ACD0ABF166BCF | 3 | RE | 1677 ms | 158 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def qft(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in reversed(range(n)):
qc.h(i)
for j in reversed(range(i)):
qc.cp(math.pi / 2 ** (i - j), j, i)
for i in range(n // 2):
qc.swap(i, n - i - 1)
return qc
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
qft_n = qft(n)
qc.compose(qft_n, k, inplace=True)
for j in range(n):
theta = (math.pi * (a & 2**j) / 2**n) * 2**j
qc.cp(theta, c, k[j])
qc.compose(qft_n.inverse(), k, inplace=True)
return qc
''' |
QPC004_B3 | ACD0ABF166BCF | 4 | RE | 1710 ms | 158 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def qft(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in reversed(range(n)):
qc.h(i)
for j in reversed(range(i)):
qc.cp(math.pi / 2 ** (i - j), j, i)
for i in range(n // 2):
qc.swap(i, n - i - 1)
return qc
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
qft_n = qft(n)
qc.compose(qft_n, k, inplace=True)
for j in range(n):
theta = (2 * math.pi * (a & 2**j) / 2**n) * 2**j
qc.cp(theta, c[0], k[j])
qc.compose(qft_n.inverse(), k, inplace=True)
return qc
''' |
QPC004_B3 | ACD0ABF166BCF | 5 | RE | 1508 ms | 158 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def qft(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in reversed(range(n)):
qc.h(i)
for j in reversed(range(i)):
qc.cp(math.pi / 2 ** (i - j), j, i)
for i in range(n // 2):
qc.swap(i, n - i - 1)
return qc
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
qft_n = qft(n)
qc.compose(qft_n, k, inplace=True)
# for j in range(n):
# theta = (2 * math.pi * (a & 2**j) / 2**n) * 2**j
# qc.cp(theta, c[0], k[j])
qc.compose(qft_n.inverse(), k, inplace=True)
return qc
''' |
QPC004_B3 | ACD0ABF166BCF | 6 | RE | 1656 ms | 158 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def qft(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in reversed(range(n)):
qc.h(i)
for j in reversed(range(i)):
qc.cp(math.pi / 2 ** (i - j), j, i)
for i in range(n // 2):
qc.swap(i, n - i - 1)
return qc
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
qft_n = qft(n)
# qc.compose(qft_n, k, inplace=True)
# for j in range(n):
# theta = (2 * math.pi * (a & 2**j) / 2**n) * 2**j
# qc.cp(theta, c[0], k[j])
# qc.compose(qft_n.inverse(), k, inplace=True)
return qc
''' |
QPC004_B3 | ACD0ABF166BCF | 7 | WA | 1585 ms | 161 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def qft(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in reversed(range(n)):
qc.h(i)
for j in reversed(range(i)):
qc.cp(math.pi / 2 ** (i - j), j, i)
for i in range(n // 2):
qc.swap(i, n - i - 1)
return qc
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
# qft_n = qft(n)
# qc.compose(qft_n, k, inplace=True)
# for j in range(n):
# theta = (2 * math.pi * (a & 2**j) / 2**n) * 2**j
# qc.cp(theta, c[0], k[j])
# qc.compose(qft_n.inverse(), k, inplace=True)
return qc
''' |
QPC004_B3 | ACD0ABF166BCF | 8 | WA | 1635 ms | 160 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def qft(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in reversed(range(n)):
qc.h(i)
for j in reversed(range(i)):
qc.cp(math.pi / 2 ** (i - j), j, i)
for i in range(n // 2):
qc.swap(i, n - i - 1)
return qc
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
qft_n = qft(n)
qc.compose(qft_n, k, inplace=True)
# for j in range(n):
# theta = (2 * math.pi * (a & 2**j) / 2**n) * 2**j
# qc.cp(theta, c[0], k[j])
qc.compose(qft_n.inverse(), k, inplace=True)
return qc
''' |
QPC004_B3 | ACD0ABF166BCF | 9 | WA | 1705 ms | 160 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def qft(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in reversed(range(n)):
qc.h(i)
for j in reversed(range(i)):
qc.cp(math.pi / 2 ** (i - j), j, i)
for i in range(n // 2):
qc.swap(i, n - i - 1)
return qc
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
qft_n = qft(n)
qc.compose(qft_n, k, inplace=True)
for j in range(n):
theta = (2 * math.pi * (a & 2**j) / 2**n) * 2**j
qc.cp(theta, c[0], k[j])
qc.compose(qft_n.inverse(), k, inplace=True)
return qc
''' |
QPC004_B3 | ACD0ABF166BCF | 10 | WA | 1997 ms | 160 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def qft(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in reversed(range(n)):
qc.h(i)
for j in reversed(range(i)):
qc.cp(math.pi / 2 ** (i - j), j, i)
for i in range(n // 2):
qc.swap(i, n - i - 1)
return qc
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
qft_n = qft(n)
qc.compose(qft_n, k, inplace=True)
for j in range(n):
theta = (2 * math.pi * (a & 2**j) / 2**n) * 2**j
qc.cp(theta, c[0], k[j])
qc.compose(qft_n.inverse(), k, inplace=True)
return qc
''' |
QPC004_B3 | ACD0ABF166BCF | 11 | WA | 1995 ms | 162 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def qft(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in reversed(range(n)):
qc.h(i)
for j in reversed(range(i)):
qc.cp(math.pi / 2 ** (i - j), j, i)
for i in range(n // 2):
qc.swap(i, n - i - 1)
return qc
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
qft_n = qft(n)
qc.compose(qft_n, k, inplace=True)
for j in range(n):
if (a & (1 << j)): # Check if j-th bit of a is 1
theta = 2 * math.pi * 2**j / 2**n
qc.cp(theta, c[0], k[n-1-j])
qc.compose(qft_n.inverse(), k, inplace=True)
return qc
''' |
QPC004_B3 | ACD0ABF166BCF | 12 | WA | 1630 ms | 162 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def qft(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in reversed(range(n)):
qc.h(i)
for j in reversed(range(i)):
qc.cp(math.pi / 2 ** (i - j), j, i)
for i in range(n // 2):
qc.swap(i, n - i - 1)
return qc
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
qft_n = qft(n)
qc.compose(qft_n, k, inplace=True)
for j in range(n):
if (a & (1 << j)): # Check if j-th bit of a is 1
theta = 2 * math.pi * 2**j / 2**n
qc.cp(theta, c[0], k[j])
qc.compose(qft_n.inverse(), k, inplace=True)
return qc
''' |
QPC004_B3 | ACD0ABF166BCF | 13 | WA | 1810 ms | 162 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def qft(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in reversed(range(n)):
qc.h(i)
for j in reversed(range(i)):
qc.cp(math.pi / 2 ** (i - j), j, i)
for i in range(n // 2):
qc.swap(i, n - i - 1)
return qc
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
qft_n = qft(n)
qc.compose(qft_n, k, inplace=True)
for j in range(n):
theta = 2 * math.pi * a * 2**j / 2**n
qc.cp(theta, c[0], k[n-1-j])
qc.compose(qft_n.inverse(), k, inplace=True)
return qc
''' |
QPC004_B3 | ACD0ABF166BCF | 14 | AC | 1979 ms | 163 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def qft(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in reversed(range(n)):
qc.h(i)
for j in reversed(range(i)):
qc.cp(math.pi / 2 ** (i - j), j, i)
for i in range(n // 2):
qc.swap(i, n - i - 1)
return qc
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
qft_n = qft(n)
qc.compose(qft_n, k, inplace=True)
for j in range(n):
theta = 2 * math.pi * a * 2**j / 2**n
qc.cp(theta, c[0], k[j])
qc.compose(qft_n.inverse(), k, inplace=True)
return qc
''' |
QPC004_B3 | AD1F256D695CD | 1 | RE | 2187 ms | 158 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def qft(n):
qc = QuantumCircuit(n)
for i in range(n-1):
qc.h(i)
for j in range(i+1, n):
qc.crz(2*math.pi/2**(j+1), j, i)
for i in range(n//2):
qc.swap(i, n-i)
return qc
def crot(n, a):
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
for i in range(n):
qc.cp(2*math.pi*a*2**i/2**n, c, i)
return qc
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
qc.compose(qft(n), qubits=k, inplace=True)
qc.compose(crot(n, a), qubits=[*k, *c], inplace=True)
qc.compose(qft(n).inverse(), qubits=k, inplace=True)
return qc
''' |
QPC004_B3 | AD1F256D695CD | 2 | RE | 1844 ms | 158 MiB | '''python
import math
def qft(n):
qc = QuantumCircuit(n)
for i in range(n-1):
qc.h(i)
for j in range(i+1, n):
qc.crz(2*math.pi/2**(j+1), j, i)
for i in range(n//2):
qc.swap(i, n-1-i)
return qc
def crot(n, a):
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
for i in range(n):
qc.cp(2*math.pi*a*2**i/2**n, c, i)
return qc
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
qc.compose(qft(n), qubits=k, inplace=True)
qc.compose(crot(n, a), qubits=[*k, *c], inplace=True)
qc.compose(qft(n).inverse(), qubits=k, inplace=True)
return qc
''' |
QPC004_B3 | AD1F256D695CD | 3 | RE | 2345 ms | 161 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def qft(n):
qc = QuantumCircuit(n)
for i in range(n-1):
qc.h(i)
for j in range(i+1, n):
qc.crz(2*math.pi/2**(j+1), j, i)
qc.barrier()
for i in range(n//2):
qc.swap(i, n-1-i)
return qc
def crot(n, a):
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
for i in range(n):
qc.cp(2*math.pi*a*2**i/2**n, c, i)
return qc
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
qc.compose(qft(n), qubits=k, inplace=True)
#qc.compose(crot(n, a), qubits=[*k, *c], inplace=True)
#qc.compose(qft(n).inverse(), qubits=k, inplace=True)
return qc
solve(3,1).draw("mpl")
''' |
QPC004_B3 | AD1F256D695CD | 4 | WA | 2377 ms | 162 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def qft(n):
qc = QuantumCircuit(n)
for i in range(n-1):
qc.h(i)
for j in range(i+1, n):
qc.crz(2*math.pi/2**(j+1), j, i)
qc.barrier()
for i in range(n//2):
qc.swap(i, n-1-i)
return qc
def crot(n, a):
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
for i in range(n):
qc.cp(2*math.pi*a*2**i/2**n, c, i)
return qc
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
qc.compose(qft(n), qubits=k, inplace=True)
qc.compose(crot(n, a), qubits=[*k, *c], inplace=True)
qc.compose(qft(n).inverse(), qubits=k, inplace=True)
return qc
''' |
QPC004_B3 | AD1F256D695CD | 5 | WA | 2204 ms | 162 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def qft(n):
qc = QuantumCircuit(n)
for i in range(n-1):
qc.h(i)
for j in range(i+1, n):
qc.crz(2*math.pi/2**(j+1), j, i)
qc.barrier()
# for i in range(n//2):
# qc.swap(i, n-1-i)
return qc
def crot(n, a):
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
for i in range(n):
qc.cp(2*math.pi*a*2**i/2**n, c, i)
return qc
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
qc.compose(qft(n), qubits=k, inplace=True)
qc.compose(crot(n, a), qubits=[*k, *c], inplace=True)
qc.compose(qft(n).inverse(), qubits=k, inplace=True)
return qc
''' |
QPC004_B3 | AD1F256D695CD | 6 | WA | 2114 ms | 162 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def qft(n):
qc = QuantumCircuit(n)
for i in range(n-1):
qc.h(i)
for j in range(i+1, n):
qc.cp(2*math.pi/2**(j+1), j, i)
qc.barrier()
for i in range(n//2):
qc.swap(i, n-1-i)
return qc
def crot(n, a):
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
for i in range(n):
qc.cp(2*math.pi*a*2**i/2**n, c, i)
return qc
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
qc.compose(qft(n), qubits=k, inplace=True)
qc.compose(crot(n, a), qubits=[*k, *c], inplace=True)
qc.compose(qft(n).inverse(), qubits=k, inplace=True)
return qc
''' |
QPC004_B3 | AD1F256D695CD | 7 | WA | 1876 ms | 161 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def qft(n):
qc = QuantumCircuit(n)
for i in range(n):
qc.h(i)
for j in range(i+1, n):
qc.cp(2*math.pi/2**(j+1), j, i)
qc.barrier()
for i in range(n//2):
qc.swap(i, n-1-i)
return qc
def crot(n, a):
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
for i in range(n):
qc.cp(2*math.pi*a*2**i/2**n, c, i)
return qc
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
qc.compose(qft(n), qubits=k, inplace=True)
qc.compose(crot(n, a), qubits=[*k, *c], inplace=True)
qc.compose(qft(n).inverse(), qubits=k, inplace=True)
return qc
''' |
QPC004_B3 | AD1F256D695CD | 8 | WA | 2116 ms | 162 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def qft(n):
qc = QuantumCircuit(n)
for i in range(n):
qc.h(i)
for j in range(i+1, n):
qc.cp(2*math.pi/2**(j+1), j, i)
qc.barrier()
# for i in range(n//2):
# qc.swap(i, n-1-i)
return qc
def crot(n, a):
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
for i in range(n):
qc.cp(2*math.pi*a*2**i/2**n, c, i)
return qc
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
qc.compose(qft(n), qubits=k, inplace=True)
qc.compose(crot(n, a), qubits=[*k, *c], inplace=True)
qc.compose(qft(n).inverse(), qubits=k, inplace=True)
return qc
''' |
QPC004_B3 | AD1F256D695CD | 9 | WA | 2573 ms | 162 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def qft(n):
qc = QuantumCircuit(n)
for i in reversed(range(n)):
qc.h(i)
for j in reversed(range(i)):
qc.cp(2*math.pi/2**(n-j), j, i)
qc.barrier()
for i in range(n//2):
qc.swap(i, n-1-i)
return qc
def crot(n, a):
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
for i in range(n):
qc.cp(2*math.pi*a*2**i/2**n, c, i)
return qc
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
qc.compose(qft(n), qubits=k, inplace=True)
qc.compose(crot(n, a), qubits=[*k, *c], inplace=True)
qc.compose(qft(n).inverse(), qubits=k, inplace=True)
return qc
''' |
QPC004_B3 | AD1F256D695CD | 10 | AC | 2233 ms | 163 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def qft(n):
qc = QuantumCircuit(n)
for i in reversed(range(n)):
qc.h(i)
for j in reversed(range(i)):
qc.cp(2*math.pi/2**(i-j+1), j, i)
qc.barrier()
for i in range(n//2):
qc.swap(i, n-1-i)
return qc
def crot(n, a):
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
for i in range(n):
qc.cp(2*math.pi*a*2**i/2**n, c, i)
return qc
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
qc.compose(qft(n), qubits=k, inplace=True)
qc.compose(crot(n, a), qubits=[*k, *c], inplace=True)
qc.compose(qft(n).inverse(), qubits=k, inplace=True)
return qc
''' |
QPC004_B3 | ADB24C647A3A2 | 1 | WA | 1991 ms | 160 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
for q in range(n):
current_a_bit = a % 2
a //=2
if current_a_bit == 1:
for i in range(q+1, n):
qc.mcx([c[0], q] + list(range(i+1, n)), i)
qc.x(q)
else:
assert current_a_bit == 0
return qc
''' |
QPC004_B3 | ADB24C647A3A2 | 2 | WA | 1931 ms | 160 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
for q in range(n):
current_a_bit = a % 2
a //=2
if current_a_bit == 1:
for i in range(q+1, n):
qc.mcx([c[0]] + list(range(q, i)), i)
qc.x(q)
else:
assert current_a_bit == 0
return qc
''' |
QPC004_B3 | ADB24C647A3A2 | 3 | AC | 2323 ms | 161 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def qft(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in reversed(range(n)):
qc.h(i)
for j in reversed(range(i)):
qc.cp(math.pi / 2 ** (i - j), j, i)
for i in range(n // 2):
qc.swap(i, n - i - 1)
return qc
def 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 solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
qc.compose(qft(n), qubits=k, inplace=True)
qc.compose(crot(n, a), qubits=[*k, *c], inplace=True)
qc.compose(qft(n).inverse(), qubits=k, inplace=True)
return qc
''' |
QPC004_B3 | ADF2C94479F92 | 1 | WA | 1785 ms | 162 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from numpy import pi, sqrt, acos
def solve(n, a) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
vis = [False] * 2**n
for start in range(2**n):
if vis[start]:
continue
vis[start] = True
x = start
while not vis[(x - a) % 2**n]:
y = (x - a) % 2**n
vis[y] = True
to_flip = []
to_control = []
to_zero_control = []
for i in range(n):
if (x ^ y) >> i & 1:
to_flip.append(i)
else:
to_control.append(i)
if ~x >> i & 1:
to_zero_control.append(i)
for i in to_zero_control:
qc.x(i)
for i in to_flip:
if to_control:
qc.mcx(to_control, i)
else:
qc.x(i)
for i in to_zero_control:
qc.x(i)
x = y
return qc
''' |
QPC004_B3 | ADF2C94479F92 | 2 | WA | 2342 ms | 163 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from numpy import pi, sqrt, acos
def apply_permutation(qc, p, option = "cycle"):
assert option in ["cycle", "list"]
n = qc.num_qubits
cycles = []
if option == "cycle":
cycles = p[:]
elif option == "list":
assert sorted(p) == list(range(len(p)))
vis = [False] * len(p)
for x in range(len(p)):
if vis[x]:
continue
cycle = []
while not vis[x]:
vis[x] = True
cycle.append(x)
x = p[x]
cycles.append(cycle)
else:
assert False
for cycle in sorted(cycles, key = lambda c: len(c)):
def recurse(l, r):
if r - l <= 1:
return
m = l + r >> 1
recurse(l, m), recurse(m, r)
x, y = cycle[l], cycle[m]
def apply_swap(i):
for j in range(n):
if j < i and ~x >> j & 1 or j > i and ~y >> j & 1:
qc.x(j)
qc.mcx(list(j for j in range(n) if i != j), i)
for j in range(n):
if j < i and ~x >> j & 1 or j > i and ~y >> j & 1:
qc.x(j)
diff = [i for i in range(n) if (x ^ y) >> i & 1]
cut = len(diff) >> 1
for i in range(cut - 1):
apply_swap(diff[i])
for i in range(cut + 1, len(diff)):
apply_swap(diff[i])
apply_swap(diff[cut])
for i in range(cut - 1):
apply_swap(diff[i])
for i in range(cut + 1, len(diff)):
apply_swap(diff[i])
recurse(0, len(cycle))
return qc
def solve(n, a) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
perm = [(j << n) + (i + a * j) % 2**n for j in range(2) for i in range(2**n)]
print(f"{perm = }")
return apply_permutation(qc, perm, option = "list")
''' |
QPC004_B3 | ADF2C94479F92 | 3 | RE | 1613 ms | 159 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from numpy import pi, sqrt, acos
def apply_stateswap(qc, x, y):
n = qc.num_qubits
assert x != y
assert 0 <= min(x, y) and max(x, y) < 2**n
def apply_bitswap(i):
for j in range(n):
if j < i and ~x >> j & 1 or j > i and ~y >> j & 1:
qc.x(j)
qc.mcx(list(j for j in range(n) if i != j), i)
for j in range(n):
if j < i and ~x >> j & 1 or j > i and ~y >> j & 1:
qc.x(j)
diff = [i for i in range(n) if (x ^ y) >> i & 1]
cut = len(diff) / 2
for i in range(cut - 1):
apply_bitswap(diff[i])
for i in range(cut + 1, len(diff)):
apply_bitswap(diff[i])
apply_bitswap(diff[cut])
for i in range(cut - 1):
apply_bitswap(diff[i])
for i in range(cut + 1, len(diff)):
apply_bitswap(diff[i])
return qc
def apply_permutation(qc, p, option = "cycle"):
assert option in ["cycle", "list"]
n = qc.num_qubits
cycles = []
if option == "cycle":
cycles = p[:]
elif option == "list":
assert sorted(p) == list(range(len(p)))
vis = [False] * len(p)
for x in range(len(p)):
if vis[x]:
continue
cycle = []
while not vis[x]:
vis[x] = True
cycle.append(x)
x = p[x]
cycles.append(cycle)
else:
assert False
for cycle in sorted(cycles, key = lambda c: len(c)):
def recurse(l, r):
if r - l <= 1:
return
m = l + r >> 1
recurse(l, m), recurse(m, r)
apply_stateswap(qc, cycle[l], cycle[m])
recurse(0, len(cycle))
return qc
def solve(n, a) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
perm = [2**n * j + (i + a * j) % 2**n for j in range(2) for i in range(2**n)]
return apply_permutation(qc, perm, option = "list")
''' |
QPC004_B3 | ADF2C94479F92 | 4 | WA | 1974 ms | 164 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from numpy import pi, sqrt, acos
def apply_stateswap(qc, x, y):
n = qc.num_qubits
assert x != y
assert 0 <= min(x, y) and max(x, y) < 2**n
def apply_bitswap(i):
for j in range(n):
if j < i and ~x >> j & 1 or j > i and ~y >> j & 1:
qc.x(j)
qc.mcx(list(j for j in range(n) if i != j), i)
for j in range(n):
if j < i and ~x >> j & 1 or j > i and ~y >> j & 1:
qc.x(j)
diff = [i for i in range(n) if (x ^ y) >> i & 1]
cut = len(diff) // 2
for i in range(cut - 1):
apply_bitswap(diff[i])
for i in range(cut + 1, len(diff)):
apply_bitswap(diff[i])
apply_bitswap(diff[cut])
for i in range(cut - 1):
apply_bitswap(diff[i])
for i in range(cut + 1, len(diff)):
apply_bitswap(diff[i])
return qc
def apply_permutation(qc, p, option = "cycle"):
assert option in ["cycle", "list"]
n = qc.num_qubits
cycles = []
if option == "cycle":
cycles = p[:]
elif option == "list":
assert sorted(p) == list(range(len(p)))
vis = [False] * len(p)
for x in range(len(p)):
if vis[x]:
continue
cycle = []
while not vis[x]:
vis[x] = True
cycle.append(x)
x = p[x]
cycles.append(cycle)
else:
assert False
for cycle in sorted(cycles, key = lambda c: len(c)):
def recurse(l, r):
if r - l <= 1:
return
m = l + r >> 1
recurse(l, m), recurse(m, r)
apply_stateswap(qc, cycle[l], cycle[m])
recurse(0, len(cycle))
return qc
def solve(n, a) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
perm = [2**n * j + (i + a * j) % 2**n for j in range(2) for i in range(2**n)]
return apply_permutation(qc, perm, option = "list")
''' |
QPC004_B3 | ADF2C94479F92 | 5 | WA | 2505 ms | 163 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from numpy import pi, sqrt, acos
# Adds about 3n circuit depth
def apply_stateswap(qc, x, y):
n = qc.num_qubits
assert x != y
assert 0 <= min(x, y) and max(x, y) < 2**n
def apply_bitflip(i):
for j in range(n):
if j < i and ~x >> j & 1 or j > i and ~y >> j & 1:
qc.x(j)
qc.mcx(list(j for j in range(n) if i != j), i)
for j in range(n):
if j < i and ~x >> j & 1 or j > i and ~y >> j & 1:
qc.x(j)
diff = [i for i in range(n) if (x ^ y) >> i & 1]
cut = len(diff) // 2
for i in range(cut):
apply_bitflip(diff[i])
for i in range(cut + 1, len(diff)):
apply_bitflip(diff[i])
apply_bitflip(diff[cut])
for i in range(cut):
apply_bitflip(diff[i])
for i in range(cut + 1, len(diff)):
apply_bitflip(diff[i])
return qc
# Adds about 3 * n * 2**n circuit depth
def apply_permutation(qc, p, option = "cycle"):
assert option in ["cycle", "list"]
n = qc.num_qubits
cycles = []
if option == "cycle":
cycles = p[:]
elif option == "list":
assert sorted(p) == list(range(len(p)))
vis = [False] * len(p)
for x in range(len(p)):
if vis[x]:
continue
cycle = []
while not vis[x]:
vis[x] = True
cycle.append(x)
x = p[x]
cycles.append(cycle)
else:
assert False
ops = 2
for cycle in cycles:
for i in reversed(range(len(cycle) - 1)):
apply_stateswap(qc, cycle[i], cycle[i + 1])
return qc
def solve(n, a) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
perm = [2**n * j + (i + a * j) % 2**n for j in range(2) for i in range(2**n)]
return apply_permutation(qc, perm, option = "list")
''' |
QPC004_B3 | ADF2C94479F92 | 6 | WA | 2070 ms | 162 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from numpy import pi, sqrt, acos
# Adds about 3n circuit depth
def apply_stateswap(qc, x, y):
n = qc.num_qubits
assert x != y
assert 0 <= min(x, y) and max(x, y) < 2**n
def apply_bitflip(i):
for j in range(n):
if j < i and ~x >> j & 1 or j > i and ~y >> j & 1:
qc.x(j)
qc.mcx(list(j for j in range(n) if i != j), i)
for j in range(n):
if j < i and ~x >> j & 1 or j > i and ~y >> j & 1:
qc.x(j)
diff = [i for i in range(n) if (x ^ y) >> i & 1]
cut = len(diff) // 2
for i in range(cut):
apply_bitflip(diff[i])
for i in range(cut + 1, len(diff)):
apply_bitflip(diff[i])
apply_bitflip(diff[cut])
for i in range(cut):
apply_bitflip(diff[i])
for i in range(cut + 1, len(diff)):
apply_bitflip(diff[i])
return qc
# Adds about 3 * n * 2**n circuit depth
def apply_permutation(qc, p, option = "cycle"):
assert option in ["cycle", "list"]
n = qc.num_qubits
cycles = []
if option == "cycle":
cycles = p[:]
elif option == "list":
assert sorted(p) == list(range(len(p)))
vis = [False] * len(p)
for x in range(len(p)):
if vis[x]:
continue
cycle = []
while not vis[x]:
vis[x] = True
cycle.append(x)
x = p[x]
cycles.append(cycle)
else:
assert False
ops = 2
for cycle in cycles:
for i in range(len(cycle) - 1):
apply_stateswap(qc, cycle[i], cycle[i + 1])
return qc
def solve(n, a) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
perm = [2**n * j + (i + a * j) % 2**n for j in range(2) for i in range(2**n)]
return apply_permutation(qc, perm, option = "list")
''' |
QPC004_B3 | ADF2C94479F92 | 7 | TLE | 3000 ms | 177 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from numpy import pi, sqrt, acos
# Adds about 3n circuit depth
def apply_stateswap(qc, x, y):
n = qc.num_qubits
assert 0 <= min(x, y) and max(x, y) < 2**n
if x == y:
return qc
def apply_bitflip(i):
for j in range(n):
if j < i and ~x >> j & 1 or j > i and ~y >> j & 1:
qc.x(j)
qc.mcx(list(j for j in range(n) if i != j), i)
for j in range(n):
if j < i and ~x >> j & 1 or j > i and ~y >> j & 1:
qc.x(j)
diff = [i for i in range(n) if (x ^ y) >> i & 1]
cut = len(diff) // 2
for i in range(cut):
apply_bitflip(diff[i])
for i in reversed(range(cut + 1, len(diff))):
apply_bitflip(diff[i])
apply_bitflip(diff[cut])
for i in reversed(range(cut)):
apply_bitflip(diff[i])
for i in range(cut + 1, len(diff)):
apply_bitflip(diff[i])
return qc
# Adds about 3 * n * 2**n circuit depth
def apply_permutation(qc, p, option = "cycle"):
assert option in ["cycle", "list"]
n = qc.num_qubits
cycles = []
if option == "cycle":
cycles = p[:]
elif option == "list":
assert sorted(p) == list(range(len(p)))
vis = [False] * len(p)
for x in range(len(p)):
if vis[x]:
continue
cycle = []
while not vis[x]:
vis[x] = True
cycle.append(x)
x = p[x]
cycles.append(cycle)
else:
assert False
ops = 2
for cycle in cycles:
for i in reversed(range(len(cycle) - 1)):
apply_stateswap(qc, cycle[i], cycle[i + 1])
return qc
def solve(n, a) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
perm = [2**n * j + (i + a * j) % 2**n for j in range(2) for i in range(2**n)]
return apply_permutation(qc, perm, option = "list")
''' |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.