Aptitude Test Preparation: Simple Interest and Problem-Solving Questions

Practice your aptitude skills with these sample questions on simple interest and problem-solving. This resource provides questions covering various aspects of simple interest calculations and numerical reasoning, helping you prepare effectively for aptitude tests and assessments. Check your answers against the provided solutions.



Aptitude and Reasoning Interview Questions

Aptitude Questions

Aptitude Questions (Examples)

Question 1: Simple Interest

How long will it take for Rs. 450 to earn Rs. 81 in simple interest at 4.5% per annum?

Solution

Simple Interest = (Principal * Rate * Time) / 100
81 = (450 * 4.5 * Time) / 100
Time = 4 years
Answer

4 years

Question 2: Simple Interest

A sum of Rs. 12,500 amounts to Rs. 15,500 in 4 years at simple interest. Find the interest rate.

Solution

Interest = 15500 - 12500 = 3000
Simple Interest = (Principal * Rate * Time) / 100
3000 = (12500 * Rate * 4) / 100
Rate = 6%
Answer

6%

Question 3: Simple Interest Ratio

What's the ratio of simple interest earned on a certain amount at the same rate for 6 years and 9 years?

Solution

Let P be the principal and R be the rate.
SI for 6 years: (P * R * 6) / 100
SI for 9 years: (P * R * 9) / 100
Ratio: 6:9 = 2:3
Answer

2:3

Question 4: Compound Interest and Simple Interest

A person borrows Rs. 5000 for 2 years at 4% simple interest and lends it at 6.25% for 2 years. Find the gain per year.

Solution

SI on borrowed amount: (5000 * 4 * 2) / 100 = 400
SI earned: (5000 * 6.25 * 2) / 100 = 625
Gain: 625 - 400 = 225
Gain per year: 225/2 = 112.5
Answer

Rs. 112.5

Question 5: Number Problem

A number's fifth part increased by 5 equals its fourth part decreased by 5. Find the number.

Solution

x/5 + 5 = x/4 - 5
4x + 100 = 5x - 100
x = 200
Answer

200

Question 6: Number Problem

The difference between a two-digit number and the number obtained by reversing its digits is 36. What is the difference between the sum and the difference of the digits if the ratio of the digits is 1:2?

Solution

Let the digits be x and 2x.
(20x + x) - (10x + 2x) = 36
9x = 36
x = 4
Digits are 8 and 4.
Sum: 12
Difference: 4
Difference between sum and difference: 8
Answer

8

Question 7: Boat Problem

A boat travels 30 km downstream and 18 km upstream in 5 hours each. Find the stream's speed. (This requires additional information to solve completely.)

Question 8: Train Problem

A 125m train passes a man in 10 seconds traveling at 50kmph. Find the train's speed.

Solution

Speed = distance/time = 125m/10s = 12.5m/s
12.5 m/s * (18/5) = 45 kmph
Answer

45 kmph

Question 9: Train Crossing Problem

Two trains 100m and 200m long run at 60 kmph and 30 kmph in opposite directions. What time to cross?

Solution

Relative speed = 60 + 30 = 90 kmph = 25 m/s
Total length = 300 m
Time = distance / speed = 300m / 25 m/s = 12 seconds
Answer

12 seconds

Question 10: Ratio and Proportion

If A:B = 2:3 and B:C = 3:4, find A:B:C.

Solution

A:B = 2:3
B:C = 3:4
To have a common value for B, multiply A:B by 3 and B:C by 1:
A:B = 6:9
B:C = 3:4
A:B:C = 6:9:12 = 2:3:4
Answer

2:3:4

Question 11: Ratio and Proportion

If X:Y = 3:4 and Y:Z = 8:9, find X:Z.

Solution

X/Y = 3/4  =>  Y = (4/3)X
Y/Z = 8/9  =>  Y = (8/9)Z
Equating Y: (4/3)X = (8/9)Z
X/Z = (8/9) * (3/4) = 2/3
X:Z = 2:3
Answer

2:3

Question 12: Ratio and Proportion

Divide 600 in the ratio 2:3.

Solution

2x + 3x = 600
5x = 600
x = 120
2x = 240
3x = 360
Answer

240, 360

Divide and Conquer

Question 9: Divide and Conquer

Divide and conquer is an algorithmic design paradigm where a problem is recursively broken into smaller subproblems, solved independently, and then the solutions are combined to solve the original problem. This approach is often more efficient than brute-force methods for problems exhibiting optimal substructure (optimal solutions to subproblems lead to an optimal solution for the overall problem) and overlapping subproblems (the same subproblems are encountered multiple times during the solution process).

Breadth-First Search (BFS)

Question 10: Breadth-First Search (BFS) Algorithm

BFS is a graph traversal algorithm that systematically explores a graph level by level, starting from a root node. It prioritizes exploring nodes closer to the root before moving to more distant nodes. BFS is useful for finding shortest paths in unweighted graphs.

Dijkstra's Algorithm

Question 11: Dijkstra's Algorithm

Dijkstra's algorithm finds the shortest paths from a single source node to all other nodes in a graph with non-negative edge weights. It's a greedy algorithm that iteratively identifies the shortest distance to each node.

Dynamic Programming vs. Divide and Conquer

Question 7: Dynamic Programming vs. Divide and Conquer

Key Differences:

Feature Dynamic Programming Divide and Conquer
Approach Typically iterative; solves overlapping subproblems once. Recursive; solves independent subproblems.
Subproblems Overlapping subproblems Independent subproblems
Efficiency More efficient for problems with overlapping subproblems Less efficient for problems with overlapping subproblems
Optimal Solution Guaranteed to find optimal solution (for problems with optimal substructure) May not always find an optimal solution

Dynamic Programming, Memoization, and Recursion

Question 8: Dynamic Programming, Memoization, and Recursion

Recursion is a function calling itself. Memoization stores and reuses previous results to avoid redundant computations. Dynamic programming uses these techniques to solve complex problems efficiently by breaking them down into smaller overlapping subproblems and storing their solutions.

Longest Palindromic Subsequence

Question 9: Longest Palindromic Subsequence

Find the longest subsequence within a given sequence that's a palindrome (reads the same forwards and backward).

Python Code (Illustrative)

def longest_palindromic_subsequence(s):
    n = len(s)
    dp = [[0 for x in range(n)] for y in range(n)]  #DP matrix
    for i in range(n):
        dp[i][i] = 1
    for cl in range(2, n + 1):
        for i in range(n - cl + 1):
            j = i + cl - 1
            if s[i] == s[j] and cl == 2:
                dp[i][j] = 2
            elif s[i] == s[j]:
                dp[i][j] = dp[i + 1][j - 1] + 2
            else:
                dp[i][j] = max(dp[i][j - 1], dp[i + 1][j])
    return dp[0][n - 1]

string = "bbbab"
print("Length of LPS is", longest_palindromic_subsequence(string)) # Output: 4

Longest Common Subsequence (LCS)

Question 10: Longest Common Subsequence (LCS)

Find the longest subsequence common to two sequences. Dynamic programming provides an efficient solution.

Python Code (Illustrative)

def lcs(X, Y):
    m = len(X)
    n = len(Y)
    #Following matrix is created for storing the length of common subsequence.
    dp = [[0 for x in range(n + 1)] for y in range(m + 1)]
    for i in range(m + 1):
        for j in range(n + 1):
            if i == 0 or j == 0:
                dp[i][j] = 0
            elif X[i - 1] == Y[j - 1]:
                dp[i][j] = dp[i - 1][j - 1] + 1
            else:
                dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])
    return dp[m][n]

X = "AGGTAB"
Y = "GXTXAYB"
print("Length of LCS is ", lcs(X, Y))  # Output: Length of LCS is  4

Dynamic Programming vs. Divide and Conquer

Question 7: Dynamic Programming vs. Divide and Conquer

Dynamic programming and divide and conquer are both powerful techniques, but they differ in how they approach subproblems. Dynamic programming is generally more efficient for problems with overlapping subproblems, while divide and conquer shines when subproblems are independent. Dynamic programming often uses tabulation (bottom-up) or memoization (top-down), while divide and conquer is typically recursive.

Dynamic Programming, Memoization, and Recursion

Question 8: Dynamic Programming, Memoization, and Recursion

Dynamic programming avoids redundant computations by storing and reusing solutions to overlapping subproblems. Memoization is a top-down approach; tabulation is a bottom-up approach. Recursion is a programming technique where a function calls itself.

Thread Safety

Question 10: Using HashMap in Multithreaded Environment

While `HashMap` isn't inherently thread-safe, you can use it safely in a multithreaded environment if only one thread modifies the map, and other threads only read. For concurrent modification, use `ConcurrentHashMap`.

Immutability

Question 12: Immutability and the `final` Keyword

While making fields `final` helps, it doesn't guarantee immutability. True immutability requires preventing modifications to the object's internal state after creation.

Inspirational Figures

Question 5: Inspirational Figures

When answering this question, focus on specific individuals who have positively influenced you. Discuss their qualities and explain how they've inspired your personal and professional development. Highlight the aspects of their character or achievements that resonate with you and have shaped your own values and goals. Be specific and provide examples.

Sample Answer

"I've been inspired by many people throughout my life, each for their unique strengths.  For example, [Name]’s unwavering commitment to [Value] and their ability to [Accomplishment] have deeply influenced my work ethic and determination. Their example has encouraged me to pursue excellence in both my personal and professional endeavors."

Difficult Decisions

Question 6: Toughest Decision

Describe a challenging decision you faced, highlighting the process you followed to arrive at a decision, and the result. Emphasize your problem-solving skills and your ability to make reasoned judgments even under pressure. Be specific and concise in your explanation, showcasing your decision-making process.

Sample Answer

"One of the most challenging decisions I faced was [briefly describe the situation].  I carefully considered various options, weighing the pros and cons of each and assessing potential risks and benefits.  After a thorough analysis, I chose [your decision], and the outcome was [result]. This experience taught me the importance of [lesson learned]."