knight tour in java

Python Tutorial

Python oops, python mysql, python mongodb, python sqlite, python questions, python tkinter (gui), python web blocker, related tutorials, python programs.

• Send your Feedback to [email protected]

Help Others, Please Share

Learn Latest Tutorials

Transact-SQL

Reinforcement Learning

R Programming

React Native

Python Design Patterns

Python Pillow

Python Turtle

Preparation

Verbal Ability

Interview Questions

Company Questions

Trending Technologies

Artificial Intelligence

Cloud Computing

Data Science

Machine Learning

B.Tech / MCA

Data Structures

Operating System

Computer Network

Compiler Design

Computer Organization

Discrete Mathematics

Ethical Hacking

Computer Graphics

Software Engineering

Web Technology

Cyber Security

C Programming

Control System

Data Mining

Data Warehouse

• Create account
• Contributions

Knight's tour

Problem : you have a standard 8x8 chessboard, empty but for a single knight on some square. Your task is to emit a series of legal knight moves that result in the knight visiting every square on the chessboard exactly once. Note that it is not a requirement that the tour be "closed"; that is, the knight need not end within a single move of its start position.

Input and output may be textual or graphical, according to the conventions of the programming environment. If textual, squares should be indicated in algebraic notation . The output should indicate the order in which the knight visits the squares, starting with the initial position. The form of the output may be a diagram of the board with the squares numbered according to visitation sequence, or a textual list of algebraic coordinates in order, or even an actual animation of the knight moving around the chessboard.

Input: starting square

Output: move sequence

• A* search algorithm
• N-queens problem
• Solve a Hidato puzzle
• Solve a Holy Knight's tour
• Solve a Hopido puzzle
• Solve a Numbrix puzzle
• Solve the no connection puzzle
• 360 Assembly

First, we specify a naive implementation the package Knights_Tour with naive backtracking. It is a bit more general than required for this task, by providing a mechanism not to visit certain coordinates. This mechanism is actually useful for the task Solve a Holy Knight's tour#Ada , which also uses the package Knights_Tour.

Here is the implementation:

Here is the main program:

For small sizes, this already works well (< 1 sec for size 8). Sample output:

For larger sizes we'll use Warnsdorff's heuristic (without any thoughtful tie breaking). We enhance the specification adding a function Warnsdorff_Get_Tour. This enhancement of the package Knights_Tour will also be used for the task Solve a Holy Knight's tour#Ada . The specification of Warnsdorff_Get_Tour is the following.

Its implementation is as follows.

The modification for the main program is trivial:

This works still well for somewhat larger sizes:

$ ./knights_tour c5 2 closed

For start at b3

... plus an animation.

ANSI BASIC does not allow function parameters to be passed by reference, so X and Y were made global variables.

For an animated version using OpenGL, see Knight's tour/C .

The following draws on console the progress of the horsie. Specify board size on commandline, or use default 8.

Uses Warnsdorff's rule and (iterative) backtracking if that fails.

• Common Lisp

This interactive program will ask for a starting case in algebraic notation and, also, whether a closed tour is desired. Each next move is selected according to Warnsdorff's rule; ties are broken at random.

The closed tour algorithm is quite crude: just find tours over and over until one happens to be closed by chance.

This code is quite verbose: I tried to make it easy for myself and for others to follow and understand. I'm not a Lisp expert, so I probably missed some idiomatic shortcuts I could have used to make it shorter.

For some reason, the interactive part does not work with SBCL, but it works fine with CLISP.

Using warnsdorff's rule

• CoffeeScript

This algorithm finds 100,000 distinct solutions to the 8x8 problem in about 30 seconds. It precomputes knight moves up front, so it turns into a pure graph traversal problem. The program uses iteration and backtracking to find solutions.

Fast Version

Shorter version.

Brute force method. Takes a long time for most solutions, so some optimization should be used. However, it has nice graphics.

The algorithm uses iterative backtracking and Warnsdorff's heuristic. It can output closed or non-closed tours.

64 shades of gray. We plot the move sequence in shades of gray, from black to white. The starting square is red. The ending square is green. One can observe that the squares near the border are played first (dark squares).

Closed path on a 12x12 board: [1]

Open path on a 24x24 board: [2]

Link to live demo: https://dmcbane.github.io/knights-tour/

Again I use backtracking. It seemed easier this time.

Taken from ERRE distribution disk. Comments are in Italian.

Knights Tour FreeBasic image

