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 |
|---|---|---|---|---|---|---|
QPC001_B4 | AE3D479569762 | 1 | RE | 1258 ms | 150 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
if(L & (1<<i)):
for j in range(i-1):
if(not (L & (1<<j))):
qc.x(j)
qc.x(i)
if i == 0:
qc.z(0)
else:
qc.append(ZGate().control(i), range(i+1))
for j in range(i-1):
if(not (L & (1<<j))):
qc.x(j)
qc.x(i)
return qc
''' |
QPC001_B4 | AE3D479569762 | 2 | WA | 1284 ms | 152 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
if(L & (1<<i)):
for j in range(i):
if(not (L & (1<<j))):
qc.x(j)
qc.x(i)
if i == 0:
qc.z(0)
else:
qc.append(ZGate().control(i), range(i+1))
for j in range(i):
if(not (L & (1<<j))):
qc.x(j)
qc.x(i)
return qc
''' |
QPC001_B4 | AE3D479569762 | 3 | WA | 2082 ms | 156 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
if(L & (1<<i)):
for j in range(i+1, n):
if(not (L & (1<<j))):
qc.x(j)
qc.x(i)
if i == n-1:
qc.z(0)
else:
qc.append(ZGate().control(n-i-1), range(i,n))
for j in range(i+1, n):
if(not (L & (1<<j))):
qc.x(j)
qc.x(i)
return qc
''' |
QPC001_B4 | AE3D479569762 | 4 | WA | 1317 ms | 152 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
if(L & (1<<i)):
for j in range(i+1, n):
if(not (L & (1<<j))):
qc.x(j)
qc.x(i)
if i == n-1:
qc.z(i)
else:
qc.append(ZGate().control(n-i-1), range(i,n))
for j in range(i+1, ):
if(not (L & (1<<j))):
qc.x(j)
qc.x(i)
return qc
''' |
QPC001_B4 | AE3D479569762 | 5 | AC | 2435 ms | 156 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
if(L & (1<<i)):
for j in range(i+1, n):
if(not (L & (1<<j))):
qc.x(j)
qc.x(i)
if i == n-1:
qc.z(i)
else:
qc.append(ZGate().control(n-i-1), range(i,n))
for j in range(i+1, n):
if(not (L & (1<<j))):
qc.x(j)
qc.x(i)
return qc
''' |
QPC001_B4 | AE752EC31EC58 | 1 | DLE | 1053 ms | 91 MiB | '''python
from qiskit import QuantumCircuit
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
#for i in range(n):
# qc.h(i)
def xmap(m: int, size: int) -> list[int]:
a = []
idx = 0
while m:
if m % 2:
a.append(idx)
idx += 1
m //= 2
return [i for i in range(size) if i not in a]
for i in range(L, 2**n):
a = xmap(i, n)
if a:
qc.x(a)
if n > 1:
qc.h(0); qc.mcx(list(range(1, n)), 0); qc.h(0)
else:
qc.z(0)
if a:
qc.x(a)
return qc
''' |
QPC001_B4 | AE752EC31EC58 | 2 | RE | 993 ms | 92 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.h(i)
def to_bin(m: int, size: int) -> list[int]:
a = [0] * size
idx = 0
while m:
if m % 2:
a[idx] = 1
idx += 1
m //= 2
return a
def xmap(m: int, size: int) -> list[int]:
a = []
idx = 0
while m:
if m % 2:
a.append(idx)
idx += 1
m //= 2
return [i for i in range(size) if i not in a]
def mcz(qc: QuantumCircuit, regs: list[int]) -> None:
if len(regs) == 0:
return
if len(regs) == 1:
qc.z(regs[0])
else:
qc.h(regs[-1])
qc.mcx(regs[:-1], regs[-1])
qc.h(regs[-1])
def xmcz(qc: QuantumCircuit, xregs: list[int], zregs: list[int]) -> None:
if xregs:
qc.x(xregs)
mcz(qc, zregs)
if xregs:
qc.x(xregs)
a = to_bin(L, n)
xs = xmap(L, n)
#print(xs)
for i in range(n):
if a[n - 1 - i] == 0:
#print("xmcz", [x for x in xs if x > n - 1 - i], list(range(n - 1 - i, n)))
xmcz(qc, [x for x in xs if x > n - 1 - i], list(range(n - 1 - i, n)))
xmcz(qc, xs, list(range(n)))
return qc
''' |
QPC001_B4 | AE752EC31EC58 | 3 | RE | 770 ms | 79 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
def to_bin(m: int, size: int) -> list[int]:
a = [0] * size
idx = 0
while m:
if m % 2:
a[idx] = 1
idx += 1
m //= 2
return a
def xmap(m: int, size: int) -> list[int]:
a = []
idx = 0
while m:
if m % 2:
a.append(idx)
idx += 1
m //= 2
return [i for i in range(size) if i not in a]
def mcz(qc: QuantumCircuit, regs: list[int]) -> None:
if len(regs) == 0:
return
if len(regs) == 1:
qc.z(regs[0])
else:
qc.h(regs[-1])
qc.mcx(regs[:-1], regs[-1])
qc.h(regs[-1])
def xmcz(qc: QuantumCircuit, xregs: list[int], zregs: list[int]) -> None:
if xregs:
qc.x(xregs)
mcz(qc, zregs)
if xregs:
qc.x(xregs)
a = to_bin(L, n)
xs = xmap(L, n)
#print(xs)
for i in range(n):
if a[n - 1 - i] == 0:
#print("xmcz", [x for x in xs if x > n - 1 - i], list(range(n - 1 - i, n)))
xmcz(qc, [x for x in xs if x > n - 1 - i], list(range(n - 1 - i, n)))
xmcz(qc, xs, list(range(n)))
return qc
''' |
QPC001_B4 | AE752EC31EC58 | 4 | AC | 1025 ms | 92 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
if L == 2**n:
return qc
def to_bin(m: int, size: int) -> list[int]:
a = [0] * size
idx = 0
while m:
if m % 2:
a[idx] = 1
idx += 1
m //= 2
return a
def xmap(m: int, size: int) -> list[int]:
a = []
idx = 0
while m:
if m % 2:
a.append(idx)
idx += 1
m //= 2
return [i for i in range(size) if i not in a]
def mcz(qc: QuantumCircuit, regs: list[int]) -> None:
if len(regs) == 0:
return
if len(regs) == 1:
qc.z(regs[0])
else:
qc.h(regs[-1])
qc.mcx(regs[:-1], regs[-1])
qc.h(regs[-1])
def xmcz(qc: QuantumCircuit, xregs: list[int], zregs: list[int]) -> None:
if xregs:
qc.x(xregs)
mcz(qc, zregs)
if xregs:
qc.x(xregs)
a = to_bin(L, n)
xs = xmap(L, n)
#print(xs)
for i in range(n):
if a[n - 1 - i] == 0:
#print("xmcz", [x for x in xs if x > n - 1 - i], list(range(n - 1 - i, n)))
xmcz(qc, [x for x in xs if x > n - 1 - i], list(range(n - 1 - i, n)))
xmcz(qc, xs, list(range(n)))
return qc
''' |
QPC001_B4 | AEA61F41880B3 | 1 | AC | 1628 ms | 93 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n-1,-1,-1):
if L&(1<<i)==0:
continue
for j in range(n-1,i,-1):
if L&(1<<j)==0:
qc.x(j)
qc.x(i)
if i==n-1:
qc.z(i)
else:
qc.append(ZGate().control(n-i-1),range(n-1,i-1,-1))
for j in range(n-1,i,-1):
if L&(1<<j)==0:
qc.x(j)
qc.x(i)
return qc
''' |
QPC001_B4 | AEACFA5CC2D0B | 1 | AC | 2373 ms | 143 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
if not (L >> i) & 1:
continue
for j in range(i + 1, n):
if not (L >> j) & 1:
qc.x(j)
qc.x(i)
if i == n - 1:
qc.z(i)
else:
qc.append(ZGate().control(n - i - 1), range(i, n))
qc.x(i)
for j in range(i + 1, n):
if not (L >> j) & 1:
qc.x(j)
qc.barrier()
return qc
''' |
QPC001_B4 | AEC41F32AC37E | 1 | RE | 1222 ms | 150 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
if((L>>j) & 1):
for j in range(i+1,n):
if not ((L>>j) & 1):
qc.x(j)
qc.x(i)
if( i == n-1):
qc.z(i)
else:
qc.append(Zgate().control(n-i-1),range(i,n))
qc.x(i)
for j in range(i+1, n):
if not (L >> j) & 1:
qc.x(j)
return qc
''' |
QPC001_B4 | AEC41F32AC37E | 2 | RE | 1148 ms | 147 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
if((L>>i) & 1):
for j in range(i+1,n):
if not ((L>>j) & 1):
qc.x(j)
qc.x(i)
if( i == n-1):
qc.z(i)
else:
qc.append(Zgate().control(n-i-1),range(i,n))
qc.x(i)
for j in range(i+1, n):
if not (L >> j) & 1:
qc.x(j)
return qc
''' |
QPC001_B4 | AEC41F32AC37E | 3 | AC | 1867 ms | 156 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
if((L>>i) & 1):
for j in range(i+1,n):
if not ((L>>j) & 1):
qc.x(j)
qc.x(i)
if( i == n-1):
qc.z(i)
else:
qc.append(ZGate().control(n-i-1),range(i,n))
qc.x(i)
for j in range(i+1, n):
if not (L >> j) & 1:
qc.x(j)
return qc
''' |
QPC001_B4 | AEC99D192C6DE | 1 | RE | 809 ms | 80 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
cnz = ZGate().control(n - 1)
skip_idx = []
first = [True for _ in range(n)]
for d in reversed(range(n)):
if (L>>d)&1:
flip = L&(((1<<n)-1)-((1<<d)-1))
if d > 0:
flip -= 1
for i in range(n):
if (not (i in skip_idx) or first[i]) and ((flip>>i)&1) == 0:
qc.x(i)
first[i] = False
qc.append(cnz, range(n))
for i in range(n):
if (not (i in skip_idx) or first[i]) and ((flip>>i)&1) == 0:
qc.x(i)
first[i] = False
else:
skip_idx.append(d)
for i in skip_idx:
qc.x(i)
return qc
''' |
QPC001_B4 | AEC99D192C6DE | 2 | RE | 821 ms | 80 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
def flip_single_state(n: int, k: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
print('n: ', n, ' k: ', k)
for i in range(n):
if ((k>>i)&1) == 0:
qc.x(i)
qc.append(ZGate().control(n-1), range(n))
for i in range(n):
if ((k>>i)&1) == 0:
qc.x(i)
return qc
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for d in reversed(range(n)):
if (L>>d)&1:
flip = (L>>d)-1
fss = flip_single_state(n-d, flip)
#fss.draw('mpl', style='iqp')
qc.append(fss.to_gate(), range(d, n))
return qc
''' |
QPC001_B4 | AEC99D192C6DE | 3 | RE | 949 ms | 90 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for d in reversed(range(n)):
if (L>>d)&1:
flip = (L>>d)-1
for i in range(n-d):
if ((flip>>i)&1) == 0:
qc.x(i+d)
qc.append(ZGate().control(n-d-1), range(d, n))
for i in range(n-d):
if ((flip>>i)&1) == 0:
qc.x(i+d)
return qc
''' |
QPC001_B4 | AEC99D192C6DE | 4 | AC | 1191 ms | 93 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for d in reversed(range(n)):
if (L>>d)&1:
flip = (L>>d)-1
for i in range(n-d):
if ((flip>>i)&1) == 0:
qc.x(i+d)
if n == d + 1:
qc.z(d)
else:
qc.append(ZGate().control(n-d-1), range(d, n))
for i in range(n-d):
if ((flip>>i)&1) == 0:
qc.x(i+d)
return qc
''' |
QPC001_B4 | AEDAB9029B257 | 1 | WA | 1763 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
def mcz(qc: QuantumCircuit, cs: list[int]):
if len(cs) == 0:
return
if len(cs) == 1:
qc.z(cs[0])
else:
mcz_gate = ZGate().control(len(cs) - 1)
qc.append(mcz_gate, cs)
# val = 2^k のとき
def num_inv_2(qc: QuantumCircuit, n: int, k: int):
qc.x(range(k, n))
mcz(qc, list(range(k, n)))
qc.x(range(k, n))
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
qc.h(range(n))
for i in range(n):
if (L >> i) & 1:
qc.x(i)
num_inv_2(qc, n, i)
return qc
''' |
QPC001_B4 | AEDAB9029B257 | 2 | WA | 1639 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
def mcz(qc: QuantumCircuit, cs: list[int]):
if len(cs) == 0:
return
if len(cs) == 1:
qc.z(cs[0])
else:
mcz_gate = ZGate().control(len(cs) - 1)
qc.append(mcz_gate, cs)
# val = 2^k のとき
def num_inv_2(qc: QuantumCircuit, n: int, k: int):
qc.x(range(k, n))
mcz(qc, list(range(k, n)))
qc.x(range(k, n))
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# qc.h(range(n))
for i in range(n):
if (L >> i) & 1:
qc.x(i)
num_inv_2(qc, n, i)
return qc
''' |
QPC001_B4 | AEDAB9029B257 | 3 | AC | 1915 ms | 143 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
def mcz(qc: QuantumCircuit, cs: list[int]):
if len(cs) == 1:
qc.z(cs[0])
else:
mcz_gate = ZGate().control(len(cs) - 1)
qc.append(mcz_gate, cs)
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# qc.h(range(n))
for i in range(n):
if (L >> i) & 1 == 0:
continue
# flip
qc.x(i)
for j in range(i + 1, n):
if (L >> j) & 1 == 0:
qc.x(j)
mcz(qc, list(range(i, n)))
# flip
qc.x(i)
for j in range(i + 1, n):
if (L >> j) & 1 == 0:
qc.x(j)
return qc
''' |
QPC001_B4 | AEFAEC7D7DEFC | 1 | DLE | 2625 ms | 146 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(L):
log=[]
for j,x in enumerate(f"{i:0{n}b}"[::-1]):
if x=="0":
log.append(j)
qc.x(j)
if n!=1:
qc.append(ZGate().control(n-1), range(n))
else:
qc.z(0)
for j in log:
qc.x(j)
return qc
''' |
QPC001_B4 | AF2A40871D818 | 1 | AC | 2472 ms | 160 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
import math
def append_cz(qc, ctrl_lst, tgt):
if ctrl_lst:
qc.append(ZGate().control(len(ctrl_lst)), ctrl_lst+[tgt])
else:
qc.z(tgt)
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
if not (L >> i) & 1:
continue
for j in range(i + 1, n):
if not (L >> j) & 1:
qc.x(j)
qc.x(i)
# if i == n - 1:
# qc.z(i)
# else:
# qc.append(ZGate().control(n - i - 1), range(i, n))
append_cz(qc, [_ for _ in range(i, n-1)], n-1)
qc.x(i)
for j in range(i + 1, n):
if not (L >> j) & 1:
qc.x(j)
return qc
''' |
QPC001_B4 | AF8069F734A36 | 1 | WA | 933 ms | 91 MiB | '''python
#%%
from qiskit import QuantumCircuit
import math
PI = math.pi
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
if n == 1:
if L == 0:
return qc
else:
qc.x(0)
qc.z(0)
qc.x(0)
return qc
for marked in range(L):
if marked == 0:
for i in range(n):
qc.x(i)
# apply MCZ
qc.mcp(PI, [qbit for qbit in range(n-1)], n-1)
else:
for apply_x_bit in range(n):
if marked & (1<<apply_x_bit) == 0 and not((marked-1) & (1<<apply_x_bit) == 0):
qc.x(apply_x_bit)
elif not(marked & (1<<apply_x_bit) == 0) and (marked-1) & (1<<apply_x_bit) == 0:
qc.x(apply_x_bit)
# apply MCZ
qc.mcp(PI, [qbit for qbit in range(n-1)], n-1)
return qc
''' |
QPC001_B4 | AF8069F734A36 | 2 | WA | 965 ms | 91 MiB | '''python
#%%
from qiskit import QuantumCircuit
import math
PI = math.pi
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
if n == 1:
if L == 0:
return qc
else:
qc.x(0)
qc.z(0)
qc.x(0)
return qc
for marked in range(L):
for zero_bit in range(n):
if marked & (1<<zero_bit) == 0:
qc.x(zero_bit)
# apply MCZ
qc.mcp(PI, [qbit for qbit in range(n-1)], n-1)
for zero_bit in range(n):
if marked & (1<<zero_bit) == 0:
qc.x(zero_bit)
return qc
''' |
QPC001_B4 | AF8069F734A36 | 3 | WA | 1041 ms | 91 MiB | '''python
#%%
from qiskit import QuantumCircuit
import math
PI = math.pi
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
if n == 1:
if L == 0:
return qc
else:
qc.x(0)
qc.z(0)
qc.x(0)
return qc
for marked in range(L):
for zero_bit in range(n):
if marked & (1<<zero_bit) == 0:
qc.x(zero_bit)
# apply MCZ
qc.mcp(PI, [qbit for qbit in range(n-1)], n-1)
for zero_bit in range(n):
if marked & (1<<zero_bit) == 0:
qc.x(zero_bit)
return qc
''' |
QPC001_B4 | AF8069F734A36 | 4 | RE | 926 ms | 91 MiB | '''python
#%%
from qiskit import QuantumCircuit
import math
PI = math.pi
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
if n == 1:
if L == 0:
return qc
else:
qc.x(0)
qc.z(0)
qc.x(0)
return qc
for marked in range(L):
for zero_bit in range(n):
if marked & (1<<zero_bit) == 0:
qc.x(zero_bit)
# apply MCZ
qc.mcp(PI, [qbit for qbit in range(n-1)], n-1)
for zero_bit in range(n):
if marked & (1<<zero_bit) == 0:
qc.x(zero_bit)
return qc.decompose(rep=5)
''' |
QPC001_B4 | AF8069F734A36 | 5 | WA | 849 ms | 91 MiB | '''python
#%%
from qiskit import QuantumCircuit
import math
PI = math.pi
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
if n == 1:
if L == 0:
return qc
else:
qc.x(0)
qc.z(0)
qc.x(0)
return qc
for marked in range(L):
for zero_bit in range(n):
if marked & (1<<zero_bit) == 0:
qc.x(zero_bit)
# apply MCZ
qc.mcp(PI, [qbit for qbit in range(n-1)], n-1)
for zero_bit in range(n):
if marked & (1<<zero_bit) == 0:
qc.x(zero_bit)
return qc.decompose(reps=5)
''' |
QPC001_C1 | A026D05469C2F | 1 | AC | 1768 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
k = 0
while True:
qc.h(k)
k += 1
if (1<<k) >= L:
break
return qc
''' |
QPC001_C1 | A04C4F3B23F97 | 1 | UGE | 1198 ms | 91 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import MCMT
import math
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
v = []
s = 0
for j in range(n - 1, -1, -1):
if ((L-1) >> j) & 1:
s += (1 << j)
theta = 2 * math.acos(((1 << j) / ((1 << j) + (L - s))) ** 0.5)
if(len(v) == 0):
qc.ry(theta, j)
else:
for k in range(len(v)):
if v[k] == 0:
qc.x((n - 1) - k)
qc.mcrx(theta, qc.qregs[0][(j+1):], qc.qregs[0][j])
'''
cnh = MCMT('h',len(v),1)
qc.compose(cnh,qubits=range(n - 1, (n - 1) - len(v) - 1, -1),inplace=True)
'''
for k in range(len(v)):
if v[k] == 0:
qc.x((n - 1) - k)
'''
qc.x(j)
for k in range(j):
qc.ch(j, k)
qc.x(j)
'''
v.append(1)
else:
v.append(0)
continue
for j in range(n - 1):
if v[j] == 1:
for k in range(j):
if(v[k] == 0):
qc.x((n - 1) - k)
qc.x((n - 1) - j)
cnh = MCMT('h',j + 1,1)
for k in range((n - 1) - j):
qc.compose(cnh,qubits = list(range(n - 1, (n - 1) - (j + 1), -1)) + [k],inplace=True)
for k in range(j):
if(v[k] == 0):
qc.x((n - 1) - k)
qc.x((n - 1) - j)
return qc
''' |
QPC001_C1 | A04C4F3B23F97 | 2 | RE | 1206 ms | 90 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
v = []
s = 0
for j in range(n - 1, -1, -1):
if ((L-1) >> j) & 1:
s += (1 << j)
theta = 2 * math.acos(((1 << j) / ((1 << j) + (L - s))) ** 0.5)
if(len(v) == 0):
qc.ry(theta, j)
else:
for k in range(len(v)):
if v[k] == 0:
qc.x((n - 1) - k)
qc.mcrx(theta, qc.qregs[0][(j+1):], qc.qregs[0][j])
'''
cnh = MCMT('h',len(v),1)
qc.compose(cnh,qubits=range(n - 1, (n - 1) - len(v) - 1, -1),inplace=True)
'''
for k in range(len(v)):
if v[k] == 0:
qc.x((n - 1) - k)
'''
qc.x(j)
for k in range(j):
qc.ch(j, k)
qc.x(j)
'''
v.append(1)
else:
v.append(0)
continue
for j in range(n - 1):
if v[j] == 1:
for k in range(j):
if(v[k] == 0):
qc.x((n - 1) - k)
qc.x((n - 1) - j)
cnh = MCMT('h',j + 1,1)
for k in range((n - 1) - j):
qc.compose(cnh,qubits = list(range(n - 1, (n - 1) - (j + 1), -1)) + [k],inplace=True)
for k in range(j):
if(v[k] == 0):
qc.x((n - 1) - k)
qc.x((n - 1) - j)
return qc
''' |
QPC001_C1 | A04C4F3B23F97 | 3 | WA | 1177 ms | 90 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
v = []
s = 0
for j in range(n - 1, -1, -1):
if ((L-1) >> j) & 1:
s += (1 << j)
theta = 2 * math.acos(((1 << j) / ((1 << j) + (L - s))) ** 0.5)
if(len(v) == 0):
qc.ry(theta, j)
else:
for k in range(len(v)):
if v[k] == 0:
qc.x((n - 1) - k)
qc.mcrx(theta, qc.qregs[0][(j+1):], qc.qregs[0][j])
'''
cnh = MCMT('h',len(v),1)
qc.compose(cnh,qubits=range(n - 1, (n - 1) - len(v) - 1, -1),inplace=True)
'''
for k in range(len(v)):
if v[k] == 0:
qc.x((n - 1) - k)
'''
qc.x(j)
for k in range(j):
qc.ch(j, k)
qc.x(j)
'''
v.append(1)
else:
v.append(0)
continue
for j in range(n - 1):
if v[j] == 1:
for k in range(j):
if(v[k] == 0):
qc.x((n - 1) - k)
qc.x((n - 1) - j)
for k in range(j):
if(v[k] == 0):
qc.x((n - 1) - k)
qc.x((n - 1) - j)
return qc
''' |
QPC001_C1 | A04C4F3B23F97 | 4 | RE | 902 ms | 79 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
v = []
s = 0
for j in range(n - 1, -1, -1):
if ((L-1) >> j) & 1:
s += (1 << j)
theta = 2 * math.acos(((1 << j) / ((1 << j) + (L - s))) ** 0.5)
if(len(v) == 0):
qc.ry(theta, j)
else:
for k in range(len(v)):
if v[k] == 0:
qc.x((n - 1) - k)
qc.mcrx(theta, qc.qregs[0][(j+1):], qc.qregs[0][j])
'''
cnh = MCMT('h',len(v),1)
qc.compose(cnh,qubits=range(n - 1, (n - 1) - len(v) - 1, -1),inplace=True)
'''
for k in range(len(v)):
if v[k] == 0:
qc.x((n - 1) - k)
'''
qc.x(j)
for k in range(j):
qc.ch(j, k)
qc.x(j)
'''
v.append(1)
else:
v.append(0)
continue
for j in range(n - 1):
if v[j] == 1:
for k in range(j):
if(v[k] == 0):
qc.x((n - 1) - k)
qc.x((n - 1) - j)
for k in range(j):
if(v[k] == 0):
qc.x((n - 1) - k)
qc.x((n - 1) - j)
return qc
''' |
QPC001_C1 | A04C4F3B23F97 | 5 | UGE | 1395 ms | 91 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import MCMT
import math
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
v = []
s = 0
for j in range(n - 1, -1, -1):
if ((L-1) >> j) & 1:
s += (1 << j)
theta = 2 * math.acos(((1 << j) / ((1 << j) + (L - s))) ** 0.5)
if(len(v) == 0):
qc.ry(theta, j)
else:
for k in range(len(v)):
if v[k] == 0:
qc.x((n - 1) - k)
qc.mcrx(theta, qc.qregs[0][(j+1):], qc.qregs[0][j])
for k in range(len(v)):
if v[k] == 0:
qc.x((n - 1) - k)
v.append(1)
else:
v.append(0)
continue
for j in range(n - 1):
if v[j] == 1:
for k in range(j):
if(v[k] == 0):
qc.x((n - 1) - k)
qc.x((n - 1) - j)
cnh = MCMT('h',j + 1,1)
for k in range((n - 1) - j):
qc.compose(cnh,qubits = list(range(n - 1, (n - 1) - (j + 1), -1)) + [k],inplace=True)
for k in range(j):
if(v[k] == 0):
qc.x((n - 1) - k)
qc.x((n - 1) - j)
return qc
''' |
QPC001_C1 | A04C4F3B23F97 | 6 | RE | 932 ms | 79 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import MCMT
import math
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
v = []
s = 0
for j in range(n - 1, -1, -1):
if ((L-1) >> j) & 1:
s += (1 << j)
theta = 2 * math.acos(((1 << j) / ((1 << j) + (L - s))) ** 0.5)
if(len(v) == 0):
qc.ry(theta, j)
else:
for k in range(len(v)):
if v[k] == 0:
qc.x((n - 1) - k)
qc.mcrx(theta, qc.qregs[0][(j+1):], qc.qregs[0][j])
for k in range(len(v)):
if v[k] == 0:
qc.x((n - 1) - k)
v.append(1)
else:
v.append(0)
continue
for j in range(n - 1):
if v[j] == 1:
for k in range(j):
if(v[k] == 0):
qc.x((n - 1) - k)
qc.x((n - 1) - j)
cnh = MCMT('h',j + 1,1)
for k in range((n - 1) - j):
# qc.compose(cnh,qubits = list(range(n - 1, (n - 1) - (j + 1), -1)) + [k],inplace=True)
for k in range(j):
if(v[k] == 0):
qc.x((n - 1) - k)
qc.x((n - 1) - j)
return qc
''' |
QPC001_C1 | A04C4F3B23F97 | 7 | WA | 1177 ms | 90 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import MCMT
import math
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
v = []
s = 0
for j in range(n - 1, -1, -1):
if ((L-1) >> j) & 1:
s += (1 << j)
theta = 2 * math.acos(((1 << j) / ((1 << j) + (L - s))) ** 0.5)
if(len(v) == 0):
qc.ry(theta, j)
else:
for k in range(len(v)):
if v[k] == 0:
qc.x((n - 1) - k)
qc.mcrx(theta, qc.qregs[0][(j+1):], qc.qregs[0][j])
for k in range(len(v)):
if v[k] == 0:
qc.x((n - 1) - k)
v.append(1)
else:
v.append(0)
continue
for j in range(n - 1):
if v[j] == 1:
for k in range(j):
if(v[k] == 0):
qc.x((n - 1) - k)
qc.x((n - 1) - j)
cnh = MCMT('h',j + 1,1)
for k in range((n - 1) - j):
pass
# qc.compose(cnh,qubits = list(range(n - 1, (n - 1) - (j + 1), -1)) + [k],inplace=True)
for k in range(j):
if(v[k] == 0):
qc.x((n - 1) - k)
qc.x((n - 1) - j)
return qc
''' |
QPC001_C1 | A04C4F3B23F97 | 8 | WA | 951 ms | 91 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import MCMT
import math
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
v = []
s = 0
for j in range(n - 1, -1, -1):
if ((L-1) >> j) & 1:
s += (1 << j)
theta = 2 * math.acos(((1 << j) / ((1 << j) + (L - s))) ** 0.5)
if(len(v) == 0):
qc.ry(theta, j)
else:
for k in range(len(v)):
if v[k] == 0:
qc.x((n - 1) - k)
# qc.mcrx(theta, qc.qregs[0][(j+1):], qc.qregs[0][j])
for k in range(len(v)):
if v[k] == 0:
qc.x((n - 1) - k)
v.append(1)
else:
v.append(0)
continue
for j in range(n - 1):
if v[j] == 1:
for k in range(j):
if(v[k] == 0):
qc.x((n - 1) - k)
qc.x((n - 1) - j)
cnh = MCMT('h',j + 1,1)
for k in range((n - 1) - j):
pass
# qc.compose(cnh,qubits = list(range(n - 1, (n - 1) - (j + 1), -1)) + [k],inplace=True)
for k in range(j):
if(v[k] == 0):
qc.x((n - 1) - k)
qc.x((n - 1) - j)
return qc
''' |
QPC001_C1 | A04C4F3B23F97 | 9 | WA | 1122 ms | 92 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import MCMT
import math
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
v = []
s = 0
for j in range(n - 1, -1, -1):
if ((L-1) >> j) & 1:
s += (1 << j)
theta = 2 * math.acos(((1 << j) / ((1 << j) + (L - s))) ** 0.5)
if(len(v) == 0):
qc.ry(theta, j)
else:
for k in range(len(v)):
if v[k] == 0:
qc.x((n - 1) - k)
# qc.mcrx(theta, qc.qregs[0][(j+1):], qc.qregs[0][j])
for k in range(len(v)):
if v[k] == 0:
qc.x((n - 1) - k)
v.append(1)
else:
v.append(0)
continue
for j in range(n - 1):
if v[j] == 1:
for k in range(j):
if(v[k] == 0):
qc.x((n - 1) - k)
qc.x((n - 1) - j)
cnh = MCMT('h',j + 1,1)
for k in range((n - 1) - j):
pass
qc.compose(cnh,qubits = list(range(n - 1, (n - 1) - (j + 1), -1)) + [k],inplace=True)
for k in range(j):
if(v[k] == 0):
qc.x((n - 1) - k)
qc.x((n - 1) - j)
return qc
''' |
QPC001_C1 | A04C4F3B23F97 | 10 | AC | 2946 ms | 106 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import MCMT
import math
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
v = []
s = 0
for j in range(n - 1, -1, -1):
if ((L-1) >> j) & 1:
s += (1 << j)
theta = 2 * math.acos(((1 << j) / ((1 << j) + (L - s))) ** 0.5)
if(len(v) == 0):
qc.ry(theta, j)
else:
for k in range(len(v)):
if v[k] == 0:
qc.x((n - 1) - k)
cnh = MCMT('h', (n - 1) - j,1)
qc.compose(cnh,qubits = list(range(n - 1, j - 1, -1)),inplace=True)
qc.mcp(theta, qc.qregs[0][(j+1):], qc.qregs[0][j])
cnh = MCMT('h', (n - 1) - j,1)
qc.compose(cnh,qubits = list(range(n - 1, j - 1, -1)),inplace=True)
for k in range(len(v)):
if v[k] == 0:
qc.x((n - 1) - k)
v.append(1)
else:
v.append(0)
continue
for j in range(n - 1):
if v[j] == 1:
for k in range(j):
if(v[k] == 0):
qc.x((n - 1) - k)
qc.x((n - 1) - j)
cnh = MCMT('h',j + 1,1)
for k in range((n - 1) - j):
qc.compose(cnh,qubits = list(range(n - 1, (n - 1) - (j + 1), -1)) + [k],inplace=True)
for k in range(j):
if(v[k] == 0):
qc.x((n - 1) - k)
qc.x((n - 1) - j)
return qc
''' |
QPC001_C1 | A0908371EB7C9 | 1 | RE | 2114 ms | 156 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.h(range(math.ceil(math.log2(L))))
return qc
''' |
QPC001_C1 | A0908371EB7C9 | 2 | AC | 2166 ms | 155 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
if L == 1:
return qc
qc.h(range(math.ceil(math.log2(L))))
return qc
''' |
QPC001_C1 | A09E90DF6C8E4 | 1 | UGE | 1379 ms | 154 MiB | '''python
from qiskit import QuantumCircuit
from math import sqrt
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
amplitude = sqrt(1 / L)
amplitudes = [amplitude] * L + [0] * (2**n - L)
qc.initialize(amplitudes, range(n))
return qc
''' |
QPC001_C1 | A0E9009986C74 | 1 | RE | 1793 ms | 157 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Apply Hadamard gates to all qubits to create superposition
for qubit in range(n):
qc.h(qubit)
# Apply controlled rotations to zero out states beyond L-1
for i in range(L, 2**n):
# Convert i to binary and apply a series of X gates to flip the states
binary_representation = format(i, f'0{n}b')
for qubit in range(n):
if binary_representation[qubit] == '1':
qc.x(qubit)
# Apply a controlled-NOT to flip the state back to |0> if the control qubit is |1>
qc.mct(list(range(n)), n) # Multi-controlled Toffoli gate
for qubit in range(n):
if binary_representation[qubit] == '1':
qc.x(qubit)
return qc
''' |
QPC001_C1 | A0E9009986C74 | 2 | RE | 1794 ms | 156 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Apply Hadamard gates to the first L qubits
for i in range(L):
qc.h(i) # Apply Hadamard to the first L qubits
# Normalize the amplitudes
# The amplitude for each of the first L states will be 1/sqrt(L)
# This is already achieved by applying H gates to L qubits.
# The remaining qubits (if any) should be set to |0>
# This is automatically the case since we initialized the circuit with |0>
return qc
''' |
QPC001_C1 | A0E9009986C74 | 3 | AC | 2946 ms | 160 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Number of qubits that must be in uniform superposition
k = 0 if L == 1 else math.ceil(math.log2(L))
# Apply Hadamard to the first k qubits (indices 0 … k-1)
for q in range(k):
qc.h(q)
return qc
''' |
QPC001_C1 | A0F4753D93A8A | 1 | RE | 813 ms | 79 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
m=0
result=1
while result*2 < L:
result *= 2
m += 1
qc.ry(2*math.asin(math.sqrt(L-result/L)),m)
for num in range(m):
qc.h(num)
return qc
''' |
QPC001_C1 | A0F4753D93A8A | 2 | RE | 1097 ms | 79 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
m=0
result=1
while result*2 < L:
result *= 2
m += 1
qc.ry(2*math.asin(math.sqrt((L-result)/L)),m)
for num in range(m):
qc.h(num)
return qc
''' |
QPC001_C1 | A0F4753D93A8A | 3 | WA | 1039 ms | 90 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
m=0
result=1
while result*2 < L:
result *= 2
m += 1
qc.ry(2*math.asin(math.sqrt((L-result)/L)),m)
for num in range(m):
qc.h(num)
return qc
''' |
QPC001_C1 | A0F4753D93A8A | 4 | UME | '''python
from qiskit import QuantumCircuit
import mat
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
m=0
result=1
while result*2 < L:
result *= 2
m += 1
for num in range(m):
qc.h(num)
return qc
''' | ||
QPC001_C1 | A0F4753D93A8A | 5 | RE | 985 ms | 78 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
m=0
result=1
while result*2 < L-:
result *= 2
m += 1
for num in range(m):
qc.h(num)
return qc
''' |
QPC001_C1 | A0F4753D93A8A | 6 | RE | 973 ms | 79 MiB | '''python
from qiskit import QuantumCircuit
i
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
m=0
result=1
while result*2 < L:
result *= 2
m += 1
for num in range(m):
qc.h(num)
return qc
''' |
QPC001_C1 | A0F4753D93A8A | 7 | WA | 1151 ms | 90 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
m=0
result=1
while result*2 < L:
result *= 2
m += 1
for num in range(m):
qc.h(num)
return qc
''' |
QPC001_C1 | A0F4753D93A8A | 8 | RE | 990 ms | 90 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
m=0
result=1
while result*2 < L:
result *= 2
m += 1
qc.h(range(num))
return qc
''' |
QPC001_C1 | A0F4753D93A8A | 9 | RE | 794 ms | 79 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
m=0
result=1
while result*2 < L:
result *= 2
m += 1
qc.h(range(num))
return qc
''' |
QPC001_C1 | A0F4753D93A8A | 10 | RE | 911 ms | 79 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
if L==1:
return qc
m=0
result=1
while result*2 < L:
result *= 2
m += 1
qc.h(range(num))
return qc
''' |
QPC001_C1 | A0F4753D93A8A | 11 | RE | 1218 ms | 90 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
if L==1:
return qc
m=0
result=1
while result*2 < L:
result *= 2
m += 1
qc.h(range(m))
return qc
''' |
QPC001_C1 | A0F5D577B76D8 | 1 | AC | 2915 ms | 92 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# for i in range(n):
# qc.h(i)
# Write your code here:
if L == (1<<n):
for i in range(n):
qc.h(i)
return qc
for i in reversed(range(n)):
if L&(1<<i) :
for j in range(i+1):
qc.h(j)
break
return qc
''' |
QPC001_C1 | A0F8119CF9439 | 1 | RE | 1111 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.h(range(math.ceil(math.log2(L))))
return qc
''' |
QPC001_C1 | A0F8119CF9439 | 2 | AC | 1449 ms | 141 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.h(range(max(1, math.ceil(math.log2(L)))))
return qc
''' |
QPC001_C1 | A11D7CA0B5392 | 1 | AC | 1337 ms | 92 MiB | '''python
import math
from qiskit import QuantumCircuit
from qiskit import QuantumRegister
from qiskit.circuit.library import HGate, CXGate, MCPhaseGate, MCMT
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
if 2 ** i >= L:
break
qc.h(i)
return qc
''' |
QPC001_C1 | A14C657C2F2EE | 1 | RE | 1070 ms | 91 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.ry(2 * math.acos(1 / math.sqrt(L)), 0)
qc.ch(0, 1)
for i in range(n - 1):
qc.cx(i, i + 1)
qc.x(0)
return qc
''' |
QPC001_C1 | A14C657C2F2EE | 2 | RE | 902 ms | 79 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.ry(2 * math.acos(1 / math.sqrt(L)), 0)
qc.ch(0, 1)
for i in range(n - 1, 0, -1):
qc.cx(i, i + 1)
qc.x(0)
return qc
''' |
QPC001_C1 | A14C657C2F2EE | 3 | RE | 1274 ms | 91 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.ry(2 * math.acos(1 / math.sqrt(L)), 0)
qc.ch(0, 1)
for i in range(n - 2):
qc.cx(i, i + 1)
qc.x(0)
return qc
''' |
QPC001_C1 | A14C657C2F2EE | 4 | WA | 1047 ms | 91 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
if n == 1:
return qc
qc.ry(2 * math.acos(1 / math.sqrt(L)), 0)
qc.ch(0, 1)
for i in range(n - 2):
qc.cx(i, i + 1)
qc.x(0)
return qc
''' |
QPC001_C1 | A14C657C2F2EE | 5 | WA | 1234 ms | 91 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
if n == 1:
return qc
qc.ry(2 * math.acos(1 / math.sqrt(L)), 0)
qc.ch(0, 1)
# qc.cx(1, 2)
# qc.cx(0, 1) # n = 3, L = 3
for i in range(n - 2, 0, -1):
qc.cx(0, i)
qc.x(0)
return qc
''' |
QPC001_C1 | A1A8D43A345C7 | 1 | WA | 1043 ms | 90 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.h(i)
return qc
''' |
QPC001_C1 | A1A8D43A345C7 | 2 | WA | 1016 ms | 91 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n-1):
qc.h(i)
qc.cz(i,i+1)
qc.h(i+1)
return qc
''' |
QPC001_C1 | A1A8D43A345C7 | 3 | RE | 831 ms | 79 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.h(i)
qc.cz(i,i+1)
qc.h(i+1)
return qc
''' |
QPC001_C1 | A1A8D43A345C7 | 4 | WA | 1132 ms | 91 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n-1):
qc.h(i)
qc.cz(i,i+1)
qc.h(i+1)
return qc
''' |
QPC001_C1 | A1CF3A7FE862D | 1 | UME | '''python
from qiskit import QuantumCircuit, Aer, transpile, assemble, execute
from qiskit.visualization import plot_histogram
from qiskit.circuit.library import MCPhaseGate
import math
def oracle(n: int, L: int) -> QuantumCircuit:
""" オラクル関数 """
qc = QuantumCircuit(n)
ato = []
for i in range(n-1,-1,-1):
lst = []
for j in range(i+1, n):
lst.append(j)
if len(lst) == 0:
if (L >> i) & 1:
qc.x(i)
qc.z(i)
qc.x(i)
else:
qc.x(i)
ato.append(i)
else:
if (L >> i) & 1:
qc.x(i)
qc.append(MCPhaseGate(math.pi, len(lst)), lst + [i])
qc.x(i)
else:
qc.x(i)
ato.append(i)
for i in ato:
qc.x(i)
return qc
def diffusion_operator(n):
""" 拡散操作関数 """
qc = QuantumCircuit(n)
qc.h(range(n))
qc.x(range(n))
qc.h(n-1)
qc.mcx(list(range(n-1)), n-1)
qc.h(n-1)
qc.x(range(n))
qc.h(range(n))
return qc
def solve(n, L):
""" グローバーのアルゴリズムを使って特定のビット列 L を見つけ出す関数 """
qc = QuantumCircuit(n, n)
# 初期化
for i in range(n):
qc.h(i)
# 繰り返し回数
iterations = int(math.sqrt((2**n)))
for _ in range(iterations):
# オラクルの適用
qc.append(oracle(n, L), range(n))
# 拡散操作の適用
qc.append(diffusion_operator(n), range(n))
''' | ||
QPC001_C1 | A1CF3A7FE862D | 2 | UME | '''python
from qiskit import QuantumCircuit, Aer, transpile, assemble, execute
#from qiskit.visualization import plot_histogram
from qiskit.circuit.library import MCPhaseGate
import math
def oracle(n: int, L: int) -> QuantumCircuit:
""" オラクル関数 """
qc = QuantumCircuit(n)
ato = []
for i in range(n-1,-1,-1):
lst = []
for j in range(i+1, n):
lst.append(j)
if len(lst) == 0:
if (L >> i) & 1:
qc.x(i)
qc.z(i)
qc.x(i)
else:
qc.x(i)
ato.append(i)
else:
if (L >> i) & 1:
qc.x(i)
qc.append(MCPhaseGate(math.pi, len(lst)), lst + [i])
qc.x(i)
else:
qc.x(i)
ato.append(i)
for i in ato:
qc.x(i)
return qc
def diffusion_operator(n):
""" 拡散操作関数 """
qc = QuantumCircuit(n)
qc.h(range(n))
qc.x(range(n))
qc.h(n-1)
qc.mcx(list(range(n-1)), n-1)
qc.h(n-1)
qc.x(range(n))
qc.h(range(n))
return qc
def solve(n, L):
""" グローバーのアルゴリズムを使って特定のビット列 L を見つけ出す関数 """
qc = QuantumCircuit(n, n)
# 初期化
for i in range(n):
qc.h(i)
# 繰り返し回数
iterations = int(math.sqrt((2**n)))
for _ in range(iterations):
# オラクルの適用
qc.append(oracle(n, L), range(n))
# 拡散操作の適用
qc.append(diffusion_operator(n), range(n))
''' | ||
QPC001_C1 | A1CF3A7FE862D | 3 | RE | 947 ms | 79 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import MCPhaseGate
import math
def oracle(n: int, L: int) -> QuantumCircuit:
""" オラクル関数 """
qc = QuantumCircuit(n)
ato = []
for i in range(n-1,-1,-1):
lst = []
for j in range(i+1, n):
lst.append(j)
if len(lst) == 0:
if (L >> i) & 1:
qc.x(i)
qc.z(i)
qc.x(i)
else:
qc.x(i)
ato.append(i)
else:
if (L >> i) & 1:
qc.x(i)
qc.append(MCPhaseGate(math.pi, len(lst)), lst + [i])
qc.x(i)
else:
qc.x(i)
ato.append(i)
for i in ato:
qc.x(i)
return qc
def diffusion_operator(n):
""" 拡散操作関数 """
qc = QuantumCircuit(n)
qc.h(range(n))
qc.x(range(n))
qc.h(n-1)
qc.mcx(list(range(n-1)), n-1)
qc.h(n-1)
qc.x(range(n))
qc.h(range(n))
return qc
def solve(n, L):
""" グローバーのアルゴリズムを使って特定のビット列 L を見つけ出す関数 """
qc = QuantumCircuit(n, n)
# 初期化
for i in range(n):
qc.h(i)
# 繰り返し回数
iterations = int(math.sqrt((2**n)))
for _ in range(iterations):
# オラクルの適用
qc.append(oracle(n, L), range(n))
# 拡散操作の適用
qc.append(diffusion_operator(n), range(n))
''' |
QPC001_C1 | A1CF3A7FE862D | 4 | RE | 1112 ms | 79 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import MCPhaseGate
import math
def oracle(n: int, L: int) -> QuantumCircuit:
""" オラクル関数 """
qc = QuantumCircuit(n)
ato = []
for i in range(n-1,-1,-1):
lst = []
for j in range(i+1, n):
lst.append(j)
if len(lst) == 0:
if (L >> i) & 1:
qc.x(i)
qc.z(i)
qc.x(i)
else:
qc.x(i)
ato.append(i)
else:
if (L >> i) & 1:
qc.x(i)
qc.append(MCPhaseGate(math.pi, len(lst)), lst + [i])
qc.x(i)
else:
qc.x(i)
ato.append(i)
for i in ato:
qc.x(i)
return qc
def diffusion_operator(n):
""" 拡散操作関数 """
qc = QuantumCircuit(n)
qc.h(range(n))
qc.x(range(n))
qc.h(n-1)
qc.mcx(list(range(n-1)), n-1)
qc.h(n-1)
qc.x(range(n))
qc.h(range(n))
return qc
def solve(n, L):
""" グローバーのアルゴリズムを使って特定のビット列 L を見つけ出す関数 """
qc = QuantumCircuit(n, n)
# 初期化
for i in range(n):
qc.h(i)
# 繰り返し回数
iterations = int(math.sqrt((2**n)))
for _ in range(iterations):
# オラクルの適用
qc.append(oracle(n, L), range(n))
# 拡散操作の適用
qc.append(diffusion_operator(n), range(n))
return qc
''' |
QPC001_C1 | A1CF3A7FE862D | 5 | RE | 1252 ms | 93 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import MCPhaseGate
import math
def oracle(qc,n, L):
""" オラクル関数 """
#qc = QuantumCircuit(n)
ato = []
for i in range(n-1,-1,-1):
lst = []
for j in range(i+1, n):
lst.append(j)
if len(lst) == 0:
if (L >> i) & 1:
qc.x(i)
qc.z(i)
qc.x(i)
else:
qc.x(i)
ato.append(i)
else:
if (L >> i) & 1:
qc.x(i)
qc.append(MCPhaseGate(math.pi, len(lst)), lst + [i])
qc.x(i)
else:
qc.x(i)
ato.append(i)
for i in ato:
qc.x(i)
return qc
def diffusion_operator(qc,n):
""" 拡散操作関数 """
#qc = QuantumCircuit(n)
qc.h(range(n))
qc.x(range(n))
qc.h(n-1)
qc.mcx(list(range(n-1)), n-1)
qc.h(n-1)
qc.x(range(n))
qc.h(range(n))
return qc
def solve(n:int, L:int):
""" グローバーのアルゴリズムを使って特定のビット列 L を見つけ出す関数 """
qc = QuantumCircuit(n)
# 初期化
for i in range(n):
qc.h(i)
# 繰り返し回数
iterations = int(math.sqrt((2**n)))
for _ in range(iterations):
# オラクルの適用
#qc.append(oracle(n, L), range(n))
oracle(qc,n, L)
# 拡散操作の適用
#qc.append(diffusion_operator(n), range(n))
diffusion_operator(qc,n)
return qc
''' |
QPC001_C1 | A1CF3A7FE862D | 6 | RE | 1201 ms | 94 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import MCPhaseGate
import math
def oracle(qc,n, L):
""" オラクル関数 """
#qc = QuantumCircuit(n)
ato = []
for i in range(n-1,-1,-1):
lst = []
for j in range(i+1, n):
lst.append(j)
if len(lst) == 0:
if (L >> i) & 1:
qc.x(i)
qc.z(i)
qc.x(i)
else:
qc.x(i)
ato.append(i)
else:
if (L >> i) & 1:
qc.x(i)
qc.append(MCPhaseGate(math.pi, len(lst)), lst + [i])
qc.x(i)
else:
qc.x(i)
ato.append(i)
for i in ato:
qc.x(i)
return qc
def diffusion_operator(qc,n):
""" 拡散操作関数 """
#qc = QuantumCircuit(n)
qc.h(range(n))
qc.x(range(n))
qc.h(n-1)
qc.mcx(list(range(n-1)), n-1)
qc.h(n-1)
qc.x(range(n))
qc.h(range(n))
return qc
def solve(n:int, L:int):
""" グローバーのアルゴリズムを使って特定のビット列 L を見つけ出す関数 """
qc = QuantumCircuit(n)
# 初期化
for i in range(n):
qc.h(i)
# 繰り返し回数
iterations = int(math.sqrt((2**n)/L))
for _ in range(iterations):
# オラクルの適用
#qc.append(oracle(n, L), range(n))
oracle(qc,n, L)
# 拡散操作の適用
#qc.append(diffusion_operator(n), range(n))
diffusion_operator(qc,n)
return qc
''' |
QPC001_C1 | A1CF3A7FE862D | 7 | RE | 1302 ms | 91 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import MCPhaseGate
import math
def oracle(qc,n, L):
""" オラクル関数 """
#qc = QuantumCircuit(n)
ato = []
for i in range(n-1,-1,-1):
lst = []
for j in range(i+1, n):
lst.append(j)
if len(lst) == 0:
if (L >> i) & 1:
qc.x(i)
qc.z(i)
qc.x(i)
else:
qc.x(i)
ato.append(i)
else:
if (L >> i) & 1:
qc.x(i)
qc.append(MCPhaseGate(math.pi, len(lst)), lst + [i])
qc.x(i)
else:
qc.x(i)
ato.append(i)
for i in ato:
qc.x(i)
return qc
def diffusion_operator(qc,n):
""" 拡散操作関数 """
#qc = QuantumCircuit(n)
qc.h(range(n))
qc.x(range(n))
qc.h(n-1)
qc.mcx(list(range(n-1)), n-1)
qc.h(n-1)
qc.x(range(n))
qc.h(range(n))
return qc
def solve(n:int, L:int):
""" グローバーのアルゴリズムを使って特定のビット列 L を見つけ出す関数 """
qc = QuantumCircuit(n)
# 初期化
for i in range(n):
qc.h(i)
# 繰り返し回数
iterations = int(math.sqrt((2**n)/(L+1)))
for _ in range(iterations):
# オラクルの適用
#qc.append(oracle(n, L), range(n))
oracle(qc,n, L)
# 拡散操作の適用
#qc.append(diffusion_operator(n), range(n))
diffusion_operator(qc,n)
return qc
''' |
QPC001_C1 | A1CF3A7FE862D | 8 | RE | 1843 ms | 95 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import MCPhaseGate
import math
def oracle(qc,n, L):
""" オラクル関数 """
#qc = QuantumCircuit(n)
ato = []
for i in range(n-1,-1,-1):
lst = []
for j in range(i+1, n):
lst.append(j)
if len(lst) == 0:
if (L >> i) & 1:
qc.x(i)
qc.z(i)
qc.x(i)
else:
qc.x(i)
ato.append(i)
else:
if (L >> i) & 1:
qc.x(i)
qc.append(MCPhaseGate(math.pi, len(lst)), lst + [i])
qc.x(i)
else:
qc.x(i)
ato.append(i)
for i in ato:
qc.x(i)
return qc
def diffusion_operator(qc,n):
""" 拡散操作関数 """
#qc = QuantumCircuit(n)
qc.h(range(n))
qc.x(range(n))
qc.h(n-1)
qc.mcx(list(range(n-1)), n-1)
qc.h(n-1)
qc.x(range(n))
qc.h(range(n))
return qc
def solve(n:int, L:int):
""" グローバーのアルゴリズムを使って特定のビット列 L を見つけ出す関数 """
qc = QuantumCircuit(n)
# 初期化
for i in range(n):
qc.h(i)
# 繰り返し回数
iterations = int(math.sqrt((2**n)/(0+1)))
for _ in range(iterations):
# オラクルの適用
#qc.append(oracle(n, L), range(n))
oracle(qc,n, L)
# 拡散操作の適用
#qc.append(diffusion_operator(n), range(n))
diffusion_operator(qc,n)
return qc
''' |
QPC001_C1 | A1CF3A7FE862D | 9 | RE | 1016 ms | 88 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import RYGate, HGate
import math
from qiskit import QuantumCircuit
def append_cry(qc, angle, ctrl_lst, tgt):
if ctrl_lst:
# 制御量子ビットがある場合、制御RYゲートを追加
qc.append(RYGate(angle).control(len(ctrl_lst)), ctrl_lst + [tgt])
else:
# 制御量子ビットがない場合、通常のRYゲートを追加
qc.ry(angle, tgt)
def append_ch(qc, ctrl_lst, tgt):
if ctrl_lst:
# 制御量子ビットがある場合、制御Hゲートを追加
qc.append(HGate().control(len(ctrl_lst)), ctrl_lst + [tgt])
else:
# 制御量子ビットがない場合、通常のHゲートを追加
qc.h(tgt)
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
dq = [(0,n,L)]
while dq:
x,m,l = dq.pop(0)
#print(x,m,l)
if l == 0 or m == 0:
continue
if l == 2**m:
for j in range(m,n):
if not (x>>j)&1:
qc.x(j)
for j in range(m):
append_ch(qc,[_ for _ in range(m,n)],j)
for j in range(m,n):
if not (x>>j)&1:
qc.x(j)
#qc.barrier()
continue
left = min(2**(m-1),l)
right = l-left
if left != l:
# 処理2
for j in range(m,n):
if not (x>>j)&1:
qc.x(j)
append_cry(qc, 2*math.acos((left/l)**0.5),[_ for _ in range(m,n)],m-1)
for j in range(m,n):
if not (x>>j)&1:
qc.x(j)
#qc.barrier()
# 追加2
dq.append((x,m-1,left))
dq.append((x+2**(m-1),m-1,right))
''' |
QPC001_C1 | A1CF3A7FE862D | 10 | AC | 2891 ms | 96 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import RYGate, HGate
import math
from qiskit import QuantumCircuit
def append_cry(qc, angle, ctrl_lst, tgt):
if ctrl_lst:
# 制御量子ビットがある場合、制御RYゲートを追加
qc.append(RYGate(angle).control(len(ctrl_lst)), ctrl_lst + [tgt])
else:
# 制御量子ビットがない場合、通常のRYゲートを追加
qc.ry(angle, tgt)
def append_ch(qc, ctrl_lst, tgt):
if ctrl_lst:
# 制御量子ビットがある場合、制御Hゲートを追加
qc.append(HGate().control(len(ctrl_lst)), ctrl_lst + [tgt])
else:
# 制御量子ビットがない場合、通常のHゲートを追加
qc.h(tgt)
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
dq = [(0,n,L)]
while dq:
x,m,l = dq.pop(0)
#print(x,m,l)
if l == 0 or m == 0:
continue
if l == 2**m:
for j in range(m,n):
if not (x>>j)&1:
qc.x(j)
for j in range(m):
append_ch(qc,[_ for _ in range(m,n)],j)
for j in range(m,n):
if not (x>>j)&1:
qc.x(j)
#qc.barrier()
continue
left = min(2**(m-1),l)
right = l-left
if left != l:
# 処理2
for j in range(m,n):
if not (x>>j)&1:
qc.x(j)
append_cry(qc, 2*math.acos((left/l)**0.5),[_ for _ in range(m,n)],m-1)
for j in range(m,n):
if not (x>>j)&1:
qc.x(j)
#qc.barrier()
# 追加2
dq.append((x,m-1,left))
dq.append((x+2**(m-1),m-1,right))
return qc
''' |
QPC001_C1 | A1E68539863FB | 1 | AC | 1508 ms | 93 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve_rec(qc: QuantumCircuit, n: int, bit: int, L: int) -> None:
if bit < 0:
return
if L < (1<<bit):
qc.x(bit)
solve_rec(qc, n, bit-1, L)
qc.x(bit)
else:
qc.r(math.pi/2, 0, bit)
qc.mcp(-2*math.acos(math.sqrt((1<<bit)/L)), list(range(bit+1,n)), bit)
qc.r(-math.pi/2, 0, bit)
qc.x(bit)
for i in range(bit):
qc.r(math.pi/2, 0, i)
qc.mcp(math.pi/2, list(range(bit,n)), i)
qc.r(-math.pi/2, 0, i)
qc.x(bit)
solve_rec(qc, n, bit-1, L-(1<<bit))
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
if n == 1 and L == 2:
qc.h(0)
if n == 1:
return qc
if L < (1<<(n-1)):
qc.x(n-1)
solve_rec(qc, n, n-2, L)
qc.x(n-1)
else:
qc.r(2*math.acos(math.sqrt((1<<(n-1))/L)), math.pi/2, n-1)
qc.x(n-1)
for i in range(n-1):
qc.ch(n-1, i)
qc.x(n-1)
solve_rec(qc, n, n-2, L-(1<<(n-1)))
return qc
''' |
QPC001_C1 | A210272EB446F | 1 | AC | 2552 ms | 94 MiB | '''python
from qiskit import QuantumCircuit
from math import pi, asin, sqrt, floor
def oracle(qc: QuantumCircuit, n: int, L: int) -> QuantumCircuit:
K = L - 1
xgates = []
for i in range(n - 1, -1, -1):
if (K >> i) & 1:
continue
if i < n - 1:
qc.mcp(pi, list(range(i + 1, n)), i)
else:
qc.z(i)
xgates.append(i)
qc.x(i)
for i in xgates:
qc.x(i)
return qc
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
qc.h(i)
theta = asin(sqrt(L / (1 << n)))
r = floor(pi / (4 * theta))
# print(theta, r)
for _ in range(r):
oracle(qc, n, L)
for i in range(n):
qc.h(i)
qc.x(i)
if n > 1:
qc.mcp(pi, list(range(n - 1)), n - 1)
else:
qc.z(n - 1)
for i in range(n):
qc.x(i)
qc.h(i)
return qc
''' |
QPC001_C1 | A22E8FF31DD25 | 1 | AC | 1604 ms | 91 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
i = 0
while (1 << i) < L:
qc.h(i)
i += 1
return qc
''' |
QPC001_C1 | A26CD432DBFF1 | 1 | RE | 1160 ms | 90 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
i=0
while 2**i <= L:
qc.h(i)
i+=1
return qc
''' |
QPC001_C1 | A26CD432DBFF1 | 2 | AC | 2391 ms | 90 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
for i in range(n):
if 2**i <= L:
qc.h(i)
return qc
''' |
QPC001_C1 | A285CD8FDE58D | 1 | TOE | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
k=0
while L>1:
k++
L=L/2
for i in range(k):
qc.h(i)
return qc
''' | ||
QPC001_C1 | A2B62D01D1154 | 1 | AC | 2592 ms | 90 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
i = 0
while 2 ** i < L:
qc.h(i)
i += 1
return qc
''' |
QPC001_C1 | A31322EC432EE | 1 | AC | 2561 ms | 96 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import XGate, ZGate, HGate, RYGate
from math import sqrt, acos, pi
def append_control_gate(qc: QuantumCircuit, gate, target_qubit: int, ctrl_state: int, controlled_qubits)->QuantumCircuit:
if len(controlled_qubits) == 0:
qc.append(gate, [target_qubit])
else:
qc.append(gate.control(len(controlled_qubits), ctrl_state = ctrl_state), controlled_qubits + [target_qubit])
return qc
def solve(n: int, L: int)->QuantumCircuit:
qc = QuantumCircuit(n)
if L == (1 << n):
for i in range(n):
qc.h(i)
return qc
mask = (1 << n) - 1
ctrl_state = 0
controlled_qubits = []
for bit in range(n - 1, -1, -1):
if L >> bit & 1:
left, right = 1 << bit, L - (1 << bit)
theta = acos(sqrt(left) / sqrt(left + right)) * 2
append_control_gate(qc, RYGate(theta), bit, ctrl_state, controlled_qubits)
for bit_next in range(bit - 1, -1, -1):
append_control_gate(qc, HGate(), bit_next, ctrl_state, controlled_qubits + [bit])
L ^= 1 << bit
ctrl_state |= 1 << len(controlled_qubits)
controlled_qubits += [bit]
return qc
''' |
QPC001_C1 | A3675FD3AC86E | 1 | RE | 837 ms | 79 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
theta = 2 * math.acos(math.sqrt(0.5))
for i in range(n):
qc.h(i)
for i in range(n):
for j in range(i+1, n):
qc.cz(i, j)
qc.u1(theta, n-1)
return qc
''' |
QPC001_C1 | A3675FD3AC86E | 2 | WA | 983 ms | 90 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
theta = 2 * math.acos(math.sqrt(0.5))
for i in range(n):
qc.h(i)
for i in range(n):
for j in range(i+1, n):
qc.cz(i, j)
qc.p(theta, n-1)
return qc
''' |
QPC001_C1 | A441909F96BBB | 1 | AC | 2343 ms | 160 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
m = math.ceil(math.log2(L))
for i in range(m):
qc.h(i)
return qc
''' |
QPC001_C1 | A46C24B77CC3E | 1 | RE | 993 ms | 79 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
def lessthan(qc: QuantumCircuit, n: int, L: int):
def xmap(m: int, size: int) -> list[int]:
a = []
idx = 0
while m:
if m % 2:
a.append(idx)
idx += 1
m //= 2
return [i for i in range(size) if i not in a]
for i in range(L, 2**n):
a = xmap(i, n)
if a:
qc.x(a)
if n > 1:
qc.h(0); qc.mcx(list(range(1, n)), 0); qc.h(0)
else:
qc.z(0)
if a:
qc.x(a)
def zmark(qc,n):
for i in range(n):
qc.h(i); qc.x(i)
if n==1:
qc.z(0)
else:
qc.h(0); qc.mcx(list(range(1, n)), 0); qc.h(0)
for i in range(n):
qc.x(i); qc.h(i)
for i in range(n):
qc.h(i)
lessthan(qc, n, L); zmark(qc, n)
lessthan(qc, n, L); zmark(qc, n)
lessthan(qc, n, L); zmark(qc, n)
lessthan(qc, n, L); zmark(qc, n)
return qc
''' |
QPC001_C1 | A46C24B77CC3E | 2 | RE | 904 ms | 79 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
def lessthan(qc: QuantumCircuit, n: int, L: int):
def xmap(m: int, size: int) -> list[int]:
a = []
idx = 0
while m:
if m % 2:
a.append(idx)
idx += 1
m //= 2
return [i for i in range(size) if i not in a]
for i in range(L, 2**n):
a = xmap(i, n)
if a:
qc.x(a)
if n > 1:
qc.h(0); qc.mcx(list(range(1, n)), 0); qc.h(0)
else:
qc.z(0)
if a:
qc.x(a)
def zmark(qc,n):
for i in range(n):
qc.h(i); qc.x(i)
if n==1:
qc.z(0)
else:
qc.h(0); qc.mcx(list(range(1, n)), 0); qc.h(0)
for i in range(n):
qc.x(i); qc.h(i)
for i in range(n):
qc.h(i)
lessthan(qc, n, L); zmark(qc, n)
lessthan(qc, n, L); zmark(qc, n)
lessthan(qc, n, L); zmark(qc, n)
lessthan(qc, n, L); zmark(qc, n)
return qc
''' |
QPC001_C1 | A46C24B77CC3E | 3 | WA | 1138 ms | 94 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
def lessthan(qc: QuantumCircuit, n: int, L: int):
def xmap(m: int, size: int) -> list[int]:
a = []
idx = 0
while m:
if m % 2:
a.append(idx)
idx += 1
m //= 2
return [i for i in range(size) if i not in a]
for i in range(L, 2**n):
a = xmap(i, n)
if a:
qc.x(a)
if n > 1:
qc.h(0); qc.mcx(list(range(1, n)), 0); qc.h(0)
else:
qc.z(0)
if a:
qc.x(a)
def zmark(qc,n):
for i in range(n):
qc.h(i); qc.x(i)
if n==1:
qc.z(0)
else:
qc.h(0); qc.mcx(list(range(1, n)), 0); qc.h(0)
for i in range(n):
qc.x(i); qc.h(i)
for i in range(n):
qc.h(i)
lessthan(qc, n, L); zmark(qc, n)
lessthan(qc, n, L); zmark(qc, n)
lessthan(qc, n, L); zmark(qc, n)
lessthan(qc, n, L); zmark(qc, n)
return qc
''' |
QPC001_C1 | A46C24B77CC3E | 4 | WA | 1120 ms | 94 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
def lessthan(qc: QuantumCircuit, n: int, L: int):
def xmap(m: int, size: int) -> list[int]:
a = []
idx = 0
while m:
if m % 2:
a.append(idx)
idx += 1
m //= 2
return [i for i in range(size) if i not in a]
for i in range(L, 2**n):
a = xmap(i, n)
if a:
qc.x(a)
if n > 1:
qc.h(0); qc.mcx(list(range(1, n)), 0); qc.h(0)
else:
qc.z(0)
if a:
qc.x(a)
def zmark(qc,n):
for i in range(n):
qc.h(i); qc.x(i)
if n==1:
qc.z(0)
else:
qc.h(0); qc.mcx(list(range(1, n)), 0); qc.h(0)
for i in range(n):
qc.x(i); qc.h(i)
for i in range(n):
qc.h(i)
lessthan(qc, n, L); zmark(qc, n)
lessthan(qc, n, L); zmark(qc, n)
lessthan(qc, n, L); zmark(qc, n)
lessthan(qc, n, L); zmark(qc, n)
lessthan(qc, n, L); zmark(qc, n)
lessthan(qc, n, L); zmark(qc, n)
lessthan(qc, n, L); zmark(qc, n)
lessthan(qc, n, L); zmark(qc, n)
return qc
''' |
QPC001_C1 | A46C24B77CC3E | 5 | AC | 3000 ms | 92 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
def xmap(m: int) -> list[int]:
a = []
idx = 0
while m:
if m % 2:
a.append(idx)
idx += 1
m //= 2
return a
if L == 0:
return qc
regs = list(range(0, min(n, xmap(L)[-1]+1)))
if regs:
qc.h(regs)
return qc
''' |
QPC001_C1 | A4809422A3E4B | 1 | RE | 832 ms | 79 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
i = 0
while (l+1 > 2**i):
i += 1
for j in range(i):
qc.h(j)
return qc
''' |
QPC001_C1 | A4809422A3E4B | 2 | RE | 1193 ms | 90 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
i = 0
while (L+1 > 2**i):
i += 1
for j in range(i):
qc.h(j)
return qc
''' |
QPC001_C1 | A4809422A3E4B | 3 | AC | 2251 ms | 91 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc = QuantumCircuit(n)
i = 0
while (L > 2**i):
i += 1
for j in range(i):
qc.h(j)
return qc
''' |
QPC001_C1 | A4964A8FAE6C2 | 1 | AC | 2557 ms | 91 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
L_keta = 1
for i in range(n):
if 2**i <= L:
L_keta = i+1
for i in range(L_keta):
qc.h(i)
return qc
''' |
QPC001_C1 | A4A7E21F2F230 | 1 | RE | 1139 ms | 79 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.h(range(math.ceil(math.log2(L))))
return qc
''' |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.