Navio: Алгоритмическая секция

Python ints are arbitrary precision, so they do not overflow like fixed 64-bit ints. Memory grows with bit length, roughly log2(n!), which can be estimated by Stirling.

Python int is arbitrary precision. Arithmetic does not overflow at 32 or 64 bits; instead, the object allocates more machine words as the value grows. Eventually you can still run out of memory or time.

To estimate memory for n!, estimate the number of bits rather than the numeric value itself. The bit length is floor(log2(n!)) + 1. Using Stirling, log2(n!) is approximately n log2(n) - n log2(e) plus a smaller term from sqrt(2 pi n). Divide by 8 for bytes and remember that Python object overhead means the actual memory is higher.

This is the key reasoning move in the interview: switch from the magnitude of n! to the logarithm of n!, because storage is proportional to digits or bits.

A for-loop calls iter(obj), then repeatedly calls next(iterator) until StopIteration. Generators are iterator objects produced by functions containing yield and have extra coroutine-style methods.

In a for-loop, Python first obtains an iterator by calling iter(obj). Then it repeatedly calls next(iterator). When the iterator has no more values, it raises StopIteration, and the loop exits normally.

An iterator is any object implementing the iterator protocol: __iter__ returns the iterator, and __next__ returns the next value or raises StopIteration. A generator is a convenient way to create such an object with a function that uses yield. Each yield pauses the function and preserves its local state until the next call.

Generators are also more than just a syntax shortcut. Generator objects support methods such as send, throw and close, which is why they can be used as coroutine building blocks. In ordinary interview answers, the important baseline is still the iter/next/StopIteration protocol.

A context manager wraps setup and cleanup around a block. __enter__ prepares the resource, __exit__ runs even on exceptions, and this is safer than waiting for GC to close scarce OS resources.

The with statement is syntax for entering and leaving a managed context. Python calls __enter__ before the block and __exit__ after the block, including when the block exits through an exception. Files, locks, transactions, sockets and temporary settings are common examples.

The reason is deterministic cleanup. Garbage collection is not a good resource-management policy for file descriptors, sockets, locks or database connections. These are external system resources with limits and side effects. Waiting until an object is eventually collected can keep handles open too long, leak locks, hold transactions or exhaust descriptors.

In ML code, the same pattern appears in things such as torch.no_grad or temporary precision/autocast contexts: the context manager makes state changes scoped and reversible.

@dataclass generates boilerplate such as __init__, __repr__ and comparisons from annotations. frozen=True prevents normal assignment after initialization. Descriptors customize attribute get/set/delete behavior.

A dataclass is a class decorator that reads annotated fields and generates common methods, usually including __init__, __repr__ and equality methods. It is a convenience layer over an ordinary Python class, not a new object model.

With frozen=True, the generated class blocks normal attribute reassignment after construction. It is useful for value objects such as points or configuration records. It is not the same as deep immutability: mutable values stored inside can still mutate unless you choose immutable field types.

Descriptors are objects that define methods such as __get__, __set__ and __delete__. Python's attribute access machinery calls them to customize reads and writes. property is a common descriptor-based API. The connection to the interview is that high-level conveniences such as dataclasses and properties ultimately sit on top of Python's attribute model.

A decorator returns a wrapper around the original function. functools.wraps preserves metadata such as __name__ and __doc__. A decorator with arguments adds one more closure layer and can import modules inside the wrapper.

A basic decorator accepts a function and returns another callable. The wrapper receives *args and **kwargs, can log inputs, calls the original function, logs the result, and returns it. functools.wraps(func) should decorate the wrapper so tooling, debugging and introspection still see the original function name, docstring, annotations and __wrapped__ link.

A decorator with arguments has three layers: the outer factory receives configuration, the middle decorator receives the function, and the inner wrapper receives runtime arguments. For lazy imports, the wrapper can call importlib.import_module(name) only at invocation time, optionally cache the module objects in the closure, and then call the original function.

The production nuance is that lazy import changes error timing and can hide import failures until runtime. Use it when startup cost matters, and make the behavior explicit.