Skip to content

Commit e8dc99d

Browse files
64json64json
committed
Replace logTracer.print with println
1 parent 768770d commit e8dc99d

File tree

65 files changed

+376
-376
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

65 files changed

+376
-376
lines changed

‎Backtracking/Knight's Tour Problem/code.js

+5-5
Original file line numberDiff line numberDiff line change
@@ -50,7 +50,7 @@ function knightTour(x, y, moveNum) {
5050
if (nextX >= 0 && nextX < N && nextY >= 0 && nextY < N && board[nextX][nextY] === -1) {
5151
board[nextX][nextY] = moveNum;
5252

53-
logTracer.print(`Move to ${nextX},${nextY}`);
53+
logTracer.println(`Move to ${nextX},${nextY}`);
5454
boardTracer.patch(nextX, nextY, moveNum).delay();
5555
boardTracer.depatch(nextX, nextY);
5656
boardTracer.select(nextX, nextY);
@@ -59,13 +59,13 @@ function knightTour(x, y, moveNum) {
5959
if (knightTour(nextX, nextY, nextMoveNum) === true) {
6060
return true;
6161
}
62-
logTracer.print(`No place to move from ${nextX},${nextY}: Backtrack`);
62+
logTracer.println(`No place to move from ${nextX},${nextY}: Backtrack`);
6363
board[nextX][nextY] = -1; // backtrack
6464
boardTracer.patch(nextX, nextY, -1).delay();
6565
boardTracer.depatch(nextX, nextY);
6666
boardTracer.deselect(nextX, nextY);
6767
} else {
68-
logTracer.print(`${nextX},${nextY} is not a valid move`);
68+
logTracer.println(`${nextX},${nextY} is not a valid move`);
6969
}
7070
}
7171
return false;
@@ -84,7 +84,7 @@ posTracer.depatch(0);
8484
posTracer.depatch(1);
8585

8686
if (knightTour(0, 0, 1) === false) {
87-
logTracer.print('Solution does not exist');
87+
logTracer.println('Solution does not exist');
8888
} else {
89-
logTracer.print('Solution found');
89+
logTracer.println('Solution found');
9090
}

‎Backtracking/N-Queens Problem/code.js

+8-8
Original file line numberDiff line numberDiff line change
@@ -22,7 +22,7 @@ const logger = new LogTracer('Progress');
2222

2323
boardTracer.set(board);
2424
queenTracer.set(queens);
25-
logger.print(`N Queens: ${N}X${N}matrix, ${N} queens`).delay();
25+
logger.println(`N Queens: ${N}X${N}matrix, ${N} queens`).delay();
2626

2727
function validState(row, col, currentQueen) {
2828
for (let q = 0; q < currentQueen; q++) {
@@ -35,18 +35,18 @@ function validState(row, col, currentQueen) {
3535
}
3636

3737
function nQ(currentQueen, currentCol) {
38-
logger.print(`Starting new iteration of nQueens () with currentQueen = ${currentQueen} & currentCol = ${currentCol}`);
39-
logger.print('------------------------------------------------------------------');
38+
logger.println(`Starting new iteration of nQueens () with currentQueen = ${currentQueen} & currentCol = ${currentCol}`);
39+
logger.println('------------------------------------------------------------------');
4040
if (currentQueen >= N) {
41-
logger.print('The recursion has BOTTOMED OUT. All queens have been placed successfully');
41+
logger.println('The recursion has BOTTOMED OUT. All queens have been placed successfully');
4242
return true;
4343
}
4444

4545
let found = false;
4646
let row = 0;
4747
while ((row < N) && (!found)) {
4848
boardTracer.select(row, currentCol).delay();
49-
logger.print(`Trying queen ${currentQueen} at row ${row} & col ${currentCol}`);
49+
logger.println(`Trying queen ${currentQueen} at row ${row} & col ${currentCol}`);
5050

5151
if (validState(row, currentCol, currentQueen)) {
5252
queens[currentQueen][0] = row;
@@ -62,14 +62,14 @@ function nQ(currentQueen, currentCol) {
6262

6363
if (!found) {
6464
boardTracer.deselect(row, currentCol).delay();
65-
logger.print(`row ${row} & col ${currentCol} didn't work out. Going down`);
65+
logger.println(`row ${row} & col ${currentCol} didn't work out. Going down`);
6666
}
6767
row++;
6868
}
6969

7070
return found;
7171
}
7272

73-
logger.print('Starting execution');
73+
logger.println('Starting execution');
7474
nQ(0, 0);
75-
logger.print('DONE');
75+
logger.println('DONE');

‎Branch and Bound/Binary Search Tree/insertion.js

+2-2
Original file line numberDiff line numberDiff line change
@@ -22,7 +22,7 @@ function bstInsert(root, element, parent) { // root = current node , parent = pr
2222
treeNode[propName] = element;
2323
T[element] = {};
2424
graphTracer.addNode(element).addEdge(root, element).select(element, root).delay().deselect(element, root);
25-
logger.print(`${element} Inserted`);
25+
logger.println(`${element} Inserted`);
2626
} else {
2727
bstInsert(treeNode[propName], element, root);
2828
}
@@ -33,7 +33,7 @@ function bstInsert(root, element, parent) { // root = current node , parent = pr
3333
const Root = elements[0]; // take first element as root
3434
T[Root] = {};
3535
graphTracer.addNode(Root).layoutTree(Root, true);
36-
logger.print(`${Root} Inserted as root of tree `);
36+
logger.println(`${Root} Inserted as root of tree `);
3737

3838
for (let i = 1; i < elements.length; i++) {
3939
elemTracer.select(i).delay();

‎Branch and Bound/Binary Search Tree/search.js

+4-4
Original file line numberDiff line numberDiff line change
@@ -36,21 +36,21 @@ tracer.log(logger).delay();
3636
function bst(item, node, parent) { // node = current node , parent = previous node
3737
tracer.visit(node, parent).delay();
3838
if (item === node) { // key found
39-
logger.print(' Match Found ');
39+
logger.println(' Match Found ');
4040
} else if (item < node) { // key less than value of current node
4141
if (T[node][0] === -1) {
42-
logger.print(' Not Found ');
42+
logger.println(' Not Found ');
4343
} else {
4444
bst(item, T[node][0], node);
4545
}
4646
} else { // key greater than value of current node
4747
if (T[node][1] === -1) {
48-
logger.print(' Not Found ');
48+
logger.println(' Not Found ');
4949
} else {
5050
bst(item, T[node][1], node);
5151
}
5252
}
5353
}
5454

55-
logger.print(`Finding number ${key}`);
55+
logger.println(`Finding number ${key}`);
5656
bst(key, 5); // node with key 5 is the root

‎Branch and Bound/Binary Search/iterative.js

+6-6
Original file line numberDiff line numberDiff line change
@@ -17,29 +17,29 @@ function BinarySearch(array, element) { // array = sorted array, element = eleme
1717

1818
tracer.select(minIndex, maxIndex).delay();
1919
tracer.patch(middleIndex);
20-
logger.print(`Searching at index: ${middleIndex}`).delay();
20+
logger.println(`Searching at index: ${middleIndex}`).delay();
2121
tracer.depatch(middleIndex);
2222
tracer.deselect(minIndex, maxIndex);
2323

2424
if (testElement < element) {
25-
logger.print('Going right.');
25+
logger.println('Going right.');
2626
minIndex = middleIndex + 1;
2727
} else if (testElement > element) {
28-
logger.print('Going left.');
28+
logger.println('Going left.');
2929
maxIndex = middleIndex - 1;
3030
} else {
31-
logger.print(`${element} is found at position ${middleIndex}!`);
31+
logger.println(`${element} is found at position ${middleIndex}!`);
3232
tracer.select(middleIndex);
3333

3434
return middleIndex;
3535
}
3636
}
3737

38-
logger.print(`${element} is not found!`);
38+
logger.println(`${element} is not found!`);
3939
return -1;
4040
}
4141

4242
const element = D[new Randomize.Integer(0, D.length - 1).create()];
4343

44-
logger.print(`Using iterative binary search to find ${element}`);
44+
logger.println(`Using iterative binary search to find ${element}`);
4545
BinarySearch(D, element);

‎Branch and Bound/Binary Search/recursive.js

+7-7
Original file line numberDiff line numberDiff line change
@@ -8,7 +8,7 @@ tracer.set(D).delay();
88

99
function BinarySearch(array, element, minIndex, maxIndex) { // array = sorted array, element = element to be found, minIndex = low index, maxIndex = high index
1010
if (minIndex > maxIndex) {
11-
logger.print(`${element} is not found!`);
11+
logger.println(`${element} is not found!`);
1212
return -1;
1313
}
1414

@@ -17,31 +17,31 @@ function BinarySearch(array, element, minIndex, maxIndex) { // array = sorted ar
1717

1818
tracer.select(minIndex, maxIndex).delay();
1919
tracer.patch(middleIndex);
20-
logger.print(`Searching at index: ${middleIndex}`).delay();
20+
logger.println(`Searching at index: ${middleIndex}`).delay();
2121
tracer.depatch(middleIndex);
2222
tracer.deselect(minIndex, maxIndex);
2323

2424
if (testElement < element) {
25-
logger.print('Going right.');
25+
logger.println('Going right.');
2626
return BinarySearch(array, element, middleIndex + 1, maxIndex);
2727
}
2828

2929
if (testElement > element) {
30-
logger.print('Going left.');
30+
logger.println('Going left.');
3131
return BinarySearch(array, element, minIndex, middleIndex - 1);
3232
}
3333

3434
if (testElement === element) {
35-
logger.print(`${element} is found at position ${middleIndex}!`);
35+
logger.println(`${element} is found at position ${middleIndex}!`);
3636
tracer.select(middleIndex);
3737
return middleIndex;
3838
}
3939

40-
logger.print(`${element} is not found!`);
40+
logger.println(`${element} is not found!`);
4141
return -1;
4242
}
4343

4444
const element = D[new Randomize.Integer(0, D.length - 1).create()];
4545

46-
logger.print(`Using binary search to find ${element}`);
46+
logger.println(`Using binary search to find ${element}`);
4747
BinarySearch(D, element, 0, D.length - 1);

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

+1-1
Original file line numberDiff line numberDiff line change
@@ -33,4 +33,4 @@ function DLSCount(limit, node, parent) { // node = current node, parent = previo
3333
}
3434
return child;
3535
}
36-
logger.print(`Number of descendant is ${DLSCount(2, 0)}`);
36+
logger.println(`Number of descendant is ${DLSCount(2, 0)}`);

‎Branch and Bound/Topological Sort/code.js

+13-13
Original file line numberDiff line numberDiff line change
@@ -19,54 +19,54 @@ const Q = [];
1919
let iter = 0;
2020
let i;
2121

22-
logger.print('Calculating in-degrees for each Node...');
22+
logger.println('Calculating in-degrees for each Node...');
2323
for (let currNode = 0; currNode < G.length; currNode++) {
2424
for (let currNodeNeighbor = 0; currNodeNeighbor < G.length; currNodeNeighbor++) {
2525
if (G[currNode][currNodeNeighbor]) {
26-
logger.print(`${currNodeNeighbor} has an incoming edge from ${currNode}`);
26+
logger.println(`${currNodeNeighbor} has an incoming edge from ${currNode}`);
2727
tracer.visit(currNodeNeighbor, currNode).delay();
2828
inDegrees[currNodeNeighbor]++;
2929
tracer.leave(currNodeNeighbor, currNode).delay();
3030
}
3131
}
3232
}
33-
logger.print(`Done. In-Degrees are: [ ${String(inDegrees)} ]`);
34-
logger.print('');
33+
logger.println(`Done. In-Degrees are: [ ${String(inDegrees)} ]`);
34+
logger.println('');
3535

36-
logger.print('Initializing queue with all the sources (nodes with no incoming edges)');
36+
logger.println('Initializing queue with all the sources (nodes with no incoming edges)');
3737
inDegrees.map((indegrees, node) => {
3838
tracer.visit(node).delay();
3939
if (!indegrees) {
40-
logger.print(`${node} is a source`);
40+
logger.println(`${node} is a source`);
4141
Q.push(node);
4242
}
4343
tracer.leave(node).delay();
4444
});
45-
logger.print(`Done. Initial State of Queue: [ ${String(Q)} ]`);
46-
logger.print('');
45+
logger.println(`Done. Initial State of Queue: [ ${String(Q)} ]`);
46+
logger.println('');
4747

4848
// begin topological sort (kahn)
4949
while (Q.length > 0) {
50-
logger.print(`Iteration #${iter}. Queue state: [ ${String(Q)} ]`);
50+
logger.println(`Iteration #${iter}. Queue state: [ ${String(Q)} ]`);
5151
const currNode = Q.shift();
5252
tracer.visit(currNode).delay();
5353

5454
for (i = 0; i < G.length; i++) {
5555
if (G[currNode][i]) {
56-
logger.print(`${i} has an incoming edge from ${currNode}. Decrementing ${i}'s in-degree by 1.`);
56+
logger.println(`${i} has an incoming edge from ${currNode}. Decrementing ${i}'s in-degree by 1.`);
5757
tracer.visit(i, currNode).delay();
5858
inDegrees[i]--;
5959
tracer.leave(i, currNode).delay();
6060

6161
if (!inDegrees[i]) {
62-
logger.print(`${i}'s in-degree is now 0. Enqueuing ${i}`);
62+
logger.println(`${i}'s in-degree is now 0. Enqueuing ${i}`);
6363
Q.push(i);
6464
}
6565
}
6666
}
6767
tracer.leave(currNode).delay();
68-
logger.print(`In-degrees are: [${String(inDegrees)} ]`);
69-
logger.print('-------------------------------------------------------------------');
68+
logger.println(`In-degrees are: [${String(inDegrees)} ]`);
69+
logger.println('-------------------------------------------------------------------');
7070

7171
iter++;
7272
}

‎Brute Force/Binary Tree Traversal/inOrder.js

+6-6
Original file line numberDiff line numberDiff line change
@@ -36,23 +36,23 @@ let index = 0;
3636

3737
function inOrder(root, parent) {
3838
if (root === -1) {
39-
logger.print('No more nodes. Backtracking.').delay();
39+
logger.println('No more nodes. Backtracking.').delay();
4040
return;
4141
}
4242

43-
logger.print(`Reached ${root}`);
43+
logger.println(`Reached ${root}`);
4444
treeTracer.visit(root, parent).delay();
4545

46-
logger.print(` Going left from ${root}`).delay();
46+
logger.println(` Going left from ${root}`).delay();
4747
inOrder(T[root][0], root);
4848

49-
logger.print(`Printing ${root}`);
49+
logger.println(`Printing ${root}`);
5050
treeTracer.leave(root);
5151
arrayTracer.patch(index++, root).delay();
5252

53-
logger.print(` Going right from ${root}`).delay();
53+
logger.println(` Going right from ${root}`).delay();
5454
inOrder(T[root][1], root);
5555
}
5656

5757
inOrder(5); // node with key 5 is the root
58-
logger.print('Finished');
58+
logger.println('Finished');

‎Brute Force/Binary Tree Traversal/postOrder.js

+6-6
Original file line numberDiff line numberDiff line change
@@ -36,23 +36,23 @@ let index = 0;
3636

3737
function postOrder(root, parent) {
3838
if (root === -1) {
39-
logger.print('No more nodes. Backtracking.').delay();
39+
logger.println('No more nodes. Backtracking.').delay();
4040
return;
4141
}
4242

43-
logger.print(`Reached ${root}`);
43+
logger.println(`Reached ${root}`);
4444
treeTracer.visit(root, parent).delay();
4545

46-
logger.print(` Going left from ${root}`).delay();
46+
logger.println(` Going left from ${root}`).delay();
4747
postOrder(T[root][0], root);
4848

49-
logger.print(` Going right from ${root}`).delay();
49+
logger.println(` Going right from ${root}`).delay();
5050
postOrder(T[root][1], root);
5151

52-
logger.print(`Printing ${root}`);
52+
logger.println(`Printing ${root}`);
5353
treeTracer.leave(root);
5454
arrayTracer.patch(index++, root).delay();
5555
}
5656

5757
postOrder(5); // node with key 5 is the root
58-
logger.print('Finished');
58+
logger.println('Finished');

‎Brute Force/Binary Tree Traversal/preOrder.js

+6-6
Original file line numberDiff line numberDiff line change
@@ -36,23 +36,23 @@ let index = 0;
3636

3737
function preOrder(root, parent) {
3838
if (root === -1) {
39-
logger.print('No more nodes. Backtracking.').delay();
39+
logger.println('No more nodes. Backtracking.').delay();
4040
return;
4141
}
4242

43-
logger.print(`Reached ${root}`);
43+
logger.println(`Reached ${root}`);
4444
treeTracer.visit(root, parent).delay();
4545

46-
logger.print(`Printing ${root}`);
46+
logger.println(`Printing ${root}`);
4747
treeTracer.leave(root);
4848
arrayTracer.patch(index++, root).delay();
4949

50-
logger.print(` Going left from ${root}`).delay();
50+
logger.println(` Going left from ${root}`).delay();
5151
preOrder(T[root][0], root);
5252

53-
logger.print(` Going right from ${root}`).delay();
53+
logger.println(` Going right from ${root}`).delay();
5454
preOrder(T[root][1], root);
5555
}
5656

5757
preOrder(5); // node with key 5 is the root
58-
logger.print('Finished');
58+
logger.println('Finished');

‎Brute Force/Bipartiteness Test/code.js

+2-2
Original file line numberDiff line numberDiff line change
@@ -41,14 +41,14 @@ function BFSCheckBipartiteness(s) {
4141
Q.push(i);
4242
tracer.visit(i, node).delay();
4343
} else if (Colors[i] === Colors[node]) {
44-
logger.print('Graph is not biparted');
44+
logger.println('Graph is not biparted');
4545
return false;
4646
}
4747
}
4848
}
4949
}
5050

51-
logger.print('Graph is biparted');
51+
logger.println('Graph is biparted');
5252
return true;
5353
}
5454

0 commit comments

Comments
 (0)