Question 1

Scheduling recurring jobs on Unix/Linux systems  Which program is traditionally used to schedule commands or scripts to run at specific times and dates automatically?

Accepted Answer

Introduction / Context:Automating system tasks is a cornerstone of Unix/Linux administration. Whether rotating logs, running backups, or refreshing caches, administrators rely on a time-based job scheduler to execute commands without manual intervention. This question checks the recognition of the standard scheduler.Given Data / Assumptions:The operating system is Unix/Linux.We need a recurring, time-based scheduling mechanism.We are not referring to one-off, immediate execution tools.Concept / Approach:cron is the de facto daemon for periodic job scheduling. Users define crontab entries specifying minute, hour, day-of-month, month, and day-of-week fields followed by the command to run. The system variant, /etc/crontab or files in /etc/cron.d, supports specifying the user as well. Complementary tools include at for one-time jobs and anacron for scheduling on systems that are not always on.Step-by-Step Solution:Identify need: recurring automatic execution.Select cron as the appropriate facility.Create or edit a user crontab with crontab -e and add a schedule line.Verify execution via syslog or command outputs redirected to logs.Verification / Alternative check:Confirm that the cron daemon is running (for example, systemctl status crond or cron depending on the distro). Test with a simple scheduled echo redirected to a file and verify it appears at the expected time.Why Other Options Are Wrong:vi: a text editor; not a scheduler.Outlook: an email and calendar client on other platforms; unrelated to Unix scheduling.Scheduler: too generic; not a standard Unix command name.None of the above: incorrect because cron is correct.Common Pitfalls:Incorrect crontab field order, environment differences (PATH) within cron jobs, and forgetting to redirect output or specify absolute paths to commands and scripts.Final Answer:cron

Question 2

Checking and repairing Linux file systems  Which tool is used to verify and repair Linux file systems after improper shutdowns or detected inconsistencies?

Accepted Answer

Introduction / Context:File system integrity is crucial for data reliability. After unexpected power loss or hardware issues, file systems may contain inconsistencies. Linux provides a standard tool to check and, when necessary, repair file systems to a consistent state before mounting them read-write.Given Data / Assumptions:We are using Linux with common file systems (for example, ext4, xfs, btrfs with their respective helpers).We need a tool to check and fix inconsistencies.We understand that specific file systems may have specialized checkers invoked under a common wrapper.Concept / Approach:fsck is the front-end tool that orchestrates file system checks. It calls the appropriate checker (such as e2fsck for ext2/3/4 or xfs_repair for XFS) based on the device and file system type. It is typically run on unmounted file systems or in single-user/emergency mode to avoid further damage.Step-by-Step Solution:Identify the target device (for example, /dev/sda1).Ensure it is unmounted or mounted read-only.Run fsck or a specific checker (for example, fsck -t ext4 /dev/sda1).Accept or review repairs as prompted, then remount and verify.Verification / Alternative check:Review system logs after boot; many distributions run fsck automatically based on mount counts or dirty flags. For ext filesystems, compare results with tune2fs -l to see mount counts and check intervals.Why Other Options Are Wrong:mkfs: creates a new file system; using it would erase data.fdisk: edits partition tables; it does not check file system integrity.mount: attaches file systems to the directory tree; it does not repair them.None of the above: incorrect because fsck is correct.Common Pitfalls:Running fsck on a mounted file system, misunderstanding that some modern file systems have different repair workflows, and ignoring hardware issues causing recurring corruption.Final Answer:fsck

Question 3

Changing the working directory on Unix/Linux  Which standard command changes the shell’s current working directory?

Accepted Answer

Introduction / Context:Navigating the file system is fundamental to shell usage. Scripts and interactive sessions rely on moving between directories to access files, run commands, and manage projects. The canonical command to change the process’s working directory is short and widely supported across shells.Given Data / Assumptions:A POSIX-like shell environment is in use (for example, sh, bash, ksh, zsh).We want to change the current working directory for the running shell process.Default shell built-in behavior applies.Concept / Approach:The command cd is a shell built-in that changes the current directory of the running shell. It accepts absolute and relative paths. Invoked with no arguments, cd takes you to your home directory. cd - toggles to the previous directory, which is useful for quick back-and-forth navigation.Step-by-Step Solution:Display your current directory with pwd.Use cd path to switch (for example, cd /var/log or cd ../project).To return home, run cd with no arguments or cd ~.Use cd - to swap between the current and previous directories.Verification / Alternative check:Run pwd before and after cd to confirm the change. Verify permissions, as cd will fail if the user lacks execute permission on the target directory.Why Other Options Are Wrong:cdir, changedir: not standard shell commands.chdir: a system call name in many languages, but not the standard interactive shell command.None of the above: incorrect because cd is correct and standard.Common Pitfalls:Using cd on paths with spaces without quoting; forgetting that cd is a built-in and cannot change the directory of a parent process; misunderstanding permissions required to enter directories.Final Answer:cd

