Tous les défis
Facile 0 résolus 0 % de réussite

Découper une liste en blocs

Découper une liste en groupes consécutifs d'une taille fixe, avec un dernier groupe plus court si nécessaire.

Ce que vous allez apprendre

  • Parcourir une liste par sauts de taille fixe
  • Prendre des tranches dont la dernière peut être plus courte
  • Grouper des données pour la pagination ou les lots

Problème

Découper des données en morceaux de taille fixe est une façon pour les programmes d'afficher des résultats par pages, d'écrire des données en lots dans une base ou d'envoyer des données par paquets.

Étant donnée une liste et une taille de morceau, découpez la liste en morceaux consécutifs de exactement size valeurs, dans l'ordre. Le dernier morceau contient ce qu'il reste et peut être plus court.

Implémentez split_into_chunks(values, size).

Entrée

values: La liste à découper.

size: La taille du morceau.

Sortie

Retournez la liste des morceaux. Une liste vide ne donne aucun morceau.

Contraintes

0 ≤ nombre de valeurs ≤ 10,000

1 ≤ size ≤ 10,000

Exemples

Exemple 1
Entrée :
size = 3
values = [1, 2, 3, 4, 5, 6, 7]

Sortie attendue :
expected = [
    [1, 2, 3],
    [4, 5, 6],
    [7]
]
Entrée :
long long size = 3;
std::vector<long long> values = {1, 2, 3, 4, 5, 6, 7};

Sortie attendue :
std::vector<std::vector<long long>> expected = {
    {1, 2, 3},
    {4, 5, 6},
    {7}
};
Entrée :
long size = 3;
long[] values = new long[] {1, 2, 3, 4, 5, 6, 7};

Sortie attendue :
long[][] expected = new long[][] {
    new long[] {1, 2, 3},
    new long[] {4, 5, 6},
    new long[] {7}
};

Explication

Des groupes de 3 : [1, 2, 3] et [4, 5, 6], et le 7 restant forme un dernier morceau plus court.

Exemple 2
Entrée :
size = 5
values = [8, 9]

Sortie attendue :
expected = [
    [8, 9]
]
Entrée :
long long size = 5;
std::vector<long long> values = {8, 9};

Sortie attendue :
std::vector<std::vector<long long>> expected = {
    {8, 9}
};
Entrée :
long size = 5;
long[] values = new long[] {8, 9};

Sortie attendue :
long[][] expected = new long[][] {
    new long[] {8, 9}
};

Explication

La taille est plus grande que la liste, donc tout tient dans un seul morceau : [[8, 9]].

Comment l'aborder

Essayez d'abord seul, puis ouvrez les indices un par un.

Indice 1

Les positions de départ sont 0, size, 2·size, etc.

Indice 2

Prenez une tranche de chaque position de départ jusqu'à start + size.

Indice 3

La dernière tranche peut être plus courte, et une liste vide ne donne aucun bloc.

Complexité attendue

temps O(n), espace supplémentaire O(n)

Références

Ce défi a été adapté pour CodeUtility. Suivez l'énoncé et les contraintes ci-dessus.

Apprenez des autres

Solutions de la communauté

Aucune solution publiée pour l'instant. Résolvez ce défi pour partager la première.