0
votes

convertir un tableau en tableau de sous-tableaux

Je cherche à convertir un tableau en un tableau de sous-tableaux.

Un exemple serait:

const isPrime = num => {
   for (let i = 2; i < num; i++)
      if (num % i === 0) return false;
    return num > 1;
}
        
const howToGroupArray = (array) => {
    if (array.length === 1) {
        return [1, 0] // group of 1 remainder 0
    }
    else if (!isPrime(array.length) || array.length === 2) {
        return [2, 0] // groups of 2 remainder 0
    }
    else {
        return [2, 1] // groups of 2 and a group of 1
    }

}
        
let values = [1,2,3,4,5,6,7]
let newArray = []
let groups = values.forEach((x, i) => {
    if ((i === 0 || i % 2 === 0) && (i !== (values.length - 1))) {
        newArray.push([x, values[i + 1]])
    }
    else if ((i % 2 === 1) && (i !== (values.length - 1))) {
        null
    }
    else {
        howToGroupArray(values)[1] === 0 ? null : newArray.push([x])
    }
})

Maintenant, si la longueur de ce tableau est non divisible par 2

let arr = [1, 2, 3, 4, 5, 6, 7]
arr = [[1, 2], [3, 4], [5, 6], [7]]

Ma solution à ce problème, pas très propre IMO

p >

let arr = [1, 2, 3, 4, 5, 6, 7, 8]
arr = [[1, 2], [3, 4], [5, 6], [7, 8]]

javascript performance refactoring code-readability

1 commentaires

Question mieux adaptée pour codereview.stackexchange.com

3 Réponses :

0
votes

Vous pouvez simplement itérer avec un index et l'incrémenter de deux.

Ensuite, prenez l'index pour le découpage et placez la partie dans le tableau de résultats.

const
    getGrouped = array => {
        let result = [],
            i = 0;
        
        while (i < array.length) result.push(array.slice(i, i += 2));

        return result;
    };

console.log(getGrouped([1, 2, 3, 4, 5, 6, 7, 8]));
console.log(getGrouped([1, 2, 3, 4, 5, 6, 7]));

0 commentaires

1
votes

Ngoc Vuong a écrit un joli article de blog sur les tableaux de segmentation. Il propose quelques solutions dans son article, que j'ai collé ci-dessous.

Boucle à travers le tableau

function chunk(array, size) {
    if (!array) return [];
    const firstChunk = array.slice(0, size); // create the first chunk of the given array
    if (!firstChunk.length) {
        return array; // this is the base case to terminal the recursive
    }
    return [firstChunk].concat(chunk(array.slice(size, array.length), size)); 
}

Parcourir le nombre de blocs

const myArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];
const chunkedArray = chunk(myArray, 2);
console.log(chunkedArray);

function chunk(array, size) {
    const chunkedArray = [];
    let index = 0;
    while (index < array.length) {
        chunkedArray.push(array.slice(index, size + index));
        index += size;
    }
    return chunkedArray;
}

Utilisation de slice ()

const myArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];
const chunkedArray = chunk(myArray, 2);
console.log(chunkedArray);

function chunk(array, size) {
    const chunkedArray = [];
    const copied = [...array];
    const numOfChild = Math.ceil(copied.length / size);
    for (let i = 0; i < numOfChild; i++) {
        chunkedArray.push(copied.splice(0, size));
    }
    return chunkedArray;
}

La méthode récursive

const myArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];
const chunkedArray = chunk(myArray, 2);
console.log(chunkedArray);

function chunk(array, size) {
    const chunkedArray = [];
    for (let i = 0; i < array.length; i++) {
        const last = chunkedArray[chunkedArray.length - 1];
        if (!last || last.length === size) {
            chunkedArray.push([array[i]]);
        } else {
            last.push(array[i]);
        }
    }
    return chunkedArray;
}

1 commentaires

Ma réponse préférée était la version hit slice (). Merci pour la trouvaille!

0
votes

Au lieu de .forEach () , vous pouvez utiliser .reduce () , comme ceci:

        
let values = [1,2,3,4,5,6,7]

let newArray = values.reduce((res, x, i, orig) =>
  i%2 ? res : [...res, [x, ...orig.slice(i+1, i+2)]]
, [])

console.log(newArray);

Il utilise la syntaxe de propagation pour construire un résultat sur chaque index pair. Les index impairs renvoient simplement l'accumulation actuelle.

2 commentaires

solution très cool, bien que difficile à digérer (pour moi du moins). Ne serait-il pas préférable d'utiliser const au lieu de let pour les valeurs et newArray? Nit-pointilleux, je sais.

@huwiler: Oui, const serait mieux. Je viens d'utiliser les déclarations incluses dans l'OP, mais je préférerais définitivement const .