发单-伪随机序列函数

有点意思，插个眼，明天上班写一写，[email protected]

lz 看看这个是不是一个符合要求的串 https://pastebin.pl/view/d8bc2c6f
单元测试也可以提供
我的邮箱是 a2FyaW56aGFuZzIzIEFUIGdtYWlsLmNvbQ==

是我理解错了吗，第三条的条件是不是有问题

密码里这种需求不常见，这种功能写一星期半个月都可能，先报预算才会有人去研究

不知我理解得对不对， 看代码：

https://leetcode.cn/playground/7iu298LX/

import sys
import os


class Solution:
def generate_bits(self, n: int = 65536) -> tuple[bool, list[int]]:
"""Generate n bits with the following constraints:
1. the diff between the number of 0s and 1s in each 32-bit number is at most 4
2. each 32-bit number is unique
3. no more than 8 consecutive 0s or 1s
Args:
n: the number of bits to generate, n >= 65536
Returns:
A tuple of two elements:
- True if the bits are successfully generated, False otherwise
- A list of n bits if the bits are successfully generated, an empty list otherwise
"""

# increase the recursion limit
sys.setrecursionlimit(max(sys.getrecursionlimit(), n * 2))

visited_nums = set() # set to store visited numbers
bits = [] # list to store generated bits

def dfs(i, c0, c1, diff, num: int) -> bool:
"""
Depth-first search to generate bits recursively
Args:
i: the index of the current bit
c0: the number of 0s in the current 32-bit number
c1: the number of 1s in the current 32-bit number
diff: the diff between the number of 0s and 1s
num: the current 32-bit number
Returns:
True if the bits are successfully generated,
False otherwise
"""

# verify the diff between the number of 0s and 1s in each 32-bit number is at most 4
if c0 - c1 > 4 or c1 - c0 > 4 or diff > 4 or diff < -4:
return False

# return True if all bits are generated
if i == n:
return True

# first 32 bits
if i < 32:
next_num = num * 2
# the rest bits
else:
next_num = (num & 0x7fffffff) * 2
# remove the leftmost bit
if bits[i - 32] == 0:
c0 -= 1
else:
c1 -= 1

x = self.random_bit() # randomly choose 0 or 1

# if x == 0, try 0 first
if x == 0 and (next_num not in visited_nums):
visited_nums.add(next_num)
bits.append(0)
if dfs(i + 1, c0 + 1, c1, diff - 1, next_num):
return True
visited_nums.remove(next_num)
bits.pop()

# if x == 0, fallback to 1
# if x == 1, try 1
next_num += 1
if next_num not in visited_nums:
visited_nums.add(next_num)
bits.append(1)
if dfs(i + 1, c0, c1 + 1, diff + 1, next_num):
return True
visited_nums.remove(next_num)
bits.pop()

# if x == 1, fallback to 0
next_num -= 1
if x == 1 and (next_num not in visited_nums):
visited_nums.add(next_num)
bits.append(0)
if dfs(i + 1, c0 + 1, c1, diff - 1, next_num):
return True
visited_nums.remove(next_num)
bits.pop()

return False

found = dfs(0, 0, 0, 0, 0)
if found and self.verify_bits(bits):
return True, bits
return False, bits

def random_bit(self) -> int:
"""Generate a random bit
"""
return os.urandom(1)[0] & 1

def verify_bits(self, bits: list[int]) -> bool:
"""Verify the generated bits
"""

n = len(bits)

# verify: the diff between the number of 0s and 1s in each 32-bit number is at most 4
for i in range(32, n+1):
c1 = sum(bits[i - 32:i])
c0 = 32 - c1
if c0 - c1 > 4 or c1 - c0 > 4:
print("Failed at diff constraint!")
return False

# verify: each 32-bit number is unique
visited_nums = set()
for i in range(32, n+1):
num = 0
for j in range(i-32, i):
num = num * 2 + bits[j]
if num in visited_nums:
print("Failed at unique constraint!")
return False
visited_nums.add(num)

# verify: no more than 8 consecutive 0s or 1s
c0, c1 = 0, 0
for i in range(n):
if bits[i] == 0:
c0 += 1
c1 = 0
else:
c1 += 1
c0 = 0
if c0 > 8 or c1 > 8:
print("Failed at consecutive constraint!")
return False

return True



if __name__ == "__main__":
sol = Solution()
n = 65536
found, bits = sol.generate_bits(n)
if found:
print("Bits are successfully generated!")
#print(bits)
else:
print("Failed to generate bits!")

@HDY 谢谢指出。的确是笔误。

@boomboom5432 嗯嗯，是的。这就是一个 m 序列问题。对于没有做过的人，从头学习是挺难的。但是做过的人就很快。

@kalinzhang @tlxxzj 我补充了一点说明，之前可能写的不够明确。需要提供计算的 f(x), 这样能反向推算出 x

@kuber 预算是多少？我大概可以推一推，但需要看预算决定要不要花时间推导

@kalinzhang 能留个联系方式吗，邮箱或者微信