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_B4 | AF76A9C95D5A3 | 1 | RE | 1398 ms | 153 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for l in range(1, 2^n + 1):
for i in range(n):
if not ((l >> i) & 1):
qc.x(i)
if n == 1:
qc.z(0)
else:
qc.append(ZGate().control(n - 1), range(n))
for i in range(n):
if not ((l >> i) & 1):
qc.x(i)
return qc
''' |
QPC003_B4 | AF7EA234BF691 | 1 | WA | 1894 ms | 160 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
import math
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.rx(math.pi,0)
for i in range(n-1):
qc.x(i)
qc.append(ZGate().control(n-1),qargs = range(n))
for i in range(n):
qc.x(i)
return qc
''' |
QPC003_B4 | AF7EA234BF691 | 2 | AC | 2087 ms | 161 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
import math
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.rx(2*math.pi,0)
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)
return qc
''' |
QPC003_B4 | AF8A4CE86BE23 | 1 | RE | 1360 ms | 153 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import PhaseGate, XGate, YGate, ZGate
from math import sqrt, acos, pi
def solve(n: int, T) -> QuantumCircuit:
qc = QuantumCircuit(n)
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)
return qc
''' |
QPC003_B4 | AF8A4CE86BE23 | 2 | AC | 1706 ms | 158 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import PhaseGate, XGate, YGate, ZGate
from math import sqrt, acos, pi
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
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)
return qc
''' |
QPC003_B5 | A09513C6B2308 | 1 | RE | 1435 ms | 153 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
def b4(qc: QuantumCircuit) -> None:
for i in range(n):
qc.x(i)
mcz = ZGate().control(n - 1)
qc.append(mcz, range(n))
for i in range(n):
qc.x(i)
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.h(i)
b4(qc)
for i in range(n):
qc.h(i)
return qc
''' |
QPC003_B5 | A09513C6B2308 | 2 | RE | 1200 ms | 154 MiB | '''python
def b4(qc: QuantumCircuit) -> None:
n = qc.num_qubits
for i in range(n):
qc.x(i)
mcz = ZGate().control(n - 1)
qc.append(mcz, range(n))
for i in range(n):
qc.x(i)
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.h(i)
b4(qc)
for i in range(n):
qc.h(i)
return qc
''' |
QPC003_B5 | A09513C6B2308 | 3 | AC | 1494 ms | 158 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
def b4(qc: QuantumCircuit) -> None:
n = qc.num_qubits
for i in range(n):
qc.x(i)
mcz = ZGate().control(n - 1)
qc.append(mcz, range(n))
for i in range(n):
qc.x(i)
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.h(i)
b4(qc)
for i in range(n):
qc.h(i)
return qc
''' |
QPC003_B5 | A0ACB2E3C5B85 | 1 | AC | 2058 ms | 155 MiB | '''python
from qiskit import QuantumCircuit
import numpy as np
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
theta = np.pi
controls = list(range(n-1))
target = n-1
qc.h(range(n))
for i in range(n):
qc.x(i)
qc.mcp(theta, controls, target)
for i in range(n):
qc.x(i)
qc.h(range(n))
return qc
''' |
QPC003_B5 | A0C69922D9FEF | 1 | WA | 2139 ms | 162 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Step 1: Apply Hadamard gates to create |ψ⟩
for i in range(n):
qc.h(i)
# Step 2: Apply the Grover diffusion operator (2|ψ⟩⟨ψ| - I)
# Apply Hadamard again
for i in range(n):
qc.h(i)
# Apply X gates
for i in range(n):
qc.x(i)
# Multi-controlled Z gate
qc.h(n-1)
qc.mcx(list(range(n-1)), n-1)
qc.h(n-1)
# Apply X gates again
for i in range(n):
qc.x(i)
# Apply Hadamard again
for i in range(n):
qc.h(i)
return qc
''' |
QPC003_B5 | A0E1BF54759FC | 1 | AC | 1642 ms | 155 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
qc.h(i)
for i in range(n):
qc.x(i)
qc.h(n - 1)
if n == 2:
qc.cx(0, 1)
else:
qc.mcx(list(range(n - 1)), n - 1)
qc.h(n - 1)
for i in range(n):
qc.x(i)
for i in range(n):
qc.h(i)
return qc
''' |
QPC003_B5 | A1C1751C3A0B6 | 1 | RE | 1536 ms | 153 MiB | '''python
from qiskit import QuantumCircuit
def reflect(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.x(range(n))
qc.append(ZGate().control(n - 1), range(n))
qc.x(range(n))
return qc
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.h(range(n))
qc.composer(reflect(n), inplace = True)
qc.h(range(n))
return qc
''' |
QPC003_B5 | A1C1751C3A0B6 | 2 | RE | 1599 ms | 153 MiB | '''python
from qiskit import QuantumCircuit
def reflect(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.x(range(n))
qc.append(ZGate().control(n - 1), range(n))
qc.x(range(n))
return qc
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.h(range(n))
qc.compose(reflect(n), inplace=True)
qc.h(range(n))
return qc
''' |
QPC003_B5 | A1C1751C3A0B6 | 3 | UME | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.libary import ZGate
def reflect(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.x(range(n))
qc.append(ZGate().control(n - 1), range(n))
qc.x(range(n))
return qc
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.h(range(n))
qc.compose(reflect(n), inplace=True)
qc.h(range(n))
return qc
''' | ||
QPC003_B5 | A1C1751C3A0B6 | 4 | AC | 1908 ms | 158 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
def reflect(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
qc.x(range(n))
qc.append(ZGate().control(n - 1), range(n))
qc.x(range(n))
return qc
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
qc.h(range(n))
qc.compose(reflect(n), inplace=True)
qc.h(range(n))
return qc
''' |
QPC003_B5 | A226714A0484C | 1 | AC | 1776 ms | 155 MiB | '''python
from qiskit import QuantumCircuit
import numpy as np
from qiskit.circuit.library.standard_gates import ZGate, HGate
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
qc.h(i)
abc = [0] * n
for i in range(n):
abc[i]=i
for i in range(n):
qc.x(i)
qc1 = QuantumCircuit(1)
qc1.z(0)
custom = qc1.to_gate().control(n-1)
qc.ry(np.pi*2,n-1)
qc.append(custom, abc)
for i in range(n):
qc.x(i)
for i in range(n):
qc.h(i)
return qc
''' |
QPC003_B5 | A2693F66A5BFE | 1 | AC | 3000 ms | 163 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
def reflect(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
qc.x(range(n))
qc.append(ZGate().control(n - 1), range(n))
qc.x(range(n))
return qc
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
qc.h(range(n))
qc.compose(reflect(n), inplace=True)
qc.h(range(n))
return qc
''' |
QPC003_B5 | A35F592113D7E | 1 | UME | '''python
from qiskit import QuantumCircuit, Aer, transpile, assemble, execute
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
qc.h(range(n))
qc.x(range(n))
qc.h(0)
qc.mcx(list(range(1, n)), 0)
qc.h(0)
qc.x(range(n))
return qc
if __name__ == "__main__":
n = 2
qc = solve(n)
print(qc.draw())
''' | ||
QPC003_B5 | A35F592113D7E | 2 | WA | 1274 ms | 155 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library.standard_gates import HGate, CXGate
import numpy as np
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for qubit in range(n):
qc.h(qubit)
qc.x(range(n))
for qubit in range(n-1):
qc.cx(qubit, n-1)
qc.x(range(n))
return qc
''' |
QPC003_B5 | A383B33647F39 | 1 | AC | 1583 ms | 155 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
# Paso 1: Aplicar puertas Hadamard a todos los qubits para crear la superposición uniforme
qc.h(range(n))
# Paso 2: Aplicar puertas X a todos los qubits
qc.x(range(n))
# Paso 3: Aplicar una puerta Z multi-controlada
# Esto se logra mediante:
# a. Aplicar una puerta Hadamard al último qubit
qc.h(n-1)
# b. Aplicar una puerta MCX (multi-controlled X) con los n-1 primeros qubits como controles y el último como objetivo
controls = list(range(n-1))
target = n-1
qc.mcx(controls, target)
# c. Aplicar nuevamente una puerta Hadamard al último qubit
qc.h(n-1)
# Paso 4: Aplicar nuevamente puertas X a todos los qubits para revertir la transformación
qc.x(range(n))
# Paso 5: Aplicar puertas Hadamard a todos los qubits nuevamente para volver a la base computacional
qc.h(range(n))
return qc
''' |
QPC003_B5 | A53FADA138B98 | 1 | WA | 1428 ms | 155 MiB | '''python
from math import pi
from qiskit import QuantumCircuit
from qiskit.circuit.library import MCPhaseGate
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.h(0)
mc_z_gate = MCPhaseGate(pi, num_ctrl_qubits=n - 1)
for i in range(n):
qc.x(i)
qc.append(mc_z_gate, [i for i in range(n)])
for i in range(n):
qc.x(i)
qc.h(0)
return qc
''' |
QPC003_B5 | A53FADA138B98 | 2 | WA | 1353 ms | 155 MiB | '''python
from math import pi
from qiskit import QuantumCircuit
from qiskit.circuit.library import MCPhaseGate
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
mc_z_gate = MCPhaseGate(pi, num_ctrl_qubits=n - 1)
for i in range(n):
qc.h(0)
qc.x(i)
qc.append(mc_z_gate, [i for i in range(n)])
for i in range(n):
qc.h(0)
qc.x(i)
return qc
''' |
QPC003_B5 | A53FADA138B98 | 3 | AC | 1650 ms | 155 MiB | '''python
from math import pi
from qiskit import QuantumCircuit
from qiskit.circuit.library import MCPhaseGate
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
mc_z_gate = MCPhaseGate(pi, num_ctrl_qubits=n - 1)
for i in range(n):
qc.h(i)
qc.x(i)
qc.append(mc_z_gate, [i for i in range(n)])
for i in range(n):
qc.x(i)
qc.h(i)
return qc
''' |
QPC003_B5 | A57D39479B097 | 1 | AC | 1764 ms | 156 MiB | '''python
from qiskit import QuantumCircuit
def b4(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
qc.z(0)
for i in range(1, n):
qc.x(range(i))
qc.h(i)
qc.mcx(list(range(i)), i, mode='noancilla')
qc.h(i)
qc.x(range(i))
return qc
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
qc.h(range(n))
qc.compose(b4(n), inplace=True)
qc.h(range(n))
return qc
''' |
QPC003_B5 | A5C9A42FA480C | 1 | AC | 1977 ms | 155 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
qc.h(range(n))
qc.x(range(n))
qc.h(0)
qc.mcx(list(range(1, n)), 0)
qc.h(0)
qc.x(range(n))
qc.h(range(n))
return qc
''' |
QPC003_B5 | A6699B2D619E8 | 1 | AC | 1623 ms | 159 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import ZGate, GlobalPhaseGate
import numpy as np
import math
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.append(GlobalPhaseGate(math.pi))
qc.h(range(n))
qc.x(range(n))
mcz = ZGate().control(n-1)
qc.append(mcz, list(range(n)))
qc.x(range(n))
qc.h(range(n))
return qc
''' |
QPC003_B5 | A6F200D480BFD | 1 | WA | 1276 ms | 156 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
# n量子ビットの回路を作成
for i in range(n):
qc.h(i)
qc.append(ZGate().control(n-1), range(n))
for i in range(n):
qc.h(i)
return qc
''' |
QPC003_B5 | A6F200D480BFD | 2 | WA | 1451 ms | 156 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
# n量子ビットの回路を作成
qc.append(ZGate().control(n-1), range(n))
return qc
''' |
QPC003_B5 | A6F200D480BFD | 3 | AC | 1621 ms | 156 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import PhaseGate
import math
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
L = 0
for i in range(n):
qc.h(i)
for i in range(n):
if not (L >> i) & 1:
qc.x(i)
if n == 1:
qc.append(PhaseGate(math.pi), [0])
else:
qc.append(PhaseGate(math.pi).control(n - 1), range(n))
for i in range(n):
if not (L >> i) & 1:
qc.x(i)
for i in range(n):
qc.h(i)
return qc
''' |
QPC003_B5 | A7AD6F7DC2D4F | 1 | AC | 1821 ms | 155 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
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_B5 | A7F87DD7F8F5E | 1 | RE | 1637 ms | 156 MiB | '''python
from qiskit import QuantumCircuit
def diffusion_oracle(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
qc.h(i)
qc.x(i)
qc.append(ZGate().control(n - 1), range(n))
for i in range(n):
qc.x(i)
qc.h(i)
return qc
def solve(n: int) -> QuantumCircuit:
return diffusion_oracle(n)
''' |
QPC003_B5 | A7F87DD7F8F5E | 2 | AC | 1983 ms | 160 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
def diffusion_oracle(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
qc.h(i)
qc.x(i)
qc.append(ZGate().control(n - 1), range(n))
for i in range(n):
qc.x(i)
qc.h(i)
return qc
def solve(n: int) -> QuantumCircuit:
return diffusion_oracle(n)
''' |
QPC003_B5 | A808C0D60B07F | 1 | AC | 1750 ms | 156 MiB | '''python
from qiskit import QuantumCircuit
import numpy as np
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.h(range(n))
qc.rz(2*np.pi, n-1)
qc.x(list(range(n)))
qc.mcp(np.pi, list(range(n-1)), n-1)
qc.x(list(range(n)))
qc.h(range(n))
return qc
''' |
QPC003_B5 | A92A50CEE1FD1 | 1 | AC | 1688 ms | 156 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.h(i)
for i in range(n):
qc.x(i)
qc.h(0)
qc.mcx(control_qubits=list(range(1,n)), target_qubit=0)
qc.h(0)
for i in range(n):
qc.x(i)
for i in range(n):
qc.h(i)
return qc
''' |
QPC003_B5 | A9734A1CD4BE5 | 1 | AC | 1644 ms | 155 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import PhaseGate, XGate, YGate, ZGate
from math import sqrt, acos, pi
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
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_B5 | A9A09566DCA8C | 1 | WA | 1723 ms | 160 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Step 1: Prepare the state |ψ⟩ = (1/sqrt(2^n)) * (|0⟩ + |1⟩ + ... + |(2^n-1)⟩)
# This is done by applying Hadamard gates to all qubits
for qubit in range(n):
qc.h(qubit)
# Step 2: Apply the operator A = 2 |ψ⟩⟨ψ| - I
# We can implement |ψ⟩⟨ψ| using a series of controlled operations.
# Create a controlled operation that flips the sign of the state |ψ⟩
# This can be done by applying a series of CNOT gates based on the state |ψ⟩
# The state |ψ⟩ is the equal superposition, so we can use the fact that
# we want to apply a negative sign to the |ψ⟩ state.
# The matrix A can be implemented as follows:
# 1. Apply a Hadamard to create |ψ⟩
# 2. Apply a series of CNOTs to create the effect of |ψ⟩⟨ψ| and then adjust for the identity.
# The effect of 2|ψ⟩⟨ψ| can be achieved by applying a phase flip to the |ψ⟩ state.
# We can use a multi-controlled Z gate to achieve this.
# Apply a controlled-Z gate with all qubits as controls to flip the sign of |ψ⟩
# This is equivalent to applying a phase of -1 to the |ψ⟩ state.
qc.h(range(n)) # Apply Hadamard to all qubits to create |ψ⟩
qc.z(range(n)) # Apply Z gate to all qubits to flip the sign of |ψ⟩
qc.h(range(n)) # Apply Hadamard again to return to the computational basis
# Step 3: The identity operation is already accounted for in the circuit.
return qc
''' |
QPC003_B5 | AA0445310DDB5 | 1 | AC | 1889 ms | 155 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library.standard_gates import GlobalPhaseGate
import math
# from qiskit.quantum_info import Statevector
def solve(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.h(0)
qc.mcx(list(range(1, n)), 0)
qc.h(0)
for i in range(n):
qc.x(i)
qc.append(GlobalPhaseGate(math.pi))
for i in range(n):
qc.h(i)
return qc
# if __name__ == "__main__":
# qc = solve(3)
# print(Statevector(qc))
''' |
QPC003_B5 | AA14E0F874826 | 1 | AC | 1744 ms | 155 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
#Gloverのゲートが出ることは対策済み
for i in range(n):#重ね合わせ状態を作る
qc.h(i)
for j in range(n):#反転じゃい
qc.x(j)
# 欲しい状態だけz gateで反転
qc.h(n - 1)
qc.mcx(list(range(n - 1)), n - 1)
qc.h(n - 1)
for k in range(n):#反転して戻しちゃえ
qc.x(k)
for l in range(n):#Hadamrd反転じゃい
qc.h(l)
return qc
''' |
QPC003_B5 | AA737B6C0A0B1 | 1 | AC | 1762 ms | 155 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,
# )
"""
You can apply oracle as follows:
qc.compose(o, inplace=True)
"""
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.h(range(n))
qc.x(range(n))
qc.mcp(pi, list(range(n - 1)), n - 1)
qc.x(range(n))
qc.h(range(n))
return qc
''' |
QPC003_B5 | ABB8B1C4963C2 | 1 | RE | 1370 ms | 154 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
lists=[]
for i in range(n):
qc.h(i)
for i in range(n):
qc.x(i)
for i in range(n-1):
lists.append(i)
qc.mcz(lists,n-1)
for i in range(n):
qc.x(i)
for i in range(n):
qc.h(i)
return qc
''' |
QPC003_B5 | ABB8B1C4963C2 | 2 | RE | 1626 ms | 154 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
lists=[]
for i in range(n):
qc.h(i)
for i in range(n):
qc.x(i)
for i in range(n-1):
lists.append(i)
qc.mct(lists,n-1)
for i in range(n):
qc.x(i)
for i in range(n):
qc.h(i)
return qc
''' |
QPC003_B5 | ABB8B1C4963C2 | 3 | RE | 1180 ms | 154 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
lists=[]
for i in range(n):
qc.h(i)
for i in range(n):
qc.x(i)
for i in range(n-1):
lists.append(i)
qc.mct(lists,n-1)
for i in range(n):
qc.x(i)
for i in range(n):
qc.h(i)
return qc
''' |
QPC003_B5 | ABB8B1C4963C2 | 4 | WA | 1627 ms | 155 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
lists=[]
for i in range(n):
qc.h(i)
for i in range(n):
qc.x(i)
for i in range(n-1):
lists.append(i)
qc.cz(0,1)
for i in range(n):
qc.x(i)
for i in range(n):
qc.h(i)
return qc
''' |
QPC003_B5 | ABB8B1C4963C2 | 5 | WA | 1304 ms | 155 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
lists=[]
for i in range(n):
qc.h(i)
for i in range(n):
qc.x(i)
for i in range(n-1):
lists.append(i)
for i in range (1,n):
qc.cz(0,i)
for i in range(n):
qc.x(i)
for i in range(n):
qc.h(i)
return qc
''' |
QPC003_B5 | ACFA849B6BD35 | 1 | AC | 2589 ms | 160 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
import math
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# 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),qargs = range(n))
for i in range(n):
qc.x(i)
for i in range(n):
qc.h(i)
return qc
''' |
QPC003_B5 | AD1F0130A3320 | 1 | AC | 1719 ms | 156 MiB | '''python
from qiskit import QuantumCircuit
from math import pi
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qubits = list(range(n))
qc.h(qubits)
qc.x(qubits)
qc.mcp(pi, qubits[1:], 0)
qc.x(qubits)
qc.h(qubits)
return qc
''' |
QPC003_B5 | ADBED0D502ADD | 1 | AC | 1788 ms | 155 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
qc.h(i)
for i in range(n):
qc.x(i)
qc.mcp(math.pi, list(range(n-1)), n-1)
for i in range(n):
qc.x(i)
for i in range(n):
qc.h(i)
return qc
''' |
QPC003_B5 | ADE8B8971BAB7 | 1 | AC | 1721 ms | 159 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from math import pi, acos, sqrt
from qiskit.circuit.library import ZGate
"""
You can apply oracle as follows:
qc.compose(o, inplace=True)
"""
def solve1(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.x(i)
qc.append(ZGate().control(n-1), range(n))
for i in range(n):
qc.x(i)
return qc
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
qc.h(i)
qc.compose(solve1(n), inplace=True)
for i in range(n):
qc.h(i)
return qc
''' |
QPC003_B5 | AE1FCB04A20FB | 1 | AC | 1642 ms | 155 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.h(i)
for i in range(n):
qc.x(i)
qc.h(n-1)
qc.mcx(list(range(n-1)), n-1)
qc.h(n-1)
for i in range(n):
qc.x(i)
for i in range(n):
qc.h(i)
return qc
''' |
QPC003_B5 | AE7EDCACF1369 | 1 | RE | 1528 ms | 154 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.h(i)
for i in range(n):
qc.x(i)
qc.mcz(list(range(n-1)),n-1)
for i in range(n):
qc.x(i)
for i in range(n):
qc.h(i)
return qc
''' |
QPC003_B5 | AE7EDCACF1369 | 2 | AC | 1701 ms | 156 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.h(i)
for i in range(n):
qc.x(i)
qc.mcp(math.pi,list(range(n-1)),n-1)
for i in range(n):
qc.x(i)
for i in range(n):
qc.h(i)
return qc
''' |
QPC003_B6 | A0B3005D03988 | 1 | AC | 1592 ms | 156 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library.standard_gates import GlobalPhaseGate
import math
"""
You can apply oracle as follows:
qc.compose(o, inplace=True)
"""
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.h(0)
qc.mcx(list(range(1, n)), 0)
qc.h(0)
for i in range(n):
qc.x(i)
qc.append(GlobalPhaseGate(math.pi))
for i in range(n):
qc.h(i)
return qc
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.h(i)
qc.compose(o, inplace=True)
qc.compose(b5(n), inplace=True)
return qc
''' |
QPC003_B6 | A1F798132E269 | 1 | RE | 1684 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:
qc = QuantumCircuit(n)
# Write your code here:
qc.h(range(n))
qc.barrier()
qc.compose(o, inplace=True)
qc.barrier()
qc.append(QFT(n), range(n))
qc.barrier()
return qc
''' |
QPC003_B6 | A1F798132E269 | 2 | UME | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import QFT
"""
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:
qc.h(range(n))
qc.barrier()
qc.compose(o, inplace=True)
qc.barrier()
qc.append(QFT(n), range(n))
qc.barrier()
return qc
''' | ||
QPC003_B6 | A1F798132E269 | 3 | WA | 1292 ms | 155 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library.standard_gates import HGate, CXGate
"""
You can apply oracle as follows:
qc.compose(o, inplace=True)
"""
def qft(n):
qc = QuantumCircuit(n)
for i in range(n):
qc.append(HGate(), [i])
for j in range(i+1, n):
qc.append(CXGate(), [i, j])
return qc
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
qc = QuantumCircuit(n)
qc.h(range(n))
qc.barrier()
qc.compose(o, inplace=True)
qc.barrier()
qc.compose(qft(n), inplace=True)
qc.barrier()
return qc
''' |
QPC003_B6 | A1F798132E269 | 4 | UME | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library.standard_gates import HGate, CPiGate
def qft(n):
qc = QuantumCircuit(n)
for i in range(n):
qc.append(HGate(), [i])
for j in range(i+1, n):
qc.append(CPiGate(2**(j-i)), [i, j])
return qc
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
qc = QuantumCircuit(n)
qc.h(range(n))
qc.barrier()
qc.compose(o, inplace=True)
qc.barrier()
qc.compose(qft(n), inplace=True)
qc.barrier()
return qc
''' | ||
QPC003_B6 | A1F798132E269 | 5 | UME | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library.standard_gates import HGate, CPiGate
import math
def qft(n):
qc = QuantumCircuit(n) # Define the qc variable here
for i in reversed(range(n)):
qc.h(i)
for j in reversed(range(i)):
qc.cp(math.pi / 2 ** (i - j), j, i)
for i in range(n // 2):
qc.swap(i, n - i - 1)
return qc
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
qc = QuantumCircuit(n)
qc.h(range(n))
qc.barrier()
qc.compose(o, inplace=True)
qc.barrier()
qc.compose(qft(n), inplace=True)
qc.barrier()
return qc
''' | ||
QPC003_B6 | A2B4AB1926478 | 1 | RE | 1776 ms | 157 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)
# Step 1: Prepare uniform superposition
for qubit in range(n):
qc.h(qubit) # Apply Hadamard to each qubit
# Step 2: Apply the oracle
qc.compose(o, inplace=True)
# Step 3: Apply the diffusion operator
# Apply Hadamard to all qubits
for qubit in range(n):
qc.h(qubit)
# Apply X gates to all qubits
for qubit in range(n):
qc.x(qubit)
# Apply controlled-Z (CZ) gate
qc.h(n-1) # Apply Hadamard to the last qubit
qc.mct(list(range(n-1)), n-1) # Multi-controlled Toffoli (n-1 controls)
qc.h(n-1) # Apply Hadamard to the last qubit again
# Apply X gates to all qubits again
for qubit in range(n):
qc.x(qubit)
# Apply Hadamard to all qubits again
for qubit in range(n):
qc.h(qubit)
return qc
''' |
QPC003_B6 | A2B4AB1926478 | 2 | WA | 1940 ms | 160 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
qc.compose(o, inplace=True)
# Apply Hadamard gates again to all qubits
for qubit in range(n):
qc.h(qubit)
return qc
''' |
QPC003_B6 | A3BB9350E11B1 | 1 | AC | 1622 ms | 155 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:
qc.h(range(n))
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_B6 | A4DBF7CEDB28C | 1 | RE | 1346 ms | 154 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:
qc.h(range(n))
num_iterations = int(np.floor(np.pi / 4 * np.sqrt(2**n)))
for _ in range(num_iterations):
qc.compose(o, inplace=True)
qc.h(range(n))
qc.x(range(n))
qc.h(range(n))
for qubit in range(n):
qc.cz(0, qubit)
qc.h(range(n))
qc.x(range(n))
qc.h(range(n))
for qubit in range(n):
if (target >> qubit) & 1:
qc.x(qubit)
return qc
''' |
QPC003_B6 | A564674417D49 | 1 | AC | 1600 ms | 157 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import ZGate, GlobalPhaseGate
import numpy as np
import math
"""
You can apply oracle as follows:
qc.compose(o, inplace=True)
"""
def refl(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.append(GlobalPhaseGate(math.pi))
qc.h(range(n))
qc.x(range(n))
mcz = ZGate().control(n-1)
qc.append(mcz, list(range(n)))
qc.x(range(n))
qc.h(range(n))
return qc
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.h(range(n))
qc.compose(o, inplace=True)
qc.compose(refl(n), inplace=True)
return qc
''' |
QPC003_B6 | A5A2A3E1164CE | 1 | WA | 1220 ms | 155 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 j in range(5):
qc.compose(o, inplace=True)
for i in range(n):
qc.h(i)
for i in range(n):
qc.x(i)
qc.h(n-1)
array = list(range(n -1))
qc.mcx(array, n-1)
qc.h(n-1)
for i in range(n):
qc.x(i)
for i in range(n):
qc.h(i)
return qc
''' |
QPC003_B6 | A5A2A3E1164CE | 2 | WA | 1220 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:
qc = QuantumCircuit(n)
# Write your code here:
for j in range(10):
qc.compose(o, inplace=True)
for i in range(n):
qc.h(i)
for i in range(n):
qc.x(i)
qc.h(n-1)
array = list(range(n -1))
qc.mcx(array, n-1)
qc.h(n-1)
for i in range(n):
qc.x(i)
for i in range(n):
qc.h(i)
return qc
''' |
QPC003_B6 | A5A2A3E1164CE | 3 | WA | 1340 ms | 157 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 j in range(20):
qc.compose(o, inplace=True)
for i in range(n):
qc.h(i)
for i in range(n):
qc.x(i)
qc.h(n-1)
array = list(range(n -1))
qc.mcx(array, n-1)
qc.h(n-1)
for i in range(n):
qc.x(i)
for i in range(n):
qc.h(i)
return qc
''' |
QPC003_B6 | A5A2A3E1164CE | 4 | WA | 1360 ms | 158 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 j in range(100):
qc.compose(o, inplace=True)
for i in range(n):
qc.h(i)
for i in range(n):
qc.x(i)
qc.h(n-1)
array = list(range(n -1))
qc.mcx(array, n-1)
qc.h(n-1)
for i in range(n):
qc.x(i)
for i in range(n):
qc.h(i)
return qc
''' |
QPC003_B6 | A5A2A3E1164CE | 5 | TLE | 3000 ms | 165 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 j in range(10000):
qc.compose(o, inplace=True)
for i in range(n):
qc.h(i)
for i in range(n):
qc.x(i)
qc.h(n-1)
array = list(range(n -1))
qc.mcx(array, n-1)
qc.h(n-1)
for i in range(n):
qc.x(i)
for i in range(n):
qc.h(i)
return qc
''' |
QPC003_B6 | A5E4EB4074999 | 1 | RE | 1510 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:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.h(i)
qc.compose(o, inplace=True)
for i in range(n):
qc.h(i)
for i in range(n):
qc.x(i)
qc.mcp(math.pi,list(range(n-1)),n-1)
for i in range(n):
qc.x(i)
for i in range(n):
qc.h(i)
return qc
''' |
QPC003_B6 | A5E4EB4074999 | 2 | AC | 1558 ms | 155 MiB | '''python
from qiskit import QuantumCircuit
import math
"""
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)
qc.compose(o, inplace=True)
for i in range(n):
qc.h(i)
for i in range(n):
qc.x(i)
qc.mcp(math.pi,list(range(n-1)),n-1)
for i in range(n):
qc.x(i)
for i in range(n):
qc.h(i)
return qc
''' |
QPC003_B6 | A6088A7EE11F6 | 1 | AC | 1979 ms | 157 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate, HGate
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.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_B6 | A6397EEC0C500 | 1 | WA | 1256 ms | 155 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 preparation(targets: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(len(targets))
qc.h(targets)
return qc
def reflection(qc, targets: list[int]):
o = preparation(targets)
qc.compose(o.inverse(), inplace=True)
qc.x(targets)
qc.mcp(pi, targets[:-1], targets[-1])
qc.x(targets)
qc.compose(o, inplace=True)
"""
You can apply oracle as follows:
qc.compose(o, inplace=True)
"""
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
prep = preparation(list(range(n)))
oracle = o
qc = QuantumCircuit(n)
qc.compose(prep, inplace=True)
qc.compose(oracle, inplace=True)
qc.compose(prep, inplace=True)
return qc
''' |
QPC003_B6 | A6397EEC0C500 | 2 | AC | 1621 ms | 155 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 preparation(targets: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(len(targets))
qc.h(targets)
return qc
def reflection(qc, targets: list[int]):
o = preparation(targets)
qc.compose(o.inverse(), inplace=True)
qc.x(targets)
qc.mcp(pi, targets[:-1], targets[-1])
qc.x(targets)
qc.compose(o, inplace=True)
"""
You can apply oracle as follows:
qc.compose(o, inplace=True)
"""
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
prep = preparation(list(range(n)))
oracle = o
qc = QuantumCircuit(n)
qc.compose(prep, inplace=True)
qc.compose(oracle, inplace=True)
reflection(qc, list(range(n)))
return qc
''' |
QPC003_B6 | A64D28FBD05AF | 1 | RE | 1673 ms | 156 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
"""
You can apply oracle as follows:
qc.compose(o, inplace=True)
"""
def diffusion_oracle(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
qc.h(i)
qc.x(i)
qc.append(ZGate().control(n - 1), range(n))
for i in range(n):
qc.x(i)
qc.h(i)
return qc
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.h(i)
for _ in range(3):
qc.compose(o, inplace=True)
qc.compose(diffusion_oracle(), inplace=True)
return qc
''' |
QPC003_B6 | A64D28FBD05AF | 2 | WA | 1781 ms | 160 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
"""
You can apply oracle as follows:
qc.compose(o, inplace=True)
"""
def diffusion_oracle(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
qc.h(i)
qc.x(i)
qc.append(ZGate().control(n - 1), range(n))
for i in range(n):
qc.x(i)
qc.h(i)
return qc
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.h(i)
for _ in range(3):
qc.compose(o, inplace=True)
qc.compose(diffusion_oracle(n), inplace=True)
return qc
''' |
QPC003_B6 | A64D28FBD05AF | 3 | AC | 2064 ms | 161 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
"""
You can apply oracle as follows:
qc.compose(o, inplace=True)
"""
def diffusion_oracle(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
qc.h(i)
qc.x(i)
qc.append(ZGate().control(n - 1), range(n))
for i in range(n):
qc.x(i)
qc.h(i)
return qc
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.h(i)
for _ in range(10):
qc.compose(o, inplace=True)
qc.compose(diffusion_oracle(n), inplace=True)
return qc
''' |
QPC003_B6 | A673AC1225EFE | 1 | AC | 1714 ms | 155 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)
for i in range(n):
qc.h(i)
qc.compose(o, inplace=True)
for i in range(n):
qc.h(i)
for i in range(n):
qc.x(i)
if n == 1:
qc.z(0)
elif n == 2:
qc.h(n - 1)
qc.cx(0, 1)
qc.h(n - 1)
else:
qc.h(n - 1)
qc.mcx(list(range(n - 1)), n - 1)
qc.h(n - 1)
for i in range(n):
qc.x(i)
for i in range(n):
qc.h(i)
return qc
''' |
QPC003_B6 | A7D9AE7DE96BC | 1 | AC | 2568 ms | 163 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import ZGate, GlobalPhaseGate
import numpy as np
import math
"""
You can apply oracle as follows:
qc.compose(o, inplace=True)
"""
def refl(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.append(GlobalPhaseGate(math.pi))
qc.h(range(n))
qc.x(range(n))
mcz = ZGate().control(n-1)
qc.append(mcz, list(range(n)))
qc.x(range(n))
qc.h(range(n))
return qc
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.h(range(n))
qc.compose(o, inplace=True)
qc.compose(refl(n), inplace=True)
return qc
''' |
QPC003_B6 | A81729EF568E5 | 1 | AC | 1844 ms | 158 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from math import pi, acos, sqrt
from qiskit.circuit.library import ZGate
"""
You can apply oracle as follows:
qc.compose(o, inplace=True)
"""
def solve1(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.x(i)
qc.append(ZGate().control(n-1), range(n))
for i in range(n):
qc.x(i)
return qc
def solve2(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
qc.h(i)
qc.compose(solve1(n), inplace=True)
for i in range(n):
qc.h(i)
return qc
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.h(i)
qc.compose(o, inplace=True)
qc.compose(solve2(n), inplace=True)
return qc
''' |
QPC003_B6 | A88FC06F93189 | 1 | AC | 1647 ms | 159 MiB | '''python
from qiskit import QuantumCircuit
import math
"""
You can apply oracle as follows:
qc.compose(o, inplace=True)
"""
def diffuser(n):
qc = QuantumCircuit(n)
for i in range(n):
qc.h(i)
for i in range(n):
qc.x(i)
qc.h(n-1)
qc.mcx(list(range(n-1)), n-1)
qc.h(n-1)
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:
qc = QuantumCircuit(n)
# Write your code here:
niter = math.floor(math.pi/4 * math.sqrt(2**n))
diff = diffuser(n)
for i in range(n):
qc.h(i)
for i in range(niter):
qc.compose(o, inplace=True)
qc.compose(diff, inplace=True)
return qc
''' |
QPC003_B6 | A8A9D79592E9D | 1 | WA | 1441 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:
qc = QuantumCircuit(n)
for i in range(n):
qc.h(i)
qc.compose(o, inplace=True)
for i in range(n):
qc.h(i)
qc.x(i)
qc.compose(o,inplace=True)
for i in range(n):
qc.x(i)
qc.h(i)
return qc
''' |
QPC003_B6 | A8A9D79592E9D | 2 | WA | 1354 ms | 155 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)
for i in range(n):
qc.h(i)
qc.compose(o, inplace=True)
for i in range(n):
qc.h(i)
qc.x(i)
qc.compose(o,inplace=True)
for i in range(n):
qc.x(i)
qc.h(i)
qc.compose(o,inplace=True)
for i in range(n):
qc.x(i)
qc.h(i)
qc.compose(o,inplace=True)
for i in range(n):
qc.x(i)
qc.h(i)
qc.compose(o,inplace=True)
for i in range(n):
qc.x(i)
qc.h(i)
return qc
''' |
QPC003_B6 | A8A9D79592E9D | 3 | WA | 1408 ms | 155 MiB | '''python
from qiskit import QuantumCircuit
import math
"""
You can apply oracle as follows:
qc.compose(o, inplace=True)
"""
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
qc = QuantumCircuit(n)
# init H
for i in range(n):
qc.h(i)
for _ in range(math.floor(math.pi/4*math.sqrt(2**n))):
qc.compose(o, inplace=True)
for i in range(n):
qc.h(i)
qc.x(i)
qc.compose(o,inplace=True)
for i in range(n):
qc.x(i)
qc.h(i)
return qc
''' |
QPC003_B6 | A8A9D79592E9D | 4 | WA | 1260 ms | 155 MiB | '''python
from qiskit import QuantumCircuit
import math
"""
You can apply oracle as follows:
qc.compose(o, inplace=True)
"""
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
qc = QuantumCircuit(n)
# init H
for i in range(n):
qc.h(i)
for _ in range(9):
qc.compose(o, inplace=True)
for i in range(n):
qc.h(i)
qc.x(i)
qc.compose(o,inplace=True)
for i in range(n):
qc.x(i)
qc.h(i)
return qc
''' |
QPC003_B6 | A8A9D79592E9D | 5 | WA | 1225 ms | 155 MiB | '''python
from qiskit import QuantumCircuit # type: ignore
import math
"""
You can apply oracle as follows:
qc.compose(o, inplace=True)
"""
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
qc = QuantumCircuit(n)
# init H
for i in range(n):
qc.h(i)
for _ in range(math.floor(math.pi/4*math.sqrt(2**n))):
qc.compose(o, inplace=True)
for i in range(n):
qc.h(i)
for i in range(n):
qc.x(i)
qc.compose(o, inplace=True)
for i in range(n):
qc.x(i)
for i in range(n):
qc.h(i)
return qc
''' |
QPC003_B6 | A8A9D79592E9D | 6 | WA | 1170 ms | 155 MiB | '''python
from qiskit import QuantumCircuit # type: ignore
import math
"""
You can apply oracle as follows:
qc.compose(o, inplace=True)
"""
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
qc = QuantumCircuit(n)
# init H
for i in range(n):
qc.h(i)
qc.compose(o, inplace=True)
for i in range(n):
qc.h(i)
for i in range(n):
qc.x(i)
qc.compose(o, inplace=True)
for i in range(n):
qc.x(i)
for i in range(n):
qc.h(i)
return qc
''' |
QPC003_B6 | A8A9D79592E9D | 7 | WA | 1343 ms | 155 MiB | '''python
from qiskit import QuantumCircuit # type: ignore
import math
"""
You can apply oracle as follows:
qc.compose(o, inplace=True)
"""
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
qc = QuantumCircuit(n)
# init H
for i in range(n):
qc.h(i)
for _ in range(5):
qc.compose(o, inplace=True)
for i in range(n):
qc.h(i)
for i in range(n):
qc.x(i)
qc.compose(o, inplace=True)
for i in range(n):
qc.x(i)
for i in range(n):
qc.h(i)
return qc
''' |
QPC003_B6 | A8A9D79592E9D | 8 | WA | 1521 ms | 157 MiB | '''python
from qiskit import QuantumCircuit # type: ignore
import math
"""
You can apply oracle as follows:
qc.compose(o, inplace=True)
"""
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
qc = QuantumCircuit(n)
# init H
for i in range(n):
qc.h(i)
for _ in range(25):
qc.compose(o, inplace=True)
for i in range(n):
qc.h(i)
for i in range(n):
qc.x(i)
qc.compose(o, inplace=True)
for i in range(n):
qc.x(i)
for i in range(n):
qc.h(i)
return qc
''' |
QPC003_B6 | A8A9D79592E9D | 9 | WA | 1477 ms | 158 MiB | '''python
from qiskit import QuantumCircuit # type: ignore
import math
"""
You can apply oracle as follows:
qc.compose(o, inplace=True)
"""
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
qc = QuantumCircuit(n)
# init H
for i in range(n):
qc.h(i)
# Grover's algorithm
for _ in range(math.floor(math.pi/4*math.sqrt(2**n/2))):
qc.compose(o, inplace=True)
for i in range(n):
qc.h(i)
for i in range(n):
qc.x(i)
qc.compose(o, inplace=True)
for i in range(n):
qc.x(i)
for i in range(n):
qc.h(i)
return qc
''' |
QPC003_B6 | A8A9D79592E9D | 10 | WA | 1256 ms | 156 MiB | '''python
from qiskit import QuantumCircuit # type: ignore
import math
"""
You can apply oracle as follows:
qc.compose(o, inplace=True)
"""
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
qc = QuantumCircuit(n)
# init H
for i in range(n):
qc.h(i)
# Grover's algorithm
for _ in range(6):
qc.compose(o, inplace=True)
for i in range(n):
qc.h(i)
for i in range(n):
qc.x(i)
qc.compose(o, inplace=True)
for i in range(n):
qc.x(i)
for i in range(n):
qc.h(i)
return qc
''' |
QPC003_B6 | A8A9D79592E9D | 11 | WA | 1419 ms | 155 MiB | '''python
from qiskit import QuantumCircuit # type: ignore
import math
"""
You can apply oracle as follows:
qc.compose(o, inplace=True)
"""
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
qc = QuantumCircuit(n)
# init H
for i in range(n):
qc.h(i)
# Grover's algorithm
for _ in range(math.floor(math.pi/4*math.sqrt(n))):
qc.compose(o, inplace=True)
for i in range(n):
qc.h(i)
for i in range(n):
qc.x(i)
qc.compose(o, inplace=True)
for i in range(n):
qc.x(i)
for i in range(n):
qc.h(i)
return qc
''' |
QPC003_B6 | A8A9D79592E9D | 12 | WA | 1281 ms | 155 MiB | '''python
from qiskit import QuantumCircuit # type: ignore
import math
"""
You can apply oracle as follows:
qc.compose(o, inplace=True)
"""
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
qc = QuantumCircuit(n)
# init H
for i in range(n):
qc.h(i)
# Grover's algorithm
for _ in range(2):
qc.compose(o, inplace=True)
for i in range(n):
qc.h(i)
for i in range(n):
qc.x(i)
qc.compose(o, inplace=True)
for i in range(n):
qc.x(i)
for i in range(n):
qc.h(i)
return qc
''' |
QPC003_B6 | A8A9D79592E9D | 13 | AC | 1562 ms | 159 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Step 1: Apply Hadamard gate to all qubits to create superposition
for i in range(n):
qc.h(i)
# Step 2: Apply Grover's algorithm with the necessary number of iterations
iterations = math.floor(math.pi / 4 * math.sqrt(2 ** n))
for _ in range(iterations):
# Apply the oracle
qc.compose(o, inplace=True)
# Diffusion operator
for i in range(n):
qc.h(i)
for i in range(n):
qc.x(i)
# Apply a multi-controlled Z gate
qc.h(0)
qc.mcx(list(range(1, n)), 0) # Apply controlled-Z
qc.h(0)
for i in range(n):
qc.x(i)
for i in range(n):
qc.h(i)
return qc
''' |
QPC003_B6 | AA1131E558C84 | 1 | WA | 2289 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)
qc.append(o,qargs = range(n))
for i in range(n):
qc.h(i)
return qc
''' |
QPC003_B6 | AA1131E558C84 | 2 | AC | 1947 ms | 160 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
"""
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)
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_B6 | AA7126FBC66AD | 1 | RE | 1157 ms | 154 MiB | '''python
from qiskit import QuantumCircuit
import numpy as np
"""
You can apply oracle as follows:
qc.compose(o, inplace=True)
"""
def diffusion(n):
theta = np.pi
controls = list(range(n-1))
target = n-1
qc.h(range(n))
for i in range(n):
qc.x(i)
qc.mcp(theta, controls, target)
for i in range(n):
qc.x(i)
qc.h(range(n))
return qc
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
rounds = np.round(np.pi/(4*(np.arcsin(np.sqrt(1/2**(n - 1)))))-1/2, 4)
rounds_int = int(np.round(rounds))
qc.h(range(n))
for _ in range(rounds_int):
qc.compose(o, inplace=True)
qc.compose(diffusion(n), inplace = True)
return qc
''' |
QPC003_B6 | AA7126FBC66AD | 2 | RE | 1161 ms | 153 MiB | '''python
from qiskit import QuantumCircuit
import numpy as np
"""
You can apply oracle as follows:
qc.compose(o, inplace=True)
"""
def diffusion(n):
theta = np.pi
controls = list(range(n-1))
target = n-1
qc.h(range(n))
for i in range(n):
qc.x(i)
qc.mcp(theta, controls, target)
for i in range(n):
qc.x(i)
qc.h(range(n))
return qc
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
rounds = np.round(np.pi/(4*(np.arcsin(np.sqrt(1/2**(n - 1)))))-1/2, 4)
rounds_int = int(np.round(rounds))
qc.h(range(n))
for _ in range(rounds_int):
qc.compose(o, inplace=True)
qc.compose(diffusion(n), inplace = True)
qc.measure_all()
return qc
''' |
QPC003_B6 | AA7126FBC66AD | 3 | RE | '''python
from qiskit import QuantumCircuit
import numpy as np
"""
You can apply oracle as follows:
qc.compose(o, inplace=True)
"""
def diffusion:
theta = np.pi
controls = list(range(n-1))
target = n-1
qc.h(range(n))
for i in range(n):
qc.x(i)
qc.mcp(theta, controls, target)
for i in range(n):
qc.x(i)
qc.h(range(n))
return qc
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
rounds = np.round(np.pi/(4*(np.arcsin(np.sqrt(1/2**(n - 1)))))-1/2, 4)
rounds_int = int(np.round(rounds))
qc.h(range(n))
for _ in range(rounds_int):
qc.compose(o, inplace=True)
qc.compose(diffusion, inplace = True)
return qc
''' | ||
QPC003_B6 | AA7126FBC66AD | 4 | RE | 1231 ms | 153 MiB | '''python
from qiskit import QuantumCircuit
import numpy as np
"""
You can apply oracle as follows:
qc.compose(o, inplace=True)
"""
def diffusion(n):
theta = np.pi
controls = list(range(n-1))
target = n-1
qc.h(range(n))
for i in range(n):
qc.x(i)
qc.mcp(theta, controls, target)
for i in range(n):
qc.x(i)
qc.h(range(n))
return qc
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
n = n
rounds = np.round(np.pi/(4*(np.arcsin(np.sqrt(1/2**(n - 1)))))-1/2, 4)
rounds_int = int(np.round(rounds))
qc.h(range(n))
for _ in range(rounds_int):
qc.compose(o, inplace=True)
qc.compose(diffusion(n), inplace = True)
return qc
''' |
QPC003_B6 | AA7126FBC66AD | 5 | RE | 1246 ms | 154 MiB | '''python
from qiskit import QuantumCircuit
import numpy as np
"""
You can apply oracle as follows:
qc.compose(o, inplace=True)
"""
def diffusion(n):
theta = np.pi
controls = list(range(n-1))
target = n-1
qc.h(range(n))
for i in range(n):
qc.x(i)
qc.mcp(theta, controls, target)
for i in range(n):
qc.x(i)
qc.h(range(n))
return qc
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
n = n
rounds = np.round(np.pi/(4*(np.arcsin(np.sqrt(1/2**(n - 1)))))-1/2, 4)
rounds_int = int(np.round(rounds))
qc.h(range(n))
for _ in range(rounds_int):
qc.compose(o, inplace=True)
qc.compose(diffusion(n), inplace = True)
qc.measure_all()
return qc
''' |
QPC003_B6 | AA7126FBC66AD | 6 | AC | 1666 ms | 157 MiB | '''python
from qiskit import QuantumCircuit
import numpy as np
"""
You can apply oracle as follows:
qc.compose(o, inplace=True)
"""
def diffusion(n):
qc = QuantumCircuit(n)
theta = np.pi
controls = list(range(n-1))
target = n-1
qc.h(range(n))
for i in range(n):
qc.x(i)
qc.mcp(theta, controls, target)
for i in range(n):
qc.x(i)
qc.h(range(n))
return qc
def solve(n: int, o: QuantumCircuit) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
n = n
rounds = np.round(np.pi/(4*(np.arcsin(np.sqrt(1/2**(n - 1)))))-1/2, 4)
rounds_int = int(np.round(rounds))
qc.h(range(n))
for _ in range(rounds_int):
qc.compose(o, inplace=True)
qc.compose(diffusion(n), inplace = True)
return qc
''' |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.