https://leetcode.cn/problems/print-foobar-alternately

Author: masx200

README.md

@@ -2584,4 +2584,6 @@ https://leetcode.cn/problems/ipo
 
 https://leetcode.cn/problems/print-in-order/
 
+https://leetcode.cn/problems/print-foobar-alternately
+
 </details>

print-foobar-alternately/BlockingQueue.ixx

@@ -0,0 +1,123 @@
+module;
+#include <functional>
+#include <mutex>
+#include <queue>
+export module leetcode_test.print_foobar_alternately.BlockingQueue;
+using namespace std;
+namespace leetcode_test::print_foobar_alternately {
+
+export template <class E>
+class BlockingQueue {
+
+private:
+    queue<E> _queue;
+    int capacity = INT_MAX;
+    condition_variable takeVariable, putVariable;
+    mutable mutex lock;
+
+public:
+    BlockingQueue();
+    /**
+     *
+     * @param capacity 队列允许的最大值,在put时size()大于此值时,put方法将会wait
+     */
+    BlockingQueue(int capacity);
+    /**
+     * size() == 0 时会阻塞
+     * @param e
+     * @return -1失败, 0成功
+     */
+    int take(E& e);
+    /**
+     * size >= capacity时会阻塞
+     * @param e
+     * @return
+     */
+    int put(const E& e);
+
+    bool empty() const;
+
+    unsigned int size() const;
+
+    void pop();
+
+    E back();
+
+    E front();
+};
+
+template <class E>
+BlockingQueue<E>::BlockingQueue() { }
+
+template <class E>
+BlockingQueue<E>::BlockingQueue(int capacity)
+    : capacity(capacity)
+{
+}
+
+template <class E>
+int BlockingQueue<E>::take(E& e)
+{
+    unique_lock<mutex> uniqueLock(lock);
+    while (_queue.empty()) {
+        takeVariable.wait(uniqueLock);
+    }
+    if (_queue.empty())
+        return -1;
+    e = _queue.front();
+    _queue.pop();
+    putVariable.notify_one();
+    return 0;
+}
+
+template <class E>
+int BlockingQueue<E>::put(const E& e)
+{
+    unique_lock<mutex> uniqueLock(lock);
+    while (_queue.size() >= capacity) {
+        putVariable.wait(uniqueLock);
+    }
+    if (_queue.size() >= capacity)
+        return -1;
+    _queue.push(e);
+    takeVariable.notify_one();
+    return 0;
+}
+
+template <class E>
+bool BlockingQueue<E>::empty() const
+{
+    lock_guard<mutex> lockGuard(lock);
+    return _queue.empty();
+}
+
+template <class E>
+unsigned int BlockingQueue<E>::size() const
+{
+    lock_guard<mutex> lockGuard(lock); // 利用变量作用域创建加锁,析构自动解锁
+    return _queue.size();
+}
+
+template <class E>
+void BlockingQueue<E>::pop()
+{
+    lock.lock();
+    _queue.pop();
+    lock.unlock();
+}
+
+template <class E>
+E BlockingQueue<E>::back()
+{
+    lock_guard<mutex> lockGuard(lock);
+    return _queue.back();
+}
+
+template <class E>
+E BlockingQueue<E>::front()
+{
+    lock_guard<mutex> lockGuard(lock);
+    return _queue.front();
+}
+
+} // namespace leetcode_test::print_foobar_alternately

print-foobar-alternately/index.ixx

@@ -0,0 +1,46 @@
+module;
+#include <functional>
+#include <mutex>
+#include <queue>
+export module leetcode_test.print_foobar_alternately.FooBar;
+import leetcode_test.print_foobar_alternately.BlockingQueue;
+using namespace std;
+namespace leetcode_test::print_foobar_alternately {
+class FooBar {
+private:
+    int n = 0;
+    BlockingQueue<int> fooinput;
+    BlockingQueue<int> barinput;
+
+public:
+    ~FooBar() { }
+    FooBar(int n) { this->n = n; }
+
+    void foo(function<void()> printFoo)
+    {
+
+        for (int i = 0; i < n; i++) {
+
+            int res = 0;
+            barinput.take(res);
+
+            printFoo();
+            fooinput.put(0);
+        }
+    }
+
+    void bar(function<void()> printBar)
+    {
+
+        for (int i = 0; i < n; i++) {
+
+            barinput.put(0);
+
+            int res = 0;
+            fooinput.take(res);
+
+            printBar();
+        }
+    }
+};
+}

split-a-circular-linked-list/test.cpp

@@ -17,31 +17,28 @@ using namespace leetcode_test::split_a_circular_linked_list;
 using namespace std;
 using std::vector;
 template <class T>
-concept sizable = requires(T& t)
-{
+concept sizable = requires(T& t) {
     {
         t.size()
-        } -> std::same_as<size_t>;
+    } -> std::same_as<size_t>;
 };
 template <class T>
-concept iterable = requires(T& t)
-{
+concept iterable = requires(T& t) {
     ++t.begin();
     {
         t.begin() != t.end()
 
-        } -> std::same_as<bool>;
+    } -> std::same_as<bool>;
 };
 
 template <class T, typename Y>
-concept equalable = requires(T& t, Y& y, size_t i)
-{
+concept equalable = requires(T& t, Y& y, size_t i) {
     {
         *t.begin() == *y.begin()
-        } -> std::same_as<bool>;
+    } -> std::same_as<bool>;
 };
 template <typename T, typename Y>
-requires sizable<T> and sizable<Y> and equalable<T, Y> and iterable<T> and iterable<Y>
+    requires sizable<T> and sizable<Y> and equalable<T, Y> and iterable<T> and iterable<Y>
 auto assertContentEquals(T& left, Y& right)
 {