blocks|key|1042865|text|只需生成2个介于0和9之间的随机数，然后从数组中选择随机元素，如下所示：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1042866|arr[rand1][rand2];|code-block|syntax|javascript|1042867|在一个循环中重复10次。没有必要让它变得更复杂。|1042868|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Just generate 2 random numbers between 0 and 9 and the select the random element from the array like:

<pre><code>arr[rand1][rand2];
</code></pre>

Do that 10 times in a loop. No need to make it more complicated than that.

blocks|key|1036922|text|for+(int+i+=+0;+i+<+10;+i%2B%2B)+{
++++//+ith+random+entry+in+the+matrix
++++arr[rand()+%25+10][rand()+%25+10];
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1036923|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>for (int i = 0; i &lt; 10; i++) {
 // ith random entry in the matrix
 arr[rand() % 10][rand() % 10];
}
</code></pre>

blocks|key|882488|text|为了稍微简化，可以将10x10数组视为100个元素的等效线性数组。现在问题变成了从一组100个不同的数字中挑选10个不同的数字。要获得第一个索引，只需在0到99之间选择一个随机数即可。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|882489|int+hits[10];++/*+stow+randomly+selected+indexes+here+*/
hits[0]+=+random1(100);++/*+random1(n)+returns+a+random+int+in+range+0..n-1+*/|code-block|syntax|javascript|882490|第二个数字几乎同样简单。从剩下的99个可能性中选择另一个数字。Random1返回一个连续范围为0..99的数字；然后必须将其映射到虚线范围0..hits-1，hits%2B1..99中。|882491|hits[1]+=+random1(99);
if+(hits[1]+==+hits[0])+hits[1]%2B%2B;|882492|现在，对于第二个数字，映射开始变得有趣起来，因为它需要一些额外的工作来确保新的数字与现有的两个选择都不同。|882493|hits[2]+=+random1(98);
if+(hits[2]+==+hits[0])+hits[2]%2B%2B;
if+(hits[2]+==+hits[1])+hits[2]%2B%2B;
if+(hits[2]+==+hits[0])+hits[2]%2B%2B;+/*+re-check,+in+case+hits[1]+==+hits[0]%2B1+*/|882494|如果按顺序对命中数组进行排序，则可以避免重新检查元素的唯一性。把所有东西放在一起：|882495|int+hits[10];
int+i,+n;
for+(n+=+0;+n+<+10;+n%2B%2B)+{
++++int+choice+=+random1(+100+-+n+);++/*+pick+a+remaining+index+at+random+*/
++++for+(i+=+0;+i+<+n;+i%2B%2B)+{
++++++++if+(choice+<+hits[i])++/*+find+where+it+belongs+in+sorted+hits+*/
++++++++++++break;
++++++++choice%2B%2B;++/*+and+make+sure+it+is+distinct+*
+++++++++++++++++++/*+need+%2B%2B+to+preserve+uniform+random+distribution!+*/
++++}
++++insert1(+hits,+n,+choice,+i+);
++++++++++++/*+insert1(...)+inserts+choice+at+i+in+growing+array+hits+*/
}|882496|您可以使用hits从10x10数组中获取元素，如下所示：|offset|length|style|CODE|882497|array[hits[0]/10][hits[0]%2510]|882498|entityMap^0|0|0|0|0|0|0|0|0|5|4|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|14|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|15|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|16|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|17|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|18|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|19|8|@]|9|@]|A|$E|F]]|$1|S|3|T|5|6|7|1A|8|@$U|1B|V|1C|W|X]]|9|@]|A|$]]|$1|Y|3|Z|5|D|7|1D|8|@]|9|@]|A|$E|F]]|$1|10|3|-4|5|6|7|1E|8|@]|9|@]|A|$]]]|11|$]]

To simplify slightly, treat the 10x10 array as an equivalent linear array of 100 elements. Now the problem becomes that of picking 10 distinct numbers from a set of 100. To get the first index, just pick a random number in the range 0 to 99.

