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_A4 | A3CE59B2D10E4 | 1 | WA | 1555 ms | 157 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Paso 1: Aplicar Ry al primer qubit
theta = 2 * math.acos(1 / math.sqrt(n))
qc.ry(theta, 0)
# Paso 2: Aplicar puertas controladas de Hadamard desde el primer qubit a los demás
for i in range(1, n):
qc.ch(0, i)
# Paso 3: Aplicar una cadena de puertas CNOT entre los qubits 1 a n-1
for i in range(1, n-1):
qc.cx(i, i+1)
# Paso 4: Aplicar puertas CNOT desde el primer qubit a los demás
for i in range(1, n):
qc.cx(0, i)
# Paso 5: Aplicar una puerta X al primer qubit
qc.x(0)
return qc
''' |
QPC003_A4 | A3CE59B2D10E4 | 2 | RE | 1228 ms | 153 MiB | '''python
from qiskit import QuantumCircuit
import math as m
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
circuit.x(0)
m = m.floor(n/2)
qubitT = 1
def _w_state_circuit(circuit, nn, mm, qubitC):
if nn == 0 and mm == 1:
pass #do nothing in this case
elif nn == 1 and mm == 2: #case (1,2)
circuit.cu3(m.pi/2, 0, 0, q[qubitC], q[qubitT])
circuit.cx(q[qubitT], q[qubitC])
qubitT = qubitT + 1
else: #otherwise
theta = 2*np.arccos(m.sqrt(nn/mm))
circuit.cu3(theta, 0, 0, q[qubitC], q[qubitT])
circuit.cx(q[qubitT], q[qubitC])
qubitTRecurse = qubitT #saving target qubit index, used as control qubit for lower child
qubitT = qubitT + 1
a = m.floor(nn/2)
b = m.floor(mm/2)
c = m.ceil(nn/2)
d = m.ceil(mm/2)
if a == 1 and b == 1: #upper child (1,1) => (1,2) became upper child
circuit = _w_state_circuit(circuit, 1, 2, qubitC)
#there is no lower child
elif c == 1 and d == 1: #lower child (1,1) => (1,2) became lower child
circuit = _w_state_circuit(circuit, 1, 2, qubitTRecurse)
#there is no upper child
else:
#upper child
circuit = _w_state_circuit(circuit, a, b, qubitC)
#lower child
circuit = _w_state_circuit(circuit, c, d, qubitTRecurse)
return circuit
qc = _w_state_circuit(qc, m, n, 0)
return qc
''' |
QPC003_A4 | A3CE59B2D10E4 | 3 | RE | 1157 ms | 154 MiB | '''python
from qiskit import QuantumCircuit
import math as m
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
circuit.x(0)
qubitT = 1
def _w_state_circuit(circuit, nn, mm, qubitC):
if nn == 0 and mm == 1:
pass #do nothing in this case
elif nn == 1 and mm == 2: #case (1,2)
circuit.cu3(m.pi/2, 0, 0, q[qubitC], q[qubitT])
circuit.cx(q[qubitT], q[qubitC])
qubitT = qubitT + 1
else: #otherwise
theta = 2*np.arccos(m.sqrt(nn/mm))
circuit.cu3(theta, 0, 0, q[qubitC], q[qubitT])
circuit.cx(q[qubitT], q[qubitC])
qubitTRecurse = qubitT #saving target qubit index, used as control qubit for lower child
qubitT = qubitT + 1
a = m.floor(nn/2)
b = m.floor(mm/2)
c = m.ceil(nn/2)
d = m.ceil(mm/2)
if a == 1 and b == 1: #upper child (1,1) => (1,2) became upper child
circuit = _w_state_circuit(circuit, 1, 2, qubitC)
#there is no lower child
elif c == 1 and d == 1: #lower child (1,1) => (1,2) became lower child
circuit = _w_state_circuit(circuit, 1, 2, qubitTRecurse)
#there is no upper child
else:
#upper child
circuit = _w_state_circuit(circuit, a, b, qubitC)
#lower child
circuit = _w_state_circuit(circuit, c, d, qubitTRecurse)
return circuit
qc = _w_state_circuit(qc, m.floor(n/2), n, 0)
return qc
''' |
QPC003_A4 | A3CE59B2D10E4 | 4 | RE | 1241 ms | 153 MiB | '''python
from qiskit import QuantumCircuit
import math as m
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
circuit.x(0)
qubitT = 1
def _w_state_circuit(circuit, nn, mm, qubitC):
if nn == 0 and mm == 1:
pass #do nothing in this case
elif nn == 1 and mm == 2: #case (1,2)
circuit.cu3(m.pi/2, 0, 0, qubitC, qubitT)
circuit.cx(qubitT, qubitC)
qubitT = qubitT + 1
else: #otherwise
theta = 2*np.arccos(m.sqrt(nn/mm))
circuit.cu3(theta, 0, 0, qubitC, qubitT)
circuit.cx(qubitT, qubitC)
qubitTRecurse = qubitT #saving target qubit index, used as control qubit for lower child
qubitT = qubitT + 1
a = m.floor(nn/2)
b = m.floor(mm/2)
c = m.ceil(nn/2)
d = m.ceil(mm/2)
if a == 1 and b == 1: #upper child (1,1) => (1,2) became upper child
circuit = _w_state_circuit(circuit, 1, 2, qubitC)
#there is no lower child
elif c == 1 and d == 1: #lower child (1,1) => (1,2) became lower child
circuit = _w_state_circuit(circuit, 1, 2, qubitTRecurse)
#there is no upper child
else:
#upper child
circuit = _w_state_circuit(circuit, a, b, qubitC)
#lower child
circuit = _w_state_circuit(circuit, c, d, qubitTRecurse)
return circuit
qc = _w_state_circuit(qc, m.floor(n/2), n, 0)
return qc
''' |
QPC003_A4 | A3CE59B2D10E4 | 5 | RE | 1476 ms | 154 MiB | '''python
from qiskit import QuantumCircuit
import math as m
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
qc.x(0)
qubitT = 1
def _w_state_circuit(circuit, nn, mm, qubitC):
if nn == 0 and mm == 1:
pass #do nothing in this case
elif nn == 1 and mm == 2: #case (1,2)
circuit.cu3(m.pi/2, 0, 0, qubitC, qubitT)
circuit.cx(qubitT, qubitC)
qubitT = qubitT + 1
else: #otherwise
theta = 2*np.arccos(m.sqrt(nn/mm))
circuit.cu3(theta, 0, 0, qubitC, qubitT)
circuit.cx(qubitT, qubitC)
qubitTRecurse = qubitT #saving target qubit index, used as control qubit for lower child
qubitT = qubitT + 1
a = m.floor(nn/2)
b = m.floor(mm/2)
c = m.ceil(nn/2)
d = m.ceil(mm/2)
if a == 1 and b == 1: #upper child (1,1) => (1,2) became upper child
circuit = _w_state_circuit(circuit, 1, 2, qubitC)
#there is no lower child
elif c == 1 and d == 1: #lower child (1,1) => (1,2) became lower child
circuit = _w_state_circuit(circuit, 1, 2, qubitTRecurse)
#there is no upper child
else:
#upper child
circuit = _w_state_circuit(circuit, a, b, qubitC)
#lower child
circuit = _w_state_circuit(circuit, c, d, qubitTRecurse)
return circuit
qc = _w_state_circuit(qc, m.floor(n/2), n, 0)
return qc
''' |
QPC003_A4 | A3CE59B2D10E4 | 6 | RE | 1303 ms | 153 MiB | '''python
from qiskit import QuantumCircuit
import math as m
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
qc.x(0)
qubitT = 1
def _w_state_circuit(circuit, nn, mm, qubitC):
if nn == 0 and mm == 1:
pass #do nothing in this case
elif nn == 1 and mm == 2: #case (1,2)
circuit.cu(m.pi/2, 0, 0, qubitC, qubitT)
circuit.cx(qubitT, qubitC)
qubitT = qubitT + 1
else: #otherwise
theta = 2*np.arccos(m.sqrt(nn/mm))
circuit.cu(theta, 0, 0, qubitC, qubitT)
circuit.cx(qubitT, qubitC)
qubitTRecurse = qubitT #saving target qubit index, used as control qubit for lower child
qubitT = qubitT + 1
a = m.floor(nn/2)
b = m.floor(mm/2)
c = m.ceil(nn/2)
d = m.ceil(mm/2)
if a == 1 and b == 1: #upper child (1,1) => (1,2) became upper child
circuit = _w_state_circuit(circuit, 1, 2, qubitC)
#there is no lower child
elif c == 1 and d == 1: #lower child (1,1) => (1,2) became lower child
circuit = _w_state_circuit(circuit, 1, 2, qubitTRecurse)
#there is no upper child
else:
#upper child
circuit = _w_state_circuit(circuit, a, b, qubitC)
#lower child
circuit = _w_state_circuit(circuit, c, d, qubitTRecurse)
return circuit
qc = _w_state_circuit(qc, m.floor(n/2), n, 0)
return qc
''' |
QPC003_A4 | A3CE59B2D10E4 | 7 | WA | 1692 ms | 158 MiB | '''python
from qiskit import QuantumCircuit
import math as m
import numpy as np
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
qc.x(0)
def _w_state_circuit(circuit, nn, mm, qubitC):
global qubitT
if nn == 0 and mm == 1:
pass #do nothing in this case
elif nn == 1 and mm == 2: #case (1,2)
circuit.cu(m.pi/2, 0, 0, 0, qubitC, qubitT)
circuit.cx(qubitT, qubitC)
qubitT = qubitT + 1
else: #otherwise
theta = 2*np.arccos(m.sqrt(nn/mm))
circuit.cu(theta, 0, 0, 0, qubitC, qubitT)
circuit.cx(qubitT, qubitC)
qubitTRecurse = qubitT #saving target qubit index, used as control qubit for lower child
qubitT = qubitT + 1
a = m.floor(nn/2)
b = m.floor(mm/2)
c = m.ceil(nn/2)
d = m.ceil(mm/2)
if a == 1 and b == 1: #upper child (1,1) => (1,2) became upper child
circuit = _w_state_circuit(circuit, 1, 2, qubitC)
#there is no lower child
elif c == 1 and d == 1: #lower child (1,1) => (1,2) became lower child
circuit = _w_state_circuit(circuit, 1, 2, qubitTRecurse)
#there is no upper child
else:
#upper child
circuit = _w_state_circuit(circuit, a, b, qubitC)
#lower child
circuit = _w_state_circuit(circuit, c, d, qubitTRecurse)
return circuit
global qubitT
qubitT = 1
qc = _w_state_circuit(qc, m.floor(n/2), n, 0)
return qc
''' |
QPC003_A4 | A3CE59B2D10E4 | 8 | WA | 1487 ms | 154 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Paso 1: Aplicar Ry al primer qubit
theta = 2 * math.acos(1 / math.sqrt(n))
qc.ry(theta, 0)
# Paso 2: Aplicar puertas controladas de Hadamard desde el primer qubit a los demás
if n >= 3:
for i in range(1, n):
qc.ch(0, i)
# Paso 3: Aplicar una cadena de puertas CNOT entre los qubits 1 a n-1
for i in range(1, n-1):
qc.cx(i, i+1)
# Paso 4: Aplicar puertas CNOT desde el primer qubit a los demás
for i in range(1, n):
qc.cx(0, i)
# Paso 5: Aplicar una puerta X al primer qubit
qc.x(0)
return qc
''' |
QPC003_A4 | A4180631A2556 | 1 | AC | 1911 ms | 157 MiB | '''python
from qiskit import QuantumCircuit
from math import acos, pi, sqrt
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.x(0)
for i in range(n - 1):
theta = 2 * acos(1 / sqrt(n - i))
qc.cry(theta, i, i + 1)
qc.cx(i + 1, i)
return qc
''' |
QPC003_A4 | A475A5F016619 | 1 | UME | '''python
from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector
import numpy as np
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
desired_state = np.zeros(2**n)
for i in range(n):
desired_state[1 << i] = 1 / np.sqrt(n)
qc.initialize(desired_state)
return qc
''' | ||
QPC003_A4 | A475A5F016619 | 2 | WA | 1332 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)
qc.append(HGate(), [0])
for i in range(1, n):
qc.append(CXGate(), [0, i])
qc.global_phase = np.arccos(1 / np.sqrt(n))
return qc
''' |
QPC003_A4 | A49D7B03D88B3 | 1 | WA | 1913 ms | 160 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Create the superposition state
for i in range(n):
qc.x(i) # Flip the i-th qubit to |1>
qc.h(i) # Apply Hadamard to create superposition
qc.x(i) # Flip back to |0>
return qc
''' |
QPC003_A4 | A4C2D51B9C151 | 1 | AC | 2010 ms | 158 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import CXGate, ZGate
from math import sqrt, acos, pi
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
qc.x(0)
def solve_for(l, r):
if r - l == 1:
return
m = l + r >> 1
theta = 2 * acos(sqrt(m - l) / sqrt(r - l))
qc.cry(theta, l, m)
qc.cx(m, l)
solve_for(l, m)
solve_for(m, r)
solve_for(0, n)
return qc
''' |
QPC003_A4 | A4E016A481935 | 1 | RE | 1279 ms | 153 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
x = math.sqrt(1/3)
y = math.sqrt(2/3)
theta = 2 * math.atan(y/x)
qc.ry(theta, 1)
qc.ch(1,2)
qc.x(0)
qc.cx(1,0)
qc.cx(2,1)
return qc
''' |
QPC003_A4 | A4E016A481935 | 2 | RE | 1637 ms | 155 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
x = math.sqrt(1/3)
y = math.sqrt(2/3)
theta = 2 * math.atan(y/x)
qc.ry(theta, 1)
qc.ch(1,2)
qc.x(0)
qc.cx(1,0)
qc.cx(2,1)
return qc
''' |
QPC003_A4 | A4E016A481935 | 3 | WA | 1428 ms | 155 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, 1, -1):
x = math.sqrt(1/i)
y = math.sqrt(i-1/i)
theta = 2 * math.atan(y/x)
qc.ry(theta, 1)
qc.x(n-1)
qc.cx(0,n-1)
for i in range(n-1):
qc.cx(i+1,i)
return qc
''' |
QPC003_A4 | A4E016A481935 | 4 | WA | 1437 ms | 155 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, 1, -1):
x = math.sqrt(1/i)
y = math.sqrt(i-1/i)
theta = 2 * math.atan(y/x)
qc.ry(theta, 1)
qc.x(n-1)
qc.cx(0,n-1)
for i in range(n-1):
qc.cx(i+1,i)
return qc
''' |
QPC003_A4 | A4E016A481935 | 5 | RE | 1259 ms | 154 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, 1, -1):
x = math.sqrt(1/i)
y = math.sqrt(i-1/i)
theta = 2 * math.atan(y/x)
qc.ry(theta, 1)
qc.x(0)
qc.cx(1,0)
qc.cx(2,1)
return qc
''' |
QPC003_A4 | A4E016A481935 | 6 | WA | 1431 ms | 155 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, 1, -1):
x = math.sqrt(1/i)
y = math.sqrt(i-1/i)
theta = 2 * math.atan(y/x)
qc.ry(theta, n-i)
qc.x(n-1)
qc.cx(0,n-1)
for i in range(n-1):
qc.cx(i+1,i)
return qc
''' |
QPC003_A4 | A4E016A481935 | 7 | WA | 1568 ms | 154 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, 1, -1):
x = math.sqrt(1/i)
y = math.sqrt(i-1/i)
theta = 2 * math.atan(y/x)
qc.ry(theta, n - i)
qc.x(n-1)
qc.cx(0,n-1)
for i in range(n-1):
qc.cx(i+1,i)
return qc
''' |
QPC003_A4 | A4E016A481935 | 8 | WA | 1545 ms | 155 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, 1, -1):
x = math.sqrt(1/i)
y = math.sqrt(i-1/i)
theta = 2 * math.atan(y/x)
if i == n:
qc.ry(theta, n - i)
else:
qc.cry(theta, n-i-1, n - i)
qc.x(n-1)
qc.cx(0,n-1)
for i in range(n-1):
qc.cx(i+1,i)
return qc
''' |
QPC003_A4 | A4E016A481935 | 9 | WA | 1494 ms | 155 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, 2, -1):
x = math.sqrt(1/i)
y = math.sqrt(i-1/i)
theta = 2 * math.atan(y/x)
if i == n:
qc.ry(theta, n - i)
else:
qc.cry(theta, n-i-1, n - i)
qc.x(n-1)
qc.cx(0,n-1)
for i in range(n-1):
qc.cx(i+1,i)
return qc
''' |
QPC003_A4 | A4E016A481935 | 10 | WA | 1510 ms | 155 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, 1, -1):
x = math.sqrt(1/i)
y = math.sqrt(i-1/i)
theta = 2 * math.atan(y/x)
if i == n:
qc.ry(theta, n - i)
else:
qc.cry(theta, n-i-1, n - i)
qc.x(n-1)
qc.cx(0,n-1)
for i in range(n-2):
qc.cx(i+1,i)
return qc
''' |
QPC003_A4 | A4E016A481935 | 11 | RE | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n, 1, -1):
x = math.sqrt(1/i)
y = math.sqrt(i-1/i)
theta = 2 * math.atan(y/x)
if i == n:
qc.ry(theta, n - i)
else:
qc.cry(theta, n-i-1, n - i)
qc.x(n-1)
qc.cx(0,n-1)
for i in range(n-):
qc.cx(i+1,i)
return qc
if __name__ == "__main__":
qc = solve()
print(Statevector(qc))
''' | ||
QPC003_A4 | A4E016A481935 | 12 | RE | 1778 ms | 156 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
x = math.sqrt(1/3)
y = math.sqrt(2/3)
theta = 2 * math.atan(y/x)
qc.ry(theta, 0)
x = math.sqrt(1/2)
y = math.sqrt(1/2)
theta = 2 * math.atan(y/x)
qc.cry(theta, 0, 1)
qc.x(2)
qc.cx(0,2)
qc.cx(1,0)
return qc
''' |
QPC003_A4 | A4E016A481935 | 13 | RE | 1768 ms | 156 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
x = math.sqrt(1/3)
y = math.sqrt(2/3)
theta = 2 * math.atan(y/x)
qc.ry(theta, 0)
x = math.sqrt(1/2)
y = math.sqrt(1/2)
theta = 2 * math.atan(y/x)
qc.cry(theta, 0, 1)
qc.x(2)
qc.cx(0,2)
qc.cx(1,0,)
return qc
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
x = math.sqrt(1/n-i)
y = math.sqrt(n-i-1/n-i)
theta = 2 * math.atan(y/x)
if i == 0:
qc.ry(theta, i)
else:
qc.cry(theta, i-1, i)
qc.x(n-1)
qc.cx(0,n-1)
for i in range(n-2):
qc.cx(i+1,i)
return qc
''' |
QPC003_A4 | A4E016A481935 | 14 | RE | 1210 ms | 154 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):
x = math.sqrt(1/n-i)
y = math.sqrt(n-i-1/n-i)
theta = 2 * math.atan(y/x)
if i == 0:
qc.ry(theta, i)
else:
qc.cry(theta, i-1, i)
qc.x(n-1)
qc.cx(0,n-1)
for i in range(n-2):
qc.cx(i+1,i)
return qc
''' |
QPC003_A4 | A4E016A481935 | 15 | RE | 1213 ms | 154 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n-1):
x = math.sqrt(1/n-i)
y = math.sqrt(n-i-1/n-i)
theta = 2 * math.atan(y/x)
if i == 0:
qc.ry(theta, i)
else:
qc.cry(theta, i-1, i)
qc.x(n-1)
qc.cx(0,n-1)
for i in range(n-2):
qc.cx(i+1,i)
return qc
''' |
QPC003_A4 | A4E016A481935 | 16 | AC | 2272 ms | 157 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range( n - 1 ):
x = math.sqrt(1/ (n-i))
y = math.sqrt((n-i-1)/(n-i))
theta = 2 * math.atan(y/x)
if i == 0:
qc.ry(theta, i)
else:
qc.cry(theta, i-1, i)
qc.x(n-1)
qc.cx(0,n-1)
for i in range(n-2):
qc.cx(i+1,i)
return qc
''' |
QPC003_A4 | A52624E1D9D63 | 1 | RE | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
theta 2*math.atan(math.sqrt(n-1))
qc.ry(theta,0)
for i in range(0,n-1):
theta = 2 * math.atan(math.sqrt(n-i))
qc.cry(theta,i,i+1)
qc.x(i)
return qc
''' | ||
QPC003_A4 | A52624E1D9D63 | 2 | RE | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
theta 2 * math.atan(math.sqrt(n-1))
qc.ry(theta,0)
for i in range(n-1):
theta = 2 * math.atan(math.sqrt(n-i-1))
qc.cry(theta,i,i+1)
qc.x(i)
return qc
''' | ||
QPC003_A4 | A52624E1D9D63 | 3 | RE | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
theta 2 * math.atan(math.sqrt(n-1))
qc.ry(theta,0)
for i in range(n-1):
theta = 2 * math.atan(math.sqrt(n-i-))
qc.cry(theta,[i],i+1)
qc.x(i)
return qc
''' | ||
QPC003_A4 | A52624E1D9D63 | 4 | WA | 1445 ms | 156 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
theta = 2 * math.atan(math.sqrt(n-1))
qc.ry(theta,0)
for i in range(n-1):
theta = 2 * math.atan(math.sqrt(n-i-1))
qc.cry(theta,i,i+1)
qc.x(i)
return qc
''' |
QPC003_A4 | A52624E1D9D63 | 5 | WA | 1270 ms | 155 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
theta = 2 * math.atan(math.sqrt(n-1))
qc.ry(theta,0)
for i in range(n-1):
theta = 2 * math.atan(math.sqrt(n-i-2))
qc.cry(theta,i,i+1)
qc.x(i)
return qc
''' |
QPC003_A4 | A52624E1D9D63 | 6 | WA | 1260 ms | 155 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
theta = 2 * math.atan(math.sqrt(n-1))
qc.ry(theta,0)
for i in range(n-2):
theta = 2 * math.atan(math.sqrt(n-i-2))
qc.cry(theta,i,i+1)
qc.x(i)
qc.ch(n-2,n-1)
qc.x(n-2)
return qc
''' |
QPC003_A4 | A52624E1D9D63 | 7 | WA | 1457 ms | 155 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
theta = 2 * math.atan(math.sqrt(n-1))
qc.ry(theta,0)
for i in range(n-2):
theta = 2 * math.atan(math.sqrt(n-i-2))
qc.cry(theta,i,i+1)
for i in range(n-1)[::-1]:
qc.cx(i+1,i)
qc.x(0)
return qc
''' |
QPC003_A4 | A52624E1D9D63 | 8 | RE | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
theta = 2 * math.atan(math.sqrt(n-1))
qc.ry(theta,0)
for i in range(n-2):
theta = 2 * math.atan(math.sqrt(n-i-2))
qc.cry(theta,i,i+1)
qc.(n-2,n-1)
for i in range(n-2)[::-1]:
qc.cx(i,i+1)
qc.x(0)
return qc
''' | ||
QPC003_A4 | A52624E1D9D63 | 9 | AC | 2027 ms | 157 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
theta = 2 * math.atan(math.sqrt(n-1))
qc.ry(theta,0)
for i in range(n-2):
theta = 2 * math.atan(math.sqrt(n-i-2))
qc.cry(theta,i,i+1)
qc.cx(n-2,n-1)
for i in range(n-2)[::-1]:
qc.cx(i,i+1)
qc.x(0)
return qc
''' |
QPC003_A4 | A544FC4A45151 | 1 | WA | 1620 ms | 155 MiB | '''python
from qiskit import QuantumCircuit
from math import sqrt, acos
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
# Rotación a cada qubit
theta = 2 * acos(1 / sqrt(n)) # Angulo
for qubit in range(n):
qc.ry(theta, qubit)
return qc
''' |
QPC003_A4 | A544FC4A45151 | 2 | WA | 1522 ms | 155 MiB | '''python
from qiskit import QuantumCircuit
from math import sqrt, acos
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.h(0)
# Aplicamos la puerta CNOT
for qubit in range(1, n):
qc.cx(0, qubit)
return qc
''' |
QPC003_A4 | A56E693AA011D | 1 | WA | 1328 ms | 155 MiB | '''python
from qiskit import QuantumCircuit
import numpy as np
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
# Step 1: Apply Ry rotation on the first qubit
angle = 2 * np.arcsin(np.sqrt(1.0 / n))
qc.ry(angle, 0)
# Step 2: Apply controlled Ry rotations on remaining qubits
for i in range(1, n):
angle = 2 * np.arcsin(np.sqrt(1.0 / (n - i)))
# Apply a multi-controlled Ry gate
qc.mcry(angle, list(range(i)), i)
return qc
''' |
QPC003_A4 | A56E693AA011D | 2 | WA | 1637 ms | 158 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import MCPhaseGate
import numpy as np
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
# Step 1: Apply Ry rotation on the first qubit
angle = 2 * np.arcsin(np.sqrt(1.0 / n))
qc.ry(angle, 0)
# Step 2: Apply controlled Ry rotations on remaining qubits
for i in range(1, n):
angle = 2 * np.arcsin(np.sqrt(1.0 / (n - i)))
# Apply a multi-controlled phase gate
mc_phase_gate = MCPhaseGate(angle, num_ctrl_qubits=i)
qc.append(mc_phase_gate, list(range(i)) + [i])
return qc
''' |
QPC003_A4 | A56E693AA011D | 3 | RE | 1176 ms | 154 MiB | '''python
from qiskit import QuantumCircuit
import numpy as np
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
# Step 1: Apply Ry rotation on the first qubit
angle = 2 * np.arcsin(np.sqrt(1.0 / n))
qc.ry(angle, 0)
# Step 2: Apply controlled Ry rotations on remaining qubits
for i in range(1, n):
angle = 2 * np.arcsin(np.sqrt(1.0 / (n - i)))
qc.mcz(angle, list(range(i)), i)
return qc
''' |
QPC003_A4 | A56E693AA011D | 4 | WA | 1555 ms | 155 MiB | '''python
from qiskit import QuantumCircuit
import numpy as np
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
# Step 1: Apply Ry rotation on the first qubit
angle = 2 * np.arcsin(np.sqrt(1.0 / n))
qc.ry(angle, 0)
# Step 2: Apply controlled Ry rotations on remaining qubits
for i in range(1, n):
angle = 2 * np.arcsin(np.sqrt(1.0 / (n - i)))
qc.mcrz(angle, list(range(i)), i)
return qc
''' |
QPC003_A4 | A596EFACEE8C1 | 1 | AC | 2929 ms | 170 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import RYGate
import math
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for k in range(n):
theta = 2 * math.asin(1 / math.sqrt(n - k))
if k == 0:
qc.ry(theta, 0)
else:
# Apply X to qubits 0..k-1
for i in range(k):
qc.x(i)
# Create a controlled Ry gate with k controls (all must be 1)
cry_gate = RYGate(theta).control(k, ctrl_state='1'*k)
qc.append(cry_gate, list(range(k)) + [k])
# Apply X again to qubits 0..k-1
for i in range(k):
qc.x(i)
return qc
''' |
QPC003_A4 | A5D1E311D0483 | 1 | RE | 1385 ms | 154 MiB | '''python
from qiskit import QuantumCircuit
from qiskit import QuantumCircuit, QuantumRegister
import numpy as np
import math
def solve() -> QuantumCircuit:
# qc = QuantumCircuit(3)z
# # Write your code here:
# q = QuantumRegister(3)
def F_gate(circ,q,i,j,n,k) :
theta = np.arccos(np.sqrt(1/(n-k+1)))
circ.ry(-theta,q[j])
circ.cz(q[i],q[j])
circ.ry(theta,q[j])
circ.barrier(q[i])
# Define the cxrv gate which uses reverse CNOT instead of CNOT
def cxrv(circ,q,i,j) :
circ.h(q[i])
circ.h(q[j])
circ.cx(q[j],q[i])
circ.h(q[i])
circ.h(q[j])
circ.barrier(q[i],q[j])
# 3-qubit W state
flag_qx2 = True
n = 4
q_w = QuantumRegister(n)
qc = QuantumCircuit(q_w)
qc.x(q_w[2]) #start is |100>
F_gate(qc,q_w,2,1,3,1) # Applying F12
F_gate(qc,q_w,1,0,3,2) # Applying F23
if flag_qx2 : # option ibmqx2
qc.cx(q_w[1],q_w[2]) # cNOT 21
qc.cx(q_w[0],q_w[1]) # cNOT 32
else : # option ibmqx4
cxrv(qc,q_w,1,2)
cxrv(qc,q_w,0,1)
return qc
''' |
QPC003_A4 | A5D1E311D0483 | 2 | RE | 1269 ms | 154 MiB | '''python
from qiskit import QuantumCircuit
from qiskit import QuantumCircuit, QuantumRegister
import numpy as np
import math
def solve(n: int) -> QuantumCircuit:
# qc = QuantumCircuit(n)
# Write your code here:
q_w = QuantumRegister(n)
qc = QuantumCircuit(q_w)
def F_gate(circ,q,i,j,n,k) :
theta = np.arccos(np.sqrt(1/(n-k+1)))
circ.ry(-theta,q[j])
circ.cz(q[i],q[j])
circ.ry(theta,q[j])
circ.barrier(q[i])
# Define the cxrv gate which uses reverse CNOT instead of CNOT
def cxrv(circ,q,i,j) :
circ.h(q[i])
circ.h(q[j])
circ.cx(q[j],q[i])
circ.h(q[i])
circ.h(q[j])
circ.barrier(q[i],q[j])
# 4-qubit W state
# n = 4
# q = QuantumRegister(n)
# c = ClassicalRegister(n)
# W_states = QuantumCircuit(q,c)
qc.x(q[3]) #start is |1000>
F_gate(qc,q,3,2,4,1) # Applying F12
F_gate(qc,q,2,1,4,2) # Applying F23
F_gate(qc,q,1,0,4,3) # Applying F34
cxrv(qc,q,2,3) # cNOT 21
qc.cx(q[1],q[2]) # cNOT 32
qc.cx(q[0],q[1]) # cNOT 43
return qc
''' |
QPC003_A4 | A65A1EF0FBF36 | 1 | AC | 2449 ms | 161 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.x(0)
for i in range(0, n-1):
theta = math.atan(math.sqrt(n-i-1)) * 2
qc.cry(theta, i, i+1)
qc.cx(i+1, i)
return qc
''' |
QPC003_A4 | A6B0EDA1EEE42 | 1 | WA | 1325 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)
return qc
''' |
QPC003_A4 | A6E9820C74560 | 1 | AC | 2182 ms | 157 MiB | '''python
from qiskit import QuantumCircuit
from math import sqrt, atan
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
theta = 2*atan(sqrt(n-1))
qc.ry(theta, 0)
for i in range(1, n-1):
theta = 2*atan(sqrt(n-1-i))
qc.cry(theta, i-1, i)
for i in range(0, n-1):
qc.cx(n-i-2, n-i-1)
qc.x(0)
return qc
''' |
QPC003_A4 | A735662C11D5C | 1 | AC | 2663 ms | 169 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library.standard_gates import RYGate
import math
# from qiskit.quantum_info import Statevector
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.ry(math.asin(1/math.sqrt(n))*2, 0)
for i in range(1, n):
for j in range(i):
qc.x(j)
qc.append(RYGate(math.asin(1/math.sqrt(n-i))*2).control(i), range(i+1))
for j in range(i):
qc.x(j)
return qc
# if __name__ == "__main__":
# qc = solve(3)
# print(Statevector(qc))
''' |
QPC003_A4 | A7457B805C611 | 1 | AC | 1881 ms | 158 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
theta_list=[0,0]
for i in range(2,n+1):
theta_list.append(4*math.atan(math.sqrt(i*(i-1))/(i+math.sqrt(i))))
qc.ry(theta_list[n],0)
for i in range(n-2):
qc.cry(theta_list[n-i-1],i,i+1)
for i in range(n-1)[::-1]:
qc.cx(i,i+1)
qc.x(0)
return qc
''' |
QPC003_A4 | A74C263C99CA7 | 1 | RE | '''python
from qiskit import QuantumCircuit
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.h(0)
for i in range(n - 1):
qc.cx(i, i + 1)
qc.cx(n - 1)
qc.cx(0, n - 1)
for i in range(1, n - 1)
qc.cx(i, i - 1)
return qc
''' | ||
QPC003_A4 | A74C263C99CA7 | 2 | RE | '''python
from qiskit import QuantumCircuit
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.h(0)
for i in range(n - 1):
qc.cx(i, i + 1)
qc.x(n - 1)
qc.cx(0, n - 1)
for i in range(1, n - 1)
qc.cx(i, i - 1)
return qc
''' | ||
QPC003_A4 | A74C263C99CA7 | 3 | WA | 1689 ms | 160 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.h(0)
for i in range(n - 1):
qc.cx(i, i + 1)
qc.x(n - 1)
qc.cx(0, n - 1)
for i in range(1, n - 1):
qc.cx(i, i - 1)
return qc
''' |
QPC003_A4 | A74C263C99CA7 | 4 | WA | 1715 ms | 159 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.h(0)
for i in range(n - 1):
qc.ch(i, i + 1)
qc.x(n - 1)
qc.cx(0, n - 1)
for i in range(1, n - 1):
qc.cx(i, i - 1)
return qc
''' |
QPC003_A4 | A74C263C99CA7 | 5 | RE | 1889 ms | 156 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
th = 2 * math.atan(math.sqrt(n - 1))
qc.ry(th, 0)
for i in range(n - 1):
th = 2 * math.atan(math.sqrt(n - 2 - i))
qc.cry(th, i, i + 1)
qc.x(n - 1)
qc.cx(0, n - 1)
for i in range(1, n - 1):
qc.cx(i, i - 1)
return qc
''' |
QPC003_A4 | A74C263C99CA7 | 6 | AC | 2427 ms | 161 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
th = 2 * math.atan(math.sqrt(n - 1))
qc.ry(th, 0)
for i in range(n - 1):
th = 2 * math.atan(math.sqrt(n - 2 - i))
qc.cry(th, i, i + 1)
qc.x(n - 1)
qc.cx(0, n - 1)
for i in range(1, n - 1):
qc.cx(i, i - 1)
return qc
''' |
QPC003_A4 | A78BBB3CA5E9D | 1 | RE | 1355 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-1):
p = math.sqrt(1/(n-i))
qc.ry(2*math.acos(p), i)
qc.cx(i, i+1)
qc.x(i)
qc.ch(n-1, n)
qc.cx(n, n-1)
return qc
''' |
QPC003_A4 | A78BBB3CA5E9D | 2 | RE | 1432 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-1):
p = math.sqrt(1/(n-i))
qc.ry(2*math.acos(p), i)
qc.cx(i, i+1)
qc.x(i)
qc.ch(n-2, n-1)
qc.cx(n-1, n-2)
return qc
''' |
QPC003_A4 | A78BBB3CA5E9D | 3 | RE | 1656 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-1):
p = math.sqrt(1/(n-i))
qc.ry(2*math.acos(p), i)
qc.cx(i, i+1)
qc.x(i)
# qc.ch(n-2, n-1)
# qc.cx(n-, n-2)
return qc
''' |
QPC003_A4 | A78BBB3CA5E9D | 4 | RE | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n-1):
p = math.sqrt(1/(n-i))
qc.ry(2*math.acos(p), i)
qc.cx(i, i+1)
qc.x(i)
qc.ch(n-2, n-1)
qc.cx(n-, n-2)
return qc
''' | ||
QPC003_A4 | A78BBB3CA5E9D | 5 | WA | 2461 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-1):
p = math.sqrt(1/(n-i))
qc.ry(2*math.acos(p), i)
qc.cx(i, i+1)
qc.x(i)
qc.ch(n-2, n-1)
qc.cx(n-1, n-2)
return qc
''' |
QPC003_A4 | A7D25DE87BBDE | 1 | WA | 1319 ms | 155 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
theta = 2 * math.acos(1 / math.sqrt(n))
qc.x(n - 1)
qc.ry(theta, 0)
for i in range(1, n - 1):
qc.ch(i - 1, i)
qc.cx(0, n - 1)
return qc
''' |
QPC003_A4 | A7D25DE87BBDE | 2 | RE | 1212 ms | 154 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int) -> QuantumCircuit:
n=3
qc = QuantumCircuit(n)
'theta = 2 * math.acos(1 / math.sqrt(n))'
qc.x(n - 1)
qc.ry(theta, 0)
for i in range(1, n - 1):
qc.ch(i - 1, i)
qc.cx(0, n - 1)
return qc
''' |
QPC003_A4 | A7D25DE87BBDE | 3 | WA | 1482 ms | 156 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
theta = 2 * math.acos(1 / math.sqrt(n))
qc.x(n - 1)
qc.ry(theta, 0)
for i in range(1, n - 1):
qc.ch(i - 1, i)
for i in range(1,n):
qc.cx(n - i - 1, n - i)
return qc
''' |
QPC003_A4 | A883D36C18B04 | 1 | AC | 1781 ms | 157 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import GlobalPhaseGate
import numpy as np
import math
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.x(0)
split(qc, 0, n)
return qc
def split(qc, stIncl, edExcl):
if stIncl + 1 == edExcl:
return
mid = (stIncl + edExcl) // 2
left = mid - stIncl
right = edExcl - mid
print(f'{left=} {right=}')
angle = 2*math.atan(math.sqrt(right/left))
qc.cry(angle, stIncl, mid)
qc.cx(mid, stIncl)
split(qc, stIncl, mid)
split(qc, mid, edExcl)
return qc
''' |
QPC003_A4 | A8B444D8B9172 | 1 | AC | 1930 ms | 157 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
theta = [2 * math.atan(math.sqrt(i)) for i in range(n - 1, 0, -1)]
qc.x(0)
for i in range(n - 1):
qc.cry(theta[i], i, i + 1)
qc.cx(i + 1, i)
return qc
''' |
QPC003_A4 | A8CF0180140B4 | 1 | AC | 1884 ms | 157 MiB | '''python
from qiskit import QuantumCircuit
from math import asin
def move(qc, f, t, ratio):
theta = 2 * asin(ratio**0.5)
qc.cry(theta, f, t)
qc.cx(t, f)
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.x(0)
parent = [None]
for i in range(1, n):
for r in (8, 4, 2, 1):
if i & r:
parent.append(i - r)
break
# print(parent)
ww = [0] * n
for i in range(n - 1, -1, -1):
ww[i] += 1 / n
if parent[i] is not None:
ww[parent[i]] += ww[i]
# print(ww)
xx = [0] * n
xx[0] = 1
for i in range(1, n):
p = parent[i]
move(qc, p, i, ww[i] / xx[p])
xx[p] -= ww[i]
xx[i] = ww[i]
return qc
''' |
QPC003_A4 | A8EA69EACC806 | 1 | UME | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import ZGate, XGate, HGate, SwapGate
import math
"""
You can apply oracle as follows:
qc.compose(o, inplace=True)
"""
def 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:
qc = QuantumCircuit(n)
qc.x(0)
count = 1
# queue = [(a, b, control bit of CRy), ...]
queue = [(n // 2, n, 0)]
# breadth first search
while len(queue):
a, b, control = queue.pop(0)
if a == 0:
continue
theta = 2 * math.atan(math.sqrt((b - a) / a))
qc.cry(theta, control, count)
qc.cx(count, control)
queue.append(((b // 2) // 2, b // 2, control))
queue.append((math.ceil(b / 2) // 2, math.ceil(b / 2), count))
count += 1
return qc
if __name__ == "__main__":
from qiskit.quantum_info import Statevector
import numpy as np
n = 3
qc = solve(n)
sv = Statevector(qc)
print(sv)
print(qc)
print(f"{qc.depth() = }")
# sv = Statevector.from_label('01000')
# print(sv.evolve(qc))
''' | ||
QPC003_A4 | A8ECB599D8C10 | 1 | AC | 1867 ms | 157 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.x(0)
for i in range(1, n):
qc.cry(2 * math.acos(1.0 / math.sqrt(n - i + 1)), i - 1, i)
for i in range(1, n):
qc.cx(i, i - 1)
return qc
''' |
QPC003_A4 | A90B6F2C8381A | 1 | RE | 1402 ms | 154 MiB | '''python
from qiskit import QuantumCircuit
from math import sqrt, atan
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.x(0)
for i in range(n-1):
t = 2*asin(sqrt(1/(n-i)))
qc.cry(t, 0, i+1)
qc.cx(i+1, 0)
return qc
''' |
QPC003_A4 | A90B6F2C8381A | 2 | AC | 1724 ms | 157 MiB | '''python
from qiskit import QuantumCircuit
from math import sqrt, asin
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.x(0)
for i in range(n-1):
t = 2*asin(sqrt(1/(n-i)))
qc.cry(t, 0, i+1)
qc.cx(i+1, 0)
return qc
''' |
QPC003_A4 | A966EED31F255 | 1 | AC | 2938 ms | 160 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.x(0)
for i in range(n-1):
print(i)
theta = 2 * math.atan(math.sqrt(n - i - 1))
print(math.cos(theta/2))
qc.cry(theta, i, i+1)
qc.cx(i+1, i)
return qc
''' |
QPC003_A4 | A9A67E2BB6C22 | 1 | AC | 1730 ms | 158 MiB | '''python
from qiskit import QuantumCircuit
import math
import numpy
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.x(0)
for i in range(n - 1):
theta = 2 * numpy.arccos(math.sqrt(1/(n - i)))
qc.cry(theta, i, i + 1)
for i in range(n - 1):
qc.cx(i + 1, i)
return qc
''' |
QPC003_A4 | A9AEE2D7F7B64 | 1 | RE | 1465 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 = 2 * np.arcsin(np.sqrt(1/3))
qc.ry(theta, 0)
qc.cx(0, 1)
qc.cx(0, 2)
theta = 2 * np.arcsin(np.sqrt(1/n))
qc.ry(theta, 0)
for i in range(1, n):
qc.cx(0, i)
return qc
''' |
QPC003_A4 | A9AEE2D7F7B64 | 2 | WA | 1395 ms | 155 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
# 回転角 θ を計算 (θ = 2 * arcsin(√(1/n)))
theta = 2 * math.asin(math.sqrt(1/n))
# 第1量子ビットに Ry ゲートを適用して重ね合わせを作成
qc.ry(theta, 0)
# 第1量子ビットが 1 のとき、他の量子ビットにエンタングルメントを作成
for i in range(1, n):
qc.cx(0, i)
return qc
''' |
QPC003_A4 | A9B4815FB0282 | 1 | WA | 1422 ms | 157 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.x(0)
for i in range(n-1):
theta = 2 * math.acos((n-i)**-0.5)
qc.cry(theta, i, i+1)
qc.cx(i+1, 0)
return qc
''' |
QPC003_A4 | A9B4815FB0282 | 2 | AC | 1727 ms | 157 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.x(0)
for i in range(n-1):
theta = 2 * math.acos((n-i)**-0.5)
qc.cry(theta, i, i+1)
qc.cx(i+1, i)
return qc
''' |
QPC003_A4 | A9C50D9C11712 | 1 | RE | 1491 ms | 154 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve() -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.x(0)
for i in range(1,n):
theta = math.atan(1/math.sqrt(n-i))*2
qc.cry(theta, 0, i)
qc.cx(i,0)
qc.x(0)
for i in range(1,n):
qc.cx(i,0)
return qc
''' |
QPC003_A4 | A9C50D9C11712 | 2 | RE | 1175 ms | 153 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve() -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.x(0)
for i in range(1,n):
theta = math.atan(math.sqrt(n-i))*2
qc.cry(theta, i - 1, i)
qc.cx(i,i - 1)
return qc
''' |
QPC003_A4 | A9C50D9C11712 | 3 | AC | 1646 ms | 157 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.x(0)
for i in range(1,n):
theta = math.atan(math.sqrt(n-i))*2
qc.cry(theta, i-1, i)
qc.cx(i,i-1)
return qc
''' |
QPC003_A4 | A9CB640D3C799 | 1 | RE | 1377 ms | 154 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.h(0)
for i in range(n):
qc.cx(i, i+1)
return qc
''' |
QPC003_A4 | AA7CCD31CA864 | 1 | RE | 1238 ms | 154 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.ry(2 * math.acos(1 / math.sqrt(n)), 0)
for i in range(1, n):
angle = 2 * math.acos(math.sqrt((n - i) / (n - i + 1)))
qc.cry(angle, i - 1, i)
return qc
''' |
QPC003_A4 | AA7CCD31CA864 | 2 | WA | 1302 ms | 155 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.ry(2 * math.acos(1 / math.sqrt(n)), 0)
for i in range(1, n):
angle = 2 * math.acos(math.sqrt((n - i) / (n - i + 1)))
qc.cry(angle, i - 1, i)
return qc
''' |
QPC003_A4 | AA7CCD31CA864 | 3 | UME | '''python
from qiskit import QuantumCircuit, QuantumRegister
import mat
def F_gate(circ,q,i,j,n,k) :
theta = math.acos(math.sqrt(1/(n-k+1)))
circ.ry(-theta,q[j])
circ.cz(q[i],q[j])
circ.ry(theta,q[j])
circ.barrier(q[i])
def cxrv(circ,q,i,j) :
circ.h(q[i])
circ.h(q[j])
circ.cx(q[j],q[i])
circ.h(q[i])
circ.h(q[j])
circ.barrier(q[i],q[j])
def solve(n: int) -> QuantumCircuit:
q = QuantumRegister(n)
qc = QuantumCircuit(q)
# Write your code here:
qc.x(n-1)
for i in range(1, n):
F_gate(qc, q, n-i, n-i-1, n, i)
for i in range(1, n):
cxrv(qc, q, n-i-1, n-i)
return qc
''' | ||
QPC003_A4 | AA7CCD31CA864 | 4 | AC | 1747 ms | 156 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def F_gate(circ,q,i,j,n,k) :
theta = math.acos(math.sqrt(1/(n-k+1)))
circ.ry(-theta,q[j])
circ.cz(q[i],q[j])
circ.ry(theta,q[j])
circ.barrier(q[i])
def cxrv(circ,q,i,j) :
circ.h(q[i])
circ.h(q[j])
circ.cx(q[j],q[i])
circ.h(q[i])
circ.h(q[j])
circ.barrier(q[i],q[j])
def solve(n: int) -> QuantumCircuit:
q = QuantumRegister(n)
qc = QuantumCircuit(q)
# Write your code here:
qc.x(n-1)
for i in range(1, n):
F_gate(qc, q, n-i, n-i-1, n, i)
for i in range(1, n):
cxrv(qc, q, n-i-1, n-i)
return qc
''' |
QPC003_A4 | AAC7A3E020E2B | 1 | WA | 2186 ms | 160 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-1):
qc.ry(math.asin(1/math.sqrt(n-i)), i)
qc.x(i)
qc.cx(i,i+1)
qc.x(i)
return qc
''' |
QPC003_A4 | AAC7A3E020E2B | 2 | WA | 1835 ms | 162 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-1):
qc.ry(2*math.asin(1/math.sqrt(n-i)), i)
qc.x(i)
qc.cx(i,i+1)
qc.x(i)
return qc
''' |
QPC003_A4 | AAC7A3E020E2B | 3 | WA | 1781 ms | 162 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.ry(2*math.asin(1/math.sqrt(n)), 0)
for i in range(n-1):
qc.x(i)
qc.cry(2*math.asin(1/math.sqrt(n-i-1)),i,i+1)
qc.x(i)
return qc
''' |
QPC003_A4 | AACD11E48F8A5 | 1 | WA | 1520 ms | 156 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
import numpy as np
qc.ry(2 * np.arccos(1 / np.sqrt(n)), 0)
for i in range(n-1):
qc.ch(0, i+1)
qc.cx(n-i-1, n-i-2)
qc.x(0)
return qc
''' |
QPC003_A4 | AACD11E48F8A5 | 2 | WA | 1379 ms | 155 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
import numpy as np
def theta(k):
return np.arccos(np.sqrt(1 / (n-k+1)))
for k in range(n-1):
qc.ry(- theta(k), k+1)
qc.cz(k, k+1)
qc.ry(theta(k), k+1)
for i in range(n-1):
qc.cx(i+0, i+1)
return qc
''' |
QPC003_A4 | AAF05F377A3C1 | 1 | AC | 1887 ms | 157 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
qc.r(2*math.acos(1.0/math.sqrt(n)), math.pi/2, 0)
for i in range(n-2):
qc.crx(2*math.acos(1.0/math.sqrt(n-i-1)), i, i+1)
qc.cp(math.pi/2, i, i+1)
for i in range(n-1):
qc.cx(n-2-i, n-1-i)
qc.x(0)
return qc
''' |
QPC003_A4 | AB818321B8959 | 1 | AC | 1872 ms | 157 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
qc.x(0)
for i in range(n-1):
theta = 2 * math.acos(1 / math.sqrt(n - i))
qc.cry(theta, i, i+1)
qc.cx(i+1, i)
return qc
''' |
QPC003_A4 | ABB1E7B0FE23D | 1 | RE | 1216 ms | 154 MiB | '''python
from qiskit import QuantumCircuit
import math
def calc(n):
return math.acos(1/n**(1/2))
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
#前側をすべて1に
for j in range(i):
qc.x(j)
theta = 2*calc(n-i)
if i >= 1:
qc.mcry(theta, list(range(i)), i+1)
else:
qc.ry(theta, 0)
for j in range(i+1):
qc.x(j)
return qc
''' |
QPC003_A4 | ABB1E7B0FE23D | 2 | WA | 1689 ms | 155 MiB | '''python
from qiskit import QuantumCircuit
import math
def calc(n):
return math.acos(1/n**(1/2))
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
#前側をすべて1に
for j in range(i):
qc.x(j)
theta = 2*calc(n-i)
if i >= 1:
qc.mcry(theta, list(range(i)), i)
else:
qc.ry(theta, 0)
for j in range(i+1):
qc.x(j)
return qc
''' |
QPC003_A4 | ABB1E7B0FE23D | 3 | WA | 1256 ms | 156 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import RYGate
import math
def calc(n):
return math.acos(1/n**(1/2))
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
#前側をすべて1に
for j in range(i):
qc.x(j)
theta = 2*calc(n-i)
if i >= 1:
ccry = RYGate(theta).control(num_ctrl_qubits=i, label=None)
#qc.mcry(theta, list(range(i)), i)
qc.append(ccry, list(range(i+1)))
else:
qc.ry(theta, 0)
for j in range(i+1):
qc.x(j)
return qc
''' |
QPC003_A4 | ABB1E7B0FE23D | 4 | WA | 1332 ms | 154 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import RYGate
import math
def calc(n):
return math.acos(1/n**(1/2))
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
#前側をすべて1に
for j in range(i):
qc.x(j)
theta = 2*calc(n-i)
if i >= 1:
ccry = RYGate(theta).control(num_ctrl_qubits=i, label=None)
#qc.mcry(theta, list(range(i)), i)
qc.append(ccry, list(range(i+1)))
else:
qc.ry(theta, 0)
for j in range(i+1):
qc.x(j)
return qc
''' |
QPC003_A4 | ABB1E7B0FE23D | 5 | WA | 1527 ms | 157 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import RYGate
import math
def calc(n):
return math.acos(1/n**(1/2))
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
#前側0をすべて1に
for j in range(i):
qc.x(j)
theta = 2*calc(n-i)
if i >= 1:
ccry = RYGate(theta).control(num_ctrl_qubits=i, label=None)
#qc.mcry(theta, list(range(i)), i)
qc.append(ccry, list(range(i+1)))
else:
qc.ry(theta, 0)
for j in range(i):
qc.x(j)
return qc
''' |
QPC003_A4 | ABB1E7B0FE23D | 6 | WA | 1578 ms | 160 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import RYGate
import math
def calc(n):
return math.acos(1/n**(1/2))
def solve(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n-1):
#前側0をすべて1に
for j in range(i):
qc.x(j)
theta = 2*calc(n-i)
if i >= 1:
ccry = RYGate(theta).control(num_ctrl_qubits=i, label=None)
#qc.mcry(theta, list(range(i)), i)
qc.append(ccry, list(range(i+1)))
else:
qc.ry(theta, 0)
#0->1にしてたやつを戻す
for j in range(i):
qc.x(j)
for i in range(n-1):
qc.x(i)
qc.mcx(list(range(n-1)), n-1)
for i in range(n-1):
qc.x(i)
return qc
''' |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.