参数与艺术

模拟

line = input()
prefix = []      # 路径前缀
prevDepth = 0
while line != "#":
    lstripLine = line.lstrip()
    depth = (len(line) - len(lstripLine)) >> 1
    if depth == 0:
        prefix.clear()      # 前面没有空格，当前是第0层目录，重新开启前缀
    elif depth <= prevDepth:
        d = depth
        while d <= prevDepth:
            prefix.pop()        # 当前目录不比上一条的级别低，则返回上级
            d += 1
    prevDepth = depth
    pair = lstripLine.split(":")
    prefix.append(pair[0])
    if pair[1]:
        print("/".join(prefix) + ":" + pair[1])
    line = input()
print("#")

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

pair<int, int> findThePathLevel(const string& path) {
    int spaceCount = 0, ColonPos = 0;
    for(const auto& it : path) {
        if(it == ' ') ++spaceCount;
        if(it != ':') {++ColonPos;}
        else break;
    }
    return {spaceCount, ColonPos};
}

int main() {
    string str;
    vector<string> pathVector;
    while(true) {
        getline(cin, str);    
        if(str == "#") { cout << str; break;}
        pair<int, int> res = findThePathLevel(str);
        int spaceCount = res.first / 2;
        int ColonPos = res.second;
        if(spaceCount == 0) {
            if(pathVector.size() != 0) {
                pathVector.clear();
            }
            pathVector.emplace_back(str.substr(0, ColonPos));
            if(str.size() != ColonPos+1)
                cout << str << endl;
        }
        else {
            string lastPath = pathVector[spaceCount - 1];
            //cout << "lastpath = " << lastPath << endl;
            string CurPath = lastPath + '/' + str.substr(res.first);
            if(str.size() != ColonPos + 1)
                cout << CurPath << endl;
            if(pathVector.size() < spaceCount + 1) {
                pathVector.emplace_back(lastPath + '/' + str.substr(spaceCount+1, ColonPos-res.first));
            }
            else {
                pathVector[spaceCount] = lastPath + '/' + str.substr(spaceCount+1, ColonPos-res.first);
            }
        }
    }
    return 0;
}
// 64 位输出请用 printf("%lld")

/*  利用栈记录前缀
 */
import java.util.*;
public class Main {
    public static void main(String[] args) {
        Scanner scan=new Scanner(System.in);
        List<String> ans=new ArrayList<>();
        Deque<String> stack=new LinkedList<>();
        String[] keyValue;
        String str;
        int depth=0;// 当前字符串的深度
        int stackDepth=0; // 栈的深度：记录前缀
        while(scan.hasNextLine()){
            str=scan.nextLine();
                    if(str.equals("#")){
                 ans.add("#");
                 break;
                    }
            depth=(str.length()-str.trim().length())>>1; 
            if(depth==0){
                // 深度为0时，清空栈中的内容
                stack.clear();
                keyValue=str.trim().split(":");
                stack.addLast(keyValue[0]);
                if(keyValue.length>1) {
                    ans.add(str);
                }
                stackDepth=depth;
                continue;
                
                
            }else if(depth<=stackDepth) {
                // 若当前字符串的深度小于栈深度，出栈，直到栈中元素小于当前字符串深度
                while(depth<=stackDepth) {
                    stack.pollLast();
                    stackDepth--;
                }
            }
            StringBuilder sb=new StringBuilder();
            keyValue=str.trim().split(":");
            stack.addLast("/"+keyValue[0]);
            stackDepth=depth;
            if(keyValue.length>1) {
                for(String s:stack) {
                    sb.append(s);
                }
                ans.add(sb.toString()+":"+keyValue[1]);
            }
                
        }
        for(String s:ans){
            System.out.println(s);
         }
        
    }
}

#include <bits/stdc++.h>
using namespace std;

