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