Software Engineer

Convert to inequalities
Fix Endurance first (middle position)

Tip 1: Extract only needed values
Tip 2: Avoid full calculation

Tip 1: Use Speed × Time

Tip 1: First correct directions
Tip 2: Then solve

Tip 1: Draw diagram
Tip 2: Track facing direction

Tip 1: Learn common synonyms and antonyms
Tip 2: Use elimination method
Tip 3: Think of real-life usage of the word

Tip 1: Identify root meaning
Tip 2: Focus on opposite meaning
Tip 3: Avoid confusing similar words

Tip 1: Check subject-verb agreement
Tip 2: Identify singular/plural subject
Tip 3: Avoid double verb forms

Tip 1: Avoid double comparison
Tip 2: Use either “more” or “-er”
Tip 3: Keep sentence simple

Tip 1: Identify tense
Tip 2: Check subject
Tip 3: Use correct verb form

Tip 1: Read first and last lines carefully
Tip 2: Avoid extreme options
Tip 3: Focus on central theme

Tip 1: Check verb forms
Tip 2: “Has” requires past participle
Tip 3: Correct form is “gone”

Tip 1: Learn common preposition usage
Tip 2: Practice fixed phrases
Tip 3: Avoid literal translation

Tip 1: Check vowel sound
Tip 2: “Honest” starts with silent h
Tip 3: Use “an”

Tip 1: Identify object
Tip 2: Change tense correctly
Tip 3: Use “was/were + V3”

Tip 1: Change tense
Tip 2: Remove quotes
Tip 3: Adjust pronouns

Tip 1: Learn common idioms
Tip 2: Use context
Tip 3: Practice regularly

Tip 1: Remember rules (i before e except after c)
Tip 2: Read frequently
Tip 3: Practice writing

Step 1: Identify that instance variables are defined inside a class
Step 2: Understand object instantiation (creating objects from class)
Step 3: Each object gets its own memory allocation
Step 4: Conclude that each object has a separate copy of instance variables

Step 1: Understand memory allocation and deallocation
Step 2: Observe repeated allocation/free cycles
Step 3: Identify gaps forming in memory
Step 4: Conclude fragmentation occurs due to repeated allocation/deallocation

Step 1: Apply pop → removes top (1)
Step 2: Apply pop → removes next (2)
Step 3: push(7) → stack updated
Step 4: peek() → returns 7 (not removed)
Step 5: pop → removes 7
Step 6: push(9)

Step 1: Understand interface provides method declarations
Step 2: Different classes implement methods differently
Step 3: Identify abstraction (hiding implementation)
Step 4: Identify polymorphism (same method, different behavior)

Step 1: Identify data object
Step 2: Determine relevant attributes
Step 3: Hide unnecessary details
Step 4: Focus on essential characteristics

Step 1: Identify Fibonacci pattern
Step 2: Track sequence generation
Step 3: Observe summation logic
Step 4: Conclude both generation and summation

Step 1: Apply right shift → divide by 2
Step 2: Get values a=5, b=10, c=10
Step 3: Evaluate ternary condition
Step 4: Select minimum value

Step 1: A process tries to access a page not present in RAM
Step 2: Hardware raises a page fault interrupt
Step 3: OS checks validity of memory reference
Step 4: Required page is fetched from disk
Step 5: Page is loaded into memory and execution resumes

Step 1: List standard RTOS states → Ready, Running, Blocked
Step 2: Compare with given options
Step 3: Identify invalid state
Step 4: Conclude “Created” is not a runtime state

Step 1: f(20) = 20 + f(12)
Step 2: f(12) = 12 + f(4)
Step 3: f(4) = 4 + f(-4)
Step 4: f(-4) stops recursion
Step 5: Add values → 20 + 12 + 4 = 36

Step 1: Identify variable type (pointer)
Step 2: Understand sizeof returns memory size
Step 3: Pointer size depends on system architecture
Step 4: On 64-bit → size = 8 bytes

Step 1: Understand Agile philosophy
Step 2: Focus on team collaboration
Step 3: Identify importance of autonomy
Step 4: Conclude → self-organizing teams

Step 1: Identify parent-child class relationship
Step 2: Subclass inherits properties
Step 3: Adds new functionality
Step 4: Conclude → inheritance

Step 1: Identify table and columns
Step 2: Use INSERT INTO syntax
Step 3: Provide values in correct order
Step 4: Execute query

Step 1: Represent -1 in two’s complement (all bits = 1)
Step 2: Apply left shift by 4 bits
Step 3: Last 4 bits become 0
Step 4: Result in hex → FFF0

Step 1: Identify privileges (SELECT, DELETE)
Step 2: Grant to user
Step 3: WITH GRANT OPTION allows further delegation
Step 4: User can grant same permissions to others

Step 1: Understand MST concept
Step 2: Identify known algorithms
Step 3: Prim’s Algorithm → greedy approach
Step 4: Kruskal’s Algorithm → edge-based approach
Step 5: Conclude both are valid

Tip 1: Since the room is dark, assume the worst-case scenario while picking items.
Tip 2: There are only two colors, so think in terms of the Pigeonhole Principle.
Tip 3: Even if you pick two different colors first, the next pick will definitely match one of them.

Tip 1: Understand that JOIN is used to combine rows from two or more tables based on a related column.
Tip 2: Focus on how matching and non-matching rows are handled in each join.
Tip 3: Practice writing queries with small tables (like Employees & Departments).

Step 1: I first thought of generating all possible subarrays and calculating their sums.
This approach had O(N²) time complexity, which is not efficient for large inputs. 
Step 2: Then I tried optimizing by keeping a running sum while traversing the array.
Step 3: I applied Kadane’s Algorithm, where:
I maintain a variable current_sum
If current_sum becomes negative, I reset it to 0
I keep updating max_sum with the maximum value encountered
Step 4: Finally, I obtained the maximum sum in O(N) time complexity.