<pre><code>int hits[10]; /* stow randomly selected indexes here */
hits[0] = random1(100); /* random1(n) returns a random int in range 0..n-1 */
</code></pre>

The second number is almost as easy. Choose another number from the 99 remaining possibilities. Random1 returns a number in the continuous range 0..99; you must then map that into the broken range 0..hits[0]-1, hits[0]+1..99.

<pre><code>hits[1] = random1(99);
if (hits[1] == hits[0]) hits[1]++;
</code></pre>

Now for the second number the mapping starts to get interesting because it takes a little extra work to ensure the new number is distinct from both existing choices.

<pre><code>hits[2] = random1(98);
if (hits[2] == hits[0]) hits[2]++;
if (hits[2] == hits[1]) hits[2]++;
if (hits[2] == hits[0]) hits[2]++; /* re-check, in case hits[1] == hits[0]+1 */
</code></pre>

If you sort the array of hits as you go, you can avoid the need to re-check elements for uniqueness. Putting everything together:

<pre><code>int hits[10];
int i, n;
for (n = 0; n &lt; 10; n++) {
 int choice = random1( 100 - n ); /* pick a remaining index at random */
 for (i = 0; i &lt; n; i++) {
 if (choice &lt; hits[i]) /* find where it belongs in sorted hits */
 break;
 choice++; /* and make sure it is distinct *
 /* need ++ to preserve uniform random distribution! */
 }
 insert1( hits, n, choice, i );
 /* insert1(...) inserts choice at i in growing array hits */
}
</code></pre>

You can use <code>hits</code> to fetch elements from your 10x10 array like this:

<pre><code>array[hits[0]/10][hits[0]%10]
</code></pre>

blocks|key|1036960|text|修改了Peter+Raynham的答案-我认为其中的想法是正确的，但他的执行太复杂了，没有正确地映射范围：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1036961|为了稍微简化，可以将10x10数组视为100个元素的等效线性数组。现在问题变成了从一组100个不同的数字中挑选10个不同的数字。|1036962|要获得第一个索引，只需在0到99之间选择一个随机数即可。|1036963|int+hits[10];++/*+stow+randomly+selected+indexes+here+*/
hits[0]+=+random1(100);++/*+random1(n)+returns+a+random+int+in+range+0..n-1+*/|code-block|syntax|javascript|1036964|第二个数字几乎同样简单。从剩下的99个可能性中选择另一个数字。Random1返回一个连续范围为0..99的数字；然后必须将其映射到虚线范围0..hits-1，hits%2B1..99中。|1036965|hits[1]+=+random1(99);
if+(hits[1]+>=+hits[0])+hits[1]%2B%2B;|1036966|请注意，必须将整个命中范围..98映射到hits%2B1..99|1036967|对于另一个数字，您必须与所有先前的数字进行比较，因此对于第三个数字，您必须这样做|1036968|hits[2]+=+random1(98);
if+(hits[2]+>=+hits[0])+hits[2]%2B%2B;
if+(hits[2]+>=+hits[1])+hits[2]%2B%2B;|1036969|你不需要对数字进行排序！把所有东西放在一起：|1036970|int+hits[10];
int+i,+n;
for+(n+=+0;+n+<+10;+n%2B%2B)+{
++++int+choice+=+random1(+100+-+n+);++/*+pick+a+remaining+index+at+random+*/

++++for+(i+=+0;+i+<+n;+i%2B%2B)
++++++++if+(choice+>=+hits[i])
++++++++++++choice%2B%2B;

++++hits[i]+=+choice;
}|1036971|您可以使用hits从10x10数组中获取元素，如下所示：|offset|length|style|CODE|1036972|array[hits[0]/10][hits[0]%2510]|1036973|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|5|4|0|0^^$0|@$1|2|3|4|5|6|7|18|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|19|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|1A|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|1B|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|1C|8|@]|9|@]|A|$]]|$1|M|3|N|5|H|7|1D|8|@]|9|@]|A|$I|J]]|$1|O|3|P|5|6|7|1E|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1F|8|@]|9|@]|A|$]]|$1|S|3|T|5|H|7|1G|8|@]|9|@]|A|$I|J]]|$1|U|3|V|5|6|7|1H|8|@]|9|@]|A|$]]|$1|W|3|X|5|H|7|1I|8|@]|9|@]|A|$I|J]]|$1|Y|3|Z|5|6|7|1J|8|@$10|1K|11|1L|12|13]]|9|@]|A|$]]|$1|14|3|15|5|H|7|1M|8|@]|9|@]|A|$I|J]]|$1|16|3|-4|5|6|7|1N|8|@]|9|@]|A|$]]]|17|$]]

