Pinterest·Machine Learning Engineer·Technical Phone Screen·Senior

Senior

Jun 2026

Summary

Pinterest ML Engineer screen, one coding question that looked simple on the surface but had a bunch of edge cases stacked underneath it. The constraint of not using float() is what makes it interesting and also where most people probably trip up.

Questions Asked (1)

Implement a round() function that takes a numeric string and returns the rounded result without using float() for parsing. Handle edge cases like leading signs, implicit zeros, very large numbers, and malformed input. Return the result as a string.

Algorithms & Data StructuresTechnical Trade-offs

Author's notes

The no-float() constraint is the whole point of the question, and I almost missed it.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements and edge cases, then outline a string-based algorithm that separates sign, integer part, and fractional part. Focus on the rounding decision based on the first fractional digit and handle carry propagation carefully. Discuss trade-offs like time/space complexity and potential pitfalls with very large numbers.

Pro tip: Mention that you would use string manipulation to avoid precision loss with very large numbers, and that you'd consider using Python's decimal module if allowed, but since float() is banned, you'll implement manual parsing. Also, proactively discuss how to handle malformed input gracefully, such as returning an error or a default value.

1. Clarify requirements and edge cases

Ask about expected behavior for malformed input, rounding rules (e.g., round half up, half to even), and whether the result should include a decimal point. Confirm constraints like maximum length and allowed characters.

2. Design the parsing and rounding algorithm

Outline steps: validate input, extract sign, split integer and fractional parts, determine rounding direction based on the first fractional digit, and handle carry propagation through the integer part.

3. Implement carry propagation and edge cases

Explain how to increment the integer part when rounding up, especially when it consists of all 9s (e.g., '999' becomes '1000'). Also handle cases like empty integer part, leading zeros, and negative zero.

4. Analyze complexity and trade-offs

Discuss time and space complexity (O(n) time, O(n) space for the result string). Mention alternative approaches like using decimal or manual digit-by-digit processing, and why string manipulation is preferred here.

5. Test with examples and edge cases

Walk through test cases: '123.456' -> '123', '-0.5' -> '-1' or '0' depending on rounding rule, '999.9' -> '1000', '000.4' -> '0', and malformed inputs like '12.3.4' or 'abc'.

Key Points to Mention

String manipulation to avoid floating-point precision issues and handle very large numbers.
Rounding rule: typically round half up, but clarify with interviewer; consider banker's rounding if relevant.
Carry propagation when rounding up, especially for numbers like '999.9'.
Handling of leading signs, implicit zeros (e.g., '.5' or '5.'), and leading zeros in the integer part.
Malformed input handling: define behavior (e.g., raise exception, return None, or return original string).
Time and space complexity: O(n) time and O(n) space, where n is the length of the input string.

AI-generated suggestions, not part of the candidate's original notes. May be inaccurate — verify before relying on them.