WordPress Online Test

A gaming company is working on a platformer game. They need a function that will compute the character's final speed, given a map and a starting speed.

The terrain on which the game character moves forward is made from various pieces of land placed together. Implement the function calculateFinalSpeed which takes the initial speed of the character, and an array of degrees of inclination that represent the uneven terrain.

The speed of the character will increase or decrease proportionally to the incline of the land, as shown in the image below:

The magnitude of the angle of inclination will always be < 90°. The speed change occurs only once for each piece of land. The function should immediately return 0 as the final speed if an incline reduces the speed to 0 or below 0, which makes the character lose 1 life.

For example, the below code:

echo calculateFinalSpeed(60, [0, 30, 0, -45, 0]);

should print:

75

You're working in the WordPress code of a philosophy blog.

It should only show posts that:

• Have the 'ethics' (id 8) or 'metaphysics' (id 9) category.
• Have the 'daily' (id 1) tag.

Which queries will retrieve only the required posts?

A megastore offers three types of discounts, which are represented as DiscountType enum.

Implement the getDiscountedPrice function which should take the total weight of the shopping cart, the total price, and the discount type. It should return the final discounted price based on the discount schemes as shown in the promotional video below:

(Open full-size video in a new tab)

For example, the following code:

echo getDiscountedPrice(12, 100, DiscountType::Weight);

should print:

82

A turn-based strategy game has a grid with water and land. The grid contains a true value where it's water and false where it's land.

The player controls a boat unit with a particular movement pattern. It can only move to fixed destinations from its current position as shown in the image below:

The boat can only move in a direct path through water to the possible destinations, so a destination will become unreachable if there is land in the way. 

Implement the canTravelTo function, that checks whether a destination is reachable by the boat. It should return true for destinations that are reachable according to the pattern above, and false for unreachable or out of bounds destinations which are outside the grid. 

For example, consider the following code:

$gameMatrix = [
    [false, true,  true,  false, false, false],
    [true,  true,  true,  false, false, false],
    [true,  true,  true,  true,  true,  true],
    [false, true,  true,  false, true,  true],
    [false, true,  true,  true,  false, true],
    [false, false, false, false, false, false],
  ];
  

echo canTravelTo($gameMatrix, 3, 2, 2, 2) ? "true\n" : "false\n"; // true, Valid move
echo canTravelTo($gameMatrix, 3, 2, 3, 4) ? "true\n" : "false\n"; // false, Can't travel through land
echo canTravelTo($gameMatrix, 3, 2, 6, 2) ? "true\n" : "false\n"; // false, Out of bounds

The following image shows valid and invalid destinations when the boat is in the position (3, 2):

The LeagueTable class tracks the score of each player in a league. After each game, the player records their score with the recordResult function. 

The player's rank in the league is calculated using the following logic:

1. The player with the highest score is ranked first (rank 1). The player with the lowest score is ranked last.
2. If two players are tied on score, then the player who has played the fewest games is ranked higher.
3. If two players are tied on score and number of games played, then the player who was first in the list of players is ranked higher.

Implement the playerRank function that returns the player at the given rank.

For example:

$table = new LeagueTable(array('Mike', 'Chris', 'Arnold'));
$table->recordResult('Mike', 2);
$table->recordResult('Mike', 3);
$table->recordResult('Arnold', 5);
$table->recordResult('Chris', 5);
echo $table->playerRank(1);

All players have the same score. However, Arnold and Chris have played fewer games than Mike, and as Chris is before Arnold in the list of players, he is ranked first. Therefore, the code above should display "Chris".

Your company is analyzing malware which targets numerical record files.

The malware uses a sliding window over the array of numbers in a file, and tries to match the following pattern:

Tl, -, -, X, -, -, -, Tr

The entire window is moved so that 'X' passes through all the values and is compared to the numbers at the 'Tl' and 'Tr' locations, which are positioned at a constant offset to 'X'.

The malware has the following rules:

• If the value at the 'Tl' or 'Tr' position of the pattern is bigger or equal to the value at the 'X’ position, the malware replaces the value at 'X' with 0.
• If the value at the 'Tl' or 'Tr' offset is out of bounds, then the value at 'X' is only compared to the other existing value.
• The record is processed in two stages: first, all the positions that should be set to 0 are located, using the original values for comparison. Only after all positions have been identified do they get set to 0.

For example, if the values in a record file are the following:

[1, 2, 0, 5, 0, 2, 4, 3, 3, 3]

The expected values after the malware runs are:

[1, 0, 0, 5, 0, 0, 0, 3, 3, 0]

In this example, both '2's, the '4' and the last '3' were replaced by 0.

Implement the simulate function so that the malware behavior is replicated for further study.

As part of a data processing pipeline, complete the implementation of the make_pipeline method:

