problem stringclasses 67
values | user stringlengths 13 13 | submission_order int64 1 57 | result stringclasses 10
values | execution_time stringlengths 0 8 | memory stringclasses 88
values | code stringlengths 47 7.62k |
|---|---|---|---|---|---|---|
QPC002_B5 | A6F060F6D6BD4 | 1 | RE | 1150 ms | 141 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.p(2. * np.pi / (2 ** m) * S[i], i)
return qc
''' |
QPC002_B5 | A6F060F6D6BD4 | 2 | AC | 2597 ms | 184 MiB | '''python
from qiskit import QuantumCircuit
import numpy as np
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.p(2. * np.pi / (2 ** m) * S[i], i)
return qc
''' |
QPC002_B5 | A760E2B00CF6F | 1 | WA | 1674 ms | 155 MiB | '''python
from math import pi
from qiskit import QuantumCircuit
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i, s in enumerate(S):
angle = 2 * pi / 2 ** m
qc.rz(angle / 2, i)
return qc
''' |
QPC002_B5 | A760E2B00CF6F | 2 | WA | 1234 ms | 154 MiB | '''python
from math import pi
from qiskit import QuantumCircuit
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i, s in enumerate(S):
if s == 1:
qc.x(i)
angle = 2 * pi / 2 ** m
qc.rz(angle / 2, i)
return qc
''' |
QPC002_B5 | A760E2B00CF6F | 3 | WA | 1452 ms | 155 MiB | '''python
from math import pi
from qiskit import QuantumCircuit
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i, s in enumerate(S):
if s == 1:
qc.x(i)
angle = 2 * pi / 2 ** m
qc.rz(angle, i)
return qc
''' |
QPC002_B5 | A760E2B00CF6F | 4 | WA | 1366 ms | 156 MiB | '''python
from math import pi
from qiskit import QuantumCircuit
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i, s in enumerate(S):
angle = 2 * pi * s / 2 ** m
if s == 1:
qc.x(i)
qc.p(angle, i)
return qc
''' |
QPC002_B5 | A760E2B00CF6F | 5 | AC | 2071 ms | 156 MiB | '''python
from math import pi
from qiskit import QuantumCircuit
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i, s in enumerate(S):
angle = 2 * pi * s / 2 ** m
qc.p(angle, i)
return qc
''' |
QPC002_B5 | A8044CD175B59 | 1 | WA | 1450 ms | 141 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate,XGate,PhaseGate
import math
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for l in range(2**n):
theta = 0
for i in range(n):
# check if i-th bit of l is 0 or 1
if not ((l >> i) & 1):
qc.x(i)
else:
theta += (1<<i)*S[i]
if n == 1:
qc.p(math.pi * theta / 2**m,0)
else:
# apply multiple controlled Z gate
qc.append(PhaseGate(theta=math.pi * theta/(2**m)).control(n - 1), range(n))
for i in range(n):
if not ((l >> i) & 1):
qc.x(i)
return qc
''' |
QPC002_B5 | A8044CD175B59 | 2 | AC | 2232 ms | 183 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate,XGate
import math
def solve(n: int, m:int, S:list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
qc.p(S[i] * 2 * math.pi / 2 ** m,i)
return qc
# for n in range(5):
# for l in range(2**(n+1)):
# print(f"{n+1} {l+1}")
# solve(n+1,l+1)
''' |
QPC002_B5 | A88554730A452 | 1 | AC | 2655 ms | 183 MiB | '''python
from qiskit import QuantumCircuit
import numpy as np
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.p(2*np.pi*S[i]/2**m, i)
return qc
''' |
QPC002_B5 | A887EF4D7090A | 1 | RE | 1346 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
for j in range(m):
if (S[i] >> j) & 1:
qc.cp(2 * np.pi / (2 ** m), i)
return qc
''' |
QPC002_B5 | A887EF4D7090A | 2 | RE | 1417 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
if S[i] != 0:
phase_shift = 2 * np.pi * S[i] / (2 ** m)
qc.p(phase_shift, i)
return qc
''' |
QPC002_B5 | A887EF4D7090A | 3 | RE | 1214 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
if(i==0):
continue
if S[i] != 0:
phase_shift = 2 * np.pi * S[i] / (2 ** m)
qc.p(phase_shift, i)
return qc
''' |
QPC002_B5 | A887EF4D7090A | 4 | RE | 1125 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
if(i==0):
continue
if S[i] != 0:
phase_shift = 2 * math.pi * S[i] / (2 ** m)
qc.p(phase_shift, i)
return qc
''' |
QPC002_B5 | A887EF4D7090A | 5 | WA | 1493 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
if(i==0):
continue
if S[i] != 0:
phase_shift = 2 * 3.141592 * S[i] / (2 ** m)
qc.p(phase_shift, i)
return qc
''' |
QPC002_B5 | A887EF4D7090A | 6 | WA | 1397 ms | 182 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
if(i==0):
continue
if S[i] != 0:
phase_shift = 2 * math.pi * S[i] / (2 ** m)
qc.p(phase_shift, i)
return qc
''' |
QPC002_B5 | A887EF4D7090A | 7 | AC | 2014 ms | 184 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
if S[i] != 0:
phase_shift = 2 * 3.141592 * S[i] / (2 ** m)
qc.p(phase_shift, i)
return qc
''' |
QPC002_B5 | A8E2BBFB3AAE9 | 1 | AC | 2167 ms | 160 MiB | '''python
from qiskit import QuantumCircuit
def solve(n, m, s) -> QuantumCircuit:
from numpy import pi
qc = QuantumCircuit(n)
for i in range(n):
qc.p(pi * s[i] / 2**(m - 1), i)
return qc
''' |
QPC002_B5 | A9033B76F8EC4 | 1 | AC | 2366 ms | 183 MiB | '''python
from qiskit import QuantumCircuit
from math import pi
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
angle = 2 * pi * S[i] / (2**m)
qc.p(angle, i)
return qc
''' |
QPC002_B5 | A90D303846997 | 1 | RE | 1340 ms | 141 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import PhaseGate
from math import pi
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
qc.x([0, 1])
# Write your code here:
if n == 1:
theta = 2 * pi * S[0] / (2 ** m)
qc.p(theta, 0)
else:
for i in range(n):
theta = 2 * pi * S[i] / (2 ** m)
qc.p(theta, i)
# mp = PhaseGate(theta).control(2)
# qc.append(mp, range(n))
return qc
''' |
QPC002_B5 | A90D303846997 | 2 | AC | 2270 ms | 184 MiB | '''python
from qiskit import QuantumCircuit
# from qiskit.circuit.library import PhaseGate
from math import pi
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# qc.x([0, 1])
# Write your code here:
if n == 1:
theta = 2 * pi * S[0] / (2 ** m)
qc.p(theta, 0)
else:
for i in range(n):
theta = 2 * pi * S[i] / (2 ** m)
qc.p(theta, i)
# mp = PhaseGate(theta).control(2)
# qc.append(mp, range(n))
return qc
''' |
QPC002_B5 | A929DDB0B4A4C | 1 | AC | 2027 ms | 183 MiB | '''python
from qiskit import QuantumCircuit
from math import pi
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.p(2 * pi * S[i] / 2 ** m, i)
return qc
''' |
QPC002_B5 | A962B2AC18595 | 1 | RE | 1218 ms | 141 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.p(2.0*np.pi/(2.0**m)*S[i], i)
return qc
''' |
QPC002_B5 | A962B2AC18595 | 2 | AC | 2122 ms | 183 MiB | '''python
from qiskit import QuantumCircuit
import numpy as np
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.p(2.0*np.pi/(2.0**m)*S[i], i)
return qc
''' |
QPC002_B5 | A97272D97D461 | 1 | RE | 1706 ms | 150 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for k in range(n):
theta = 2*math.pi()*S[k]//2**m
qc.p(theta,k)
return qc
''' |
QPC002_B5 | A97272D97D461 | 2 | RE | 1550 ms | 149 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for k in range(n):
theta = 2*math.pi*S[k]//2**m
qc.p(theta,k)
return qc
''' |
QPC002_B5 | A97272D97D461 | 3 | AC | 1899 ms | 152 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for k in range(n):
theta = 2*math.pi*S[k]/2**m
qc.p(theta,k)
return qc
''' |
QPC002_B5 | A9839A6D299F5 | 1 | WA | 1420 ms | 141 MiB | '''python
from qiskit import QuantumCircuit
import numpy as np
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
angle = 2 * np.pi * S[i]
qc.p(angle, i)
return qc
''' |
QPC002_B5 | A9839A6D299F5 | 2 | RE | 1321 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
import numpy as n
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
angle = 2 * np.pi * S[i] / 2**m
qc.p(angle, i)
return qc
''' |
QPC002_B5 | A9839A6D299F5 | 3 | AC | 1818 ms | 183 MiB | '''python
from qiskit import QuantumCircuit
import numpy as np
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
angle = 2 * np.pi * S[i] / 2**m
qc.p(angle, i)
return qc
''' |
QPC002_B5 | AA4AD89664AA9 | 1 | RE | 1904 ms | 183 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
qc.x(1)
# Write your code here:
for i in range(n):
qc.p(2*math.pi*S[i]/(1<<m), i)
return qc
''' |
QPC002_B5 | AA4AD89664AA9 | 2 | AC | 2032 ms | 183 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.p(2*math.pi*S[i]/(1<<m), i)
return qc
''' |
QPC002_B5 | AA588D4784175 | 1 | RE | 1150 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
phase_factor = 2.0*np.pi/(2.0**m)
for i,s in enumerate(s):
qc.p(phase_factor*s, i)
return qc
''' |
QPC002_B5 | AA588D4784175 | 2 | RE | 1398 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
import numpy as np
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
phase_factor = 2.0*np.pi/(2.0**m)
for i,s in enumerate(s):
qc.p(phase_factor*s, i)
return qc
''' |
QPC002_B5 | AA588D4784175 | 3 | AC | 1704 ms | 183 MiB | '''python
from qiskit import QuantumCircuit
import numpy as np
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
phase_factor = 2.0*np.pi/(2.0**m)
for i in range(n):
qc.p(phase_factor*S[i], i)
return qc
''' |
QPC002_B5 | AB01925FE41CC | 1 | RE | 1402 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
# Calculate the phase angle for the current qubit
phase_angle = 2 * np.pi * S[i] / (2 ** m)
# Apply the phase gate to the i-th qubit
qc.p(phase_angle, i)
return qc
''' |
QPC002_B5 | AB01925FE41CC | 2 | RE | '''python
from qiskit import QuantumCircuit
!pip install numpy
import numpy as np
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
# Calculate the phase angle for the current qubit
phase_angle = 2 * np.pi * S[i] / (2 ** m)
# Apply the phase gate to the i-th qubit
qc.p(phase_angle, i)
return qc
''' | ||
QPC002_B5 | AB01925FE41CC | 3 | AC | 2695 ms | 183 MiB | '''python
from qiskit import QuantumCircuit
import numpy as np
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
# Calculate the phase angle for the current qubit
phase_angle = 2 * np.pi * S[i] / (2 ** m)
# Apply the phase gate to the i-th qubit
qc.p(phase_angle, i)
return qc
''' |
QPC002_B5 | AB50A97D62FE6 | 1 | RE | 1224 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for x in range(2**n):
fx = sum(S[i] * ((x >> i) & 1) for i in range(n))
phase = 2 * np.pi * fx / (2**m)
qc.append(PhaseGate(phase), range(n))
return qc
''' |
QPC002_B5 | ABF6840B751CF | 1 | WA | 1897 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import PhaseGate
import math
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
theta=math.pi
#theta*=2**i
theta/=2**m
theta*=S[i]
qc.p(theta,i)
# Write your code here:
return qc
''' |
QPC002_B5 | AC36B32B73A3D | 1 | AC | 2028 ms | 184 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.p(2*math.pi*S[i]/2**m, i)
return qc
''' |
QPC002_B5 | AC9153EF58202 | 1 | RE | 2937 ms | 158 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here
for i in range (n):
theta=2*math.pi*S[i]/2**m
qc.p(theta,i)
return qc
''' |
QPC002_B5 | AC9153EF58202 | 2 | AC | 3000 ms | 163 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here
for i in range (n):
theta=2*math.pi*S[i]/2**m
qc.p(theta,i)
return qc
''' |
QPC002_B5 | AD40A8C228B38 | 1 | RE | 1202 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
angle = 2 * pi * S[i] / (2 ** m)
qc.rz(angle, i)
return qc
''' |
QPC002_B5 | AD40A8C228B38 | 2 | AC | 1811 ms | 183 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
angle = 2 * math.pi * S[i] / (2 ** m)
qc.rz(angle, i)
return qc
''' |
QPC002_B5 | AD5FF868E6A44 | 1 | AC | 1908 ms | 183 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
angle = (2 * math.pi * S[i]) / (2 ** m)
qc.p(angle,i)
return qc
''' |
QPC002_B5 | AD712A9888AA9 | 1 | AC | 2333 ms | 184 MiB | '''python
from qiskit import QuantumCircuit
import numpy as np
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
lam = 2 * np.pi * S[i] / 2 ** m
qc.u(0, 0, lam, i)
return qc
''' |
QPC002_B5 | ADC0F575325BD | 1 | WA | 2203 ms | 160 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.p(4*math.pi*S[i]/2**m,i)
return qc
''' |
QPC002_B5 | ADC0F575325BD | 2 | WA | 1950 ms | 160 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.p(4*math.pi*S[i]/2**(m/n),i)
return qc
''' |
QPC002_B5 | ADC0F575325BD | 3 | AC | 2271 ms | 160 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.p(2*math.pi*S[i]/2**m,i)
return qc
''' |
QPC002_B5 | AE988BAF16D5D | 1 | RE | 1582 ms | 154 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
theta = 2*math.pi*S[i]/2**m
qc.p(theta,i)
return qc
''' |
QPC002_B5 | AE988BAF16D5D | 2 | AC | 1786 ms | 155 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
theta = 2*math.pi*S[i]/2**m
qc.p(theta,i)
return qc
''' |
QPC002_B5 | AECADED823952 | 1 | RE | 1442 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.q(2*math.pi*S[i] / 2**m)
return qc
''' |
QPC002_B5 | AECADED823952 | 2 | RE | 1583 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.p(2*math.pi*S[i] / 2**m)
return qc
''' |
QPC002_B5 | AECADED823952 | 3 | AC | 1801 ms | 183 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.p(2*math.pi*S[i] / 2**m, i)
return qc
''' |
QPC002_B5 | AF019F311E440 | 1 | RE | 1231 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
import numpy as np
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
# Apply Hadamard gates to the first n qubits (to create superposition)
for qubit in range(n):
qc.h(qubit)
# Apply controlled-phase gates based on the values of S
for i in range(n):
for j in range(i, n):
if S[i] != 0:
angle = 2 * np.pi * S[i] / (2 ** m)
qc.cp(angle, j, n) # Apply controlled-phase gate
return qc
''' |
QPC002_B5 | AF019F311E440 | 2 | DLE | 1085 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
import numpy as np
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n + m, m)
# Write your code here:
# Apply Hadamard gates to the first n qubits (to create superposition)
for qubit in range(n):
qc.h(qubit)
# Apply controlled-phase gates based on the values of S
for i in range(n):
for j in range(i, n):
if S[i] != 0:
angle = 2 * np.pi * S[i] / (2 ** m)
qc.cp(angle, j, n) # Apply controlled-phase gate
return qc
''' |
QPC002_B5 | AF019F311E440 | 3 | DLE | 1344 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
import numpy as np
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n + m, m)
# Write your code here:
for qubit in range(n):
qc.h(qubit)
# Apply the phase shift using controlled rotations
for i in range(n):
if S[i] != 0:
angle = 2 * np.pi * S[i] / (2 ** m)
# Apply multi-controlled phase shift
for control in range(n):
if control != i:
qc.cp(angle, control, n)
# Apply inverse Hadamard gates to the first n qubits to complete the QFT
for qubit in range(n):
qc.h(qubit)
return qc
''' |
QPC002_B5 | AF019F311E440 | 4 | DLE | 1780 ms | 141 MiB | '''python
from qiskit import QuantumCircuit
import numpy as np
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n + m, m)
# Write your code here:
for qubit in range(n):
qc.h(qubit)
# Apply the phase shift for the given S values
for i in range(n):
if S[i] != 0:
# Calculate the angle for the phase shift
angle = 2 * np.pi * S[i] / (2 ** m)
# Apply the controlled-phase gate
for qubit in range(n):
if (i & (1 << qubit)) != 0:
qc.cp(angle, qubit, n) # Apply controlled-phase gate
# Apply inverse QFT to undo the initial Hadamard gates
for qubit in range(n):
qc.h(qubit)
for k in range(qubit):
qc.cp(-np.pi / 2**(qubit - k), k, qubit)
return qc
''' |
QPC002_B5 | AF019F311E440 | 5 | DLE | 1196 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
import numpy as np
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n + m, m)
# Write your code here:
# Apply Hadamard gates to the first n qubits (to create superposition)
for qubit in range(n):
qc.h(qubit)
# Apply controlled rotations to encode f(x) into the phase of the target qubits
for i in range(n):
if S[i] != 0:
# Calculate the phase angle for the S[i] value
angle = 2 * np.pi * S[i] / (2 ** m)
# Apply the controlled-phase gate to the target qubits
for j in range(m):
qc.crz(angle / (2 ** j), i, n + j)
return qc
''' |
QPC002_B5 | AF0AE7D306FE9 | 1 | RE | 1432 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
from math import pi
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
bits = []
for item in S:
qc.p(2*pi/2**(m)*item)
return qc
''' |
QPC002_B5 | AF0AE7D306FE9 | 2 | AC | 2721 ms | 184 MiB | '''python
from qiskit import QuantumCircuit
from math import pi
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
bits = []
for i, item in enumerate(S):
qc.p(2*pi/2**(m)*item, i)
return qc
''' |
QPC002_B5 | AF0B5BD771F68 | 1 | RE | 1372 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.p(2 * math.pi / (2 ** m) * S[i])
return qc
''' |
QPC002_B5 | AF0B5BD771F68 | 2 | AC | 1904 ms | 183 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.p(2 * math.pi / (2 ** m) * S[i], i)
return qc
''' |
QPC002_B5 | AF13B925B8FEF | 1 | RE | 1376 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import PhaseGate
import numpy as np
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n + 1) # n qubits for the function and 1 auxiliary qubit
# Apply a Hadamard gate to the last qubit
qc.h(n)
# Apply controlled phase gates based on the function f(x)
for x in range(2 ** n):
f_x = sum(S[k] * ((x >> k) & 1) for k in range(n))
phase = np.exp(2j * np.pi * f_x / (2 ** m))
# Apply the phase gate to the auxiliary qubit
if phase != 1:
qc.u1(np.angle(phase), n) # U1 gate is used to apply the phase
# Apply a Hadamard gate to the last qubit to complete the oracle
qc.h(n)
return qc
''' |
QPC002_B5 | AF13B925B8FEF | 2 | UME | '''python
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit.circuit.library import PhaseGate
import numpy as np
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
# Quantum and classical registers
q = QuantumRegister(n + 1, name='q') # n qubits for function and 1 qubit for phase
c = ClassicalRegister(n, name='c')
qc = QuantumCircuit(q, c)
# Apply Hadamard gates to all qubits (except the last one for phase)
qc.h(q[:n])
# Apply controlled phase gates based on the function f(x)
for x in range(2 ** n):
f_x = sum(S[k] * ((x >> k) & 1) for k in range(n))
phase = np.exp(2j * np.pi * f_x / (2 ** m))
# Apply controlled phase gate to the last qubit
if phase != 1:
qc.p(np.angle(phase), q[n]) # p gate applies phase to the last qubit
# Optional: Apply additional operations if needed, such as using ancilla qubits
return qc
''' | ||
QPC002_B5 | AF2073045BEC4 | 1 | WA | 1430 ms | 141 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import qiskit.circuit.library as qlib
import numpy as np
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
qc.p(np.pi*S[i] / (2 ** m), i)
return qc
''' |
QPC002_B5 | AF2073045BEC4 | 2 | RE | 1324 ms | 139 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import qiskit.circuit.library as qlib
import numpy as np
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
for i in range(n):
qc.x(i)
qc.p(np.pi * S[i] / (2 ** m), i)
qc.x(i)
return qc
''' |
QPC002_B5 | AF2073045BEC4 | 3 | WA | 1270 ms | 140 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import qiskit.circuit.library as qlib
import numpy as np
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
qc.x(i)
qc.p(np.pi * S[i] / (2 ** m), i)
qc.x(i)
return qc
''' |
QPC002_B5 | AF2073045BEC4 | 4 | WA | 1599 ms | 181 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import qiskit.circuit.library as qlib
import numpy as np
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
qc.x(i)
qc.p(2*np.pi * S[i] / (2 ** m), i)
qc.x(i)
return qc
''' |
QPC002_B5 | AF2073045BEC4 | 5 | WA | 1133 ms | 140 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import qiskit.circuit.library as qlib
import numpy as np
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
qc.x(i)
qc.p(2*np.pi * S[-i-1] / (2 ** m), i)
qc.x(i)
return qc
''' |
QPC002_B5 | AF2073045BEC4 | 6 | WA | 1188 ms | 141 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import qiskit.circuit.library as qlib
import numpy as np
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
qc.x(i)
qc.p(4*np.pi * S[i] / (2 ** m), i)
qc.x(i)
return qc
''' |
QPC002_B5 | AF2073045BEC4 | 7 | AC | 1831 ms | 183 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import qiskit.circuit.library as qlib
import numpy as np
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
qc.p(2*np.pi * S[i] / (2 ** m), i)
return qc
''' |
QPC002_B6 | A05FC3F208234 | 1 | WA | 1219 ms | 155 MiB | '''python
import math
from qiskit import QuantumCircuit, QuantumRegister
def qfts(qc, i, n) -> QuantumCircuit:
for q in range(i):
qc.cp(-math.pi / 2 ** (i - q), q, i)
qc.h(i)
def iqft(qc,n):
for i in range(n // 2):
qc.swap(i, n - i - 1)
for i in range(n):
qfts(qc,i,n)
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n+m)
for j in range(m):
qc.h(j)
for j in range(m):
for i in range(n):
theta = (2 * math.pi * S[i] / 2**m) * 2**j
qc.cp(theta, i+m,j)
iqft(qc,m)
return qc
solve(5,2,(1,0,0,0,1))
''' |
QPC002_B6 | A05FC3F208234 | 2 | WA | 1433 ms | 155 MiB | '''python
import math
from qiskit import QuantumCircuit, QuantumRegister
def qfts(qc, i, n) -> QuantumCircuit:
for q in range(i):
qc.cp(-math.pi / 2 ** (i - q), q, i)
qc.h(i)
def iqft(qc,n):
for i in range(n // 2):
qc.swap(i, n - i - 1)
for i in range(n):
qfts(qc,i,n)
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n+m)
for j in range(m):
qc.h(j)
for j in range(m):
for i in range(n):
theta = (2 * math.pi * S[i] / 2**m) * 2**j
qc.cp(theta, i+m,j)
iqft(qc,m)
return qc
''' |
QPC002_B6 | A05FC3F208234 | 3 | WA | 1228 ms | 154 MiB | '''python
import math
from qiskit import QuantumCircuit, QuantumRegister
def qfts(qc, i, n) -> QuantumCircuit:
for q in range(i):
qc.cp(-math.pi / 2 ** (i - q), q, i)
qc.h(i)
def iqft(qc,n):
for i in range(n // 2):
qc.swap(i, n - i - 1)
for i in range(n):
qfts(qc,i,n)
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n+m)
for j in range(m):
qc.h(j)
for j in range(m):
for i in range(n):
theta = (2 * math.pi * S[i] / 2**m) * 2**j
qc.cp(theta, j,i+m)
iqft(qc,m)
return qc
''' |
QPC002_B6 | A093844655B23 | 1 | RE | 1412 ms | 140 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import numpy as np
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
for i in range(m):
qc.h(i)
for j in range(n):
qc.cp(2*np.pi*S[j]/2**m, (i,j))
for i in range(m // 2):
qc.swap(i, 2*n - i - 1)
for i in range(m - 1, -1, -1):
for j in range(i - 1, -1, -1):
qc.cp(-np.pi / 2**(i - j), n+i, n+j)
qc.h(n+i)
return qc
''' |
QPC002_B6 | A093844655B23 | 2 | RE | 1593 ms | 141 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import numpy as np
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
for i in range(m):
qc.h(i+n)
for j in range(n):
qc.cp(2*np.pi*S[j]/2**m, i+n,j)
for i in range(m // 2):
qc.swap(i, 2*n - i - 1)
for i in range(m - 1, -1, -1):
for j in range(i - 1, -1, -1):
qc.cp(-np.pi / 2**(i - j), n+i, n+j)
qc.h(n+i)
return qc
''' |
QPC002_B6 | A093844655B23 | 3 | RE | 1129 ms | 140 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import numpy as np
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
for i in range(m):
qc.h(i+n)
for j in range(n):
qc.cp(2*np.pi*S[j]/2**m, i+n,j)
for i in range(m // 2):
qc.swap(i+n, 2*n - i - 1)
for i in range(m - 1, -1, -1):
for j in range(i - 1, -1, -1):
qc.cp(-np.pi / 2**(i - j), n+i, n+j)
qc.h(n+i)
return qc
''' |
QPC002_B6 | A093844655B23 | 4 | UGE | 1143 ms | 140 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import numpy as np
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
for i in range(m):
qc.h(i+n)
for j in range(n):
qc.cp(2*np.pi*S[j]/2**m, i+n,j)
def qft(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n // 2):
qc.swap(i, n - i - 1)
for i in range(n):
for j in range(i):
qc.cp(-np.pi / 2**(i - j), j, i)
qc.h(i)
return qc
qc.append(qft(m), range(n, n+m))
return qc
''' |
QPC002_B6 | A093844655B23 | 5 | RE | 1449 ms | 140 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import numpy as np
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
for i in range(m):
qc.h(i+n)
for j in range(n):
qc.cp(2*np.pi*S[j]/2**m, i+n,j)
for i in range(n // 2):
qc.swap(i+n, n+n - i - 1)
for i in range(n):
for j in range(i):
qc.cp(-np.pi / 2**(i - j), j+n, i+n)
qc.h(i+n)
return qc
''' |
QPC002_B6 | A093844655B23 | 6 | RE | 1342 ms | 144 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import numpy as np
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
for i in range(m):
qc.h(i+n)
for j in range(n):
qc.cp(2*np.pi*S[j]/2**m, i+n,j)
for i in range(m // 2):
qc.swap(i+n, n+n - i - 1)
for i in range(m):
for j in range(i):
qc.cp(-np.pi / 2**(i - j), j+n, i+n)
qc.h(i+n)
return qc
''' |
QPC002_B6 | A093844655B23 | 7 | RE | 1466 ms | 140 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import numpy as np
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
for i in range(m):
qc.h(i+n)
for j in range(n):
qc.cp(2*np.pi*S[j]/2**(n-i), i+n,j)
for i in range(m // 2):
qc.swap(i+n, n+n - i - 1)
for i in range(m):
for j in range(i):
qc.cp(-np.pi / 2**(i - j), j+n, i+n)
qc.h(i+n)
return qc
''' |
QPC002_B6 | A093844655B23 | 8 | AC | 1983 ms | 184 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import numpy as np
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
for i in range(m):
qc.h(i+n)
for j in range(n):
qc.cp(2*np.pi*S[j]/2**(m-i), i+n,j)
for i in range(m // 2):
qc.swap(i+n, n+m - i - 1)
for i in range(m):
for j in range(i):
qc.cp(-np.pi / 2**(i - j), j+n, i+n)
qc.h(i+n)
return qc
''' |
QPC002_B6 | A0E3CCE2D2115 | 1 | WA | 1595 ms | 142 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# 各項 S[i] * x[i] を計算してyに加算
for i in range(n):
# S[i]の各ビットについて処理
for j in range(m):
bit_value = (S[i] >> j) & 1 # S[i]のj番目のビット
if bit_value == 1:
# x[i]が1のときのみy[j]をフリップ
qc.cx(x[i], y[j])
return qc
''' |
QPC002_B6 | A123DBD2E3351 | 1 | WA | 1673 ms | 144 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import GlobalPhaseGate
import numpy as np
import math
def qft(n):
qc = QuantumCircuit(n)
thetas = []
for k in range(0, 1+n):
thetas.append(2 * math.pi / (2**k))
for idx in range(0, n):
qc.h(n-1-idx)
for jdx in range(idx+1, n):
thetaidx = jdx - idx + 1
qc.cp(thetas[thetaidx], n-1-jdx, n-1-idx)
for idx in range(0, n//2):
qc.swap(idx, n-idx-1)
return qc
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
qc.h(range(n, n+m))
for idx in range(0, n):
theta = 2 * math.pi * S[idx] / (2**m)
for jdx in range(n, n+m):
qc.cp(theta, idx, jdx)
qc = qc.compose(qft(m).inverse(), range(n, n+m))
return qc
''' |
QPC002_B6 | A123DBD2E3351 | 2 | WA | 1447 ms | 182 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import GlobalPhaseGate
import numpy as np
import math
def qft(n):
qc = QuantumCircuit(n)
thetas = []
for k in range(0, 1+n):
thetas.append(2 * math.pi / (2**k))
for idx in range(0, n):
qc.h(n-1-idx)
for jdx in range(idx+1, n):
thetaidx = jdx - idx + 1
qc.cp(thetas[thetaidx], n-1-jdx, n-1-idx)
for idx in range(0, n//2):
qc.swap(idx, n-idx-1)
return qc
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
qc.h(range(n, n+m))
for idx in range(0, n):
for jdx in range(n, n+m):
theta = 2 * math.pi * S[idx] * (jdx-n+1) / (2**m)
qc.cp(theta, idx, jdx)
qc = qc.compose(qft(m).inverse(), range(n, n+m))
return qc
''' |
QPC002_B6 | A123DBD2E3351 | 3 | WA | 1580 ms | 182 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import GlobalPhaseGate
import numpy as np
import math
def qft(n):
qc = QuantumCircuit(n)
thetas = []
for k in range(0, 1+n):
thetas.append(2 * math.pi / (2**k))
for idx in range(0, n):
qc.h(n-1-idx)
for jdx in range(idx+1, n):
thetaidx = jdx - idx + 1
qc.cp(thetas[thetaidx], n-1-jdx, n-1-idx)
for idx in range(0, n//2):
qc.swap(idx, n-idx-1)
return qc
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
qc.h(range(n, n+m))
for idx in range(0, n):
for jdx in range(n, n+m):
theta = 2 * math.pi * S[idx] * (jdx-n+1) / (2**m)
qc.cp(theta, idx, jdx)
qc = qc.compose(qft(m).inverse(), range(n, n+m))
return qc
''' |
QPC002_B6 | A123DBD2E3351 | 4 | WA | 1846 ms | 183 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import GlobalPhaseGate
import numpy as np
import math
def qft(n):
qc = QuantumCircuit(n)
thetas = []
for k in range(0, 1+n):
thetas.append(2 * math.pi / (2**k))
for idx in range(0, n):
qc.h(n-1-idx)
for jdx in range(idx+1, n):
thetaidx = jdx - idx + 1
qc.cp(thetas[thetaidx], n-1-jdx, n-1-idx)
for idx in range(0, n//2):
qc.swap(idx, n-idx-1)
return qc
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
qc.h(y)
for idx in range(0, n):
for jdx in range(0, m):
theta = 2 * math.pi * S[idx] * (jdx+1) / (2**m)
qc.cp(theta, x[idx], y[jdx])
qc = qc.compose(qft(m).inverse(), y)
return qc
''' |
QPC002_B6 | A123DBD2E3351 | 5 | AC | 1858 ms | 184 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import GlobalPhaseGate
import numpy as np
import math
def qft(n):
qc = QuantumCircuit(n)
thetas = []
for k in range(0, 1+n):
thetas.append(2 * math.pi / (2**k))
for idx in range(0, n):
qc.h(n-1-idx)
for jdx in range(idx+1, n):
thetaidx = jdx - idx + 1
qc.cp(thetas[thetaidx], n-1-jdx, n-1-idx)
for idx in range(0, n//2):
qc.swap(idx, n-idx-1)
return qc
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
qc.h(y)
for idx in range(0, n):
for jdx in range(0, m):
theta = 2 * math.pi * S[idx] * (2**jdx) / (2**m)
qc.cp(theta, x[idx], y[jdx])
qc = qc.compose(qft(m).inverse(), y)
return qc
''' |
QPC002_B6 | A20C0E4B41E35 | 1 | AC | 2442 ms | 155 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
# from qiskit.quantum_info import Statevector
def quantum_fourier_transform(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n-1, -1, -1):
qc.h(i)
for j in range(i-1, -1, -1):
qc.cp(2*math.pi/(2**(i-j+1)), j, i)
i = 0
while i<n-i-1:
qc.swap(i, n-i-1)
i += 1
return qc
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# init = [0]*(2**(n+m))
# init[3] = 1
# qc.initialize(init)
# Write your code here:
qc.compose(quantum_fourier_transform(m), y, inplace=True)
for j in range(m):
for i in range(n):
qc.cp(2*math.pi*S[i]/(2**m)*(2**j), x[i], y[j])
qc.compose(quantum_fourier_transform(m).inverse(), y, inplace=True)
return qc
# if __name__ == "__main__":
# qc = solve(2, 2, [1, 2])
# print(Statevector(qc))
''' |
QPC002_B6 | A266591AA7DFC | 1 | UGE | 1140 ms | 141 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import numpy as np
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
def qft(n):
qc = QuantumCircuit(n)
for i in range(n):
qc.h(-1-i)
for j in range(i+1,n):
qc.cp(2 * np.pi / 2**(j+1-i), -1-j, -1-i)
for i in range(n//2):
qc.swap(i, n-i-1)
return qc
for i in range(n):
qc.p(2*np.pi*S[i]/2**m, x[i])
for j in range(m):
qc.h(y[j])
inv_qft = qft(m).inverse()
qc.append(inv_qft, y)
return qc
''' |
QPC002_B6 | A3CC7611E64D4 | 1 | WA | 1423 ms | 153 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
# Step through each qubit in x and apply the corresponding controlled addition
for i in range(n):
for j in range(m):
# Calculate the bit of S[i] that needs to be added to y[j]
if (S[i] >> j) & 1:
qc.cx(x[i], y[j]) # Apply a controlled-X operation based on x[i]
return qc
''' |
QPC002_B6 | A42D4991261E7 | 1 | WA | 1175 ms | 141 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
for i in range(n):
for j in range(m):
if ((S[i] >> j) & 1) == 1:
qc.cx(i, n + j)
if j < m - 1:
qc.x(n + j)
qc.cx(n + j, n + j + 1)
qc.x(n + j)
return qc
''' |
QPC002_B6 | A42D4991261E7 | 2 | WA | 1332 ms | 140 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
for i in range(n):
for j in range(m - 1, -1, -1):
if ((S[i] >> j) & 1) == 1:
qc.cx(i, n + j)
if j < m - 1:
qc.x(n + j)
qc.cx(n + j, n + j + 1)
qc.x(n + j)
return qc
''' |
QPC002_B6 | A42D4991261E7 | 3 | WA | 1645 ms | 144 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
for i in range(n):
for j in range(m):
if ((S[i] >> j) & 1) == 1:
qc.cx(i, n + j)
for k in range(j, m - 1):
qc.x(n + k)
qc.cx(n + k, n + k + 1)
qc.x(n + k)
return qc
''' |
QPC002_B6 | A42D4991261E7 | 4 | WA | 1433 ms | 182 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import MCXGate
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
for i in range(n):
for j in range(m):
if ((S[i] >> j) & 1) == 1:
qc.cx(i, n + j)
for k in range(j + 1, m):
for s in range(j, k):
qc.x(n + s)
mcx = MCXGate(k - j)
qc.append(mcx, range(n + j, n + k + 1))
for s in range(j, k):
qc.x(n + s)
return qc
''' |
QPC002_B6 | A42D4991261E7 | 5 | AC | 1980 ms | 184 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from math import pi
def qft(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
j = n - 1 - i
if i >= j:
break
qc.swap(i, j)
for i in range(n):
qc.h(i)
for j in range(i + 1, n):
theta = 2 * pi / (2 ** (j + 1 - i))
qc.cp(theta, j, i)
return qc
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
for j in range(m):
qc.h(n + j)
for i in range(n):
theta = 2 * pi * S[i] * 2 ** (j - m)
qc.cp(theta, j + n, i)
qc.compose(qft(m).inverse(), y, inplace=True)
return qc
''' |
QPC002_B6 | A4673A94888F5 | 1 | RE | 1118 ms | 140 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
for i in range(m):
qc.h(i)
for i in range(n):
for j in range(m):
qc.cp(2. * np.pi * S[i] * (2 ** i) * (2 **j) / (2 ** m), x[i], y[j])
return qc
''' |
QPC002_B6 | A4673A94888F5 | 2 | RE | 1140 ms | 140 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
for i in range(m):
qc.h(i)
for i in range(n):
for j in range(m):
qc.cp(2. * np.pi * S[i] * (2 ** i) * (2 **j)/ (2 ** m), x[i], y[j])
def qft(n):
for itarg in range(n - 1, -1, -1):
qc.h(itarg)
for ictrl in range(itarg - 1, -1, -1):
power = ictrl - itarg - 1 + n
qc.cp((2 ** power) * 2. * np.pi / (2 ** n), ictrl, itarg)
for i in range(n // 2):
qc.swap(i, n - 1 - i)
qc.compose(qft(m).inverse(), y, inplace=True)
return qc
''' |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.