Android and Java Online Test

Refactor the AlertService and MapAlertDAO classes:

• Create a new package-private interface, named AlertDAO, that contains the same methods as MapAlertDAO.
• MapAlertDAO should implement the AlertDAO interface.
• AlertService should have a public constructor that accepts AlertDAO.
• The raiseAlert and getAlertTime methods should use the object passed through the constructor.

Which statements are true for the Parcelable interface?

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

Implement the getDiscountedPrice method 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:

System.out.println(getDiscountedPrice(12, 100, DiscountType.Weight));

should print:

82.0

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:

boolean[][] 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},
};

System.out.println(canTravelTo(gameMatrix, 3, 2, 2, 2)); // true, Valid move
System.out.println(canTravelTo(gameMatrix, 3, 2, 3, 4)); // false, Can't travel through land
System.out.println(canTravelTo(gameMatrix, 3, 2, 6, 2)); // false, Out of bounds

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

Using JUnit 4's Assert class, write tests for the Account class that cover the following cases:

• The deposit and withdraw methods will not accept negative numbers.
• Account cannot overstep its overdraft limit.
• The deposit and withdraw methods will deposit or withdraw the correct amount, respectively.
• The withdraw and deposit methods return the correct results.

public class Account {
    private double balance;
    private double overdraftLimit;
    
    public Account(double overdraftLimit) {
        this.balance = 0;
        this.overdraftLimit = overdraftLimit > 0 ? overdraftLimit : 0;
    }
    
    public boolean deposit(double amount) {
        if(amount >= 0) {
            this.balance += amount;
            return true;
        }
        return false;
    }
    
    public boolean withdraw(double amount) {
        if(this.balance - amount >= -this.overdraftLimit && amount >= 0) {
            this.balance -= amount;
            return true;
        }
        return false;
    }
    
    public double getBalance() {
        return balance;
    }
    
    public double getOverdraftLimit() {
        return overdraftLimit;
    }
}

Each of the test case methods should be in the AccountTest class and have the Test annotation.

A gaming company is working on a platformer game. They need a method 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 method 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 method 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:

System.out.println(calculateFinalSpeed(60.0, new int[] { 0, 30, 0, -45, 0 }));

should print:

75

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

Implement the class TextInput that contains:

• Public method void add(char c) - adds the given character to the current value
• Public method String getValue() - returns the current value

Implement the class NumericInput that:

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

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

TextInput input = new NumericInput();
input.add('1');
input.add('a');
input.add('0');
System.out.println(input.getValue());

Implement a function folderNames, which accepts a string containing an XML file that specifies folder structure and returns all folder names that start with startingLetter. The XML format is given in the example below.

For example, for the letter 'u' and an XML file:

<?xml version="1.0" encoding="UTF-8"?>
<folder name="c">
    <folder name="program files">
        <folder name="uninstall information" />
    </folder>
    <folder name="users" />
</folder>

the function should return a collection with items "uninstall information" and "users" (in any order).

The Java method getAppSettings returns the config settings for the app. The code below shows the main method using it:

import java.util.*;

public class Main {
    static Object getAppSettings(boolean detailed) {
        if (detailed) {
            Map<String, String> map = new HashMap<>();
            map.put("os", System.getProperty("os.name"));
            map.put("machine", System.getProperty("device.name"));
            map.put("user", System.getProperty("user.name"));
            return map;
        }

        return System.getProperty("device.name");
    }

    public static void main(String[] args) {
        Object appSettings = getAppSettings(true);
        System.out.println(appSettings.get("os"));
    }
}

The code in the main method causes the following compile time error.

ERROR!
Main.java:19: error: cannot find symbol
        System.out.println(appSettings.get("os"));
                                      ^

Explain in short why the compile error occurred in the main method.

(An answer up to 40 words is sufficient)

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 static method to check if the parentheses in an expression are balanced:

public static boolean isBalanced(String parentheses) {
    Stack<Character> stack = new Stack<>();
    Set<Character> opening = new HashSet<>(Arrays.asList('(', '[', '{'));
    Set<Character> closing = new HashSet<>(Arrays.asList(')', ']', '}'));

    Map<Character, Character> pairs = new HashMap<>();
    pairs.put(')', '(');
    pairs.put(']', '[');
    pairs.put('}', '{');

    for (char c : parentheses.toCharArray()) {
        if (opening.contains(c)) {
            stack.push(c);
        } else if (closing.contains(c)) {
            if (stack.isEmpty() || stack.peek() != pairs.get(c)) {
                return false;
            }
            stack.pop();
        }
    }

    return stack.isEmpty();
}

What is correct for the given method?

A company is designing the class hierarchy for various cache implementations:

public class Cache {}

public class DiskCache extends Cache {}

public class MemoryCache extends Cache {}

public class OptimizedDiskCache extends DiskCache {}

Select all the answers that will result in a runtime exception.

Consider the following image:

Fill in the blanks in the following layout so that it renders like the image above:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="_____________">
        <LinearLayout
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:orientation="_____________">
            <TextView
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:padding="5dp"
                android:text="User"/>
            <TextView
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:padding="5dp"
                android:text="Last login date"/>
        </LinearLayout>
        <LinearLayout
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:orientation="_____________">
            <TextView
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:padding="5dp"
                android:text="Address"/>
            <TextView
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:padding="5dp"
                android:text="Secondary address"/>
        </LinearLayout>
</LinearLayout>

Fill in the blanks, so that changes in the shared preferences are saved:

SharedPreferences pref = getApplicationContext().getSharedPreferences("MyPref", MODE_PRIVATE);
Editor editor = pref.______();
editor.putString("start_message", "Hello!");
editor.putString("end_message", "Goodbye!");
editor.________();

Which of these methods are called when the screen changes orientation from portrait to landscape in Android?

Consider the following code:

@Override
protected void onResume() {
    super.onResume();
    mp = MediaPlayer.create(getBaseContext(), R.raw.sound);
    Thread timer = new Thread() {
        @Override
        public void run() {
            try {
                Thread.sleep(1000);
                Intent main = new Intent(Splash.this, MainActivity.class);
                startActivity(main);
                finish();
            } catch (InterruptedException e) {}
        }
    };
    timer.start();
    mp.start();
}

@Override
protected void onPause() {
    super.onPause();
    if (mp != null) {
        if (mp.isPlaying()) {
            mp.stop();
        }
        mp.release();
        mp = null;
    }
}

Select the statements that are correct if the wave file sound is 3 seconds long.