CCNA The Power Of The Command Line Questions

The && operator runs the right-hand command only if the left-hand command exits with status 0, which signals success. That matches the requirement exactly: deploy.sh runs only when the build succeeded. If the build fails, the shell skips deploy.sh and the overall exit status reflects the failure, which is useful in scripts.

The cat command concatenates and displays the entire contents of a file to standard output. It is a simple and common way to view file contents quickly, especially for short files. It directly shows the file's content without pagination or additional processing.

The which command searches the directories in the PATH environment variable and prints the full path of the first matching executable. This directly answers the question of which python3 would run. It is the standard tool for locating a command's executable in the current shell environment.

The pwd command stands for 'print working directory' and outputs the absolute pathname of the current directory. It is a shell built-in in most shells and directly fulfills the requirement to display the current working directory.

The -v flag inverts grep's matching logic, printing only lines that fail to match the pattern. Applied to 'success' in file.txt, it returns every line not containing that word, precisely satisfying the requirement to exclude matching lines rather than select them.

The shell expands $USER to the value of the USER environment variable, which holds the login name of the account running the session. echo then writes that string to standard output, printing the current username.

The -a option tells ls to list all entries, including those whose names begin with a dot (hidden files). By default, ls omits such files. Using ls -a in the project directory will display every file and directory, meeting the developer's need to see hidden items as well as regular ones.

The notation 2> redirects file descriptor 2, which is standard error, to the specified file. Standard output (file descriptor 1) remains connected to the terminal, so normal output is still displayed. This exactly matches the requirement.

cat reads the file sequentially and writes its contents to standard output, which is the terminal, satisfying the requirement to display config.txt directly on screen. It requires no pager or editor and outputs the raw file contents.

The info command opens GNU Info documentation, a hypertext manual system providing detailed help for commands, satisfying the requirement for a valid help method. It reads .info files, typically installed under /usr/share/info, and offers navigation between nodes.

End of line.

awk is a complete pattern-scanning and field-processing language: it splits each input record into fields, applies pattern-action rules and can reformat or summarise text. This satisfies the text-processing requirement alongside stream editors and search tools.

With -exec ... \;, find runs the specified command separately for every file that matches, substituting each path for the {} placeholder. The escaped semicolon terminates the command list for find rather than the shell. So each .log file under /var/log is passed individually to rm and removed, one invocation per match.

pwd prints the absolute path of the directory the shell is currently in, reading it from the shell's tracked location rather than the filesystem. It directly answers the question of where you are, requiring no arguments.

The -v option inverts the match, so grep prints lines that do not match the pattern. With the anchor ^root, it selects all lines that do not begin with 'root'. This is exactly what the user needs. The command is efficient and standard for excluding lines based on a pattern.

Piping cat's output into another command feeds that command's standard input from the file's contents, achieving input redirection indirectly. This satisfies the stem's requirement by supplying data via a pipe rather than the shell's < operator.

`rmdir` removes empty directories, satisfying the stem's requirement for a deletion command. Unlike `rm -r`, which recurses through populated trees, `rmdir` refuses non-empty directories, so it deletes only the directory entry itself. This precise, non-recursive behaviour makes it one of the two valid deletion commands listed.

pwd stands for 'print working directory' and outputs the absolute path of the current directory. It is a shell built-in in most shells, so it reflects the shell's internal notion of the current directory, which may differ from the kernel's if symbolic links are involved.

A zombie process has finished execution, but the parent has not yet called wait() to collect its exit status. The kernel keeps a minimal process table entry until the parent reaps it. Because the parent here is PID 1 (init/systemd), it normally reaps children quickly; a lingering zombie usually indicates a bug or a stuck reaping loop.

The tilde character is expanded by the shell to the absolute path of the invoking user's home directory, so ~/file resolves correctly regardless of username. This satisfies the requirement for a portable shorthand referencing the current user's home.

The export builtin marks PATH for export to child processes, and $PATH:/opt/bin appends the new directory while preserving existing entries. This is the standard POSIX shell syntax for persistently modifying PATH within the current session, matching the stem's requirement to include /opt/bin.

