Последовательное распределение данных из списка по массивам разного веса.

Question

Как, последовательно распределять данные из списка по массивам (или другим структурам) фиксированного размера / веса.

Например, допустим, у меня есть список из 10 элементов.Я хочу последовательно распределить элементы по 3 массивам A, B и C. Массивам присваивается вес, скажем, A = 3, B = 5 и C = 2.

Элемент будет распределен вследующая мода.

A - list[0]  list[3] list[6]
B - list[1]  list[4] list[7] list[8] list[9]
C - list[2]  list[5] 

Если размер списка равен 13, то после рассмотренного выше распределения он начнется снова после завершения цикла

A - list[0]  list[3] list[6] list[10]
B - list[1]  list[4] list[7] list[8] list[9] list[11]
C - list[2]  list[5] list[12]

Размер списка является динамическим, поэтомув приведенном выше примере размер списка будет 3, 4 или 100 и т. д. А количество массивов (или структуры) и вес массивов доступны только во время выполнения.

Есть ли хороший способрешить это?

Answer 1

Самый простой способ последовательно распределить элемент по массиву различных весовых массивов (фиксированный размер) - это автоматически загрязнять стеки, используя размер массива. И положить стек в круговой массив. последовательно получить следующий стек и вытолкнуть элемент стека. Если в стеке нет больше элементов, удалите его из кругового массива, пока список рассылки не станет пустым. если размер списка рассылки не задан заранее или круговой массив становится пустым, сбросьте круговой массив и начните с начала.

A = 3, B = 5 и C = 1.

    Stack<String> sA= new Stack<String>();
    sA.push("A");sA.push("A");sA.push("A");

    Stack<String> sB = new Stack<String>();
    sB .push("B");sB .push("B");sB .push("B");sB .push("B");sB .push("B");


    Stack<String> sC = new Stack<String>();
    sC.push("C");

// добавляем стек в массив CircularLinkedList list = new CircularLinkedList (); list.add (S1); list.add (с2); list.add (s3);

    CircularListIterator<Stack> iterator = list.iterator();
    Stack<String> s;

// итерация до тех пор, пока стек не станет пустым, сбросить стек, если список рассылки остался // или если лидерство поступает из другого источника, например, с веб-сайта, просто получите следующий стек

    while (iterator.hasNext()){
        s = iterator.next();
        if (s.empty()){
            iterator.remove();
            continue;
        } 
        System.out.println(s.pop());            
    }

Вот пример кругового списка // http://www.cs.princeton.edu/algs4/13stacks/CircularLinkedList.java.html

Answer 2

Не уверен, что это именно то, что вы хотите, потому что в вашем примере десятое значение возвращалось к первому массиву, когда я подозреваю, что оно должно было перейти к третьему. И это, вероятно, можно несколько оптимизировать ...

package test.stack.overflow;

import java.util.ArrayList;

public class TestWeights
{
    public static void main(String[] args)
    {
        int[] w = {3, 5, 2};
        ArrayList<ArrayList<Integer>> v = new ArrayList<ArrayList<Integer>>(w.length);

        int s = 0, i = 0;
        for (int x = 0 ; x < w.length; x++)
        {
            v.add(new ArrayList<Integer>());
            s += w[x];
        }

        for (int nv = 0; nv < 30; nv++)
        {
            int r = 1 + nv / s;

            while (true)
            {
                if (v.get(i).size() < w[i] * r)
                {
                    v.get(i).add(nv);
                    i = ++i % w.length;
                    break;
                }
                else
                    i = ++i % w.length;
            }
        }

        for(ArrayList<Integer> a : v)
        {
            for(Integer ai : a)
                System.out.print(ai + " ");

            System.out.println();
        }
    }
}

Answer 3

Я бы использовал ArrayLists со связанными частями элементов, которые должны быть добавлены в них.

Например: ArrayListA - с ассоциированным значением 3 ArrayListB - с ассоциированным значением (3 + 5) = 8 ArrayListC - с ассоциированным значением (8 + 2) = 10

и для каждого элемента из списка: 1. найти случайное число от 0 до 10 2. добавить элемент в массив с указанным значением, например: если номер i 9, то добавить в ArrayListC если номер i 2, то добавить в ArrayListA если номер i 8, добавить ArrayListB

и если массив действительно нужен, то конвертируйте его в массив.

и этих массивов вы можете хранить в одной структуре, так что вы можете иметь их столько, сколько захотите.

Answer 4

Вы должны лучше определить проблему.Термин «вес» не является достаточно детерминированным и обычно просто означает, что в качестве фактора используется некоторая процедура или расчет.

Например, если вы хотите последовательно назначать элементы из очереди в n-сегменты, стремясь копределенное распределение данных в корзинах, тогда проблема становится яснее.

Тогда вы можете просто взять следующий элемент из очереди и бросить кубик таким образом, чтобы он определил корзину с данным распределением (используя пример сРаспределение A, B, C-> 3,5,2, бросьте кости с 10 сторонами и, если вы получили 1,2 или 3, поместите элемент в A, если он равен 4,5,6,7,8, поместите его вB и если это 9 или 10, поместите это в C).

Тем не менее, поймите, что я не полностью определил проблему, когда я говорю «цель для распространения», нет никакой гарантии, когда такое распространение будет достигнуто.ни то, сколько вы можете быть от этого по пути (особенно в начале процесса).

Из вашего примера кажется, что вы хотите, чтобы распределение было как можно ближенасколько это возможно для распределения, к которому вы стремитесь, для каждого обработанного элемента.

В этом случае наивным и простым усилием будет добавление элемента в корзину, что сделает новый дистрибутив наиболее близким к целевому распределению.

Answer 5

Как я понимаю, проблема состоит в том, что если существует N различных весов (W1, W2..etc) и M является их суммой, вы хотите, чтобы цикл повторялся для каждого M элементов. Было бы N разных массивов, и каждый цикл помещал бы весовое число элементов в каждом массиве, как первый занимает W1 и т. Д.

Одним из решений является простое считывание элементов с сохранением счетчика, если счетчик равен