Skip to content

Commit 351120c

Browse files
64json64json
committed
Break method chains pt.1
1 parent cab2d5a commit 351120c

File tree

72 files changed

+781
-389
lines changed

Some content is hidden

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

72 files changed

+781
-389
lines changed

‎.bin/batchFix.js

+21-21
Original file line numberDiff line numberDiff line change
@@ -14,30 +14,30 @@ listDirectories(rootPath).forEach(category => {
1414
const filePath = path.resolve(algorithmPath, file);
1515
const content = fs.readFileSync(filePath, 'utf8');
1616

17-
const variables = [];
18-
let lineNumber = -1;
19-
let needDelay = false;
20-
const lines = content.split('\n').map((line, i) => {
21-
const match = /^\s*const (\w+) = new \w*Tracer\(/g.exec(line);
17+
/*
18+
TODO:
19+
1. Break method chains (except for directed()/weighted()/layout*()
20+
2. Call static method delay() instead of member method delay()
21+
*/
22+
23+
const lines = content.split('\n');
24+
25+
for (let i = 0; i < lines.length; i++) {
26+
const line = lines[i];
27+
if (line.includes('Randomize')) continue;
28+
const match = /^(\s*)(\w+)(\.\w+\([^(]*\))(\.\w+\([^(]*\))(.+)$/.exec(line);
2229
if (match) {
23-
variables.push(match[1]);
24-
lineNumber = i;
25-
line = line.replace(/\.delay\(\s*\)/g, () => {
26-
needDelay = true;
27-
return '';
28-
});
30+
const [, first, variable, method1, method2, last] = match;
31+
const firstLine = `${first}${variable}${method1};`;
32+
const secondLine = `${first}${variable}${method2}${last}`;
33+
lines.splice(i, 1, firstLine, secondLine);
2934
}
30-
return line.replace(' } = require(\'algorithm-visualizer\')', ', Layout, VerticalLayout } = require(\'algorithm-visualizer\')');
31-
});
32-
33-
if (~lineNumber) {
34-
const line = `Layout.setRoot(new VerticalLayout([${variables.join(', ')}]))${needDelay ? '.delay()' : ''};`;
35-
lines.splice(lineNumber + 1, 0, line);
36-
const newContent = lines.join('\n');
37-
fs.writeFileSync(filePath, newContent, 'utf8');
38-
} else {
39-
console.error('wtf');
4035
}
36+
37+
const newContent = lines.join('\n');
38+
console.log(newContent);
39+
console.log('------------------------------------------------------------');
40+
fs.writeFileSync(filePath, newContent, 'utf8');
4141
});
4242
});
4343
});

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