grep searches file contents line by line for a pattern, printing matching lines. Given the constraint of locating every 'ERROR' occurrence inside the syslog file, grep 'ERROR' syslog is the direct tool; alternatives like find or locate operate on filenames, not file contents.

The nohup command makes a process immune to hangup signals, so it continues running after the terminal closes. The ampersand (&) runs it in the background. This combination ensures the script persists beyond the session, which is exactly what the user needs.

The tar command with -c creates a new archive, -z compresses it with gzip, and -f specifies the archive filename. Including the directory path archives the entire directory tree. This command correctly creates project.tar.gz containing the project directory and its contents.

Changing the current working directory affects the shell process itself, so cd must be implemented as a builtin. A separate executable could change only its own working directory and then exit, leaving the parent shell unchanged. That is why cd appears in the shell's builtin list and cannot be replaced by an external binary in normal use.

The numeric mode 755 sets owner permissions to read, write, and execute (7), and group and others to read and execute (5). This exactly matches the requirement: the owner gets full control, while group and others can read and execute but not write. It is a standard way to make a script executable for everyone while restricting write access.

echo is a shell built-in implemented within the shell itself rather than as a separate executable, so it runs without spawning a child process. This matches the stem's criterion for common shell built-in command types, alongside cd and export.

`cat` concatenates and writes files to standard output, directly displaying a file's contents in the terminal. It satisfies the stem's requirement for a valid display command, and remains one of the two expected answers alongside `less`. Its core purpose is reading files sequentially, making it correct here.

SIGTERM requests graceful process termination, allowing the program to save state and release resources before exiting. It satisfies the stem's requirement for a signal used to interact with running processes, since the kernel delivers it to a target process, which may catch, ignore, or handle it rather than being forcibly killed.

The semicolon operator runs commands sequentially regardless of whether earlier commands succeed, satisfying the requirement for unconditional sequential execution. Unlike `&&`, which halts on failure, or `||`, which runs only after failure, `;` simply separates and orders commands, making it a valid mechanism for running them one after another.

The -mtime -7 predicate matches files whose data was modified less than seven days ago, satisfying the requirement to find recently modified files. The minus sign means "less than", whereas +7 would match files older than seven days.

Piping the recursive grep output into less launches a pager that displays one screenful at a time and lets the administrator scroll forward and backward through the entire result set. This directly satisfies both requirements: viewing the complete output screen by screen and being able to revisit earlier lines without rerunning the search.

The && operator runs the second command only when the first exits with status zero, giving conditional sequential execution. The semicolon runs commands regardless of outcome, while || executes the second only on failure, so && matches the success-dependent requirement.

rm -rf combines recursive (-r) traversal of the directory tree with force (-f) suppression of prompts, deleting the directory and all contents. The -r flag satisfies the stem's recursive requirement, while -f avoids interactive confirmation for each entry.

gzip compresses single files into .gz archives, satisfying the requirement to manage compressed archive contents. It reduces file size for storage or transfer, though it cannot bundle multiple files together—that needs tar first. For the exam's purpose, gzip is a recognised compression tool that directly handles archive content.

Pressing Tab invokes the shell's completion facility, which reads the current partial token and expands it against available commands or filenames in the search path. This satisfies the requirement for a keyboard shortcut that autocompletes both commands and filenames without executing anything.

less opens the file in a pager, letting you scroll forward and backward through long content one screen at a time without loading everything into memory. It also supports searching, unlike cat, which dumps the entire file at once.

The double chevron opens the target file in append mode, positioning the write offset at end-of-file so existing content survives. A single chevron would truncate instead, so >> satisfies the requirement to preserve original content.

The -i flag makes matching case-insensitive, and -n prefixes each matching line with its line number. Combined, they satisfy both requirements in one pass over the file. Without -i, only lowercase occurrences would match; without -n, no line numbers would appear, so both flags are needed together.

