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 |
|---|---|---|---|---|---|---|
QPC005_A2 | A5AC687BA3E09 | 1 | WA | 1762 ms | 142 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Write your code here:
if k==0:
qc.x(k)
qc.h(k)
return qc
''' |
QPC005_A2 | A5AC687BA3E09 | 2 | WA | 1723 ms | 142 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Write your code here:
if k==0:
qc.x(m)
qc.h(m)
return qc
''' |
QPC005_A2 | A5AC687BA3E09 | 3 | WA | 1630 ms | 142 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Write your code here:
if k==0:
qc.h(m)
return qc
''' |
QPC005_A2 | A5AC687BA3E09 | 4 | WA | 1757 ms | 143 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Write your code here:
if k==0:
qc.h(k)
return qc
''' |
QPC005_A2 | A5AC687BA3E09 | 5 | WA | 1651 ms | 142 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Write your code here:
if k==0:
qc.h(0)
return qc
''' |
QPC005_A2 | A5AC687BA3E09 | 6 | WA | 1677 ms | 143 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Write your code here:
if k==0:
qc.h(m)
return qc
''' |
QPC005_A2 | A5AC687BA3E09 | 7 | WA | 1613 ms | 142 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Write your code here:
if k==0:
qc.h(m[0])
return qc
''' |
QPC005_A2 | A65636DFBE64B | 1 | RE | 1587 ms | 141 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Write your code here:
qc.x(k)
qc.append(x.control(n-1), range(n))
qc.append(h.control(n-1), range(n))
qc.x(k)
return qc
''' |
QPC005_A2 | A65636DFBE64B | 2 | RE | 1614 ms | 141 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Write your code here:
qc.x(k)
qc.append(x.control(n), range(n+1))
qc.append(h.control(n), range(n+1))
qc.x(k)
return qc
''' |
QPC005_A2 | A65636DFBE64B | 3 | UME | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import Gate
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Write your code here:
qc.x(k)
qc.append(x.control(n), range(n+1))
qc.append(h.control(n), range(n+1))
qc.x(k)
return qc
''' | ||
QPC005_A2 | A65636DFBE64B | 4 | UME | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import X, H
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Write your code here:
qc.x(k)
qc.append(X.control(n), range(n+1))
qc.append(H.control(n), range(n+1))
qc.x(k)
return qc
''' | ||
QPC005_A2 | A65636DFBE64B | 5 | RE | 1702 ms | 141 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Write your code here:
qc.x(k)
qc.append(x(0).control(n), range(n+1))
qc.append(h(0).control(n), range(n+1))
qc.x(k)
return qc
''' |
QPC005_A2 | A65636DFBE64B | 6 | RE | 1703 ms | 141 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Write your code here:
qc.x(k)
qc.append(XGate().control(n), range(n+1))
qc.append(HGate().control(n), range(n+1))
qc.x(k)
return qc
''' |
QPC005_A2 | A65636DFBE64B | 7 | RE | 1856 ms | 141 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import XGate, HGate
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Write your code here:
qc.x(k)
qc.append(XGate().control(n), range(n+1))
qc.append(HGat().control(n), range(n+1))
qc.x(k)
return qc
''' |
QPC005_A2 | A65636DFBE64B | 8 | RE | 1977 ms | 141 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import XGate, HGate
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Write your code here:
qc.x(k)
qc.append(XGate().control(n), range(n+1))
qc.append(HGat().control(n), range(n+1))
qc.x(k)
return qc
''' |
QPC005_A2 | A65636DFBE64B | 9 | WA | 2302 ms | 142 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import XGate, HGate
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Write your code here:
qc.x(k)
qc.append(XGate().control(n), range(n+1))
qc.append(HGate().control(n), range(n+1))
qc.x(k)
return qc
''' |
QPC005_A2 | A65636DFBE64B | 10 | RE | 1955 ms | 141 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import XGate, HGate
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Write your code here:
qc.x(k)
qc.append(XGate().control(0), range(n+1))
qc.append(HGate().control(0), range(n+1))
qc.x(k)
return qc
''' |
QPC005_A2 | A65636DFBE64B | 11 | RE | 1673 ms | 140 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import XGate, HGate
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Write your code here:
qc.x(k)
qc.append(XGate().control(0), list(k) + [m[0]])
qc.append(HGate().control(0), list(k) + [m[0]])
qc.x(k)
return qc
''' |
QPC005_A2 | A65636DFBE64B | 12 | WA | 1947 ms | 143 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import XGate, HGate
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Write your code here:
qc.x(k)
qc.append(XGate().control(n), list(k) + [m[0]])
qc.append(HGate().control(n), list(k) + [m[0]])
qc.x(k)
return qc
''' |
QPC005_A2 | A65636DFBE64B | 13 | AC | 2087 ms | 143 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import XGate, HGate
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Write your code here:
qc.x(k)
qc.append(HGate().control(n), list(k) + [m[0]])
qc.x(k)
return qc
''' |
QPC005_A2 | A6EE6AC0152A6 | 1 | WA | 1759 ms | 142 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
aux = QuantumRegister(1, 'aux')
qc.add_register(aux)
qc.x(aux[0])
for i in range(n):
qc.cx(k[i], aux[0])
qc.ch(aux[0], m[0])
for i in range(n):
qc.cx(k[i], aux[0])
qc.x(aux[0])
return qc
''' |
QPC005_A2 | A6EE6AC0152A6 | 2 | WA | 1558 ms | 142 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import HGate, ZGate
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
controlled_h = HGate().control(n, ctrl_state='0' * n)
qc.append(controlled_h, k[:] + [m[0]])
controlled_z = ZGate().control(n, ctrl_state='0' * n)
qc.append(controlled_z, k[:] + [m[0]])
return qc
''' |
QPC005_A2 | A6EE6AC0152A6 | 3 | AC | 2110 ms | 143 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import HGate
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
controlled_h = HGate().control(n, ctrl_state='0' * n)
qc.append(controlled_h, k[:] + [m[0]])
return qc
''' |
QPC005_A2 | A7B1AE9BD3F88 | 1 | AC | 2120 ms | 143 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import HGate
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Write your code here:
c0h = HGate().control(n, ctrl_state=0)
qc.append(c0h, list(range(1, n + 1)) + [0])
return qc
def main():
print(solve(1))
print(solve(2))
print(solve(3))
if __name__ == "__main__":
main()
''' |
QPC005_A2 | A831609A06DB3 | 1 | WA | 1734 ms | 143 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Write your code here:
qc.ch(k, m)
return qc
''' |
QPC005_A2 | A831609A06DB3 | 2 | WA | 1673 ms | 143 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Write your code here:
qc.x(k)
qc.ch(k, m)
qc.x(k)
return qc
''' |
QPC005_A2 | A831609A06DB3 | 3 | RE | 1405 ms | 140 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Write your code here:
qc.x(k)
qc.append(HGate().control(len(k)), range(len(k),-1,-1))
qc.x(k)
return qc
''' |
QPC005_A2 | A831609A06DB3 | 4 | RE | 2049 ms | 141 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Write your code here:
qc.x(k)
qc.append(HGate().control(len(k)), range(len(k),-1,-1))
qc.x(k)
return qc
''' |
QPC005_A2 | A831609A06DB3 | 5 | RE | 2135 ms | 141 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Write your code here:
qc.x(k)
qc.compose(HGate().control(len(k)), [*k, m[0]], inplace=True)
qc.x(k)
return qc
''' |
QPC005_A2 | A831609A06DB3 | 6 | AC | 2304 ms | 143 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import HGate
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Write your code here:
qc.x(k)
qc.append(HGate().control(len(k)), range(len(k),-1,-1))
qc.x(k)
return qc
''' |
QPC005_A2 | A84FBE06EF9E5 | 1 | AC | 2167 ms | 143 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import HGate
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Write your code here:
qc.x(k)
qc.append(HGate().control(n), list(range(1, n+1))+[0])
qc.x(k)
return qc
''' |
QPC005_A2 | A88C2755F6F2E | 1 | RE | 1440 ms | 141 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Write your code here:
# Flip k so that controls are on '0'
for i in range(n):
qc.x(k[i])
# Multi-controlled Hadamard is hard; instead, we:
# Put state |m> through H, and then Z conditioned on m and all k==0
qc.h(m[0])
if n == 0:
# No controls, always act
qc.z(m[0])
else:
qc.mcz([m[0]] + [k[i] for i in range(n)], m[0])
# But Qiskit mcz does not allow target as part of controls!
# Instead, do controlled-Z on m[0], controlled by all k==0
if n > 0:
qc.mcz([k[i] for i in range(n)], m[0])
# Unflip k
for i in range(n):
qc.x(k[i])
return qc
''' |
QPC005_A2 | A88C2755F6F2E | 2 | RE | 1368 ms | 141 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Write your code here:
# Invert all k qubits (check if they're in |0⟩)
for i in range(n):
qc.x(k[i])
# Apply multi-controlled Toffoli to m (using no ancilla)
if n == 1:
qc.cx(k[0], m[0])
elif n == 2:
qc.ccx(k[0], k[1], m[0])
else:
qc.mct(k[:], m[0], mode='noancilla') # n ≥ 3
# Apply Z then H to m[0]
qc.z(m[0])
qc.h(m[0])
# Undo the Toffoli
if n == 1:
qc.cx(k[0], m[0])
elif n == 2:
qc.ccx(k[0], k[1], m[0])
else:
qc.mct(k[:], m[0], mode='noancilla') # n ≥ 3
# Undo the X gates
for i in range(n):
qc.x(k[i])
return qc
''' |
QPC005_A2 | A88C2755F6F2E | 3 | WA | 1990 ms | 142 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Write your code here:
# Apply X gates to flip m if needed (controlled by k=0 condition)
# Use multi-controlled X gate to check if k == 0
qc.x(k) # Flip all k qubits to test the inverse
qc.mcx(k, m) # Multi-controlled X gate with k controlling m
qc.x(k) # Flip back k qubits
# Apply Hadamard to m to get the superposition
qc.h(m)
return qc
''' |
QPC005_A2 | A88C2755F6F2E | 4 | WA | 2356 ms | 142 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Write your code here:
# Use an ancillary qubit approach to detect k = 0 and apply phase
qc.h(m) # Start with Hadamard to get superposition
# Apply multi-controlled Z gate to introduce phase when k != 0
qc.mcx(k, m) # Control on k qubits, target m (flips when k != 0)
qc.x(m) # Correct the phase by flipping m
qc.h(m) # Reapply Hadamard to adjust superposition
return qc
''' |
QPC005_A2 | A88C2755F6F2E | 5 | WA | 1542 ms | 142 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Write your code here:
# Apply transformation only when k = 0
qc.x(k) # Flip k qubits to test k = 0 (all 1s means original k = 0)
qc.mcx(k, m) # Multi-controlled X when k = 0
qc.h(m) # Apply Hadamard to get superposition
qc.x(k) # Restore k qubits
return qc
''' |
QPC005_A2 | A88C2755F6F2E | 6 | WA | 2094 ms | 143 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Write your code here:
# Add an ancillary qubit to handle the control
anc = QuantumRegister(1, 'anc')
qc.add_register(anc)
# Initialize anc to |0>
qc.x(anc) # anc = |1> for control inversion
# Check if k = 0 using multi-controlled X
qc.mcx(k, anc) # anc flips to |0> only if k = 0
# Apply controlled Hadamard with phase
qc.ch(m, anc) # Controlled Hadamard when anc = |1> (k != 0 does nothing)
qc.cz(m, anc) # Apply phase based on m when anc = |1>
qc.x(anc) # Reset anc
return qc
''' |
QPC005_A2 | A88C2755F6F2E | 7 | RE | 1407 ms | 141 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Write your code here:
# Apply X gates to invert k for k = 0 condition
qc.x(k) # Flip all k qubits (k = 0 becomes all |1>)
# Use multi-controlled Hadamard with phase
qc.mch(k, m) # Multi-controlled Hadamard (approximates superposition)
qc.mcx(k, m) # Apply controlled X to adjust phase
qc.x(k) # Restore k qubits
return qc
''' |
QPC005_A2 | A88C2755F6F2E | 8 | WA | 2283 ms | 143 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Write your code here:
# Apply transformation only when k = 0
# Invert k to check k = 0 (all |1> means original k = 0)
for i in range(n):
qc.x(k[i]) # Flip each k qubit
# Apply controlled operation
qc.h(m) # Start with Hadamard
for i in range(n):
qc.cx(k[i], m) # Use CNOT to build control (approximates multi-control)
qc.h(m) # Refine superposition
for i in range(n):
qc.x(k[i]) # Restore k qubits
return qc
''' |
QPC005_A2 | A88C2755F6F2E | 9 | RE | 2108 ms | 140 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Write your code here:
# Apply transformation only when k = 0
qc.x(k) # Invert k (k = 0 becomes all |1>)
qc.mct(k, m) # Multi-controlled Toffoli when k = 0
qc.h(m) # Apply Hadamard to get superposition
qc.mct(k, m) # Undo the control to adjust phase
qc.x(k) # Restore k
return qc
''' |
QPC005_A2 | A88C2755F6F2E | 10 | WA | 1738 ms | 143 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Write your code here:
# Conditionally apply transformation when k = 0
for i in range(n):
qc.x(k[i]) # Invert k (k = 0 becomes all |1>)
# Use controlled operations to apply transformation
qc.h(m) # Apply Hadamard
for i in range(n-1, -1, -1): # Iterate backwards for control
qc.cx(k[i], m) # Control on each k[i]
qc.h(m) # Refine superposition
for i in range(n):
qc.x(k[i]) # Restore k
return qc
''' |
QPC005_A2 | A88C2755F6F2E | 11 | RE | 1370 ms | 140 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Write your code here:
# Invert k to check k = 0 (all |1> means original k = 0)
for i in range(n):
qc.x(k[i])
# Apply controlled Hadamard and phase
qc.h(m) # Initial Hadamard
for i in range(n-1, -1, -1): # Control chain
qc.cx(k[i], m)
# Apply phase based on m
qc.cz(m, m) # Self-controlled Z to introduce (-1)^m phase
for i in range(n-1, -1, -1): # Undo control chain
qc.cx(k[i], m)
qc.h(m) # Final Hadamard to complete transformation
for i in range(n):
qc.x(k[i]) # Restore k
return qc
''' |
QPC005_A2 | A88C2755F6F2E | 12 | WA | 1533 ms | 143 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Invert k to check k = 0 (all |1> means original k = 0)
for i in range(n):
qc.x(k[i])
# Apply controlled Hadamard and phase
qc.h(m) # Initial Hadamard
# Build control chain
for i in range(n-1, -1, -1):
qc.cx(k[i], m)
# Apply Z gate for phase (-1)^m, controlled by the chain
qc.z(m) # Apply Z to introduce phase
for i in range(n-1, -1, -1):
qc.cx(k[i], m) # Undo control chain
qc.h(m) # Final Hadamard to complete transformation
for i in range(n):
qc.x(k[i]) # Restore k
return qc
''' |
QPC005_A2 | A88C2755F6F2E | 13 | WA | 1552 ms | 142 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Invert k to check k = 0 (all |1> means original k = 0)
for i in range(n):
qc.x(k[i])
# Apply controlled Hadamard and phase
qc.h(m) # Initial Hadamard
qc.mcx(k, m) # Multi-controlled X when k = 0
qc.z(m) # Apply Z gate for (-1)^m phase
qc.mcx(k, m) # Undo the control to apply conditionally
qc.h(m) # Final Hadamard to complete transformation
for i in range(n):
qc.x(k[i]) # Restore k
return qc
''' |
QPC005_A2 | A88C2755F6F2E | 14 | WA | 1673 ms | 143 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Invert k to check k = 0 (all |1> means original k = 0)
for i in range(n):
qc.x(k[i])
# Apply controlled transformation
qc.mcx(k, m) # Control on k, target m
qc.h(m) # Hadamard within control
qc.z(m) # Phase flip
qc.h(m) # Complete the transformation
qc.mcx(k, m) # Undo the control
for i in range(n):
qc.x(k[i]) # Restore k
return qc
''' |
QPC005_A2 | A8B2B320D8663 | 1 | WA | 1557 ms | 142 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
if k==0:
qc.h(0)
else:
pass
return qc
''' |
QPC005_A2 | A8B2B320D8663 | 2 | WA | 1749 ms | 142 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
if k==0 and m==0:
qc.x(0)
qc.h(0)
elif k==0 and m==1:
qc.h(0)
else:
pass
return qc
''' |
QPC005_A2 | A8B2B320D8663 | 3 | WA | 1758 ms | 142 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import numpy as np
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
qc.ry(np.pi / 4, m[0])
qc.x(k)
qc.h(m[0])
qc.mcx([*k], m[0])
qc.h(m[0])
qc.x(k)
qc.ry(-np.pi / 4, m[0])
return qc
''' |
QPC005_A2 | A8B2B320D8663 | 4 | RE | 1482 ms | 141 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import numpy as np
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
h_gate = HGate()
multi_controlled_h_gate = h_gate.control(num_ctrl_qubits=n, ctrl_state='0' * n)
qc.append(multi_controlled_h_gate, [*k, m[0]])
return qc
''' |
QPC005_A2 | A8B2B320D8663 | 5 | AC | 1999 ms | 143 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import HGate
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
h_gate = HGate()
multi_controlled_h_gate = h_gate.control(num_ctrl_qubits=n, ctrl_state='0' * n)
qc.append(multi_controlled_h_gate, [*k, m[0]])
return qc
''' |
QPC005_A2 | A920778DEBBB0 | 1 | WA | 1526 ms | 142 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Write your code here:
qc.h(m)
qc.cz(k, m)
return qc
''' |
QPC005_A2 | A920778DEBBB0 | 2 | WA | 1662 ms | 143 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Write your code here:
qc.ch(k, m)
return qc
''' |
QPC005_A2 | A920778DEBBB0 | 3 | RE | 1700 ms | 143 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import HGate
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
qc.append(HGate().control(n - 1), range(n))
return qc
''' |
QPC005_A2 | A920778DEBBB0 | 4 | UME | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import HGate
from qiskit.quantum_info import Statevector
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
qc.append(HGate().control(n - 1), range(1, n + 1))
return qc
''' | ||
QPC005_A2 | A920778DEBBB0 | 5 | RE | 2108 ms | 143 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import HGate
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
qc.append(HGate().control(n - 1), range(1, n + 1))
return qc
''' |
QPC005_A2 | A920778DEBBB0 | 6 | RE | 1466 ms | 140 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import HGate
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
qc.x(k)
qc.append(HGate().control(n), range(1, n + 1))
qc.x(k)
return qc
''' |
QPC005_A2 | A920778DEBBB0 | 7 | WA | 1694 ms | 143 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import HGate
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
qc.x(k)
qc.append(HGate().control(n), range(n + 1))
qc.x(k)
return qc
''' |
QPC005_A2 | A920778DEBBB0 | 8 | RE | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import HGate
from qiskit.quantum_info
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
for i in range(1, n + 1):
qc.x(i)
qc.append(HGate().control(n), range(n + 1))
for i in range(1, n + 1):
qc.x(i)
return qc
''' | ||
QPC005_A2 | A920778DEBBB0 | 9 | RE | 1277 ms | 140 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Write your code here:
qc.append(HGate().control(n), k[:] + m[:])
return qc
''' |
QPC005_A2 | A920778DEBBB0 | 10 | RE | 1370 ms | 140 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Write your code here:
qc.x(k)
target = range()
qc.append(HGate().control(n), range(n+1))
qc.x(k)
return qc
''' |
QPC005_A2 | A920778DEBBB0 | 11 | RE | 1565 ms | 141 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Write your code here:
qc.x(k)
qc.append(HGate().control(n), range(n+1))
qc.x(k)
return qc
''' |
QPC005_A2 | A920778DEBBB0 | 12 | RE | 1550 ms | 141 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Write your code here:
qc.x(k)
qc.append(HGate().control(n), list(range(1, n + 1)) + [0])
qc.x(k)
return qc
''' |
QPC005_A2 | A920778DEBBB0 | 13 | RE | 1550 ms | 141 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Write your code here:
qc.x(k)
qc.append(HGate().control(n), k[:] + m[:])
qc.x(k)
return qc
''' |
QPC005_A2 | A920778DEBBB0 | 14 | AC | 1903 ms | 143 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import HGate
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Write your code here:
qc.x(k)
qc.append(HGate().control(n), k[:] + m[:])
qc.x(k)
return qc
''' |
QPC005_A2 | A94B77A3F5009 | 1 | AC | 2188 ms | 143 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import HGate, XGate
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Write your code here:
for i in range(1, n + 1):
qc.x(i)
qc.append(HGate().control(n), list(range(1, n + 1)) + [0])
for i in range(1, n + 1):
qc.x(i)
return qc
''' |
QPC005_A2 | A96129F66D3F2 | 1 | RE | 1630 ms | 142 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import HGate
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Write your code here:
qc.append(HGate().control(n - 1), range(n))
return qc
''' |
QPC005_A2 | A96129F66D3F2 | 2 | RE | 1455 ms | 141 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import HGate
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Write your code here:
qc.append(HGate().control(n),[n,range(n)])
return qc
''' |
QPC005_A2 | A96129F66D3F2 | 3 | RE | 1820 ms | 140 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import HGate
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
qc.x(k)
# Write your code here:
qc.append(HGate().control(n),k+m)
qc.x(k)
return qc
''' |
QPC005_A2 | A96129F66D3F2 | 4 | AC | 2490 ms | 143 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import HGate
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
qc.x(k)
# Write your code here:
qc.append(HGate().control(n),k[:]+m[:])
qc.x(k)
return qc
''' |
QPC005_A2 | AAA061A26196C | 1 | WA | 1483 ms | 143 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Write your code here:
qc.h(m)
return qc
''' |
QPC005_A2 | AAA061A26196C | 2 | RE | 1486 ms | 141 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import ZGate
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Write your code here:
for i in range(1,n+1):
qc.x(i)
qc.swap(0,n)
qc.append(ZGate().control(n-1), range(n))
qc.swap(0,n)
for i in range(1,n+1):
qc.x(i)
return qc
''' |
QPC005_A2 | AAA061A26196C | 3 | AC | 1913 ms | 143 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import HGate
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Write your code here:
for i in range(1,n+1):
qc.x(i)
qc.swap(0,n)
qc.append(HGate().control(n), range(n+1))
qc.swap(0,n)
for i in range(1,n+1):
qc.x(i)
return qc
''' |
QPC005_A2 | AABCCF1F488EA | 1 | AC | 2100 ms | 143 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import HGate
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Write your code here:
for i in range(n):
qc.x(k[i])
mcH = HGate().control(n)
qc.append(mcH, [*k, m[0]])
for i in range(n):
qc.x(k[i])
return qc
''' |
QPC005_A2 | AAD0F4E4D2A99 | 1 | RE | 1631 ms | 141 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Write your code here:
ch = HGATE().control(n)
qc.append(ch,k[:]+m[:])
qc.x(k)
return qc
''' |
QPC005_A2 | AAD0F4E4D2A99 | 2 | RE | 1360 ms | 141 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Write your code here:
qc.x(k)
ch = HGATE().control(n)
qc.append(ch,k[:]+m[:])
qc.x(k)
return qc
''' |
QPC005_A2 | AAD0F4E4D2A99 | 3 | UME | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import HGATE
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Write your code here:
qc.x(k)
ch = HGATE().control(n)
qc.append(ch,k[:]+m[:])
qc.x(k)
return qc
''' | ||
QPC005_A2 | AAD0F4E4D2A99 | 4 | RE | 1658 ms | 140 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Write your code here:
h_circ.h(0)
h_gate = h_circ.to_gate()
ch_gate = h_gate.control(n)
qc.x(k)
qc.append(ch_gate,k[:]+m[:])
qc.x(k)
return qc
''' |
QPC005_A2 | AAD0F4E4D2A99 | 5 | RE | 1450 ms | 141 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Write your code here:
h_circ = quantumCircuit(1)
h_circ.h(0)
h_gate = h_circ.to_gate()
ch_gate = h_gate.control(n)
qc.x(k)
qc.append(ch_gate,k[:]+m[:])
qc.x(k)
return qc
''' |
QPC005_A2 | AB2EA751F9BEA | 1 | RE | 1522 ms | 141 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
qc.x(k)
qc.append(HGate().control(n), [k, m], inplace=True)
qc.x(k)
return qc
''' |
QPC005_A2 | AC9F1627437F4 | 1 | UME | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import HGate, ZGate
from qiskit.circuit import Gate
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
for i in range(n):
qc.x(k[i])
qc.append(ZGate().control(n), [q for q in k] + [m[0]])
qc.h(m[0])
for i in range(n):
qc.x(k[i])
return qc
''' | ||
QPC005_A2 | AC9F1627437F4 | 2 | WA | 1885 ms | 142 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import HGate, ZGate
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
for i in range(n):
qc.x(k[i])
qc.append(ZGate().control(n), [q for q in k] + [m[0]])
qc.h(m[0])
for i in range(n):
qc.x(k[i])
return qc
''' |
QPC005_A2 | AC9F1627437F4 | 3 | RE | 1557 ms | 141 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
if n == 1:
qc.x(k[0])
qc.ch(k[0], m[0])
qc.x(k[0])
else:
for i in range(n):
qc.x(k[i])
control_qubits = [k[i] for i in range(n)]
qc.mch(control_qubits, m[0])
for i in range(n):
qc.x(k[i])
return qc
''' |
QPC005_A2 | AC9F1627437F4 | 4 | WA | 1631 ms | 143 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import HGate, ZGate
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
for i in range(n):
qc.x(k[i])
if n == 1:
qc.ch(k[0], m[0])
elif n == 2:
qc.ccx(k[0], k[1], m[0])
qc.h(m[0])
qc.ccx(k[0], k[1], m[0])
qc.h(m[0])
else:
control_qubits = [k[i] for i in range(n)]
qc.mcx(control_qubits, m[0])
qc.h(m[0])
qc.mcx(control_qubits, m[0])
qc.h(m[0])
for i in range(n):
qc.x(k[i])
return qc
''' |
QPC005_A2 | AC9F1627437F4 | 5 | AC | 1830 ms | 143 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library.standard_gates import HGate, ZGate
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
if n == 1:
qc.x(k[0])
qc.ch(k[0], m[0])
qc.x(k[0])
else:
h_gate = HGate()
controlled_h = h_gate.control(num_ctrl_qubits=n, ctrl_state='0'*n)
qubits = [k[i] for i in range(n)] + [m[0]]
qc.append(controlled_h, qubits)
return qc
''' |
QPC005_A2 | ACEEC18E56B5B | 1 | RE | 1610 ms | 142 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import HGate
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Write your code here:
if n == 0:
qc.h(m[0])
else:
qc.append(HGate().control(n - 1), range(n))
return qc
''' |
QPC005_A2 | ACEEC18E56B5B | 2 | RE | 2121 ms | 143 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import HGate
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Write your code here:
if n == 0:
qc.h(m[0])
else:
qc.append(HGate().control(n - 1), k[:n-1] + [m[0]])
return qc
''' |
QPC005_A2 | ACEEC18E56B5B | 3 | AC | 1988 ms | 143 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import HGate
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Write your code here:
if n == 0:
qc.h(m[0])
else:
for i in range(n):
qc.x(k[i])
qc.append(HGate().control(n), list(k) + [m[0]])
for i in range(n):
qc.x(k[i])
return qc
''' |
QPC005_A2 | ACF96273BC5B9 | 1 | RE | '''python
from qiskit import QuantumCircuit, QuantumRegister
from math
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Write your code here:
for i in range(n):
qc.x(i)
qc.h(n)
if n == 1:
qc.cz(0, n)
else:
qc.mcp(math.pi(), list(range(n)), n)
qc.h(n)
for i in range(n):
qc.x(i)
return qc
''' | ||
QPC005_A2 | ACF96273BC5B9 | 2 | RE | '''python
from qiskit import QuantumCircuit, QuantumRegister
from math
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Write your code here:
for i in range(n):
qc.x(k[i])
# m にHadamard
qc.h(m[0])
# k=|1...1> のときに m に制御Z
if n == 1:
qc.cz(k[0], m[0])
else:
qc.mcp(math.pi, [k[i] for i in range(n)], m[0])
# m にHadamard
qc.h(m[0])
# k を元に戻す
for i in range(n):
qc.x(k[i])
return qc
''' | ||
QPC005_A2 | ACF96273BC5B9 | 3 | RE | '''python
from qiskit import QuantumCircuit, QuantumRegister
from math
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Write your code here:
for i in range(n):
qc.x(k[i])
qc.h(m[0])
if n == 0:
qc.z(m[0]) # kビットが無い場合
elif n == 1:
qc.cz(k[0], m[0])
else:
qc.mcp(math.pi, [k[i] for i in range(n)], m[0])
# mにHを作用
qc.h(m[0])
# kを元に戻す
for i in range(n):
qc.x(k[i])
return qc
''' | ||
QPC005_A2 | ACF96273BC5B9 | 4 | RE | '''python
from qiskit import QuantumCircuit, QuantumRegister
from math
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Write your code here:
for i in range(n):
qc.x(k[i])
# 制御付きHadamard
if n == 1:
qc.ch(k[0], m[0])
elif n >= 2:
qc.h(m[0])
qc.mcx([k[i] for i in range(n)], m[0])
qc.h(m[0])
else: # n==0の場合はmにHのみ
qc.h(m[0])
# kを元に戻す
for i in range(n):
qc.x(k[i])
return qc
''' | ||
QPC005_A2 | ACF96273BC5B9 | 5 | RE | '''python
from qiskit import QuantumCircuit, QuantumRegister
from math
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Write your code here:
for i in range(n):
qc.x(k[i])
# 制御付きHadamard
if n == 1:
qc.ch(k[0], m[0])
elif n >= 2:
# n>=2の多重制御Hは分解が必要（補助ビット無しなら mcu1 + H などで近似）
# 例として、mビットに対して多重制御Xをはさむ
# ここでは簡単にmビットにHadamard+多重制御X+Hadamard
qc.mcx([k[i] for i in range(n)], m[0])
qc.x(0)
qc.h(m[0])
else: # n==0の場合はmにHのみ
qc.h(m[0])
# kを元に戻す
for i in range(n):
qc.x(k[i])
return qc
''' | ||
QPC005_A2 | ACF96273BC5B9 | 6 | RE | '''python
from qiskit import QuantumCircuit, QuantumRegister
from math
from qiskit.circuit.library import ZGate
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Write your code here:
for i in range(n):
qc.x(k[i])
# 制御付き（k=0のときだけ）H→Z→H
# H
qc.h(m[0])
# 多重制御Z（符号反転、Z = P(π) = Rz(π)）
qc.mcz([k[i] for i in range(n)], m[0])
# H
qc.h(m[0])
# kを元に戻す
for i in range(n):
qc.x(k[i])
return qc
''' | ||
QPC005_A2 | ACF96273BC5B9 | 7 | RE | '''python
from qiskit import QuantumCircuit, QuantumRegister
from math
from qiskit.circuit.library import ZGate
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Write your code here:
for i in range(n):
qc.x(k[i])
# Hでmを±に分解
qc.h(m[0])
# 多重制御Xで |k=111...1⟩をmに制御X
if n > 0:
qc.mcx([k[i] for i in range(n)], m[0])
# Hで基底を戻す
qc.h(m[0])
# kを元に戻す
for i in range(n):
qc.x(k[i])
return qc
''' | ||
QPC005_A2 | ACF96273BC5B9 | 8 | RE | '''python
from qiskit import QuantumCircuit, QuantumRegister
from math
from qiskit.circuit.library import ZGate
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Write your code here:
if n == 1:
# k[0]==1の時のみ
qc.ch(k[0], m[0])
else:
# n>=2: k[0]~k[n-1]すべて1の時だけm[0]にH
# Hadamardを2回で挟んだmcx（Toffoli拡張）でX型の符号調整も可能
qc.h(m[0]) # 変換
qc.mcx([k[i] for i in range(n)], m[0])
qc.h(m[0]) # 戻す
return qc
''' | ||
QPC005_A2 | ACF96273BC5B9 | 9 | WA | 1645 ms | 143 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
from qiskit.circuit.library import ZGate
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Write your code here:
if n == 1:
# k[0]==1の時のみ
qc.ch(k[0], m[0])
else:
# n>=2: k[0]~k[n-1]すべて1の時だけm[0]にH
# Hadamardを2回で挟んだmcx（Toffoli拡張）でX型の符号調整も可能
qc.h(m[0]) # 変換
qc.mcx([k[i] for i in range(n)], m[0])
qc.h(m[0]) # 戻す
return qc
''' |
QPC005_A2 | ACF96273BC5B9 | 10 | WA | 1585 ms | 143 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import ZGate
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Write your code here:
if n == 1:
# k[0]==1の時のみ
qc.ch(k[0], m[0])
else:
# n>=2: k[0]~k[n-1]すべて1の時だけm[0]にH
# Hadamardを2回で挟んだmcx（Toffoli拡張）でX型の符号調整も可能
qc.h(m[0]) # 変換
qc.mcx([k[i] for i in range(n)], m[0])
qc.h(m[0]) # 戻す
return qc
''' |
QPC005_A2 | ACF96273BC5B9 | 11 | WA | 1586 ms | 143 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import ZGate
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Write your code here:
for i in range(n):
qc.x(k[i])
# 制御付きHadamard
if n == 1:
qc.ch(k[0], m[0])
elif n >= 2:
# Hadamardで重ね合わせ
qc.h(m[0])
# 多重制御Z（符号反転）、HでX-Z-X変換して多重制御XでもOK
qc.mcx([k[i] for i in range(n)], m[0])
qc.h(m[0])
# kを元に戻す
for i in range(n):
qc.x(k[i])
return qc
''' |
QPC005_A2 | ACF96273BC5B9 | 12 | WA | 1654 ms | 142 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import ZGate
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Write your code here:
for i in range(n):
qc.x(k[i])
# 2. 多重制御Hゲート（mに対してk全部が1のときだけ作用）
if n == 0:
qc.h(m[0]) # kレジスタが無い場合
elif n == 1:
qc.ch(k[0], m[0])
else:
# HadamardでH→mcx→Hで多重制御Hを合成
qc.h(m[0])
qc.mcx([k[i] for i in range(n)], m[0])
qc.h(m[0])
# 3. kを元に戻す
for i in range(n):
qc.x(k[i])
return qc
''' |
QPC005_A2 | ACF96273BC5B9 | 13 | WA | 1737 ms | 142 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import ZGate
def solve(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Write your code here:
for i in range(n):
qc.x(k[i])
# 2. 多重制御Hゲート（mに対してk全部が1のときだけ作用）
if n == 0:
qc.h(m[0]) # kレジスタが無い場合
elif n == 1:
qc.ch(k[0], m[0])
else:
# HadamardでH→mcx→Hで多重制御Hを合成
qc.mcx([k[i] for i in range(n)], m[0])
qc.x(0)
qc.h(m[0])
# 3. kを元に戻す
for i in range(n):
qc.x(k[i])
return qc
''' |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.