c# - 如何去掉列表中的循环数字

Question

好吧，我知道这段代码很粗糙，而且到处都是乱七八糟的，但我不是程序员，所以请多多包涵。我有这个列出一堆数字的代码，但我希望它不列出数字的任何循环副本。

例如，如果号码 111262 在我的列表中，我不希望列出 112621、126211、262111、621112 或 211126。

抱歉，该号码不在列表中。

举一个真实的例子，如果数字 111252 在我的列表中，我不想列出 112521、125211、252111、521112 或 211125。

感谢任何帮助!

namespace Toric_Classes
{
class Program
{
    static void Main(string[] args)
    {
        int number_of_perms=0;
        bool badsubsum1;
        bool badsubsum2;
        int subsum1 = 0;
        int subsum2 = 0;
        int sum = 0;
        int class_length=6;
        int[] toric_class=new int[class_length];
        // The nested for loops scroll through every possible number of length class_length, where each digit can have a value of 1,2,..., or class_length-1
        // Each number is looked at as an array, and is not stored anywhere, only printed if it satisfies certain conditions
        for(int i1=1; i1<class_length; i1++)
        {
            toric_class[0] = i1;
            for (int i2 = 1; i2 < class_length; i2++)
            {
                toric_class[1] = i2;
                for (int i3 = 1; i3 < class_length; i3++)
                {
                    toric_class[2] = i3;
                    for (int i4 = 1; i4 < class_length; i4++)
                    {
                        toric_class[3] = i4;
                        for (int i5 = 1; i5 < class_length; i5++)
                        {
                            toric_class[4] = i5;
                            for (int i6 = 1; i6 < class_length; i6++)
                            {
                                badsubsum1 = false;
                                badsubsum2 = false;
                                toric_class[5] = i6;
                                // Find the value of the sum of the digits of our array.
                                // We only want numbers that have a total digit sum being a multiple of class_length
                                for (int k = 0; k < class_length; k++)
                                {
                                    sum += toric_class[k];
                                }
                                // The follwong two nested loops find the value of every contiguous subsum of our number, but not the total subsum.
                                // We *do not* want any subsum to be a multiple of class_length.
                                // That is, if our number is, say, 121342, we want to find 1+2, 1+2+1, 1+2+1+3, 1+2+1+3+4, 2+1, 2+1+3, 2+1+3+4, 2+1+3+4+2, 1+3, 1+3+4, 1+3+4+2, 3+4, 3+4+2, and 4+2
                                // The following checks 1+2, 1+2+1, 1+2+1+3, 1+2+1+3+4, 2+1, 2+1+3, 2+1+3+4, 1+3, 1+3+4, and 3+4
                                for (int i = 0; i < class_length - 1; i++)
                                {
                                    for (int j = i + 1; j < class_length - 1; j++)
                                    {
                                        for (int k = i; k < j; k++)
                                        {
                                            subsum1 += toric_class[k];
                                        }
                                        if (subsum1 % class_length == 0)
                                        {
                                            badsubsum1 = true;
                                            break;
                                        }
                                        subsum1 = 0;
                                    }
                                }
                                // The following checks 2+1, 2+1+3, 2+1+3+4, 2+1+3+4+2, 1+3, 1+3+4, 1+3+4+2, 3+4, 3+4+2, and 4+2
                                for (int i = 1; i < class_length; i++)
                                {
                                    for (int j = i + 1; j < class_length; j++)
                                    {
                                        for (int k = i; k < j; k++)
                                        {
                                            subsum2 += toric_class[k];
                                        }
                                        if (subsum2 % class_length == 0)
                                        {
                                            badsubsum2 = true;
                                            break;
                                        }
                                        subsum2 = 0;
                                    }
                                }
                                // We only want numbers that satisfies the following conditions
                                if (sum % class_length == 0 && badsubsum1 == false && badsubsum2 == false)
                                {
                                    foreach (var item in toric_class)
                                    {
                                        Console.Write(item.ToString());
                                    }
                                    Console.Write(Environment.NewLine);
                                    number_of_perms++;
                                }
                                sum = 0;
                                subsum1 = 0;
                                subsum2 = 0;

                            }
                        }
                    }
                }
            }
        }
        Console.WriteLine("Number of Permuatations: "+number_of_perms);
        Console.Read();
    }
}
}

编辑

为了澄清，我正在创建一个列表，其中包含满足特定条件且长度为 n 的所有数字。考虑数字 d1d2...dn，其中每个 di 都是我们数字的一个数字。每个 di 的值可能为 1,2,...,n。如果满足以下条件，我们的号码就会在列表中

1. 所有数字的和是n的倍数，即

   d1+d2+...+dn = 0 mod n

2. 数字的每个连续相加都不是 n 的倍数，除了总和，也就是说，如果 i !=1 和 j != n，则

   di+d(i+1)+...+dj != 0 mod n

我要再次提一下，“数字”在其数字中并不严格使用数字 0-9。它可以取 1 到 n 之间的任何值。在我的代码中，我使用了 n=6 的情况。

代码通过创建一个长度为 class_length 的数组来工作(在上面的代码中，我使用了 class_length=6)。我们首先有 6 个嵌套的 for 循环，它们简单地为数组 toric_class 赋值。第一个 for 分配 toric_class[0]，第二个 for 分配 toric_class[1]，依此类推。在第一次循环中，我们生成数组 111111，然后是 111112，直到 111115，然后是 111121等。所以本质上，我们正在查看所有不包括 0 的十六进制数。一旦我们达到数组中的第六个值，我们检查数组 toric_class 并检查其值以确保它满足以上条件。如果是，我们只需将数组打印成一行，然后继续。

Answer 1

这是我的简单而低效的方法，应该对您的代码进行最少的更改。它需要共享字符串列表 var strList = new List<string>();存储使用过的号码。然后这部分:

foreach (var item in toric_class)
{
    Console.Write(item.ToString());
}
Console.Write(Environment.NewLine);
number_of_perms++; 

变成这样:

string strItem = " " + string.Join(" ", toric_class) + " "; // Example: int[] {1, 12, 123} becomes " 1 12 123 "

if (!strList.Any(str => str.Contains(strItem))) // Example: if " 1 12 123 1 12 123 " contains " 1 12 123 "
{
    Console.WriteLine(strItem);

    strItem += strItem.Substring(1); // double the string, but keep only one space between them
    strList.Add(strItem);
}

number_of_perms++; // not sure if this should be in the if statement

---

这个想法是，例如字符串 " 1 1 1 2 5 2 1 1 1 2 5 2 "包含号码的所有循环副本 {1, 1, 1, 2, 5, 2} .我使用字符串作为检查数组是否包含子数组的惰性方法，但您可以使用类似的方法将使用过的数字的副本存储在数组列表中 new List<int[]>()并检查列表中的任何数组是否是当前数组的循环副本，或者更好 HashSet<int[]>()类似于@slavanap 的回答的方法。

---

first version of my answer是最简单的，但它只适用于单个数字项目的数组。

List几乎与数组相同( new List<string>() 而不是 new string[] )，但可以更轻松高效地向其添加项目。例如{1,2}.Add(3)变成 {1,2,3} .

str => str.Contains(strItem)是接受参数 str 的函数的快捷方式并返回 str.Contains(strItem) 的结果.然后将该“功能”传递给 .Any LINQ 扩展，所以

strList.Any(str => str.Contains(strItem))

是这样的快捷方式:

foreach(string str in strList)
{
    if (str.Contains(strItem)) 
    {
        return true;
    }
}
return false;