DNF types (Disjunctive Normal Form) in PHP - Mini Project: Build & Apply

DNF types (Disjunctive Normal Form) in PHP

📖 Scenario: Imagine you are building a simple rule checker for a game. The rules are written in a way that combines conditions with AND and OR. This is called Disjunctive Normal Form (DNF). You want to represent these rules in PHP and check if a player's attributes match any of the rules.

🎯 Goal: You will create a PHP program that stores rules in DNF format, sets a player's attributes, checks which rules the player matches, and prints the matching rules.

📋 What You'll Learn

Create an array called $rules that holds multiple rules in DNF format.

Create an associative array called $player with specific attributes.

Write a loop to check each rule against the player's attributes using DNF logic.

Print the indexes of the rules that the player matches.

💡 Why This Matters

🌍 Real World

DNF is used in logic and computer science to simplify complex conditions. This project shows how to represent and check such conditions in code.

💼 Career

Understanding DNF and condition checking is useful for roles in software testing, rule engines, game development, and any job involving complex decision logic.

1

Create the rules array in DNF format

Create an array called $rules with two rules. Each rule is an array of clauses. Each clause is an associative array with keys 'color' and 'size'. Use these exact values: First rule: one clause with 'color' => 'red' and 'size' => 'large'. Second rule: two clauses, first with 'color' => 'blue' and 'size' => 'small', second with 'color' => 'green' and 'size' => 'medium'.

PHP

<?php

// Create the $rules array with the exact DNF structure
// Your code here

Hint

Remember, DNF means OR of ANDs. Each rule is an OR clause, each clause inside is an AND condition.

2

Create the player attributes array

Create an associative array called $player with these exact keys and values: 'color' => 'blue', 'size' => 'small'.

PHP

 'red', 'size' => 'large']
    ],
    [
        ['color' => 'blue', 'size' => 'small'],
        ['color' => 'green', 'size' => 'medium']
    ]
];

// Create the $player array with exact attributes
// Your code here

Hint

Use an associative array with keys 'color' and 'size' exactly as shown.

3

Check which rules the player matches

Write a loop using foreach with variables $index and $rule to iterate over $rules. Inside, write another loop with variables $clauseIndex and $clause to iterate over $rule. For each $clause, check if all keys and values match exactly with $player. If any clause matches, add $index to an array called $matchedRules. Initialize $matchedRules as an empty array before the loops.

PHP

 'red', 'size' => 'large']
    ],
    [
        ['color' => 'blue', 'size' => 'small'],
        ['color' => 'green', 'size' => 'medium']
    ]
];

$player = ['color' => 'blue', 'size' => 'small'];

// Initialize $matchedRules as empty array
// Use foreach loops to check each rule and clause
// Add matching rule indexes to $matchedRules
// Your code here

Hint

Check each clause fully matches the player. If yes, add the rule index to $matchedRules and stop checking that rule.

4

Print the matching rule indexes

Write a print_r statement to display the $matchedRules array.

PHP

 'red', 'size' => 'large']
    ],
    [
        ['color' => 'blue', 'size' => 'small'],
        ['color' => 'green', 'size' => 'medium']
    ]
];

$player = ['color' => 'blue', 'size' => 'small'];

$matchedRules = [];
foreach ($rules as $index => $rule) {
    foreach ($rule as $clause) {
        $match = true;
        foreach ($clause as $key => $value) {
            if (!isset($player[$key]) || $player[$key] !== $value) {
                $match = false;
                break;
            }
        }
        if ($match) {
            $matchedRules[] = $index;
            break;
        }
    }
}

// Print the $matchedRules array
// Your code here

Hint

Use print_r($matchedRules); to show the array of matched rule indexes.

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