C# 需要帮助创建一个'；ll返回按排序顺序可被5整除的元素数组

所以我需要创建一个算法来显示数组元素可以被5整除，范围从0到1000。 以下是说明：

设A是{0，1000}范围内n个正整数的数组。设m是5的倍数的整数。编写一个O（n）算法，以查找并返回按排序顺序可被5整除的m个元素的数组

这是我到目前为止的代码。。。到目前为止，我能在我的终端得到的只有2，2，2。我知道还有很多事情要做，我被卡住了。我还需要什么

namespace Sort_Assignment
{
class Program
{

    static void Main(string[] args)
    {
        // Create array of 0 to 1000 elements
        int[] array = new int[] {0, 1000};


        // Start from 0 and increment parameters by 1 until the end
        for (int i = 0; i <= array.Length; i++)
        {
            Console.WriteLine(array.Length);
        }
    }
}

名称空间排序\u分配
{
班级计划
{
静态void Main（字符串[]参数）
{
//创建0到1000个元素的数组
int[]数组=新的int[]{0，1000}；
//从0开始，将参数递增1，直到结束
对于（int i=0；i您应该检查以下内容：

 >p>检查语法以初始化数组。在这种情况下，由于必须初始化数组中的前1000个元素，最好在将数组的大小设置为1000之后，在循环中执行此操作。还可以考虑使用c*集合库。

你必须使用模运算符来检查这个数字是否可以被5整除。当你做a%b时，结果等于你用a除以b得到的余数

请参阅下面的代码以了解想法：

class Program
{

    static void Main(string[] args)
    {
        List<int> list = new List<int>();
        for(int i = 0; i < 1000; i++)
        {
            list.Add(i);
        }

        int[] arr = new int[1000];
        arr = list.ToArray();

        // Start from 0 and increment parameters by 1 until the end
        for (int i = 0; i < arr.Length; i++)
        {
            if(arr[i] % 5 == 0)
            {
                Console.WriteLine(arr[i]);
            }
        }
    }
}

类程序
{
静态void Main（字符串[]参数）
{
列表=新列表（）；
对于（int i=0；i<1000；i++）
{
列表.添加（i）；
}
int[]arr=新int[1000]；
arr=list.ToArray（）；
//从0开始，将参数递增1，直到结束
对于（int i=0；i
列出版本

var l = new List<int>(); // Declare list to load items divisible by 5

for (int i = 0; i <= 1000; i++) // Load list with items divisible by 5
{
    if (i % 5 == 0) // add item with no modulus remainder
        l.Add(i);
}

foreach (var i in l) // Print items
    Console.WriteLine(i);

您可以使用linq函数

    int start = 0;
    int end = 1000;
    int divisible = 5;

    var list = System.Linq.Enumerable.Range(start, (end / divisible)+1)
                                     .Select(i => i * divisible);
    foreach (var item in list)
    {
        Console.WriteLine (item);
    }

你不明白的是这条线

// Create array of 0 to 1000 elements
int[] array = new int[] {0, 1000};

创建了一个包含两个元素的数组

array[0] = 0
array[1] = 1000;

您需要了解的另一件事是，如果要显示可被5整除的元素，则需要使用模运算符（%）

这将数字除以5，结果将是余数

Remainder Example: 11 % 5 = 1

相反，您可以尝试以下两种不同的方法：

一种方法是不使用Linq
另一种方法是使用Linq，只需一行代码即可完成
代码

using System;
using System.Linq;

public class Program
{
    public static void Main()
    {
        // Initialize array with elements from 0 - 1000
        int[] array = new int[1001];
        for (int i = 0; i < array.Length; i++) 
        {
            array[i] = i;
        }

        // Print the elements that are divisible by 5
        foreach (int a in array)
        {
            if (a % 5 == 0)
            {
                Console.WriteLine(a);
            }
        }

        // One liner using Linq
        Enumerable.Range(0, 1001).Where(i => i % 5 == 0).ToList().ForEach(Console.WriteLine);
    }
}

使用系统；
使用System.Linq；
公共课程
{
公共静态void Main（）
{
//使用0到1000之间的元素初始化数组
int[]数组=新int[1001]；
for（int i=0；ii%5==0.ToList（）.ForEach（Console.WriteLine）；
}
}


希望这有帮助！
要获得O（n）解决方案，您可以使用计数排序（因为范围相对较小）。因此，下一步可以解决您的问题：

public List DivisibleBy5Sorted（IEnumerable a）
{
var count=new int[251]；//count[i]将是原始数组中5*i元素的计数
foreach（a中的var i）
{
//我们对不能除以5的数字不感兴趣
如果（i%5！=0）
持续
计数[i/5]++；
}
var result=新列表（）；
//按升序遍历所有元素
对于（var i=0；i 1.“我在终端中只能得到2,2,2”-您正在打印数组长度，而不是项。2.是您的朋友。您已使用两个元素初始化了一个数组`int[]array=new int[]{0，1000}；`这就是为什么您会得到2,2,2的输出，您已将数组初始化为{0，1000}。这意味着您的数组长度是2。现在您正在运行从0到2（包括2）的循环。这意味着程序将打印数组长度3次。var array=new int[]{0，250，…，1000}.ToList（）。其中（x=>（x%5）。等于（0））。OrderBy（x=>x）。ToArray（）；您可以使用计数排序，类似于
list[arr[i]/5]+=1
。对不起，我不懂C，不能做更多。你的答案是最好的，但我想这会打印到1005年，我想你需要用
（end/divisible）+1
=>
（end/divisible）+1
我评论中的打字
（end/divisible）+1
（end/divisible）
（end/divisible）
：）来更改
（end/divisible）
即使可以整除，也不会打印结尾。我在post之前测试过：）N个数字的数组…按排序顺序返回M个数字…我看不到任何类似于这些要求的内容…问题是“一种算法，它将按排序顺序返回可被5整除的元素数组”我想我的答案给出了答案。N个数字的数组…按排序顺序返回M个数字…我看不到任何类似于这些要求的东西…看起来不错！但是为什么使用1001而不是1000？有什么特别的原因吗？因为0-1000是所需的范围。我读到“让A是范围{0，1000}内的N个正整数的数组”作为一个值为0-1000的数组。@普雷斯顿-请您编辑这个问题，使其与公认的答案一致好吗？“设A为{0，1000}范围内n个正整数的数组。”与“0到1000个整数的顺序数组”有很大的不同，实际上顺序数组不需要对“O（n）…按排序顺序”进行任何处理.与此答案相比，问题中的不同要求使所有答案无效-因此，请善待回答者并更改您的问题（请注意，此代码不会为您的作业提供答案，因为它回答了非常不同的问题）
Remainder Example: 11 % 5 = 1

using System;
using System.Linq;

public class Program
{
    public static void Main()
    {
        // Initialize array with elements from 0 - 1000
        int[] array = new int[1001];
        for (int i = 0; i < array.Length; i++) 
        {
            array[i] = i;
        }

        // Print the elements that are divisible by 5
        foreach (int a in array)
        {
            if (a % 5 == 0)
            {
                Console.WriteLine(a);
            }
        }

        // One liner using Linq
        Enumerable.Range(0, 1001).Where(i => i % 5 == 0).ToList().ForEach(Console.WriteLine);
    }
}