We Keep Coding

Possible overtakes a chess piece can make as a List? One liner java 8

Given a 2D array of a Piece. Has location etc.
Piece[][] board = new Piece[8][8];
Given a pair-value Location object (row, col).
Given a validator that validates moves (standard chess):
public boolean isValidMove(Piece piece, Location toLocation) { ... }
I wrote this:
/**
* Generates a List of possible overtakes for a Piece.
*
* #param piece
* Piece that will be overtaking another.
* #return A List of possible overtakes the piece can make.
*/
public List<Piece> possibleMoves(Piece piece) {
return Stream.of(board.getBoard()).flatMap(Stream::of).filter(
p -> p != null && isValidMove(piece, p.getLocation())).collect(
Collectors.toList());
}
But this will only return the Piece that it can overtake. How can I get only the Location?
Also another question, this looks fancy and all but performance-wise. Is it better or worse than a double for loop in anyway?

Is this MVC method a good way to program a Sudoku Game?

I'm building a Sudoku Game. I came here to get some help because I'm completely stuck in my code. I'm not asking for you to complete my code, I know that's not your job. Just few hints as what to do next would be great!
I use MVC and Swing Components for GUI to make the code lighter. I divided each field and method so I can understand what to do next but I'm confused. I'm particularly having trouble understanding how to do the following methods:
initializeGrid
chooseGameDifficulty
makeMove
cancelMove
Model
public class GameSudokuModel {
// states -- fields
Scanner userInput = new Scanner (System.in); // accept user input
// int levelDifficulty = 0; // level of difficulties
int [] gridSize ; // Sudoku 9x9 == 81 cells -- used to initialize grid or solve puzzle --
int [] subGridSize ; // a sub-grid = 9 cells
int gameMove = 0; // calculate the total number of moves per game // ++makeMove and --cancelMove
int [] gameCell = {1, 2, 3, 4, 5, 6, 7, 8, 9}; // a cell contain a list of choices numbers 1-9
int currentGameTime = 0; // calculates the total time to complete a puzzle
String currentPlayerName = userInput.nextLine(); // player name
// end of fields
//behaviors -- methods
/******************************************************
*
* Method calculateGameTime (initialiserGrille)
*
*
* Calculates time
*
* The stopwatch starts when the player makes ​​his first move
*
*
*
******************************************************/
public class calculateGameTime{
}
/******************************************************
*
* Method initializeGrid (initialiserGrille)
*
*
* Used to initialize a grid
*
* Reset the grid ( back to the original Sudoku grid ) using the list of moves .
*
*
*
*
*
******************************************************/
public class initializeGrid {
}
/******************************************************
*
* Method levelDifficulty
*
*
* Established the parameters of level of difficulty
*
*
* #param beginner
* #param expert
* #return
******************************************************/
public int levelDifficulty (int beginner, int expert){
while(true)
{
int levelDifficulty = 0;
levelDifficulty= userInput.nextInt();
System.out.println (" ");
if(levelDifficulty < beginner || levelDifficulty> expert){
System.out.print (" You must choose 1, 2 or 3." + "Please try again : ");
System.out.println (" ");
}
else
return levelDifficulty;
}
}
/****************************************************
* Method chooseGameDifficulty (chosisirNiveauDifficulte)
*
* The method makes possible to choose the level of complexity of a grid
*
* (1) beginner: the player starts the game with a grid made ​​up to 75% (81 * 0.75)
*
* (2) Intermediate : the player starts the game with a grid made ​​up to 50% (81 * 0.50)
*
* (3) Expert : the player starts the game with a grid made ​​up to 25% (81 * 0.25)
*
* Numbers are set randomly on the grid every new game
*
* #param beginner
* #param intermediate
* #param expert
******************************************************/
public void chooseGameDifficulty(int beginner, int intermediate, int expert){
boolean entreeValide;
int levelDifficulty;
String reponse;
levelDifficulty= levelDifficulty(beginner,expert); // call function levelDifficulty()
if(levelDifficulty==beginner)
//get easy level grid (getter)
//set easy level grid (setter)
if(levelDifficulty==intermediate)
//get intermediate level grid (getter)
//set intermediate level grid (setter)
if(levelDifficulty==expert)
//get expert level grid (getter)
//set easy expert grid (setter)
}
/****************************************************
* Method solvePuzzle (resoudrePuzzle)
*
* This method makes possible to solve the entire grid meaning all the 81 cells
*
******************************************************/
public class solvePuzzle {
}
/****************************************************
* Method makeMove (fairePlacement)
*
* Save a record of the player's actions on the grid.
*
*
*
* (1) make move on the grid ;
* (2) save moves in an array list
*
******************************************************/
public class makeMove {
//choose a cell , enter a number on the cell and confirm the selection
// adds move to the array list
int makeMove = gameMove++;
}
/****************************************************
* Method cancelMove (annulerPlacement)
*
*
*
* (1) retrieve the last instance in the arraylist (using the remove method and the size method to determine the number of elements )
* (2) cancel the move in the grid.
*
******************************************************/
public class cancelMove {
//choose a cell , remove the number on the cell and confirm the cancellation
//substracts move from array list
int cancelMove = gameMove--;
}
}

