标签: pseudocode

我的孩子们有这款名为Spot It的有趣游戏!游戏限制(我能描述的最好)是:

• 这是一张55张牌
• 每张卡上有8张独特的图片(即一张卡不能有2张相同的图片)
• 鉴于从牌组中选择的任何2张牌,只有1张匹配图片.
• 匹配的图片可能会在不同的卡上进行不同的缩放,但这只会使游戏更难(即小树仍然匹配更大的树)

游戏的原则是:翻转2张牌,无论谁先挑选匹配的图片都能得到一分.

这是一张澄清的图片:

(例如:你可以从上面的2张卡片上看到匹配的图片是绿色恐龙.在右下角和中右图之间,它是一个小丑的头.)

我想了解以下内容:

1. 满足这些标准所需的最小不同图片数量是多少？您如何确定？

2. 使用伪代码(或Ruby),如何从N个图片阵列中生成55张游戏卡(其中N是问题1中的最小数字)？

更新:

每张照片确实发生了两次以上的照片(与一些人推测的情况相反).看到这张3张牌的照片,每张牌都有一个闪电:

计算给定数量的除数的最佳算法(性能方面)是什么？

如果您能提供伪代码或链接到一些示例,那将会很棒.

编辑:所有答案都非常有帮助,谢谢.我正在实施Atkin的Sieve,然后我将使用类似于Jonathan Leffler所说的东西.Justin Bozonier发布的链接提供了我想要的更多信息.

实现Quicksort时,您需要做的一件事就是选择一个数据透视表.但是当我看下面的伪代码时,我不知道应该如何选择枢轴.列表的第一个要素？别的什么？

 function quicksort(array)
     var list less, greater
     if length(array) ? 1  
         return array  
     select and remove a pivot value pivot from array
     for each x in array
         if x ? pivot then append x to less
         else append x to greater
     return concatenate(quicksort(less), pivot, quicksort(greater))

有人可以帮助我掌握选择枢轴的概念,以及不同的场景是否需要不同的策略.

Program A()
{
    x, y, z: integer;

    procedure B()
    {
        y: integer;
        y=0;
        x=z+1;
        z=y+2;
    }

    procedure C()
    {
        z: integer;

        procedure D()
        {
            x: integer;
            x = z + 1;
            y = x + 1;
            call B();
        }

        z = 5;
        call D();
    }

    x = 10;
    y = 11;
    z = 12;
    call C();
    print x, y, z;
}

根据我的理解,使用静态作用域运行时该程序的结果是:x = 13,y = 7,z = 2.

但是,当使用动态范围运行时,结果为:x = 10,y = 7,z = 12.

这些结果是我们教授给我们的结果.但是,我无法理解他的生活如何达到这些结果.有人可能会通过伪代码并在两种不同类型的范围内解释它们的值吗？

我有两个矩形,每个矩形有4个值:

左侧位置X,顶部位置Y,宽度W和高度H:

X1, Y1, H1, W1
X2, Y2, H2, W2

矩形不会旋转,如下所示:

+--------------------> X axis
|
|    (X,Y)      (X+W, Y)
|    +--------------+
|    |              |
|    |              |
|    |              |
|    +--------------+
v    (X, Y+H)     (X+W,Y+H)

Y axis

确定两个矩形的交点是否为空的最佳解决方案是什么？

假设我以下面的方式连接节点,我如何得出给定点之间存在的路径数量和路径详细信息？

1,2 //node 1 and 2 are connected
2,3
2,5
4,2
5,11
11,12
6,7
5,6
3,6
6,8
8,10
8,9

找到1到7的路径:

答案:找到2条路径,它们是

1,2,3,6,7
1,2,5,6,7

在这里找到的实现很好,我将使用相同的

这是python中上面链接的片段

# a sample graph
graph = {'A': ['B', 'C','E'],
             'B': ['A','C', 'D'],
             'C': ['D'],
             'D': ['C'],
             'E': ['F','D'],
             'F': ['C']}

class MyQUEUE: # just an implementation of a queue

    def __init__(self):
        self.holder = []

    def enqueue(self,val):
        self.holder.append(val)

    def dequeue(self):
        val = None
        try:
            val = self.holder[0]
            if len(self.holder) == 1:
                self.holder = [] …

我需要从毫秒到(小时,分钟,秒,毫秒)的元组表示相同的时间量.例如:

10799999ms = 2h 59m 59s 999ms

以下伪代码是我唯一可以提出的:

# The division operator below returns the result as a rounded down integer
function to_tuple(x):
    h = x / (60*60*1000)
    x = x - h*(60*60*1000)
    m = x / (60*1000)
    x = x - m*(60*1000)
    s = x / 1000
    x = x - s*1000
    return (h,m,s,x)

我敢肯定必须能够做得更聪明/更优雅/更快/更紧凑.

说n = 100; 如何生成100种视觉上鲜明的颜色？这在数学上是否可行？

我是一个完整的ROOKIE,所以我需要一些帮助.

您将如何使用参数创建uml类图和构造函数.

默认情况下(无参数)

用于图表和伪代码的policyholder()

对于参数你会做同样的事情

保险单(policynumber,服务类和客户年龄)用于类图和伪代码.

它还要求将每个属性初始化为可以实例化此类型的对象的值,如果策略编号不在1000和999之间,则将策略编号设置为0.(策略编号是属性)

我一直在寻找一种算法来对图表进行传递减少,但没有成功.在我的算法圣经中没有任何内容(Cormen等人的算法导论),虽然我已经看到了大量的传递闭包伪代码,但我还是无法追踪任何减少的东西.我最接近的是Volker Turau的"Algorithmische Graphentheorie"中有一个(ISBN:978-3-486-59057-9),但不幸的是我无法访问这本书!维基百科是无益的,谷歌还没有发现任何东西.:^(

有谁知道用于执行传递减少的算法？