Buch Cover Buch Cover Buch Cover Buch Cover

Web-Code: - Webcode Help

Ernö Rubiks Zauberwürfelalgorithmen (Algorithmen)

Schreiben Sie ein Programm, das von einem Algorithmus für den Zauberwürfel die Ordnugszahl ermittelt.

Rubiks Cube
 
Die Ordnungszahl ist diejenige Anzahl, wie oft der Algorithmus ausgeführt werden muss, damit der Würfel in seinen Startzustand gelangt. Mit anderen Worten: Wenn ich einen gelösten Würfel habe und immer wieder den selben Algorithmus darauf anwende: Wie lange dauert es, bis der Würfel wieder gelöst ist.

Ein Algorithmus für den Zauberwürfel besteht aus verschiedenen Drehungen. Diese werden meist durch
links
rechts
hinten
vorne
oben
unten
und durch
90, 180 oder 270 Grad Drehungen angegeben.

Natürlich muss noch abgemacht werden ob die mittleren Ebenen auch gedreht werden dürfen, und in welche Richtung jeweils gedreht wird. Doch die Notation überlassen wir in dieser Aufgabe komplett der Programmiererin bzw. dem Programmierer.
Netz des Rubiks-Cube
Schreiben Sie also nun ein Programm, das einen Algorithmus in einer wohldefinierten Notation entgegen nimmt und den Algorithmus solange anwendet, bis der Würfel wieder gelöst ist. Die Ausgabe des Programmes ist dann die Ordnungszahl des Algorithmus.

Wer lernen will, wie man den Rubiks-Cube löst, kann sich hier schlau machen: https://www.youtube.com/watch?v=3hXWa6eeLSE

0 Kommentare

Bitte melde dich an um einen Kommentar abzugeben

4 Lösung(en)

package ch.programmieraufgaben.algorithmen.rubiks;

import java.util.*;

/**
 * @author phi@gress.ly
 * @date   2018-10-15
 * 
 * a) Change something like "r'U2Xb" to a sequence like
 *    [Move.r_INV, Move.U, Move.U, Move.X, Move.b]
 * b) apply an array of Moves to a cube 
 * c) count how many times you have to apply your algorithmn until
 *    the cube is solved again (grade).
 */

public class CubeAlgorithm {

	public static void main(String[] args) {
		new CubeAlgorithm().top();
	}

	void top() {
		Scanner sc = new Scanner(System.in);
		System.out.println("Bitte Algorithmus eingeben:");
		String algo = sc.nextLine().trim();
		sc.close();
		List<Move> moves = toMoveArray(algo);
		CubeImplementation c = new CubeImplementation();
		apply(c, moves);
		System.out.println(c);
		// move Count until solved again
		long cnt = 1;
		while(! c.isSolved()) {
			apply(c, moves);
			cnt++;
		}
		System.out.println("Algorithm grade: " + cnt + ".") ;
		System.out.println("Move count     : " + cnt*moves.size() + ".");
	}

	public void apply(CubeImplementation c, List<Move> algorithm) {
		for(Move m : algorithm) {
			//System.out.println("Applying " + m);
			c.move(m);
		}
	}

	/**
	 * Converts a Speedcuber String (eg. "RUDU") into a
	 * List of Moves (see enum Move below).
	 */
	public List<Move> toMoveArray(String algorithm) {
		List<Move> algo = new ArrayList<Move>();
		int readPos = 0;
		while(readPos < algorithm.length()) {
			char mv = algorithm.charAt(readPos);
			char modifier = 0; // no Modifier found
			if(readPos < algorithm.length() - 1) {
				modifier = algorithm.charAt(readPos + 1);
				if('\'' != modifier && '2' != modifier) {
					// not a Modifier!
					modifier = 0;
				} else {
					readPos++; // valid modifier found, so increase read pos
				}
			}
			Move move;
			if('\'' == modifier) {
				move = findMoveByNameInverted(mv);
			} else { 
				move = findMoveByName(mv);
			}
			if(null == move) {
				System.out.println("ERROR IN ALGO: " + algorithm  );
				System.out.println("       at pos: " + (readPos+1));
				return null;
			}
			if('2' == modifier) {
				algo.add(move);
			}
			algo.add(move);
			readPos++;
		}
		return algo;
	}

	private Move findMoveByName(char move) {
		Move m = null;
		if('R' == move) m = Move.R;
		if('L' == move) m = Move.L;
		if('B' == move) m = Move.B;
		if('F' == move) m = Move.F;
		if('D' == move) m = Move.D;
		if('U' == move) m = Move.U;

		if('r' == move) m = Move.r;
		if('l' == move) m = Move.l;
		if('b' == move) m = Move.b;
		if('f' == move) m = Move.f;
		if('d' == move) m = Move.d;
		if('u' == move) m = Move.u;

		if('X' == move) m = Move.X;
		if('Y' == move) m = Move.Y;
		if('Z' == move) m = Move.Z;
		if('M' == move) m = Move.M;
		if('E' == move) m = Move.E;
		if('S' == move) m = Move.S;

		if(null == m) {
			System.out.println("ERROR: MOVE UNKNOWN: " + move);
		}
		return m;
	}

	private Move findMoveByNameInverted(char move) {
		Move m = null;
		if('R' == move) m = Move.R_INV;
		if('L' == move) m = Move.L_INV;
		if('B' == move) m = Move.B_INV;
		if('F' == move) m = Move.F_INV;
		if('D' == move) m = Move.D_INV;
		if('U' == move) m = Move.U_INV;

		if('r' == move) m = Move.r_INV;
		if('l' == move) m = Move.l_INV;
		if('b' == move) m = Move.b_INV;
		if('f' == move) m = Move.f_INV;
		if('d' == move) m = Move.d_INV;
		if('u' == move) m = Move.u_INV;

		if('X' == move) m = Move.X_INV;
		if('Y' == move) m = Move.Y_INV;
		if('Z' == move) m = Move.Z_INV;
		if('M' == move) m = Move.M_INV;
		if('E' == move) m = Move.E_INV;
		if('S' == move) m = Move.S_INV;

		if(null == m) {
			System.out.println("ERROR: MOVE UNKNOWN: " + move);
		}
		return m;
	}

} // end of class Cube

enum Move {
	R    , L    , U    , D    , F    , B    , 
	R_INV, L_INV, U_INV, D_INV, F_INV, B_INV,
	r    , l    , u    , d    , f    , b    ,
	r_INV, l_INV, u_INV, d_INV, f_INV, b_INV,

	// M (middle)   Mitte zwischen R & L (Richtung L)
	// E (equator)  Mitte zwischen U & D (Richtung D)
	// S (standing) Mitte zwischen F & B (Richtung F)
	M    , E    , S    ,
	M_INV, E_INV, S_INV,

	// X, wie R, aber ganzer Würfel
	// Y, wie U, aber ganzer Würfel
	// Z, wie F, aber ganzer Würfel
	X,     Y,     Z    ,
	X_INV, Y_INV, Z_INV;

} // end of enum Move

enum Color {
	RED, GREEN, ORANGE, BLUE, WHITE, YELLOW;
} // end of enum Color

class CubeImplementation {

	Color[][] cube;

	public static void main(String[] args) {
		new CubeImplementation().top();
	}

