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

|

620 Discussions

|

  • pjt727
     + 0 comments
    def organizingContainers(container) -> str:
    '''returns Impossible | Possible for whether the balls can be split'''
    # this problem is very easy with two containers
    # the count of balls in one container must be equal to the counts of one type
    
    # this logic can be extended to the fact that for every count of a ball type there needs to be a container that fits it
    # in other words the sum of the columns must be equal to the sum of some other row (and that row cannot already be filled with a different ball type)
    
    # if you are wondering why zip(*container) gives a list of a ball type's count in each container here is the breakdown
    # container = [
    #      [1,4],
    #      [2,3],
    # ]
    # the * operator unpacks the container matrix 
    # zip(*container) = zip([1,4], [2,3])
    #
    # zip then joins equal indices together
    # list(zip(*container)) = [(1,2), (4,3)]
    sums_of_balls = [sum(b) for b in zip(*container)]
    sums_of_containers = [sum(c) for c in container]
    sums_of_balls.sort()
    sums_of_containers.sort()
    return "Possible" if sums_of_balls == sums_of_containers else "Impossible"

  • 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