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

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

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

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

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

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

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

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

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

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

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