	public CubeImplementation() {
		cube = new Color[12][9];
		// orange:
		cube[3][0] = cube[ 4][0] = cube[ 5][0] =
		cube[3][1] = cube[ 4][1] = cube[ 5][1] =
		cube[3][2] = cube[ 4][2] = cube[ 5][2] = Color.ORANGE;
		// yellow:
		cube[3][3] = cube[ 4][3] = cube[ 5][3] =
		cube[3][4] = cube[ 4][4] = cube[ 5][4] =
		cube[3][5] = cube[ 4][5] = cube[ 5][5] = Color.YELLOW;
		// blue:
		cube[0][3] = cube[ 1][3] = cube[ 2][3] =
		cube[0][4] = cube[ 1][4] = cube[ 2][4] =
		cube[0][5] = cube[ 1][5] = cube[ 2][5] = Color.BLUE;
		// red;
		cube[3][6] = cube[ 4][6] = cube[ 5][6] =
		cube[3][7] = cube[ 4][7] = cube[ 5][7] =
		cube[3][8] = cube[ 4][8] = cube[ 5][8] = Color.RED;
		// green;
		cube[6][3] = cube[ 7][3] = cube[ 8][3] =
		cube[6][4] = cube[ 7][4] = cube[ 8][4] =
		cube[6][5] = cube[ 7][5] = cube[ 8][5] = Color.GREEN;
		// white;
		cube[9][3] = cube[10][3] = cube[11][3] =
		cube[9][4] = cube[10][4] = cube[11][4] =
		cube[9][5] = cube[10][5] = cube[11][5] = Color.WHITE;
	}

	void printNet() {
		System.out.println(this.toString());
	}


	String visible = "rgobwy";
	@Override
	public String toString() {
		String representation = "";
		for(int y = 0; y < 9; y++) {
			for(int x = 0; x < 12; x ++) {
				if(null == cube[x][y]) {
					representation += "-";
				} else {
					representation += visible.charAt(cube[x][y].ordinal());
				}
			}
			representation += '\n';
		}
		return representation;
	}

	void top() {
		if(isConsistent()) {
			System.out.println("Cube initialized");
		} else {
			System.out.println("Error in Cube Initilisition: not Consistent!");
			return;
		}
		printNet();
		int cnt = 1;
		move(Move.Y);
		move(Move.R); move(Move.B); move(Move.L); move(Move.F);
	
		while(! isSolved()) {
			cnt++;
			move(Move.R); move(Move.B); move(Move.L); move(Move.F);
		}
		System.out.println("Used " +4*cnt+ " times the Algorithm = " + cnt + " movements");
	
		printNet();
	}

/** Netz des Cube:
-- -- -- 30 40 50 -- -- -- -- -- -- 
-- -- -- 31 41 51 -- -- -- -- -- -- 
-- -- -- 32 42 52 -- -- -- -- -- -- 
03 13 23 33 43 53 63 73 83 93 A3 B3
04 14 24 34 44 54 64 74 84 94 A4 B4
05 15 25 35 45 55 65 75 85 95 A5 B5
-- -- -- 36 46 56 -- -- -- -- -- --
-- -- -- 37 47 57 -- -- -- -- -- -- 
-- -- -- 38 48 58 -- -- -- -- -- -- 
*/

	public void move(Move m) {
		if(Move.r == m) {
			move(Move.X); move(Move.L);
		}
		if(Move.r_INV == m) {move(Move.r); move(Move.r); move(Move.r);}

		if(Move.f == m) {
			move(Move.Z); move(Move.B);
		}
		if(Move.f_INV == m) {move(Move.f); move(Move.f); move(Move.f);}

		if(Move.l == m) {
			move(Move.X_INV); move(Move.R);
		}
		if(Move.l_INV == m) {move(Move.l); move(Move.l); move(Move.l);}

		if(Move.b == m) {
			move(Move.Z_INV); move(Move.F);
		}
		if(Move.b_INV == m) {move(Move.b); move(Move.b); move(Move.b); }

		if(Move.u == m) {
			move(Move.Y); move(Move.D);
		}
		if(Move.u_INV == m) {move(Move.u); move(Move.u); move(Move.u);}

		if(Move.d == m) {
			move(Move.Y_INV); move(Move.U);
		}
		if(Move.d_INV == m) {move(Move.d); move(Move.d); move(Move.d);}

		if(Move.X == m) {
			move(Move.L_INV); move(Move.M_INV); move(Move.R);
		}
		if(Move.X_INV == m) {move(Move.X); move(Move.X); move(Move.X);}

		if(Move.Y == m) {
			move(Move.D_INV); move(Move.E_INV); move(Move.U);
		}
		if(Move.Y_INV == m) {move(Move.Y); move(Move.Y); move(Move.Y);}

		if(Move.Z == m) {
			move(Move.F); move(Move.S); move(Move.B_INV);
		}
		if(Move.Z_INV == m) {move(Move.Z); move(Move.Z); move(Move.Z);}

		if(Move.E == m) { // Equatorial
			move("37>75>51>13");
			move("47>74>41>14");
			move("57>73>31>15");
		}
		if(Move.E_INV == m) {move(Move.E); move(Move.E); move(Move.E);}

		if(Move.M  == m) { // Middle
			move("43>46>A5>40");
			move("44>47>A4>41");
			move("45>48>A3>42");
		}
		if(Move.M_INV == m) {move(Move.M); move(Move.M); move(Move.M);}

		if(Move.S == m) { // Standing
			move("34>64>94>04");
			move("44>74>A4>14");
			move("54>84>B4>24");
		}
		if(Move.S_INV == m) {move(Move.S); move(Move.S); move(Move.S);}

		if(Move.R_INV == m) {move(Move.R); move(Move.R); move(Move.R);}
		if(Move.L_INV == m) {move(Move.L); move(Move.L); move(Move.L);}
		if(Move.D_INV == m) {move(Move.D); move(Move.D); move(Move.D);}
		if(Move.U_INV == m) {move(Move.U); move(Move.U); move(Move.U);}
		if(Move.F_INV == m) {move(Move.F); move(Move.F); move(Move.F);}
		if(Move.B_INV == m) {move(Move.B); move(Move.B); move(Move.B);}

		if(Move.D == m) { // D = Down
			move("93>B3>B5>95");
			move("A3>B4>A5>94");
			move("83>30>05>58");
			move("84>40>04>48");
			move("85>50>03>38");
		}
		if(Move.B == m) { // B = back, not Bottom!
			move("42>31>40>51");
			move("32>30>50>52");
			move("33>03>93>63");
			move("43>13>A3>73");
			move("53>23>B3>83");
		}
		if(Move.F == m) {
			move("46>57>48>37");
			move("56>58>38>36");
			move("35>65>95>05");
			move("45>75>A5>15");
			move("55>85>B5>25");
		}
		if(Move.L == m) {
			move("24>15>04>13");
			move("23>25>05>03");
			move("33>36>B5>30");
			move("34>37>B4>31");
			move("35>38>B3>32");
		}
		if(Move.R == m) {
			move("64>73>84>75");
			move("63>83>85>65");
			move("53>50>95>56");
			move("55>52>93>58");
			move("54>51>94>57");
		}
		if(Move.U == m) {
			move("33>53>55>35");
			move("43>54>45>34");
			move("42>64>46>24");
			move("32>63>56>25");
			move("52>65>36>23");
		}
		if(! isConsistent()) {
			System.out.println("CubeImpl.move(): inconsistent move: " + m);
		}
	}

	private void move(String seq) {
		String[] seqArr = seq.split(">");
		Color tmp = getColorFromStringDesc(seqArr[seqArr.length - 1]);
		for(int pos = seqArr.length - 1; pos > 0; pos --) {
			Color from = getColorFromStringDesc(seqArr[pos - 1]);
			setColorToStringDesc(seqArr[pos], from);
		}
		setColorToStringDesc(seqArr[0], tmp);
	}


	private void setColorToStringDesc(String pos, Color col) {
		int x = getPosFromStringDesc(pos.charAt(0));
		int y = getPosFromStringDesc(pos.charAt(1));
		cube[x][y] = col;
	}

	private Color getColorFromStringDesc(String pos) {
		int x = getPosFromStringDesc(pos.charAt(0));
		int y = getPosFromStringDesc(pos.charAt(1));
		return cube[x][y];
	}

	private int getPosFromStringDesc(char ch) {
		if('A' == ch || 'a' == ch) return 10;
		if('B' == ch || 'b' == ch) return 11;
		if(ch >= '0' && ch <= '9') {
			return ch - '0';
		}
		System.out.println("ERROR: getPosFromString: " + ch + " not Known Position!");
		return -1;
	}

	public boolean isSolved() {
		if(!allMiddle( 1, 4)) return false;
		if(!allMiddle( 4, 1)) return false;
		if(!allMiddle( 4, 4)) return false;
		if(!allMiddle( 4, 7)) return false;
		if(!allMiddle( 7, 4)) return false;
		if(!allMiddle(10, 4)) return false;
		return true;
	}

	private boolean allMiddle(int xCenter, int yCenter) {
		for(int x = xCenter-1; x <= xCenter+1; x++) {
			for(int y = yCenter-1; y <= yCenter+1; y++) {
				if(cube[x][y] != cube[xCenter][yCenter]) {
					return false;
				}
			}
		}
		return true;
	}

	public Color get(int x, int y) {
		return this.cube[x][y];
	}


	public boolean isConsistent() {
		// check count of each color:
		int reds, greens, blues, oranges, yellows, whites;
		reds = greens = blues = oranges = yellows = whites = 0;
		for(int x = 0; x < 12; x++) {
			for(int y = 0; y < 9; y ++) {
				if(cube[x][y] == Color.RED   ) reds   ++;
				if(cube[x][y] == Color.GREEN ) greens ++;
				if(cube[x][y] == Color.BLUE  ) blues  ++;
				if(cube[x][y] == Color.ORANGE) oranges++;
				if(cube[x][y] == Color.YELLOW) yellows++;
				if(cube[x][y] == Color.WHITE ) whites ++;
			}
		}
		if(9 != reds    || 9 != greens  || 9 != blues ||
		   9 != oranges || 9 != yellows || 9 != whites) {
			System.out.println("color count failed: inconsistent");
			return false;
		}

		return true;
	}	

}  // end of class CubeImplementation
                

Lösung von: Philipp Gressly Freimann (SANTIS Training AG)

from copy import deepcopy


