Black Friday
It’s black friday and the supermarket near Ninja’s house is offering a special discount to every Nth customer that generates a bill. You are initially given 2 arrays, “PRODUCTS” and “PRICES” where “PRODUCTS[i]” represents the ID of the ith product and “PRICES[i]” represents the price of the ith product per unit. You are also given an integer “DISCOUNT” which represents the discount percentage for every nth customer (i.e. the effective amount to be paid would be ‘(100 - discount) / (100 * amount’).

For each customer that visits the store, you are given 2 arrays, “PRODUCTID” and “QUANTITY” where “PRODUCTID[i]” represents the ID of the ith product and “QUANTITY[i]” represents the quantity of the ith product purchased by the customer.

Your task is to implement the following 2 functions:

1. blackFriday(int N, int discount, int[] products, int[] prices) where every Nth customer receives a discount, “discount” is the discount percentage, “products” contains the product IDs, and “prices” contains the prices of products. 2. generateBill(int[] productID, int[] quantity) where “productID” contains the product IDs and “quantity” contains the quantities of products purchased by the customer.

Input Format

The first line of input contains an integer ‘T’ denoting the number of test cases to run. Then the test case follows. The first line contains three space-separated integers ‘N’, “discount” and ‘S’ denoting the customer’s getting a discount, discount percentage and number of products. The next line contains ‘S’ space-separated integers denoting the array “products”. The next line contains ‘S’ space-separated integers denoting the array “prices”. The next line of each test case contains an integer ‘K’ denoting the number of queries. For the next K queries: The first line contains an integer ‘S’ denoting the number of distinct products purchased. The next line contains ‘S’ space-separated integers denoting the array “productID”. The next line contains ‘S’ space-separated integers denoting the array “quantity”.

Output Format :

For each test case, return a list containing the bill amount for each customer after discount(if applicable) in the order they generated the bill. Output for each test case will be printed in a new line.

Note:

Print the result till 5 decimal places

Note:

You do not need to print anything; it has already been taken care of. Just implement the given functions.

Constraints:

1

Question

Black Friday

It’s black friday and the supermarket near Ninja’s house is offering a special discount to every Nth customer that generates a bill. You are initially given 2 arrays, “PRODUCTS” and “PRICES” where “PRODUCTS[i]” represents the ID of the ith product and “PRICES[i]” represents the price of the ith product per unit. You are also given an integer “DISCOUNT” which represents the discount percentage for every nth customer (i.e. the effective amount to be paid would be ‘(100 - discount) / (100 * amount’).

For each customer that visits the store, you are given 2 arrays, “PRODUCTID” and “QUANTITY” where “PRODUCTID[i]” represents the ID of the ith product and “QUANTITY[i]” represents the quantity of the ith product purchased by the customer.

Your task is to implement the following 2 functions:

1. blackFriday(int N, int discount, int[] products, int[] prices) where every Nth customer receives a discount, “discount” is the discount percentage, “products” contains the product IDs, and “prices” contains the prices of products.

2. generateBill(int[] productID, int[] quantity) where “productID” contains the product IDs and “quantity” contains the quantities of products purchased by the customer.

Input Format

The first line of input contains an integer ‘T’ denoting the number of test cases to run. Then the test case follows.

The first line contains three space-separated integers ‘N’, “discount” and ‘S’ denoting the customer’s getting a discount, discount percentage and number of products.

The next line contains ‘S’ space-separated integers denoting the array “products”.

The next line contains ‘S’ space-separated integers denoting the array “prices”.

The next line of each test case contains an integer ‘K’ denoting the number of queries.

For the next K  queries:
The first line contains an integer ‘S’ denoting the number of distinct products purchased.
The next line contains ‘S’ space-separated integers denoting the array “productID”.
The next line contains ‘S’ space-separated integers denoting the array “quantity”.

Output Format :

For each test case, return a list containing the bill amount for each customer after discount(if applicable) in the order they generated the bill.

Output for each test case will be printed in a new line.

Note:

Print the result till 5 decimal places

Note:

You do not need to print anything; it has already been taken care of. Just implement the given functions.

Constraints:

1 <= T <= 100
1 <= K <= 1000
1 <= S <= 100
1 <= productID[i], products[i], quantity[i], prices[i] <= 1000

Where ‘T’ denotes the number of test cases,
‘K’ denotes the number of queries and
‘S’ denotes the number of products

Time Limit: 1sec

Accepted Answer

Counting Number of Previous Customers

We can simply start by creating a hashmap that stores each product ID and corresponding price. For each customer, calculating the bill amount is simple, just multiply the quantity by the price of each product they purchased.

We also keep a count of previous customers and increase it as soon as generateBill is called. If this count is divisible by ‘N’, we simply apply the discount and return the bill amount.

Algorithm:

Create a hashmap “productPrice” which maps each product ID to its price.
Store the number of previous customers in a variable “customerCount” and initialize it with 0.
Each time “generateBill” is called, increase “customerCount”.
Calculate the bill by iterating “productID” and “quantity” array using the expression: billAmount = Σ(productID[i] * quantity[i]) for i ranging from 0 to length of productID array.
If “customerCount” is divisible by ‘N’, reduce “billAmount” by “discount” percent.
Return “billAmount”.

Space Complexity: OtherExplanation:

O(S), where ‘S’ denotes the number of distinct products.

Since we are using a hashmap of size ‘S’ to store our prices, the overall space complexity is O(S).

Time Complexity: OtherExplanation:

O(K * S), where ‘K’ denotes the number of queries and ‘S’ denotes the number of distinct products.

Note that in each query, we iterate through each product at most once in each query

Therefore time complexity for each of the ‘K’ queries is at most O(S), the total time complexity is O(K * S).

Python (3.5)

'''

    Time Complexity : O(K * S)

    Space Complexity : O(S)



    where ‘K’ denotes the number of queries and

    ‘S’ denotes the number of distinct products.

'''



from collections import defaultdict



class blackFriday:



    def __init__(self):



        # Create a hashmap to map productID's to their price.

        self.productPrice = defaultdict(int)

        self.customerCount = 0

        self.n = 0

        self.discount = 0

        

    def blackFriday(self, N, discount, products, prices):

        self.n = N

        self.discount = discount



        # Initialize the count of customers to zero.

        self.customerCount = 0

        

        for i in range (len(products)):

            self.productPrice[products[i]] = prices[i]

    

    def generateBill(self, productID, quantity):

        

        # Increase count of customers that visited.

        self.customerCount += 1

        

        billAmount = 0

        

        # Calculate bill.

        for i in range (len(productID)):

            billAmount += quantity[i] * self.productPrice[productID[i]]

            

        # Check if the customer gets a discount.

        if self.customerCount % self.n == 0:

            billAmount -= billAmount * self.discount / 100

            

        return billAmount

Java (SE 1.8)

/*

    Time Complexity : O(K * S)

    Space Complexity : O(S)



    where "K" denotes the number of queries and

    "S" denotes the number of distinct products.

*/



import java.util.HashMap;



public class blackFriday{

    

	// Create a hashmap to map productID's to their price.

	HashMap productPrice = new HashMap();



    // Create variables to count number of previous customers.

    int customerCount, n, discount;

    

	blackFriday(int N, int discount, int[] products, int[] prices){

		this.n = N;

        this.discount = discount;



        // Initialize the count of customers to zero.

        customerCount = 0;



        // Map each productID with their price.

        for (int i = 0; i < products.length; i++){

        	productPrice.put(products[i],prices[i]);

        }

	}

	

    double generateBill(int[] productID, int[] quantity){



        // Increase count of customers that visited.

        customerCount = customerCount + 1;



        // Initialize bill amount with zero.

        double billAmount = 0;



        // Calculate bill amount.

        for (int i = 0; i < productID.length; i++){

            billAmount = billAmount + quantity[i] * productPrice.get(productID[i]);

        }



        // Check if customer gets a discount.

        if (customerCount % n == 0){

            billAmount = billAmount - billAmount * discount / 100;

        }



        // Return the bill amount.

        return billAmount;

	}

}

C++ (g++ 5.4)

/*

    Time Complexity : O(K * S)

    Space Complexity : O(S)



    where ‘K’ denotes the number of queries and

    ‘S’ denotes the number of distinct products.

*/



class  blackFriday

{

public:



    // Create a hashmap to map productID's to their price.

    unordered_map productPrice;



    // Create variables to count number of previous customers.

    int customerCount, n, discount;



    blackFriday(int N, int discount, vector &products, vector &prices)

    {

        this -> n = N;

        this -> discount = discount;



        // Initialize the count of customers to zero.

        customerCount = 0;



        // Map each productID with their price.

        for (int i = 0; i < products.size(); i++)

        {

            productPrice[products[i]] = prices[i];

        }

    }



    double generateBill(vector &productID, vector &quantity)

    {



        // Increase count of customers that visited.

        customerCount = customerCount + 1;



        // Initialize bill amount with zero.

        double billAmount = 0;



        // Calculate bill amount.

        for (int i = 0; i < productID.size(); i++)

        {

            billAmount = billAmount + quantity[i] * productPrice[productID[i]];

        }



        // Check if customer gets a discount.

        if (customerCount % n == 0)

        {

            billAmount = billAmount - billAmount * discount / 100;

        }



        // Return the bill amount.

        return billAmount;

    }

};

For each customer that visits the store, you are given 2 arrays, “PRODUCTID” and “QUANTITY” where “PRODUCTID[i]” represents the ID of the ith product and “QUANTITY[i]” represents the quantity of the ith product purchased by the customer.

Your task is to implement the following 2 functions:

Input Format

Output Format :

Note:

Note:

Constraints:

Top Cognizant Trainee Analyst interview questions & answers

Popular interview questions of Trainee Analyst