CODEWITHSUNDEEP
javaarraysmultidimensional-array
Dishant Mewada
Dishant Mewada

Reputation: 87

counting negative numbers in array

I am trying to find the counts for negative numbers in a 2d-array ( square- matix). In matrix if you go from up to down and left to write number increases. Logic here is to start from last column and proceed to the left. If you find the neg num then increase the row index and proceed the same way till the last row. I am getting the error in java code but not in python.

public class O_n 

{

public static void main(String[] args)

{

    int firstarray[][] = {{-2,-1,0},{-1,0,1},{0,1,2}};
    int secondarray[][] = {{-4,-3,-2},{-3,-2,-1},{-2,-1,0}};
    System.out.print ("First array has"+count_neg(firstarray));
    System.out.println("negative numbers");
    System.out.print ("Second array has"+count_neg(secondarray));
    System.out.println("negative numbers");
}

public static int count_neg(int x[][]){
    int count = 0;
    int i = 0; //rows
    int j = x.length - 1; //columns

    System.out.println("max column index is: "+j);
    while ( i >=0 && j<x.length){
        if (x[i][j] < 0){ // negative number
            count += (j + 1);// since j is an index...so j + 1
            i += 1;
        }
        else { // positive number
            j -= 1;
        }
    }
    return (count);
    }
}

I am getting this output

max column index is: 2
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: -1
    at O_n.count_neg(O_n.java:22)
    at O_n.main(O_n.java:9)
/home/eos/.cache/netbeans/8.1/executor-snippets/run.xml:53: Java 
returned: 1
BUILD FAILED (total time: 0 seconds)

What is wrong with this code? the same thing worked in python...

def count_neg(array):
    count = 0
    i = 0 # row
    j = len(array) -1 # col
    # since we are starting from right side

    while j >= 0 and i < len(array):
        if array[i][j] < 0: 
            count += (j + 1)
            i += 1
        else:
            j -= 1
    return count
print(count_neg([[-4,-3,-1,1],[-2,-2,1,2],[-1,1,2,3],[1,2,4,5]]))

Upvotes: 5

Views: 1756

Answers (4)

oreh
oreh

Reputation: 1181

Here a small change in the algorithms to produce correct result with columns which don't contain negative numbers:

    while j >= 0 and i < len(array):
    if array[i][j] < 0:
        count += (j + 1)
        i += 1
    else:
        j -= 1
    if j < 0:
        i += 1
        j = len(array) - 1

You can test it with the following array [[1,2,4,5],[-2,-2,1,2],[-1,1,2,3],[1,2,4,5]]

Upvotes: 1

oreh
oreh

Reputation: 1181

First of all your algorithm don't find the count of negative numbers.

Here are the results of the python code:

print(count_neg([[1, 1, -1],[1, 1, -1],[1, 1, -1]])) result - 9

print(count_neg([[1, 1, -1],[1, 1, 1],[1, 1, 1]])) result - 3

So the provided code finds sum of column indexes + 1 for some negative numbers, not all. And for your test arrays it's return pseudo correct counts.

To find the count of negative numbers in a two-dimentional array you just have to get each number, check if the one is less than zero and increase the counter by one if it's true. So it's impossible to get the correct result with complexity better than O(n2).

Here the correct code in Java of doing that:

public static int count_neg(int x[][]){
    int count = 0;
    for(int i = 0; i < x.length; i++){
        for(int j = 0; j < x[i].length; j++){
            if(x[i][j] < 0) count++;
        }
    }

    return count;
}

Upvotes: 1

StaticBeagle
StaticBeagle

Reputation: 5175

Your indexes are reversed from the python version:

while j >= 0 and i < len(array)

To the Java version:

while (i >= 0 && j < x.length)
// Change to
while (j >= 0 && i < x.length)

Output:

max column index is: 2
3

If you are using Java8, you can use streams to implement count_neg:

public static int countNeg(int x[][]) {
    long count = Stream.of(x)
            .flatMapToInt(arr -> IntStream.of(arr))
            .filter(i -> i < 0)
            .count();
    return Math.toIntExact(count);
}

Upvotes: 1

Sacha
Sacha

Reputation: 332

I would write the method like this, just go through the 2d array and increase count each time a negative number is found

public static int count_neg(int x[][]){
    int count = 0;

    for(int i = 0; i < x.length; i++){
        for(int j = 0; j < x[i].length; j++){
            if(x[i][j] < 0){
                count++;
            }
        }
    }
    return (count);
}

Upvotes: 2

Related Questions