python 3 단계 큐 브 복원 을 위 한 예제 코드

14464 단어 python3 단계 마방
사고의 방향
큐 브 복원 어 려 운 문제 의 분해:
1.적당 한 데이터 구조 로 3 단계 큐 브 의 6 개 면 과 각 면 의 색 을 나 타 냅 니 다.
2.매번 서로 다른 회전 작업 의 실현
3.복원 시 현재 큐 브 가 어떤 공식 을 사용 해 야 하 는 지 어떻게 판단 합 니까?
이번 실험 은 앞의 두 가지 조작 을 실 현 했 는데 구체 적 인 사고방식 은 다음 과 같다.
numpy 라 이브 러 리 의 행렬 로 6 개의 면 을 각각 표시 하고 상하 좌우 전후 순 으로 목록 에 넣 습 니 다.그 다음 에 유행 공식 에서 의 방법 에 따라 모든 면 을 회전 시 키 는 함 수 를 작성 하고 함 수 를 호출 하여 마방 의 회전 을 실현 합 니 다.마지막 으로 명령 을 입력 하면 회전 후의 큐 브 를 얻 을 수 있 고 역순 명령 을 실행 한 후 큐 브 복원 을 검증 할 수 있 습 니 다.
예비 지식
매트릭스:numpy 라 이브 러 리 의 매트릭스 구 조 를 사용 합 니 다.
함수 설명:
U:위 에서 시계 방향 으로 90°회전
D:바닥 이 시계 방향 으로 90°회전 합 니 다.
L:왼쪽 시계 방향 으로 90°회전
R:오른쪽 시계 방향 으로 90°회전
F:정면 시계 방향 으로 90°회전
B:뒷면 은 시계 방향 으로 90°회전 합 니 다.
**주:**자모 앞 에 밑줄''시계 반대 방향
코드 상세 설명
이번 실험 은[위,아래,왼쪽,오른쪽,앞,뒤]여섯 개의 면 을 숫자[0,1,2,3,4,5]로 원래 의 각 면 의 색깔 을 표시 하고 목록 faces[]에 순서대로 저장 합 니 다(즉,faces[0]에 저 장 된 것 은 맨 위의 숫자 가 모두 0 인 3 단계 행렬 입 니 다)
주:마방 의 시각 은 항상 고정 되 어 있 습 니 다.즉,전체 과정 에서 정(왼쪽...)면 은 항상 정(왼쪽...)면 입 니 다.

#      ，  faces   ，    （0）， （1）， （2）， （3）， （4）， （5）
faces = [np.zeros((3, 3))]

for i in range(1, 6):
    faces.append(np.ones((3, 3)) + faces[i - 1])
在这里插入图片描述
각 면 의 시계 방향 과 시계 반대 방향 회전 은 함수 clockwise()와 antiClockwise()로 이 루어 집 니 다.

t = np.array([[0, 0, 1],
              [0, 1, 0],
              [1, 0, 0]])

#         90  
def clockwise(face):
    face = face.transpose().dot(t)
    return face

#         90  
def antiClockwise(face):
    face = face.dot(t).transpose()
    return face
A.transpose()방법 은 A 행렬 의 전환 을 실현 하 는 것 이다.
A.dot(B)방법 은 A 곱 하기 행렬 B 를 실현 하 는 것 이다.
계산 을 통 해 상기 방법 은 행렬 의 시계 방향 이나 시계 반대 방향 으로 회전 하 는 효 과 를 실현 할 수 있다.
여기 서 왼쪽 의 시계 방향 으로 90°회전 하 는 것 을 예 로 들 면 다른 회전 방식 은 비교 할 수 있다.

