Rely selection of 1’s at particular place in a Matrix

// C++ code for the above means:
#come with <bits/stdc++.h>
the use of namespace std;

int findNumberOfOnes(vector<vector<char> >& mat)
{
    const int m = mat.dimension();
    const int n = mat[0].dimension();
    int ans = 0;

    // Auxiliary row and col for monitoring
    // what number of B at that corresponding
    // row and col
    vector<int> rows(m);
    vector<int> cols(n);

    // Traversing during the mat[][]
    // matrix. If mat[i][j] == B then
    // increment rows[i]++(for row) and
    // increment cols[j]++(for column).
    for (int i = 0; i < m; ++i)
        for (int j = 0; j < n; ++j)
            if (mat[i][j] == 1) {
                ++rows[i];
                ++cols[j];
            }

    // Traversing during the mat[][]
    // matrix once more and if
    // rows[i]==1 || cols[j]==1
    // then ans++, else proceed.
    for (int i = 0; i < m; ++i)
        if (rows[i] == 1)
            for (int j = 0; j < n; ++j)

                // If the present positon
                // is 1 on this row then
                // wreck and seek
                // the following row
                if (mat[i][j] == 1) {
                    if (cols[j] == 1)
                        ++ans;
                    wreck;
                }
    go back ans;
}

// Drivers code
int major()
{
    vector<vector<char> > mat
        = { { 0, 0, 1 }, { 0, 1, 0 }, { 1, 0, 0 } };

    // Serve as Name
    cout << findNumberOfOnes(mat);
    go back 0;
}

/*package deal no matter // don't write package deal identify right here */

// A program for locating the lonely colour
import java.io.*;

magnificence GFG {
    public static int findLonelyColor(char[][] portray)
    {
        int m = portray.period, n = portray[0].period;
        // Auxiliary row and col for monitoring what number of B at
        // that corresponding row and col
        int[] rows = new int[m];
        int[] cols = new int[n];

        // Traversing during the portray matrix. If
        // portray[i][j]==B then increment rows[i]++(for
        // row) and increment cols[j]++(for column).
        for (int i = 0; i < m; ++i) {
            for (int j = 0; j < n; ++j) {
                if (portray[i][j] == 'B') {
                    rows[i]++;
                    cols[j]++;
                }
            }
        }

        int ans = 0;
        // Traversing during the portray matrix once more and
        // if rows[i]==1 || cols[j]==1 then ans++, else
        // proceed.
        for (int i = 0; i < m; ++i) {
            if (rows[i] == 1) {
                for (int j = 0; j < n; ++j) {
                    // If the present positon is 'B' on this
                    // row then wreck and seek the following
                    // row
                    if (portray[i][j] == 'B'
                        && cols[j] == 1) {
                        ans++;
                        wreck;
                    }
                }
            }
        }
        go back ans;
    }

    public static void major(String[] args)
    {
        char[][] portray = { { 'W', 'W', 'B' },
                              { 'W', 'B', 'W' },
                              { 'B', 'W', 'W' } };
        int ans = findLonelyColor(portray);
        Machine.out.println(ans);
    }
}

# A program for locating the lonely colour
from typing import Listing


def findLonelyColor(self, portray: Listing[List[str]]) -> int:
    # Auxiliary row and col for monitoring what number of B at that
    # corresponding row and col
    m, n = len(portray), len(portray[0])
    rows, cols = [0] * m, [0] * n
    # Traversing during the portray matrix.
    # If portray[i][j]== B then increment rows[i]++(for row)
    # and increment cols[j]++(for column).
    for i in vary(m):
        for j in vary(n):
            if portray[i][j] == 'B':
                rows[i] += 1
                cols[j] += 1

    ans = 0
    # Traversing during the portray matrix once more and
    # if rows[i]== 1 || cols[j]== 1 then ans++, else proceed
    for i in vary(m):
        if rows[i] == 1:
            for j in vary(n):
                # If the present positon is 'B' on this row
                # then wreck and seek the following row
                if portray[i][j] == 'B' and cols[j] == 1:
                    ans += 1
                    wreck
    go back ans


if __name__ == "__main__":
    portray = [['W', 'W', 'B'],
                ['W', 'B', 'W'],
                ['B', 'W', 'W']]
    print(findLonelyColor(__name__, portray))