Split array of strings into more arrays of strings?

You can easily achieve the result as:

const arr = ['george', 'ben', 'bob', 'alex', 'robert'];
const amount_of_characters = 10;

let currentTotal = 0;
const result = [];

for (let i = 0; i < arr.length; i++) {
  const curr = arr[i];
  if (currentTotal + curr.length <= amount_of_characters) {
    currentTotal += curr.length;
    const last = result[result.length - 1];
    !last ? result.push([curr]) : result[result.length - 1].push(curr);
  } else {
    currentTotal = 0;
    result.push([]);
    i--;
  }
}

console.log(result);

function split(arr, amount_of_characters){
  let final_arr = [];
  let i = 0; // This will be used to denote which position on the original array should be filled
  let j = 0; // This will be used to denote which position on the final array should be filled
  while (i < arr.length){
    // Create a new array in the array
    final_arr[j] = [];
    let current_character_count = 0;

    // Iterate over the input array
    while (i < arr.length && arr[i].length + current_character_count < amount_of_characters){
      final_arr[j].push(arr[i]);
      current_character_count += arr[i].length;
      i++;
    }
    j++;
  }
}

You could use a for-of loop and access the last element of the current group using Array.prototype.at():

const groupByUpToNCharacters = (arr, n) => {
    const groups = [[]];
    let currGroupLength = 0;
    for (const word of arr) {
        const wordLength = word.length;
        if (currGroupLength + wordLength <= n) {
            groups.at(-1).push(word);
            currGroupLength += wordLength;
        } else {
            groups.push([word]);
            currGroupLength = wordLength;
        }
    }
    return groups;
}


const arr = ["george", "ben", "bob", "alex", "robert"];
const groupedArr = groupByUpToNCharacters(arr, 10);
console.log(groupedArr);

So, what is required here is an algorithm to achieve the expected result. While multiple answers above have given elegant solutions, the below solutions use a recursive approach.

Solution - Style-1:

const joinUptoLen1 = (arr = [], mlen, i = 0) => (
  i < arr.length - 1 ?
  arr[i].length + arr[i + 1].length < mlen ?
  [
    [arr[i], arr[i + 1]]
  ].concat(joinUptoLen1(arr, mlen, i + 2)) :
  [
    [arr[i]]
  ].concat(joinUptoLen1(arr, mlen, i + 1)) :
  i === arr.length - 1 ?
  [
    [arr[i]]
  ] :
  []
);

The same solution written another way is shown below:

Solution - Style-2:

const joinUptoLen2 = (arr = [], mlen, i = 0) => {
  if (i < arr.length - 1) {
    if (arr[i].length + arr[i + 1].length < mlen) {
      return [
        [arr[i], arr[i + 1]]
      ].concat(joinUptoLen2(arr, mlen, i + 2));
    } else {
      return [
        [arr[i]]
      ].concat(joinUptoLen2(arr, mlen, i + 1));
    }
  } else {
    if (i === arr.length - 1) return [
      [arr[i]]
    ];
    return [];
  }
};

Approach is very simple. Check if sum-of-lengths of 2 consequent array-elements is lesser than the input-length. If so, make an array of the 2 elements and push this new-array into the result-array. If not, push an array with just the one element into the result-array. Recursively follow the same and handle the edge-scenario (if the last element was not included into a pair).

And here's a code snippet for quick-demo:

const inpArr1 = ["george", "ben", "bob", "alex", "robert"];
const inpArr2 = ["george", "ben", "bob", "alex", "robert", "pat"];
const splitLen = 10;

const joinUptoLen1 = (arr = [], mlen, i = 0) => (
  i < arr.length - 1 ?
  arr[i].length + arr[i + 1].length < mlen ? [
    [arr[i], arr[i + 1]]
  ].concat(joinUptoLen1(arr, mlen, i + 2)) : [
    [arr[i]]
  ].concat(joinUptoLen1(arr, mlen, i + 1)) :
  i === arr.length - 1 ? [
    [arr[i]]
  ] : []
);

const joinUptoLen2 = (arr = [], mlen, i = 0) => {
  if (i < arr.length - 1) {
    if (arr[i].length + arr[i + 1].length < mlen) {
      return [
        [arr[i], arr[i + 1]]
      ].concat(joinUptoLen2(arr, mlen, i + 2));
    } else {
      return [
        [arr[i]]
      ].concat(joinUptoLen2(arr, mlen, i + 1));
    }
  } else {
    if (i === arr.length - 1) return [
      [arr[i]]
    ];
    return [];
  }
};

console.log('style-1 results: ', joinUptoLen1(inpArr1, splitLen));
console.log('style-2 results: ', joinUptoLen2(inpArr1, splitLen));

const foo = function (arr, max) { // arr - input, max - max characters in one array
const result = [];
for (let i = 0; i < arr.length; i++) {
    let cur = [];
    if (arr[i].length < max && i !== arr.length - 1) {
        let sum = arr[i].length;
        cur.push(arr[i]);
        while (sum <= max) {
            i++;
            if (arr[i].length + sum <= max) {
                sum += arr[i].length;
                cur.push(arr[i]);
            } else {
                sum = max + 1;
                i--;
            }
        }
    } else cur.push(arr[i]);
    result.push(cur);
}
return result;

};

Another way of writing it using Array.reduce():

const input = ["george","ben","bob","alex","Robert"];

let idx=0;

const output = (amount_of_characters)=>{
    return input.reduce((acc,curr)=>{
        acc[idx]?null: acc.push([]);
        acc[idx].join('').length + curr.length <= amount_of_characters? 
        acc[idx].push(curr):(idx++, acc.push([]), acc[idx].push(curr)); 
        return acc;
    },[])
}

console.log(output(10));