Finding Your Way ON A Linux System practice questions

ls -lt

Why it fails: This puts the newest files at the bottom.

ls -lr

Why it fails: This sorts alphabetically in reverse.

ls -Rlt

Why it fails: This adds recursion, which is unnecessary here.

find

Why it fails: find searches the entire filesystem, which is overkill for executables in PATH.

locate

Why it fails: locate uses a database and might not be up-to-date.

whereis

Why it fails: whereis finds binaries, sources, and man pages, but 'which' is the specific tool for the command in PATH.

head

Why it fails: head shows only the top of the file.

more

Why it fails: more is a pager, but it is less feature-rich than less.

cat

Why it fails: cat dumps the entire file at once.

grep "*.conf"

Why it fails: grep searches inside files, not for filenames.

search *.conf

Why it fails: There is no standard search command.

ls *.conf

Why it fails: ls does not search subdirectories.

-o

Why it fails: -o is for owner info, but less common than -l.

-z

Why it fails: -z is not a standard ls flag.

-x

Why it fails: -x sorts by columns.

pwd

Why it fails: pwd prints the absolute path of the current working directory; it never enumerates entries. It is tempting because it is a core filesystem navigation command used constantly alongside ls, but its purpose is orientation, not listing. The stem requires directory contents, which ls or echo * provide.

cd

Why it fails: cd changes the shell's current working directory; it produces no listing of entries. It is tempting because it is the standard navigation command used immediately before listing, but changing location is not enumerating contents. The stem requires ls or echo *, which actually output directory entries.

cat

Why it fails: cat concatenates and prints file contents to standard output; given a directory it errors rather than listing entries. It is tempting because it displays information on screen, but that information is file data, not directory entries. The stem requires ls or echo *, which enumerate names within a directory.

whereis ls

Why it fails: 'whereis ls' searches standard locations for the binary, source, and manual page for 'ls'. It reports all matching files rather than the single executable the shell would execute, and it ignores PATH order, aliases, and functions. Therefore it does not answer which executable would actually run.

type ls

Why it fails: The 'type' builtin reports how the shell would interpret 'ls', such as 'ls is aliased to ls --color=auto' or 'ls is /usr/bin/ls', but it does not print the full pathname of the executable. It also shows aliases, functions, and builtins, so it is not a reliable way to obtain only the executable path.

which ls

Why it fails: Although 'which ls' prints the path of the first matching executable in PATH, it is an external utility that can behave inconsistently across distributions and does not account for shell builtins, aliases, or functions. It is not the most reliable command for determining the executable that the shell itself would run.

pwd -P

Why it fails: The -P option with pwd resolves symbolic links and prints the physical directory path, not the logical path containing the symlink names. Since the administrator wants the path including the traversed symbolic links, this option does the opposite of what is required and would show the real filesystem location instead.

ls -d .

Why it fails: The ls -d . command lists the current directory entry itself rather than printing the absolute pathname of the working directory. It outputs a single dot or a relative name, which does not satisfy the need to see the full path including symbolic links, so it is unsuitable here.

cd .

Why it fails: The cd . command changes to the current directory, effectively doing nothing to the working directory, and it produces no pathname output at all. It cannot reveal the location of the current directory, so it fails to meet the administrator's goal of displaying the full pathname.

fdisk -l

Why it fails: fdisk -l lists partition tables and partition information for block devices, including sizes and partition types, but it does not show which filesystems are currently mounted or their mount points. It is a disk partitioning tool, not a mount information tool, so it does not answer the question about mounted filesystems.

lsblk

Why it fails: lsblk lists block devices and their partitions in a tree, showing device names, sizes, and mount points. It does not show the filesystem type by default and does not include mount options. Since the task specifically asks for filesystem type and detailed mount information, lsblk alone would not satisfy the requirement.

df -h

Why it fails: The df command reports filesystem disk space usage. With -h it shows sizes in human-readable units, and it does list mount points and total/used/available space, but it does not report the filesystem type or detailed mount options. The scenario asks for type and detailed information about mounts, which df does not provide by default.

man -k timeout

Why it fails: The -k option performs a keyword search across the manual page names and short descriptions, similar to apropos, rather than searching inside the ssh manual content. It would list commands related to the term, not occurrences within ssh's page, so it does not meet the requirement.