initializeGrid and chooseGameDifficulty aren't really features of the model. The model maintains the current state of the data and the rules uses to manage it.
Technically, these features should be functions of some kind of factory that given a difficult level will return a instance of the model
public class SudokuFactory {
public enum Difficulty {
HARD,
MODERATE,
EASY
}
public SudokuModel createModel(Difficulty difficult) {
// Make a new model based on the rules for your difficulty
// settings
}
}
The model would then simply contain the information and functionality to manage it
You should also avoid static where practically possible, it should never be used as a cross class communication mechanism, if you need to share data, you should pass it. static just makes the whole thing a lot more difficult to manage and debug
The view would get the information from the user (like the difficulty level), which would be used by the controller to build a new model. The model would then be passed to a new controller, which would generate a new view, which should present the current state of the model.
The controller would then respond to changes in the view, updating the model and the controller would respond to changes in the model and update the view.
You should also prefer using interfaces over implementation
So, based on my (rather pathetic) understanding of Sudoku you could use a model as simple as ...
public interface SudokuModel {
public void setValueAt(int value, int row, int col) throws IllegalArgumentException;
public int getValueAt(int row, int col);
}
Now, me, personally, I'd have an implementation that had two buffers, one which represents the actual game/solution and one which represents the player data (pre-filled based on the difficulty level), now you could have a single buffer, but you'd have constantly scan the grid to see if the new value was valid and I'm just too lazy ;)

How to solve a maze with a Queue?

I'm very confused on how I would solve a maze using a queue. I've provided some javadocs and some psuedo code that my professor has given us. Help if possibble. I've looked on other topics but I could not understand there's hopefully someone can help me with my solve method. thanks
public class QueueMazeSolver implements MazeSolver {
private MazeGUI gui;
public static class Cell {
private int r;
private int c;
public Cell(int row, int col){
r = row;
c = col;
}
}
public QueueMazeSolver(){
gui = new MazeGUI( this );
}
/**
* This method is called when the start button is
* clicked in the MazeGUI. This method should solve the maze.
* This method may call MazeGUI.drawMaze(...) whenever the
* GUI display should be updated (after each step of the solution).
*
* The maze is provided as the first parameter. It is a 2D array containing
* characters that represent the spaces in the maze. The following
* characters will be found in the array:
* '#' - This represents a wall.
* ' ' - This represents an open space (corridor)
*
* When calling MazeGUI.drawMaze(...) to update the display, the GUI
* will recognize the '#' and ' ' characters as well as the following:
* '#' - Means the cell is a space that has been explored
* '%' - Means that the cell is part of the best path to the goal.
*
* #param maze the maze (see above).
* #param startR the row of the start cell.
* #param startC the column of the start cell.
* #param endR the row of the end (goal) cell.
* #param endC the column of the end (goal) cell.
*/
#Override
public void solve(char[][] maze, int startR, int startC, int endR, int endC) {
maze[startR][startC] = '#';
ArrayQueue<Cell> agenda = new ArrayQueue<Cell>();
Cell temp = new Cell(startR, startC);
agenda.offer(temp);
// while agenda is not empty and red not found
while(!agenda.isEmpty() && maze[endR][endC] != '#' ){
Cell current = agenda.poll(); //remove front square from queue
/*
if front square is red
found it
else
mark amaze all unexplored neighbors of front
square and add them to the square
*/
if(current == new Cell(endR, endC) ){
break;
}
else{
=
}
}
/** Notes
maze[r][c] = '#' //marking cell seen
up = r-1, c
down = r+1, c
left = r, c-1
right = r, c+1
*/
}
if (!agenda.isEmpty())
gui.setStatusText("Maze is solvable");
else
gui.setStatusText("Maze is unsolvable");
gui.drawMaze(maze);
try {Thread.sleep(150);}
catch (InterruptedException e){
System.err.println("Thread interrupted");
}
}
public static void main(String[] args){
QueueMazeSolver solver = new QueueMazeSolver();
}
}

