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 |
|---|---|---|---|---|---|---|
QPC002_Ex | A7E68578D8B33 | 1 | WA | 1607 ms | 155 MiB | '''python
from qiskit import QuantumCircuit
"""
You can apply U and R as follows:
qc.compose(U(), inplace=True)
qc.compose(R(theta), inplace=True)
"""
def solve(n: int, P: float, U, R) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
return qc
''' |
QPC002_Ex | A7E68578D8B33 | 2 | RE | 2456 ms | 154 MiB | '''python
from qiskit import QuantumCircuit
"""
You can apply U and R as follows:
qc.compose(U(), inplace=True)
qc.compose(R(theta), inplace=True)
"""
def solve(n: int, P: float, U, R) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.compose(U(), inplace=True)
theta = np.arccos(np.sqrt(P))
for _ in range(10):
qc.compose(R(theta), inplace=True)
qc.compose(U().inverse(), inplace=True)
return qc
''' |
QPC002_Ex | A7E68578D8B33 | 3 | WA | 1533 ms | 155 MiB | '''python
from qiskit import QuantumCircuit
import numpy as np
"""
You can apply U and R as follows:
qc.compose(U(), inplace=True)
qc.compose(R(theta), inplace=True)
"""
def solve(n: int, P: float, U, R) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.compose(U(), inplace=True)
theta = np.arccos(np.sqrt(P))
for _ in range(10):
qc.compose(R(theta), inplace=True)
qc.compose(U().inverse(), inplace=True)
return qc
''' |
QPC002_Ex | A806716018B93 | 1 | RE | 1219 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
import numpy as np
"""
You can apply U and R as follows:
qc.compose(U(), inplace=True)
qc.compose(R(theta), inplace=True)
"""
def solve(n: int, P: float, U, R) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.compose(U(),inplace=True)
theta = np.arccos(np.sqrt(p))*2
m = int(np.pi/2/theta - 0.5)
for i in range(m):
qc.compose(R(np.pi), inplace=True)
qc.compose(U(),inplace=True)
qc.x(range(n))
qc.h(n-1)
qc.mcx(list(range(n-1)), n-1)
qc.h(n-1)
qc.x(range(n))
qc.compose(U(),inplace=True)
return qc
''' |
QPC002_Ex | AB25428AD0585 | 1 | WA | 1298 ms | 141 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, P: float, U, R) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Calculate the number of iterations
num_iterations = math.floor(math.pi / (4 * math.asin(math.sqrt(P))))
# Apply U to prepare the initial superposition
qc.compose(U(), inplace=True)
# Amplitude amplification
for _ in range(num_iterations):
# Apply R(pi) which is equivalent to the oracle
qc.compose(R(math.pi), inplace=True)
# Apply U
qc.compose(U(), inplace=True)
# Apply R(0) which is equivalent to the diffusion operator
qc.compose(R(0), inplace=True)
# Apply U inverse
qc.compose(U().inverse(), inplace=True)
return qc
''' |
QPC002_Ex | AB25428AD0585 | 2 | WA | 1190 ms | 141 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, P: float, U, R) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Apply U to prepare the initial state
qc.compose(U(), inplace=True)
# Calculate the phase for R
theta = 2 * math.asin(math.sqrt(P))
# Apply phase estimation
num_iterations = int(math.pi / (2 * theta))
for _ in range(num_iterations):
qc.compose(R(theta), inplace=True)
return qc
''' |
QPC002_Ex | AB25428AD0585 | 3 | WA | 1098 ms | 141 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, P: float, U, R) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Calculate the phase for R
theta = 2 * math.asin(math.sqrt(P))
# Calculate the number of iterations
L = min(math.pi / (2 * theta), 100) # Ensure we don't exceed 100 applications
m = math.ceil(math.log(L, 2)) # Number of bits for phase estimation
# Apply U to prepare the initial state
qc.compose(U(), inplace=True)
# Fixed-Point Quantum Search
for k in range(m):
# Apply controlled rotation
angle = 2 * math.pi / (2 ** (k + 1))
for j in range(2**k):
qc.compose(R(angle), inplace=True)
# Apply U†
qc.compose(U().inverse(), inplace=True)
# Apply controlled-Z
qc.z(0)
# Apply U
qc.compose(U(), inplace=True)
return qc
''' |
QPC002_Ex | AB25428AD0585 | 4 | WA | 1449 ms | 141 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, P: float, U, R) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Apply U to prepare the initial state
qc.compose(U(), inplace=True)
# Calculate the optimal number of iterations
m = math.floor(math.pi / (4 * math.asin(math.sqrt(P))) - 0.5)
m = min(m, 50) # Ensure we don't exceed 100 applications of R
# Apply amplitude amplification
for _ in range(m):
# Apply R(π)
qc.compose(R(math.pi), inplace=True)
# Apply U†
qc.compose(U().inverse(), inplace=True)
# Apply R(π)
qc.compose(R(math.pi), inplace=True)
# Apply U
qc.compose(U(), inplace=True)
return qc
''' |
QPC002_Ex | AB25428AD0585 | 5 | WA | 1114 ms | 141 MiB | '''python
from qiskit import QuantumCircuit
import math
"""You can apply U and R as follows:
qc.compose(U(), inplace=True)
qc.compose(R(theta), inplace=True)"""
def solve(n: int, P: float, U, R) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
# Apply U to prepare the initial state
qc.compose(U(), inplace=True)
# Calculate the optimal number of iterations
m = math.floor(math.pi / (4 * math.asin(math.sqrt(P))) - 0.5)
m = min(m, 50) # Ensure we don't exceed 100 applications of R
# Apply amplitude amplification
for _ in range(m):
# Apply R(π)
qc.compose(R(math.pi), inplace=True)
# Apply U†
qc.compose(U().inverse(), inplace=True)
# Apply R(π)
qc.compose(R(math.pi), inplace=True)
# Apply U
qc.compose(U(), inplace=True)
return qc
''' |
QPC002_Ex | AB25428AD0585 | 6 | WA | 1153 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
"""You can apply U and R as follows:
qc.compose(U(), inplace=True)
qc.compose(R(theta), inplace=True)"""
def solve(n: int, P: float, U, R) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
import math
qc.compose(U(), inplace=True)
m = min(int(math.pi / (4 * math.asin(math.sqrt(P))) - 0.5), 50)
for _ in range(m):
qc.compose(R(math.pi), inplace=True)
qc.compose(U().inverse(), inplace=True)
qc.compose(R(math.pi), inplace=True)
qc.compose(U(), inplace=True)
return qc
''' |
QPC002_Ex | AB25428AD0585 | 7 | WA | 1296 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
"""You can apply U and R as follows:
qc.compose(U(), inplace=True)
qc.compose(R(theta), inplace=True)"""
def solve(n: int, P: float, U, R) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
import math
qc.compose(U(), inplace=True)
theta = 2 * math.asin(math.sqrt(P))
iterations = min(int(math.pi / (2 * theta)), 100)
for _ in range(iterations):
qc.compose(R(theta), inplace=True)
return qc
''' |
QPC002_Ex | AB25428AD0585 | 8 | WA | 1063 ms | 141 MiB | '''python
from qiskit import QuantumCircuit
"""You can apply U and R as follows:
qc.compose(U(), inplace=True)
qc.compose(R(theta), inplace=True)"""
def solve(n: int, P: float, U, R) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
import math
# Apply U to prepare the initial state
qc.compose(U(), inplace=True)
# Calculate the number of iterations
m = min(int(1 / math.sqrt(P)), 100)
# Apply phase estimation
for k in range(m):
theta = 2 * math.pi / (2 ** (k + 1))
qc.compose(R(theta), inplace=True)
return qc
''' |
QPC002_Ex | AB25428AD0585 | 9 | WA | 1080 ms | 141 MiB | '''python
from qiskit import QuantumCircuit
import numpy as np
def solve(n: int, P: float, U, R) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Apply U to the quantum circuit
qc.compose(U(), inplace=True)
# Choose theta based on P
# Note: We need to derive or choose theta such that the projection yields the probability P.
# This is often done by solving equations or approximations, but for simplicity,
# we will use a fixed theta as an example. This will need adjustment based on P.
# We use a placeholder theta here; you need to compute this based on the problem requirements.
theta = np.arccos(np.sqrt(P)) # Example, adjust according to exact requirements
# Apply R(theta) to the quantum circuit
qc.compose(R(theta), inplace=True)
return qc
''' |
QPC002_Ex | AB25428AD0585 | 10 | WA | 1117 ms | 141 MiB | '''python
from qiskit import QuantumCircuit
import numpy as np
def solve(n: int, P: float, U, R) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Apply U to the quantum circuit
qc.compose(U(), inplace=True)
# Calculate theta based on P
# We solve for theta where:
# P = |⟨ω|U|0⟩|^2
# For simplicity, we'll use a direct calculation for theta
# which is typically derived from the problem specifics. Here, a generic example.
# Ensure the calculation matches the probability requirement.
# Example: theta calculation
theta = 2 * np.arccos(np.sqrt(P))
# Apply R(theta) to the quantum circuit
qc.compose(R(theta), inplace=True)
return qc
''' |
QPC002_Ex | AB25428AD0585 | 11 | WA | 1113 ms | 141 MiB | '''python
from qiskit import QuantumCircuit
import numpy as np
def solve(n: int, P: float, U, R) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Apply U to the quantum circuit
qc.compose(U(), inplace=True)
# Compute theta
# We use P to determine theta for the R(theta) gate.
# Since theta needs to match the probability P, we use:
# theta = 2 * arccos(sqrt(P))
theta = 2 * np.arccos(np.sqrt(P))
# Apply R(theta) to the quantum circuit
qc.compose(R(theta), inplace=True)
return qc
''' |
QPC002_Ex | AB50E4ED77BBC | 1 | WA | 1154 ms | 143 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, P: float, U, R) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(100):
qc.compose(U(), inplace=True)
qc.compose(R(1), inplace=True)
return qc
''' |
QPC002_Ex | AB50E4ED77BBC | 2 | WA | 1478 ms | 141 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, P: float, U, R) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(50):
qc.compose(U(), inplace=True)
qc.compose(R(math.pi), inplace=True)
qc.compose(U().inverse(), inplace=True)
qc.compose(R(math.pi).inverse(), inplace=True)
return qc
''' |
QPC002_Ex | AB84161F073F6 | 1 | WA | 1082 ms | 141 MiB | '''python
from qiskit import QuantumCircuit
"""
You can apply U and R as follows:
qc.compose(U(), inplace=True)
qc.compose(R(theta), inplace=True)
"""
def solve(n: int, P: float, U, R) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
from math import acos, sqrt, pi
theta = 2 * acos(sqrt(P))
# Compute the inverse theta
qc.compose(R(theta).inverse(), inplace=True)
# Apply U inverse
qc.compose(U().inverse(), inplace=True)
# Apply R(theta) again
qc.compose(R(theta), inplace=True)
return qc
''' |
QPC002_Ex | AB84161F073F6 | 2 | WA | 1174 ms | 141 MiB | '''python
from qiskit import QuantumCircuit
import numpy as np
"""
You can apply U and R as follows:
qc.compose(U(), inplace=True)
qc.compose(R(theta), inplace=True)
"""
def solve(n: int, P: float, U, R) -> QuantumCircuit:
qc = QuantumCircuit(n)
num_iterations = 10 # Adjust as needed
# Initial application of U
qc.compose(U(), inplace=True)
# Amplitude amplification loop
for _ in range(num_iterations):
qc.compose(R(np.pi/2), inplace=True) # Assuming optimal theta
qc.compose(U().inverse(), inplace=True)
qc.compose(R(np.pi/2), inplace=True)
qc.compose(U(), inplace=True)
return qc
''' |
QPC002_Ex | AD2410AE1BCC8 | 1 | RE | 1112 ms | 141 MiB | '''python
from qiskit import QuantumCircuit
import math
"""
You can apply U and R as follows:
qc.compose(U(), inplace=True)
qc.compose(R(theta), inplace=True)
"""
def solve(n: int, P: float, U, R) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.compose(U(), inplace=True)
for i in range (100):
qc.compose(R(math.pi / 3), inplace=True)
qc.compose(U().inverse(), inplace=True)
for j in range(n):
qc.x(j)
qc.append(PhaseGate(math.pi / 3).control(n - 1), range(n))
for j in range(n):
qc.x(j)
qc.compose(U(), inplace=True)
return qc
''' |
QPC002_Ex | AD2410AE1BCC8 | 2 | RE | 1143 ms | 141 MiB | '''python
from qiskit import QuantumCircuit
import math
"""
You can apply U and R as follows:
qc.compose(U(), inplace=True)
qc.compose(R(theta), inplace=True)
"""
def solve(n: int, P: float, U, R) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.compose(U(), inplace=True)
for i in range (100):
qc.compose(R(math.pi / 3), inplace=True)
#qc.compose(U().inverse(), inplace=True)
for j in range(n):
qc.x(j)
qc.append(PhaseGate(math.pi / 3).control(n - 1), range(n))
for j in range(n):
qc.x(j)
qc.compose(U(), inplace=True)
return qc
''' |
QPC002_Ex | AD2410AE1BCC8 | 3 | RE | 1505 ms | 141 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import PhaseGate
import math
"""
You can apply U and R as follows:
qc.compose(U(), inplace=True)
qc.compose(R(theta), inplace=True)
"""
def solve(n: int, P: float, U, R) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.compose(U(), inplace=True)
for i in range (100):
qc.compose(R(math.pi / 3), inplace=True)
qc.compose(U().inverse(), inplace=True)
for j in range(n):
qc.x(j)
qc.append(PhaseGate(math.pi / 3).control(n - 1), range(n))
for j in range(n):
qc.x(j)
qc.compose(U(), inplace=True)
return qc
''' |
QPC002_Ex | AD2410AE1BCC8 | 4 | RE | 1288 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import PhaseGate
import math
"""
You can apply U and R as follows:
qc.compose(U(), inplace=True)
qc.compose(R(theta), inplace=True)
"""
def solve(n: int, P: float, U, R) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.compose(U(), inplace=True)
for i in range (100):
qc.compose(R(math.pi / 3), inplace=True)
#qc.compose(U().inverse(), inplace=True)
for j in range(n):
qc.x(j)
qc.append(PhaseGate(math.pi / 3).control(n - 1), range(n))
for j in range(n):
qc.x(j)
qc.compose(U(), inplace=True)
return qc
''' |
QPC002_Ex | AD2410AE1BCC8 | 5 | WA | 1155 ms | 141 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import PhaseGate
import math
"""
You can apply U and R as follows:
qc.compose(U(), inplace=True)
qc.compose(R(theta), inplace=True)
"""
def solve(n: int, P: float, U, R) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.compose(U(), inplace=True)
#for i in range(100):
# qc.compose(R(math.pi / 3), inplace=True)
# qc.compose(U().inverse(), inplace=True)
# for j in range(n):
# qc.x(j)
# qc.append(PhaseGate(math.pi / 3).control(n - 1), range(n))
# for j in range(n):
# qc.x(j)
# qc.compose(U(), inplace=True)
return qc
''' |
QPC002_Ex | AD2410AE1BCC8 | 6 | RE | 1064 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import PhaseGate
import math
"""
You can apply U and R as follows:
qc.compose(U(), inplace=True)
qc.compose(R(theta), inplace=True)
"""
def solve(n: int, P: float, U, R) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.compose(U(), inplace=True)
for i in range(100):
qc.compose(R(math.pi / 3), inplace=True)
qc.compose(U().replace(operation=U().operation.inverse(annotated=annotated)), inplace=True)
for j in range(n):
qc.x(j)
qc.append(PhaseGate(math.pi / 3).control(n - 1), range(n))
for j in range(n):
qc.x(j)
qc.compose(U(), inplace=True)
return qc
''' |
QPC002_Ex | AD2410AE1BCC8 | 7 | RE | 1232 ms | 141 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import PhaseGate
import math
"""
You can apply U and R as follows:
qc.compose(U(), inplace=True)
qc.compose(R(theta), inplace=True)
"""
def solve(n: int, P: float, U, R) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.compose(U(), inplace=True)
for i in range(100):
qc.compose(R(math.pi / 3), inplace=True)
qc2 = QuantumCircuit(n)
qc2.compose(U(), inplace=True)
qc.append(qc2.inverse(), range(n))
for j in range(n):
qc.x(j)
qc.append(PhaseGate(math.pi / 3).control(n - 1), range(n))
for j in range(n):
qc.x(j)
qc.compose(U(), inplace=True)
return qc
''' |
QPC002_Ex | AD2410AE1BCC8 | 8 | RE | 1178 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import PhaseGate
import math
"""
You can apply U and R as follows:
qc.compose(U(), inplace=True)
qc.compose(R(theta), inplace=True)
"""
def solve(n: int, P: float, U, R) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.compose(U(), inplace=True)
for i in range(100):
qc.compose(R(math.pi / 3), inplace=True)
qc.compose(U(), inplace=True)
for j in range(n):
qc.x(j)
qc.append(PhaseGate(math.pi / 3).control(n - 1), range(n))
for j in range(n):
qc.x(j)
qc.compose(U(), inplace=True)
return qc
''' |
QPC002_Ex | AD2410AE1BCC8 | 9 | WA | 1220 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import PhaseGate
import math
"""
You can apply U and R as follows:
qc.compose(U(), inplace=True)
qc.compose(R(theta), inplace=True)
"""
def solve(n: int, P: float, U, R) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.compose(U(), inplace=True)
for i in range(100):
qc.compose(R(math.pi / 3), inplace=True)
qc.compose(U(), inplace=True)
for j in range(n):
qc.x(j)
if(n==1):
qc.p(math.pi / 3, 0)
else:
qc.append(PhaseGate(math.pi / 3).control(n - 1), range(n))
for j in range(n):
qc.x(j)
qc.compose(U(), inplace=True)
return qc
''' |
QPC002_Ex | AD2410AE1BCC8 | 10 | RE | 1335 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import PhaseGate
import math
"""
You can apply U and R as follows:
qc.compose(U(), inplace=True)
qc.compose(R(theta), inplace=True)
"""
def solve(n: int, P: float, U, R) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.compose(U(), inplace=True)
for i in range(100):
qc.compose(R(math.pi / 3), inplace=True)
qc.compose(inverse(U()), inplace=True)
for j in range(n):
qc.x(j)
if(n==1):
qc.p(math.pi / 3, 0)
else:
qc.append(PhaseGate(math.pi / 3).control(n - 1), range(n))
for j in range(n):
qc.x(j)
qc.compose(U(), inplace=True)
return qc
''' |
QPC002_Ex | AD2410AE1BCC8 | 11 | RE | 1137 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import PhaseGate
import math
"""
You can apply U and R as follows:
qc.compose(U(), inplace=True)
qc.compose(R(theta), inplace=True)
"""
def solve(n: int, P: float, U, R) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.compose(U(), inplace=True)
for i in range(100):
qc.compose(R(math.pi / 3), inplace=True)
qc.compose(U.inverse(), inplace=True)
for j in range(n):
qc.x(j)
if(n==1):
qc.p(math.pi / 3, 0)
else:
qc.append(PhaseGate(math.pi / 3).control(n - 1), range(n))
for j in range(n):
qc.x(j)
qc.compose(U(), inplace=True)
return qc
''' |
QPC002_Ex | AD2410AE1BCC8 | 12 | RE | 1266 ms | 139 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import PhaseGate
import math
"""
You can apply U and R as follows:
qc.compose(U(), inplace=True)
qc.compose(R(theta), inplace=True)
"""
def solve(n: int, P: float, U, R) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.compose(U(), inplace=True)
for i in range(100):
qc.compose(R(math.pi / 3), inplace=True)
qc.compose(inverse(U), inplace=True)
for j in range(n):
qc.x(j)
if(n==1):
qc.p(math.pi / 3, 0)
else:
qc.append(PhaseGate(math.pi / 3).control(n - 1), range(n))
for j in range(n):
qc.x(j)
qc.compose(U(), inplace=True)
return qc
''' |
QPC002_Ex | AD2410AE1BCC8 | 13 | WA | 1404 ms | 141 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import PhaseGate
import math
"""
You can apply U and R as follows:
qc.compose(U(), inplace=True)
qc.compose(R(theta), inplace=True)
"""
def solve(n: int, P: float, U, R) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.compose(U(), inplace=True)
for i in range(100):
qc.compose(R(math.pi / 3), inplace=True)
qc.compose(U().inverse(), inplace=True)
for j in range(n):
qc.x(j)
if(n==1):
qc.p(math.pi / 3, 0)
else:
qc.append(PhaseGate(math.pi / 3).control(n - 1), range(n))
for j in range(n):
qc.x(j)
qc.compose(U(), inplace=True)
return qc
''' |
QPC002_Ex | AD2410AE1BCC8 | 14 | RE | 1076 ms | 141 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import PhaseGate
import math
import numpy as np
"""
You can apply U and R as follows:
qc.compose(U(), inplace=True)
qc.compose(R(theta), inplace=True)
"""
def solve(n: int, P: float, U, R) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.compose(U(), inplace=True)
delta=0.1
L=int(np.log(1/delta)/np.sqrt(P)/2)*2 + 1
gamma = 1/(np.cos((1/L)*np.arccos(1/delta)))
l = (L-1)/2
alpha=[]
beta=[]
for i in range(l):
alpha.append(2*np.arctan(1/(np.tan(i*np.pi*2/L)*np.sqrt(1-gamma**2))))
for i in range(l):
qc.compose(R(alpha[l-i-1]), inplace=True)
qc.compose(U().inverse(), inplace=True)
for j in range(n):
qc.x(j)
if(n==1):
qc.p(alpha[i], 0)
else:
qc.append(PhaseGate(alpha[i]).control(n - 1), range(n))
for j in range(n):
qc.x(j)
qc.compose(U(), inplace=True)
return qc
''' |
QPC002_Ex | AD2410AE1BCC8 | 15 | RE | 1089 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import PhaseGate
import math
import numpy as np
"""
You can apply U and R as follows:
qc.compose(U(), inplace=True)
qc.compose(R(theta), inplace=True)
"""
def solve(n: int, P: float, U, R) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.compose(U(), inplace=True)
delta=0.1
L=int(np.log(1/delta)/np.sqrt(P)/2)*2 + 1
gamma = 1/(np.cos((1/L)*np.arccos(1/delta)))
l = int(np.log(1/delta)/np.sqrt(P)/2)
alpha=[]
beta=[]
for i in range(l):
alpha.append(2*np.arctan(1/(np.tan(i*np.pi*2/L)*np.sqrt(1-gamma**2))))
for i in range(l):
qc.compose(R(alpha[l-i-1]), inplace=True)
qc.compose(U().inverse(), inplace=True)
for j in range(n):
qc.x(j)
if(n==1):
qc.p(alpha[i], 0)
else:
qc.append(PhaseGate(alpha[i]).control(n - 1), range(n))
for j in range(n):
qc.x(j)
qc.compose(U(), inplace=True)
return qc
''' |
QPC002_Ex | AD2410AE1BCC8 | 16 | RE | 1148 ms | 141 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import PhaseGate
import math
import numpy as np
"""
You can apply U and R as follows:
qc.compose(U(), inplace=True)
qc.compose(R(theta), inplace=True)
"""
def solve(n: int, P: float, U, R) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.compose(U(), inplace=True)
delta=0.1
L=int(np.log(1/delta)/np.sqrt(P)/2)*2 + 1
gamma = 1/(np.cos((1/L)*np.arccos(1/delta)))
l = int(np.log(1/delta)/np.sqrt(P)/2)
alpha=[]
for i in range(l):
alpha.append(2*np.arctan(1/(np.tan(i*np.pi*2/L)*np.sqrt(1-gamma**2))))
for i in range(l):
qc.compose(R(-alpha[l-i-1]), inplace=True)
qc.compose(U().inverse(), inplace=True)
for j in range(n):
qc.x(j)
if(n==1):
qc.p(alpha[i], 0)
else:
qc.append(PhaseGate(-alpha[i]).control(n - 1), range(n))
for j in range(n):
qc.x(j)
qc.compose(U(), inplace=True)
return qc
''' |
QPC002_Ex | AD2410AE1BCC8 | 17 | RE | 1158 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import PhaseGate
import math
import numpy as np
"""
You can apply U and R as follows:
qc.compose(U(), inplace=True)
qc.compose(R(theta), inplace=True)
"""
def solve(n: int, P: float, U, R) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.compose(U(), inplace=True)
delta=0.1
L=int(np.log(2/delta)/np.sqrt(P)/2)*2 + 1
gamma = 1/(1-(np.log(1/delta)/L)**2)
l = int(np.log(2/delta)/np.sqrt(P)/2)
alpha=[]
for i in range(l):
alpha.append(2*np.arctan(1/(np.tan(i*np.pi*2/L)*np.sqrt(1-gamma**2))))
for i in range(l):
qc.compose(R(-alpha[l-i-1]), inplace=True)
qc.compose(U().inverse(), inplace=True)
for j in range(n):
qc.x(j)
if(n==1):
qc.p(alpha[i], 0)
else:
qc.append(PhaseGate(-alpha[i]).control(n - 1), range(n))
for j in range(n):
qc.x(j)
qc.compose(U(), inplace=True)
return qc
''' |
QPC002_Ex | AD2410AE1BCC8 | 18 | WA | 1495 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import PhaseGate
import math
import numpy as np
"""
You can apply U and R as follows:
qc.compose(U(), inplace=True)
qc.compose(R(theta), inplace=True)
"""
def solve(n: int, P: float, U, R) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.compose(U(), inplace=True)
delta=0.1
L=int(np.log(2/delta)/np.sqrt(P)/2)*2 + 1
gamma = 1/(1-(np.log(1/delta)/L)**2)
l = int(np.log(2/delta)/np.sqrt(P)/2)
alpha=[]
for i in range(l):
#alpha.append(2*np.arctan(1/(np.tan(i*np.pi*2/L)*np.sqrt(1-gamma**2))))
alpha.append(np.pi/3)
for i in range(l):
qc.compose(R(-alpha[l-i-1]), inplace=True)
qc.compose(U().inverse(), inplace=True)
for j in range(n):
qc.x(j)
if(n==1):
qc.p(alpha[i], 0)
else:
qc.append(PhaseGate(-alpha[i]).control(n - 1), range(n))
for j in range(n):
qc.x(j)
qc.compose(U(), inplace=True)
return qc
''' |
QPC002_Ex | AD2410AE1BCC8 | 19 | RE | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import PhaseGate
import math
import numpy as np
"""
You can apply U and R as follows:
qc.compose(U(), inplace=True)
qc.compose(R(theta), inplace=True)
"""
def solve(n: int, P: float, U, R) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.compose(U(), inplace=True)
delta=0.1
L=int(np.log(2/delta)/np.sqrt(P)/2)*2 + 1
gamma = 1/(1-(np.log(1/delta)/L)**2)
l = int(np.log(2/delta)/np.sqrt(P)/2)
alpha=[]
for i in range(100):
#alpha.append(2*np.arctan(1/(np.tan(i*np.pi*2/L)*np.sqrt(1-gamma**2))))
alpha.append(np.pi/)
for i in range(100):
qc.compose(R(-alpha[l-i-1]), inplace=True)
qc.compose(U().inverse(), inplace=True)
for j in range(n):
qc.x(j)
if(n==1):
qc.p(alpha[i], 0)
else:
qc.append(PhaseGate(-alpha[i]).control(n - 1), range(n))
for j in range(n):
qc.x(j)
qc.compose(U(), inplace=True)
return qc
''' | ||
QPC002_Ex | AD2410AE1BCC8 | 20 | RE | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import PhaseGate
import math
import numpy as np
"""
You can apply U and R as follows:
qc.compose(U(), inplace=True)
qc.compose(R(theta), inplace=True)
"""
def solve(n: int, P: float, U, R) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.compose(U(), inplace=True)
delta=0.1
L=int(np.log(2/delta)/np.sqrt(P)/2)*2 + 1
gamma = 1/(1-(np.log(1/delta)/L)**2)
l = int(np.log(2/delta)/np.sqrt(P)/2)
alpha=[]
for i in range(100):
#alpha.append(2*np.arctan(1/(np.tan(i*np.pi*2/L)*np.sqrt(1-gamma**2))))
alpha.append(np.pi/)
for i in range(100):
qc.compose(R(-alpha[100-i-1]), inplace=True)
qc.compose(U().inverse(), inplace=True)
for j in range(n):
qc.x(j)
if(n==1):
qc.p(alpha[i], 0)
else:
qc.append(PhaseGate(-alpha[i]).control(n - 1), range(n))
for j in range(n):
qc.x(j)
qc.compose(U(), inplace=True)
return qc
''' | ||
QPC002_Ex | AD2410AE1BCC8 | 21 | WA | 1186 ms | 141 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import PhaseGate
import math
import numpy as np
"""
You can apply U and R as follows:
qc.compose(U(), inplace=True)
qc.compose(R(theta), inplace=True)
"""
def solve(n: int, P: float, U, R) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.compose(U(), inplace=True)
delta=0.1
L=int(np.log(2/delta)/np.sqrt(P)/2)*2 + 1
gamma = 1/(1-(np.log(1/delta)/L)**2)
l = int(np.log(2/delta)/np.sqrt(P)/2)
alpha=[]
for i in range(100):
#alpha.append(2*np.arctan(1/(np.tan(i*np.pi*2/L)*np.sqrt(1-gamma**2))))
alpha.append(np.pi/3)
for i in range(100):
qc.compose(R(-alpha[100-i-1]), inplace=True)
qc.compose(U().inverse(), inplace=True)
for j in range(n):
qc.x(j)
if(n==1):
qc.p(alpha[i], 0)
else:
qc.append(PhaseGate(-alpha[i]).control(n - 1), range(n))
for j in range(n):
qc.x(j)
qc.compose(U(), inplace=True)
return qc
''' |
QPC002_Ex | AD800E4494D52 | 1 | RE | 1042 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
"""
You can apply U and R as follows:
qc.compose(U(), inplace=True)
qc.compose(R(theta), inplace=True)
"""
def solve(n: int, P: float, U, R) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.append(U, range(n))
# Define the phase gate R(θ) in terms of RZ and I
# Note: This example assumes R(θ) has a known structure. You might need to adapt it to your specific case.
def R(theta):
# R(theta) = I - (1 - e^iθ) |ω⟩⟨ω|
# Assume ω is the state after applying U
# In the ideal case, we would need to apply RZ or other gates based on θ
qc.rz(theta, 0) # Example phase gate
return qc
''' |
QPC002_Ex | AD800E4494D52 | 2 | RE | 1291 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
"""
You can apply U and R as follows:
qc.compose(U(), inplace=True)
qc.compose(R(theta), inplace=True)
"""
def solve(n: int, P: float, U, R) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.append(U, range(n))
def R(theta):
qc.rz(theta, 0)
return qc
''' |
QPC002_Ex | AD800E4494D52 | 3 | RE | '''python
from qiskit import QuantumCircuit
"""
You can apply U and R as follows:
qc.compose(U(), inplace=True)
qc.compose(R(theta), inplace=True)
"""
def solve(n: int, P: float, U, R) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.append(U, range(n))
# Define the phase gate R(θ) in terms of RZ and I
# Note: This example assumes R(θ) has a known structure. You might need to adapt it to your specific case.
def R(theta):
R(theta) = I - (1 - e^iθ) |ω⟩⟨ω|
# Assume ω is the state after applying U
# In the ideal case, we would need to apply RZ or other gates based on θ
qc.rz(theta, 0) # Example phase gate
return qc
# Apply R(θ) to the circuit
qc = R(theta)
return qc
''' | ||
QPC002_Ex | AD800E4494D52 | 4 | RE | '''python
from qiskit import QuantumCircuit
"""
You can apply U and R as follows:
qc.compose(U(), inplace=True)
qc.compose(R(theta), inplace=True)
"""
def solve(n: int, P: float, U, R) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.append(U, range(n))
def R(theta):
R(theta) = I - (1 - e^iθ) |ω⟩⟨ω|
qc = R(theta)
return qc
''' | ||
QPC002_Ex | AD800E4494D52 | 5 | RE | '''python
from qiskit import QuantumCircuit
"""
You can apply U and R as follows:
qc.compose(U(), inplace=True)
qc.compose(R(theta), inplace=True)
"""
def solve(n: int, P: float, U, R) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.append(U, range(n))
def R(theta):
R(theta) = I - (1 - e^i(theta)) |ω⟩⟨ω|
qc = R(theta)
return qc
''' | ||
QPC002_Ex | AD800E4494D52 | 6 | RE | '''python
from qiskit import QuantumCircuit
"""
You can apply U and R as follows:
qc.compose(U(), inplace=True)
qc.compose(R(theta), inplace=True)
"""
def solve(n: int, P: float, U, R) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.append(U, range(n))
def R(theta):
R(theta) = I - (1 - e^i(theta)) |ω⟩⟨ω|
qc.append(R(theta), range(n))
return qc
''' | ||
QPC002_Ex | AF774607990AF | 1 | WA | 1833 ms | 161 MiB | '''python
import math
from qiskit import QuantumCircuit
def solve(n: int, P: float, U, R) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Step 1: Prepare initial state using U
qc.compose(U(), inplace=True)
# If initial probability is already high enough, return the circuit as is
if P >= 0.99:
return qc
# Step 2: Calculate the initial angle and determine rotation counts
theta0 = math.asin(math.sqrt(P)) # initial angle such that sin^2(theta0) = P
# Determine the number of full rotations without overshooting π/2
if theta0 == 0:
k_full = 0
else:
k_full = math.floor((math.pi/2 - theta0) / (2 * theta0))
# Compute the angle achieved after k_full full rotations
achieved_angle = (2 * k_full + 1) * theta0
# Compute the partial rotation needed to reach π/2 (optimal) from achieved_angle
theta_partial = (math.pi/2) - achieved_angle
# Step 3: Apply k_full full R rotations
full_rotation_angle = 2 * theta0 # angle for one full Grover iteration
for _ in range(k_full):
qc.compose(R(full_rotation_angle), inplace=True)
# Step 4: Apply a partial rotation if needed to reach >= 99% success
if theta_partial > 1e-6: # if a significant partial rotation remains
qc.compose(R(2 * theta_partial), inplace=True)
# Note: If R(θ) is defined to perform a rotation by θ directly,
# we should use R(theta_partial) here instead of R(2*theta_partial).
# The factor 2 accounts for the typical Grover double-angle per iteration.
return qc
''' |
QPC002_Ex | AF774607990AF | 2 | WA | 1777 ms | 163 MiB | '''python
import math
from qiskit import QuantumCircuit
def solve(n: int, P: float, U, R) -> QuantumCircuit:
qc = QuantumCircuit(n)
# 初期状態の準備: U を適用
qc.compose(U(), inplace=True)
# 初期成功確率 P のアークサインを計算
theta0 = math.asin(math.sqrt(P))
# 固定点量子探索 (Grover-Yoder) の適用回数を決定
k_max = min(100, math.ceil(math.log(1 / (1 - 0.99)) / math.log(3))) # 保守的に100以下に制限
# Grover-Yoder 法の位相シフトを適用
for k in range(1, k_max + 1):
theta_k = math.pi / (2 * k + 2) # 位相シフト
qc.compose(R(2 * theta_k), inplace=True)
return qc
''' |
QPC002_Ex | AF774607990AF | 3 | WA | 1740 ms | 163 MiB | '''python
import math
from qiskit import QuantumCircuit
def solve(n: int, P: float, U, R) -> QuantumCircuit:
qc = QuantumCircuit(n)
# 初期状態の準備: U を適用
qc.compose(U(), inplace=True)
# 初期角度 theta_0 の計算
theta_k = math.asin(math.sqrt(P))
# FPQS の適用回数の決定 (最大 100 ステップ)
k_max = min(100, math.ceil(math.log(1 / (1 - 0.99)) / math.log(3)))
for k in range(1, k_max + 1):
# Grover-Yoder の適切な角度更新
theta_k = math.atan( math.sin(theta_k) / (math.cos(theta_k) + 1 / math.tan(theta_k)) )
# 量子回路に FPQS ステップを適用
qc.compose(R(2 * theta_k), inplace=True) # ターゲット状態の位相回転
qc.compose(U().inverse(), inplace=True) # 逆変換
qc.compose(R(-2 * theta_k), inplace=True) # 逆位相回転
qc.compose(U(), inplace=True) # もう一度 U を適用
return qc
''' |
QPC002_Ex | AF774607990AF | 4 | DLE | 1759 ms | 164 MiB | '''python
import math
from qiskit import QuantumCircuit
def solve(n: int, P: float, U, R) -> QuantumCircuit:
qc = QuantumCircuit(n)
# 初期状態の準備: U を適用
qc.compose(U(), inplace=True)
# 初期角度 theta_0 の計算
theta_k = math.asin(math.sqrt(P))
# 固定点量子探索の最大反復回数
max_iterations = 100
for k in range(max_iterations):
# 現在の角度 theta_k に基づいて R(2 * theta_k) を適用
qc.compose(R(2 * theta_k), inplace=True)
# U の逆ゲートを適用
qc.compose(U().inverse(), inplace=True)
# R(-2 * theta_k) を適用
qc.compose(R(-2 * theta_k), inplace=True)
# U を再度適用
qc.compose(U(), inplace=True)
# 次の角度 theta_{k+1} を計算
theta_k = 2 * math.asin(math.sin(theta_k / 2))
return qc
''' |
QPC002_Ex | AF774607990AF | 5 | WA | 1711 ms | 170 MiB | '''python
import math
from qiskit import QuantumCircuit
def solve(n: int, P: float, U, R) -> QuantumCircuit:
qc = QuantumCircuit(n)
# 初期状態の準備: U を適用
qc.compose(U(), inplace=True)
# 初期角度 theta_0 の計算
theta_k = math.asin(math.sqrt(P))
# 固定点量子探索の最大反復回数
max_iterations = 30
for k in range(max_iterations):
# 現在の角度 theta_k に基づいて R(2 * theta_k) を適用
qc.compose(R(2 * theta_k), inplace=True)
# U の逆ゲートを適用
qc.compose(U().inverse(), inplace=True)
# R(-2 * theta_k) を適用
qc.compose(R(-2 * theta_k), inplace=True)
# U を再度適用
qc.compose(U(), inplace=True)
# 次の角度 theta_{k+1} を計算
theta_k = 2 * math.asin(math.sin(theta_k / 2))
return qc
''' |
QPC002_Ex | AFC53E7F80E76 | 1 | RE | 1124 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
"""
You can apply U and R as follows:
qc.compose(U(), inplace=True)
qc.compose(R(theta), inplace=True)
"""
def solve(n: int, P: float, U, R) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.compose(U(), inplace=True)
qc.compose(R(theta), inplace=True)
qc.compose(U().inverse(), inplace=True)
return qc
''' |
QPC003_A1 | A011ED81C9F48 | 1 | WA | 1569 ms | 155 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
return qc
''' |
QPC003_A1 | A011ED81C9F48 | 2 | AC | 1255 ms | 154 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
qc.y(0)
return qc
''' |
QPC003_A1 | A01AFC86A4766 | 1 | AC | 1573 ms | 155 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.y(0)
return qc
''' |
QPC003_A1 | A01F89409E98D | 1 | AC | 1527 ms | 155 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.y(0)
return qc
''' |
QPC003_A1 | A029A3E381B53 | 1 | WA | 1592 ms | 154 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.global_phase += math.pi/2
return qc
''' |
QPC003_A1 | A029A3E381B53 | 2 | AC | 1854 ms | 154 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.x(0)
qc.s(0)
return qc
''' |
QPC003_A1 | A037524E62E17 | 1 | AC | 1212 ms | 155 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
qc.y(0)
return qc
''' |
QPC003_A1 | A04F7C0AE2627 | 1 | AC | 1220 ms | 155 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.y(0)
return qc
''' |
QPC003_A1 | A06EC03617CA7 | 1 | WA | 1506 ms | 155 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.z(0)
qc.y(0)
qc.x(0)
return qc
''' |
QPC003_A1 | A06EC03617CA7 | 2 | AC | 1264 ms | 155 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.y(0)
return qc
''' |
QPC003_A1 | A0A2AB4BD4B48 | 1 | WA | 1567 ms | 155 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
qc.rz(math.pi, 0)
qc.ry(math.pi, 0)
return qc
''' |
QPC003_A1 | A0A2AB4BD4B48 | 2 | AC | 1580 ms | 154 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
qc.rz(-math.pi, 0)
qc.ry(math.pi, 0)
return qc
''' |
QPC003_A1 | A0ABC0A4A09DD | 1 | AC | 1256 ms | 155 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.y(0)
return qc
''' |
QPC003_A1 | A0D00F2A0C1D4 | 1 | RE | 1698 ms | 153 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.Y(0)
return qc
''' |
QPC003_A1 | A0D00F2A0C1D4 | 2 | AC | 1661 ms | 155 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.y(0)
return qc
''' |
QPC003_A1 | A0D7E0DD6DFAF | 1 | AC | 1226 ms | 155 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.y(0)
return qc
''' |
QPC003_A1 | A0DDC804B8384 | 1 | AC | 1790 ms | 155 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.x(0)
qc.s(0)
return qc
''' |
QPC003_A1 | A0E43A6122C67 | 1 | AC | 1488 ms | 155 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.y(0)
return qc
''' |
QPC003_A1 | A0E8C62419D95 | 1 | WA | 1453 ms | 155 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import GlobalPhaseGate
import numpy as np
import math
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.append(GlobalPhaseGate(math.pi / 2))
return qc
''' |
QPC003_A1 | A0E8C62419D95 | 2 | AC | 1381 ms | 154 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import GlobalPhaseGate
import numpy as np
import math
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.append(GlobalPhaseGate(math.pi / 2))
qc.x(0)
return qc
''' |
QPC003_A1 | A0EFCA4174B5F | 1 | AC | 1255 ms | 154 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import YGate
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
qc.append(YGate(), [0])
return qc
''' |
QPC003_A1 | A0F8630251A90 | 1 | WA | 1853 ms | 154 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.h(0)
qc.p(math.pi / 2, -0)
return qc
''' |
QPC003_A1 | A0F8630251A90 | 2 | UME | '''python
from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector
import math
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.p(math.pi/2, 0)
return qc
# if __name__ == "__main__":
# qc = solve()
# print(Statevector(qc))
''' | ||
QPC003_A1 | A0F8630251A90 | 3 | WA | 1733 ms | 155 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.p(math.pi/2, 0)
return qc
# if __name__ == "__main__":
# qc = solve()
# print(Statevector(qc))
''' |
QPC003_A1 | A0F8630251A90 | 4 | AC | 1462 ms | 155 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.x(0)
qc.p(math.pi/2, 0)
return qc
''' |
QPC003_A1 | A1087AEC2AD49 | 1 | AC | 2025 ms | 160 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Apply the S gate to the |1> state
qc.x(0) # First, we need to flip |0> to |1>
qc.s(0) # Apply the S gate to introduce the phase
return qc
''' |
QPC003_A1 | A112DD1F6DB8F | 1 | WA | 1433 ms | 160 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.x(0)
return qc
''' |
QPC003_A1 | A112DD1F6DB8F | 2 | WA | 1715 ms | 162 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.x(0)#at 0
qc.h(0)#|->
qc.s(0)
return qc
''' |
QPC003_A1 | A130FAB8DADD3 | 1 | WA | 1363 ms | 165 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
qc.x(0)
qc.z(0)
# Write your code here:
return qc
''' |
QPC003_A1 | A149D8D76EBD5 | 1 | AC | 1544 ms | 154 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.y(0)
return qc
''' |
QPC003_A1 | A170D9AB43336 | 1 | AC | 1856 ms | 155 MiB | '''python
from qiskit import QuantumCircuit
from math import pi
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.rx(3*pi, 0)
return qc
''' |
QPC003_A1 | A204EFF5CD74D | 1 | AC | 1694 ms | 155 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.y(0)
return qc
''' |
QPC003_A1 | A23416D952662 | 1 | AC | 1686 ms | 155 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.y(0)
return qc
''' |
QPC003_A1 | A235814DF1E73 | 1 | AC | 1545 ms | 154 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.x(0)
qc.s(0)
return qc
''' |
QPC003_A1 | A2443080AB6F4 | 1 | AC | 1436 ms | 155 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.y(0)
return qc
''' |
QPC003_A1 | A244E4D0A2D6C | 1 | AC | 2132 ms | 159 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.y(0)
return qc
''' |
QPC003_A1 | A26ECC55D1A1E | 1 | AC | 1413 ms | 154 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
theta = math.pi/2
qc.x(0)
qc.p(theta, 0)
return qc
''' |
QPC003_A1 | A2A393E8FAD11 | 1 | UME | '''python
from glskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
qc.x(0)
qc.s(0)
return qc
''' | ||
QPC003_A1 | A2A393E8FAD11 | 2 | AC | 1519 ms | 160 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
qc.x(0)
qc.s(0)
return qc
''' |
QPC003_A1 | A2B4BC8F1C66E | 1 | WA | 1198 ms | 155 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.x(0)
qc.y(0)
return qc
''' |
QPC003_A1 | A2B4BC8F1C66E | 2 | AC | 1636 ms | 155 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.y(0)
return qc
''' |
QPC003_A1 | A2B837AC1A3C2 | 1 | WA | 1635 ms | 155 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.x(0)
qc.y(0)
return qc
''' |
QPC003_A1 | A2B837AC1A3C2 | 2 | WA | 1240 ms | 155 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.h(0)
qc.y(0)
qc.h(0)
qc.x(0)
return qc
''' |
QPC003_A1 | A2B837AC1A3C2 | 3 | AC | 1216 ms | 154 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.y(0)
return qc
''' |
QPC003_A1 | A2D14318B0071 | 1 | AC | 1196 ms | 154 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.y(0)
return qc
''' |
QPC003_A1 | A36D92A49C192 | 1 | AC | 1597 ms | 155 MiB | '''python
import numpy as np
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
qc.y(0)
return qc
''' |
QPC003_A1 | A386DDF77988B | 1 | AC | 1586 ms | 154 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
qc.y(0)
return qc
if __name__ == '__main__':
qc = solve()
print(qc)
''' |
QPC003_A1 | A38D3413436E5 | 1 | RE | 1630 ms | 153 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.x(0)
qc.p(np.pi/2)
return qc
''' |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.