Question 4

Binary to dotted-decimal conversion of an IPv4 address  Convert the 32-bit address 10000000 00001010 00000010 00011110 to dotted-decimal form.

Accepted Answer

Introduction / Context:IPv4 addresses are commonly written in dotted-decimal notation, but under the hood they are 32-bit binary values split into four octets. Network engineers and students must be fluent in converting between binary and dotted-decimal formats for subnetting, routing, and troubleshooting.Given Data / Assumptions:The binary address is 10000000 00001010 00000010 00011110.Each group of 8 bits represents one octet.We convert each octet from binary to decimal independently.Concept / Approach:Break the 32-bit binary string into four octets. Convert each octet from base 2 to base 10 using positional weights (128, 64, 32, 16, 8, 4, 2, 1). Concatenate the four decimal values using dots between them to form dotted-decimal notation.Step-by-Step Solution:Octet 1: 10000000 = 128.Octet 2: 00001010 = 8 + 2 = 10.Octet 3: 00000010 = 2.Octet 4: 00011110 = 16 + 8 + 4 + 2 = 30.Combine results: 128.10.2.30.Verification / Alternative check:Use a calculator or quick mental conversion: the presence of a single leading 1 in the first octet confirms 128; the second octet has bits at 8 and 2 positions; the third only at 2; the fourth at 16, 8, 4, and 2. Everything matches the final value 128.10.2.30.Why Other Options Are Wrong:210.20.2.64, 164.100.9.61, 148.20.2.30: do not correspond to the given binary octets.None of the above: incorrect because 128.10.2.30 is correct.Common Pitfalls:Misgrouping bits into octets, treating binary as a single big-endian integer without splitting, or miscalculating weights (for example, forgetting that the leftmost bit is 128 in an octet). Practice with common patterns improves speed and accuracy.Final Answer:128.10.2.30

Question 5

History of Linux: founder of the Linux kernel  Who initiated and originally developed the Linux kernel project?

Accepted Answer

Introduction / Context:The Linux kernel is the core component of countless servers, desktops, and embedded systems worldwide. Understanding its origins provides context for the broader open-source ecosystem, licensing, and governance models that shape modern computing.Given Data / Assumptions:The question asks specifically about the founder of the Linux kernel, not the GNU project or other operating systems.We distinguish between the kernel itself and distributions that package it.Historical attribution is widely documented and unambiguous.Concept / Approach:Linus Torvalds began the Linux kernel as a personal project in 1991 while a student at the University of Helsinki. He announced it publicly and licensed it under terms compatible with free software ideals. The kernel later combined with GNU userland tools and other software to form complete GNU/Linux systems maintained by many distributions.Step-by-Step Solution:Identify the scope: kernel, not the broader OS ecosystem.Recall the founder: Linus Torvalds initiated and leads kernel development governance.Eliminate figures associated with other domains: for example, Bill Gates (Microsoft), Richard Stallman (GNU project, Free Software Foundation).Select Linus Torvalds as the correct answer.Verification / Alternative check:Historical archives and the original Usenet announcement confirm Torvalds’s authorship. The ongoing kernel development process still recognizes him as the project’s benevolent dictator and release manager, coordinating contributions from a global developer community.Why Other Options Are Wrong:Bill Gates: co-founded Microsoft; not related to founding Linux.Ben Thomas: not associated with Linux’s creation.Richard Stallman: founded the GNU project and the Free Software Foundation, not the Linux kernel.None of the above: incorrect because Linus Torvalds is correct.Common Pitfalls:Conflating GNU and Linux, or assuming the founder of GNU also founded the kernel. The combined term GNU/Linux reflects a collaboration of distinct projects with separate origins.Final Answer:Linus Torvalds

Question 6