class Cube:
    def __init__(self):
        self.f = [[ 0,  1,  2],
                  [ 3,  4,  5],
                  [ 6,  7,  8]]  # front
        self.r = [[10, 11, 12],
                  [13, 14, 15],
                  [16, 17, 18]]  # right
        self.u = [[20, 21, 22],
                  [23, 24, 25],
                  [26, 27, 28]]  # up
        self.b = [[30, 31, 32],
                  [33, 34, 35],
                  [36, 37, 38]]  # back
        self.l = [[40, 41, 42],
                  [43, 44, 45],
                  [46, 47, 48]]  # left
        self.d = [[50, 51, 52],
                  [53, 54, 55],
                  [56, 57, 58]]  # down

    def parser(self, s, original):
        finished = 0
        s = s.upper()
        counter = 0

        while finished == 0:
            for i in range(0, len(s)):
                if s[i] == 'F':
                    try:
                        if s[i + 1] == "'":
                            self.do_f_ccw()
                        elif s[i + 1] == '2':
                            self.do_f()
                            self.do_f()
                        else:
                            self.do_f()
                    except IndexError:
                        self.do_f()

                if s[i] == 'R':
                    try:
                        if s[i + 1] == "'":
                            self.do_r_ccw()
                        elif s[i + 1] == '2':
                            self.do_r()
                            self.do_r()
                        else:
                            self.do_r()
                    except IndexError:
                        self.do_r()

                if s[i] == 'U':
                    try:
                        if s[i + 1] == "'":
                            self.do_u_ccw()
                        elif s[i + 1] == '2':
                            self.do_u()
                            self.do_u()
                        else:
                            self.do_u()
                    except IndexError:
                        self.do_u()

                if s[i] == 'B':
                    try:
                        if s[i + 1] == "'":
                            self.do_b_ccw()
                        elif s[i + 1] == '2':
                            self.do_b()
                            self.do_b()
                        else:
                            self.do_b()
                    except IndexError:
                        self.do_b()

                if s[i] == 'L':
                    try:
                        if s[i + 1] == "'":
                            self.do_l_ccw()
                        elif s[i + 1] == '2':
                            self.do_l()
                            self.do_l()
                        else:
                            self.do_l()
                    except IndexError:
                        self.do_l()

                if s[i] == 'D':
                    try:
                        if s[i + 1] == "'":
                            self.do_d_ccw()
                        elif s[i + 1] == '2':
                            self.do_d()
                            self.do_d()
                        else:
                            self.do_d()
                    except IndexError:
                        self.do_d()

            counter += 1

            if self.compare(original) == 0:
                return counter

    # deprecated
    def deep_compare_helper(self, l):
        return frozenset(frozenset(p) for p in l)

    def compare(self, cube):
        if (self.f == cube.f and
                self.r == cube.r and
                self.u == cube.u and
                self.b == cube.b and
                self.l == cube.l and
                self.d == cube.d):
            return 0
        return 1

    def do_f(self):
        # print('f')
        temp_f = deepcopy(self.f)
        temp_u = deepcopy(self.u)
        temp_r = deepcopy(self.r)
        temp_d = deepcopy(self.d)
        temp_l = deepcopy(self.l)
        temp_b = deepcopy(self.b)

        self.f = [[temp_f[2][0], temp_f[1][0], temp_f[0][0]],
                  [temp_f[2][1], temp_f[1][1], temp_f[0][1]],
                  [temp_f[2][2], temp_f[1][2], temp_f[0][2]]]

        self.r[0][0] = temp_u[2][0]
        self.r[1][0] = temp_u[2][1]
        self.r[2][0] = temp_u[2][2]

        self.d[0][0] = temp_r[2][0]
        self.d[0][1] = temp_r[1][0]
        self.d[0][2] = temp_r[0][0]

        self.l[0][2] = temp_d[0][0]
        self.l[1][2] = temp_d[0][1]
        self.l[2][2] = temp_d[0][2]

        self.u[2][0] = temp_l[2][2]
        self.u[2][1] = temp_l[1][2]
        self.u[2][2] = temp_l[0][2]

    def do_f_ccw(self):
        # print('f-')
        temp_f = deepcopy(self.f)
        temp_u = deepcopy(self.u)
        temp_r = deepcopy(self.r)
        temp_d = deepcopy(self.d)
        temp_l = deepcopy(self.l)
        temp_b = deepcopy(self.b)

        self.f = [[temp_f[0][2], temp_f[1][2], temp_f[2][2]],
                  [temp_f[0][1], temp_f[1][1], temp_f[2][1]],
                  [temp_f[0][0], temp_f[1][0], temp_f[2][0]]]

        self.r[0][0] = temp_d[0][2]
        self.r[1][0] = temp_d[0][1]
        self.r[2][0] = temp_d[0][0]

        self.d[0][0] = temp_l[0][2]
        self.d[0][1] = temp_l[1][2]
        self.d[0][2] = temp_l[2][2]

        self.l[0][2] = temp_u[2][2]
        self.l[1][2] = temp_u[2][1]
        self.l[2][2] = temp_u[2][0]

        self.u[2][0] = temp_r[0][0]
        self.u[2][1] = temp_r[1][0]
        self.u[2][2] = temp_r[2][0]

    def do_r(self):
        # print('r')
        temp_f = deepcopy(self.f)
        temp_u = deepcopy(self.u)
        temp_r = deepcopy(self.r)
        temp_d = deepcopy(self.d)
        temp_l = deepcopy(self.l)
        temp_b = deepcopy(self.b)

        self.r = [[temp_r[2][0], temp_r[1][0], temp_r[0][0]],
                  [temp_r[2][1], temp_r[1][1], temp_r[0][1]],
                  [temp_r[2][2], temp_r[1][2], temp_r[0][2]]]

        self.b[0][0] = temp_u[2][2]
        self.b[1][0] = temp_u[1][2]
        self.b[2][0] = temp_u[0][2]

        self.d[0][2] = temp_b[2][0]
        self.d[1][2] = temp_b[1][0]
        self.d[2][2] = temp_b[0][0]

        self.f[0][2] = temp_d[0][2]
        self.f[1][2] = temp_d[1][2]
        self.f[2][2] = temp_d[2][2]

        self.u[0][2] = temp_f[0][2]
        self.u[1][2] = temp_f[1][2]
        self.u[2][2] = temp_f[2][2]

    def do_r_ccw(self):
        # print('r-')
        temp_f = deepcopy(self.f)
        temp_u = deepcopy(self.u)
        temp_r = deepcopy(self.r)
        temp_d = deepcopy(self.d)
        temp_l = deepcopy(self.l)
        temp_b = deepcopy(self.b)

        self.r = [[temp_r[0][2], temp_r[1][2], temp_r[2][2]],
                  [temp_r[0][1], temp_r[1][1], temp_r[2][1]],
                  [temp_r[0][0], temp_r[1][0], temp_r[2][0]]]

        self.b[0][0] = temp_d[2][2]
        self.b[1][0] = temp_d[1][2]
        self.b[2][0] = temp_d[0][2]

        self.d[0][2] = temp_f[0][2]
        self.d[1][2] = temp_f[1][2]
        self.d[2][2] = temp_f[2][2]

        self.f[0][2] = temp_u[0][2]
        self.f[1][2] = temp_u[1][2]
        self.f[2][2] = temp_u[2][2]

        self.u[0][2] = temp_b[2][0]
        self.u[1][2] = temp_b[1][0]
        self.u[2][2] = temp_b[0][0]

    def do_u(self):
        # print('u')
        temp_f = deepcopy(self.f)
        temp_u = deepcopy(self.u)
        temp_r = deepcopy(self.r)
        temp_d = deepcopy(self.d)
        temp_l = deepcopy(self.l)
        temp_b = deepcopy(self.b)

        self.u = [[temp_u[2][0], temp_u[1][0], temp_u[0][0]],
                  [temp_u[2][1], temp_u[1][1], temp_u[0][1]],
                  [temp_u[2][2], temp_u[1][2], temp_u[0][2]]]

        self.b[0][0] = temp_l[0][0]
        self.b[0][1] = temp_l[0][1]
        self.b[0][2] = temp_l[0][2]

        self.r[0][0] = temp_b[0][0]
        self.r[0][1] = temp_b[0][1]
        self.r[0][2] = temp_b[0][2]

        self.f[0][0] = temp_r[0][0]
        self.f[0][1] = temp_r[0][1]
        self.f[0][2] = temp_r[0][2]

        self.l[0][0] = temp_f[0][0]
        self.l[0][1] = temp_f[0][1]
        self.l[0][2] = temp_f[0][2]

    def do_u_ccw(self):
        # print('u-')
        temp_f = deepcopy(self.f)
        temp_u = deepcopy(self.u)
        temp_r = deepcopy(self.r)
        temp_d = deepcopy(self.d)
        temp_l = deepcopy(self.l)
        temp_b = deepcopy(self.b)

        self.u = [[temp_u[0][2], temp_u[1][2], temp_u[2][2]],
                  [temp_u[0][1], temp_u[1][1], temp_u[2][1]],
                  [temp_u[0][0], temp_u[1][0], temp_u[2][0]]]

        self.b[0][0] = temp_r[0][0]
        self.b[0][1] = temp_r[0][1]
        self.b[0][2] = temp_r[0][2]

        self.r[0][0] = temp_f[0][0]
        self.r[0][1] = temp_f[0][1]
        self.r[0][2] = temp_f[0][2]

        self.f[0][0] = temp_l[0][0]
        self.f[0][1] = temp_l[0][1]
        self.f[0][2] = temp_l[0][2]

        self.l[0][0] = temp_b[0][0]
        self.l[0][1] = temp_b[0][1]
        self.l[0][2] = temp_b[0][2]

    def do_b(self):
        # print('b')
        temp_f = deepcopy(self.f)
        temp_u = deepcopy(self.u)
        temp_r = deepcopy(self.r)
        temp_d = deepcopy(self.d)
        temp_l = deepcopy(self.l)
        temp_b = deepcopy(self.b)

        self.b = [[temp_b[2][0], temp_b[1][0], temp_b[0][0]],
                  [temp_b[2][1], temp_b[1][1], temp_b[0][1]],
                  [temp_b[2][2], temp_b[1][2], temp_b[0][2]]]

        self.u[0][0] = temp_r[0][2]
        self.u[0][1] = temp_r[1][2]
        self.u[0][2] = temp_r[2][2]

        self.l[0][0] = temp_u[0][2]
        self.l[1][0] = temp_u[0][1]
        self.l[2][0] = temp_u[0][0]

        self.d[2][0] = temp_l[0][0]
        self.d[2][1] = temp_l[1][0]
        self.d[2][2] = temp_l[2][0]

        self.r[0][2] = temp_d[2][2]
        self.r[1][2] = temp_d[2][1]
        self.r[2][2] = temp_d[2][0]

    def do_b_ccw(self):
        # print('b-')
        temp_f = deepcopy(self.f)
        temp_u = deepcopy(self.u)
        temp_r = deepcopy(self.r)
        temp_d = deepcopy(self.d)
        temp_l = deepcopy(self.l)
        temp_b = deepcopy(self.b)

        self.b = [[temp_b[0][2], temp_b[1][2], temp_b[2][2]],
                  [temp_b[0][1], temp_b[1][1], temp_b[2][1]],
                  [temp_b[0][0], temp_b[1][0], temp_b[2][0]]]

        self.u[0][0] = temp_l[2][0]
        self.u[0][1] = temp_l[1][0]
        self.u[0][2] = temp_l[0][0]

        self.l[0][0] = temp_d[2][0]
        self.l[1][0] = temp_d[2][1]
        self.l[2][0] = temp_d[2][2]

        self.d[2][0] = temp_r[0][2]
        self.d[2][1] = temp_r[1][2]
        self.d[2][2] = temp_r[2][2]

        self.r[0][2] = temp_u[0][0]
        self.r[1][2] = temp_u[0][1]
        self.r[2][2] = temp_u[0][2]

    def do_l(self):
        # print('l')
        temp_f = deepcopy(self.f)
        temp_u = deepcopy(self.u)
        temp_r = deepcopy(self.r)
        temp_d = deepcopy(self.d)
        temp_l = deepcopy(self.l)
        temp_b = deepcopy(self.b)

        self.l = [[temp_l[2][0], temp_l[1][0], temp_l[0][0]],
                  [temp_l[2][1], temp_l[1][1], temp_l[0][1]],
                  [temp_l[2][2], temp_l[1][2], temp_l[0][2]]]

        self.u[0][0] = temp_b[2][2]
        self.u[1][0] = temp_b[1][2]
        self.u[2][0] = temp_b[0][2]

        self.f[0][0] = temp_u[0][0]
        self.f[1][0] = temp_u[1][0]
        self.f[2][0] = temp_u[2][0]

        self.d[0][0] = temp_f[0][0]
        self.d[1][0] = temp_f[1][0]
        self.d[2][0] = temp_f[2][0]

        self.b[0][2] = temp_d[2][0]
        self.b[1][2] = temp_d[1][0]
        self.b[2][2] = temp_d[0][0]

    def do_l_ccw(self):
        # print('l-')
        temp_f = deepcopy(self.f)
        temp_u = deepcopy(self.u)
        temp_r = deepcopy(self.r)
        temp_d = deepcopy(self.d)
        temp_l = deepcopy(self.l)
        temp_b = deepcopy(self.b)

        self.l = [[temp_l[0][2], temp_l[1][2], temp_l[2][2]],
                  [temp_l[0][1], temp_l[1][1], temp_l[2][1]],
                  [temp_l[0][0], temp_l[1][0], temp_l[2][0]]]

        self.u[0][0] = temp_f[0][0]
        self.u[1][0] = temp_f[1][0]
        self.u[2][0] = temp_f[2][0]

        self.f[0][0] = temp_d[0][0]
        self.f[1][0] = temp_d[1][0]
        self.f[2][0] = temp_d[2][0]

        self.d[0][0] = temp_b[2][2]
        self.d[1][0] = temp_b[1][2]
        self.d[2][0] = temp_b[0][2]

        self.b[0][2] = temp_u[2][0]
        self.b[1][2] = temp_u[1][0]
        self.b[2][2] = temp_u[0][0]

    def do_d(self):
        # print('d')
        temp_f = deepcopy(self.f)
        temp_u = deepcopy(self.u)
        temp_r = deepcopy(self.r)
        temp_d = deepcopy(self.d)
        temp_l = deepcopy(self.l)
        temp_b = deepcopy(self.b)

        self.d = [[temp_d[2][0], temp_d[1][0], temp_d[0][0]],
                  [temp_d[2][1], temp_d[1][1], temp_d[0][1]],
                  [temp_d[2][2], temp_d[1][2], temp_d[0][2]]]

        self.f[2][0] = temp_l[2][0]
        self.f[2][1] = temp_l[2][1]
        self.f[2][2] = temp_l[2][2]

        self.r[2][0] = temp_f[2][0]
        self.r[2][1] = temp_f[2][1]
        self.r[2][2] = temp_f[2][2]

        self.b[2][0] = temp_r[2][0]
        self.b[2][1] = temp_r[2][1]
        self.b[2][2] = temp_r[2][2]

        self.l[2][0] = temp_b[2][0]
        self.l[2][1] = temp_b[2][1]
        self.l[2][2] = temp_b[2][2]

    def do_d_ccw(self):
        # print('d-')
        temp_f = deepcopy(self.f)
        temp_u = deepcopy(self.u)
        temp_r = deepcopy(self.r)
        temp_d = deepcopy(self.d)
        temp_l = deepcopy(self.l)
        temp_b = deepcopy(self.b)

        self.d = [[temp_d[0][2], temp_d[1][2], temp_d[2][2]],
                  [temp_d[0][1], temp_d[1][1], temp_d[2][1]],
                  [temp_d[0][0], temp_d[1][0], temp_d[2][0]]]

        self.f[2][0] = temp_r[2][0]
        self.f[2][1] = temp_r[2][1]
        self.f[2][2] = temp_r[2][2]

        self.r[2][0] = temp_b[2][0]
        self.r[2][1] = temp_b[2][1]
        self.r[2][2] = temp_b[2][2]

        self.b[2][0] = temp_l[2][0]
        self.b[2][1] = temp_l[2][1]
        self.b[2][2] = temp_l[2][2]

        self.l[2][0] = temp_f[2][0]
        self.l[2][1] = temp_f[2][1]
        self.l[2][2] = temp_f[2][2]


