Question 1

Copying files in UNIX/Linux  Which command copies a regular file (and, with flags, can also copy directories)?

Accepted Answer

Introduction / Context: File copying is foundational in system administration and scripting. UNIX/Linux uses a concise, portable command to copy files, preserve attributes, and recursively copy directory trees with optional flags for safety and verbosity. Given Data / Assumptions: You need to copy files between paths on the same system. Basic permissions allow reading source and writing destination. Standard POSIX toolset available. Concept / Approach: The cp command copies files. Common flags include -r or -R for recursive directory copy, -p to preserve mode, ownership, and timestamps, -i to prompt before overwrite, and -v for verbose progress. For archival purposes, tools like tar or cpio are preferable, but for direct filesystem copies, cp is primary. Step-by-Step Solution: Copy a single file: cp source.txt dest.txtCopy into a directory: cp source.txt /path/dir/Recursive directory copy: cp -R srcdir dstdirPreserve attributes: cp -p source dest Verification / Alternative check: Use ls -l and diff or checksums (md5sum/sha256sum) to verify results. For maintaining sparse files or extended attributes, consult distro-specific flags or use rsync. Why Other Options Are Wrong: copy (Option A) is a DOS/Windows command, not UNIX.cpio (Option C) and tar (Option D) are archiving tools rather than simple copy utilities. Common Pitfalls: Overwriting files unintentionally; use -i or backups. Forgetting -R when copying directories, resulting in “omitting directory”. Losing timestamps or ownership without -p when that metadata matters. Final Answer: cp

Question 2

chmod practice (symbolic mode example)  For a file named note, which command removes execute permission from the user (owner) and grants read permission to the group and others?

Accepted Answer

Introduction / Context: Symbolic chmod expressions allow precise, readable permission changes. Administrators frequently need to revoke execute rights from owners while providing read access to collaborators, making a combined symbolic expression convenient and auditable in scripts and documentation. Given Data / Assumptions: Target file is note. Desired result: user loses x; group gains r; others gain r. Order of symbolic operations can be combined with commas in a single command. Concept / Approach: Use classes u (user), g (group), o (others) and operators + (add), - (remove). Multiple clauses separated by commas are applied left-to-right. Here we want to remove x for u and add r for g and o. The syntax can be expressed as one command against the file note. Step-by-Step Solution: Remove user execute bit: chmod u-x noteAdd read for group and others: chmod go+r noteCombine: chmod u-x,go+r noteVerify: ls -l note shows expected r bits and no x for user. Verification / Alternative check: Numeric equivalent depends on prior bits; to set absolutely, use = with known baseline (e.g., chmod u=rw,g=r,o=r note to force 644). Symbolic modification is safer when you only intend relative changes. Why Other Options Are Wrong: Option B adds user execute (u+x), opposite of requirement.Option C removes group execute (g-x) but does not address user execute; also grants read to user and others (uo+r) inexactly.Option D adds execute to group and others (go+x), contrary to the brief. Common Pitfalls: Mistyping commas or spaces causing the shell to parse separate commands incorrectly. Confusing class letters; u is owner, not user accounts in general. Forgetting to quote filenames containing spaces. Final Answer: chmod u-x, go+r note

Question 3

Removing files on UNIX/Linux  Which standard command removes one or more files from the filesystem?

Accepted Answer

Introduction / Context: Deleting files is a frequent operation in UNIX/Linux. The shell provides a well-known command that removes files and, with appropriate flags, directories. Proper usage prevents accidental data loss and supports scripted cleanups in build systems and cron jobs. Given Data / Assumptions: You have permission to remove the specified files. Wildcards may match multiple files; the shell expands them before rm runs. Removed files typically cannot be recovered without backups or special tools. Concept / Approach: The rm command removes directory entries, effectively deleting files. Common flags: -i (interactive prompt), -f (force), -r or -R (recursive for directories), and -v (verbose). Always double-check patterns to avoid unintended deletions. Step-by-Step Solution: Remove a file: rm file.txtPrompt before each removal: rm -i *.logRemove a directory tree carefully: rm -r old_projectCombine force and recursive (use cautiously): rm -rf tmpdir Verification / Alternative check: List directory contents with ls before and after. Use trash utilities on desktop environments if you prefer recoverable deletions; rm bypasses a “trash can.” Why Other Options Are Wrong: erase (Option A) and delete (Option B) are DOS/Windows commands, not standard UNIX.dm (Option D) is not a removal command.None of the above (Option E) is incorrect because rm is correct. Common Pitfalls: Using sudo rm -rf with an incorrect path or extra space. Forgetting quotes around patterns, causing the shell to expand unexpectedly. Attempting to remove write-protected files without -f or proper permissions. Final Answer: rm