man ssh | grep -v timeout

Why it fails: The -v option inverts the match, printing every line that does not contain 'timeout'. This is the opposite of what is needed, since the technician wants the lines that do contain the term, and it also does not ignore case without an additional flag.

man ssh | grep timeout

Why it fails: This pipeline searches for the exact lowercase string 'timeout' and would miss occurrences such as 'Timeout' or 'TIMEOUT'. Because the scenario explicitly requires ignoring case differences, this command is insufficient even though it does search within the manual page.

grep -r '*.conf' /etc

Why it fails: 'grep -r' searches the contents of files for the literal or pattern text '*.conf', not file names. It would report lines containing that string inside files, not a list of files whose names end with '.conf'. This is a fundamental misuse of grep for filename matching.

find /etc -name '*.conf' -type d

Why it fails: This command uses '-type d', which restricts matches to directories. It would list only directories whose names end in '.conf', the exact opposite of what is needed. The name pattern is correct, but the type filter is wrong for the stated goal of listing regular files.

ls /etc/*.conf

Why it fails: Shell globbing expands '/etc/*.conf' to all matching entries in '/etc', including directories whose names end in '.conf'. Because 'ls' does not filter by file type, any matching directory would appear in the output. It also does not recurse into subdirectories, so it fails on both counts.

wc -l /etc/passwd

Why it fails: wc -l counts the number of newline characters in the file and reports a single number representing the line count. It does not display any file contents and provides no line numbering of the actual text. This command answers how many lines exist, not what those lines say.

nl -b a /etc/passwd

Why it fails: nl with -b a numbers all lines, including blank ones, so it does produce numbered output and could satisfy the first requirement. However, the stem asks for two commands that together cover both tasks, and this option duplicates the numbering function already provided by cat -n while leaving the first-ten-lines requirement unmet by the selected pair.

tail -n 10 /etc/passwd

Why it fails: tail -n 10 prints the last ten lines of the file, not the first ten. For /etc/passwd, that would show the most recently added user entries rather than the beginning of the file. It is the complement of head and does not satisfy the requirement to view only the first ten lines.

cp report.txt /tmp/archive/

Why it fails: A plain cp copies the file contents and creates a new file with the current time as the modification timestamp and permissions based on the umask and source mode, but it does not preserve timestamps. Since the requirement explicitly includes preserving timestamps, this command does not fully meet the need, even though it copies the file successfully.

mv report.txt /tmp/archive/

Why it fails: mv moves the file rather than copying it, removing it from the source location. Even though mv preserves timestamps and permissions by default when moving within the same filesystem, the scenario asks to copy the file, implying the original should remain. Using mv would delete report.txt from the projects directory, which is not desired.

cp -a report.txt /tmp/archive/

Why it fails: The -a option is an archive mode that implies -dR --preserve=all, which preserves timestamps, permissions, ownership, and also copies directories recursively. While it does preserve timestamps and permissions, it is more than needed for a single file and may attempt to preserve ownership, which can fail for non-root users. The simpler -p is the precise answer.

ls -ltr /etc

Why it fails: This long listing sorts by time in reverse, which displays oldest first, not newest first. It also omits the -a flag, so hidden files such as dotfiles are excluded. Both the sort order and the hidden-file requirement are therefore unmet, making it incorrect for this scenario.

ls -lt /etc && cd /etc

Why it fails: The ls portion sorts by time but omits hidden files, and the subsequent cd changes the working directory, which the scenario explicitly forbids. Even though the listing occurs first, the command as a whole violates the constraint of staying in /var.

ls -at /etc

Why it fails: The -a option includes hidden files and -t sorts by modification time, but without -r the order is newest first only if the default is oldest first; actually -t alone gives newest first, so the missing behavior here is that -a also lists the . and .. entries, which may not be desired, and the scenario asks for hidden files, not directory self-entries. However, the definitive failure is that no reverse flag is needed, but the option set does not exclude . and .., so it does not strictly match the requirement as precisely as the intended answer.

cat -n /etc/services

Why it fails: The cat command with -n numbers every line and prints the entire file, which could be thousands of lines long. That floods the terminal rather than showing just the first few lines, and it provides no inode or size metadata, so it does not meet either stated goal.

file /etc/services

Why it fails: The file utility inspects content and reports a classification such as ASCII text. It does not print the inode number or byte size, and it does not show file contents, so it addresses neither the first-lines view nor the metadata inspection the technician requires.

wc -l /etc/services

Why it fails: The wc utility counts lines, words, or bytes depending on flags. With -l it returns only the total line count, not the inode number, and it never displays file content. It therefore fails both parts of the task, despite being a legitimate tool for summarizing a file.

tail -n 15 system.log

Why it fails: tail -n 15 shows the last 15 lines of the file, not the first 15. While tail is commonly used with -f to follow a file, without -f it only prints the tail and exits. The requirement explicitly asks for the first 15 lines, so this command starts from the wrong end of the file.

tail -n +15 -f system.log

Why it fails: tail -n +15 starts printing from the 15th line to the end of the file, not the first 15 lines. The plus sign changes the meaning to start at that line number, so it would show line 15 onward. This does follow with -f, but it does not meet the requirement to display the first 15 lines.

head -n 15 system.log

Why it fails: head -n 15 displays the first 15 lines but exits immediately, so it does not follow the file for new content. The scenario requires both viewing the beginning and monitoring appended lines in real time, which head alone cannot do. It is useful for a quick peek but not for continuous monitoring.

rm temp_backup

Why it fails: rm without -r refuses to remove a directory, reporting that temp_backup is a directory. It is tempting because rm deletes files and is the obvious removal command, and it would work for individual files inside the directory. Recursive deletion requires the -r flag.

rmdir temp_backup

Why it fails: rmdir removes only empty directories, so it fails with an error when temp_backup contains files. It is tempting because it is the dedicated directory-removal command, and it would succeed on an empty directory. The scenario requires recursive deletion of the contents as well.

rm -f temp_backup

Why it fails: rm -f forces removal without prompting but still does not recurse into directories, so temp_backup survives. It is tempting because -f suppresses confirmation, appearing thorough. It would correctly delete read-only files. Deleting a populated directory needs -r, optionally combined as -rf.

cd ..

Why it fails: cd .. moves up exactly one level in the directory tree, so it only reaches home when the current directory is a direct child of it. It is tempting as a quick relative shortcut, but it cannot guarantee arrival at home from arbitrary locations; bare cd does that.

cd /

Why it fails: cd / changes to the filesystem root, not the user's home directory, so it fails the requirement regardless of current location. It is tempting because the root is a fixed, absolute destination reachable from anywhere, but the home directory is reached with cd ~ or bare cd.

cd /home

Why it fails: cd /home enters the shared parent directory containing all users' home directories, not the current user's own home. It is tempting because /home is a fixed absolute path, but the correct target is the user's specific directory, reached via cd ~ or bare cd.

cp

Why it fails: cp duplicates an existing source file to a destination; with no source it fails, and it never creates a truly empty file or updates a timestamp in place. It is tempting as a file-creation command, and would be correct when copying content from one path to another.

mkdir

Why it fails: mkdir creates directories, not files, so it cannot produce an empty file or refresh a timestamp. It is tempting because it is a basic filesystem-creation command, and it would be correct when the task is to create a new directory hierarchy rather than a file.

mv

Why it fails: mv moves or renames files and directories; it neither creates an empty file nor updates timestamps. touch performs both actions. mv would be the correct choice when relocating a file to a different directory or renaming it within the same filesystem.

cp -p

Why it fails: The -p flag preserves mode, ownership and timestamps, yet without -r it will not descend into subdirectories, so nested content is skipped. It is the right flag when copying individual files whose attributes must be retained, not a whole directory tree.

cp -v

Why it fails: The -v flag only prints each file name as it is copied, providing verbose output with no effect on recursion or attribute preservation. It is useful for auditing or troubleshooting a copy operation, but it does not satisfy the requirement to preserve subdirectories and file attributes.

cp -r

Why it fails: The -r flag recurses into subdirectories, but it does not preserve file attributes such as ownership, timestamps and permissions; those are handled by -a or -p. Recursion is the correct choice when only the directory tree structure must be duplicated, not the metadata.