Fōrmulæ programs are not textual, visualization/edition of programs is done showing/manipulating structures but not text. Moreover, there can be multiple visual representations of the same program. Even though it is possible to have textual representation —i.e. XML, JSON— they are intended for storage and transfer purposes more than visualization and edition.

Programs in Fōrmulæ are created/edited online in its website .

In this page you can see and run the program(s) related to this task and their results. You can also change either the programs or the parameters they are called with, for experimentation, but remember that these programs were created with the main purpose of showing a clear solution of the task, and they generally lack any kind of validation.

$ echo "c5 2 T" | ./knights_tour

Fortran 2008

(This one is not a translation of my ATS implementation. I wrote it earlier.)

$ ./knights_tour a1 b2 c3

Warnsdorf's rule

Icon and unicon.

This implements Warnsdorff's algorithm using unordered sets.

• The board must be square (it has only been tested on 8x8 and 7x7). Currently the maximum size board (due to square notation) is 26x26.
• Tie breaking is selectable with 3 variants supplied (first in list, random, and Roth's distance heuristic).
• A debug log can be generated showing the moves and choices considered for tie breaking.

The algorithm doesn't always generate a complete tour.

The following can be used when debugging to validate the board structure and to image the available moves on the board.

Sample output:

Two 7x7 boards:

Solution: The Knight's tour essay on the Jwiki shows a couple of solutions including one using Warnsdorffs algorithm .

Example Use:

More efficient non-trackback solution

Using Warnsdorff rule and Backtracking.

You can test it here .

To test it, you'll need an index.html

And a style.css

A composition of values, drawing on generic abstractions:

Adapted from Wren

Works with jq, the C implementation of jq

Works with gojq, the Go implementation of jq except that _nwise/1 must be provided.

In the following program, the board size is specified by the top-level function named `boardSize` so that it can readily be changed, e.g. to a variable set on the command-line. In calculating algebraic notation, however, it is assumed that the board size is no larger than 26x26.

Uses the Hidato puzzle solver module, which has its source code listed here in the Hadato task.

• Locomotive Basic

Influenced by the Python version, although computed tours are different.

• M2000 Interpreter

Warnsdorff’s rule, with random tie-breaks. The program keeps trying until it finds a solution. Running time can vary a lot.

Beware the program writes to a file ‘__random_number__’ in the working directory. (This can be avoided in GNU m4 by using ‘esyscmd’ instead of ‘syscmd’. I do not know how to avoid it in general.)

This is just a sample. Outputs are random.

$ m4 knights_tour.m4

Mathematica / Wolfram Language

vertexLabels replaces the default vertex (i.e. square) names of the chessboard with the standard algebraic names "a1", "a2",...,"h8".

knightsGraph creates a graph of the solution space.

Find a Hamiltonian cycle (a path that visits each square exactly one time.)

Find the end square:

Find shortest path from the start square to the end square.

While a little slower than using Warnsdorff this solution is interesting:

1. It shows that Hidato and Knights Tour are essentially the same problem.

2. It is possible to specify which square is used for any Knights Move.

This is a translation of the C++ and D versions with some changes, the most important being the addition of a check to detect that there is no solution. Without this check, the program crashes with an IndexError as Nim in debug and in release modes generates code to insure that indexes are valid.

We have added a case to test the absence of solution. Note that, in this case, there is a lot of backtracking which considerably slows down the execution.

Knight's tour using Warnsdorffs algorithm

Sample output (start square c3):

This is pretty fast (<<1s) up to size 48, before some sizes start to take quite some time to complete. It will even solve a 200x200 in 0.67s

You probably shouldn't send this to a printer. Solution using Warnsdorffs algorithm.

Knights tour using Warnsdorffs algorithm

Output :

Alternative version

20x20 board runs in: time: 0.91 memory: 68608.

The 200x200 example warmed my study in its computation but did return a tour.

P.S. There is a slight deviation to a strict interpretation of Warnsdorff's algorithm in that as a convenience, tuples of the length of the knight moves followed by the position are minimized so knights moves with the same length will try and break the ties based on their minimum x,y position. In practice, it seems to give comparable results to the original algorithm.

boardsize: 5 Start position: a3 Traceback (most recent call last):

ValueError: min() arg is an empty sequence

Based on a slight modification of Warnsdorff's algorithm , in that if a dead-end is reached, the program backtracks to the next best move.

(formerly Perl 6)

(Output identical to Perl's above.)

For use with the public domain ratfor77 translator and a FORTRAN 77 compiler.

This REXX version is modeled after the XPL0 example.

The size of the chessboard may be specified as well as the knight's starting position.

This is an   open tour   solution.   (See this task's   discussion   page for an explanation, the section is   The 7x7 problem .)

output   when using the default input:

Knights tour using Warnsdorffs rule

Which produces:

cf. Solve a Holy Knight's tour :

Knights tour using Warnsdorffs rule (No Backtracking)

8 X 8 board:

20 X 20 board:

Demonstrating:

The above code supports other sizes of boards and starting from nominated locations:

Which could produce this output:

Example output:

This solution is for XSLT 3.0 Working Draft 10 (July 2012). This solution, originally reported on this blog post , will be updated or removed when the final version of XSLT 3.0 is released.

First we build a generic package for solving any kind of tour over the chess board. Here it is…

And now for the style-sheet to solve the Knight’s tour…

So an input like this…

…should be transformed in something like this…

Check that a solution for all squares is found:

• Programming Tasks
• Solutions by Programming Task
• Pages with broken file links
• Forms,Types,SysUtils,Graphics,ExtCtrls
• Mathematica
• Wolfram Language
• Pages with syntax highlighting errors
• Toggle limited content width

• [email protected]

What’s New ?

The Top 10 favtutor Features You Might Have Overlooked

• Don’t have an account Yet? Sign Up

Remember me Forgot your password?

• Already have an Account? Sign In

Lost your password? Please enter your email address. You will receive a link to create a new password.

Back to log-in

By Signing up for Favtutor, you agree to our Terms of Service & Privacy Policy.

The Knight's Tour Problem (using Backtracking Algorithm)

• Jun 30, 2023
• 6 Minute Read
• Why Trust Us We uphold a strict editorial policy that emphasizes factual accuracy, relevance, and impartiality. Our content is crafted by top technical writers with deep knowledge in the fields of computer science and data science, ensuring each piece is meticulously reviewed by a team of seasoned editors to guarantee compliance with the highest standards in educational content creation and publishing.
• By Vedanti Kshirsagar

Ever wondered how a computer playing as a chess player improves its algorithm to defeat you in the game? In this article, we will learn about the Knight's Tour Problem, the various ways to solve it along with their time and space complexities. So, let's get started!

What is Knight's Tour Problem?

Just for a reminder, the knight is a piece in chess that usually looks like a horse and moves in an L-shaped pattern. This means it will first move two squares in one direction and then one square in a perpendicular direction.

The Knight's Tour problem is about finding a sequence of moves for the knight on a chessboard such that it visits every square on the board exactly one time. It is a type of Hamiltonian path problem in graph theory, where the squares represent the vertices and the knight's moves represent the edges of the graph.

This problem has fascinated many mathematicians for centuries, but the solutions they found were very difficult. The simple solution will be to find every conceivable configuration and selecting the best one is one technique to solve this problem. But that will take a load of time.

One popular solution to solve the Knight's tour problem is Warnsdorff's rule, which involves choosing the next move that leads to a square with the fewest available moves. There is also a backtracking approach. 

 But first moving to all that, let's take a quick understanding of the Hamiltonian path problem.

Hamiltonian Path Problem

The Hamiltonian path problem is a well-known problem in graph theory that asks whether a given graph contains a path that visits every vertex exactly once.

A path that visits every vertex exactly once is called a Hamiltonian path, and a graph that contains a Hamiltonian path is called a Hamiltonian graph. 

Let's take an example of the Hamiltonian path problem. Suppose we have a graph with five vertices and the following edges:

This graph can be represented as:

Knight's Tour Backtracking Algorithm

The backtracking algorithm works by exploring all possible moves for the knight, starting from a given square, and backtracking to try different moves if it reaches a dead end.

Here's the basic outline of the backtracking algorithm to solve the Knight's tour problem:

• Choose a starting square for the knight on the chessboard.
• Mark the starting square as visited.
• For each valid move from the current square, make the move and recursively repeat the process for the new square.
• If all squares on the chessboard have been visited, we have found a solution. Otherwise, undo the last move and try a different move.
• If all moves have been tried from the current square and we have not found a solution, backtrack to the previous square and try a different move from there.
• If we have backtracked to the starting square and tried all possible moves without finding a solution, there is no solution to the problem.

We have given the full C++ program for Backtracking Algorithm to solve Knight's Tour Problem below:

Check the image below before we explain the code:

In this implementation, we first define a function validMoves  which takes the current row and column of the knight as input and returns a vector of pairs representing all the valid moves that the knight can make from that position.

The solve function is a recursive function that takes the current row and column of the knight, as well as the current move number, as input. We mark the current square as visited by setting board[row][column] it to the current move number, and then we recursively try all possible moves from the current position.

If we reach the last move, then we found a solution and return true. If no valid move is found from the current position, we backtrack by setting the current square to 0 and returning false.

In the main function, we start the solve function at a specified starting position and then output the number of moves it took to find a solution and print the final chessboard with the solution.

Time & Space Complexity for Backtracking

The backtracking algorithm used to solve the Knight's Tour problem has an exponential time complexity. The number of possible paths for the knight grows very quickly as the size of the chessboard increases, which means that the time taken to explore all possible paths grows exponentially.

The exact time complexity of the Knight's Tour Backtracking algorithm is O(8^(n^2)), where n is the size of the chessboard. This is because each move has a maximum of 8 possible directions, and we have to explore all possible moves until we find a solution.

The space complexity of the backtracking algorithm is O(n^2), where n is the size of the chessboard. So, we can say that the backtracking algorithm is efficient for smaller chessboards.

Warnsdorff's Rule

Warndorff's rule is a heuristic greedy algorithm used to solve this problem. It tries to move the knight to the square with the fewest valid moves, hoping that this will lead to a solution.

Here's an overview of how Warndorff's rule algorithm works:

• Start with a random square on the chessboard.
• From the current square, consider all possible moves and count the number of valid moves from each adjacent square.
• Move to the square with the lowest number of valid moves. In case of a tie, move to the square with the lowest number of valid moves from its adjacent squares.
• Repeat steps 2 and 3 until all squares on the chessboard have been visited.

Here is the pseudocode for Warndorff's rule algorithm:

The time complexity of Warndorff's rule algorithm is O(n^2 log n), where n is the size of the chessboard. This is because we have to visit each square once, and for each square, we have to compute the number of valid moves from each adjacent square. The space complexity of the algorithm is O(n^2) since we need to store the chessboard and the current position of the knight.

Overall, The Knight's Tour problem is related to chess, and solving it can help chess players improve their strategy and become better at the game. In the real world, you can also use it to design efficient algorithms for finding the shortest path between two points in a network.

Now we know The Knight's Tour Problem and its solutions using Backtracking and Warnsdorff's Rule. It has several applications in various fields such as Game theory, Network Routing etc, making it an important problem to study in computer science and mathematics.

FavTutor - 24x7 Live Coding Help from Expert Tutors!

About The Author

Vedanti Kshirsagar

More by favtutor blogs, monte carlo simulations in r (with examples), aarthi juryala.

The unlist() Function in R (with Examples)

Paired Sample T-Test using R (with Examples)

• Data Structures & Algorithms
• DSA - Overview
• DSA - Environment Setup
• DSA - Algorithms Basics
• DSA - Asymptotic Analysis
• Data Structures
• DSA - Data Structure Basics
• DSA - Data Structures and Types
• DSA - Array Data Structure
• Linked Lists
• DSA - Linked List Data Structure
• DSA - Doubly Linked List Data Structure
• DSA - Circular Linked List Data Structure
• Stack & Queue
• DSA - Stack Data Structure
• DSA - Expression Parsing
• DSA - Queue Data Structure
• Searching Algorithms
• DSA - Searching Algorithms
• DSA - Linear Search Algorithm
• DSA - Binary Search Algorithm
• DSA - Interpolation Search
• DSA - Jump Search Algorithm
• DSA - Exponential Search
• DSA - Fibonacci Search
• DSA - Sublist Search
• DSA - Hash Table
• Sorting Algorithms
• DSA - Sorting Algorithms
• DSA - Bubble Sort Algorithm
• DSA - Insertion Sort Algorithm
• DSA - Selection Sort Algorithm
• DSA - Merge Sort Algorithm
• DSA - Shell Sort Algorithm
• DSA - Heap Sort
• DSA - Bucket Sort Algorithm
• DSA - Counting Sort Algorithm
• DSA - Radix Sort Algorithm
• DSA - Quick Sort Algorithm
• Graph Data Structure
• DSA - Graph Data Structure
• DSA - Depth First Traversal
• DSA - Breadth First Traversal
• DSA - Spanning Tree
• Tree Data Structure
• DSA - Tree Data Structure
• DSA - Tree Traversal
• DSA - Binary Search Tree
• DSA - AVL Tree
• DSA - Red Black Trees
• DSA - B Trees
• DSA - B+ Trees
• DSA - Splay Trees
• DSA - Tries
• DSA - Heap Data Structure
• DSA - Recursion Algorithms
• DSA - Tower of Hanoi Using Recursion
• DSA - Fibonacci Series Using Recursion
• Divide and Conquer
• DSA - Divide and Conquer
• DSA - Max-Min Problem
• DSA - Strassen's Matrix Multiplication
• DSA - Karatsuba Algorithm
• Greedy Algorithms
• DSA - Greedy Algorithms
• DSA - Travelling Salesman Problem (Greedy Approach)
• DSA - Prim's Minimal Spanning Tree
• DSA - Kruskal's Minimal Spanning Tree
• DSA - Dijkstra's Shortest Path Algorithm
• DSA - Map Colouring Algorithm
• DSA - Fractional Knapsack Problem
• DSA - Job Sequencing with Deadline
• DSA - Optimal Merge Pattern Algorithm
• Dynamic Programming
• DSA - Dynamic Programming
• DSA - Matrix Chain Multiplication
• DSA - Floyd Warshall Algorithm
• DSA - 0-1 Knapsack Problem
• DSA - Longest Common Subsequence Algorithm
• DSA - Travelling Salesman Problem (Dynamic Approach)
• Approximation Algorithms
• DSA - Approximation Algorithms
• DSA - Vertex Cover Algorithm
• DSA - Set Cover Problem
• DSA - Travelling Salesman Problem (Approximation Approach)
• Randomized Algorithms
• DSA - Randomized Algorithms
• DSA - Randomized Quick Sort Algorithm
• DSA - Karger’s Minimum Cut Algorithm
• DSA - Fisher-Yates Shuffle Algorithm
• DSA Useful Resources
• DSA - Questions and Answers
• DSA - Quick Guide
• DSA - Useful Resources
• DSA - Discussion
• Selected Reading
• UPSC IAS Exams Notes
• Developer's Best Practices
• Questions and Answers
• Effective Resume Writing
• HR Interview Questions
• Computer Glossary

Knight's tour problem

What is knight's tour problem.

In the knight's tour problem, we are given with an empty chess board of size NxN, and a knight. In chess, the knight is a piece that looks exactly like a horse. Assume, it can start from any location on the board. Now, our task is to check whether the knight can visit all of the squares on the board or not. When it can visit all of the squares, then print the number of jumps needed to reach that location from the starting point.

There can be two ways in which a knight can finish its tour. In the first way, the knight moves one step and returns back to the starting position forming a loop which is called a closed tour . In the second way i.e. the open tour , it finishes anywhere in the board.

For a person who is not familiar with chess, note that the knight moves in a special manner. It can move either two squares horizontally and one square vertically or two squares vertically and one square horizontally in each direction. So, the complete movement looks like English letter 'L' .

Suppose the size of given chess board is 8 and the knight is at the top-left position on the board. The next possible moves are shown below −

Each cell in the above chess board holds a number, that indicates where to start and in how many moves the knight will reach a cell. The final values of the cell will be represented by the below matrix −

Remember, this problem can have multiple solutions, the above matrix is one possible solution.

One way to solve the knight's tour problem is by generating all the tours one by one and then checking if they satisfy the specified constraint or not. However, it is time consuming and not an efficient way.

Backtracking Approach to Solve Knight's tour problem

The other way to solve this problem is to use backtracking. It is a technique that tries different possibilities until a solution is found or all options are tried. It involves choosing a move, making it, and then recursively trying to solve the rest of the problem. If the current move leads to a dead end, we backtrack and undo the move, then try another one.

To solve the knight's tour problem using the backtracking approach, follow the steps given below −

Start from any cell on the board and mark it as visited by the knight.

Move the knight to a valid unvisited cell and mark it visited. From any cell, a knight can take a maximum of 8 moves.

If the current cell is not valid or not taking to the solution, then backtrack and try other possible moves that may lead to a solution.

Repeat this process until the moves of knight are equal to 8 x 8 = 64.

In the following example, we will practically demonstrate how to solve the knight's tour problem.

Knights Tour Problem

The Knight’s tour is a puzzle in a N * N chessboard where Knight makes sequence of moves and must visit every square exactly once. This problem can be solved with backtracking. We begin the solution by placing knight at (0, 0). At every position, we try the possible moves to find a valid one. If we find a valid move, we move the knight to that position. If we don’t find such valid move, we backtrack and try to re-position the previous move. If we have completed all the squares of the board, we have a solution. If we have tried all possible moves and could not cover all the squares, we have failed to find a solution.

Visualization of Knights Tour

Implementation of Knights Tour

• DSA Tutorial
• Data Structures
• Linked List
• Dynamic Programming
• Binary Tree
• Binary Search Tree
• Divide & Conquer
• Mathematical
• Backtracking
• Branch and Bound
• Pattern Searching

Possible moves of knight

Given a chess board of dimension m * n. Find number of possible moves where knight can be moved on a chessboard from given position. If mat[i][j] = 1 then the block is filled by something else, otherwise empty. Assume that board consist of all pieces of same color, i.e., there are no blocks being attacked. 

Examples:  

We can observe that knight on a chessboard moves either: 

• Two moves horizontal and one move vertical 
• Two moves vertical and one move horizontal

The idea is to store all possible moves of knight and then count the number of valid moves. A move will be invalid if: 

• A block is already occupied by another piece. 
• Move is out of the chessboard.

Implementation:

Time Complexity: O(1)  Auxiliary Space: O(1)

Please Login to comment...

Similar reads.

• chessboard-problems
• How to Get a Free SSL Certificate
• Best SSL Certificates Provider in India
• Elon Musk's xAI releases Grok-2 AI assistant
• What is OpenAI SearchGPT? How it works and How to Get it?
• Content Improvement League 2024: From Good To A Great Article

Improve your Coding Skills with Practice

What kind of Experience do you want to share?

Navigation Menu

Search code, repositories, users, issues, pull requests..., provide feedback.

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly.

To see all available qualifiers, see our documentation .

knight-tour

Here are 18 public repositories matching this topic..., kamoloff / n-queen-puzzle-knights-tour.

Solution for both N Queens Puzzle and Knight's Tour (with GUI)

• Updated Jun 27, 2022

bellmcp / Knights-Tour-Solver

A Java implementation of the Knight's Tour algorithm.

• Updated Aug 26, 2019

veysiertekin / knights-tour

A complete solution with heuristic & non-heuristic ways to knights-tour problem in chess

• Updated Aug 9, 2017

akshaybahadur21 / KnightsTour

Knight's tour algorithm for humans ♞

• Updated Jun 4, 2021

gkhays / knights-tour

Visualization of the Knight's Tour move sequence

• Updated Feb 5, 2018

cyrillkuettel / knights-tour

Two different methods are being utilized to solve this famous puzzle. They are backtracking and genetic algorithms. The second approach is still in development. Backtracking method seems to be faster, but GA delivers more consistent results for a diverse palette of starting positions. All in all, a very interesting project to me personally.

• Updated Aug 20, 2022

m4mbo / np-complete

Solutions to two classic np-complete problems: n-queens and knight's tour.

• Updated Mar 6, 2024

ejoneid / algoritmer2_Springerproblemet

Knight's tour solution

• Updated Mar 10, 2021

pranavmswamy / knights-tour

Knight’s Tour is a sequence of valid moves of a knight on a chessboard in such a way that the knight covers all the squares on the board. This is a Hamiltonian path problem in computer science which is NP-complete. In this project, I compare the time complexities of Knight's Tour while implementing i) Backtracking, and ii) Warnsdorff's heuristic.

• Updated Oct 8, 2020

rezaarshad / KnightTour

Solving Knight's tour problem using Java

• Updated Jun 14, 2023

p-derakhshan / KnightTour

Knight's Tour Problem

• Updated Feb 8, 2022

bt15cse052 / RSA_WITH_CRYPTOTOUR

An attempt to overcome factorization attack on RSA.

• Updated Dec 21, 2017

Akeempositive / KnightTour

• Updated Mar 16, 2018

MarvinZhong / HorseRPG

A knight's tour (HorseRPG) is a sequence of moves of a knight on a chessboard such that the knight visits every square exactly once.

• Updated Oct 3, 2020

tcyang-md / Knight-Board

Knight's tour implemented in java using stacks and backtracking to find a single solution for 3x3 - 8x8 sized boards

• Updated Jun 29, 2022

Rafsan0Z / MKS22X-Knight

• Updated Mar 18, 2019

bphun / KnightsTour

Knights Tour game created using Java for AP Computer Science A

• Updated Jun 2, 2017

lucaspbastos / Knights-Tour

Knight's Tour project for an m*n chess board in Java for Fall 2019 CS 114.

• Updated May 21, 2021

Improve this page

Add a description, image, and links to the knight-tour topic page so that developers can more easily learn about it.

Curate this topic

Add this topic to your repo

To associate your repository with the knight-tour topic, visit your repo's landing page and select "manage topics."