Tools

---

Dark Mode

Show Highlights

Audio Clips

Tools Master Quiz

A comprehensive mix of all tools quizzes.

What is the standard syntax to define a basic build rule in a Makefile?

target: prerequisites command

A rule defines the target file to be built, the prerequisite files it depends on, and the command(s) to execute to build it.

What specific whitespace character MUST be used to indent the command/recipe lines in a Makefile rule?

A Tab character

If you use spaces instead of a Tab, make will throw an error (often ‘missing separator’).

How do you reference a variable (or macro) named ‘CC’ in a Makefile command?

$(CC) or ${CC}

Variables are defined using an equals sign (e.g., CC = gcc) and referenced by wrapping the name in parentheses or curly braces preceded by a dollar sign.

What Automatic Variable represents the file name of the target of the rule?

$@

This is commonly used in the compilation command to specify the output file name dynamically.

What Automatic Variable represents the name of the first prerequisite?

$<

This is frequently used in pattern rules to pass the specific source file (like a .c file) to the compiler.

What Automatic Variable represents the names of all the prerequisites, with spaces between them?

$^

This is often used in linking commands where all object files need to be passed to the compiler at once to create an executable.

What wildcard character is used to define a Pattern Rule (a generic rule applied to multiple files)?

% (Percent sign)

For example, %.o: %.c tells make how to compile any .o object file from a corresponding .c source file.

What special target is used to declare that a target name is an action (like ‘clean’) and not an actual file to be created?

.PHONY: target_name

This prevents conflicts if a file literally named ‘clean’ is ever created in the directory, ensuring the recipe will always run when invoked.

What metacharacter can be placed at the very beginning of a recipe command to suppress make from echoing the command to the terminal?

@ (At symbol)

For example, @echo "Done!" will print ‘Done!’ to the terminal without printing the actual ‘echo’ command first.

What syntax is used for string substitution on a variable, such as changing all .c extensions in $(SRCS) to .o?

$(SRCS:.c=.o)

This evaluates to the value of the SRCS variable, but replaces the suffix .c with .o for every word in the list.

You have some uncommitted, incomplete changes in your working directory, but you need to switch to another branch to urgently fix a bug. How do you temporarily save your current work without making a messy commit?

git stash

git stash temporarily shelves your staged and unstaged changes for tracked files. To include brand new, untracked files in the stash, you must use git stash -u.

You know a bug was introduced recently, but you aren’t sure which commit caused it. How do you perform a binary search through your commit history to find the exact commit that broke the code?

git bisect

git bisect systematically halves your commit history, asking you to test if the bug is present at each step, making it highly efficient for tracking down regressions.

You are looking at a file and want to know exactly who last modified a specific line of code, and in which commit they did it.

git blame

git blame annotates each line of a file with the author and the commit hash of the last modification, which is very useful for figuring out who to ask about a piece of code.

You want to safely ‘undo’ a previous commit that introduced an error, but you don’t want to rewrite history or force-push. How do you create a new commit with the exact inverse changes?

git revert

git revert is the safest way to undo changes on a shared branch because it adds a new commit that nullifies the targeted commit, rather than deleting history.

You want to see exactly what has changed in your working directory compared to your last saved snapshot (the most recent commit).

git diff HEAD

Using git diff HEAD compares your current modified tracked files on disk with the most recent commit. Note that it does not show completely untracked files.

You have a feature branch with several experimental commits, but you only want to move one specific, completed commit over to your main branch.

git cherry-pick

git cherry-pick allows you to selectively grab a specific commit from one branch and apply it onto your current branch, without merging the entire branch history.

You want to integrate a feature branch into main, but instead of bringing over all 15 tiny incremental commits, you want them combined into one clean commit on the main branch.

git merge --squash

Squashing combines all the patches from the feature branch into a single set of changes, allowing you to make one clean commit on the target branch and keep the history tidy with git merge --squash.

You are building a massive project and want to include an entirely separate external Git repository as a subdirectory within your project, while keeping its history independent.

git submodule

git submodule allows you to nest an independent repository inside your main project. It essentially creates a pointer to a specific commit of that external library.

You are starting a brand new project in an empty folder on your computer and want Git to start tracking changes in this directory.

git init

This command initializes a new, empty Git repository in the current directory via git init, creating the hidden .git folder that manages all version control data.

You have just installed Git on a new computer and need to set up your username and email address so that your commits are properly attributed to you.

git config

Using git config --global user.name and user.email establishes your default identity, which can be overridden for specific projects using git config --local.

You’ve made changes to three different files, but you only want two of them to be included in your next snapshot. How do you move those specific files to the staging area?

git add <filename>

The git add command moves file modifications from the working directory into the staging area (index) to prepare them for the next commit.

You’ve lost track of what you’ve been doing. You want a quick overview of which files are modified, which are staged, and which are completely untracked by Git.

git status

This command git status provides a high-level summary of the working tree and staging area statuses, making it one of the most frequently used Git commands.

You have staged all the files for a completed feature and are ready to permanently save this snapshot to your local repository’s history with a descriptive message.

git commit -m 'message'

Committing takes everything in the staging area and records it as a permanent new version in your local Git history via git commit.

You want to review the chronological history of all past commits on your current branch, including their author, date, and commit message.

git log

This command git log prints out the commit history. You can also add flags like -p to see the exact patch/diff introduced in each commit.

You’ve made edits to a file but haven’t staged it yet. You want to see the exact lines of code you added or removed compared to what is currently in the staging area.

git diff

Running git diff without any arguments compares your current working directory against the staging area.

You want to start working on a completely new feature in isolation without affecting the main codebase.

git branch <branch-name>

This command git branch creates a new branch pointer at your current commit, allowing you to diverge from the main line of development.

You are currently on your feature branch and need to switch your working directory back to the ‘main’ branch.

git switch main

The modern git switch command navigates between branches, updating your working directory and moving HEAD. The legacy equivalent git checkout main still works and is widely seen in older documentation and scripts.

Your feature branch is complete, and you want to integrate its entire commit history into your current ‘main’ branch.

git merge <branch-name>

Merging with git merge takes the divergent histories of two branches and combines them, often resulting in a new ‘merge commit’ with two parents.

Instead of creating a merge commit, you want to take the commits from your feature branch and re-apply them directly on top of the latest ‘main’ branch to create a clean, linear history.

git rebase main

Rebasing with git rebase rewrites history by moving the base of your current branch to the tip of another, which creates a cleaner history but should be avoided on public/shared branches.

