Laravel Online Test

Your company is analyzing malware that targets numerical record files stored in an array.

The malware adjusts values at both the edges of the array using a window of size 's' as shown in the video below:

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

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

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

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

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?

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>

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?

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?