Solution in Java:

static long waitingTime(int[] tickets, int p) {
        long noOfIterations = 0;
        int ticketBeingProcessed = 0;
        int numberOfParticipantsInLine = tickets.length;
        if(numberOfParticipantsInLine > p)
        {
            while(tickets[p] != 0)
            {
                // The person has already got his ticket and exited the line, just go to the next person, dont increase number of iterations because it took no time
                if(tickets[ticketBeingProcessed] != 0)
                {
                    // ticket being processed got one ticket
                    tickets[ticketBeingProcessed] = tickets[ticketBeingProcessed] -1;
                    // if we have reached the end of the line
                    if(ticketBeingProcessed == numberOfParticipantsInLine -1)
                        ticketBeingProcessed = 0;
                    else
                        ticketBeingProcessed ++;
                    noOfIterations ++;
                }
                else {
                    if (ticketBeingProcessed == numberOfParticipantsInLine - 1)
                        ticketBeingProcessed = 0;
                    else
                        ticketBeingProcessed++;
                }
                Log.d("asd",printArray(tickets));
            }
        }
        return noOfIterations;
    }

      

        
        
        
      

    

For python:

def function(tickets):
    count = 0
    delta = 0
    for i in range(len(tickets)):
        if tickets[i] < tickets[p]:
            delta+=tickets[p]-tickets[i]
            if i > p:
               delta - = 1

    count = len(tickets) * (tickets[p] - 1) + (p+1) - delta

    return count

      

        
        
        
      

    

Here is the solution I came across (in Java, but anyone with a C ++ background can read this code)

import java.util.Arrays;
import java.util.List;

public class TickerPurcahseTime {
  public static int calculateTimeOptimized(List<Integer> line, int pos) {
    // Minimum time I have to wait is the number of tickets I want to buy.
    int waitingTime = line.get(pos);
    for (int i = 0; i < line.size(); i++) {
      if (i == pos) continue;
      // I will see people -> minimum(how many tickets I need, how many tickets they need).
      waitingTime += (Math.min(line.get(pos), line.get(i)));
      // Unless they were behind me, I got my ticket before them so I need to see them 1 time less.
      if (i > pos) {
        waitingTime--;
      }
    }

    return waitingTime;
  }

  public static void main(String [] args) {
    System.out.println(calculateTimeOptimized(Arrays.asList(5, 5, 2, 3), 3));
  }
}

      

        
        
        
      

    

Here's a simple C ++ solution:

#include<bits/stdc++.h>
using namespace std;
int waiting_time(int ticket[],int p,int size)
{
  int count=0;
  while(ticket[p]!=0)
  for(int i=0;i<size;i++)
  {
    if(ticket[p]!=0)
    {
      if(ticket[i]>0)
      count++;
      ticket[i]--;
    }
  }
  return count;
}
int main()
{
  int ticket[]={5, 5, 2, 3};
  int p=3;
  int size=sizeof(ticket)/sizeof(ticket[0]);
  cout<<waiting_time(ticket,p,size);
  return 0;
}

      

        
        
        
      

    

so here is my comprehensive and clear O (n) solution

# people stading before jess will be waiting for t(p) times 
# (or)
# t(i) times (if t(i) - t(p) < 0 this means they will buy less tickets than jess, 
# so they will stand only t(i) times)
#
# people standing beside jess will be waiting for t(p)-1 times
# (or)
# t(i) time (if t(i) - t(p) < 0 )
#
# sum of the above will result in the wating time for jess

def wt(tickets, p):
    sum = 0;
    for i in range(len(tickets)):
        if i<=p :
            if tickets[i]-tickets[p] >= 0 :
                sum += tickets[p];
            else :
                sum += tickets[i];
        else:
            if tickets[i]-(tickets[p]-1) >= 0 :
                sum += tickets[p]-1;
            else:
                sum += tickets[i];
    print(sum);

      

        
        
        
      

    

test cases:

wt([5,5,2,3], 3)

wt([5,5,2,3], 0)

wt([5,5,2,3], 1)

wt([5,5,2,3], 2)

wt([1,1,1,1], 0)

wt([2,6,3,4,5], 2)

wt([2,6,3,4,5], 0)

wt([2,6,3,4,5], 1)

wt([2,6,3,4,5], 3)

wt([2,6,3,4,5], 4)

      

        
        
        
      

    

outputs:

11

14

15

7

1

12

6

20

16

19

      

        
        
        
      

    

Here is a simple solution using ruby

    def waiting_line(tickets, p)
      user_tickets = tickets[p]
      time = 0
      while user_tickets > 0
        for i in (0...tickets.length)
          break if tickets[p] == 0
          next if (tickets[i] == 0) 
          time +=1 
          tickets[i] -= 1
        end
        user_tickets -=1
      end
      time
    end