You want to start working on an open-source project hosted on GitHub. How do you download a full local copy of that repository to your machine?

git clone <url>

Cloning with git clone downloads the entire repository, including its full history and all branches, from a remote server to your local disk.

Your team members have uploaded new commits to the shared remote repository. You want to fetch those changes and immediately integrate them into your current local branch.

git pull

The git pull command is effectively a combination of git fetch and git merge (the default) or git rebase (if configured), integrating remote changes into your local branch.

You have finished making several commits locally and want to upload them to the remote GitHub repository so your team can see them.

git push

git push transmits your local commits to the remote server, updating the remote branch to match your local branch.

You have a specific commit hash and want to see detailed information about it, including the commit message, author, and the exact code diff it introduced.

git show <commit-hash>

git show displays the details of a specific Git object, most commonly used to inspect exactly what changed in a single commit.

You want to start working on a new feature in isolation. How do you create a new branch called ‘feature-auth’ and immediately switch to it in a single command?

git switch -c feature-auth

git switch -c creates a new branch and switches to it in one step. The -c flag stands for ‘create’. The legacy equivalent is git checkout -b feature-auth, which you will still encounter in older scripts and documentation.

You accidentally staged a file you didn’t intend to include in your next commit. How do you move it back to the working directory without losing your modifications?

git restore --staged <filename>

git restore --staged unstages a file by copying the version from the last commit back into the staging area, leaving your working directory modifications completely untouched. It is the modern equivalent of the older git reset HEAD <file>.

You made some experimental changes to a file but want to discard them entirely and revert to the version from your last commit.

git restore <filename>

git restore <file> discards unstaged changes in the working directory, reverting it to the staged version (or the last commit if nothing is staged). To explicitly revert to the last commit, use git restore --source=HEAD <file>.

You merge a feature branch into main, and Git performs the merge without creating a new merge commit — it simply moves the ‘main’ pointer forward. What type of merge is this, and when does it occur?

A fast-forward merge — occurs when ‘main’ has no new commits since the feature branch was created.

A fast-forward merge happens when the target branch hasn’t diverged. Git can simply advance its pointer in a straight line to the tip of the incoming branch, keeping the commit history perfectly linear. If both branches have diverged, Git performs a three-way merge and creates a merge commit instead.

You want to safely inspect the codebase at a specific older commit without modifying any branch. How do you do this?

git switch --detach <commit-hash>

git switch --detach places you in ‘detached HEAD’ state, where HEAD points directly to a specific commit rather than a branch. You can look around freely, but any commits made here are not anchored to a branch and can be lost when switching away. Use git switch -c <name> to anchor them to a new branch if needed.

Write a basic Makefile rule to compile a single C source file (main.c) into an executable named app.

app: main.c gcc main.c -o app

This defines app as the target, main.c as the prerequisite, and provides the exact compilation command required to build the executable. (Remember the command must be indented with a Tab).

Write a Makefile snippet that defines variables for the C compiler (gcc) and standard compilation flags (-Wall -g), and uses them to compile main.c into main.o.

`CC = gcc CFLAGS = -Wall -g

main.o: main.c $(CC) $(CFLAGS) -c main.c -o main.o`

Variables make the Makefile flexible. If you later want to switch to clang or add optimization flags, you only need to change the variable definitions at the top.

Write a standard clean target that removes all .o files and an app executable, ensuring it runs even if a file literally named ‘clean’ is created in the directory.

.PHONY: clean clean: rm -f *.o app

The .PHONY declaration tells make that clean is an action, not a file. The -f flag in rm prevents errors if the files don’t exist.

Write a generic pattern rule to compile any .c file into a corresponding .o file, using automatic variables for the target name and the first prerequisite.

%.o: %.c $(CC) $(CFLAGS) -c $< -o $@

The % acts as a wildcard. $< substitutes the name of the .c file, and $@ substitutes the name of the .o file.

Given a variable SRCS = main.c utils.c, write a variable definition for OBJS that dynamically replaces the .c extension with .o for all files in SRCS.

OBJS = $(SRCS:.c=.o)

This is a substitution reference. It takes the value of SRCS, looks for the .c suffix at the end of each word, and replaces it with .o.

Write a rule to link an executable myprog from a list of object files stored in the $(OBJS) variable, using the automatic variable that lists all prerequisites.

myprog: $(OBJS) $(CC) $^ -o $@

$^ expands to a space-separated list of all prerequisites (all the .o files), and $@ expands to the target name (myprog).

Write the conventional default target rule that is used to build multiple executables (e.g., app1 and app2) when a user simply types make without specifying a target.

all: app1 app2

By convention, all is the first target in a Makefile. Since make defaults to the first target it sees, this guarantees both apps are built. No commands are needed; simply listing them as prerequisites triggers their respective build rules.

Write a run target that executes an output file named ./app, but suppresses make from printing the command to the terminal before running it.

run: app @./app

Adding the @ symbol at the very beginning of the recipe line tells make to execute the command silently (without echoing it to standard output first).

Write a variable definition SRCS that uses a Make function to dynamically find and list all .c files in the current directory.

SRCS = $(wildcard *.c)

The wildcard function tells make to search the filesystem and return a space-separated list of all files matching the given pattern.

Write a generic rule to create a build directory build/ using the mkdir command.

build/: mkdir -p $@

Directories can be targets just like regular files. The -p flag ensures mkdir doesn’t throw an error if the directory already exists.

You need to see a list of all the files and folders in your current directory. What command do you use?

ls

The ls command lists directory contents. You can also use flags like ls -l for a detailed list or ls -a to see hidden files.

You are currently in your home directory and need to navigate into a folder named ‘Documents’. Which command achieves this?

cd Documents

The cd (change directory) command is used to change the current working directory in the command line operating system.

You want to quickly view the entire contents of a small text file named ‘config.txt’ printed directly to your terminal screen.

cat config.txt

The cat (concatenate) command reads data from the file and gives its content as output. It is widely used to display file contents.

You need to find every line containing the word ‘ERROR’ inside a massive log file called ‘server.log’.

grep 'ERROR' server.log

grep searches for patterns in each file. It prints each line that matches the given pattern, making it invaluable for parsing logs.

You wrote a new bash script named ‘script.sh’, but when you try to run it, you get a ‘Permission denied’ error. How do you make the file executable?

chmod +x script.sh

