Capturing groups and backreferences in PHP - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to match a word using a capturing group.

PHP

<?php
$pattern = '/(\w+)[1]/';
$text = 'Hello';
if (preg_match($pattern, $text, $matches)) {
    echo $matches[1];
}
?>

Drag options to blanks, or click blank then click option'

A+

B*

C?

D{2}

Attempts:

3 left

💡 Hint

Common Mistakes

Using '*' matches zero or more, which might match empty strings.

Using '?' matches zero or one, which might not capture the full word.

The + quantifier matches one or more of the preceding token, so (\w)+ captures one or more word characters.

2fill in blank

medium

Complete the code to use a backreference to match repeated words.

PHP

<?php
$pattern = '/(\w+)[1]\1/';
$text = 'hello hello';
if (preg_match($pattern, $text)) {
    echo 'Match found';
}
?>

Drag options to blanks, or click blank then click option'

A\d+

B\S+

C\w+

D\s+

Attempts:

3 left

💡 Hint

Common Mistakes

Using \d+ matches digits, not spaces.

Using \w+ matches word characters, which won't match spaces.

The backreference \1 matches the same text as the first capturing group. The \s+ matches one or more whitespace characters between the repeated words.

3fill in blank

hard

Fix the error in the pattern to correctly match a repeated word using backreference.

PHP

<?php
$pattern = '/(\w+)[1]\1/';
$text = 'test test';
if (preg_match($pattern, $text)) {
    echo 'Repeated word found';
}
?>

Drag options to blanks, or click blank then click option'

A\d+

B\w+

C\s+

D\S+

Attempts:

3 left

💡 Hint

Common Mistakes

Using \w+ or \d+ which do not match spaces.

Not escaping the backslash properly.

The pattern needs to match whitespace between the repeated words. Using \s+ fixes the error.

4fill in blank

hard

Fill both blanks to create a pattern that matches a word repeated twice with a space between.

PHP

<?php
$pattern = '/([1])[2]\1/';
$text = 'echo echo';
if (preg_match($pattern, $text)) {
    echo 'Match!';
}
?>

Drag options to blanks, or click blank then click option'

A\\w+

B\\d+

C\\s+

D\\S+

Attempts:

3 left

💡 Hint

Common Mistakes

Using \d+ for the word, which matches digits only.

Using \S+ for the space, which matches non-space characters.

The first blank should capture one or more word characters (\w+), and the second blank should match one or more whitespace characters (\s+) between the repeated words.

5fill in blank

hard

Fill all three blanks to create a pattern that matches a repeated word separated by a comma and space.

PHP

<?php
$pattern = '/([1])[2]\1[3]/';
$text = 'word, word ';
if (preg_match($pattern, $text)) {
    echo 'Pattern matched';
}
?>

Drag options to blanks, or click blank then click option'

A\\w+

B\\s*,\\s*

C\\s+

D,

Attempts:

3 left

💡 Hint

Common Mistakes

Using a literal ', ' for the comma and space, which is less flexible.

Not matching spaces properly around the comma.

The first blank captures one or more word characters (\w+). The second blank matches a comma possibly surrounded by spaces (\s*,\s*). The third blank matches one or more spaces (\s+) after the repeated word.

Practice

1. What does a capturing group in a PHP regular expression do?

easy

A. It ignores the matched text inside parentheses.

B. It repeats the entire pattern multiple times.

C. It saves part of the matched text for later use.

D. It changes the case of matched text.

Solution

1. Step 1: Understand capturing groups

   Parentheses () in regex save the matched part for reuse.

2. Step 2: Purpose of capturing groups

   This saved part can be accessed later in the code or reused in the pattern.

3. Final Answer:

   It saves part of the matched text for later use. -> Option C

4. Quick Check:

   Capturing group = save matched text [OK]

Hint: Parentheses capture text to reuse later in regex or code [OK]

Common Mistakes:

