Laravel Online Test

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.

A petting zoo is using the following Laravel controller:

class AnimalController extends Controller
{
    public function animalDetailsByName(Request $request, $animalName)
    {
        return View::make('welcome', ['fullAnimalName' => $animalName]);
    }
}

What can be concluded about the controller and the view it returns?

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):

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"]].

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".

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'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?

An HR department uses the following Laravel resources to get employee data:

Route::get('/employee/{id?}', function ($id = 0) {
    return view('employee');
});
Route::get('/employee/{id}/subordinates/', function ($id) {
    return view('subordinates');
});
Route::get('/employee/{id}/subordinates/{subordinateId}', function ($id, $subordinateId) {
    return view('subordinateDetails');
});

A request to "/employee/" will get mapped to the _____________ view.

A request to "/employee/12" will get mapped to the _____________ view.

A request to "/employee/10/subordinates/1" will get mapped to the _____________ view.

A request to "/employee/10/subordinates/" will get mapped to the _____________ view.

A request to "/employee/10/subordinates/1/10" will get mapped to the _____________ view.

A cinema is using Laravel and Blade templates for their website. Their page at /movies should list all their movies and their directors. The relevant Laravel code is shown here:

class Movie
{
    public string $title;
    public string $director;

    function ̲ ̲ construct(string $title, string $director)
    {
        $this->title = $title;
        $this->director = $director;
    }
}

Route::get('/movies', function ()
{
    $movies = [new Movie("Casablanca", "Michael Curtiz"), new Movie("Psycho", "Alfred Hitchcock")];
    return View::make('welcome', ['movies' => $movies]);
});

Fill in the blanks for the following welcome.blade.php Blade template so that it prints correct data:

<!DOCTYPE html>
<html>
  <head>
    <title>Movies</title>
  </head>
  <body>
    <div>
      @_______________(________ as $movie)
         <p>Movie title: {{ ________________ }}, director: {{ ________________ }}</p>
      @_____________
    </div>
  </body>
</html>