#########

# TO DO #

#########

ARCHITECTURE

{x} organize src files -> GO-style

{x} be able to 'go build ...'

{x} store useful functions in new Golang library (filterUnique)

PARSING

{x} EITHER file OR flags

{ } print usage

{x} filter out negative numbers

{x} filter out floats

{x} filter out duplicates ... should these be admissible ??

{x} leave empty space (0) in random board generation

{x} are both row and col between 0 and (n - 1) ?

{x} panics when passed a file from command line that's misspelled

{x} check for panics

SOLVER

{x} test IsSolvable

{x} Neighboring boards: generate a board per move

{x} move pieces around the board

{x} how do I know if I am at the goal state?

{x} bloom filter

{x} solves puzzle size 3, doesn't solve size 4

{x} MUST: priority queue

{x} MUST: A*

{ } MUST: 3 heuristics

{ } ability to choose heuristic from command line

{x} MUST: closed set (checks if node is currently in the set)

{x} MUST: total number of states in open set (time complexity)

{x} MUST: max number of states represented in memory at the same time (size complexity)

{x} MUST: ordered solution sequence

{x} MUST: solvable or unsolvable

{ } MUST: admissible = optimistic heuristic

{ } BONUS: uniform-cost and greedy-search

ALGO

{x} priority queue?

{x} Must: 3 heuristic functions, including Manhattan-distance

{ } Others: A-Star, IDA-Star

UNIT TESTS

{x} make some, test it

OPTIMIZING

{x} test performance: bytes.Equal vs reflect.DeepEqual >> bytes is supposed to be WAY faster

{ } concurrency?

{ } Define variables as close to their usage as possible (prevent extra variables declared)

{x} When considering the neighbors of a search node, don't enqueue a neighbor if its board is the same as the board of the predecessor search node.