--update: added Array chunk generation problem

Author: ashokdey

src/array-chunk/array-chunk.test.js

@@ -0,0 +1,89 @@
+const {
+  arrayChunk, errFirstArgument, errSecondArguemnt, chunkUsingSlice,
+} = require('.');
+
+describe('Chunk of Arrays', () => {
+  describe('Using normal itteration', () => {
+    it('Should throw an error for invalid `array` argument', () => {
+      expect(() => arrayChunk({ array: 'hello', size: 3 })).toThrow(errFirstArgument);
+    });
+
+    it('Should throw an error for invalid `size` value', () => {
+      expect(() => arrayChunk({ array: [1, 2, 3, 4, 5], size: 'A' })).toThrow(errSecondArguemnt);
+    });
+
+    it('Should return 5 chunks of size 2 of array with 10 elements', () => {
+      expect(
+        arrayChunk({
+          array: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
+          size: 2,
+        }).length,
+      ).toEqual(5);
+    });
+
+    it('Should return the given array as chunk if the chunk size >= given array', () => {
+      const array = [1, 2, 3, 4, 5];
+      expect(
+        arrayChunk({
+          array,
+          size: 8,
+        }),
+      ).toEqual([array]);
+    });
+
+    it('Should return [[1,2], [3,4], [5]] for [1, 2, 3, 4, 5] with chunk size of 2', () => {
+      const array = [1, 2, 3, 4, 5];
+      const output = [[1, 2], [3, 4], [5]];
+
+      expect(
+        arrayChunk({
+          array,
+          size: 2,
+        }),
+      ).toEqual(output);
+    });
+  });
+
+  describe('Using Array.slice()', () => {
+    it('Should throw an error for invalid `array` argument', () => {
+      expect(() => chunkUsingSlice({ array: 'hello', size: 3 })).toThrow(errFirstArgument);
+    });
+
+    it('Should throw an error for invalid `size` value', () => {
+      expect(() => chunkUsingSlice({ array: [1, 2, 3, 4, 5], size: 'A' })).toThrow(
+        errSecondArguemnt,
+      );
+    });
+
+    it('Should return 5 chunks of size 2 of array with 10 elements', () => {
+      expect(
+        chunkUsingSlice({
+          array: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
+          size: 2,
+        }).length,
+      ).toEqual(5);
+    });
+
+    it('Should return the given array as chunk if the chunk size >= given array', () => {
+      const array = [1, 2, 3, 4, 5];
+      expect(
+        chunkUsingSlice({
+          array,
+          size: 8,
+        }),
+      ).toEqual([array]);
+    });
+
+    it('Should return [[1,2], [3,4], [5]] for [1, 2, 3, 4, 5] with chunk size of 2', () => {
+      const array = [1, 2, 3, 4, 5];
+      const output = [[1, 2], [3, 4], [5]];
+
+      expect(
+        chunkUsingSlice({
+          array,
+          size: 2,
+        }),
+      ).toEqual(output);
+    });
+  });
+});

src/array-chunk/index.js

@@ -0,0 +1,56 @@
+const errFirstArgument = 'Invalid Argument: Expected an array as first argument';
+const errSecondArguemnt = 'Invalid Argument: Expected a positive number as second argument';
+
+function validateArguments(array, size) {
+  if (!Array.isArray(array)) {
+    throw new Error(errFirstArgument);
+  }
+
+  if (typeof size !== 'number' || size < 0) {
+    throw new Error(errSecondArguemnt);
+  }
+
+  if (size > array.length) {
+    return [array];
+  }
+  return 0;
+}
+
+function arrayChunk({ array, size }) {
+  validateArguments(array, size);
+
+  const result = [];
+
+  for (let i = 0; i < array.length; i += 1) {
+    const lastChunk = result[result.length - 1];
+
+    if (!lastChunk || lastChunk.length === size) {
+      result.push([array[i]]);
+    } else {
+      lastChunk.push(array[i]);
+    }
+  }
+
+  return result;
+}
+
+function chunkUsingSlice({ array, size }) {
+  validateArguments(array, size);
+
+  let index = 0;
+  const result = [];
+
+  while (index < array.length) {
+    result.push(array.slice(index, index + size));
+    index += size;
+  }
+
+  return result;
+}
+
+module.exports = {
+  errFirstArgument,
+  errSecondArguemnt,
+  arrayChunk,
+  chunkUsingSlice,
+};