Como converter um array de inteiros em uma árvore?

Question

Aqui estão 100 números, 10 por linha.

[1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
 1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
 1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
 1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
 1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
 1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
 1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
 1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
 1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
 1, 2, 3, 4, 5, 6, 7, 8, 9, 0]

Eu gostaria de organizar esses números em uma espécie de árvore , onde cada nó tem no máximo 5 elementos. Algo assim:

[                                                                                       ]
 [                   ],[                   ],[                   ],[                   ]
  [ ],[ ],[ ],[ ],[ ]   [ ],[ ],[ ],[ ],[ ]   [ ],[ ],[ ],[ ],[ ]   [ ],[ ],[ ],[ ],[ ]
   1   6   1   6   1     6   1   6   1   6     1   6   1   6   1     6   1   6   1   6
   2   7   2   7   2     7   2   7   2   7     2   7   2   7   2     7   2   7   2   7
   3   8   3   8   3     8   3   8   3   8     3   8   3   8   3     8   3   8   3   8
   4   9   4   9   4     9   4   9   4   9     4   9   4   9   4     9   4   9   4   9
   5   0   5   0   5     0   5   0   5   0     5   0   5   0   5     0   5   0   5   0

Portanto, temos 4 "camadas" na árvore:

1. Na camada 1 (camada superior), temos 4 filhos (4 arrays de arrays de números).
2. Na camada 2, temos 5 filhos (5 matrizes de números).
3. Na camada 3, temos 5 filhos (5 números).
4. A camada 4 são os números.

Como escrever um algoritmo JavaScript para gerar uma árvore como esta? As regras são, no máximo 5 por bloco. Ou mais geralmente, máximo npor bloco.

Isso é um pouco semelhante a um algoritmo de agrupamento de matriz , mas ao mesmo tempo parece mais complicado.

Estou perplexo com isso há alguns dias, mas isso vai ajudar a resolver este problema: Como dividir um array em uma árvore de baldes com potências de dois?

Basicamente, conforme a matriz fica mais longa, o aninhamento fica cada vez maior.

Outro exemplo mais simples é este, array de 13 itens:

[1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
 1, 2, 3]

Que é convertido nesta árvore:

[           ]
 [ ],[ ],[ ]
  1   6   1
  2   7   2
  3   8   3
  4   9   
  5   0   

Answer 1

Você pode usar a abordagem recursiva onde você começa do tamanho do bloco mais interno e, em seguida, divide essa saída em cada nível acima. Portanto, desde que o comprimento do resultado seja maior que o sizeparâmetro, você o divide chamando a função.

const data = [
 1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
 1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
 1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
 1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
 1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
 1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
 1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
 1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
 1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
 1, 2, 3, 4, 5, 6, 7, 8, 9, 0
]

function divide(data, size) {
  const result = []

  for (let i = 0; i < data.length; i += size) {
    const chunk = data.slice(i, i + size);
    result.push(chunk)
  }

  if (result.length > size) {
    return divide(result, size)
  }

  return result;
}

const result = divide(data, 5);
console.log(result)