def L(FACES):
    FACES[2] = clockwise(FACES[2])
    FACES_new = cp.deepcopy(FACES)
    a, b, c, d = clockwise(FACES_new[4]), clockwise(FACES_new[1]), antiClockwise(FACES_new[5]), clockwise(FACES_new[0])
    e, f, g, h = cp.deepcopy(a), cp.deepcopy(b), cp.deepcopy(c), cp.deepcopy(d)
    e[0], f[0], g[0], h[0] = d[0], a[0], b[0], c[0]
    FACES[4], FACES[1], FACES[5], FACES[0] = antiClockwise(e), antiClockwise(f), clockwise(g), antiClockwise(h)
1.함 수 를 직접 호출 하여 왼쪽(2 면)을 시계 방향 으로 90°회전 시 킵 니 다.

FACES[2] = clockwise(FACES[2])
2.여 기 는 깊이 있 게 복사 하고 cp.deepcopy()를 사용 하 는 방법 으로 등호'='을 직접 사용 하여 서로 다른 변 수 를 같은 값 으로 가리 키 지 않도록 합 니 다.이때[e,f,g,h]와[a,b,c,d]는 큐 브 의
[정면,바닥 은 시계 방향 으로 90°회전 하고 뒷면 은 시계 반대 방향 으로 90°회전 하 며 위 는 시계 방향 으로 90°회전 합 니 다]

a, b, c, d = clockwise(FACES_new[4]), clockwise(FACES_new[1]), antiClockwise(FACES_new[5]), clockwise(FACES_new[0])
회전의 목적 은:
왼쪽 에서 회전 하 는 과정 에서 왼쪽 은 다른 네 면 에 영향 을 미 치지 만 다른 네 면 에 미 치 는 영향 은 다르다.예 를 들 어 정면,바닥 과 위 에 영향 을 받 는 것 은 첫 번 째 열 이 고 뒷면 에 영향 을 받 는 것 은 세 번 째 열 이다.우 리 는 각 면 을 통일 시 키 고 수치의 변 화 를 편리 하 게 하기 위해 서,우 리 는 정,바닥,위 를 시계 방향 으로 90°회전 시 키 고,뒷면 을 시계 반대 방향 으로 90°회전 시 키 는 것 을 선택한다.이때 우 리 는 각 면 의 첫 줄 을 순서대로 교환 하고 마지막 에 시계 반대 방향 이나 시계 방향 으로 돌아 오 면 된다.
在这里插入图片描述
3.순서대로 교환:정면 첫 번 째 줄 은 마지막 줄 로 전달 합 니 다.
위의 첫 줄 은 정면 첫 줄 로 전달 된다.
뒷면 첫 줄 이 위 첫 줄 로 넘 어 갑 니 다.
바닥 첫 줄 은 뒷면 첫 줄 로 전달 합 니 다.

e[0], f[0], g[0], h[0] = d[0], a[0], b[0], c[0]
마지막 으로 상기 조작 에 따라 역 회전 하여 돌아 갑 니 다.

FACES[4], FACES[1], FACES[5], FACES[0] = antiClockwise(e), antiClockwise(f), clockwise(g), antiClockwise(h)
코드

import numpy as np
import copy as cp

#      ，  faces   ，    （0）， （1）， （2）， （3）， （4）， （5）
faces = [np.zeros((3, 3))]

for i in range(1, 6):
    faces.append(np.ones((3, 3)) + faces[i - 1])

t = np.array([[0, 0, 1],
              [0, 1, 0],
              [1, 0, 0]])

#         90  
def clockwise(face):
    face = face.transpose().dot(t)
    return face

#         90  
def antiClockwise(face):
    face = face.dot(t).transpose()
    return face


def U(FACES):
    FACES[0] = clockwise(FACES[0])
    FACES_new = cp.deepcopy(FACES)
    a, b, c, d = FACES_new[4], FACES_new[2], FACES_new[5], FACES_new[3]
    FACES[4][0], FACES[2][0], FACES[5][0], FACES[3][0] = d[0], a[0], b[0], c[0]


