add: 220415-CN [cpp]

cpp/2204/220415-CN.cpp

@@ -0,0 +1,135 @@
+#include <vector>
+#include <string>
+
+// This is the interface that allows for creating nested lists.
+// You should not implement it, or speculate about its implementation
+class NestedInteger {
+private:
+	std::vector<NestedInteger> content;
+
+	int x = 0x7FFFFFFF;
+
+public:
+	// Constructor initializes an empty nested list.
+	explicit NestedInteger();
+
+	// Constructor initializes a single integer.
+	explicit NestedInteger(int value);
+
+	// Return true if this NestedInteger holds a single integer, rather than a nested list.
+	bool isInteger() const;
+
+	// Return the single integer that this NestedInteger holds, if it holds a single integer
+	// The result is undefined if this NestedInteger holds a nested list
+	int getInteger() const;
+
+	// Set this NestedInteger to hold a single integer.
+	void setInteger(int value);
+
+	// Set this NestedInteger to hold a nested list and adds a nested integer to it.
+	void add(const NestedInteger& ni);
+
+	// Return the nested list that this NestedInteger holds, if it holds a nested list
+	// The result is undefined if this NestedInteger holds a single integer
+	const std::vector<NestedInteger>& getList() const;
+};
+
+/**
+ * 385. Mini Parser
+ * Given a string s represents the serialization of a nested list, implement a parser to deserialize it and return the deserialized NestedInteger.
+ * Each element is either an integer or a list whose elements may also be integers or other lists.
+ */
+
+class Solution {
+private:
+	static std::vector<std::string> spiltPreservingStructure(const std::string& str, char ch = ',') {
+		std::vector<std::string> ret;
+		int n = str.length(), prevPos = 0;
+		const char* s = str.c_str();
+
+		auto tryPush = [&](int x, int y) {
+			auto nx = std::string(s + x, s + y);
+			if (!nx.empty())
+				ret.push_back(std::move(nx));
+		};
+
+		for (int i = 0; i < n; ++i) {
+			if (s[i] == ch) {
+				tryPush(prevPos, i);
+				prevPos = 1 + i;
+			}
+			if (s[i] != '[')
+				continue;
+
+			// s[i] == '['
+			for (int stack = 1, dummy = ++i; stack; ++i) {
+				if (s[i] == '[')
+					++stack;
+				else if (s[i] == ']')
+					--stack;
+			}
+			--i;
+		}
+		tryPush(prevPos, n);
+		return ret;
+	}
+
+public:
+	static NestedInteger deserialize(const std::string& s) {
+		// Detect whole number?
+		if (std::all_of(s.begin() + 1, s.end(), [](char ch){ return std::isdigit(ch); }) && (s.front() == '-' || std::isdigit(s.front())))
+			return NestedInteger(std::stoi(s));
+
+		// Strip surrounding []
+		auto ss = s.substr(1);
+		ss.pop_back();
+		auto sss = spiltPreservingStructure(ss);
+		NestedInteger ret;
+		for (const auto& ssss : sss) {
+			ret.add(deserialize(ssss));
+		}
+		return ret;
+	}
+
+	static auto debug(const std::string& s) {
+		return spiltPreservingStructure(s);
+	}
+};
+
+int main() {
+	// auto ans = Solution::deserialize("324");
+	auto ret = Solution::debug("123,[456,[789]],1212,[123]");
+	return 0;
+}
+
+NestedInteger::NestedInteger() = default;
+
+NestedInteger::NestedInteger(int value) : x(value) {}
+
+bool NestedInteger::isInteger() const {
+	return x < 0x7FFFFFFE;
+}
+
+int NestedInteger::getInteger() const {
+	return x;
+}
+
+void NestedInteger::setInteger(int value) {
+	x = value;
+	content.clear();
+}
+
+void NestedInteger::add(const NestedInteger& ni) {
+	if (!this->isInteger()) {
+		content.push_back(ni);
+		return;
+	}
+	content.clear();
+	content.emplace_back(x);
+	content.push_back(ni);
+	x = 0x7FFFFFFF;
+}
+
+const std::vector<NestedInteger>& NestedInteger::getList() const {
+	return content;
+}

cpp/2204/CMakeLists.txt

@@ -3,4 +3,4 @@ PROJECT(2204)
 
 SET(CMAKE_CXX_STANDARD 23)
 
-ADD_EXECUTABLE(2204 220413.cpp)
+ADD_EXECUTABLE(2204 220415-CN.cpp)