DNF types (Disjunctive Normal Form) in PHP - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define a simple DNF clause array.

PHP

<?php
$clause = [[1]];
?>

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

A'A && B'

B'A || B'

C'A && !B'

D'!A || !B'

Attempts:

3 left

💡 Hint

Common Mistakes

Using '||' instead of '&&' inside a clause.

The clause in DNF is a conjunction (AND) of literals, so 'A && B' is correct.

2fill in blank

medium

Complete the code to represent a DNF formula as an array of clauses.

PHP

<?php
$dnf = [
    ['A', 'B'],
    [1]
];
?>

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

A['A && C']

B['A || C']

C['!A', 'C']

D['!A || C']

Attempts:

3 left

💡 Hint

Common Mistakes

Using combined strings with '||' or '&&' inside a clause.

Each clause is an array of literals combined with AND. So ['!A', 'C'] is a valid clause.

3fill in blank

hard

Fix the error in the code to correctly check if a literal is negated.

PHP

<?php
$literal = '!A';
$isNegated = [1];
?>

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

Astrpos($literal, '!') === 0

Bstrpos($literal, '!') == 1

Cstrpos($literal, '!') === false

Dstrpos($literal, '!') > 0

Attempts:

3 left

💡 Hint

Common Mistakes

Checking for position 1 or greater instead of 0.

To check if the literal starts with '!', strpos must return 0 (start of string).

4fill in blank

hard

Fill both blanks to create a function that returns true if a clause contains a literal.

PHP

<?php
function containsLiteral(array $clause, string $literal): bool {
    return in_array([1], [2]);
}
?>

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

A$literal

B$clause

C$literal[0]

D$clause[0]

Attempts:

3 left

💡 Hint

Common Mistakes

Swapping the arguments or using incorrect variables.

The function checks if the literal is in the clause array using in_array.

5fill in blank

hard

Fill all three blanks to build a DNF formula and check if it contains a negated literal.

PHP

<?php
$dnf = [
    ['A', 'B'],
    ['!C', 'D']
];

foreach ($dnf as $clause) {
    foreach ($clause as [1]) {
        if (strpos([2], '!') === 0) {
            echo [3] . " is negated\n";
        }
    }
}
?>

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

A$literal

B$clause

D$clause[0]

Attempts:

3 left

💡 Hint

Common Mistakes

Using the clause array instead of the literal variable inside the loop.

We loop over each literal in a clause, check if it starts with '!', and print the literal.

Practice

1.

What does a Disjunctive Normal Form (DNF) type represent in PHP?

easy

A. A type that disables type checking

B. A type that combines OR (union) and AND (intersection) conditions

C. A type that restricts variables to integers only

D. A type that only allows a single data type

Solution

1. Step 1: Understand DNF type concept

   DNF types combine multiple conditions using OR (union) and AND (intersection) to specify allowed types.

2. Step 2: Compare options with definition

   Only the type that combines OR (union) and AND (intersection) conditions correctly describes this combination of OR and AND conditions in PHP types.

3. Final Answer:

   A type that combines OR (union) and AND (intersection) conditions -> Option B

4. Quick Check:

   DNF types = OR + AND conditions [OK]

Hint: DNF means combining OR and AND in types [OK]

Common Mistakes:

• Thinking DNF only means union types
• Confusing DNF with simple single types
• Assuming DNF disables type checks

2.

Which of the following is the correct PHP syntax for a DNF type combining union and intersection?

function example( /* type here */ $param) {}

easy

A. int&float&Serializable

B. int&float|Serializable

C. int|float|Serializable

D. int|float&Serializable

Solution

1. Step 1: Recall PHP DNF syntax rules

   PHP uses | for union (OR) and & for intersection (AND). Intersection has higher precedence, so int|float&Serializable means int OR (float AND Serializable).

2. Step 2: Analyze each option

   int|float&Serializable correctly uses union and intersection combined. int&float|Serializable misplaces operators, C uses only union, D uses only intersection.

3. Final Answer:

   int|float&Serializable -> Option D

4. Quick Check:

   Union (|) and intersection (&) combined correctly = int|float&Serializable [OK]

Hint: Use | for OR, & for AND in PHP types [OK]

Common Mistakes:

• Mixing order of | and & operators
• Using only unions or only intersections
• Writing invalid syntax like &| or |&

3.

What is the output of this PHP code snippet?

interface A {} 
interface B {} 
class C implements A, B {} 
function test(A|B&object $param): string { 
  return $param instanceof B ? 'Yes' : 'No'; 
} 
$obj = new C(); 
echo test($obj);

medium

A. Fatal error

B. No

C. Yes

D. Empty output

Solution

1. Step 1: Understand the type declaration

   The parameter type is A OR (B AND object). Class C implements both A and B, so it matches the type.

2. Step 2: Evaluate the instanceof check

   $obj is instance of B, so the ternary returns 'Yes'.

3. Final Answer:

   Yes -> Option C

4. Quick Check:

   Object matches B, so output is 'Yes' [OK]

Hint: Check instanceof for intersection parts in DNF types [OK]

Common Mistakes:

• Assuming type mismatch causes error
• Ignoring intersection precedence
• Thinking output is 'No' without checking instanceof

4.

Identify the error in this PHP function using DNF types:

function checkType(int|float&Countable $value) { 
  return is_countable($value); 
}

medium

A. Invalid use of & with float, which is not an object

B. Missing return type declaration

C. is_countable() cannot be used here

D. int and float cannot be unioned

Solution

1. Step 1: Analyze intersection with primitive types

   float is a primitive type and cannot be combined with & Countable (an interface) because & requires object types.

2. Step 2: Confirm error cause

   Using & between float and Countable causes a type error since float is not an object.

3. Final Answer:

   Invalid use of & with float, which is not an object -> Option A

4. Quick Check:

   Intersection requires objects, float is primitive [OK]

Hint: Intersection (&) only works with object types [OK]

Common Mistakes:

• Thinking primitives can be intersected with interfaces
• Ignoring PHP type system rules
• Assuming is_countable() causes error

5.

Given these interfaces and classes:

interface X {} 
interface Y {} 
class A implements X {} 
class B implements Y {} 
class C implements X, Y {}

Which DNF type correctly accepts objects that implement either X alone, or both X and Y together?

hard

A. X|(X&Y)

B. X&Y|Y

C. X|Y

D. (X|Y)&Y

Solution

1. Step 1: Understand the requirement

   Accept objects that implement X alone OR both X and Y together.

2. Step 2: Translate to DNF

   This means either X alone OR (X AND Y). X|(X&Y) expresses this as X|(X&Y).

3. Step 3: Check other options

   X&Y|Y includes Y alone, which is incorrect. X|Y accepts X or Y alone, too broad. (X|Y)&Y includes Y alone, which is incorrect.

4. Final Answer:

   X|(X&Y) -> Option A

5. Quick Check:

   DNF matches X alone or X and Y together = X|(X&Y) [OK]

Hint: Use union of X and intersection X&Y for this case [OK]

Common Mistakes:

• Choosing simple union X|Y which is too broad
• Misplacing parentheses changing logic
• Confusing intersection and union precedence