Changing file permissions: make file named report executable for everyone  Which chmod command grants execute permission to user, group, and others on a file named report (without altering other permissions)?

Accepted Answer

Introduction / Context:File permissions control who can read, write, or execute files on Unix/Linux systems. Making a script or program executable is a common administrative task. Using chmod with the correct symbolic mode ensures that only the intended permission bits are changed, preserving the rest of the file’s mode.Given Data / Assumptions:The file is named report in the current directory.We want to add execute permission for user (u), group (g), and others (o).We do not want to remove existing read or write permissions.Concept / Approach:chmod supports symbolic modes such as ugo+x to add execute permission to all three classes without disturbing other bits. This is safer than absolute numeric modes when you only want to add a specific capability. After applying, the executable bit is set for user, group, and others, enabling the file to be run as a program if its contents allow.Step-by-Step Solution:Identify required change: add execute for all classes.Use the additive symbolic form: chmod ugo+x report.Verify with ls -l report to see x bits added to user, group, and others.Optionally, use a numeric form such as chmod 755 if you also want to enforce specific read/write bits.Verification / Alternative check:Run ls -l before and after. If permissions were, for example, rw-r--r--, after the change they will become rwxr-xr-x. The only difference should be the addition of execute bits.Why Other Options Are Wrong:chmod u+x report: adds execute only for the user, not for group and others.chmod ugo+rw report: adds read and write, not execute.chmod ugo+r report: adds only read permission.None of the above: incorrect because chmod ugo+x report is correct.Common Pitfalls:Confusing symbolic and numeric modes, unintentionally removing permissions by using an absolute numeric mode without considering current bits, or forgetting that scripts need a valid shebang line to run as expected even when marked executable.Final Answer:chmod ugo+x report

Question 7

Linux shell startup files: Which system-wide script sets default environment variables and startup behavior for all users when they log in to a Bash shell?

Accepted Answer

Introduction / Context:Understanding Bash startup files is essential for Linux system administration. Different files are sourced depending on whether a shell is a login or non-login shell and whether the configuration is system-wide or per-user. This question targets the system-wide file that establishes default environment settings for all users at login.Given Data / Assumptions:Bash is the default shell considered.We are concerned with global defaults that apply to all users.The context is a login shell (for example, when a user logs in via console, SSH, or a display manager starting a login shell).Concept / Approach:Bash distinguishes between system-wide and per-user initialization files. For login shells, Bash reads /etc/profile first (system-wide) and then looks for per-user files like ~/.bash_profile, ~/.bash_login, or ~/.profile. For interactive non-login shells, many distributions use /etc/bash.bashrc or /etc/bashrc plus the user's ~/.bashrc. Only one of the options given is the canonical system-wide login file.Step-by-Step Solution:Identify the system-wide login initialization file: /etc/profile.Confirm that hidden variants like /etc/.profile are non-standard in Linux distributions.Recognize that /etc/.bashrc is also non-standard; common names are /etc/bash.bashrc or /etc/bashrc, not listed here.Discard unrelated paths like /etc/.log.Verification / Alternative check:On a typical Linux system, run man bash and review the INVOCATION section, which explains that login shells read /etc/profile. Distribution documentation (Debian/Ubuntu, RHEL/Fedora) confirms this behavior.Why Other Options Are Wrong:/etc/.profile: Not a standard global login file; misleading due to the dot prefix./etc/.bashrc: Not standard; most systems use /etc/bash.bashrc or /etc/bashrc for non-login shells./etc/.log: Not a configuration file for shells.None of the above: Incorrect because /etc/profile is correct.Common Pitfalls:Confusing system-wide files with per-user dotfiles (for example, ~/.bashrc). Also, mixing up login and non-login shell behavior leads to incorrect assumptions about which file executes. Always consider shell type and distribution conventions.Final Answer:/etc/profile

Question 8

Unix command-line basics: Which command is commonly used to display the contents of files and can also be used to create simple files from standard input?

Accepted Answer

Introduction / Context:The Unix philosophy emphasizes small tools that do one thing well. The cat command (concatenate) is one of the oldest and most frequently used commands for displaying file contents and assembling files from input streams, making it essential knowledge for shell users and administrators.Given Data / Assumptions:You want to view file contents directly in the terminal.You may also want to create a small text file from typed input or redirected output.Standard POSIX shell behavior is assumed.Concept / Approach:cat file prints the file's contents to standard output. You can combine multiple files (cat f1 f2 > combined) or create a quick file with cat > newfile, then type lines and press Ctrl+D to save. Editors like ed or vi are for interactive editing, not simple display, and lyrix is not a standard Unix utility.Step-by-Step Solution:To display a file: cat filenameTo concatenate multiple files: cat a b c > out.txtTo quickly create a file from stdin: cat > notes.txt (type content, Ctrl+D)To number lines: cat -n filenameVerification / Alternative check:Compare cat with less or more; the latter paginate content, while cat streams the entire file. For editing, use vi or nano instead of cat.Why Other Options Are Wrong:lyrix: Not a standard Unix command.ed: A line editor; used for editing, not just display/creation via redirection.vi: A full-screen editor; not the simplest tool for just displaying.None of the above: Incorrect because cat does exactly what is asked.Common Pitfalls:Using cat on very large files can flood the terminal; prefer less for paging. Beware of accidental truncation when redirecting output with > to an existing file. For appending, use >> instead.Final Answer:cat

Question 9

Linux boot loaders: What is LILO and what is it used for in the context of Linux on x86 hardware?

Accepted Answer

Introduction / Context:Before a Linux kernel can run, firmware or a bootloader must load it into memory and transfer control. LILO (Linux Loader) is a traditional Linux bootloader for x86 systems, historically popular before GRUB became dominant. Understanding LILO helps when maintaining legacy systems or studying Linux history and boot processes.Given Data / Assumptions:Platform is x86 PC-class hardware.Legacy boot processes using Master Boot Record (MBR) are in scope.Focus is on identification and purpose, not configuration details.Concept / Approach:LILO is both an acronym (Linux Loader) and a boot manager that can load Linux kernels (and other OSes) from MBR or partition boot sectors. It requires updating the boot map after configuration changes. While GRUB has largely superseded LILO due to dynamic configuration and filesystem awareness, LILO remains a valid, instructive example of bootloaders.Step-by-Step Solution:Confirm meaning: LILO = Linux Loader.Identify role: Linux boot loader capable of loading kernels.Match usage: Used to boot the kernel on x86 hardware.Therefore, “All of the above” accurately encompasses all statements.Verification / Alternative check:Review standard Linux documentation (man lilo, man lilo.conf). Verify that LILO installs boot code to the MBR or partition VBR and relies on a map file to locate kernels and initial RAM disks.Why Other Options Are Wrong:A, B, and C individually are true but incomplete; the most comprehensive choice is D.None of the above: Incorrect because all statements are accurate for LILO.Common Pitfalls:Forgetting to run /sbin/lilo after modifying /etc/lilo.conf, which leaves the boot map outdated. Confusing LILO with GRUB or systemd-boot; each has different configuration styles and capabilities.Final Answer:All of the above

Question 10

Disk partitioning (MBR scheme): How many extended partitions can be created on a single MBR-partitioned drive?

Accepted Answer

Introduction / Context:On legacy MBR-partitioned disks, partition types and limits are a frequent source of confusion. Understanding the roles of primary, extended, and logical partitions is essential when setting up dual-boot systems or older servers.Given Data / Assumptions:The disk uses the MBR (Master Boot Record) partitioning scheme, not GPT.We are discussing the number of extended partitions specifically.Logical partitions reside inside an extended partition.Concept / Approach:MBR allows up to four primary partitions. To overcome that limit, one of those entries can be designated as an extended partition, which then contains a linked list of logical partitions. By design, there can be only one extended partition per disk, but it can hold many logical partitions (for example, /dev/sda5, /dev/sda6, ...).Step-by-Step Solution:Recall the MBR rule: max 4 primaries.Replace one primary with a single extended partition to host logical partitions.Therefore only one extended partition is permitted per MBR disk.Logical partitions are created within that single extended container.Verification / Alternative check:Tools like fdisk or parted show partition tables; on MBR disks you will observe at most one extended partition (type 0x05/0x0F) containing any number of logical partitions beyond four total partitions.Why Other Options Are Wrong:16, 4, 2: These numbers relate to other limits (for example, four primaries), not the count of extended partitions.None of the above: Incorrect because exactly one extended partition is allowed.Common Pitfalls:Confusing the number of logical partitions (which can be many) with the number of extended partitions (always one at most). Also, mixing MBR rules with GPT (GUID Partition Table), which uses a different model and does not require extended partitions.Final Answer:1

Question 11

Linux disk quotas: Which administrative command is used to set (edit) user and group quotas on a Linux system?

Accepted Answer

Introduction / Context:Disk quotas limit the amount of filesystem space or inodes a user or group can consume. Linux provides a set of quota tools to enable, configure, and report usage. Administrators must know which tool actually edits quota limits versus those that merely enable or display them.Given Data / Assumptions:Traditional quota tools are installed (quota, quotaon, edquota).Filesystems are mounted with quota support where applicable.Goal: change the hard/soft limits for users or groups.Concept / Approach:The workflow typically is: enable quotas with quotaon, optionally initialize with quotacheck, and then set limits with edquota. The quota command displays current usage and limits; it does not edit them. Nonexistent commands (like /sbin/usrquota) are distractors.Step-by-Step Solution:Choose the editor: /sbin/edquota (often invoked simply as edquota).Run: edquota username (opens a text editor to modify blocks/inodes soft and hard limits).To set group quotas: edquota -g groupname.Apply and verify with quota username and repquota filesystem.Verification / Alternative check:After editing, use quota -u user or repquota -a to confirm limits. Ensure /etc/fstab includes usrquota and/or grpquota options and that quotaon has been executed.Why Other Options Are Wrong:/sbin/usrquota: Not a standard quota command./sbin/quotaon: Enables quotas on a filesystem; does not edit limits./sbin/quota: Displays usage and limits; read-only reporting.None of the above: Incorrect because /sbin/edquota is correct.Common Pitfalls:Editing quotas before enabling them; forgetting to mount filesystems with quota options; misinterpreting block units (often 1 KB or 1 block size unit depending on build); and not running quotacheck after major changes.Final Answer:/sbin/edquota

Question 12

RPM basics (Linux packaging): Which statement best describes RPM in practical, distribution-agnostic terms?

Accepted Answer

Introduction / Context:RPM is a foundational package management system used by many Linux distributions (for example, RHEL, Fedora, openSUSE). Administrators routinely use RPM tools to install, verify, query, and remove software. Understanding what RPM actually does avoids confusing it with unrelated system management tasks.Given Data / Assumptions:We focus on the RPM toolset functionality rather than branding.The question requires a single best description.Package management involves installing, upgrading, verifying, and removing software packages.Concept / Approach:At its core, RPM (today often backronymed as “RPM Package Manager”) provides a database-backed system to manage packages, track file ownership, verify integrity, and query metadata. The rpm command works with .rpm files and the RPM database. Higher-level tools (for example, dnf, zypper) build on RPM for dependency resolution and repository management.Step-by-Step Solution:Identify the operational role: package installation, removal, verification, and queries.Match with option describing management functions: “is used to install, uninstall, and manage packages”.Reject options that imply user management or networking functions.Note that while historically “Red Hat Package Manager” was the expansion, the modern neutral name avoids vendor lock-in.Verification / Alternative check:Commands like rpm -ivh package.rpm, rpm -e packagename, rpm -qa, and rpm -V packagename demonstrate RPM’s package management capabilities in practice.Why Other Options Are Wrong:stands for Red Hat Package Manager: Historically acceptable but incomplete and somewhat outdated as a definition.is used to keep track of the users: User management is handled by tools like useradd, not RPM.assigns a dynamic IP address: That is the role of DHCP clients/servers, not RPM.None of the above: Incorrect because RPM’s package management role is captured by option B.Common Pitfalls:Confusing rpm (the low-level tool) with DNF/YUM (high-level dependency-resolution tools). Also, thinking RPM alone resolves dependencies; dependency handling typically requires a higher-level package manager.Final Answer:is used to install, uninstall, and manage packages

Question 13

Linux logs (Red Hat family): Where are system and mail log files typically stored on Red Hat–based distributions?

Accepted Answer

Introduction / Context:Logs are crucial for troubleshooting and auditing. On Red Hat–based systems (and most Unix-like OSes), the Filesystem Hierarchy Standard (FHS) defines conventional locations for log files, enabling consistent administration across systems and tools.Given Data / Assumptions:The question refers to Red Hat Linux and derivatives.We consider default, conventional locations without custom redirection by administrators.Examples include system logs (messages, secure) and mail logs (maillog).Concept / Approach:The directory /var/log holds variable log files for the system. Within it, files such as /var/log/messages, /var/log/secure, and /var/log/maillog are commonly used. Systemd-journald may store binary journals under /var/log/journal as well, and rsyslog can forward to text files in the same tree.Step-by-Step Solution:Identify the FHS directory for logs: /var/log.Recognize common files: messages, secure, dmesg, maillog, cron.Exclude nonstandard paths like /etc/log or /mail.Confirm with distribution documentation and FHS references.Verification / Alternative check:Run ls /var/log to see typical logs. If systemd-journald is primary, check journalctl and confirm persistent storage under /var/log/journal when configured.Why Other Options Are Wrong:/etc/log: /etc holds configuration, not runtime logs./mail: Not a standard log directory; mail logs are in /var/log/maillog by default on Red Hat.All of the above: Incorrect; only /var/log is correct.None of the above: Incorrect since /var/log is correct.Common Pitfalls:Assuming logs are always plain text; journald can store binary logs. Also, admins can customize rsyslog to write elsewhere, but defaults follow FHS conventions.Final Answer:/var/log

Question 14

RPM query mode: Which rpm command option is used to query information about a specific package (for example, to check if it is installed)?

Accepted Answer

Introduction / Context:Querying installed packages is a routine task in system administration. The rpm tool provides a query mode that quickly answers questions such as whether a package is installed, its version, and which files it installed.Given Data / Assumptions:The system uses RPM-based packaging.We want to query package information, not install or remove it.We are using the low-level rpm command, not higher-level tools like dnf or yum.Concept / Approach:The -q option enables query mode. You can use rpm -q packagename to check installation and version, rpm -qi packagename for detailed info, and rpm -ql packagename to list installed files. Other letters have different purposes (for example, -i for install, -e for erase).Step-by-Step Solution:Choose the query switch: -qCheck existence/version: rpm -q packagenameGet details: rpm -qi packagenameList files: rpm -ql packagenameVerification / Alternative check:Compare output with dnf list installed or rpm -qa | grep packagename. All methods corroborate whether a package is present.Why Other Options Are Wrong:rpm -a: Not a valid standalone query; common is -qa (query all). As shown, -a alone does not mean “query package”.rpm -d: Not a standard query option for rpm; often misremembered from other tools.rpm -1: Invalid option (and “-1” is not a recognized flag).None of the above: Incorrect; rpm -q is correct.Common Pitfalls:Forgetting to combine flags properly (for example, using -qa to list all packages). Confusing rpm query capabilities with repository-enabled tools like dnf that can query remote repos.Final Answer:rpm -q

Question 15

Filesystem hierarchy (FHS): Which directory is designated for user system resources, including subdirectories for user and administrative executables such as /usr/bin and /usr/sbin?

Accepted Answer

Introduction / Context:The Linux Filesystem Hierarchy Standard (FHS) defines a common directory structure across distributions. Knowing where executables and libraries reside helps administrators manage software, PATH settings, and storage.Given Data / Assumptions:We are identifying the standard location of user and administrative executables.We focus on system-provided software, not temporary files or mount points.FHS conventions are followed.Concept / Approach:The /usr hierarchy holds user system resources: binaries in /usr/bin, system admin binaries in /usr/sbin, libraries in /usr/lib, and shared data in /usr/share. Locally installed admin/user software typically goes under /usr/local. /opt is for add-on packages; /tmp is for temporary files; /mnt is a mount point.Step-by-Step Solution:Identify directory containing /usr/bin and /usr/sbin: /usr.Recognize that /usr/local supports locally built software without overwriting vendor packages.Exclude /opt (add-ons), /tmp (temporary), and /mnt (mount point).Thus, /usr is the correct answer.Verification / Alternative check:List directories with ls /usr to confirm existence of bin, sbin, lib, share, and local. Consult man hier or FHS documentation for definitions.Why Other Options Are Wrong:/tmp: Temporary files; not for installed executables./opt: Optional add-on packages; not the primary hierarchy for user/admin executables./mnt: Generic mount point; not for program storage.None of the above: Incorrect because /usr is correct.Common Pitfalls:Confusing /usr with /usr/local or /opt. While programs can exist in all three, /usr is the principal tree for distribution-provided binaries and libraries, whereas /usr/local is for locally installed software and /opt is for third-party add-ons.Final Answer:/usr

Question 16