def _U(FACES):
    FACES[0] = antiClockwise(FACES[0])
    FACES_new = cp.deepcopy(FACES)
    a, b, c, d = FACES_new[4], FACES_new[2], FACES_new[5], FACES_new[3]
    FACES[4][0], FACES[2][0], FACES[5][0], FACES[3][0] = b[0], c[0], d[0], a[0]


def U2(FACES):
    for i in range(2):
        U(FACES)
    '''
    FACES[0] = clockwise(clockwise(FACES[0]))
    FACES_new = cp.deepcopy(FACES)
    a, b, c, d = FACES_new[4], FACES_new[2], FACES_new[5], FACES_new[3]
    FACES[4][0], FACES[2][0], FACES[5][0], FACES[3][0] = c[0], d[0], a[0], b[0]
    '''


def D(FACES):
    FACES[1] = clockwise(FACES[1])
    FACES_new = cp.deepcopy(FACES)
    a, b, c, d = FACES_new[4], FACES_new[2], FACES_new[5], FACES_new[3]
    FACES[4][2], FACES[2][2], FACES[5][2], FACES[3][2] = b[2], c[2], d[2], a[2]


def _D(FACES):
    FACES[1] = antiClockwise(FACES[1])
    FACES_new = cp.deepcopy(FACES)
    a, b, c, d = FACES_new[4], FACES_new[2], FACES_new[5], FACES_new[3]
    FACES[4][2], FACES[2][2], FACES[5][2], FACES[3][2] = d[2], a[2], b[2], c[2]


def D2(FACES):
    for i in range(2):
        D(FACES)
    '''
    FACES[1] = clockwise(clockwise(FACES[1]))
    FACES_new = cp.deepcopy(FACES)
    a, b, c, d = FACES_new[4], FACES_new[2], FACES_new[5], FACES_new[3]
    FACES[4][2], FACES[2][2], FACES[5][2], FACES[3][2] = c[2], d[2], a[2], b[2]
    '''


def L(FACES):
    FACES[2] = clockwise(FACES[2])
    FACES_new = cp.deepcopy(FACES)
    a, b, c, d = clockwise(FACES_new[4]), clockwise(FACES_new[1]), antiClockwise(FACES_new[5]), clockwise(FACES_new[0])
    e, f, g, h = cp.deepcopy(a), cp.deepcopy(b), cp.deepcopy(c), cp.deepcopy(d)
    e[0], f[0], g[0], h[0] = d[0], a[0], b[0], c[0]
    FACES[4], FACES[1], FACES[5], FACES[0] = antiClockwise(e), antiClockwise(f), clockwise(g), antiClockwise(h)


def _L(FACES):
    FACES[2] = antiClockwise(FACES[2])
    FACES_new = cp.deepcopy(FACES)
    a, b, c, d = clockwise(FACES_new[4]), clockwise(FACES_new[1]), antiClockwise(FACES_new[5]), clockwise(FACES_new[0])
    e, f, g, h = cp.deepcopy(a), cp.deepcopy(b), cp.deepcopy(c), cp.deepcopy(d)
    e[0], f[0], g[0], h[0] = b[0], c[0], d[0], a[0]
    FACES[4], FACES[1], FACES[5], FACES[0] = antiClockwise(e), antiClockwise(f), clockwise(g), antiClockwise(h)


def L2(FACES):
    for i in range(2):
        L(FACES)


#  （0）， （1）， （2）， （3）， （4）， （5）
def R(FACES):
    FACES[3] = clockwise(FACES[3])
    FACES_new = cp.deepcopy(FACES)
    a, b, c, d = antiClockwise(FACES_new[4]), antiClockwise(FACES_new[1]), clockwise(FACES_new[5]), antiClockwise(
        FACES_new[0])
    e, f, g, h = cp.deepcopy(a), cp.deepcopy(b), cp.deepcopy(c), cp.deepcopy(d)
    g[0], f[0], e[0], h[0] = d[0], c[0], b[0], a[0]
    FACES[4], FACES[1], FACES[5], FACES[0] = clockwise(e), clockwise(f), antiClockwise(g), clockwise(h)


