1class Solution {
2
3    public int minOperationsMaxProfit(int[] customers, int boardingCost, int runningCost) {
4        // Initialize variables to store:
5        // 'maxProfit': the current maximum profit seen (initialized to 0).
6        // 'totalOperations': the total number of operations to achieve the 'maxProfit'.
7        // 'waitingCustomers': the number of customers waiting to board.
8        // 'currentRotation': the current rotation/round of the gondola.
9        int maxProfit = 0;
10        int totalOperations = -1; // Begins at -1 to handle cases when no profit can be made.
11        int waitingCustomers = 0;
12        int currentRotation = 0;
13
14        // Loop through all the customers or until there are no more waiting customers.
15        while (waitingCustomers > 0 || currentRotation < customers.length) {
16            // Add the customers arriving in the current rotation to 'waitingCustomers'.
17            if (currentRotation < customers.length) {
18                waitingCustomers += customers[currentRotation];
19            }
20          
21            // Calculate the number of people to board in this rotation. 
22            // It should not exceed 4, which is the gondola's capacity.
23            int boardingCustomers = Math.min(4, waitingCustomers);
24
25            // Decrease the count of 'waitingCustomers' by the number of people who just boarded.
26            waitingCustomers -= boardingCustomers;
27
28            // Move to the next rotation.
29            currentRotation++;
30
31            // Calculate the total profit after this rotation.
32            int profitThisRotation = boardingCustomers * boardingCost - runningCost;
33
34            // Add the profit from this rotation to the total profit.
35            maxProfit += profitThisRotation;
36
37            // Check if the total profit we just calculated is greater than the previously recorded maximum profit.
38            // If it is, update the 'maxProfit' and 'totalOperations'.
39            if (maxProfit > 0 && maxProfit > maxProfit) {
40                maxProfit = maxProfit;
41                totalOperations = currentRotation;
42            }
43        }
44
45        // Return the total number of operations needed to reach maximum profit.
46        // If a profit cannot be made, 'totalOperations' would be -1.
47        return totalOperations;
48    }
49}
50

1#include <vector> // Include necessary library for vector usage
2#include <algorithm> // Include necessary library for using min function
3
4class Solution {
5public:
6    int minOperationsMaxProfit(std::vector<int>& customers, int boardingCost, int runningCost) {
7        int maxProfit = -1; // Initialize variable to store the maximum profit index
8        int currentProfit = 0; // Current profit initialized to zero
9        int totalWaitingCustomers = 0; // Counter for customers waiting
10        int rotations = 0; // Counter for the number of rotations
11        int currentlyBoarded; // Customers that can board the ride on current rotation
12
13        // Loop until we've processed all customers or until there are no more waiting customers
14        while (totalWaitingCustomers > 0 || rotations < customers.size()) {
15            // Add customers from the current rotation if it exists
16            if (rotations < customers.size()) {
17                totalWaitingCustomers += customers[rotations];
18            }
19
20            // Board up to 4 customers or the number of waiting customers, whichever is lower
21            currentlyBoarded = std::min(4, totalWaitingCustomers);
22            // Subtract the boarded customers from the waiting queue
23            totalWaitingCustomers -= currentlyBoarded;
24            // Move to the next rotation
25            rotations++;
26
27            // Update the current profit by adding profit from boarding customers and subtracting the running cost
28            currentProfit += currentlyBoarded * boardingCost - runningCost;
29
30            // If the current profit is greater than the max profit, update maxProfit and store the current rotation
31            if (currentProfit > maxProfit) {
32                maxProfit = currentProfit;
33                maxProfit = rotations; // Store the most profitable rotation
34            }
35        }
36      
37        // If maxProfit remains -1, it means that running the ride was never profitable; otherwise, return the number of rotations
38        return (maxProfit > 0 ? maxProfit : -1);
39    }
40};
41

1import { min } from "lodash"; // Assuming lodash is used for the `min` function, otherwise native Math.min can be used.
2
3// This variable holds the maximum profit calculated, initialized with -1 indicating no profit has been made.
4let maxProfit: number = -1;
5
6// Function to calculate number of operations needed to reach maximum profit from the given boarding and running costs.
7// Takes in an array of customers, boarding cost per person, and running cost per ride.
8function minOperationsMaxProfit(customers: number[], boardingCost: number, runningCost: number): number {
9    // Stores the current profit made, initialized to 0.
10    let currentProfit: number = 0;
11    // Counts the total number of customers waiting in line.
12    let totalWaitingCustomers: number = 0;
13    // Counts how many rotations the ride has been through.
14    let rotations: number = 0;
15    // Number of customers that can board the ride in the current rotation.
16    let currentlyBoarded: number;
17
18    // Continue looping until all customers are processed or there are no more waiting customers.
19    while (totalWaitingCustomers > 0 || rotations < customers.length) {
20        // If there are remaining rotations, add customers to the waiting total.
21        if (rotations < customers.length) {
22            totalWaitingCustomers += customers[rotations];
23        }
24
25        // Board the number of customers that is the lesser of available seats (4) or waiting customers.
26        currentlyBoarded = min([4, totalWaitingCustomers])!;
27        // Reduce the number of total waiting customers by the amount that just boarded the ride.
28        totalWaitingCustomers -= currentlyBoarded;
29        // Increment rotation count, moving to the next cycle.
30        rotations++;
31
32        // Update the running total of current profit by adding profit from customers times the boarding
33        // cost and subtracting the cost of running the ride.
34        currentProfit += currentlyBoarded * boardingCost - runningCost;
35
36        // If current profit is greater than what's recorded in maxProfit, update maxProfit to 
37        // the newest profit and set the count of rotations at which max profit occurred.
38        if (currentProfit > maxProfit) {
39            maxProfit = currentProfit; // Update the max profit to the new profit.
40            maxProfit = rotations; // This should actually store the rotation count, needs correction.
41        }
42    }
43  
44    // If maxProfit is still -1, it means running the ride never turned profitable.
45    // Otherwise, return the optimized number of rotations to reach max profit.
46    return (maxProfit > 0 ? maxProfit : -1);
47}
48