original_cube = Cube()

while 1:
    algorithm_cube = Cube()
    string = input('gimme some cool algorithm to test: ')
    tries = algorithm_cube.parser(string, cube_original)
    print('had to use the algorithm {0} times'.format(tries))

                

Lösung von: Ich Bins (tubs)

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

"""
Programmieraufgabe: Zauberwürfel Ordnungszahl
https://www.programmieraufgaben.ch/aufgabe/ernoe-rubiks-zauberwuerfelalgorithmen/vymwb4k7
"""

import re
from typing import *


# Der Zauberwürfel besteht außen aus 26 Steinen. Jeder Stein ist eindeutig
# durch seine Farben (ein bis drei Farben je Element) identifiziert.
# Die Steine liegen auf einem 3x3x3 Gitter im Raum.
# Von einem Stein muss seine Position und seine Orientierung beachtet werden.
# Anstelle einer farbigen Seite eines Steins könte der Stein auch eine farbige
# Kugel auf seiner Seite haben. Diese farbigen Kugeln würden auf einem 5x5x5
# Gitters im Raum liegen.
# Anstelle der Bewegungen der Steine können die Bewegungen der farbigen Kugel
# beobachtet werden. Von diesen farbigen Kugel müssen nur die Positionen, nicht
# die Orientierungen betrachtet werden.
# In der Klasse Cube wird der Raum, das 5x5x5 Gitter, in einem Feld dargestellt.
# Jede der farbigen Kugeln wird durch eine Nummer identifiziert. Die Nummer im
# Feld bedeutet eine Kugel an dem entsprechenden Ort des Gitters.
# Das 5x5x5 Gitter wird in einer Liste mit 125 dargestellt.
# Die räumlichen Positionen (x,y,z) werden dem Index in der Liste durch die Methode
# 'xyz_to_index' zugeordnet. Jede Koordinate kann die Werte 0,1,2 annehmen. Die x-Achse ist
# nach rechts, die y-Achse nach hinten und die z-Achse nach oben gerichtet.
# Im Startzustand ist im Feld mit dem Index i der Stein mit Nummer i enthalten. Beim
# Drehen verändert sich der Inhalt der Liste 'elements'.
# Für jede Seite des Würfels wird eine Drehfunktion 'rotation_up" usw. bei der
# Initialisierung erzeugt. Die Drehfunktionen arbeiten mit einfachen Tabellen
# in der Art 'von Feld i - nach Feld j'.


def xyz_to_index(xyz: Tuple[int, int, int]) -> int:
    """
    Umrechung der Koordinaten in Indexnummer in der Liste.
    :param xyz: x Koordinate x,y,z jeweils im Bereich 0 bis 4
    :return: Index in der Liste 0...124
    """
    assert all(0 <= xyz[i] < 5 for i in range(3))
    return ((xyz[2] * 5) + xyz[1]) * 5 + xyz[0]


def index_to_xyz(index: int) -> Tuple[int, int, int]:
    """
    Index in der Liste umgerechnet in x,y,z Koordinate.
    :param index: Index in der Liste
    :return: Die Koordinate x,y,z des zugeordneten Punkts
    """
    assert 0 <= index < 125
    return index % 5, index // 5 % 5, index // 25


