Organizing Containers of Balls Solution in C, C++, Java, Python

David has several containers, each with a number of balls in it. He has just enough containers to sort each type of ball he has into its own container. David wants to sort the balls using his sort method.

As an example, David has n=2 containers and 2 different types of balls, both of which are numbered from 0 to n-1=1. The distribution of ball types per container are described by an  n*n matrix of integers, 

In a single operation, David can swap two balls located in different containers.

The diagram below depicts a single swap operation:

David wants to perform some number of swap operations such that:

  • Each container contains only balls of the same type.
  • No two balls of the same type are located in different containers.

You must perform  queries where each query is in the form of a matrix, . For each query, print Possible on a new line if David can satisfy the conditions above for the given matrix. Otherwise, print Impossible.

Function Description

Complete the organizingContainers function in the editor below. It should return a string, either Possible or Impossible.

organizingContainers has the following parameter(s):

  • containter: a two dimensional array of integers that represent the number of balls of each color in each container

Input Format

The first line contains an integer , the number of queries.

Each of the next  sets of lines is as follows:

  1. The first line contains an integer , the number of containers (rows) and ball types (columns).
  2. Each of the next  lines contains  space-separated integers describing row .

Constraints

  • 1<=q<=10
  • 1<=n<=100
  • 0<=M[container][type]<=10^9

Scoring

  • For 33% of score,1<=n<=10 .
  • For 100% of score,1<=n<=100 .

Output Format

For each query, print Possible on a new line if David can satisfy the conditions above for the given matrix. Otherwise, print Impossible.

Sample Input 0

2

2

1 1

1 1

2

0 2

1 1

 

Sample Output 0

Possible

Impossible

 

Organizing Containers of Balls Solution in C

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

int main() {
    int t;
    scanf("%d", &t);
    while(t--){
        int n, i, j;
        scanf("%d", &n);
        int a[n][n];
        int *sum1 = (int *)calloc(sizeof(int), n);
        for(i = 0; i < n; i++){
            for(j = 0; j < n; j++){
                scanf("%d", &a[i][j]);
                sum1[i] += a[i][j];
            }
        }
        for(i = 0; i < n; i++){
            int sum2 = 0;
            for(j = 0; j < n; j++){
                sum2 += a[j][i];
            }
            for(j = 0; j < n; j++) if (sum1[j] == sum2){ sum1[j] = 0; break; }
            if (j == n){
                printf("Impossible\n");
                break;
            }
        }
        if (i == n) printf("Possible\n");
    }
    /* Enter your code here. Read input from STDIN. Print output to STDOUT */   
    return 0;
}

 

Organizing Containers of Balls Solution in C++

#include <map>
#include <set>
#include <list>
#include <cmath>
#include <ctime>
#include <deque>
#include <queue>
#include <stack>
#include <string>
#include <bitset>
#include <cstdio>
#include <limits>
#include <vector>
#include <climits>
#include <cstring>
#include <cstdlib>
#include <fstream>
#include <numeric>
#include <sstream>
#include <iostream>
#include <algorithm>
#include <unordered_map>

using namespace std;


int main(){
    int q;
    cin >> q;
    for(int a0 = 0; a0 < q; a0++){
        int n;
        cin >> n;
        vector< vector<int> > M(n,vector<int>(n));
        long long totalIn[101]={0},totalOf[100]={0};
        for(int M_i = 0;M_i < n;M_i++){
           for(int M_j = 0;M_j < n;M_j++){
              cin >> M[M_i][M_j];
               totalIn[M_i]+=M[M_i][M_j];
               totalOf[M_j]+=M[M_i][M_j];
           }
        }
        sort(totalIn,totalIn+100);
        sort(totalOf,totalOf+100);
        int i;
        for(i=0;i<100;i++)
            {
            if(totalIn[i]!=totalOf[i])
                break;
        }
        if(i==100)
            cout<<"Possible"<<endl;
        else
            cout<<"Impossible"<<endl;
        // your code goes here
    }
    return 0;
}

 

Organizing Containers of Balls Solution in Java

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

public class Solution {

    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();
                }
            }
            int[] rt = new int[n];
            int[] ct = new int[n];
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < n; j++) {
                    rt[i] += M[i][j];
                    ct[j] += M[i][j];
                }
            }
            Arrays.sort(rt);
            Arrays.sort(ct);
            String ans = "Possible";
            for (int i = 0; i < n; i++) {
                if (rt[i] != ct[i])
                    ans = "Impossible";
            }
            System.out.println(ans);
        }
    }
}

 

Organizing Containers of Balls Solution in Python

#!/bin/python

import sys


