We use cookies to ensure you have the best browsing experience on our website. Please read our cookie policy for more information about how we use cookies.
  1. Prepare
  2. Algorithms
  3. Implementation
  4. Organizing Containers of Balls
  5. Discussions

Organizing Containers of Balls

Sort by

recency

|

619 Discussions

|

  • mohammed_abrar_1
     + 0 comments

    import java.io.; import java.util.; import java.util.stream.*; import static java.util.stream.Collectors.toList;

    class Result {

    /*
 * Complete the 'organizingContainers' function below.
 *
 * The function is expected to return a STRING.
 * The function accepts 2D_INTEGER_ARRAY container as parameter.
 */

public static String organizingContainers(List<List<Integer>> container) {
    int n = container.size();
    int[] containerCapacity = new int[n];
    int[] typeCount = new int[n];

    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            containerCapacity[i] += container.get(i).get(j); // total balls in container i
            typeCount[j] += container.get(i).get(j);         // total balls of type j
        }
    }

    Arrays.sort(containerCapacity);
    Arrays.sort(typeCount);

    return Arrays.equals(containerCapacity, typeCount) ? "Possible" : "Impossible";
}

    }

    public class Solution { public static void main(String[] args) throws IOException { BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in)); BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(System.getenv("OUTPUT_PATH")));

        int q = Integer.parseInt(bufferedReader.readLine().trim());

    IntStream.range(0, q).forEach(qItr -> {
        try {
            int n = Integer.parseInt(bufferedReader.readLine().trim());

            List<List<Integer>> container = new ArrayList<>();

            IntStream.range(0, n).forEach(i -> {
                try {
                    container.add(
                        Stream.of(bufferedReader.readLine().replaceAll("\\s+$", "").split(" "))
                            .map(Integer::parseInt)
                            .collect(toList())
                    );
                } catch (IOException ex) {
                    throw new RuntimeException(ex);
                }
            });

            String result = Result.organizingContainers(container);

            try {
                bufferedWriter.write(result);
                bufferedWriter.newLine();
            } catch (IOException ex) {
                throw new RuntimeException(ex);
            }
        } catch (IOException ex) {
            throw new RuntimeException(ex);
        }
    });

    bufferedReader.close();
    bufferedWriter.close();
}

    }

  • kami518
     + 0 comments

    I dislike this problem.

    it should give an example that container[0] doesn't have to contain only the balls labeled by 0 .

  • afzal_saiyed931
     + 0 comments
    def organizingContainers(container):
    # Write your code here
    n = len(container)
    capacity = []
    type_count = []
    for i in range(n):
        capacity.append(sum(container[i]))
        current_total = 0
        for j in range(n):
            current_total += container[j][i]
            
        type_count.append(current_total)
                  
    return "Possible" if sorted(capacity) == sorted(type_count) else "Impossible"

  • carminemangione
     + 0 comments

    This problem sucks. It has no relevance in the really real world and is so poorly stated it is more of a 'can i parse this idiots question' versus solve some algorithm. Damn I hate this site

  • yashdeora98294
     + 0 comments

    Here is problem solution in Python, Java, C++, C and Javascript - https://programmingoneonone.com/hackerrank-organizing-containers-of-balls-problem-solution.html