def index_to_str(i: int) -> str:
    """
    Indexnummer in kompakte String-Darstellung 'xyz' umwandeln.
    Die kompakte String-Darstellung ist anschaulicher als die Index-Nummer.
    """
    assert 0 <= i < 125
    return str(i % 5) + str((i // 5) % 5) + str(i // 25)


def _generate_rot(source: List[int], dest90: List[int], dest180: List[int], dest270: List[int]) \
        -> Callable[[object, int], None]:
    """
    Erzeugt eine Drehfunktion basierend auf den Übertragungstabellen.
    :param source: Liste der Index-Nummer der Felder die verschoben werden.
    :param dest90: Für 90° Rotation: Liste der Index-Nummern auf die die Felder kommen.
    :param dest180: Für 180° Rotation: Liste der Index-Nummern auf die die Felder kommen.
    :param dest270: Für 200° Rotation: Liste der Index-Nummern auf die die Felder kommen.
    :return: Funktion für die Rotation des Würfels mit Drehwinkel in Grad als Argument.
    """
    assert len(source) == len(dest90) == len(dest180) == len(dest270)

    def rotation(cube: object, angle: int) -> None:
        """
        Rotation um 0, +/-90, +/-180 oder +/-270 Grad.
        :param cube: Eine Seite dieses Würfels wird gedreht.
        :param angle: Um diesen Winkel wird gedreht.
        """
        angle %= 360
        if angle == 90:
            cube.move(source, dest90)
        elif angle == 180:
            cube.move(source, dest180)
        elif angle == 270:
            cube.move(source, dest270)
        elif angle == 0:
            pass
        else:
            raise ValueError("invalid angle")

    return rotation


def rotation_plane(xyz: Tuple[int, int, int]) -> Tuple[int, int, int]:
    """
    Rotation des Punktes xyz um 90° im Uhrzeigersinn
    um eine z-parallele Achse durch den Punkt (2,2.0).
    :param xyz: Diesen Punkt rotieren.
    :return: Die Koordinaten nach der Rotation.
    """
    return xyz[1], 4 - xyz[0], xyz[2]


def _generate_rotation(side_to_xyz: Callable[[Tuple[int, int, int]], Tuple[int, int, int]]) -> \
        Callable[[object, int], None]:
    """
    Erzeugt die Drehfunktion für eine Seite des Würfels.
    :param side_to_xyz: Liefert die Koordinaten x,y,z für einen Stein im Würfel
     als Funktion der x,y,z Koordinaten für einen Stein auf der Seite.
    :return: Funktion für die Rotation der Seite mit Parameter: Würfel, Winkel in Grad
    """
    # Die Koordinaten der Farbkugeln auf der Seite und an den Rändern der Seite
    side = [(x, y, 1) for x in range(1, 4) for y in range(1, 4)] + \
           [(x, 0, 0) for x in range(1, 4)] + \
           [(x, 4, 0) for x in range(1, 4)] + \
           [(0, y, 0) for y in range(1, 4)] + \
           [(4, y, 0) for y in range(1, 4)]
    # Die Index-Nummer der Felder in der Seite
    source = [xyz_to_index(side_to_xyz(xyz)) for xyz in side]
    # Diese Felder werden bei 90° Rotation im Uhrzeigersinn zu den Feldern
    destination90 = [xyz_to_index(side_to_xyz(rotation_plane(xyz))) for xyz in side]
    # in 90° Schritte weiterdrehen. Der Drehwinkel wird um die x,y oder z-Achse angegeben.
    # Bei positivem Winkel wird im Uhrzeigersinn gedreht.
    destination180 = [xyz_to_index(side_to_xyz(rotation_plane(rotation_plane(xyz)))) for xyz in side]
    destination270 = [xyz_to_index(side_to_xyz(rotation_plane(rotation_plane(rotation_plane(xyz))))) for xyz in side]
    return _generate_rot(source, destination90, destination180, destination270)


class Cube:
    """
    Würfel mit Drehoperationen.
    """

    # Der Index in dem Feld folgt über xyz_to_index aus ein Ort im Raum.
    # Der Wert des Elements i ist die Nummer des Objeks, der an dem Ort i ist.
    elements: ByteString

    @property
    def is_initial_state(self) -> bool:
        """
        Zustand des Würfels mit dem Startzustand vergleichen.
        :return: True genau dann, wenn der Würfel im Startzustand ist.
        """
        return self.elements == Cube._initial_state

    def __repr__(self) -> str:
        """
        Die Codenummer der farbigen Kugeln am Würel werden als kompakte Koordinate ausgegeben.
        :return: Der Zustand des Würfel. Obere, mittlere und untere Seite.
        """
        accu = ""
        for z in range(4, -1, -1):
            for y in range(4, -1, -1):
                for x in range(5):
                    if 4 <= (2 - x) ** 2 + (2 - y) ** 2 + (2 - z) ** 2 <= 6:
                        accu += index_to_str(self.elements[xyz_to_index((x, y, z))]) + " "
                    else:
                        accu += " .  "
                accu += "\n"
            accu += "\n"
        # Das \n am Stringende nicht zurückgeben
        return accu[:-2]

    def move(self, source: List[int], destination: List[int]) -> None:
        """
        Drehen einer Seite anhand einer Bewegungstabelle.
        """
        assert len(source) == len(destination)
        # Kopieren über Zwischenspeicher, weil die Bereiche überlappen.
        buffer = self.elements[:]
        for source_index, destination_index in zip(source, destination):
            self.elements[destination_index] = buffer[source_index]

    # Inhalt des elements Felds, wenn der Würfel im Start-Zustand ist.
    _initial_state = bytes(range(5 * 5 * 5))

    # Funktionen für die Rotationen der einzelnen Seiten
    rotation_up = _generate_rotation(lambda xyz: (xyz[0], xyz[1], 3 + xyz[2]))
    rotation_down = _generate_rotation(lambda xyz: (xyz[1], xyz[0], 1 - xyz[2]))
    rotation_right = _generate_rotation(lambda xyz: (3 + xyz[2], xyz[0], xyz[1]))
    rotation_left = _generate_rotation(lambda xyz: (1 - xyz[2], xyz[1], xyz[0]))
    rotation_back = _generate_rotation(lambda xyz: (xyz[1], 3 + xyz[2], xyz[0]))
    rotation_front = _generate_rotation(lambda xyz: (xyz[0], 1 - xyz[2], xyz[1]))

    def __init__(self) -> None:
        """
        Erzeugt den Würfel im Startzustand.
        """
        self.elements = bytearray(Cube._initial_state)


class CubeCodes:
    """Interpretieren der Cube Rotationen in Zeichenkette."""

    # Tabelle der Rotationsfunktionen für jeden Codebuchstaben.
    rotation_table: Dict[str, Callable[[Cube, int], None]] = {
        "F": Cube.rotation_front,
        "B": Cube.rotation_back,
        "R": Cube.rotation_right,
        "L": Cube.rotation_left,
        "U": Cube.rotation_up,
        "D": Cube.rotation_down}

    # Tabelle der Rotationswinkel für jeden Zeichencode.
    angle_table: Dict[str, int] = {"": 90, "'": -90, "2": 180, "'2": -180}

    @classmethod
    def compile_code(cls, code: str) -> Callable[[Cube], None]:
        """
        Übersetzt einen BewegungsCode in einen Aufruf einer Drehfunktion.
        Die Codes der einzelnen Rotationen nach https://speedcube.de/notation.php:
        F = front, B = back, R = right, L = left, U = up, D = down
        Dem Buchstaben für die Rotation kann ein Zeichen für den Winkel folgen:
        kein Zeichen = 90°, ' = -90°, 2 = 180°, '2 = -180°
        """
        try:
            code = code.strip()
            rotation = cls.rotation_table[code[0:1]]
            angle = cls.angle_table[code[1:]]
            return lambda cube: rotation(cube, angle)
        except KeyError:
            raise RuntimeError("falscher Bewegungscode: " + code)

    @classmethod
    def compile_algorithmus(cls, algorithm: str) -> Callable[[Cube], None]:
        """
        Übersetzt einen Algorithmus-Code in eine Funktion mit dem Drehungen.
        Einzelne Rotationen können mit einem Leerzeichen getrennt sein.
        Die Codes sind in der Funktion compile_code beschrieben.
        :param algorithm: Algorithmus als String.
        :return: Algorithmus in eine Funktion übersetzt.
        """
        program = [cls.compile_code(step) for step in re.split("([A-Z]'?2?)", algorithm) if step.istitle()]

        def run(cube: Cube) -> None:
            for step in program:
                step(cube)

        return run


def calculate_number(algorithm: Callable[[Cube], None]) -> int:
    """
    Berechnen der Ordnungszahl.
    :param algorithm: Der Algorithmus in einer Funktion auf dem Würfel.
    :return: Die Ordnungszahl des Algorithmus.
    """
    cube = Cube()
    assert cube.is_initial_state
    algorithm(cube)
    result: Int = 1
    while not cube.is_initial_state:
        algorithm(cube)
        result += 1
    return result


test_cases = ("R",  # 4
              "L",  # 4
              "U",  # 4
              "D",  # 4
              "F",  # 4
              "B",  # 4
              "R L",  # 4
              "U D",  # 4
              "F B",  # 4
              "R2 U R2",  # 4
              "R' D' R D",  # 6
              "UUR'LLDDB'R'U'B'R'U'B'R'U",  # 336
              "RUR'",  # 4
              "RULD",  # 315
              "RUF",  # 80
              "RUF2",  # 36
              "RUUFU")  # 420
for test in test_cases:
    algo = CubeCodes.compile_algorithmus(test)
    number = calculate_number(algo)
    print("Algorithmus: {:15} Ordnungszahl: {:4}".format(test, number))
                

Lösung von: Name nicht veröffentlicht

f = [[0,0,0],[0,0,0],[0,0,0]]				# Definiere Seiten des Würfels als 3x3 Matrizen 
b = [[1,1,1],[1,1,1],[1,1,1]]				 
l = [[2,2,2],[2,2,2],[2,2,2]]
r = [[3,3,3],[3,3,3],[3,3,3]]
u = [[4,4,4],[4,4,4],[4,4,4]]
d = [[5,5,5],[5,5,5],[5,5,5]]

cube =[f,b,l,r,u,d]							# Zusammenfassung der Matrizen zu Einem Würfel

from copy import deepcopy

def F(cube):								# Definiere Operationen auf dem Würfel
	
	f= cube[0]
	b= cube[1]
	l= cube[2]
	r= cube[3]
	u= cube[4]
	d= cube[5]
		
	tempf = deepcopy(cube[0])
	tempb = deepcopy(cube[1])
	templ = deepcopy(cube[2])
	tempr = deepcopy(cube[3])
	tempu = deepcopy(cube[4])
	tempd = deepcopy(cube[5])
	
	f[0][2]= tempf[0][0]					# Austausch der Elemente gemäß Rotationsvorgaben
	f[2][2]= tempf[0][2]
	f[2][0]= tempf[2][2]
	f[0][0]= tempf[2][0]
		
	f[1][2]= tempf[0][1]
	f[2][1]= tempf[1][2]
	f[1][0]= tempf[2][1]
	f[0][1]= tempf[1][0]
	
	r[2][0]= tempu[2][0]
	d[0][2]= tempr[2][0]
	l[2][0]= tempd[0][2]
	u[2][0]= templ[2][0]
	
	r[2][1]= tempu[2][1]
	d[0][1]= tempr[2][1]
	l[2][1]= tempd[0][1]
	u[2][1]= templ[2][1]
	
	r[2][2]= tempu[2][2]
	d[0][0]= tempr[2][2]
	l[2][2]= tempd[0][0]
	u[2][2]= templ[2][2]
	
	cube =[f,b,l,r,u,d]
	return cube
	
def L(cube):							# Definiere Operationen auf dem Würfel 
	
	f= cube[0]
	b= cube[1]
	l= cube[2]
	r= cube[3]
	u= cube[4]
	d= cube[5]
	
	tempf = deepcopy(cube[0])
	tempb = deepcopy(cube[1])
	templ = deepcopy(cube[2])
	tempr = deepcopy(cube[3])
	tempu = deepcopy(cube[4])
	tempd = deepcopy(cube[5])
		
	l[0][2]= templ[0][0]				# Austausch der Elemente gemäß Rotationsvorgaben
	l[2][2]= templ[0][2]
	l[2][0]= templ[2][2]
	l[0][0]= templ[2][0]
	
	l[1][2]= templ[0][1]
	l[2][1]= templ[1][2]
	l[1][0]= templ[2][1]
	l[0][1]= templ[1][0]
		
	f[0][0]= tempu[0][0]
	d[0][0]= tempf[0][0]
	b[0][0]= tempd[0][0]
	u[0][0]= tempb[0][0]
	
	f[1][0]= tempu[1][0]
	d[1][0]= tempf[1][0]
	b[1][0]= tempd[1][0]
	u[1][0]= tempb[1][0]
	
	f[2][0]= tempu[2][0]
	d[2][0]= tempf[2][0]
	b[2][0]= tempd[2][0]
	u[2][0]= tempb[2][0]
	
	cube =[f,b,l,r,u,d]
	return cube
	
def R(cube):								
	
	f= cube[0]
	b= cube[1]
	l= cube[2]
	r= cube[3]
	u= cube[4]
	d= cube[5]
	
	tempf = deepcopy(cube[0])
	tempb = deepcopy(cube[1])
	templ = deepcopy(cube[2])
	tempr = deepcopy(cube[3])
	tempu = deepcopy(cube[4])
	tempd = deepcopy(cube[5])
	
	r[0][2]= tempr[0][0]					
	r[2][2]= tempr[0][2]
	r[2][0]= tempr[2][2]
	r[0][0]= tempr[2][0]
	
	r[1][2]= tempr[0][1]
	r[2][1]= tempr[1][2]
	r[1][0]= tempr[2][1]
	r[0][1]= tempr[1][0]
	
	u[0][2]= tempf[0][2]
	b[0][2]= tempu[0][2]
	d[0][2]= tempb[0][2]
	f[0][2]= tempd[0][2]
	
	u[1][2]= tempf[1][2]
	b[1][2]= tempu[1][2]
	d[1][2]= tempb[1][2]
	f[1][2]= tempd[1][2]
	
	u[2][2]= tempf[2][2]
	b[2][2]= tempu[2][2]
	d[2][2]= tempb[2][2]
	f[2][2]= tempd[2][2]
	
	cube =[f,b,l,r,u,d]
	return cube
	
def U(cube):								 
	
	f= cube[0]
	b= cube[1]
	l= cube[2]
	r= cube[3]
	u= cube[4]
	d= cube[5]
	
	tempf = deepcopy(cube[0])
	tempb = deepcopy(cube[1])
	templ = deepcopy(cube[2])
	tempr = deepcopy(cube[3])
	tempu = deepcopy(cube[4])
	tempd = deepcopy(cube[5])
	
	u[0][2]= tempu[0][0]				
	u[2][2]= tempu[0][2]
	u[2][0]= tempu[2][2]
	u[0][0]= tempu[2][0]
	
	u[1][2]= tempu[0][1]
	u[2][1]= tempu[1][2]
	u[1][0]= tempu[2][1]
	u[0][1]= tempu[1][0]
	
	l[2][2]= tempf[0][2]
	b[2][0]= templ[2][2]
	r[0][0]= tempb[2][0]
	f[0][2]= tempr[0][0]

	l[1][2]= tempf[0][1]
	b[2][1]= templ[1][2]
	r[1][0]= tempb[2][1]
	f[0][1]= tempr[1][0]
	
	l[0][2]= tempf[0][0]
	b[2][2]= templ[0][2]
	r[2][0]= tempb[2][2]
	f[0][0]= tempr[2][0]
	
	cube =[f,b,l,r,u,d]
	return cube
	
def D(cube):							 
	
	f= cube[0]
	b= cube[1]
	l= cube[2]
	r= cube[3]
	u= cube[4]
	d= cube[5]
	
	tempf = deepcopy(cube[0])
	tempb = deepcopy(cube[1])
	templ = deepcopy(cube[2])
	tempr = deepcopy(cube[3])
	tempu = deepcopy(cube[4])
	tempd = deepcopy(cube[5])

	d[0][2]= tempd[0][0]				
	d[2][2]= tempd[0][2]
	d[2][0]= tempd[2][2]
	d[0][0]= tempd[2][0]
	
	d[1][2]= tempd[0][1]
	d[2][1]= tempd[1][2]
	d[1][0]= tempd[2][1]
	d[0][1]= tempd[1][0]
	
	r[2][2]= tempf[2][0]
	b[0][2]= tempr[2][2]
	l[0][0]= tempb[0][2]
	f[2][0]= templ[0][0]

	r[1][2]= tempf[2][1]
	b[0][1]= tempr[1][2]
	l[1][0]= tempb[0][1]
	f[2][1]= templ[1][0]
	
	r[0][2]= tempf[2][2]
	b[0][0]= tempr[0][2]
	l[2][0]= tempb[0][0]
	f[2][2]= templ[2][0]
	
	cube =[f,b,l,r,u,d]
	return cube
	
def B(cube):							
	
	f= cube[0]
	b= cube[1]
	l= cube[2]
	r= cube[3]
	u= cube[4]
	d= cube[5]
	
	tempf = deepcopy(cube[0])
	tempb = deepcopy(cube[1])
	templ = deepcopy(cube[2])
	tempr = deepcopy(cube[3])
	tempu = deepcopy(cube[4])
	tempd = deepcopy(cube[5])
	
	b[0][2]= tempb[0][0]						
	b[2][2]= tempb[0][2]
	b[2][0]= tempb[2][2]
	b[0][0]= tempb[2][0]
	
	b[1][2]= tempb[0][1]
	b[2][1]= tempb[1][2]
	b[1][0]= tempb[2][1]
	b[0][1]= tempb[1][0]
	
	r[0][2]= tempd[2][0]
	u[0][2]= tempr[0][2]
	l[0][2]= tempu[0][2]
	d[2][0]= templ[0][2]

	r[0][1]= tempd[2][1]
	u[0][1]= tempr[0][1]
	l[0][1]= tempu[0][1]
	d[2][1]= templ[0][1]
	
	r[0][0]= tempd[2][2]
	u[0][0]= tempr[0][0]
	l[0][0]= tempu[0][0]
	d[2][2]= templ[0][0]
	
	cube =[f,b,l,r,u,d]
	return cube

def Finv(cube):							# Definition der inversen Drehungen entgegen dem Uhrzeigersinn
	cube = F(cube)
	cube = F(cube)
	cube = F(cube)
	return cube
	
def Rinv(cube):
	cube = R(cube)
	cube = R(cube)
	cube = R(cube)
	return cube
	
def Linv(cube):
	cube = L(cube)
	cube = L(cube)
	cube = L(cube)
	return cube
	
def Uinv(cube):
	cube = U(cube)
	cube = U(cube)
	cube = U(cube)
	return cube
	
def Dinv(cube):
	cube = D(cube)
	cube = D(cube)
	cube = D(cube)
	return cube
	
def Binv(cube):
	cube = B(cube)
	cube = B(cube)
	cube = B(cube)
	return cube

def KontrolleMatrix (A):				# Kontrolliere Einträge der Matrizen, falls a_ij=a_22 forall i,j -> true
	for k in range (0,3):				# Farben der Seiten sind durch Farbe des jeweiligen Zentrums gegeben
		for l in range (0,3):
			if A[k][l] != A[1][1]:
				return False
	return True
	
def KontrolleCube(cube):				# Kontrolle des gesamten Würfels durch Iteration von KontrolleMatrix über jede Seite
	for k in range (0,6):
		if KontrolleMatrix(cube[k])== False:
			return False
	return True
	
def ZugAnpassen(String):				#Funktion zur Anpassung des eingebenen Strings im Falle von inversen Zügen
	L = list(String)
	l = len(L) 
	for k in range (0,l-1):
		if L[k+1] =='`':
			L[k] = L[k]+'`'
	return L 
	
def ZugKontrollieren(String):			# Funktion zur Kontrolle der gültigen Eingaben
	L = ZugAnpassen(String)				# Umwandlng des String in Liste
	l = len(L)
	check = True						# Definition eines Kontrollschalters
	ErlaubteEingaben = ['F','R','L','U','D','B','F`','R`','L`','U`','D`','B`','`']
	for k in range (0,l):				# Iteration über alle Listeneinträge
		if L[k] in ErlaubteEingaben:	# Falls Listenelement korrenkt -> nächster Eintrag
			k = k+1
		else:							# Falls Listenelement falsch -> ändere Kontrollschalter 
			check = False
	if check == True:					# Prüfe Kontrollschalter mit entsprechender Ausgabe
		return True
	else: 
		return False
		
def Operation(cube,string):		
	A = ZugAnpassen(string)	
	a = len(A)
	for k in range (0,a): 
		if A[k] == 'F':
			cube = F(cube)
		elif A[k] == 'L':
			cube = L(cube)
		elif A[k] == 'R':
			cube = R(cube)
		elif A[k] == 'U':
			cube = U(cube)
		elif A[k] == 'D':
			cube = D(cube)
		elif A[k] == 'B':
			cube = B(cube)
		elif A[k] == 'F`':
			cube = Finv(cube)
		elif A[k] == 'R`':
			cube = Rinv(cube)
		elif A[k] == 'L`':
			cube = Linv(cube)
		elif A[k] == 'U`':
			cube = Uinv(cube)
		elif A[k] == 'D`':
			cube = Dinv(cube)
		elif A[k] == 'B`':
			cube = Binv(cube)
	return (cube)
	
def ZugGrad (cube, string):					# Funktion zur Bestimmung des Zuggrades, Eingaben = Würfel als Array und Zug als String
	if ZugKontrollieren(string) == False:	# Kontrolliere Eingabe des String
		print ("Ungültige Eingabe")
	else:
		k=0									# Counter zum Zählen der ausgeführten Operationen
		check = False						# Schalter zum Beenden der Schleife, falls Würfen gelöst
		while check == False:	
			cube = Operation(cube,string)
			k = k+1
			if KontrolleCube(cube) == True:
				check = True
		print (k)

ZugGrad(cube,'L')
                

Lösung von: Name nicht veröffentlicht

Verifikation/Checksumme:

Die Speedcuber-Notation steht z. B. hier:
https://speedcube.de/notation.php

Move    |   Orndungszahl
----------------
RUR'    |   4
RULD    | 315
RUF     |  80
RUF2    |  36
RUUFU   | 420

Aktionen

Bewertung

Durchschnittliche Bewertung:

Eigene Bewertung:
Bitte zuerst anmelden

Meta

Zeit: 8
Schwierigkeit: Schwer
Webcode: vymw-b4k7
Autor: Philipp Gressly Freimann (SANTIS Training AG)

Download PDF

Download ZIP

Zu Aufgabenblatt hinzufügen