Rewrote in React.js

Author: 64json

backtracking/knight's_tour/basic/code.js

@@ -7,34 +7,34 @@ function knightTour(x, y, moveNum) {
 		var nextX = x + X[i];
 		var nextY = y + Y[i];
 
-		posTracer._notify ( 0, nextX)._wait ();
-		posTracer._notify ( 1, nextY)._wait ();
-		posTracer._denotify (0);
-		posTracer._denotify (1);
+		posTracer.notify ( 0, nextX).wait ();
+		posTracer.notify ( 1, nextY).wait ();
+		posTracer.denotify (0);
+		posTracer.denotify (1);
 		/*
 		Check if knight is still in the board
 		Check that knight does not visit an already visited square
 		*/
 		if (nextX>=0 && nextX<N && nextY>=0 && nextY<N && board[nextX][nextY]===-1) {
 			board[nextX][nextY] = moveNum;
 
-			logTracer._print ('Move to ' + nextX + ',' + nextY);
-			boardTracer._notify ( nextX, nextY, moveNum)._wait();
-			boardTracer._denotify( nextX, nextY);
-			boardTracer._select ( nextX, nextY);
+			logTracer.print ('Move to ' + nextX + ',' + nextY);
+			boardTracer.notify ( nextX, nextY, moveNum).wait();
+			boardTracer.denotify( nextX, nextY);
+			boardTracer.select ( nextX, nextY);
 
 			var nextMoveNum = moveNum + 1;
 			if ( knightTour (nextX,nextY, nextMoveNum) === true) {
 				return true;
 			} else {
-				logTracer._print ('No place to move from ' + nextX + ',' +nextY + ': Backtrack');
+				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._deselect( nextX, nextY);
+				boardTracer.notify ( nextX, nextY, -1).wait();
+				boardTracer.denotify( nextX, nextY);
+				boardTracer.deselect( nextX, nextY);
 			}
 		} else {
-			logTracer._print (nextX + ',' + nextY + ' is not a valid move');
+			logTracer.print (nextX + ',' + nextY + ' is not a valid move');
 		}
 	}
 	return false;
@@ -44,16 +44,16 @@ 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.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);
 
 if (knightTour ( 0, 0, 1) === false ) {
-	logTracer._print ('Solution does not exist');
+	logTracer.print ('Solution does not exist');
 } else {
-	logTracer._print ('Solution found');
+	logTracer.print ('Solution found');
 }

backtracking/knight's_tour/basic/data.js

@@ -24,6 +24,6 @@ var Y = [ 1, 2,  2,  1, -1, -2, -2, -1 ];
 var pos = new Array (2);
 pos[0] = pos[1] = -1;
 
-var boardTracer = new Array2DTracer ('Board')._setData (board);
-var posTracer = new Array1DTracer ('Knight Position')._setData (pos);
+var boardTracer = new Array2DTracer ('Board').set (board);
+var posTracer = new Array1DTracer ('Knight Position').set (pos);
 var logTracer = new LogTracer ('Console');

backtracking/n_queens/n_queens/code.js

@@ -9,40 +9,40 @@ function validState (row, col, currentQueen) {
 }
 
 function nQ (currentQueen, currentCol) {
-	logger._print ('Starting new iteration of nQueens () with currentQueen = ' + currentQueen +  ' & currentCol = ' + currentCol);
-	logger._print ('------------------------------------------------------------------');
+	logger.print ('Starting new iteration of nQueens () with currentQueen = ' + currentQueen +  ' & currentCol = ' + currentCol);
+	logger.print ('------------------------------------------------------------------');
 	if (currentQueen >= N) {
-		logger._print ('The recursion has BOTTOMED OUT. All queens have been placed successfully');
+		logger.print ('The recursion has BOTTOMED OUT. All queens have been placed successfully');
 		return true;
 	}
 
 	var found = false, row = 0;
 	while ( (row < N) && (!found) ) {
-		boardTracer._select (row, currentCol)._wait ();
-		logger._print ('Trying queen ' + currentQueen + ' at row ' + row + ' & col ' + currentCol);
+		boardTracer.select (row, currentCol).wait ();
+		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.notify (currentQueen, 0, row).wait ();
+			queenTracer.notify (currentQueen, 1, currentCol).wait ();
+			queenTracer.denotify (currentQueen, 0).wait ();
+			queenTracer.denotify (currentQueen, 1).wait ();
 
 			found = nQ (currentQueen + 1, currentCol + 1);
 		}
 
 		if (!found) {
-			boardTracer._deselect (row, currentCol)._wait ();
-			logger._print ('row ' + row + ' & col ' + currentCol + ' didn\'t work out. Going down');
+			boardTracer.deselect (row, currentCol).wait ();
+			logger.print ('row ' + row + ' & col ' + currentCol + ' didn\'t work out. Going down');
 		}
 		row++;
 	}
 
 	return found;
 }
 
