I want to make a complicated code golf challenge (with a time limit ;). In this particular case I want people to golf the Elliptic-Curve Method to factorization.
Now there are two issues with planning this challenge, on which I'd like to ask for "official" guidance:
- Implementing this algorithm will be very work-intensive (one needs to implement a specific set of group operations efficiently and then on top of that implement the actual non-trivial algorithm), can and / or should I split this into several challenges that build upon each other or is it preferred to have this as one big challenge?
- There are also languages (MATL, Sagemath and Mathematica would be my guesses) that have built-ins for certain core operations (like implementing said group), should I let people "just deal with it" or would it be preferred to allow code re-use with minimal penalty? For example one would need addition (probably 30-100 bytes for languages without built-in), could / should I allow people to re-use functions / programs from pre-existing challenges at the costs of the associated call?
The second point would also allow people to make other potentially interesting challenges, for example: "Given a function that finds a non-trivial factor of a number (as a 'built-in'), write a function / program that outputs the prime factorization of a number."
My current idea for a policy for the second point would read as:
You are allowed to define a helper function that will not count towards your total bytes, only calls to this function will count. If your language supports functions and you want to use this helper, you have to use a call. If your language does not support functions, you may inline the code instead and for each occurence of the same function with formal parameter replacements you have to add 5 bytes and 2 bytes per argument per function call to your byte count but are allowed to not count the inlined function towards your byte count.
One possible additional restriction here would be to limit the source of the helper function to competing answers to an existing, defined code-golf question.