int main(){
    string s;
    vector<string> ans;
    vector<string> path;
    while(getline(cin, s)){
        if(s == "#"){
            break;
        }
        if(s[0] == '/'){
            path.clear();
            int idx = s.find(":");
            if(idx + 1 < s.size()){
                ans.push_back(s);
            }
            string head = s.substr(0, idx) + "/";
            path.push_back(head);
        }
        else{
            int backspace = 0;
            while(s[backspace] == ' '){
                ++backspace;
            }
            while(path.size() > (backspace/2)){
                path.pop_back();
            }
            int idx = s.find(":");
            int n = s.size();
            string head = s.substr(backspace, idx-backspace) + "/";
            if(idx + 1 < n){
                string path_join;
                for(int i=0; i < backspace/2; ++i){
                    path_join += path[i];
                }
                path_join += s.substr(backspace);
                ans.push_back(path_join);
            }
            path.push_back(head);
        }
    }
    for(auto str : ans){
        cout << str << endl;
    }
    cout << "#" << endl;

    return 0;
}

import java.util.*;

public class Main{
    public static void main(String[] args){
        ArrayList<String> prefix=new ArrayList<String>();
        int stackPeek=0;
        Scanner in=new Scanner(System.in);
        int exblank=0;
        while(true){
            String thisLine=in.nextLine();
            if(thisLine.equals("#"))    break;
            for(exblank=0;thisLine.charAt(exblank)==' ';exblank++);
            while(exblank<stackPeek*2){
                stackPeek--;
                prefix.remove(stackPeek);//栈弹出;直到深度小于当前一级;
            }
            String temp=thisLine.substring(exblank,thisLine.length());
            String temps[]=temp.split(":");//前缀压入栈;
            if(stackPeek==0)
            	prefix.add(temps[0]);
            else
            	prefix.add('/'+temps[0]);
            stackPeek++;
            if(temps.length==1) {//如:后没有文件，则跳过输出部分;
            	continue;
            }
            for(String it:prefix){//输出前缀;
                System.out.print(it);
            }
            System.out.printf(":%s\n",temps[1]);
        }
        System.out.printf("#");
        return;
    }
}

let line
let answer = []  // 存储当前路径所对应的完整的相对路径
let prefix = []
while(line = readline()) {
    if (line === '#') {
        answer.push(line)
        break
    }
    if (line[0] === '/') {
        prefix = []  // 清空前边保存的路径前缀信息
        // 保存此时路径中的前缀信息 [不管当前路径下有没有选择文件，为后边服务]
        prefix.push(line.slice(0, line.indexOf(':')))
        if (line.indexOf(':') + 1 < line.length) {
            answer.push(line) //当前路径有文件，直接存储当前路径
        }
        continue
    }

    // 以空格开头的路径
    let space = 0
    while(line[space] === ' ') {
        space++ // 统计当前行的空格数量
    }
    if (prefix.length === space / 2) {
        prefix.push(prefix[space / 2 - 1] + '/' + line.slice(space, line.indexOf(':')))
    }
    let current = prefix[space / 2 - 1] + '/' + line.slice(space)
    answer.push(current)
}
for (let item of answer) {
    print(item)
}

# Here is input 
endingstr = ''
l = 0
strinput = []
while endingstr != '#':
    strinput.append(input())
    endingstr = strinput[l]
    l += 1
# strinput = ['/P1:v1','  Q1:v2', '    R1:v3','/P2:v2','/P2','#']
# print(strinput)
strnum = len(strinput)
stroutput = []

for i in range(strnum):
    strlen = len(strinput[i])
    if strinput[i][0] == '/':
        pathheader = [] #reset header
        pathheader.append( strinput[i][0:3] + '/')
        if len(strinput[i])>4:
            stroutput.append(strinput[i])
    elif strinput[i][0] == ' ':
        k = 0 #count the space
        for j in range(len(strinput[i])):
            if strinput[i][j] == ' ':
                k+=1
        # clear all spaces
        strinput[i] = strinput[i].replace(' ','')
        # get the sub header
        pathheader.append(strinput[i][0:2] + '/')
        # join the current string with header
        joinedheader = []
        for j in range(0,int(k/2)):
            joinedheader.append(pathheader[j])
        joinedpath = ''.join(joinedheader) + strinput[i]
        # print(joinedpath)
        stroutput.append(joinedpath)
    elif strinput[i][0] == '#':
        stroutput.append('#')

# now set the print loop

for i in range(len(stroutput)):
    print(stroutput[i])