Question

Main objective: Solve the n queens problems. You have to place n queens on an n ×
n chessboard such that no two attack each other. Important: the chessboard should be
indexed starting from 1, in standard (x, y) coordinates. Thus, (4, 3) refers to the
square in the 4th column and 3rd row.
We have a slight twist in this assignment. We will take as input the position of
one queen, and have to generate a solution with a queen in this position.
Specifics: You should provide a Makefile. On running make, it should create
“NQueens.jar”. You should run the jar with two command line arguments: the first is
an input file, the second is the output file. For example, we would call the command:
java -jar NQueens.jar in.txt solution.txt
The file in.txt will have inputs to the main program (as described below), and
the file solution.txt will have the desired solution.
Each line of the input file corresponds to a different instance. Each line of the
input file will have three integers: the chessboard size, the column where the input
queen is placed, and the row where the input queen is placed. For example, the file
may look like:
7 3 2
4 1 1
The first line means we have a 7 × 7 chessboard, with one queen placed at (3, 2).
We wish to place 6 more queens so that none of the 7 queens attack any other. The
second line means we have a 4 × 4 chessboard, with one queen at (1, 1). We wish to
place 3 more queens without any attacks. So on and so forth.

Output: On running the command, the following should be printed in the output
file. For each line of the input file, there is a line in the output file with the placement of Queens

• If there is no solution to the problem, print “No solution” (with a newline at the
end)
• If there is a solution, print the position of each queen as <column> <space>
<row> <space> followed by the position for the next queen. The positions
should be in increasing order of column, so first column first, second column
second, etc. Please follow this format exactly, so that the checking script works
for you. The last character on the line will be a space, then followed by a
newline. This format should make your code easier to write.
For example, the output for the input described above could be:
1 1 2 5 3 2 4 6 5 3 6 7 7 4
No solution

Observe how “3 2” is part of the first solution, since we started with a queen
there. The solution is not unique, so your code might find some other placement. On
the other hand, a 4 × 4 chessboard with a queen at (1, 1) has no solution.

Answer 1

package file;

import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;

public class Queens {

  
  
  
   StringBuilder sb=new StringBuilder();
     public String[] flipLines(Scanner s){
  
       String[] numbers=null;
         try
         {
    s = new Scanner(new File("in.txt"));
    while(s.hasNextLine()){
    String line = s.nextLine();
    System.out.println(line);
    Scanner lineScanner = new Scanner(line);
  
    numbers = line.split(" ");
  
    }
  
    //exceptions
    } catch (FileNotFoundException ex){
    System.out.println("This file does not exist");
    }
         return numbers;
    }
  
  
  
  
  
  
  
       /***************************************************************************
        * Return true if queen placement q[n] does not conflict with
        * other queens q[0] through q[n-1]
        */
        public static boolean isConsistent(int[] q, int n) {
            for (int i = 0; i < n; i++) {
                if (q[i] == q[n])             return false;   // same column
                if ((q[i] - q[n]) == (n - i)) return false;   // same major diagonal
                if ((q[n] - q[i]) == (n - i)) return false;   // same minor diagonal
            }
            return true;
        }

       /***************************************************************************
        * Prints n-by-n placement of queens from permutation q in ASCII.
        ***************************************************************************/
        public static void printQueens(int[] q) {
            int n = q.length;
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < n; j++) {
                    if (q[i] == j) System.out.print("Q ");
                    else      System.out.print("* ");    
                }
                System.out.println();
            }
            System.out.println();
        }

       /***************************************************************************
        * Try all permutations using backtracking
        ***************************************************************************/
        public static void enumerate(int n) {
            int[] a = new int[n];
            enumerate(a, 0);
        }

        public static void enumerate(int[] q, int k) {
            int n = q.length;
            if (k == n) printQueens(q);
            else {
                for (int i = 0; i < n; i++) {
                    q[k] = i;
                    if (isConsistent(q, k)) enumerate(q, k+1);
                }
            }
        }

        public static void main(String[] args) {
        
          
           Queens q=new Queens();
           String[] sarray=q.flipLines(new Scanner(System.in));
          
        //   Scanner sc=new Scanner(System.in);
           int n=Integer.parseInt(sarray[0]);
       
            enumerate(n);
        }

   }

/*output:-

4 1 1
* Q * *
* * * Q
Q * * *
* * Q *

* * Q *
Q * * *
* * * Q
* Q * *

*/