feature/march leetcode challenge (#1)

* testing code coverage part 3

* fix yml file and git-ignore

Author: Mvrs

.gitignore

@@ -0,0 +1,10 @@
+node_modules
+
+# env tokens for code-cov
+codecov.yml
+
+# dotenv environment variables file
+.env
+
+# Coverage directory used by tools like istanbul
+coverage

.travis.yml

@@ -0,0 +1,9 @@
+language: node_js
+node_js:
+  - node
+env:
+  - CODECOV_TOKEN='565c9b90-78cd-4ead-9a89-aaddae5adbf6'
+after_success:
+  - bash <(curl -s https://codecov.io/bash)
+script:
+  - jest --coverage && codecov

README.md

@@ -1 +1,6 @@
 # leetcode
+
+[![Build Status](https://travis-ci.com/Mvrs/leetcode.svg?token=Ek5Qzx5pczABPWP2y28e&branch=feature/march-leetcode-challenge)](https://travis-ci.com/Mvrs/leetcode)
+[![codecov](https://codecov.io/gh/Mvrs/leetcode/branch/main/graph/badge.svg?token=G1R16KIQTF)](https://codecov.io/gh/Mvrs/leetcode)
+
+My Solutions for [LeetCode problems](https://leetcode.com/problemset/all/)

jest.config.js

@@ -0,0 +1,10 @@
+module.exports = {
+  // An array of glob patterns indicating a set of files for which coverage information should be collected
+  collectCoverageFrom: ['problems/**/*.js'],
+
+  // The directory where Jest should output its coverage files
+  coverageDirectory: 'coverage',
+
+  // The test environment that will be used for testing
+  testEnvironment: 'node',
+}

package.json

@@ -0,0 +1,36 @@
+{
+  "devDependencies": {
+    "@types/jest": "^26.0.20",
+    "codecov": "^3.8.1",
+    "eslint": "^7.22.0",
+    "eslint-config-standard": "^16.0.2",
+    "eslint-plugin-import": "^2.22.1",
+    "eslint-plugin-jest": "^24.2.1",
+    "eslint-plugin-node": "^11.1.0",
+    "eslint-plugin-promise": "^4.3.1",
+    "eslint-plugin-standard": "^5.0.0",
+    "jest": "^26.6.3"
+  },
+  "name": "leetcode",
+  "description": "My solutions for Leetcode problems",
+  "version": "1.0.0",
+  "main": "index.js",
+  "scripts": {
+    "test": "jest",
+    "test:watch": "jest --watchAll",
+    "test:coverage": "jest --coverage"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Mvrs/leetcode.git"
+  },
+  "keywords": [
+    "leetcode"
+  ],
+  "author": "Marlon Johnson",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/Mvrs/leetcode/issues"
+  },
+  "homepage": "https://github.com/Mvrs/leetcode#readme"
+}

problems/missing-number/README.md

@@ -0,0 +1,52 @@
+# Missing Numbers
+
+Leetcode: [#268](https://leetcode.com/problems/missing-number/)
+
+Difficulty: Easy
+
+Topic: `Arrays` `Math` `Bit Manipulation`
+
+## Problem
+
+Given an array `nums` containing `n` distanct numbers in the range `[0, n]`, return the only number in the range that is missing from _the array_
+
+**Follow up:** Could you implement a solution using only `O(1)` extra space complexity and `O(n)` runtime complexity?
+
+Example 1:
+
+```
+Input: nums = [3,0,1]
+Output: 2
+Explanation: n = 3 since there are 3 numbers, so all numbers are in the range [0,3]. 2 is the missing number in the range since it does not appear in nums.
+```
+
+Example 2:
+
+```
+Input: nums = [0,1]
+Output: 2
+Explanation: n = 2 since there are 2 numbers, so all numbers are in the range [0,2]. 2 is the missing number in the range since it does not appear in nums.
+```
+
+Example 3:
+
+```
+Input: nums = [0,1]
+Output: 2
+Explanation: n = 2 since there are 2 numbers, so all numbers are in the range [0,2]. 2 is the missing number in the range since it does not appear in nums.
+```
+
+Example 4:
+
+```
+Input: nums = [0]
+Output: 1
+Explanation: n = 1 since there is 1 number, so all numbers are in the range [0,1]. 1 is the missing number in the range since it does not appear in nums.
+```
+
+Constraints:
+
+- `n == nums.length`
+- `1 <=n <= 10^4`
+- `0 <= nums[i] <= n`
+- All the numbers of `nums` are **unique**

problems/missing-number/solution.js

@@ -0,0 +1,16 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var missingNumber = function (nums) {
+  const N = nums.length
+  let total = 0
+
+  for (let i = 0; i < N; i++) {
+    total += nums[i]
+  }
+
+  return (N * (N + 1)) / 2 - total
+}
+
+module.exports = missingNumber

problems/missing-number/solution.test.js

@@ -0,0 +1,29 @@
+const missingNumber = require('./solution')
+
+test('Example 1', () => {
+  const nums = [3, 0, 1]
+  const result = missingNumber(nums)
+
+  expect(result).toBe(2)
+})
+
+test('Example 2', () => {
+  const nums = [0, 1]
+  const result = missingNumber(nums)
+
+  expect(result).toBe(2)
+})
+
+test('Example 3', () => {
+  const nums = [9, 6, 4, 2, 3, 5, 7, 0, 1]
+  const result = missingNumber(nums)
+
+  expect(result).toBe(8)
+})
+
+test('Example 4', () => {
+  const nums = [0]
+  const result = missingNumber(nums)
+
+  expect(result).toBe(1)
+})

problems/swapping-nodes-in-a-linked-list/solution.js

@@ -0,0 +1,45 @@
+// Definition for singly-linked list.
+function ListNode(val, next) {
+  this.val = val === undefined ? 0 : val
+  this.next = next === undefined ? null : next
+}
+
+// const ListNode = require('../../utils/singly-linked-lists')
+
+/**
+ * @param {ListNode} head
+ * @param {number} k
+ * @return {ListNode}
+ */
+var swapNodes = function (head, k) {
+  // lets grab the length of the list
+  // to determine the distanct from the Kth node (firstNode) to endNode\
+
+  let listLength = 0
+  let currentHead = head
+
+  // find the length of the linkedlist
+  while (currentHead !== null) {
+    listLength++
+    currentHead = currentHead.next
+  }
+
+  let frontNode = head
+  for (let i = 1; i < k; i++) {
+    frontNode = frontNode.next
+  }
+
+  let endNode = head
+  for (let i = 1; i <= listLength - k; i++) {
+    endNode = endNode.next
+  }
+
+  // attemp swap
+  let temp = frontNode.val
+  frontNode.val = endNode.val
+  endNode.val = temp
+
+  return head
+}
+
+module.exports = swapNodes

problems/swapping-nodes-in-a-linked-list/solution.test.js

@@ -0,0 +1,17 @@
+const { deserialize, serialize } = require('../../utils/singly-linked-lists')
+const swapNodes = require('./solution')
+
+function getNode(head, k) {
+  let node = head
+  while (node.val !== k) {
+    node = node.next
+  }
+  return node
+}
+
+test('Example 1', () => {
+  const head = deserialize([1, 2, 3, 4, 5])
+  const k = 2
+  swapNodes(head, k)
+  expect(serialize(head)).toStrictEqual([1, 4, 3, 2, 5])
+})