如何使用memoization生成不重复的随机数？

Question

我想使用自己编写的 function 为 HTML 元素生成不重复的随机密钥。

问题是每次调用 function 时缓存都会丢失。

到目前为止，这是我的代码：

function generateRandomKey(cache = []) {
  const newRandomKey = Number(Math.random().toFixed(2));
  if (cache.includes(newRandomKey)) return generateRandomKey(cache);
  cache.push(newRandomKey);
  return newRandomKey;
}

我可以从 function scope 中声明cache ，这将在全球范围内可用，因为我希望缓存是这样的，但我担心这将是不好的做法。

我想过使用 memoization，像这样：

const memoizedRandomKey = (cache = []) => {
  return (generateRandomKey) => {
    const key = generateRandomKey();
    if (cache.includes(key) {
      return memoizedRandomKey(cache)
    }
    else {
      cache.push(key)
      return key
    }
  }
}

但是，缓存也会不断被覆盖。

我不确定我做错了什么，或者记忆在这种情况下是否有用。

您会推荐哪种方法？ 我逻辑思维的漏洞在哪里？

谢谢。

Answer 1

不要使用随机密钥

每次您进入同一个随机空间时，您都有可能收到一个非唯一值。 要检查您是否已经看到特定值，您需要某种缓存。

不要使用缓存

随着缓存填满，越来越难找到未使用的唯一值。

不要使用拼接

每次生成随机数时，使用.splice调整数组的大小。 这是一个非常昂贵的操作。

把事情简单化

这个顺序 ID 生成器保证 ID 是唯一的，不需要任何碰撞检测、缓存、预分配或其他昂贵的计算。 对于生成的 HTML 元素，这就足够了 -

 function createGenerator(init = 0) { return () => (init++).toString(16).padStart(2, "0") } const foo = createGenerator(1000) const bar = createGenerator() console.log(foo(), foo()) // 3e8 3e9 console.log(bar(), bar()) // 00 01 console.log(foo(), foo()) // 3ea 3eb console.log(bar(), bar()) // 02 03

预分配的随机顺序标识符

如果标识符是已知的或提前计算的，让我们探索一个替代方案 -

const t = popRandom(["a", "b", "c", "d", "e", "f"])

console.log(t(),t(),t()) // d c a
console.log(t(),t(),t()) // b e f
console.log(t())         // Error: no more values

从输入数组和n = keys.length ，随机r可以是 0 到（不包括） n的任何值。 假设第一次迭代r = 3 -

["a", "b", "c", "d", "e", "f"]
                 ^ r = 3

"d"将是第一个返回值，然后将keys[r]与数组keys[n - 1]的末尾交换，结果是 -

["a", "b", "c", "f", "e", "d"]

在下一次迭代中n = 5所以唯一有效的随机元素是a ， b ， c ， f ， e -

["a", "b", "c", "f", "e", "d"]
  ^    ^    ^    ^    ^
                      n = 5

一旦n = 0 ，就没有更多的值并提醒调用者。 现在我们实施它 -

 function popRandom(keys) { let n = keys.length let r, q return () => { if (n == 0) throw Error("no more values") r = Math.random() * n >> 0; q = keys[r] keys[r] = keys[n - 1] keys[n - 1] = qn -= 1 return q } } const keys = ["a", "b", "c", "d", "e", "f"] const t = popRandom(keys) console.log(t(),t(),t()) // eda console.log(t(),t(),t()) // c fb console.log(keys) // keys are shuffled console.log(t()) // error no more values

洗牌 output

一旦popRandom已用尽所有可能的值，输入键将被打乱顺序。 有关详细信息，请参阅Fisher-Yates 随机播放。

不可变键

如果您不想改变输入键，只需在输入时复制它们 -

const t = popRandom([...myKeys]) // copy 
// t(); t(); t(); ...

Answer 2

使用您的代码，您可以制作 100 个键（0.00 到 0.99）。 随着缓存变大，冲突将更频繁地发生，并且您将进行大量递归调用 - 可能导致堆栈溢出等问题。 更好的解决方案可能是先创建所有密钥，然后根据需要随机选择/删除它们。

我主要在 C++ 和 C# 工作，所以我自然更喜欢使用类。 （虽然貌似 JS 程序员用得不多？）。 所以这是一个 static class。它创建了 100 个键，然后删除/返回它们直到列表为空。

 class RandomKey { static keys = Array.apply(null, Array(100)).map((x, i) => (i / 100).toFixed(2)); static generate() { if (RandomKey.keys.length == 0) { throw new Error("No more keys."); } const index = Math.floor(RandomKey.keys.length * Math.random()); const selectedKey = RandomKey.keys[index]; RandomKey.keys.splice(index, 1); return selectedKey; } } // Test for (let i = 0; i < 101; i++) { console.log(RandomKey.generate()); }

Answer 3

您的memoizedRandomKey function 不起作用的原因是您在递归情况下调用了错误的 function 。 您应该调用它返回的 function，但 function 未命名，因此您必须为其命名。 我们可以这样做：

const memoizedRandomKey = (cache = []) => {
  return function getRandom (generateRandomKey) {
    const key = generateRandomKey();
    if (cache.includes(key)) {
      return getRandom(generateRandomKey)
    }
    else {
      cache.push(key)
      return key
    }
  }
}

但我认为这可以稍微清理一下。 所以我可能会尝试这样的事情：

 const generateRandomKey = () => Math.random().toFixed (2).slice (2) const makeRandomizer = (generator, cache = []) => (key = generator ()) => key in cache? makeRandomizer (generator) (): (cache.push (key), key) const randomId = makeRandomizer (generateRandomKey) console.log (Array.from ({length: 50}, () => randomId ()))

 .as-console-wrapper {max-height: 100%;important: top: 0}

尽管如此，正如其他人指出的那样，这可能会遇到缓存填满时反复检查的问题。 另一种方法是在开始时生成所有键，将它们打乱，然后将当前索引保留在闭包中。 当您将自己限制在 100 种可能性时，这很容易做到，但对于更大的潜在 ID 空间来说，这将成为一个问题。

对于较大的情况，您将不得不决定随机的含义，以及 id 冲突问题的严重程度。 如果只是因为它们在不经意间看起来不可预测，那么您可以尝试使用Linear Congruential Generator ，它很容易计算，并且从随机种子开始，每次运行看起来都会有所不同。 请记住，虽然您可以根据自己的喜好设置周期，但它会是周期性的。 如果您需要更随机的东西，请查看Crypto.getRandom ，但请记住，尽管碰撞不太可能发生，但它们还是有可能发生。

Answer 4

我认为你在正确的轨道上。 您通常希望cache成为闭包的一部分，而不是将其作为参数传入。 也许是这样的。

 const generateRandomKey = () => Math.random().toFixed(10) function makeKeyGenerator() { const cache = {}; return function () { let key = generateRandomKey(); // if the key is in the cache get a new key while (key in cache) { key = generateRandomKey(); } cache[key] = true; console.log(cache); return key; }; } const getKey = makeKeyGenerator(); const key = getKey();

请注意，您将很快用完toFixed(2)的密钥。 如果发生这种情况， while循环将使您度过糟糕的一天。