Unix text-processing tools: Which of the following is not a filter command (i.e., a program that reads from standard input and writes to standard output)?

Accepted Answer

Introduction / Context:Unix excels at building pipelines by connecting programs that read from standard input and write to standard output—these are commonly called filters. Recognizing which commands behave as filters helps you compose effective pipelines for searching, counting, sorting, and transforming text.Given Data / Assumptions:A filter typically reads from stdin and writes to stdout.Many classic Unix utilities can operate without requiring filenames, thereby acting as filters.We are evaluating sort, wc, grep, and cat.Concept / Approach:sort sorts lines received from stdin or files and writes sorted output to stdout. wc counts lines, words, and bytes from stdin or files and prints results to stdout. grep filters lines matching a pattern, again from stdin or files, to stdout. cat concatenates files or stdin and writes to stdout, often used as a simple pass-through or to combine streams. All four therefore qualify as filters when used in pipelines.Step-by-Step Solution:Check each utility's stdin/stdout behavior: all accept stdin and produce stdout.Confirm pipeline usage: e.g., dmesg | grep error | sort | wc -l | catSince each can be used as a filter, none of them is “not a filter”.Hence the correct choice is “None of the above.”Verification / Alternative check:Run a simple pipeline: printf "bac" | sort | wc -l. Insert cat anywhere in the chain; it still reads stdin and writes stdout, proving its filter behavior in practice.Why Other Options Are Wrong:sort: Is a classic filter, not incorrect.wc: Also a filter; reads from stdin fine.grep: A textbook filter used for pattern matching in pipelines.cat: Often used to pass data through or concatenate; behaves as a filter.Common Pitfalls:Thinking “cat” is not a filter because it often reads files by name; in fact, it reads stdin when no file is specified, making it a filter. Likewise, all of the listed commands can take input from stdin, aligning with the filter definition.Final Answer:None of the above

Question 17

Linux system administration: Which command-line utility is used to create, delete, and modify disk partitions on a hard drive (for example, preparing a new disk before making filesystems)?

Accepted Answer

Introduction / Context:Before a Linux system can format a filesystem or mount storage, the disk must be partitioned. Partitioning defines start and end sectors for one or more logical areas on a physical drive. The traditional utility for this task on MBR-style disks is fdisk, which provides interactive commands to add, delete, and change partition types.Given Data / Assumptions:The question is about partitioning, not formatting or checking filesystems.A standard Linux environment is assumed with common administrative tools present.No specific partition table type is mandated (fdisk primarily targets MBR; many builds can also handle GPT, though gdisk/parted are often preferred for GPT).Concept / Approach:Partitioning precedes filesystem creation. The correct tool must manipulate the disk’s partition table. fdisk edits partition entries at the block device level, allowing administrators to create primary/extended/logical partitions and set partition types and bootable flags.Step-by-Step Solution:Identify the disk to partition (for example, /dev/sda or /dev/nvme0n1).Run fdisk /dev/sda to open the interactive editor.Use p to print the current partition table and n to create a new partition.Select partition number, start sector, and size (for example, +20G).Write changes with w, then create a filesystem (for example, mkfs.ext4 /dev/sda1) and mount.Verification / Alternative check:Verify with lsblk, blkid, or fdisk -l that the partition table reflects your changes. Try mounting the new partition to ensure it is accessible after creating a filesystem.Why Other Options Are Wrong:a: mkfs creates a filesystem inside a partition; it does not partition the disk.c: fsck checks and repairs an existing filesystem; it does not edit a partition table.d: mount attaches an existing filesystem to the directory tree; it does not create partitions.e: Not applicable since fdisk is correct for partitioning.Common Pitfalls:Confusing partitioning with formatting, writing changes to the wrong device, and forgetting to update /etc/fstab for persistent mounts. Always back up critical data before changing partitions.Final Answer:fdisk

Question 18

UNIX file management: Which command removes (deletes) a file from the filesystem, permanently freeing its directory entry and disk space after the last link is gone?

Accepted Answer