Question 4

Creating links in UNIX/Linux filesystems  Which command is used to create links (hard or symbolic) between files or paths?

Accepted Answer

Introduction / Context: Links allow multiple directory entries to reference the same data (hard links) or act as pointers to other pathnames (symbolic links). They are fundamental to UNIX/Linux filesystem flexibility, enabling aliasing, versioned paths, and shared resources without duplication. Given Data / Assumptions: Filesystem supports hard links (most native UNIX filesystems do; not across filesystems for hard links). Symbolic links can cross filesystems and point to directories. Proper permissions exist for creating the link at the destination. Concept / Approach: The ln command creates links. By default it creates hard links; with -s it creates symbolic links. A hard link increases a file’s link count and references the same inode. A symbolic link stores a pathname and resolves at access time, useful for redirects and version management. Step-by-Step Solution: Create a hard link: ln original.txt alias.txtCreate a symbolic link: ln -s /opt/app/current/bin/app ~/bin/appVerify with ls -li (inodes) and ls -l (symlink arrow).Remove links safely; deleting a symlink does not delete the target file. Verification / Alternative check: Use stat to view link counts on hard-linked files. Confirm that editing either hard-linked name changes the same underlying data. Why Other Options Are Wrong: lk (Option A) is not a standard link command.cp (Option C) copies data, it does not create links.tar (Option D) archives; it does not create filesystem links. Common Pitfalls: Trying to hard-link directories (usually disallowed) or across filesystems (not possible). Breaking symlinks by moving targets; relative symlinks often survive moves better within a tree. Overwriting existing symlinks without using ln -sf carefully. Final Answer: ln

Question 5

vi editor modes: identifying a non–input command Which of the following is not an input-mode command in vi (i.e., it does not enter insert/replace input)?

Accepted Answer

Introduction / Context: vi is a modal editor with distinct normal and input modes. Normal mode focuses on navigation and structural edits, while input (insert/replace) modes accept literal text. Recognizing which keystrokes change modes is critical to editing efficiently and avoiding unintended modifications. Given Data / Assumptions: Standard vi/Vim behavior in normal mode. Commands considered: i, a, A, j, R. Goal: identify the one that does not enter an input (insert/replace) mode. Concept / Approach: Commands i (insert before cursor), a (append after cursor), A (append at end of line), and R (replace mode) all enter an input context where typed characters are inserted into the buffer. In contrast, j is a movement command that moves the cursor down one line and keeps you in normal mode without accepting typed text as input. Step-by-Step Solution: Press i → editor enters insert mode; status often shows -- INSERT --.Press a → append after cursor; input mode begins.Press A → jump to EOL and begin appending; input mode.Press R → enter replace mode; typing overwrites characters.Press j → cursor moves down; no mode change to input occurs. Verification / Alternative check: Observe the mode indicator in Vim or attempt to type letters after pressing j; the letters will be interpreted as further commands, confirming normal mode persists. Why Other Options Are Wrong: i starts insert mode immediately.a and A append and therefore enter input mode.R starts replace (input) mode until Esc is pressed. Common Pitfalls: Confusing R (replace) with r (single-character replace in normal mode). Forgetting to press Esc to exit input modes before issuing navigation commands. Accidentally mapping j in custom vimrc to something else; defaults assume movement. Final Answer: j

Question 6

