Question

首先，我要向 Marc Gravel，Dahlbyk 表示衷心的感谢，其余的帮助我实际应用linq。

以下是我在面试中遇到的几个问题，以解决应用Linq问题。因为我不熟悉Linq，所以我没有使用 Linq。

解决了它

我很感激帮助我使用 Linq

解决这些问题的答案

提前致谢。

<小时/> 问题1： 问题是要找到不同的数字，这样，无论以何种顺序使用它们来制作一个三位数的数字，该数字都不能被这个数字整除：

3,5,7,11,13或17。

为了确保没有任何矛盾，假设三位数是a，b和c.Then，没有数字的组合：

说abc，acb，bac，bca，cab和cba将除以3,5,7,11,13或17。 的

示例：

当我拿248时，它的任何组合（284,428,482,842,824）都不会被3,5,7,11,13或17整除。

public void FindingRareNumbers()
{
   for (int i = 1; i <= 9; i++)
   {
    for (int j = 1; j <= 9; j++)
    {
      for (int k = 1; k <= 9; k++)
      {
   //to form the three digit
    string digit = i.ToString() + j.ToString() + k.ToString();
   //converting to  integer
    int StrToDigit = Convert.ToInt32(digit);
    char[] digitcombination = digit.ToCharArray();
    string PossibleCombination = "";

    bool testpassed = false;
    int dcount = 0;
     #region different possible combinations 

       for (int p = 0; p <= 2; p++)
        {
         for (int q = 0; q <= 2; q++)
          {
            for (int r = 0; r <= 2; r++)
            {
             // The following condition avoid the repeatance 
              // of digit like 111,111,111
               if (p != q && p != r && r != q)
               {
                  PossibleCombination =  

                  digitcombination[p].ToString() +                               
                  digitcombination[q].ToString() +
                  digitcombination[r].ToString();

                  int num =  Convert.ToInt32(PossibleCombination);

                  if (num % 3 != 0 && num % 5 != 0 && num % 7 != 0 
                      && num % 11 != 0 && num % 11 != 0
                      && num % 13 != 0 && num % 17 != 0)
                    {
                       //count is increment for 6 times
                       // it satisfies the condition    
                         dcount++;
                         testpassed = true;
                   }

             }

          }
      }
  }

   #endregion combination
  if (testpassed && dcount==6)

  {

    Console.WriteLine(StrToDigit);

  }

 }
}
}               
}

（编码工作）

问题2：

任务是将元素排列在矩阵中，以便所有行，列和对角线加起来相同。（编码中的位问题，我正在尝试解决它。）

------------------
1     2        3  
-----------------
4     5        6
-----------------
7     8        9
-----------------

示例：

解决方案之一如下：

-----------
2   9   4
-----------
7   5   3
----------
6   1   8
----------

Answer 1

我同意Marc解决您的第一个问题是一种合理的方法。但我认为这里有一个更大的问题，那就是“如何以LINQ-ish的方式解决这样的问题？”

请注意您的解决方案是完全“程序性的”和“必要的”。您的代码指定了一系列步骤，您将使用深循环一个接一个地执行这些步骤。除非你了解它在更大的整体中的位置，否则沿途的每一步都是毫无意义的。

在解决LINQ问题时，我想用两个想法：

描述程序正在做什么逻辑，而不是列出一系列命令
将问题描述为针对数据集的查询，而不是要遵循的过程。

那么，我们的数据集是什么？我们希望从三位数的所有组合的集合中过滤掉一些元素。

我们如何过滤它们？置换数字，然后对每个排列执行可除性检查。

好的，现在我们有了一个程序结构：

var query = from c in ThreeDigitCombinations() where DivisibilityCheckPasses(c) select c; foreach(Combination result in query) Console.WriteLine(result);

现在你可以继续分解每一个，依次使用LINQ解决每个子问题。

同样适合你的“魔方”问题;你正在寻找具有某种属性的排列，所以写一个排列生成器，编写一个过滤器，然后执行它。

Answer 2

第一个：

static IEnumerable<int> Permute(int x, int y, int z)
{
    yield return x * 100 + y * 10 + z;
    yield return x * 100 + z * 10 + y;
    yield return y * 100 + x * 10 + z;
    yield return y * 100 + z * 10 + x;
    yield return z * 100 + x * 10 + y;
    yield return z * 100 + y * 10 + x;
}
static void Main()
{
    var divs = new[] {3,5,7,11,13,17};
    // combinations of 1-9
    var combinations =
              from x in Enumerable.Range(1, 7)
              from y in Enumerable.Range(x + 1, 8 - x)
              from z in Enumerable.Range(y + 1, 9 - y)
              select new { x, y, z };

    // permute
    var qry = from comb in combinations
              where !Permute(comb.x, comb.y, comb.z).Any(
                i => divs.Any(d => i % d == 0))
              select comb;

    foreach (var answer in qry)
    {
        Console.WriteLine("{0}, {1}, {2}", answer.x, answer.y, answer.z);
    }
}

对于第二个 - 不优雅，但它有效（返回样本的8个排列）：

static void Main() {
    var data = Enumerable.Range(1, 9);
    var magicSquares =
        // generate 1st row and deduce the target
        from a in data let arrA = new[] { a }
        from b in data.Except(arrA) let arrB = new[] { a,b }
        from c in data.Except(arrB) let arrC = new[] { a,b,c }
        let target = a + b + c
        // generate 2nd row and filter to target matches
        from d in data.Except(arrC) let arrD = new[] { a,b,c,d }
        from e in data.Except(arrD) let arrE = new[] { a,b,c,d,e }
        from f in data.Except(arrE) let arrF = new[] { a,b,c,d,e,f }
        where d + e + f == target 
        // generate 3rd row and filter to target matches
        from g in data.Except(arrF) let arrG = new[] { a,b,c,d,e,f,g }
        from h in data.Except(arrG) let arrH = new[] { a,b,c,d,e,f,g,h }
        from i in data.Except(arrH)
        where g + h + i == target
        // filter columns
           && a + d + g == target
           && b + e + h == target
           && c + f + i == target
        // filter diagonals
           && a + e + i == target
           && c + e + g == target 
       select new {a,b,c,d,e,f,g,h,i};

    foreach (var row in magicSquares)
    {
        Console.WriteLine("{0} {1} {2}", row.a, row.b, row.c);
        Console.WriteLine("{0} {1} {2}", row.d, row.e, row.f);
        Console.WriteLine("{0} {1} {2}", row.g, row.h, row.i);
        Console.WriteLine();
    }
}

使用linq解决脑筋急转弯

2 个答案: