[pull] master from TheAlgorithms:master

.husky/pre-commit

@@ -1,5 +1,5 @@
 #!/bin/sh
 . "$(dirname "$0")/_/husky.sh"
 
-npm run style
+npm run check-style
 npm run test

Conversions/DateDayDifference.js

@@ -6,54 +6,28 @@
  Algorithm & Explanation : https://ncalculators.com/time-date/date-difference-calculator.htm
 */
 
-// Internal method for make calculations easier
-const isLeap = (year) =>{
- if (year % 400 === 0) return true
- else if (year % 100 === 0) return false
- else if (year % 4 === 0) return true
- else return false
-}
+import{isLeapYear } from '../Maths/LeapYear'
+import{parseDate } from '../Timing-Functions/ParseDate'
+
 const DateToDay = (dd, mm, yyyy) =>{
- return Math.floor(
+ return (
  365 * (yyyy - 1) +
- (yyyy - 1) / 4 -
- (yyyy - 1) / 100 +
- (yyyy - 1) / 400 +
-dd +
- (367 * mm - 362) / 12 +
-(mm <= 2 ? 0 : isLeap(yyyy) ? -1 : -2)
+Math.floor((yyyy - 1) / 4) -
+Math.floor((yyyy - 1) / 100) +
+Math.floor((yyyy - 1) / 400) +
+ dd +
+Math.floor((367 * mm - 362) / 12) +
+ (mm <= 2 ? 0 : isLeapYear(yyyy) ? -1 : -2)
  )
 }
 
 const DateDayDifference = (date1, date2) =>{
- // firstly, check that both input are string or not.
- if (typeof date1 !== 'string' || typeof date2 !== 'string'){
- return new TypeError('Argument is not a string.')
- }
- // extract the first date
- const [firstDateDay, firstDateMonth, firstDateYear] = date1
- .split('/')
- .map((ele) => Number(ele))
- // extract the second date
- const [secondDateDay, secondDateMonth, secondDateYear] = date2
- .split('/')
- .map((ele) => Number(ele))
- // check the both data are valid or not.
- if (
- firstDateDay < 0 ||
- firstDateDay > 31 ||
- firstDateMonth > 12 ||
- firstDateMonth < 0 ||
- secondDateDay < 0 ||
- secondDateDay > 31 ||
- secondDateMonth > 12 ||
- secondDateMonth < 0
- ){
- return new TypeError('Date is not valid.')
- }
+ const firstDate = parseDate(date1)
+ const secondDate = parseDate(date2)
+
  return Math.abs(
- DateToDay(secondDateDay, secondDateMonth, secondDateYear) -
- DateToDay(firstDateDay, firstDateMonth, firstDateYear)
+ DateToDay(secondDate.day, secondDate.month, secondDate.year) -
+ DateToDay(firstDate.day, firstDate.month, firstDate.year)
  )
 }
 

Conversions/DateToDay.js

@@ -12,6 +12,8 @@
  Algorithm & Explanation : https://en.wikipedia.org/wiki/Zeller%27s_congruence
 */
 
+import{parseDate } from '../Timing-Functions/ParseDate'
+
 // Array holding name of the day: Saturday - Sunday - Friday => 0 - 1 - 6
 const daysNameArr = [
  'Saturday',
@@ -25,15 +27,10 @@ const daysNameArr = [
 
 const DateToDay = (date) =>{
  // firstly, check that input is a string or not.
- if (typeof date !== 'string'){
- return new TypeError('Argument is not a string.')
- }
- // extract the date
- let [day, month, year] = date.split('/').map((x) => Number(x))
- // check the data are valid or not.
- if (day < 1 || day > 31 || month > 12 || month < 1){
- return new TypeError('Date is not valid.')
- }
+ const dateStruct = parseDate(date)
+ let year = dateStruct.year
+ let month = dateStruct.month
+ let day = dateStruct.day
 
  // In case of Jan and Feb:
  // Year: we consider it as previous year

Conversions/RailwayTimeConversion.js

@@ -18,14 +18,14 @@
 const RailwayTimeConversion = (timeString) =>{
  // firstly, check that input is a string or not.
  if (typeof timeString !== 'string'){
-return new TypeError('Argument is not a string.')
+throw new TypeError('Argument is not a string.')
  }
  // split the string by ':' character.
  const [hour, minute, secondWithShift] = timeString.split(':')
  // split second and shift value.
  const [second, shift] = [
- secondWithShift.substr(0, 2),
- secondWithShift.substr(2)
+ secondWithShift.substring(0, 2),
+ secondWithShift.substring(2)
  ]
  // convert shifted time to not-shift time(Railway time) by using the above explanation.
  if (shift === 'PM'){

Conversions/test/DateDayDiffernce.test.js

@@ -1,21 +1,36 @@
 import{DateDayDifference } from '../DateDayDifference'
 
-test('The difference between 17/08/2002 & 10/10/2020 is 6630', () =>{
- const res = DateDayDifference('17/08/2002', '10/10/2020')
- expect(res).toBe(6630)
-})
-
-test('The difference between 18/02/2001 & 16/03/2022 is 7696', () =>{
- const res = DateDayDifference('18/02/2001', '16/03/2022')
- expect(res).toBe(7696)
-})
+describe('DateDayDifference', () =>{
+ it.each([
+ ['17/08/2002', '10/10/2020', 6629],
+ ['18/02/2001', '16/03/2022', 7696],
+ ['11/11/2011', '12/12/2012', 397],
+ ['01/01/2001', '16/03/2011', 3726],
+ ['04/03/2024', '04/03/2024', 0],
+ ['03/03/2024', '04/03/2024', 1],
+ ['02/03/2024', '04/03/2024', 2],
+ ['01/03/2024', '04/03/2024', 3],
+ ['29/02/2024', '04/03/2024', 4],
+ ['04/03/2024', '04/03/2025', 365],
+ ['04/03/2023', '04/03/2024', 366]
+ ])(
+ 'The difference between %s and %s is %i',
+ (firstDate, secondDate, expected) =>{
+ expect(DateDayDifference(firstDate, secondDate)).toBe(expected)
+ expect(DateDayDifference(secondDate, firstDate)).toBe(expected)
+ }
+ )
 
-test('The difference between 11/11/2011 & 12/12/2012 is 398', () =>{
-const res = DateDayDifference('11/11/2011', '12/12/2012')
- expect(res).toBe(398)
-})
+ it('should throw when any input is not a string', () =>{
+ expect(() => DateDayDifference(10102024, '11/10/2024')).toThrowError()
+expect(() => DateDayDifference('11/10/2024', 10102024)).toThrowError()
+})
 
-test('The difference between 01/01/2001 & 16/03/2011 is 3727', () =>{
- const res = DateDayDifference('01/01/2001', '16/03/2011')
- expect(res).toBe(3727)
+ it.each(['32/01/2000', '00/01/2000', '15/00/2000', '15/13/2000'])(
+ 'should throw when input is not a correct date %s',
+ (wrongDate) =>{
+ expect(() => DateDayDifference(wrongDate, '04/03/2024')).toThrowError()
+ expect(() => DateDayDifference('04/03/2024', wrongDate)).toThrowError()
+ }
+ )
 })

Conversions/test/DateToDay.test.js

@@ -1,35 +1,28 @@
 import{DateToDay } from '../DateToDay'
 
-test('The date 18/02/2001 is Sunday', () =>{
- const res = DateToDay('18/02/2001')
- expect(res).toBe('Sunday')
-})
-
-test('The date 18/12/2020 is Friday', () =>{
- const res = DateToDay('18/12/2020')
- expect(res).toBe('Friday')
-})
+describe('DateToDay', () =>{
+ it.each([
+ ['18/02/2001', 'Sunday'],
+ ['18/12/2020', 'Friday'],
+ ['12/12/2012', 'Wednesday'],
+ ['01/01/2001', 'Monday'],
+ ['1/1/2020', 'Wednesday'],
+ ['2/3/2014', 'Sunday'],
+ ['28/2/2017', 'Tuesday'],
+ ['02/03/2024', 'Saturday'],
+ ['29/02/2024', 'Thursday']
+ ])('%s is %s', (date, day) =>{
+ expect(DateToDay(date)).toBe(day)
+ })
 
-test('The date 12/12/2012 is Wednesday', () =>{
- const res = DateToDay('12/12/2012')
- expect(res).toBe('Wednesday')
-})
-test('The date 01/01/2001 is Monday', () =>{
- const res = DateToDay('01/01/2001')
- expect(res).toBe('Monday')
-})
-
-test('The date 1/1/2020 is Wednesday', () =>{
- const res = DateToDay('1/1/2020')
- expect(res).toBe('Wednesday')
-})
-
-test('The date 2/3/2014 is Sunday', () =>{
- const res = DateToDay('2/3/2014')
- expect(res).toBe('Sunday')
-})
+ it('should throw when input is not a string', () =>{
+ expect(() => DateToDay(100)).toThrowError()
+ })
 
-test('The date 28/2/2017 is Tuesday', () =>{
- const res = DateToDay('28/2/2017')
- expect(res).toBe('Tuesday')
+ it.each(['32/01/2000', '00/01/2000', '15/00/2000', '15/13/2000'])(
+ 'should throw when input is not a correct date %s',
+ (wrongDate) =>{
+ expect(() => DateToDay(wrongDate)).toThrowError()
+ }
+ )
 })

Conversions/test/RailwayTimeConversion.test.js

@@ -19,3 +19,7 @@ test('The RailwayTimeConversion of 11:20:00PM is 23:20:00', () =>{
  const res = RailwayTimeConversion('11:20:00PM')
  expect(res).toEqual('23:20:00')
 })
+
+test('The RailwayTimeConversion throws when input is not a string', () =>{
+ expect(() => RailwayTimeConversion(1120)).toThrowError()
+})

DIRECTORY.md

@@ -260,7 +260,6 @@
  * [SquareRootLogarithmic](Maths/SquareRootLogarithmic.js)
  * [SumOfDigits](Maths/SumOfDigits.js)
  * [SumOfGeometricProgression](Maths/SumOfGeometricProgression.js)
- * [TwinPrime](Maths/TwinPrime.js)
  * [TwoSum](Maths/TwoSum.js)
  * [Volume](Maths/Volume.js)
  * [WhileLoopFactorial](Maths/WhileLoopFactorial.js)
@@ -296,7 +295,6 @@
 * **Recursive**
  * [BinaryEquivalent](Recursive/BinaryEquivalent.js)
  * [BinarySearch](Recursive/BinarySearch.js)
- * [EucledianGCD](Recursive/EucledianGCD.js)
  * [Factorial](Recursive/Factorial.js)
  * [FibonacciNumberRecursive](Recursive/FibonacciNumberRecursive.js)
  * [FloodFill](Recursive/FloodFill.js)

Data-Structures/Array/Reverse.js

@@ -7,11 +7,9 @@
 
 const Reverse = (arr) =>{
  // limit specifies the amount of Reverse actions
- for (let i = 0, j = arr.length - 1; i < arr.length / 2; i++, j--){
- const temp = arr[i]
- arr[i] = arr[j]
- arr[j] = temp
- }
+ for (let i = 0, j = arr.length - 1; i < arr.length / 2; i++, j--)
+ [arr[i], arr[j]] = [arr[j], arr[i]]
+
  return arr
 }
 export{Reverse }

Data-Structures/Queue/CircularQueue.js

@@ -77,7 +77,7 @@ class CircularQueue{
 
  // Displays the length of queue
  length(){
- return this.queue.length - 1
+ return this.checkEmpty() ? 0 : this.queue.length - 1
  }
 
  // Display the top most value of queue

Data-Structures/Stack/Stack.js

@@ -8,22 +8,22 @@
 // Functions: push, pop, peek, view, length
 
 // Creates a stack constructor
-const Stack = (function (){
-function Stack(){
+class Stack{
+constructor(){
  // The top of the Stack
  this.top = 0
  // The array representation of the stack
  this.stack = []
  }
 
  // Adds a value onto the end of the stack
-Stack.prototype.push = function (value){
+ push(value){
  this.stack[this.top] = value
  this.top++
  }
 
  // Removes and returns the value at the end of the stack
-Stack.prototype.pop = function (){
+ pop(){
  if (this.top === 0){
  return 'Stack is Empty'
  }
@@ -35,23 +35,21 @@ const Stack = (function (){
  }
 
  // Returns the size of the stack
-Stack.prototype.size = function (){
+ size(){
  return this.top
  }
 
  // Returns the value at the end of the stack
-Stack.prototype.peek = function (){
+ peek(){
  return this.stack[this.top - 1]
  }
 
  // To see all the elements in the stack
-Stack.prototype.view = function (output = (value) => console.log(value)){
+ view(output = (value) => console.log(value)){
  for (let i = 0; i < this.top; i++){
  output(this.stack[i])
  }
  }
-
- return Stack
-})()
+}
 
 export{Stack }