UNIX/Linux shell usage: Which command saves the output of the who command into a file named user.lst while simultaneously displaying the same output on the terminal?

Accepted Answer

Introduction / Context: The UNIX/Linux shell provides simple but powerful tools to capture command output to files. Sometimes you want to both see the output on screen and save it for later review. The tee utility is designed exactly for this purpose, splitting the output stream so that it is written to a file and echoed to the terminal at the same time. Given Data / Assumptions: You are running who to list currently logged-in users. You need the results stored in a file named user.lst. You also want the output to remain visible on your screen. Concept / Approach: The pipeline operator | sends the standard output of the command on the left to the command on the right. The tee program reads from standard input, writes the same data to a file, and passes it through to standard output, so the terminal still shows it. Redirection operators like > and >> only write to files and do not mirror to the screen by default. Step-by-Step Solution: Run: who | tee user.lsttee creates or overwrites user.lst and echoes the same output to the terminal.Confirm by opening user.lst or by running cat user.lst.Use tee -a to append instead of overwrite when needed. Verification / Alternative check: Compare with who > user.lst (no terminal display) and who >> user.lst (appends, still no terminal display). Only tee duplicates output to both destinations simultaneously. Why Other Options Are Wrong: who > user.lst: saves but does not display on screen. who >> user.lst: appends but also hides output. who < user.lste: attempts input redirection from a likely non-existent file; unrelated to capturing output. None of the above: incorrect because the tee solution exists. Common Pitfalls: Forgetting that > truncates existing files; using >> unintentionally grows logs; assuming redirection shows output on screen. Use tee -a for safe appends. Final Answer: who | tee user.lst

Question 7

UNIX login initialization: Which per-user startup file contains shell instructions that are executed automatically when a user logs in (for Bourne/POSIX-compatible shells)?

Accepted Answer

Introduction / Context: On UNIX and Linux, each user can customize the shell environment at login. The shell reads specific dotfiles in the user’s home directory to set variables, change the PATH, define aliases, and start background agents. Knowing which file is executed at login is essential for persistent configuration and troubleshooting environment issues. Given Data / Assumptions: You are using a Bourne-compatible shell (sh, ksh, bash in POSIX mode). You want commands to run automatically at login time. Dotfiles are hidden files stored in the user’s home directory. Concept / Approach: For Bourne/POSIX shells, the standard login initialization file is ~/.profile. When a login shell starts, it sources this file and applies exported variables, PATH changes, and other startup logic. Other shells have different files (e.g., bash also uses ~/.bash_profile or ~/.bash_login; csh/tcsh use ~/.login and ~/.cshrc), but .profile is the classic answer for Bourne-style shells. Step-by-Step Solution: Create or edit ~/.profile in your home directory.Add environment settings such as PATH, umask, and aliases.Log out and back in, or run . ~/.profile to apply changes immediately.Verify with echo $PATH or alias to confirm the changes took effect. Verification / Alternative check: Check your shell’s manual (man sh, man bash) for the exact startup file order. On bash, ~/.bash_profile may be preferred; if absent, bash will fall back to ~/.profile for login shells. Why Other Options Are Wrong: .exrc: vi editor configuration, not a shell login file. .autoexec / autoexec.bat: DOS/Windows legacy startup files, not UNIX. None of the above: incorrect because ~/.profile is valid. Common Pitfalls: Editing the wrong file for the shell in use; forgetting to export variables; expecting changes to apply to already running shells without sourcing the file. Final Answer: .profile

Question 8

UNIX file permissions: Which chmod command sets read-only permission for all categories (user, group, and others) on a file named note, removing any write or execute rights?

Accepted Answer

