Aufkommen von Code n Golang: Slicing and Dicing Reports

Einführung

Dies ist also Tag 2 des Advent of Code 2024 in Golang, und wir werden meinen Ansatz und meine Lösung dafür untersuchen. Das Problem war nicht so einfach, aber nachdem es implementiert und für richtig befunden wurde, war es ziemlich einfach.

Sie können meine Lösungen hier auf GitHub ansehen.

Teil 1

Wir haben einige Zeilen erhalten, die Berichte genannt werden, und jeder Bericht hat eine Reihe von Ebenen. und die Anforderung des Berichts besteht darin, dass er entweder strikt um den Faktor 1 oder höchstens 3 ansteigt oder abnimmt.

Das heißt, wenn die ersten beiden Elemente sogar um eins zunehmen, sollten die anderen nachfolgenden Elemente in diesem Bericht um 1, 2 oder 3 Stufen ansteigen und es darf keine Änderung geben (d. h. 0 Änderung in zwei benachbarten). Zahlen oder zwei benachbarte Zahlen dürfen nicht gleich sein)

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

• Wir führen zuerst das Parsen der Eingaben durch. Es ist ziemlich einfach. Wir müssen es durch n aufteilen, um einzelne Berichte zu erhalten. Dies wird eine Zeichenfolge sein, also „7 6 4 2 1“, wir möchten ein Segment erhalten von ganzen Zahlen.

• Also machen wir weiter und teilen nach Leerzeichen/Leerzeichen „ “, um die einzelnen Ebenen (Zahlen) zu erhalten, und wir müssen sie in ganze Zahlen umwandeln.

• Sobald wir einzelne Zeichenfolgen des Berichts haben, d. h. Ebenen wie [„7“, „6“, „4“, „2“, „1“], müssen wir sie in ganze Zahlen umwandeln.

• Wir durchlaufen jeden von ihnen, wandeln sie in ganze Zahlen um und hängen sie an die Liste an.

• Sobald wir die Liste erstellt haben, hängen wir sie an die Berichtsliste an, die das Array von Arrays sein wird, d. h. jede Zeile ist ein Bericht, und jeder Bericht hat viele Ebenen, also einen Ausschnitt aus ganzen Zahlen.
  

func SplitLevels(lines []string) [][]int {
    reportLevels := [][]int{}
    for i, reportLine := range lines {
        reportLevels = append(reportLevels, []int{})
        for _, levelStr := range strings.Split(reportLine, " ") {
            level, err := strconv.Atoi(levelStr)
            if err != nil {
                log.Fatal(err)
            }
            reportLevels[i] = append(reportLevels[i], level)
        }
    }
    return reportLevels
}

Sobald wir die Berichte und Ebenen erstellt haben, fahren wir mit der eigentlichen Analyse der Muster innerhalb der Ebenen in den einzelnen Berichten fort.

Dafür:

• Wir nehmen zunächst einzelne Berichte, berechnen die Differenz zwischen den ersten beiden Elementen und denken daran, hier die absolute Differenz sorgfältig zu verwenden.

• Wir müssen ein Flag pflegen, das angibt, ob die Werte im Bericht steigen oder fallen, was mit den ersten beiden Elementen bestimmt werden kann.

  Das heißt, wenn die ersten beiden Elemente zunehmen, sollten auch die nachfolgenden Ebenen zunehmen, und wenn sie abnehmen, sollten auch alle Ebenen abnehmen

• Wir führen zunächst eine Schutzprüfung durch, um festzustellen, ob die Differenz zwischen ihnen 0 oder mehr als 3 oder weniger als -3 beträgt. Dies ist die Bedingung, dass die Ebenen sicher sind. Wenn das der Fall ist, geben wir „false“ zurück, was bedeutet, dass der Bericht nicht sicher ist.

• Wir durchlaufen nun den Bericht nach den ersten beiden Elementen und berechnen dann die Differenz zwischen den nächsten beiden Ebenen, wenn die Flagge zunimmt und wahr ist und die aktuelle Differenz kleiner oder gleich 0 ist oder größer ist 3 markieren wir es auch als falsch

• Die andere Bedingung ist, dass wenn das Flag abnimmt, was bedeutet, dass die ersten beiden Elemente eine negative Differenz hatten, wir prüfen, ob die aktuelle Differenz größer oder gleich 0 oder kleiner als - ist. 3, wenn das der Fall ist, markieren wir es als falsch

• Nachdem wir die Differenz für alle Ebenen berechnet haben und die Schleife verlassen, geben wir „true“ zurück, da wir keine Diskrepanz in den Ebenen festgestellt haben.
  

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

Teil 2

Für Teil zwei müssen wir ein paar Dinge tun, wir müssen berechnen, ob der Bericht sicher ist oder nicht, und wenn das unsicher ist, können wir fast ein Element aus dem Bericht entfernen, um ihn sicher zu machen.

Dafür lautet der Ansatz:

• Holen Sie sich den Index, in dem wir die Diskrepanz in den Ebenen zum ersten Mal gesehen haben

• Überprüfen Sie durch Entfernen dieses Elements aus dem Bericht, ob der Bericht dadurch sicher ist, und geben Sie „true“ zurück, d. h. wir haben den sicheren Bericht gefunden

• Wenn wir den Bericht immer noch für unsicher halten, entfernen Sie das Element vor dem Index, in dem die Diskrepanz gefunden wurde. Wenn wir ihn jetzt nach dem Entfernen dieses Elements für sicher halten, markieren Sie ihn als sicher

• Wenn wir den Bericht immer noch für unsicher halten, entfernen Sie das Element nach dem Index, in dem wir die Diskrepanz ursprünglich gefunden haben. Wenn der Bericht sicher wird, markieren wir diesen Bericht als sicher

• Andernfalls markieren wir den Bericht als unsicher, da wir nicht nur das entfernbare Element finden können, das den Bericht sicher macht.
  

func SplitLevels(lines []string) [][]int {
    reportLevels := [][]int{}
    for i, reportLine := range lines {
        reportLevels = append(reportLevels, []int{})
        for _, levelStr := range strings.Split(reportLine, " ") {
            level, err := strconv.Atoi(levelStr)
            if err != nil {
                log.Fatal(err)
            }
            reportLevels[i] = append(reportLevels[i], level)
        }
    }
    return reportLevels
}

Sie können meine Lösungen hier auf GitHub ansehen.

Abschluss

Das war es also, ein ziemlich einfaches Problem für Tag 2 der Einführung von Code 2024 in Golang. Ich hoffe, Ihnen hat diese Komplettlösung des Rätsels vom ersten Tag im Advent of Code 2024 in Golang gefallen.

Lassen Sie mich wissen, wenn Sie weitere interessante Lösungen haben oder etwas dazu mitteilen möchten. Feedback, Fragen oder Vorschläge sind willkommen.

Vielen Dank fürs Lesen. Wir sehen uns morgen für Tag 3

Viel Spaß beim Programmieren :)

Das obige ist der detaillierte Inhalt vonAufkommen von Code n Golang: Slicing and Dicing Reports. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!