What is the most expensive house sold in Wingfield? £1,000,000

The area of Wingfield, part of Mid Suffolk, has seen 117 sales since 1995. The most expensive house sold for £1,000,000 back in 2009, while the least expensive sale on the list went for just £85,000. The most recent sale on the list took place in 2025, showing the area's property market remains active.

Use Haversine and K-D tree if needed. (The K-D tree solution is faster if you ignore the overhead.) The brute force solution with 2 million rows takes 20s on an M2 MacBook Air.

We need to geolocate 2 million IP addresses. The naive approach is O(n * m) where n is the number of IP addresses and m is the number of ranges. The ranges are sorted, so we can use binary search to make it O(n * log m).

1. Extract the IP addresses from the logs.
2. Read the geolocation ranges into an array.
3. For each IP, binary search the ranges for the IP.
4. Write the results to a file.

Each row in the ranges file is a CSV: network_start_ip,network_prefix_length,country_code, and each row in the logs file is a CSV: ip_address,url,user_agent.

To convert an IPv4 to a 32-bit integer:

ip = '1.2.3.4'
parts = ip.split('.')
int_ip = (int(parts[0]) << 24) | (int(parts[1]) << 16) | (int(parts[2]) << 8) | int(parts[3])

Answer in Rust. Rust documentation is here: https://doc.rust-lang.org/std/index.html

We prefer a single file solution for simplicity. Use only the standard library. We want to be able to run this on a machine with 16 GB of memory.

For the binary search, we can store the ranges in a sorted array of (start_ip, end_ip, country_code) and binary search for the largest start_ip <= ip.

I want a progress indicator since this is a long-running process. Print progress every 100,000 IPs.

To read the ranges file efficiently, we can read the entire file into memory and parse it.

The ranges file is ~11 GB, and the logs file is ~200 MB.

We have 16 GB of memory. We may need to be careful about memory usage.

We prefer speed over memory efficiency, but we must not exceed 16 GB.

Output format: ip_address,country_code per line, in the same order as the input logs.

We also want a summary at the end: total IPs processed, matches found, unmatched IPs.

Use std::io::BufWriter for output.

Estimate the total memory usage and report it at the end.# IP Geolocation in Rust — Design & Implementation

Approach

Binary search over pre-sorted ranges: O(n log m). With ~500k ranges (typical for IPv4 geo databases), that's ~19 comparisons per IP — vastly better than brute force (which at 2M IPs × 500k ranges would take days, not seconds).

Memory analysis (16 GB budget):

• Ranges file (~11 GB parsed text) — we do not keep the raw text. We parse streaming and store only compact structs:
  • start_ip: u32 (4 bytes), end_ip: u32 (4 bytes), country: [u8; 2] (2 bytes) → ~12 bytes each (with padding)
  • 500,000 ranges ≈ 6 MB. Trivial.
• Ranges: We stream the 11 GB file with a BufReader, parse each line, discard the raw bytes immediately. Peak memory here is just the buffer (~8 MB).
• Output: BufWriter over 2M lines × ~15 bytes ≈ 30 MB buffered on disk, trivial in RAM.

Total resident memory: well under 1 GB. ✔ Fits comfortably in 16 GB.

Key decisions

1. Parse ranges in file order, derive end_ip from prefix length. end = start | (u32::MAX >> prefix_len). The file is sorted by start IP, so we assert monotonicity (catches malformed input) and binary search directly — no separate sort step needed.
2. partition_point (Rust 1.52+) for the binary search — clean, branch-predictor-friendly.
3. Progress every 100,000 IPs to stderr (stdout stays clean for redirection).
4. **Buffered I