Алгоритмы обучения с js, python и java 6: кусок массива

Это шестая статья моих попыток последовать Стивена Градера Удемический курс на трех разных языках. Решения JavaScript являются Стивен Отказ Я пытаюсь «перевести» его в Python и Java.

Сегодняшний вопрос:

— Направления с учетом размера массива и чанка, разделите массив во многие подчинители, где каждая подставка имеет размер длины — Примеры куска ([1, 2, 3, 4], 2) -> [[1, 2], [3, 4]] Кусок ([1, 2, 3, 4, 5], 2) -> [[1, 2], [3, 4], [5]] кусок ([1, 2, 3, 4, 5, 6, 7, 8], 3) – > [[1, 2, 3], [4, 5, 6], [7, 8]] кусок ([1, 2, 3, 4, 5], 4) -> [[1, 2, 3, 4], [5]] кусок ([1, 2, 3, 4, 5], 10) – > [[ 1, 2, 3, 4, 5]]

Я добавляю к каждому решению времени (MS), потребовалось, чтобы разделить массив с 10 000 000 элементов в помех с 1000 элементами.

JavaScript:

function chunk1(array, size) { // 227.480ms
    const chunked = [];

    for (let element of array) {
        const lastChunk = chunked[chunked.length - 1];

        if (!lastChunk || lastChunk.length === size) {
            chunked.push([element]);
        } else {
            lastChunk.push(element);
        }
    }

    return chunked;
}

Python:

def chunk1a(lst: list, size: int) -> list: # 2409.636ms
    chunked = []

    for element in lst:
        if not chunked or len(chunked[-1]) == size:
            chunked.append([])
        last_chunk = chunked[-1]
        last_chunk.append(element)

    return chunked

Как в Упражнение 4 мы не можем начать с last_chunk [-1] Как в JS, потому что это вызвало бы индексэрмер.

Так как это ищет последний элемент раскаленный Дважды, он становится немного быстрее, переписав его как:

def chunk1b(lst: list, size: int) -> list: # 2014.493ms
    chunked = []

    for element in lst:
        if not chunked:
            chunked.append([])
        last_chunk = chunked[-1]
        if len(last_chunk) == size:
            last_chunk = []
            chunked.append(last_chunk)
        last_chunk.append(element)

    return chunked

Я также подумал об использовании коллекционных коллекций. Это вместо списка:

from collections import deque

def chunk1c(lst: list, size: int) -> list: # 2618.956ms
    chunked = deque()

    for element in lst:
        if not chunked or len(chunked[-1]) == size:
            chunked.append([])
        last_chunk = chunked[-1]
        last_chunk.append(element)

    return list(chunked)

Но это привело к дольшему времени выполнения, чем первое решение.

Ява:

import java.util.ArrayList;
import java.util.List;

public static List> chunk1a(List list, int size) { // 2072.358ms
    List> chunked = new ArrayList<>();

    for (int element : list) {
        if (chunked.isEmpty() || chunked.get(chunked.size() - 1).size() == size) {
            chunked.add(new ArrayList<>());
        }
        List lastChunk = chunked.get(chunked.size() - 1);
        lastChunk.add(element);
    }

    return chunked;
}

Раствор, как Python 1B, намного быстрее, чем первый.

import java.util.ArrayList;
import java.util.List;

public static List> chunk1b(List list, int size) { // 404.818ms
    List> chunked = new ArrayList<>();

    for (int element : list) {
        if (chunked.isEmpty()) {
            chunked.add(new ArrayList<>());
        }
        List lastChunk = chunked.get(chunked.size() - 1);
        if (lastChunk.size() == size) {
            lastChunk = new ArrayList<>();
            chunked.add(lastChunk);
        }
        lastChunk.add(element);
    }

    return chunked;
}

Его можно улучшить, когда я использую связанные списки:

import java.util.LinkedList;
import java.util.List;

public static List> chunk1c(List list, int size) { // 295.885ms
    LinkedList> chunked = new LinkedList<>();

    for (int element : list) {
        if (chunked.isEmpty()) {
            chunked.add(new LinkedList<>());
        }
        List lastChunk = chunked.getLast();
        if (lastChunk.size() == size) {
            lastChunk = new ArrayList<>();
            chunked.add(lastChunk);
        }
        lastChunk.add(element);
    }

    return chunked;
}

Кстати, вот версия LinkedList первого кода Java, и это намного медленнее, чем любое решение. Интересно, почему, потому что это выглядит мне по сути так же, как 1С выше.

public static List> chunk1d(List list, int size) { // 4556.835ms
    LinkedList> chunked = new LinkedList<>();

    for (int element : list) {
        if (chunked.isEmpty() || chunked.getLast().size() == size) {
            chunked.add(new LinkedList<>());
        }
        List lastChunk = chunked.getLast();
        lastChunk.add(element);
    }

    return chunked;
}

Этот пост получил дольше, чем я ожидал, но теперь наступает второй набор решений, которые более лаконичны, а также быстрее.

JavaScript:

function chunk2(array, size) { // 83.652ms
    const chunked = [];
    let index = 0;

    while (index < array.length) {
        chunked.push(array.slice(index, index + size));
        index += size;
    }

    return chunked;
}

Python:

def chunk2a(lst: list, size: int) -> list: # 240.898ms
    chunked = []
    index = 0

    while index < len(lst):
        chunked.append(lst[index:index+size])
        index += size

    return chunked

Питоновый одноклассник:

def chunk2b(lst: list, size: int) -> list: # 234.880ms
    return [lst[i:i+size] for i in range(0, len(lst), size)]

Ява:

import java.util.ArrayList;
import java.util.List;
import java.lang.Math;

public static List> chunk2(List list, int size) { // 1.250ms
    List> chunked = new LinkedList<>();
    int index = 0;

    while (index < list.size()) {
        chunked.add(list.subList(index, Math.min(index + size, list.size())));
        index += size;
    }

    return chunked;
}

Этот определенно самый быстрый из всех!

Оригинал: “https://dev.to/tommy3/learning-algorithms-with-js-python-and-java-6-array-chunking-3mii”

Читайте ещё по теме: