Question

Solve in Java and Python
public static int feedCows(int[] cows, int k)

You are a farmer with a row of cows that need feeding and an unlimited supply of food at the beginning of the row of cows. The cows are represented as an array, ​cows​, where ​cows[i]​ is the non-negative amount of cups of food that cow needs. Capacity, k, is the amount of cups of food you can hold in your bucket. You have to feed all the cows. Assume you start with a full bucket of food and at the position of the unlimited supply of food.

Return the minimum number of steps needed to feed the cows with the following constraints:

1. Each cow is 1 step apart from each other.

2. You must finish feeding cows[i-1] before moving to cows[i]. That is, you cannot

   skip cows while walking.

3. You must use all the food in your bucket. Until then, you cannot go any farther.

   That is, if you have 2 cups of food in your bucket, you must go to the next cow before returning to refill the bucket. Also, if your bucket is at 0 cups and you just finished feeding cows[i], you still need to travel to the next cow (if it exists) as the next cow may not need food i.e. cows[i] = 0.

4. The unlimited supply of food is located 1 step before the beginning of the array of cows. So if you are traveling with an empty bucket from index 2 to refill, you must travel 3 steps back to get to the supply of food.

Sample input/output​:

1. input: cows = [1, 2, 3, 4], k = 5

   output: 10
   Explanation: Start with a full bucket. Feed cows[0], bucket is at 5-1=4, steps is

   0+1=1. Feed cow[1] bucket is at 4-2=2, steps is 1+1=2. Feed cows[2] as much as is in the bucket, so bucket is at 0, steps is 2+1=3. Go back to the supply of food, REFILL and RETURN to cows[2]. So steps 3+3+3=9. cows[2] still needs 1 cup of food. After feeding cows[2], your bucket is at 5-1=4, steps is at 9. Feed cows[3], bucket is at 0, steps is at 10. All cows have been fed. Do not need to step away from the last cow.

2. input: cows = [1, 2, 3, 4, 5] k = 5 output: 21

   Explanation: Same as before after feeding the cow[4], the bucket is at 4-4=0 cups. Must step to cows[4] to see if it needs to be fed, steps is 10+1=11. You see cows[4] needs to be fed so you go back to the supply of food to REFILL your bucket and return to cows[4]. So the bucket is at 5 and steps is 11 + 5 (go to supply) + 5 (go back to cows[4]) = 21. Feed cows[4] and you are done. Return 21.

Answer 1

public class Main {

   public static void main(String[] args)
   {
       int[] cows = { 1, 2, 3, 4,5};
       System.out.println(feedCows(cows, 5));
   }

   public static int feedCows(int[] cows, int k)
   {
       int steps = 0;
       int contentInBucket = k;
       int bucketPosition = 0;
       boolean finished = false;
       for (int i = 0; i < cows.length;)
       {
           steps = steps+(i + 1) - bucketPosition;
           if (contentInBucket > cows[i])
           {
               contentInBucket = contentInBucket - cows[i];
               cows[i] = 0;
               bucketPosition = (i + 1); //index starts at 0 so we have to add 1 everywhere to i
           }
           else if (contentInBucket == cows[i])
           {
               cows[i] = contentInBucket = 0;
               bucketPosition = i+1;
               bucketPosition = i+2;   
           }
           else
           {
               cows[i] = cows[i] - contentInBucket;
               contentInBucket = 0;
               bucketPosition = (i + 1);
           }
           if(i==cows.length-1&&cows[i]==0)
           {
               finished = true;
           }
           if(cows[i]==0&&contentInBucket==0&&!finished) //current cow fed completely had to move to next cow
           {
               steps = steps+1;
           }
           if (contentInBucket == 0 && !finished)
           {
               steps = steps + bucketPosition;
               bucketPosition = 0;
               contentInBucket = k;
           }
           if(cows[i]==0) {
               i++;
           }
       }

       return steps;
   }
}