The chmod command changes file modes or Access Control Lists. The +x flag specifically adds execute permissions to the file.

You want to rename a file from ‘draft_v1.txt’ to ‘final_version.txt’ without creating a copy.

mv draft_v1.txt final_version.txt

The mv command is used to move files or directories, but it is also the standard command used to rename a file by moving it to a new name in the same directory.

You are starting a new project and need to create a brand new, empty folder named ‘src’ in your current location.

mkdir src

mkdir stands for ‘make directory’. It creates a new directory with the specified name, provided you have the correct permissions.

You want to view the contents of a very long text file called ‘manual.txt’ one page at a time so you can scroll through it.

less manual.txt

The less command is a terminal pager program that allows viewing (but not editing) the contents of a text file one screen at a time, allowing both forward and backward navigation.

You need to create an exact duplicate of a file named ‘report.pdf’ and save it as ‘report_backup.pdf’.

cp report.pdf report_backup.pdf

The cp (copy) command is used to copy files or directories from one location to another.

You have a temporary file called ‘temp_data.csv’ that you no longer need and want to permanently delete from your system.

rm temp_data.csv

The rm (remove) command deletes files or directories. Use with caution, as deleted files are generally not recoverable.

You want to quickly print the phrase ‘Hello World’ to the terminal or pass that string into a pipeline.

echo 'Hello World'

The echo command outputs the strings it is being passed as arguments. It is commonly used in scripts to display messages or write data to a file using redirection.

You want to know exactly how many lines are contained within a file named ‘essay.txt’.

wc -l essay.txt

The wc (word count) command prints newline, word, and byte counts for a file. Adding the -l flag restricts the output to only the line count.

You need to perform an automated find-and-replace operation on a stream of text to change the word ‘apple’ to ‘orange’.

sed 's/apple/orange/g'

The sed (stream editor) s: Stands for ‘substitute’. /: The delimiter that separates the search and replacement terms. apple: The string you want to find. orange: The string you want to replace it with. g: Stands for ‘global’. This tells sed to replace every instance of ‘apple’ on a line, rather than just the first one it finds.

You have a space-separated log file and want a tool to extract and print only the 3rd column of data.

awk '{print $3}'

awk is a versatile command-line utility and programming language designed for text processing and data extraction, particularly excelling at handling structured, column-based data.

You want to store today’s date (formatted as YYYY-MM-DD) in a variable called TODAY so you can use it to name a backup file dynamically.

TODAY=$(date +%Y-%m-%d)

Command substitution $(...) executes the inner command in a subshell and replaces itself with the command’s standard output. This is the standard way to capture the result of a command into a variable.

A variable FILE holds the value my report.pdf. Running rm $FILE fails with a ‘No such file or directory’ error for both ‘my’ and ‘report.pdf’. How do you fix this?

rm "$FILE"

Without quotes, the shell performs word splitting on the expanded variable, breaking my report.pdf into two separate arguments: my and report.pdf. Wrapping the variable in double quotes ("$FILE") prevents word splitting and passes the entire value as a single argument.

You are writing a script that requires exactly two arguments. How do you check how many arguments were passed to the script so you can print a usage error if the count is wrong?

$#

$# expands to the total count of positional arguments passed to the script. A typical guard looks like: if [ $# -ne 2 ]; then echo 'Usage: script.sh src dest'; exit 1; fi. Other useful special variables: $1, $2 (individual args), $0 (script name), $@ (all args).

You want to create a directory called ‘build’ and then immediately run cmake .. inside it, but only if the directory creation succeeded — all in a single command.

mkdir build && cd build && cmake ..

The && (AND) operator runs the next command only if the previous one succeeded (exit code 0). If mkdir fails, neither cd nor cmake will execute. This is a concise alternative to a full if/then/fi block for simple success-guarded sequences.

At the start of a script, you need to change into /deploy/target. If that directory doesn’t exist, the script must abort immediately — write a defensive one-liner.

cd /deploy/target || exit 1

The || (OR) operator runs the right-hand command only if the left-hand command fails (non-zero exit code). This is the standard idiom for aborting a script when a critical precondition is not met, without needing a full if statement.

You want to delete all files ending in .tmp in the current directory using a single command, without listing each filename explicitly.

rm *.tmp

The * wildcard is a glob pattern — it is expanded by the shell itself (filename expansion) before rm runs. Globbing is entirely separate from regular expressions: in RegEx, * means ‘zero or more of the preceding character’, not ‘match anything’.

Given the snippet app: main.o network.o utils.o followed by the command $(CC) $(CFLAGS) $^ -o $@, what exactly does the command evaluate to if CC=gcc and CFLAGS=-Wall?

gcc -Wall main.o network.o utils.o -o app

$^ expands to all prerequisites (the three .o files), and $@ expands to the target name (app). This is the standard way to link object files into a final C executable.

If a C project Makefile contains SRCS = main.c math.c io.c and OBJS = $(SRCS:.c=.o), what does OBJS evaluate to?

main.o math.o io.o

This is a substitution reference. It iterates through every file listed in SRCS, finds the .c extension, and replaces it with .o to dynamically generate the list of object files needed for compilation.

Read this common pattern rule: %.o: %.c followed by $(CC) $(CFLAGS) -c $< -o $@. If make uses this rule to build utils.o from utils.c, what does $< represent?

utils.c

In a pattern rule, $< is an automatic variable that evaluates to the first prerequisite. In this case, it passes the specific C source file being compiled to the compiler.

You see the line CC ?= gcc at the top of a Makefile. What happens if a developer compiles the project by typing make CC=clang in their terminal?

The compiler used will be clang, not gcc.

The ?= operator is a conditional assignment. It only sets CC to gcc if CC has not already been defined. The command-line argument overrides the default.

A C project has a rule clean: rm -f *.o myapp. Why is it critical to also include .PHONY: clean in this Makefile?

To ensure the cleanup runs even if a developer accidentally creates a file literally named clean in the project directory.

Without .PHONY, if a file named clean exists and has no prerequisites, make will think the target clean is already “up to date” and will refuse to execute the rm command.

In the rule main.o: main.c main.h types.h, what happens if you edit and save types.h?

make will recompile main.o the next time it is run.

Even though types.h is not directly passed to the compiler in the recipe, listing header files as prerequisites tells make to track their modification timestamps. If a header changes, the object files that depend on it must be rebuilt.

You are reading a Makefile and see @echo "Compiling $@..." followed by @$(CC) -c $< -o $@. What do the @ symbols do?