Introduction / Context: The chmod command adjusts read (r), write (w), and execute (x) permissions for the owner (u), group (g), and others (o). A common requirement is to make a file readable by everyone while disallowing modifications and execution. Understanding symbolic modes helps you express that concisely and safely. Given Data / Assumptions: Target file is named note. Desired permission: read-only for user, group, and others. Any previously set write/execute bits should be cleared. Concept / Approach: Symbolic mode ugo=r sets the permissions for all three classes to exactly read-only. The equals sign (=) assigns the specified set and clears all other bits. This guarantees there is no lingering execute or write access for any class. Using additive modes (+ or -) can be ambiguous if you do not also remove unwanted bits. Step-by-Step Solution: Run: chmod ugo=r noteConfirmation: ls -l note should show -r--r--r-- (assuming a regular file and no special bits).Optionally, verify with stat note to view octal mode (444). Verification / Alternative check: Compare with chmod 444 note which is the octal equivalent of read-only for all. Both approaches yield the same result. Why Other Options Are Wrong: chmod go+r note: adds read for group/others but does not restrict user or clear execute/write that may exist. chmod a-rw: removes read and write for all, not read-only. chmod u+r,g+r,o-x note: adds some permissions and removes only others’ execute; it does not ensure a universal read-only state. Common Pitfalls: Using +r without removing w/x; forgetting that execute is needed for directories to traverse; applying read-only to scripts that still need execute permission to run. Final Answer: chmod ugo=r note

Question 9

UNIX permission bits (octal): For a mode of 652 (owner=6, group=5, others=2), which statement is true about the resulting permissions?

Accepted Answer

Introduction / Context: UNIX file permissions are often represented in octal form as owner-group-others. Each digit sums the bits: read=4, write=2, execute=1. Correctly interpreting these digits ensures accurate security settings and prevents accidental exposure or loss of access. Given Data / Assumptions: Octal mode is 652. Owner digit 6 means read + write. Group digit 5 means read + execute. Others digit 2 means write only. Concept / Approach: Break 652 into three classes. Owner=6 maps to r and w (4+2). Group=5 maps to r and x (4+1). Others=2 maps to w only. Validate each provided statement against these derived permissions to find the single correct description. Step-by-Step Solution: Owner 6: r=4, w=2, x=0 → rw-.Group 5: r=4, w=0, x=1 → r-x.Others 2: r=0, w=2, x=0 → -w-.Evaluate statements: owner execute? No. others write? Yes. group read+write? No, it is read+execute. Verification / Alternative check: Use a quick mnemonic: 7=rwx, 6=rw-, 5=r-x, 4=r--, 2=-w-, 1=--x. This cross-check confirms that others have write permission in 652. Why Other Options Are Wrong: Execute permission for the owner: owner has rw-, no execute. Read and write permission of groups: group has r-x, not write. All of the above/None of the above: inconsistent with the analysis; only the statement about “write for others” is true. Common Pitfalls: Confusing group and others digits; assuming “5” includes write; forgetting that octal 2 is write-only. Always decompose each digit into 4, 2, and 1 to avoid mistakes. Final Answer: Write permission for others

Question 10

UNIX basics: Which command removes (deletes) an empty directory from the filesystem?

Accepted Answer

Introduction / Context: Managing directories is a routine UNIX/Linux task. When a directory is no longer needed and is empty, you can remove it with a specific command. Using the proper utility prevents accidental data loss and ensures compatibility across systems. Given Data / Assumptions: The directory to be removed is empty. You have the necessary permissions on the parent directory. You are using standard POSIX tools. Concept / Approach: The rmdir command removes empty directories. If the directory contains files or subdirectories, rmdir will fail. For non-empty directories, use rm -r carefully. Some systems offer convenience flags like rmdir -p to remove parent directories if they become empty, but the fundamental rule remains: rmdir only works on empty directories. Step-by-Step Solution: Ensure the directory is empty: ls DIR should show no entries (other than . and ..).Run: rmdir DIRIf removing a nested empty path, consider rmdir -p parent/child.Verify by listing the parent directory. Verification / Alternative check: If rmdir fails with “Directory not empty,” remove contents first or use rm -r with extreme caution. Confirm permissions with ls -ld on the parent directory since write/execute on the parent affect deletion. Why Other Options Are Wrong: rd, remove, rdir: not standard POSIX commands; may exist on other platforms or shells as aliases, but not portable UNIX. None of the above: incorrect because rmdir is correct. Common Pitfalls: Attempting to remove non-empty directories with rmdir; lacking write permission on the parent directory; accidentally using rm -r without double-checking contents. Final Answer: rmdir

Question 11

UNIX utilities: What is the primary purpose of the cat command when used on a regular text file?

Accepted Answer

Introduction / Context: The cat utility (short for “concatenate”) is among the most frequently used UNIX commands. Although it can join multiple files, its most common everyday use is to write the contents of a file to standard output, effectively displaying it on the terminal or piping it to other commands. Given Data / Assumptions: We are discussing cat with a single regular text file argument. Output appears on the terminal unless redirected or piped. Printing to paper or making filesystem copies is not implied by cat alone. Concept / Approach: cat filename reads the file and writes its contents to standard output. This makes it ideal for quick inspections, for feeding content into pipelines (e.g., cat file | grep pattern), and for concatenating several files into a new file via redirection. Step-by-Step Solution: To display: cat notes.txtTo concatenate: cat a.txt b.txt > merged.txtTo pipe: cat config | grep timeoutTo number lines (via another tool): cat file | nl Verification / Alternative check: Compare cat file with less file or more file; less is better for paging, but cat is fastest for streaming small files. For copying, use cp, and for printing to paper, use lp or lpr. Why Other Options Are Wrong: capture a file: vague and not a standard term. print a file: printing requires lpr/lp; cat only sends to stdout. copy a file: cp performs copies; cat can be used in redirections but that is not its primary role. Common Pitfalls: Using cat for very large files floods the terminal; preferring less/more for paging; unintentionally overwriting files with redirection if careless. Final Answer: display a file

Question 12

Shell globbing: Which wildcard matches any number of characters (including zero characters) when expanding filenames in a POSIX shell?

Accepted Answer

Introduction / Context: Filename expansion (globbing) lets you select sets of files using wildcards in the shell. Understanding how each wildcard behaves is essential for writing correct commands, avoiding accidental matches, and building robust scripts. Given Data / Assumptions: You are using a POSIX-like shell (bash, dash, ksh, zsh in sh-compatibility). You want a wildcard that can match zero or more characters. Hidden files do not match unless the pattern begins with a dot or dotglob is set. Concept / Approach: The asterisk * matches any sequence of characters, including the empty string. The question mark ? matches exactly one character. Bracket expressions like [ijk] match exactly one character from a specified set, while [!ijk] matches exactly one character not in the set. Therefore, * is the general wildcard for “zero or more characters.” Step-by-Step Solution: Use .txt to match all names ending with .txt (zero or more characters before .txt).Use file to match file, file1, file_backup, etc.Use * (alone) to match all non-hidden entries in the current directory.Combine with other tools: ls .log | wc -l to count logs. Verification / Alternative check: Run echo .txt to see which names expand. To include hidden files, use a leading dot like . or enable dotglob in Bash. Why Other Options Are Wrong: ? matches exactly one character. [ijk] matches one character chosen from i, j, k. [!ijk] matches one character not in {i, j, k}. None of these allow zero or variable-length matching. Common Pitfalls: Expecting * to match dotfiles; confusing globbing with regular expressions where . and * have different meanings; forgetting quotes which can prevent expansion when desired. Final Answer:

Question 13

UNIX reminders: Which command provides a simple automatic reminder service that emails upcoming events listed in a user’s calendar file?

Accepted Answer

Introduction / Context: Classic UNIX systems include lightweight utilities for notifications and reminders. One such tool is calendar, which scans a user-maintained file of dates and events and can notify the user (typically by email) when those dates are imminent. Given Data / Assumptions: A per-user calendar file (often named calendar) exists in the home directory. The system runs calendar periodically (e.g., via cron) to check upcoming dates. Notifications are sent via local mail or display when invoked interactively. Concept / Approach: The calendar utility reads the user’s calendar file, matches entries against today’s (and sometimes tomorrow’s) date, and outputs matching lines. System administrators can schedule it to email reminders. Other commands like write and mesg handle live terminal messaging and permission for messages, while mail is a general mail reader and sender rather than an automatic reminder engine. Step-by-Step Solution: Create a ~/calendar file with lines like “08/15 Team demo at 2 PM”.Run calendar manually or set up a cron job to invoke it daily.Read reminders in terminal output or local mailbox, depending on system setup.Update the file as events change to keep reminders accurate. Verification / Alternative check: Run calendar - to test formatting; consult system documentation for locale-specific date formats. Check local mail with mail or mailx to confirm delivery. Why Other Options Are Wrong: write: sends interactive messages to logged-in users. mesg: toggles permission to receive write wall messages. mail: general-purpose mail tool, not an automatic reminder service by itself. Common Pitfalls: Incorrect date formats; forgetting to enable cron or system integration; assuming calendar reads from system-wide calendars without configuration. Final Answer: calendar

Question 14

grep regular expressions: Which pattern anchors a match to the end of a line so that only lines ending with the text “pat” are selected?

Accepted Answer

Introduction / Context: grep uses basic regular expressions to match text in files or streams. Anchors are special metacharacters that constrain where a pattern must appear in a line. The dollar sign $ anchors the pattern to the line end, and the caret ^ anchors to the line start. Given Data / Assumptions: You want lines that end with the literal substring “pat”. You are using grep (basic regex) without extended flags. No special escaping is needed for letters; anchors retain their special meaning. Concept / Approach: To match “pat” only at the end, write pat$ so that “pat” must immediately precede the end of the line. Using ^pat would instead require “pat” at the beginning. Placing anchors incorrectly or in the wrong order will change the match or render it meaningless. Step-by-Step Solution: Use: grep 'pat$' file.txtThis returns lines whose final characters read “pat”.Test with echo -e 'pat
compat
pattern' | grep 'pat$' → matches “pat” and “compat”.If you need an exact whole-line match, use ^pat$ instead. Verification / Alternative check: Experiment with ^pat to see it matches only at the start. Combine with character classes or quantifiers as needed, keeping the $ at the end to enforce line-ending. Why Other Options Are Wrong: ^pat: start-of-line anchor. $pat / pat^: misordered anchors; not meaningful for the intended end-of-line constraint. None of the above: incorrect because pat$ is correct. Common Pitfalls: Forgetting that grep patterns are regex, not globbing; neglecting to quote the pattern in the shell to avoid unintended expansions; confusing ^ and $ with shell anchors. Final Answer: pat$

Question 15

Interpreting permission triplets: In a long listing, the first permission triplet shows “rw-” for the owner. What does this indicate about the owner’s access rights on that file?

Accepted Answer

Introduction / Context: UNIX ls -l displays file permissions in triplets for owner, group, and others. Each triplet is a sequence of three characters representing read (r), write (w), and execute (x). Correctly reading these triplets is critical for understanding who can view, modify, or run a file. Given Data / Assumptions: The owner’s permission triplet is rw-. r means read access, w means write access, and - means no execute permission. The context is a regular file (special bits are not shown here). Concept / Approach: Permission rw- equals read plus write for the owner, without execute. It allows the owner to view and modify the file contents but not execute it as a program or script (without changing permissions). This interpretation holds for both files and directories, though for directories execute has a different meaning (traversal), which is not present here. Step-by-Step Solution: Identify characters: r (read) present, w (write) present, x (execute) absent.Map to capabilities: read contents and modify contents; execution denied.State the result in plain words: owner has read and write permissions. Verification / Alternative check: Use chmod u+x filename to add execute and observe the triplet change from rw- to rwx. Use stat -c %A filename to display permissions in symbolic form. Why Other Options Are Wrong: Executable only: contradicts rw-. Write+execute or read+execute: inconsistent with the shown characters. None of the above: incorrect because rw- clearly means read and write. Common Pitfalls: Confusing directory execute (search/traverse) with file execute; misreading the position of triplets (owner vs group vs others); ignoring special bits like setuid which appear elsewhere in the string. Final Answer: both read and write permissions

Question 16