q = int(raw_input().strip())
for a0 in xrange(q):
    n = int(raw_input().strip())
    M = []
    for M_i in xrange(n):
        M_temp = map(int,raw_input().strip().split(' '))
        M.append(M_temp)
    ballcounts = {}
    for j in xrange(n):
        s = 0
        for i in xrange(n):
            s += M[i][j]
        if s in ballcounts:
            ballcounts[s] += 1
        else:
            ballcounts[s] = 1
    
    conts = {}
    for i in xrange(n):
        s = 0
        for j in xrange(n):
            s += M[i][j]
        if s in conts:
            conts[s] += 1
        else:
            conts[s] = 1    
    poss = True
    #for x in ballcounts:
    #    if ballcounts[x] % 2 == 1:
    #        poss = False
    for x in ballcounts:
        if not (x in conts):
            poss = False
            break
        if conts[x] != ballcounts[x]:
            poss = False
            break
    for x in conts:
        if not (x in ballcounts):
            poss = False
            break
        if conts[x] != ballcounts[x]:
            poss = False
            break
    if (poss):
        print "Possible"
    else:
        print "Impossible"

 

Organizing Containers of Balls Solution in C#

using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Linq.Expressions;
using System.Text;

namespace CF317
{
    internal class Program
    {
        private static void Main(string[] args)
        {
            var sr = new InputReader(Console.In);
            //var sr = new InputReader(new StreamReader("input.txt"));
            var task = new Task();
            using (var sw = Console.Out)
            //using (var sw = new StreamWriter("output.txt"))
            {
                task.Solve(sr, sw);
                //Console.ReadKey();
            }
        }
    }

    internal class Task
    {
        public void Solve(InputReader sr, TextWriter sw)
        {
            var tests = sr.NextInt32();
            for (var t = 0; t < tests; t++) {
                var n = sr.NextInt32();
                var matrix = new long[n, n];
                for (var i = 0; i < n; i++) {
                    var input = sr.ReadArray(Int64.Parse);
                    for (var j = 0; j < n; j++) {
                        matrix[i, j] = input[j];
                    }
                }
                var containersCap = new Dictionary<long, int>();
                for (var i = 0; i < n; i++) {
                    var currCap = 0L;
                    for (var j = 0; j < n; j++) {
                        currCap += matrix[i, j];
                    }
                    if (!containersCap.ContainsKey(currCap)) {
                        containersCap.Add(currCap, 0);
                    }
                    containersCap[currCap]++;
                }
                var typesCap = new Dictionary<long, int>();
                    for (var j = 0; j < n; j++) {
                    var curr = 0L;
                        for (var i = 0; i < n; i++) {
                            curr += matrix[i, j];
                        }
                        if (!typesCap.ContainsKey(curr)) {
                            typesCap.Add(curr, 0);
                        }
                        typesCap[curr]++;
                    }
                 var answ = "Possible";
                foreach (var item in typesCap) {
                    if (!containersCap.ContainsKey(item.Key)) {
                        answ = "Impossible";
                        break;
                    }
                    containersCap[item.Key] -= item.Value;
                    if (containersCap[item.Key] != 0) {
                        answ = "Impossible";
                        break;
                    }
                    containersCap.Remove(item.Key);
                }
                if (containersCap.Count != 0) {
                    answ = "Impossible";
                }

                sw.WriteLine(answ);
            }
        }
    }
}

internal class InputReader : IDisposable
{
    private bool isDispose;
    private readonly TextReader sr;

    public InputReader(TextReader stream)
    {
        sr = stream;
    }

    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    public string NextString()
    {
        var result = sr.ReadLine();
        return result;
    }

    public int NextInt32()
    {
        return Int32.Parse(NextString());
    }

    public long NextInt64()
    {
        return Int64.Parse(NextString());
    }

    public string[] NextSplitStrings()
    {
        return NextString()
            .Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
    }

    public T[] ReadArray<T>(Func<string, CultureInfo, T> func)
    {
        return NextSplitStrings()
            .Select(s => func(s, CultureInfo.InvariantCulture))
            .ToArray();
    }

    public T[] ReadArrayFromString<T>(Func<string, CultureInfo, T> func, string str)
    {
        return
            str.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries)
                .Select(s => func(s, CultureInfo.InvariantCulture))
                .ToArray();
    }

    protected void Dispose(bool dispose)
    {
        if (!isDispose)
        {
            if (dispose)
                sr.Close();
            isDispose = true;
        }
    }

    ~InputReader()
    {
        Dispose(false);
    }
}

 

Attempt Organizing Containers of Balls HackerRank Challenge 

Link – https://www.hackerrank.com/challenges/taum-and-bday/

Next HackerRank Challenge Solution 

Link – https://exploringbits.com/encryption-hackerrank-solution/

 

Leave a Comment