Алгоритм судоку в C#

Это приблизительно в 50-250 раз быстрее, чем решение LINQ (в зависимости от того, как рано дубликат найден):

public static bool IsValid(int[] values) {
    int flag = 0;
    foreach (int value in values) {
        if (value != 0) {
            int bit = 1 << value;
            if ((flag & bit) != 0) return false;
            flag |= bit;
        }
    }
    return true;
}

!a.GroupBy(i => i).Any(gp => gp.Key != 0 && gp.Count() > 1)

Я обычно осуждаю решения, которые включают полученные переменные, но у меня было желание записать это:

bool hasRepeating = false;
int previous = 0;

int firstDuplicateValue = a
  .Where(i => i != 0)
  .OrderBy(i => i)
  .FirstOrDefault(i => 
  {
    hasRepeating = (i == previous);
    previous = i;
    return hasRepeating;
  });

if (hasRepeating)
{
  Console.WriteLine(firstDuplicateValue);
}

Как насчет:

var itIsOk = a.Where(x => x > 0).Distinct().Count() == a.Where(x => x > 0).Count();

Обоснование: Сначала создайте перечисление без 0s. Из остающихся чисел, если его отличный список является той же длиной как фактический список, то нет никаких повторений.

или: Если список уникальных чисел меньше, чем фактический список, то у Вас должно быть повторное число.

Это - версия остроты. A. Где (x => x> 0) список мог быть факторизован.

var nonZeroList = a.Where(x => x > 0).ToList();
var itIsOk = nonZeroList.Distinct().Count() == nonZeroList.Count();

Почему Вы хотите замысловатую строку кода Linq, вместо того, чтобы обернуть эффективное внедрение теста в дополнительном методе и назвать это?

var a = new int[9] {1,2,3,4,5,6,7,8,9};
var itIsOk = a.HasNoNonZeroRepeats();

Одна реализация NoNonZeroRepeats могла быть должна использовать 9 самых низких битов короткого для указания на присутствие значения в массиве, дав O (длина (a)) тест без использования динамической памяти. Linq является милым, но если Вы только не используете его по эстетическим причинам (Вы конкретно не говорите запись решателя судоку с помощью только Linq в качестве осуществления), это, кажется, просто добавляет сложность здесь.

Это старый вопрос, но недавно мне было указано на однострочное решение с использованием пользовательского SQL Oracle для делать древовидные структуры. Я подумал, что было бы неплохо преобразовать это в Linq.

Вы можете прочитать больше в моем блоге о том, как решать судоку в одной строке Linq

Вот код:

public static string SolveStrings(string Board)
{
    string[] leafNodesOfMoves = new string[] { Board };
    while ((leafNodesOfMoves.Length > 0) && (leafNodesOfMoves[0].IndexOf(' ') != -1))
    {
        leafNodesOfMoves = (
            from partialSolution in leafNodesOfMoves
            let index = partialSolution.IndexOf(' ')
            let column = index % 9
            let groupOf3 = index - (index % 27) + column - (index % 3)
            from searchLetter in "123456789"
            let InvalidPositions =
            from spaceToCheck in Enumerable.Range(0, 9)
            let IsInRow = partialSolution[index - column + spaceToCheck] == searchLetter
            let IsInColumn = partialSolution[column + (spaceToCheck * 9)] == searchLetter
            let IsInGroupBoxOf3x3 = partialSolution[groupOf3 + (spaceToCheck % 3) +
                (int)Math.Floor(spaceToCheck / 3f) * 9] == searchLetter
            where IsInRow || IsInColumn || IsInGroupBoxOf3x3
            select spaceToCheck
            where InvalidPositions.Count() == 0
            select partialSolution.Substring(0, index) + searchLetter + partialSolution.Substring(index + 1)
                ).ToArray();
    }
    return (leafNodesOfMoves.Length == 0)
        ? "No solution"
        : leafNodesOfMoves[0];
}