Numbers and Math

Arithmetic looks the same in every language until the edge cases bite. Go's edges are unusually well-defined — no undefined behavior, no silent coercions — but you have to know where they are, because two of them (integer division and float representation) fail quietly.

Integer arithmetic: exact, until it isn't

+ - * / % behave as expected on int, with one universal gotcha:

Integer division truncates — it doesn't round. 99 / 100 is 0, and a surprising number of real bugs ("why is my percentage always zero?") are exactly that line. When you want real division on integer variables, convert deliberately: float64(a) / float64(b).

% (modulo) is the remainder — the tool for "is it divisible" (n % 3 == 0), "wrap around" (i % len), and digit extraction (n % 10 is the last digit, n / 10 drops it). It earns its keep constantly.

Overflow: Go integers are fixed-size and wrap around silently at runtime — a runtime int64 holding math.MaxInt64, plus one, becomes a huge negative number with no exception and no warning. (Written as the compile-time constant math.MaxInt64 + 1 the compiler actually rejects it — "constant overflows int64" — so silent wraparound is strictly a runtime-value behavior.) With 64 bits (±9.2 quintillion) you won't hit it counting things; you will hit it multiplying big numbers. Know it exists.

Floats: fast, useful, and slightly wrong

float64 is IEEE-754 double precision — the same type every mainstream language uses — and it cannot represent most decimal fractions exactly:

This isn't a Go bug; it's binary floating point being binary. Two working rules: never compare floats with == (compare math.Abs(a-b) < 1e-9 instead), and never use floats for money (count cents in an int).

Conversions are always loud

As with all Go types, nothing converts itself:

int(f) chopping toward zero is the second silent killer of the lesson. Rounding is explicit: math.Round(f) (then convert).

The math package

Everything in math speaks float64 — mixing it with int variables means conversions at the border, written out where everyone can see them.

Your exercise

Rectangle area is one multiplication — which is exactly why it's here. The actual skill being graded is the plumbing: read values from stdin (fmt.Scan(&w, &h)), compute, and print in the exact expected format. Decide consciously whether the inputs are int or float64 (read the problem's examples!), because 12 and 12.00 are different outputs, and byte-exact graders care. Getting input → types → arithmetic → formatted output right on a trivial formula is the loop you'll run on every non-trivial one for the rest of the course.