获取二进制数组中最大和最小的一组

时间:2019-10-02 08:17:55

标签: java arrays

我有一个0和1的2D数组。

每个具有1的连续单元都被视为单个对象。

我的任务是为每行找到最大的连续1,也为最小的连续1求出差值。

Example:

oth Row --> 0 0 0 0 0
1st Row --> 0 0 1 0 0 
2nd Row --> 0 0 1 0 1
3rd Row --> 1 1 1 0 1 
4th Row --> 0 0 0 0 0 

说明:

在第0行中没有1,因此不需要任何操作。

在第一行中只有一个1,因此我认为它是该行的最大对象是1。

在第二行中,在位置[2,2]处有一个1,我认为这是该行的最大对象。现在在位置[2,4]的下一个1中,我认为它是最小的对象。该行的值为1。

在第三行中,位置[3,0],[3,1],[3,2]上有三个1,我认为它是该行的最大对象是3。现在下一个1位于位置[ 3,4],我认为它是这一行的最小对象是1。

第4行中没有1,因此不需要任何操作。

我的任务是找到所有最大物体的总和与所有最小物体的总和之间的差。

在此示例中:

Sum of largest objects = 0 (0th row) + 1 (1st row) + 1 (2nd row) + 3 (3rd row) + 0 (4th row) = 5
Sum of smallest objects = 0 (0th row) + 0 (1st row) + 1 (2nd row) + 1 (3rd row) + 0 (4th row) = 2

Result = sum of largest - sum of smallest = 5 - 2 = 3.

我想出了以下逻辑:

public static int process(int[][] array)
{
    int result = 0;
    // Get row and column size
    int rows = array.length;
    int cols = array[0].length;

    // variables to store sum of large and small objects
    int large = 0;
    int small = 0;

    for(int i=0; i<rows; i++) {
        // variables to store large and small objects per row level
        int l_count = 0;
        int s_count = 0;


        boolean valid = false;
        for(int j=0; j<cols-1; j++) {
            int curr = array[i][j];
            int next = array[i][j+1];
            // First occurrence of 1 is considered as large object
            if(l_count == 0 && curr == 1) {
                l_count++;
                valid = true;
            }
            // consecutive 1's added to large count
            if(valid && curr == next) {
                l_count++;
            } else {
                valid = false;
            }

            // Get small count
            if(!valid && curr == 1 || next == 1) {
                s_count++;
            }
        }
        // Add row level counts to large and small objects
        large += l_count;
        small += s_count;

    }
    result = large - small;
  return result;
}

这不起作用并且给出错误的结果,我无法找到解决此问题所需的逻辑。

2 个答案:

答案 0 :(得分:1)

要查找每一行中最大和最小的对象,您可能首先需要获取该行中所有对象的列表,然后进行相应的过滤,即具有可以执行此操作的函数

0 0 0 0 0 -> []
0 0 1 0 0 -> [1]
0 0 1 0 1 -> [1,1]
1 1 1 0 1 -> [3,1]
0 0 0 0 0 -> []

之后,您可以使用诸如Collections.max(collection)Collections.min(Collection)之类的函数来获取最大值和最小值。要说明第1行的情况,您可以选中if(foundObjects.size < 2)并将min设置为0

为此,假设您使用的是Java 1.8或更高版本,可能的实现如下:

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

class ObjectCalculator {
    static int compute(int[][] array){
        return Arrays.stream(array)
                .map(ObjectCalculator::findObjects)
                .mapToInt(objects -> {
                    int min, max;
                    if (objects.size() < 2) min = 0;
                    else min = Collections.min(objects);
                    if (objects.size() < 1) max = 0;
                    else max = Collections.max(objects);
                    return max - min;
                }).sum();
    }

    static List<Integer> findObjects(int[] array) {
        ArrayList<Integer> objects = new ArrayList<>();
        int curSize = 0;
        for(int i : array){
            if(i == 1)curSize++;
            else if(curSize > 0){
                objects.add(curSize);
                curSize = 0;
            }
        }
        if(curSize > 0){
            objects.add(curSize);
        }
        return objects;
    }
}

答案 1 :(得分:0)

也许下面的更改可以解决您的问题。不要查看下一个元素,只需保持计数并始终使用当前元素即可。

public static int process(int[][] array)
{
    int result = 0;
    // Get row and column size
    int rows = array.length;
    int cols = array[0].length;

    // variables to store sum of large and small objects
    int large = 0;
    int small = 0;

    for(int i=0; i<rows; i++) {
        // variables to store large and small objects per row level
        int l_count = 0;
        int s_count = 0;
        int count = 0;

        for(int j=0; j<cols; j++) {
            if (array[i][j]) {
                count++;
            } else if (count > 0) {
                if (count > l_count) {
                    l_count = count;
                } else if (count < s_count || s_count == 0) {
                    s_count = count;
                }
                count = 0;
            }
        }
        // Add row level counts to large and small objects
        large += l_count;
        small += s_count;

    }
    result = large - small;
  return result;
}