Know yourself, others and the world ™️

SUPERSET

POSTERIOR

Some questionnaire

Questionnaire Completed Successfully

Thank you for completing this questionnaire. Your results have been saved.

Ready to begin?

This questionnaire contains 3 problems.

Provide Your Information

First Name:

Phone Number:

Questionnaire Completed Successfully!

Thank you for your responses. Your questionnaire has been successfully completed and submitted.

Problem 1 of 3

Note: Click and hold to view problem and solutions.

Diamond Problem

Solutions for this problem:

Diamond Problem Solution

Note: Click and hold to view problem and solutions.

Minimum Discards to Balance Inventory

Solutions for this problem:

Balancing by Sliding

Note: Click and hold to view problem and solutions.

Make Me a Pixellated Image

Solutions for this problem:

2D Array A

2D Array B

2D Array C

Diamond Problem

Requirements

Question:

How is the diamond problem solved in C++?

Diamond Problem Solution

Solution Steps

Step 1:

Using virtual inheritance.

Minimum Discards to Balance Inventory

Requirements

Return the minimum number of arrivals to be discarded so that every w-day window contains at most m occurrences of each type.

Givens

You are given two integers w and m, and an integer array arrivals, where arrivals[i] is the type of item arriving on day i (days are 1-indexed).

Items are managed according to the following rules:

Each arrival may be kept or discarded; an item may only be discarded on its arrival day.
For each day i, consider the window of days [max(1, i - w + 1), i] (the w most recent days up to day i):
- For any such window, each item type may appear at most m times among kept arrivals whose arrival day lies in that window.
- If keeping the arrival on day i would cause its type to appear more than m times in the window, that arrival must be discarded.

Example 1:

Input: arrivals = [1,2,1,3,1], w = 4, m = 2

Output: 0

Explanation:

On day 1, Item 1 arrives; the window contains no more than m occurrences of this type, so we keep it.
On day 2, Item 2 arrives; the window of days 1 - 2 is fine.
On day 3, Item 1 arrives, window [1, 2, 1] has item 1 twice, within limit.
On day 4, Item 3 arrives, window [1, 2, 1, 3] has item 1 twice, allowed.
On day 5, Item 1 arrives, window [2, 1, 3, 1] has item 1 twice, still valid.

There are no discarded items, so return 0.

Example 2:

Input: arrivals = [1,2,3,3,3,4], w = 3, m = 2

Output: 1

Explanation:

On day 1, Item 1 arrives. We keep it.
On day 2, Item 2 arrives, window [1, 2] is fine.
On day 3, Item 3 arrives, window [1, 2, 3] has item 3 once.
On day 4, Item 3 arrives, window [2, 3, 3] has item 3 twice, allowed.
On day 5, Item 3 arrives, window [3, 3, 3] has item 3 three times, exceeds limit, so the arrival must be discarded.
On day 6, Item 4 arrives, window [3, 4] is fine.

Item 3 on day 5 is discarded, and this is the minimum number of arrivals to discard, so return 1.

Constraints:

1 <= arrivals.length <= 10⁵
1 <= arrivals[i] <= 10⁵
1 <= w <= arrivals.length
1 <= m <= w

Balancing by Sliding

Solution Steps

Step 1:

First step is to translate the obtuse problem definition into something clear and crisp.

Requirement: find No of items to be discarded

Givens:

consider each items as it arrives on the day t
w is some random integer used to specify size of time window [max(0, t-w+1), t]
m is some random integer used in the constraint "No of item occurences in window" <= m

Step 2:

C++:

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273

class Logger{
    public:
        enum class LogLevel {
            INFO,
            DEBUG,
            ERROR
        };

        Logger(LogLevel level) : currentLevel(level) {}

        void log(const std::string& message, LogLevel level) {
            if (level >= currentLevel) {
                if (level == LogLevel::INFO) {
                    std::cout << "INFO: ";
                } else if (level == LogLevel::DEBUG) {
                    std::cout << "DEBUG: ";                
                } else if (level == LogLevel::ERROR) {
                    std::cout << "ERROR: ";
                }
                std::cout << message << std::endl;
            }
        }

    private:
        LogLevel currentLevel;
};

// TYPE: Basic Sliding Window
//       Whole difficulty is translating the incredibly obtuse description.
class Solution {
public:
    int minArrivalsToDiscard(vector<int>& arrivals, int w, int m) {
        Logger logger(Logger::LogLevel::DEBUG);
        map<int,int> counter;
        int discartionCount = 0;
        unordered_set<int> discardedIndices;
        for (int t = 0; t < arrivals.size(); ++t) {
            //logger.log("Day: " + to_string(t), Logger::LogLevel::DEBUG);
            //for (const pair<int, int>& element : counter){
            //    int key = element.first;
            //    int value = element.second;
            //    logger.log("Key: " + to_string(key), Logger::LogLevel::DEBUG);
            //    logger.log("Value: " + to_string(value), Logger::LogLevel::DEBUG);
            //}
            // Sliding counter maintenance.
            int r = t;
            int l = max(0, t - w + 1);
            ++counter[arrivals[t]];
            //logger.log("Added " + to_string(arrivals[t]) + " to counter.", Logger::LogLevel::DEBUG);
            if ((r - l + 1) == w && t >= w && !discardedIndices.count(l-1)>0) {  // Tricky -- no point in removing already discarded items.              
                if (counter[arrivals[l-1]] == 1){
                    counter.erase(arrivals[l-1]);
                }
                else {
                    --counter[arrivals[l-1]];
                }
            }
            // Main constraint processing.
            int no = counter[arrivals[t]];
            if (no > m) {
                discartionCount += 1;
                discardedIndices.insert(t);
                int val = arrivals[t];
                counter[val]-=1;
                if (counter[val]==0){
                    counter.erase(val); // Tricky -- need to delete from counter as well discards.
                };
            }
            //logger.log("Discartion count: " + to_string(discartionCount), Logger::LogLevel::DEBUG);
        }
        return discartionCount;
    }
};

Make Me a Pixellated Image

Requirements

Instantiate a 2D pixellatedImage variable.

Givens

Language is C++ 11

2D Array A

Solution Steps

Step 1:

int imagePixels[9][4];

2D Array B

Solution Steps

Step 1:

int height = 9;

int width = 4;

int[height][width] imagePixel;

2D Array C

Solution Steps

Step 1:

int<int> imagePixel;

PRIOR

SUBSET

Login

Registration

Some questionnaire

Questionnaire Completed Successfully

Ready to begin?

Provide Your Information

Questionnaire Completed Successfully!

Diamond Problem

Solutions for this problem:

Minimum Discards to Balance Inventory

Solutions for this problem:

Make Me a Pixellated Image

Solutions for this problem:

Diamond Problem

Requirements

Diamond Problem Solution

Solution Steps

Minimum Discards to Balance Inventory

Requirements

Givens

Balancing by Sliding

Solution Steps

Make Me a Pixellated Image

Requirements

Givens

2D Array A

Solution Steps

2D Array B

Solution Steps

2D Array C

Solution Steps