+14-7
Original file line numberDiff line numberDiff line change
@@ -40,8 +40,10 @@ function knightTour(x, y, moveNum) {
4040
const nextX = x + X[i];
4141
const nextY = y + Y[i];
4242

43-
posTracer.patch(0, nextX).delay();
44-
posTracer.patch(1, nextY).delay();
43+
posTracer.patch(0, nextX);
44+
posTracer.delay();
45+
posTracer.patch(1, nextY);
46+
posTracer.delay();
4547
posTracer.depatch(0);
4648
posTracer.depatch(1);
4749
/*
@@ -52,7 +54,8 @@ function knightTour(x, y, moveNum) {
5254
board[nextX][nextY] = moveNum;
5355

5456
logTracer.println(`Move to ${nextX},${nextY}`);
55-
boardTracer.patch(nextX, nextY, moveNum).delay();
57+
boardTracer.patch(nextX, nextY, moveNum);
58+
boardTracer.delay();
5659
boardTracer.depatch(nextX, nextY);
5760
boardTracer.select(nextX, nextY);
5861

@@ -62,7 +65,8 @@ function knightTour(x, y, moveNum) {
6265
}
6366
logTracer.println(`No place to move from ${nextX},${nextY}: Backtrack`);
6467
board[nextX][nextY] = -1; // backtrack
65-
boardTracer.patch(nextX, nextY, -1).delay();
68+
boardTracer.patch(nextX, nextY, -1);
69+
boardTracer.delay();
6670
boardTracer.depatch(nextX, nextY);
6771
boardTracer.deselect(nextX, nextY);
6872
} else {
@@ -76,9 +80,12 @@ board[0][0] = 0; // start from this position
7680
pos[0] = 0;
7781
pos[0] = 0;
7882

79-
boardTracer.patch(0, 0, 0).delay();
80-
posTracer.patch(0, 0).delay();
81-
posTracer.patch(1, 0).delay();
83+
boardTracer.patch(0, 0, 0);
84+
boardTracer.delay();
85+
posTracer.patch(0, 0);
86+
posTracer.delay();
87+
posTracer.patch(1, 0);
88+
posTracer.delay();
8289
boardTracer.depatch(0, 0);
8390
boardTracer.depatch(0, 0);
8491
posTracer.depatch(0);

‎Backtracking/N-Queens Problem/code.js

+14-7
Original file line numberDiff line numberDiff line change
@@ -23,7 +23,8 @@ Layout.setRoot(new VerticalLayout([boardTracer, queenTracer, logger]));
2323

2424
boardTracer.set(board);
2525
queenTracer.set(queens);
26-
logger.println(`N Queens: ${N}X${N}matrix, ${N} queens`).delay();
26+
logger.println(`N Queens: ${N}X${N}matrix, ${N} queens`);
27+
logger.delay();
2728

2829
function validState(row, col, currentQueen) {
2930
for (let q = 0; q < currentQueen; q++) {
@@ -46,23 +47,29 @@ function nQ(currentQueen, currentCol) {
4647
let found = false;
4748
let row = 0;
4849
while ((row < N) && (!found)) {
49-
boardTracer.select(row, currentCol).delay();
50+
boardTracer.select(row, currentCol);
51+
boardTracer.delay();
5052
logger.println(`Trying queen ${currentQueen} at row ${row} & col ${currentCol}`);
5153

5254
if (validState(row, currentCol, currentQueen)) {
5355
queens[currentQueen][0] = row;
5456
queens[currentQueen][1] = currentCol;
5557

56-
queenTracer.patch(currentQueen, 0, row).delay();
57-
queenTracer.patch(currentQueen, 1, currentCol).delay();
58-
queenTracer.depatch(currentQueen, 0).delay();
59-
queenTracer.depatch(currentQueen, 1).delay();
58+
queenTracer.patch(currentQueen, 0, row);
59+
queenTracer.delay();
60+
queenTracer.patch(currentQueen, 1, currentCol);
61+
queenTracer.delay();
62+
queenTracer.depatch(currentQueen, 0);
63+
queenTracer.delay();
64+
queenTracer.depatch(currentQueen, 1);
65+
queenTracer.delay();
6066

6167
found = nQ(currentQueen + 1, currentCol + 1);
6268
}
6369

6470
if (!found) {
65-
boardTracer.deselect(row, currentCol).delay();
71+
boardTracer.deselect(row, currentCol);
72+
boardTracer.delay();
6673
logger.println(`row ${row} & col ${currentCol} didn't work out. Going down`);
6774
}
6875
row++;

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

+17-7
Original file line numberDiff line numberDiff line change
@@ -7,10 +7,12 @@ const graphTracer = new GraphTracer(' BST - Elements marked red indicates the cu
77
const elemTracer = new Array1DTracer(' Elements ').set(elements);
88
const logger = new LogTracer(' Log ');
99
Layout.setRoot(new VerticalLayout([graphTracer, elemTracer, logger]));
10-
graphTracer.log(logger).delay();
10+
graphTracer.log(logger);
11+
graphTracer.delay();
1112

1213
function bstInsert(root, element, parent) { // root = current node , parent = previous node
13-
graphTracer.visit(root, parent).delay();
14+
graphTracer.visit(root, parent);
15+
graphTracer.delay();
1416
const treeNode = T[root];
1517
let propName = '';
1618
if (element < root) {
@@ -22,22 +24,30 @@ function bstInsert(root, element, parent) { // root = current node , parent = pr
2224
if (!(propName in treeNode)) { // insert as left child of root
2325
treeNode[propName] = element;
2426
T[element] = {};
25-
graphTracer.addNode(element).addEdge(root, element).select(element, root).delay().deselect(element, root);
27+
graphTracer.addNode(element);
28+
graphTracer.addEdge(root, element);
29+
graphTracer.select(element, root);
30+
graphTracer.delay();
31+
graphTracer.deselect(element, root);
2632
logger.println(`${element} Inserted`);
2733
} else {
2834
bstInsert(treeNode[propName], element, root);
2935
}
3036
}
31-
graphTracer.leave(root, parent).delay();
37+
graphTracer.leave(root, parent);
38+
graphTracer.delay();
3239
}
3340

3441
const Root = elements[0]; // take first element as root
3542
T[Root] = {};
36-
graphTracer.addNode(Root).layoutTree(Root, true);
43+
graphTracer.addNode(Root);
44+
graphTracer.layoutTree(Root, true);
3745
logger.println(`${Root} Inserted as root of tree `);
3846

3947
for (let i = 1; i < elements.length; i++) {
40-
elemTracer.select(i).delay();
48+
elemTracer.select(i);
49+
elemTracer.delay();
4150
bstInsert(Root, elements[i]); // insert ith element
42-
elemTracer.deselect(i).delay();
51+
elemTracer.deselect(i);
52+
elemTracer.delay();
4353
}

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

+4-2
Original file line numberDiff line numberDiff line change
@@ -32,10 +32,12 @@ const key = new Randomize.Integer(0, G.length - 1).create(); // item to be searc
3232
const tracer = new GraphTracer(' Binary Search Tree ').set(G).layoutTree(5);
3333
const logger = new LogTracer(' Log ');
3434
Layout.setRoot(new VerticalLayout([tracer, logger]));
35-
tracer.log(logger).delay();
35+
tracer.log(logger);
36+
tracer.delay();
3637

3738
function bst(item, node, parent) { // node = current node , parent = previous node
38-
tracer.visit(node, parent).delay();
39+
tracer.visit(node, parent);
40+
tracer.delay();
3941
if (item === node) { // key found
4042
logger.println(' Match Found ');
4143
} else if (item < node) { // key less than value of current node

‎Branch and Bound/Binary Search/iterative.js

+6-3
Original file line numberDiff line numberDiff line change
@@ -5,7 +5,8 @@ const tracer = new Array1DTracer().chart(chart);
55
const logger = new LogTracer();
66
Layout.setRoot(new VerticalLayout([chart, tracer, logger]));
77
const D = new Randomize.Array1D(15, new Randomize.Integer(0, 50)).sorted().create();
8-
tracer.set(D).delay();
8+
tracer.set(D);
9+
tracer.delay();
910

1011
function BinarySearch(array, element) { // array = sorted array, element = element to be found
1112
let minIndex = 0;
@@ -16,9 +17,11 @@ function BinarySearch(array, element) { // array = sorted array, element = eleme
1617
const middleIndex = Math.floor((minIndex + maxIndex) / 2);
1718
testElement = array[middleIndex];
1819

19-
tracer.select(minIndex, maxIndex).delay();
20+
tracer.select(minIndex, maxIndex);
21+
tracer.delay();
2022
tracer.patch(middleIndex);
21-
logger.println(`Searching at index: ${middleIndex}`).delay();
23+
logger.println(`Searching at index: ${middleIndex}`);
24+
logger.delay();
2225
tracer.depatch(middleIndex);
2326
tracer.deselect(minIndex, maxIndex);
2427

‎Branch and Bound/Binary Search/recursive.js

+6-3
Original file line numberDiff line numberDiff line change
@@ -5,7 +5,8 @@ const tracer = new Array1DTracer().chart(chart);
55
const logger = new LogTracer();
66
Layout.setRoot(new VerticalLayout([chart, tracer, logger]));
77
const D = new Randomize.Array1D(15, new Randomize.Integer(0, 50)).sorted().create();
8-
tracer.set(D).delay();
8+
tracer.set(D);
9+
tracer.delay();
910

1011
function BinarySearch(array, element, minIndex, maxIndex) { // array = sorted array, element = element to be found, minIndex = low index, maxIndex = high index
1112
if (minIndex > maxIndex) {
@@ -16,9 +17,11 @@ function BinarySearch(array, element, minIndex, maxIndex) { // array = sorted ar
1617
const middleIndex = Math.floor((minIndex + maxIndex) / 2);
1718
const testElement = array[middleIndex];
1819

19-
tracer.select(minIndex, maxIndex).delay();
20+
tracer.select(minIndex, maxIndex);
21+
tracer.delay();
2022
tracer.patch(middleIndex);
21-
logger.println(`Searching at index: ${middleIndex}`).delay();
23+
logger.println(`Searching at index: ${middleIndex}`);
24+
logger.delay();
2225
tracer.depatch(middleIndex);
2326
tracer.deselect(minIndex, maxIndex);
2427

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

+5-2
Original file line numberDiff line numberDiff line change
@@ -17,12 +17,15 @@ const G = [ // G[i][j] indicates whether the path from the i-th node to the j-th
1717
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
1818
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
1919
];
20-
tracer.set(G).layoutTree(0).delay();
20+
tracer.set(G);
21+
tracer.layoutTree(0);
22+
tracer.delay();
2123

2224
// This is a sample DLS applications where
2325
// we try to find number of descendant of root within some depth
2426
function DLSCount(limit, node, parent) { // node = current node, parent = previous node
25-
tracer.visit(node, parent).delay();
27+
tracer.visit(node, parent);
28+
tracer.delay();
2629
let child = 0;
2730
if (limit > 0) { // cut off the search
2831
for (let i = 0; i < G[node].length; i++) {

‎Branch and Bound/Topological Sort/code.js

+18-9
Original file line numberDiff line numberDiff line change
@@ -13,7 +13,8 @@ const G = [
1313
[1, 0, 0, 1, 0, 0],
1414
[1, 1, 0, 0, 0, 0],
1515
];
16-
tracer.set(G).delay();
16+
tracer.set(G);
17+
tracer.delay();
1718

1819
const inDegrees = Array(...Array(G.length)).map(Number.prototype.valueOf, 0); // create an Array of G.length number of 0s
1920
const Q = [];
@@ -25,9 +26,11 @@ for (let currNode = 0; currNode < G.length; currNode++) {
2526
for (let currNodeNeighbor = 0; currNodeNeighbor < G.length; currNodeNeighbor++) {
2627
if (G[currNode][currNodeNeighbor]) {
2728
logger.println(`${currNodeNeighbor} has an incoming edge from ${currNode}`);
28-
tracer.visit(currNodeNeighbor, currNode).delay();
29+
tracer.visit(currNodeNeighbor, currNode);
30+
tracer.delay();
2931
inDegrees[currNodeNeighbor]++;
30-
tracer.leave(currNodeNeighbor, currNode).delay();
32+
tracer.leave(currNodeNeighbor, currNode);
33+
tracer.delay();
3134
}
3235
}
3336
}
@@ -36,12 +39,14 @@ logger.println('');
3639

3740
logger.println('Initializing queue with all the sources (nodes with no incoming edges)');
3841
inDegrees.map((indegrees, node) => {
39-
tracer.visit(node).delay();
42+
tracer.visit(node);
43+
tracer.delay();
4044
if (!indegrees) {
4145
logger.println(`${node} is a source`);
4246
Q.push(node);
4347
}
44-
tracer.leave(node).delay();
48+
tracer.leave(node);
49+
tracer.delay();
4550
});
4651
logger.println(`Done. Initial State of Queue: [ ${String(Q)} ]`);
4752
logger.println('');
@@ -50,22 +55,26 @@ logger.println('');
5055
while (Q.length > 0) {
5156
logger.println(`Iteration #${iter}. Queue state: [ ${String(Q)} ]`);
5257
const currNode = Q.shift();
53-
tracer.visit(currNode).delay();
58+
tracer.visit(currNode);
59+
tracer.delay();
5460

5561
for (i = 0; i < G.length; i++) {
5662
if (G[currNode][i]) {
5763
logger.println(`${i} has an incoming edge from ${currNode}. Decrementing ${i}'s in-degree by 1.`);
58-
tracer.visit(i, currNode).delay();
64+
tracer.visit(i, currNode);
65+
tracer.delay();
5966
inDegrees[i]--;
60-
tracer.leave(i, currNode).delay();
67+
tracer.leave(i, currNode);
68+
tracer.delay();
6169

6270
if (!inDegrees[i]) {
6371
logger.println(`${i}'s in-degree is now 0. Enqueuing ${i}`);
6472
Q.push(i);
6573
}
6674
}
6775
}
68-
tracer.leave(currNode).delay();
76+
tracer.leave(currNode);
77+
tracer.delay();
6978
logger.println(`In-degrees are: [${String(inDegrees)} ]`);
7079
logger.println('-------------------------------------------------------------------');
7180

‎Brute Force/Binary Tree Traversal/inOrder.js

+10-5
Original file line numberDiff line numberDiff line change
@@ -37,21 +37,26 @@ let index = 0;
3737

3838
function inOrder(root, parent) {
3939
if (root === -1) {
40-
logger.println('No more nodes. Backtracking.').delay();
40+
logger.println('No more nodes. Backtracking.');
41+
logger.delay();
4142
return;
4243
}
4344

4445
logger.println(`Reached ${root}`);
45-
treeTracer.visit(root, parent).delay();
46+
treeTracer.visit(root, parent);
47+
treeTracer.delay();
4648

47-
logger.println(` Going left from ${root}`).delay();
49+
logger.println(` Going left from ${root}`);
50+
logger.delay();
4851
inOrder(T[root][0], root);
4952

5053
logger.println(`Printing ${root}`);
5154
treeTracer.leave(root);
52-
arrayTracer.patch(index++, root).delay();
55+
arrayTracer.patch(index++, root);
56+
arrayTracer.delay();
5357

54-
logger.println(` Going right from ${root}`).delay();
58+
logger.println(` Going right from ${root}`);
59+
logger.delay();
5560
inOrder(T[root][1], root);
5661
}
5762

0 commit comments

Comments
 (0)