Introduction / Context:Deleting files is a core administrative skill on UNIX and Linux. Unlike some desktop environments that send files to a recycle bin, the rm command permanently removes directory entries. When no other hard links reference the inode and no process keeps the file open, the space is reclaimed.Given Data / Assumptions:You have a standard POSIX shell environment.The task is deleting a file (not moving or renaming).Permissions allow deletion (write permission on the parent directory is crucial).Concept / Approach:rm removes directory entries for files and directories (with -r for recursive). It does not ask for confirmation by default, so using -i is safer in interactive sessions. The actual data blocks are freed when no references remain, and the kernel updates filesystem metadata accordingly.Step-by-Step Solution:List files with ls to confirm the target name.Run rm filename to remove a single file.Use rm -i filename to prompt before removal (safer).Use rm -r directory to remove a directory tree; consider rm -rf with caution.Verify removal by listing the directory again.Verification / Alternative check:Run ls or find to confirm the file is gone. If a process had the file open, lsof can show open handles; space is reclaimed once handles close.Why Other Options Are Wrong:a: del is a DOS/Windows command, not standard UNIX.b: mv moves or renames a file; it does not delete it.d: remove is not the standard user command; rm is.e: Not applicable because rm is correct.Common Pitfalls:Accidental use of wildcards, removing files as root without prompts, and attempting to delete without write permission on the parent directory. Consider aliases like rm -i to add a safety net.Final Answer:rm

Question 19

Shell pipelines and counting: Using standard pipelines, which command counts the number of directory entries shown by ls in the current directory (one count per line of ls output)?

Accepted Answer

Introduction / Context:Pipelines combine simple UNIX tools to accomplish useful tasks. A common need is to count how many items a command lists. The wc (word count) utility can report lines, words, and bytes for its input, making it perfect to summarize ls output.Given Data / Assumptions:The goal is to count entries printed by ls in the current directory.No need to handle hidden files unless you add -a to ls.Default ls output prints one entry per line (depending on aliases and terminal width).Concept / Approach:wc -l counts lines of input. Piping ls to wc -l yields the number of lines produced by ls, which typically corresponds to the number of visible directory entries. If your environment formats ls in multiple columns, use ls -1 to force one per line before piping.Step-by-Step Solution:Run ls -1 | wc -l to ensure one-per-line counting in all environments.Optionally include hidden files: ls -A1 | wc -l.Capture the result in a variable if used in scripts (count=(ls -1 | wc -l)).Use find . -maxdepth 1 -type f | wc -l to count only regular files.Verify counts by comparing with graphical file managers or manual checks.Verification / Alternative check:Compare ls -1 output visually and ensure the number of lines matches wc -l. For robust scripting, prefer find with explicit type filters and null-delimited results when filenames include newlines.Why Other Options Are Wrong:a: wc -c reports byte count, not lines.b: wc -w reports word count, not reliable for filenames with spaces.d: wc without options prints lines, words, and bytes; it does not directly return just the line count.e: Not applicable because ls | wc -l is correct.Common Pitfalls:Relying on ls default column formatting; to be safe, use -1. Also note that ls counts directories and files together; use find to tailor results precisely.Final Answer:ls | wc -l

Question 20

vi editor navigation: In classic vi normal mode, which single-key motion command moves the cursor one character to the left?

Accepted Answer

Introduction / Context:vi and Vim provide powerful keyboard-centric navigation. The four basic motion keys h, j, k, and l allow cursor movement without leaving the home row. Mastering these motions improves speed and precision during text editing on UNIX systems.Given Data / Assumptions:You are in normal mode (not insert mode) in vi/Vim.You want to move exactly one character left.No multi-count prefix is used (like 5h).Concept / Approach:vi normal mode maps movement keys to directions: h (left), j (down), k (up), l (right). These motions can be combined with numeric counts and with operators (such as d for delete) to form powerful editing commands (for example, dh deletes one character to the left).Step-by-Step Solution:Ensure you are in normal mode by pressing Escape.Press h to move one character to the left.Use a count, such as 5h, to move five characters left.Combine with operators: dh deletes left, yh yanks left, ch changes left.Use l, j, k for the other directions to navigate efficiently.Verification / Alternative check:Observe the cursor position before and after pressing h. Compare with arrow keys if enabled; in minimal terminals, hjkl remain reliable even without arrow key support.Why Other Options Are Wrong:b: k moves the cursor up one line.c: j moves the cursor down one line.d: i switches to insert mode at the cursor; it does not move left.e: Not applicable because h is the correct motion for one character left.Common Pitfalls:Accidentally being in insert mode (where h inserts a character) and forgetting motion counts. Practice keeps motions fluid and reduces reliance on arrow keys.Final Answer:h

Linux Questions

Questions

Practice smarter