Javascript init

Author: dawsbot

.eslintrc

@@ -0,0 +1,24 @@
+{
+  "rules": {
+    "quotes": [2, 'single'],
+    "semi": 2,
+    "curly": 2,
+    "camelcase": 0,
+    "no-unused-vars": 2,
+    "no-use-before-define": 2,
+    "no-underscore-dangle": 2,
+    "strict": 0,
+    "no-multi-spaces": 2,
+    "semi-spacing": 2,
+    "no-shadow": 2
+  },
+
+  "env": {
+    "browser": true,
+    "node": true,
+    "mocha": true
+  },
+  "globals": {
+    "chrome": false
+  }
+}

README.md

@@ -0,0 +1,22 @@
+####Run the code and test
+This project uses Mocha and Chai for testing:
+
+<br>
+#####Install dependencies:
+```bash
+npm install
+npm install -g mocha
+npm install -g chai
+```
+
+<br>
+#####Run tests:
+```bash
+mocha --recursive
+```
+
+<br>
+#####Add new npm modules:
+```bash
+npm install --save <package name>
+```

lib/data-structures/chapter-1/1_1.js

@@ -0,0 +1,19 @@
+module.exports = Strings_1_1 = (function() {
+  return {
+    /*
+     * Tests to see if string contains all unique chars.
+     * @param {String} str - The string to be checked for uniqueness
+     * @returns {Boolean} true if string has only unique chars. False if a duplicate exists
+     */
+    isUnique: function(str) {
+      var char_set = Array.apply(null, Array(256)).map(Boolean.prototype.valueOf, false);
+      for (var i = 0; i < str.length; i++) {
+        if (char_set[str[i].charCodeAt(0)]) {
+          return false;
+        }
+        char_set[str[i].charCodeAt(0)] = true;
+      }
+      return true;
+   }
+  };
+}());

lib/data-structures/chapter-1/1_2.js

@@ -0,0 +1,31 @@
+module.exports = Strings1_2 = (function() {
+  return {
+    // Tests to see if two strings are permutations of one another
+    // Solution #2 from the book. Assumes ascii character set
+    // @param {String} s - The first string
+    // @param {String} t - The second string
+    // @retuns {Boolean} - true if the strings are permutations of one another, false otherwise
+    isPermutation: function(s, t) {
+
+      var sLength = s.length;
+      var tLength = t.length;
+
+      if (sLength !== tLength) {
+        return false;
+      }
+
+      var s_array = Array.apply(null, Array(256)).map(Number.prototype.valueOf, 0);
+
+      for (var i = 0; i < sLength; i++) {
+        s_array[s[i].charCodeAt(0)]++;
+      }
+
+      for (var i = 0; i < tLength; i++) {
+        if (--s_array[t[i].charCodeAt(0)] < 0){
+          return false;
+        }
+      }
+      return true;
+    }
+  };
+}());

lib/data-structures/chapter-1/1_8.js

@@ -0,0 +1,15 @@
+module.exports = Strings_1_8 = (function() {
+  var _isSubstring = function(str1, str2) {
+    return str1.indexOf(str2) != -1
+  }
+  var _sameLengthAndNotBlank = function(str1, str2) {
+    var len = str1.length;
+    return len === str2.length && len > 0
+  }
+  return {
+    isRotation: function(str1, str2) {
+      if(!_sameLengthAndNotBlank(str1, str2)) return false;
+      if(_isSubstring(str1+str1, str2)) return true;
+    }
+  }
+}());

lib/data-structures/chapter-3/3_5.js

@@ -0,0 +1,29 @@
+module.exports = MyQueue = (function(){
+
+  function MyQueue() {
+    if (!(this instanceof MyQueue)) {
+      return new MyQueue;
+    }
+    this.oldStack = [];
+    this.newStack = [];
+  };
+
+  function shiftStacks() {
+    if(this.oldStack.length == 0) {
+      while(this.newStack.length > 0) {
+        this.oldStack.push(this.newStack.pop());
+      }
+    }
+  };
+
+  MyQueue.prototype.push = function(item) {
+    this.newStack.push(item);
+  };
+
+  MyQueue.prototype.pop = function() {
+    shiftStacks.call(this);
+    return this.oldStack.pop();
+  };
+
+  return MyQueue;
+})();

lib/index.js

@@ -0,0 +1,2 @@
+var requireDirectory = require('require-directory');
+module.exports = requireDirectory(module);

package.json

@@ -0,0 +1,13 @@
+{
+  "name": "CrackingJS",
+  "version": "0.0.1",
+  "description": "Data Structures and Algorithms in Javascript",
+  "dependencies": {
+    "mocha": "*",
+    "chai": "*",
+    "require-directory": "*",
+    "sinon": "*"
+  },
+  "devDependencies": {
+  }
+}

test/data-structures/chapter-1/1_1_Spec.js

@@ -0,0 +1,18 @@
+require('../../test_helper');
+describe('1.1 #hasUniqueChars', function () {
+  var str1, str2;
+  beforeEach(function () {
+    str1 = 'abcdef';
+    str2 = 'qwertyuiopasdfghjkl;\'zxcvbnm,.';
+    str3 = 'abcdefa';
+  });
+  it('returns true if string is all unique chars', function () {
+    expect(Strings_1_1.isUnique(str1)).to.be.true;
+  });
+  it('returns true if string is all unique chars', function () {
+    expect(Strings_1_1.isUnique(str2)).to.be.true;
+  });
+  it('returns false if string contains duplicate chars', function () {
+    expect(Strings_1_1.isUnique(str3)).to.be.false;
+  });
+});

test/data-structures/chapter-1/1_2_Spec.js

@@ -0,0 +1,15 @@
+require('../../test_helper');
+describe('1.2 #isPermutation', function () {
+  var str1, str2;
+  beforeEach(function () {
+    str1 = 'hello';
+    str2 = 'olleh';
+    str3 = 'abcdef';
+  });
+  it('returns true if strings are permutations', function () {
+    expect(Strings1_2.isPermutation(str1, str2)).to.be.true;
+  });
+  it('returns false if strings are not permutations', function () {
+    expect(Strings1_2.isPermutation(str1, str3)).to.be.false;
+  });
+});