vi/vim navigation — moving the cursor left  In the classic vi (and vim in normal mode), which single-key motion command moves the cursor one character to the left?

Accepted Answer

Introduction / Context: Efficient text editing in Unix-like systems often relies on the vi/vim editor. Mastering the basic motion keys lets you navigate without leaving the home row. This question checks your knowledge of the fundamental h-j-k-l navigation pattern used to move the cursor left, down, up, and right in normal mode. Given Data / Assumptions: The editor is vi or vim operating in normal (command) mode, not insert or visual mode. We are using default key bindings (no remapping). The task is to move exactly one character position to the left. Concept / Approach: vi was designed for terminals without arrows. The navigation keys were placed under the right hand: h (left), j (down), k (up), l (right). Movement commands act once per keystroke but can be repeated with a numeric count. They do not insert text; they reposition the cursor only. Step-by-Step Solution: Ensure you are in normal mode by pressing Esc.Use h to move left by one character.Optionally, prefix with a count (for example, 5h moves left five characters).Remember the full set: h=left, j=down, k=up, l=right. Verification / Alternative check: Open any file, place the cursor in the middle of a word, press h repeatedly, and observe the cursor shift left. Compare with l (right) and j/k (vertical movement) to reinforce the mapping. Why Other Options Are Wrong: i: enters insert mode; it does not move left. j: moves the cursor down one line. k: moves the cursor up one line. None of the above: incorrect because h is correct. Common Pitfalls: Forgetting to leave insert mode before attempting movement; assuming arrow keys are required; holding the key continuously instead of using counts for faster movement; remappings that change defaults in personal configs. Final Answer: h

Question 17

vi/vim navigation — scroll half a page backward (up)  In vi/vim normal mode, which control-key command scrolls the screen up by half a page (i.e., a half-page backward)?

Accepted Answer

Introduction / Context: Beyond single-line cursor moves, vi/vim provides efficient paging commands to move through large files quickly. Knowing half-page and full-page scrolls is essential for rapid navigation without losing context. Given Data / Assumptions: Editor is vi/vim in normal mode. We need the half-page scroll upward (backward through the file). Default key bindings are in effect. Concept / Approach: In vi/vim, Ctrl+U scrolls upward by half a screen (half a page). Its opposite is Ctrl+D, which scrolls downward by half a screen. Full-page equivalents are Ctrl+B (back) and Ctrl+F (forward). These scrolling commands move the window while keeping the cursor in view. Step-by-Step Solution: Ensure normal mode (press Esc).Press Ctrl+U to scroll up by half a page.Use Ctrl+D to scroll down by half a page if needed.For full pages, use Ctrl+B (up) and Ctrl+F (down). Verification / Alternative check: Open a long file, note the line numbers on the screen, press Ctrl+U, and observe that the topmost line advances toward lower numbers by roughly half the window height. Repeat with Ctrl+D to confirm symmetry. Why Other Options Are Wrong: [Control-d]: scrolls half a page down (forward), not up. [Control-c]: interrupts operations in many shells/contexts, not a vi scroll. [Control -P]: not a standard vi paging command; in insert mode Ctrl+P may complete words in vim but does not scroll. None of the above: incorrect because Ctrl+U is correct. Common Pitfalls: Confusing Ctrl+U with undo (u); mixing up half-page commands (Ctrl+U vs Ctrl+D); forgetting that these are view scrolls and do not change file content. Final Answer: [Control - u]

Question 18

Unix cmp utility — report differing byte numbers and values in octal  Which cmp option produces a detailed list of each differing byte position along with the differing byte values in octal for two files being compared?

Accepted Answer

