# HackerRank Organizing Containers of Balls problem solution

In this HackerRank Organizing Containers of Balls problem, You must perform q queries where each query is in the form of a matrix, M. For each query, print Possible on a new line if David can satisfy the conditions above for the given matrix. Otherwise, print Impossible.

## Problem solution in Python programming.

```#!/bin/python3

import sys

q = int(input().strip())
for a0 in range(q):
n = int(input().strip())
M = []
for M_i in range(n):
M_t = [int(M_temp) for M_temp in input().strip().split(' ')]
M.append(M_t)
# your code goes here

Rows = []
Cols = []
Works = True

for i in range(n):
Rows.append(sum(M[i]))

N = [list(i) for i in zip(*M)]
for i in range(n):
Cols.append(sum(N[i]))

Rows.sort()
Cols.sort()
if(Rows == Cols):
print("Possible")
else:
print("Impossible")```

## Problem solution in Java Programming.

```import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;

public class Solution {

private static boolean greedy(final int[] types, final int[] containers) {
final int n = types.length;
for (int i = n - 1; i >= 0; i--) {
if (types[i] > containers[i]) {
return false;
}
}
return true;
}

public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int q = in.nextInt();
for(int a0 = 0; a0 < q; a0++){
int n = in.nextInt();
int[][] M = new int[n][n];
for(int M_i=0; M_i < n; M_i++){
for(int M_j=0; M_j < n; M_j++){
M[M_i][M_j] = in.nextInt();
}
}
final int[] types = new int[n];
for (int t = 0; t < n; t++) {
for (int i = 0; i < n; i++) {
types[t] += M[i][t];
}
}

final int[] containers = new int[n];
for (int c = 0; c < n; c++) {
for (int i = 0; i < n; i++) {
containers[c] += M[c][i];
}
}

Arrays.sort(types);
Arrays.sort(containers);
final boolean possible = greedy(types, containers);
final String answer = possible ? "Possible" : "Impossible";
}
}
}```

### Problem solution in C++ programming.

```#define _CRT_SECURE_NO_WARNINGS
#include <string>
#include <vector>
#include <map>
#include <list>
#include <iterator>
#include <set>
#include <queue>
#include <iostream>
#include <sstream>
#include <stack>
#include <deque>
#include <cmath>
#include <memory.h>
#include <cstdlib>
#include <cstdio>
#include <cctype>
#include <algorithm>
#include <utility>
#include <assert.h>
#include <time.h>
#include <complex.h>

#include <fstream>
#include <sys/stat.h>
#include <stdlib.h>
#include <stdio.h>
using namespace std;

#define FOR(i, a, b) for(int i=(a);i<(b);i++)
#define RFOR(i, b, a) for(int i=(b)-1;i>=(a);--i)
#define FILL(A,value) memset(A,value,sizeof(A))
#define ALL(V) V.begin(), V.end()
#define SZ(V) (int)V.size()
#define PB push_back
#define MP make_pair
#define Pi 3.14159265358979

typedef long long Int;
typedef unsigned long long UInt;
typedef vector<int> VI;
typedef pair<Int, Int> PII;

const int INF = 1000000000;
const int MAX = 300007;
const int MAXD = 20;
const int MOD = 1000000007;

int A[MAX];
int B[MAX];

int main()
{
//freopen("in.txt" , "r" , stdin);
//freopen("out.txt" , "w" , stdout);

int q;
cin >> q;
FOR(qq,0,q)
{
int n;
cin >> n;
FILL(A, 0);
FILL(B,0);
FOR(i,0,n)
FOR(j,0,n)
{
int x;
cin >> x;
A[i] += x;
B[j] += x;
}
sort(A , A + n);
sort(B , B + n);
bool ok = 1;
FOR(i,0,n)
ok &= (A[i] == B[i]);
if (ok) cout << "Possible"<< endl;
else cout << "Impossible" << endl;
}

return 0;
}```

### Problem solution in C programming.

```#include <math.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
#include <limits.h>
#include <stdbool.h>

int main(){
int q;
scanf("%d",&q);
for(int a = 0; a < q; a++){
int n,f=0,d=0;
scanf("%d",&n);
int M[n][n],x[n],s,y=0,z[n],l;
for(int i=0;i<n;i++){
for(int j=0;j<n;j++)
scanf("%d ",&M[i][j]);

}
for(int i=0;i<n;i++){
s=0;
l=0;
for(int j=0;j<n;j++)
s=s+M[j][i];
x[i]=s;
for(int j=0;j<n;j++)
l=l+M[i][j];
z[i]=l;
}
for(int i=0;i<n;i++) {
d=0;
for(int j=0;j<n;j++)
if(x[i]==z[j]) d=1;

f=f+d;
}
if(f==n && d==1) printf("Possible\n");
else printf("Impossible\n");

}
return 0;
}```

### Problem solution in JavaScript programming.

```process.stdin.resume();
process.stdin.setEncoding('ascii');

var input_stdin = "";
var input_stdin_array = "";
var input_currentline = 0;

process.stdin.on('data', function (data) {
input_stdin += data;
});

process.stdin.on('end', function () {
input_stdin_array = input_stdin.split("\n");
main();
});

return input_stdin_array[input_currentline++];
}

/////////////// ignore above this line ////////////////////

function main() {
var q = parseInt(readLine());
for(var a0 = 0; a0 < q; a0++){
var n = parseInt(readLine());
var M = [];
for(M_i = 0; M_i < n; M_i++){
M[M_i] = readLine().split(' ');
M[M_i] = M[M_i].map(Number);
}

// your code goes here
var containerMap = {};
var itemMap = {};
for (var i = 0; i < M.length; i++) {
var containerCount = 0;
itemCounts = M[i];
for (var j = 0; j < itemCounts.length; j++) {
var itemCount = itemCounts[j];
containerCount += itemCount;
if (!itemMap[j]) itemMap[j] = 0;
itemMap[j] += itemCount;
}
if (!containerMap[containerCount]) containerMap[containerCount] = 0;
containerMap[containerCount]++;
}

var possible = true;
for (var key in itemMap) {
var count = itemMap[key];
if (!containerMap[count]) {
possible = false;
break;
}
containerMap[count]--;
}

if (possible) {
console.log('Possible');
} else {
console.log('Impossible');
}
}
}```