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 | A1DF48A294E05 | 2 | WA | 1780 ms | 162 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from math import 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):
qc.cp(pi/(2**(n - i)), n, i)
return qc
''' |
QPC004_B2 | A1DF48A294E05 | 3 | WA | 1840 ms | 162 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from math import 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):
qc.cp(2*pi/(2**(n - i)), n, i)
return qc
''' |
QPC004_B2 | A1DF48A294E05 | 4 | AC | 2321 ms | 163 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from math import 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):
qc.cp(2*a*pi/(2**(n - i)), n, i)
return qc
''' |
QPC004_B2 | A3CD632CB3206 | 1 | RE | 1589 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:
for i in range(n):
qc.cp(2*math.pi*a / 2**(n-i), n, i)
return qc
''' |
QPC004_B2 | A3CD632CB3206 | 2 | AC | 2786 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
for i in range(n):
qc.cp(2*math.pi*a / 2**(n-i), n, i)
return qc
''' |
QPC004_B2 | A3DD5B53D4651 | 1 | RE | 1891 ms | 158 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library.standard_gates import PhaseGate
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.append(PhaseGate(2*math.pi*a/(2**(n-i))).control(i), [n])
return qc
''' |
QPC004_B2 | A3DD5B53D4651 | 2 | AC | 2434 ms | 162 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library.standard_gates import PhaseGate
import math
# from qiskit.quantum_info import Statevector
def solve(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
# if __name__ == "__main__":
# qc = solve(3, 1)
# print(Statevector(qc))
''' |
QPC004_B2 | A46DFCB7BFB2D | 1 | RE | 1811 ms | 158 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):
a_k = (a >> i) & 1
if a_k == 1:
angle = 2 * math.pi * a_k / (2**n)
qc.cp(angle, k[i], c[0])
qc.append([qc.cx(c[0], k[i]) for i in range(n)], k)
return qc
''' |
QPC004_B2 | A46DFCB7BFB2D | 2 | RE | 1788 ms | 157 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 * math.pi * a * k / 2**n
qc.p(theta, c, i)
return qc
''' |
QPC004_B2 | A46DFCB7BFB2D | 3 | WA | 1844 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 * i / 2**n
qc.p(theta, k[i])
return qc
''' |
QPC004_B2 | A46DFCB7BFB2D | 4 | WA | 1891 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 * i / 2**n
qc.cp(theta, c, k[i])
return qc
''' |
QPC004_B2 | A46DFCB7BFB2D | 5 | WA | 1982 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 * i / 2**n
qc.cp(theta, c[0], k[i])
return qc
''' |
QPC004_B2 | A46DFCB7BFB2D | 6 | RE | 1688 ms | 157 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
import qiskit.circuit.library as qulib
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 * i )/ 2**n
cy_gate1 = qulib.RYGate(Theta).control(1,ctrl_state = '1')
qc.append(cy_gate1, [c, k[i]])
return qc
''' |
QPC004_B2 | A4A1F64DE42A9 | 1 | AC | 2418 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):
phase = 2 * np.pi * a * (2 ** i) / (2 ** n)
qc.cp(phase, k[i], c[0])
return qc
''' |
QPC004_B2 | A509995FC078A | 1 | RE | 1814 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:
for i in range(n):
qc.cp(2*math.pi*a/2**n,n,i)
return qc
''' |
QPC004_B2 | A509995FC078A | 2 | RE | 1755 ms | 157 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import PhaseGate as PGate
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.append(PGate(2*math.pi*a/2**n).control(1), qargs=(i,n))
return qc
''' |
QPC004_B2 | A509995FC078A | 3 | WA | 1884 ms | 160 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import PhaseGate as PGate
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.append(PGate(2*math.pi*a/2**n).control(1), qargs=(i,n))
return qc
''' |
QPC004_B2 | A509995FC078A | 4 | UME | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import PhaseGate as PGate
import ma
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.append(PGate(2*math.pi*a/2**n).control(1), qargs=(n,i))
return qc
''' | ||
QPC004_B2 | A509995FC078A | 5 | WA | 1900 ms | 160 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import PhaseGate as PGate
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.append(PGate(2*math.pi*a/2**n).control(1), qargs=(n,i))
return qc
''' |
QPC004_B2 | A509995FC078A | 6 | RE | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import PhaseGate as PGate
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.append(PGate(2*math.pi*/2**(n-i)).control(1), qargs=(n,i))
return qc
''' | ||
QPC004_B2 | A509995FC078A | 7 | AC | 1994 ms | 161 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import PhaseGate as PGate
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.append(PGate(2*math.pi*a/2**(n-i)).control(1), qargs=(n,i))
return qc
''' |
QPC004_B2 | A57BD588E6457 | 1 | RE | 1643 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 * i * a * k / 2**n
qc.p(theta, i)
return qc
''' |
QPC004_B2 | A57BD588E6457 | 2 | RE | 1611 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 * i *a * k / 2**n
# qc.p(theta, i)
# For each qubit in k, apply a controlled-phase (cp) gate.
for i in range(n):
# Each qubit k[i] (which has weight 2^i) gets a phase shift:
angle = 2 * math.pi * a * (2**i) / (2**n)
# Apply the controlled phase gate: if c=1 and k[i]=1, then apply exp(i*angle)
qc.cp(angle, c[0], k[i])
return qc
''' |
QPC004_B2 | A57BD588E6457 | 3 | RE | 1732 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 * i *a * k / 2**n
# qc.p(theta, i)
# For each qubit in k, apply a controlled-phase (cp) gate.
for i in range(n):
# Each qubit k[i] (which has weight 2^i) gets a phase shift:
angle = 2 * math.pi * a * i / (2**n)
# Apply the controlled phase gate: if c=1 and k[i]=1, then apply exp(i*angle)
qc.cp(angle, c[0], k[i])
return qc
''' |
QPC004_B2 | A57BD588E6457 | 4 | RE | 1726 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 * i *a * k / 2**n
# qc.p(theta, i)
# # For each qubit in k, apply a controlled-phase (cp) gate.
# for i in range(n):
# # Each qubit k[i] (which has weight 2^i) gets a phase shift:
# angle = 2 * math.pi * a * i / (2**n)
# # Apply the controlled phase gate: if c=1 and k[i]=1, then apply exp(i*angle)
# qc.cp(angle, c[0], k[i])
# 各 k のビット k_i に対して制御位相シフトを適用
for i in range(n):
theta = 2 * math.pi * a * (2**i) / 2**n # 位相シフト角度の計算
qc.cp(theta, k[i], c[0]) # 制御付き位相シフト
return qc
''' |
QPC004_B2 | A57BD588E6457 | 5 | RE | 1908 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 * i *a * k / 2**n
# qc.p(theta, i)
# # For each qubit in k, apply a controlled-phase (cp) gate.
# for i in range(n):
# # Each qubit k[i] (which has weight 2^i) gets a phase shift:
# angle = 2 * math.pi * a * i / (2**n)
# # Apply the controlled phase gate: if c=1 and k[i]=1, then apply exp(i*angle)
# qc.cp(angle, c[0], k[i])
# 各 k のビット k_i に対して制御位相シフトを適用
for i in range(n):
theta = 2 * math.pi * a * (i) / 2**n # 位相シフト角度の計算
qc.cp(theta, k[i], c[0]) # 制御付き位相シフト
return qc
''' |
QPC004_B2 | A57BD588E6457 | 6 | RE | '''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 * i *a * k / 2**n
# qc.p(theta, i)
# # For each qubit in k, apply a controlled-phase (cp) gate.
# for i in range(n):
# # Each qubit k[i] (which has weight 2^i) gets a phase shift:
# angle = 2 * math.pi * a * i / (2**n)
# # Apply the controlled phase gate: if c=1 and k[i]=1, then apply exp(i*angle)
# qc.cp(angle, c[0], k[i])
# 各 k のビット k_i に対して制御位相シフトを適用
for i in range(n):
theta = 2 * math.pi * a * / 2**(n - i) # 位相シフト角度の計算
qc.cp(theta, k[i], c[0]) # 制御付き位相シフト
return qc
''' | ||
QPC004_B2 | A57BD588E6457 | 7 | RE | 1507 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 * i *a * k / 2**n
# qc.p(theta, i)
# # For each qubit in k, apply a controlled-phase (cp) gate.
# for i in range(n):
# # Each qubit k[i] (which has weight 2^i) gets a phase shift:
# angle = 2 * math.pi * a * i / (2**n)
# # Apply the controlled phase gate: if c=1 and k[i]=1, then apply exp(i*angle)
# qc.cp(angle, c[0], k[i])
# 各 k のビット k_i に対して制御位相シフトを適用
for i in range(n):
theta = 2 * math.pi * a * i / 2**(n) # 位相シフト角度の計算
qc.cp(theta, k[i], c) # 制御付き位相シフト
return qc
''' |
QPC004_B2 | A57BD588E6457 | 8 | RE | 1689 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 * i *a * k / 2**n
# qc.p(theta, i)
# # For each qubit in k, apply a controlled-phase (cp) gate.
# for i in range(n):
# # Each qubit k[i] (which has weight 2^i) gets a phase shift:
# angle = 2 * math.pi * a * i / (2**n)
# # Apply the controlled phase gate: if c=1 and k[i]=1, then apply exp(i*angle)
# qc.cp(angle, c[0], k[i])
# 各 k のビット k_i に対して制御位相シフトを適用
for i in range(n):
theta = 2 * math.pi * a * i / 2**(n) # 位相シフト角度の計算
qc.cp(theta, i, 1) # 制御付き位相シフト
return qc
''' |
QPC004_B2 | A57BD588E6457 | 9 | RE | 1531 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 * i *a * k / 2**n
# qc.p(theta, i)
# # For each qubit in k, apply a controlled-phase (cp) gate.
# for i in range(n):
# # Each qubit k[i] (which has weight 2^i) gets a phase shift:
# angle = 2 * math.pi * a * i / (2**n)
# # Apply the controlled phase gate: if c=1 and k[i]=1, then apply exp(i*angle)
# qc.cp(angle, c[0], k[i])
# 各 k のビット k_i に対して制御位相シフトを適用
for i in range(n):
theta = 2 * math.pi * a * i / 2**(n) # 位相シフト角度の計算
qc.cp(theta, i, 0) # 制御付き位相シフト
return qc
''' |
QPC004_B2 | A57BD588E6457 | 10 | RE | 1772 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 * i *a * k / 2**n
# qc.p(theta, i)
# # For each qubit in k, apply a controlled-phase (cp) gate.
# for i in range(n):
# # Each qubit k[i] (which has weight 2^i) gets a phase shift:
# angle = 2 * math.pi * a * i / (2**n)
# # Apply the controlled phase gate: if c=1 and k[i]=1, then apply exp(i*angle)
# qc.cp(angle, c[0], k[i])
# 各 k のビット k_i に対して制御位相シフトを適用
for i in range(n):
theta = 2 * math.pi * a * i / 2**(n) # 位相シフト角度の計算
qc.cp(theta, c[0], k[i]) # 制御付き位相シフト
return qc
''' |
QPC004_B2 | A57BD588E6457 | 11 | RE | 1606 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 * i *a * k / 2**n
# qc.p(theta, i)
# # For each qubit in k, apply a controlled-phase (cp) gate.
# for i in range(n):
# # Each qubit k[i] (which has weight 2^i) gets a phase shift:
# angle = 2 * math.pi * a * i / (2**n)
# # Apply the controlled phase gate: if c=1 and k[i]=1, then apply exp(i*angle)
# qc.cp(angle, c[0], k[i])
# 各 k のビット k_i に対して制御位相シフトを適用
for i in range(n):
theta = 2 * math.pi * a * (2**i) / 2**(n) # 位相シフト角度の計算
qc.cp(theta, c[0], k[i]) # 制御付き位相シフト
return qc
''' |
QPC004_B2 | A57BD588E6457 | 12 | RE | 1942 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:
# 各 k のビット k_i に対して制御位相シフトを適用
for i in range(n):
theta = 2 * math.pi * a * (2**i) / 2**n # 位相シフト角度の計算
qc.cp(theta, c[0], k[i]) # 制御付き位相シフト
return qc
''' |
QPC004_B2 | A57BD588E6457 | 13 | WA | 1700 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:
# 各 k のビット k_i に対して制御位相シフトを適用
for i in range(n):
# theta = 2 * math.pi * a * (2**i) / 2**n # 位相シフト角度の計算
# qc.cp(theta, c[0], k[i]) # 制御付き位相シフト
if c == 1:
theta = 2 * math.pi * a * k / 2**n
qc.p(theta, i)
return qc
''' |
QPC004_B2 | A63AA88460D2F | 1 | WA | 1791 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)
for i in range(n):
theta = 2 * math.pi / 2**n * a
qc.cp(theta,n,i)
# Write your code here:
return qc
''' |
QPC004_B2 | A63AA88460D2F | 2 | WA | 1614 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)
return qc
''' |
QPC004_B2 | A63AA88460D2F | 3 | WA | 1977 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)
for i in range(n):
theta = 2 * math.pi * 1 * a / 2**n
qc.p(theta,i)
return qc
''' |
QPC004_B2 | A63AA88460D2F | 4 | WA | 1793 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)
for i in range(n):
theta = 2 * math.pi * 1 * a / 2**n
qc.cp(theta,c[0],k[i])
return qc
''' |
QPC004_B2 | A63AA88460D2F | 5 | WA | 1719 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)
for i in range(n):
theta = 2 * math.pi * 1 * a / 2**n
qc.p(theta,k[i])
return qc
''' |
QPC004_B2 | A63AA88460D2F | 6 | WA | 1910 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)
for i in range(n):
theta = 2 * math.pi * 1 * a / 2**n
qc.p(theta,k[i])
qc = QuantumCircuit(k, c)
return qc
''' |
QPC004_B2 | A63AA88460D2F | 7 | RE | 1783 ms | 158 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
for i in range(n):
theta = 2 * math.pi * 1 * a / 2**n
k.p(theta,i)
qc = QuantumCircuit(k, c)
return qc
''' |
QPC004_B2 | A63AA88460D2F | 8 | AC | 1926 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)
p=math.pi
# Write your code here:
for i in range(n):
qc.cp(p*2**i/2**(n-1)*a,n,i)
return qc
solve(4,3).draw()
''' |
QPC004_B2 | A6463F4716127 | 1 | RE | 1598 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*k) / 2**n
qc.p(theta, i)
return qc
''' |
QPC004_B2 | A6463F4716127 | 2 | RE | 1920 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)
# Write your code here:
for i in range(n):
theta = 2 * math.pi * (a*k) / 2**n
qc.p(theta, i)
return qc
''' |
QPC004_B2 | A6463F4716127 | 3 | UME | '''python
from qiskit import QuantumCircuit, QuantumRegister
import mat
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*i) / 2**n
qc.p(theta, i)
return qc
''' | ||
QPC004_B2 | A6463F4716127 | 4 | UME | '''python
from qiskit import QuantumCircuit, QuantumRegister
import mat
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*i*k) / 2**n
qc.p(theta, i)
return qc
''' | ||
QPC004_B2 | A6463F4716127 | 5 | RE | 1740 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*i*k) / 2**n
qc.p(theta, i)
return qc
''' |
QPC004_B2 | A6728D5281BDF | 1 | WA | 1898 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
for j in range(1, n):
theta = 2 * math.pi * a * (2**(j-n))
qc.cp(theta,0,j)
return qc
''' |
QPC004_B2 | A6728D5281BDF | 2 | WA | 1879 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
for j in range(1,n+1):
theta = 2 * math.pi * a * (2**(j-n))
qc.cp(theta,0,j)
return qc
''' |
QPC004_B2 | A6728D5281BDF | 3 | WA | 1794 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:
import math
for j in range(1,n+1):
theta = 2 * math.pi * a * (2**(-n))
qc.cp(theta,0,j)
return qc
''' |
QPC004_B2 | A6728D5281BDF | 4 | AC | 1889 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 j in range(n):
theta = (2 * 3.141592653589793 * a) / (2 ** (n - j))
qc.cp(theta, k[j], c[0]) # c を制御ビット、k[j] を対象ビットとして位相を適用
return qc
''' |
QPC004_B2 | A6839A71066FF | 1 | AC | 3000 ms | 162 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from math import pi, acos, sqrt, asin
from qiskit.circuit.library import XGate, ZGate, PhaseGate
"""
You can apply oracle as follows:
qc.compose(o, inplace=True)
"""
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
for i in range(n):
qc.append(PhaseGate(2*pi*a*(1/2)**(n-i)).control(1), [n, i])
return qc
''' |
QPC004_B2 | A68B1F136C9AC | 1 | WA | 2776 ms | 159 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from math import 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):
angle = (2**i * a * 2* pi* i) / 2**n
qc.cp(angle, c[0], i)
return qc
''' |
QPC004_B2 | A68B1F136C9AC | 2 | AC | 2142 ms | 160 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from math import 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):
angle = (2* pi * 2**i * a ) / 2**n
qc.cp(angle, c[0], i)
return qc
''' |
QPC004_B2 | A6D224A0F875F | 1 | RE | 1794 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 k in range(n):
theta = 2 * math.pi * i * k * c * a / 2**n
qc.p(theta, k)
return qc
''' |
QPC004_B2 | A6D224A0F875F | 2 | RE | 1661 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 k in range(n):
theta = 2 * math.pi * c * a * k/ 2**n
qc.p(theta, k)
return qc
''' |
QPC004_B2 | A6D224A0F875F | 3 | RE | '''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) 2**i
qc.cp(theta, c[0], k[i])
return qc
''' | ||
QPC004_B2 | A6D224A0F875F | 4 | RE | 1681 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) * 2**i
qc.cp(theta, c[0], k[i])
return qc
''' |
QPC004_B2 | A6D224A0F875F | 5 | AC | 2210 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) * 2**i
qc.cp(theta, -1, i)
return qc
''' |
QPC004_B2 | A6EB0AF7D8644 | 1 | AC | 2131 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=2*math.pi*a*(2**j)/(2**n)
qc.cp(theta,k[j],c[0])
return qc
''' |
QPC004_B2 | A7555CBE259FD | 1 | RE | 1710 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 * pi * a / 2**n
qc.cp(theta,n, i)
return qc
''' |
QPC004_B2 | A7555CBE259FD | 2 | WA | 1707 ms | 161 MiB | '''python
from math import ceil,floor,acos,asin,atan,sqrt,pi,gcd,sin,cos,tan
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 * pi * a / 2**n
qc.cp(theta,n, i)
return qc
''' |
QPC004_B2 | A7555CBE259FD | 3 | AC | 2100 ms | 163 MiB | '''python
from math import ceil,floor,acos,asin,atan,sqrt,pi,gcd,sin,cos,tan
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 * pi * a * 2**i / 2**n
qc.cp(theta,n, i)
return qc
''' |
QPC004_B2 | A76737D9E6673 | 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:
k = QuantumRegister(n)
c = QuantumRegister(1)
qc = QuantumCircuit(k, c)
for i in range(n):
qc.cp(2 * np.pi * a / (2**n), k[i], c[0])
return qc
''' |
QPC004_B2 | A76737D9E6673 | 2 | WA | 1919 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:
k = QuantumRegister(n)
c = QuantumRegister(1)
qc = QuantumCircuit(k, c)
for i in range(n):
qc.cp(2 * np.pi * a / (2**n), k[i], c[0])
return qc
''' |
QPC004_B2 | A76737D9E6673 | 3 | WA | 1941 ms | 161 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import PhaseGate
def solve(n: int, a: int) -> QuantumCircuit:
k = QuantumRegister(n, 'k')
c = QuantumRegister(1, 'c')
qc = QuantumCircuit(k, c)
for j in range(n):
for l in range(n - j):
phase = (a * 2**(l + j)) / (2**n)
qc.append(PhaseGate(2 * phase * 2**j), [k[l]])
for j in range(n):
qc.cx(k[j], c[0])
return qc
''' |
QPC004_B2 | A76737D9E6673 | 4 | WA | 1825 ms | 163 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import PhaseGate
def solve(n: int, a: int) -> QuantumCircuit:
k = QuantumRegister(n, 'k')
c = QuantumRegister(1, 'c')
qc = QuantumCircuit(k, c)
for j in range(n):
phase = (a * 2**j) / (2**n)
qc.append(PhaseGate(2 * phase), [k[j]])
for j in range(n):
qc.cx(k[j], c[0])
return qc
''' |
QPC004_B2 | A76737D9E6673 | 5 | WA | 1890 ms | 162 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import PhaseGate
def solve(n: int, a: int) -> QuantumCircuit:
k = QuantumRegister(n, 'k')
c = QuantumRegister(1, 'c')
qc = QuantumCircuit(k, c)
for j in range(n):
phase = (a * 2**j) / (2**n)
qc.append(PhaseGate(2 * phase * (2**(n-1-j))), [k[j]])
for j in range(n):
qc.cx(k[j], c[0])
return qc
''' |
QPC004_B2 | A76737D9E6673 | 6 | WA | 1848 ms | 162 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import PhaseGate
def solve(n: int, a: int) -> QuantumCircuit:
k = QuantumRegister(n, 'k')
c = QuantumRegister(1, 'c')
qc = QuantumCircuit(k, c)
for j in range(n):
phase = (a * 2**j) / (2**n)
qc.append(PhaseGate(2 * phase * (2**(n-1-j))), [k[j]])
for j in range(n):
qc.cx(k[j], c[0])
return qc
''' |
QPC004_B2 | A76737D9E6673 | 7 | RE | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import PhaseGate
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
for i in range(n):
qc.append(
qc.crz(2 * pi * a / (2**n), k[i], c[0]), # 位相ゲート（制御付き）
[k[i], c[0]]
)
return qc
''' | ||
QPC004_B2 | A76737D9E6673 | 8 | RE | '''python
from qiskit import QuantumCircuit, QuantumRegister
from math import pi
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
for i in range(n):
qc.append(
qc.crz(2 * pi * a / (2**n), k[i], c[0]), # 位相ゲート（制御付き）
[k[i], c[0]]
)
return qc
''' | ||
QPC004_B2 | A76737D9E6673 | 9 | RE | '''python
from qiskit import QuantumCircuit, QuantumRegister
from math import pi
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
for i in range(n):
qc.crz(2 * pi * a / (2**n), k[i], c[0]) # 位相ゲート（制御付き）
return qc
''' | ||
QPC004_B2 | A76737D9E6673 | 10 | WA | 2097 ms | 162 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from math import pi
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
for i in range(n):
qc.crz(2 * pi * a / (2**n), k[i], c[0]) # 位相ゲート（制御付き）
return qc
''' |
QPC004_B2 | A7EE5502F514F | 1 | AC | 2091 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)
theta = math.pi*a
for i in range(n-1,-1,-1):
qc.cp(theta,i,n)
theta/=2
return qc
''' |
QPC004_B2 | A8ED6006EF7EA | 1 | RE | 1574 ms | 157 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)
# Calculate phase for each qubit position
for i in range(n):
# Phase is applied when k[i]=1 and c=1
# Phase angle for position i is: 2π * a * 2^i / 2^n = 2π * a * 2^(i-n)
angle = 2 * a * pow(2, i-n) # Normalized by 2π
# Controlled-controlled phase rotation
# Only apply phase when both k[i]=1 and c=1
qc.cp(2 * pi * angle, k[i], c[0])
return qc
''' |
QPC004_B2 | A8ED6006EF7EA | 2 | AC | 2049 ms | 163 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from math import pi
def solve(n: int, a: int) -> QuantumCircuit:
# Create quantum registers for k and c
k = QuantumRegister(n)
c = QuantumRegister(1)
qc = QuantumCircuit(k, c)
# For each bit position in k
for i in range(n):
# Calculate phase angle: 2π * a * 2^i / 2^n
angle = 2 * pi * a * pow(2, i-n)
# Apply controlled phase rotation
# Use controlled-phase gate between k[i] and c[0]
qc.cp(angle, k[i], c[0])
return qc
''' |
QPC004_B2 | A951004B1C3AF | 1 | AC | 2594 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)
for i in range(n):
qc.cp(2 * a * pi / 2**n * 2**i, c, k[i])
return qc
''' |
QPC004_B2 | A95F0B16D9518 | 1 | RE | 1851 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 * S[i] / 2**m
qc.cp(theta, n, i)
return qc
''' |
QPC004_B2 | A95F0B16D9518 | 2 | RE | 1491 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 * i / 2**m
qc.cp(theta, n, i)
return qc
''' |
QPC004_B2 | A95F0B16D9518 | 3 | RE | 1497 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 * i / 2**m
qc.cp(theta, n, i)
return qc
''' |
QPC004_B2 | A95F0B16D9518 | 4 | RE | 1544 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 * i / 2**n
qc.cp(theta, n, i)
return qc
''' |
QPC004_B2 | A95F0B16D9518 | 5 | WA | 1924 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 (c == 1):
theta = 2 * math.pi * a * i / 2**n
qc.p(theta)
return qc
''' |
QPC004_B2 | A95F0B16D9518 | 6 | RE | 1616 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):
if (c):
theta = 2 * math.pi * a * i / 2**n
qc.p(theta)
return qc
''' |
QPC004_B2 | A95F0B16D9518 | 7 | RE | 1536 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 (c.measure()):
theta = 2 * math.pi * a * i / 2**n
qc.p(theta)
return qc
''' |
QPC004_B2 | A9963837D7AE6 | 1 | AC | 2081 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)
for i in range(n):
angle = 2 * np.pi * a / (2 ** (n-i))
qc.cp(angle, i, n)
return qc
''' |
QPC004_B2 | A99AE87E3C658 | 1 | RE | '''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)
angle=2*np.pi*a*(2**n-1)/2**n
qc.rz(angle, n)
for i in range (n):
angle_i=2*np.pi*a*(2**(i)/2**n
qc.crz(angle_i, n, i)
return qc
''' | ||
QPC004_B2 | A99AE87E3C658 | 2 | WA | 1617 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)
angle=2*np.pi*a*(2**n-1)/2**n
qc.rz(angle, n)
for i in range (n):
angle_i=2*np.pi*a*2**(i)/2**n
qc.crz(angle_i, n, i)
return qc
''' |
QPC004_B2 | A99AE87E3C658 | 3 | WA | 1735 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)
angle=2*np.pi*a*(2**n-1)/2**n
qc.rz(angle, n)
for i in range (n):
angle_i=2*np.pi*a*2**(i)/2**n
qc.crz(angle_i, n, i)
return qc
''' |
QPC004_B2 | A99AE87E3C658 | 4 | WA | 1629 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)
angle=2*np.pi*a*(2**n-1)/2**n
qc.rz(angle, c[0])
for i in range (n):
angle_i=2*np.pi*a*2**(i)/2**n
qc.crz(angle_i, c[0], i)
return qc
''' |
QPC004_B2 | A99AE87E3C658 | 5 | RE | 1744 ms | 158 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)
angle=2*np.pi*a*(2**n-1)/2**n
qc.rz(angle*c[0], c[0])
for i in range (n):
angle_i=2*np.pi*a*2**(i)/2**n
qc.crz(angle_i, c[0], i)
return qc
''' |
QPC004_B2 | A99AE87E3C658 | 6 | RE | 1665 ms | 158 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)
for i in range (n):
angle_i=2*np.pi*a*2**(i)/2**n
qc.cp(n, angle_i)
return qc
''' |
QPC004_B2 | A99AE87E3C658 | 7 | RE | 1512 ms | 158 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import numpy as np
from qiskit.circuit.library import CU1Gate
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
for i in range (n):
angle_i=2*np.pi*a*2**(i)/2**n
qc.cp(n, angle_i)
return qc
''' |
QPC004_B2 | A99AE87E3C658 | 8 | AC | 2077 ms | 162 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import numpy as np
from qiskit.circuit.library import CU1Gate
def solve(n: int, a: int) -> QuantumCircuit:
k, c = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(k, c)
for i in range (n):
angle_i=2*np.pi*a*2**(i)/2**n
qc.cp(angle_i, n, i)
return qc
''' |
QPC004_B2 | A9CFC42737691 | 1 | RE | 1868 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 | A9CFC42737691 | 2 | AC | 2351 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 ** i / 2 ** n
qc.cp(theta,n,i)
return qc
''' |
QPC004_B2 | A9FC585F70810 | 1 | RE | 1987 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(math.pi * a * 2 ** (1-_-n),n,i)
return qc
''' |
QPC004_B2 | A9FC585F70810 | 2 | WA | 2287 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 _ in range(n):
qc.cp(math.pi * a * 2 ** (1-_-n),n,_)
return qc
''' |
QPC004_B2 | A9FC585F70810 | 3 | AC | 2395 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 _ in range(n):
qc.cp(2 * math.pi * a * 2 ** _ / 2 ** n,n,_)
return qc
''' |
QPC004_B2 | AAD3D81DBABAB | 1 | RE | 1694 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 * np.pi * a / (2 ** (i - n))
qc.cp(theta, c[0], k[i])
return qc
return qc
''' |
QPC004_B2 | AAD3D81DBABAB | 2 | RE | 1666 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 * np.pi * a / (2 ** (i - n))
qc.cp(theta, c[0], k[i])
return qc
''' |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.