simple-array-functions
v0.0.2
Published
Library for array functions
Downloads
7
Readme
Array Function
A light-weigted array function library.
Installation
npm install simple-array-functions
Why to use
It has zero dependencies.
Doc
const arrayFunction = require("simple-array-functions");
const generateFibSeries = arrayFunction.generateFibSeries;
const reverseSeries = arrayFunction.reverseSeries;
const splitEvenOddNumbers = arrayFunction.splitEvenOddNumbers;
const findSumOfNumberList = arrayFunction.findSumOfNumberList;
const addTwoNumbers = arrayFunction.addTwoNumbers;
const extractAlternateNumbers = arrayFunction.extractAlternateNumbers;
const findMaxOfList = arrayFunction.findMaxOfList;
const findMinValueInList = arrayFunction.findMinValueInList;
const isEven = arrayFunction.isEven;
const isOdd = arrayFunction.isOdd;
const extractEvenNumbers = arrayFunction.extractEvenNumbers;
const extractOddNumbers = arrayFunction.extractOddNumbers;
const mapLength = arrayFunction.mapLength;
const countEvenNumbers = arrayFunction.countEvenNumbers;
const countOddNumbers = arrayFunction.countOddNumbers;
const countNumbersAboveThreshold = arrayFunction.countNumbersAboveThreshold;
const countNumbersBelowThreshold = arrayFunction.countNumbersBelowThreshold;
const findIndex = arrayFunction.findIndex;
const sortInAscending = arrayFunction.sortInAscending;
const sortInDescending = arrayFunction.sortInDescending;
const extractDigit = arrayFunction.extractDigit;
const isAscending = arrayFunction.isAscending;
const isDescending = arrayFunction.isDescending;
const extractUniqe = arrayFunction.extractUniqe;
const listPartition = arrayFunction.listPartition;
const unionArray = arrayFunction.unionArray;
const zipElemets = arrayFunction.zipElemets;
const intersectArray = arrayFunction.intersectArray;
const findDifference = arrayFunction.findDifference;
const isSubset = arrayFunction.isSubset;
const rotateArray = arrayFunction.rotateArray;
/*---------- Test for generateFibSeries ------------*/
//for regular numbers
assert.deepEqual(generateFibSeries(5), [0,1,1,2,3]);
assert.deepEqual(generateFibSeries(0), []);
//for 1 and 2
assert.deepEqual(generateFibSeries(1), [0]);
assert.deepEqual(generateFibSeries(2), [0,1]);
/*---------- Test for reverseSeries ----------------*/
//for empty values and 1 value
assert.deepEqual(reverseSeries([]), []);
assert.deepEqual(reverseSeries([0]), [0]);
//for positive and negitive numbers
assert.deepEqual(reverseSeries([1,2]), [2,1]);
assert.deepEqual(reverseSeries([-1,-5,5,32]), [32,5,-5,-1]);
/*---------- Test for split splitEvenOddNumbers ----------*/
//for empty list and 1 even value
assert.deepEqual(splitEvenOddNumbers([]),[[],[]]);
assert.deepEqual(splitEvenOddNumbers([2]),[[2],[]]);
//for negetive values and all odd
assert.deepEqual(splitEvenOddNumbers([-1,-2,-3,-5]),[[-2],[-1,-3,-5]]);
assert.deepEqual(splitEvenOddNumbers([]),[[],[]]);
/*---------- Test for findSumOfNumberList ----------*/
//for list of one and two elements
assert.equal(findSumOfNumberList([1]),1);
assert.equal(findSumOfNumberList([-1,1]),0);
//for >1000 values
assert.equal(findSumOfNumberList([12,12,12]),36);
assert.equal(findSumOfNumberList([1000,2000]),3000);
/*----------- Test for addTwoNumbers ---------------*/
assert.equal(addTwoNumbers(10,20), 30);
assert.equal(addTwoNumbers(0,0),0);
/*----------- Test for addTwoNumbers ---------------*/
//for empty and 1 element list
assert.deepEqual(extractAlternateNumbers([]),[]);
assert.deepEqual(extractAlternateNumbers([1]),[1]);
assert.deepEqual(extractAlternateNumbers([1,2,3,4]),[1,3]);
assert.deepEqual(extractAlternateNumbers([1,-4,5,1,65]),[1,5,65]);
/*----------- Test for findMaxOfList ---------------*/
assert.equal(findMaxOfList([1,2,3,4,5]), 5);
assert.equal(findMaxOfList([1]), 1);
assert.equal(findMaxOfList([111,1,11,]), 111);
assert.equal(findMaxOfList([5,5,5,5,5]), 5);
/*----------- Test for findMaxOfList ---------------*/
assert.equal(findMaxOfList([1,2,3,4,5]), 5);
assert.equal(findMaxOfList([1]), 1);
assert.equal(findMaxOfList([-111,-1,-11,]), -1);
assert.equal(findMaxOfList([5,5,5,5,5]), 5);
assert.equal(findMaxOfList([-5,5,5,-5,5]), 5);
/*----------- Test for isEven ---------------*/
assert.equal(isEven(0), true);
assert.equal(isEven(2), true);
assert.equal(isEven(1), false);
assert.equal(isEven(-11), false);
assert.equal(isEven(12), true);
/*----------- Test for isOdd ---------------*/
assert.equal(isOdd(0), false);
assert.equal(isOdd(2), false);
assert.equal(isOdd(1), true);
assert.equal(isOdd(-11), true);
assert.equal(isOdd(12), false);
/*----------- Test for extractEvenNumbers ---------------*/
assert.deepEqual(extractEvenNumbers([1]),[]);
assert.deepEqual(extractEvenNumbers([0]),[0]);
assert.deepEqual(extractEvenNumbers([1,2]),[2]);
assert.deepEqual(extractEvenNumbers([1,2,3,4]),[2,4]);
assert.deepEqual(extractEvenNumbers([-1,-2]),[-2]);
assert.deepEqual(extractEvenNumbers([1,-12]),[-12]);
/*----------- Test for extractOddNumbers ---------------*/
assert.deepEqual(extractOddNumbers([1]),[1]);
assert.deepEqual(extractOddNumbers([0]),[]);
assert.deepEqual(extractOddNumbers([1,2]),[1]);
assert.deepEqual(extractOddNumbers([1,2,3,4]),[1,3]);
assert.deepEqual(extractOddNumbers([-1,-2]),[-1]);
assert.deepEqual(extractOddNumbers([1,-12]),[1]);
/*----------- Test for mapLength ---------------*/
assert.deepEqual(mapLength(["a"]),[1]);
assert.deepEqual(mapLength([]),[]);
assert.deepEqual(mapLength(["a","abc"]),[1,3]);
assert.deepEqual(mapLength(["ABC","CDE","GHIJ"]),[3,3,4]);
/*----------- Test for countEvenNumbers ---------------*/
assert.equal(countEvenNumbers([1]),0);
assert.equal(countEvenNumbers([0]),1);
assert.equal(countEvenNumbers([2,,4,6]),3);
assert.equal(countEvenNumbers([1,2,-4]),2);
/*----------- Test for countOddNumbers ---------------*/
assert.equal(countOddNumbers([1]),1)
assert.equal(countOddNumbers([0]),0)
assert.equal(countOddNumbers([2,,4,6]),0)
assert.equal(countOddNumbers([1,2,-4]),1)
/*----------- Test for countNumbersAboveThreshold ---------------*/
assert.equal(countNumbersAboveThreshold([1,2],1),1);
assert.equal(countNumbersAboveThreshold([1],1),0);
assert.equal(countNumbersAboveThreshold([1,2,12,4,6],4),2);
assert.equal(countNumbersAboveThreshold([2,2,3,4,],2),2);
/*----------- Test for countNumbersBelowThreshold ---------------*/
assert.equal(countNumbersBelowThreshold([1,2],1),0);
assert.equal(countNumbersBelowThreshold([1],1),0);
assert.equal(countNumbersBelowThreshold([1,2,12,4,6],4),2);
assert.equal(countNumbersBelowThreshold([2,2,3,4,],2),0);
/*------------ Test for findIndex -------------------*/
assert.equal(findIndex([1],1),0);
assert.equal(findIndex([1,2,4],2),1);
assert.equal(findIndex([1,2,3,4],10),-1);
assert.equal(findIndex([1,2,-1,2,1],-1),2);
/*------------ Test for sortInAscending -------------------*/
assert.deepEqual(sortInAscending([1]),[1]);
assert.deepEqual(sortInAscending([2,1]),[1,2]);
assert.deepEqual(sortInAscending([2,-1,10,1]),[-1,1,2,10]);
assert.deepEqual(sortInAscending([99,9,9,1]),[1,9,9,99]);
/*------------ Test for sortInDescending -------------------*/
assert.deepEqual(sortInDescending([1]),[1]);
assert.deepEqual(sortInDescending([2,1]),[2,1]);
assert.deepEqual(sortInDescending([2,-1,10,1]),[10,2,1,-1]);
assert.deepEqual(sortInDescending([-1,-2,-3,-4]),[-1,-2,-3,-4]);
/*------------- Test for extractDigit ----------------*/
assert.deepEqual(extractDigit(1),[1]);
assert.deepEqual(extractDigit(123),[1,2,3]);
assert.deepEqual(extractDigit(98765),[9,8,7,6,5]);
assert.deepEqual(extractDigit(-123),['-',1,2,3]);
/*------------- Test for isAscending ----------------*/
assert.equal(isAscending([]),true);
assert.equal(isAscending([2,3,55]),true);
assert.equal(isAscending([1,12,1]),false);
assert.equal(isAscending([99,1]),false);
/*------------- Test for isDescending ----------------*/
assert.equal(isDescending([]),true);
assert.equal(isDescending([2,3,55]),false);
assert.equal(isDescending([5,4,3,2,1]),true);
assert.equal(isDescending([99,1]),true);
/*-------------- Test for extractUniqe ---------------*/
assert.deepEqual(extractUniqe([1,1]),[1]);
assert.deepEqual(extractUniqe([1,1,2,2]),[1,2]);
assert.deepEqual(extractUniqe([1,2,1,1]),[1,2]);
assert.deepEqual(extractUniqe([1,12,14,4]),[1,12,14,4]);
/*-------------- Test for listPartition ---------------*/
assert.deepEqual(listPartition([1,2,3],2),[[1,2],[3]])
assert.deepEqual(listPartition([-1,0,1],0),[[-1,0],[1]])
assert.deepEqual(listPartition([11,21,11,11],11),[[11,11,11],[21]])
assert.deepEqual(listPartition([11,12,130],130),[[11,12,130],[]])
/*-------------- Test for unionArray ---------------*/
assert.deepEqual(unionArray([1],[1]),[1]);
assert.deepEqual(unionArray([1,2,3],[2,3,4]),[1,2,3,4]);
assert.deepEqual(unionArray([1,2,3,4,5],[1]),[1,2,3,4,5]);
assert.deepEqual(unionArray([1],[]),[1]);
/*-------------- Test for zipElemets ---------------*/
assert.deepEqual(zipElemets([1],[1]),[[1,1]]);
assert.deepEqual(zipElemets([1,2,3],[4,5,6]),[[1,4],[2,5],[3,6]]);
assert.deepEqual(zipElemets([1,2,3],[4,5,6,11,2]),[[1,4],[2,5],[3,6]]);
assert.deepEqual(zipElemets([1,2,3,1,2,3],[4,5,6]),[[1,4],[2,5],[3,6]]);
/*-------------- Test for intersectArray ---------------*/
assert.deepEqual(intersectArray([1],[1]),[1]);
assert.deepEqual(intersectArray([1,2,3],[1,2]),[1,2]);
assert.deepEqual(intersectArray([1,3,4],[1]),[1]);
assert.deepEqual(intersectArray([],[]),[]);
/*-------------- Test for findDifference ---------------*/
assert.deepEqual(findDifference([1,2],[1]),[2]);
assert.deepEqual(findDifference([1,2,1],[2]),[1,1]);
assert.deepEqual(findDifference([1,2,3],[3]),[1,2]);
assert.deepEqual(findDifference([1,2],[]),[1,2]);
/*-------------- Test for isSubset ---------------*/
assert.deepEqual(isSubset([1,2],[1]),true);
assert.deepEqual(isSubset([1,2],[]),true);
assert.deepEqual(isSubset([1,2,12,1],[1,12]),true);
assert.deepEqual(isSubset([1,2],[1,2,3]),false);
/*-------------- Test for rotateArray ---------------*/
assert.deepEqual(rotateArray([1,2,3],2),[3,1,2]);
assert.deepEqual(rotateArray([1,2,3,4,5],2),[3,4,5,1,2]);
assert.deepEqual(rotateArray([1,2,3,4,5],3),[4,5,1,2,3]);
assert.deepEqual(rotateArray([1,2,3,4,5],4),[5,1,2,3,4]);
/*------------------------------------------------*/