Rename method wait to delay, notify to patch, and denotify to depatch

Author: 64json

Backtracking/Knight's tour problem/code.js

@@ -28,7 +28,7 @@ pos[0] = pos[1] = -1;
 
 const boardTracer = new Array2DTracer('Board').set(board);
 const posTracer = new Array1DTracer('Knight Position').set(pos);
-const logTracer = new LogTracer('Console').wait();
+const logTracer = new LogTracer('Console').delay();
 
 function knightTour(x, y, moveNum) {
   if (moveNum === N * N) {
@@ -39,10 +39,10 @@ function knightTour(x, y, moveNum) {
     const nextX = x + X[i];
     const nextY = y + Y[i];
 
-    posTracer.notify(0, nextX).wait();
-    posTracer.notify(1, nextY).wait();
-    posTracer.denotify(0);
-    posTracer.denotify(1);
+    posTracer.patch(0, nextX).delay();
+    posTracer.patch(1, nextY).delay();
+    posTracer.depatch(0);
+    posTracer.depatch(1);
     /*
     Check if knight is still in the board
     Check that knight does not visit an already visited square
@@ -51,8 +51,8 @@ function knightTour(x, y, moveNum) {
       board[nextX][nextY] = moveNum;
 
       logTracer.print(`Move to ${nextX},${nextY}`);
-      boardTracer.notify(nextX, nextY, moveNum).wait();
-      boardTracer.denotify(nextX, nextY);
+      boardTracer.patch(nextX, nextY, moveNum).delay();
+      boardTracer.depatch(nextX, nextY);
       boardTracer.select(nextX, nextY);
 
       const nextMoveNum = moveNum + 1;
@@ -61,8 +61,8 @@ function knightTour(x, y, moveNum) {
       }
       logTracer.print(`No place to move from ${nextX},${nextY}: Backtrack`);
       board[nextX][nextY] = -1; // backtrack
-      boardTracer.notify(nextX, nextY, -1).wait();
-      boardTracer.denotify(nextX, nextY);
+      boardTracer.patch(nextX, nextY, -1).delay();
+      boardTracer.depatch(nextX, nextY);
       boardTracer.deselect(nextX, nextY);
     } else {
       logTracer.print(`${nextX},${nextY} is not a valid move`);
@@ -75,13 +75,13 @@ board[0][0] = 0; // start from this position
 pos[0] = 0;
 pos[0] = 0;
 
-boardTracer.notify(0, 0, 0).wait();
-posTracer.notify(0, 0).wait();
-posTracer.notify(1, 0).wait();
-boardTracer.denotify(0, 0);
-boardTracer.denotify(0, 0);
-posTracer.denotify(0);
-posTracer.denotify(1);
+boardTracer.patch(0, 0, 0).delay();
+posTracer.patch(0, 0).delay();
+posTracer.patch(1, 0).delay();
+boardTracer.depatch(0, 0);
+boardTracer.depatch(0, 0);
+posTracer.depatch(0);
+posTracer.depatch(1);
 
 if (knightTour(0, 0, 1) === false) {
   logTracer.print('Solution does not exist');

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`).wait();
+logger.print(`N Queens: ${N}X${N}matrix, ${N} queens`).delay();
 
 function validState(row, col, currentQueen) {
   for (let q = 0; q < currentQueen; q++) {
@@ -45,23 +45,23 @@ function nQ(currentQueen, currentCol) {
   let found = false;
   let row = 0;
   while ((row < N) && (!found)) {
-    boardTracer.select(row, currentCol).wait();
+    boardTracer.select(row, currentCol).delay();
     logger.print(`Trying queen ${currentQueen} at row ${row} & col ${currentCol}`);
 
     if (validState(row, currentCol, currentQueen)) {
       queens[currentQueen][0] = row;
       queens[currentQueen][1] = currentCol;
 
-      queenTracer.notify(currentQueen, 0, row).wait();
-      queenTracer.notify(currentQueen, 1, currentCol).wait();
-      queenTracer.denotify(currentQueen, 0).wait();
-      queenTracer.denotify(currentQueen, 1).wait();
+      queenTracer.patch(currentQueen, 0, row).delay();
+      queenTracer.patch(currentQueen, 1, currentCol).delay();
+      queenTracer.depatch(currentQueen, 0).delay();
+      queenTracer.depatch(currentQueen, 1).delay();
 
       found = nQ(currentQueen + 1, currentCol + 1);
     }
 
     if (!found) {
-      boardTracer.deselect(row, currentCol).wait();
+      boardTracer.deselect(row, currentCol).delay();
       logger.print(`row ${row} & col ${currentCol} didn't work out. Going down`);
     }
     row++;

Cryptography/Affine Cipher/code.js

@@ -5,7 +5,7 @@ const ptTracer = new Array1DTracer('Encryption');
 const ctTracer = new Array1DTracer('Decryption');
 const logger = new LogTracer();
 
-ptTracer.set(plainText).wait();
+ptTracer.set(plainText).delay();
 
 /*
  code assumes that plainText contains ONLY LOWER CASE ALPHABETS
@@ -36,13 +36,13 @@ function encrypt(plainText) {
   logger.print(`keys.a=${keys.a}, keys.b=${keys.b}, N=${N}`);
 
   for (const i in plainText) {
-    ptTracer.select(i).wait();
+    ptTracer.select(i).delay();
     ptTracer.deselect(i);
 
     cypherText += cryptAlpha(plainText[i]);
 
-    ptTracer.notify(i, cypherText.slice(-1)).wait();
-    ptTracer.denotify(i);
+    ptTracer.patch(i, cypherText.slice(-1)).delay();
+    ptTracer.depatch(i);
   }
 
   return cypherText;
@@ -75,13 +75,13 @@ function decrypt(cypherText) {
   logger.print(`keys.b=${keys.b}, N=${N}`);
 
   for (const i in cypherText) {
-    ctTracer.select(i).wait();
-    ctTracer.deselect(i).wait();
+    ctTracer.select(i).delay();
+    ctTracer.deselect(i).delay();
 
     plainText += decryptAlpha(cypherText[i]);
 
-    ctTracer.notify(i, plainText.slice(-1)).wait();
-    ctTracer.denotify(i).wait();
+    ctTracer.patch(i, plainText.slice(-1)).delay();
+    ctTracer.depatch(i).delay();
   }
 
   return plainText;

Cryptography/Caesar Cipher/code.js

@@ -15,7 +15,7 @@ const encryptTracer = new Array1DTracer('Encryption');
 const decryptTracer = new Array1DTracer('Decryption');
 const logger = new LogTracer();
 
-encryptTracer.set(string).wait();
+encryptTracer.set(string).delay();
 
 function getPosUp(pos) {
   return (pos === alphabet.length - 1) ? 0 : pos + 1;
@@ -38,19 +38,19 @@ function cipher(str, rotation, direction, cipherTracer) {
   if (!str) return '';
 
   for (let i = 0; i < str.length; i++) {
-    cipherTracer.wait();
+    cipherTracer.delay();
 
     let currChar = str.charAt(i);
     if (typeof alphabetMap[currChar] === 'number') { // don't encrpt/decrypt characters not in  alphabetMap
       let r = rotation;
 
       logger.print(`Rotating ${currChar} ${direction} ${rotation} times`);
-      cipherTracer.select(i).wait();
+      cipherTracer.select(i).delay();
 
       // perform given amount of rotations in the given direction
       while (r-- > 0) {
         currChar = getNextChar(currChar, direction);
-        cipherTracer.notify(i, currChar).wait();
+        cipherTracer.patch(i, currChar).delay();
       }
     } else {
       logger.print('Ignore this character');

Dynamic Programming/Catalan Number/code.js

@@ -7,26 +7,26 @@ for (let i = N; i >= 0; i--) {
 }
 
 const tracer = new Array1DTracer(' Catalan Numbers ').set(A);
-const logger = new LogTracer().wait();
+const logger = new LogTracer().delay();
 
 A[0] = 1;
-tracer.notify(0, A[0]).wait();
-tracer.denotify(0);
+tracer.patch(0, A[0]).delay();
+tracer.depatch(0);
 A[1] = 1;
-tracer.notify(1, A[1]).wait();
-tracer.denotify(1);
+tracer.patch(1, A[1]).delay();
+tracer.depatch(1);
 
 for (let i = 2; i <= N; i++) {
   for (let j = 0; j < i; j++) {
     A[i] += A[j] * A[i - j - 1];
-    tracer.select(j).wait();
-    tracer.select(i - j - 1).wait();
-    tracer.notify(i, A[i]).wait();
+    tracer.select(j).delay();
+    tracer.select(i - j - 1).delay();
+    tracer.patch(i, A[i]).delay();
     tracer.deselect(j);
     tracer.deselect(i - j - 1);
-    tracer.denotify(i);
+    tracer.depatch(i);
   }
 }
 
 logger.print(` The ${N}th Catalan Number is ${A[N]}`);
-tracer.select(N).wait();
+tracer.select(N).delay();

Dynamic Programming/Fibonacci Sequence/code.js

@@ -6,12 +6,12 @@ const D = [1, 1];
 for (let i = 2; i < index; i++) {
   D.push(0);
 }
-tracer.set(D).wait();
+tracer.set(D).delay();
 
 for (let i = 2; i < index; i++) {
   D[i] = D[i - 2] + D[i - 1];
-  tracer.select(i - 2, i - 1).wait();
-  tracer.notify(i, D[i]).wait();
-  tracer.denotify(i);
+  tracer.select(i - 2, i - 1).delay();
+  tracer.patch(i, D[i]).delay();
+  tracer.depatch(i);
   tracer.deselect(i - 2, i - 1);
 }

Dynamic Programming/Integer Partition/code.js

@@ -11,7 +11,7 @@ for (let i = 0; i <= integer; i++) {
   D[i][1] = 1;
   for (let j = 0; j <= integer; j++) D[i][j] = 0;
 }
-tracer.set(D).wait();
+tracer.set(D).delay();
 
 function partition(A, n, p) {
   if (n === 0) logger.print(`[${A.join(', ')}]`);
@@ -31,10 +31,10 @@ function integerPartition(n) {
     // We are allowed to use numbers from 2 to i
     for (let j = 1; j <= i; j++) {
       // Number of partitions without j number + number of partitions with max j
-      tracer.select(i, j).wait();
+      tracer.select(i, j).delay();
       D[i][j] = D[i][j - 1] + D[i - j][Math.max(j, i - j)];
-      tracer.notify(i, j, D[i][j]).wait();
-      tracer.denotify(i, j);
+      tracer.patch(i, j, D[i][j]).delay();
+      tracer.depatch(i, j);
       tracer.deselect(i, j);
     }
   }

Dynamic Programming/Knapsack Problem/code.js

@@ -16,7 +16,7 @@ for (let i = 0; i < N + 1; i++) {
 const tracer = new Array2DTracer('Knapsack Table').set(DP);
 const dataViewer1 = new Array1DTracer('Values').set(val);
 const dataViewer2 = new Array1DTracer('Weights').set(wt);
-const logger = new LogTracer().wait();
+const logger = new LogTracer().delay();
 
 for (let i = 0; i <= N; i++) {
   for (let j = 0; j <= W; j++) {
@@ -26,12 +26,12 @@ for (let i = 0; i <= N; i++) {
       then the total weight in our collection is 0
       */
       DP[i][0] = 0;
-      tracer.notify(i, j, DP[i][j]).wait();
-      tracer.denotify(i, j);
+      tracer.patch(i, j, DP[i][j]).delay();
+      tracer.depatch(i, j);
     } else if (wt[i - 1] <= j) { // take the current item in our collection
-      dataViewer1.select(i - 1).wait();
-      dataViewer2.select(i - 1).wait();
-      tracer.select(i - 1, j).wait();
+      dataViewer1.select(i - 1).delay();
+      dataViewer2.select(i - 1).delay();
+      tracer.select(i - 1, j).delay();
 
       const A = val[i - 1] + DP[i - 1][j - wt[i - 1]];
       const B = DP[i - 1][j];
@@ -41,20 +41,20 @@ for (let i = 0; i <= N; i++) {
        */
       if (A > B) {
         DP[i][j] = A;
-        tracer.notify(i, j, DP[i][j]).wait();
+        tracer.patch(i, j, DP[i][j]).delay();
       } else {
         DP[i][j] = B;
-        tracer.notify(i, j, DP[i][j]).wait();
+        tracer.patch(i, j, DP[i][j]).delay();
       }
 
       tracer.deselect(i - 1, j);
-      tracer.denotify(i, j);
+      tracer.depatch(i, j);
       dataViewer2.deselect(i - 1);
       dataViewer1.deselect(i - 1);
     } else { // leave the current item from our collection
       DP[i][j] = DP[i - 1][j];
-      tracer.notify(i, j, DP[i][j]).wait();
-      tracer.denotify(i, j);
+      tracer.patch(i, j, DP[i][j]).delay();
+      tracer.depatch(i, j);
     }
   }
 }

Dynamic Programming/Longest Common Subsequence/code.js

@@ -12,7 +12,7 @@ for (let i = 0; i < m + 1; i++) {
 const tracer1 = new Array1DTracer('String 1').set(string1);
 const tracer2 = new Array1DTracer('String 2').set(string2);
 const tracer3 = new Array2DTracer('Memo Table').set(A);
-const logger = new LogTracer().wait();
+const logger = new LogTracer().delay();
 
 let i;
 let j;
@@ -23,18 +23,18 @@ for (i = 0; i <= m; i++) {
     if (i === 0 || j === 0) {
       A[i][j] = 0;
     } else if (string1[i - 1] === string2[j - 1]) {
-      tracer1.select(i - 1).wait();
-      tracer2.select(j - 1).wait();
-      tracer3.select(i - 1, j - 1).wait();
+      tracer1.select(i - 1).delay();
+      tracer2.select(j - 1).delay();
+      tracer3.select(i - 1, j - 1).delay();
 
       A[i][j] = A[i - 1][j - 1] + 1;
 
       tracer1.deselect(i - 1);
       tracer2.deselect(j - 1);
       tracer3.deselect(i - 1, j - 1);
     } else {
-      tracer3.select(i - 1, j).wait();
-      tracer3.select(i, j - 1).wait();
+      tracer3.select(i - 1, j).delay();
+      tracer3.select(i, j - 1).delay();
 
       if (A[i - 1][j] > A[i][j - 1]) {
         A[i][j] = A[i - 1][j];
@@ -45,19 +45,19 @@ for (i = 0; i <= m; i++) {
       tracer3.deselect(i - 1, j);
       tracer3.deselect(i, j - 1);
     }
-    tracer3.notify(i, j, A[i][j]).wait();
-    tracer3.denotify(i, j);
+    tracer3.patch(i, j, A[i][j]).delay();
+    tracer3.depatch(i, j);
   }
 }
 
 let finalString = '';
 i = m;
 j = n;
 while (i >= 1 && j >= 1) {
-  tracer3.select(i, j).wait();
+  tracer3.select(i, j).delay();
   if (string1[i - 1] === string2[j - 1]) {
-    tracer1.select(i - 1).wait();
-    tracer2.select(j - 1).wait();
+    tracer1.select(i - 1).delay();
+    tracer2.select(j - 1).delay();
 
     finalString = string1[i - 1] + finalString;
     i--;

Dynamic Programming/Longest Increasing Subsequence/code.js

@@ -4,7 +4,7 @@ const tracer = new Array1DTracer();
 const logger = new LogTracer();
 const A = Randomize.array1D(10, { min: 0, max: 10 });
 const LIS = new Array(A.length);
-tracer.set(A).wait();
+tracer.set(A).delay();
 
 // Initialize LIS values for all indexes
 for (let i = 0; i < A.length; i++) {
@@ -17,8 +17,8 @@ for (let i = 1; i < A.length; i++) {
   tracer.select(i);
   logger.print(` LIS[${i}] = ${LIS[i]}`);
   for (let j = 0; j < i; j++) {
-    tracer.notify(j).wait();
-    tracer.denotify(j);
+    tracer.patch(j).delay();
+    tracer.depatch(j);
     if (A[i] > A[j] && LIS[i] < LIS[j] + 1) {
       LIS[i] = LIS[j] + 1;
       logger.print(` LIS[${i}] = ${LIS[i]}`);