Replace logTracer.print with println

Author: 64json

Backtracking/Knight's Tour Problem/code.js

@@ -50,7 +50,7 @@ function knightTour(x, y, moveNum) {
     if (nextX >= 0 && nextX < N && nextY >= 0 && nextY < N && board[nextX][nextY] === -1) {
       board[nextX][nextY] = moveNum;
 
-      logTracer.print(`Move to ${nextX},${nextY}`);
+      logTracer.println(`Move to ${nextX},${nextY}`);
       boardTracer.patch(nextX, nextY, moveNum).delay();
       boardTracer.depatch(nextX, nextY);
       boardTracer.select(nextX, nextY);
@@ -59,13 +59,13 @@ function knightTour(x, y, moveNum) {
       if (knightTour(nextX, nextY, nextMoveNum) === true) {
         return true;
       }
-      logTracer.print(`No place to move from ${nextX},${nextY}: Backtrack`);
+      logTracer.println(`No place to move from ${nextX},${nextY}: Backtrack`);
       board[nextX][nextY] = -1; // backtrack
       boardTracer.patch(nextX, nextY, -1).delay();
       boardTracer.depatch(nextX, nextY);
       boardTracer.deselect(nextX, nextY);
     } else {
-      logTracer.print(`${nextX},${nextY} is not a valid move`);
+      logTracer.println(`${nextX},${nextY} is not a valid move`);
     }
   }
   return false;
@@ -84,7 +84,7 @@ posTracer.depatch(0);
 posTracer.depatch(1);
 
 if (knightTour(0, 0, 1) === false) {
-  logTracer.print('Solution does not exist');
+  logTracer.println('Solution does not exist');
 } else {
-  logTracer.print('Solution found');
+  logTracer.println('Solution found');
 }

Backtracking/N-Queens Problem/code.js

@@ -22,7 +22,7 @@ const logger = new LogTracer('Progress');
 
 boardTracer.set(board);
 queenTracer.set(queens);
-logger.print(`N Queens: ${N}X${N}matrix, ${N} queens`).delay();
+logger.println(`N Queens: ${N}X${N}matrix, ${N} queens`).delay();
 
 function validState(row, col, currentQueen) {
   for (let q = 0; q < currentQueen; q++) {
@@ -35,18 +35,18 @@ function validState(row, col, currentQueen) {
 }
 
 function nQ(currentQueen, currentCol) {
-  logger.print(`Starting new iteration of nQueens () with currentQueen = ${currentQueen} & currentCol = ${currentCol}`);
-  logger.print('------------------------------------------------------------------');
+  logger.println(`Starting new iteration of nQueens () with currentQueen = ${currentQueen} & currentCol = ${currentCol}`);
+  logger.println('------------------------------------------------------------------');
   if (currentQueen >= N) {
-    logger.print('The recursion has BOTTOMED OUT. All queens have been placed successfully');
+    logger.println('The recursion has BOTTOMED OUT. All queens have been placed successfully');
     return true;
   }
 
   let found = false;
   let row = 0;
   while ((row < N) && (!found)) {
     boardTracer.select(row, currentCol).delay();
-    logger.print(`Trying queen ${currentQueen} at row ${row} & col ${currentCol}`);
+    logger.println(`Trying queen ${currentQueen} at row ${row} & col ${currentCol}`);
 
     if (validState(row, currentCol, currentQueen)) {
       queens[currentQueen][0] = row;
@@ -62,14 +62,14 @@ function nQ(currentQueen, currentCol) {
 
     if (!found) {
       boardTracer.deselect(row, currentCol).delay();
-      logger.print(`row ${row} & col ${currentCol} didn't work out. Going down`);
+      logger.println(`row ${row} & col ${currentCol} didn't work out. Going down`);
     }
     row++;
   }
 
   return found;
 }
 
-logger.print('Starting execution');
+logger.println('Starting execution');
 nQ(0, 0);
-logger.print('DONE');
+logger.println('DONE');

Branch and Bound/Binary Search Tree/insertion.js

@@ -22,7 +22,7 @@ function bstInsert(root, element, parent) { // root = current node , parent = pr
       treeNode[propName] = element;
       T[element] = {};
       graphTracer.addNode(element).addEdge(root, element).select(element, root).delay().deselect(element, root);
-      logger.print(`${element} Inserted`);
+      logger.println(`${element} Inserted`);
     } else {
       bstInsert(treeNode[propName], element, root);
     }
@@ -33,7 +33,7 @@ function bstInsert(root, element, parent) { // root = current node , parent = pr
 const Root = elements[0]; // take first element as root
 T[Root] = {};
 graphTracer.addNode(Root).layoutTree(Root, true);
-logger.print(`${Root} Inserted as root of tree `);
+logger.println(`${Root} Inserted as root of tree `);
 
 for (let i = 1; i < elements.length; i++) {
   elemTracer.select(i).delay();

Branch and Bound/Binary Search Tree/search.js

@@ -36,21 +36,21 @@ tracer.log(logger).delay();
 function bst(item, node, parent) { // node = current node , parent = previous node
   tracer.visit(node, parent).delay();
   if (item === node) { // key found
-    logger.print(' Match Found ');
+    logger.println(' Match Found ');
   } else if (item < node) { // key less than value of current node
     if (T[node][0] === -1) {
-      logger.print(' Not Found ');
+      logger.println(' Not Found ');
     } else {
       bst(item, T[node][0], node);
     }
   } else { // key greater than value of current node
     if (T[node][1] === -1) {
-      logger.print(' Not Found ');
+      logger.println(' Not Found ');
     } else {
       bst(item, T[node][1], node);
     }
   }
 }
 
-logger.print(`Finding number ${key}`);
+logger.println(`Finding number ${key}`);
 bst(key, 5); // node with key 5 is the root

Branch and Bound/Binary Search/iterative.js

@@ -17,29 +17,29 @@ function BinarySearch(array, element) { // array = sorted array, element = eleme
 
     tracer.select(minIndex, maxIndex).delay();
     tracer.patch(middleIndex);
-    logger.print(`Searching at index: ${middleIndex}`).delay();
+    logger.println(`Searching at index: ${middleIndex}`).delay();
     tracer.depatch(middleIndex);
     tracer.deselect(minIndex, maxIndex);
 
     if (testElement < element) {
-      logger.print('Going right.');
+      logger.println('Going right.');
       minIndex = middleIndex + 1;
     } else if (testElement > element) {
-      logger.print('Going left.');
+      logger.println('Going left.');
       maxIndex = middleIndex - 1;
     } else {
-      logger.print(`${element} is found at position ${middleIndex}!`);
+      logger.println(`${element} is found at position ${middleIndex}!`);
       tracer.select(middleIndex);
 
       return middleIndex;
     }
   }
 
-  logger.print(`${element} is not found!`);
+  logger.println(`${element} is not found!`);
   return -1;
 }
 
 const element = D[new Randomize.Integer(0, D.length - 1).create()];
 
-logger.print(`Using iterative binary search to find ${element}`);
+logger.println(`Using iterative binary search to find ${element}`);
 BinarySearch(D, element);

Branch and Bound/Binary Search/recursive.js

@@ -8,7 +8,7 @@ tracer.set(D).delay();
 
 function BinarySearch(array, element, minIndex, maxIndex) { // array = sorted array, element = element to be found, minIndex = low index, maxIndex = high index
   if (minIndex > maxIndex) {
-    logger.print(`${element} is not found!`);
+    logger.println(`${element} is not found!`);
     return -1;
   }
 
@@ -17,31 +17,31 @@ function BinarySearch(array, element, minIndex, maxIndex) { // array = sorted ar
 
   tracer.select(minIndex, maxIndex).delay();
   tracer.patch(middleIndex);
-  logger.print(`Searching at index: ${middleIndex}`).delay();
+  logger.println(`Searching at index: ${middleIndex}`).delay();
   tracer.depatch(middleIndex);
   tracer.deselect(minIndex, maxIndex);
 
   if (testElement < element) {
-    logger.print('Going right.');
+    logger.println('Going right.');
     return BinarySearch(array, element, middleIndex + 1, maxIndex);
   }
 
   if (testElement > element) {
-    logger.print('Going left.');
+    logger.println('Going left.');
     return BinarySearch(array, element, minIndex, middleIndex - 1);
   }
 
   if (testElement === element) {
-    logger.print(`${element} is found at position ${middleIndex}!`);
+    logger.println(`${element} is found at position ${middleIndex}!`);
     tracer.select(middleIndex);
     return middleIndex;
   }
 
-  logger.print(`${element} is not found!`);
+  logger.println(`${element} is not found!`);
   return -1;
 }
 
 const element = D[new Randomize.Integer(0, D.length - 1).create()];
 
-logger.print(`Using binary search to find ${element}`);
+logger.println(`Using binary search to find ${element}`);
 BinarySearch(D, element, 0, D.length - 1);

Branch and Bound/Depth-Limited Search/code.js

@@ -33,4 +33,4 @@ function DLSCount(limit, node, parent) { // node = current node, parent = previo
   }
   return child;
 }
-logger.print(`Number of descendant is ${DLSCount(2, 0)}`);
+logger.println(`Number of descendant is ${DLSCount(2, 0)}`);

Branch and Bound/Topological Sort/code.js

@@ -19,54 +19,54 @@ const Q = [];
 let iter = 0;
 let i;
 
-logger.print('Calculating in-degrees for each Node...');
+logger.println('Calculating in-degrees for each Node...');
 for (let currNode = 0; currNode < G.length; currNode++) {
   for (let currNodeNeighbor = 0; currNodeNeighbor < G.length; currNodeNeighbor++) {
     if (G[currNode][currNodeNeighbor]) {
-      logger.print(`${currNodeNeighbor} has an incoming edge from ${currNode}`);
+      logger.println(`${currNodeNeighbor} has an incoming edge from ${currNode}`);
       tracer.visit(currNodeNeighbor, currNode).delay();
       inDegrees[currNodeNeighbor]++;
       tracer.leave(currNodeNeighbor, currNode).delay();
     }
   }
 }
-logger.print(`Done. In-Degrees are: [ ${String(inDegrees)} ]`);
-logger.print('');
+logger.println(`Done. In-Degrees are: [ ${String(inDegrees)} ]`);
+logger.println('');
 
-logger.print('Initializing queue with all the sources (nodes with no incoming edges)');
+logger.println('Initializing queue with all the sources (nodes with no incoming edges)');
 inDegrees.map((indegrees, node) => {
   tracer.visit(node).delay();
   if (!indegrees) {
-    logger.print(`${node} is a source`);
+    logger.println(`${node} is a source`);
     Q.push(node);
   }
   tracer.leave(node).delay();
 });
-logger.print(`Done. Initial State of Queue: [ ${String(Q)} ]`);
-logger.print('');
+logger.println(`Done. Initial State of Queue: [ ${String(Q)} ]`);
+logger.println('');
 
 // begin topological sort (kahn)
 while (Q.length > 0) {
-  logger.print(`Iteration #${iter}. Queue state: [ ${String(Q)} ]`);
+  logger.println(`Iteration #${iter}. Queue state: [ ${String(Q)} ]`);
   const currNode = Q.shift();
   tracer.visit(currNode).delay();
 
   for (i = 0; i < G.length; i++) {
     if (G[currNode][i]) {
-      logger.print(`${i} has an incoming edge from ${currNode}. Decrementing ${i}'s in-degree by 1.`);
+      logger.println(`${i} has an incoming edge from ${currNode}. Decrementing ${i}'s in-degree by 1.`);
       tracer.visit(i, currNode).delay();
       inDegrees[i]--;
       tracer.leave(i, currNode).delay();
 
       if (!inDegrees[i]) {
-        logger.print(`${i}'s in-degree is now 0. Enqueuing ${i}`);
+        logger.println(`${i}'s in-degree is now 0. Enqueuing ${i}`);
         Q.push(i);
       }
     }
   }
   tracer.leave(currNode).delay();
-  logger.print(`In-degrees are: [${String(inDegrees)} ]`);
-  logger.print('-------------------------------------------------------------------');
+  logger.println(`In-degrees are: [${String(inDegrees)} ]`);
+  logger.println('-------------------------------------------------------------------');
 
   iter++;
 }

Brute Force/Binary Tree Traversal/inOrder.js

@@ -36,23 +36,23 @@ let index = 0;
 
 function inOrder(root, parent) {
   if (root === -1) {
-    logger.print('No more nodes. Backtracking.').delay();
+    logger.println('No more nodes. Backtracking.').delay();
     return;
   }
 
-  logger.print(`Reached ${root}`);
+  logger.println(`Reached ${root}`);
   treeTracer.visit(root, parent).delay();
 
-  logger.print(` Going left from ${root}`).delay();
+  logger.println(` Going left from ${root}`).delay();
   inOrder(T[root][0], root);
 
-  logger.print(`Printing ${root}`);
+  logger.println(`Printing ${root}`);
   treeTracer.leave(root);
   arrayTracer.patch(index++, root).delay();
 
-  logger.print(` Going right from ${root}`).delay();
+  logger.println(` Going right from ${root}`).delay();
   inOrder(T[root][1], root);
 }
 
 inOrder(5); // node with key 5 is the root
-logger.print('Finished');
+logger.println('Finished');

Brute Force/Binary Tree Traversal/postOrder.js

@@ -36,23 +36,23 @@ let index = 0;
 
 function postOrder(root, parent) {
   if (root === -1) {
-    logger.print('No more nodes. Backtracking.').delay();
+    logger.println('No more nodes. Backtracking.').delay();
     return;
   }
 
-  logger.print(`Reached ${root}`);
+  logger.println(`Reached ${root}`);
   treeTracer.visit(root, parent).delay();
 
-  logger.print(` Going left from ${root}`).delay();
+  logger.println(` Going left from ${root}`).delay();
   postOrder(T[root][0], root);
 
-  logger.print(` Going right from ${root}`).delay();
+  logger.println(` Going right from ${root}`).delay();
   postOrder(T[root][1], root);
 
-  logger.print(`Printing ${root}`);
+  logger.println(`Printing ${root}`);
   treeTracer.leave(root);
   arrayTracer.patch(index++, root).delay();
 }
 
 postOrder(5); // node with key 5 is the root
-logger.print('Finished');
+logger.println('Finished');

Brute Force/Binary Tree Traversal/preOrder.js

@@ -36,23 +36,23 @@ let index = 0;
 
 function preOrder(root, parent) {
   if (root === -1) {
-    logger.print('No more nodes. Backtracking.').delay();
+    logger.println('No more nodes. Backtracking.').delay();
     return;
   }
 
-  logger.print(`Reached ${root}`);
+  logger.println(`Reached ${root}`);
   treeTracer.visit(root, parent).delay();
 
-  logger.print(`Printing ${root}`);
+  logger.println(`Printing ${root}`);
   treeTracer.leave(root);
   arrayTracer.patch(index++, root).delay();
 
-  logger.print(` Going left from ${root}`).delay();
+  logger.println(` Going left from ${root}`).delay();
   preOrder(T[root][0], root);
 
-  logger.print(` Going right from ${root}`).delay();
+  logger.println(` Going right from ${root}`).delay();
   preOrder(T[root][1], root);
 }
 
 preOrder(5); // node with key 5 is the root
-logger.print('Finished');
+logger.println('Finished');

Brute Force/Bipartiteness Test/code.js

@@ -41,14 +41,14 @@ function BFSCheckBipartiteness(s) {
           Q.push(i);
           tracer.visit(i, node).delay();
         } else if (Colors[i] === Colors[node]) {
-          logger.print('Graph is not biparted');
+          logger.println('Graph is not biparted');
           return false;
         }
       }
     }
   }
 
-  logger.print('Graph is biparted');
+  logger.println('Graph is biparted');
   return true;
 }