Question

编辑：我认为C＃编译器或网站上出现了问题，我不知道如何使它比最终获得项目更快。我改用Java，它的工作原理与C＃项目完全相同。

using System;

namespace ConsoleApp1
{
class Program
{
    static void Main(string[] args)
    {
        int testCases = int.Parse(Console.ReadLine());
        while (testCases > 0)
        {
            int nNum = int.Parse(Console.ReadLine()); //Needed num version for validation
            string[] numbers = new string[nNum];
            for (int j = 0; j < numbers.Length; j++)               
                numbers[j] = Console.ReadLine(); //This fills array with numbers                
            Array.Sort(numbers); //Sorts string array
            bool consistent = true; //Checking whether we detect any 'inconsistencies'
            for (int j = 0; j < numbers.Length - 1; j++)
            {
                if (numbers[j+1].StartsWith(numbers[j]))
                {
                    consistent = false;
                    break;
                }

            }
            Console.WriteLine(consistent ? "YES" : "NO");
            testCases--;
        }

    }
}
}

这是我对C＃的最终代码。无论我做什么，它都保持在3秒以上。

原始问题：我要尽快解决-我已经完成了这项任务，我得到了1-10000个唯一的电话号码。我必须检查数组中的数字是否是另一个数字的前缀，即“ 911”，是一个电话号码，而“ 911859285”是另一个数字，尽管我必须打印它“不是一致的列表”，第二个数字的前缀是第一个数字。

我最初的想法是嵌套的for循环...考虑到那时我必须测试1亿次比较，您可以看到这绝对是一个可怕的想法。我尝试通过布尔来突破这个嵌套循环，但是后来意识到，如果确实所有数字都有效，那么我们仍然会遇到问题。

tl; dr -我需要一种快速的方法来比较1-10000个元素的字符串数组中的元素。如果一个字符串是另一个字符串的开头，则它是无效的数字列表。

我已经看到了很多不同的东西，例如SequenceEquals和LINQ表达式，但是我决定来这里寻求专业帮助。

更新代码

using System;

namespace ConsoleApp1
{
    class Program
    {
    static void Main(string[] args)
    {
        bool validTestNum = false;
        int testCases = 0;
        try
        {
            testCases = int.Parse(Console.ReadLine());
            validTestNum = true;
            if (testCases < 1 || testCases > 40)
            {
                validTestNum = false;
            }
        }
        catch { }

        for (int i = 0; i < testCases; i++)
        {
            bool validN = false;
            string nString = ""; //Needed string 
            int nNum = 0; //Needed num version for validation
            while (!validN)
            {
                nNum = int.Parse(Console.ReadLine());
                validN = true;
                if (nNum < 1 || nNum > 10000)
                    validN = false; //This is validating the amount of phone numbers received
            }

            nString = nNum.ToString();
            string[] numbers = new string[int.Parse(nString)];
            for (int j = 0; j < numbers.Length; j++)
            {
                numbers[j] = Console.ReadLine(); //This fills array with numbers
            }

            bool consistent = true; //Checking whether we detect any 'inconsistencies'
            Array.Sort(numbers); //Sorts string array

            for (int j = 1; j < numbers.Length; j++)
            {
                string possiblePrefix = numbers[j - 1];
                if (j < numbers.Length && numbers[j].StartsWith(possiblePrefix))
                {
                    consistent = false;
                    break;
                }
            }

            if (consistent)
            {
                Console.WriteLine("YES"); //Means the list is consistent
            }
            else if (!consistent)
            {
                Console.WriteLine("NO"); //Means it isn't
            }
        }
        Console.ReadLine();

    }
}

}

Answer 1

排序数组。较短的数字（例如“ 911”）将始终位于它所包含的任何较长的数字之前。排序列表示例：

因此，您要做的就是检查给定的数字是否是下一个数字的开头。您可以立即停止。

Array.Sort(a);
for (int i = 1; i < a.Length; i++) { // Note: we start at index 1, not 0
    string possiblePrefix = a[i - 1];
    for (int k = i; k < a.Length && a[k].StartsWith(possiblePrefix); k++) {
        // a[k] is inconsistent with possiblePrefix , add it to a list or whatever.
        Console.WriteLine($"{possiblePrefix} - {a[k]}");
    }
}

请注意，对于大多数数字，内部循环甚至不会开始循环。仅在极少数情况下发现不一致，它才会循环。因此，这是一种接近O(n)的算法。排序是一项O(n log(n))操作。

如果只需要知道系列的第一个不一致之处，也可以用简单的if替换内部循环。

Answer 2

如果您想走这条路，这是一个LINQ解决方案：

static void Main(string[] args)
{
    var list = new List<string>
    {
        "1",
        "23",
        "456",
        "7890",
        "23457"
    };

    var prefixFound = false;
    foreach (var num in list)
    {
        if (list.Any(x => x.StartsWith(num) && x != num))
        {
            prefixFound = true;
            Console.WriteLine(num);
            break;
        }
    }
    if (!prefixFound)
        Console.WriteLine("Consistent list.");

    Console.ReadLine();
}

&& x != num条件是排除数字在技术上以其开头的情况。

快速比较相同字符串数组的元素

2 个答案: