# Linux Find Command

<https://leetcode.com/discuss/interview-question/369272/Amazon-or-Onsite-or-Linux-Find-Command>\
**Version 1:**

```
class File {
    String name;
    int size;
    int type;
    boolean isDirectory;
    File[] children;
}

abstract class Filter {
    abstract boolean apply(File file);
}

class MinSizeFilter extends Filter {

    int minSize;

    public MinSizeFilter(int minSize) {
        this.minSize = minSize;
    }

    @Override
    boolean apply(File file) {
        return file.size > minSize;
    }
}

class TypeFilter extends Filter {

    int type;

    public TypeFilter(int type) {
        this.type = type;
    }

    @Override
    boolean apply(File file) {
        return file.type == type;
    }
}

class FindCommand {

    public List<File> findWithFilters(File directory, List<Filter> filters) {
        if (!directory.isDirectory) {
            return new NotADirectoryException();
        }
        List<File> output = new ArrayList<>();
        findWithFilters(directory, filters, output);
        return output;
    }

    private void findWithFilters(File directory, List<Filter> filters, List<File> output) {
        if (directory.children == null) {
            return;
        }
        for (File file : directory.children) {
            if (file.isDirectory) {
                findWithFilters(file, filters, output);
            } else {
                boolean selectFile = true;
                for (Filter filter : filters) {
                    if (!filter.apply(file)) {
                        selectFile = false;
                    }
                }
                if (selectFile) {
                    output.add(file);
                }
            }
        }
    }
}
```

&#x20;**Version 2:**

```
 public interface Filter {
       public boolean match(File f);
   }

public class ExtensionFilter implements Filter {
       final private String ext;
   
       public ExtensionFilter(String ext) {
           this.ext = ext;
       }
   
       public boolean match(File f) {
           return f.getName().endsWith("." + ext);
       }
   }

public class SizeFilter implements Filter {
       enum SizeOperator {
           LT,
           LTE,
           EQ,
           GT,
           GTE
       };
   
       private final int size;
       private final SizeOperator op;
   
       public SizeFilter(int size, SizeOperator op) {
           this.size = size;
           this.op = op;
       }
   
       public boolean match(File f) {
          int actualSize = f.length();
           switch (op) {
               case LT:
                   return actualSize < size;
               case LTE:
                   return actualSize <= size;
               case EQ:
                   return actualSize == size;
               case GT:
                   return actualSize > size;
               case GTE:
                   return actualSize >= size;
           }
   
           return false;
       }
   }

public void find(File f, Filter filter, List<Files> files) {
           if (f.isDirectory()) {
               for (File file : baseDir.listFiles()) {
                  find(file, filter, files);
               }
           } else {
                  if (filter.match(f)) {
                       files.add(f);
                   }
             }
       }
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://junnie.gitbook.io/amazon-mock-interview/2022/ood/linux-find-command.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.