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_C1 | A4A7E21F2F230 | 2 | RE | 1155 ms | 90 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
import math
qc.h(range(math.ceil(math.log2(L))))
return qc
''' |
QPC001_C1 | A4A7E21F2F230 | 3 | RE | 758 ms | 79 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
import math
m=math.ceil(math.log2(L))
qc.h(range(m))
return qc
''' |
QPC001_C1 | A4A7E21F2F230 | 4 | AC | 1776 ms | 92 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
import math
m=math.ceil(math.log2(L))
qc.h(range(m))
return qc
''' |
QPC001_C1 | A4AA855286D55 | 1 | AC | 1479 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
if L == 1: return qc
k = 1
while 1 << k < L: k += 1
for i in range(k): qc.h(i)
return qc
''' |
QPC001_C1 | A4F1301407711 | 1 | AC | 1799 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)
for i in range(n):
if L > (1 << i):
qc.h(i)
return qc
''' |
QPC001_C1 | A52D7E6ECC137 | 1 | RE | 1134 ms | 90 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
eff_n = int(math.log2(L)) + 1
qc.h(0)
for i in range(eff_n - 1):
qc.cx(i, i + 1)
return qc
''' |
QPC001_C1 | A52D7E6ECC137 | 2 | RE | 1053 ms | 90 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
eff_n = int(math.log2(L - 1)) + 1
print(eff_n)
qc.h(0)
for i in range(eff_n - 1):
qc.cx(i, i + 1)
return qc
''' |
QPC001_C1 | A52D7E6ECC137 | 3 | RE | 985 ms | 90 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
eff_n = int(math.log2(L - 1)) + 1
for i in range(eff_n):
qc.h(i)
return qc
''' |
QPC001_C1 | A52D7E6ECC137 | 4 | AC | 1732 ms | 90 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
eff_n = int(math.log2(L - 1)) + 1 if L > 1 else 0
for i in range(eff_n):
qc.h(i)
return qc
''' |
QPC001_C1 | A5679677B5C6A | 1 | RE | 1616 ms | 141 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(L.bit_length()):
qc.h(i)
return qc
''' |
QPC001_C1 | A5679677B5C6A | 2 | RE | 1399 ms | 141 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(str(L).bit_length()):
qc.h(i)
return qc
''' |
QPC001_C1 | A5679677B5C6A | 3 | AC | 1557 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(L.bit_length()-int(2**n==L)):
qc.h(i)
return qc
''' |
QPC001_C1 | A5686D4D93196 | 1 | RE | 954 ms | 90 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
l=L-1
k=0
while l>0:
for i in range(n-1-k,-1,-1):
if 1<<i > l:
continue
if 1<<i <=l and 1<<(i+1)>l:
print(1<<(i))
qc.u(-math.acos(math.sqrt((1<<i))/math.sqrt(l+1))*2,math.pi,0,i)
qc.x(i)
c3h_gate = HGate().control(1)
for j in range(0,i):
qc.append(c3h_gate,[i,j])
qc.x(i)
k+=1
l=l-(1<<i) # 最上位ビット削除
return qc
''' |
QPC001_C1 | A5686D4D93196 | 2 | RE | 1439 ms | 91 MiB | '''python
from qiskit import QuantumCircuit
import math
from qiskit.circuit.library import HGate, U3Gate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
l=L-1
k=0
while l>0:
maxi=0
for i in range(n-1-k,-1,-1):
if 1<<i > l:
continue
if 1<<i <=l and 1<<(i+1)>l:
maxi=max(maxi,i)
print(1<<(i))
# if i>0:
l2=L-1
for k1 in range(n-1,i,-1):
if not (1<<k1)&l2:
qc.x(k1)
clist=list(range(n-1,i,-1))+[i]
cu3_gate = U3Gate(-math.acos(math.sqrt((1<<i))/math.sqrt(l+1))*2,math.pi,0).control(len(clist)-1)
print(clist)
qc.append(cu3_gate,clist)
l2=L-1
for k1 in range(n-1,i,-1):
if not (1<<k1)&l2:
qc.x(k1)
qc.x(i)
for j in range(n-1,maxi,-1):
qc.x(j)
for j in range(0,i):
clist=list(range(n-1,i-1,-1))+[j]
c3h_gate = HGate().control(len(clist)-1)
print(clist)
qc.append(c3h_gate,clist)
qc.x(i)
for j in range(n-1,maxi,-1):
qc.x(j)
k+=1
l=l-(1<<i) # 最上位ビット削除
return qc
''' |
QPC001_C1 | A586E2A50EDE7 | 1 | RE | 2880 ms | 157 MiB | '''python
from qiskit import QuantumCircuit
from numpy import sqrt, log2, ceil
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Determine the required number of qubits
num_states = min(L, 2**n) # Ensure L does not exceed the total number of states
# Apply Hadamard gates on a subset of qubits to create a superposition
num_qubits_needed = ceil(log2(num_states))
for i in range(num_qubits_needed):
qc.h(i)
# Use a barrier for visualization (optional)
qc.barrier()
# If L is not a power of 2, we need to adjust the probability amplitudes
if num_states != 2**num_qubits_needed:
probability_threshold = num_states / 2**num_qubits_needed
qc.ry(2 * sqrt(probability_threshold), num_qubits_needed - 1)
return qc
''' |
QPC001_C1 | A586E2A50EDE7 | 2 | UGE | 1559 ms | 158 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# The total Hilbert space has dimension 2^n.
dim = 2 ** n
# Create a state vector of length 2^n.
# For i in 0 to L-1, set the amplitude to 1/sqrt(L), and leave all other amplitudes as 0.
state = [0] * dim
amplitude = 1 / math.sqrt(L)
for i in range(L):
state[i] = amplitude
# Use Qiskit's initialize() method.
# Passing list(range(n)) makes sure the state vector is interpreted in little-endian order.
qc.initialize(state, list(range(n)))
return qc
''' |
QPC001_C1 | A586E2A50EDE7 | 3 | TLE | 3000 ms | 163 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Given a k–bit prefix (interpreted in big–endian order),
# count how many numbers in {0,1,...,L-1} have that prefix.
def count(prefix: int, k: int, L: int, n: int) -> int:
# The k–bit prefix p (an integer in 0,...,2^k-1)
# corresponds to all numbers in the interval:
# [ p * 2^(n-k), (p+1)*2^(n-k) - 1 ]
low = prefix * (2 ** (n - k))
# high = (prefix+1)*2^(n-k) - 1 (not needed explicitly)
if L <= low:
return 0
return min(2 ** (n - k), L - low)
# Recursively “build” the uniformly controlled rotations.
# Here, k is the number of bits already fixed.
# (We work in “logical” qubit order – that is, logical qubit 0 is the most–significant bit.
# Later we note that physical qubit (n-1) will play the role of logical qubit 0,
# physical qubit (n-2) that of logical qubit 1, etc. This exactly produces little–endian encoding.)
def prepare(prefix: int, k: int):
if k == n:
return # all bits fixed
f_prefix = count(prefix, k, L, n)
if f_prefix == 0:
return # no amplitude flows down this branch
# Compute counts for the two branches:
f0 = count(prefix * 2, k + 1, L, n)
f1 = count(prefix * 2 + 1, k + 1, L, n)
# The desired rotation should “split” the amplitude so that the |0⟩ branch gets weight f0/f_prefix.
# In other words, choose theta so that:
# cos(theta/2) = sqrt(f0/f_prefix)
theta = 2 * math.acos(math.sqrt(f0 / f_prefix))
# The target qubit for level k is logical qubit k, which we now map to physical qubit (n-1-k)
target = n - 1 - k
if k == 0:
# No control needed on the very first rotation.
qc.ry(theta, target)
else:
# Controls come from the previously fixed (logical) qubits.
# (They are mapped to physical qubits: logical j -> physical (n-1-j).)
controls = [n - 1 - j for j in range(k)]
# Because Qiskit’s controlled–rotation (cry/mcry) gates control on |1⟩,
# we “flip” any control qubit whose bit in our prefix is 0.
for j in range(k):
bit = (prefix >> (k - 1 - j)) & 1 # extract the jth bit (with j=0 = most–significant)
if bit == 0:
qc.x(n - 1 - j)
if k == 1:
qc.cry(theta, controls[0], target)
else:
qc.mcry(theta, controls, target, None, mode='noancilla')
for j in range(k):
bit = (prefix >> (k - 1 - j)) & 1
if bit == 0:
qc.x(n - 1 - j)
# Recurse to “prepare” the next bits in both branches.
prepare(prefix * 2, k + 1)
prepare(prefix * 2 + 1, k + 1)
# Begin with an empty prefix.
prepare(0, 0)
return qc
''' |
QPC001_C1 | A586E2A50EDE7 | 4 | AC | 2938 ms | 163 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# For L == 1, the initial state |0...0> already meets the requirement.
if L == 1:
return qc
# Determine the smallest k such that 2^k >= L.
k = math.ceil(math.log2(L))
# Apply Hadamard to the first k qubits.
qc.h(range(k))
return qc
''' |
QPC001_C1 | A59B44D998810 | 1 | RE | 1090 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(int.bit_length(L)):
qc.h(i)
return qc
''' |
QPC001_C1 | A59B44D998810 | 2 | AC | 2319 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(int.bit_length(L-1)):
qc.h(i)
return qc
''' |
QPC001_C1 | A59BE1905D54A | 1 | WA | 2129 ms | 162 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import HGate, RYGate
import math
def add_rule(qc: QuantumCircuit, n: int, suffix: list[int], Lpre: int) -> None:
k = len(suffix)
split_idx = n - k - 1
#print(f"Lpre={Lpre}, split_idx={split_idx}")
num = 1 << split_idx
denom = Lpre
#print(f"{num}/{denom}")
theta = math.acos(math.sqrt(num/denom)) * 2
if k > 0:
idx = n - 1
for bit in suffix:
if bit == 0:
qc.x(idx)
idx -= 1
#print("ry", k, range(split_idx + 1, n))
qc.append(RYGate(theta).control(k), list(range(split_idx + 1, n)) + [split_idx])
idx = n - 1
for bit in suffix:
if bit == 0:
qc.x(idx)
idx -= 1
else:
qc.ry(theta, n - 1)
#print(suffix)
for i in range(0, split_idx):
idx = n - 1
for bit in suffix + [0]:
if bit == 0:
qc.x(idx)
idx -= 1
size = k + 1
qubits = list(range(split_idx, n)) + [i]
#print(size, qubits)
qc.append(HGate().control(size), qubits)
idx = n - 1
for bit in suffix + [0]:
if bit == 0:
qc.x(idx)
idx -= 1
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
if L == (1 << n):
for i in range(n):
qc.h(i)
return qc
cnt = 0
suffix = []
Lpre = L
for i in range(n - 1, -1, -1):
if L & (1 << i):
add_rule(qc, n, suffix, Lpre)
if cnt == 1:
break
Lpre -= (1 << i)
suffix.append(1)
else:
suffix.append(0)
cnt += 1
return qc
''' |
QPC001_C1 | A59BE1905D54A | 2 | AC | 2839 ms | 166 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import HGate, RYGate
import math
def add_rule(qc: QuantumCircuit, n: int, suffix: list[int], Lpre: int) -> None:
k = len(suffix)
split_idx = n - k - 1
#print(f"Lpre={Lpre}, split_idx={split_idx}")
num = 1 << split_idx
denom = Lpre
#print(f"{num}/{denom}")
theta = math.acos(math.sqrt(num/denom)) * 2
if k > 0:
idx = n - 1
for bit in suffix:
if bit == 0:
qc.x(idx)
idx -= 1
#print("ry", k, range(split_idx + 1, n))
qc.append(RYGate(theta).control(k), list(range(split_idx + 1, n)) + [split_idx])
idx = n - 1
for bit in suffix:
if bit == 0:
qc.x(idx)
idx -= 1
else:
qc.ry(theta, n - 1)
#print(suffix)
for i in range(0, split_idx):
idx = n - 1
for bit in suffix + [0]:
if bit == 0:
qc.x(idx)
idx -= 1
size = k + 1
qubits = list(range(split_idx, n)) + [i]
#print(size, qubits)
qc.append(HGate().control(size), qubits)
idx = n - 1
for bit in suffix + [0]:
if bit == 0:
qc.x(idx)
idx -= 1
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
if L == (1 << n):
for i in range(n):
qc.h(i)
return qc
cnt = 0
suffix = []
Lpre = L
for i in range(n - 1, -1, -1):
if L & (1 << i):
add_rule(qc, n, suffix, Lpre)
Lpre -= (1 << i)
suffix.append(1)
else:
suffix.append(0)
cnt += 1
return qc
''' |
QPC001_C1 | A5B8DFCC2E275 | 1 | RE | 947 ms | 79 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(1, n + 1):
if L <= 2 ** i:
last = i
break
prob_amp = math.sqrt(2 ** (last - 1) / L)
rot_ang = 2 * math.acos(prob_amp)
qc.ry(rot_ang, last)
for i in range(last):
qc.h(i)
return qc
''' |
QPC001_C1 | A5B8DFCC2E275 | 2 | RE | 863 ms | 79 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(1, n + 1):
if L <= 2 ** i:
last = i
break
prob_amp = math.sqrt((L - 2 ** (last - 1)) / L)
rot_ang = 2 * math.acos(prob_amp)
qc.ry(rot_ang, last)
for i in range(last):
qc.h(i)
return qc
''' |
QPC001_C1 | A5B8DFCC2E275 | 3 | RE | 972 ms | 79 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(1, n + 1):
if L <= 2 ** i:
last = i
break
prob_amp = math.sqrt((L -2 ** (last - 1)) / L)
rot_ang = 2 * math.acos(prob_amp)
qc.ry(rot_ang, last)
for i in range(last):
qc.h(i)
return qc
''' |
QPC001_C1 | A5B8DFCC2E275 | 4 | WA | 1029 ms | 90 MiB | '''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(1, n + 1):
if L <= 2 ** i:
last = i
break
prob_amp = math.sqrt((L -2 ** (last - 1)) / L)
rot_ang = 2 * math.acos(prob_amp)
qc.ry(rot_ang, last - 1)
for i in range(last - 1):
qc.h(i)
return qc
''' |
QPC001_C1 | A5BA3B5EE1491 | 1 | RE | 1824 ms | 162 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
bits = 0
while L:
L >>= 1
bits += 1
for i in range(bits):
qc.h(i)
return qc
''' |
QPC001_C1 | A5BA3B5EE1491 | 2 | AC | 2537 ms | 163 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
L -= 1
bits = 0
while L:
L >>= 1
bits += 1
for i in range(bits):
qc.h(i)
return qc
''' |
QPC001_C1 | A5DC4DE6A934C | 1 | WA | 1902 ms | 151 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
a = 0
for i in range(n):
if L <= (1<<i):
a = i
for i in range(a):
qc.h(i)
return qc
''' |
QPC001_C1 | A5DC4DE6A934C | 2 | WA | 1731 ms | 151 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
a = 0
for i in range(n):
if L <= (1<<i):
a = i+1
break
for i in range(a):
qc.h(i)
return qc
''' |
QPC001_C1 | A5DC4DE6A934C | 3 | WA | 2021 ms | 151 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
a = 0
for i in range(n):
if L <= (1<<i):
a = i
break
for i in range(a):
qc.h(i)
return qc
''' |
QPC001_C1 | A5DC4DE6A934C | 4 | WA | 1660 ms | 151 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
a = 0
for i in range(n):
if L-1 <= (1<<i):
a = i+1
break
for i in range(a):
qc.h(i)
return qc
''' |
QPC001_C1 | A5DC4DE6A934C | 5 | AC | 2575 ms | 152 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
a = 0
for i in range(n+1):
if L <= (1<<i):
a = i
break
for i in range(a):
qc.h(i)
return qc
''' |
QPC001_C1 | A5F2AFBDD89E6 | 1 | TLE | 3000 ms | 145 MiB | '''python
import math
from qiskit import QuantumCircuit
import qiskit.circuit.library as qis
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
L -= 1
bits = []
ones = []
for i in range(n-1, -1, -1):
if L & (1<<i) != 0:
bits += [(i, len(ones), 1)]
ones += [i]
else:
bits += [(i, len(ones), 0)]
for target, up_to_i_controls, bit in bits:
for lsb_ctrl_i in range(up_to_i_controls, 0, -1):
ctrl_subset = ones[0:lsb_ctrl_i]
ctrl_state = (1<< (lsb_ctrl_i - 1)) - 1
gate = qis.HGate().control(num_ctrl_qubits=len(ctrl_subset), ctrl_state=ctrl_state)
qc.append(gate, ctrl_subset + [target])
if bit == 1:
controls = ones[0:up_to_i_controls]
left = 1<<target
right = (L % left) + 1
wanted_cos = (left/(left + right))**0.5
theta = math.acos(wanted_cos)*2
gate = qis.RXGate(theta=theta)
if len(controls) != 0:
gate = gate.control(num_ctrl_qubits=len(controls))
qc.append(gate, controls + [target])
return qc
''' |
QPC001_C1 | A5F2AFBDD89E6 | 2 | TLE | 3000 ms | 145 MiB | '''python
import math
from qiskit import QuantumCircuit
import qiskit.circuit.library as qis
import numpy as np
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
L -= 1
ones = []
one_count = 0
inds = np.arange(n)
lefts = np.vectorize(lambda x: 1<<x)(inds)
wanted_coss = np.vectorize(lambda left: (left / (left + ((L%left) + 1))) ** 0.5)(lefts)
thetas = np.vectorize(lambda w: math.acos(w) * 2)(wanted_coss)
for target in range(n-1, -1, -1):
bit = L & (1<<target) != 0
for lsb_ctrl_i in range(len(ones), 0, -1):
ctrl_subset = ones[0:lsb_ctrl_i]
ctrl_state = (1<< (lsb_ctrl_i - 1)) - 1
gate = qis.HGate().control(num_ctrl_qubits=len(ctrl_subset), ctrl_state=ctrl_state)
qc.append(gate, ctrl_subset + [target], copy=False)
if bit == 1:
theta = thetas[target]
gate = qis.RXGate(theta=theta)
if one_count != 0:
gate = gate.control(num_ctrl_qubits=one_count)
qc.append(gate, ones + [target], copy=False)
ones.append(target)
one_count += 1
return qc
''' |
QPC001_C1 | A60A8FA16A1A0 | 1 | AC | 1702 ms | 151 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
k = math.ceil(math.log2(L))
qc.h(range(k))
return qc
''' |
QPC001_C1 | A63B2B76C8CCE | 1 | AC | 2376 ms | 93 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
k = 0
while True:
qc.h(k)
k += 1
if (1<<k) >= L:
break
return qc
''' |
QPC001_C1 | A653A72392169 | 1 | RE | 959 ms | 79 MiB | '''python
from qiskit import QuantumCircuit
import qiskit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
str_int = str(bin(L)).replace('0b', '')
for i in range(n)[::-1]:
if str_int[i] == '1':
cx = qiskit.circuit.library.standard_gates.ZGate().control(n-i)
for j in range(i):
qc.append(cx, list(range(i, n)[::-1]) + [j],)
return qc
''' |
QPC001_C1 | A6567F0EB4DF5 | 1 | RE | 897 ms | 79 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
while L * 2 <= n
n //= 2
for i in range(n):
qc.h(i)
return qc
''' |
QPC001_C1 | A6567F0EB4DF5 | 2 | WA | 1087 ms | 90 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
while L * 2 <= n:
n //= 2
for i in range(n):
qc.h(i)
return qc
''' |
QPC001_C1 | A6567F0EB4DF5 | 3 | RE | 1004 ms | 79 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
m = 0, mk = 1
while mk < L:
m += 1
mk *= 2
for i in range(m):
qc.h(i)
return qc
''' |
QPC001_C1 | A6567F0EB4DF5 | 4 | AC | 2165 ms | 92 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
m = 0
mk = 1
while mk < L:
m += 1
mk *= 2
for i in range(m):
qc.h(i)
return qc
''' |
QPC001_C1 | A6645C8455E68 | 1 | AC | 2319 ms | 91 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
a = n
for i in range(n):
if L <= 2**i:
a = i
break
for i in range(a):
qc.h(i)
return qc
''' |
QPC001_C1 | A66A621698CDE | 1 | RE | 781 ms | 78 MiB | '''python
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
l = L
for i in range(n - 1):
mid = 2 ** (n - 1 - i)
if l >= mid:
theta = 2 * math.acos(math.sqrt(mid / l))
qc.ry(theta, n - 1 - i)
l -= mid
return qc
''' |
QPC001_C1 | A66A621698CDE | 2 | RE | 844 ms | 90 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
l = L
for i in range(n - 1):
mid = 2 ** (n - 1 - i)
if l >= mid:
theta = 2 * math.acos(math.sqrt(mid / l))
qc.ry(theta, n - 1 - i)
l -= mid
return qc
''' |
QPC001_C1 | A66A621698CDE | 3 | WA | 1029 ms | 91 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
qr = qc.qregs[0]
# Write your code here:
if n == 1:
if L == 1:
pass
else:
assert L == 2
qc.h(0)
return qc.decompose()
mid = 2 ** (n - 1)
if L <= mid:
c = solve(n - 1, L)
qc.x(n - 1)
qc.append(c.control(1).decompose(), [qr[-1]] + qr[:-1])
qc.x(n - 1)
return qc.decompose()
theta = 2 * math.acos(math.sqrt(mid / L))
qc.ry(theta, n - 1)
for i in range(n - 1):
qc.x(i)
qc.cx(n - 1, i)
qc.x(i)
c = solve(n - 1, L - mid)
qc.append(c.control(1).decompose(), [qr[-1]] + qr[:-1])
return qc.decompose()
''' |
QPC001_C1 | A66A621698CDE | 4 | WA | 877 ms | 90 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
qr = qc.qregs[0]
# Write your code here:
if n == 1:
if L == 1:
pass
else:
assert L == 2
qc.h(0)
return qc.decompose()
mid = 2 ** (n - 1)
if L <= mid:
c = solve(n - 1, L)
qc.x(n - 1)
qc.append(c.control(1).decompose(), qr)
qc.x(n - 1)
return qc.decompose()
theta = 2 * math.acos(math.sqrt(mid / L))
qc.ry(theta, n - 1)
for i in range(n - 1):
qc.x(i)
qc.cx(n - 1, i)
qc.x(i)
c = solve(n - 1, L - mid)
qc.append(c.control(1).decompose(), qr)
return qc.decompose()
''' |
QPC001_C1 | A66A621698CDE | 5 | UME | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
qr = qc.qregs[0]
# Write your code here:
if n == 1:
if L == 1:
pass
else:
assert L == 2
qc.h(0)
return qc.decompose()
mid = 2 ** (n - 1)
if L <= mid:
c = solve(n - 1, L)
qc.x(n - 1)
qc.append(c.control(1).decompose(), [qr[-1]] + qr[:-1])
qc.x(n - 1)
return qc.decompose()
theta = 2 * math.acos(math.sqrt(mid / L))
qc.ry(theta, n - 1)
qc.x(n - 1)
for i in range(n - 1):
qc.cx(n - 1, i)
qc.x(n - 1)
c = solve(n - 1, L - mid)
qc.append(c.control(1).decompose(), [qr[-1]] + qr[:-1])
return qc.decompose()
import qiskit_aer
def run(circuit):
sim = qiskit_aer.AerSimulator()
c = circuit.copy()
c.save_statevector()
return sim.run(c, shots=1).result()
if __name__ == "__main__":
n = 2
L = 1
c = solve(n, L)
print(c)
r = run(c)
print(r)
''' | ||
QPC001_C1 | A66A621698CDE | 6 | WA | 889 ms | 90 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
qr = qc.qregs[0]
# Write your code here:
if n == 1:
if L == 1:
pass
else:
assert L == 2
qc.h(0)
return qc.decompose()
mid = 2 ** (n - 1)
if L <= mid:
c = solve(n - 1, L)
qc.x(n - 1)
qc.append(c.control(1).decompose(), [qr[-1]] + qr[:-1])
qc.x(n - 1)
return qc.decompose()
theta = 2 * math.acos(math.sqrt(mid / L))
qc.ry(theta, n - 1)
qc.x(n - 1)
for i in range(n - 1):
qc.cx(n - 1, i)
qc.x(n - 1)
c = solve(n - 1, L - mid)
qc.append(c.control(1).decompose(), [qr[-1]] + qr[:-1])
return qc.decompose()
''' |
QPC001_C1 | A66A621698CDE | 7 | TLE | 3000 ms | 108 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
qr = qc.qregs[0]
# Write your code here:
if n == 1:
if L == 1:
pass
else:
assert L == 2
qc.h(0)
return qc.decompose()
mid = 2 ** (n - 1)
if L <= mid:
c = solve(n - 1, L)
qc.x(n - 1)
qc.append(c.control(1).decompose(), [qr[-1]] + qr[:-1])
qc.x(n - 1)
return qc.decompose()
theta = 2 * math.acos(math.sqrt(mid / L))
qc.ry(theta, n - 1)
qc.x(n - 1)
for i in range(n - 1):
qc.ch(n - 1, i)
qc.x(n - 1)
c = solve(n - 1, L - mid)
qc.append(c.control(1).decompose(), [qr[-1]] + qr[:-1])
return qc.decompose()
''' |
QPC001_C1 | A66A621698CDE | 8 | RE | 783 ms | 79 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
qr = qc.qregs[0]
# Write your code here:
if n == 1:
if L == 1:
pass
else:
assert L == 2
qc.h(0)
return qc
mid = 2 ** (n - 1)
if L <= mid:
c = solve(n - 1, L)
qc.x(n - 1)
qc.append(c.control(1), [qr[-1]] + qr[:-1])
qc.x(n - 1)
return qc
theta = 2 * math.acos(math.sqrt(mid / L))
qc.ry(theta, n - 1)
qc.x(n - 1)
for i in range(n - 1):
qc.ch(n - 1, i)
qc.x(n - 1)
c = solve(n - 1, L - mid)
qc.append(c.control(1), [qr[-1]] + qr[:-1])
return qc
''' |
QPC001_C1 | A6E65C67C03BA | 1 | AC | 2636 ms | 160 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 | A6E827E1D6477 | 1 | RE | 804 ms | 78 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
# ランダムに複素振幅を設定
alphas = np.random.rand(2**n) + 1j * np.random.rand(2**n)
# 複素振幅を正規化
norm = np.linalg.norm(alphas)
normalized_alphas = alphas / norm
# 正規化された複素振幅を量子回路にセット
qc.initialize(normalized_alphas, range(n))
return qc
''' |
QPC001_C1 | A6F08C80DB43A | 1 | AC | 3000 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):
if 2**i < L:
qc.h(i)
return qc
''' |
QPC001_C1 | A72888A0C066C | 1 | WA | 1562 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
return qc
''' |
QPC001_C1 | A72888A0C066C | 2 | WA | 1666 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
return qc
''' |
QPC001_C1 | A77D220D22982 | 1 | RE | 966 ms | 79 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# 各状態の振幅を等しくするため、量子回路にHゲートを適用します（必要なビット数分だけ）
for i in range(math.ceil(math.log(L, 2))):
qc.h(i)
# 末尾に余分な状態が含まれないようにする
# ここではビットが少ないケースが考慮されているが、一般的な解決方法が必要です。
if L != 2 ** n:
# 未使用のビット位置を計算する
unused_bits = n - math.ceil(math.log(L, 2))
# 制御リセットゲートを未使用のビット位置に適用して、余分な状態をリセットする
for l in range(L, 2 ** n):
binary_state = bin(l)[2:].zfill(n)
controls = [ii for ii, bb in enumerate(reversed(binary_state)) if bb == '1']
if controls:
qc.x(controls)
qc.mct(controls, list(range(math.ceil(math.log(L, 2)), n)), None, mode='noancilla')
if controls:
qc.x(controls)
return qc
# トレースを除去してコードを実行するためのテスト
if __name__ == "__main__":
n = 3
L = 3
qc = solve(n, L)
print(qc)
''' |
QPC001_C1 | A77D220D22982 | 2 | AC | 1656 ms | 90 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# 各状態の振幅を等しくするため、量子回路にHゲートを適用します（必要なビット数分だけ）
for i in range(math.ceil(math.log(L, 2))):
qc.h(i)
return qc
''' |
QPC001_C1 | A7D7437CA8BD0 | 1 | AC | 2053 ms | 92 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
if L == 1:
return qc
k = math.ceil(math.log2(L))
qc.h(range(k))
return qc
''' |
QPC001_C1 | A7FAE44274EF1 | 1 | UGE | 787 ms | 78 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
amplitudes = [2 / (2 ** n) for _ in range(2 ** n - 1)]
amplitudes.append(1 - sum(amplitudes))
# 振幅を使用して状態を作成
qc.initialize(amplitudes, list(range(n)))
return qc
''' |
QPC001_C1 | A80985514564C | 1 | RE | 1399 ms | 153 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
k = math.ceil(math.log2(L))
qc.h(range(L))
return qc
''' |
QPC001_C1 | A80985514564C | 2 | AC | 1914 ms | 156 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
k = math.ceil(math.log2(L))
qc.h(range(k))
return qc
''' |
QPC001_C1 | A8ABA8888F884 | 1 | RE | 787 ms | 78 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
k = math.ceil(math.log2(L))
qc.h(range(k))
return qc
''' |
QPC001_C1 | A8ABA8888F884 | 2 | RE | 965 ms | 90 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
k = math.ceil(math.log2(L))
qc.h(range(k))
return qc
''' |
QPC001_C1 | A8ABA8888F884 | 3 | AC | 2078 ms | 92 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
k = math.ceil(math.log2(L))
qc.h(range(k))
return qc
''' |
QPC001_C1 | A8CC9A2757458 | 1 | AC | 1582 ms | 92 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import XGate
from qiskit.circuit.library import ZGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
p=1
qc.h(0)
while((1<<p)<L):
qc.h(p)
p+=1
return qc
''' |
QPC001_C1 | A9325C94F105F | 1 | RE | 971 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(len(bin(L))-2):
qc.h(i)
return qc
''' |
QPC001_C1 | A9325C94F105F | 2 | AC | 2765 ms | 93 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
if L == (1<<n):
for i in range(n):
qc.h(i)
else:
for i in range(len(bin(L))-2):
qc.h(i)
return qc
''' |
QPC001_C1 | A947D54F2E79D | 1 | RE | 979 ms | 90 MiB | '''python
from qiskit import QuantumCircuit
from math import ceil,log2
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
ceilL = ceil(log2(L))
qc.h(range(ceilL))
return qc
''' |
QPC001_C1 | A947D54F2E79D | 2 | AC | 2000 ms | 93 MiB | '''python
from qiskit import QuantumCircuit
from math import ceil,log2
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
ceilL = ceil(log2(L))
if ceilL != 0:
qc.h(range(ceilL))
return qc
''' |
QPC001_C1 | A955EB597174E | 1 | RE | 2119 ms | 156 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import RYGate
import math
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
th = 2 * math.atan(math.sqrt(L-1))
qc.ry(th, 0)
for i in range(L-1):
qc.append(RYGate(th).control(1), i, i + 1)
qc.cx(i + 1, i)
return qc
''' |
QPC001_C1 | A955EB597174E | 2 | RE | 1895 ms | 156 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
th = 2 * math.atan(math.sqrt(L-1))
qc.ry(th, 0)
for i in range(L-1):
th = 2 * math.atan(math.sqrt(L - i - 2))
qc.cry(th, i, i + 1)
qc.cx(i + 1, i)
return qc
''' |
QPC001_C1 | A955EB597174E | 3 | RE | 1742 ms | 156 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
th = 2 * math.atan(math.sqrt(L-1))
L = L - 1
qc.ry(th, 0)
for i in range(L-1):
th = 2 * math.atan(math.sqrt(L - i - 2))
qc.cry(th, i, i + 1)
qc.cx(i + 1, i)
return qc
''' |
QPC001_C1 | A955EB597174E | 4 | RE | 1710 ms | 156 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
th = 2 * math.atan(math.sqrt(L-1))
qc.ry(th, 0)
for i in range(L-1):
th = 2 * math.atan(math.sqrt(L - i - 2))
qc.cry(th, i, i + 1)
qc.cx(i + 1, i)
return qc
''' |
QPC001_C1 | A955EB597174E | 5 | AC | 2395 ms | 160 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 | A97CF304D2887 | 1 | WA | 1017 ms | 91 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import RYGate, HGate
import math
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
target_L = 0
x_lst = []
for digit in range(n):
target_R = target_L + (1 << (n - digit - 1))
if L > target_R:
theta = math.asin(math.sqrt((L - target_R) / (L - target_L))) * 2
if(digit == 0):
qc.ry(theta, n-1)
else:
for i in x_lst: qc.x(i)
qc.append(RYGate(theta).control(digit), range(n - digit - 1, n)[::-1])
for i in x_lst: qc.x(i)
target_L += (1 << (n - digit - 1))
else:
x_lst.append(n - digit - 1)
return qc
''' |
QPC001_C1 | A97CF304D2887 | 2 | AC | 2602 ms | 99 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import RYGate, HGate
import math
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
if L == (1 << n):
for i in range(n):
qc.h(i)
return qc
target_L = 0
x_lst = []
for digit in range(n):
target_R = target_L + (1 << (n - digit - 1))
if L > target_R:
theta = math.asin(math.sqrt((L - target_R) / (L - target_L))) * 2
if(digit == 0):
qc.ry(theta, n-1)
else:
for i in x_lst: qc.x(i)
qc.append(RYGate(theta).control(digit), range(n - digit - 1, n)[::-1])
for i in x_lst: qc.x(i)
for i in x_lst: qc.x(i)
qc.x(n - digit - 1)
for i in range(n - digit - 1):
qc.append(HGate().control(digit + 1), list(range(n - digit - 1, n)) + [i])
for i in x_lst: qc.x(i)
qc.x(n - digit - 1)
target_L += (1 << (n - digit - 1))
else:
x_lst.append(n - digit - 1)
return qc
''' |
QPC001_C1 | A99B88D483935 | 1 | WA | 1029 ms | 90 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
qc.h(i)
half = n // 2
i = 0
while half > 0:
if L > half:
break
qc.h(i)
i += 1
half //= 2
return qc
''' |
QPC001_C1 | A99B88D483935 | 2 | WA | 1062 ms | 92 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
qc.h(i)
half = 2**n // 2
i = 0
while half > 0:
if L > half:
break
qc.h(i)
i += 1
half //= 2
return qc
print(solve(3, 3))
''' |
QPC001_C1 | A99B88D483935 | 3 | WA | 1034 ms | 93 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for i in range(n):
qc.h(i)
m = 2**n
i = 0
while m > 0:
if L * 2 > m:
break
qc.h(i)
i += 1
m //= 2
return qc
print(solve(3, 3))
''' |
QPC001_C1 | A99B88D483935 | 4 | WA | 1007 ms | 92 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
m = 1
i = n - 1
while m < L:
qc.h(i)
m *= 2
i -= 1
return qc
n = 3
for l in range(1, 2**n + 1):
print(solve(n, l))
''' |
QPC001_C1 | A99B88D483935 | 5 | AC | 2199 ms | 93 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
m = 1
i = 0
while m < L:
qc.h(i)
m *= 2
i += 1
return qc
n = 3
for l in range(1, 2**n + 1):
print(solve(n, l))
''' |
QPC001_C1 | A9AAD72E23849 | 1 | AC | 1610 ms | 142 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
k = math.ceil(math.log2(L))
for i in range(k):
qc.h(i)
return qc
''' |
QPC001_C1 | A9C8EC2C5D45C | 1 | RE | 3000 ms | 154 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
left_coeff = math.sqrt(0.6/L)
right_coeff = math.sqrt(0.4/(2**n-L))
coeffs = [left_coeff]*L + [right_coeff]*(2**n-L)
qc.initialize(coeffs, list(range(n)))
return qc.decompose(reps=5)
''' |
QPC001_C1 | A9C8EC2C5D45C | 2 | RE | 2584 ms | 150 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
left_coeff = math.sqrt(0.6/L)
right_coeff = math.sqrt(0.4/(2**n-L))
coeffs = [left_coeff]*L + [right_coeff]*(2**n-L)
qc.initialize(coeffs, list(range(n)))
return qc.decompose(reps=10)
''' |
QPC001_C1 | A9C8EC2C5D45C | 3 | AC | 1582 ms | 141 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
th = 0
while True:
if 2**th >= L:
break
else:
th += 1
qc.h(range(th))
return qc
''' |
QPC001_C1 | A9FCB137582F8 | 1 | RE | 1970 ms | 157 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
k = math.ceil(math.log2(L))
for i in range(k):
qc.h(i)
return qc
''' |
QPC001_C1 | A9FCB137582F8 | 2 | RE | 1764 ms | 156 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
if L == 1:
return qc
# Write your code here:
k = math.ceil(math.log2(L))
for i in range(k):
qc.h(i)
return qc
''' |
QPC001_C1 | A9FCB137582F8 | 3 | AC | 2603 ms | 161 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
if L == 1:
return qc
k = math.ceil(math.log2(L))
for i in range(k):
qc.h(i)
return qc
''' |
QPC001_C1 | AA5059C15EED5 | 1 | RE | 1370 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
theta = 2*arcsin(1/sqrt(n))
qc.ry(theta, 0)
for i in range(1, n):
qc.ch(0, i)
return qc
''' |
QPC001_C1 | AA5059C15EED5 | 2 | WA | 1259 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
from numpy import arcsin, sqrt, pi
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
theta = 2*arcsin(1/sqrt(n))
qc.ry(theta, 0)
for i in range(1, n):
qc.ch(0, i)
return qc
''' |
QPC001_C1 | AA5059C15EED5 | 3 | UME | '''python
from qiskit import QuantumCircuit
from numpy import arcsin, sqrt, p
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
theta = 2*arcsin(1/sqrt(L))
qc.ry(theta, 0)
for i in range(1, n):
qc.ch(0, i)
return qc
''' | ||
QPC001_C1 | AA5059C15EED5 | 4 | WA | 1339 ms | 140 MiB | '''python
from qiskit import QuantumCircuit
import numpy as np
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
theta = 2*np.arcsin(1/np.sqrt(L))
qc.ry(theta, 0)
for i in range(1, n):
qc.ch(0, i)
return qc
''' |
QPC001_C1 | AA59A668DC89E | 1 | RE | 875 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(n))
# Tゲートを適用して位相を導入
for _ in range(L):
for qubit in range(n):
qc.append(TGate(), [qubit])
return qc
''' |
QPC001_C1 | AA59A668DC89E | 2 | WA | 1290 ms | 94 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import HGate, TGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.h(range(n))
# Tゲートを適用して位相を導入
for _ in range(L):
for qubit in range(n):
qc.append(TGate(), [qubit])
return qc
''' |
QPC001_C1 | AA59A668DC89E | 3 | WA | 1241 ms | 91 MiB | '''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import HGate, TGate
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# Write your code here:
qc.h(range(n))
# Tゲートを適用して位相を導入
for _ in range(L):
for qubit in range(n):
qc.append(TGate(), [qubit])
return qc
''' |
QPC001_C1 | AA5D2D01F19A6 | 1 | AC | 1490 ms | 141 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
k = math.ceil(math.log2(L))
qc.h(range(k))
return qc
''' |
QPC001_C1 | AA7F3571AF678 | 1 | RE | 872 ms | 79 MiB | '''python
from qiskit import QuantumCircuit
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
for qubit in range(n):
qc.h(qubit)
# 振幅を調整
# 例: 最初の 'L' 状態の振幅を減少させる
for i in range(L):
angle = pi / L # 回転角度は 'L' に応じて調整
qc.ry(-angle, i) # 'ry' はY軸回転ゲート
return qc
''' |
QPC001_C1 | AA7F3571AF678 | 2 | RE | 1053 ms | 91 MiB | '''python
from qiskit import QuantumCircuit
from math import pi
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
# すべての量子ビットにアダマールゲートを適用
for qubit in range(n):
qc.h(qubit)
# 振幅を調整
# 例: 最初の 'L' 状態の振幅を減少させる
for i in range(L):
angle = pi / L # 回転角度は 'L' に応じて調整
qc.ry(-angle, i) # 'ry' はY軸回転ゲート
return qc
''' |
QPC001_C1 | AA85DE624ED2C | 1 | RE | 1875 ms | 157 MiB | '''python
from qiskit import QuantumCircuit
import math
def solve(n: int, L: int) -> QuantumCircuit:
qc = QuantumCircuit(n)
qc.x(0)
for i in range(L-1):
# print(i)
theta = 2 * math.atan(math.sqrt(n - i - 1))
# print(math.cos(theta/2))
qc.cry(theta, i, i+1)
qc.cx(i+1, i)
return qc
''' |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.