哔哩哔哩第二次笔试 第三题key-value分割

#include <iostream>
#include<string>
#include<vector>
#include<stack>
using namespace std;

class KeyValue{
public: 		
    string key;
    string value;
        
    KeyValue(string key,string value);
};

KeyValue::KeyValue(string key,string value){
	this->key=key;
	this->value=value;
}

void clearStack(stack<char>* stack){
	while(!stack->empty()){
		stack->pop();
	}
}

string getString(stack<char> stack){
    int keySize=stack.size();
    char keyChars[keySize];
    int index=keySize-1;
    while (!stack.empty()){
        keyChars[index]=stack.top();
        stack.pop();
        index--;
    }
    clearStack(&stack);
    string s(keyChars,keySize);
    return s;
}
    
    


vector<KeyValue> solution(string str){
    vector<KeyValue> result;
    stack<char> key;
    stack<char> value;
    bool flag=false;
    for(int i=0;i<str.size();i++){
        char current=str[i];
        if(current==' '){
            continue;
        }
        if(current==':'){
            if(key.empty()){
                flag=false;
                continue;
            }
            else{
                // 修改当前操作符
                flag=true;
            }
            continue;
        }
        else if(current=='#'){
            if(key.empty()&&value.empty()){
                continue;
            }
            if(!key.empty()&&!value.empty()){
                string keyString=getString(key);
                string valueString=getString(value);
                KeyValue keyValue(keyString,valueString);
                result.push_back(keyValue);
            }
            if(!key.empty()) {
                clearStack(&key);
            }
            if(!value.empty()) {
                clearStack(&value);
            }
            flag=false;
            continue;
        }

        if(flag){
            value.push(current);
        }
        else{
            key.push(current);
        }


    }

    if(!key.empty()&&!value.empty()){
        string keyString=getString(key);
        string valueString=getString(value);
        KeyValue keyValue(keyString,valueString);
        result.push_back(keyValue);
    }
    return result;
}
    
    
int main() {
    string a;
    while(cin >> a ){
    	vector<KeyValue> result=solution(a);
    	cout<<result.size()<<endl;
    	for(auto it=result.begin();it != result.end();++it){
			cout<<it->key<<" "<<it->value<<endl;
		}
	}        
}

package bilibili;

import java.util.List;
import java.util.ArrayList;
import java.util.Scanner;
import java.util.Stack;

public class Third {
    public static void main(String[] args){
        Scanner scanner=new Scanner(System.in);
        String str=scanner.nextLine();
        List<KeyValue> result=solution(str);
        System.out.println(result);
    }
    public static List<KeyValue> solution(String str){
        List<KeyValue> result=new ArrayList<>();
        Stack<Character> key=new Stack<>();
        Stack<Character> value=new Stack<>();
        boolean flag=false;
        for(int i=0;i<str.length();i++){
            char current=str.charAt(i);
            if(current==' '){
                continue;
            }
            if(current==':'){
                if(key.isEmpty()){
                    flag=false;
                    continue;
                }
                else{
                    // 修改当前操作符
                    flag=true;
                }
                continue;
            }
            else if(current=='#'){
                if(key.isEmpty()&&value.isEmpty()){
                    continue;
                }
                if(!key.isEmpty()&&!value.isEmpty()){
                    System.out.println(key);
                    System.out.println(value);
                    String keyString=getString(key);
                    String valueString=getString(value);
                    KeyValue keyValue=new KeyValue(keyString.trim(),valueString.trim());
                    result.add(keyValue);
                }
                if(!key.isEmpty()) {
                    key.clear();
                }
                if(!value.isEmpty()) {
                    value.clear();
                }
                flag=false;
                continue;
            }

            if(flag){
                value.push(current);
            }
            else{
                key.push(current);
            }


        }

        if(!key.isEmpty()&&!value.isEmpty()){
            String keyString=getString(key);
            String valueString=getString(value);
            KeyValue keyValue=new KeyValue(keyString.trim(),valueString.trim());
            result.add(keyValue);
        }
        return result;
    }

    public static String getString(Stack<Character> stack){
        int keySize=stack.size();
        char[] keyChars=new char[keySize];
        int index=keySize-1;
        while (!stack.isEmpty()){
            keyChars[index--]=stack.pop();
        }
        return String.valueOf(keyChars);
    }

    static class KeyValue{
        String key;
        String value;
        public KeyValue(String key,String value){
            this.key=key;
            this.value=value;
        }

        public String toString(){
            StringBuilder strb=new StringBuilder();
            strb.append(key);
            strb.append(" ");
            strb.append(value);
            return strb.toString();
        }
    }
}