Q: Special shell parameters — process ID of the current shell In POSIX/Bourne-compatible shells, which special parameter expands to the process number (PID) of the current shell instance?

Introduction / Context: Shell scripting often needs the process ID (PID) to create unique filenames, manage lock files, or send signals. POSIX shells provide built-in special parameters that expand to useful values without invoking external commands. Given Data / Assumptions: Shell is POSIX/Bourne-compatible (sh, bash, ksh, dash). We need the PID of the current shell process. We are not asking for PIDs of background jobs or parent processes. Concept / Approach: The special parameter expands to the PID of the current shell. Other related parameters include $! (PID of the most recently executed background pipeline), $0 (name of the shell or script), and $* (all positional parameters). Step-by-Step Solution: Echo the parameter: echo to see the PID.Use it in filenames: tmpfile=/tmp/app. toavoidcollisions.Optionallyconfirmwithps−p toavoidcollisions.Optionallyconfirmwithps−p to see the matching process.Remember $! is different (last background job PID). Verification / Alternative check: In an interactive shell, compare echo withthePIDreportedbypsforyourshellprocess.Insideasubshell,observethat withthePIDreportedbypsforyourshellprocess.Insideasubshell,observethat can change because it refers to that subshell's PID. Why Other Options Are Wrong: $!: PID of the most recent background job, not the current shell. $0: script or shell name, not a PID. $*: all positional parameters as a single word. None of the above: incorrect because iscorrect. CommonPitfalls: Using iscorrect. CommonPitfalls: Using inside subshells without realizing it changes; confusing $! and ;forgettingtoquotewhenembeddinginpathswithothervariables. FinalAnswer: ;forgettingtoquotewhenembeddinginpathswithothervariables. FinalAnswer:

Q: Moving files up one level — send everything to ../bin Which command moves all non-hidden files from the current directory into the bin subdirectory of the parent directory?

Introduction / Context: Unix file operations often involve reorganizing directories. Moving a collection of files one level up into a specific subdirectory is a common task. Using shell globs correctly avoids mistakes like overwriting or targeting the wrong path. Given Data / Assumptions: You are in a directory containing files you want to move. The destination is the bin subdirectory of the parent directory, i.e., ../bin. Hidden files (names beginning with a dot) are not included by the glob unless explicitly specified. Concept / Approach: The command mv * ../bin expands to all non-hidden entries in the current directory and moves them into ../bin. This is the minimal, portable form. You should ensure that ../bin exists and that the shell's glob does not expand to an empty list (some shells handle empty globs differently). Step-by-Step Solution: Verify destination exists: ls -ld ../bin.Preview the expansion: echo to see which files will move.Execute: mv * ../bin.Confirm by listing ../bin and the now-empty current directory (except hidden files). Verification / Alternative check: Use a dry run approach by testing in a temporary directory. For including dotfiles, use constructs like shopt -s dotglob in bash or explicit patterns (. ) with care. Why Other Options Are Wrong: mv . /bin/: targets system-wide /bin and matches only names containing a dot; risky and incorrect destination. mv * /bin/: tries to move into files that match /bin/ rather than the directory; incorrect and dangerous. mv * ../bin .: syntactically wrong for a single destination; provides extra arguments without clear intent. None of the above: incorrect because mv * ../bin is correct. Common Pitfalls: Overwriting files with the same name at the destination; forgetting that * excludes dotfiles; accidentally targeting /bin instead of ../bin; moving directories you did not intend to move. Final Answer: mv * ../bin

Q: Shell redirection in Unix/Linux: Which operator should you use to append the standard output to the end of an existing file instead of overwriting its current contents?

