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

Lines changed: 5 additions & 5 deletions
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

Lines changed: 8 additions & 8 deletions
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

Lines changed: 2 additions & 2 deletions
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

Lines changed: 4 additions & 4 deletions
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

Lines changed: 6 additions & 6 deletions
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

Lines changed: 7 additions & 7 deletions
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

Lines changed: 1 addition & 1 deletion
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

Lines changed: 13 additions & 13 deletions
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

Lines changed: 6 additions & 6 deletions
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

Lines changed: 6 additions & 6 deletions
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');

0 commit comments

Comments
 (0)
pFad - Phonifier reborn

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.

Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.


Alternative Proxies:

Alternative Proxy

pFad Proxy

pFad v3 Proxy

pFad v4 Proxy