示例#1
0
 def test_move_to_left_to_fail(self):
     matrix = [
         [1, 2, 3],
         [0, 8, 4],
         [7, 6, 5]]
     new = Puzzle(matrix)
     self.assertFalse(new.left())
示例#2
0
 def test_move_to_right_to_fail(self):
     matrix = [
         [1, 2, 3],
         [8, 4, 0],
         [7, 6, 5]]
     new = Puzzle(matrix)
     self.assertFalse(new.right())
示例#3
0
 def test_move_to_down_to_fail(self):
     matrix = [
         [1, 2, 3],
         [8, 4, 5],
         [7, 6, 0]]
     new = Puzzle(matrix)
     self.assertFalse(new.down())
示例#4
0
 def test_move_to_up_to_fail(self):
     matrix = [
         [1, 2, 0],
         [8, 4, 3],
         [7, 6, 5]]
     new = Puzzle(matrix)
     self.assertFalse(new.up())
示例#5
0
class PuzzleTest(unittest.TestCase):
    matrix = [
        [1, 2, 3],
        [8, 0, 4],
        [7, 6, 5]]
    p = None

    def setUp(self):
        self.p = Puzzle(self.matrix)

    def test_get_blank(self):
        p = Puzzle(self.matrix)
        self.assertEquals(p.get_blank, (1, 1))

    def test_move_to_up(self):
        matrix = [
            [1, 0, 3],
            [8, 2, 4],
            [7, 6, 5]]
        self.assertEquals(self.p.up(), matrix)

    def test_move_to_up_to_fail(self):
        matrix = [
            [1, 2, 0],
            [8, 4, 3],
            [7, 6, 5]]
        new = Puzzle(matrix)
        self.assertFalse(new.up())

    def test_move_to_down(self):
        matrix = [
            [1, 2, 3],
            [8, 6, 4],
            [7, 0, 5]]
        self.assertEquals(self.p.down(), matrix)

    def test_move_to_down_to_fail(self):
        matrix = [
            [1, 2, 3],
            [8, 4, 5],
            [7, 6, 0]]
        new = Puzzle(matrix)
        self.assertFalse(new.down())

    def test_move_to_left(self):
        matrix = [
            [1, 2, 3],
            [0, 8, 4],
            [7, 6, 5]]
        self.assertEquals(self.p.left(), matrix)

    def test_move_to_left_to_fail(self):
        matrix = [
            [1, 2, 3],
            [0, 8, 4],
            [7, 6, 5]]
        new = Puzzle(matrix)
        self.assertFalse(new.left())

    def test_move_to_right(self):
        matrix = [
            [1, 2, 3],
            [8, 4, 0],
            [7, 6, 5]]
        self.assertEquals(self.p.right(), matrix)

    def test_move_to_right_to_fail(self):
        matrix = [
            [1, 2, 3],
            [8, 4, 0],
            [7, 6, 5]]
        new = Puzzle(matrix)
        self.assertFalse(new.right())

    def test_copy_data(self):
        new_data = self.p.copy_data()
        self.assertEquals(self.p.matrix, new_data)
示例#6
0
 def setUp(self):
     self.p = Puzzle(self.matrix)
from model.puzzle import Puzzle
from model.node import Node
from action.generate import Tree

matrix = [
    [1, 3, 4],
    [4, 5, 6],
    [7, 8, 0]
]

p = Puzzle(matrix)
p.move_to("LEFT")
p.move_to("UP")


class BSF:
    def __init__(self,init_matrix,final_matrix):
        self.init_matrix = init_matrix
        self.final_matrix = final_matrix
        self.run(init_matrix,final_matrix)

    def run(self,init_m,final_m):
        init_node = Node(Puzzle(init_m))
        final_node = Node(Puzzle(final_m))
        tree = Tree(init_node,final_node)
        tree.procedure(init_node,final_node)


def main(init,final):
    # Recibir una Matriz inicial y final
    BSF(init,final)