Introduction / Context: Command-line redirection is fundamental in Unix and Linux. You frequently need to add new output to the end of a log or report without destroying what is already there. Distinguishing between overwrite and append operators prevents data loss and supports safe scripting. Given Data / Assumptions: You are writing standard output to a file. You want to preserve the file’s existing content and add new output at the end. Standard POSIX shell syntax is assumed (sh, bash, zsh, etc.). Concept / Approach: The operator > sends standard output to a file and truncates it first. The operator >> appends standard output to the file, creating it if it does not exist. Operators like > to add to the end of a file.Example: echo "line" >> report.txt appends “line”.Avoid > when preservation matters, because it truncates existing content.Do not use input redirection ( demo.txt. Then append: echo "second" >> demo.txt. Display with cat demo.txt and confirm both lines appear, proving that >> appended rather than overwrote. Why Other Options Are Wrong: > symbols: Overwrites (truncates) the file before writing. > is exactly the append operator. Common Pitfalls: Accidentally using > when you intended to append can destroy logs. For safety, some shells support noclobber to prevent overwrites, or you can use >> consistently for logs. Always test redirections on scratch files first. Final Answer: >> symbols

Question 1

BSD mail (traditional mail user agent) — forward a message to another user list In the classic BSD/Unix mail program's internal command set, which command forwards the current message to the specified user-list?

Accepted Answer

Introduction / Context: Before modern graphical mail clients, Unix systems commonly used terminal-based mail user agents like mail or mailx. These tools have internal commands for replying, forwarding, deleting, and editing messages. Understanding these commands remains useful for server administration and scripting. Given Data / Assumptions: The environment is the traditional BSD mail (or a compatible variant). We want to forward the contents of the current message to recipients listed as user-list. We are not composing a brand-new message from scratch; we are forwarding an existing one. Concept / Approach: In classic mail, the command m user-list is used to send (mail) a copy of the current message to another recipient list, effectively forwarding it. Other commands target different actions: r replies to the sender, d deletes messages, and e invokes an editor to modify the message being composed or to edit headers. Step-by-Step Solution: Start mail and select the message you wish to forward (by number if necessary).At the & prompt, type m user1 user2 to forward to those users.Provide any additional headers or annotations if prompted, then send.Verify that the recipients receive the forwarded message. Verification / Alternative check: Consult the system's man mail page for your specific implementation. Some variants also include f (forward) aliases. If your system supports mailx, you may prefer forward or use ~m during composition to include the current message. Why Other Options Are Wrong: r user-list: reply to sender (and possibly recipients), not forward. d user-list: deletes messages, does not send them. e user-list: edits the message in an editor; not a forwarding action. None of the above: incorrect because m user-list performs the forwarding in classic mail. Common Pitfalls: Assuming modern mailx syntax is identical everywhere; different Unix flavors may offer additional aliases like f for forward. Always check the local manual page for exact semantics. Final Answer: m user-list

Question 2

Counting lines in a file on Unix/Linux  Which single command counts only the number of lines contained in a text file (no words or bytes)?

Accepted Answer

Introduction / Context: Simple text analytics are frequently needed on Unix-like systems. The wc (word count) utility quickly provides counts of lines, words, and bytes. Knowing the correct option flags avoids writing custom scripts for basic statistics. Given Data / Assumptions: The input is a regular text file or piped text stream. We need the number of lines only. We are using a standard POSIX wc implementation. Concept / Approach: wc supports independent flags for each metric: -l for lines, -w for words, and -c for bytes. Combining flags prints multiple counts in order. To get lines alone, specify -l by itself. Step-by-Step Solution: Choose the correct metric: lines.Run wc -l filename to print the line count and filename.For just the number, you can use command substitution or cut (e.g., wc -l < filename).With pipelines, use ... | wc -l to count lines in a stream. Verification / Alternative check: Cross-check with nl -ba filename | tail -n 1, which numbers all lines. The final number should equal the output from wc -l. Why Other Options Are Wrong: wc -c: counts bytes. wc -w: counts words. wc -r: not a standard option. None of the above: incorrect because wc -l is correct. Common Pitfalls: Counting lines in files without a trailing newline can yield off-by-one expectations; remember wc -l counts newline characters. On huge files, prefer wc for performance over scripting loops. Final Answer: wc -l

Question 3

Special shell parameters — process ID of the current shell  In POSIX/Bourne-compatible shells, which special parameter expands to the process number (PID) of the current shell instance?

Accepted Answer

Introduction / Context: Shell scripting often needs the process ID (PID) to create unique filenames, manage lock files, or send signals. POSIX shells provide built-in special parameters that expand to useful values without invoking external commands. Given Data / Assumptions: Shell is POSIX/Bourne-compatible (sh, bash, ksh, dash). We need the PID of the current shell process. We are not asking for PIDs of background jobs or parent processes. Concept / Approach: The special parameter expands to the PID of the current shell. Other related parameters include $! (PID of the most recently executed background pipeline), $0 (name of the shell or script), and $* (all positional parameters). Step-by-Step Solution: Echo the parameter: echo to see the PID.Use it in filenames: tmpfile=/tmp/app. toavoidcollisions.Optionallyconfirmwithps−p toavoidcollisions.Optionallyconfirmwithps−p to see the matching process.Remember $! is different (last background job PID). Verification / Alternative check: In an interactive shell, compare echo withthePIDreportedbypsforyourshellprocess.Insideasubshell,observethat withthePIDreportedbypsforyourshellprocess.Insideasubshell,observethat can change because it refers to that subshell's PID. Why Other Options Are Wrong: $!: PID of the most recent background job, not the current shell. $0: script or shell name, not a PID. $*: all positional parameters as a single word. None of the above: incorrect because iscorrect. CommonPitfalls: Using iscorrect. CommonPitfalls: Using inside subshells without realizing it changes; confusing $! and ;forgettingtoquotewhenembeddinginpathswithothervariables. FinalAnswer: ;forgettingtoquotewhenembeddinginpathswithothervariables. FinalAnswer:

Question 4

vi editor command-line corrections — back up over typing errors  When entering ex/vi commands (for example, after typing a colon), which historical erase character is commonly used to back up over a single typing error on terminals that do not suppo…

Accepted Answer

Introduction / Context: Classic vi grew up on hard-copy and glass TTYs with limited keysets. Before modern Backspace behavior was standardized, terminal drivers provided special erase and kill characters for command-line editing. Knowing these legacy conventions helps when working on constrained systems or through raw serial consoles. Given Data / Assumptions: We are entering an ex command line in vi (for example, after typing :). The terminal's erase and kill characters are configured to traditional defaults. We want the character that erases one previous character (a single backspace effect). Concept / Approach: Historically, the hash mark # acted as the erase character, removing the immediately preceding character on the command line. The at sign @ often acted as the line-kill character, clearing the entire input line. While modern terminals support the Backspace key, these legacy controls still appear in documentation and older environments. Step-by-Step Solution: Enter command-line mode with : in vi.If you mistype, press # to erase the last character (on systems honoring this convention).Use @ to erase the whole line if necessary (legacy behavior).Press Enter to execute once the command is correct. Verification / Alternative check: Check your terminal settings with stty -a. The erase and kill characters show the current bindings, which may be Backspace and Ctrl+U in modern setups. If set to # and @, the described behavior will occur in vi's command-line entry. Why Other Options Are Wrong: @: typically the kill-line character (erase the whole line), not single-character erase. $: represents end-of-line in regular expressions; not an erase character. !: used for shell escapes in ex/vi commands (for example, :!ls), not for editing mistakes. None of the above: incorrect because # is traditionally used for single-character erase in this context. Common Pitfalls: Assuming your modern Backspace will always work in raw terminals; not checking stty settings; confusing vi's insert-mode editing with ex command-line editing rules. Final Answer: #

Question 5

Moving files up one level — send everything to ../bin  Which command moves all non-hidden files from the current directory into the bin subdirectory of the parent directory?

Accepted Answer

Introduction / Context: Unix file operations often involve reorganizing directories. Moving a collection of files one level up into a specific subdirectory is a common task. Using shell globs correctly avoids mistakes like overwriting or targeting the wrong path. Given Data / Assumptions: You are in a directory containing files you want to move. The destination is the bin subdirectory of the parent directory, i.e., ../bin. Hidden files (names beginning with a dot) are not included by the glob unless explicitly specified. Concept / Approach: The command mv * ../bin expands to all non-hidden entries in the current directory and moves them into ../bin. This is the minimal, portable form. You should ensure that ../bin exists and that the shell's glob does not expand to an empty list (some shells handle empty globs differently). Step-by-Step Solution: Verify destination exists: ls -ld ../bin.Preview the expansion: echo to see which files will move.Execute: mv * ../bin.Confirm by listing ../bin and the now-empty current directory (except hidden files). Verification / Alternative check: Use a dry run approach by testing in a temporary directory. For including dotfiles, use constructs like shopt -s dotglob in bash or explicit patterns (. ) with care. Why Other Options Are Wrong: mv . /bin/: targets system-wide /bin and matches only names containing a dot; risky and incorrect destination. mv * /bin/: tries to move into files that match /bin/ rather than the directory; incorrect and dangerous. mv * ../bin .: syntactically wrong for a single destination; provides extra arguments without clear intent. None of the above: incorrect because mv * ../bin is correct. Common Pitfalls: Overwriting files with the same name at the destination; forgetting that * excludes dotfiles; accidentally targeting /bin instead of ../bin; moving directories you did not intend to move. Final Answer: mv * ../bin

Question 6

Unix paging utilities: Which command displays a text file one screenful at a time with a default page length of 24 lines, allowing you to move forward through the file content?

Accepted Answer

Introduction / Context: When working at a Unix or Linux terminal, long files can scroll off the screen quickly. Pagers are utilities that show content a screenful at a time. Historically, the pg command uses a default page size of 24 lines, which is why many textbooks reference “view 24 lines at a time.” Knowing which pager provides that default helps with day-to-day system administration and exam questions alike. Given Data / Assumptions: The environment is a Unix-like shell. The goal is to view a file interactively by pages, not to print it or dump it all at once. The question calls out the classic default of 24 lines per page. Concept / Approach: Pagers offer interactive navigation. The pg utility (System V heritage) presents a file in 24-line chunks by default. It accepts navigation keystrokes (space to advance, q to quit). Other commands either do not paginate or are intended for different tasks (printing or raw output). Step-by-Step Solution: Identify the pager with a 24-line default: pg.Compare with more: more also paginates but is commonly tied to terminal height; the question’s signature phrasing points to pg.Exclude cat: it streams the entire file without paging.Exclude lp: lp sends jobs to the printer, not the screen.Therefore, choose pg as the correct command. Verification / Alternative check: Run pg /etc/services and press space to advance. You will see the content displayed page by page. For similar functionality with richer navigation, many modern systems use less, but the “24 lines” cue historically maps to pg. Why Other Options Are Wrong: more: A pager, but the question’s 24-line default is specifically associated with pg. cat: No paging; prints everything at once. lp: Submits a print job; not a viewer. None of the above: Incorrect because pg satisfies the requirement. Common Pitfalls: Assuming all pagers behave identically. While more and less are common, certification-style questions often expect pg when “24 lines” is emphasized. Also remember that page length can be affected by terminal size settings and environment variables. Final Answer: pg

Question 7

Shell redirection in Unix/Linux: Which operator should you use to append the standard output to the end of an existing file instead of overwriting its current contents?

Accepted Answer

Introduction / Context: Command-line redirection is fundamental in Unix and Linux. You frequently need to add new output to the end of a log or report without destroying what is already there. Distinguishing between overwrite and append operators prevents data loss and supports safe scripting. Given Data / Assumptions: You are writing standard output to a file. You want to preserve the file’s existing content and add new output at the end. Standard POSIX shell syntax is assumed (sh, bash, zsh, etc.). Concept / Approach: The operator > sends standard output to a file and truncates it first. The operator >> appends standard output to the file, creating it if it does not exist. Operators like < and << read from files or here-documents and do not write to files. Step-by-Step Solution: Choose the append operator: use >> to add to the end of a file.Example: echo "line" >> report.txt appends “line”.Avoid > when preservation matters, because it truncates existing content.Do not use input redirection (<, <<) for writing; they serve different purposes. Verification / Alternative check: Create a test file: echo "first" > demo.txt. Then append: echo "second" >> demo.txt. Display with cat demo.txt and confirm both lines appear, proving that >> appended rather than overwrote. Why Other Options Are Wrong: > symbols: Overwrites (truncates) the file before writing. < symbols: Redirects file content to command input (stdin), not output to a file. << symbols: Starts a here-document for multi-line input; not used to append output. None of the above: Incorrect because >> is exactly the append operator. Common Pitfalls: Accidentally using > when you intended to append can destroy logs. For safety, some shells support noclobber to prevent overwrites, or you can use >> consistently for logs. Always test redirections on scratch files first. Final Answer: >> symbols

Question 8

UNIX filesystem fundamentals: The traditional UNIX file system stores user data in physical disk blocks of which size (classic default on many systems)?

Accepted Answer

Introduction / Context: Block size is a foundational concept in filesystems. It affects performance, metadata density, and compatibility with disk hardware. Traditional UNIX designs commonly referenced 512-byte physical blocks (aligned with classic disk sectors), even though modern filesystems often use larger logical blocks internally for efficiency. Given Data / Assumptions: The question refers to the classic UNIX file system notion of physical blocks. We are not discussing modern ext4 default block sizes or filesystem cluster sizes, only the traditional “physical block” granularity. Values are in bytes and represent the size unit used to store on-disk data. Concept / Approach: Historically, UNIX literature describes a physical disk block as 512 bytes, matching the standard sector size of many legacy disks. While filesystems can aggregate multiple physical sectors into larger logical blocks (for example, 1 KB or 4 KB), the canonical baseline for many questions remains 512 bytes. Step-by-Step Solution: Recall legacy disk sector size: 512 bytes.Recognize that classic UNIX documentation often equates “physical block” with sector.Note that larger sizes (1024, 2048 bytes) are common for logical filesystem blocks, not necessarily physical blocks.Therefore select 512 bytes as the correct, traditional answer. Verification / Alternative check: Many older UNIX manuals and disk utilities (such as dd with bs=512) reinforce the 512-byte sector convention. Modern drives can expose 4096-byte sectors, but exam-style questions typically expect the historical 512-byte answer unless otherwise stated. Why Other Options Are Wrong: 1024 and 2048 bytes: Common as logical filesystem block sizes in some UNIX variants, but not the traditional physical block size asked here. 256 bytes: Too small for standard sector conventions; not a typical UNIX physical block size. None of the above: Incorrect because 512 bytes is valid. Common Pitfalls: Confusing “physical block/sector size” with “filesystem block size.” The former is a hardware-oriented minimum transfer unit, while the latter is a filesystem parameter, often a multiple of the sector size for efficiency. Final Answer: 512 bytes

Question 9

User-to-user communication on multiuser Unix systems: Which command enables an immediate two-way text conversation with another user who is currently logged in (real-time messaging to a terminal)?

Accepted Answer

Introduction / Context: Unix is a multiuser operating system. Beyond email, it provides terminal-based tools for instant, interactive communication between logged-in users. Knowing which utility initiates a real-time two-way chat is essential for classic administration tasks and historical compatibility. Given Data / Assumptions: The recipient user is currently logged in and has not blocked messages. The goal is immediate, interactive communication, not deferred mail. Standard single-host terminals or pseudo-terminals are in use. Concept / Approach: The write command sends text directly to another user’s terminal. Once you start typing after invoking write username, your lines appear on their screen. They can respond by issuing write back to you, achieving two-way communication. The mesg command simply allows or denies such messages; it does not send them. mail sends asynchronous messages via the local mail system. Step-by-Step Solution: Choose the real-time terminal chat tool: write.Invoke as write user or write user tty to target a specific terminal.Recipient replies with write yourname to establish two-way conversation.End with Ctrl+D (EOF) to terminate the session. Verification / Alternative check: Check the recipient’s ability to receive with mesg: if mesg n is set, your write will be blocked. Switching to mesg y allows incoming messages. This confirms that write is the chat mechanism and mesg is the permission control. Why Other Options Are Wrong: mail: Asynchronous email delivery; not a live chat. mesg: Toggles permission for receiving messages; does not send them. grep: Searches text; unrelated to messaging. None of the above: Incorrect because write is correct. Common Pitfalls: Forgetting to specify the correct TTY when a user has multiple logins; not checking mesg permissions; attempting to use write across different hosts without appropriate system support. Final Answer: write

Question 10

Bourne/Bash shell special parameters: In POSIX shells, what does the special variable $* expand to during script execution?

Accepted Answer

Introduction / Context: Shell scripts receive arguments as positional parameters. Special parameters like $, $@, $#, $?, , and $0 provide structured access to arguments, status codes, and process information. Understanding their semantics is critical for writing reliable scripts and interpreting command-line input. Given Data / Assumptions: We are using a Bourne-compatible shell (sh, bash, dash, ksh, zsh in sh mode). Double-quoting behavior matters for $* versus $@. We need the definition of $* specifically. Concept / Approach: $* expands to all positional parameters. When double-quoted, "$*" expands to a single word containing all parameters joined by the first character of IFS (often a space). By contrast, "$@" expands to separate words, one per parameter, preserving argument boundaries. Other parameters serve different roles like exit status ($?), process ID (), and script name ($0). Step-by-Step Solution: Recall: $ = all positional parameters in one expansion."$" = one word containing all arguments separated by IFS."$@" = multiple words, one per argument (preferred for safe argument passing).Therefore, select “list of all positional parameters as a single word.” Verification / Alternative check: In a script invoked as ./s a "b c" d, echo "$" outputs a b c d (one word with embedded spaces as separated by IFS), while echo "$@" outputs a on one field, b c as one field, and d as another, preserving argument boundaries. Why Other Options Are Wrong: Exit status: $? not $. Process ID: $$ not $. Command name: $0 not $. None of the above: Incorrect because the provided definition matches $. Common Pitfalls: Using "$" when you intend to forward arguments verbatim; prefer "$@" in that case to preserve argument separation. Be mindful of IFS changes, which alter how "$" joins arguments. Final Answer: list of all positional parameters as a single word

Question 11

Finding stale files by access time: With the Unix find command, which primary selects files that have not been accessed for more than 365 days?

Accepted Answer

Introduction / Context: System cleanup often targets files that have not been used recently. The find command offers predicates for selecting files by last access time (atime) and last modification time (mtime). Choosing the correct predicate avoids deleting files that are still in use. Given Data / Assumptions: The selection criterion is based on last access, not last modification. “More than 365 days” means strictly older than 365 days. We are using standard POSIX find semantics where +N means greater than N days. Concept / Approach: -atime n selects files accessed exactly n24 hours ago; -atime +n selects files accessed more than n24 hours ago; -atime -n selects files accessed less than n*24 hours ago. The corresponding predicates for modification are -mtime. Step-by-Step Solution: We need last access time older than 365 days.Use -atime because the criterion is access-based.Use the greater-than form: -atime +365.Example command: find /path -type f -atime +365 -print Verification / Alternative check: To check matches without deleting, first run with -print. To combine with deletion and confirmation, use -ok rm {} \; or to delete directly, -exec rm {} \;. You can also pair with -mtime if you additionally require no recent modifications. Why Other Options Are Wrong: -mtime + 365: Uses modification time, not access time; also the space is harmless but not standard style. -atime -365: Selects files accessed within the last 365 days (less than), not older. -mtime -365: Uses modification time and less than; wrong dimension and comparison. None of the above: Incorrect because -atime +365 is correct. Common Pitfalls: Confusing atime with mtime; forgetting that find counts in 24-hour units, not calendar days; not quoting parentheses when combining predicates; and testing delete actions on the wrong directory tree. Final Answer: -atime +365

Question 12

Controlling terminal messaging on Unix: Which command can a user employ to allow or restrict incoming write/wall messages to their terminal session?

Accepted Answer

Introduction / Context: On multiuser systems, terminal-to-terminal messaging (for example, write or wall) can interrupt your work. Unix provides a per-terminal permission toggle to allow or deny such messages, giving users control over their session’s privacy and noise level. Given Data / Assumptions: The user wants to control whether others can send messages to their terminal. We are dealing specifically with write/wall permissions, not email. Standard POSIX userland tools are available. Concept / Approach: The mesg command enables or disables message reception on the current terminal. Use mesg y to permit and mesg n to deny. This setting affects utilities like write and wall that attempt to output to your terminal device. Step-by-Step Solution: Identify the control utility: mesg.To block: mesg n; to allow: mesg y.Check current state by running mesg without arguments (varies by implementation).Combine with who or tty to identify terminals if you have multiple sessions. Verification / Alternative check: Ask a colleague to write to you: if mesg n is set, they will receive a “Message to user not allowed” error. Switching to mesg y immediately permits incoming messages, confirming the setting works per terminal. Why Other Options Are Wrong: grep: Text search; does not control terminals. halt: Shuts the system down; unrelated to messaging. sleep: Pauses execution for a set time; not a permission control. None of the above: Incorrect because mesg is the correct utility. Common Pitfalls: Forgetting that mesg applies to the current terminal only; blocking messages on one session does not affect others. Also, utilities like wall (broadcast) may be restricted by system policy independently of mesg on some systems. Final Answer: mesg

Question 13

Searching within files: Which command displays every line containing the literal string 'sales' from the file named empl.lst?

Accepted Answer

Introduction / Context: Searching text is a core Unix capability. grep scans files for patterns and prints lines that match. This forms the basis of countless data-processing pipelines, log reviews, and audit scripts. Recognizing correct grep usage is essential for effective command-line work. Given Data / Assumptions: The target file is empl.lst. The search pattern is the literal string sales. No regular expression anchors or case-insensitive flags are specified. Concept / Approach: The basic grep syntax is grep pattern file. By default, grep prints each matching line to standard output. You can add options like -i for case-insensitive search, -n for line numbers, or -w to match whole words only, but none are required here. Step-by-Step Solution: Select the search tool: grep.Apply the pattern and file: grep sales empl.lst.Output: All lines containing “sales”.Optionally refine: grep -i sales empl.lst for case-insensitive matches. Verification / Alternative check: Run grep sales empl.lst and compare output against manual inspection with less or more. Line count can be confirmed with grep -c sales empl.lst to ensure completeness. Why Other Options Are Wrong: cut sales empl.lst: cut selects columns; it does not search for strings. /sales > empl.lst: Looks like a vi search or sed address, not a shell command. cat | /sales > empl.lst: Invalid pipeline; /sales is not a command. None of the above: Incorrect because grep is correct. Common Pitfalls: Forgetting to quote patterns containing shell metacharacters; using grep without -F when the pattern includes regex special characters that should be treated literally; writing results back into the same source file inadvertently. Final Answer: grep sales empl.lst

Question 14

Capture and view output simultaneously: Which command copies standard output to a file while also echoing it to the terminal at the same time?

Accepted Answer

Introduction / Context: Sometimes you need to keep a record of command output while still monitoring it on screen. The tee utility solves this by duplicating standard output—writing to both a file and the terminal—making it invaluable for logging and troubleshooting pipelines. Given Data / Assumptions: The requirement is to save output to a file and display it simultaneously. We are using standard POSIX command-line tools. No special formatting or filtering is required. Concept / Approach: The syntax is cmd | tee file. By default, tee overwrites the file; use tee -a file to append. tee acts as a T-junction in a pipeline: it passes input through to standard output and also writes it to the named file(s). Step-by-Step Solution: Identify the duplication tool: tee.Form the pipeline: some_command | tee output.logTo append instead of overwrite: some_command | tee -a output.logConfirm that terminal shows live output while the file captures it. Verification / Alternative check: Run ls -lR / | tee listing.txt. Observe output on screen and verify listing.txt contains the same data. Re-run with -a to append additional listings without truncating previous content. Why Other Options Are Wrong: more and cat: Display output but do not simultaneously save to a file. grep: Filters lines by pattern; does not split output to a file and screen. None of the above: Incorrect because tee matches the requirement exactly. Common Pitfalls: Forgetting -a when you intend to append; accidentally overwriting existing logs; misunderstanding that tee only captures what is piped into it (stdout), not stderr unless you redirect stderr to stdout (for example, 2>&1). Final Answer: tee

Question 15

vi/Vim navigation shortcut: In the vi editor, typing a line number followed by the uppercase letter G moves the cursor where?

Accepted Answer

Introduction / Context: Efficient navigation is the hallmark of expert vi/Vim usage. Jumping directly to a specified line saves time when editing large files or investigating error messages that include line numbers. The [number]G motion is one of the fastest ways to reposition the cursor precisely. Given Data / Assumptions: We are in command (normal) mode in vi or Vim. A numeric prefix is entered before the uppercase letter G. We want to know the effect of this motion on cursor position. Concept / Approach: In normal mode, G without a count moves to the end of the file. Prepending a count moves to that exact line number. The cursor is placed at the first non-blank character of the target line (behavior may vary slightly with settings), effectively moving to the beginning for editing purposes. Step-by-Step Solution: Enter normal mode (press Esc).Type the desired line number, for example 120.Press uppercase G: the cursor jumps to line 120.Verify with :. (print current line number) or :set number to see line numbers. Verification / Alternative check: Use :120 as an alternative command-line mode jump, which also moves to line 120. Both methods place the cursor on the specified line, confirming the mapping of [line number] + G. Why Other Options Are Wrong: Left/right by one position: That is h and l in normal mode. Down by one line: That is j; G with a count is a direct jump, not a single-line move. None of the above: Incorrect because [number]G is exactly the go-to-line operation. Common Pitfalls: Using lowercase g (a different motion in Vim), forgetting to be in normal mode, or typing an invalid line number, which causes movement to the nearest valid boundary (start or end). For extremely large files, consider :set number and search commands like /pattern to combine jumps and searches. Final Answer: to the beginning of the line specified by the number

Question 16

vi editor basics: In the classic vi editor (or Vim in vi-compatibility mode), which command saves the current file to disk but keeps you in edit mode (does not quit)?

Accepted Answer

Introduction / Context: Efficient editing in UNIX/Linux often relies on the vi editor (and its enhanced successor, Vim). Knowing the difference between save-only and save-and-quit commands is essential to prevent accidental exits and to preserve work frequently during long edit sessions. Given Data / Assumptions: You are editing a file in vi/Vim using ex-style colon commands. You want to write (save) the file to disk but stay in the editor to continue working. No special file permissions issues are involved (writable buffer). Concept / Approach: Colon commands in vi provide file-level and session-level actions. The command :w writes the current buffer to the associated filename. Commands like :x and :wq both write and exit, while :q attempts to quit and :q! forces quit without saving. Therefore, the save-only action corresponds to :w. Step-by-Step Solution: Enter command-line mode by pressing the colon key.Type w to form :w and press Enter.Observe the status message indicating bytes written and the filename.Continue editing; your session remains open in vi.Use :w filename to write to a new file name if needed (save-as behavior). Verification / Alternative check: Use :ls or :buffers in Vim to confirm buffer state, and check timestamps with ls -l from a shell to ensure the write occurred. Reopen the file to confirm your recent changes persist. Why Other Options Are Wrong: a: :q attempts to quit; it does not save, and it exits if there are no unsaved changes. c: q! forces quit without saving—dangerous if you intend to keep edits. d: :x writes and quits (similar to :wq), not save-only. e: Not applicable because :w is the correct save-and-stay command. Common Pitfalls: Mistyping :wq instead of :w, which will exit unintentionally; forgetting to write with elevated privileges when editing protected files (use :w !sudo tee % in Vim); confusing uppercase Q (ex mode) with :q. Final Answer: :w

Question 17

Process control in UNIX: Which command syntax sends a signal to all processes in your current process group (effectively terminating all your processes except the controlling login shell in many shells)?

Accepted Answer

Introduction / Context: UNIX process management hinges on signals delivered by the kill utility. Besides sending a signal to a single PID, kill can target groups of processes. Understanding special PID values helps you control runaway processes without logging out or killing the login shell itself. Given Data / Assumptions: The shell running kill is your interactive login shell. You want to terminate processes you started, typically in the same process group. No elevated privileges are assumed; only processes you own are signaled. Concept / Approach: By POSIX convention, kill 0 sends a signal to every process in the same process group as the sender. In many interactive shells, the login shell is the group leader and does not terminate when you send SIGTERM to the group from within it (though behavior can vary by shell and signal). This makes kill 0 a practical way to clean up child jobs you launched. You can also specify signals, for example kill -TERM 0 or kill -KILL 0 for a forceful stop. Step-by-Step Solution: List your processes (ps -f) to understand what will be affected.Run kill 0 to send SIGTERM to your process group.If needed, escalate with kill -KILL 0 for stubborn processes.Verify remaining jobs with jobs or ps to ensure cleanup succeeded.Avoid targeting PID 1 (init/systemd) as it is critical. Verification / Alternative check: Compare before/after output of ps -o pid,pgid,comm to observe signals delivered to the shared process group. Confirm your shell remains functional. Why Other Options Are Wrong: a: kill 1 targets PID 1 (init/systemd)—never use for this purpose. c, d: cancel is not a standard UNIX signal command. e: Not applicable since kill 0 is the correct group-targeting usage. Common Pitfalls: Assuming identical behavior across all shells; using -KILL immediately (gives no cleanup chance); running the command under sudo, which may broaden impact beyond your own processes. Final Answer: kill 0

Question 18

ls output formatting: Which command lists filenames in multiple columns across the terminal (compact, side-by-side layout)?

Accepted Answer

Introduction / Context: Directory listings can be tailored to different needs. When scanning many filenames quickly, a compact multi-column listing helps maximize screen real estate. The ls utility provides flags to adjust layout, sorting, and detail level. Given Data / Assumptions: You want a compact, multi-column display. Terminal width is sufficient for columns. No need for long metadata (owner, size, permissions). Concept / Approach: ls without options may choose a default multi-column format, but behavior varies by environment variables and aliases. The option -x explicitly sorts entries across, then down, and displays them in multiple columns, producing a dense, readable layout. In contrast, -1 forces one entry per line, and -l shows a detailed long listing. Step-by-Step Solution: Run ls -x in a directory with many files.Observe that filenames are arranged in multiple columns across the screen width.Resize the terminal to see how column count adapts.Use ls -C (uppercase C) on some systems for columnar display down then across; verify your platform's man page.Combine with -a to include dotfiles if needed. Verification / Alternative check: Compare outputs of ls, ls -1, and ls -x to confirm that -x is providing the intended multi-column across display consistently regardless of defaults or aliases. Why Other Options Are Wrong: a: ls alone may be multi-column but is not guaranteed; the question asks for a command that ensures multiple columns. b: ls -1 forces one item per line. d: lc is not a standard command. e: Not applicable; ls -x is the correct explicit choice. Common Pitfalls: Relying on default ls aliases that already add options; forgetting to use -a when hidden files should appear; mixing -x with -l (they conflict in layout goals). Final Answer: ls -x

Unix Questions