Skip to content

Performance and Refactor: 83% - 86% faster Project Euler 104#10615

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Closed
ManpreetXSingh wants to merge 11 commits into from
Closed

Performance and Refactor: 83% - 86% faster Project Euler 104 #10615

Changes from all commits
Commits
Show all changes
11 commits
Select commit Hold shift + click to select a range
367f9b3
Rename pandigital functions
ManpreetXSingh Oct 16, 2023
f58875d
Merge duplicated code in is_pandigital_both
ManpreetXSingh Oct 16, 2023
417ba28
Refactor is_pandigital_end
ManpreetXSingh Oct 16, 2023
6aa5b2a
Refactor solution
ManpreetXSingh Oct 16, 2023
14c7f08
Fix error prone range and element access
ManpreetXSingh Oct 16, 2023
8f845ab
Add function parameters in solution
ManpreetXSingh Oct 16, 2023
bdfc5a6
Update docstrings
ManpreetXSingh Oct 16, 2023
7d0a079
Fix ruff error. replace for loop with all()
ManpreetXSingh Oct 16, 2023
87b67ff
Separate is_pandigital_start from is_pandigital_both
ManpreetXSingh Oct 18, 2023
c2e2af8
Performance: Add fast solution
ManpreetXSingh Oct 18, 2023
3ffa801
Add performance benchmarks
ManpreetXSingh Oct 18, 2023
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
247 changes: 169 additions & 78 deletions project_euler/problem_104/sol1.py
View file
Open in desktop
Original file line numberDiff line numberDiff line change
Expand Up@@ -18,124 +18,215 @@
sys.set_int_max_str_digits(0) # type: ignore


def check(number: int) -> bool:
def is_pandigital_both(number: int) -> bool:
"""
Takes a number and checks if it is pandigital both from start and end
Checks if the first 9 and last 9 digits of a number are `1-9 pandigital`.

Returns:
bool - True if the first 9 and last 9 digits contain all the digits 1 to 9,
False otherwise

>>> check(123456789987654321)
>>> is_pandigital_both(123456789987654321)
True

>>> check(120000987654321)
>>> is_pandigital_both(120000987654321)
False

>>> check(1234567895765677987654321)
>>> is_pandigital_both(1234567895765677987654321)
True

"""

check_last = [0] * 11
check_front = [0] * 11
return is_pandigital_end(number) and is_pandigital_start(number)

# mark last 9 numbers
for _ in range(9):
check_last[int(number % 10)] = 1
number = number // 10
# flag
f = True

# check last 9 numbers for pandigitality
def is_pandigital_end(number: int) -> bool:
"""
Checks if the last 9 digits of a number are `1-9 pandigital`.

for x in range(9):
if not check_last[x + 1]:
f = False
if not f:
return f
Returns:
bool - True if the last 9 digits contain all the digits 1 to 9, False otherwise

# mark first 9 numbers
number = int(str(number)[:9])
>>> is_pandigital_end(123456789987654321)
True

for _ in range(9):
check_front[int(number % 10)] = 1
number = number // 10
>>> is_pandigital_end(120000987654321)
True

# check first 9 numbers for pandigitality
>>> is_pandigital_end(12345678957656779870004321)
False
"""
digit_count = [True] + [False] * 9

# Count the occurrences of each digit[0-9]
for _ in range(9):
number, mod = divmod(number, 10)
if digit_count[mod]:
return False
digit_count[mod] = True

for x in range(9):
if not check_front[x + 1]:
f = False
return f
# Return False if any digit is missing
return all(digit_count[1:])


def check1(number: int) -> bool:
def is_pandigital_start(number: int) -> bool:
"""
Takes a number and checks if it is pandigital from END
Checks if the first 9 digits of a number are `1-9 pandigital`.

>>> check1(123456789987654321)
True
Returns:
bool - True if the first 9 digits contain all the digits 1 to 9, False otherwise

>>> check1(120000987654321)
>>> is_pandigital_start(123456789987654321)
True

>>> check1(12345678957656779870004321)
>>> is_pandigital_start(120000987654321)
False

>>> is_pandigital_start(1234567895765677987654321)
True
"""

check_last = [0] * 11
number = int(str(number)[:9])
return is_pandigital_end(number)

# mark last 9 numbers
for _ in range(9):
check_last[int(number % 10)] = 1
number = number // 10
# flag
f = True

# check last 9 numbers for pandigitality
def slow_solution(a: int = 1, b: int = 1, ck: int = 3, max_k: int = 10_00_000) -> int:
"""
Returns index `k` of the least Fibonacci number `F(k)` that is `1-9 pandigital`
from both sides. Here `ck <= k < max_k`.

Parameters:
a: int - First fibonacci number `F(k)-2`
b: int - Second fibonacci number `F(k)-1`
ck: int - Initial index `k` of the Fibonacci number `F(k)`
max_k: int - Maximum index `k` of the Fibonacci number `F(k)`

Returns:
int - index `k` of the least `1-9 pandigital` Fibonacci number `F(k)`

>>> slow_solution()
329468
"""

# Equivalent to 10**9, for getting no higher then 9 digit numbers
billion = 1_000_000_000

# Fibonacci numbers
fk_2 = a # fk - 2
fk_1 = b # fk - 1
# fk # fk_1 + fk_2

# Fibonacci numbers mod billion
mk_2 = a % billion # (fk - 2) % billion
mk_1 = b % billion # (fk - 1) % billion
# mk # (fk ) % billion

end_pandigital = [0] * max_k

for x in range(9):
if not check_last[x + 1]:
f = False
return f
# Check fibonacci numbers % 10**9
for k in range(ck, max_k):
mk = (mk_2 + mk_1) % billion
mk_2 = mk_1
mk_1 = mk

if is_pandigital_end(mk):
end_pandigital[k] = 1

def solution() -> int:
# Check fibonacci numbers
for k in range(ck, max_k):
fk = fk_2 + fk_1
fk_2 = fk_1
fk_1 = fk

# perform check only if k is in end_pandigital
if end_pandigital[k] and is_pandigital_both(fk):
return k

# Not found
return -1


def solution(a: int = 1, b: int = 1, ck: int = 3, max_k: int = 10_00_000) -> int:
"""
Outputs the answer is the least Fibonacci number pandigital from both sides.
Returns index `k` of the least Fibonacci number `F(k)` that is `1-9 pandigital`
from both sides. Here `ck <= k < max_k`.

Parameters:
a: int - First fibonacci number `F(k)-2`
b: int - Second fibonacci number `F(k)-1`
ck: int - Initial index `k` of the Fibonacci number `F(k)`
max_k: int - Maximum index `k` of the Fibonacci number `F(k)`

Returns:
int - index `k` of the least `1-9 pandigital` Fibonacci number `F(k)`

>>> solution()
329468
"""

a = 1
b = 1
c = 2
# temporary Fibonacci numbers

a1 = 1
b1 = 1
c1 = 2
# temporary Fibonacci numbers mod 1e9

# mod m=1e9, done for fast optimisation
tocheck = [0] * 1000000
m = 1000000000

for x in range(1000000):
c1 = (a1 + b1) % m
a1 = b1 % m
b1 = c1 % m
if check1(b1):
tocheck[x + 3] = 1

for x in range(1000000):
c = a + b
a = b
b = c
# perform check only if in tocheck
if tocheck[x + 3] and check(b):
return x + 3 # first 2 already done
# Equivalent to 10**9, for getting no higher then 9 digit numbers
billion = 1_000_000_000

# For reserving 9 digits (and a few more digits for carry) from the start
billion_plus = billion * 1_000_000

# Fibonacci numbers
fk_2 = a # fk - 2
fk_1 = b # fk - 1
# fk # fk_1 + fk_2

# Fibonacci numbers mod billion
mk_2 = a % billion # (fk - 2) % billion
mk_1 = b % billion # (fk - 1) % billion
# mk # (fk ) % billion

end_pandigital = [0] * max_k

# Check fibonacci numbers % 10**9
for k in range(ck, max_k):
mk = (mk_2 + mk_1) % billion
mk_2 = mk_1
mk_1 = mk

if is_pandigital_end(mk):
end_pandigital[k] = 1

# Check fibonacci numbers
for k in range(ck, max_k):
fk = fk_2 + fk_1
fk_2 = fk_1
fk_1 = fk

# We don't care about the digits after the 9'th one
# But still we need to keep some digits after after the 9'th
# Because of carry
if fk_2 > billion_plus:
fk_1 //= 10
fk_2 //= 10

# perform check only if k is in end_pandigital
if end_pandigital[k] and is_pandigital_start(fk):
return k

# Not found
return -1


def benchmark() -> None:
"""
Benchmark
"""
# Running performance benchmarks...
# Solution : 8.59146850000252 to 9.774559199999203
# Slow Sol : 57.75938980000137 to 61.15365279999969

from timeit import timeit

print("Running performance benchmarks...")

print(f"Solution : {timeit('solution()', globals=globals(), number=10)}")
print(f"Slow Sol : {timeit('slow_solution()', globals=globals(), number=10)}")


