problem stringclasses 67
values | user stringlengths 13 13 | submission_order int64 1 57 | result stringclasses 10
values | execution_time stringlengths 0 8 | memory stringclasses 88
values | code stringlengths 47 7.62k |
|---|---|---|---|---|---|---|
QPC005_B1 | A55AAF8BEE4E7 | 4 | WA | 1666 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
import numpy as np
def solve(n: int, k_const: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.rz(2 * i * k_const * np.pi / np.power(2, n), i)
return qc
''' |
QPC005_B1 | A55AAF8BEE4E7 | 5 | WA | 1689 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
import numpy as np
def solve(n: int, k_const: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.rz(2 * i * k_const * np.pi / (2**n), i)
return qc
''' |
QPC005_B1 | A55AAF8BEE4E7 | 6 | AC | 1679 ms | 143 MiB | '''python
from qiskit import QuantumCircuit
import numpy as np
def solve(n: int, k_const: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.rz(2 * (2 ** i) * k_const * np.pi / (2 ** n), i)
return qc
''' |
QPC005_B1 | A5B3DDABDCDE0 | 1 | AC | 2023 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
from math import pi
def solve(n: int, k_const: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for s in range(n):
qc.p(pi*2 * 2**(s-n) * k_const, s)
return qc
''' |
QPC005_B1 | A5EBCD9E10BAD | 1 | AC | 2001 ms | 143 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, k_const: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
angle = 2 * math.pi / (2**n) * k_const * (2**i)
qc.p(angle, i)
return qc
''' |
QPC005_B1 | A6A6CD8961C46 | 1 | AC | 1944 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
import numpy as np
def solve(n: int, k_const: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for j in range(n):
lambda_j = (2 * np.pi * k_const) / (2**(n - j))
if lambda_j != 0:
qc.p(lambda_j, j)
return qc
''' |
QPC005_B1 | A81824D7C291F | 1 | RE | 1481 ms | 141 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, k_const: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
omega_angle = 2 * np.pi * k_const / (2**n)
for j in range(n):
angle = (2 ** j) * omega_angle
qc.rz(angle, j)
return qc
''' |
QPC005_B1 | A81824D7C291F | 2 | RE | 1417 ms | 141 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, k_const: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
omega_angle = 2 * np.pi * k_const / (2**n)
for j in range(n):
angle = (2 ** j) * omega_angle
qc.p(angle, j)
return qc
''' |
QPC005_B1 | A81824D7C291F | 3 | RE | 1366 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, k_const: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
omega_angle = 2 * np.pi * k_const / (2**n)
for j in range(n):
angle = (2 ** j) * omega_angle
qc.u1(angle, j)
return qc
''' |
QPC005_B1 | A81824D7C291F | 4 | RE | 1560 ms | 141 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, k_const: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
omega_angle = 2 * np.pi * k_const / (2**n)
for j in range(n):
angle = (2 ** j) * omega_angle
qc.p(angle, j)
return qc
''' |
QPC005_B1 | A81824D7C291F | 5 | AC | 1680 ms | 143 MiB | '''python
from qiskit import QuantumCircuit
import numpy as np
def solve(n: int, k_const: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
omega_angle = 2 * np.pi * k_const / (2**n)
for j in range(n):
angle = (2 ** j) * omega_angle
qc.p(angle, j)
return qc
''' |
QPC005_B1 | A8EFE262A21E4 | 1 | RE | 1383 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, k_const: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.h(n)
return qc
''' |
QPC005_B1 | A90DD3397E700 | 1 | WA | 1943 ms | 142 MiB | '''python
from math import pi
from qiskit import QuantumCircuit
def solve(n: int, k_const: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
qc.p(2 * pi * k_const / 2**n, i)
return qc
''' |
QPC005_B1 | A90DD3397E700 | 2 | RE | 1698 ms | 141 MiB | '''python
from math import pi
from qiskit import QuantumCircuit
def solve(n: int, k_const: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
qc.p(2 * pi * int(bin(k_const)[:-1-i]) / 2**n, i)
return qc
''' |
QPC005_B1 | A9288531CAC27 | 1 | WA | 1634 ms | 143 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, k_const: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
k_const_bits = []
temp = k_const
for i in range(n):
k_const_bits.append(temp % 2)
temp //= 2
for j in range(n):
if k_const_bits[j] == 1:
angle = 2 * math.pi / (2**(n-j))
qc.p(angle, j)
return qc
''' |
QPC005_B1 | A9288531CAC27 | 2 | WA | 1471 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, k_const: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for j in range(n):
angle = 0
for i in range(n):
if (k_const >> i) & 1:
if i <= j:
angle += math.pi / (2**(j - i))
if angle != 0:
qc.p(2 * angle, j)
return qc
''' |
QPC005_B1 | A9288531CAC27 | 3 | WA | 1538 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, k_const: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for j in range(n):
phase_accumulator = 0.0
for i in range(n):
if (k_const >> i) & 1:
if i <= j:
phase_accumulator += 1.0 / (2.0 ** (j - i + 1))
if phase_accumulator > 0:
angle = 2.0 * math.pi * phase_accumulator
qc.p(angle, j)
return qc
''' |
QPC005_B1 | A96CF8F6B691D | 1 | RE | 1398 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, k_const: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
theta = 2 * math.pi * k_const / (2 ** (i + 1))
qc.p(theta, i)
return qc
''' |
QPC005_B1 | A96CF8F6B691D | 2 | RE | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, k_const: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):￥
theta = 2 * math.pi * k_const / (2 ** (i + 1))
qc.p(theta, i)
return qc
''' | ||
QPC005_B1 | A96CF8F6B691D | 3 | WA | 1573 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, k_const: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
theta = 2 * math.pi * k_const / (2 ** (i + 1))
qc.p(theta, i)
return qc
''' |
QPC005_B1 | A96CF8F6B691D | 4 | AC | 1918 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, k_const: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
theta = 2 * math.pi * k_const / (2 ** (n - i))
qc.p(theta, i)
return qc
''' |
QPC005_B1 | AAA65D3F49C59 | 1 | AC | 1837 ms | 142 MiB | '''python
import math
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import ZGate, XGate, HGate, SwapGate
def solve(n: int, k_const: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
theta = 2 * math.pi * k_const * 2 ** i / 2 ** n
qc.p(theta, i)
return qc
''' |
QPC005_B1 | AAB22FC1DD5B4 | 1 | RE | 1610 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, k_const: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.p(2 ** (1 - n + i) * math.pi * k_const)
return qc
''' |
QPC005_B1 | AAB22FC1DD5B4 | 2 | UME | '''python
from qiskit import QuantumCircuit
import mat
def solve(n: int, k_const: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.p(2 ** (1 - n + i) * math.pi * k_const, i)
return qc
''' | ||
QPC005_B1 | AAB22FC1DD5B4 | 3 | UME | '''python
from qiskit import QuantumCircuit
import mat
def solve(n: int, k_const: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.p(2 * math.pi / 2 ** n * 2 ** i * k_const, i)
return qc
''' | ||
QPC005_B1 | AAB22FC1DD5B4 | 4 | AC | 2662 ms | 143 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, k_const: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.p(2 ** (i + 1 - n) * math.pi * k_const, i)
return qc
''' |
QPC005_B1 | AAF53979AB9B4 | 1 | AC | 1766 ms | 143 MiB | '''python
from qiskit import QuantumCircuit
from math import tau
def solve(n: int, k_const: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
theta = tau * k_const * (1 << i) / (1 << n)
qc.p(theta, i)
return qc
''' |
QPC005_B1 | AAF60924E35DA | 1 | AC | 1976 ms | 143 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, k_const: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
phase_angle = 2 * 3.141592653589793 * k_const / (2 ** (n - i))
qc.p(phase_angle, i)
return qc
''' |
QPC005_B1 | AC6505D2B86B5 | 1 | AC | 1901 ms | 143 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, k_const: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
theta = 2 * math.pi / (2.0 ** (n - i)) * k_const
qc.p(theta, i)
return qc
def main():
print(solve(4, 1))
print(solve(4, 2))
if __name__ == "__main__":
main()
''' |
QPC005_B1 | AC761A94D17F0 | 1 | WA | 1603 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, k_const: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.p(2*math.pi*k_const / 2**n, i)
return qc
''' |
QPC005_B1 | AC761A94D17F0 | 2 | WA | 1593 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, k_const: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.p(2*math.pi*k_const*(i+1) / 2**n, i)
return qc
''' |
QPC005_B1 | AC761A94D17F0 | 3 | AC | 1800 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, k_const: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.p(2*math.pi*k_const*2**(i) / 2**n, i)
return qc
''' |
QPC005_B1 | AE1735E36A60B | 1 | AC | 1745 ms | 143 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import numpy as np
# from qiskit.quantum_info import Statevector
from qiskit.circuit.library.standard_gates import XGate
def solve(n: int, k_const: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
rot=2*np.pi/2**n*k_const*(2**i)
# print(rot)
qc.p(rot,i)
return qc
# if __name__ == "__main__":
# qc = solve(2,2)
# print(Statevector(qc))
''' |
QPC005_B1 | AF9AB4DB306F1 | 1 | AC | 1692 ms | 143 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, k_const: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
S = [k_const * (2 ** i) for i in range(n)]
for i in range(n):
theta = 2 * math.pi * S[i] / 2**n
qc.p(theta, i)
return qc
''' |
QPC005_B1 | AFCA95E240625 | 1 | WA | 1845 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
from math import pi
def solve(n: int, k_const: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
if k_const & (1<<i) :
phase_shift = 2 * pi * 2**i / (2 ** n)
qc.p(phase_shift, i)
return qc
''' |
QPC005_B1 | AFCA95E240625 | 2 | WA | 1468 ms | 143 MiB | '''python
from qiskit import QuantumCircuit
from math import pi
def solve(n: int, k_const: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
phase_shift = 2 * pi * 2**i / (2 ** n)
qc.p(phase_shift, i)
return qc
''' |
QPC005_B1 | AFCA95E240625 | 3 | AC | 1852 ms | 143 MiB | '''python
from qiskit import QuantumCircuit
from math import pi
def solve(n: int, k_const: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
phase_shift = 2 * pi * 2**i * k_const / (2 ** n)
qc.p(phase_shift, i)
return qc
''' |
QPC005_B2 | A09DFF99FF7F9 | 1 | UGE | 1417 ms | 141 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import numpy as np
from qiskit.circuit.library.standard_gates import XGate
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(np.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_left: int, k_left: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
qc.append(qft(n),range(1,n+1))
for j in range(n):
ang=2*np.pi*k_left/(2**(j+1))
qc.p(ang,j+1)
qc.cp(-2*ang,0,j+1)
qc.append(qft(n).inverse(),range(1,n+1))
if m_left:
qc.x(0)
return qc
# from qiskit.quantum_info import Statevector
# if __name__ == "__main__":
# qc = solve(3,3,3)
# print(Statevector(qc))
''' |
QPC005_B2 | A09DFF99FF7F9 | 2 | UGE | 1540 ms | 141 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import numpy as np
from qiskit.circuit.library.standard_gates import XGate
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(np.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_left: int, k_left: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
qc.append(qft(n),range(1,n+1))
# for j in range(n):
# ang=2*np.pi*k_left/(2**(j+1))
# qc.p(ang,j+1)
# qc.cp(-2*ang,0,j+1)
# qc.append(qft(n).inverse(),range(1,n+1))
if m_left:
qc.x(0)
return qc
# from qiskit.quantum_info import Statevector
# if __name__ == "__main__":
# qc = solve(3,3,3)
# print(Statevector(qc))
''' |
QPC005_B2 | A09DFF99FF7F9 | 3 | UGE | 1475 ms | 141 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import numpy as np
from qiskit.circuit.library.standard_gates import XGate
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(np.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_left: int, k_left: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
qc.append(qft(n),range(1,n+1))
# for j in range(n):
# ang=2*np.pi*k_left/(2**(j+1))
# qc.p(ang,j+1)
# qc.cp(-2*ang,0,j+1)
# qc.append(qft(n).inverse(),range(1,n+1))
if m_left:
qc.x(0)
return qc
# from qiskit.quantum_info import Statevector
# if __name__ == "__main__":
# qc = solve(3,3,3)
# print(Statevector(qc))
''' |
QPC005_B2 | A09DFF99FF7F9 | 4 | WA | 1623 ms | 142 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import numpy as np
from qiskit.circuit.library.standard_gates import XGate
# 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(np.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_left: int, k_left: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
# qc.append(qft(n),range(1,n+1))
# for j in range(n):
# ang=2*np.pi*k_left/(2**(j+1))
# qc.p(ang,j+1)
# qc.cp(-2*ang,0,j+1)
# qc.append(qft(n).inverse(),range(1,n+1))
if m_left:
qc.x(0)
return qc
# from qiskit.quantum_info import Statevector
# if __name__ == "__main__":
# qc = solve(3,3,3)
# print(Statevector(qc))
''' |
QPC005_B2 | A09DFF99FF7F9 | 5 | UGE | 1550 ms | 141 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import numpy as np
from qiskit.circuit.library.standard_gates import XGate
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(np.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_left: int, k_left: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
qc.append(qft(n),range(1,n+1))
# for j in range(n):
# ang=2*np.pi*k_left/(2**(j+1))
# qc.p(ang,j+1)
# qc.cp(-2*ang,0,j+1)
# qc.append(qft(n).inverse(),range(1,n+1))
if m_left:
qc.x(0)
return qc
# from qiskit.quantum_info import Statevector
# if __name__ == "__main__":
# qc = solve(3,3,3)
# print(Statevector(qc))
''' |
QPC005_B2 | A09DFF99FF7F9 | 6 | WA | 1627 ms | 142 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import numpy as np
from qiskit.circuit.library.standard_gates import XGate
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(np.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_left: int, k_left: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
qc.compose(qft(n),range(1,n+1),inplace=True)
for j in range(n):
ang=2*np.pi*k_left/(2**(j+1))
qc.p(ang,j+1)
qc.cp(-2*ang,0,j+1)
qc.compose(qft(n).inverse(),range(1,n+1),inplace=True)
if m_left:
qc.x(0)
return qc
# from qiskit.quantum_info import Statevector
# if __name__ == "__main__":
# qc = solve(3,3,3)
# print(Statevector(qc))
''' |
QPC005_B2 | A09DFF99FF7F9 | 7 | WA | 1663 ms | 142 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import numpy as np
from qiskit.circuit.library.standard_gates import XGate
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(np.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_left: int, k_left: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
qc.compose(qft(n),range(1,n+1),inplace=True)
for j in range(n):
ang=2*np.pi*k_left/(2**(j+1))
qc.p(ang,j+1)
qc.cp(-2*ang,0,j+1)
qc.compose(qft(n).inverse(),range(1,n+1),inplace=True)
if m_left:
qc.x(0)
return qc
# from qiskit.quantum_info import Statevector
# if __name__ == "__main__":
# qc = solve(3,3,3)
# print(Statevector(qc))
''' |
QPC005_B2 | A09DFF99FF7F9 | 8 | WA | 1710 ms | 142 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import numpy as np
from qiskit.circuit.library.standard_gates import XGate
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(np.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_left: int, k_left: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
qc.compose(qft(n),range(1,n+1),inplace=True)
for j in range(n):
ang=2*np.pi*k_left/(2**(j+1))
qc.p(ang,j+1)
qc.cp(-2*ang,0,j+1)
qc.compose(qft(n).inverse(),range(1,n+1),inplace=True)
if m_left:
qc.x(0)
return qc
# from qiskit.quantum_info import Statevector
# if __name__ == "__main__":
# qc = solve(3,0,1)
# print(Statevector(qc))
''' |
QPC005_B2 | A1C722FECC72D | 1 | RE | 1564 ms | 141 MiB | '''python
from qiskit import QuantumCircuit
from math import pi
def solve(n: int, m_left: int, k_left: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
qc.x(range(2,n+1))
qc.mcz(range(n),n)
qc.x(range(2,n+1))
if m_left%2 == 1: qc.x(0)
for i in range(k_left):
qc.rz(2 * pi * 2**(k_left*i - n + 1))
if m_left%2 == 1:
qc.x(range(2,n+1))
qc.mcx(range(2,n),0)
qc.x(range(2,n+1))
return qc
''' |
QPC005_B2 | A1C722FECC72D | 2 | RE | 1546 ms | 141 MiB | '''python
from qiskit import QuantumCircuit
from math import pi
def solve(n: int, m_left: int, k_left: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
qc.x(range(2,n+1))
qc.mcz(range(n),n)
qc.x(range(2,n+1))
if m_left%2 == 1: qc.x(0)
for i in range(n-1):
qc.rz(2 * pi * 2**(k_left*i - n + 1), i+2)
if m_left%2 == 1:
qc.x(range(2,n+1))
qc.mcx(range(2,n),0)
qc.x(range(2,n+1))
return qc
''' |
QPC005_B2 | A1C722FECC72D | 3 | RE | 1392 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
from math import pi
def solve(n: int, m_left: int, k_left: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
qc.x(range(2,n+1))
qc.append(ZGate().control(n), range(n+1))
#qc.mcz(range(n),n)
qc.x(range(2,n+1))
if m_left%2 == 1: qc.x(0)
for i in range(n-1):
qc.rz(2 * pi * 2**(k_left*i - n + 1), i+2)
if m_left%2 == 1:
qc.x(range(2,n+1))
qc.mcx(list(range(2,n)),0)
qc.x(range(2,n+1))
return qc
''' |
QPC005_B2 | A1C722FECC72D | 4 | RE | 1853 ms | 143 MiB | '''python
from qiskit import QuantumCircuit
from math import pi
from qiskit.circuit.library import ZGate
def solve(n: int, m_left: int, k_left: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
qc.x(range(2,n+1))
qc.append(ZGate().control(n), range(n+1))
#qc.mcz(range(n),n)
qc.x(range(2,n+1))
if m_left%2 == 1: qc.x(0)
for i in range(n-1):
qc.rz(2 * pi * 2**(k_left*i - n + 1), i+2)
if m_left%2 == 1:
qc.x(range(2,n+1))
qc.mcx(list(range(2,n)),0)
qc.x(range(2,n+1))
return qc
''' |
QPC005_B2 | A1C722FECC72D | 5 | RE | 1460 ms | 141 MiB | '''python
from qiskit import QuantumCircuit
from math import pi
from qiskit.circuit.library import ZGate
def solve(n: int, m_left: int, k_left: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
qc.x(range(2,n+1))
qc.append(ZGate().control(n), range(n+1))
#qc.mcz(range(n),n)
qc.x(range(2,n+1))
if m_left%2 == 1: qc.x(0)
for i in range(n-1):
qc.rz(2 * pi * 2**(k_left*i - n + 1), i+2)
if m_left%2 == 1:
qc.x(range(2,n+1))
qc.mcx(list(range(2,n+1)),0)
qc.x(range(2,n+1))
return qc
''' |
QPC005_B2 | A1C722FECC72D | 6 | RE | 1601 ms | 143 MiB | '''python
from qiskit import QuantumCircuit
from math import pi
from qiskit.circuit.library import ZGate
def solve(n: int, m_left: int, k_left: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
if m_left%2 == 1: qc.x(0)
if k_left%2 == 1: qc.x(1)
qc.x(range(2,n+1))
qc.append(ZGate().control(n), range(n+1))
#qc.mcz(range(n),n)
qc.x(range(2,n+1))
if m_left%2 == 1: qc.x(0)
if k_left%2 == 1: qc.x(1)
if m_left%2 == 1: qc.x(0)
for i in range(n-1):
qc.rz(2 * pi * 2**(k_left*i - n + 1), i+2)
if m_left%2 == 1:
qc.x(range(2,n+1))
qc.mcx(list(range(2,n+1)),0)
qc.x(range(2,n+1))
return qc
''' |
QPC005_B2 | A1C722FECC72D | 7 | RE | 1584 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
from math import pi
from qiskit.circuit.library import ZGate
def solve(n: int, m_left: int, k_left: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
qc.x(range(2,n+1))
if m_left%2 == 1 and k_left%2 == 1:
qc.append(ZGate().control(n), range(n+1))
elif m_left%2 == 1 and k_left%2 == 0:
qc.append(ZGate().control(n-1), [0] + list(range(2,n+1)))
elif m_left%2 == 0 and k_left%2 == 1:
qc.append(ZGate().control(n-1), range(1, n+1))
else:
qc.append(ZGate().control(n-2), range(2, n+1))
#qc.mcz(range(n),n)
qc.x(range(2,n+1))
if m_left%2 == 1: qc.x(0)
for i in range(n-1):
qc.rz(2 * pi * 2**(k_left*i - n + 1), i+2)
if m_left%2 == 1:
qc.x(range(2,n+1))
qc.mcx(list(range(2,n+1)),0)
qc.x(range(2,n+1))
return qc
''' |
QPC005_B2 | A1C722FECC72D | 8 | RE | 1679 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
from math import pi
from qiskit.circuit.library import ZGate
def solve(n: int, m_left: int, k_left: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
qc.x(range(2,n+1))
if m_left%2 == 1 and k_left%2 == 1:
qc.append(ZGate().control(n), range(n+1))
elif m_left%2 == 1 and k_left%2 == 0:
qc.append(ZGate().control(n-1), [0] + list(range(2,n+1)))
elif m_left%2 == 0 and k_left%2 == 1:
qc.append(ZGate().control(n-1), range(1, n+1))
else:
qc.append(ZGate().control(n-2), range(2, n+1))
#qc.mcz(range(n),n)
qc.x(range(2,n+1))
if m_left%2 == 1: qc.x(0)
for i in range(n-1):
qc.rz(2 * pi * 2**(k_left*i - n + 1), i+2)
#if m_left%2 == 1:
# qc.x(range(2,n+1))
# qc.mcx(list(range(2,n+1)),0)
# qc.x(range(2,n+1))
return qc
''' |
QPC005_B2 | A1C722FECC72D | 9 | WA | 1704 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
from math import pi
from qiskit.circuit.library import ZGate
def solve(n: int, m_left: int, k_left: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
ctrl = [2+s for s in range(n-1)]
# c に比例する位相回転 ( R^{ck_l} )
for s in range(n-1):
qc.cp(pi*2 * 2**(s-n+1) * k_left, 2+s, 0)
# X^{m_l}
if m_left % 2 == 1:
qc.x(0)
# c=0 に対して x をキャンセル
qc.x(ctrl)
qc.mcx(ctrl, 0)
qc.x(ctrl)
# c=0 に対して，|a>|b> -> (-1)^{a m_l + b k_l} |a>|b>
qc.x(ctrl)
if m_left % 2 == 1:
qc.mcrz(pi, ctrl, 0)
if k_left % 2 == 1:
qc.mcrz(pi, ctrl, 1)
qc.x(ctrl)
return qc
''' |
QPC005_B2 | A1C722FECC72D | 10 | WA | 1835 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
from math import pi
from qiskit.circuit.library import ZGate
def solve(n: int, m_left: int, k_left: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
ctrl = [2+s for s in range(n-1)]
# c=0 に対して，|a>|b> -> (-1)^{a m_l + b k_l} |a>|b>
qc.x(ctrl)
if m_left % 2 == 1:
qc.mcrz(pi, ctrl, 0)
if k_left % 2 == 1:
qc.mcrz(pi, ctrl, 1)
qc.x(ctrl)
# c に比例する位相回転 ( R^{ck_l} )
for s in range(n-1):
qc.cp(pi*2 * 2**(s-n+1) * k_left, 2+s, 0)
# X^{m_l}
if m_left % 2 == 1:
qc.x(0)
# c=0 に対して x をキャンセル
#qc.x(ctrl)
#qc.mcx(ctrl, 0)
#qc.x(ctrl)
return qc
''' |
QPC005_B2 | A1C722FECC72D | 11 | WA | 1884 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
from math import pi
from qiskit.circuit.library import ZGate
def solve(n: int, m_left: int, k_left: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
ctrl = [2+s for s in range(n-1)]
# c=0 に対して，|a>|b> -> (-1)^{a m_l + b k_l} |a>|b>
qc.x(ctrl)
if m_left % 2 == 1:
# qc.mcrz(pi, ctrl, 0)
qc.compose(ZGate().control(n-1), ctrl+[0], inplace=True)
if k_left % 2 == 1:
#qc.mcrz(pi, ctrl, 1)
qc.compose(ZGate().control(n-1), ctrl+[1], inplace=True)
qc.x(ctrl)
# c に比例する位相回転 ( R^{ck_l} )
for s in range(n-1):
qc.cp(pi*2 * 2**(s-n+1) * k_left, 2+s, 0)
# X^{m_l}
if m_left % 2 == 1:
qc.x(0)
# c=0 に対して x をキャンセル
#qc.x(ctrl)
#qc.mcx(ctrl, 0)
#qc.x(ctrl)
return qc
''' |
QPC005_B2 | A1C722FECC72D | 12 | WA | 1499 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
from math import pi
from qiskit.circuit.library import ZGate
def solve(n: int, m_left: int, k_left: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
ctrl = [2+s for s in range(n-1)]
# c=0 に対して，|a>|b> -> (-1)^{a m_l + b k_l} |a>|b>
qc.x(ctrl)
if m_left % 2 == 1:
# qc.mcrz(pi, ctrl, 0)
qc.compose(ZGate().control(n-1), ctrl+[0], inplace=True)
if k_left % 2 == 1:
#qc.mcrz(pi, ctrl, 1)
qc.compose(ZGate().control(n-1), ctrl+[1], inplace=True)
qc.x(ctrl)
# c に比例する位相回転 ( R^{ck_l} )
for s in range(n-1):
qc.cp(pi*2 * 2**(s-n+1) * k_left, 2+s, 0)
# X^{m_l}
if m_left % 2 == 1:
qc.x(0)
# c=0 に対して x をキャンセル
qc.x(ctrl)
qc.mcx(ctrl, 0)
qc.x(ctrl)
return qc
''' |
QPC005_B2 | A1C722FECC72D | 13 | RE | 1537 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
from math import pi
from qiskit.circuit.library import ZGate
def solve(n: int, m_left: int, k_left: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
ctrl = [2+s for s in range(n-1)]
# c=0 に対して，|a>|b> -> (-1)^{a m_l + b k_l} |a>|b>
qc.x(ctrl)
if m_left % 2 == 1:
# qc.mcrz(pi, ctrl, 0)
qc.compose(ZGate().control(n-1), ctrl+[0], inplace=True)
if k_left % 2 == 1:
#qc.mcrz(pi, ctrl, 1)
qc.compose(ZGate().control(n-1), ctrl+[1], inplace=True)
qc.x(ctrl)
# c に比例する位相回転 ( R^{ck_l} )
for s in range(n-1):
#qc.cp(pi*2 * 2**(s-n+1) * k_left, 2+s, 0)
qc.rz(pi*2 * 2**(s-n+1) * k_left, 2+s, 0)
# X^{m_l}
if m_left % 2 == 1:
qc.x(0)
# c=0 に対して x をキャンセル
qc.x(ctrl)
qc.mcx(ctrl, 0)
qc.x(ctrl)
return qc
''' |
QPC005_B2 | A1C722FECC72D | 14 | AC | 2153 ms | 145 MiB | '''python
from qiskit import QuantumCircuit
from math import pi
from qiskit.circuit.library import ZGate
def solve(n: int, m_left: int, k_left: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
ctrl = [2+s for s in range(n-1)]
# c=0 に対して，|a>|b> -> (-1)^{a m_l + b k_l} |a>|b>
qc.x(ctrl)
if m_left % 2 == 1:
# qc.mcrz(pi, ctrl, 0)
qc.compose(ZGate().control(n-1), ctrl+[0], inplace=True)
if k_left % 2 == 1:
#qc.mcrz(pi, ctrl, 1)
qc.compose(ZGate().control(n-1), ctrl+[1], inplace=True)
qc.x(ctrl)
# c に比例する位相回転 ( R^{ck_l} )
for s in range(n-1):
#qc.cp(pi*2 * 2**(s-n+1) * k_left, 2+s, 0)
qc.crz(pi*2 * 2**(s-n+1) * k_left, 2+s, 0)
# X^{m_l}
if m_left % 2 == 1:
qc.x(0)
# c=0 に対して x をキャンセル
qc.x(ctrl)
qc.mcx(ctrl, 0)
qc.x(ctrl)
return qc
''' |
QPC005_B2 | A4810BF2F49EE | 1 | WA | 1811 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
import math
def solve(n: int, m_left: int, k_left: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
if m_left == 1:
z0 = ZGate().control(n - 1, ctrl_state=0)
qc.append(z0, list(range(2, n + 1)) + [0])
if k_left % 2 == 1:
z1 = ZGate().control(n - 1, ctrl_state=0)
qc.append(z1, list(range(2, n + 1)) + [1])
for i in range(n - 1):
theta = 2 * math.pi / (2.0 ** (n - 1 - i)) * k_left
qc.p(theta, 2 + i)
if m_left == 1:
qc.x(0)
return qc
''' |
QPC005_B2 | A4810BF2F49EE | 2 | WA | 1852 ms | 143 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import XGate, ZGate
import math
def solve(n: int, m_left: int, k_left: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
if m_left == 1:
z0 = ZGate().control(n - 1, ctrl_state=0)
qc.append(z0, list(range(2, n + 1)) + [0])
if k_left % 2 == 1:
z1 = ZGate().control(n - 1, ctrl_state=0)
qc.append(z1, list(range(2, n + 1)) + [1])
for i in range(n - 1):
theta = 2 * math.pi / (2.0 ** (n - 1 - i)) * k_left
qc.crz(theta, 2 + i, 0)
x0h = XGate().control(n - 1, ctrl_state=0)
qc.append(x0h, list(range(2, n + 1)) + [0])
qc.x(0)
return qc
def main():
print(solve(4, 1, 1))
# print(solve(4, 2))
if __name__ == "__main__":
main()
''' |
QPC005_B2 | A4810BF2F49EE | 3 | WA | 1566 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import XGate, ZGate
import math
def solve(n: int, m_left: int, k_left: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
if m_left == 1:
z0 = ZGate().control(n - 1, ctrl_state=0)
qc.append(z0, list(range(2, n + 1)) + [0])
if k_left % 2 == 1:
z1 = ZGate().control(n - 1, ctrl_state=0)
qc.append(z1, list(range(2, n + 1)) + [1])
for i in range(n - 1):
theta = 2 * math.pi / (2.0 ** (n - 1 - i)) * k_left
qc.crz(theta, 2 + i, 0, ctrl_state=0)
x0h = XGate().control(n - 1, ctrl_state=0)
qc.append(x0h, list(range(2, n + 1)) + [0])
qc.x(0)
return qc
def main():
print(solve(4, 1, 1))
# print(solve(4, 2))
if __name__ == "__main__":
main()
''' |
QPC005_B2 | A4810BF2F49EE | 4 | WA | 2160 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import XGate, ZGate
import math
def solve(n: int, m_left: int, k_left: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
if m_left == 1:
z0 = ZGate().control(n - 1, ctrl_state=0)
qc.append(z0, list(range(2, n + 1)) + [0])
if k_left % 2 == 1:
z1 = ZGate().control(n - 1, ctrl_state=0)
qc.append(z1, list(range(2, n + 1)) + [1])
qc.x(range(2, n + 1))
for i in range(n - 1):
theta = 2 * math.pi / (2.0 ** (n - 1 - i)) * k_left
qc.crz(theta, 2 + i, 0)
x0h = XGate().control(n - 1, ctrl_state=0)
qc.append(x0h, list(range(2, n + 1)) + [0])
qc.x(0)
return qc
def main():
print(solve(4, 1, 1))
# print(solve(4, 2))
if __name__ == "__main__":
main()
''' |
QPC005_B2 | A4810BF2F49EE | 5 | AC | 2047 ms | 145 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import XGate, ZGate
import math
def solve(n: int, m_left: int, k_left: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
if m_left == 1:
z0 = ZGate().control(n - 1, ctrl_state=0)
qc.append(z0, list(range(2, n + 1)) + [0])
if k_left % 2 == 1:
z1 = ZGate().control(n - 1, ctrl_state=0)
qc.append(z1, list(range(2, n + 1)) + [1])
for i in range(n - 1):
theta = 2 * math.pi / (2.0 ** (n - 1 - i)) * k_left
qc.crz(theta, control_qubit=2 + i, target_qubit=0)
if m_left == 1:
x0h = XGate().control(n - 1, ctrl_state=0)
qc.append(x0h, list(range(2, n + 1)) + [0])
qc.x(0)
return qc
def main():
print(solve(4, 1, 1))
# print(solve(4, 2))
if __name__ == "__main__":
main()
''' |
QPC005_B2 | A59B8A5A9E621 | 1 | RE | 1410 ms | 141 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import HGate, ZGate, XGate, PhaseGate
from qiskit import QuantumRegister
import math
def QFT(qc : QuantumCircuit, idx : list[int], inversed : bool = False) -> QuantumCircuit:
n = len(idx)
for i in range(n // 2):
qc.swap(idx[i], idx[n - i - 1])
for j in range(n):
qc.h(idx[j])
for k in range(j+1, n):
theta = math.pi / (2 ** (k - j))
if (inversed):
theta *= -1
qc.cp(theta, idx[k], idx[j])
#for i in range(n // 2):
# qc.swap(idx[i], idx[n - i - 1])
return qc
def solve(n: int, m_left: int, k_left: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
k_bits = list()
for i in range(n):
k_bits.append(k_left % 2)
k_left >>= 1
if (m_left == 1):
qc.x(0)
for i in range(1, n + 1):
qc.h(i)
for i in range(1, n + 1):
theta = 2 * math.pi * k_bits(i - 1) * (2 ** (i - 1)) / 2 ** n
qc.cp(-theta, 0, i)
qc.x(0)
for i in range(1, n + 1):
theta = 2 * math.pi * k_bits(i - 1) * (2 ** (i - 1)) / 2 ** n
qc.cp(theta, 0, i)
qc.x(0)
return qc
''' |
QPC005_B2 | A59B8A5A9E621 | 2 | RE | 1599 ms | 141 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import HGate, ZGate, XGate, PhaseGate
from qiskit import QuantumRegister
import math
def QFT(qc : QuantumCircuit, idx : list[int], inversed : bool = False) -> QuantumCircuit:
n = len(idx)
for i in range(n // 2):
qc.swap(idx[i], idx[n - i - 1])
for j in range(n):
qc.h(idx[j])
for k in range(j+1, n):
theta = math.pi / (2 ** (k - j))
if (inversed):
theta *= -1
qc.cp(theta, idx[k], idx[j])
#for i in range(n // 2):
# qc.swap(idx[i], idx[n - i - 1])
return qc
def solve(n: int, m_left: int, k_left: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
k_bits = list()
for i in range(n):
k_bits.append(k_left % 2)
k_left = k_left // 2
if (m_left == 1):
qc.x(0)
for i in range(1, n + 1):
qc.h(i)
for i in range(1, n + 1):
theta = 2 * math.pi * k_bits(i - 1) * (2 ** (i - 1)) / 2 ** n
qc.cp(-theta, 0, i)
qc.x(0)
for i in range(1, n + 1):
theta = 2 * math.pi * k_bits(i - 1) * (2 ** (i - 1)) / 2 ** n
qc.cp(theta, 0, i)
qc.x(0)
QFT(qc, list(range(1, n + 1)), inversed=True)
return qc
''' |
QPC005_B2 | A59B8A5A9E621 | 3 | RE | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import HGate, ZGate, XGate, PhaseGate
from qiskit import QuantumRegister
import math
def QFT(qc : QuantumCircuit, idx : list[int], inversed : bool = False) -> QuantumCircuit:
n = len(idx)
for i in range(n // 2):
qc.swap(idx[i], idx[n - i - 1])
for j in range(n):
qc.h(idx[j])
for k in range(j+1, n):
theta = math.pi / (2 ** (k - j))
if (inversed):
theta *= -1
qc.cp(theta, idx[k], idx[j])
#for i in range(n // 2):
# qc.swap(idx[i], idx[n - i - 1])
return qc
def solve(n: int, m_left: int, k_left: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
k_bits = list()
for i in range(n):
k_bits.append(k_left % 2)
k_left = k_left //
if (m_left == 1):
qc.x(0)
for i in range(1, n + 1):
qc.h(i)
for i in range(1, n + 1):
theta = 2 * math.pi * k_bits[i - 1] * (2 ** (i - 1)) / 2 ** n
qc.cp(-theta, 0, i)
qc.x(0)
for i in range(1, n + 1):
theta = 2 * math.pi * k_bits[i - 1] * (2 ** (i - 1)) / 2 ** n
qc.cp(theta, 0, i)
qc.x(0)
QFT(qc, list(range(1, n + 1)), inversed=True)
return qc
''' | ||
QPC005_B2 | A59B8A5A9E621 | 4 | RE | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import HGate, ZGate, XGate, PhaseGate
from qiskit import QuantumRegister
import math
def QFT(qc : QuantumCircuit, idx : list[int], inversed : bool = False) -> QuantumCircuit:
n = len(idx)
for i in range(n // 2):
qc.swap(idx[i], idx[n - i - 1])
for j in range(n):
qc.h(idx[j])
for k in range(j+1, n):
theta = math.pi / (2 ** (k - j))
if (inversed):
theta *= -1
qc.cp(theta, idx[k], idx[j])
#for i in range(n // 2):
# qc.swap(idx[i], idx[n - i - 1])
return qc
def solve(n: int, m_left: int, k_left: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
k_bits = list()
for i in range(n):
k_bits.append(k_left % 2)
k_left = k_left //
if (m_left == 1):
qc.x(0)
for i in range(1, n + 1):
qc.h(i)
for i in range(1, n + 1):
theta = 2 * math.pi * k_bits[i - 1] * (2 ** (i - 1)) / 2 ** n
qc.cp(-theta, 0, i)
qc.x(0)
for i in range(1, n + 1):
theta = 2 * math.pi * k_bits[i - 1] * (2 ** (i - 1)) / 2 ** n
qc.cp(theta, 0, i)
qc.x(0)
QFT(qc, list(range(1, n + 1)), inversed=True)
return qc
''' | ||
QPC005_B2 | A59B8A5A9E621 | 5 | WA | 1781 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import HGate, ZGate, XGate, PhaseGate
from qiskit import QuantumRegister
import math
def QFT(qc : QuantumCircuit, idx : list[int], inversed : bool = False) -> QuantumCircuit:
n = len(idx)
for i in range(n // 2):
qc.swap(idx[i], idx[n - i - 1])
for j in range(n):
qc.h(idx[j])
for k in range(j+1, n):
theta = math.pi / (2 ** (k - j))
if (inversed):
theta *= -1
qc.cp(theta, idx[k], idx[j])
#for i in range(n // 2):
# qc.swap(idx[i], idx[n - i - 1])
return qc
def solve(n: int, m_left: int, k_left: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
k_bits = list()
for i in range(n):
k_bits.append(k_left % 2)
k_left = k_left // 2
if (m_left == 1):
qc.x(0)
for i in range(1, n + 1):
qc.h(i)
for i in range(1, n + 1):
theta = 2 * math.pi * k_bits[i - 1] * (2 ** (i - 1)) / 2 ** n
qc.cp(-theta, 0, i)
qc.x(0)
for i in range(1, n + 1):
theta = 2 * math.pi * k_bits[i - 1] * (2 ** (i - 1)) / 2 ** n
qc.cp(theta, 0, i)
qc.x(0)
QFT(qc, list(range(1, n + 1)), inversed=True)
return qc
''' |
QPC005_B2 | A59B8A5A9E621 | 6 | RE | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import HGate, ZGate, XGate, PhaseGate
from qiskit import QuantumRegister
import math
def QFT(qc : QuantumCircuit, idx : list[int], inversed : bool = False) -> QuantumCircuit:
n = len(idx)
for i in range(n // 2):
qc.swap(idx[i], idx[n - i - 1])
for j in range(n):
qc.h(idx[j])
for k in range(j+1, n):
theta = math.pi / (2 ** (k - j))
if (inversed):
theta *= -1
qc.cp(theta, idx[k], idx[j])
#for i in range(n // 2):
# qc.swap(idx[i], idx[n - i - 1])
return qc
def solve(n: int, m_left: int, k_left: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
k_bits = list()
for i in range(n):
k_bits.append(k_left % 2)
k_left = k_left //
for i in range(1, n + 1):
qc.h(i)
for i in range(1, n + 1):
theta = 2 * math.pi * k_bits[i - 1] * (2 ** (i - 1)) / 2 ** n
qc.p(theta, 0, i)
for i in range(1, n + 1):
theta = -4 * math.pi * k_bits[i - 1] * (2 ** (i - 1)) / 2 ** n
qc.cp(theta, 0, i)
if (m_left == 1):
qc.x(0)
QFT(qc, list(range(1, n + 1)), inversed=True)
return qc
''' | ||
QPC005_B2 | A59B8A5A9E621 | 7 | WA | 1590 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import HGate, ZGate, XGate, PhaseGate
from qiskit import QuantumRegister
import math
def QFT(qc : QuantumCircuit, idx : list[int], inversed : bool = False) -> QuantumCircuit:
n = len(idx)
for i in range(n // 2):
qc.swap(idx[i], idx[n - i - 1])
for j in range(n):
qc.h(idx[j])
for k in range(j+1, n):
theta = math.pi / (2 ** (k - j))
if (inversed):
theta *= -1
qc.cp(theta, idx[k], idx[j])
#for i in range(n // 2):
# qc.swap(idx[i], idx[n - i - 1])
return qc
def solve(n: int, m_left: int, k_left: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
k_bits = list()
for i in range(n):
k_bits.append(k_left % 2)
k_left = k_left // 2
for i in range(1, n + 1):
qc.h(i)
for i in range(1, n + 1):
theta = 2 * math.pi * k_bits[i - 1] * (2 ** (i - 1)) / 2 ** n
qc.p(theta, i)
for i in range(1, n + 1):
theta = -4 * math.pi * k_bits[i - 1] * (2 ** (i - 1)) / 2 ** n
qc.cp(theta, 0, i)
if (m_left == 1):
qc.x(0)
QFT(qc, list(range(1, n + 1)), inversed=True)
return qc
''' |
QPC005_B2 | A59B8A5A9E621 | 8 | WA | 1612 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import HGate, ZGate, XGate, PhaseGate
from qiskit import QuantumRegister
import math
def QFT(qc : QuantumCircuit, idx : list[int], inversed : bool = False) -> QuantumCircuit:
n = len(idx)
for i in range(n // 2):
qc.swap(idx[i], idx[n - i - 1])
for j in range(n):
qc.h(idx[j])
for k in range(j+1, n):
theta = math.pi / (2 ** (k - j))
if (inversed):
theta *= -1
qc.cp(theta, idx[k], idx[j])
#for i in range(n // 2):
# qc.swap(idx[i], idx[n - i - 1])
return qc
def solve(n: int, m_left: int, k_left: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
for i in range(1, n + 1):
qc.h(i)
for i in range(1, n + 1):
theta = 2 * math.pi * k_left * (2 ** (i - 1)) / 2 ** n
qc.p(theta, i)
for i in range(1, n + 1):
theta = -4 * math.pi * k_left * (2 ** (i - 1)) / 2 ** n
qc.cp(theta, 0, i)
if (m_left == 1):
qc.x(0)
QFT(qc, list(range(1, n + 1)), inversed=True)
return qc
''' |
QPC005_B2 | A59B8A5A9E621 | 9 | WA | 1970 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import HGate, ZGate, XGate, PhaseGate
from qiskit import QuantumRegister
import math
def QFT(qc : QuantumCircuit, idx : list[int], inversed : bool = False) -> QuantumCircuit:
n = len(idx)
for i in range(n // 2):
qc.swap(idx[i], idx[n - i - 1])
for j in range(n):
qc.h(idx[j])
for k in range(j+1, n):
theta = math.pi / (2 ** (k - j))
if (inversed):
theta *= -1
qc.cp(theta, idx[k], idx[j])
#for i in range(n // 2):
# qc.swap(idx[i], idx[n - i - 1])
return qc
def solve(n: int, m_left: int, k_left: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
QFT(qc, list(range(1, n + 1)))
for i in range(1, n + 1):
theta = 2 * math.pi * k_left * (2 ** (i - 1)) / 2 ** n
qc.p(theta, i)
for i in range(1, n + 1):
theta = -4 * math.pi * k_left * (2 ** (i - 1)) / 2 ** n
qc.cp(theta, 0, i)
if (m_left == 1):
qc.x(0)
QFT(qc, list(range(1, n + 1)), inversed=True)
return qc
''' |
QPC005_B2 | A59B8A5A9E621 | 10 | WA | 1581 ms | 143 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import HGate, ZGate, XGate, PhaseGate
from qiskit import QuantumRegister
import math
def QFT(qc : QuantumCircuit, idx : list[int], inversed : bool = False) -> QuantumCircuit:
n = len(idx)
for i in range(n // 2):
qc.swap(idx[i], idx[n - i - 1])
for j in range(n):
qc.h(idx[j])
for k in range(j+1, n):
theta = math.pi / (2 ** (k - j))
if (inversed):
theta *= -1
qc.cp(theta, idx[k], idx[j])
#for i in range(n // 2):
# qc.swap(idx[i], idx[n - i - 1])
return qc
def solve(n: int, m_left: int, k_left: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
QFT(qc, list(range(1, n + 1)))
for i in range(1, n + 1):
theta = 2 * math.pi * k_left * (2 ** (i - 1)) / 2 ** n
qc.p(theta, i)
for i in range(1, n + 1):
theta = -4 * math.pi * k_left * (2 ** (i - 1)) / 2 ** n
qc.cp(theta, 0, i)
QFT(qc, list(range(1, n + 1)), inversed=True)
if (m_left == 1):
qc.x(0)
return qc
''' |
QPC005_B2 | A59B8A5A9E621 | 11 | WA | 1857 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import HGate, ZGate, XGate, PhaseGate
from qiskit import QuantumRegister
import math
def QFT(qc : QuantumCircuit, idx : list[int], inversed : bool = False) -> QuantumCircuit:
n = len(idx)
for i in range(n // 2):
qc.swap(idx[i], idx[n - i - 1])
for j in range(n):
qc.h(idx[j])
for k in range(j+1, n):
theta = math.pi / (2 ** (k - j))
if (inversed):
theta *= -1
qc.cp(theta, idx[k], idx[j])
#for i in range(n // 2):
# qc.swap(idx[i], idx[n - i - 1])
return qc
def solve(n: int, m_left: int, k_left: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
qc.rz(2 * math.pi * k_left / (2 **(n - 1)), 0)
if (m_left == 1):
qc.x(0)
return qc
''' |
QPC005_B2 | A59B8A5A9E621 | 12 | WA | 1682 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import HGate, ZGate, XGate, PhaseGate
from qiskit import QuantumRegister
import math
def QFT(qc : QuantumCircuit, idx : list[int], inversed : bool = False) -> QuantumCircuit:
n = len(idx)
for i in range(n // 2):
qc.swap(idx[i], idx[n - i - 1])
for j in range(n):
qc.h(idx[j])
for k in range(j+1, n):
theta = math.pi / (2 ** (k - j))
if (inversed):
theta *= -1
qc.cp(theta, idx[k], idx[j])
#for i in range(n // 2):
# qc.swap(idx[i], idx[n - i - 1])
return qc
def solve(n: int, m_left: int, k_left: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
qc.rz(2 * math.pi * k_left / (2 **(n)), 0)
if (m_left == 1):
qc.x(0)
return qc
''' |
QPC005_B2 | A59B8A5A9E621 | 13 | WA | 1582 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import HGate, ZGate, XGate, PhaseGate
from qiskit import QuantumRegister
import math
def QFT(qc : QuantumCircuit, idx : list[int], inversed : bool = False) -> QuantumCircuit:
n = len(idx)
for i in range(n // 2):
qc.swap(idx[i], idx[n - i - 1])
for j in range(n):
qc.h(idx[j])
for k in range(j+1, n):
theta = math.pi / (2 ** (k - j))
if (inversed):
theta *= -1
qc.cp(theta, idx[k], idx[j])
#for i in range(n // 2):
# qc.swap(idx[i], idx[n - i - 1])
return qc
def solve(n: int, m_left: int, k_left: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
qc.rz(2 * math.pi * k_left / (2 **(n - 1)), 0)
if (m_left == 1):
qc.z(0)
return qc
''' |
QPC005_B2 | A59B8A5A9E621 | 14 | RE | 1710 ms | 141 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import HGate, ZGate, XGate, PhaseGate
from qiskit import QuantumRegister
import math
def QFT(qc : QuantumCircuit, idx : list[int], inversed : bool = False) -> QuantumCircuit:
n = len(idx)
for i in range(n // 2):
qc.swap(idx[i], idx[n - i - 1])
for j in range(n):
qc.h(idx[j])
for k in range(j+1, n):
theta = math.pi / (2 ** (k - j))
if (inversed):
theta *= -1
qc.cp(theta, idx[k], idx[j])
#for i in range(n // 2):
# qc.swap(idx[i], idx[n - i - 1])
return qc
def solve(n: int, m_left: int, k_left: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
for i in range(2, n + 1):
qc.x(i)
qc.mcp(math.pi * m_left, list(range(2, n + 1)), 0)
qc.mcp(math.pi * k_left, list(range(2, n + 1)), 1)
qc.mcrz(-2 * math.pi * k_left / (2 ** (n - 1)), list(range(2, n + 1)), 0)
qc.rz(2 * math.pi * k_left / (2 **(n - 1)), 0)
if (m_left == 1):
qc.mcz(list(range(2, n+1)), 0)
qc.z(0)
return qc
''' |
QPC005_B2 | A59B8A5A9E621 | 15 | WA | 1587 ms | 143 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import HGate, ZGate, XGate, PhaseGate
from qiskit import QuantumRegister
import math
def QFT(qc : QuantumCircuit, idx : list[int], inversed : bool = False) -> QuantumCircuit:
n = len(idx)
for i in range(n // 2):
qc.swap(idx[i], idx[n - i - 1])
for j in range(n):
qc.h(idx[j])
for k in range(j+1, n):
theta = math.pi / (2 ** (k - j))
if (inversed):
theta *= -1
qc.cp(theta, idx[k], idx[j])
#for i in range(n // 2):
# qc.swap(idx[i], idx[n - i - 1])
return qc
def solve(n: int, m_left: int, k_left: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
for i in range(2, n + 1):
qc.x(i)
qc.mcp(math.pi * m_left, list(range(2, n + 1)), 0)
qc.mcp(math.pi * k_left, list(range(2, n + 1)), 1)
qc.mcrz(-2 * math.pi * k_left / (2 ** (n - 1)), list(range(2, n + 1)), 0)
qc.rz(2 * math.pi * k_left / (2 **(n - 1)), 0)
if (m_left == 1):
qc.mcp(math.pi, list(range(2, n+1)), 0)
for i in range(2, n + 1):
qc.x(i)
return qc
''' |
QPC005_B2 | A59B8A5A9E621 | 16 | WA | 1640 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import HGate, ZGate, XGate, PhaseGate
from qiskit import QuantumRegister
import math
def QFT(qc : QuantumCircuit, idx : list[int], inversed : bool = False) -> QuantumCircuit:
n = len(idx)
for i in range(n // 2):
qc.swap(idx[i], idx[n - i - 1])
for j in range(n):
qc.h(idx[j])
for k in range(j+1, n):
theta = math.pi / (2 ** (k - j))
if (inversed):
theta *= -1
qc.cp(theta, idx[k], idx[j])
#for i in range(n // 2):
# qc.swap(idx[i], idx[n - i - 1])
return qc
def solve(n: int, m_left: int, k_left: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
for i in range(2, n + 1):
qc.x(i)
qc.mcp(math.pi * m_left, list(range(2, n + 1)), 0)
qc.mcp(math.pi * k_left, list(range(2, n + 1)), 1)
qc.mcrz(-2 * math.pi * k_left / (2 ** (n - 1)), list(range(2, n + 1)), 0)
qc.rz(2 * math.pi * k_left / (2 **(n - 1)), 0)
if (m_left == 1):
qc.mcp(2 * math.pi,list(range(2, n+1)), 0)
for i in range(2, n + 1):
qc.x(i)
return qc
''' |
QPC005_B2 | A59B8A5A9E621 | 17 | WA | 1752 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import HGate, ZGate, XGate, PhaseGate
from qiskit import QuantumRegister
import math
def QFT(qc : QuantumCircuit, idx : list[int], inversed : bool = False) -> QuantumCircuit:
n = len(idx)
for i in range(n // 2):
qc.swap(idx[i], idx[n - i - 1])
for j in range(n):
qc.h(idx[j])
for k in range(j+1, n):
theta = math.pi / (2 ** (k - j))
if (inversed):
theta *= -1
qc.cp(theta, idx[k], idx[j])
#for i in range(n // 2):
# qc.swap(idx[i], idx[n - i - 1])
return qc
def solve(n: int, m_left: int, k_left: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
for i in range(2, n + 1):
qc.x(i)
qc.mcp(math.pi * m_left, list(range(2, n + 1)), 0)
qc.mcp(math.pi * k_left, list(range(2, n + 1)), 1)
qc.mcrz(-2 * math.pi * k_left / (2 ** (n - 1)), list(range(2, n + 1)), 0)
qc.rz(2 * math.pi * k_left / (2 **(n - 1)), 0)
if (m_left == 1):
qc.z(0)
qc.mcp(2 * math.pi,list(range(2, n+1)), 0)
for i in range(2, n + 1):
qc.x(i)
return qc
''' |
QPC005_B2 | A5E2D9864291A | 1 | WA | 1455 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library.standard_gates import XGate, RZGate
from math import pi
def solve(n: int, m_left: int, k_left: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
qc.x(range(2, n + 1))
S = [k_left * (2 ** i) for i in range(n)]
for i in range(n):
theta = 2 * pi * S[i] / 2**n
qc.p(theta, i)
if m_left == 1:
qc.x(0)
if m_left == 1:
qc.append(XGate().control(n - 1), list(range(2, n + 1)) + [0])
qc.x(range(2, n + 1))
return qc
''' |
QPC005_B2 | A5E2D9864291A | 2 | WA | 1695 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library.standard_gates import XGate, RZGate
from math import pi
def solve(n: int, m_left: int, k_left: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
qc.x(range(2, n + 1))
S = [k_left * (2 ** i) for i in range(n - 1)]
for i in range(n - 1):
theta = 2 * pi * S[i] / 2**n
qc.cp(theta, i + 2, 0)
if m_left == 1:
qc.x(0)
if m_left == 1:
qc.append(XGate().control(n - 1), list(range(2, n + 1)) + [0])
qc.x(range(2, n + 1))
return qc
''' |
QPC005_B2 | A5E2D9864291A | 3 | WA | 1526 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library.standard_gates import XGate, RZGate
from math import pi
def solve(n: int, m_left: int, k_left: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
qc.x(range(2, n + 1))
S = [k_left * (2 ** i) for i in range(n - 1)]
for i in range(n - 1):
theta = 2 * pi * S[i] / 2**n
qc.crz(theta, i + 2, 0)
if m_left == 1:
qc.x(0)
if m_left == 1:
qc.append(XGate().control(n - 1), list(range(2, n + 1)) + [0])
qc.x(range(2, n + 1))
return qc
''' |
QPC005_B2 | A5E2D9864291A | 4 | WA | 1469 ms | 144 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library.standard_gates import XGate, RZGate
from math import pi
def solve(n: int, m_left: int, k_left: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
qc.x(range(2, n + 1))
S = [k_left * (2 ** i) for i in range(n - 1)]
for i in range(n - 1):
theta = 2 * pi * S[i] / 2**(n - 1)
qc.crz(theta, i + 2, 0)
if m_left == 1:
qc.x(0)
if m_left == 1:
qc.append(XGate().control(n - 1), list(range(2, n + 1)) + [0])
qc.x(range(2, n + 1))
return qc
''' |
QPC005_B2 | A5E2D9864291A | 5 | WA | 1628 ms | 145 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library.standard_gates import XGate, RZGate
from math import pi
def solve(n: int, m_left: int, k_left: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
S = [k_left * (2 ** i) for i in range(n - 1)]
for i in range(n - 1):
theta = 2 * pi * S[i] / 2**(n - 1)
qc.crz(theta, i + 2, 0)
qc.x(range(2, n + 1))
if m_left == 1:
qc.x(0)
if m_left == 1:
qc.append(XGate().control(n - 1), list(range(2, n + 1)) + [0])
qc.x(range(2, n + 1))
return qc
''' |
QPC005_B2 | A5E2D9864291A | 6 | WA | 1621 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library.standard_gates import XGate, ZGate
from math import pi
def solve(n: int, m_left: int, k_left: int) -> QuantumCircuit:
qc = QuantumCircuit(n + 1)
# Write your code here:
qc.x(range(2, n + 1))
if m_left == 1:
qc.append(ZGate().control(n - 1), list(range(2, n + 1)) + [0])
if k_left%2 == 1:
qc.append(ZGate().control(n - 1), list(range(2, n + 1)) + [1])
S = [k_left * (2 ** i) for i in range(n - 1)]
for i in range(n - 1):
theta = 2 * pi * S[i] / 2**(n - 1)
qc.crz(theta, i + 2, 0)
if m_left == 1:
qc.x(0)
if m_left == 1:
qc.append(XGate().control(n - 1), list(range(2, n + 1)) + [0])
qc.x(range(2, n + 1))
return qc
''' |
QPC005_B2 | A604BC7EFCD4D | 1 | WA | 1476 ms | 143 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import numpy as np
from qiskit.circuit.library.standard_gates import HGate, XGate, XXPlusYYGate, RZZGate
def solve(n: int, m_left: int, k_left: int) -> QuantumCircuit:
a, b, c, anc = (
QuantumRegister(1),
QuantumRegister(1),
QuantumRegister(n - 1),
QuantumRegister(1),
)
qc = QuantumCircuit(a, b, c, anc)
zangle = 2 * np.pi / 2 ** (n - 1)
qc.x(anc)
qc.mcx(c, anc)
if m_left == 0:
for i in range(n - 1):
qc.mcrz(zangle * (2**i), anc, c[i])
qc.mcx(c, anc)
qc.x(anc)
return qc
''' |
QPC005_B2 | A604BC7EFCD4D | 2 | WA | 1626 ms | 142 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import numpy as np
from qiskit.circuit.library.standard_gates import HGate, XGate, XXPlusYYGate, RZZGate
def solve(n: int, m_left: int, k_left: int) -> QuantumCircuit:
a, b, c, anc = (
QuantumRegister(1),
QuantumRegister(1),
QuantumRegister(n - 1),
QuantumRegister(1),
)
qc = QuantumCircuit(a, b, c, anc)
zangle = 2 * np.pi / 2 ** (n - 1)
qc.x(anc)
qc.mcx(c, anc)
if m_left == 0:
for i in range(n - 1):
qc.mcrz(zangle * k_left * (2**i), anc, c[i])
qc.mcx(c, anc)
qc.x(anc)
return qc
''' |
QPC005_B2 | A604BC7EFCD4D | 3 | WA | 1679 ms | 142 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import numpy as np
from qiskit.circuit.library.standard_gates import HGate, XGate, XXPlusYYGate, RZZGate
def solve(n: int, m_left: int, k_left: int) -> QuantumCircuit:
a, b, c = (
QuantumRegister(1),
QuantumRegister(1),
QuantumRegister(n - 1),
)
qc = QuantumCircuit(a, b, c)
zangle = 2 * np.pi / (2 ** (n - 1))
if m_left == 0:
for i in range(n - 1):
qc.rz(zangle * k_left * (2**i), c[i])
return qc
''' |
QPC005_B2 | A604BC7EFCD4D | 4 | RE | 1379 ms | 141 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import numpy as np
from qiskit.circuit.library.standard_gates import HGate, XGate, XXPlusYYGate, RZZGate
def solve(n: int, m_left: int, k_left: int) -> QuantumCircuit:
a, b, c, anc = (
QuantumRegister(1),
QuantumRegister(1),
QuantumRegister(n - 1),
QuantumRegister(1),
)
qc = QuantumCircuit(a, b, c)
zangle = 2 * np.pi / (2 ** (n - 1))
qc.x(anc)
qc.mcx(c, anc)
if m_left == 0:
for i in range(n - 1):
qc.crz(zangle * k_left * (2**i), anc, a)
qc.mcx(c, anc)
qc.x(anc)
return qc
''' |
QPC005_B2 | A604BC7EFCD4D | 5 | WA | 1584 ms | 142 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import numpy as np
from qiskit.circuit.library.standard_gates import HGate, XGate, XXPlusYYGate, RZZGate
def solve(n: int, m_left: int, k_left: int) -> QuantumCircuit:
a, b, c, anc = (
QuantumRegister(1),
QuantumRegister(1),
QuantumRegister(n - 1),
QuantumRegister(1),
)
qc = QuantumCircuit(a, b, c, anc)
zangle = 2 * np.pi / (2 ** (n - 1))
qc.x(anc)
qc.mcx(c, anc)
if m_left == 0:
for i in range(n - 1):
qc.crz(zangle * k_left * (2**i), anc, a)
qc.mcx(c, anc)
qc.x(anc)
return qc
''' |
QPC005_B2 | A604BC7EFCD4D | 6 | WA | 1692 ms | 145 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import numpy as np
from qiskit.circuit.library.standard_gates import HGate, XGate, XXPlusYYGate, RZZGate
def solve(n: int, m_left: int, k_left: int) -> QuantumCircuit:
a, b, c = (
QuantumRegister(1),
QuantumRegister(1),
QuantumRegister(n - 1),
)
qc = QuantumCircuit(a, b, c)
zangle = 2 * np.pi / (2 ** (n - 1))
if m_left == 0:
for i in range(n - 1):
qc.crz(zangle * k_left * (2**i), c[i], a)
return qc
''' |
QPC005_B2 | A604BC7EFCD4D | 7 | WA | 1687 ms | 146 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import numpy as np
from qiskit.circuit.library.standard_gates import HGate, XGate, XXPlusYYGate, RZZGate
def solve(n: int, m_left: int, k_left: int) -> QuantumCircuit:
a, b, c, anc = (
QuantumRegister(1),
QuantumRegister(1),
QuantumRegister(n - 1),
QuantumRegister(1),
)
qc = QuantumCircuit(a, b, c, anc)
zangle = 2 * np.pi / (2 ** (n - 1))
qc.x(c)
qc.x(anc)
qc.mcx(c, anc)
qc.x(c)
if m_left == 0:
for i in range(n - 1):
qc.crz(zangle * k_left * (2**i), c[i], a)
else:
for i in range(n - 1):
qc.crz(zangle * k_left * (2**i), c[i], a)
qc.cx(anc, a)
qc.x(c)
qc.mcx(c, anc)
qc.x(anc)
qc.x(c)
return qc
''' |
QPC005_B2 | A604BC7EFCD4D | 8 | WA | 1488 ms | 145 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import numpy as np
from qiskit.circuit.library.standard_gates import ZGate, XGate, XXPlusYYGate, RZZGate
def solve(n: int, m_left: int, k_left: int) -> QuantumCircuit:
a, b, c, anc = (
QuantumRegister(1),
QuantumRegister(1),
QuantumRegister(n - 1),
QuantumRegister(1),
)
qc = QuantumCircuit(a, b, c, anc)
zangle = 2 * np.pi / (2 ** (n - 1))
qc.x(c)
qc.x(anc)
qc.mcx(c, anc)
qc.x(c)
if m_left == 0:
for i in range(n - 1):
qc.crz(zangle * k_left * (2**i), c[i], a)
else:
for i in range(n - 1):
qc.crz(zangle * k_left * (2**i), c[i], a)
qc.cx(anc, a)
qc.x(c)
# 11
if (m_left + k_left) % 2 == 1:
qc.append(ZGate().control(1), [*a, *b])
qc.x(a)
# 01
if (k_left) % 2 == 1:
qc.append(ZGate().control(1), [*a, *b])
qc.x(a)
qc.x(b)
# 10
if (m_left) % 2 == 1:
qc.append(ZGate().control(1), [*a, *b])
qc.x(b)
qc.mcx(c, anc)
qc.x(anc)
qc.x(c)
return qc
''' |
QPC005_B2 | A604BC7EFCD4D | 9 | WA | 1570 ms | 143 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import numpy as np
from qiskit.circuit.library.standard_gates import ZGate, XGate, XXPlusYYGate, RZZGate
def solve(n: int, m_left: int, k_left: int) -> QuantumCircuit:
a, b, c, anc = (
QuantumRegister(1),
QuantumRegister(1),
QuantumRegister(n - 1),
QuantumRegister(1),
)
qc = QuantumCircuit(a, b, c, anc)
zangle = 2 * np.pi / (2 ** (n - 1))
qc.x(c)
qc.x(anc)
qc.mcx(c, anc)
qc.x(c)
if m_left == 0:
for i in range(n - 1):
qc.crz(zangle * k_left * (2**i), c[i], a)
else:
for i in range(n - 1):
qc.crz(zangle * k_left * (2**i), c[i], a)
qc.cx(anc, a)
qc.x(c)
# 11
if (m_left + k_left) % 2 == 1:
qc.append(ZGate().control(2), [*a, *b, *anc])
qc.x(a)
# 01
if (k_left) % 2 == 1:
qc.append(ZGate().control(2), [*a, *b, *anc])
qc.x(a)
qc.x(b)
# 10
if (m_left) % 2 == 1:
qc.append(ZGate().control(2), [*a, *b, *anc])
qc.x(b)
qc.mcx(c, anc)
qc.x(anc)
qc.x(c)
return qc
''' |
QPC005_B2 | A604BC7EFCD4D | 10 | UME | '''python
from qiskit import QuantumCircuit, QuantumRegister
import numpy as np
from qiskit.circuit.library.standard_gates import ZGate, XGate, XXPlusYYGate, RZZGate
def solve(n: int, m_left: int, k_left: int) -> QuantumCircuit:
a, b, c, anc = (
QuantumRegister(1),
QuantumRegister(1),
QuantumRegister(n - 1),
QuantumRegister(1),
)
qc = QuantumCircuit(a, b, c, anc)
zangle = 2 * np.pi / (2 ** (n - 1))
qc.x(c)
qc.x(anc)
qc.mcx(c, anc)
qc.x(c)
if m_left == 0:
for i in range(n - 1):
qc.crz(zangle * k_left * (2**i), c[i], a)
else:
for i in range(n - 1):
qc.crz(zangle * k_left * (2**i), c[i], a)
qc.cx(anc, a)
qc.x(anc)
# 11
if (m_left + k_left) % 2 == 1:
qc.append(ZGate().control(2), [*a, *b, *anc])
qc.x(a)
# 01
if (k_left) % 2 == 1:
qc.append(ZGate().control(2), [*a, *b, *anc])
qc.x(a)
qc.x(b)
# 10
if (m_left) % 2 == 1:
qc.append(ZGate().control(2), [*a, *b, *anc])
qc.x(b)
qc.x(c)
qc.mcx(c, anc)
qc.x(c)
return qc
## test here
import qutils
cv = qutils.CircuitViewer(solve(3, 1, 1))
cv.draw()
# cv.print_mapping()
''' | ||
QPC005_B2 | A604BC7EFCD4D | 11 | AC | 2064 ms | 145 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import numpy as np
from qiskit.circuit.library.standard_gates import ZGate, XGate, XXPlusYYGate, RZZGate
def solve(n: int, m_left: int, k_left: int) -> QuantumCircuit:
a, b, c, anc = (
QuantumRegister(1),
QuantumRegister(1),
QuantumRegister(n - 1),
QuantumRegister(1),
)
qc = QuantumCircuit(a, b, c, anc)
zangle = 2 * np.pi / (2 ** (n - 1))
qc.x(c)
qc.x(anc)
qc.mcx(c, anc)
qc.x(c)
if m_left == 0:
for i in range(n - 1):
qc.crz(zangle * k_left * (2**i), c[i], a)
else:
for i in range(n - 1):
qc.crz(zangle * k_left * (2**i), c[i], a)
qc.cx(anc, a)
qc.x(anc)
# 11
if (m_left + k_left) % 2 == 1:
qc.append(ZGate().control(2), [*a, *b, *anc])
qc.x(a)
# 01
if (k_left) % 2 == 1:
qc.append(ZGate().control(2), [*a, *b, *anc])
qc.x(a)
qc.x(b)
# 10
if (m_left) % 2 == 1:
qc.append(ZGate().control(2), [*a, *b, *anc])
qc.x(b)
qc.x(c)
qc.mcx(c, anc)
qc.x(c)
return qc
''' |
QPC005_B2 | A6E6E157055EB | 1 | RE | 1812 ms | 142 MiB | '''python
import math
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import XGate, ZGate, RZGate
def A3(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Write your code here:
qc.x(m)
qc.x(k)
qc.compose(XGate().control(len(k)),[*k, m[0]], inplace=True)
qc.x(k)
return qc
def solve(n: int, m_left: int, k_left: int) -> QuantumCircuit:
a, b, c = QuantumRegister(1), QuantumRegister(1), QuantumRegister(n - 1)
qc = QuantumCircuit(a, b, c)
# Write your code here:
qc.x(c)
if m_left:
qc.compose(ZGate().control(len(c)),[*c, *a])
if k_left % 2:
qc.compose(ZGate().control(len(c)),[*c, *b])
qc.x(c)
for i in range(n - 1):
qc.compose(RZGate(2 ** (2 - n + i) * math.pi).control(1),[*c, *a])
if m_left:
qc.compose(A3(n - 1) ,[a[0], *c], inplace=True)
return qc
''' |
QPC005_B2 | A6E6E157055EB | 2 | RE | 1606 ms | 140 MiB | '''python
import math
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import XGate, ZGate, RZGate
def A3(n: int) -> QuantumCircuit:
m, k = QuantumRegister(1), QuantumRegister(n)
qc = QuantumCircuit(m, k)
# Write your code here:
qc.x(m)
qc.x(k)
qc.compose(XGate().control(len(k)),[*k, m[0]], inplace=True)
qc.x(k)
return qc
def solve(n: int, m_left: int, k_left: int) -> QuantumCircuit:
a, b, c = QuantumRegister(1), QuantumRegister(1), QuantumRegister(n - 1)
qc = QuantumCircuit(a, b, c)
# Write your code here:
qc.x(c)
if m_left:
qc.compose(ZGate().control(len(c)),[*c, *a])
if k_left % 2:
qc.compose(ZGate().control(len(c)),[*c, *b])
qc.x(c)
for i in range(n - 1):
qc.compose(RZGate(2 ** (2 - n + i) * k_left * math.pi).control(1),[*c, *a])
if m_left:
qc.compose(A3(n - 1), [a[0], *c], inplace=True)
return qc
''' |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.