Merge pull request #2 from ProgSoc/notminhkhanh/time-traveler-trading-company

Merge Time-Traveler Trading Question from Minh Khanh

Author: TianLangHin

competition/time-traveler/.gitignore

@@ -0,0 +1 @@
+.vscode/

competition/time-traveler/prob.md

@@ -0,0 +1,69 @@
+---toml
+[fuzz]
+exec = ["g++", "--std=c++20", "src/main.cpp", "-o", "time-traveler", "&&", "./time-traveler", "generate"]
+env = {}
+
+[judge]
+exec = ["./time-traveler", "verify"]
+
+[problem]
+points = 15
+difficulty = 2
+---
+
+# ⏰ Time Traveler's Trading Company
+
+Congratulations, you've built a working time machine. You have so many ideas in changing the past for the betterment of our world. But messing with the past can be dangerous, especially for those you care about. So instead of altering major events, you decide to do something subtle: hacking the stock market.
+
+You have gathered the stock prices for `N` days and need to calculate the maximum profit you can achieve without jeopardizing the space-time continuum.
+
+To avoid raising suspicions from ASIC or impacting the market significantly, you set strict rules for yourself:
+- You start with an unlimited amount of capital borrowed from the bank, and own `0` share at the start of day `1`
+- You can only sell a share when you own at least `1` of them
+- Each day you will either buy one share, sell one share, or do nothing (at most 1 action per day)
+- At the end of day `N`, your position needs to be `0` to avoid risk exposure
+
+## Input
+
+- The first line contains `T` - the number of testcases
+- For the next `T` pairs of lines (each representing a seperate testcase):
+	- The  first line contains an integer `N` - the number of days
+	- The  second line contains `N` integers `price[1], price[2], ..., price[n]` - the stock prices for the next `N` days, seperated by space.
+
+## Output
+
+Output `T` lines of number, each contains a single integer representing the maximum profit you can make for each test case.
+
+## Constraints
+
+- `2 <= N <= 3 * 10^5`
+- `1 <= price[i] <= 10^6`
+- The sum of `N` over all test cases will not exceed `3*10^5`
+
+## Example
+
+#### Input
+
+```
+1
+9  
+10 5 4 7 9 12 6 2 10
+```
+
+#### Output
+
+```
+20
+```
+
+#### Explanation
+
+To get the maximum profit, we will make these transactions:
+- Buy a share at day `2` at price `5`
+- Buy a share at day `3` at price `4`
+- Sell a share at day `5` at price `9`
+- Sell a share at day `6` at price `12`
+- Buy a share at day `8` at price `2`
+- Sell a share at day `9` at price `10`
+
+The total profit is `0 - 5 - 4 + 9 + 12 - 2 + 10 = 20`

competition/time-traveler/src/main.cpp