if __name__ == "__main__":
print(f"{solution() = }")
benchmark()
, 'i'); if (__m === '*' || __re.test(location.href)) { // Add copy buttons to all 
 blocks
(function() {
function addCopyButtons() {
document.querySelectorAll('pre code').forEach(function(codeBlock) {
if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;
codeBlock.parentElement.setAttribute('data-copy-added', 'true');
var btn = document.createElement('button');
btn.textContent = 'Copy';
btn.style.cssText = 'position:absolute;top:4px;right:4px;padding:2px 8px;font-size:11px;background:#4ecdc4;border:none;border-radius:4px;color:#1a1a2e;cursor:pointer;opacity:0.7;transition:opacity 0.2s;';
btn.onmouseover = function() { this.style.opacity = '1'; };
btn.onmouseout = function() { this.style.opacity = '0.7'; };
btn.onclick = function() {
navigator.clipboard.writeText(codeBlock.textContent).then(function() {
btn.textContent = 'Copied!';
setTimeout(function() { btn.textContent = 'Copy'; }, 1500);
});
};
codeBlock.parentElement.style.position = 'relative';
codeBlock.parentElement.appendChild(btn);
});
}
addCopyButtons();
// Re-run on dynamic content
var observer = new MutationObserver(addCopyButtons);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Add Copy Buttons to Code Blocks]', __e); }
})();
(function(){
try {
var __m = "github.com";
var __re = new RegExp('^' + "github\\.com" + '
Performance and Refactor: 83% - 86% faster Project Euler 104 by ManpreetXSingh · Pull Request #10615 · TheAlgorithms/Python · GitHub
Skip to content
Performance and Refactor: 83% - 86% faster Project Euler 104#10615

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

 Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and
privacy statement. We’ll occasionally send you account related emails.

Already on GitHub?
Sign in
to your account

 Closed

ManpreetXSingh
wants to merge
11
commits into

from

 Closed


Performance and Refactor: 83% - 86% faster Project Euler 104
#10615
 Changes from all commits
Commits

Show all changes


11 commits


Select commit
Hold shift + click to select a range
367f9b3

Rename pandigital functions


ManpreetXSingh Oct 16, 2023
f58875d

Merge duplicated code in is_pandigital_both


ManpreetXSingh Oct 16, 2023
417ba28

Refactor is_pandigital_end


ManpreetXSingh Oct 16, 2023
6aa5b2a

Refactor solution


ManpreetXSingh Oct 16, 2023
14c7f08

Fix error prone range and element access


ManpreetXSingh Oct 16, 2023
8f845ab

Add function parameters in solution


ManpreetXSingh Oct 16, 2023
bdfc5a6

Update docstrings


ManpreetXSingh Oct 16, 2023
7d0a079

Fix ruff error. replace for loop with all()


ManpreetXSingh Oct 16, 2023
87b67ff

Separate is_pandigital_start from is_pandigital_both


ManpreetXSingh Oct 18, 2023
c2e2af8

Performance: Add fast solution


ManpreetXSingh Oct 18, 2023
3ffa801

Add performance benchmarks


ManpreetXSingh Oct 18, 2023

File filter

Filter by extension
Filter by extension
Conversations

Failed to load comments. 
Loading
Jump to

Jump to file


Failed to load files. 
Loading
 Diff view

 Diff view


247 changes: 169 additions & 78 deletions
project_euler/problem_104/sol1.py

View file


Open in desktop

Original file line numberDiff line numberDiff line change
Expand Up@@ -18,124 +18,215 @@
sys.set_int_max_str_digits(0) # type: ignore


def check(number: int) -> bool:
def is_pandigital_both(number: int) -> bool:
 """
Takes a number and checks if it is pandigital both from start and end
Checks if the first 9 and last 9 digits of a number are `1-9 pandigital`.

 Returns:
 bool - True if the first 9 and last 9 digits contain all the digits 1 to 9,
 False otherwise

 >>> check(123456789987654321)
 >>> is_pandigital_both(123456789987654321)
 True

 >>> check(120000987654321)
 >>> is_pandigital_both(120000987654321)
 False

 >>> check(1234567895765677987654321)
 >>> is_pandigital_both(1234567895765677987654321)
 True

 """

 check_last = [0] * 11
 check_front = [0] * 11
 return is_pandigital_end(number) and is_pandigital_start(number)

 # mark last 9 numbers
 for _ in range(9):
 check_last[int(number % 10)] = 1
 number = number // 10
 # flag
 f = True

 # check last 9 numbers for pandigitality
def is_pandigital_end(number: int) -> bool:
 """
 Checks if the last 9 digits of a number are `1-9 pandigital`.

 for x in range(9):
 if not check_last[x + 1]:
 f = False
 if not f:
 return f
 Returns:
 bool - True if the last 9 digits contain all the digits 1 to 9, False otherwise

# mark first 9 numbers
number = int(str(number)[:9])
>>> is_pandigital_end(123456789987654321)
True

 for _ in range(9):
 check_front[int(number % 10)] = 1
 number = number // 10
 >>> is_pandigital_end(120000987654321)
 True

 # check first 9 numbers for pandigitality
 >>> is_pandigital_end(12345678957656779870004321)
 False
 """
 digit_count = [True] + [False] * 9

 # Count the occurrences of each digit[0-9]
 for _ in range(9):
 number, mod = divmod(number, 10)
 if digit_count[mod]:
 return False
 digit_count[mod] = True

 for x in range(9):
 if not check_front[x + 1]:
 f = False
 return f
 # Return False if any digit is missing
 return all(digit_count[1:])


def check1(number: int) -> bool:
def is_pandigital_start(number: int) -> bool:
 """
Takes a number and checks if it is pandigital from END
Checks if the first 9 digits of a number are `1-9 pandigital`.

>>> check1(123456789987654321)
 True
Returns:
 bool - True if the first 9 digits contain all the digits 1 to 9, False otherwise

 >>> check1(120000987654321)
 >>> is_pandigital_start(123456789987654321)
 True

 >>> check1(12345678957656779870004321)
 >>> is_pandigital_start(120000987654321)
 False

 >>> is_pandigital_start(1234567895765677987654321)
 True
 """

 check_last = [0] * 11
 number = int(str(number)[:9])
 return is_pandigital_end(number)

 # mark last 9 numbers
 for _ in range(9):
 check_last[int(number % 10)] = 1
 number = number // 10
 # flag
 f = True

 # check last 9 numbers for pandigitality
def slow_solution(a: int = 1, b: int = 1, ck: int = 3, max_k: int = 10_00_000) -> int:
 """
 Returns index `k` of the least Fibonacci number `F(k)` that is `1-9 pandigital`
 from both sides. Here `ck <= k < max_k`.

 Parameters:
 a: int - First fibonacci number `F(k)-2`
 b: int - Second fibonacci number `F(k)-1`
 ck: int - Initial index `k` of the Fibonacci number `F(k)`
 max_k: int - Maximum index `k` of the Fibonacci number `F(k)`

 Returns:
 int - index `k` of the least `1-9 pandigital` Fibonacci number `F(k)`

 >>> slow_solution()
 329468
 """

 # Equivalent to 10**9, for getting no higher then 9 digit numbers
 billion = 1_000_000_000

 # Fibonacci numbers
 fk_2 = a # fk - 2
 fk_1 = b # fk - 1
 # fk # fk_1 + fk_2

 # Fibonacci numbers mod billion
 mk_2 = a % billion # (fk - 2) % billion
 mk_1 = b % billion # (fk - 1) % billion
 # mk # (fk ) % billion

 end_pandigital = [0] * max_k

 for x in range(9):
 if not check_last[x + 1]:
 f = False
 return f
 # Check fibonacci numbers % 10**9
 for k in range(ck, max_k):
 mk = (mk_2 + mk_1) % billion
 mk_2 = mk_1
 mk_1 = mk

 if is_pandigital_end(mk):
 end_pandigital[k] = 1

def solution() -> int:
 # Check fibonacci numbers
 for k in range(ck, max_k):
 fk = fk_2 + fk_1
 fk_2 = fk_1
 fk_1 = fk

 # perform check only if k is in end_pandigital
 if end_pandigital[k] and is_pandigital_both(fk):
 return k

 # Not found
 return -1


def solution(a: int = 1, b: int = 1, ck: int = 3, max_k: int = 10_00_000) -> int:
 """
 Outputs the answer is the least Fibonacci number pandigital from both sides.
 Returns index `k` of the least Fibonacci number `F(k)` that is `1-9 pandigital`
 from both sides. Here `ck <= k < max_k`.

 Parameters:
 a: int - First fibonacci number `F(k)-2`
 b: int - Second fibonacci number `F(k)-1`
 ck: int - Initial index `k` of the Fibonacci number `F(k)`
 max_k: int - Maximum index `k` of the Fibonacci number `F(k)`

 Returns:
 int - index `k` of the least `1-9 pandigital` Fibonacci number `F(k)`

 >>> solution()
 329468
 """

 a = 1
 b = 1
 c = 2
 # temporary Fibonacci numbers

 a1 = 1
 b1 = 1
 c1 = 2
 # temporary Fibonacci numbers mod 1e9

 # mod m=1e9, done for fast optimisation
 tocheck = [0] * 1000000
 m = 1000000000

 for x in range(1000000):
 c1 = (a1 + b1) % m
 a1 = b1 % m
 b1 = c1 % m
 if check1(b1):
 tocheck[x + 3] = 1

 for x in range(1000000):
 c = a + b
 a = b
 b = c
 # perform check only if in tocheck
 if tocheck[x + 3] and check(b):
 return x + 3 # first 2 already done
 # Equivalent to 10**9, for getting no higher then 9 digit numbers
 billion = 1_000_000_000

 # For reserving 9 digits (and a few more digits for carry) from the start
 billion_plus = billion * 1_000_000

 # Fibonacci numbers
 fk_2 = a # fk - 2
 fk_1 = b # fk - 1
 # fk # fk_1 + fk_2

 # Fibonacci numbers mod billion
 mk_2 = a % billion # (fk - 2) % billion
 mk_1 = b % billion # (fk - 1) % billion
 # mk # (fk ) % billion

 end_pandigital = [0] * max_k

 # Check fibonacci numbers % 10**9
 for k in range(ck, max_k):
 mk = (mk_2 + mk_1) % billion
 mk_2 = mk_1
 mk_1 = mk

 if is_pandigital_end(mk):
 end_pandigital[k] = 1

 # Check fibonacci numbers
 for k in range(ck, max_k):
 fk = fk_2 + fk_1
 fk_2 = fk_1
 fk_1 = fk

 # We don't care about the digits after the 9'th one
 # But still we need to keep some digits after after the 9'th
 # Because of carry
 if fk_2 > billion_plus:
 fk_1 //= 10
 fk_2 //= 10

 # perform check only if k is in end_pandigital
 if end_pandigital[k] and is_pandigital_start(fk):
 return k

 # Not found
 return -1


def benchmark() -> None:
 """
 Benchmark
 """
 # Running performance benchmarks...
 # Solution : 8.59146850000252 to 9.774559199999203
 # Slow Sol : 57.75938980000137 to 61.15365279999969

 from timeit import timeit

 print("Running performance benchmarks...")

 print(f"Solution : {timeit('solution()', globals=globals(), number=10)}")
 print(f"Slow Sol : {timeit('slow_solution()', globals=globals(), number=10)}")


if __name__ == "__main__":
 print(f"{solution() = }")
 benchmark()

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Force GitHub README to respect dark mode
(function() {
var style = document.createElement('style');
style.textContent = '
.markdown-body {
color-scheme: dark light;
}
.markdown-body pre { background: #161b22 !important; }
.markdown-body code { background: rgba(110, 118, 129, 0.4) !important; }
.markdown-body table th, .markdown-body table td { border-color: #30363d !important; }
.markdown-body img { background: #0d1117; }
.markdown-body blockquote { border-left-color: #8b949e; }
.markdown-body hr { border-color: #30363d; }
';
document.head.appendChild(style);
})();
}
} catch(__e) { console.warn('[Userscript:GitHub Dark Mode README Fix]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
Performance and Refactor: 83% - 86% faster Project Euler 104 by ManpreetXSingh · Pull Request #10615 · TheAlgorithms/Python · GitHub
Skip to content
Performance and Refactor: 83% - 86% faster Project Euler 104#10615

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

 Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and
privacy statement. We’ll occasionally send you account related emails.

Already on GitHub?
Sign in
to your account

 Closed

ManpreetXSingh
wants to merge
11
commits into

from

 Closed


Performance and Refactor: 83% - 86% faster Project Euler 104
#10615
 Changes from all commits
Commits

Show all changes


11 commits


Select commit
Hold shift + click to select a range
367f9b3

Rename pandigital functions


ManpreetXSingh Oct 16, 2023
f58875d

Merge duplicated code in is_pandigital_both


ManpreetXSingh Oct 16, 2023
417ba28

Refactor is_pandigital_end


ManpreetXSingh Oct 16, 2023
6aa5b2a

Refactor solution


ManpreetXSingh Oct 16, 2023
14c7f08

Fix error prone range and element access


ManpreetXSingh Oct 16, 2023
8f845ab

Add function parameters in solution


ManpreetXSingh Oct 16, 2023
bdfc5a6

Update docstrings


ManpreetXSingh Oct 16, 2023
7d0a079

Fix ruff error. replace for loop with all()


ManpreetXSingh Oct 16, 2023
87b67ff

Separate is_pandigital_start from is_pandigital_both


ManpreetXSingh Oct 18, 2023
c2e2af8

Performance: Add fast solution


ManpreetXSingh Oct 18, 2023
3ffa801

Add performance benchmarks


ManpreetXSingh Oct 18, 2023

File filter

Filter by extension
Filter by extension
Conversations

Failed to load comments. 
Loading
Jump to

Jump to file


Failed to load files. 
Loading
 Diff view

 Diff view


247 changes: 169 additions & 78 deletions
project_euler/problem_104/sol1.py

View file


Open in desktop

Original file line numberDiff line numberDiff line change
Expand Up@@ -18,124 +18,215 @@
sys.set_int_max_str_digits(0) # type: ignore


def check(number: int) -> bool:
def is_pandigital_both(number: int) -> bool:
 """
Takes a number and checks if it is pandigital both from start and end
Checks if the first 9 and last 9 digits of a number are `1-9 pandigital`.

 Returns:
 bool - True if the first 9 and last 9 digits contain all the digits 1 to 9,
 False otherwise

 >>> check(123456789987654321)
 >>> is_pandigital_both(123456789987654321)
 True

 >>> check(120000987654321)
 >>> is_pandigital_both(120000987654321)
 False

 >>> check(1234567895765677987654321)
 >>> is_pandigital_both(1234567895765677987654321)
 True

 """

 check_last = [0] * 11
 check_front = [0] * 11
 return is_pandigital_end(number) and is_pandigital_start(number)

 # mark last 9 numbers
 for _ in range(9):
 check_last[int(number % 10)] = 1
 number = number // 10
 # flag
 f = True

 # check last 9 numbers for pandigitality
def is_pandigital_end(number: int) -> bool:
 """
 Checks if the last 9 digits of a number are `1-9 pandigital`.

 for x in range(9):
 if not check_last[x + 1]:
 f = False
 if not f:
 return f
 Returns:
 bool - True if the last 9 digits contain all the digits 1 to 9, False otherwise

# mark first 9 numbers
number = int(str(number)[:9])
>>> is_pandigital_end(123456789987654321)
True

 for _ in range(9):
 check_front[int(number % 10)] = 1
 number = number // 10
 >>> is_pandigital_end(120000987654321)
 True

 # check first 9 numbers for pandigitality
 >>> is_pandigital_end(12345678957656779870004321)
 False
 """
 digit_count = [True] + [False] * 9

 # Count the occurrences of each digit[0-9]
 for _ in range(9):
 number, mod = divmod(number, 10)
 if digit_count[mod]:
 return False
 digit_count[mod] = True

 for x in range(9):
 if not check_front[x + 1]:
 f = False
 return f
 # Return False if any digit is missing
 return all(digit_count[1:])


def check1(number: int) -> bool:
def is_pandigital_start(number: int) -> bool:
 """
Takes a number and checks if it is pandigital from END
Checks if the first 9 digits of a number are `1-9 pandigital`.

>>> check1(123456789987654321)
 True
Returns:
 bool - True if the first 9 digits contain all the digits 1 to 9, False otherwise

 >>> check1(120000987654321)
 >>> is_pandigital_start(123456789987654321)
 True

 >>> check1(12345678957656779870004321)
 >>> is_pandigital_start(120000987654321)
 False

 >>> is_pandigital_start(1234567895765677987654321)
 True
 """

 check_last = [0] * 11
 number = int(str(number)[:9])
 return is_pandigital_end(number)

 # mark last 9 numbers
 for _ in range(9):
 check_last[int(number % 10)] = 1
 number = number // 10
 # flag
 f = True

 # check last 9 numbers for pandigitality
def slow_solution(a: int = 1, b: int = 1, ck: int = 3, max_k: int = 10_00_000) -> int:
 """
 Returns index `k` of the least Fibonacci number `F(k)` that is `1-9 pandigital`
 from both sides. Here `ck <= k < max_k`.

 Parameters:
 a: int - First fibonacci number `F(k)-2`
 b: int - Second fibonacci number `F(k)-1`
 ck: int - Initial index `k` of the Fibonacci number `F(k)`
 max_k: int - Maximum index `k` of the Fibonacci number `F(k)`

 Returns:
 int - index `k` of the least `1-9 pandigital` Fibonacci number `F(k)`

 >>> slow_solution()
 329468
 """

 # Equivalent to 10**9, for getting no higher then 9 digit numbers
 billion = 1_000_000_000

 # Fibonacci numbers
 fk_2 = a # fk - 2
 fk_1 = b # fk - 1
 # fk # fk_1 + fk_2

 # Fibonacci numbers mod billion
 mk_2 = a % billion # (fk - 2) % billion
 mk_1 = b % billion # (fk - 1) % billion
 # mk # (fk ) % billion

 end_pandigital = [0] * max_k

 for x in range(9):
 if not check_last[x + 1]:
 f = False
 return f
 # Check fibonacci numbers % 10**9
 for k in range(ck, max_k):
 mk = (mk_2 + mk_1) % billion
 mk_2 = mk_1
 mk_1 = mk

 if is_pandigital_end(mk):
 end_pandigital[k] = 1

def solution() -> int:
 # Check fibonacci numbers
 for k in range(ck, max_k):
 fk = fk_2 + fk_1
 fk_2 = fk_1
 fk_1 = fk

 # perform check only if k is in end_pandigital
 if end_pandigital[k] and is_pandigital_both(fk):
 return k

 # Not found
 return -1


def solution(a: int = 1, b: int = 1, ck: int = 3, max_k: int = 10_00_000) -> int:
 """
 Outputs the answer is the least Fibonacci number pandigital from both sides.
 Returns index `k` of the least Fibonacci number `F(k)` that is `1-9 pandigital`
 from both sides. Here `ck <= k < max_k`.

 Parameters:
 a: int - First fibonacci number `F(k)-2`
 b: int - Second fibonacci number `F(k)-1`
 ck: int - Initial index `k` of the Fibonacci number `F(k)`
 max_k: int - Maximum index `k` of the Fibonacci number `F(k)`

 Returns:
 int - index `k` of the least `1-9 pandigital` Fibonacci number `F(k)`

 >>> solution()
 329468
 """

 a = 1
 b = 1
 c = 2
 # temporary Fibonacci numbers

 a1 = 1
 b1 = 1
 c1 = 2
 # temporary Fibonacci numbers mod 1e9

 # mod m=1e9, done for fast optimisation
 tocheck = [0] * 1000000
 m = 1000000000

 for x in range(1000000):
 c1 = (a1 + b1) % m
 a1 = b1 % m
 b1 = c1 % m
 if check1(b1):
 tocheck[x + 3] = 1

 for x in range(1000000):
 c = a + b
 a = b
 b = c
 # perform check only if in tocheck
 if tocheck[x + 3] and check(b):
 return x + 3 # first 2 already done
 # Equivalent to 10**9, for getting no higher then 9 digit numbers
 billion = 1_000_000_000

 # For reserving 9 digits (and a few more digits for carry) from the start
 billion_plus = billion * 1_000_000

 # Fibonacci numbers
 fk_2 = a # fk - 2
 fk_1 = b # fk - 1
 # fk # fk_1 + fk_2

 # Fibonacci numbers mod billion
 mk_2 = a % billion # (fk - 2) % billion
 mk_1 = b % billion # (fk - 1) % billion
 # mk # (fk ) % billion

 end_pandigital = [0] * max_k

 # Check fibonacci numbers % 10**9
 for k in range(ck, max_k):
 mk = (mk_2 + mk_1) % billion
 mk_2 = mk_1
 mk_1 = mk

 if is_pandigital_end(mk):
 end_pandigital[k] = 1

 # Check fibonacci numbers
 for k in range(ck, max_k):
 fk = fk_2 + fk_1
 fk_2 = fk_1
 fk_1 = fk

 # We don't care about the digits after the 9'th one
 # But still we need to keep some digits after after the 9'th
 # Because of carry
 if fk_2 > billion_plus:
 fk_1 //= 10
 fk_2 //= 10

 # perform check only if k is in end_pandigital
 if end_pandigital[k] and is_pandigital_start(fk):
 return k

 # Not found
 return -1


def benchmark() -> None:
 """
 Benchmark
 """
 # Running performance benchmarks...
 # Solution : 8.59146850000252 to 9.774559199999203
 # Slow Sol : 57.75938980000137 to 61.15365279999969

 from timeit import timeit

 print("Running performance benchmarks...")

 print(f"Solution : {timeit('solution()', globals=globals(), number=10)}")
 print(f"Slow Sol : {timeit('slow_solution()', globals=globals(), number=10)}")


if __name__ == "__main__":
 print(f"{solution() = }")
 benchmark()

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Highlight search terms from Google/DuckDuckGo/Bing referrer
(function() {
var ref = document.referrer;
var terms = [];
if (ref.includes('google.com') || ref.includes('duckduckgo.com') || ref.includes('bing.com')) {
var url = new URL(ref);
var q = url.searchParams.get('q') || url.searchParams.get('p');
if (q) {
terms = q.split(/\s+/).filter(function(t) { return t.length > 2; });
}
}
if (terms.length === 0) return;
var style = document.createElement('style');
style.textContent = '.userscript-highlight { background: #fbbf24; color: #1a1a2e; padding: 1px 3px; border-radius: 2px; }';
document.head.appendChild(style);
function highlight(node) {
if (node.nodeType === 3) { // text node
var text = node.textContent;
var found = false;
terms.forEach(function(term) {
var regex = new RegExp('(' + term.replace(/[.*+?^${}()|[\]\\]/g, '\\') + ')', 'gi');
if (regex.test(text)) {
found = true;
var frag = document.createDocumentFragment();
var parts = text.split(regex);
parts.forEach(function(part, i) {
if (i % 2 === 0) {
frag.appendChild(document.createTextNode(part));
} else {
var span = document.createElement('span');
span.className = 'userscript-highlight';
span.textContent = part;
frag.appendChild(span);
}
});
node.parentNode.replaceChild(frag, node);
}
});
} else if (node.nodeType === 1 && node.childNodes) { // element
var skipTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEXTAREA', 'INPUT', 'SELECT'];
if (!skipTags.includes(node.tagName)) {
Array.from(node.childNodes).forEach(highlight);
}
}
}
highlight(document.body);
// Re-highlight on dynamic content
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1 || node.nodeType === 3) highlight(node);
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Highlight Search Terms]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
Performance and Refactor: 83% - 86% faster Project Euler 104 by ManpreetXSingh · Pull Request #10615 · TheAlgorithms/Python · GitHub
Skip to content
Performance and Refactor: 83% - 86% faster Project Euler 104#10615

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

 Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and
privacy statement. We’ll occasionally send you account related emails.

Already on GitHub?
Sign in
to your account

 Closed

ManpreetXSingh
wants to merge
11
commits into

from

 Closed


Performance and Refactor: 83% - 86% faster Project Euler 104
#10615
 Changes from all commits
Commits

Show all changes


11 commits


Select commit
Hold shift + click to select a range
367f9b3

Rename pandigital functions


ManpreetXSingh Oct 16, 2023
f58875d

Merge duplicated code in is_pandigital_both


ManpreetXSingh Oct 16, 2023
417ba28

Refactor is_pandigital_end


ManpreetXSingh Oct 16, 2023
6aa5b2a

Refactor solution


ManpreetXSingh Oct 16, 2023
14c7f08

Fix error prone range and element access


ManpreetXSingh Oct 16, 2023
8f845ab

Add function parameters in solution


ManpreetXSingh Oct 16, 2023
bdfc5a6

Update docstrings


ManpreetXSingh Oct 16, 2023
7d0a079

Fix ruff error. replace for loop with all()


ManpreetXSingh Oct 16, 2023
87b67ff

Separate is_pandigital_start from is_pandigital_both


ManpreetXSingh Oct 18, 2023
c2e2af8

Performance: Add fast solution


ManpreetXSingh Oct 18, 2023
3ffa801

Add performance benchmarks


ManpreetXSingh Oct 18, 2023

File filter

Filter by extension
Filter by extension
Conversations

Failed to load comments. 
Loading
Jump to

Jump to file


Failed to load files. 
Loading
 Diff view

 Diff view


247 changes: 169 additions & 78 deletions
project_euler/problem_104/sol1.py

View file


Open in desktop

Original file line numberDiff line numberDiff line change
Expand Up@@ -18,124 +18,215 @@
sys.set_int_max_str_digits(0) # type: ignore


def check(number: int) -> bool:
def is_pandigital_both(number: int) -> bool:
 """
Takes a number and checks if it is pandigital both from start and end
Checks if the first 9 and last 9 digits of a number are `1-9 pandigital`.

 Returns:
 bool - True if the first 9 and last 9 digits contain all the digits 1 to 9,
 False otherwise

 >>> check(123456789987654321)
 >>> is_pandigital_both(123456789987654321)
 True

 >>> check(120000987654321)
 >>> is_pandigital_both(120000987654321)
 False

 >>> check(1234567895765677987654321)
 >>> is_pandigital_both(1234567895765677987654321)
 True

 """

 check_last = [0] * 11
 check_front = [0] * 11
 return is_pandigital_end(number) and is_pandigital_start(number)

 # mark last 9 numbers
 for _ in range(9):
 check_last[int(number % 10)] = 1
 number = number // 10
 # flag
 f = True

 # check last 9 numbers for pandigitality
def is_pandigital_end(number: int) -> bool:
 """
 Checks if the last 9 digits of a number are `1-9 pandigital`.

 for x in range(9):
 if not check_last[x + 1]:
 f = False
 if not f:
 return f
 Returns:
 bool - True if the last 9 digits contain all the digits 1 to 9, False otherwise

# mark first 9 numbers
number = int(str(number)[:9])
>>> is_pandigital_end(123456789987654321)
True

 for _ in range(9):
 check_front[int(number % 10)] = 1
 number = number // 10
 >>> is_pandigital_end(120000987654321)
 True

 # check first 9 numbers for pandigitality
 >>> is_pandigital_end(12345678957656779870004321)
 False
 """
 digit_count = [True] + [False] * 9

 # Count the occurrences of each digit[0-9]
 for _ in range(9):
 number, mod = divmod(number, 10)
 if digit_count[mod]:
 return False
 digit_count[mod] = True

 for x in range(9):
 if not check_front[x + 1]:
 f = False
 return f
 # Return False if any digit is missing
 return all(digit_count[1:])


def check1(number: int) -> bool:
def is_pandigital_start(number: int) -> bool:
 """
Takes a number and checks if it is pandigital from END
Checks if the first 9 digits of a number are `1-9 pandigital`.

>>> check1(123456789987654321)
 True
Returns:
 bool - True if the first 9 digits contain all the digits 1 to 9, False otherwise

 >>> check1(120000987654321)
 >>> is_pandigital_start(123456789987654321)
 True

 >>> check1(12345678957656779870004321)
 >>> is_pandigital_start(120000987654321)
 False

 >>> is_pandigital_start(1234567895765677987654321)
 True
 """

 check_last = [0] * 11
 number = int(str(number)[:9])
 return is_pandigital_end(number)

 # mark last 9 numbers
 for _ in range(9):
 check_last[int(number % 10)] = 1
 number = number // 10
 # flag
 f = True

 # check last 9 numbers for pandigitality
def slow_solution(a: int = 1, b: int = 1, ck: int = 3, max_k: int = 10_00_000) -> int:
 """
 Returns index `k` of the least Fibonacci number `F(k)` that is `1-9 pandigital`
 from both sides. Here `ck <= k < max_k`.

 Parameters:
 a: int - First fibonacci number `F(k)-2`
 b: int - Second fibonacci number `F(k)-1`
 ck: int - Initial index `k` of the Fibonacci number `F(k)`
 max_k: int - Maximum index `k` of the Fibonacci number `F(k)`

 Returns:
 int - index `k` of the least `1-9 pandigital` Fibonacci number `F(k)`

 >>> slow_solution()
 329468
 """

 # Equivalent to 10**9, for getting no higher then 9 digit numbers
 billion = 1_000_000_000

 # Fibonacci numbers
 fk_2 = a # fk - 2
 fk_1 = b # fk - 1
 # fk # fk_1 + fk_2

 # Fibonacci numbers mod billion
 mk_2 = a % billion # (fk - 2) % billion
 mk_1 = b % billion # (fk - 1) % billion
 # mk # (fk ) % billion

 end_pandigital = [0] * max_k

 for x in range(9):
 if not check_last[x + 1]:
 f = False
 return f
 # Check fibonacci numbers % 10**9
 for k in range(ck, max_k):
 mk = (mk_2 + mk_1) % billion
 mk_2 = mk_1
 mk_1 = mk

 if is_pandigital_end(mk):
 end_pandigital[k] = 1

def solution() -> int:
 # Check fibonacci numbers
 for k in range(ck, max_k):
 fk = fk_2 + fk_1
 fk_2 = fk_1
 fk_1 = fk

 # perform check only if k is in end_pandigital
 if end_pandigital[k] and is_pandigital_both(fk):
 return k

 # Not found
 return -1


def solution(a: int = 1, b: int = 1, ck: int = 3, max_k: int = 10_00_000) -> int:
 """
 Outputs the answer is the least Fibonacci number pandigital from both sides.
 Returns index `k` of the least Fibonacci number `F(k)` that is `1-9 pandigital`
 from both sides. Here `ck <= k < max_k`.

 Parameters:
 a: int - First fibonacci number `F(k)-2`
 b: int - Second fibonacci number `F(k)-1`
 ck: int - Initial index `k` of the Fibonacci number `F(k)`
 max_k: int - Maximum index `k` of the Fibonacci number `F(k)`

 Returns:
 int - index `k` of the least `1-9 pandigital` Fibonacci number `F(k)`

 >>> solution()
 329468
 """

 a = 1
 b = 1
 c = 2
 # temporary Fibonacci numbers

 a1 = 1
 b1 = 1
 c1 = 2
 # temporary Fibonacci numbers mod 1e9

 # mod m=1e9, done for fast optimisation
 tocheck = [0] * 1000000
 m = 1000000000

 for x in range(1000000):
 c1 = (a1 + b1) % m
 a1 = b1 % m
 b1 = c1 % m
 if check1(b1):
 tocheck[x + 3] = 1

 for x in range(1000000):
 c = a + b
 a = b
 b = c
 # perform check only if in tocheck
 if tocheck[x + 3] and check(b):
 return x + 3 # first 2 already done
 # Equivalent to 10**9, for getting no higher then 9 digit numbers
 billion = 1_000_000_000

 # For reserving 9 digits (and a few more digits for carry) from the start
 billion_plus = billion * 1_000_000

 # Fibonacci numbers
 fk_2 = a # fk - 2
 fk_1 = b # fk - 1
 # fk # fk_1 + fk_2

 # Fibonacci numbers mod billion
 mk_2 = a % billion # (fk - 2) % billion
 mk_1 = b % billion # (fk - 1) % billion
 # mk # (fk ) % billion

 end_pandigital = [0] * max_k

 # Check fibonacci numbers % 10**9
 for k in range(ck, max_k):
 mk = (mk_2 + mk_1) % billion
 mk_2 = mk_1
 mk_1 = mk

 if is_pandigital_end(mk):
 end_pandigital[k] = 1

 # Check fibonacci numbers
 for k in range(ck, max_k):
 fk = fk_2 + fk_1
 fk_2 = fk_1
 fk_1 = fk

 # We don't care about the digits after the 9'th one
 # But still we need to keep some digits after after the 9'th
 # Because of carry
 if fk_2 > billion_plus:
 fk_1 //= 10
 fk_2 //= 10

 # perform check only if k is in end_pandigital
 if end_pandigital[k] and is_pandigital_start(fk):
 return k

 # Not found
 return -1


def benchmark() -> None:
 """
 Benchmark
 """
 # Running performance benchmarks...
 # Solution : 8.59146850000252 to 9.774559199999203
 # Slow Sol : 57.75938980000137 to 61.15365279999969

 from timeit import timeit

 print("Running performance benchmarks...")

 print(f"Solution : {timeit('solution()', globals=globals(), number=10)}")
 print(f"Slow Sol : {timeit('slow_solution()', globals=globals(), number=10)}")


if __name__ == "__main__":
 print(f"{solution() = }")
 benchmark()

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Strip utm_, fbclid, gclid, etc. from all links on page
(function() {
var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',
'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid',
'ref', 'ref_src', 'source', 'medium', 'campaign'];
function cleanUrl(url) {
try {
var u = new URL(url, window.location.origin);
var changed = false;
trackingParams.forEach(function(p) {
if (u.searchParams.has(p)) {
u.searchParams.delete(p);
changed = true;
}
});
return changed ? u.toString() : url;
} catch (e) {
return url;
}
}
function cleanLinks() {
document.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
cleanLinks();
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1) {
if (node.tagName === 'A') cleanLinks();
node.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Remove Tracking Parameters from Links]', __e); }
})();
(function(){
try {
var __m = "youtube.com";
var __re = new RegExp('^' + "youtube\\.com" + '
Performance and Refactor: 83% - 86% faster Project Euler 104 by ManpreetXSingh · Pull Request #10615 · TheAlgorithms/Python · GitHub
Skip to content
Performance and Refactor: 83% - 86% faster Project Euler 104#10615

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

 Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and
privacy statement. We’ll occasionally send you account related emails.

Already on GitHub?
Sign in
to your account

 Closed

ManpreetXSingh
wants to merge
11
commits into

from

 Closed


Performance and Refactor: 83% - 86% faster Project Euler 104
#10615
 Changes from all commits
Commits

Show all changes


11 commits


Select commit
Hold shift + click to select a range
367f9b3

Rename pandigital functions


ManpreetXSingh Oct 16, 2023
f58875d

Merge duplicated code in is_pandigital_both


ManpreetXSingh Oct 16, 2023
417ba28

Refactor is_pandigital_end


ManpreetXSingh Oct 16, 2023
6aa5b2a

Refactor solution


ManpreetXSingh Oct 16, 2023
14c7f08

Fix error prone range and element access


ManpreetXSingh Oct 16, 2023
8f845ab

Add function parameters in solution


ManpreetXSingh Oct 16, 2023
bdfc5a6

Update docstrings


ManpreetXSingh Oct 16, 2023
7d0a079

Fix ruff error. replace for loop with all()


ManpreetXSingh Oct 16, 2023
87b67ff

Separate is_pandigital_start from is_pandigital_both


ManpreetXSingh Oct 18, 2023
c2e2af8

Performance: Add fast solution


ManpreetXSingh Oct 18, 2023
3ffa801

Add performance benchmarks


ManpreetXSingh Oct 18, 2023

File filter

Filter by extension
Filter by extension
Conversations

Failed to load comments. 
Loading
Jump to

Jump to file


Failed to load files. 
Loading
 Diff view

 Diff view


247 changes: 169 additions & 78 deletions
project_euler/problem_104/sol1.py

View file


Open in desktop

Original file line numberDiff line numberDiff line change
Expand Up@@ -18,124 +18,215 @@
sys.set_int_max_str_digits(0) # type: ignore


def check(number: int) -> bool:
def is_pandigital_both(number: int) -> bool:
 """
Takes a number and checks if it is pandigital both from start and end
Checks if the first 9 and last 9 digits of a number are `1-9 pandigital`.

 Returns:
 bool - True if the first 9 and last 9 digits contain all the digits 1 to 9,
 False otherwise

 >>> check(123456789987654321)
 >>> is_pandigital_both(123456789987654321)
 True

 >>> check(120000987654321)
 >>> is_pandigital_both(120000987654321)
 False

 >>> check(1234567895765677987654321)
 >>> is_pandigital_both(1234567895765677987654321)
 True

 """

 check_last = [0] * 11
 check_front = [0] * 11
 return is_pandigital_end(number) and is_pandigital_start(number)

 # mark last 9 numbers
 for _ in range(9):
 check_last[int(number % 10)] = 1
 number = number // 10
 # flag
 f = True

 # check last 9 numbers for pandigitality
def is_pandigital_end(number: int) -> bool:
 """
 Checks if the last 9 digits of a number are `1-9 pandigital`.

 for x in range(9):
 if not check_last[x + 1]:
 f = False
 if not f:
 return f
 Returns:
 bool - True if the last 9 digits contain all the digits 1 to 9, False otherwise

# mark first 9 numbers
number = int(str(number)[:9])
>>> is_pandigital_end(123456789987654321)
True

 for _ in range(9):
 check_front[int(number % 10)] = 1
 number = number // 10
 >>> is_pandigital_end(120000987654321)
 True

 # check first 9 numbers for pandigitality
 >>> is_pandigital_end(12345678957656779870004321)
 False
 """
 digit_count = [True] + [False] * 9

 # Count the occurrences of each digit[0-9]
 for _ in range(9):
 number, mod = divmod(number, 10)
 if digit_count[mod]:
 return False
 digit_count[mod] = True

 for x in range(9):
 if not check_front[x + 1]:
 f = False
 return f
 # Return False if any digit is missing
 return all(digit_count[1:])


def check1(number: int) -> bool:
def is_pandigital_start(number: int) -> bool:
 """
Takes a number and checks if it is pandigital from END
Checks if the first 9 digits of a number are `1-9 pandigital`.

>>> check1(123456789987654321)
 True
Returns:
 bool - True if the first 9 digits contain all the digits 1 to 9, False otherwise

 >>> check1(120000987654321)
 >>> is_pandigital_start(123456789987654321)
 True

 >>> check1(12345678957656779870004321)
 >>> is_pandigital_start(120000987654321)
 False

 >>> is_pandigital_start(1234567895765677987654321)
 True
 """

 check_last = [0] * 11
 number = int(str(number)[:9])
 return is_pandigital_end(number)

 # mark last 9 numbers
 for _ in range(9):
 check_last[int(number % 10)] = 1
 number = number // 10
 # flag
 f = True

 # check last 9 numbers for pandigitality
def slow_solution(a: int = 1, b: int = 1, ck: int = 3, max_k: int = 10_00_000) -> int:
 """
 Returns index `k` of the least Fibonacci number `F(k)` that is `1-9 pandigital`
 from both sides. Here `ck <= k < max_k`.

 Parameters:
 a: int - First fibonacci number `F(k)-2`
 b: int - Second fibonacci number `F(k)-1`
 ck: int - Initial index `k` of the Fibonacci number `F(k)`
 max_k: int - Maximum index `k` of the Fibonacci number `F(k)`

 Returns:
 int - index `k` of the least `1-9 pandigital` Fibonacci number `F(k)`

 >>> slow_solution()
 329468
 """

 # Equivalent to 10**9, for getting no higher then 9 digit numbers
 billion = 1_000_000_000

 # Fibonacci numbers
 fk_2 = a # fk - 2
 fk_1 = b # fk - 1
 # fk # fk_1 + fk_2

 # Fibonacci numbers mod billion
 mk_2 = a % billion # (fk - 2) % billion
 mk_1 = b % billion # (fk - 1) % billion
 # mk # (fk ) % billion

 end_pandigital = [0] * max_k

 for x in range(9):
 if not check_last[x + 1]:
 f = False
 return f
 # Check fibonacci numbers % 10**9
 for k in range(ck, max_k):
 mk = (mk_2 + mk_1) % billion
 mk_2 = mk_1
 mk_1 = mk

 if is_pandigital_end(mk):
 end_pandigital[k] = 1

def solution() -> int:
 # Check fibonacci numbers
 for k in range(ck, max_k):
 fk = fk_2 + fk_1
 fk_2 = fk_1
 fk_1 = fk

 # perform check only if k is in end_pandigital
 if end_pandigital[k] and is_pandigital_both(fk):
 return k

 # Not found
 return -1


def solution(a: int = 1, b: int = 1, ck: int = 3, max_k: int = 10_00_000) -> int:
 """
 Outputs the answer is the least Fibonacci number pandigital from both sides.
 Returns index `k` of the least Fibonacci number `F(k)` that is `1-9 pandigital`
 from both sides. Here `ck <= k < max_k`.

 Parameters:
 a: int - First fibonacci number `F(k)-2`
 b: int - Second fibonacci number `F(k)-1`
 ck: int - Initial index `k` of the Fibonacci number `F(k)`
 max_k: int - Maximum index `k` of the Fibonacci number `F(k)`

 Returns:
 int - index `k` of the least `1-9 pandigital` Fibonacci number `F(k)`

 >>> solution()
 329468
 """

 a = 1
 b = 1
 c = 2
 # temporary Fibonacci numbers

 a1 = 1
 b1 = 1
 c1 = 2
 # temporary Fibonacci numbers mod 1e9

 # mod m=1e9, done for fast optimisation
 tocheck = [0] * 1000000
 m = 1000000000

 for x in range(1000000):
 c1 = (a1 + b1) % m
 a1 = b1 % m
 b1 = c1 % m
 if check1(b1):
 tocheck[x + 3] = 1

 for x in range(1000000):
 c = a + b
 a = b
 b = c
 # perform check only if in tocheck
 if tocheck[x + 3] and check(b):
 return x + 3 # first 2 already done
 # Equivalent to 10**9, for getting no higher then 9 digit numbers
 billion = 1_000_000_000

 # For reserving 9 digits (and a few more digits for carry) from the start
 billion_plus = billion * 1_000_000

 # Fibonacci numbers
 fk_2 = a # fk - 2
 fk_1 = b # fk - 1
 # fk # fk_1 + fk_2

 # Fibonacci numbers mod billion
 mk_2 = a % billion # (fk - 2) % billion
 mk_1 = b % billion # (fk - 1) % billion
 # mk # (fk ) % billion

 end_pandigital = [0] * max_k

 # Check fibonacci numbers % 10**9
 for k in range(ck, max_k):
 mk = (mk_2 + mk_1) % billion
 mk_2 = mk_1
 mk_1 = mk

 if is_pandigital_end(mk):
 end_pandigital[k] = 1

 # Check fibonacci numbers
 for k in range(ck, max_k):
 fk = fk_2 + fk_1
 fk_2 = fk_1
 fk_1 = fk

 # We don't care about the digits after the 9'th one
 # But still we need to keep some digits after after the 9'th
 # Because of carry
 if fk_2 > billion_plus:
 fk_1 //= 10
 fk_2 //= 10

 # perform check only if k is in end_pandigital
 if end_pandigital[k] and is_pandigital_start(fk):
 return k

 # Not found
 return -1


def benchmark() -> None:
 """
 Benchmark
 """
 # Running performance benchmarks...
 # Solution : 8.59146850000252 to 9.774559199999203
 # Slow Sol : 57.75938980000137 to 61.15365279999969

 from timeit import timeit

 print("Running performance benchmarks...")

 print(f"Solution : {timeit('solution()', globals=globals(), number=10)}")
 print(f"Slow Sol : {timeit('slow_solution()', globals=globals(), number=10)}")


if __name__ == "__main__":
 print(f"{solution() = }")
 benchmark()

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Auto-enable theater mode on YouTube
(function() {
function tryTheater() {
var btn = document.querySelector('button[aria-label="Theater mode"], ytd-player #player button[title="Theater mode"]');
if (btn && !btn.classList.contains('activated')) {
btn.click();
}
}
// Try immediately
tryTheater();
// Try after navigation (SPA)
var lastUrl = location.href;
setInterval(function() {
if (location.href !== lastUrl) {
lastUrl = location.href;
setTimeout(tryTheater, 500);
}
}, 1000);
// Also try on player load
var observer = new MutationObserver(tryTheater);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:YouTube Theater Mode Default]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
Performance and Refactor: 83% - 86% faster Project Euler 104 by ManpreetXSingh · Pull Request #10615 · TheAlgorithms/Python · GitHub
Skip to content
Performance and Refactor: 83% - 86% faster Project Euler 104#10615

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

 Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and
privacy statement. We’ll occasionally send you account related emails.

Already on GitHub?
Sign in
to your account

 Closed

ManpreetXSingh
wants to merge
11
commits into

from

 Closed


Performance and Refactor: 83% - 86% faster Project Euler 104
#10615
 Changes from all commits
Commits

Show all changes


11 commits


Select commit
Hold shift + click to select a range
367f9b3

Rename pandigital functions


ManpreetXSingh Oct 16, 2023
f58875d

Merge duplicated code in is_pandigital_both


ManpreetXSingh Oct 16, 2023
417ba28

Refactor is_pandigital_end


ManpreetXSingh Oct 16, 2023
6aa5b2a

Refactor solution


ManpreetXSingh Oct 16, 2023
14c7f08

Fix error prone range and element access


ManpreetXSingh Oct 16, 2023
8f845ab

Add function parameters in solution


ManpreetXSingh Oct 16, 2023
bdfc5a6

Update docstrings


ManpreetXSingh Oct 16, 2023
7d0a079

Fix ruff error. replace for loop with all()


ManpreetXSingh Oct 16, 2023
87b67ff

Separate is_pandigital_start from is_pandigital_both


ManpreetXSingh Oct 18, 2023
c2e2af8

Performance: Add fast solution


ManpreetXSingh Oct 18, 2023
3ffa801

Add performance benchmarks


ManpreetXSingh Oct 18, 2023

File filter

Filter by extension
Filter by extension
Conversations

Failed to load comments. 
Loading
Jump to

Jump to file


Failed to load files. 
Loading
 Diff view

 Diff view


247 changes: 169 additions & 78 deletions
project_euler/problem_104/sol1.py

View file


Open in desktop

Original file line numberDiff line numberDiff line change
Expand Up@@ -18,124 +18,215 @@
sys.set_int_max_str_digits(0) # type: ignore


def check(number: int) -> bool:
def is_pandigital_both(number: int) -> bool:
 """
Takes a number and checks if it is pandigital both from start and end
Checks if the first 9 and last 9 digits of a number are `1-9 pandigital`.

 Returns:
 bool - True if the first 9 and last 9 digits contain all the digits 1 to 9,
 False otherwise

 >>> check(123456789987654321)
 >>> is_pandigital_both(123456789987654321)
 True

 >>> check(120000987654321)
 >>> is_pandigital_both(120000987654321)
 False

 >>> check(1234567895765677987654321)
 >>> is_pandigital_both(1234567895765677987654321)
 True

 """

 check_last = [0] * 11
 check_front = [0] * 11
 return is_pandigital_end(number) and is_pandigital_start(number)

 # mark last 9 numbers
 for _ in range(9):
 check_last[int(number % 10)] = 1
 number = number // 10
 # flag
 f = True

 # check last 9 numbers for pandigitality
def is_pandigital_end(number: int) -> bool:
 """
 Checks if the last 9 digits of a number are `1-9 pandigital`.

 for x in range(9):
 if not check_last[x + 1]:
 f = False
 if not f:
 return f
 Returns:
 bool - True if the last 9 digits contain all the digits 1 to 9, False otherwise

# mark first 9 numbers
number = int(str(number)[:9])
>>> is_pandigital_end(123456789987654321)
True

 for _ in range(9):
 check_front[int(number % 10)] = 1
 number = number // 10
 >>> is_pandigital_end(120000987654321)
 True

 # check first 9 numbers for pandigitality
 >>> is_pandigital_end(12345678957656779870004321)
 False
 """
 digit_count = [True] + [False] * 9

 # Count the occurrences of each digit[0-9]
 for _ in range(9):
 number, mod = divmod(number, 10)
 if digit_count[mod]:
 return False
 digit_count[mod] = True

 for x in range(9):
 if not check_front[x + 1]:
 f = False
 return f
 # Return False if any digit is missing
 return all(digit_count[1:])


def check1(number: int) -> bool:
def is_pandigital_start(number: int) -> bool:
 """
Takes a number and checks if it is pandigital from END
Checks if the first 9 digits of a number are `1-9 pandigital`.

>>> check1(123456789987654321)
 True
Returns:
 bool - True if the first 9 digits contain all the digits 1 to 9, False otherwise

 >>> check1(120000987654321)
 >>> is_pandigital_start(123456789987654321)
 True

 >>> check1(12345678957656779870004321)
 >>> is_pandigital_start(120000987654321)
 False

 >>> is_pandigital_start(1234567895765677987654321)
 True
 """

 check_last = [0] * 11
 number = int(str(number)[:9])
 return is_pandigital_end(number)

 # mark last 9 numbers
 for _ in range(9):
 check_last[int(number % 10)] = 1
 number = number // 10
 # flag
 f = True

 # check last 9 numbers for pandigitality
def slow_solution(a: int = 1, b: int = 1, ck: int = 3, max_k: int = 10_00_000) -> int:
 """
 Returns index `k` of the least Fibonacci number `F(k)` that is `1-9 pandigital`
 from both sides. Here `ck <= k < max_k`.

 Parameters:
 a: int - First fibonacci number `F(k)-2`
 b: int - Second fibonacci number `F(k)-1`
 ck: int - Initial index `k` of the Fibonacci number `F(k)`
 max_k: int - Maximum index `k` of the Fibonacci number `F(k)`

 Returns:
 int - index `k` of the least `1-9 pandigital` Fibonacci number `F(k)`

 >>> slow_solution()
 329468
 """

 # Equivalent to 10**9, for getting no higher then 9 digit numbers
 billion = 1_000_000_000

 # Fibonacci numbers
 fk_2 = a # fk - 2
 fk_1 = b # fk - 1
 # fk # fk_1 + fk_2

 # Fibonacci numbers mod billion
 mk_2 = a % billion # (fk - 2) % billion
 mk_1 = b % billion # (fk - 1) % billion
 # mk # (fk ) % billion

 end_pandigital = [0] * max_k

 for x in range(9):
 if not check_last[x + 1]:
 f = False
 return f
 # Check fibonacci numbers % 10**9
 for k in range(ck, max_k):
 mk = (mk_2 + mk_1) % billion
 mk_2 = mk_1
 mk_1 = mk

 if is_pandigital_end(mk):
 end_pandigital[k] = 1

def solution() -> int:
 # Check fibonacci numbers
 for k in range(ck, max_k):
 fk = fk_2 + fk_1
 fk_2 = fk_1
 fk_1 = fk

 # perform check only if k is in end_pandigital
 if end_pandigital[k] and is_pandigital_both(fk):
 return k

 # Not found
 return -1


def solution(a: int = 1, b: int = 1, ck: int = 3, max_k: int = 10_00_000) -> int:
 """
 Outputs the answer is the least Fibonacci number pandigital from both sides.
 Returns index `k` of the least Fibonacci number `F(k)` that is `1-9 pandigital`
 from both sides. Here `ck <= k < max_k`.

 Parameters:
 a: int - First fibonacci number `F(k)-2`
 b: int - Second fibonacci number `F(k)-1`
 ck: int - Initial index `k` of the Fibonacci number `F(k)`
 max_k: int - Maximum index `k` of the Fibonacci number `F(k)`

 Returns:
 int - index `k` of the least `1-9 pandigital` Fibonacci number `F(k)`

 >>> solution()
 329468
 """

 a = 1
 b = 1
 c = 2
 # temporary Fibonacci numbers

 a1 = 1
 b1 = 1
 c1 = 2
 # temporary Fibonacci numbers mod 1e9

 # mod m=1e9, done for fast optimisation
 tocheck = [0] * 1000000
 m = 1000000000

 for x in range(1000000):
 c1 = (a1 + b1) % m
 a1 = b1 % m
 b1 = c1 % m
 if check1(b1):
 tocheck[x + 3] = 1

 for x in range(1000000):
 c = a + b
 a = b
 b = c
 # perform check only if in tocheck
 if tocheck[x + 3] and check(b):
 return x + 3 # first 2 already done
 # Equivalent to 10**9, for getting no higher then 9 digit numbers
 billion = 1_000_000_000

 # For reserving 9 digits (and a few more digits for carry) from the start
 billion_plus = billion * 1_000_000

 # Fibonacci numbers
 fk_2 = a # fk - 2
 fk_1 = b # fk - 1
 # fk # fk_1 + fk_2

 # Fibonacci numbers mod billion
 mk_2 = a % billion # (fk - 2) % billion
 mk_1 = b % billion # (fk - 1) % billion
 # mk # (fk ) % billion

 end_pandigital = [0] * max_k

 # Check fibonacci numbers % 10**9
 for k in range(ck, max_k):
 mk = (mk_2 + mk_1) % billion
 mk_2 = mk_1
 mk_1 = mk

 if is_pandigital_end(mk):
 end_pandigital[k] = 1

 # Check fibonacci numbers
 for k in range(ck, max_k):
 fk = fk_2 + fk_1
 fk_2 = fk_1
 fk_1 = fk

 # We don't care about the digits after the 9'th one
 # But still we need to keep some digits after after the 9'th
 # Because of carry
 if fk_2 > billion_plus:
 fk_1 //= 10
 fk_2 //= 10

 # perform check only if k is in end_pandigital
 if end_pandigital[k] and is_pandigital_start(fk):
 return k

 # Not found
 return -1


def benchmark() -> None:
 """
 Benchmark
 """
 # Running performance benchmarks...
 # Solution : 8.59146850000252 to 9.774559199999203
 # Slow Sol : 57.75938980000137 to 61.15365279999969

 from timeit import timeit

 print("Running performance benchmarks...")

 print(f"Solution : {timeit('solution()', globals=globals(), number=10)}")
 print(f"Slow Sol : {timeit('slow_solution()', globals=globals(), number=10)}")


if __name__ == "__main__":
 print(f"{solution() = }")
 benchmark()

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Remove or un-stick sticky/fixed headers that block content
(function() {
function unstick() {
document.querySelectorAll('header, nav, [role="banner"], .header, .navbar, .sticky, .fixed-top, [style*="position: fixed"], [style*="position:sticky"]').forEach(function(el) {
if (el.style.position === 'fixed' || el.style.position === 'sticky' || getComputedStyle(el).position === 'fixed' || getComputedStyle(el).position === 'sticky') {
el.style.position = 'static';
el.style.top = 'auto';
el.style.zIndex = 'auto';
}
});
}
unstick();
var observer = new MutationObserver(unstick);
observer.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['style', 'class'] });
})();
}
} catch(__e) { console.warn('[Userscript:Kill Sticky Headers]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
Performance and Refactor: 83% - 86% faster Project Euler 104 by ManpreetXSingh · Pull Request #10615 · TheAlgorithms/Python · GitHub
Skip to content
Performance and Refactor: 83% - 86% faster Project Euler 104#10615

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

 Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and
privacy statement. We’ll occasionally send you account related emails.

Already on GitHub?
Sign in
to your account

 Closed

ManpreetXSingh
wants to merge
11
commits into

from

 Closed


Performance and Refactor: 83% - 86% faster Project Euler 104
#10615
 Changes from all commits
Commits

Show all changes


11 commits


Select commit
Hold shift + click to select a range
367f9b3

Rename pandigital functions


ManpreetXSingh Oct 16, 2023
f58875d

Merge duplicated code in is_pandigital_both


ManpreetXSingh Oct 16, 2023
417ba28

Refactor is_pandigital_end


ManpreetXSingh Oct 16, 2023
6aa5b2a

Refactor solution


ManpreetXSingh Oct 16, 2023
14c7f08

Fix error prone range and element access


ManpreetXSingh Oct 16, 2023
8f845ab

Add function parameters in solution


ManpreetXSingh Oct 16, 2023
bdfc5a6

Update docstrings


ManpreetXSingh Oct 16, 2023
7d0a079

Fix ruff error. replace for loop with all()


ManpreetXSingh Oct 16, 2023
87b67ff

Separate is_pandigital_start from is_pandigital_both


ManpreetXSingh Oct 18, 2023
c2e2af8

Performance: Add fast solution


ManpreetXSingh Oct 18, 2023
3ffa801

Add performance benchmarks


ManpreetXSingh Oct 18, 2023

File filter

Filter by extension
Filter by extension
Conversations

Failed to load comments. 
Loading
Jump to

Jump to file


Failed to load files. 
Loading
 Diff view

 Diff view


247 changes: 169 additions & 78 deletions
project_euler/problem_104/sol1.py

View file


Open in desktop

Original file line numberDiff line numberDiff line change
Expand Up@@ -18,124 +18,215 @@
sys.set_int_max_str_digits(0) # type: ignore


def check(number: int) -> bool:
def is_pandigital_both(number: int) -> bool:
 """
Takes a number and checks if it is pandigital both from start and end
Checks if the first 9 and last 9 digits of a number are `1-9 pandigital`.

 Returns:
 bool - True if the first 9 and last 9 digits contain all the digits 1 to 9,
 False otherwise

 >>> check(123456789987654321)
 >>> is_pandigital_both(123456789987654321)
 True

 >>> check(120000987654321)
 >>> is_pandigital_both(120000987654321)
 False

 >>> check(1234567895765677987654321)
 >>> is_pandigital_both(1234567895765677987654321)
 True

 """

 check_last = [0] * 11
 check_front = [0] * 11
 return is_pandigital_end(number) and is_pandigital_start(number)

 # mark last 9 numbers
 for _ in range(9):
 check_last[int(number % 10)] = 1
 number = number // 10
 # flag
 f = True

 # check last 9 numbers for pandigitality
def is_pandigital_end(number: int) -> bool:
 """
 Checks if the last 9 digits of a number are `1-9 pandigital`.

 for x in range(9):
 if not check_last[x + 1]:
 f = False
 if not f:
 return f
 Returns:
 bool - True if the last 9 digits contain all the digits 1 to 9, False otherwise

# mark first 9 numbers
number = int(str(number)[:9])
>>> is_pandigital_end(123456789987654321)
True

 for _ in range(9):
 check_front[int(number % 10)] = 1
 number = number // 10
 >>> is_pandigital_end(120000987654321)
 True

 # check first 9 numbers for pandigitality
 >>> is_pandigital_end(12345678957656779870004321)
 False
 """
 digit_count = [True] + [False] * 9

 # Count the occurrences of each digit[0-9]
 for _ in range(9):
 number, mod = divmod(number, 10)
 if digit_count[mod]:
 return False
 digit_count[mod] = True

 for x in range(9):
 if not check_front[x + 1]:
 f = False
 return f
 # Return False if any digit is missing
 return all(digit_count[1:])


def check1(number: int) -> bool:
def is_pandigital_start(number: int) -> bool:
 """
Takes a number and checks if it is pandigital from END
Checks if the first 9 digits of a number are `1-9 pandigital`.

>>> check1(123456789987654321)
 True
Returns:
 bool - True if the first 9 digits contain all the digits 1 to 9, False otherwise

 >>> check1(120000987654321)
 >>> is_pandigital_start(123456789987654321)
 True

 >>> check1(12345678957656779870004321)
 >>> is_pandigital_start(120000987654321)
 False

 >>> is_pandigital_start(1234567895765677987654321)
 True
 """

 check_last = [0] * 11
 number = int(str(number)[:9])
 return is_pandigital_end(number)

 # mark last 9 numbers
 for _ in range(9):
 check_last[int(number % 10)] = 1
 number = number // 10
 # flag
 f = True

 # check last 9 numbers for pandigitality
def slow_solution(a: int = 1, b: int = 1, ck: int = 3, max_k: int = 10_00_000) -> int:
 """
 Returns index `k` of the least Fibonacci number `F(k)` that is `1-9 pandigital`
 from both sides. Here `ck <= k < max_k`.

 Parameters:
 a: int - First fibonacci number `F(k)-2`
 b: int - Second fibonacci number `F(k)-1`
 ck: int - Initial index `k` of the Fibonacci number `F(k)`
 max_k: int - Maximum index `k` of the Fibonacci number `F(k)`

 Returns:
 int - index `k` of the least `1-9 pandigital` Fibonacci number `F(k)`

 >>> slow_solution()
 329468
 """

 # Equivalent to 10**9, for getting no higher then 9 digit numbers
 billion = 1_000_000_000

 # Fibonacci numbers
 fk_2 = a # fk - 2
 fk_1 = b # fk - 1
 # fk # fk_1 + fk_2

 # Fibonacci numbers mod billion
 mk_2 = a % billion # (fk - 2) % billion
 mk_1 = b % billion # (fk - 1) % billion
 # mk # (fk ) % billion

 end_pandigital = [0] * max_k

 for x in range(9):
 if not check_last[x + 1]:
 f = False
 return f
 # Check fibonacci numbers % 10**9
 for k in range(ck, max_k):
 mk = (mk_2 + mk_1) % billion
 mk_2 = mk_1
 mk_1 = mk

 if is_pandigital_end(mk):
 end_pandigital[k] = 1

def solution() -> int:
 # Check fibonacci numbers
 for k in range(ck, max_k):
 fk = fk_2 + fk_1
 fk_2 = fk_1
 fk_1 = fk

 # perform check only if k is in end_pandigital
 if end_pandigital[k] and is_pandigital_both(fk):
 return k

 # Not found
 return -1


def solution(a: int = 1, b: int = 1, ck: int = 3, max_k: int = 10_00_000) -> int:
 """
 Outputs the answer is the least Fibonacci number pandigital from both sides.
 Returns index `k` of the least Fibonacci number `F(k)` that is `1-9 pandigital`
 from both sides. Here `ck <= k < max_k`.

 Parameters:
 a: int - First fibonacci number `F(k)-2`
 b: int - Second fibonacci number `F(k)-1`
 ck: int - Initial index `k` of the Fibonacci number `F(k)`
 max_k: int - Maximum index `k` of the Fibonacci number `F(k)`

 Returns:
 int - index `k` of the least `1-9 pandigital` Fibonacci number `F(k)`

 >>> solution()
 329468
 """

 a = 1
 b = 1
 c = 2
 # temporary Fibonacci numbers

 a1 = 1
 b1 = 1
 c1 = 2
 # temporary Fibonacci numbers mod 1e9

 # mod m=1e9, done for fast optimisation
 tocheck = [0] * 1000000
 m = 1000000000

 for x in range(1000000):
 c1 = (a1 + b1) % m
 a1 = b1 % m
 b1 = c1 % m
 if check1(b1):
 tocheck[x + 3] = 1

 for x in range(1000000):
 c = a + b
 a = b
 b = c
 # perform check only if in tocheck
 if tocheck[x + 3] and check(b):
 return x + 3 # first 2 already done
 # Equivalent to 10**9, for getting no higher then 9 digit numbers
 billion = 1_000_000_000

 # For reserving 9 digits (and a few more digits for carry) from the start
 billion_plus = billion * 1_000_000

 # Fibonacci numbers
 fk_2 = a # fk - 2
 fk_1 = b # fk - 1
 # fk # fk_1 + fk_2

 # Fibonacci numbers mod billion
 mk_2 = a % billion # (fk - 2) % billion
 mk_1 = b % billion # (fk - 1) % billion
 # mk # (fk ) % billion

 end_pandigital = [0] * max_k

 # Check fibonacci numbers % 10**9
 for k in range(ck, max_k):
 mk = (mk_2 + mk_1) % billion
 mk_2 = mk_1
 mk_1 = mk

 if is_pandigital_end(mk):
 end_pandigital[k] = 1

 # Check fibonacci numbers
 for k in range(ck, max_k):
 fk = fk_2 + fk_1
 fk_2 = fk_1
 fk_1 = fk

 # We don't care about the digits after the 9'th one
 # But still we need to keep some digits after after the 9'th
 # Because of carry
 if fk_2 > billion_plus:
 fk_1 //= 10
 fk_2 //= 10

 # perform check only if k is in end_pandigital
 if end_pandigital[k] and is_pandigital_start(fk):
 return k

 # Not found
 return -1


def benchmark() -> None:
 """
 Benchmark
 """
 # Running performance benchmarks...
 # Solution : 8.59146850000252 to 9.774559199999203
 # Slow Sol : 57.75938980000137 to 61.15365279999969

 from timeit import timeit

 print("Running performance benchmarks...")

 print(f"Solution : {timeit('solution()', globals=globals(), number=10)}")
 print(f"Slow Sol : {timeit('slow_solution()', globals=globals(), number=10)}")


if __name__ == "__main__":
 print(f"{solution() = }")
 benchmark()

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Universal Dark Mode - works on any site
(function() {
var enabled = true;
function applyDarkMode() {
if (!enabled) return;
// Create style element if it doesn't exist
var style = document.getElementById('universal-dark-mode-style');
if (!style) {
style = document.createElement('style');
style.id = 'universal-dark-mode-style';
document.head.appendChild(style);
}
// Dark mode CSS - inverts colors but preserves images/video
style.textContent = '
/* Invert everything except media */
html {
filter: invert(1) hue-rotate(180deg) !important;
background: #1a1a2e !important;
}
/* Restore images, videos, iframes, canvas */
img, video, iframe, canvas, svg, picture, [style*="background-image"] {
filter: invert(1) hue-rotate(180deg) !important;
}
/* Preserve specific elements that should not be inverted */
.no-dark-mode, .no-dark-mode *,
[data-theme="light"], [data-theme="light"],
.ace_editor, .ace_editor *,
.CodeMirror, .CodeMirror *,
.monaco-editor, .monaco-editor *,
.markdown-body pre, .markdown-body pre *,
.highlight, .highlight *,
pre code, pre code * {
filter: none !important;
}
/* Fix common UI elements */
.modal, .popup, .dropdown-menu, .tooltip, .popover {
filter: invert(1) hue-rotate(180deg) !important;
background: #2d2d44 !important;
border-color: #444 !important;
}
/* Scrollbars */
::-webkit-scrollbar { background: #1a1a2e !important; }
::-webkit-scrollbar-thumb { background: #444 !important; }
::-webkit-scrollbar-thumb:hover { background: #555 !important; }
/* Selection */
::selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
::-moz-selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
';
}
function removeDarkMode() {
var style = document.getElementById('universal-dark-mode-style');
if (style) style.remove();
}
// Toggle with Alt+Shift+D
document.addEventListener('keydown', function(e) {
if (e.altKey && e.shiftKey && e.key === 'D') {
e.preventDefault();
enabled = !enabled;
if (enabled) {
applyDarkMode();
console.log('[Universal Dark Mode] Enabled');
} else {
removeDarkMode();
console.log('[Universal Dark Mode] Disabled');
}
}
});
// Apply on load
applyDarkMode();
// Re-apply on dynamic content
var observer = new MutationObserver(function(mutations) {
if (enabled && !document.getElementById('universal-dark-mode-style')) {
applyDarkMode();
}
});
observer.observe(document.head, { childList: true });
console.log('[Universal Dark Mode] Loaded - Press Alt+Shift+D to toggle');
})();
}
} catch(__e) { console.warn('[Userscript:Universal Dark Mode]', __e); }
})();
})();
Performance and Refactor: 83% - 86% faster Project Euler 104 by ManpreetXSingh · Pull Request #10615 · TheAlgorithms/Python · GitHub
Skip to content
Performance and Refactor: 83% - 86% faster Project Euler 104#10615

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

 Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and
privacy statement. We’ll occasionally send you account related emails.

Already on GitHub?
Sign in
to your account

 Closed

ManpreetXSingh
wants to merge
11
commits into

from

 Closed


Performance and Refactor: 83% - 86% faster Project Euler 104
#10615
 Changes from all commits
Commits

Show all changes


11 commits


Select commit
Hold shift + click to select a range
367f9b3

Rename pandigital functions


ManpreetXSingh Oct 16, 2023
f58875d

Merge duplicated code in is_pandigital_both


ManpreetXSingh Oct 16, 2023
417ba28

Refactor is_pandigital_end


ManpreetXSingh Oct 16, 2023
6aa5b2a

Refactor solution


ManpreetXSingh Oct 16, 2023
14c7f08

Fix error prone range and element access


ManpreetXSingh Oct 16, 2023
8f845ab

Add function parameters in solution


ManpreetXSingh Oct 16, 2023
bdfc5a6

Update docstrings


ManpreetXSingh Oct 16, 2023
7d0a079

Fix ruff error. replace for loop with all()


ManpreetXSingh Oct 16, 2023
87b67ff

Separate is_pandigital_start from is_pandigital_both


ManpreetXSingh Oct 18, 2023
c2e2af8

Performance: Add fast solution


ManpreetXSingh Oct 18, 2023
3ffa801

Add performance benchmarks


ManpreetXSingh Oct 18, 2023

File filter

Filter by extension
Filter by extension
Conversations

Failed to load comments. 
Loading
Jump to

Jump to file


Failed to load files. 
Loading
 Diff view

 Diff view


247 changes: 169 additions & 78 deletions
project_euler/problem_104/sol1.py

View file


Open in desktop

Original file line numberDiff line numberDiff line change
Expand Up@@ -18,124 +18,215 @@
sys.set_int_max_str_digits(0) # type: ignore


def check(number: int) -> bool:
def is_pandigital_both(number: int) -> bool:
 """
Takes a number and checks if it is pandigital both from start and end
Checks if the first 9 and last 9 digits of a number are `1-9 pandigital`.

 Returns:
 bool - True if the first 9 and last 9 digits contain all the digits 1 to 9,
 False otherwise

 >>> check(123456789987654321)
 >>> is_pandigital_both(123456789987654321)
 True

 >>> check(120000987654321)
 >>> is_pandigital_both(120000987654321)
 False

 >>> check(1234567895765677987654321)
 >>> is_pandigital_both(1234567895765677987654321)
 True

 """

 check_last = [0] * 11
 check_front = [0] * 11
 return is_pandigital_end(number) and is_pandigital_start(number)

 # mark last 9 numbers
 for _ in range(9):
 check_last[int(number % 10)] = 1
 number = number // 10
 # flag
 f = True

 # check last 9 numbers for pandigitality
def is_pandigital_end(number: int) -> bool:
 """
 Checks if the last 9 digits of a number are `1-9 pandigital`.

 for x in range(9):
 if not check_last[x + 1]:
 f = False
 if not f:
 return f
 Returns:
 bool - True if the last 9 digits contain all the digits 1 to 9, False otherwise

# mark first 9 numbers
number = int(str(number)[:9])
>>> is_pandigital_end(123456789987654321)
True

 for _ in range(9):
 check_front[int(number % 10)] = 1
 number = number // 10
 >>> is_pandigital_end(120000987654321)
 True

 # check first 9 numbers for pandigitality
 >>> is_pandigital_end(12345678957656779870004321)
 False
 """
 digit_count = [True] + [False] * 9

 # Count the occurrences of each digit[0-9]
 for _ in range(9):
 number, mod = divmod(number, 10)
 if digit_count[mod]:
 return False
 digit_count[mod] = True

 for x in range(9):
 if not check_front[x + 1]:
 f = False
 return f
 # Return False if any digit is missing
 return all(digit_count[1:])


def check1(number: int) -> bool:
def is_pandigital_start(number: int) -> bool:
 """
Takes a number and checks if it is pandigital from END
Checks if the first 9 digits of a number are `1-9 pandigital`.

>>> check1(123456789987654321)
 True
Returns:
 bool - True if the first 9 digits contain all the digits 1 to 9, False otherwise

 >>> check1(120000987654321)
 >>> is_pandigital_start(123456789987654321)
 True

 >>> check1(12345678957656779870004321)
 >>> is_pandigital_start(120000987654321)
 False

 >>> is_pandigital_start(1234567895765677987654321)
 True
 """

 check_last = [0] * 11
 number = int(str(number)[:9])
 return is_pandigital_end(number)

 # mark last 9 numbers
 for _ in range(9):
 check_last[int(number % 10)] = 1
 number = number // 10
 # flag
 f = True

 # check last 9 numbers for pandigitality
def slow_solution(a: int = 1, b: int = 1, ck: int = 3, max_k: int = 10_00_000) -> int:
 """
 Returns index `k` of the least Fibonacci number `F(k)` that is `1-9 pandigital`
 from both sides. Here `ck <= k < max_k`.

 Parameters:
 a: int - First fibonacci number `F(k)-2`
 b: int - Second fibonacci number `F(k)-1`
 ck: int - Initial index `k` of the Fibonacci number `F(k)`
 max_k: int - Maximum index `k` of the Fibonacci number `F(k)`

 Returns:
 int - index `k` of the least `1-9 pandigital` Fibonacci number `F(k)`

 >>> slow_solution()
 329468
 """

 # Equivalent to 10**9, for getting no higher then 9 digit numbers
 billion = 1_000_000_000

 # Fibonacci numbers
 fk_2 = a # fk - 2
 fk_1 = b # fk - 1
 # fk # fk_1 + fk_2

 # Fibonacci numbers mod billion
 mk_2 = a % billion # (fk - 2) % billion
 mk_1 = b % billion # (fk - 1) % billion
 # mk # (fk ) % billion

 end_pandigital = [0] * max_k

 for x in range(9):
 if not check_last[x + 1]:
 f = False
 return f
 # Check fibonacci numbers % 10**9
 for k in range(ck, max_k):
 mk = (mk_2 + mk_1) % billion
 mk_2 = mk_1
 mk_1 = mk

 if is_pandigital_end(mk):
 end_pandigital[k] = 1

def solution() -> int:
 # Check fibonacci numbers
 for k in range(ck, max_k):
 fk = fk_2 + fk_1
 fk_2 = fk_1
 fk_1 = fk

 # perform check only if k is in end_pandigital
 if end_pandigital[k] and is_pandigital_both(fk):
 return k

 # Not found
 return -1


def solution(a: int = 1, b: int = 1, ck: int = 3, max_k: int = 10_00_000) -> int:
 """
 Outputs the answer is the least Fibonacci number pandigital from both sides.
 Returns index `k` of the least Fibonacci number `F(k)` that is `1-9 pandigital`
 from both sides. Here `ck <= k < max_k`.

 Parameters:
 a: int - First fibonacci number `F(k)-2`
 b: int - Second fibonacci number `F(k)-1`
 ck: int - Initial index `k` of the Fibonacci number `F(k)`
 max_k: int - Maximum index `k` of the Fibonacci number `F(k)`

 Returns:
 int - index `k` of the least `1-9 pandigital` Fibonacci number `F(k)`

 >>> solution()
 329468
 """

 a = 1
 b = 1
 c = 2
 # temporary Fibonacci numbers

 a1 = 1
 b1 = 1
 c1 = 2
 # temporary Fibonacci numbers mod 1e9

 # mod m=1e9, done for fast optimisation
 tocheck = [0] * 1000000
 m = 1000000000

 for x in range(1000000):
 c1 = (a1 + b1) % m
 a1 = b1 % m
 b1 = c1 % m
 if check1(b1):
 tocheck[x + 3] = 1

 for x in range(1000000):
 c = a + b
 a = b
 b = c
 # perform check only if in tocheck
 if tocheck[x + 3] and check(b):
 return x + 3 # first 2 already done
 # Equivalent to 10**9, for getting no higher then 9 digit numbers
 billion = 1_000_000_000

 # For reserving 9 digits (and a few more digits for carry) from the start
 billion_plus = billion * 1_000_000

 # Fibonacci numbers
 fk_2 = a # fk - 2
 fk_1 = b # fk - 1
 # fk # fk_1 + fk_2

 # Fibonacci numbers mod billion
 mk_2 = a % billion # (fk - 2) % billion
 mk_1 = b % billion # (fk - 1) % billion
 # mk # (fk ) % billion

 end_pandigital = [0] * max_k

 # Check fibonacci numbers % 10**9
 for k in range(ck, max_k):
 mk = (mk_2 + mk_1) % billion
 mk_2 = mk_1
 mk_1 = mk

 if is_pandigital_end(mk):
 end_pandigital[k] = 1

 # Check fibonacci numbers
 for k in range(ck, max_k):
 fk = fk_2 + fk_1
 fk_2 = fk_1
 fk_1 = fk

 # We don't care about the digits after the 9'th one
 # But still we need to keep some digits after after the 9'th
 # Because of carry
 if fk_2 > billion_plus:
 fk_1 //= 10
 fk_2 //= 10

 # perform check only if k is in end_pandigital
 if end_pandigital[k] and is_pandigital_start(fk):
 return k

 # Not found
 return -1


def benchmark() -> None:
 """
 Benchmark
 """
 # Running performance benchmarks...
 # Solution : 8.59146850000252 to 9.774559199999203
 # Slow Sol : 57.75938980000137 to 61.15365279999969

 from timeit import timeit

 print("Running performance benchmarks...")

 print(f"Solution : {timeit('solution()', globals=globals(), number=10)}")
 print(f"Slow Sol : {timeit('slow_solution()', globals=globals(), number=10)}")


if __name__ == "__main__":
 print(f"{solution() = }")
 benchmark()