They suppress the terminal from printing the actual commands before executing them.

Instead of seeing the messy gcc command printed out, the developer will only see the clean, custom message: Compiling main.o....

What is the conventional purpose of the CFLAGS variable in a C Makefile?

To store flags and options passed to the C compiler (e.g., warnings and optimizations).

Common values include -Wall (enable all warnings), -Wextra (extra warnings), -g (include debugging symbols), or -O2 (optimize for speed).

What is the conventional purpose of the LDFLAGS or LDLIBS variables in a C Makefile?

To store flags and library links passed to the linker during the final executable creation.

For example, if your C program uses the math library <math.h>, you would define LDLIBS = -lm so the linker knows to include it when combining the .o files.

A C project has multiple executables: a server and a client. The Makefile starts with all: server client. What happens if you just type make?

It will build both the server and the client executables.

make defaults to the first target defined in the file (which is all here). By listing both programs as prerequisites for all, it forces make to evaluate and build the rules for both of them.

What metacharacter asserts the start of a string?

^ (Caret)

Placed at the very beginning of a pattern, it constrains the match to the start of the string.

What metacharacter asserts the end of a string?

$ (Dollar sign)

Placed at the very end of a pattern, it constrains the match to the end of the string.

What syntax is used to define a Character Class (matching any single character from a specified group)?

[...] (Square brackets)

Wrapping characters in square brackets tells the engine to match exactly one of the characters found inside.

What syntax is used inside a character class to act as a negation operator (matching any character NOT in the group)?

[^...] (Caret immediately after the opening bracket)

If the caret is the very first character inside the brackets, it inverts the character class.

What metacharacter is used to match any single digit?

\d

This is the direct equivalent of the character class [0-9].

What meta character is used to match any ‘word’ character (alphanumeric plus underscore)?

\w

This is the direct equivalent of the character class [a-zA-Z0-9_].

What meta character is used to match any whitespace character (spaces, tabs, line breaks)?

\s

This quickly targets formatting and spacing characters.

What metacharacter acts as a wildcard, matching any single character except a newline?

. (Dot)

To match a literal dot, you would need to escape it (.).

What quantifier specifies that the preceding element should match ‘0 or more’ times?

* (Asterisk)

This allows the preceding character or group to be completely absent or repeat infinitely.

What quantifier specifies that the preceding element should match ‘1 or more’ times?

+ (Plus sign)

This guarantees the character or group appears at least once, but allows it to repeat infinitely.

What quantifier specifies that the preceding element should match ‘0 or 1’ time?

? (Question mark)

This essentially makes the preceding character, class, or group optional.

What syntax is used to specify that the preceding element must repeat exactly n times?

{n} (Curly braces with a number)

You can also specify a range of repetitions using {n,m}.

What syntax is used to create a group?

(...) (Parentheses)

This groups tokens together as a single unit. You can apply quantifiers to the whole group and access the matched substring by index (e.g., match[1]).

What is the syntax used to create a Named Group?

(?<name>pattern) (or (?P<name>pattern) in Python)

A named group lets you assign a meaningful label to the match, so you can access it by name (e.g., match.groups.name) instead of just a numbered index.

Write a regex to validate a standard email address (e.g., user@domain.com).

^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$

This matches a sequence of alphanumeric characters and allowed symbols for the username, followed by an ‘@’, a domain name, and a 2+ character top-level domain.

Write a regex to match a standard US phone number, with optional parentheses and various separators (e.g., 123-456-7890 or (123) 456-7890).

^(\(\d{3}\)|\d{3})[- .]?\d{3}[- .]?\d{4}$

The first group matches either 3 digits in parentheses or just 3 digits. The [- .]? allows for an optional dash, space, or dot between the number segments.

Write a regex to match a 3 or 6 digit hex color code starting with a hashtag (e.g., #FFF or #1A2B3C).

^#([a-fA-F0-9]{6}|[a-fA-F0-9]{3})$

Matches the literal ‘#’ followed by either exactly 6 hexadecimal characters or exactly 3 hexadecimal characters, ensuring no extra characters exist using the $ anchor.

Write a regex to validate a strong password (at least 8 characters, containing at least one uppercase letter, one lowercase letter, and one number).

^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)[a-zA-Z\d]{8,}$

Uses positive lookaheads (?=...) to scan ahead and guarantee the presence of a lowercase, uppercase, and digit before matching a string of 8 or more valid characters.

Write a regex to match a valid IPv4 address (e.g., 192.168.1.1).

^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$

Ensures that each of the 4 octets falls between 0 and 255, separating the first three with literal dots.