-logger._print ('Starting execution');
+logger.print ('Starting execution');
 nQ (0, 0);
-logger._print ('DONE');
+logger.print ('DONE');

backtracking/n_queens/n_queens/data.js

@@ -18,6 +18,6 @@ var boardTracer = new Array2DTracer ('Board'),
 	queenTracer = new Array2DTracer ('Queen Positions'),
 	logger = new LogTracer ('Progress');
 
-boardTracer._setData (board);
-queenTracer._setData (queens);
-logger._print ('N Queens: ' + N + 'X' + N + 'matrix, ' + N + ' queens');
+boardTracer.set (board);
+queenTracer.set (queens);
+logger.print ('N Queens: ' + N + 'X' + N + 'matrix, ' + N + ' queens');

cryptography/affine_cipher/basic/code.js

@@ -16,24 +16,24 @@ function encrypt(plainText) {
     var index = alpha.charCodeAt(0) - 'a'.charCodeAt(0);
     var result = ((keys.a * index) + keys.b).mod(N);
 
-    logger._print('Index of ' + alpha + ' = ' + index);
+    logger.print('Index of ' + alpha + ' = ' + index);
 
     result += 'a'.charCodeAt(0);
     return String.fromCharCode(result);
   }
 
-  logger._print('Beginning Affine Encryption');
-  logger._print('Encryption formula: <b>((keys.a * index_of_alphabet) + keys.b) % N</b>');
-  logger._print('keys.a=' + keys.a + ', keys.b=' + keys.b + ', N=' + N);
+  logger.print('Beginning Affine Encryption');
+  logger.print('Encryption formula: <b>((keys.a * index_of_alphabet) + keys.b) % N</b>');
+  logger.print('keys.a=' + keys.a + ', keys.b=' + keys.b + ', N=' + N);
 
   for (var i in plainText) {
-    ptTracer._select(i)._wait();
-    ptTracer._deselect(i);
+    ptTracer.select(i).wait();
+    ptTracer.deselect(i);
 
     cypherText += cryptAlpha(plainText [i]);
 
-    ptTracer._notify(i, cypherText.slice(-1))._wait();
-    ptTracer._denotify(i);
+    ptTracer.notify(i, cypherText.slice(-1)).wait();
+    ptTracer.denotify(i);
   }
 
   return cypherText;
@@ -49,35 +49,35 @@ function decrypt(cypherText) {
     }
   })();
 
-  logger._print('a<sup>-1</sup> = ' + aInverse);
+  logger.print('a<sup>-1</sup> = ' + aInverse);
 
   function decryptAlpha(alpha) {
     var index = alpha.charCodeAt(0) - 'a'.charCodeAt(0);
     var result = (aInverse * (index - keys.b)).mod(N);
 
-    logger._print('Index of ' + alpha + ' = ' + index);
+    logger.print('Index of ' + alpha + ' = ' + index);
 
     result += 'a'.charCodeAt(0);
     return String.fromCharCode(result);
   }
 
-  logger._print('Beginning Affine Decryption');
-  logger._print('Decryption formula: <b>(a<sup>-1</sup> * (index - keys.b)) % N</b>');
-  logger._print('keys.b=' + keys.b + ', N=' + N);
+  logger.print('Beginning Affine Decryption');
+  logger.print('Decryption formula: <b>(a<sup>-1</sup> * (index - keys.b)) % N</b>');
+  logger.print('keys.b=' + keys.b + ', N=' + N);
 
   for (var i in cypherText) {
-    ctTracer._select(i)._wait();
-    ctTracer._deselect(i)._wait();
+    ctTracer.select(i).wait();
+    ctTracer.deselect(i).wait();
 
     plainText += decryptAlpha(cypherText [i]);
 
-    ctTracer._notify(i, plainText.slice(-1))._wait();
-    ctTracer._denotify(i)._wait();
+    ctTracer.notify(i, plainText.slice(-1)).wait();
+    ctTracer.denotify(i).wait();
   }
 
   return plainText;
 }
 
 var cipherText = encrypt(plainText);
-ctTracer._setData(cipherText);
+ctTracer.set(cipherText);
 decrypt(cipherText);

cryptography/affine_cipher/basic/data.js

