Sudoku-Algorithmus in C#

Bräuchte ich einen liner (oder nahe daran), dass überprüft, ob gegebene array mit 9 Elementen enthalten nicht wiederholende zahlen 1,2,3,...,9. Wiederholen Nullen zählen nicht (Sie repräsentieren leere Zellen).

Die besten, die ich kam so weit ist:

var a = new int[9] {1,2,3,4,5,6,7,8,9};
var itIsOk = a.Join(a, i => i, j => j, (x, y) => x)
    .GroupBy(y => y).Where(g => g.Key > 0 && g.Count() > 1).Count() == 0;

Wenn Sie nicht wollen, meine Probleme zu lösen :), könnte Sie zumindest sagen, ob der obige Algorithmus funktioniert korrekt?

Und, ja, gelesen haben diese eine.

Führen Sie den code und finden Sie heraus?
Was bedeutet, dass Sie nicht wollen, um mir zu helfen 🙂
Die Gemeinschaft hilft denen, die sich selbst helfen
"Führen Sie den code und finden out" ist keine akzeptable Methodologie für die überprüfung der Richtigkeit.

InformationsquelleAutor Prankster | 2009-04-06

c#linq sudoku

10

Glück für Sie baute ich ein sudoku-solver selbst vor nicht allzu langer Zeit 🙂 Das ganze war über 200 Zeilen C#, und es würde lösen die schwierigsten Rätsel, die ich finden konnte, line-in 4 Sekunden oder weniger.

Leistung ist wohl nicht so toll wegen der Verwendung von .Zählen, aber es sollte funktionieren:
```
!a.Any(i => i != 0 && a.Where(j => j != 0 && i == j).Count >  1)
```
Auch, die j != 0 Teil ist nicht wirklich notwendig, aber es sollte helfen, die Dinge laufen ein wenig schneller.

[edit:] kvb Antwort gab mir eine andere Idee:
```
!a.Where(i => i != 0).GroupBy(i => i).Any(gp => gp.Count() > 1)
```
Filter die 0 vor Gruppierung. Obwohl die basieren auf, wie IEnumerable funktioniert es möglicherweise nicht egal.

Entweder Weg, Für optimale Leistung ersetzen Sie .Count > 1 in einer von den beiden mit einem neuen IEnumerable-Erweiterung-Methode, die wie folgt aussieht:
```
bool MoreThanOne(this IEnumerable<T> enumerable, Predictate<T> pred)
{
    bool flag = false;
    foreach (T item in enumerable)
    {
       if (pred(item))
       {
          if (flag)
             return true;
          flag = true;
       }
    }
    return false;
}
```
Wird es das wohl auch keine Rolle, zu viel, da arrays sind beschränkt auf 9 Punkte, aber wenn Sie nennen es eine Menge, es könnte hinzufügen.

InformationsquelleAutor Joel Coehoorn

Dies ist etwa 50-250 mal schneller als eine LINQ Lösung (je nachdem, wie früh das Duplikat gefunden wird):

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;
}

+1 mit Abstand die beste Antwort. Präzise, schnell, lesbar, wiederverwendbar, testbar.
Da gab es nicht viel Erklärung mit dieser Lösung, hier ist was Los für diejenigen, die nicht sicher sind: stackoverflow.com/questions/5111434/...

InformationsquelleAutor Guffa

3

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

InformationsquelleAutor kvb
2

Warum wollen Sie eine gewundene Linie von Linq-code, sondern als Zusammenfassung eine effiziente Durchführung des Tests in eine extension-Methode und aufrufen?
```
var a = new int[9] {1,2,3,4,5,6,7,8,9};
var itIsOk = a.HasNoNonZeroRepeats();
```
Einer Umsetzung von NoNonZeroRepeats könnte die 9 untersten bits einer kurzen anzugeben Vorhandensein eines Wertes in das array, wodurch ein O(length(a)) test mit keinen dynamischen Speicher verwenden. Linq ist Niedlich, aber es sei denn, Sie sind nur aus ästhetischen Gründen (Sie nicht ausdrücklich sagen, dass Sie schreiben ein sudoku-solver, die nur mithilfe von Linq als eine übung) es scheint nur die Komplexität hier.

Ich denke nicht, dass die vorgeschlagenen Lösungen von Joel Coehoorn sind vielschichtig. (Ich kann nicht sagen das gleiche über mir :).
Sie sind deutlich komplizierter als bei einem einzelnen Aufruf der Methode, sowohl in Bezug auf das, was geschrieben steht und was ausgeführt wird, und erfordert Ausschneiden und einfügen, wo immer Sie brauchen, um den test durchzuführen, die sehr schlechte software-engineering.
Es bedeutet nicht, dass Sie nicht wickeln Sie diese one-liner in eine Funktion mit einem aussagekräftigen Namen.
An dem Punkt wird es irrelevant, ob es ein Einzeiler oder nicht. Es sei denn, Sie haben einige seltsame 'nicht mehr als eine Zeile code in jeder Methode" - Regel.
Tatsächlich, es ist "nicht mehr als 3 Zeilen pro Methode" - Regel (M. Fawler et al) 🙂 Aber der Punkt mit LINQ ist seine Kombinierbarkeit, wo Sie können Kette Abfragen zusammen, um neue Abfragen

InformationsquelleAutor Pete Kirkham

Dies ist eine alte Frage, aber ich wurde vor kurzem darauf hingewiesen, eine 1-line-Lösung mit Oracle benutzerdefinierte SQL-tut für Baum-ähnlichen Strukturen. Ich dachte, es wäre schön, zu konvertieren, das in Linq.

Lesen Sie mehr auf meinem blog darüber, wie Lösen Sie Sudoku in 1 Zeile von Linq

Hier ist der code:

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];
}

InformationsquelleAutor Jason

1

Wie etwa:
```
var itIsOk = a.Where(x => x > 0).Distinct().Count() == a.Where(x => x > 0).Count();
```
Argumentation: Zuerst erstellen Sie eine enumeration ohne 0EN. Aus den verbleibenden zahlen, wenn seine Besondere Liste ist die gleiche Länge wie die aktuelle Liste, dann gibt es keine Wiederholungen.

oder:
Wenn die Liste von eindeutigen Nummern kleiner als die eigentliche Liste, dann müssen Sie eine wiederholte Anzahl.

Dies ist die Einzeiler-version. Die ein.Where(x=>x>0) die Liste könnte ausgeklammert.
```
var nonZeroList = a.Where(x => x > 0).ToList();
var itIsOk = nonZeroList.Distinct().Count() == nonZeroList.Count();
```
InformationsquelleAutor geofftnz

Ich in der Regel Stirnrunzeln auf Lösungen, die Einbeziehung der erfassten Variablen, aber ich hatte den Drang, das zu schreiben:

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);
}

InformationsquelleAutor Amy B

1

Für die Kürze, wenn nicht die Leistung, wie über
var itIsOk = ein.Summe() == ein.Distinct().Summe();

InformationsquelleAutor Richard Astle

Folgende ist einfach und schnell.

if a.Select(i => Math.Pow(2, i - 1)).ToArray().Sum()==511 ...

InformationsquelleAutor Scormer

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.