Write a regex to extract the domain name from a URL, ignoring the protocol and ‘www’ (e.g., extracting ‘example.com’ from ‘https://www.example.com/page’).

^(https?:\/\/)?(www\.)?(?<domain>[^\/]+)

The groups (...) make the ‘http(s)://’ and ‘www.’ optional. The named group (?<domain>...) matches all characters up to the first forward slash, accessible via match.groups.domain.

Write a regex to match a date in the format YYYY-MM-DD with basic month and day validation.

^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$

Matches exactly 4 digits for the year, restricts the month to 01-12, and restricts the day to 01-31. Note: this does not validate that the day is correct for the specific month (e.g., it would accept February 31).

Write a regex to match a time in 24-hour format (HH:MM).

^([01]\d|2[0-3]):([0-5]\d)$

The hour group allows either 00-19 or 20-23. The minute group strictly allows 00-59.

Write a regex to match an opening or closing HTML tag.

<\/?[a-zA-Z][\s\S]*>

Matches the opening <, an optional / for closing tags, a starting letter (upper or lowercase), and then any characters (including newlines) until the closing >.

Write a regex to find all leading and trailing whitespaces in a string (commonly used for string trimming).

^\s+|\s+$

Matches one or more whitespace characters \s+ at the start ^ of the string, OR | one or more whitespace characters at the end $ of the string.

Workout Complete!

Your Score: 0/102

Come back later to improve your recall!

Tools Master Quiz

A comprehensive mix of all tools flashcards.

A developer needs to parse a massive log file, extract IP addresses, sort them, and count unique occurrences. Instead of writing a 500-line Python script, they use cat | awk | sort | uniq -c. Why is this approach fundamentally preferred in the UNIX environment?

Correct Answer:

Explanation

The UNIX design philosophy revolves around writing programs that ‘do one thing and do it well’, and having them work together by handling text streams. Pipelines allow complex tasks to be solved elegantly by chaining these simple tools together.

A script runs a command that generates both useful output and a flood of permission error messages. The user runs script.sh > output.txt, but the errors still clutter the terminal screen while the useful data goes to the file. What underlying concept explains this behavior?

Correct Answer:

Explanation

In UNIX, processes have three default streams: stdin, stdout, and stderr. Redirection with > only captures stdout. To capture the errors, you would need to redirect stderr specifically (e.g., using 2>).

A C++ developer writes a Bash script with a for loop. Inside the loop, they declare a variable temp_val. After the loop finishes, they try to print temp_val expecting it to be undefined or empty, but it prints the last value assigned in the loop. Why did this happen?

Correct Answer:

Explanation

Bash does not use block-level scoping. Unless explicitly declared as local inside a function, variables assigned within control structures like loops or conditionals bleed into the rest of the script.

You want to use a command that requires two file inputs (like diff), but your data is currently coming from the live outputs of two different commands. Instead of creating temporary files on the disk, you use the <(command) syntax. What is this concept called and what does it achieve?

Correct Answer:

Explanation

Process substitution <() allows the standard output of a command to be treated as a file. The operating system creates a temporary file descriptor (like /dev/fd/63) that the consuming command can read from as if it were a physical file.

A script contains entirely valid Python code, but the file is named script.sh and has #!/bin/bash at the very top. When executed via ./script.sh, the terminal throws dozens of ‘command not found’ and syntax errors. What is the fundamental misunderstanding here?

Correct Answer:

Explanation

In UNIX systems, file extensions are largely superficial. The shebang (#!) on the first line is what tells the operating system’s program loader which interpreter program (e.g., Bash, Python, Node) to use to parse the rest of the file.

A developer uses the regular expression [0-9]{4} to validate that a user’s input is exactly a four-digit PIN. However, the system incorrectly accepts ‘12345’ and ‘A1234’. What crucial RegEx concept did the developer omit?

Correct Answer:

Explanation

Without anchors, a regular expression looks for a match anywhere within the string. Because ‘12345’ contains ‘1234’, the pattern matches. Adding ^ (start) and $ (end) ensures the pattern must account for the entire string.

You are designing a data pipeline in the shell. Which of the following statements correctly describe how UNIX handles data streams and command chaining? (Select all that apply)

Correct Answers:

Explanation

Pipes (|) link stdout to stdin, >> appends stdout to a file, and < feeds a file into stdin. By default, pipes do NOT pass stderr (errors will still print to the screen). >! is not the standard way to redirect both streams in Bash (typically >& or &> is used).

You’ve written a shell script deploy.sh but it throws a ‘Permission denied’ error or fails to run when you type ./deploy.sh. Which of the following are valid reasons or necessary steps to successfully execute a script as a standalone program? (Select all that apply)

Correct Answers:

Explanation

Scripts require execute permissions (chmod +x) to be run as programs, and a shebang tells the OS how to interpret the text. They are interpreted, not compiled. The ./ explicitly tells the OS to look in the current directory, bypassing the need for the directory to be in the $PATH.

In Bash, exit codes are crucial for determining if a command succeeded or failed. Which of the following statements are true regarding how Bash handles exit statuses and control flow? (Select all that apply)

Correct Answers:

Explanation

In UNIX, an exit code of 0 means success, while non-zero (like 1) means failure/error. if statements work by running a command and proceeding if its exit code is 0. set -e is a common safety mechanism to fail fast if an error occurs.

When you type a command like python or grep into the terminal, the shell knows exactly what program to run without you providing the full file path. How does the $PATH environment variable facilitate this, and how is it managed? (Select all that apply)

Correct Answers:

Explanation

$PATH is an explicit list of directories, not a global search crawler (which would be extremely slow). The OS checks these directories in order. Modifications in the terminal are bound to that specific session unless saved in a configuration file like .bashrc.

A developer writes LOGFILE="access errors.log" and then runs wc -l $LOGFILE. The command fails with ‘No such file or directory’ errors for both ‘access’ and ‘errors.log’. What is the root cause?

Correct Answer:

Explanation

When a variable is expanded without double quotes, the shell splits the result on whitespace. wc -l $LOGFILE is interpreted as wc -l access errors.log — two separate arguments. The fix is to always quote variable expansions: wc -l "$LOGFILE".

A script is invoked with ./deploy.sh production 8080 myapp. Inside the script, which variable holds the value 8080?

Correct Answer:

Explanation

$0 is the script name (./deploy.sh), $1 is the first argument (production), $2 is the second argument (8080), and $3 would be myapp. $# holds the total argument count (3).

A script contains the line: cd /deploy/target && ./run_tests.sh && echo 'All tests passed!'. If ./run_tests.sh exits with a non-zero status code, what happens next?

Correct Answer:

Explanation

The && operator short-circuits on failure. Since ./run_tests.sh returned a non-zero exit code, the shell skips all remaining &&-linked commands. Only if every command in the chain succeeds does echo 'All tests passed!' execute.

Which of the following statements correctly describe Bash quoting and command substitution behavior? (Select all that apply)

Correct Answers:

Explanation

Single quotes suppress all expansion; double quotes allow variable and command substitution while protecting spaces. Quoting "$VARIABLE" is essential to prevent word splitting on values containing spaces. Single and double quotes are NOT interchangeable when variable expansion is needed. $(command) is command substitution — the standard way to capture command output into a variable.

Arrange the pipeline fragments to build a command that extracts all ERROR lines from a log, sorts them, removes duplicates, and counts how many unique errors remain.

Drag fragments into the answer area in the correct order (some items are distractors that should not be used):

→ Drop here →

Correct order:
grep 'ERROR' server.log|sort|uniq|wc -l

Explanation

grep filters for ERROR lines, sort orders them (required before uniq), uniq removes adjacent duplicates, and wc -l counts the remaining lines. Each | pipes stdout to the next command’s stdin — the UNIX philosophy of chaining single-purpose tools. cat is unnecessary here (UUOC — Useless Use of Cat) and > would redirect to a file rather than pipe.

Arrange the lines to write a shell script that validates a command-line argument, prints an error to stderr if missing, and exits with a non-zero code.

Drag lines into the solution area in the correct order (some items are distractors that should not be used):

↓ Drop here ↓

Correct order:
#!/bin/bash
if [ $# -lt 1 ]; then
echo "Error: no filename given" >&2
exit 1
fi
echo "Processing $1..."

Explanation

The shebang (#!/bin/bash) must be the first line. The if [ $# -lt 1 ] test checks argument count, >&2 redirects echo to stderr, and exit 1 terminates with a failure code. fi closes the if block (no semicolon). The distractor return 1 only works inside functions, not at the top level of a script. fi; with a trailing semicolon is unnecessary and unconventional.

Arrange the pipeline fragments to find the 5 most frequently occurring IP addresses in an access log.

Drag fragments into the answer area in the correct order (some items are distractors that should not be used):

→ Drop here →

Correct order:
grep -oE '[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+' access.log|sort|uniq -c|sort -rn|head -5

Explanation

The grep -oE extracts all IPv4 addresses (one per line). sort groups identical IPs together (required for uniq). uniq -c counts each group. sort -rn sorts by count in descending numeric order. head -5 takes the top 5. tail -5 would give the least frequent, and wc -l would just count total lines.

Arrange the fragments to redirect both stdout and stderr of a deployment script into a single log file.

Drag fragments into the answer area in the correct order (some items are distractors that should not be used):

→ Drop here →

Correct order:
./deploy.sh>output.log2>&1

Explanation

> output.log redirects stdout to the file first, then 2>&1 redirects stderr to wherever stdout currently points (the file). Order matters: 2>&1 > output.log would send stderr to the original stdout (terminal) and only stdout to the file. The distractor 1>&2 goes the wrong direction — it sends stdout to stderr. Using 2> output.log alone still lets stdout reach the terminal.

Arrange the pipeline to count how many files under src/ contain the word TODO.

Drag fragments into the answer area in the correct order (some items are distractors that should not be used):

→ Drop here →

Correct order:
grep -rl 'TODO' src/|wc -l

Explanation

grep -rl (recursive, files-with-matches) prints one matching filename per line — each file counted once regardless of how many matches it contains. wc -l then counts those filenames. The distractor grep -r (without -l) prints every matching line, so wc -l would count occurrences, not files. sort is unnecessary here since we only need a count.

Arrange the fragments to grant execute permission on a script and immediately run it.

Drag fragments into the answer area in the correct order (some items are distractors that should not be used):

→ Drop here →

Correct order:
chmod +x script.sh&&./script.sh

Explanation

chmod +x script.sh adds the execute bit, making the file runnable as a program. && ensures the script only runs if chmod succeeded. ./script.sh executes it using the shebang to select the interpreter. Using || instead of && would run the script only when chmod fails — the opposite of the intent. sh script.sh works but bypasses the shebang, hardcoding the interpreter to sh regardless of what the script specifies.

Which of the following best describes the core difference between centralized and distributed version control systems (like Git)?

Correct Answer:

Explanation

This defines the distributed model, giving developers offline access to the full project history and the ability to work independently.

What are the three primary local states that a file can reside in within a standard Git workflow?

Correct Answer:

Explanation

Files are edited in the working directory, moved to the staging area to prep for a snapshot, and finally committed to the local repository.

What does the command git diff HEAD compare?

Correct Answer:

Explanation

Adding HEAD tells Git to compare the uncommitted files currently on your disk with the snapshot of the most recent commit.

Which Git command should you NEVER use on a shared branch because it can permanently overwrite and destroy work pushed by other team members?

Correct Answer:

Explanation

Force-pushing overwrites the remote repository’s history to exactly match yours, which will permanently delete any new commits made by your collaborators.

You have some uncommitted, incomplete changes in your working directory, but you need to switch to another branch to urgently fix a bug. Which command is best suited to temporarily save your current work without making a messy commit?

Correct Answer:

Explanation

git stash temporarily shelves your staged and unstaged changes, leaving you with a clean working directory so you can safely switch contexts.

What happens when you enter a ‘Detached HEAD’ state in Git?

Correct Answer:

Explanation

Checking out a specific commit hash detaches HEAD. Any new commits made in this state won’t update a branch pointer and can easily be lost.

Which Git command utilizes a binary search through your commit history to help you pinpoint the exact commit that introduced a bug?

Correct Answer:

Explanation

git bisect systematically halves your commit history, asking you to test if the bug is present at each step, to efficiently find the exact commit that broke the code.

What is the primary purpose of Git Submodules?

Correct Answer:

Explanation

Submodules allow you to nest an independent repository inside your main project, pointing to a specific commit of that external library.

Which of the following are advantages of a Distributed Version Control System (like Git) compared to a Centralized one? (Select all that apply)

Correct Answers:

Explanation

In distributed systems like Git, developers have a full local copy of the repository, allowing for offline work and eliminating the single point of failure found in centralized systems. This makes it ideal for large, distributed teams. However, it does not prevent merge conflicts.

Which of the following represent the core local states (or areas) where files can reside in a standard Git architecture? (Select all that apply)

Correct Answers:

Explanation

The three primary local states in Git’s architecture are the Working Directory (files on disk), the Staging Area (prepped for the next commit), and the Local Repository (the compressed history of commits). The remote server is external, and ‘Detached HEAD’ is a state of the HEAD pointer, not a file area.

Which of the following commands are primarily used to review changes, history, or differences in a Git repository? (Select all that apply)

Correct Answers:

Explanation

git log shows the commit history, git diff shows differences between states or commits, and git show displays details about a specific Git object (like a commit). git push uploads data, and git init creates a new repository.

In which of the following scenarios would using git stash be considered an appropriate and helpful practice? (Select all that apply)

Correct Answers:

Explanation

git stash temporarily shelves your local modifications (both staged and unstaged), leaving you with a clean working directory. This is perfect for quick context switches or pulling updates without committing messy, incomplete work. It is not used for permanent deletion or applying commits (which would be git cherry-pick).

Which of the following are valid methods or strategies for integrating changes from a feature branch back into the main codebase? (Select all that apply)

Correct Answers:

Explanation

Merging, rebasing, and squashing (git merge --squash) are all techniques used to integrate branch histories together. git bisect is a debugging tool for finding bugs, and git blame is used to see who last modified specific lines of code.

A faulty commit was pushed to a shared ‘main’ branch last week and your teammates have already synced it. Why should you use git revert to fix this rather than git reset --hard followed by a force-push?

Correct Answer:

Explanation

git revert is the safe choice on shared branches because it adds a new forward-moving commit that nullifies the targeted commit, without rewriting or destroying history. Using git reset --hard and force-pushing would overwrite the shared history, causing serious disruption for any teammate who has already synced that commit.

When integrating a feature branch into ‘main’, under what condition will Git perform a fast-forward merge rather than creating a three-way merge commit?

Correct Answer:

Explanation

A fast-forward merge occurs when the target branch’s history has not diverged — Git can simply slide its pointer forward to incorporate the changes linearly. If both branches have unique commits since they split, Git must perform a three-way merge using their common ancestor, resulting in a merge commit with two parents.

What does the file .git/HEAD contain when you are checked out on a branch, compared to when you are in a detached HEAD state?

Correct Answer:

Explanation

Normally, .git/HEAD is a symbolic reference like ref: refs/heads/main — a pointer to a branch pointer. When you enter detached HEAD state (e.g., with git switch --detach <hash>), HEAD is disconnected from any branch and contains the raw SHA hash of a specific commit directly. Any commits made in this state are not anchored to a branch and can be lost when switching away.

Arrange the Git commands into the correct order to: create a feature branch, make changes, and integrate them back into main via a merge.

Drag fragments into the answer area in the correct order (some items are distractors that should not be used):

→ Drop here →

Correct order:
git switch -c feature&&git add app.py&&git commit -m 'Add feature'&&git switch main&&git merge feature

Explanation

The workflow is: create and switch to a feature branch (switch -c), stage changes (add), commit them, switch back to main, and merge the feature branch in. git push -f is dangerous on shared branches and is not part of a local merge workflow. git init creates a new repository — irrelevant here.

Arrange the commands to safely stash your work, pull remote changes, and restore your stashed work.

Drag fragments into the answer area in the correct order (some items are distractors that should not be used):

→ Drop here →

Correct order:
git stash&&git pull&&git stash pop

Explanation

git stash saves uncommitted changes temporarily, git pull fetches and merges remote changes onto a clean working directory, and git stash pop re-applies the stashed changes on top. git stash drop would discard the stash without applying it. git reset --hard would destroy all local changes — dangerous!

Arrange the commands to undo a bad commit on a shared branch safely: first identify the commit, then revert it, then push the fix.

Drag fragments into the answer area in the correct order (some items are distractors that should not be used):

→ Drop here →

Correct order:
git log --oneline&&git revert &&git push</code> </span> </div>

Explanation

git log identifies the bad commit hash. git revert creates a new commit that undoes the bad one — preserving history for all collaborators. git push shares the fix. The distractors (reset --hard + push -f) would rewrite shared history, destroying teammates’ work. Always use revert on shared branches, never reset --hard + force-push.

</div>

Arrange the commands to initialize a new repository and record an initial commit.

Drag fragments into the answer area in the correct order (some items are distractors that should not be used):

→ Drop here →

Correct order:
git init&&git add .&&git commit -m 'Initial commit'

Explanation

git init creates the repository, git add . stages every file in the working directory, and git commit records the first snapshot. git clone copies an existing remote repo — it doesn’t create one from scratch. git push requires a remote to already exist.

Arrange the commands to register a remote called origin and push the main branch to it for the first time.

Drag fragments into the answer area in the correct order (some items are distractors that should not be used):

→ Drop here →

Correct order:
git remote add origin &&git push -u origin main</code> </span> </div>

Explanation

git remote add origin <url> registers the remote address under the alias origin. git push -u origin main uploads the branch and sets the upstream tracking reference so future git push/git pull calls need no extra arguments. git fetch and git pull download data — they don’t publish your local branch.

</div>

Arrange the commands to stage a forgotten file and fold it into the last commit without changing the commit message.

Drag fragments into the answer area in the correct order (some items are distractors that should not be used):

→ Drop here →

Correct order:
git add forgotten.py&&git commit --amend --no-edit

Explanation

git add forgotten.py stages the missing file, and git commit --amend --no-edit rewrites the previous commit to include it while keeping the original message. git reset --hard HEAD~1 would destroy the previous commit entirely. Creating a brand-new commit (-m 'Add forgotten file') is valid but pollutes history with a fixup commit — amend is cleaner when the previous commit hasn’t been pushed.

What is the primary mechanism make uses to determine if a target needs to be rebuilt?

Correct Answer:

Explanation

make looks at the file modification timestamps. If a prerequisite (like a .c file) has a newer timestamp than the target (like a .o file), make knows the source code has changed and recompiles the target. This enables efficient incremental builds.

What specific whitespace character MUST be used to indent the command/recipe lines in a Makefile rule?

Correct Answer:

Explanation

Makefile syntax strictly requires command lines (recipes) to be indented with a single Tab character. Using spaces will result in a ‘missing separator’ error.

What does the automatic variable $@ represent in a Makefile rule?

Correct Answer:

Explanation

$@ evaluates to the target name. It is heavily used in compilation commands (e.g., gcc ... -o $@) to dynamically specify the output file name.

Why is the .PHONY directive used in Makefiles (e.g., .PHONY: clean)?

Correct Answer:

Explanation

If you have a rule named clean, and a file literally named clean is accidentally created in the directory, make clean will say ‘clean is up to date’ and do nothing. .PHONY: clean forces make to execute the recipe regardless of whether a file named clean exists.

If a user runs the make command in their terminal without specifying a target, what will make do?

Correct Answer:

Explanation

By default, make begins execution with the first target it encounters in the file. By convention, developers often make the first target all (which depends on the main executables) so that running make builds the entire project.

You have a pattern rule: %.o: %.c. What does the % symbol do?

Correct Answer:

Explanation

The % symbol is a wildcard in pattern rules. %.o: %.c acts as a generic template, avoiding the need to write individual rules for every single source file in a project.

Which of the following are primary benefits of using a Makefile instead of a standard procedural Bash script (build.sh)? (Select all that apply)

Correct Answers:

Explanation

Makefiles save time via incremental compilation, manage complex dependency graphs automatically (declarative vs procedural), and provide standardized commands. They do not run the compiler faster, nor do they write code for you.

Which of the following are valid Automatic Variables in Make? (Select all that apply)

Correct Answers:

Explanation

$@, $<, and $^ are standard automatic variables used to make Makefile rules concise and dynamic. $# and $$ are Bash variables, not Make automatic variables.

In standard C/C++ project Makefiles, which of the following variables are common conventions used to increase flexibility? (Select all that apply)

Correct Answers:

Explanation

CC, CFLAGS, and LDFLAGS are universal conventions in Makefiles. Using them allows developers to easily swap compilers or add flags via command line arguments (e.g., make CC=clang) without editing the actual Makefile. MAKE_IT_FAST is not a standard convention.

How does the evaluation logic of a Makefile differ from a standard cookbook recipe or procedural script? (Select all that apply)

Correct Answers:

Explanation

Makefiles are declarative, not procedural. They do not execute top-to-bottom sequentially, nor do they execute blindly. They build a dependency graph from the top-down (starting at the target), and then execute the necessary commands from the bottom-up, skipping anything that is already up to date.

You are tasked with extracting all data enclosed in HTML <div> tags. You write a regular expression, but it consistently fails on deeply nested divs (e.g., <div><div>text</div></div>). From a theoretical computer science perspective, why is standard RegEx the wrong tool for this?

Correct Answer:

Explanation

Standard regular expressions correlate to regular languages in formal language theory. They are evaluated by Finite State Machines, which do not have a ‘stack’ or memory mechanism to keep track of balanced, nested pairs (unlike context-free grammars used by HTML parsers).

A developer writes a regex to parse a log file: ^.*error.*$. They notice that while it works, it runs much slower than expected on very long log lines. What underlying behavior of the .* token is causing this inefficiency?

Correct Answer:

Explanation

Greedy quantifiers (like * and +) match as much as possible right away. .* consumes the whole string, realizes it missed ‘error’, and has to backtrack (step backwards) one character at a time to find a match, which is computationally expensive on long strings.

You need to validate user input to ensure a password contains both a number and a special character, but you don’t know what order they will appear in. What mechanism allows a RegEx engine to assert these conditions without actually ‘consuming’ the string character by character?

Correct Answer:

Explanation

Lookaheads and lookbehinds are ‘zero-width assertions’. They look ahead in the string to verify a pattern exists, but they do not consume any characters. This allows you to chain multiple lookaheads at the start of a string to act like a logical ‘AND’ statement.

You are given the regex (?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2}) and apply it to the string 2026-04-01. After a successful match, which of the following correctly describes how you can access the captured month value?

Correct Answer:

Explanation

Named groups are assigned both a name and a positional index. You can retrieve the match using either match.group('month') or match.group(2). This dual-access design means named groups are a strict superset of numbered groups — they add readability without removing any existing functionality.

When writing a complex regex to extract phone numbers, you use parentheses (...) to group the area code so you can apply a ? quantifier. However, you also want to extract the area code by name for later use in your code. What is the best approach?

Correct Answer:

Explanation

Standard parentheses (...) create groups that can be accessed by index (e.g., match[1]). Named groups (?<name>...) let you assign a meaningful label, so you can access the matched value by name (e.g., match.groups.areaCode) — making your code self-documenting and easier to maintain.

You write a regex to ensure a username is strictly alphanumeric: [a-zA-Z0-9]+. However, a user successfully submits the username admin!@#. Why did this happen?

Correct Answer:

Explanation

Without positional anchors (^ for the start, $ for the end), a regex will search for any substring that satisfies the pattern. It found ‘admin’, considered it a successful match, and ignored the trailing invalid characters. Anchors are mandatory for strict input validation.

Which of the following scenarios are highly appropriate use cases for Regular Expressions? (Select all that apply)

Correct Answers:

Explanation

RegEx excels at pattern matching flat strings, validating strict formats, and doing structural find-and-replace operations. It should NOT be used to parse complex, tree-like structures like JSON or HTML, as it cannot handle infinite nesting and is prone to security bypasses.

In the context of evaluating a regex for data extraction, what represents a ‘False Positive’ and a ‘False Negative’? (Select all that apply)

Correct Answers:

Explanation

A False Positive is an unwanted match (the regex was too loose). A False Negative is a missed match (the regex was too strict and missed valid data). These are the two primary edge cases engineers must balance when writing patterns.

You use the regex <.*> to extract a single HTML tag from <b>bold</b> text, but it matches the entire string <b>bold</b> instead of just <b>. What is the simplest fix?

Correct Answer:

Explanation

By default, * is greedy — it matches as many characters as possible, consuming everything from the first < to the last >. Adding ? makes it lazy (*?), so it matches as few characters as possible and stops at the first > it encounters.

Which of the following statements about Lookaheads (?=...) are true? (Select all that apply)

Correct Answers:

Explanation

Lookaheads do not consume characters, can be chained to check multiple conditions from the exact same starting position, and are the standard way to enforce logical ‘AND’ in regex. However, they are a feature of PCRE (Perl Compatible Regular Expressions) and are generally NOT supported by basic POSIX tools like standard sed.

Arrange the regex fragments to build a pattern that validates a simple email address like user@example.com. The pattern should be anchored to match the entire string.

Drag fragments into the answer area in the correct order (some items are distractors that should not be used):

→ Drop here →

Correct order:
^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$

Explanation

The pattern anchors with ^ and $ to match the full string. [a-zA-Z0-9._%+-]+ matches the local part (username), @ is the literal at-sign, [a-zA-Z0-9.-]+ matches the domain name, and \.[a-zA-Z]{2,} matches the dot followed by a TLD of at least 2 letters. The distractors \d{3} (three digits) and \s+ (whitespace) have no place in an email pattern.

Arrange the regex fragments to build a pattern that matches a date in YYYY-MM-DD format (e.g., 2024-01-15). Anchor the pattern.

Drag fragments into the answer area in the correct order (some items are distractors that should not be used):

→ Drop here →

Correct order:
^\d{4}-\d{2}-\d{2}$

Explanation

The date pattern uses \d{4} for the 4-digit year, literal - as separators, and \d{2} for 2-digit month and day. Anchors ^ and $ ensure the entire string is a date. The / distractor would be for a different date format (MM/DD/YYYY), and \w+ is too broad (matches letters, digits, and underscores).

Arrange the regex fragments to extract the protocol and domain from a URL like https://www.example.com/path. Use a capturing group for the domain.

Drag fragments into the answer area in the correct order (some items are distractors that should not be used):

→ Drop here →

Correct order:
https?://([^/]+)

Explanation

https?:// matches both http:// and https:// (the s is optional via ?). The capturing group ([^/]+) matches one or more characters that are NOT a forward slash — i.e., the domain name. \w+:// is a distractor that would also match things like ftp:// which wasn’t the intent, and [a-z] matches only a single lowercase letter.

</div>

Workout Complete!

Your Score: 0/65

</div>