Uniform proportion algorithm - arrays

Question

Suppose that I have two arrays A and B where A is a m by n matrix and B is a vector of size m. Each value in B refers to same row in A and has a value of 1 or 0. Now assume A and B like below:
A= 1 2 3 4 B= 1
5 6 7 8 0
5 6 7 8 0
5 6 7 8 0
5 6 7 8 0
5 6 7 8 1
5 6 7 8 0
5 6 7 8 0
I want to break both arrays to k parts and I want all parts have a (semi) uniform number of 1s and 0s. By default some proportions are empty of 1 while some have many.
I need an algorithm to sort both arrays before doing this breaking (splitting) job. How should this type of sort be done. Or what's the best way?
It is worth mentioning that the real data has 679 rows with corresponding 1 for 70 of them and 0 for others. And by now the desired k is 10.

Answer 1

You haven't given any code examples, and I don't want to give any code, because I've recently asked a similar question as a homework exercise. However, here is some pseudocode mixed with Java-esque method signatures. In the following, I will assume that one row of your dataset is modeled as Pair<A, B> with some generic types A and B (thinking of A as "features" and B as "labels" in a supervised machine learning task). In your concrete case, A would be some kind of list of integers, and B might be Boolean.
First, you define a helper method that can shuffle and split the dataset into k parts, completely ignoring the labels. In Java-syntax:
public static <A,B> ArrayList<ArrayList<Pair<A,B>>> split(
ArrayList<Pair<A, B>> dataset,
int k
) {
// shuffle the dataset
// generate `k` new lists
// add rows from the shuffled list to the `k` lists
// in round-robin fashion, i.e.
// move `i`-th item to the `i%k`-th list.
}
Building on top of that, you can define the stratified split version:
public static <A,B> ArrayList<ArrayList<Pair<A,B>>> stratifiedSplit(
ArrayList<Pair<A,B>> dataset,
int k
) {
// create a (hash?)map for the strata.
// In this map, you want to collect rows in separate
// lists, depending on their label:
HashMap<B, ArrayList<Pair<A,B>>> strata = ...;
// (Check whether your collection library of choice
// provides a `groupBy` or a `groupingBy` of some sort.
// In C#, this might help:
// https://msdn.microsoft.com/en-us/library/bb534304(v=vs.110).aspx )
// In your concrete case,
// your map should look something like this:
// {
// false -> [
// ([5, 6, 7, 8], false),
// ([5, 6, 7, 8], false),
// ([5, 6, 7, 8], false),
// ([5, 6, 7, 8], false),
// ([5, 6, 7, 8], false),
// ([5, 6, 7, 8], false)
// ],
// true -> [
// ([5, 6, 7, 8], true),
// ([1, 2, 3, 4], true)
// ]
// }
// where `{}`=map, `[]`=list/array, `()`=tuple/pair.
// Now you generate `k` lists to hold the result.
// For each stratum, you call the ordinary non-stratified
// `split` method, and append the `k` pieces returned by
// this method to the `k` result lists.
// In the end, you again shuffle each of the `k` result
// lists (so that the labels aren't sorted in the end)
// return `k` result lists.
}
Writing out the details is left as an exercise.