Beginner: I/O, Arithmetic, Loops

Add every element into a running sum in one pass, then divide by the count using BigDecimal with an explicit scale and rounding mode.

For each number, if dividing by two leaves no remainder it is even, otherwise it is odd: route it into the matching collection in a single pass.

A prime has exactly two divisors, one and itself, and you only need to test divisors up to its square root.

Outer loop picks the row, inner loop prints that many stars, then a newline, giving a growing staircase.

Assume everything is prime, then walk the primes and cross out their multiples; the survivors are prime.

Factorial of N is N times factorial of N minus one, and factorial of zero is one: the base case stops the recursion.

Ways to form N equal the sum of ways to form N-1, N-3, and N-4, because the last factor used is 1, 3, or 4.

At each element choose the better of skipping it or taking it plus the best from two back.

The target elements have ranks K1+1 through K2-1; use a size-K2 max-heap to peel them off and sum them.

The largest absolute subarray sum is the bigger of the maximum subarray sum and the magnitude of the minimum subarray sum.

After the pointers meet in the loop, send one back to the head and walk both one step at a time; they meet at the loop's start.

Walk both lists adding digit plus digit plus carry, write the ones digit, carry the rest: grade-school addition as a linked-list pass.

BFS per level, sum the values, divide by the level size, one average per level.

Carry a running number down each path with running * 10 + digit, and add it to the total at every leaf.

Return the best clamped downward branch to the parent, but update the global best with node value plus both clamped branches.

Factorial is a running product that starts at one and multiplies in every integer from one to N, and because an empty product is one, zero factorial is one.

Adding two numbers is read, add, print, but in banking the amounts must be BigDecimal so the sum of money is exact to the paisa.

Average is sum divided by count, and for money the division must use BigDecimal with an explicit scale and rounding mode.

A number is even when its remainder on division by two is zero and odd otherwise; test the remainder against zero so negative numbers are handled correctly.

The larger of two values comes from one comparison: if A is greater than B take A, otherwise take B, and for money compare with compareTo, not equals.

The largest of three comes from nested comparisons using >= : first test whether A beats both others, else choose the larger of B and C.

The signum function returns 1, -1, or 0 for the sign of a number, and BigDecimal exposes it directly as signum().

A year is leap when divisible by 4 and not by 100, or divisible by 400, and this directly decides the day count used for interest.

Three lengths form a triangle only when every pair sums to strictly more than the third, checked as three AND-joined inequalities.

A product loop seeds the accumulator at 1, the multiplicative identity, and multiplies in each value, which is why an empty product and 0! are both 1.

Print evens by starting at 2 and stepping by 2 up to N: more efficient than walking all numbers and filtering with modulo.

A number is prime if no integer from 2 up to its square root divides it evenly, and checking only up to the square root is the key efficiency.

Summing a fixed set of inputs is an accumulation loop seeded at 0, the additive identity, adding each value in turn.

The sum of 1 to N is an accumulation of the counter, and the closed form N*(N+1)/2 gives it directly without a loop.

Sum even numbers in a range by stepping from the first even value by 2, or use the arithmetic-series formula: count * (first + last) / 2.