Sudoku

Inspiration

We wanted to try and build Sudoku because we thought it would be a randomized game would be a step up from the current projects we have learned through CSCI 1301 and CSCI 1302. We originally started thinking of games we could program with our skill level, and Sudoku seemed like the right fit -- it would be difficult and a good chance to learn about random algorithms.

What it does

It offers the user the ability to create a random 3x3 or random 2x2 solvable Sudoku board, and well, solve it!

How we built it

We started by making a plan of action -- how were we going to build the program (generally), and from there made UML diagrams of methods we knew we were going to need as described in our psuedocode. We used VScode and git to collaborate on the project and tackle different parts of it at a time, and experimented with different ways to build a randomized but valid Sudoku board.

Challenges we ran into

The hardest challenge we ran into was creating an algorithm to generate randomized, valid Sudoku boards. Almost all the advice/guides we ran into detailed using recursion, but since we weren't confident with that aspect of programming yet, we had to find a way to make the board in one fell swoop, instead of backtracking to fix previously generated cells.

The second major challenge was using git and github. Since this project was each teammate's first major collaborative project ever, it was instrumental learning git in order to individually work on the project at the same time and tackle different areas of the project. Git commands, merging issues, and configurations were very difficult to figure out, but after extensive research, we were able to use it effectively to push and pull changes with ease.

The last major challenge was teamwork -- since this was each team member's first collaborative project, it took a lot of time to get the teamwork and roles down. This was the worst at the beginning, where we knew what we wanted to program, but had different plans of attack -- it took a lot of time to explain how we wanted to do things to others as a result. However, by the second day, our teamwork improved significantly and we were able to function extremely well together.

Accomplishments that we're proud of

We're most proud of learning Git and how to work in a team for collaborative programming projects. Programming in a team-based environment is hugely different from a solo job because it forces you to be able to explain code and illustrate ideas to others who may not think about algorithms or concepts the same way you do. Additionally, we're proud of out teamwork because it proved that we could learn to compromise and work well together to create a solid product.

Secondly, we're really proud that we were able to make a somewhat difficult randomized algorithm. We were stuck on it for multiple hours, with multiple team members working in conjunction to try and crack it, so it serves as testament to our team keeping the faith and not giving up. Once we finally "cracked the code", it was a euphoric moment and we all jumped in excitement because it was a significant logical and programming challenge given our experience and skill levels.

What we learned

We learned multiple git commands, how to program in a collaborative environment, how to make more advanced algorithms using multi-dimensional arrays, how to use planning and UML diagrams to improve our implementation of code, and how to work as a team.

What's next for Sudoku

We want to implement user-submitted Sudoku puzzles -- in the case the user has a specific puzzle they want to try to solve, we are implementing support for seed files. This will be a fun challenge because it will test our validity algorithms on boards that have not been randomly generated and solved already, but rather boards that are not fully finished. Additionally, we want to implement pre-made levels into our game - we have already made 50 puzzles ranging in difficulty from easy to extreme, and want to incorporate those puzzles as another way to play our program so that friends can compete to solve the same board to compare their skills.