it seems you are trying to get possible paths to move in a maze and reach red cell , which has walls (can't cross) or open space .
Basically this code is applying a breadth first search .
we remove a cell from queue and if the surrounding cells [at distance 1 unit] are not visited , add them to queue and visit them .
Pseudocode (from wikipedia) :
1 procedure BFS(G,v) is
2 create a queue Q
3 create a vector set V
4 enqueue v onto Q
5 add v to V
6 while Q is not empty loop
7 t ← Q.dequeue()
8 if t is what we are looking for then
9 return t
10 end if
11 for all edges e in G.adjacentEdges(t) loop
12 u ← G.adjacentVertex(t,e)
13 if u is not in V then
14 add u to V
15 enqueue u onto Q
16 end if
17 end loop
18 end loop
19 return none
20 end BFS
suppose you are at cell(i,j) , therefore t=(i,j) and adjacentEdges(t) are (i+1,j) , (i,j+1) , (i-1,j) . (i,j-1)
If (i+1,j) is not visited before , add it to queue (so , next time you pop from queue , you will get it) else if it is visited (i.e in V) then we are done with it . Repeat same for other three cells .
This way you do O(m*n) operations and visit each cell exactly once .

Web caching algorithm (hashmaps keys-values issue?)

I am newbee in programming in general and in Java in particular. The last few months I am working on a project regarding a Web caching algorithm. After a lot of work I have done everything (and since this is my first real project, I am very happy about that) except one little but important detail. Let me be more precise on that.
In the code I generate random Zipf-distributed requests. Each requested item is distinguished by its numeric ID (reqID). The cache is implemented as a doubly linked list (a Java LinkedList). The caching algorithm is called WeightLFU and it works as follows:
Each request is assigned a weight which is given by the formula
weight = Math.pow(1/p, reqIndex);
where p is a weight factor and reqIndex is the numeric index of the request (1st, 2nd, 3rd etc.).
The score (which I call weighted frequency, weightFreq) of each cached item is given as the sum of its weights. Let us see an example to illustrate this. Assume that we have the following request stream (the reqIDs are given):
ReqIndex: 1 | 2 | 3 | 4 | 5
ReqID: 7 | 3 | 7 | 1 | 3
Assuming p= 0.5 (just a convenient value), the weights assigned to each request are:
ReqIndex: 1 | 2 | 3 | 4 | 5
Weight: 1 | 2 | 4 | 8 | 16
Therefore, the score of the requested item with reqID 7 is 1 + 4 = 5, the score of the item with reqID 3 is 2 + 16 = 18 and finally the score of the item with reqID 1 is 8.
Now here is what I do wrong. In this example, I would have the following: the score of item 3 would be 16+8+4+2+1 = 31, the score of item 1 would be 8+4+2+1 = 15 etc., i.e. the code sums all the previous weights irrespective of the request ID. Here are the relevant parts of the code:
Class WeightLFU
public class WeightLFU {
//////////////////////////////////////////
// member attributes
/** weightLFU cache */
private List<Request> weightLFU = new LinkedList<Request>();
/** Max cache size */
private int M;
/** Fading factor */
private double p;
/** Weight */
private double weight;
/** Score (weightFreq) */
private double weightFreq;
/** Map of reqID (K) and weight (V) */
private Map<Integer, Double> weights;
/** Map of reqID (K) and weightFreq (V) */
private Map<Integer, Double> weightFreqs;
//////////////////////////////////////////
// member methods
// constructor, printing methods, initializers etc.
/**
* Getter for weight of request
* #param request The requested item
* #param reqIndex The index of the request
* #return this.weights.get(request.reqID) The weight of the request
*/
public double getWeight(Request request, int reqIndex) {
// calculate weight
weight = Math.pow(1/p, reqIndex);
// put request along with its weight to the weights map
weights.put(request.reqID, weight);
// return weight of requested item
return this.weights.get(request.reqID);
}
/**
* Calculate weightFreq of requested item
* #param request The requested item
* #param reqIndex Index of the request
*/
public void calcWeightFreq(Request request, int reqIndex) {
// initialize weightFreq
initWeightFreqs(request);
// calculate weight freq
weightFreq += getWeight(request, reqIndex);
// put reqID along with its weightFreq into the weightFreqs map
weightFreqs.put(request.reqID, weightFreq);
}
/**
* Getter for weightFreq of requested item
* #param request The requested item
* #return this.weightFreqs.get(request.reqID); weightFreq of req. item
*/
public double getWeightFreq(Request request) {
// return weightFreq of requested item
return this.weightFreqs.get(request.reqID);
}
// other stuff (cache lookup, insertion, replacement etc.)
}
The reason I use a method calcWeightFreq and another method as getter instead of combining them in a single getter method is just to avoid using as parameter the reqIndex when I call the getter method in cache insertion and replacement operations latter on. It is irrelevant of my issue.
Main class:
// several irrelevant stuff
// scan the request list
for(int ir = 0; ir < reqs.size(); ir++) {
// assign the item in position ir in the reqs list to a Request item r
Request r = reqs.get(ir);
// other stuff
}
// other stuff
}
I understand that this abnormal behavior makes sense. I assume that in the calcWeightFreq method I have to scan the weights map in order to get the sum of the weights only for the specific reqID, but this does not work either (I get 0 value for all the weightFreq values).
I hope I have clearly stated the issue. I assume that it needs only 5-10 lines of additional code to be addressed, but I don't know how to do it. Any guidance would be appreciated. Thank you in advance.

