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 | AAD3D81DBABAB | 3 | WA | 1880 ms | 162 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):
theta = 2 * np.pi * a / (2 ** (i - n))
qc.cp(theta, c[0], k[i])
return qc
''' |
QPC004_B2 | AAD3D81DBABAB | 4 | AC | 1882 ms | 163 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.cp(2 * np.pi * a * 2 ** (i - n), c[0], k[i])
return qc
''' |
QPC004_B2 | AB5359488B09A | 1 | RE | 1598 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):
qc.cp(2. * np.pi * a / (2 ** (i + 1)), c, k[i])
return qc
''' |
QPC004_B2 | AB5359488B09A | 2 | WA | 1622 ms | 161 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.cp(2. * np.pi * a / (2 ** (i + 1)), c, k[i])
return qc
''' |
QPC004_B2 | AB5359488B09A | 3 | AC | 2000 ms | 162 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.cp(2. * np.pi * a / (2 ** (n - i)), c, k[i])
return qc
''' |
QPC004_B2 | ABA4C7D30507A | 1 | RE | 1722 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 = tau * a / (1 << n - i)
qc.crz(theta, c[0], k[i])
return qc
''' |
QPC004_B2 | ABA4C7D30507A | 2 | RE | 1738 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 = tau * a / (1 << n - i)
qc.cp(theta, c[0], k[i])
return qc
''' |
QPC004_B2 | ABA4C7D30507A | 3 | AC | 1967 ms | 163 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from math import tau
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 = tau * a / (1 << n - i)
qc.cp(theta, c[0], k[i])
return qc
''' |
QPC004_B2 | ABD8384219E76 | 1 | RE | 1660 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:
repetitions = 1
for counting_qubit in range(k):
for i in range(repetitions):
qpe.cp(math.pi/4, counting_qubit, 3);
repetitions *= 2
return qc
''' |
QPC004_B2 | ABD8384219E76 | 2 | RE | 1558 ms | 158 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:
repetitions = 1
for counting_qubit in range(k):
for i in range(repetitions):
qc.cp(math.pi/4, counting_qubit, 3);
repetitions *= 2
return qc
''' |
QPC004_B2 | ABD8384219E76 | 3 | WA | 1823 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:
for i in range(n):
theta = 2 * math.pi * a / 2**n
qc.p(theta, i)
return qc
''' |
QPC004_B2 | ABD8384219E76 | 4 | RE | 1549 ms | 158 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):
theta = 2 * math.pi * a *k / 2**n
qc.c(theta, i)
return qc
''' |
QPC004_B2 | ABD8384219E76 | 5 | WA | 1897 ms | 160 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):
theta = 2 * math.pi * a / 2**n
qc.cp(theta, i, c)
return qc
''' |
QPC004_B2 | ABD8384219E76 | 6 | RE | 1631 ms | 158 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):
theta = 2 * math.pi * a / 2**n
qc.cp(theta, i, n+1)
return qc
''' |
QPC004_B2 | ABD8384219E76 | 7 | WA | 1951 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:
for i in range(n):
theta = 2 * math.pi * a / 2**n
qc.cp(theta, i, n)
return qc
''' |
QPC004_B2 | ABD8384219E76 | 8 | WA | 2094 ms | 162 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):
theta = 2 * math.pi * a / 2**n
qc.cp(theta, i, n)
return qc
''' |
QPC004_B2 | ABD8384219E76 | 9 | RE | 1627 ms | 158 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):
theta = 2 * math.pi * a / 2**n
qc.cp(theta, i, 0)
return qc
''' |
QPC004_B2 | ABD8384219E76 | 10 | WA | 1820 ms | 162 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:
repetitions = 1
for i in range(repetitions):
for i in range(n):
theta = 2 * math.pi * a / 2**n
qc.cp(theta, i, c)
repetitions *= 2
return qc
''' |
QPC004_B2 | ABD8384219E76 | 11 | WA | 1635 ms | 162 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:
repetitions = 1
for k in range(repetitions):
for i in range(n):
theta = 2 * math.pi * a / 2**n
qc.cp(theta, i, c)
repetitions *= 2
return qc
''' |
QPC004_B2 | ABD8384219E76 | 12 | DLE | 1547 ms | 158 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:
repetitions = 1
theta = 2 * math.pi * a / 2**n
for i in range(n):
for k in range(repetitions):
qc.cp(theta, i, c)
repetitions *= 2
return qc
''' |
QPC004_B2 | ABD8384219E76 | 13 | AC | 2036 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:
repetitions = 1
for i in range(n):
theta = 2 * math.pi * a * repetitions / 2**n
qc.cp(theta, i, c)
repetitions *= 2
return qc
''' |
QPC004_B2 | ABDF7E51FDEF5 | 1 | RE | 1612 ms | 158 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:
theta = 2*math.pi*a/(2**n)
for i in range(n):
qc.cphase(k[i], c, theta)
theta *= 2
return qc
''' |
QPC004_B2 | ABDF7E51FDEF5 | 2 | RE | 1676 ms | 158 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:
theta = 2*math.pi*a/(2**n)
for i in range(n):
qc.cp(k[i], c, theta)
theta *= 2
return qc
''' |
QPC004_B2 | ABDF7E51FDEF5 | 3 | RE | 1588 ms | 158 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:
theta = 2*math.pi*a/(2**n)
for i in range(n):
qc.c(theta, k[i], c)
theta *= 2
return qc
''' |
QPC004_B2 | ABDF7E51FDEF5 | 4 | AC | 1876 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:
theta = 2*math.pi*a/(2**n)
for i in range(n):
qc.cp(theta, k[i], c)
theta *= 2
return qc
''' |
QPC004_B2 | AC5ED9B9286DD | 1 | RE | 1644 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):
t = 2 * math.pi * a * (2 ** i) / (2 ** n)
print(i,t)
qc.cp(t,n,i)
return qc
''' |
QPC004_B2 | AC5ED9B9286DD | 2 | RE | 1721 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):
t = 2 * math.pi * a * (2 ** i) / (2 ** n)
qc.cp(t,n,i)
return qc
''' |
QPC004_B2 | AC5ED9B9286DD | 3 | AC | 2038 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:
import math
if False:
isv = Statevector([1 if i == (1+8) else 0 for i in range(16)])
print(isv)
qc.prepare_state(isv)
for i in range(n):
t = 2 * math.pi * a * (2 ** i) / (2 ** n)
qc.cp(t,n,i)
return qc
''' |
QPC004_B2 | AD73CCA548CBA | 1 | WA | 3000 ms | 158 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 _ in range(n):
qc.cp(2 * n * a * 2 ** _ / 2 ** n,n,_)
return qc
''' |
QPC004_B2 | AD73CCA548CBA | 2 | AC | 2306 ms | 160 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 _ in range(n):
qc.cp(2 * math.pi * a * 2 ** _ / 2 ** n,n,_)
return qc
''' |
QPC004_B2 | AE5270A14F50E | 1 | WA | 1692 ms | 162 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 j in range(n):
theta_j = 2*math.pi * a * (2**j) / (2**n)
qc.crz(theta_j/2, k[j], c[0])
qc.cx(k[j], c[0])
qc.crz(-theta_j/2, k[j], c[0])
qc.cx(k[j], c[0])
qc.crz(theta_j/2, k[j], c[0])
return qc
''' |
QPC004_B2 | AE5270A14F50E | 2 | DLE | 1590 ms | 158 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def qft(qc: QuantumCircuit, qubits, inverse=False):
n = len(qubits)
if not inverse:
for j in range(n):
qc.h(qubits[j])
for m in range(j+1, n):
angle = math.pi / (2**(m-j))
qc.cp(angle, qubits[m], qubits[j])
# 最後にビット順を左右反転(SWAP)
for i in range(n//2):
qc.swap(qubits[i], qubits[n-1-i])
else:
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:
qft(qc, k, inverse=False)
# 2) c=1 のとき，k[j] に位相 cp(θ_j)
# θ_j = 2π a 2^j / 2^n
# => sum_j θ_j * k_j = 2π a k / 2^n
for j in range(n):
theta_j = 2 * math.pi * a * (2**j) / (2**n)
qc.cp(theta_j, c[0], k[j])
# 3) kに iQFT
qft(qc, k, inverse=True)
return qc
''' |
QPC004_B2 | AE5270A14F50E | 3 | RE | 1506 ms | 157 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def qft_butterfly(qc, qubits, inverse=False):
"""
バタフライ構造のQFT/iQFT (リトルエンディアン) を簡潔に実装。
- qubits[0] が最下位ビット
- inverse=False で 順QFT
- inverse=True で 逆QFT (iQFT)
通常のQFTより同時並列にcpをかける部分が多く、回路深さを削減できる。
"""
n = len(qubits)
if n <= 1:
return
# 1) ビット列を左右反転 (最下位<->最上位, ... )
for i in range(n // 2):
qc.swap(qubits[i], qubits[n - 1 - i])
# 2) バタフライ段階：段数 ~ log2(n)
sign = -1 if not inverse else +1
stage = 1
while (1 << stage) <= n:
size = 1 << stage
half = size >> 1
# sizeごとのブロックに分割して並列にcp
for start in range(0, n, size):
for i in range(half):
angle = sign * math.pi * i / half
if abs(angle) > 1e-15:
qc.cp(angle, qubits[start + half + i], qubits[start + i])
stage += 1
# 3) 各ビットにH
for i in range(n):
qc.h(qubits[i])
# 順QFTの場合は最後に再びビット反転が必要だが
# ここでは最初にswap済みなので再度swapして元に戻す
if not inverse:
for i in range(n // 2):
qc.swap(qubits[i], qubits[n - 1 - i])
def solve(n: int, a: int) -> QuantumCircuit:
"""
リトルエンディアン:
k[0] が最下位ビット (2^0),
k[n-1] が最上位ビット (2^(n-1)).
c = 0 のとき位相なし,
c = 1 のとき exp(2πi a k / 2^n) を付与する。
"""
k = QuantumRegister(n, 'k')
c = QuantumRegister(1, 'c')
qc = QuantumCircuit(k, c)
# 1) QFT(k) --- バタフライ実装
qft_butterfly(qc, k, inverse=False)
# 2) c=1 のときにのみ位相 exp(i * 2π a 2^j / 2^n) を掛ける
# ( j=0..n-1 を全並列で処理 => 深さわずかに +1 程度 )
for j in range(n):
angle = 2 * math.pi * a * (2**j) / (2**n)
qc.cp(angle, c[0], k[j])
# 3) iQFT(k) --- バタフライ実装
qft_butterfly(qc, k, inverse=True)
return qc
''' |
QPC004_B2 | AE5270A14F50E | 4 | RE | 1647 ms | 158 MiB | '''python
import math
from qiskit import QuantumCircuit, QuantumRegister
def qft_butterfly(qc: QuantumCircuit, qubits, inverse=False):
"""
バタフライ構造で QFT (inverse=False) または iQFT (inverse=True) を実装する。
リトルエンディアン想定で、qubits[0] が最下位ビット。
通常の O(n^2) QFT 実装より浅い深さで済むが、
ゲート数は変わらず O(n^2)。n<=10 程度なら十分。
※ 位相ゲート cp() をバタフライの各ステージで並列に配置する。
"""
n = len(qubits)
if n <= 1:
return # 1量子ビット以下なら何もしない
# 1) bitの並びを反転 (最下位<->最上位, ..., 交換)
# 順QFTなら最後にこれをするが、バタフライ実装では最初にやったほうが簡便
for i in range(n//2):
qc.swap(qubits[i], qubits[n-1-i])
# もし inverse=True (逆QFT) なら
# QFT(|x>) = 1/sqrt(2^n) Σy e^{2πi xy/2^n}|y>
# を逆にする際、cpゲートの符号が逆になるだけ。
# 以下、"angle = ±π/2^(...) or ±2π/2^(...)" で符号を切り替える。
sign = -1.0 if not inverse else +1.0
# 2) バタフライ演算: log(n) 段のループ
# ステージ s=1..log(n)
# ブロックサイズ = 2^s
# 各ブロック内で "半分の長さ" にわたって制御位相 (cp) をかけていく
stage = 1
while (1 << stage) <= n:
block_size = 1 << stage # 2^stage
half_size = block_size >> 1
# ブロックの先頭位置を step
for start in range(0, n, block_size):
# start + i と start + i + half_size がペアになる
for i in range(half_size):
# A = qubits[start + i]
# B = qubits[start + i + half_size]
# ここで A, B をカップルにして制御位相をかける
angle = sign * math.pi / (block_size >> 1) * i
if abs(angle) > 1e-15:
qc.cp(angle, qubits[start + i + half_size], qubits[start + i])
stage += 1
# 3) 各ビットにHをかける (parallel)
for i in range(n):
qc.h(qubits[i])
# inverse=True (iQFT) の場合、ここまでで完了。
# inverse=False (順QFT) の場合、さらにビット反転が必要だが
# この実装では最初に swap を済ませているので不要。
# ただしダミー的にもう一度 swap して元に戻したいなら最後にやってもOK。
if not inverse:
for i in range(n//2):
qc.swap(qubits[i], qubits[n-1-i])
def solve(n: int, a: int) -> QuantumCircuit:
"""
リトルエンディアン:
k[0] が最下位ビット
補助ビット c[0] を加え: c=0 のとき位相なし, c=1 のとき位相 2π a k / 2^n
回路深さを抑えるため:
1) "バタフライ版QFT" で k を変換 (深さ ≈ n log n)
2) 単制御位相を各ビットに一括してかける (深さ 1～2)
3) バタフライ版 iQFT (深さ ≈ n log n)
"""
k = QuantumRegister(n, 'k') # n量子ビット
c = QuantumRegister(1, 'c') # 1量子ビット
qc = QuantumCircuit(k, c)
# 1) QFT(k)
qft_butterfly(qc, k, inverse=False)
# 2) c=1 のときにだけ k[j] へ位相 cp(...) を掛ける
# ただし QFT空間では k[j] が "周波数ビット" になっているので，
# 角度は 2π a * 2^j / 2^n
# ここはすべて並列実行可能 => 深さ1～2程度
for j in range(n):
angle_j = 2 * math.pi * a * (2**j) / (2**n)
qc.cp(angle_j, c[0], k[j])
# 3) iQFT(k)
qft_butterfly(qc, k, inverse=True)
return qc
''' |
QPC004_B2 | AE5270A14F50E | 5 | RE | 1844 ms | 161 MiB | '''python
import math
from qiskit import QuantumCircuit, QuantumRegister
def qft_butterfly(qc, qubits, inverse=False):
"""
バタフライ構造のQFT/iQFT (リトルエンディアン) を簡潔に実装。
- qubits[0] が最下位ビット
- inverse=False で 順QFT
- inverse=True で 逆QFT (iQFT)
通常のQFTより同時並列にcpをかける部分が多く、回路深さを削減できる。
"""
n = len(qubits)
if n <= 1:
return
# 1) ビット列を左右反転 (最下位<->最上位, ... )
for i in range(n // 2):
qc.swap(qubits[i], qubits[n - 1 - i])
# 2) バタフライ段階：段数 ~ log2(n)
sign = -1 if not inverse else +1
stage = 1
while (1 << stage) <= n:
size = 1 << stage
half = size >> 1
# sizeごとのブロックに分割して並列にcp
for start in range(0, n, size):
for i in range(half):
angle = sign * math.pi * i / half
if abs(angle) > 1e-15:
qc.cp(angle, qubits[start + half + i], qubits[start + i])
stage += 1
# 3) 各ビットにH
for i in range(n):
qc.h(qubits[i])
# 順QFTの場合は最後に再びビット反転が必要だが
# ここでは最初にswap済みなので再度swapして元に戻す
if not inverse:
for i in range(n // 2):
qc.swap(qubits[i], qubits[n - 1 - i])
def solve(n: int, a: int) -> QuantumCircuit:
"""
リトルエンディアン:
k[0] が最下位ビット (2^0),
k[n-1] が最上位ビット (2^(n-1)).
c = 0 のとき位相なし,
c = 1 のとき exp(2πi a k / 2^n) を付与する。
"""
k = QuantumRegister(n, 'k')
c = QuantumRegister(1, 'c')
qc = QuantumCircuit(k, c)
# 1) QFT(k) --- バタフライ実装
qft_butterfly(qc, k, inverse=False)
# 2) c=1 のときにのみ位相 exp(i * 2π a 2^j / 2^n) を掛ける
# ( j=0..n-1 を全並列で処理 => 深さわずかに +1 程度 )
for j in range(n):
angle = 2 * math.pi * a * (2**j) / (2**n)
qc.cp(angle, c[0], k[j])
# 3) iQFT(k) --- バタフライ実装
qft_butterfly(qc, k, inverse=True)
return qc
''' |
QPC004_B2 | AE5270A14F50E | 6 | RE | 1748 ms | 157 MiB | '''python
import math
from qiskit import QuantumCircuit, QuantumRegister
def qft_butterfly(qc: QuantumCircuit, qubits, inverse=False):
"""
バタフライ構造(QFT/iQFT) - リトルエンディアン対応。
- qubits[0] が最下位ビット
- inverse=False: 順QFT
- inverse=True : 逆QFT (iQFT)
通常のQFTより多くの cp を並列化できるため、回路深さを小さく抑えられる。
"""
n = len(qubits)
if n < 2:
return # 1ビット以下なら何もしない
# (1) ビット反転: qubits[i] <-> qubits[n-1-i]
for i in range(n // 2):
qc.swap(qubits[i], qubits[n - 1 - i])
# (2) バタフライ段階：log(n) ステージ
# 各ステージで「ブロックサイズ = 2^stage」に分割し，
# 半分の長さ half について並列に cp を掛ける
sign = -1 if not inverse else +1
stage = 1
while (1 << stage) <= n:
size = 1 << stage # 2^stage
half = size >> 1 # 2^(stage-1)
for start in range(0, n, size):
for i in range(half):
angle = sign * math.pi * i / half
if abs(angle) < 1e-15:
continue
# cp(angle, qubits[start+half+i], qubits[start+i])
qc.cp(angle, qubits[start + half + i], qubits[start + i])
stage += 1
# (3) 各ビットに H
for i in range(n):
qc.h(qubits[i])
# 順QFTの場合、最後にビットを再び反転しておく
if not inverse:
for i in range(n // 2):
qc.swap(qubits[i], qubits[n - 1 - i])
def solve(n: int, a: int) -> QuantumCircuit:
"""
0 <= k < 2^n, c in {0,1}:
|k>_n |c> ---> exp(2πi * a * c * k / 2^n) |k>_n |c>
リトルエンディアン: k[0] が最下位ビット
回路深さを小さくするために「バタフライ版QFT -> 単制御位相 -> iQFT」の流れ。
"""
k = QuantumRegister(n) # n量子ビット (k[0]がLSB)
c = QuantumRegister(1) # 1量子ビット (制御)
qc = QuantumCircuit(k, c)
# 1) QFT(k) [バタフライ構造で深さを抑える]
qft_butterfly(qc, k, inverse=False)
# 2) c=1 のときにだけ位相 exp(i * 2π a 2^j / 2^n) をかける
# ( j=0..n-1 を並列に適用 => 深さは +1～2程度 )
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_butterfly(qc, k, inverse=True)
return qc
''' |
QPC004_B2 | AE5270A14F50E | 7 | WA | 1825 ms | 162 MiB | '''python
import math
from qiskit import QuantumCircuit, QuantumRegister
def qft_butterfly(qc: QuantumCircuit, qubits, inverse=False):
"""
バタフライ構造のQFT/iQFT (リトルエンディアン):
- qubits[0]が最下位ビット
- inverse=False -> 順QFT
- inverse=True -> 逆QFT (iQFT)
回路深さを小さくしつつ、n=2等の小規模でも安全に動作するよう調整。
"""
n = len(qubits)
if n <= 1:
# 1量子ビット以下なら何もしない
if n == 1:
qc.h(qubits[0])
return
#
# (1) ビット反転: qubits[i] <-> qubits[n-1-i]
#
for i in range(n // 2):
qc.swap(qubits[i], qubits[n - 1 - i])
#
# (2) バタフライ段階
#
sign = -1.0 if not inverse else +1.0
stage = 1
while (1 << stage) <= n:
size = 1 << stage # 2^stage
if size > n:
break # 範囲外を避けるためスキップ
half = size >> 1 # 2^(stage-1)
# ブロックを size ごとに切って並列実行
for start in range(0, n, size):
# block: [start .. start+size-1]
# 前半: [start .. start+half-1]
# 後半: [start+half .. start+size-1]
# バタフライカーネル
for i in range(half):
# 後半 = (start+half+i), 前半 = (start+i)
idxA = start + i
idxB = start + half + i
if idxA >= n or idxB >= n:
continue
angle = sign * math.pi * i / half
# angle=0 のときcpしても位相が0なのでスキップ
if abs(angle) < 1e-15:
continue
qc.cp(angle, qubits[idxB], qubits[idxA])
stage += 1
#
# (3) 各ビットに H
#
for i in range(n):
qc.h(qubits[i])
#
# (4) 順QFTなら最後にもう一度ビット反転
#
if not inverse:
for i in range(n // 2):
qc.swap(qubits[i], qubits[n - 1 - i])
def solve(n: int, a: int) -> QuantumCircuit:
"""
問題:
0 <= k < 2^n, c in {0,1} に対し
|k>_n |c> -> exp(2πi * a * c * k / 2^n) |k>_n |c>
リトルエンディアン( k[0] が最下位ビット )想定。
バタフライ版QFTで回路深さを削減しつつ、位相を付与。
"""
k = QuantumRegister(n) # n量子ビット (k[0]がLSB)
c = QuantumRegister(1) # 1量子ビット (制御)
qc = QuantumCircuit(k, c)
# 1) QFT(k)
qft_butterfly(qc, k, inverse=False)
# 2) c=1 のとき k[j] に位相 2π a 2^j / 2^n を付与 (並列にcp)
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_butterfly(qc, k, inverse=True)
return qc
''' |
QPC004_B2 | AE5270A14F50E | 8 | AC | 2154 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 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_B2 | AEA6C2755E52B | 1 | DLE | 1868 ms | 156 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)
# Iterate over all possible values of k (0 to 2^n - 1)
for k_value in range(2**n):
# Calculate the phase shift angle
phase_shift = (2 * math.pi * a * k_value) / (2**n)
# Apply the controlled phase shift if c is 1
# We use the `cp` gate for controlled phase shift
qc.cp(phase_shift, c[0], k) # c[0] controls the phase shift on all k qubits
return qc
''' |
QPC004_B2 | AEA6C2755E52B | 2 | RE | 2075 ms | 156 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_val in range(2**n):
qc.u1(2 * math.pi * a * k_val / 2**n, k)
return qc
''' |
QPC004_B2 | AF2DE78B41C6F | 1 | RE | 1484 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):
phase = 2 * math.pi * a * (2**i) / (2**n)
qc.cp(phase, n, i)
return qc
''' |
QPC004_B2 | AF2DE78B41C6F | 2 | RE | 1668 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):
phase = 2 * math.pi * a / (2**n)
qc.cp(phase, n, i)
return qc
''' |
QPC004_B2 | AF2DE78B41C6F | 3 | RE | 1659 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):
phase = 2 * math.pi * a * (2**(n-1-i)) / (2**n)
qc.cp(phase, n, i)
return qc
''' |
QPC004_B2 | AF2DE78B41C6F | 4 | RE | 1717 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):
phase = 2 * math.pi * a * (2**(n-1-i)) / (2**n)
qc.cp(phase, n, i)
return qc
''' |
QPC004_B2 | AF2DE78B41C6F | 5 | RE | 1529 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):
phase = 2 * math.pi * a * (2**(n-i)) / (2**n)
qc.cp(phase, n, i)
return qc
''' |
QPC004_B2 | AF2DE78B41C6F | 6 | RE | 1647 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):
phase = 2 * math.pi * a * (2**(n-i)) / (2**n)
qc.cp(phase, n, i)
return qc
''' |
QPC004_B2 | AF2DE78B41C6F | 7 | RE | 1576 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):
phase = 2 * math.pi * a * (2**(i+1)) / (2**n)
qc.cp(phase, n, i)
return qc
''' |
QPC004_B2 | AF2DE78B41C6F | 8 | RE | 1601 ms | 158 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def oracle(n, a):
qc = QuantumCircuit(n)
for i in range(n):
phase = 2 * math.pi * a * (2**(i+1)) / (2**n)
qc.p(phase, i)
return qc.to_gate().control(1)
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
oracle_gate = oracle(n, a)
qbits = []
qbits.append(n)
for i in range(0, n):
qbits.append(i)
qc.append(oracle_gate, qbits)
return qc
''' |
QPC004_B2 | AF2DE78B41C6F | 9 | RE | 1502 ms | 158 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def oracle(n, a):
for i in range(n-1, 0, -1):
qc.swap(qc, i, i-1)
qc = QuantumCircuit(n)
for i in range(n-1):
phase = 2 * math.pi * a * (2**(i+1)) / (2**n)
qc.cp(phase, i+1, i)
phase = 2 * math.pi * a * (2**n) / (2**n)
for i in range(0, n-1):
qc.swap(qc, i, i+1)
qc.cp(phase, 0, n-1)
return qc.to_gate().control(1)
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
oracle_gate = oracle(n, a)
qbits = []
qbits.append(n)
for i in range(0, n):
qbits.append(i)
qc.append(oracle_gate, qbits)
return qc
''' |
QPC004_B2 | AF2DE78B41C6F | 10 | RE | 1586 ms | 157 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def oracle(n, a):
qc = QuantumCircuit(n)
for i in range(n-1, 0, -1):
qc.swap(i, i-1)
for i in range(n-1):
phase = 2 * math.pi * a * (2**(i+1)) / (2**n)
qc.cp(phase, i+1, i)
phase = 2 * math.pi * a * (2**n) / (2**n)
for i in range(0, n-1):
qc.swap(i, i+1)
qc.cp(phase, 0, n-1)
return qc.to_gate().control(1)
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
oracle_gate = oracle(n, a)
qbits = []
qbits.append(n)
for i in range(0, n):
qbits.append(i)
qc.append(oracle_gate, qbits)
return qc
solve(3, 2).draw()
''' |
QPC004_B2 | AF2DE78B41C6F | 11 | RE | 1703 ms | 158 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def oracle(n, a):
qc = QuantumCircuit(n)
for i in range(n-1, 0, -1):
qc.swap(i, i-1)
for i in range(n-1):
phase = 2 * math.pi * a * (2**(i+1)) / (2**n)
qc.cp(phase, i+1, i)
phase = 2 * math.pi * a * (2**n) / (2**n)
for i in range(0, n-1):
qc.swap(i, i+1)
qc.cp(phase, 0, n-1)
return qc.to_gate().control(1)
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
oracle_gate = oracle(n, a)
qbits = []
qbits.append(n)
for i in range(0, n):
qbits.append(i)
qc.append(oracle_gate, qbits)
return qc
''' |
QPC004_B2 | AF2DE78B41C6F | 12 | RE | 1582 ms | 157 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def oracle(n, a):
qc = QuantumCircuit(n)
for i in range(n-1, 0, -1):
qc.swap(i, i-1)
for i in range(n-1):
phase = 2 * math.pi * a * (2**(i+1)) / (2**n)
qc.cp(phase, i+1, i)
phase = 2 * math.pi * a * (2**n) / (2**n)
qc.cp(phase, 0, n-1)
for i in range(0, n-1):
qc.swap(i, i+1)
return qc.to_gate().control(1)
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
oracle_gate = oracle(n, a)
qbits = []
qbits.append(n)
for i in range(0, n):
qbits.append(i)
qc.append(oracle_gate, qbits)
return qc
''' |
QPC004_B2 | AF2DE78B41C6F | 13 | RE | 1737 ms | 157 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def oracle(n, a):
qc = QuantumCircuit(n)
for i in range(n-1, 0, -1):
qc.swap(i, i-1)
for i in range(n-1):
phase = 2 * math.pi * a * (2**(i)) / (2**n)
qc.cp(phase, i+1, i)
phase = 2 * math.pi * a * (2**(n-1)) / (2**n)
qc.cp(phase, 0, n-1)
for i in range(0, n-1):
qc.swap(i, i+1)
return qc.to_gate().control(1)
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
oracle_gate = oracle(n, a)
qbits = []
qbits.append(n)
for i in range(0, n):
qbits.append(i)
qc.append(oracle_gate, qbits)
return qc
''' |
QPC004_B2 | AF2DE78B41C6F | 14 | RE | 1769 ms | 158 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def oracle(n, a):
qc = QuantumCircuit(n)
for i in range(n-1, 0, -1):
qc.swap(i, i-1)
for i in range(n-1):
phase = 2 * math.pi * a * (2**(n-i)) / (2**n)
qc.cp(phase, i+1, i)
phase = 2 * math.pi * a * (2**(n-n+1)) / (2**n)
qc.cp(phase, 0, n-1)
for i in range(0, n-1):
qc.swap(i, i+1)
qc.draw()
return qc.to_gate().control(1)
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
oracle_gate = oracle(n, a)
qbits = []
qbits.append(n)
for i in range(0, n):
qbits.append(i)
qc.append(oracle_gate, qbits)
return qc
''' |
QPC004_B2 | AF2DE78B41C6F | 15 | RE | 1811 ms | 158 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def oracle(n, a):
qc = QuantumCircuit(n)
for i in range(n-1, 0, -1):
qc.swap(i, i-1)
for i in range(n-1):
phase = 2 * math.pi * a * (2**(n-i+1)) / (2**n)
qc.cp(phase, i+1, i)
phase = 2 * math.pi * a * (2**(n-n+1)) / (2**n)
qc.cp(phase, 0, n-1)
for i in range(0, n-1):
qc.swap(i, i+1)
qc.draw()
return qc.to_gate().control(1)
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
oracle_gate = oracle(n, a)
qbits = []
qbits.append(n)
for i in range(0, n):
qbits.append(i)
qc.append(oracle_gate, qbits)
return qc
''' |
QPC004_B2 | AF2DE78B41C6F | 16 | RE | 1865 ms | 158 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def oracle(n, a):
qc = QuantumCircuit(n)
for i in range(n-1, 0, -1):
qc.swap(i, i-1)
for i in range(n-1):
phase = 2 * math.pi * a * (2**(i+1)) / (2**n)
qc.h(i+1)
qc.cp(phase, i+1, i)
qc.h(i+1)
phase = 2 * math.pi * a * (2**n) / (2**n)
qc.h(n-1)
qc.cp(phase, 0, n-1)
qc.h(n-1)
for i in range(0, n-1):
qc.swap(i, i+1)
qc.draw()
return qc.to_gate().control(1)
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
oracle_gate = oracle(n, a)
qbits = []
qbits.append(n)
for i in range(0, n):
qbits.append(i)
qc.append(oracle_gate, qbits)
return qc
''' |
QPC004_B2 | AF2DE78B41C6F | 17 | RE | '''python
from qiskit import QuantumCircuit, QuantumRegister
def oracle(n, a):
qc = QuantumCircuit(n)
for i in range(n-1, 0, -1):
qc.swap(i, i-1)
for i in range(n-1):
phase = 2 * math.pi * a * (2**(i)) / (2**n)
qc.h(i+1)
qc.cp(phase, i+1, i)
qc.h(i+1)
phase = 2 * math.pi * a * (2**(n-1)) / (2**n)
qc.h(n-1)
qc.cp(phase, 0, n-1)
qc.h(n-)
for i in range(0, n-1):
qc.swap(i, i+1)
qc.draw()
return qc.to_gate().control(1)
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
oracle_gate = oracle(n, a)
qbits = []
qbits.append(n)
for i in range(0, n):
qbits.append(i)
qc.append(oracle_gate, qbits)
return qc
''' | ||
QPC004_B2 | AF2DE78B41C6F | 18 | RE | '''python
from qiskit import QuantumCircuit, QuantumRegister
def oracle(n, a):
qc = QuantumCircuit(n)
for i in range(n-1, 0, -1):
qc.swap(i, i-1)
for i in range(n-1):
phase = 2 * math.pi * a * (2**(i)) / (2**n)
qc.h(i+1)
qc.cp(phase, i+1, i)
qc.h(i+1)
phase = 2 * math.pi * a * (2**(n-)) / (2**n)
qc.h(n-1)
qc.cp(phase, 0, n-1)
qc.h(n-)
for i in range(0, n-1):
qc.swap(i, i+1)
return qc.to_gate().control(1)
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
oracle_gate = oracle(n, a)
qbits = []
qbits.append(n)
for i in range(0, n):
qbits.append(i)
qc.append(oracle_gate, qbits)
return qc
''' | ||
QPC004_B2 | AF2DE78B41C6F | 19 | RE | '''python
from qiskit import QuantumCircuit, QuantumRegister
def oracle(n, a):
qc = QuantumCircuit(n)
for i in range(n-1, 0, -1):
qc.swap(i, i-1)
for i in range(n-1):
phase = 2 * math.pi * a * (2**(i)) / (2**n)
qc.h(i+1)
qc.cp(phase, i+1, i)
qc.h(i+1)
phase = 2 * math.pi * a * (2**(n-)) / (2**n)
qc.h(0)
qc.cp(phase, 0, n-1)
qc.h(0)
for i in range(0, n-1):
qc.swap(i, i+1)
return qc.to_gate().control(1)
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
oracle_gate = oracle(n, a)
qbits = []
qbits.append(n)
for i in range(0, n):
qbits.append(i)
qc.append(oracle_gate, qbits)
return qc
''' | ||
QPC004_B2 | AF2DE78B41C6F | 20 | RE | 1496 ms | 157 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def oracle(n, a):
qc = QuantumCircuit(n)
for i in range(n-1, 0, -1):
qc.swap(i, i-1)
for i in range(n-1):
phase = 2 * math.pi * a * (2**(i+1)) / (2**n)
qc.h(i+1)
qc.cp(phase, i+1, i)
qc.h(i+1)
phase = 2 * math.pi * a * (2**(n)) / (2**n)
qc.h(0)
qc.cp(phase, 0, n-1)
qc.h(0)
for i in range(0, n-1):
qc.swap(i, i+1)
return qc.to_gate().control(1)
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
oracle_gate = oracle(n, a)
qbits = []
qbits.append(n)
for i in range(0, n):
qbits.append(i)
qc.append(oracle_gate, qbits)
return qc
''' |
QPC004_B2 | AF2DE78B41C6F | 21 | RE | 1754 ms | 158 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def oracle(n, a):
qc = QuantumCircuit(n)
for i in range(n-1, 0, -1):
qc.swap(i, i-1)
for i in range(n-1):
phase = 2 * math.pi * a * (2**(n-i-1)) / (2**n)
qc.h(i+1)
qc.cp(phase, i+1, i)
qc.h(i+1)
phase = 2 * math.pi * a * (2**(n-n+1)) / (2**n)
qc.h(0)
qc.cp(phase, 0, n-1)
qc.h(0)
for i in range(0, n-1):
qc.swap(i, i+1)
return qc.to_gate().control(1)
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
# Write your code here:
oracle_gate = oracle(n, a)
qbits = []
qbits.append(n)
for i in range(0, n):
qbits.append(i)
qc.append(oracle_gate, qbits)
return qc
''' |
QPC004_B2 | AF2DE78B41C6F | 22 | RE | 1946 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(0, n):
phase = 2 * math.pi * a * (2**i) / (2**n)
qc.cp(phase, n, i)
return qc
''' |
QPC004_B2 | AF2DE78B41C6F | 23 | AC | 1963 ms | 162 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(0, n):
phase = 2 * math.pi * a * (2**i) / (2**n)
qc.cp(phase, n, i)
return qc
''' |
QPC004_B2 | AF3E30B088F41 | 1 | WA | 2206 ms | 159 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import ZGate, XGate, HGate, SwapGate
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):
theta = 2 * math.pi * a * (2 ** i) / (2 ** n)
qc.cry(theta, k[i], c)
return qc
''' |
QPC004_B2 | AF3E30B088F41 | 2 | AC | 2887 ms | 160 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import ZGate, XGate, HGate, SwapGate
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):
theta = 2 * math.pi * a * (2 ** i) / (2 ** n)
qc.cp(theta, k[i], c)
return qc
''' |
QPC004_B2 | AF95927B7CA88 | 1 | RE | 1652 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**n
qc.cp(theta, i, n+1)
return qc
''' |
QPC004_B2 | AF95927B7CA88 | 2 | RE | 1762 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**n
qc.cp(theta, n+1,i)
return qc
''' |
QPC004_B2 | AF95927B7CA88 | 3 | RE | 1652 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**n
qc.cp(theta, n, i)
return qc
''' |
QPC004_B2 | AF95927B7CA88 | 4 | RE | 1705 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**n
qc.cp(theta, c[1], i)
return qc
''' |
QPC004_B2 | AF95927B7CA88 | 5 | RE | 1766 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**n
qc.cp(theta, c[0], i)
return qc
''' |
QPC004_B2 | AF95927B7CA88 | 6 | RE | 1459 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**n
qc.cp(theta, n, i)
return qc
''' |
QPC004_B2 | AF95927B7CA88 | 7 | RE | 1615 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**n
qc.cp(theta, i,n)
return qc
''' |
QPC004_B2 | AF95927B7CA88 | 8 | RE | 1758 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**n
qc.cp(theta,n,i)
return qc
''' |
QPC004_B2 | AF95927B7CA88 | 9 | RE | 1437 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**n
qc.cp(theta,n+1,i)
return qc
''' |
QPC004_B2 | AF95927B7CA88 | 10 | 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)
# Write your code here:
for i in range(n):
theta = 2 * math.pi * a / 2**n
qc.cp(theta,n-1,i)
return qc
''' |
QPC004_B2 | AF95927B7CA88 | 11 | RE | 1628 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**n
qc.cp(theta,qc[n],i)
return qc
''' |
QPC004_B2 | AF95927B7CA88 | 12 | RE | 2009 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**n
qc.cp(theta,n,i)
return qc
''' |
QPC004_B2 | AF95927B7CA88 | 13 | RE | 1558 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**n
qc.cp(theta,n,i)
return qc
''' |
QPC004_B2 | AF95927B7CA88 | 14 | 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)
# Write your code here:
for i in range(n):
theta = 2 * math.pi * a / 2**n
qc.cp(theta,n,i)
return qc
''' |
QPC004_B2 | AF95927B7CA88 | 15 | RE | 1759 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**n
qc.cp(theta,n,i)
return qc
''' |
QPC004_B2 | AF95927B7CA88 | 16 | RE | 1488 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**n
qc.cp(theta,c[0],i)
return qc
''' |
QPC004_B2 | AF95927B7CA88 | 17 | RE | 1733 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**n
qc.cp(theta,c[1],i)
return qc
''' |
QPC004_B2 | AF95927B7CA88 | 18 | RE | 1543 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**n
qc.cp(theta,c[0],i)
return qc
''' |
QPC004_B2 | AF95927B7CA88 | 19 | RE | 1540 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**n
qc.cp(theta,n,i)
return qc
''' |
QPC004_B2 | AF95927B7CA88 | 20 | RE | 1881 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(k):
theta = 2 * math.pi * a / 2**n
qc.cp(theta,n,i)
return qc
''' |
QPC004_B2 | AF95927B7CA88 | 21 | RE | 1561 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(k):
theta = 2 * math.pi * a / 2**k
qc.cp(theta,c[0],i)
return qc
''' |
QPC004_B2 | AF95927B7CA88 | 22 | RE | 1646 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**n
qc.cp(theta,n,i)
return qc
''' |
QPC004_B2 | AF95927B7CA88 | 23 | RE | 1717 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**n
qc.cp(theta,i,n)
return qc
''' |
QPC004_B2 | AF95927B7CA88 | 24 | RE | 1837 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:
theta = 2 * math.pi * a / 2**n
for i in range(n):
qc.cp(theta,n,i)
return qc
''' |
QPC004_B2 | AF95927B7CA88 | 25 | RE | 1681 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:
theta = 2 * math.pi * a / 2**n
for i in range(n):
qc.cp(theta,c[0],i)
return qc
''' |
QPC004_B2 | AF95927B7CA88 | 26 | RE | 1632 ms | 156 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:
theta = 2 * math.pi * a / 2**n
for i in range(n):
qc.cp(theta,n,i)
return qc
''' |
QPC004_B2 | AF95927B7CA88 | 27 | RE | 1590 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:
theta = 2 * math.pi * a / 2**n
for i in range(n):
qc.cp(theta,c[0],i)
return qc
''' |
QPC004_B2 | AF95927B7CA88 | 28 | RE | 1742 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:
theta = 2 * math.pi * a / 2**n
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 | 29 | RE | 1696 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:
theta = 2 * math.pi * a / 2**n
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 | 30 | RE | 1774 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:
theta = 2 * math.pi * a / 2**n
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 | 31 | RE | 1737 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:
theta = 2 * math.pi * a / 2**n
for i in range(n):
theta = (2 * math.pi * a * 2**(n-i)) / 2**n
qc.cp(theta,c[0],i)
return qc
''' |
QPC004_B2 | AF95927B7CA88 | 32 | RE | 1622 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:
theta = 2 * math.pi * a / 2**n
for i in range(n):
theta = (2 * math.pi * a * 2**(n-i-1)) / 2**n
qc.cp(theta,c[0],i)
return qc
''' |
QPC004_B2 | AF95927B7CA88 | 33 | RE | 1632 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:
theta = 2 * math.pi * a / 2**n
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 | 34 | RE | 1771 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:
theta = 2 * math.pi * a / 2**n
for i in range(n):
theta = (2 * math.pi * a * 2**(i+1)) / 2**n
qc.cp(theta,c[0],i)
return qc
''' |
QPC004_B2 | AF95927B7CA88 | 35 | RE | 1821 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:
theta = 2 * math.pi * a / 2**n
for i in range(n):
theta = (2 * math.pi * a * 2**i) / 2**n
qc.cp(theta,c[0],i)
return qc
''' |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.