Modified this from Peter Raynham's answer - I think the idea in it is right, but his execution is too complex and isn't mapping the ranges correctly:

To simplify slightly, treat the 10x10 array as an equivalent linear array of 100 elements. Now the problem becomes that of picking 10 distinct numbers from a set of 100. 

To get the first index, just pick a random number in the range 0 to 99.

<pre><code>int hits[10]; /* stow randomly selected indexes here */
hits[0] = random1(100); /* random1(n) returns a random int in range 0..n-1 */
</code></pre>

The second number is almost as easy. Choose another number from the 99 remaining possibilities. Random1 returns a number in the continuous range 0..99; you must then map that into the broken range 0..hits[0]-1, hits[0]+1..99.

<pre><code>hits[1] = random1(99);
if (hits[1] &gt;= hits[0]) hits[1]++;
</code></pre>

Note that you must map the complete range of hits[0]..98 to hits[0]+1..99

For another number you must compare to all previous numbers, so for the third number you must do

<pre><code>hits[2] = random1(98);
if (hits[2] &gt;= hits[0]) hits[2]++;
if (hits[2] &gt;= hits[1]) hits[2]++;
</code></pre>

You don't need to sort the numbers! Putting everything together:

<pre><code>int hits[10];
int i, n;
for (n = 0; n &lt; 10; n++) {
 int choice = random1( 100 - n ); /* pick a remaining index at random */

 for (i = 0; i &lt; n; i++)
 if (choice &gt;= hits[i])
 choice++;

 hits[i] = choice;
}
</code></pre>

You can use <code>hits</code> to fetch elements from your 10x10 array like this:

<pre><code>array[hits[0]/10][hits[0]%10]
</code></pre>

blocks|key|882592|text|如果你想要你从网格中选择的随机单元是唯一的--看起来你真的想要构造随机排列。在这种情况下：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|882593|882594|将单元号0..99放入一维数组中|unordered-list-item|offset|length|style|CODE|882595|取一些shuffle+algorithm并将该数组与其一起丢弃|882596|从混洗数组中读取前10个元素。|882597|F29|882598|缺点:该算法的运行时间随着单元数的增加而线性增加。因此，出于实际原因，可能更好的做法是按照@+says+P.R.O.所说的那样做。|882599|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Knuth_shuffle^0|0|0|4|5|0|3|H|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Z|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|10|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|11|8|@$F|12|G|13|H|I]]|9|@]|A|$]]|$1|J|3|K|5|E|7|14|8|@]|9|@$F|15|G|16|1|17]]|A|$]]|$1|L|3|M|5|E|7|18|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|19|8|@]|9|@]|A|$]]|$1|P|3|Q|5|6|7|1A|8|@]|9|@]|A|$]]|$1|R|3|-4|5|6|7|1B|8|@]|9|@]|A|$]]]|S|$T|$5|U|V|W|A|$X|Y]]]]

If you want your chosen random cells from grid to be unique - it seems that you really want to construct random permutations. In that case:

<ul>
<li>Put cell number <code>0..99</code> into 1D array</li>
<li>Take some <a href="http://en.wikipedia.org/wiki/Knuth_shuffle" rel="nofollow">shuffle algorithm</a> and toss that array with it</li>
<li>Read first 10 elements out of shuffled array.</li>
</ul>

