如何生成这个特定的数字序列？答案

【问题标题】：How do I generate this specific sequence of numbers?如何生成这个特定的数字序列？
【发布时间】：2011-04-16 17:37:31
【问题描述】：

显然 .net 中没有可用的预定义列表。

我想使用一些标准颜色，例如像红色、绿色、蓝色、黄色……即典型的颜色，由 00 和 FF 分量组成，其次是带有额外 7F 分量的颜色……

有没有办法检索这些“标准”颜色，还是我必须自己写IEnumerable<Color>？

编辑：这是 RGB 值的可能输出。

请注意，集合的顺序很重要，因为 00/FF 枚举必须在添加 80 之前完成，并且 00/80/FF 枚举必须在添加 40/B0 之前完成，等等。 集合中的顺序无关紧要（即 00 FF 00 可能在 00 00 FF 之前）。

00 00 00 // start out with 00 and FF components
00 00 FF
00 FF 00
FF 00 00
FF FF 00
FF 00 FF
00 FF FF
FF FF FF
00 00 80 // ok, now add 80
00 80 00
...
80 80 80
FF 00 80
FF 80 00
FF 80 80
80 FF 00
80 FF 80
FF FF 80
...
// now add 40 and B0

【问题讨论】：

什么上下文（windows forms、WPF、web）？
实际上两者都不是，但如果你知道一个合适的库函数，例如WPF 我很好。
所以你想要一个按特定顺序排序的颜色数组？顺便说一句：FF 00 00 被列出了两次。
@mafutrct 听起来您的问题是关于排序，而不是颜色？
@mafutrct 我敢肯定，如果您手动构建更多最终序列，如何生成它会变得更加明显。（例如，我看不到从 80 80 80 跳转到 FF (100?) 00 80 背后的逻辑。）如果我是你，我会尝试嵌套 Linq 投影。 :)

标签： .net colors numbers sequence

【解决方案1】：

Colors 类上有许多预定义的 ARGB 颜色，Color 结构体也是如此。这些包含Yellow、White、Green 等内容...

如果您想要用户定义的系统颜色，您可以使用 SystemColors 类，它具有 ActiveBorder、WindowText 等内容...

更新：

框架中没有任何东西可以按照 ARGB 值对颜色进行排序，因为它没有多大意义

您可以使用 Linq 按颜色列表对颜色列表进行排序（OrderBy 扩展方法）。

【讨论】：

是，但不是按“标准”排序的列表。
@mafutrct - 定义“标准”。
我认为他的意思就像在 Windows 颜色选择器中的小部件中找到的颜色。（或一般的“颜色选择器”）。
@mafutrct OrderBy(c=>c.R).ThenBy(c=>c.G)? :)
@mafutrct - 见this - 它可能会有所帮助。使用 Linq 进行排序并使用 Color 结构应该很容易（因为 Color 具有每个组件的成员 - 即 Red.R 将是 255。

【解决方案2】：

SystemColors 类可能适合您。

【讨论】：

【解决方案3】：

AFAIK“标准”颜色不等于基于您描述的图案具有 RGB 值的颜色。例如紫色具有 #B803FF RGB 值（类似的 'fuchsia' 具有 #FF00FF ）。

【讨论】：

【解决方案4】：

这是一种相当快速的生成序列的方法：

public static IEnumerable<Color> StandardColors ()
{
    int r = 0;
    int g = 0;
    int b = 0;
    int inc = 0x100;

    yield return Color.FromArgb (0, 0, 0);

    while (true) {
        if (((r | g | b) & inc) != 0) {
            int outR = r == 0 ? 0 : r - 1;
            int outG = g == 0 ? 0 : g - 1;
            int outB = b == 0 ? 0 : b - 1;
            yield return Color.FromArgb (outR, outG, outB);
        }

        r += inc;
        if (r > 256) {
            r = 0;
            g += inc;

            if (g > 256) {
                g = 0;
                b += inc;

                if (b > 256) {
                    b = 0;
                    inc >>= 1;

                    if (inc <= 1) {
                        break;
                    }
                }
            }
        }
    }
}

这当然可以改进。例如，应避免使用单独的 outR/G/B 变量，并且应通过 2*inc 从奇数（基于inc）值开始进行递增，以避免必须测试该值是否已在之前生成。

使用这个测试

static void Main (string[] args)
{
    var colors = StandardColorEnumerator.StandardColors ().Take (15)
        .Concat (StandardColorEnumerator.StandardColors ().Skip (1000).Take (10));
    foreach (var color in colors) {
        Console.WriteLine (color.B + "\t" + color.G + "\t" + color.R);
    }

    Console.ReadKey (true);
}

生成以下输出：

0       0       0
0       0       255
0       255     0
0       255     255
255     0       0
255     0       255
255     255     0
255     255     255
0       0       127
0       127     0
0       127     127
0       127     255
0       255     127
127     0       0
127     0       127

15      47      191
15      47      207
15      47      223
15      47      239
15      47      255
15      63      0
15      63      15
15      63      31
15      63      47
15      63      63

【讨论】：