# Leetcode Longest Absolute File Path problem solution

In this Leetcode Longest Absolute File Path problem solution, you have given a string input representing the file system in the explained format, return the length of the longest absolute path to a file in the abstracted file system. If there is no file in the system, return 0.

## Problem solution in Python.

```class Solution:
def lengthLongestPath(self, input: str) -> int:
import re
if '.' not in input:
return 0
dirs=input.split('\n')
fli=[]
for i in range(len(dirs)):
if '.' in dirs[i]:
fli.append(i)
ans=[]
for i in fli:
cnt=dirs[i].count('\t')
q=re.sub('\t','',dirs[i])
cnt-=1
for j in range(i,-1,-1):
if cnt==-1:
break
if dirs[j].count('\t')==cnt:
q=re.sub('\t','',dirs[j])+'/'+q
cnt-=1
ans.append(len(q))
return max(ans)
```

## Problem solution in Java.

```public int lengthLongestPath(String input) {
int longest = 0;
String[] lines = input.split("\n");
int[] lens = new int[lines.length+1];
for(String line: lines) {
String[] subs = line.split("\t");
String cur = subs[subs.length-1];
int len = lens[subs.length-1] + cur.length() + 1;
if(cur.contains(".")) longest = Math.max(longest, len-1);
else lens[subs.length] = len;
}
return longest;
}
```

## Problem solution in C++.

```class Solution {
public:
bool delimiter(const char* const p) {
return *p == '\n' || *p == '\t';
}

int lengthLongestPath(string input) {
std::stack<int> lengths;
int total_length = 0;

const char* p = &input[0];
const char* const end = &input[0] + input.size();
int best = 0;

std::string name;
int depth;

while (p != end && !delimiter(p)) {
name += *p;
++p;
}

if (name.find('.') != std::string::npos) {
best = name.size();
}
lengths.push(name.size());
total_length += name.size();
name = "";

while (p != end) {
depth = parseDelimiter(&p, end);
while (p != end && !delimiter(p)) {
name += *p;
++p;
}
while (depth <= lengths.size()) {
total_length -= lengths.top();
lengths.pop();
}
lengths.push(name.size());
total_length += name.size();
if (name.find('.') != std::string::npos) {
best = std::max(best, total_length + depth - 1);
}
name = "";
}
return best;
}

int parseDelimiter(const char** pp, const char* end) {
int count = 0;
while (*pp != end && delimiter(*pp)) {
++(*pp);
++count;
}
return count;
}
};
```

## Problem solution in C.

```int lengthLongestPath(char* input) {
int stack[256] = {0};
int stack_idx = 0;

char *p = input;
int max_length = 0;
int current_base_length = 0;
int current_indent_level = 0;
int last_length = 0;

int iter = 0;

while(*p != '\0')
{

int indent_level = 0;
for(; *p == '\t'; p++, indent_level++);

if(indent_level == current_indent_level)
{
}
else if (indent_level < current_indent_level)
{
while(indent_level < current_indent_level)
{
current_indent_level--;
current_base_length = stack[--stack_idx];
}
}
else
{
stack[stack_idx++] = current_base_length;
current_base_length = last_length;
current_indent_level++;

}

bool is_file = false;
int filename_len = 0;
for(; *p != '\n' && *p != '\0'; p++, filename_len++)
{
if (*p == '.') is_file = true;
}

if(*p == '\n') p++;

last_length = filename_len + current_base_length + 1;
if(is_file && last_length > max_length)
{
max_length = last_length;
}

}

return max_length == 0 ? 0 : (max_length - 1);
}
```