Introduction / Context: The cmp command is a binary comparator used to identify differences between two files. While its default output is minimal, certain options enable detailed byte-by-byte diagnostics, which are invaluable for debugging binary data or investigating subtle file corruption. Given Data / Assumptions: We are comparing two files with cmp. We want a detailed list of differences: byte offsets and byte values. Output should show octal representations of differing bytes. Concept / Approach: cmp -l file1 file2 outputs each mismatch as a line containing the 1-based byte position, the byte value from the first file in octal, and the byte value from the second file in octal. This contrasts with the default behavior, which only reports the first difference and stops. Other options change exit behavior but do not produce this detailed listing. Step-by-Step Solution: Choose the verbose difference listing option: -l.Run: cmp -l file1.bin file2.bin.Read each line: position and octal values for both files.Use the output to pinpoint exact byte offsets for patching or verification. Verification / Alternative check: Create two small files with known byte differences and compare them. Verify that the listed byte numbers and octal values match expectations. You can cross-check with od -An -tx1 -v or xxd for hex dumps. Why Other Options Are Wrong: -d: not the detailed octal difference listing in standard cmp. -r: nonstandard for cmp; often relates to recursion in other tools. -b: not the correct cmp verbose setting for octal differences. None of the above: incorrect because -l is correct. Common Pitfalls: Expecting 0-based positions (cmp uses 1-based); misreading octal values as decimal or hex; assuming cmp behaves like diff, which is line-oriented rather than byte-oriented. Final Answer: -l

Question 19

Changing to your home directory in Unix shells  Which command returns the current shell to the user's home directory using the standard POSIX behavior?

Accepted Answer

Introduction / Context: Navigating directories is a daily task in Unix/Linux. Returning quickly to your home directory saves time. The POSIX standard defines a simple way to do this that works across Bourne-like shells (sh, bash, ksh, dash). Given Data / Assumptions: We are in a POSIX-compatible shell. HOME environment variable is set to the user's home path. No shell options have altered the default cd behavior. Concept / Approach: Running cd with no arguments changes the current directory to $HOME. This is standardized, portable, and works consistently. Alternative shortcuts like cd ~ also work in many shells due to tilde expansion, but the canonical minimal form is bare cd. Step-by-Step Solution: Check current directory with pwd.Execute cd with no arguments.Verify new location with pwd, which should equal $HOME.Optionally use echo $HOME to see the target path. Verification / Alternative check: Try cd ~ as an alternative in bash/ksh/zsh; it should produce the same result. Using cd - will toggle back to the previous directory if needed. Why Other Options Are Wrong: cd..: invalid; correct usage is cd .. (with space) to go up one level, not to home. cd/: goes to the filesystem root /, not the home directory. cd HOME.: not valid syntax; HOME is an environment variable and would require expansion like cd "$HOME". None of the above: incorrect because cd is correct. Common Pitfalls: Confusing root directory with home; forgetting quotes when $HOME contains spaces; assuming cd.. (DOS style) works on Unix shells. Final Answer: cd

Question 20

vi/vim editing — delete the character under the cursor  In vi/vim normal mode, which command deletes the single character directly beneath (under) the cursor?

Accepted Answer

Introduction / Context: Precise character-level edits are common when correcting typos. vi/vim provides single-keystroke deletion commands that work from normal mode without entering insert mode, enabling very fast text manipulation. Given Data / Assumptions: We are in normal (command) mode. The goal is to remove exactly one character, the one under the cursor. No custom mappings are in place. Concept / Approach: The command x deletes the character under the cursor. Its uppercase counterpart, X, deletes the character to the left of the cursor (backspace-like). Other delete commands operate on larger text objects or ranges (for example, dd deletes the entire line, and D deletes from the cursor to the end of the line). Step-by-Step Solution: Press Esc to ensure normal mode.Position the cursor over the character to remove.Press x to delete it.Optionally use a count: 3x deletes the next three characters under and after the cursor. Verification / Alternative check: Type a sample word, place the cursor on a letter, press x, and observe it vanish. Try X to see the difference (deletes to the left). Use u to undo if you delete the wrong character. Why Other Options Are Wrong: X: deletes the character to the left, not under the cursor. dd: deletes the whole current line. D: deletes from the cursor to end of line. None of the above: incorrect because x is correct. Common Pitfalls: Being in insert mode and pressing x (which will just type the letter x); mixing up x and X; forgetting that counts speed up repeated deletions. Final Answer: x

Unix Questions