• The make_pipeline method should accept a variable number of functions, and it should return a new function that accepts one parameter $arg.
• The returned function should call the first function in make_pipeline with the parameter $arg, and call the second function with the result of the first function.
• The returned function should continue calling each function in make_pipeline in order, following the same pattern, and return the value from the last function.

For example, calling make_pipeline(function($x) { return $x * 3; }, function($x) { return $x + 1; }, function($x) { return $x / 2; }), and then calling the returned function with 3 should return 5.

Implement the function findRoots to find the roots of the quadratic equation: ax² + bx + c = 0. The function should return an array containing both roots in any order. If the equation has only one solution, the function should return that solution as both elements of the array. The equation will always have at least one solution.

The roots of the quadratic equation can be found with the following formula:

For example, findRoots(2, 10, 8) should return [-1, -4] or [-4, -1] as the roots of the equation 2x² + 10x + 8 = 0 are -1 and -4.

Implement the unique_names function. When passed two arrays of names, it will return an array containing the names that appear in either or both arrays. The returned array should have no duplicates.

For example, calling unique_names(['Ava', 'Emma', 'Olivia'], ['Olivia', 'Sophia', 'Emma']) should return ['Emma', 'Olivia', 'Ava', 'Sophia'] in any order.

A thesaurus contains words and synonyms for each word. Below is an example of a data structure that defines a thesaurus:

array("buy" => array("purchase"), "big" => array("great", "large"))

Implement the function getSynonyms, which accepts a word as a string and returns all synonyms for that word in JSON format, as in the example below.

For example, the call $thesaurus->getSynonyms("big") should return:

'{"word":"big","synonyms":["great", "large"]}'

while a call with a word that doesn't have synonyms, like $thesaurus->getSynonyms("agelast") should return:

'{"word":"agelast","synonyms":[]}'

The user interface contains two types of user input controls: TextInput, which accepts all texts and NumericInput, which accepts only digits.

Implement the class TextInput that contains:

• Public function add($text) - adds the given text to the current value.
• Public function getValue() - returns the current value (string).

Implement the class NumericInput that:

• Inherits from TextInput.
• Overrides the add method so that each non-numeric text is ignored.

For example, the following code should output '10':

$input = new NumericInput();
$input->add('1');
$input->add('a');
$input->add('0');
echo $input->getValue();

Implement a groupByOwners function that:

• Accepts an associative array containing the file owner name for each file name.
• Returns an associative array containing an array of file names for each owner name, in any order.

For example, for associative array ["Input.txt" => "Randy", "Code.py" => "Stan", "Output.txt" => "Randy"] the groupByOwners function should return ["Randy" => ["Input.txt", "Output.txt"], "Stan" => ["Code.py"]].

A WordPress theme contains, among other things, all the files listed below. Which of these files will be used to display the homepage after this theme is activated?

You are working on a calculator application where users can input a mathematical expression such as: (3 + 5) * (2 - 4).

To correctly evaluate this expression, the application needs to validate the expression and ensure that the parentheses are balanced. The balanced parentheses are crucial for determining the order of operations and evaluating the expression correctly.

You have used an AI assistant to generate the following function to check if the parentheses in an expression are balanced:

function isBalanced($parentheses)
{
    $stack = [];
    $opening = ['(' => true, '[' => true, '{' => true];
    $closing = [')' => true, ']' => true, '}' => true];
    $pairs = [
        ')' => '(',
        ']' => '[',
        '}' => '{'
    ];

    for ($i = 0; $i < strlen($parentheses); $i++) {
        $c = $parentheses[$i];

        if (isset($opening[$c])) {
            array_push($stack, $c);
        } elseif (isset($closing[$c])) {
            if (count($stack) == 0 || array_pop($stack) != $pairs[$c]) {
                return false;
            }
        }
    }

    return count($stack) == 0;
}

What are the correct statements for the given function?

You are hosting a WordPress site for veterinary procedures with lots of animal images. The content has 86 WordPress taxonomies related to the respective body parts involved in each procedure.

Recently, the site became very slow in peak hours, when the pictures are requested very often, overloading the network.

Which of the following options are likely to increase the performance of the site enough for the peak hours to be fast again?

You're maintaining the PHP back-end of a Tree Planting website.

The registerForEvent function is called by the server when interested people fill a form to register for a tree planting event.

The register function it calls performs the registration logic.

Consider the code for the registerForEvent function:

function registerForEvent($name, $seedBagsNeeded)
{
    $sanitizedName = filter_var($name, FILTER_SANITIZE_SPECIAL_CHARS);
    $filteredBagsNeeded = filter_var($seedBagsNeeded, FILTER_VALIDATE_INT);
    register($sanitizedName, $filteredBagsNeeded);
}

What is correct about the filtering and sanitization done in the code above?

Select all the actions that the following line of code does when used inside a WordPress theme's index.php file.

<?php get_header("home"); ?>