Was ist dieser Artikel?

Ich entwickle gerade einen Roboter, der einen 2x2x2 Rubikwürfel löst. Dies ist eine Sammlung von Kommentaren zum Roboterprogramm. Ich habe einmal eine Sammlung von Artikeln geschrieben, die durch den Artikel [hier] repräsentiert werden (https://qiita.com/Nyanyan_Cube/items/60f3699db96dba4a4bf5), aber seitdem wurde die Software erheblich aktualisiert, sodass ich ein neues Programm einführen werde. Überlegen.

Der entsprechende Code ist hier verfügbar [https://github.com/Nyanyan/soltvvo/tree/master/Soltvvo3.2].

Zum Thema passende Artikel

"Lass uns einen Roboter bauen, der den Zauberwürfel löst!"

"Aktualisierte Software für Rubik Cube Robot"

Grundfunktion (dieser Artikel)
Vorberechnung
Lösungssuche
Staatliche Anerkennung
Maschinenbedienung (Python)
Maschinenbetrieb (Arduino)
Hauptverarbeitung

Dieses Mal werden wir `` `basic_functions.py``` als Grundfunktionen einführen.

Funktion zum Drehen des Puzzles

Erfahren Sie, wie Sie die Rätsel in einem Array halten und wie Sie den Vorgang zum Drehen der Rätsel implementieren.

'''Funktion zum Drehen des Würfels'''
''' Functions for twisting cube '''

#Rotationsverarbeitung CP
# Rotate CP
def move_cp(cp, arr):
    #Ersetzen Sie Teile mithilfe der Oberfläche und ersetzen Sie die Arrays
    surface = [[3, 1, 7, 5], [1, 0, 6, 7], [0, 2, 4, 6], [2, 3, 5, 4]]
    replace = [[3, 0, 1, 2], [2, 3, 0, 1], [1, 2, 3, 0]]
    res = [i for i in cp]
    for i, j in zip(surface[arr[0]], replace[-(arr[1] + 1)]):
        res[surface[arr[0]][j]] = cp[i]
    return res

#Rotationsverarbeitung CO
# Rotate CO
def move_co(co, arr):
    #Nach dem Ersetzen der Teile über die Oberfläche und dem Ersetzen von Arrays wird das pls-Array verwendet, um die Änderung des CO bei einer Drehung um 90 Grad zu reproduzieren.
    surface = [[3, 1, 7, 5], [1, 0, 6, 7], [0, 2, 4, 6], [2, 3, 5, 4]]
    replace = [[3, 0, 1, 2], [2, 3, 0, 1], [1, 2, 3, 0]]
    pls = [2, 1, 2, 1]
    res = [i for i in co]
    for i, j in zip(surface[arr[0]], replace[-(arr[1] + 1)]):
        res[surface[arr[0]][j]] = co[i]
    if arr[1] != -2:
        for i in range(4):
            res[surface[arr[0]][i]] += pls[i]
            res[surface[arr[0]][i]] %= 3
    return res

Der 2x2x2 Rubik Cube (farbige Pars) besteht aus acht Teilen eines Typs, wie in der Abbildung gezeigt. iOS の画像(26).jpg Es wäre nicht großartig, wenn Sie diesen Puzzle-Status beispielsweise in einer Farbanordnung hätten, aber er verbraucht viel Speicher und ist vor allem umständlich. Daher werden wir den Zustand des Puzzles in zwei Arrays beibehalten.

CP-Array (Corner Permutation), das die Reihenfolge der einzelnen Teile anzeigt
CO-Array (Corner Orientation), das die Ausrichtung jedes Teils anzeigt

Es gibt zwei Arten. Jedes wird durch ein Array mit 8 Elementen dargestellt. Da es 8 Teile gibt, sind die Elemente des CP-Arrays "0, 1, 2, 3, 4, 5, 6, 7", und es gibt 3 Arten der Ausrichtung jedes Teils, also das CO-Array Die Elemente sind `` `0, 1, 2```.

Die eingeführte Funktion drückt im Wesentlichen die ** Rotationsaktion ** des Puzzles durch ** Ersetzen ** des Arrays aus. In Bezug auf die CO-Anordnung ändert sich die Ausrichtung der Teile in Abhängigkeit davon, wie das Puzzle gedreht wird, sodass eine zusätzliche Verarbeitung erfolgt.

Statusindizierung

Es ist nicht sehr gut, die Rätsel immer in einem Array zu halten. Die Verarbeitung dauert lange und verbraucht Speicher. Daher werden wir im nächsten Artikel (Vorberechnung) jedem Zustand des Puzzles einen eindeutigen Wert zuordnen. Ich werde die ** Funktion, die das Array verbindet, und den Wert ** erklären, der zu diesem Zeitpunkt sehr nützlich ist.

'''Indizierung des Arrays'''
''' Indexing'''

#Erstellen Sie eine eindeutige Nummer aus dem cp-Array
# Return the number of CP
def cp2idx(cp):
    #Indiziert nach Rangmultiplikator
    res = 0
    for i in range(8):
        cnt = cp[i]
        for j in cp[:i]:
            if j < cp[i]:
                cnt -= 1
        res += fac[7 - i] * cnt
    return res

#Erstellen Sie eine eindeutige Nummer aus dem Co-Array
# Return the number of CO
def co2idx(co):
    #Ternär indiziert. Der Zustand wird durch die Betrachtung der 7 Teile eindeutig bestimmt
    res = 0
    for i in co[:7]:
        res *= 3
        res += i
    return res

#Erstellen Sie ein CP-Array aus einer eindeutigen Nummer
# Return the array of CP
def idx2cp(cp_idx):
    #Konvertierung vom Basismultiplikator zum Array
    res = [-1 for _ in range(8)]
    for i in range(8):
        candidate = cp_idx // fac[7 - i]
        marked = [True for _ in range(i)]
        for _ in range(8):
            for j, k in enumerate(res[:i]):
                if k <= candidate and marked[j]:
                    candidate += 1
                    marked[j] = False
        res[i] = candidate
        cp_idx %= fac[7 - i]
    return res

#Erstellen Sie ein Co-Array aus einer eindeutigen Nummer
# Return the array of CO
def idx2co(co_idx):
    #Konvertierung von ternär zu Array
    res = [0 for _ in range(8)]
    for i in range(7):
        res[6 - i] = co_idx % 3
        co_idx //= 3
    res[7] = (3 - sum(res) % 3) % 3
    return res

Für die Indizierung sollte das CP-Array der Reihe nach nummeriert sein, damit die Basisnummer verwendet wird. Das CO-Array betrachtet das Array selbst als 7-stellige ternäre Zahl und konvertiert es in eine Dezimalzahl.

Ich habe gerade implementiert, was auf der Website hier geschrieben ist, um die Anzahl der Ränge zu berechnen.

Sie wundern sich vielleicht über die Indizierung von CO-Arrays: "Warum betrachten Sie sie als 7-stellige ternäre Zahl, obwohl die Anzahl der Elemente 8 beträgt?" Solange sich der CO des Puzzles im selben Zustand befindet, können Sie bei Betrachtung der sieben Teile den Zustand des verbleibenden einen Teils sehen. Deshalb reicht eine 7-stellige ternäre Nummer aus.

Häufig verwendete Konstanten

Die Konstanten und Arrays, die häufig in mehreren Programmen verwendet werden, werden zusammen geschrieben.

'''Konstante'''
''' Constants '''

#Wert des Bodens
fac = [1]
for i in range(1, 9):
    fac.append(fac[-1] * i)

#Häufig verwendete Werte und Arrays
grip_cost = 1
j2color = ['g', 'b', 'r', 'o', 'y', 'w']
dic = {'w':'white', 'g':'green', 'r':'red', 'b':'blue', 'o':'magenta', 'y':'yellow'}
parts_color = [['w', 'o', 'b'], ['w', 'b', 'r'], ['w', 'g', 'o'], ['w', 'r', 'g'], ['y', 'o', 'g'], ['y', 'g', 'r'], ['y', 'b', 'o'], ['y', 'r', 'b']]
parts_place = [[[0, 2], [2, 0], [2, 7]], [[0, 3], [2, 6], [2, 5]], [[1, 2], [2, 2], [2, 1]], [[1, 3], [2, 4], [2, 3]], [[4, 2], [3, 1], [3, 2]], [[4, 3], [3, 3], [3, 4]], [[5, 2], [3, 7], [3, 0]], [[5, 3], [3, 5], [3, 6]]]
twist_lst = [[[0, -1]], [[0, -2]], [[2, -1]], [[0, -1], [2, -1]], [[0, -2], [2, -1]], [[0, -1], [2, -2]], [[1, -1]], [[1, -2]], [[3, -1]], [[1, -1], [3, -1]], [[1, -2], [3, -1]], [[1, -1], [3, -2]]]
cost_lst = [1, 2, 1, 1, 2, 2, 1, 2, 1, 1, 2, 2]
solved_cp = [[0, 1, 2, 3, 4, 5, 6, 7], [2, 3, 4, 5, 6, 7, 0, 1], [4, 5, 6, 7, 0, 1, 2, 3], [6, 7, 0, 1, 2, 3, 4, 5], [1, 7, 3, 5, 2, 4, 0, 6], [3, 5, 2, 4, 0, 6, 1, 7], [2, 4, 0, 6, 1, 7, 3, 5], [0, 6, 1, 7, 3, 5, 2, 4], [7, 6, 5, 4, 3, 2, 1, 0], [5, 4, 3, 2, 1, 0, 7, 6], [3, 2, 1, 0, 7, 6, 5, 4], [1, 0, 7, 6, 5, 4, 3, 2], [6, 0, 4, 2, 5, 3, 7, 1], [4, 2, 5, 3, 7, 1, 6, 0], [5, 3, 7, 1, 6, 0, 4, 2], [7, 1, 6, 0, 4, 2, 5, 3], [2, 0, 3, 1, 5, 7, 4, 6], [3, 1, 5, 7, 4, 6, 2, 0], [5, 7, 4, 6, 2, 0, 3, 1], [4, 6, 2, 0, 3, 1, 5, 7], [6, 4, 7, 5, 1, 3, 0, 2], [7, 5, 1, 3, 0, 2, 6, 4], [1, 3, 0, 2, 6, 4, 7, 5], [0, 2, 6, 4, 7, 5, 1, 3]]
solved_co = [[0, 0, 0, 0, 0, 0, 0, 0], [2, 1, 1, 2, 2, 1, 1, 2], [0, 0, 0, 0, 0, 0, 0, 0], [2, 1, 1, 2, 2, 1, 1, 2], [1, 2, 2, 1, 1, 2, 2, 1], [1, 2, 2, 1, 1, 2, 2, 1], [1, 2, 2, 1, 1, 2, 2, 1], [1, 2, 2, 1, 1, 2, 2, 1], [0, 0, 0, 0, 0, 0, 0, 0], [2, 1, 1, 2, 2, 1, 1, 2], [0, 0, 0, 0, 0, 0, 0, 0], [2, 1, 1, 2, 2, 1, 1, 2], [1, 2, 2, 1, 1, 2, 2, 1], [1, 2, 2, 1, 1, 2, 2, 1], [1, 2, 2, 1, 1, 2, 2, 1], [1, 2, 2, 1, 1, 2, 2, 1], [0, 0, 0, 0, 0, 0, 0, 0], [2, 1, 1, 2, 2, 1, 1, 2], [0, 0, 0, 0, 0, 0, 0, 0], [2, 1, 1, 2, 2, 1, 1, 2], [0, 0, 0, 0, 0, 0, 0, 0], [2, 1, 1, 2, 2, 1, 1, 2], [0, 0, 0, 0, 0, 0, 0, 0], [2, 1, 1, 2, 2, 1, 1, 2]]
neary_solved_depth = 15

Die Bedeutung jeder Konstante und jedes Arrays wird bei der tatsächlichen Verwendung erläutert.

Zusammenfassung

Ich habe die Grundfunktionen des Rubik Cube Roboters erklärt. Alle anderen Programme verwenden diese Funktion und Konstanten.