@@ -15,4 +15,4 @@ var ptTracer = new Array1DTracer('Encryption');
 var ctTracer = new Array1DTracer('Decryption');
 var logger = new LogTracer();
 
-ptTracer._setData(plainText);
+ptTracer.set(plainText);

cryptography/caesar_cipher/basic/code.js

@@ -11,7 +11,7 @@ function getNextChar(currChar, direction) {
   var nextPos = direction === 'up' ? getPosUp(pos) : getPosDown(pos);
   var nextChar = alphabet.charAt(nextPos);
 
-  logger._print(currChar + ' -> ' + nextChar);
+  logger.print(currChar + ' -> ' + nextChar);
   return nextChar;
 }
 
@@ -20,43 +20,43 @@ function cipher(str, rotation, direction, cipherTracer) {
 
   for (var i = 0; i < str.length; i++) {
 
-    cipherTracer._wait();
+    cipherTracer.wait();
 
     var currChar = str.charAt(i);
     if (typeof alphabetMap[currChar] === 'number') { // don't encrpt/decrypt characters not in  alphabetMap
       var r = rotation;
 
-      logger._print('Rotating ' + currChar + ' ' + direction + ' ' + rotation + ' times');
-      cipherTracer._select(i)._wait();
+      logger.print('Rotating ' + currChar + ' ' + direction + ' ' + rotation + ' times');
+      cipherTracer.select(i).wait();
 
       // perform given amount of rotations in the given direction
       while (r-- > 0) {
         currChar = getNextChar(currChar, direction);
-        cipherTracer._notify(i, currChar)._wait();
+        cipherTracer.notify(i, currChar).wait();
       }
     } else {
-      logger._print('Ignore this character');
+      logger.print('Ignore this character');
     }
     str = str.substring(0, i) + currChar + str.substring(i + 1);
-    logger._print('Current result: ' + str);
+    logger.print('Current result: ' + str);
   }
 
   return str;
 }
 
 function encrypt(str, rotation) {
-  logger._print('Encrypting: ' + str);
+  logger.print('Encrypting: ' + str);
   return cipher(str, rotation, 'up', encryptTracer);
 }
 
 function decrypt(str, rotation) {
-  logger._print('Decrypting: ' + str);
+  logger.print('Decrypting: ' + str);
   return cipher(str, rotation, 'down', decryptTracer);
 }
 
 var encrypted = encrypt(string, rotation);
-logger._print('Encrypted result: ' + encrypted);
+logger.print('Encrypted result: ' + encrypted);
 
-decryptTracer._setData(encrypted);
+decryptTracer.set(encrypted);
 var decrypted = decrypt(encrypted, rotation);
-logger._print('Decrypted result: ' + decrypted);
+logger.print('Decrypted result: ' + decrypted);

cryptography/caesar_cipher/basic/data.js

@@ -13,4 +13,4 @@ var encryptTracer = new Array1DTracer('Encryption');
 var decryptTracer = new Array1DTracer('Decryption');
 var logger = new LogTracer();
 
-encryptTracer._setData(string);
+encryptTracer.set(string);

dp/catalan_number/catalan_number/code.js

@@ -1,21 +1,21 @@
 A[0] = 1;
-tracer._notify ( 0, A[0] )._wait();
-tracer._denotify ( 0 );
+tracer.notify ( 0, A[0] ).wait();
+tracer.denotify ( 0 );
 A[1] = 1;
-tracer._notify ( 1, A[1] )._wait();
-tracer._denotify ( 1 );
+tracer.notify ( 1, A[1] ).wait();
+tracer.denotify ( 1 );
 
 for (var i = 2; i <= N; i++) {
 	for (var 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._deselect( j );
-		tracer._deselect( i - j - 1 );
-		tracer._denotify( i );
+		tracer.select( j ).wait();
+		tracer.select( i - j -1 ).wait();
+		tracer.notify( i, A[i]).wait();
+		tracer.deselect( j );
+		tracer.deselect( i - j - 1 );
+		tracer.denotify( i );
 	}
 }
 
-logger._print ( ' The ' + N + 'th Catalan Number is ' + A[N] );
-tracer._select( N )._wait();
+logger.print ( ' The ' + N + 'th Catalan Number is ' + A[N] );
+tracer.select( N ).wait();

dp/catalan_number/catalan_number/data.js

@@ -4,5 +4,5 @@ for (var i = N; i >= 0; i--) {
 	A[i] = 0;
 }
 
-var tracer = new Array1DTracer( ' Catalan Numbers ')._setData( A );
+var tracer = new Array1DTracer( ' Catalan Numbers ').set( A );
 var logger = new LogTracer();