• Thinking capturing groups repeat patterns
• Believing they ignore matched text
• Assuming they change text case

2. Which of the following is the correct syntax for a backreference to the first capturing group in a PHP regex pattern?

easy

A. \(1\)

B. \\1

C. \$1

D. \1

Solution

1. Step 1: Identify backreference syntax in PHP regex

   Backreferences use a single backslash followed by group number, like \1 in regex patterns.

2. Step 2: Differentiate from string escaping

   In PHP strings, to represent \1 you write "\\1" but the regex pattern itself uses \1.

3. Final Answer:

   \1 -> Option D

4. Quick Check:

   Backreference first group = \1 [OK]

Hint: Use single backslash before group number for backreference in regex [OK]

Common Mistakes:

• Using double backslash instead of single
• Confusing backreference with variable syntax
• Adding parentheses around the number

3. What will be the output of the following PHP code?

$pattern = '/(\w+)\s\1/';
$subject = 'hello hello world';
if (preg_match($pattern, $subject, $matches)) {
    echo $matches[0];
} else {
    echo 'No match';
}

medium

A. hello world

B. hello hello

C. No match

D. hello

Solution

1. Step 1: Understand the regex pattern

   The pattern /(\w+)\s\1/ matches a word, a space, then the same word again (backreference \1).

2. Step 2: Apply pattern to the subject string

   The string 'hello hello world' contains 'hello hello' which matches the pattern.

3. Final Answer:

   hello hello -> Option B

4. Quick Check:

   Backreference matches repeated word = hello hello [OK]

Hint: Backreference \1 matches exact previous captured word [OK]

Common Mistakes:

• Ignoring backreference meaning
• Matching different words instead of repeated
• Expecting full string match

4. Identify the error in this PHP regex pattern: preg_match('/(\d+)\s\2/', '123 123', $matches);

medium

A. Backreference \2 is invalid because only one group is captured.

B. The pattern should use \1 instead of \2 for backreference.

C. The pattern is missing delimiters.

D. The pattern should not use capturing groups.

Solution

1. Step 1: Count capturing groups in the pattern

   There is only one capturing group: (\d+), so only \1 is valid.

2. Step 2: Check backreference usage

   Using \2 refers to a second group which does not exist, causing an error.

3. Final Answer:

   Backreference \2 is invalid because only one group is captured. -> Option A

4. Quick Check:

   Backreference number must match captured groups [OK]

Hint: Backreference number must not exceed captured groups count [OK]

Common Mistakes:

• Using backreference number higher than groups
• Ignoring missing groups
• Confusing delimiters with backreferences

5. Given the string 'abc123abc456', which regex pattern using capturing groups and backreferences will match the repeated substring 'abc' only if it appears twice separated by digits?

hard

A. /(abc)\d+\1/

B. /(abc)\1\d+/

C. /abc(\d+)abc/

D. /(abc)+\d+/

Solution

1. Step 1: Understand the requirement

   We want to match 'abc' repeated twice with digits in between.

2. Step 2: Analyze each pattern

   /(abc)\d+\1/: /(abc)\d+\1/ matches 'abc', digits, then same 'abc' again. This fits the requirement.
   /(abc)\1\d+/: /(abc)\1\d+/ expects 'abcabc' then digits, which is incorrect.
   /abc(\d+)abc/: /abc(\d+)abc/ matches 'abc', digits, 'abc' but digits are captured, not 'abc'.
   /(abc)+\d+/: /(abc)+\d+/ matches one or more 'abc' then digits, but no backreference to ensure repetition.

3. Final Answer:

   /(abc)\d+\1/ -> Option A

4. Quick Check:

   Backreference \1 repeats captured 'abc' after digits [OK]

Hint: Backreference \1 repeats first group exactly where needed [OK]

Common Mistakes:

• Placing backreference before digits
• Not using backreference to repeat 'abc'
• Capturing digits instead of 'abc'