input: def bucket_operations(grid, capacity):
      import math
      """
      Given a 2D array representing wells, where each row is a well and each '1' represents a water unit,
      and given that every well has buckets with identical capacities for extracting water:
      Determine the number of bucket operations needed to completely empty the wells.
  
      Example 1:
          Input: 
              grid : [[0,0,1,0], [0,1,0,0], [1,1,1,1]]
              bucket_capacity : 1
          Output: 6
  
      Example 2:
          Input: 
              grid : [[0,0,1,1], [0,0,0,0], [1,1,1,1], [0,1,1,1]]
              bucket_capacity : 2
          Output: 5
      
      Example 3:
          Input: 
              grid : [[0,0,0], [0,0,0]]
              bucket_capacity : 5
          Output: 0
  
      Constraints:
          * Each well (row) in the grid has the same number of columns
          * 1 <= grid.length <= 100
          * 1 <= grid[i].length <= 100
          * grid[i][j] is either 0 or 1
          * 1 <= capacity <= 10
      """
output:     total_water = 0
  
      for row in grid:
          total_water += sum(row)
      
      return math.ceil(total_water / capacity)