The export builtin marks MYVAR for inclusion in the environment of subsequently executed commands, so child processes inherit it. Assigning without export would create only a shell variable, invisible to children, failing the stem's inheritance requirement.

The > redirection operator sends stdout to dirlist.txt, truncating and overwriting any existing content, exactly as the scenario requires. The shell opens the file for writing before executing ls, so prior contents are discarded rather than appended.

The -i flag makes grep perform case-insensitive matching, so patterns match regardless of upper or lower case letters. Combined with grep's default line-matching behaviour, it displays every line containing the pattern without regard to casing.

The `-z` flag invokes gzip compression during archive creation, satisfying the requirement for a `.tar.gz` file. Combined with `-c` to create and `-f` to specify the filename, `tar -czf` writes the compressed archive directly, avoiding a separate compression step.

This find command searches /home, restricts to regular files with -type f, matches files larger than 100 MB with -size +100M, and files modified within the last 7 days with -mtime -7. All conditions are ANDed by default, so it returns exactly the desired files.

grep "^d" matches lines beginning with d, the first character in ls -la output denoting a directory. Piping the long listing through this filter therefore returns only directories, satisfying the scenario's requirement to list directories alone.

This command uses find with -mtime -1 to match files modified less than 24 hours ago, -size +1M for files larger than 1 MB, and redirects the output to the specified file. It directly meets all criteria: search path, file type, time, size, and output redirection.

The -n option to grep prefixes each matching line with its 1-based line number within the input file. This is useful for locating matches in large files or when you need to reference a specific line later. In this scenario, the numbers identify where in /var/log/app.log each 'error' match appears.

The find command combines the predicates -type f (regular files), -name '*.log' (name pattern), -size +10M (greater than 10 megabytes), and -delete to remove matches. This is safe because -delete only acts on files that satisfy all preceding tests, and it avoids invoking a separate process for each file. It also respects the directory traversal order.

The wc command with the -l option counts the number of newline characters in the file, which corresponds to the number of lines. This is the standard and simplest way to count lines in a file, directly providing the required information without additional processing.

The regular expression ^[A-Z][a-z]+ [0-9]{3}$ anchors the match to the entire line. The $ asserts the end of line immediately after the three digits. If the lines have trailing spaces, carriage returns, or any extra characters, the pattern fails. This is the most likely cause of no output when the visible content appears to match.

The `history` builtin prints the numbered list of previously executed commands held in the shell's in-memory history list, satisfying the stem's request directly. It neither re-runs commands nor edits the list; those require separate mechanisms such as `!!` expansion or `history -c`.

The shell stores the previous command's exit status in the special parameter $?, so echo $? prints that numeric value. This directly satisfies the requirement to check whether the last executed command succeeded or failed.

The man command displays the manual page for a given command. Running `man cp` opens the cp manual, where the administrator can read about options like -r, -p, and -i. This is the standard way to access documentation on a Linux system for commands and configuration files.

The `-n` flag makes `sort` compare lines by their leading numeric value rather than lexicographically, so "10" ranks after "9" instead of before it. This directly satisfies the stem's requirement to sort numerically rather than alphabetically, which is the default byte-order comparison.

grep filters piped input line by line, printing only lines matching a specified pattern. This is a standard way to manipulate command output within a pipeline, satisfying the stem's requirement, unlike commands that merely display or redirect output.

The sed substitute command with the g flag replaces every match on each line, and without -i it writes to standard output, so results appear in the terminal while data.txt stays untouched. This satisfies both the replace-all and view-in-terminal constraints.

The find command with -type f limits the search to regular files, and -mtime -1 selects files modified less than 24 hours ago. This directly matches the requirement to find files modified in the last day and list their names.

USER holds the current logged-in account's username and is exported by the login process, making it a standard shell environment variable. It is inherited by child processes, matching the stem's criterion of variables commonly present in a Linux shell.

find / -name notes.txt begins traversal at the root directory and recurses through every subdirectory, matching the filename exactly. This guarantees the file is located wherever it resides, satisfying the requirement to search from root.