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 |
|---|---|---|---|---|---|---|
QPC003_EX1 | AEE5BFDF8E24D | 1 | AC | 1932 ms | 156 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
"""
You can apply oracle as follows:
qc.compose(o, inplace=True)
"""
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(x, y)
# Write your code here:
qc.x(y[0])
qc.h(y[0])
qc.compose(o, inplace=True)
qc.h(y[0])
qc.x(y[0])
return qc
''' |
QPC003_EX1 | AF8F1BE10926F | 1 | WA | 1217 ms | 155 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
"""
You can apply oracle as follows:
qc.compose(o, inplace=True)
"""
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
x = QuantumRegister(n)
y = QuantumRegister(1)
qc = QuantumCircuit(x, y)
qc.h(x)
qc.x(y)
qc.compose(o, inplace=True)
return qc
''' |
QPC003_EX1 | AF8F1BE10926F | 2 | RE | 1394 ms | 154 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
"""
You can apply oracle as follows:
qc.compose(o, inplace=True)
"""
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
x = QuantumRegister(n)
y = QuantumRegister(1)
qc = QuantumCircuit(x, y)
qc.x(y)
qc.compose(o, inplace=True)
qc.x(y)
qc.mct(x, y)
qc.x(y)
return qc
''' |
QPC003_EX1 | AF8F1BE10926F | 3 | RE | 1262 ms | 154 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
"""
You can apply oracle as follows:
qc.compose(o, inplace=True)
"""
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
x = QuantumRegister(n)
y = QuantumRegister(1)
qc = QuantumCircuit(x, y)
qc.x(y)
qc.compose(o, inplace=True)
qc.x(y)
qc.mct(x, y)
qc.x(y)
return qc
''' |
QPC003_EX1 | AFB88AAF9AE3F | 1 | AC | 2228 ms | 161 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
"""
You can apply oracle as follows:
qc.compose(o, inplace=True)
"""
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(x, y)
# Write your code here:
qc.x(n)
qc.h(n)
qc.compose(o,inplace=True)
qc.h(n)
qc.x(n)
return qc
''' |
QPC003_EX2 | A1B1A8AD4E4C5 | 1 | RE | 1158 ms | 153 MiB | '''python
from qiskit import QuantumCircuit
"""
You can apply oracle as follows:
qc.compose(o, inplace=True)
"""
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
"""
Implementa un circuito cuántico que prepara el estado |psi> tal que
la probabilidad de medir |L> es al menos 0.9.
Parámetros:
- n: Número de qubits
- o: Oráculo O como QuantumCircuit de profundidad 1 que actúa sobre n qubits y 1 auxiliar
Retorna:
- qc: QuantumCircuit que implementa la operación deseada
"""
# Definir registros cuánticos
x = QuantumRegister(n, 'x') # Qubits para |x>
y = QuantumRegister(1, 'y') # Qubit auxiliar
qc = QuantumCircuit(x, y)
def diffuser(n):
"""
Crea el operador de difusión (diffuser) para el Algoritmo de Grover.
"""
qc = QuantumCircuit(n)
qc.h(range(n))
qc.x(range(n))
# Aplicar una puerta Z multi-controlada
qc.h(n-1)
qc.mcx(list(range(n-1)), n-1) # Puerta Toffoli multi-controlada
qc.h(n-1)
qc.x(range(n))
qc.h(range(n))
# Convertir el circuito en una puerta
diffuser_gate = qc.to_gate()
diffuser_gate.name = "Diffuser"
return diffuser_gate
# Paso 1: Preparar el qubit auxiliar en el estado |-> = (|0> - |1>)/sqrt(2)
qc.x(y[0])
qc.h(y[0])
# Paso 2: Aplicar puertas Hadamard a todos los qubits para crear una superposición uniforme
qc.h(x)
# Definir el operador de difusión
diffuser_gate = diffuser(n)
# Calcular el número óptimo de iteraciones de Grover
N = 2**n
k = 1 # Número de soluciones (k=1 ya que L es único)
theta = math.asin(math.sqrt(k / N))
optimal_iterations = int(math.floor((math.pi / (4 * theta)) - 0.5))
# Determinar el número de iteraciones permitidas por la restricción de profundidad
# Estimación de profundidad por iteración:
# - Oráculo O: profundidad 1
# - H y X en y: profundidad 2
# - Difusor: profundidad aproximadamente n (depende de la implementación)
# Asumimos una profundidad total aproximada por iteración
depth_per_iteration = 1 + 2 + 20 # Ajustar según n
max_iterations = math.floor(75 / depth_per_iteration)
iterations = min(optimal_iterations, max_iterations)
iterations = max(1, iterations) # Al menos una iteración
# Aplicar el algoritmo de Grover
for _ in range(iterations):
# Paso 3: Aplicar el oráculo O
qc.compose(o, qubits=x[:] + [y[0]], inplace=True)
# Paso 4: Aplicar puertas H y X al qubit auxiliar para realizar phase kickback
qc.h(y[0])
qc.x(y[0])
# Paso 5: Aplicar el operador de difusión
qc.append(diffuser_gate, qargs=x[:], inplace=True)
return qc
''' |
QPC003_EX2 | A1B1A8AD4E4C5 | 2 | RE | 1139 ms | 153 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def diffuser(n):
"""
Crea el operador de difusión (diffuser) para el Algoritmo de Grover.
"""
qc = QuantumCircuit(n)
qc.h(range(n))
qc.x(range(n))
# Aplicar una puerta Z multi-controlada
qc.h(n-1)
qc.mcx(list(range(n-1)), n-1) # Puerta Toffoli multi-controlada
qc.h(n-1)
qc.x(range(n))
qc.h(range(n))
# Convertir el circuito en una puerta
diffuser_gate = qc.to_gate()
diffuser_gate.name = "Diffuser"
return diffuser_gate
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
"""
Implementa un circuito cuántico que prepara el estado |psi> tal que
la probabilidad de medir |L> es al menos 0.9.
Parámetros:
- n: Número de qubits
- o: Oráculo O como QuantumCircuit de profundidad 1 que actúa sobre n qubits y 1 auxiliar
Retorna:
- qc: QuantumCircuit que implementa la operación deseada
"""
# Definir registros cuánticos
x = QuantumRegister(n, 'x') # Qubits para |x>
y = QuantumRegister(1, 'y') # Qubit auxiliar
qc = QuantumCircuit(x, y)
# Paso 1: Preparar el qubit auxiliar en el estado |-> = (|0> - |1>)/sqrt(2)
qc.x(y[0])
qc.h(y[0])
# Paso 2: Aplicar puertas Hadamard a todos los qubits para crear una superposición uniforme
qc.h(x)
# Definir el operador de difusión
diffuser_gate = diffuser(n)
# Calcular el número óptimo de iteraciones de Grover
N = 2**n
k = 1 # Número de soluciones (k=1 ya que L es único)
theta = math.asin(math.sqrt(k / N))
optimal_iterations = int(math.floor((math.pi / (4 * theta)) - 0.5))
# Determinar el número de iteraciones permitidas por la restricción de profundidad
# Estimación de profundidad por iteración:
# - Oráculo O: profundidad 1
# - H y X en y: profundidad 2
# - Difusor: profundidad aproximadamente n (depende de la implementación)
# Asumimos una profundidad total aproximada por iteración
depth_per_iteration = 1 + 2 + 20 # Ajustar según n
max_iterations = math.floor(75 / depth_per_iteration)
iterations = min(optimal_iterations, max_iterations)
iterations = max(1, iterations) # Al menos una iteración
# Aplicar el algoritmo de Grover
for _ in range(iterations):
# Paso 3: Aplicar el oráculo O
qc.compose(o, qubits=x[:] + [y[0]], inplace=True)
# Paso 4: Aplicar puertas H y X al qubit auxiliar para realizar phase kickback
qc.h(y[0])
qc.x(y[0])
# Paso 5: Aplicar el operador de difusión
qc.append(diffuser_gate, qargs=x[:], inplace=True)
return qc
''' |
QPC003_EX2 | A1B1A8AD4E4C5 | 3 | RE | 1382 ms | 154 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
"""
Implementa un circuito cuántico que prepara el estado |psi> tal que
la probabilidad de medir |L> es al menos 0.9.
Parámetros:
- n: Número de qubits
- o: Oráculo O como QuantumCircuit de profundidad 1 que actúa sobre n qubits y 1 auxiliar
Retorna:
- qc: QuantumCircuit que implementa la operación deseada
"""
# Definir registros cuánticos
x = QuantumRegister(n, 'x') # Qubits para |x>
y = QuantumRegister(1, 'y') # Qubit auxiliar
qc = QuantumCircuit(x, y)
# Paso 1: Preparar el qubit auxiliar en el estado |-> = (|0> - |1>)/sqrt(2)
qc.x(y[0])
qc.h(y[0])
# Paso 2: Aplicar puertas Hadamard a todos los qubits para crear una superposición uniforme
qc.h(x)
# Calcular el número óptimo de iteraciones de Grover
N = 2**n
k = 1 # Número de soluciones (k=1 ya que L es único)
theta = math.asin(math.sqrt(k / N))
optimal_iterations = int(math.floor((math.pi / (4 * theta)) - 0.5))
# Determinar el número de iteraciones permitidas por la restricción de profundidad
# Estimación de profundidad por iteración:
# - Oráculo O: profundidad 1
# - H y X en y: profundidad 2
# - Difusor: profundidad aproximadamente n (depende de la implementación)
# Asumimos una profundidad total aproximada por iteración
depth_per_iteration = 1 + 2 + 20 # Ajustar según n
max_iterations = math.floor(75 / depth_per_iteration)
iterations = min(optimal_iterations, max_iterations)
iterations = max(1, iterations) # Al menos una iteración
# Aplicar el algoritmo de Grover
for _ in range(iterations):
# Paso 3: Aplicar el oráculo O
qc.compose(o, qubits=x[:] + [y[0]], inplace=True)
# Paso 4: Aplicar puertas H y X al qubit auxiliar para realizar phase kickback
qc.h(y[0])
qc.x(y[0])
# Paso 5: Aplicar el operador de difusión
qc.h(range(n))
qc.x(range(n))
# Aplicar una puerta Z multi-controlada
qc.h(n-1)
qc.mcx(list(range(n-1)), n-1) # Puerta Toffoli multi-controlada
qc.h(n-1)
qc.x(range(n))
qc.h(range(n))
return qc
''' |
QPC003_EX2 | A1B1A8AD4E4C5 | 4 | WA | 1639 ms | 159 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
"""
Implementa un circuito cuántico que prepara el estado |psi⟩ tal que
la probabilidad de medir |L⟩ es al menos 0.9.
Parámetros:
- n: Número de qubits
- o: Oráculo O como QuantumCircuit de profundidad 1 que actúa sobre n qubits
Retorna:
- qc: QuantumCircuit que implementa la operación deseada
"""
# Definir el registro cuántico
x = QuantumCircuit(n)
qc = QuantumCircuit(n)
# Paso 1: Aplicar puertas Hadamard a todos los qubits para crear una superposición uniforme
qc.h(range(n))
# Paso 2: Determinar el número óptimo de iteraciones de Grover
# Número total de estados
N = 2**n
# Número de soluciones (k=1, ya que L es único)
k = 1
# Calcular el ángulo theta
theta = math.asin(math.sqrt(k / N))
# Número óptimo de iteraciones
optimal_iterations = int(math.floor((math.pi / (4 * theta)) - 0.5))
# Estimar la profundidad por iteración
# Cada iteración incluye:
# - Oráculo O: profundidad 1
# - Difusor: profundidad aproximada 4 (H, X, MCX, etc.)
# Total por iteración: ~5
depth_per_iteration = 5
max_depth = 75
# Calcular el número máximo de iteraciones sin exceder la profundidad
max_iterations = min(optimal_iterations, max_depth // depth_per_iteration)
# Asegurarse de que al menos se realice una iteración
iterations = max(1, max_iterations)
# Aplicar iteraciones de Grover
for _ in range(iterations):
# Paso 3: Aplicar el oráculo O
qc.compose(o, qubits=range(n), inplace=True)
# Paso 4: Aplicar el operador de difusión
# Aplicar puertas Hadamard a todos los qubits
qc.h(range(n))
# Aplicar puertas X a todos los qubits
qc.x(range(n))
# Aplicar una puerta Z multi-controlada
# Implementación de una puerta CCZ para n=2 o MCZ para n>2
if n == 1:
qc.z(0)
elif n == 2:
qc.cz(0, 1)
else:
# Aplicar Hadamard al último qubit
qc.h(n-1)
# Aplicar MCX con los primeros n-1 qubits como controles y el último como objetivo
qc.mcx(list(range(n-1)), n-1)
# Aplicar nuevamente Hadamard al último qubit
qc.h(n-1)
# Aplicar puertas X a todos los qubits
qc.x(range(n))
# Aplicar puertas Hadamard a todos los qubits
qc.h(range(n))
return qc
''' |
QPC003_EX2 | A1B1A8AD4E4C5 | 5 | WA | 1872 ms | 159 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
"""
Implementa un circuito cuántico que prepara el estado |psi⟩ tal que
la probabilidad de medir |L⟩ es al menos 0.9.
Parámetros:
- n: Número de qubits
- o: Oráculo O como QuantumCircuit de profundidad 1 que actúa sobre n qubits
Retorna:
- qc: QuantumCircuit que implementa la operación deseada
"""
# Definir el registro cuántico
x = QuantumCircuit(n)
qc = QuantumCircuit(n)
# Paso 1: Aplicar puertas Hadamard a todos los qubits para crear una superposición uniforme
qc.h(range(n))
# Paso 2: Determinar el número óptimo de iteraciones de Grover
# Número total de estados
N = 2**n
# Número de soluciones (k=1, ya que L es único)
k = 1
# Calcular el ángulo theta
theta = math.asin(math.sqrt(k / N))
# Número óptimo de iteraciones
optimal_iterations = int(math.floor((math.pi / (4 * theta)) - 0.5))
# Estimar la profundidad por iteración
# Cada iteración incluye:
# - Oráculo O: profundidad 1
# - Difusor: profundidad aproximada 4 (H, X, MCX, etc.)
# Total por iteración: ~5
depth_per_iteration = 5
max_depth = 75
# Calcular el número máximo de iteraciones sin exceder la profundidad
max_iterations = min(optimal_iterations, max_depth // depth_per_iteration)
# Asegurarse de que al menos se realice una iteración
iterations = max(1, max_iterations)
# Aplicar iteraciones de Grover
for _ in range(iterations):
# Paso 3: Aplicar el oráculo O
qc.compose(o, qubits=range(n), inplace=True)
# Paso 4: Aplicar el operador de difusión
qc.h(range(n))
qc.x(range(n))
# Aplicar una puerta Z multi-controlada
qc.h(n-1)
qc.mcx(list(range(n-1)), n-1) # Puerta Toffoli multi-controlada
qc.h(n-1)
qc.x(range(n))
qc.h(range(n))
return qc
''' |
QPC003_EX2 | A1B1A8AD4E4C5 | 6 | WA | 1241 ms | 157 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
"""
Implementa un circuito cuántico que prepara el estado |psi⟩ tal que
la probabilidad de medir |L⟩ es al menos 0.9.
Parámetros:
- n: Número de qubits
- o: Oráculo O como QuantumCircuit de profundidad 1 que actúa sobre n qubits
Retorna:
- qc: QuantumCircuit que implementa la operación deseada
"""
# Inicializar el circuito cuántico con n qubits
qc = QuantumCircuit(n)
# Definir el qubit auxiliar como el último qubit (n-1)
y = n - 1
# Paso 1: Preparar el qubit auxiliar y en el estado |-> = (|0⟩ - |1⟩)/sqrt(2)
qc.x(y) # Aplica X para convertir |0⟩ en |1⟩
qc.h(y) # Aplica Hadamard para obtener |->
# Paso 2: Aplicar puertas Hadamard a todos los qubits excepto el auxiliar para crear una superposición uniforme
if n > 1:
qc.h(range(n - 1))
else:
qc.h(y) # Si n=1, aplicar H al único qubit
# Calcular el número óptimo de iteraciones de Grover
# Número total de estados
N = 2**n
# Número de soluciones (k=1, ya que L es único)
k = 1
# Calcular el ángulo theta
theta = math.asin(math.sqrt(k / N))
# Número óptimo de iteraciones
optimal_iterations = int(math.floor((math.pi / (4 * theta)) - 0.5))
# Estimar la profundidad por iteración
# Cada iteración incluye:
# - Oráculo O: profundidad 1
# - Difusor: profundidad aproximada (dependiendo de n)
# Para simplificar, asumimos una profundidad por iteración de 3n + 3
depth_per_iteration = 3 * n + 3
max_depth = 75
initial_depth = 2 + (n - 1 if n > 1 else 1) # X y H en y qubit, H en otros qubits
# Calcular el número máximo de iteraciones sin exceder la profundidad
remaining_depth = max_depth - initial_depth
if remaining_depth < depth_per_iteration:
iterations = 1 # Al menos una iteración
else:
iterations = min(optimal_iterations, remaining_depth // depth_per_iteration)
# Asegurarse de que al menos se realice una iteración
iterations = max(1, iterations)
# Definir el operador de difusión (diffuser)
def diffuser_operator(diffuser):
"""
Crea el operador de difusión para el Algoritmo de Grover.
"""
#diffuser = QuantumCircuit(n_qubits, name='Diffuser')
diffuser.h(range(n))
diffuser.x(range(n))
# Aplicar la puerta Z multi-controlada
if n == 1:
diffuser.z(0)
elif n == 2:
diffuser.cz(0, 1)
else:
diffuser.h(n - 1)
diffuser.mcx(list(range(n - 1)), n - 1) # Puerta Toffoli multi-controlada
diffuser.h(n - 1)
diffuser.x(range(n))
diffuser.h(range(n))
#return diffuser.to_gate()
#diffuser_gate = diffuser_operator(n)
# Aplicar iteraciones de Grover
for _ in range(iterations):
# Paso 3: Aplicar el oráculo O
qc.compose(o, qubits=range(n), inplace=True)
# Paso 4: Aplicar el operador de difusión
#qc.append(diffuser_gate, qargs=range(n))
diffuser_operator(qc)
return qc
''' |
QPC003_EX2 | A1B1A8AD4E4C5 | 7 | RE | 1301 ms | 154 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
"""
Implementa un circuito cuántico que prepara el estado |psi⟩ tal que
la probabilidad de medir |L⟩ es al menos 0.9.
Parámetros:
- n: Número de qubits
- o: Oráculo O como QuantumCircuit de profundidad 1 que actúa sobre n qubits
Retorna:
- qc: QuantumCircuit que implementa la operación deseada
"""
# Inicializar el circuito cuántico con n qubits
qc = QuantumCircuit(n)
# Definir el qubit auxiliar como el último qubit (n-1)
y = n - 1
# Paso 1: Preparar el qubit auxiliar y en el estado |-> = (|0⟩ - |1⟩)/sqrt(2)
qc.x(y) # Aplica X para convertir |0⟩ en |1⟩
qc.h(y) # Aplica Hadamard para obtener |->
# Paso 2: Aplicar puertas Hadamard a todos los qubits excepto el auxiliar para crear una superposición uniforme
if n > 1:
qc.h(range(n - 1))
else:
qc.h(y) # Si n=1, aplicar H al único qubit
# Calcular el número óptimo de iteraciones de Grover
# Número total de estados
N = 2**n
# Número de soluciones (k=1, ya que L es único)
k = 1
# Calcular el ángulo theta
theta = math.asin(math.sqrt(k / N))
# Número óptimo de iteraciones
optimal_iterations = int(math.floor((math.pi / (4 * theta)) - 0.5))
# Estimar la profundidad por iteración
# Cada iteración incluye:
# - Oráculo O: profundidad 1
# - Difusor: profundidad aproximada (dependiendo de n)
# Para simplificar, asumimos una profundidad por iteración de 3n + 3
depth_per_iteration = 3 * n + 3
max_depth = 75
initial_depth = 2 + (n - 1 if n > 1 else 1) # X y H en y qubit, H en otros qubits
# Calcular el número máximo de iteraciones sin exceder la profundidad
remaining_depth = max_depth - initial_depth
if remaining_depth < depth_per_iteration:
iterations = 1 # Al menos una iteración
else:
iterations = min(optimal_iterations, remaining_depth // depth_per_iteration)
# Asegurarse de que al menos se realice una iteración
iterations = max(1, iterations)
# Definir el operador de difusión (diffuser)
def diffuser_operator(n_qubits):
"""
Crea el operador de difusión para el Algoritmo de Grover.
"""
diffuser = QuantumCircuit(n_qubits, name='Diffuser')
diffuser.h(range(n_qubits))
diffuser.x(range(n_qubits))
# Aplicar la puerta Z multi-controlada
if n_qubits == 1:
diffuser.z(0)
elif n_qubits == 2:
diffuser.cz(0, 1)
else:
diffuser.h(n_qubits - 1)
diffuser.mcx(list(range(n_qubits - 1)), n_qubits - 1) # Puerta Toffoli multi-controlada
diffuser.h(n_qubits - 1)
diffuser.x(range(n_qubits))
diffuser.h(range(n_qubits))
return diffuser.to_gate()
diffuser_gate = diffuser_operator(n)
# Aplicar iteraciones de Grover
for _ in range(iterations):
# Paso 3: Aplicar el oráculo O
qc.compose(o, qubits=range(n), inplace=True)
# Paso 4: Aplicar el operador de difusión
qc.append(diffuser_gate, qargs=range(n), inplace=True)
return qc
''' |
QPC003_EX2 | A1B1A8AD4E4C5 | 8 | WA | 1653 ms | 159 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
"""
Implementa un circuito cuántico que prepara el estado |psi⟩ tal que
la probabilidad de medir |L⟩ es al menos 0.9.
Parámetros:
- n: Número de qubits
- o: Oráculo O como QuantumCircuit de profundidad 1 que actúa sobre n qubits
Retorna:
- qc: QuantumCircuit que implementa la operación deseada
"""
# Definir el registro cuántico
x = QuantumCircuit(n)
qc = QuantumCircuit(n)
# Paso 1: Aplicar puertas Hadamard a todos los qubits para crear una superposición uniforme
qc.h(range(n))
# Paso 2: Determinar el número óptimo de iteraciones de Grover
# Número total de estados
N = 2**n
# Número de soluciones (k=1, ya que L es único)
k = 1
# Calcular el ángulo theta
theta = math.asin(math.sqrt(k / N))
# Número óptimo de iteraciones
optimal_iterations = int(math.floor((math.pi / (4 * theta)) - 0.5))
# Estimar la profundidad por iteración
# Cada iteración incluye:
# - Oráculo O: profundidad 1
# - Difusor: profundidad aproximada 4 (H, X, MCX, etc.)
# Total por iteración: ~5
depth_per_iteration = 5
max_depth = 75
# Calcular el número máximo de iteraciones sin exceder la profundidad
max_iterations = min(optimal_iterations, max_depth // depth_per_iteration)
# Asegurarse de que al menos se realice una iteración
iterations = max(1, max_iterations)
# Aplicar iteraciones de Grover
for _ in range(iterations):
# Paso 3: Aplicar el oráculo O
qc.compose(o, qubits=range(n), inplace=True)
# Paso 4: Aplicar el operador de difusión
qc.h(range(n))
qc.x(range(n))
# Aplicar una puerta Z multi-controlada
qc.h(n-1)
qc.mcx(list(range(n-1)), n-1) # Puerta Toffoli multi-controlada
qc.h(n-1)
qc.x(range(n))
qc.h(range(n))
return qc
''' |
QPC003_EX2 | A1B1A8AD4E4C5 | 9 | RE | 1159 ms | 153 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
"""
Implementa un circuito cuántico que prepara el estado |psi⟩ tal que
la probabilidad de medir |L⟩ es al menos 0.9.
Parámetros:
- n: Número de qubits
- o: Oráculo O como QuantumCircuit de profundidad 1 que actúa sobre n qubits y 1 auxiliar
Retorna:
- qc: QuantumCircuit que implementa la operación deseada
"""
# Definir los registros cuánticos
x = QuantumRegister(n, 'x') # Qubits para |x⟩
y = QuantumRegister(1, 'y') # Qubit auxiliar
qc = QuantumCircuit(x, y)
# Paso 1: Preparar el qubit auxiliar en el estado |-> = (|0⟩ - |1⟩)/sqrt(2)
qc.x(y[0]) # Aplicar puerta X para |1⟩
qc.h(y[0]) # Aplicar puerta Hadamard para |->
# Paso 2: Aplicar puertas Hadamard a todos los qubits de x para crear una superposición uniforme
qc.h(x)
# Calcular el número óptimo de iteraciones de Grover
N = 2**n
k = 1 # Número de soluciones (único L)
theta = math.asin(math.sqrt(k / N))
optimal_iterations = int(math.floor((math.pi / (4 * theta)) - 0.5))
# Estimar la profundidad por iteración
# Cada iteración incluye:
# - Oráculo O: profundidad 1
# - Difusor: aproximadamente 4n + 2 (puertas H, X, MCX, etc.)
# Suponemos una profundidad por iteración de 5n para mayor seguridad
depth_per_iteration = 5 * n
max_depth = 75
initial_depth = 2 + n # X and H on y qubit and H on x qubits
# Calcular el número máximo de iteraciones sin exceder la profundidad
remaining_depth = max_depth - initial_depth
if remaining_depth < depth_per_iteration:
iterations = 1 # Al menos una iteración
else:
iterations = min(optimal_iterations, remaining_depth // depth_per_iteration)
# Asegurarse de que al menos se realice una iteración
iterations = max(1, iterations)
# Definir el operador de difusión (diffuser) sin usar to_gate()
def apply_diffuser(circuit, qubits):
"""
Aplica el operador de difusión de Grover al circuito dado sobre los qubits especificados.
"""
# Paso 1: Aplicar puertas Hadamard a todos los qubits
circuit.h(qubits)
# Paso 2: Aplicar puertas X a todos los qubits
circuit.x(qubits)
# Paso 3: Aplicar la puerta Z multi-controlada
if len(qubits) == 1:
# Caso n=1: Aplicar puerta Z directamente
circuit.z(qubits[0])
elif len(qubits) == 2:
# Caso n=2: Aplicar puerta CZ
circuit.cz(qubits[0], qubits[1])
else:
# Caso n > 2: Implementar una puerta Z multi-controlada
# Convertir la última qubit a Z mediante MCX y H
circuit.h(qubits[-1])
circuit.mcx(qubits[:-1], qubits[-1]) # Puerta Toffoli multi-controlada
circuit.h(qubits[-1])
# Paso 4: Aplicar puertas X a todos los qubits
circuit.x(qubits)
# Paso 5: Aplicar puertas Hadamard a todos los qubits
circuit.h(qubits)
# Aplicar iteraciones de Grover
for _ in range(iterations):
# Paso 3: Aplicar el oráculo O
qc.compose(o, qubits=x[:] + [y[0]], inplace=True)
# Paso 4: Aplicar el operador de difusión
apply_diffuser(qc, x)
# Paso 5: Medir los qubits de x (opcional, dependiendo de la evaluación)
# qc.measure_all()
return qc
''' |
QPC003_EX2 | A2755435ACE6F | 1 | RE | 2425 ms | 156 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Apply Hadamard gates to all qubits
for qubit in range(n):
qc.h(qubit)
# Apply the oracle circuit
qc.compose(o, inplace=True)
# Apply the inverse quantum Fourier transform
for qubit in range(n):
for j in range(qubit):
qc.cu1(-2 * math.pi / 2**(qubit - j), j, qubit)
qc.h(qubit)
return qc
''' |
QPC003_EX2 | A6E427F589D3B | 1 | WA | 2031 ms | 160 MiB | '''python
from qiskit import QuantumCircuit
"""
You can apply oracle as follows:
qc.compose(o, inplace=True)
"""
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.h(i)
for i in range(n):
qc.compose(o,inplace=True)
qc.h(i)
return qc
''' |
QPC003_EX2 | A6E427F589D3B | 2 | WA | 2059 ms | 161 MiB | '''python
from qiskit import QuantumCircuit
"""
You can apply oracle as follows:
qc.compose(o, inplace=True)
"""
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.h(i)
for i in range(n):
qc.compose(o,inplace=True)
qc.h(i)
qc.z(i)
return qc
''' |
QPC003_EX2 | A6E427F589D3B | 3 | RE | 1764 ms | 156 MiB | '''python
from qiskit import QuantumCircuit
"""
You can apply oracle as follows:
qc.compose(o, inplace=True)
"""
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(x, y)
# Write your code here:-
for i in range(n):
qc.h(i)
row = [math.sin((2*r+1)*math.asin(2**(-n/2)))**2 for r in range(10)]
r = np.argmax(row)
for _ in range(r):
qc.append(o,qargs = range(n+1))
qc.z(n)
qc.append(o,qargs = range(n+1))
for i in range(n):
qc.h(i)
for i in range(n):
qc.x(i)
qc.append(ZGate().control(n-1),qargs = range(n))
for i in range(n):
qc.x(i)
for i in range(n):
qc.h(i)
return qc
''' |
QPC003_EX2 | A6E427F589D3B | 4 | RE | 1859 ms | 156 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
import math
import numpy as np
"""
You can apply oracle as follows:
qc.compose(o, inplace=True)
"""
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(x, y)
# Write your code here:-
for i in range(n):
qc.h(i)
row = [math.sin((2*r+1)*math.asin(2**(-n/2)))**2 for r in range(10)]
r = np.argmax(row)
for _ in range(r):
qc.append(o,qargs = range(n))
for i in range(n):
qc.h(i)
for i in range(n):
qc.x(i)
qc.append(ZGate().control(n-1),qargs = range(n))
for i in range(n):
qc.x(i)
for i in range(n):
qc.h(i)
return qc
''' |
QPC003_EX2 | A6E427F589D3B | 5 | WA | 1922 ms | 161 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
import math
import numpy as np
"""
You can apply oracle as follows:
qc.compose(o, inplace=True)
"""
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:-
for i in range(n):
qc.h(i)
row = [math.sin((2*r+1)*math.asin(2**(-n/2)))**2 for r in range(10)]
r = np.argmax(row)
for _ in range(r):
qc.append(o,qargs = range(n))
for i in range(n):
qc.h(i)
for i in range(n):
qc.x(i)
qc.append(ZGate().control(n-1),qargs = range(n))
for i in range(n):
qc.x(i)
for i in range(n):
qc.h(i)
return qc
''' |
QPC003_EX2 | A6E427F589D3B | 6 | RE | 1847 ms | 157 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
import math
import numpy as np
"""
You can apply oracle as follows:
qc.compose(o, inplace=True)
"""
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
if n <= 7:
return grover(n,o)
else:
for i in range(n):
qc.h(i)
for _ in range(2):
qc.compose(o)
qc.compose(uniform_one_hot)
for i in range(n):
qc.x(i)
qc.compose(ZGate().control(n-1))
for i in range(n):
qc.x(i)
qc.compose(uniform_one_hot)
return qc
return qc
def grover(n: int, o: QuantumCircuit) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:-
for i in range(n):
qc.h(i)
row = [math.sin((2*r+1)*math.asin(2**(-n/2)))**2 for r in range(10)]
r = np.argmax(row)
for _ in range(r):
qc.append(o,qargs = range(n))
for i in range(n):
qc.h(i)
for i in range(n):
qc.x(i)
qc.append(ZGate().control(n-1),qargs = range(n))
for i in range(n):
qc.x(i)
for i in range(n):
qc.h(i)
return qc
def uniform_one_hot(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
n_code = bin(n)[2:]
m = [0]
for i in range(len(n_code)):
if n_code[i] == "1":
m.append(m[-1]+2**(len(n_code)-i-1))
qc.x(0)
for i in range(1,len(m)-1):
split_one_hot(qc,m[i-1],m[i],(m[i]-m[i-1])/(n-m[i-1]))
for j in range(1,len(m)):
for k in range(1,m[j]-m[j-1]):
split_one_hot(qc,m[j-1]+k-2**int(math.log2(k)),m[j-1]+k,1/2)
return qc
def split_one_hot(qc,m1,m2,l):
print(m1,m2,l)
qc.cry(2*math.acos(math.sqrt(l)),m1,m2)
qc.cx(m2,m1)
''' |
QPC003_EX2 | A6E427F589D3B | 7 | WA | 1992 ms | 161 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
import math
import numpy as np
"""
You can apply oracle as follows:
qc.compose(o, inplace=True)
"""
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
if n <= 7:
return grover(n,o)
else:
for i in range(n):
qc.h(i)
for _ in range(2):
qc.compose(o)
qc.compose(uniform_one_hot(n))
for i in range(n):
qc.x(i)
qc.compose(ZGate().control(n-1))
for i in range(n):
qc.x(i)
qc.compose(uniform_one_hot(n))
return qc
def grover(n: int, o: QuantumCircuit) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:-
for i in range(n):
qc.h(i)
row = [math.sin((2*r+1)*math.asin(2**(-n/2)))**2 for r in range(10)]
r = np.argmax(row)
for _ in range(r):
qc.append(o,qargs = range(n))
for i in range(n):
qc.h(i)
for i in range(n):
qc.x(i)
qc.append(ZGate().control(n-1),qargs = range(n))
for i in range(n):
qc.x(i)
for i in range(n):
qc.h(i)
return qc
def uniform_one_hot(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
n_code = bin(n)[2:]
m = [0]
for i in range(len(n_code)):
if n_code[i] == "1":
m.append(m[-1]+2**(len(n_code)-i-1))
qc.x(0)
for i in range(1,len(m)-1):
split_one_hot(qc,m[i-1],m[i],(m[i]-m[i-1])/(n-m[i-1]))
for j in range(1,len(m)):
for k in range(1,m[j]-m[j-1]):
split_one_hot(qc,m[j-1]+k-2**int(math.log2(k)),m[j-1]+k,1/2)
return qc
def split_one_hot(qc,m1,m2,l):
print(m1,m2,l)
qc.cry(2*math.acos(math.sqrt(l)),m1,m2)
qc.cx(m2,m1)
''' |
QPC003_EX2 | A6E427F589D3B | 8 | WA | 2200 ms | 161 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
import math
import numpy as np
"""
You can apply oracle as follows:
qc.compose(o, inplace=True)
"""
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
if n <= 7:
return grover(n,o)
else:
for i in range(n):
qc.h(i)
for _ in range(2):
qc.compose(o)
qc.compose(uniform_one_hot(n))
for i in range(n):
qc.x(i)
qc.compose(ZGate().control(n-1))
for i in range(n):
qc.x(i)
qc.compose(uniform_one_hot(n).inverse())
return qc
def grover(n: int, o: QuantumCircuit) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:-
for i in range(n):
qc.h(i)
row = [math.sin((2*r+1)*math.asin(2**(-n/2)))**2 for r in range(10)]
r = np.argmax(row)
for _ in range(r):
qc.append(o,qargs = range(n))
for i in range(n):
qc.h(i)
for i in range(n):
qc.x(i)
qc.append(ZGate().control(n-1),qargs = range(n))
for i in range(n):
qc.x(i)
for i in range(n):
qc.h(i)
return qc
def uniform_one_hot(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
n_code = bin(n)[2:]
m = [0]
for i in range(len(n_code)):
if n_code[i] == "1":
m.append(m[-1]+2**(len(n_code)-i-1))
qc.x(0)
for i in range(1,len(m)-1):
split_one_hot(qc,m[i-1],m[i],(m[i]-m[i-1])/(n-m[i-1]))
for j in range(1,len(m)):
for k in range(1,m[j]-m[j-1]):
split_one_hot(qc,m[j-1]+k-2**int(math.log2(k)),m[j-1]+k,1/2)
return qc
def split_one_hot(qc,m1,m2,l):
print(m1,m2,l)
qc.cry(2*math.acos(math.sqrt(l)),m1,m2)
qc.cx(m2,m1)
''' |
QPC003_EX2 | A6E427F589D3B | 9 | WA | 1913 ms | 161 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
import math
import numpy as np
"""
You can apply oracle as follows:
qc.compose(o, inplace=True)
"""
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
if n <= 7:
return grover(n,o)
else:
for i in range(n):
qc.h(i)
for _ in range(2):
qc.compose(o)
qc.compose(uniform_one_hot(n).inverse())
for i in range(n):
qc.x(i)
qc.compose(ZGate().control(n-1))
for i in range(n):
qc.x(i)
qc.compose(uniform_one_hot(n))
return qc
def grover(n: int, o: QuantumCircuit) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:-
for i in range(n):
qc.h(i)
row = [math.sin((2*r+1)*math.asin(2**(-n/2)))**2 for r in range(10)]
r = np.argmax(row)
for _ in range(r):
qc.append(o,qargs = range(n))
for i in range(n):
qc.h(i)
for i in range(n):
qc.x(i)
qc.append(ZGate().control(n-1),qargs = range(n))
for i in range(n):
qc.x(i)
for i in range(n):
qc.h(i)
return qc
def uniform_one_hot(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
n_code = bin(n)[2:]
m = [0]
for i in range(len(n_code)):
if n_code[i] == "1":
m.append(m[-1]+2**(len(n_code)-i-1))
qc.x(0)
for i in range(1,len(m)-1):
split_one_hot(qc,m[i-1],m[i],(m[i]-m[i-1])/(n-m[i-1]))
for j in range(1,len(m)):
for k in range(1,m[j]-m[j-1]):
split_one_hot(qc,m[j-1]+k-2**int(math.log2(k)),m[j-1]+k,1/2)
return qc
def split_one_hot(qc,m1,m2,l):
print(m1,m2,l)
qc.cry(2*math.acos(math.sqrt(l)),m1,m2)
qc.cx(m2,m1)
''' |
QPC003_EX2 | A6E427F589D3B | 10 | WA | 1875 ms | 160 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
import math
import numpy as np
"""
You can apply oracle as follows:
qc.compose(o, inplace=True)
"""
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
if n <= 7:
return grover(n,o)
else:
for i in range(n):
qc.h(i)
for _ in range(2):
qc.compose(o, inplace=True)
qc.compose(uniform_one_hot(n).inverse(), inplace=True)
for i in range(n):
qc.x(i)
qc.compose(ZGate().control(n-1), inplace=True)
for i in range(n):
qc.x(i)
qc.compose(uniform_one_hot(n), inplace=True)
return qc
def grover(n: int, o: QuantumCircuit) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:-
for i in range(n):
qc.h(i)
row = [math.sin((2*r+1)*math.asin(2**(-n/2)))**2 for r in range(10)]
r = np.argmax(row)
for _ in range(r):
qc.append(o,qargs = range(n))
for i in range(n):
qc.h(i)
for i in range(n):
qc.x(i)
qc.append(ZGate().control(n-1),qargs = range(n))
for i in range(n):
qc.x(i)
for i in range(n):
qc.h(i)
return qc
def uniform_one_hot(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
n_code = bin(n)[2:]
m = [0]
for i in range(len(n_code)):
if n_code[i] == "1":
m.append(m[-1]+2**(len(n_code)-i-1))
qc.x(0)
for i in range(1,len(m)-1):
split_one_hot(qc,m[i-1],m[i],(m[i]-m[i-1])/(n-m[i-1]))
for j in range(1,len(m)):
for k in range(1,m[j]-m[j-1]):
split_one_hot(qc,m[j-1]+k-2**int(math.log2(k)),m[j-1]+k,1/2)
return qc
def split_one_hot(qc,m1,m2,l):
print(m1,m2,l)
qc.cry(2*math.acos(math.sqrt(l)),m1,m2)
qc.cx(m2,m1)
''' |
QPC003_EX2 | A6E427F589D3B | 11 | WA | 1846 ms | 161 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
import math
import numpy as np
"""
You can apply oracle as follows:
qc.compose(o, inplace=True)
"""
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
if n <= 7:
return grover(n,o)
else:
for i in range(n):
qc.h(i)
for _ in range(2):
qc.compose(o, inplace=True)
qc.compose(uniform_one_hot(n).inverse(), inplace=True)
for i in range(n):
qc.x(i)
qc.compose(ZGate().control(n-1), inplace=True)
for i in range(n):
qc.x(i)
qc.compose(uniform_one_hot(n), inplace=True)
return qc
def grover(n: int, o: QuantumCircuit) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:-
for i in range(n):
qc.h(i)
row = [math.sin((2*r+1)*math.asin(2**(-n/2)))**2 for r in range(10)]
r = np.argmax(row)
for _ in range(r):
qc.compose(o, inplace=True)
for i in range(n):
qc.h(i)
for i in range(n):
qc.x(i)
qc.compose(ZGate().control(n-1), inplace=True)
for i in range(n):
qc.x(i)
for i in range(n):
qc.h(i)
return qc
def uniform_one_hot(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
n_code = bin(n)[2:]
m = [0]
for i in range(len(n_code)):
if n_code[i] == "1":
m.append(m[-1]+2**(len(n_code)-i-1))
qc.x(0)
for i in range(1,len(m)-1):
split_one_hot(qc,m[i-1],m[i],(m[i]-m[i-1])/(n-m[i-1]))
for j in range(1,len(m)):
for k in range(1,m[j]-m[j-1]):
split_one_hot(qc,m[j-1]+k-2**int(math.log2(k)),m[j-1]+k,1/2)
return qc
def split_one_hot(qc,m1,m2,l):
print(m1,m2,l)
qc.cry(2*math.acos(math.sqrt(l)),m1,m2)
qc.cx(m2,m1)
''' |
QPC003_EX2 | A6E427F589D3B | 12 | WA | 1932 ms | 161 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
import math
import numpy as np
"""
You can apply oracle as follows:
qc.compose(o, inplace=True)
"""
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
if n <= 7:
return grover(n,o)
else:
for i in range(n):
qc.h(i)
for _ in range(2):
qc.compose(o, inplace=True)
qc.compose(uniform_one_hot(n).inverse(), inplace=True)
qc.compose(reflect(n), inplace=True)
qc.compose(uniform_one_hot(n), inplace=True)
return qc
def grover(n: int, o: QuantumCircuit) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:-
for i in range(n):
qc.h(i)
row = [math.sin((2*r+1)*math.asin(2**(-n/2)))**2 for r in range(10)]
r = np.argmax(row)
for _ in range(r):
qc.compose(o, inplace=True)
for i in range(n):
qc.h(i)
qc.compose(reflect(n), inplace=True)
for i in range(n):
qc.h(i)
return qc
def reflect(n:int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.x(range(n))
qc.compose(ZGate().control(n-1), inplace=True)
qc.x(range(n))
return qc
def uniform_one_hot(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
n_code = bin(n)[2:]
m = [0]
for i in range(len(n_code)):
if n_code[i] == "1":
m.append(m[-1]+2**(len(n_code)-i-1))
qc.x(0)
for i in range(1,len(m)-1):
split_one_hot(qc,m[i-1],m[i],(m[i]-m[i-1])/(n-m[i-1]))
for j in range(1,len(m)):
for k in range(1,m[j]-m[j-1]):
split_one_hot(qc,m[j-1]+k-2**int(math.log2(k)),m[j-1]+k,1/2)
return qc
def split_one_hot(qc,m1,m2,l):
print(m1,m2,l)
qc.cry(2*math.acos(math.sqrt(l)),m1,m2)
qc.cx(m2,m1)
''' |
QPC003_EX2 | A6E427F589D3B | 13 | AC | 2315 ms | 161 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
import math
import numpy as np
"""
You can apply oracle as follows:
qc.compose(o, inplace=True)
"""
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
if n <= 7:
return grover(n,o)
else:
qc.compose(uniform_one_hot(n), inplace=True)
for _ in range(2):
qc.compose(o, inplace=True)
qc.compose(uniform_one_hot(n).inverse(), inplace=True)
qc.compose(reflect(n), inplace=True)
qc.compose(uniform_one_hot(n), inplace=True)
return qc
def grover(n: int, o: QuantumCircuit) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:-
for i in range(n):
qc.h(i)
row = [math.sin((2*r+1)*math.asin(2**(-n/2)))**2 for r in range(10)]
r = np.argmax(row)
for _ in range(r):
qc.compose(o, inplace=True)
for i in range(n):
qc.h(i)
qc.compose(reflect(n), inplace=True)
for i in range(n):
qc.h(i)
return qc
def reflect(n:int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.x(range(n))
qc.compose(ZGate().control(n-1), inplace=True)
qc.x(range(n))
return qc
def uniform_one_hot(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
n_code = bin(n)[2:]
m = [0]
for i in range(len(n_code)):
if n_code[i] == "1":
m.append(m[-1]+2**(len(n_code)-i-1))
qc.x(0)
for i in range(1,len(m)-1):
split_one_hot(qc,m[i-1],m[i],(m[i]-m[i-1])/(n-m[i-1]))
for j in range(1,len(m)):
for k in range(1,m[j]-m[j-1]):
split_one_hot(qc,m[j-1]+k-2**int(math.log2(k)),m[j-1]+k,1/2)
return qc
def split_one_hot(qc,m1,m2,l):
print(m1,m2,l)
qc.cry(2*math.acos(math.sqrt(l)),m1,m2)
qc.cx(m2,m1)
''' |
QPC003_EX2 | A83F0EBC0A5F4 | 1 | RE | 1479 ms | 154 MiB | '''python
from math import (
pi,
# degrees,
# radians,
asin,
# acos,
# atan2,
# sqrt,
# sin,
# cos,
# tan
)
import numpy as np
from qiskit import QuantumCircuit, QuantumRegister
# from qiskit.circuit.library.standard_gates import (
# C3XGate,
# C3SXGate,
# C4XGate,
# CCXGate,
# DCXGate,
# CHGate,
# CPhaseGate,
# CRXGate,
# CRYGate,
# CRZGate,
# CSwapGate,
# CSXGate,
# CUGate,
# CU1Gate,
# CU3Gate,
# CXGate,
# CYGate,
# CZGate,
# CCZGate,
# HGate,
# IGate,
# MCPhaseGate,
# PhaseGate,
# RCCXGate,
# RC3XGate,
# RXGate,
# RXXGate,
# RYGate,
# RYYGate,
# RZGate,
# RZZGate,
# RZXGate,
# XXMinusYYGate,
# XXPlusYYGate,
# ECRGate,
# SGate,
# SdgGate,
# CSGate,
# CSdgGate,
# SwapGate,
# iSwapGate,
# SXGate,
# SXdgGate,
# TGate,
# TdgGate,
# UGate,
# U1Gate,
# U2Gate,
# U3Gate,
# XGate,
# YGate,
# ZGate,
# )
def split_state(qc: QuantumCircuit, targets: list[int], proportions: list[float]):
sum_p = sum(proportions)
proportions = [p / sum_p for p in proportions]
for i in range(1, len(targets)):
qc.cry(
asin(sqrt((1 - sum(proportions[:i])) / (1 - sum(proportions[: i - 1]))))
* 2,
targets[i - 1],
targets[i],
)
for i in range(1, len(targets)):
qc.cx(targets[i], targets[i - 1])
def solve_main(qc: QuantumCircuit, i0: int, i1: int):
if i1 - i0 <= 1:
return
i = (i0 + i1) // 2
split_state(qc, [i0, i], [len(range(i0, i)), len(range(i, i1))])
solve_main(qc, i0, i)
solve_main(qc, i, i1)
def prep_A6(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.x(0)
solve_main(qc, 0, n)
return qc
"""
You can apply oracle as follows:
qc.compose(o, inplace=True)
"""
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
qc = QuantumCircuit(n)
prep_qc = prep_A6(n)
# Write your code here:
qc.compose(prep_qc, inplace=True)
theta_0 = asin(np.sqrt(1 / n))
K = int(np.floor((pi / 2 - theta_0) / theta_0 / 2))
for _ in range(K):
qc.compose(o, inplace=True)
qc.compose(prep_qc.inverse(), inplace=True)
qc.x(range(n))
qc.mcp(pi, list(range(n - 1)), n - 1)
qc.x(range(n))
qc.compose(prep_qc, inplace=True)
return qc
''' |
QPC003_EX2 | A83F0EBC0A5F4 | 2 | WA | 1775 ms | 160 MiB | '''python
from math import (
pi,
# degrees,
# radians,
asin,
# acos,
# atan2,
sqrt,
# sin,
# cos,
# tan
)
import numpy as np
from qiskit import QuantumCircuit, QuantumRegister
# from qiskit.circuit.library.standard_gates import (
# C3XGate,
# C3SXGate,
# C4XGate,
# CCXGate,
# DCXGate,
# CHGate,
# CPhaseGate,
# CRXGate,
# CRYGate,
# CRZGate,
# CSwapGate,
# CSXGate,
# CUGate,
# CU1Gate,
# CU3Gate,
# CXGate,
# CYGate,
# CZGate,
# CCZGate,
# HGate,
# IGate,
# MCPhaseGate,
# PhaseGate,
# RCCXGate,
# RC3XGate,
# RXGate,
# RXXGate,
# RYGate,
# RYYGate,
# RZGate,
# RZZGate,
# RZXGate,
# XXMinusYYGate,
# XXPlusYYGate,
# ECRGate,
# SGate,
# SdgGate,
# CSGate,
# CSdgGate,
# SwapGate,
# iSwapGate,
# SXGate,
# SXdgGate,
# TGate,
# TdgGate,
# UGate,
# U1Gate,
# U2Gate,
# U3Gate,
# XGate,
# YGate,
# ZGate,
# )
def split_state(qc: QuantumCircuit, targets: list[int], proportions: list[float]):
sum_p = sum(proportions)
proportions = [p / sum_p for p in proportions]
for i in range(1, len(targets)):
qc.cry(
asin(sqrt((1 - sum(proportions[:i])) / (1 - sum(proportions[: i - 1]))))
* 2,
targets[i - 1],
targets[i],
)
for i in range(1, len(targets)):
qc.cx(targets[i], targets[i - 1])
def solve_main(qc: QuantumCircuit, i0: int, i1: int):
if i1 - i0 <= 1:
return
i = (i0 + i1) // 2
split_state(qc, [i0, i], [len(range(i0, i)), len(range(i, i1))])
solve_main(qc, i0, i)
solve_main(qc, i, i1)
def prep_A6(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.x(0)
solve_main(qc, 0, n)
return qc
"""
You can apply oracle as follows:
qc.compose(o, inplace=True)
"""
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
qc = QuantumCircuit(n)
prep_qc = prep_A6(n)
# Write your code here:
qc.compose(prep_qc, inplace=True)
theta_0 = asin(sqrt(1 / n))
K = int(np.floor((pi / 2 + theta_0) / theta_0 / 2))
for _ in range(K):
qc.compose(o, inplace=True)
qc.compose(prep_qc.inverse(), inplace=True)
qc.x(range(n))
qc.mcp(pi, list(range(n - 1)), n - 1)
qc.x(range(n))
qc.compose(prep_qc, inplace=True)
return qc
''' |
QPC003_EX2 | A83F0EBC0A5F4 | 3 | WA | 1850 ms | 161 MiB | '''python
from math import (
pi,
# degrees,
# radians,
asin,
# acos,
# atan2,
sqrt,
# sin,
# cos,
# tan
)
import numpy as np
from qiskit import QuantumCircuit, QuantumRegister
# from qiskit.circuit.library.standard_gates import (
# C3XGate,
# C3SXGate,
# C4XGate,
# CCXGate,
# DCXGate,
# CHGate,
# CPhaseGate,
# CRXGate,
# CRYGate,
# CRZGate,
# CSwapGate,
# CSXGate,
# CUGate,
# CU1Gate,
# CU3Gate,
# CXGate,
# CYGate,
# CZGate,
# CCZGate,
# HGate,
# IGate,
# MCPhaseGate,
# PhaseGate,
# RCCXGate,
# RC3XGate,
# RXGate,
# RXXGate,
# RYGate,
# RYYGate,
# RZGate,
# RZZGate,
# RZXGate,
# XXMinusYYGate,
# XXPlusYYGate,
# ECRGate,
# SGate,
# SdgGate,
# CSGate,
# CSdgGate,
# SwapGate,
# iSwapGate,
# SXGate,
# SXdgGate,
# TGate,
# TdgGate,
# UGate,
# U1Gate,
# U2Gate,
# U3Gate,
# XGate,
# YGate,
# ZGate,
# )
def split_state(qc: QuantumCircuit, targets: list[int], proportions: list[float]):
sum_p = sum(proportions)
proportions = [p / sum_p for p in proportions]
for i in range(1, len(targets)):
qc.cry(
asin(sqrt((1 - sum(proportions[:i])) / (1 - sum(proportions[: i - 1]))))
* 2,
targets[i - 1],
targets[i],
)
for i in range(1, len(targets)):
qc.cx(targets[i], targets[i - 1])
def solve_main(qc: QuantumCircuit, i0: int, i1: int):
if i1 - i0 <= 1:
return
i = (i0 + i1) // 2
split_state(qc, [i0, i], [len(range(i0, i)), len(range(i, i1))])
solve_main(qc, i0, i)
solve_main(qc, i, i1)
def prep_A6(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.x(0)
solve_main(qc, 0, n)
return qc
"""
You can apply oracle as follows:
qc.compose(o, inplace=True)
"""
def solve_7(n: int, o: QuantumCircuit) -> QuantumCircuit:
qc = QuantumCircuit(8)
prep_qc = prep_A6(8)
# Write your code here:
qc.compose(prep_qc, inplace=True)
theta_0 = asin(sqrt(1 / 8))
K = int(np.round((pi / 2 - theta_0) / theta_0 / 2))
for _ in range(K):
qc.compose(o, inplace=True)
qc.compose(prep_qc.inverse(), inplace=True)
qc.x(range(8))
qc.mcp(pi, list(range(8 - 1)), 8 - 1)
qc.x(range(8))
qc.compose(prep_qc, inplace=True)
return qc
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
if n == 7:
return solve_7(n, o)
qc = QuantumCircuit(n)
prep_qc = prep_A6(n)
# Write your code here:
qc.compose(prep_qc, inplace=True)
theta_0 = asin(sqrt(1 / n))
K = int(np.round((pi / 2 - theta_0) / theta_0 / 2))
for _ in range(K):
qc.compose(o, inplace=True)
qc.compose(prep_qc.inverse(), inplace=True)
qc.x(range(n))
qc.mcp(pi, list(range(n - 1)), n - 1)
qc.x(range(n))
qc.compose(prep_qc, inplace=True)
return qc
''' |
QPC003_EX2 | A83F0EBC0A5F4 | 4 | AC | 1674 ms | 160 MiB | '''python
from math import (
pi,
# degrees,
# radians,
asin,
# acos,
# atan2,
sqrt,
# sin,
# cos,
# tan
)
import numpy as np
from qiskit import QuantumCircuit, QuantumRegister
# from qiskit.circuit.library.standard_gates import (
# C3XGate,
# C3SXGate,
# C4XGate,
# CCXGate,
# DCXGate,
# CHGate,
# CPhaseGate,
# CRXGate,
# CRYGate,
# CRZGate,
# CSwapGate,
# CSXGate,
# CUGate,
# CU1Gate,
# CU3Gate,
# CXGate,
# CYGate,
# CZGate,
# CCZGate,
# HGate,
# IGate,
# MCPhaseGate,
# PhaseGate,
# RCCXGate,
# RC3XGate,
# RXGate,
# RXXGate,
# RYGate,
# RYYGate,
# RZGate,
# RZZGate,
# RZXGate,
# XXMinusYYGate,
# XXPlusYYGate,
# ECRGate,
# SGate,
# SdgGate,
# CSGate,
# CSdgGate,
# SwapGate,
# iSwapGate,
# SXGate,
# SXdgGate,
# TGate,
# TdgGate,
# UGate,
# U1Gate,
# U2Gate,
# U3Gate,
# XGate,
# YGate,
# ZGate,
# )
def split_state(qc: QuantumCircuit, targets: list[int], proportions: list[float]):
sum_p = sum(proportions)
proportions = [p / sum_p for p in proportions]
for i in range(1, len(targets)):
qc.cry(
asin(sqrt((1 - sum(proportions[:i])) / (1 - sum(proportions[: i - 1]))))
* 2,
targets[i - 1],
targets[i],
)
for i in range(1, len(targets)):
qc.cx(targets[i], targets[i - 1])
def solve_main(qc: QuantumCircuit, i0: int, i1: int):
if i1 - i0 <= 1:
return
i = (i0 + i1) // 2
split_state(qc, [i0, i], [len(range(i0, i)), len(range(i, i1))])
solve_main(qc, i0, i)
solve_main(qc, i, i1)
def prep_A6(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.x(0)
solve_main(qc, 0, n)
return qc
"""
You can apply oracle as follows:
qc.compose(o, inplace=True)
"""
def solve_2(n: int, o: QuantumCircuit) -> QuantumCircuit:
qc = QuantumCircuit(4)
prep_qc = prep_A6(4)
# Write your code here:
qc.compose(prep_qc, inplace=True)
theta_0 = asin(sqrt(1 / 4))
K = int(np.round((pi / 2 - theta_0) / theta_0 / 2))
for _ in range(K):
qc.compose(o, inplace=True)
qc.compose(prep_qc.inverse(), inplace=True)
qc.x(range(4))
qc.mcp(pi, list(range(4 - 1)), 4 - 1)
qc.x(range(4))
qc.compose(prep_qc, inplace=True)
return qc
def solve_7(n: int, o: QuantumCircuit) -> QuantumCircuit:
qc = QuantumCircuit(8)
prep_qc = prep_A6(8)
# Write your code here:
qc.compose(prep_qc, inplace=True)
theta_0 = asin(sqrt(1 / 8))
K = int(np.round((pi / 2 - theta_0) / theta_0 / 2))
for _ in range(K):
qc.compose(o, inplace=True)
qc.compose(prep_qc.inverse(), inplace=True)
qc.x(range(8))
qc.mcp(pi, list(range(8 - 1)), 8 - 1)
qc.x(range(8))
qc.compose(prep_qc, inplace=True)
return qc
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
if n == 2:
return solve_2(n, o)
if n == 7:
return solve_7(n, o)
qc = QuantumCircuit(n)
prep_qc = prep_A6(n)
# Write your code here:
qc.compose(prep_qc, inplace=True)
theta_0 = asin(sqrt(1 / n))
K = int(np.round((pi / 2 - theta_0) / theta_0 / 2))
for _ in range(K):
qc.compose(o, inplace=True)
qc.compose(prep_qc.inverse(), inplace=True)
qc.x(range(n))
qc.mcp(pi, list(range(n - 1)), n - 1)
qc.x(range(n))
qc.compose(prep_qc, inplace=True)
return qc
''' |
QPC003_EX2 | A8A4F03D1F0BC | 1 | DLE | 1806 ms | 160 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import ZGate, GlobalPhaseGate
import numpy as np
import math
def psi(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.x(0)
split(qc, 0, n)
return qc
def split(qc, stIncl, edExcl):
if stIncl + 1 == edExcl:
return
mid = (stIncl + edExcl) // 2
left = mid - stIncl
right = edExcl - mid
angle = 2*math.atan(math.sqrt(right/left))
qc.cry(angle, stIncl, mid)
qc.cx(mid, stIncl)
split(qc, stIncl, mid)
split(qc, mid, edExcl)
return qc
def refl(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.append(GlobalPhaseGate(math.pi))
qc.x(range(n))
mcz = ZGate().control(n-1)
qc.append(mcz, list(range(n)))
qc.x(range(n))
return qc
def refl_psi(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.compose(psi(n).inverse(), inplace=True)
qc.compose(refl(n), inplace=True)
qc.compose(psi(n), inplace=True)
return qc
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(x, y)
# Write your code here:
qc.x(y)
qc.h(y)
qc.compose(psi(n), x, inplace=True)
init_prob = math.sqrt(1/n)
init_angle = math.acos(init_prob)
target_prob = 0.9
repeat = 0
while True:
angle = (2*repeat+1) * init_angle
curr_prob = math.cos(angle)**2
print(f'{repeat=} {curr_prob=}')
if curr_prob > target_prob:
break
qc.compose(o, inplace=True)
qc.compose(psi(n).inverse(), inplace=True)
qc.compose(refl(n), inplace=True)
qc.compose(psi(n), inplace=True)
repeat += 1
qc.h(y)
qc.x(y)
return qc
''' |
QPC003_EX2 | A8A4F03D1F0BC | 2 | WA | 1780 ms | 160 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import ZGate, GlobalPhaseGate
import numpy as np
import math
def psi(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.x(0)
split(qc, 0, n)
return qc
def split(qc, stIncl, edExcl):
if stIncl + 1 == edExcl:
return
mid = (stIncl + edExcl) // 2
left = mid - stIncl
right = edExcl - mid
angle = 2*math.atan(math.sqrt(right/left))
qc.cry(angle, stIncl, mid)
qc.cx(mid, stIncl)
split(qc, stIncl, mid)
split(qc, mid, edExcl)
return qc
def refl(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.append(GlobalPhaseGate(math.pi))
qc.x(range(n))
mcz = ZGate().control(n-1)
qc.append(mcz, list(range(n)))
qc.x(range(n))
return qc
def refl_psi(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.compose(psi(n).inverse(), inplace=True)
qc.compose(refl(n), inplace=True)
qc.compose(psi(n), inplace=True)
return qc
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(x, y)
# Write your code here:
qc.x(y)
qc.h(y)
qc.compose(psi(n), x, inplace=True)
init_prob = math.sqrt(1/n)
init_angle = math.acos(init_prob)
target_prob = 0.9
repeat = 0
for _ in range(2):
angle = (2*repeat+1) * init_angle
curr_prob = math.cos(angle)**2
print(f'{repeat=} {curr_prob=}')
if curr_prob > target_prob:
break
qc.compose(o, inplace=True)
qc.compose(psi(n).inverse(), inplace=True)
qc.compose(refl(n), inplace=True)
qc.compose(psi(n), inplace=True)
repeat += 1
qc.h(y)
qc.x(y)
return qc
''' |
QPC003_EX2 | A8A4F03D1F0BC | 3 | WA | 1833 ms | 160 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import ZGate, GlobalPhaseGate
import numpy as np
import math
def psi(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.x(0)
split(qc, 0, n)
return qc
def split(qc, stIncl, edExcl):
if stIncl + 1 == edExcl:
return
mid = (stIncl + edExcl) // 2
left = mid - stIncl
right = edExcl - mid
angle = 2*math.atan(math.sqrt(right/left))
qc.cry(angle, stIncl, mid)
qc.cx(mid, stIncl)
split(qc, stIncl, mid)
split(qc, mid, edExcl)
return qc
def refl(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.append(GlobalPhaseGate(math.pi))
qc.x(range(n))
mcz = ZGate().control(n-1)
qc.append(mcz, list(range(n)))
qc.x(range(n))
return qc
def refl_psi(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.compose(psi(n).inverse(), inplace=True)
qc.compose(refl(n), inplace=True)
qc.compose(psi(n), inplace=True)
return qc
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(x, y)
# Write your code here:
qc.x(y)
qc.h(y)
qc.compose(psi(n), x, inplace=True)
init_prob = math.sqrt(1/n)
init_angle = math.acos(init_prob)
target_prob = 0.9
repeat = 0
for _ in range(3):
angle = (2*repeat+1) * init_angle
curr_prob = math.cos(angle)**2
print(f'{repeat=} {curr_prob=}')
if curr_prob > target_prob:
break
qc.compose(o, inplace=True)
qc.compose(psi(n).inverse(), inplace=True)
qc.compose(refl(n), inplace=True)
qc.compose(psi(n), inplace=True)
repeat += 1
qc.h(y)
qc.x(y)
return qc
''' |
QPC003_EX2 | A8A4F03D1F0BC | 4 | AC | 1988 ms | 161 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import ZGate, GlobalPhaseGate
import numpy as np
import math
def psi(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
angle = math.acos(1/16)
qc.ry(2*math.acos(math.sqrt(1-math.cos(angle)*n)), 0)
split(qc, 0, n)
return qc
def split(qc, stIncl, edExcl):
if stIncl + 1 == edExcl:
return
mid = (stIncl + edExcl) // 2
left = mid - stIncl
right = edExcl - mid
angle = 2*math.atan(math.sqrt(right/left))
qc.cry(angle, stIncl, mid)
qc.cx(mid, stIncl)
split(qc, stIncl, mid)
split(qc, mid, edExcl)
return qc
def refl(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.append(GlobalPhaseGate(math.pi))
qc.x(range(n))
mcz = ZGate().control(n-1)
qc.append(mcz, list(range(n)))
qc.x(range(n))
return qc
def refl_psi(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.compose(psi(n).inverse(), inplace=True)
qc.compose(refl(n), inplace=True)
qc.compose(psi(n), inplace=True)
return qc
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(x, y)
# Write your code here:
qc.x(y)
qc.h(y)
qc.compose(psi(n), x, inplace=True)
init_prob = math.sqrt(1/16)
init_angle = math.acos(init_prob)
target_prob = 0.9
repeat = 0
while True:
angle = (2*repeat+1) * init_angle
curr_prob = math.cos(angle)**2
print(f'{repeat=} {curr_prob=}')
if curr_prob > target_prob:
break
qc.compose(o, inplace=True)
qc.compose(psi(n).inverse(), inplace=True)
qc.compose(refl(n), inplace=True)
qc.compose(psi(n), inplace=True)
repeat += 1
qc.h(y)
qc.x(y)
return qc
''' |
QPC003_EX2 | AA1618AE47E92 | 1 | WA | 1810 ms | 161 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import ZGate, XGate, HGate, SwapGate
import math
"""
You can apply oracle as follows:
qc.compose(o, inplace=True)
"""
def w_state(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
qc.x(0)
count = 1
# queue = [(a, b, control bit of CRy), ...]
queue = [(n // 2, n, 0)]
# breadth first search
while len(queue):
a, b, control = queue.pop(0)
if a == 0:
continue
theta = 2 * math.atan(math.sqrt((b - a) / a))
qc.cry(theta, control, count)
qc.cx(count, control)
queue.append(((b // 2) // 2, b // 2, control))
queue.append((math.ceil(b / 2) // 2, math.ceil(b / 2), count))
count += 1
return qc
def reflect_w_state(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
qc.compose(w_state(n).inverse(), inplace=True)
qc.x(range(n))
qc.append(ZGate().control(n - 1), range(n))
qc.x(range(n))
qc.compose(w_state(n), inplace=True)
return qc
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(x, y)
theta = math.asin(1 / (n) ** 0.5)
iterations = math.floor(math.pi / (4 * theta))
# print(theta, iterations)
qc.compose(w_state(n), inplace=True)
reflect = reflect_w_state(n)
for _ in range(iterations):
qc.compose(o, inplace=True)
qc.z(y)
qc.compose(o.inverse(), inplace=True)
qc.compose(reflect, inplace=True)
return qc
''' |
QPC003_EX2 | AA1618AE47E92 | 2 | WA | 1827 ms | 161 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import ZGate, XGate, HGate, SwapGate
import math
"""
You can apply oracle as follows:
qc.compose(o, inplace=True)
"""
def w_state(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
qc.x(0)
count = 1
# queue = [(a, b, control bit of CRy), ...]
queue = [(n // 2, n, 0)]
# breadth first search
while len(queue):
a, b, control = queue.pop(0)
if a == 0:
continue
theta = 2 * math.atan(math.sqrt((b - a) / a))
qc.cry(theta, control, count)
qc.cx(count, control)
queue.append(((b // 2) // 2, b // 2, control))
queue.append((math.ceil(b / 2) // 2, math.ceil(b / 2), count))
count += 1
return qc
def reflect_w_state(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
qc.compose(w_state(n).inverse(), inplace=True)
qc.x(range(n))
qc.append(ZGate().control(n - 1), range(n))
qc.x(range(n))
qc.compose(w_state(n), inplace=True)
return qc
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(x, y)
theta = math.asin(1 / n ** 0.5)
iterations = math.floor(math.pi / (4 * theta))
# print(f"{theta = } {iterations = }")
qc.compose(w_state(n), inplace=True)
reflect = reflect_w_state(n)
for _ in range(iterations):
qc.compose(o, inplace=True)
qc.z(y)
qc.compose(o.inverse(), inplace=True)
qc.compose(reflect, inplace=True)
return qc
''' |
QPC003_EX2 | AA88D013A27C7 | 1 | RE | 1647 ms | 157 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
qr = QuantumRegister(n, 'q')
anc = QuantumRegister(1, 'ancilla')
qc = QuantumCircuit(qr, anc)
qc.h(qr)
qc.x(anc)
qc.h(anc)
qc.compose(o, qubits=qr[:] + anc[:], inplace=True)
qc.h(qr)
qc.x(qr)
qc.h(qr[-1])
qc.mct(qr[:-1], qr[-1])
qc.h(qr[-1])
qc.x(qr)
qc.h(qr)
qc = qc.remove_final_measurements(inplace=False)
final_qc = QuantumCircuit(n)
final_qc.compose(qc, qubits=range(n), inplace=True)
return final_qc
''' |
QPC003_EX2 | AA88D013A27C7 | 2 | RE | 1624 ms | 157 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
qc = QuantumCircuit(n)
ancilla = n - 1
qc.x(ancilla)
qc.h(ancilla)
qc.h(range(n-1))
qc.compose(o, inplace=True)
qc.h(range(n-1))
qc.x(range(n-1))
qc.mct(list(range(n-1)), ancilla)
qc.x(range(n-1))
qc.h(range(n-1))
return qc
''' |
QPC003_EX2 | AA88D013A27C7 | 3 | RE | 1357 ms | 157 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
qc = QuantumCircuit(n)
qc.h(range(n))
qc.compose(o, inplace=True)
qc.h(range(n))
qc.x(range(n))
qc.mcz(list(range(n-1)), n-1)
qc.x(range(n))
qc.h(range(n))
return qc
''' |
QPC003_EX2 | AA88D013A27C7 | 4 | WA | 1524 ms | 161 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
qc.h(i)
k = 75 // (2*n+4)
for _ in range(k):
qc.compose(o, inplace=True)
qc.h(range(n))
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.h(range(n))
return qc
''' |
QPC003_EX2 | AAB48AE0D5F9E | 1 | RE | 1124 ms | 152 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library.standard_gates import GlobalPhaseGate, ZGate, RYGate
import math
"""
You can apply oracle as follows:
qc.compose(o, inplace=True)
"""
def a5(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.x(i)
if n==7:
qc.ry(math.asin(-1/math.sqrt(n+1))*2, 0)
for i in range(1, n):
qc.append(RYGate(math.asin(-1/math.sqrt(n-i+1))*2).control(i), range(i+1))
# qc.mcx(list(range(n-1)), n-1)
else:
qc.ry(math.asin(-1/math.sqrt(n))*2, 0)
for i in range(1, n-1):
qc.append(RYGate(math.asin(-1/math.sqrt(n-i))*2).control(i), range(i+1))
qc.mcx(list(range(n-1)), n-1)
for i in range(n):
qc.x(i)
return qc
def b7(n: int, T: list[float]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.compose(a5(n, T).inverse(), inplace=True)
for i in range(n):
qc.x(i)
qc.append(ZGate().control(n-1), list(range(n)))
for i in range(n):
qc.x(i)
# qc.append(GlobalPhaseGate(math.pi))
qc.compose(a5(n, T), inplace=True)
return qc
# def b5(n: int) -> QuantumCircuit:
# qc = QuantumCircuit(n)
# # init = [0]*(2**n)
# # init[2] = 1
# # qc.initialize(init)
# # Write your code here:
# for i in range(n):
# qc.h(i)
# for i in range(n):
# qc.x(i)
# qc.append(ZGate().control(n-1), list(range(n)))
# for i in range(n):
# qc.x(i)
# for i in range(n):
# qc.h(i)
# return qc
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(x, y)
# Write your code here:
qc.compose(a5(n), inplace=True)
t = math.asin(1/math.sqrt(n))
for i in range(1, 100):
qc.compose(o, inplace=True)
qc.compose(b7(n), inplace=True)
if math.sin((2*i+1)*t)**2>=0.9:
break
return qc
''' |
QPC003_EX2 | AAB48AE0D5F9E | 2 | DLE | 1260 ms | 154 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library.standard_gates import GlobalPhaseGate, ZGate, RYGate
import math
"""
You can apply oracle as follows:
qc.compose(o, inplace=True)
"""
def a5(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.x(i)
if n==7:
qc.ry(math.asin(-1/math.sqrt(n+1))*2, 0)
for i in range(1, n):
qc.append(RYGate(math.asin(-1/math.sqrt(n-i+1))*2).control(i), range(i+1))
# qc.mcx(list(range(n-1)), n-1)
else:
qc.ry(math.asin(-1/math.sqrt(n))*2, 0)
for i in range(1, n-1):
qc.append(RYGate(math.asin(-1/math.sqrt(n-i))*2).control(i), range(i+1))
qc.mcx(list(range(n-1)), n-1)
for i in range(n):
qc.x(i)
return qc
def b7(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.compose(a5(n).inverse(), inplace=True)
for i in range(n):
qc.x(i)
qc.append(ZGate().control(n-1), list(range(n)))
for i in range(n):
qc.x(i)
# qc.append(GlobalPhaseGate(math.pi))
qc.compose(a5(n), inplace=True)
return qc
# def b5(n: int) -> QuantumCircuit:
# qc = QuantumCircuit(n)
# # init = [0]*(2**n)
# # init[2] = 1
# # qc.initialize(init)
# # Write your code here:
# for i in range(n):
# qc.h(i)
# for i in range(n):
# qc.x(i)
# qc.append(ZGate().control(n-1), list(range(n)))
# for i in range(n):
# qc.x(i)
# for i in range(n):
# qc.h(i)
# return qc
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(x, y)
# Write your code here:
qc.compose(a5(n), inplace=True)
t = math.asin(1/math.sqrt(n))
for i in range(1, 100):
qc.compose(o, inplace=True)
qc.compose(b7(n), inplace=True)
if math.sin((2*i+1)*t)**2>=0.9:
break
return qc
''' |
QPC003_EX2 | AAB48AE0D5F9E | 3 | DLE | 1350 ms | 160 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library.standard_gates import GlobalPhaseGate, ZGate, RYGate
import math
"""
You can apply oracle as follows:
qc.compose(o, inplace=True)
"""
def a5(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.x(i)
if n==7:
qc.ry(math.asin(-1/math.sqrt(n+1))*2, 0)
for i in range(1, n):
qc.append(RYGate(math.asin(-1/math.sqrt(n-i+1))*2).control(i), range(i+1))
# qc.mcx(list(range(n-1)), n-1)
else:
qc.ry(math.asin(-1/math.sqrt(n))*2, 0)
for i in range(1, n-1):
qc.append(RYGate(math.asin(-1/math.sqrt(n-i))*2).control(i), range(i+1))
qc.mcx(list(range(n-1)), n-1)
for i in range(n):
qc.x(i)
return qc
def b7(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.compose(a5(n).inverse(), inplace=True)
for i in range(n):
qc.x(i)
qc.append(ZGate().control(n-1), list(range(n)))
for i in range(n):
qc.x(i)
# qc.append(GlobalPhaseGate(math.pi))
qc.compose(a5(n), inplace=True)
return qc
# def b5(n: int) -> QuantumCircuit:
# qc = QuantumCircuit(n)
# # init = [0]*(2**n)
# # init[2] = 1
# # qc.initialize(init)
# # Write your code here:
# for i in range(n):
# qc.h(i)
# for i in range(n):
# qc.x(i)
# qc.append(ZGate().control(n-1), list(range(n)))
# for i in range(n):
# qc.x(i)
# for i in range(n):
# qc.h(i)
# return qc
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(x, y)
# Write your code here:
qc.compose(a5(n), inplace=True)
t = math.asin(1/math.sqrt(n))
if n==7:
t = math.asin(1/math.sqrt(n+1))
for i in range(1, 100):
qc.compose(o, inplace=True)
qc.compose(b7(n), inplace=True)
if math.sin((2*i+1)*t)**2>=0.9:
break
return qc
''' |
QPC003_EX2 | AAB48AE0D5F9E | 4 | RE | 1296 ms | 156 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library.standard_gates import GlobalPhaseGate, ZGate, RYGate
import math
"""
You can apply oracle as follows:
qc.compose(o, inplace=True)
"""
def a5(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.x(i)
if n==7:
qc.ry(math.asin(-1/math.sqrt(n+1))*2, 0)
for i in range(1, n):
qc.append(RYGate(math.asin(-1/math.sqrt(n-i+1))*2).control(i), range(i+1))
# qc.mcx(list(range(n-1)), n-1)
else:
qc.ry(math.asin(-1/math.sqrt(n))*2, 0)
for i in range(1, n-1):
qc.append(RYGate(math.asin(-1/math.sqrt(n-i))*2).control(i), range(i+1))
qc.mcx(list(range(n-1)), n-1)
for i in range(n):
qc.x(i)
return qc
def b7(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.compose(a5(n).inverse(), inplace=True)
for i in range(n):
qc.x(i)
qc.append(ZGate().control(n-1), list(range(n)))
for i in range(n):
qc.x(i)
# qc.append(GlobalPhaseGate(math.pi))
qc.compose(a5(n), inplace=True)
return qc
# def b5(n: int) -> QuantumCircuit:
# qc = QuantumCircuit(n)
# # init = [0]*(2**n)
# # init[2] = 1
# # qc.initialize(init)
# # Write your code here:
# for i in range(n):
# qc.h(i)
# for i in range(n):
# qc.x(i)
# qc.append(ZGate().control(n-1), list(range(n)))
# for i in range(n):
# qc.x(i)
# for i in range(n):
# qc.h(i)
# return qc
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
assert n!=10
x, y = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(x, y)
# Write your code here:
qc.compose(a5(n), inplace=True)
t = math.asin(1/math.sqrt(n))
if n==7:
t = math.asin(1/math.sqrt(n+1))
for i in range(1, 100):
qc.compose(o, inplace=True)
qc.compose(b7(n), inplace=True)
if math.sin((2*i+1)*t)**2>=0.9:
break
return qc
''' |
QPC003_EX2 | AAB48AE0D5F9E | 5 | AC | 2966 ms | 173 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library.standard_gates import GlobalPhaseGate, ZGate, RYGate
import math
"""
You can apply oracle as follows:
qc.compose(o, inplace=True)
"""
def a5(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.x(i)
if n==7 or n==2:
qc.ry(math.asin(-1/math.sqrt(n+1))*2, 0)
for i in range(1, n):
qc.append(RYGate(math.asin(-1/math.sqrt(n-i+1))*2).control(i), range(i+1))
# qc.mcx(list(range(n-1)), n-1)
else:
qc.ry(math.asin(-1/math.sqrt(n))*2, 0)
for i in range(1, n-1):
qc.append(RYGate(math.asin(-1/math.sqrt(n-i))*2).control(i), range(i+1))
qc.mcx(list(range(n-1)), n-1)
for i in range(n):
qc.x(i)
return qc
def b7(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.compose(a5(n).inverse(), inplace=True)
for i in range(n):
qc.x(i)
qc.append(ZGate().control(n-1), list(range(n)))
for i in range(n):
qc.x(i)
# qc.append(GlobalPhaseGate(math.pi))
qc.compose(a5(n), inplace=True)
return qc
# def b5(n: int) -> QuantumCircuit:
# qc = QuantumCircuit(n)
# # init = [0]*(2**n)
# # init[2] = 1
# # qc.initialize(init)
# # Write your code here:
# for i in range(n):
# qc.h(i)
# for i in range(n):
# qc.x(i)
# qc.append(ZGate().control(n-1), list(range(n)))
# for i in range(n):
# qc.x(i)
# for i in range(n):
# qc.h(i)
# return qc
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(x, y)
# Write your code here:
qc.compose(a5(n), inplace=True)
t = math.asin(1/math.sqrt(n))
if n==7 or n==2:
t = math.asin(1/math.sqrt(n+1))
for i in range(1, 100):
qc.compose(o, inplace=True)
qc.compose(b7(n), inplace=True)
if math.sin((2*i+1)*t)**2>=0.9:
break
return qc
''' |
QPC003_EX2 | AD248C13D2A2D | 1 | RE | 1394 ms | 154 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library.standard_gates import HGate, XGate
"""
You can apply oracle as follows:
qc.compose(o, inplace=True)
"""
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
qc.append(HGate(), [i])
qc.compose(o, inplace=True)
for i in range(n):
qc.append(HGate(), [i])
for i in range(n):
qc.append(XGate(), [i])
qc.h(n-1)
qc.mct(list(range(n-1)), n-1)
qc.h(n-1)
for i in range(n):
qc.append(XGate(), [i])
for i in range(n):
qc.append(HGate(), [i])
return qc
''' |
QPC003_EX2 | AD9EE9692F48F | 1 | RE | 2267 ms | 157 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.y(0)
return qc
''' |
QPC003_EX2 | AD9EE9692F48F | 2 | AC | 2518 ms | 163 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import ZGate, GlobalPhaseGate
import numpy as np
import math
def psi(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
angle = math.acos(1/16)
qc.ry(2*math.acos(math.sqrt(1-math.cos(angle)*n)), 0)
split(qc, 0, n)
return qc
def split(qc, stIncl, edExcl):
if stIncl + 1 == edExcl:
return
mid = (stIncl + edExcl) // 2
left = mid - stIncl
right = edExcl - mid
angle = 2*math.atan(math.sqrt(right/left))
qc.cry(angle, stIncl, mid)
qc.cx(mid, stIncl)
split(qc, stIncl, mid)
split(qc, mid, edExcl)
return qc
def refl(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.append(GlobalPhaseGate(math.pi))
qc.x(range(n))
mcz = ZGate().control(n-1)
qc.append(mcz, list(range(n)))
qc.x(range(n))
return qc
def refl_psi(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.compose(psi(n).inverse(), inplace=True)
qc.compose(refl(n), inplace=True)
qc.compose(psi(n), inplace=True)
return qc
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(1)
qc = QuantumCircuit(x, y)
# Write your code here:
qc.x(y)
qc.h(y)
qc.compose(psi(n), x, inplace=True)
init_prob = math.sqrt(1/16)
init_angle = math.acos(init_prob)
target_prob = 0.9
repeat = 0
while True:
angle = (2*repeat+1) * init_angle
curr_prob = math.cos(angle)**2
print(f'{repeat=} {curr_prob=}')
if curr_prob > target_prob:
break
qc.compose(o, inplace=True)
qc.compose(psi(n).inverse(), inplace=True)
qc.compose(refl(n), inplace=True)
qc.compose(psi(n), inplace=True)
repeat += 1
qc.h(y)
qc.x(y)
return qc
''' |
QPC004_A1 | A00C73306AD07 | 1 | AC | 2104 ms | 162 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.x(0)
return qc
''' |
QPC004_A1 | A01648FFFDB21 | 1 | AC | 1785 ms | 162 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.x(0)
return qc
''' |
QPC004_A1 | A0196A070FEF8 | 1 | AC | 1706 ms | 162 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.x(0)
return qc
''' |
QPC004_A1 | A025B0682BA02 | 1 | AC | 1931 ms | 160 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.x(0)
return qc
''' |
QPC004_A1 | A0285E7EA6A24 | 1 | AC | 1709 ms | 160 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.x(0)
return qc
''' |
QPC004_A1 | A033ED9692939 | 1 | RE | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.x(₁)
return qc
''' | ||
QPC004_A1 | A033ED9692939 | 2 | RE | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.x(₀)
return qc
''' | ||
QPC004_A1 | A033ED9692939 | 3 | AC | 1752 ms | 161 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.x(0)
return qc
''' |
QPC004_A1 | A0382E8F23E87 | 1 | AC | 1857 ms | 162 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.x(0)
return qc
''' |
QPC004_A1 | A05E92625EF2F | 1 | AC | 1628 ms | 162 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from math import pi, acos, sqrt, asin
from qiskit.circuit.library import XGate, ZGate
"""
You can apply oracle as follows:
qc.compose(o, inplace=True)
"""
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.x(0)
return qc
''' |
QPC004_A1 | A064F7AC9CC7F | 1 | AC | 2102 ms | 160 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.x(0)
return qc
''' |
QPC004_A1 | A0AB4CB2203DC | 1 | AC | 2846 ms | 202 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
for _ in range(2*10**4+1):
qc.x(0)
return qc
# from qiskit import Aer, execute
# def simulate(qc: QuantumCircuit):
# simulator = Aer.get_backend("statevector_simulator")
# statevector = execute(qc, simulator).result().get_statevector(qc)
# print(statevector)
# if __name__ == "__main__":
# simulate(solve())
''' |
QPC004_A1 | A0CC2D9C0910B | 1 | AC | 2204 ms | 160 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.x(0)
return qc
''' |
QPC004_A1 | A0E5DE34010D7 | 1 | AC | 1775 ms | 160 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
qc.x(0)
return qc
''' |
QPC004_A1 | A0E9C5E28285D | 1 | AC | 1935 ms | 158 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.x(0)
return qc
''' |
QPC004_A1 | A11F82D38A336 | 1 | AC | 1705 ms | 160 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
qc.x(0)
return qc
''' |
QPC004_A1 | A129DACCBF2C2 | 1 | AC | 1895 ms | 162 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.x(0)
return qc
''' |
QPC004_A1 | A146806CA08F5 | 1 | AC | 1683 ms | 162 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.x(0)
return qc
''' |
QPC004_A1 | A1BBBFE1C0F13 | 1 | RE | 2648 ms | 157 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
c.x(0)
return qc
''' |
QPC004_A1 | A1BBBFE1C0F13 | 2 | AC | 2819 ms | 161 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.x(0)
return qc
''' |
QPC004_A1 | A1D7F23CB680F | 1 | AC | 1749 ms | 160 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.x(0)
return qc
''' |
QPC004_A1 | A1F591408DAC5 | 1 | AC | 1807 ms | 161 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.x(0)
return qc
''' |
QPC004_A1 | A2183BA6E7892 | 1 | AC | 1724 ms | 161 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
qc.x(0)
return qc
''' |
QPC004_A1 | A22DC59D8EF6D | 1 | AC | 1897 ms | 161 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.x(0)
return qc
''' |
QPC004_A1 | A23105CDE06A7 | 1 | AC | 1975 ms | 159 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.x(0)
return qc
''' |
QPC004_A1 | A2F43814ABD62 | 1 | AC | 1844 ms | 160 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.x(0)
return qc
''' |
QPC004_A1 | A32AD6898FA0D | 1 | AC | 1843 ms | 158 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.x(0)
return qc
''' |
QPC004_A1 | A33A19B2A837A | 1 | AC | 1595 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.x(0)
return qc
''' |
QPC004_A1 | A3CFB2E7A539D | 1 | AC | 2497 ms | 160 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.x(0)
return qc
''' |
QPC004_A1 | A3F5A331DBF10 | 1 | AC | 1718 ms | 161 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.x(0)
return qc
''' |
QPC004_A1 | A4102FFD7590A | 1 | AC | 2219 ms | 160 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.x(0)
return qc
''' |
QPC004_A1 | A44B62C717E5B | 1 | RE | 1595 ms | 158 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.x();
return qc
''' |
QPC004_A1 | A44B62C717E5B | 2 | AC | 1786 ms | 162 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.x(0);
return qc
''' |
QPC004_A1 | A4599A9AA67FC | 1 | AC | 1934 ms | 162 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.x(0)
return qc
''' |
QPC004_A1 | A48B2454A0DC7 | 1 | RE | 1776 ms | 157 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.g(0)
return qc
''' |
QPC004_A1 | A48B2454A0DC7 | 2 | WA | 1945 ms | 162 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.x(0)
qc.h(0)
return qc
''' |
QPC004_A1 | A48B2454A0DC7 | 3 | AC | 1698 ms | 160 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.x(0)
return qc
''' |
QPC004_A1 | A4AD1D5450403 | 1 | RE | 1650 ms | 156 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.x(1)
return qc
''' |
QPC004_A1 | A4AD1D5450403 | 2 | AC | 1661 ms | 161 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.x(0)
return qc
''' |
QPC004_A1 | A4B528455FF08 | 1 | WA | 2089 ms | 160 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
return qc
''' |
QPC004_A1 | A4B9ABD33113B | 1 | AC | 1916 ms | 160 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.x(0)
return qc
''' |
QPC004_A1 | A4C7EAAB11C5E | 1 | AC | 1906 ms | 158 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.x(0)
return qc
''' |
QPC004_A1 | A4EEE334225EF | 1 | AC | 1727 ms | 162 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.x(0)
return qc
''' |
QPC004_A1 | A4FF02C22EF2B | 1 | AC | 1738 ms | 159 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
# Create quantum circuit with 1 qubit
qc = QuantumCircuit(1)
# Apply X gate to flip from |0⟩ to |1⟩
qc.x(0)
return qc
''' |
QPC004_A1 | A50475A958D97 | 1 | AC | 1602 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
qc.x(0)
return qc
''' |
QPC004_A1 | A51A825C5A8FF | 1 | AC | 1849 ms | 159 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.x(0)
return qc
''' |
QPC004_A1 | A51B8E08A0A6F | 1 | WA | 1701 ms | 159 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
return qc
''' |
QPC004_A1 | A58213E246CBA | 1 | AC | 1884 ms | 159 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
qc.x(0)
return qc
''' |
QPC004_A1 | A5F8C835EDB4A | 1 | AC | 2451 ms | 160 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.x(0)
return qc
''' |
QPC004_A1 | A61AB1088077A | 1 | AC | 1792 ms | 160 MiB | '''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
qc = QuantumCircuit(1)
# Write your code here:
qc.x(0)
return qc
''' |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.