public boolean moveDown() {
for (Cell cell : tetromino.getCells(this)) {
if (isOccupied(cell.getCol(), cell.getRow() + 1)) return false;
}
tetromino.fall();
return true;
}
@Override
public boolean equals(Object other) {
if (other instanceof Cell) {
Cell otherCell = (Cell) other;
return (otherCell.getRow() == row) && (otherCell.getCol() == col);
}
return false;
}
/** @return the largest connected component of the graph. */
public ArrayList<Cell> getLargestConnectedComponent() {
ArrayList<ArrayList<Cell>> components = new ArrayList<>();
boolean visited[][] = new boolean[rowCount][colCount];
for (int row = 0; row < rowCount; ++row)
for (int col = 0; col < colCount; ++col) visited[row][col] = false;
Queue<Cell> q;
Cell t = null, u = null;
for (Cell c : g.vertexSet()) {
if (!visited[c.getRow()][c.getCol()]) {
q = new LinkedList<Cell>();
ArrayList<Cell> component = new ArrayList<>();
visited[c.getRow()][c.getCol()] = true;
// Find all connected nodes
q.add(c);
component.add(c);
while (!q.isEmpty()) {
t = q.remove();
for (WeightedEdge e : g.edgesOf(t)) {
u = t.equals(g.getEdgeSource(e)) ? g.getEdgeTarget(e) : g.getEdgeSource(e);
if (!visited[u.getRow()][u.getCol()]) {
visited[u.getRow()][u.getCol()] = true;
q.add(u);
component.add(u);
}
}
}
components.add(component);
}
}
int largestSize = 0, largestIndex = 0;
for (int i = 0; i < components.size(); ++i) {
if (components.get(i).size() > largestSize) {
largestSize = components.get(i).size();
largestIndex = i;
}
}
filterGraph(components.get(largestIndex));
return components.get(largestIndex);
}
private void backtrackSequential(int[][] sudokuBoard) {
if (isSolution(sudokuBoard)) {
// process
System.out.println("Solution found");
printBoard(sudokuBoard);
finished = true;
return;
}
Cell unassigned = getUnAssignedCell(sudokuBoard);
for (int i = 1; i <= sudokuBoard.length; i++) {
if (isSafe(sudokuBoard, i, unassigned.getRow(), unassigned.getCol())) {
sudokuBoard[unassigned.getRow()][unassigned.getCol()] = i;
backtrackSequential(sudokuBoard);
if (finished) {
return;
}
sudokuBoard[unassigned.getRow()][unassigned.getCol()] = 0;
}
}
}
protected Object getTraceback() {
StringBuffer align1Buf = new StringBuffer();
StringBuffer align2Buf = new StringBuffer();
Cell currentCell = getTracebackStartingCell();
while (traceBackIsNotDone(currentCell)) {
if (currentCell.getRow() - currentCell.getPrevCell().getRow() == 1) {
align2Buf.insert(0, sequence2.charAt(currentCell.getRow() - 1));
} else {
align2Buf.insert(0, '-');
}
if (currentCell.getCol() - currentCell.getPrevCell().getCol() == 1) {
align1Buf.insert(0, sequence1.charAt(currentCell.getCol() - 1));
} else {
align1Buf.insert(0, '-');
}
currentCell = currentCell.getPrevCell();
}
String[] alignments = new String[] {align1Buf.toString(), align2Buf.toString()};
return alignments;
}
private void backtrack(int[][] sudokuBoard, int index) {
if (isSolution(sudokuBoard)) {
// process
System.out.println("Solution found");
printBoard(sudokuBoard);
finished = true;
return;
}
if (index >= cellChoices.size()) {
return;
}
Cell cell = cellChoices.get(index);
for (int i : cell.getPossibleValue()) {
if (isSafe(sudokuBoard, i, cell.getRow(), cell.getCol())) {
sudokuBoard[cell.getRow()][cell.getCol()] = i;
backtrack(sudokuBoard, index + 1);
if (finished) {
return;
}
sudokuBoard[cell.getRow()][cell.getCol()] = 0;
}
}
}
/** Presents the given cell feed as a map from row, column pair to CellEntry. */
private void refreshCachedData() throws IOException, ServiceException {
CellQuery cellQuery = new CellQuery(backingEntry.getCellFeedUrl());
cellQuery.setReturnEmpty(true);
this.cellFeed = spreadsheetService.getFeed(cellQuery, CellFeed.class);
// A subtlety: Spreadsheets row,col numbers are 1-based whereas the
// cellEntries array is 0-based. Rather than wasting an extra row and
// column worth of cells in memory, we adjust accesses by subtracting
// 1 from each row or column number.
cellEntries = new CellEntry[rows][columns];
for (CellEntry cellEntry : cellFeed.getEntries()) {
Cell cell = cellEntry.getCell();
cellEntries[cell.getRow() - 1][cell.getCol() - 1] = cellEntry;
}
}
public int countBlobs() {
Cell currentCell;
int count = 0;
Cell check;
for (int row = 0; row < rows; row++) {
for (int col = 0; col < columns; col++) {
currentCell = grid[row][col];
if (!currentCell.isVisited() && currentCell.hasBlob()) {
currentCell.setVisited();
count++;
markBlob(row, col);
}
while (!stack.isEmpty()) {
check = stack.pop();
markBlob(check.getRow(), check.getCol());
}
}
}
return count;
}
public static void gogogo(
String username,
String password,
int itemsPerBatch,
String spreadsheetName,
String worksheetName,
String data)
throws Exception {
System.out.println("# Initializing upload to Google Spreadsheets...");
System.out.print("# Logging in as: \"" + username + "\"... ");
ImportClient client = new ImportClient(username, password, itemsPerBatch, spreadsheetName);
System.out.println("Success!");
Pattern delim = Pattern.compile(DELIM);
try {
int row = 0;
String[] allLines = data.split("\n");
int currentCell = 1;
int allRow = allLines.length;
System.out.println("# Preparing " + allRow + " rows to be updated... ");
List<CellEntry> updatedCells = new LinkedList<CellEntry>();
Worksheet workSheet = client.getWorksheet(spreadsheetName, worksheetName);
ProgressBar.updateProgress(0, allRow);
for (String line : allLines) {
// Break up the line by the delimiter and insert the cells
String[] cells = delim.split(line, -1);
for (int col = 0; col < cells.length; col++) {
// old way - send the change
// client.insertCellEntry(spreadsheet, worksheet, row + 1, col + 1,
// cells[col]);
// prepare change
CellEntry cellEntry = workSheet.getCell(row + 1, col + 1);
String value = cells[col];
cellEntry.changeInputValueLocal(value);
updatedCells.add(cellEntry);
}
// Advance the loop
ProgressBar.updateProgress(++row, allRow);
}
// send the batches
int allBatches = updatedCells.size();
int currentBatch = 0;
List<List<CellEntry>> batches = chunkList(updatedCells, ITEMS_PER_BATCH);
System.out.println("\n\n# Uploading changes in " + batches.size() + " chunks, ");
System.out.println("# containing a total of " + allBatches + " operations... ");
for (List<CellEntry> batch : batches) {
CellFeed batchFeed = new CellFeed();
for (CellEntry cellEntry : batch) {
ProgressBar.updateProgress(++currentBatch, allBatches);
Cell cell = cellEntry.getCell();
BatchUtils.setBatchId(cellEntry, "R" + cell.getRow() + "C" + cell.getCol());
BatchUtils.setBatchOperationType(cellEntry, BatchOperationType.UPDATE);
batchFeed.getEntries().add(cellEntry);
}
Link batchLink = workSheet.getBatchUpdateLink();
CellFeed batchResultFeed = client.service.batch(new URL(batchLink.getHref()), batchFeed);
// Make sure all the operations were successful.
for (CellEntry entry : batchResultFeed.getEntries()) {
if (!BatchUtils.isSuccess(entry)) {
String batchId = BatchUtils.getBatchId(entry);
BatchStatus status = BatchUtils.getBatchStatus(entry);
System.err.println("Failed entry");
System.err.println("\t" + batchId + " failed (" + status.getReason() + ") ");
return;
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* Returns the alignment of two sequences based on the passed array of pointers
*
* @param s1 sequence #1
* @param s2 sequence #2
* @param m scoring matrix
* @param pointers traceback matrix
* @param cell The cell where the traceback starts.
* @return {@link Alignment} with the two aligned sequences and alignment score.
* @see Cell
* @see Alignment
*/
private static Alignment traceback(
Sequence s1, Sequence s2, Matrix m, byte[] pointers, Cell cell, short[] lengths) {
logger.info("Started...");
char[] array1 = s1.toArray();
char[] array2 = s2.toArray();
float[][] scores = m.getScores();
Alignment alignment = new Alignment();
alignment.setScore(cell.getScore());
// maximum length after the aligned sequences
int maxlen = s1.length() + s2.length();
char[] reversed1 = new char[maxlen]; // reversed sequence #1
char[] reversed2 = new char[maxlen]; // reversed sequence #2
char[] reversed3 = new char[maxlen]; // reversed markup
int len1 = 0; // length of sequence #1 after alignment
int len2 = 0; // length of sequence #2 after alignment
int len3 = 0; // length of the markup line
int identity = 0; // count of identitcal pairs
int similarity = 0; // count of similar pairs
int gaps = 0; // count of gaps
char c1, c2;
int i = cell.getRow(); // traceback start row
int j = cell.getCol(); // traceback start col
int n = s2.length() + 1;
int row = i * n;
int a = s1.length() - 1;
int b = s2.length() - 1;
if (a - i > b - j) {
for (; a - i > b - j; a--) {
reversed1[len1++] = array1[a];
reversed2[len2++] = Alignment.GAP;
reversed3[len3++] = Markups.GAP;
gaps++;
}
for (; b > j - 1; a--, b--) {
c1 = array1[a];
c2 = array2[b];
reversed1[len1++] = c1;
reversed2[len2++] = c2;
if (c1 == c2) {
reversed3[len3++] = Markups.IDENTITY;
identity++;
similarity++;
} else if (scores[c1][c2] > 0) {
reversed3[len3++] = Markups.SIMILARITY;
similarity++;
} else {
reversed3[len3++] = Markups.MISMATCH;
}
}
} else {
for (; b - j > a - i; b--) {
reversed1[len1++] = Alignment.GAP;
reversed2[len2++] = array2[b];
reversed3[len3++] = Markups.GAP;
gaps++;
}
for (; a > i - 1; a--, b--) {
c1 = array1[a];
c2 = array2[b];
reversed1[len1++] = c1;
reversed2[len2++] = c2;
if (c1 == c2) {
reversed3[len3++] = Markups.IDENTITY;
identity++;
similarity++;
} else if (scores[c1][c2] > 0) {
reversed3[len3++] = Markups.SIMILARITY;
similarity++;
} else {
reversed3[len3++] = Markups.MISMATCH;
}
}
}
// Traceback flag, where true => continue and false => stop
boolean stillGoing = true;
while (stillGoing) {
int l = row + j;
switch (pointers[l]) {
case Directions.UP:
for (int k = 0, len = lengths[l]; k < len; k++) {
reversed1[len1++] = array1[--i];
reversed2[len2++] = Alignment.GAP;
reversed3[len3++] = Markups.GAP;
row -= n;
gaps++;
}
break;
case Directions.DIAGONAL:
c1 = array1[--i];
c2 = array2[--j];
reversed1[len1++] = c1;
reversed2[len2++] = c2;
row -= n;
if (c1 == c2) {
reversed3[len3++] = Markups.IDENTITY;
identity++;
similarity++;
} else if (scores[c1][c2] > 0) {
reversed3[len3++] = Markups.SIMILARITY;
similarity++;
} else {
reversed3[len3++] = Markups.MISMATCH;
}
break;
case Directions.LEFT:
for (int k = 0, len = lengths[l]; k < len; k++) {
reversed1[len1++] = Alignment.GAP;
reversed2[len2++] = array2[--j];
reversed3[len3++] = Markups.GAP;
gaps++;
}
break;
case Directions.STOP:
stillGoing = false;
}
}
alignment.setSequence1(reverse(reversed1, len1));
alignment.setStart1(i);
alignment.setSequence2(reverse(reversed2, len2));
alignment.setStart2(j);
alignment.setMarkupLine(reverse(reversed3, len3));
alignment.setIdentity(identity);
alignment.setGaps(gaps);
alignment.setSimilarity(similarity);
logger.info("Finished.");
return alignment;
}
/** Déplace le tetromino vers la droite */
public boolean moveRight() {
for (Cell cell : tetromino.getCells(this))
if (isOccupied(cell.getCol() + 1, cell.getRow())) return false;
tetromino.moveRight();
return true;
}