Drawback: Running time of this algorithm increases linearly with increasing number of cells. So it may be better for practical reasons to do as @PaulP.R.O. says ...

blocks|key|4665765|text|在hjhill的解决方案中有一个细微的bug。如果您没有对列表中的元素进行排序，那么当您扫描列表时(内部for循环)，当您遇到选择索引(choice%2B%2B)时，就需要重新扫描。这是因为您可能会将它撞到列表中的前一个条目中-例如，使用随机数:+90，89，89。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4665766|完整的代码：|4665767|int+hits[10];
int+i,+j,+n;
for+(n+=+0;+n+<+10;+n%2B%2B)+{
++++int+choice+=+random1(+100+-+n+);++/*+pick+a+remaining+index+at+random+*/
++++for+(i+=+0;+i+<+n;+i%2B%2B)+{
++++++++if+(choice+>=+hits[i])+{+++/*+find+its+place+in+partitioned+range+*/
++++++++++++choice%2B%2B;
++++++++++++for+(j+=+0;+j+<+i;+j%2B%2B)+{+++/*+adjusted+the+index,+must+...+*/
++++++++++++++++if+(choice+==+hits[j])+{++/*+...+ensure+no+collateral+damage+*/
++++++++++++++++++++choice%2B%2B;
++++++++++++++++++++j+=+0;
++++++++++++++++}
++++++++++++}
++++++++}
++++}
++++hits[n]+=+choice;
}|code-block|syntax|javascript|4665768|我知道五个层次的嵌套让它变得有点丑陋。当只选择几个元素(例如，100个元素中的10个)时，它将具有比排序解决方案更好的性能；当选择大量元素(例如，100个元素中的90个)时，性能可能会比排序解决方案更差。|4665769|entityMap^0|1G|3|1W|8|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|V|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|W|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|X|8|@]|D|@]|E|$]]|$1|O|3|-4|5|6|7|Y|8|@]|D|@]|E|$]]]|P|$]]

There is a subtle bug in hjhill's solution. If you don't sort the elements in your list, then when you scan the list (inner <code>for</code> loop), you need to re-scan whenever you bump the choice index (<code>choice++</code>). This is because you may bump it into a previous entry in the list - for example with random numbers: 90, 89, 89.

The complete code:

<pre><code>int hits[10];
int i, j, n;
for (n = 0; n &lt; 10; n++) {
 int choice = random1( 100 - n ); /* pick a remaining index at random */
 for (i = 0; i &lt; n; i++) {
 if (choice &gt;= hits[i]) { /* find its place in partitioned range */
 choice++;
 for (j = 0; j &lt; i; j++) { /* adjusted the index, must ... */
 if (choice == hits[j]) { /* ... ensure no collateral damage */
 choice++;
 j = 0;
 }
 }
 }
 }
 hits[n] = choice;
}
</code></pre>

I know it's getting a little ugly with five levels of nesting. When selecting just a few elements (e.g., 10 of 100) it will have better performance than the sorting solution; when selecting a lot of elements (e.g., 90 of 100), performance will likely be worse than the sorting solution.

I am trying to write C code to randomly select 10 random sites from a grid of 10x10. The way I am considering going about this is to assign every cell a random number between zero and RAND_MAX and then picking out the 10 smallest/largest values. But I have very little idea about how to actually code something like that :/

I have used pseudo-random number generators before so I can do that part.

Starting with a 10x10 array how do I choose 10 random sites

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我正在尝试编写C代码，从10x10的网格中随机选择10个站点。我正在考虑的方法是为每个单元格分配一个介于0和RAND_MAX之间的随机数，然后挑选出10个最小/最大的值。但我几乎不知道如何实际编写这样的代码:/我以前使用过伪随机数生成器，所以我可以完成这一部分。

问从10x10阵列开始，如何选择10个随机站点
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问从10x10阵列开始，如何选择10个随机站点EN