Binary search tree: return occurrences of a word from a text file

This is my first post so apologies if I haven't quite got the framing of the question quite right yet. I'll put my hands up straight away and say this is part of my 'homework', I've got about 99% of it done but I've got this niggling bug that has been driving me crazy all week and I simply can't see the wood through the trees here.
The basic concept is that we have a text file, a poem of sorts, that our program has to look at and then place into a binary tree. We should record each word, the occurrence of each word and which line it appears in. I have managed to do that, save for that for in the example "And I went to StackOverFlow and I asked the question, and the answer was..." my program should return that the word "And" appears in line 1 (which it currently does), but it is currently recording every occurrence of that word and it should only record that the word "and" occurs in line 1 and not every instance of it.
So in the above example "And I went to StackOverFlow and I asked the question, and the answer was.."
So just picking out the word "And" here since it occurs multiple times, my program is currently returning:
"And [1, 1, 1]"
But it should be returning:
"And [1]"
I have supplied the code for the entire program, but the method I think to focus on is the recordWord method, at the final else if, something isn't quite right there clearly! Apologies if this explanation is hugely convoluted but I couldn't think of another way to explain it! Any help would be hugely appreciated
import java.util.*;
/**
* A class representing a binary tree containing words.
*
*/
public class WordTree {
public String word;
public ArrayList<Integer> lineNumbers;
public WordTree left, right;
/**
* Constructs a tree consisting of a single node, with the given word and
* line number.
*
* #param w
* the word
* #param lineNo
* the line number
* #pre true
* #post word tree containing word w on line lineNo has been constructed
*/
public WordTree(String w, int lineNo) {
word = w;
lineNumbers = new ArrayList<Integer>();
lineNumbers.add(lineNo);
left = null;
right = null;
}
/**
* Records a new occurrence of the given word, in the tree.
*
* #param w
* the word
* #param lineNo
* the line number
* #pre this is a well formed binary search tree
* #post if word was not in this tree, then the word and its line number
* line have been inserted into ordered word tree, else line has been
* appended to line-number list for word (if we haven't already
* recorded that line number for this word)
*/
public void recordWord(String word2, int lineNo) {
if (word.compareToIgnoreCase(word2) < 0) {
if (right != null) {
right.recordWord(word2, lineNo);
} else {
right = new WordTree(word2, lineNo);
}
} else if (word.compareToIgnoreCase(word2) > 0) {
if (left != null) {
left.recordWord(word2, lineNo);
} else {
left = new WordTree(word2, lineNo);
}
} else if (word.compareToIgnoreCase(word2) == 0) {
lineNumbers.add(lineNo);
}
}
// System.out.println("method recordWord not implemented yet");
/**
* Displays all the words in this tree.
*
* #pre this is a well formed binary search tree
* #post words have been written out in alphabetical order, each followed by
* ascending list of line numbers on which the word occurs
*/
public void display() {
if (left != null) {
left.display();
}
System.out.println(word + lineNumbers);
if (right != null) {
right.display();
}
}
/**
* Counts how many different words there are in this tree.
*
* #pre this is a well formed binary search tree
* #return the number of different words in tree
*/
public int numberOfEntries() {
int count = 1;
if (left != null) {
count += left.numberOfEntries();
}
if (right != null) {
count += right.numberOfEntries();
}
}
}

Since List accepts duplication, it may accepts elements with the same value. Instead, you could use Set interface which eliminates duplication for you automatically. In your example, you can declare lineNumbers as a TreeSet to print the output in ascending line number.
Declare lineNumbers as a Set
public Set<Integer> lineNumbers;
Then initialize it in the constructor using TreeSet
lineNumbers = new TreeSet<Integer>();
It's all that you need to change. Hope it's clear enough.