ProjectEuler | Polyglot solutions for www.projecteuler.net | Functional Programming library

/ works in the reverse way to what you expected - it evaluates through the array right-to-left.

F/a b c d is ⊂a F b F c F d, or, with parentheses, ⊂(a F (b F (c F d))).

After removing the ⌽ and swapping ⍺ and ⍵, you get {⍺+(2⌈/⍵),0}/d, which gives the result you want.

You have three problems with this code:

1. An actual bug. You don't handle when a prime divides the number multiple times. I'm fairly sure the four lines before the println output are a workaround you put in when you encountered a failure this causes, that fixed the specific failure you found but don't actually address the root cause. I just tested it, your code outputs 3 for the input 252. The correct output for 252 is 7.
2. Part of your code invokes a library method that may be significantly expensive. You should not be using isProbablePrime.
3. Your algorithm's logic scales poorly. Hackerrank's test cases probably include something where the correct output is something like 20 digits long. A major point of Project Euler is that it's not enough to write code that will find the correct answer. You need to write code that will find the correct answer efficiently. To fix this, you will need new logic for the fundamental design of the program.

You cannot use floating-point arithmetic here. Floating point supports a limited number of significant digits (17 or some such). When the code divides numbers, the result is a floating-point number, and very soon (iteration 25 or some such) there will be not enough precision to represent it as float.

What actually happens is your numbers become so large, float cannot even represent their exponent, and overflows to infinity. But that shouldn't matter, because the numbers are wrong long before they overflow.

What you need is an algorithm which calculates numerator and denominator using only integer operations (like addition and multiplication), no division.

Variable-length array like

At the very least, you need to collect all of the numbers, de-duplicate, sort, and then check lower numbers against higher ones. There are tricks you can use to streamline the process; you can make bit maps, check primality, etc. However, you still have an inherently O(N^2) process.

However, the faster way to solve the original problem is to take the sums of the individual arithmetic sequences:

You are using a for loop to iterate through numbers starting from 600851475143 going down; this is extremely slow. I suspect the program is taking too long to run. All project euler programs should be able to be completed within 2 minutes of running. Try optimising your algorithm so it runs faster.

Apply some straightforward optimizations:

• list numbers should not be used because each number can be calculated based on an index
• simplified initialization of Isprime.

For 1'000'000 got:

It appears that you have an integer overflow. In Python itself integers can have arbitraty precision, but since pandas/numpy by default use C data types, overflow can happen:

enter link description here

In order to solve the issue you might want to manually cast the data to Python integers:

Small problem first: terminal_finder goes into infinite loop for x=0. To fix it, add if x == 0: return 0

The reason for bad results is in the value list which contains both the numbers and their square sums. You are then searching the index of a square sum, but the search goes through both types of list items. So don't put the input numbers there, just the square sums.

Actually, you don't have to search the list, because now there is the result for number N at the list index N.

The minimal correction to your code is here: