Abstract / Summary

Given an integer and k, count how many integer pairs have a digit-wise xor equal to the number.

Note

The full problem description, including helpful examples, can be found on LeetCode.

This problem is ranked as

and has an acceptance rate of about 64% (100k+ submissions).

Typical patterns to solve this problem:

• Math
• Sliding Window
• String

Every single line of code was written by me, 100% from scratch, between August 2023 and August 2024.
However, two years later I set up this website and used various AI tools to generate most of the walkthrough / explanations below.

See this dedicated page for more details.

Overview

The provided Solution class implements a method that counts how many contiguous substrings of length k within the decimal representation of a given integer num are non-zero divisors of num. The algorithm works by treating the number as a string, sliding a fixed-size window across it, converting each window into an integer, and testing the divisibility condition.

Key Steps

The first operation converts the integer num into its string form so that individual digits can be accessed directly.

s = str(num)

A loop iterates from the start of the string up to the position where a full window of length k can still be taken. The range expression len(s) - k + 1 guarantees that the loop body executes only when a complete substring exists.

for i in range(len(s) - k + 1):

Inside the loop, a slice of length k is extracted from the current position i. The slice is immediately cast to an integer, producing the candidate divisor.

sub = int(s[i : i + k])

The algorithm then checks two conditions: the candidate must be greater than zero, and num must be exactly divisible by it. When both hold, the result counter is incremented.

if sub > 0 and num % sub == 0:
    result += 1

After the loop finishes, the accumulated count is returned.

return result

Edge Cases Handled

When the substring extracted consists solely of zeros, the conversion yields 0. The explicit sub > 0 guard prevents a division-by-zero error, thereby safely ignoring such substrings.

If k equals the length of the string representation of num, the loop runs exactly once, evaluating the whole number as the only possible substring.

When k exceeds the number of digits in num, the expression len(s) - k + 1 becomes non-positive, causing the range to be empty. Consequently, the loop body never executes and the method returns 0, correctly indicating that no valid substrings exist.

Leading zeros inside a substring are naturally handled by the integer conversion: a slice like "005" becomes the integer 5, and the subsequent divisor test applies to the numeric value rather than the textual representation.

Performance Optimizations

The implementation performs the string conversion a single time, avoiding repeated calls that would increase overhead. By iterating with a simple for loop and using direct slice indexing, the code accesses each required substring in constant time per iteration.

The check sub > 0 is placed before the modulo operation, ensuring that the potentially expensive division is only executed for valid, non-zero candidates. This ordering eliminates unnecessary arithmetic when the substring evaluates to zero.

No auxiliary data structures such as lists or sets are allocated; the algorithm maintains only a few scalar variables (result, s, i, sub). This minimal memory footprint contributes to efficient execution, especially for large input values where the number of digits may be substantial.

Overall, the method leverages Python’s built-in string handling and arithmetic operations to achieve a concise and performant solution for counting divisor substrings.

Imagine having a big number made of lots of digits lined up like a train. This code looks at that train and picks out smaller groups of cars that are a certain length long. It starts at the front and grabs a little chunk, then it slides over one spot and grabs another chunk, and it keeps on sliding until it reaches the very end. For every chunk it collects, it turns those digits back into a number to see if the big train number can be split perfectly by that smaller number. Whenever the big number divides evenly by the small chunk with nothing left over, it counts that as a success by adding one to a total score. After checking every possible chunk, the process stops.

Several LLMs ranked my code quality on a scale from 1 (very poor) to 10 (outstanding):

not analyzed yet

I wrote a basic crawler to find other solutions to that problem.
Obviously, I did that after I solved the problem myself.

In general, AlgoMonster and WalkCCC solutions are high-quality and always worth a look.
I haven't checked most of the other solutions, but they might be helpful as well.

And of course, the LeetCode forum is always a good place (or even the best) to look for alternative approaches.

(click on a column header to sort the table)

	author
author	solutions
www	AlgoMonster	Java	Python			C++	TS
	WalkCCC	Java	Python			C++
	leetcode.ca	Java	Python		Go	C++	TS
	Progiez	Java	Python			C++
github	charles-wangkai	Java
	fsq					C++
	JoshCrozier			JS
	lkwq007		Python
	muhammadfarhankt				Go
	varunu28	Java
AlgoMonster	C++, Python, Java, TypeScript
WalkCCC	C++, Python, Java
leetcode.ca	C++, Go, Java, Python, TypeScript
Progiez	C++, Java, Python
charles-wangkai	Java
fsq	C++
JoshCrozier	JavaScript
lkwq007	Python
muhammadfarhankt	Go
varunu28	Java

There are a few extra pages giving you some insights into my setup:

• Tech Stack - my development environment and tools
• AI - how AI helped me create this website (NOT solving the problems)
• Progress - progression over time
• Quality - code quality