C# 快速返回所有小于或可被7整除的数字

所以我有一个面试问题：写一个函数，它接受一个数字并返回所有小于或可被7整除的数字

    private List<int> GetLessThanOrDivisbleBySeven(int num)
    {
       List<int> ReturnList = new List<int>();

       for(int i = 0; i <= num; i++)
       {
           if(i <7 || i % 7 == 0)
           {
              ReturnList.Add(i);
            }
         }

         return ReturnList;
      }

private List getlessthanordivisiblebyseven（int num）
{
List ReturnList=新列表（）；
对于（int i=0；i您可以缓存结果。每次调用您的函数时，检查缓存中的数字，然后计算其余的数字

如果当前数字较小，请返回相应的缓存结果。
您可以缓存结果。每次调用函数时，请检查缓存中的数字，然后计算其余数字

如果当前数字较小，则返回相应的缓存结果。
面试问题通常更多地是关于您如何处理一般问题，而不是技术实现。在您的情况下，您可以做很多小事情，例如在外部缓存列表。如果space不是问题。也许有人可以想出一些更聪明的数学，以节省计算，但通常更多的是问正确的问题和考虑正确的选项。比如，如果你问“这个程序是否在web服务器上运行？也许我可以将所有数据存储在一个表中，并将其用作快速查找，而不是每次重新计算。”甚至可能没有正确或最好的答案，他们可能只是想听，你可以考虑特殊情况。
面试问题通常更多的是关于你如何处理一般问题，而不是技术实现。在你的情况下，你可以做很多小事情，比如在外面缓存列表。缓存dif如果空间不是问题的话，可以在字典中列出不同版本的列表。也许有人可以想出一些更聪明的数学，以节省计算，但通常更多的是问正确的问题和考虑正确的选项。比如，如果你问的话“此程序是否在web服务器上运行？也许我可以将所有数据存储在一个表中，并将其用作快速查找，而不是每次都重新计算。”可能甚至没有正确或最佳的答案，他们可能只是想听到，您可以考虑特殊情况。
在计算新列表时使用以前的结果

int oldMax = 0;
List<int> ReturnList = new List<int>();

private List<int> GetLessThanOrDivisbleBySeven(int num)
{
       if (num > oldMax )
       {
           oldMax  = num;
           for(int i = oldMax ; i <= num; i++)
           {
              if(i <7 || i % 7 == 0)
              {
                 ReturnList.Add(i);
               }
            }
              return ReturnList;
       }
       else 
       {
            // create a copy of ReturnList  and Remove from  the copy numbers bigger than num
       }
} 

intoldmax=0；
List ReturnList=新列表（）；
私有列表GetLessThanOrdivisableBy偶数（int num）
{
如果（num>oldMax）
{
oldMax=num；
对于（int i=oldMax；i计算新列表时使用以前的结果

int oldMax = 0;
List<int> ReturnList = new List<int>();

private List<int> GetLessThanOrDivisbleBySeven(int num)
{
       if (num > oldMax )
       {
           oldMax  = num;
           for(int i = oldMax ; i <= num; i++)
           {
              if(i <7 || i % 7 == 0)
              {
                 ReturnList.Add(i);
               }
            }
              return ReturnList;
       }
       else 
       {
            // create a copy of ReturnList  and Remove from  the copy numbers bigger than num
       }
} 

intoldmax=0；
List ReturnList=新列表（）；
私有列表GetLessThanOrdivisableBy偶数（int num）
{
如果（num>oldMax）
{
oldMax=num；
对于（int i=oldMax；i如果您想在不缓存的情况下加快速度，您可以将i增加7，以使所有数字都可以被7整除，如下所示：

        static private List<int> GetLessThanOrDivisbleBySeven(int num) {
            List<int> ReturnList;
            int i;
            if (num <= 7) {
                ReturnList = new List<int>();
                for (i = 0; i <= num; i++) {
                    ReturnList.Add(i);
                }
                return ReturnList;
            }

            ReturnList = new List<int> { 0, 1, 2, 3, 4, 5, 6 };
            i = 7;
            while (i <= num) {
                ReturnList.Add(i);
                i += 7;
            }

            return ReturnList;
        }

静态私有列表getlessthanordivisiblebyseven（int num）{
列表返回列表；
int i；
如果（num如果您想在不缓存的情况下加快速度，您可以将i增加7，使所有数字都可以被7整除，它将是这样的：

        static private List<int> GetLessThanOrDivisbleBySeven(int num) {
            List<int> ReturnList;
            int i;
            if (num <= 7) {
                ReturnList = new List<int>();
                for (i = 0; i <= num; i++) {
                    ReturnList.Add(i);
                }
                return ReturnList;
            }

            ReturnList = new List<int> { 0, 1, 2, 3, 4, 5, 6 };
            i = 7;
            while (i <= num) {
                ReturnList.Add(i);
                i += 7;
            }

            return ReturnList;
        }

静态私有列表getlessthanordivisiblebyseven（int num）{
列表返回列表；
int i；
如果（num您可以通过计算res=num/7找到所有可被7整除且小于num的数字，然后创建一个从1到res的循环，并将每个数字乘以7

private List<int> GetLessThanOrDivisbleBySeven(int num)
{
   List<int> ReturnList = new List<int>();
   // Add all the numbers that are less than 7 first
   int i = 0;
   for(i = 0; i < 7; i++)
      ReturnList.Add(i);

   int res = num / 7;// num = res*7+rem
   for(i = 1; i <= res; i++)
   {
       ReturnList.Add(i*7);
   }

   return ReturnList;
 }

private List getlessthanordivisiblebyseven（int num）
{
List ReturnList=新列表（）；
//首先将小于7的所有数字相加
int i=0；
对于（i=0；i<7；i++）
返回名单。添加（i）；
int res=num/7；//num=res*7+rem
对于（i=1；i您可以通过计算res=num/7找到所有可被7整除且小于num的数字，然后创建一个从1到res的循环，并将每个数字乘以7

private List<int> GetLessThanOrDivisbleBySeven(int num)
{
   List<int> ReturnList = new List<int>();
   // Add all the numbers that are less than 7 first
   int i = 0;
   for(i = 0; i < 7; i++)
      ReturnList.Add(i);

   int res = num / 7;// num = res*7+rem
   for(i = 1; i <= res; i++)
   {
       ReturnList.Add(i*7);
   }

   return ReturnList;
 }

private List getlessthanordivisiblebyseven（int num）
{
List ReturnList=新列表（）；
//首先将小于7的所有数字相加
int i=0；
对于（i=0；i<7；i++）
返回名单。添加（i）；
int res=num/7；//num=res*7+rem
对于（i=1；i考虑内存管理和
列表如何工作

除非您告诉它所需的容量，否则它会在空间用完时分配一个新的阵列，但是计算出它所需的大小很容易

与使用
列表相比，返回数组将节省一个对象分配，因此讨论两者之间的权衡

如何使用“YeldRead”来预置内存，或者有其他的成本要考虑吗？< /P>
是经常要求的数字，如果是这样，考虑缓存。< /P>
LINQ，可能使用
枚举范围
会有帮助吗

一个有经验的C#程序员应该至少了解一点以上的知识，内存管理通常是一个隐藏的问题。
想想内存管理和
列表
类是如何工作的

除非您告诉它所需的容量，否则它会在空间用完时分配一个新的阵列，但是计算出它所需的大小很容易

与使用
列表相比，返回数组将节省一个对象分配，因此讨论两者之间的权衡

如何使用“YeldRead”来预置内存，或者有其他的成本要考虑吗？< /P>
是经常要求的数字，如果是这样，考虑缓存。< /P>
LINQ，可能使用
枚举范围
会有帮助吗

一个有经验的C#程序员应该至少了解一点上述内容，并且内存管理通常是一个隐藏的问题。
Always 7？缓存列表。您是否试图查找“低于/可被7整除”的值或索引“？这个问题让人觉得他们想要值，但您的示例返回索引。我将是val