def _R(FACES):
    FACES[3] = antiClockwise(FACES[3])
    FACES_new = cp.deepcopy(FACES)
    a, b, c, d = antiClockwise(FACES_new[4]), antiClockwise(FACES_new[1]), clockwise(FACES_new[5]), antiClockwise(
        FACES_new[0])
    e, f, g, h = cp.deepcopy(a), cp.deepcopy(b), cp.deepcopy(c), cp.deepcopy(d)
    f[0], g[0], h[0], e[0] = a[0], b[0], c[0], d[0]
    FACES[4], FACES[1], FACES[5], FACES[0] = clockwise(e), clockwise(f), antiClockwise(g), clockwise(h)


def R2(FACES):
    for i in range(2):
        R(FACES)


def F(FACES):
    FACES[4] = clockwise(FACES[4])
    FACES_new = cp.deepcopy(FACES)
    a, b, c, d = clockwise(clockwise(FACES_new[0])), FACES_new[1], antiClockwise(FACES_new[2]), clockwise(FACES_new[3])
    e, f, g, h = cp.deepcopy(a), cp.deepcopy(b), cp.deepcopy(c), cp.deepcopy(d)
    e[0], g[0], f[0], h[0] = c[0], b[0], d[0], a[0]
    FACES[0], FACES[1], FACES[2], FACES[3] = clockwise(clockwise(e)), f, clockwise(g), antiClockwise(h)


def _F(FACES):
    FACES[4] = antiClockwise(FACES[4])
    FACES_new = cp.deepcopy(FACES)
    a, b, c, d = clockwise(clockwise(FACES_new[0])), FACES_new[1], antiClockwise(FACES_new[2]), clockwise(FACES_new[3])
    e, f, g, h = cp.deepcopy(a), cp.deepcopy(b), cp.deepcopy(c), cp.deepcopy(d)
    g[0], f[0], h[0], e[0] = a[0], c[0], b[0], d[0]
    FACES[0], FACES[1], FACES[2], FACES[3] = clockwise(clockwise(e)), f, clockwise(g), antiClockwise(h)


def F2(FACES):
    for _ in range(2):
        F(FACES)


#  （0）， （1）， （2）， （3）， （4）， （5）
def B(FACES):
    FACES[5] = clockwise(FACES[5])
    FACES_new = cp.deepcopy(FACES)
    a, b, c, d = FACES_new[0], clockwise(clockwise(FACES_new[1])), clockwise(FACES_new[2]), antiClockwise(FACES_new[3])
    e, f, g, h = cp.deepcopy(a), cp.deepcopy(b), cp.deepcopy(c), cp.deepcopy(d)
    g[0], f[0], h[0], e[0] = a[0], c[0], b[0], d[0]
    FACES[0], FACES[1], FACES[2], FACES[3] = e, clockwise(clockwise(f)), antiClockwise(g), clockwise(h)


def _B(FACES):
    FACES[5] = antiClockwise(FACES[5])
    FACES_new = cp.deepcopy(FACES)
    a, b, c, d = FACES_new[0], clockwise(clockwise(FACES_new[1])), clockwise(FACES_new[2]), antiClockwise(FACES_new[3])
    e, f, g, h = cp.deepcopy(a), cp.deepcopy(b), cp.deepcopy(c), cp.deepcopy(d)
    e[0], g[0], f[0], h[0] = c[0], b[0], d[0], a[0]
    FACES[0], FACES[1], FACES[2], FACES[3] = e, clockwise(clockwise(f)), antiClockwise(g), clockwise(h)


def B2(FACES):
    for i in range(2):
        B(FACES)