@@ -0,0 +1,188 @@
+#include <iostream>
+#include <vector>
+#include <queue>
+#include <cassert>
+#include <exception>
+#include <random>
+#include <algorithm>
+#include <fstream>
+#include <utility>
+#include <unordered_map>
+#include <string>
+#include <sstream>
+
+constexpr int NUM_TESTCASES = 10;
+
+using namespace std::string_literals;
+
+long long dynamicProgramming(const std::vector<long long>& prices){
+    int n = prices.size();
+    int m = n / 2; // Maximum Long Position
+    const long long INF = 1e15; // A large value to represent infinity
+
+    std::vector<std::vector<long long>> dp(n + 1, std::vector<long long>(m + 1, -INF));
+    // dp[i][j] represents the maximum profit by the end of day i with j long positions held (i is 1-indexed)
+
+    dp[0][0] = 0; // On day 0, no profit and no positions held
+
+    for (int i = 1; i <= n; ++i){
+        for (int j = 0; j <= m; ++j){
+            dp[i][j] = dp[i - 1][j]; // do nothing on day i
+            if (j > 0){
+                // Buy on day i
+                dp[i][j] = std::max(dp[i][j], dp[i - 1][j - 1] - prices[i - 1]);
+            }
+            if (j < m && i > 1){
+                // Sell on day i
+                dp[i][j] = std::max(dp[i][j], dp[i - 1][j + 1] + prices[i - 1]);
+            }
+        }
+    }
+
+    return dp[n][0]; // Return the maximum profit with no risk exposure
+}
+
+long long regretableGreedy(const std::vector<long long>& prices){
+    std::priority_queue<long long, std::vector<long long>, std::greater<long long>> minHeap;
+    long long profit = 0;
+
+    for (auto price : prices){
+        if (!minHeap.empty() && price > minHeap.top()){
+            profit += price - minHeap.top(); // Sell at current price, buy at minimum price seen so far
+            minHeap.pop(); // Remove the minimum price from the heap
+            minHeap.push(price); // Add extra option to allow us to regret this decision
+        }
+        minHeap.push(price); // Add current price to the heap
+    }
+
+    return profit;
+}
+
+std::vector<int> splitTestcaseSizes(int tc, std::mt19937& rng){
+    std::vector<int> sizes;
+
+    std::uniform_int_distribution<int> cutDistribution(0, 300000 - tc);
+
+    std::vector<int> cuts;
+    cuts.push_back(0);
+    cuts.push_back(300000 - tc);
+
+    for (int i = 1 ; i < tc ; ++i){
+        cuts.push_back(cutDistribution(rng));
+    }
+
+    std::sort(cuts.begin(), cuts.end());
+
+    for (int i = 1 ; i < cuts.size() ; ++i){
+        sizes.push_back(cuts[i] - cuts[i - 1] + 1);
+    }
+
+    assert(sizes.size() == tc);
+    assert(std::accumulate(sizes.begin(), sizes.end(), 0) == 300000);
+
+    return sizes;
+}
+
+// The testcases are generates in pairs of prompt (input) as a string
+// and the solutions, which is a list of long long integers.
+std::pair<std::string, std::vector<long long>> generateTestcases(std::mt19937& rng){
+    auto sizes = splitTestcaseSizes(NUM_TESTCASES, rng);
+
+    std::stringstream input;
+    std::vector<long long> expectedOutput;
+
+    input << NUM_TESTCASES << "\n";
+
+    std::uniform_int_distribution<long long> priceDistribution(1, 1'000'000);
+
+    bool sortedTestcase = false;
+
+    for (auto size : sizes){
+        input << size << "\n";
+        std::vector<long long> prices(size);
+        for (int i = 0; i < size; ++i){
+            prices[i] = priceDistribution(rng);
+        }
+
+        if (!sortedTestcase){
+            std::sort(prices.begin(), prices.end());
+            sortedTestcase = true;
+        }
+
+        for (const auto& price : prices){
+            input << price << " ";
+        }
+        input << "\n";
+
+        long long greedyResult = regretableGreedy(prices);
+        if (size <= 10000){
+            assert(greedyResult == dynamicProgramming(prices) && "Verifier's Greedy solution failed!");
+        }
+
+        expectedOutput.push_back(greedyResult);
+    }
+
+    return { input.str(), expectedOutput };
+}
+
+int main(int argc, char* argv[]){
+    /*
+    Usage:
+    - For `fuzz`-ing: `./time-traveler generate <seed>` will print prompt to std::cout.
+    - For `judge`-ing: `./time-traveler verify <seed>` will read lines from std::cin.
+    - For extra solution validation, you can also use `./time-traveler solution <seed>`.
+    */
+
+    // A string is given as a seed, which is passed to the hasher.
+    // The RNG is then initialised based on this seed, and is thus
+    // passed as references to each of the methods rather than being a global variable.
+    std::hash<std::string> hasher;
+    std::mt19937 rng(hasher(argv[2]));
+
+    auto [prompt, answers] = generateTestcases(rng);
+
+    if (argv[1] == "generate"s){
+        std::cout << prompt;
+        return 0;
+    }
+    else if (argv[1] == "verify"s){
+        // To retrieve submitted answers, query each line one by one until no more lines are found.
+        std::vector<long long> submittedAnswers;
+
+        std::string line;
+        std::getline(std::cin, line);
+        for (int i = 0; !line.empty(); ++i, std::getline(std::cin, line)){
+            try {
+                submittedAnswers.push_back(std::stoll(line));
+            } catch (const std::invalid_argument& error){
+                std::cerr << "Line " << (i + 1) << " of your answer is not a valid integer.\n";
+                return 1;
+            } catch (const std::out_of_range& error){
+                std::cerr << "Line " << (i + 1) << " contains an invalid 64-bit integer.\n";
+                return 1;
+            }
+        }
+
+        // Compare the submitted answers with the expected answers.
+        if (submittedAnswers == answers){
+            return 0;
+        }
+        else if (submittedAnswers.size() != answers.size()){
+            std::cerr << "Wrong solution format: there should be " << NUM_TESTCASES << " lines.\n";
+            return 1;
+        }
+        else{
+            std::cerr << "Wrong answer\n";
+            return 1;
+        }
+    }
+    else if (argv[1] == "solution"s){
+        for (long long answer : answers){
+            std::cout << answer << "\n";
+        }
+        return 0;
+    }
+    else{
+        return 1;
+    }
+}