@gkucmierz/utils 1.24.0 → 1.25.0

package/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@gkucmierz/utils",
-  "version": "1.24.0",
+  "version": "1.25.0",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@gkucmierz/utils",
-      "version": "1.24.0",
+      "version": "1.25.0",
       "license": "MIT",
       "devDependencies": {
         "husky": "^8.0.1",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gkucmierz/utils",
-  "version": "1.24.0",
+  "version": "1.25.0",
   "description": "Usefull functions for solving programming tasks",
   "main": "main.mjs",
   "scripts": {

package/spec/binary-search.spec.mjs

@@ -1,6 +1,9 @@
 
 import {
   binarySearchArr,
+  binarySearchLE,
+  binarySearchGE,
+  binarySearchRangeIncl,
 } from '../src/binary-search.mjs';
 
 describe('binarySearchArr', () => {
@@ -13,3 +16,76 @@ describe('binarySearchArr', () => {
     expect(binarySearchArr([1, 2, 3, 4], 5)).toBe(-1);
   });
 });
+
+describe('binarySearchLE', () => {
+  it('mid group', () => {
+    const arr = [0,1,2,2,3];
+    expect(binarySearchLE(arr, -100)).toBe(-1);
+    expect(binarySearchLE(arr, 0)).toBe(0);
+    expect(binarySearchLE(arr, 1)).toBe(1);
+    expect(binarySearchLE(arr, 2)).toBe(3);
+    expect(binarySearchLE(arr, 3)).toBe(4);
+    expect(binarySearchLE(arr, 100)).toBe(4);
+  });
+
+  it('begin group', () => {
+    const arr = [2,2,3];
+    expect(binarySearchLE(arr, -100)).toBe(-1);
+    expect(binarySearchLE(arr, 2)).toBe(1);
+    expect(binarySearchLE(arr, 3)).toBe(2);
+    expect(binarySearchLE(arr, 100)).toBe(2);
+  });
+
+  it('end group', () => {
+    const arr = [1,2,2];
+    expect(binarySearchLE(arr, -100)).toBe(-1);
+    expect(binarySearchLE(arr, 1)).toBe(0);
+    expect(binarySearchLE(arr, 2)).toBe(2);
+    expect(binarySearchLE(arr, 100)).toBe(2);
+  });
+});
+
+describe('binarySearchGE', () => {
+  it('mid group', () => {
+    const arr = [0,1,2,2,3];
+    expect(binarySearchGE(arr, -100)).toBe(0);
+    expect(binarySearchGE(arr, 0)).toBe(0);
+    expect(binarySearchGE(arr, 1)).toBe(1);
+    expect(binarySearchGE(arr, 2)).toBe(2);
+    expect(binarySearchGE(arr, 3)).toBe(4);
+    expect(binarySearchGE(arr, 100)).toBe(5);
+  });
+
+  it('begin group', () => {
+    const arr = [2,2,3];
+    expect(binarySearchGE(arr, -100)).toBe(0);
+    expect(binarySearchGE(arr, 2)).toBe(0);
+    expect(binarySearchGE(arr, 3)).toBe(2);
+    expect(binarySearchGE(arr, 100)).toBe(3);
+  });
+
+  it('end group', () => {
+    const arr = [1,2,2];
+    expect(binarySearchGE(arr, -100)).toBe(0);
+    expect(binarySearchGE(arr, 1)).toBe(0);
+    expect(binarySearchGE(arr, 2)).toBe(1);
+    expect(binarySearchGE(arr, 100)).toBe(3);
+  });
+});
+
+describe('binarySearchRangeIncl', () => {
+  it('basic', () => {
+    const arr = [0,1,1,3];
+    const check = [-10, ...arr, 10];
+    const expected = [
+      [0, -1],
+      [0, 0], [1, 2], [1, 2], [3, 3],
+      [4, 3],
+    ];
+
+    for (let i = 0; i < check.length; ++i) {
+      expect(binarySearchRangeIncl(arr, check[i])).toEqual(expected[i]);
+    }
+  });
+});
+

package/src/binary-search.mjs

@@ -1,4 +1,6 @@
 
+// binary search array exact element
+// in sorted array
 export const binarySearchArr = (arr, target) => {
   let [a, b] = [0, arr.length];
   let lm;
@@ -17,3 +19,47 @@ export const binarySearchArr = (arr, target) => {
   }
   return -1;
 };
+
+// binary search array less or equal element
+export const binarySearchLE = (arr, target) => {
+  let [a, b] = [0, arr.length];
+  let lm;
+  while (b - a > 0) {
+    const mid = (a + b) / 2 | 0;
+    const val = arr[mid];
+    if (target < val) {
+      b = mid;
+    } else if (val <= target) {
+      a = mid;
+    }
+    if (lm === mid) return mid;
+    lm = mid;
+  }
+  return -1;
+};
+
+// binary search array greater or equal element
+export const binarySearchGE = (arr, target) => {
+  let [a, b] = [0, arr.length];
+  let lm;
+  while (b - a > 0) {
+    const mid = (a + b) / 2 | 0;
+    const val = arr[mid];
+    if (target > val) {
+      a = mid;
+    } else if (val >= target) {
+      b = mid;
+    }
+    if (lm === mid) return mid + 1;
+    lm = mid;
+  }
+  return 0;
+};
+
+// binary search for range of elements in array inclusive
+export const binarySearchRangeIncl = (arr, target) => {
+  return [
+    binarySearchGE(arr, target),
+    binarySearchLE(arr, target),
+  ];
+};

package/src/copy-case.mjs

@@ -1,5 +1,10 @@
 
-
+/**
+ * Copy the case of a string into another.
+ * @param {string} target String to change the case.
+ * @param {string} source Source of case pattern.
+ * @return {string} Converted string.
+ */
 export const copyCase = (word, from) => {
   const isLower = w => w.toLowerCase() === w;
   const isUpper = w => w.toUpperCase() === w;