'''
                          |************|
                          |*U1**U2**U3*|
                          |************|
                          |*U4**U5**U6*|
                          |************|
                          |*U7**U8**U9*|
                          |************|
              ************|************|************|************|
              *L1**L2**L3*|*F1**F2**F3*|*R1**R2**R3*|*B1**B2**B3*|
              ************|************|************|************|
              *L4**L5**L6*|*F4**F5**F6*|*R4**R5**R6*|*B4**B5**B6*|
              ************|************|************|************|
              *L7**L8**L9*|*F7**F8**F9*|*R7**R8**R9*|*B7**B8**B9*|
              ************|************|************|************|
                          |************|
                          |*D1**D2**D3*|
                          |************|
                          |*D4**D5**D6*|
                          |************|
                          |*D7**D8**D9*|
                          |************|
'''


def toString(FACES):
    print()
    for i in range(3):
        print("     ", int(FACES[0][i][0]), int(FACES[0][i][1]), int(FACES[0][i][2]))
    for i in range(3):
        print(int(FACES[2][i][0]), int(FACES[2][i][1]), int(FACES[2][i][2]), end=" ")
        print(int(FACES[4][i][0]), int(FACES[4][i][1]), int(FACES[4][i][2]), end=" ")
        print(int(FACES[3][i][0]), int(FACES[3][i][1]), int(FACES[3][i][2]), end=" ")
        print(int(FACES[5][i][0]), int(FACES[5][i][1]), int(FACES[5][i][2]))
    for i in range(3):
        print("     ", int(FACES[1][i][0]), int(FACES[1][i][1]), int(FACES[1][i][2]))
    print()


def moves(FACES, lst):
    for x in lst:
        if x == 'U':
            U(faces)
        elif x == 'u':
            _U(faces)
        elif x == 'D':
            D(faces)
        elif x == 'd':
            _D(faces)
        elif x == 'L':
            L(faces)
        elif x == 'l':
            _L(faces)
        elif x == 'R':
            R(faces)
        elif x == 'r':
            _R(faces)
        elif x == 'F':
            F(faces)
        elif x == 'f':
            _F(faces)
        elif x == 'B':
            B(faces)
        elif x == 'b':
            _B(faces)


lst = input("     :")
moves(faces, lst)
print("       ")
toString(faces)
reverse = ''.join(map(chr, map(lambda x: ord(x) ^ 32, lst)))[::-1]
moves(faces, reverse)
print("      ：", reverse)
toString(faces)
예시

     :UBLDFRULFDRULBGBVFDRLLBFLLDSSDBVDJFRUDLRFBDLFBbdj
       

      2 5 3
      5 0 2
      5 0 5
5 2 3 1 2 1 2 4 0 4 0 0
1 2 3 1 4 5 1 3 1 4 5 2
2 5 2 4 4 3 1 0 5 3 4 4
      1 0 4
      3 1 3
      0 3 0

      ： JDBbfldbfrldurfjdvbdssdllfbllrdfvbgblurdflurfdlbu

      0 0 0
      0 0 0
      0 0 0
2 2 2 4 4 4 3 3 3 5 5 5
2 2 2 4 4 4 3 3 3 5 5 5
2 2 2 4 4 4 3 3 3 5 5 5
      1 1 1
      1 1 1
      1 1 1


Process finished with exit code 0
주:대문자 는 시계 방향 이 고,소문 자 는 시계 반대 방향 이다.
python 이 3 단계 큐 브 복원 을 실현 하 는 예제 코드 에 관 한 이 글 은 여기까지 소개 되 었 습 니 다.더 많은 관련 python 3 단계 큐 브 복원 내용 은 우리 의 이전 글 을 검색 하거나 아래 의 관련 글 을 계속 조회 하 시기 바 랍 니 다.앞으로 많은 응원 바 랍 니 다!
링크 ux 명령 으로 디 렉 터 리 를 전환 하 는 방법
Javascript valueOf 사용 방법

좋은 웹페이지 즐겨찾기

개발자 우수 사이트 수집

개발자가 알아야 할 필수 사이트 100선 추천 우리는 당신을 위해 100개의 자주 사용하는 개발자 학습 사이트를 정리했습니다
best100-homepage