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_B6 | A520A33F84E16 | 1 | WA | 1546 ms | 154 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:
qc.cx(x[i], y[j])
return qc
''' |
QPC002_B6 | A5B6F098774A6 | 1 | UGE | 1071 ms | 140 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def r(qc: QuantumCircuit, control:int, target:int, l:int):
#Apply Cphase operation
theta = 2 * math.pi / (1 << l)
qc.cp(theta, control, target)
def qft(n:int) -> QuantumCircuit:
qc = QuantumCircuit(n)
#Now swap qubits to reverse their order
for i in range(n//2):
qc.swap(i,n-i-1)
#Apply the qft
for i in range(n):
qc.h(i)
for j in range(i+1,n):
r(qc, j, i, j-i+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:
#Apply H-gate to all qubits in y
qc.h(y)
#Apply cphase gates
for k in range(m):
for i in range(n):
theta = 2 * math.pi * S[i]/ (1<<m)*(1<<k)
qc.cp(theta, y[k], x[i])
#Apply IQFT to y-reg
qc.append(qft(m).inverse(), y)
return qc
''' |
QPC002_B6 | A5B6F098774A6 | 2 | RE | 1257 ms | 182 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def r(qc: QuantumCircuit, control:int, target:int, l:int):
#Apply Cphase operation
theta = 2 * math.pi / (1 << l)
qc.cp(theta, control, target)
def qft(n:int) -> QuantumCircuit:
qc = QuantumCircuit(n)
#Now swap qubits to reverse their order
for i in range(n//2):
qc.cx(i,n-1)
qc.cx(n-i-1,i)
qc.cx(i,n-i-1)
#Apply the qft
for i in range(0,n):
qc.h(i)
for j in range(1,n-1):
r(qc, i+j, i, j+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:
#Apply H-gate to all qubits in y
qc.h(y)
#Apply cphase gates
for k in range(m):
for i in range(n):
theta = 2 * math.pi * S[i]/ (1<<m)*(1<<k)
qc.cp(theta, y[k], x[i])
#Apply IQFT to y-reg
qc.compose(qft(m).inverse(), y)
return qc
''' |
QPC002_B6 | A5B6F098774A6 | 3 | RE | 1342 ms | 153 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def r(qc: QuantumCircuit, control:int, target:int, l:int):
#Apply Cphase operation
theta = 2 * math.pi / (1 << l)
qc.cp(theta, control, target)
def qft(n:int) -> QuantumCircuit:
qc = QuantumCircuit(n)
#Now swap qubits to reverse their order
for i in range(n//2):
qc.cx(i,n-1)
qc.cx(n-i-1,i)
qc.cx(i,n-i-1)
#Apply the qft
for i in range(0,n):
qc.h(i)
for j in range(1,n-1):
r(qc, i+j, i, j+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:
#Apply H-gate to all qubits in y
qc.h(y)
#Apply cphase gates
for k in range(m):
for i in range(n):
theta = 2 * math.pi * S[i]/ (1<<m)*(1<<k)
qc.cp(theta, y[k], x[i])
#Apply IQFT to y-reg
qc = qc.compose(qft(m).inverse(), y)
return qc
''' |
QPC002_B6 | A5B6F098774A6 | 4 | RE | 1078 ms | 140 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def r(qc: QuantumCircuit, control:int, target:int, l:int):
#Apply Cphase operation
theta = 2 * math.pi / (1 << l)
qc.cp(theta, control, target)
def qft(n:int) -> QuantumCircuit:
qc = QuantumCircuit(n)
#Now swap qubits to reverse their order
for i in range(n//2):
qc.cx(i,n-i-1)
qc.cx(n-i-1,i)
qc.cx(i,n-i-1)
#Apply the qft
for i in range(0,n):
qc.h(i)
for j in range(1,n-1):
r(qc, i+j, i, j+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:
#Apply H-gate to all qubits in y
qc.h(y)
#Apply cphase gates
for k in range(m):
for i in range(n):
theta = 2 * math.pi * S[i]/ (1<<m)*(1<<k)
qc.cp(theta, y[k], x[i])
#Apply IQFT to y-reg
qc = qc.compose(qft(m).inverse(), y)
return qc
''' |
QPC002_B6 | A5B6F098774A6 | 5 | AC | 1793 ms | 183 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def r(qc: QuantumCircuit, control:int, target:int, l:int):
#Apply Cphase operation
theta = 2 * math.pi / (1 << l)
qc.cp(theta, control, target)
def qft(n:int) -> QuantumCircuit:
qc = QuantumCircuit(n)
#Now swap qubits to reverse their order
for i in range(n//2):
qc.cx(i,n-i-1)
qc.cx(n-i-1,i)
qc.cx(i,n-i-1)
#Apply the qft
for i in range(0,n):
qc.h(i)
for j in range(1,n-i):
r(qc, i+j, i, j+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:
#Apply H-gate to all qubits in y
qc.h(y)
#Apply cphase gates
for k in range(m):
for i in range(n):
theta = 2 * math.pi * S[i]/ (1<<m)*(1<<k)
qc.cp(theta, y[k], x[i])
#Apply IQFT to y-reg
qc = qc.compose(qft(m).inverse(), y)
return qc
''' |
QPC002_B6 | A61F70AC9F35C | 1 | RE | 1356 ms | 154 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(min(n, m)):
angle = 2 * pi * S[i] / 2 ** m
qc.cp(angle, i, i + n)
return qc
''' |
QPC002_B6 | A61F70AC9F35C | 2 | WA | 1163 ms | 154 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from math import pi
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(min(n, m)):
angle = 2 * pi * S[i] / 2 ** m
qc.cp(angle, i, i + n)
return qc
''' |
QPC002_B6 | A6993D15856B8 | 1 | RE | '''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):
bin_data = format(S[i], f'0{n}b')
data_1_bits = [idx for idx, digit in enumerate(reversed(bin_data)) if digit == '1' && idx < m]
if len(data_0_bits) > 0:
qc.cx(x[i], y[data_0_bits])
return qc
''' | ||
QPC002_B6 | A6993D15856B8 | 2 | RE | 1106 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):
bin_data = format(S[i], f'0{n}b')
data_1_bits = [idx for idx, digit in enumerate(reversed(bin_data)) if digit == '0' and idx < m]
if len(data_0_bits) > 0:
qc.cx(x[i], y[data_0_bits])
return qc
''' |
QPC002_B6 | A6993D15856B8 | 3 | WA | 1389 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):
bin_data = format(S[i], f'0{n}b')
data_1_bits = [idx for idx, digit in enumerate(reversed(bin_data)) if digit == '0' and idx < m]
if len(data_1_bits) > 0:
qc.cx(x[i], y[data_1_bits])
return qc
''' |
QPC002_B6 | A6993D15856B8 | 4 | UGE | 1358 ms | 140 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
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: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n-1,-1,-1):
qc.h(i)
for j in range(i):
qc.cp(math.pi/(2**(j+1)), i-j-1, i)
for i in range(int(n/2)):
qc.swap(i,n-i-1)
return qc
qft_circ = qft(m)
qc.append(qft_circ, y)
for i in range(n):
for j in range(m):
phase = S[i] * 2**j / 2**m * math.pi
qc.cp(phase, x[i], y[j])
qc.append(qft_circ.inverse(), y)
return qc
''' |
QPC002_B6 | A6993D15856B8 | 5 | UGE | 1158 ms | 140 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def qft(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n-1,-1,-1):
qc.h(i)
for j in range(i):
qc.cp(math.pi/(2**(j+1)), i-j-1, i)
for i in range(int(n/2)):
qc.swap(i,n-i-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:
qft_circ = qft(m)
qc.append(qft_circ, y)
for i in range(n):
for j in range(m):
phase = S[i] * 2**j / 2**m * math.pi
qc.cp(phase, x[i], y[j])
qc.append(qft_circ.inverse(), y)
return qc
''' |
QPC002_B6 | A6993D15856B8 | 6 | UGE | 1272 ms | 140 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def qft(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n-1,-1,-1):
qc.h(i)
for j in range(i):
qc.cp(math.pi/(2**(j+1)), i-j-1, i)
for i in range(int(n/2)):
qc.cx(i,n-i-1)
qc.cx(n-i-1,i)
qc.cx(i,n-i-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:
qft_circ = qft(m)
qc.append(qft_circ, y)
for i in range(n):
for j in range(m):
phase = S[i] * 2**j / 2**m * math.pi
qc.cp(phase, x[i], y[j])
qc.append(qft_circ.inverse(), y)
return qc
''' |
QPC002_B6 | A6993D15856B8 | 7 | RE | 1164 ms | 140 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def qft(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n-1,-1,-1):
qc.h(i)
for j in range(i):
qc.cp(math.pi/(2**(j+1)), i-j-1, i)
for i in range(int(n/2)):
qc.swap(i,n-i-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.append(qft_circ(m), y)
for i in range(n):
for j in range(m):
phase = S[i] * 2**j / 2**m * math.pi
qc.cp(phase, x[i], y[j])
qc.append(qft_circ(m).inverse(), y)
return qc
''' |
QPC002_B6 | A6993D15856B8 | 8 | UGE | 1312 ms | 140 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def qft(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n-1,-1,-1):
qc.h(i)
for j in range(i):
qc.cp(math.pi/(2**(j+1)), i-j-1, i)
for i in range(int(n/2)):
qc.swap(i,n-i-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.append(qft(m), y)
for i in range(n):
for j in range(m):
phase = S[i] * 2**j / 2**m * math.pi
qc.cp(phase, x[i], y[j])
qc.append(qft(m).inverse(), y)
return qc
''' |
QPC002_B6 | A6993D15856B8 | 9 | WA | 1288 ms | 182 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def qft(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n-1,-1,-1):
qc.h(i)
for j in range(i):
qc.cp(math.pi/(2**(j+1)), i-j-1, i)
for i in range(int(n/2)):
qc.swap(i,n-i-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.compose(qft(m), y)
for i in range(n):
for j in range(m):
phase = S[i] * 2**j / 2**m * math.pi
qc.cp(phase, x[i], y[j])
qc.compose(qft(m).inverse(), y)
return qc
''' |
QPC002_B6 | A6993D15856B8 | 10 | RE | 1203 ms | 140 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def qft(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n-1,-1,-1):
qc.h(i)
for j in range(i):
qc.cp(math.pi/(2**(j+1)), i-j-1, i)
for i in range(int(n/2)):
qc.swap(i,n-i-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 i in range(n):
for j in range(m):
phase = S[i] * 2**j / 2**m * math.pi
qc.cp(phase, x[i], y[j])
qc.compos(qft(m).inverse(), y)
return qc
''' |
QPC002_B6 | A6C66ABDC120A | 1 | WA | 2165 ms | 160 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x = QuantumRegister(n) # Register for x
y = QuantumRegister(m) # Register for f(x) mod 2^m
qc = QuantumCircuit(x, y)
# We will use a series of controlled additions to compute f(x)
for i in range(n):
if S[i] > 0: # Only consider non-zero S[i]
# Convert S[i] to binary and apply controlled additions
binary_S = format(S[i], '0' + str(m) + 'b') # Get binary representation of S[i]
for j in range(m):
if binary_S[m - 1 - j] == '1': # Check if the j-th bit is set
qc.cx(x[i], y[j]) # Apply CNOT from x[i] to y[j]
return qc
''' |
QPC002_B6 | A72CC47CA0CF1 | 1 | RE | 1157 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):
for j in range(m):
x = (1 << j)
if (S[i] & x):
for k in range(1 << m):
if(k % (2 * x) < x):
qc.swap(k, k + x)
return qc
''' |
QPC002_B6 | A72CC47CA0CF1 | 2 | RE | 1513 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
import math
from qiskit.circuit.library import SwapGate
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):
x = (1 << j)
if (S[i] & x):
for k in range(j, m - 1):
if k == 0:
qc.swap(0, 1)
else:
qc.append(SwapGate(0, k + 1).control(k - 1), range(1, k))
return qc
''' |
QPC002_B6 | A72CC47CA0CF1 | 3 | RE | 1298 ms | 140 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
from qiskit.circuit.library import SwapGate
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):
x = (1 << j)
if (S[i] & x):
for k in range(j, m - 1):
if k == 0:
qc.swap(0, 1)
else:
qc.append(SwapGate(0, k + 1).control(k - 1), range(1, k))
return qc
''' |
QPC002_B6 | A72CC47CA0CF1 | 4 | RE | 1257 ms | 139 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
from qiskit.circuit.library import SwapGate
def solve(n: int, m: int, S) -> 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):
x = (1 << j)
if (S[i] & x):
for k in range(j, m - 1):
if k == 0:
qc.swap(0, 1)
else:
qc.append(SwapGate(0, k + 1).control(k - 1), range(1, k + 1))
return qc
''' |
QPC002_B6 | A72CC47CA0CF1 | 5 | RE | 1305 ms | 140 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
from qiskit.circuit.library import SwapGate
def solve(n: int, m: int, S) -> 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):
x = (1 << j)
if (S[i] & x):
for k in range(j, m - 1):
if k == 0:
qc.swap(0, 1)
else:
qc.append(SwapGate(0, k + 1).control(k), range(1, k + 1))
return qc
''' |
QPC002_B6 | A72CC47CA0CF1 | 6 | RE | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
from qiskit.circuit.library import SwapGate
def solve(n: int, m: int, S) -> 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):
x = (1 << j)
if (S[i] & x):
for k in range(min(j, m - 1):
if k == 0:
qc.swap(0, 1)
else:
qc.append(SwapGate(0, k + 1).control(k), range(1, k + 1))
return qc
''' | ||
QPC002_B6 | A72CC47CA0CF1 | 7 | RE | 1442 ms | 153 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
from qiskit.circuit.library import SwapGate
def solve(n: int, m: int, S) -> 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):
x = (1 << j)
if (S[i] & x):
for k in range(min(j, m - 1)):
if k == 0:
qc.swap(0, 1)
else:
qc.append(SwapGate(0, k + 1).control(k), range(1, k + 1))
return qc
''' |
QPC002_B6 | A770A77C704FD | 1 | RE | 1921 ms | 156 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 j in range(m):
qc.h(n+j)
for i in range(n):
for j in range(m):
qc.cp(2*math.pi*S[i]/2**(m-j),i,n+j)
for j in range(m-1,-1,-1):
qc.h(n+j)
for l in range(j-1,-1,-1):
qc.cp(-2*math.pi/2**(j-l+1),n+l,n+j)
for k in range(m//2):
qc.swap(n+k,n+m-1-k)
return qc
''' |
QPC002_B6 | A770A77C704FD | 2 | AC | 2457 ms | 161 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
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):
for j in range(m):
qc.cp(2*math.pi*S[i]/2**(m-j),i,n+j)
for j in range(m-1,-1,-1):
qc.h(n+j)
for l in range(j-1,-1,-1):
qc.cp(-2*math.pi/2**(j-l+1),n+l,n+j)
for k in range(m//2):
qc.swap(n+k,n+m-1-k)
return qc
''' |
QPC002_B6 | A7C0D4BBD3C06 | 1 | WA | 1139 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:
# Apply the oracle function f(x) = S0*x0 + S1*x1 + ... + Sn-1*xn-1
for i in range(n):
if S[i] != 0:
qc.cx(x[i], y[0])
for j in range(1, m):
if S[i] & (1 << (j - 1)):
qc.cx(x[i], y[j])
return qc
''' |
QPC002_B6 | A7C0D4BBD3C06 | 2 | RE | '''python
from qiskit import QuantumCircuit, QuantumRegister
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x = QuantumRegister(n, 'x') # For the input bits
y = QuantumRegister(m, 'y') # For the output bits
qc = QuantumCircuit(x, y)
# We will use controlled addition to add S_i * x_i into the y register
# Auxiliary qubit for carrying the addition results
carry = QuantumRegister(1, 'carry')
qc.add_register(carry)
# Initialize carry qubit to |0⟩
qc.reset(carry[0])
# Controlled addition circuits for each S_i
for i in range(n):
# We will be adding S_i * x_i to the y register
# Using controlled addition gates
s = S[i]
if s > 0:
# Use the controlled adder technique to add s*x_i to the y register
# Decompose s into its binary representation and add it conditionally
for bit in range(m):
if s & (1 << bit):
qc.cx(x[i], y[bit])
return qc
''' | ||
QPC002_B6 | A7C0D4BBD3C06 | 3 | RE | '''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) for i in range(n):
for j in range(m):
if (S[i] >> j) & 1: qc.cx(x[i], y[j])
return qc
''' | ||
QPC002_B6 | A7C0D4BBD3C06 | 4 | AC | 1781 ms | 183 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def r(qc: QuantumCircuit, control: int, target: int, l: int):
qc.cp(2*math.pi/(1<<l), control, target)
def qft(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n//2):
qc.cx(i, n-i-1)
qc.cx(n-i-1, i)
qc.cx(i, n-i-1)
for i in range(0, n):
qc.h(i)
for j in range(1, n-i):
r(qc, i+j, i, j+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 k in range(m):
for i in range(n):
qc.cp(2*math.pi*S[i]/(1<<m)*(1<<k), y[k], x[i])
qc = qc.compose(qft(m).inverse(), y)
return qc
''' |
QPC002_B6 | A7CFCCAEDF382 | 1 | UME | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library.standard_gates import *
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# i を control として y に S[i] を加算しないといけない
for j in reversed(range(m)):
for i in range(n):
if S[i] & (1 << j):
# y に (1 << j) を加算
for k in range(n - 1, j, -1):
qc.append(XGate().control(k - j + 1), [i] + list(range(n + j, n + k + 1)))
qc.cx(i, n + j)
return qc
''' | ||
QPC002_B6 | A7CFCCAEDF382 | 2 | UME | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library.standard_gates import XGate
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# i を control として y に S[i] を加算しないといけない
for j in reversed(range(m)):
for i in range(n):
if S[i] & (1 << j):
# y に (1 << j) を加算
for k in range(n - 1, j, -1):
qc.append(XGate().control(k - j + 1), [i] + list(range(n + j, n + k + 1)))
qc.cx(i, n + j)
return qc
from qiskit.quantum_info import Statevector
if __name__ == "__main__":
qc = solve(5, 5, [31, 31, 31, 31, 31])
qc.draw('mpl').savefig('a.png')
print(Statevector(qc))
''' | ||
QPC002_B6 | A7CFCCAEDF382 | 3 | RE | 1312 ms | 153 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library.standard_gates import XGate
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# i を control として y に S[i] を加算しないといけない
for j in reversed(range(m)):
for i in range(n):
if S[i] & (1 << j):
# y に (1 << j) を加算
for k in range(n - 1, j, -1):
qc.append(XGate().control(k - j + 1), [i] + list(range(n + j, n + k + 1)))
qc.cx(i, n + j)
return qc
''' |
QPC002_B6 | A7CFCCAEDF382 | 4 | UGE | 1229 ms | 140 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library.standard_gates import U1Gate
from math import pi
def QFT(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n//2):
qc.swap(i, n-i-1)
for i in range(n):
qc.h(i)
for j in range(i+1, n):
qc.append(U1Gate(pi/2**(j-i)).control(1), [j, i])
return qc
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# y をフーリエ変換
for i in range(m):
qc.h(n + i)
# S[i] をフーリエ変換したものを掛ける
for i in range(n):
for j in range(m):
qc.append(U1Gate(2 * pi * S[i] / 2 ** (m - j)).control(1), [i, n + j])
# y を逆フーリエ変換
qc.append(QFT(m).inverse(), range(n, n + m))
return qc
''' |
QPC002_B6 | A7CFCCAEDF382 | 5 | DLE | 1896 ms | 183 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library.standard_gates import U1Gate
from math import pi
def QFT(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n//2):
qc.swap(i, n-i-1)
for i in range(n):
qc.h(i)
for j in range(i+1, n):
qc.append(U1Gate(pi/2**(j-i)).control(1), [j, i])
return qc
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# y をフーリエ変換
for i in range(m):
qc.h(n + i)
# S[i] をフーリエ変換したものを掛ける
for i in range(n):
for j in range(m):
qc.append(U1Gate(2 * pi * S[i] / 2 ** (m - j)).control(1), [i, n + j])
# y を逆フーリエ変換
qc.append(QFT(m).inverse(), range(n, n + m))
return qc.decompose()
''' |
QPC002_B6 | A7CFCCAEDF382 | 6 | AC | 1973 ms | 183 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library.standard_gates import U1Gate
from math import pi
def QFT(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n//2):
qc.swap(i, n-i-1)
for i in range(n):
qc.h(i)
for j in range(i+1, n):
qc.append(U1Gate(pi/2**(j-i)).control(1), [j, i])
return qc
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# y をフーリエ変換
for i in range(m):
qc.h(n + i)
# S[i] をフーリエ変換したものを掛ける
for i in range(n):
for j in range(m):
qc.append(U1Gate(2 * pi * S[i] / 2 ** (m - j)).control(1), [i, n + j])
# y を逆フーリエ変換
for i in range(m//2):
qc.swap(n + i, n + m-i-1)
for i in range(m):
qc.h(n + i)
for j in range(i+1, m):
qc.append(U1Gate(-pi/2**(j-i)).control(1), [n + j, n + i])
return qc
''' |
QPC002_B6 | A845C836C82DF | 1 | WA | 1406 ms | 182 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] & (1 << j)) != 0:
qc.cx(x[i], y[j])
return qc
''' |
QPC002_B6 | A8CAF4302851D | 1 | WA | 1142 ms | 154 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import numpy as np
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x = QuantumRegister(n, name='x')
y = QuantumRegister(m, name='y')
qc = QuantumCircuit(x, y)
qc.reset(y)
for i in range(n):
if S[i] != 0:
for j in range(m):
if (S[i] >> j) & 1:
qc.cx(x[i], y[j])
return qc
''' |
QPC002_B6 | A8CAF4302851D | 2 | WA | 1367 ms | 143 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import numpy as np
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x = QuantumRegister(n, name='x')
y = QuantumRegister(m, name='y')
qc = QuantumCircuit(x, y)
# Apply controlled addition gates
for i in range(n):
for j in range(m):
if (S[i] >> j) & 1:
qc.cx(x[i], y[j])
return qc
''' |
QPC002_B6 | A92983DA3BC1B | 1 | RE | 1429 ms | 153 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
def qft(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in reversed(range(n)):
qc.h(i)
for j in reversed(range(i)):
qc.cp(math.pi / 2 ** (i - j), j, i)
for i in range(n // 2):
qc.swap(i, n - i - 1)
return qc
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
qc.h(y)
for j in range(m):
for i in range(n):
theta = (2 * math.pi * S[i] / 2**m) * 2**j
qc.cp(theta, x[i], y[j])
qc.compose(qft(m).inverse(), y, inplace=True)
return qc
''' |
QPC002_B6 | A92983DA3BC1B | 2 | AC | 1725 ms | 155 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def qft(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in reversed(range(n)):
qc.h(i)
for j in reversed(range(i)):
qc.cp(math.pi / 2 ** (i - j), j, i)
for i in range(n // 2):
qc.swap(i, n - i - 1)
return qc
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
qc.h(y)
for j in range(m):
for i in range(n):
theta = (2 * math.pi * S[i] / 2**m) * 2**j
qc.cp(theta, x[i], y[j])
qc.compose(qft(m).inverse(), y, inplace=True)
return qc
''' |
QPC002_B6 | A93735C67CC40 | 1 | WA | 1140 ms | 141 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library.standard_gates import PhaseGate
import math
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n + m)
qc.x(0)
for i in range(m):
qc.h(n + i)
for i in range(n):
for j in range(m):
qc.append(PhaseGate(-2 * math.pi * S[i] / pow(2, m - j)).control(1), [i, n + j])
for i in range(m - 1, -1, -1):
for j in range(m - 1, i, -1):
qc.append(PhaseGate(2 * math.pi * math.pow(2, i - 1 - j)).control(1), [n + i, n + j])
qc.h(n + i)
for i in range(m // 2):
qc.cx(n + i, n + m - 1 - i)
qc.cx(n + m - 1 - i, n + i)
qc.cx(n + i, n + m - 1 - i)
return qc
''' |
QPC002_B6 | A93735C67CC40 | 2 | AC | 2064 ms | 183 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library.standard_gates import PhaseGate
import math
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
qc = QuantumCircuit(n + m)
for i in range(m):
qc.h(n + i)
for i in range(n):
for j in range(m):
qc.append(PhaseGate(-2 * math.pi * S[i] / pow(2, m - j)).control(1), [i, n + j])
for i in range(m - 1, -1, -1):
for j in range(m - 1, i, -1):
qc.append(PhaseGate(2 * math.pi * math.pow(2, i - 1 - j)).control(1), [n + i, n + j])
qc.h(n + i)
for i in range(m // 2):
qc.cx(n + i, n + m - 1 - i)
qc.cx(n + m - 1 - i, n + i)
qc.cx(n + i, n + m - 1 - i)
return qc
''' |
QPC002_B6 | A99E5103D111F | 1 | RE | 1370 ms | 182 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,m):
qc.h(i)
for i in range(n,m):
for j in range(n):
qc.cp(2.0*np.pi/(2.0**m)*S[j]*(2.0**(i-n)), j, i)
for i in range(n,m):
if i < m-1-i:
qc.swap(i,m-1-i)
for i in range(n,m):
for j in range(n,i):
qc.cp(-np.pi/(2.0**(i-j)), k, i)
qc.h(i)
return qc
''' |
QPC002_B6 | A99E5103D111F | 2 | RE | 1584 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,m):
qc.h(i)
for i in range(n,m):
for j in range(n):
qc.cp(2.0*np.pi/(2.0**m)*S[j]*(2.0**(i-n)), j, i)
for i in range(m):
if n+i < m-1-i:
qc.swap(n+i,m-1-i)
for i in range(n,m):
for j in range(n,i):
qc.cp(-np.pi/(2.0**(i-j)), j, i)
qc.h(i)
return qc
''' |
QPC002_B6 | A99E5103D111F | 3 | RE | 1255 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,n+m):
qc.h(i)
for i in range(n,n+m):
for j in range(n):
qc.cp(2.0*np.pi/(2.0**m)*S[j]*(2.0**(i-n)), j, i)
for i in range(m):
if n+i < m-1-i:
qc.swap(n+i,m-1-i)
for i in range(n,n+m):
for j in range(n,i):
qc.cp(-np.pi/(2.0**(i-j)), j, i)
qc.h(i)
return qc
''' |
QPC002_B6 | A99E5103D111F | 4 | RE | 1283 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:
for i in range(n,m):
qc.h(i)
for i in range(n,m):
for j in range(n):
qc.cp(2.0*np.pi/(2.0**m)*S[j]*(2.0**(i-n)), j, i)
for i in range(m):
if n+i < m-1-i:
qc.swap(n+i,m-1-i)
for i in range(n,m):
for j in range(n,i):
qc.cp(-np.pi/(2.0**(i-j)), j, i)
qc.h(i)
return qc
''' |
QPC002_B6 | A99E5103D111F | 5 | RE | 1320 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,n+m):
qc.h(i)
for i in range(n,m):
for j in range(n):
qc.cp(2.0*np.pi/(2.0**m)*S[j]*(2.0**(i-n)), j, i)
for i in range(m):
if n+i < m-1-i:
qc.swap(n+i,m-1-i)
for i in range(n,nm):
for j in range(n,i):
qc.cp(-np.pi/(2.0**(i-j)), j, i)
qc.h(i)
return qc
''' |
QPC002_B6 | A99E5103D111F | 6 | RE | 1282 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:
nms = n+m
for i in range(n,nms):
qc.h(i)
for i in range(n,m):
for j in range(n):
qc.cp(2.0*np.pi/(2.0**m)*S[j]*(2.0**(i-n)), j, i)
for i in range(m):
if n+i < m-1-i:
qc.swap(n+i,m-1-i)
for i in range(n,nm):
for j in range(n,i):
qc.cp(-np.pi/(2.0**(i-j)), j, i)
qc.h(i)
return qc
''' |
QPC002_B6 | A99E5103D111F | 7 | WA | 1508 ms | 181 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,n+m):
qc.h(i)
# for i in range(n,n+m):
# for j in range(n):
# qc.cp(2.0*np.pi/(2.0**m)*S[j]*(2.0**(i-n)), j, i)
# for i in range(m):
# if n+i < m-1-i:
# qc.swap(n+i,m-1-i)
# for i in range(n,nm):
# for j in range(n,i):
# qc.cp(-np.pi/(2.0**(i-j)), j, i)
# qc.h(i)
return qc
''' |
QPC002_B6 | A99E5103D111F | 8 | RE | 1267 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,n+m):
qc.h(i)
# for i in range(n,n+m):
# for j in range(n):
# qc.cp(2.0*np.pi/(2.0**m)*S[j]*(2.0**(i-n)), j, i)
for i in range(m):
if n+i < m-1-i:
qc.swap(n+i,m-1-i)
for i in range(n,n+m):
for j in range(n,i):
qc.cp(-np.pi/(2.0**(i-j)), j, i)
qc.h(i)
return qc
''' |
QPC002_B6 | A99E5103D111F | 9 | WA | 1457 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,n+m):
qc.h(i)
# for i in range(n,n+m):
# for j in range(n):
# qc.cp(2.0*np.pi/(2.0**m)*S[j]*(2.0**(i-n)), j, i)
for i in range(m):
if n+i < m-1-i:
qc.swap(n+i,m-1-i)
# for i in range(n,n+m):
# for j in range(n,i):
# qc.cp(-np.pi/(2.0**(i-j)), j, i)
# qc.h(i)
return qc
''' |
QPC002_B6 | A99E5103D111F | 10 | WA | 1124 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,n+m):
qc.h(i)
for i in range(n,n+m):
for j in range(n):
qc.x(0)
# qc.cp(2.0*np.pi/(2.0**m)*S[j]*(2.0**(i-n)), j, i)
for i in range(m):
if n+i < m-1-i:
qc.swap(n+i,m-1-i)
# for i in range(n,n+m):
# for j in range(n,i):
# qc.cp(-np.pi/(2.0**(i-j)), j, i)
# qc.h(i)
return qc
''' |
QPC002_B6 | A99E5103D111F | 11 | RE | 1488 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,n+m):
qc.h(i)
for i in range(n,n+m):
for j in range(n):
qc.cp(2.0*np.pi/(2.0**m)*S[j]*(2.0**(i-n)), j, i)
for i in range(m):
if n+i < m-1-i:
qc.swap(n+i,m-1-i)
# for i in range(n,n+m):
# for j in range(n,i):
# qc.cp(-np.pi/(2.0**(i-j)), j, i)
# qc.h(i)
return qc
''' |
QPC002_B6 | A99E5103D111F | 12 | RE | 1457 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,n+m):
qc.h(i)
for i in range(n,n+m):
for j in range(n):
qc.cp(np.pi, 0, 1)
# qc.cp(2.0*np.pi/(2.0**m)*S[j]*(2.0**(i-n)), j, i)
for i in range(m):
if n+i < m-1-i:
qc.swap(n+i,m-1-i)
# for i in range(n,n+m):
# for j in range(n,i):
# qc.cp(-np.pi/(2.0**(i-j)), j, i)
# qc.h(i)
return qc
''' |
QPC002_B6 | A99E5103D111F | 13 | WA | 1081 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,n+m):
qc.h(i)
for i in range(n,n+m):
for j in range(n):
qc.x(0)
# qc.cp(np.pi, 0, 1)
# qc.cp(2.0*np.pi/(2.0**m)*S[j]*(2.0**(i-n)), j, i)
for i in range(m):
if n+i < m-1-i:
qc.swap(n+i,m-1-i)
# for i in range(n,n+m):
# for j in range(n,i):
# qc.cp(-np.pi/(2.0**(i-j)), j, i)
# qc.h(i)
return qc
''' |
QPC002_B6 | A99E5103D111F | 14 | WA | 1228 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(n,n+m):
qc.h(i)
for i in range(n,n+m):
for j in range(n):
qc.cp(2.0*np.pi/(2.0**m)*S[j]*(2.0**(i-n)), j, i)
for i in range(m):
if n+i < m-1-i:
qc.swap(n+i,m-1-i)
# for i in range(n,n+m):
# for j in range(n,i):
# qc.cp(-np.pi/(2.0**(i-j)), j, i)
# qc.h(i)
return qc
''' |
QPC002_B6 | A99E5103D111F | 15 | WA | 1362 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(n,n+m):
qc.h(i)
for i in range(n,n+m):
for j in range(n):
qc.cp(2.0*np.pi/(2.0**m)*S[j]*(2.0**(i-n)), j, i)
for i in range(m):
if n+i < m-1-i:
qc.swap(n+i,m-1-i)
for i in range(n,n+m):
for j in range(n,i):
qc.cp(-np.pi/(2.0**(i-j)), j, i)
qc.h(i)
return qc
''' |
QPC002_B6 | A99E5103D111F | 16 | WA | 1298 ms | 153 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(n,n+m):
qc.h(i)
for i in range(n,n+m):
for j in range(n):
qc.cp(2.0*np.pi/(2.0**m)*S[j]*(2.0**(i-n)), i, j)
for i in range(m):
if n+i < m-1-i:
qc.swap(n+i,m-1-i)
for i in range(n,n+m):
for j in range(n,i):
qc.cp(-np.pi/(2.0**(i-j)), j, i)
qc.h(i)
return qc
''' |
QPC002_B6 | A99E5103D111F | 17 | WA | 1875 ms | 183 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(n,n+m):
qc.h(i)
for i in range(n,n+m):
for j in range(n):
qc.cp(2.0*np.pi/(2.0**m)*S[j]*(2.0**((n+m-1)-i)), i, j)
for i in range(m):
if n+i < m-1-i:
qc.swap(n+i,m-1-i)
for i in range(n,n+m):
for j in range(n,i):
qc.cp(-np.pi/(2.0**(i-j)), j, i)
qc.h(i)
return qc
''' |
QPC002_B6 | A99E5103D111F | 18 | RE | 1364 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(n,n+m):
qc.h(i)
for i in range(n,n+m):
for j in range(n):
qc.cp(2.0*np.pi/S[j]*(2.0**((n-1)-i)), i, j)
for i in range(m):
if n+i < m-1-i:
qc.swap(n+i,m-1-i)
for i in range(n,n+m):
for j in range(n,i):
qc.cp(-np.pi/(2.0**(i-j)), j, i)
qc.h(i)
return qc
''' |
QPC002_B6 | A99E5103D111F | 19 | WA | 1387 ms | 182 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(n,n+m):
qc.h(i)
for i in range(n,n+m):
for j in range(n):
qc.cp(2.0*np.pi/(2.0**m)*S[j]*(2.0**((n+m-1)-i)), i, j)
for i in range(m):
if n+i < m-1-i:
qc.swap(n+i,m-1-i)
for i in range(n,n+m):
for j in range(n,i):
qc.cp(-np.pi/(2.0**(i-j)), j, i)
qc.h(i)
return qc
''' |
QPC002_B6 | A99E5103D111F | 20 | AC | 1778 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(n,n+m):
qc.h(i)
for i in range(n,n+m):
for j in range(n):
qc.cp(2.0*np.pi/(2.0**m)*S[j]*(2.0**((n+m-1)-i)), i, j)
# for i in range(m):
# if n+i < m-1-i:
# qc.swap(n+i,m-1-i)
for i in range(n,n+m):
for j in range(n,i):
qc.cp(-np.pi/(2.0**(i-j)), j, i)
qc.h(i)
return qc
''' |
QPC002_B6 | A9D96D6719D4C | 1 | UME | '''python
from qiskit import QuantumRegister, QuantumCircuit
from numpy import pi
def solve(n, m, s) -> QuantumCircuit:
from qiskit.circuit.library import QFT
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
for i in range(n):
qc.append(QFT(m).control(1), [x[i]] + list(y))
for j in range(m):
qc.cp(2 * pi * s[i] / 2**(m - j), x[i], y[j])
qc.append(QFT(m, inverse = True).control(1), [x[i]] + list(y))
return qc
''' | ||
QPC002_B6 | A9D96D6719D4C | 2 | DLE | 1780 ms | 156 MiB | '''python
from qiskit import QuantumRegister, QuantumCircuit
# Adds 2 * len(qubits) circuit depth
def apply_QFT(qc, qubits, ctrl_qubit = None, inverse = False):
from numpy import pi
coef = -pi if inverse else pi
if ctrl_qubit:
for i in reversed(range(len(qubits))):
qc.ch(ctrl_qubit, qubits[i])
for j in reversed(range(i)):
qc.mcp(coef / 2**(i - j), [ctrl_qubit, qubits[j]], qubits[i])
for i in range(len(qubits) // 2):
qc.cswap(ctrl_qubit, qubits[i], qubits[len(qubits) - 1 - i])
else:
for i in reversed(range(len(qubits))):
qc.h(qubits[i])
for j in reversed(range(i)):
qc.cp(coef / 2**(i - j), qubits[j], qubits[i])
for i in range(len(qubits) // 2):
qc.swap(qubits[i], qubits[len(qubits) - 1 - i])
return qc
def solve(n, m, s) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
from numpy import pi
for i in range(n):
apply_QFT(qc, y, x[i])
for j in range(m):
qc.cp(2 * pi * s[i] / 2**(m - j), x[i], y[j])
apply_QFT(qc, y, x[i], inverse = True)
return qc
''' |
QPC002_B6 | A9D96D6719D4C | 3 | AC | 2597 ms | 161 MiB | '''python
from qiskit import QuantumRegister, QuantumCircuit
# Adds 2 * len(qubits) circuit depth
def apply_QFT(qc, qubits, ctrl_qubit = None, inverse = False):
from numpy import pi
coef = -pi if inverse else pi
if ctrl_qubit:
for i in reversed(range(len(qubits))):
qc.ch(ctrl_qubit, qubits[i])
for j in reversed(range(i)):
qc.mcp(coef / 2**(i - j), [ctrl_qubit, qubits[j]], qubits[i])
for i in range(len(qubits) // 2):
qc.cswap(ctrl_qubit, qubits[i], qubits[len(qubits) - 1 - i])
else:
for i in reversed(range(len(qubits))):
qc.h(qubits[i])
for j in reversed(range(i)):
qc.cp(coef / 2**(i - j), qubits[j], qubits[i])
for i in range(len(qubits) // 2):
qc.swap(qubits[i], qubits[len(qubits) - 1 - i])
return qc
def solve(n, m, s) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
from numpy import pi
for j in range(m):
qc.h(y[j])
for i in range(n):
for j in range(m):
qc.cp(pi * s[i] / 2**(m - 1 - j), x[i], y[j])
apply_QFT(qc, y, inverse = True)
return qc
''' |
QPC002_B6 | AA18282AD1861 | 1 | WA | 1233 ms | 143 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)
# Implement the oracle
for i in range(n):
for j in range(m):
if (S[i] & (1 << j)) != 0:
qc.cx(x[i], y[j])
return qc
''' |
QPC002_B6 | AA18282AD1861 | 2 | WA | 1480 ms | 182 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)
# Implement the oracle
for i in range(n):
si = S[i]
for j in range(m):
if si & 1:
qc.cx(x[i], y[j])
si >>= 1
# Reverse the additions for qubits other than the least significant
if i > 0:
si = S[i]
for j in range(m-1, 0, -1):
if si & (1 << j):
for k in range(j):
qc.cx(y[j], y[k])
return qc
''' |
QPC002_B6 | AA18282AD1861 | 3 | WA | 1499 ms | 182 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)
# Implement the oracle
for i in range(n):
si = S[i]
for j in range(m):
if si & 1:
qc.cx(x[i], y[j])
si >>= 1
# Reverse the additions for qubits other than the least significant
if i > 0:
si = S[i]
for j in range(m-1, 0, -1):
if si & (1 << j):
for k in range(j):
qc.cx(y[j], y[k])
return qc
''' |
QPC002_B6 | AA18282AD1861 | 4 | WA | 1247 ms | 153 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from math import pi
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Implement f(x) using controlled rotations
for i in range(n):
for j in range(m):
angle = (S[i] * 2**j * 2 * pi) / (2**m)
qc.cry(angle, x[i], y[j])
return qc
''' |
QPC002_B6 | AA18282AD1861 | 5 | WA | 1770 ms | 183 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)
# Implement f(x) using controlled additions
for i in range(n):
# Convert S[i] to binary representation
si_binary = format(S[i], f'0{m}b')[::-1] # Reverse for little-endian
# Apply controlled-X gates for each bit of S[i]
for j in range(m):
if si_binary[j] == '1':
qc.cx(x[i], y[j])
return qc
''' |
QPC002_B6 | AB55BEFC1BFD0 | 1 | AC | 1927 ms | 183 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def r(qc: QuantumCircuit, control: int, target: int, l: int):
qc.cp(2*math.pi/(1<<l), control, target)
def qft(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n//2):
qc.cx(i, n-i-1)
qc.cx(n-i-1, i)
qc.cx(i, n-i-1)
for i in range(0, n):
qc.h(i)
for j in range(1, n-i):
r(qc, i+j, i, j+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 k in range(m):
for i in range(n):
qc.cp(2*math.pi*S[i]/(1<<m)*(1<<k), y[k], x[i])
qc = qc.compose(qft(m).inverse(), y)
return qc
''' |
QPC002_B6 | AB907F5E55DD5 | 1 | WA | 1167 ms | 153 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def calc_f(m: int, S: list[int], qc: QuantumCircuit, r: QuantumRegister) -> None:
for i in range(len(r)):
qc.p(2 * math.pi / (2 ** m) * S[i], r[i])
def inv_qft(qc: QuantumCircuit, r: QuantumRegister) -> None:
n = len(r)
# swap
for i in range(n // 2):
qc.swap(i, r[n - 1 - i])
for i in reversed(range(n)):
for j in reversed(range(i + 1, n)):
theta = 2 * math.pi / (2 ** (j - i + 1))
qc.cp(- theta, r[n - 1 - j], r[n - 1 - i])
qc.h(r[n - 1 - 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:
calc_f(m, S, qc, x)
inv_qft(qc, y)
return qc
''' |
QPC002_B6 | AB907F5E55DD5 | 2 | RE | 1348 ms | 139 MiB | '''python
from qiskit import QuantumCircuit
import math
def qft(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.h(n - 1 - i)
for j in range(i + 1, n):
theta = 2 * math.pi / (2 ** (j - i + 1))
qc.cp(theta, n - 1 - j, n - 1 -i)
# swap
for i in range(n // 2):
qc.swap(i, n - 1 - 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:
qc.h(y)
for j in range(m):
for i in range(n):
qc.cp(2 * math.pi / (2 ** m) * S[i] * (2 ** j), y[j], x[i])
qc.compose(qc_f, x, inplace=True)
qc.copmose(qft(m).inverse(), y, inplace=True)
return qc
''' |
QPC002_B6 | AB907F5E55DD5 | 3 | RE | 1217 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
import math
def qft(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.h(n - 1 - i)
for j in range(i + 1, n):
theta = 2 * math.pi / (2 ** (j - i + 1))
qc.cp(theta, n - 1 - j, n - 1 -i)
# swap
for i in range(n // 2):
qc.swap(i, n - 1 - 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:
qc.h(y)
for j in range(m):
for i in range(n):
qc.cp(2 * math.pi / (2 ** m) * S[i] * (2 ** j), y[j], x[i])
qc.copmose(qft(m).inverse(), y, inplace=True)
return qc
''' |
QPC002_B6 | AB907F5E55DD5 | 4 | RE | 1291 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
import math
def qft(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.h(n - 1 - i)
for j in range(i + 1, n):
theta = 2 * math.pi / (2 ** (j - i + 1))
qc.cp(theta, n - 1 - j, n - 1 -i)
# swap
for i in range(n // 2):
qc.swap(i, n - 1 - 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:
qc.h(y)
for j in range(m):
for i in range(n):
qc.cp(2 * math.pi / (2 ** m) * S[i] * (2 ** j), y[j], x[i])
qc.compose(qft(m).inverse(), y, inplace=True)
return qc
''' |
QPC002_B6 | AB907F5E55DD5 | 5 | RE | 1300 ms | 139 MiB | '''python
from qiskit import QuantumCircuit
import math
def qft(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in reversed(range(n)):
qc.h(i)
for j in reversed(range(i)):
qc.cp(math.pi / 2 ** (i - j), j, i)
for i in range(n // 2):
qc.swap(i, n - i - 1)
return qc
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
# Write your code here:
qc.h(y)
for j in range(m):
for i in range(n):
qc.cp(2 * math.pi / (2 ** m) * S[i] * (2 ** j), y[j], x[i])
qc.compose(qft(m).inverse(), y, inplace=True)
return qc
''' |
QPC002_B6 | AB907F5E55DD5 | 6 | RE | 1422 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
import math
def qft(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.h(n - 1 - i)
for j in range(i + 1, n):
theta = 2 * math.pi / (2 ** (j - i + 1))
qc.cp(theta, n - 1 - j, n - 1 - i)
# swap
for i in range(n // 2):
qc.swap(i, n - 1 - i)
return qc
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
qc.h(y)
for j in range(m):
for i in range(n):
theta = (2 * math.pi * S[i] / 2**m) * 2**j
qc.cp(theta, x[i], y[j])
qc.compose(qft(m).inverse(), y, inplace=True)
return qc
''' |
QPC002_B6 | ABEC87D596E54 | 1 | RE | '''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:
# Apply X gates to flip the bits of y that correspond to non-zero coefficients in S
for i in range(n):
if S[i] != 0:
qc.x(y[S[i] % m])
# Apply controlled-X gates to compute the sum modulo 2^m
for i in range(n):
for j in range(m):
if (S[i] >> j) & 1:
(link unavailable)(x[i], y[j])
# Apply X gates again to flip the bits of y back
for i in range(n):
if S[i] != 0:
qc.x(y[S[i] % m])
return qc
''' | ||
QPC002_B6 | AC0E38E100BD2 | 1 | WA | 1254 ms | 152 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
for i in range(len(S)):
for j in range(m):
if (S[i]&(1<<j)) > 0:
for k in range(m-1, j, -1):
qc.h(n+k)
qc.mcp(math.pi, list(range(n,n+k)), n+k)
qc.h(n+k)
qc.x(n+j)
return qc
''' |
QPC002_B6 | AC0E38E100BD2 | 2 | RE | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
for i in range(len(S)):
for j in range(m):
if (S[i]&(1<<j)) > 0:
for k in range(m-1, j-1, -1):
qc.h(n+k)
qc.mcp(math.pi, [i, **(list(range(n+j,n+k))) ], n+k)
qc.h(n+k)
return qc
''' | ||
QPC002_B6 | AC0E38E100BD2 | 3 | DLE | 1496 ms | 182 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
for i in range(len(S)):
for j in range(m):
if (S[i]&(1<<j)) > 0:
for k in range(m-1, j-1, -1):
qc.h(n+k)
qc.mcp(math.pi, [i, *(list(range(n+j,n+k))) ], n+k)
qc.h(n+k)
return qc
''' |
QPC002_B6 | AC0E38E100BD2 | 4 | RE | 1684 ms | 140 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
for i in range(len(S)):
for j in range(m-1, 0, -1):
rem = (1<<j)-S[i]%(1<<j)
for k in range(j-1, -1, -1):
if rem >= (1<<k):
qc.mpc(math.pi, [ i, *(list(range(n+j-1, n+k-1, -1))) ], n+j)
if k > 0:
rem -= (1<<k)
qc.x(n+k)
rem = (1<<j)-S[i]%(1<<j)
for k in range(j-1, -1, -1):
if rem >= (1<<k):
if k > 0:
rem -= (1<<k)
qc.x(n+k)
return qc
''' |
QPC002_B6 | AC0E38E100BD2 | 5 | RE | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
for i in range(len(S)):
for j in range(m-1, 0, -1):
qc.h(n+j)
rem = (1<<j)-S[i]%(1<<j)
for k in range(j-1, -1, -1):
if rem <= (1<<k):
qc.mpc(math.pi, [ i, *(list(range(n+j-1, n+k-1, -1))) ], n+j)
if k > 0:
qc.x(n+k)
else:
rem -= (1<<k)
rem = (1<<j)-S[i]%(1<<j)
for k in range(j-1, -1, -1):
if rem > (1<<k):
rem -= (1<<k)
else if k > 0:
qc.x(n+k)
qc.h(n+j)
if (S[i]&(1<<j)) > 0:
qc.cx(i, n+j)
if S[i]%2 == 1:
qc.cx(i, n)
return qc
''' | ||
QPC002_B6 | AC0E38E100BD2 | 6 | DLE | 1540 ms | 182 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def solve(n: int, m: int, S: list[int]) -> QuantumCircuit:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
for i in range(len(S)):
for j in range(m-1, 0, -1):
qc.h(n+j)
rem = (1<<j)-S[i]%(1<<j)
for k in range(j-1, -1, -1):
if rem <= (1<<k):
qc.mcp(math.pi, [ i, *(list(range(n+j-1, n+k-1, -1))) ], n+j)
if k > 0:
qc.x(n+k)
else:
rem -= (1<<k)
rem = (1<<j)-S[i]%(1<<j)
for k in range(j-1, -1, -1):
if rem > (1<<k):
rem -= (1<<k)
elif k > 0:
qc.x(n+k)
qc.h(n+j)
if (S[i]&(1<<j)) > 0:
qc.cx(i, n+j)
if S[i]%2 == 1:
qc.cx(i, n)
return qc
''' |
QPC002_B6 | AD58125C011A1 | 1 | AC | 1800 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 | ADC1BE39EC707 | 1 | WA | 1466 ms | 144 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:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
for i in range(n):
for j in range(m):
if (S[i] >> j) & 1:
qc.cx(x[i], y[j])
return qc
''' |
QPC002_B6 | ADC1BE39EC707 | 2 | WA | 1150 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:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
for i in range(min(n, m)):
for j in range(m):
if (S[i] >> j) & 1:
qc.cx(x[i], y[j])
return qc
''' |
QPC002_B6 | ADC1BE39EC707 | 3 | WA | 1376 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:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
now = 0
for i in range(n):
for j in range(m):
if (S[i] >> j) & 1:
qc.cx(x[i], y[j])
return qc
''' |
QPC002_B6 | ADC1BE39EC707 | 4 | WA | 1196 ms | 153 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:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
now = 0
for i in range(n):
for j in range(m):
if (S[i] >> j) & 1:
qc.cx(x[i], y[j])
for i in range(n):
for j in range(m):
if (S[i] >> j) & 1:
for k in range(j + 1, m):
if (S[i] >> k) & 1:
qc.cx(y[k], y[j])
return qc
''' |
QPC002_B6 | ADC1BE39EC707 | 5 | WA | 1171 ms | 153 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:
x, y = QuantumRegister(n), QuantumRegister(m)
qc = QuantumCircuit(x, y)
now = 0
for i in range(n):
for j in range(m):
if (S[i] >> j) & 1:
for k in range(j, m):
qc.cx(x[i], y[k])
return qc
''' |
QPC002_B6 | AF21F6BF33D48 | 1 | WA | 1246 ms | 182 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] & (1<<m):
qc.cx(x[i], y[j])
return qc
''' |
QPC002_B6 | AF612293F7B68 | 1 | WA | 1270 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)
for i in range(2**n):
j = 0
for k in range(n):
j += ((i >> k) & 1) * S[k]
j %= 2**m
if i == j:
continue
for k in range(n):
if (i >> k) & 1 == 0:
qc.x(x[k])
for k in range(m):
if (j >> k) & 1 == 1:
qc.mcx(x, y[k])
for k in range(n):
if (i >> k) & 1 == 0:
qc.x(x[k])
return qc
''' |
QPC002_B6 | AF612293F7B68 | 2 | WA | 1140 ms | 143 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)
for i in range(n):
for j in range(m):
if (S[i] >> j) & 1 == 1:
qc.cx(x[i], y[j])
return qc
''' |
QPC002_B6 | AF612293F7B68 | 3 | WA | 1890 ms | 183 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)
for i in reversed(range(n)):
for j in range(m):
if (S[i] >> j) & 1 == 1:
qc.cx(x[i], y[j])
return qc
''' |
QPC002_B6 | AF66D93D9F2B1 | 1 | RE | 1726 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:
import math
def qft(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
qc.h(i)
rotation = math.pi / 2
for j in range(i + 1, n):
qc.cp(rotation, j, i)
rotation /= 2
for i in range(n // 2):
qc.swap(i, n - i - 1)
qc = qc.reverse_bits()
return qc
def add_k_fourier(
qc: QuantumCircuit, k: int, control: QuantumRegister
) -> QuantumCircuit:
for i in range(n):
qc.crz(math.pi * k / 2**i, control, y[i])
qc.compose(qft(n), inplace=True, qubits=x)
for i in range(n):
add_k_fourier(qc, S[i], x[i])
qc.compose(qft(n).inverse(), inplace=True, qubits=x)
return qc
''' |
QPC002_B6 | AF66D93D9F2B1 | 2 | WA | 1553 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:
import math
def qft(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
qc.h(i)
rotation = math.pi / 2
for j in range(i + 1, n):
qc.cp(rotation, j, i)
rotation /= 2
for i in range(n // 2):
qc.swap(i, n - i - 1)
qc = qc.reverse_bits()
return qc
def add_k_fourier(
qc: QuantumCircuit, k: int, control: QuantumRegister
) -> QuantumCircuit:
for i in range(m):
qc.crz(math.pi * k / 2**i, control, y[i])
qc.compose(qft(n), inplace=True, qubits=x)
for i in range(n):
add_k_fourier(qc, S[i], x[i])
qc.compose(qft(n).inverse(), inplace=True, qubits=x)
return qc
''' |
QPC002_B6 | AF66D93D9F2B1 | 3 | WA | 1404 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:
import math
def qft(n: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
qc.h(i)
rotation = math.pi / 2
for j in range(i + 1, n):
qc.cp(rotation, j, i)
rotation /= 2
for i in range(n // 2):
qc.swap(i, n - i - 1)
# qc = qc.reverse_bits()
return qc
def add_k_fourier(
qc: QuantumCircuit, k: int, control: QuantumRegister
) -> QuantumCircuit:
for i in range(m):
qc.crz(math.pi * k / 2**i, control, y[i])
qc.compose(qft(m), inplace=True, qubits=y)
for i in range(n):
add_k_fourier(qc, S[i], x[i])
qc.compose(qft(m).inverse(), inplace=True, qubits=y)
return qc
''' |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.