H.PWiz

That seems like a sensible thing to think

In my regexes for 5 and 7, I have (||){1,4}, which can be (|){3,6} according to your list

Then you can take add 21*(n^2-1)*n, and then add n

We have n^7-14n^5+49n^3-36, so we add 14*(n^2-4)*(n^2-1)*n to get n^7-21*n^3+20*n

For odd powers, you can do something like x*x*x+x+x+x+ which gives (n-3)*(n-2)*(n-1)*n*(n+1)*(n+2)*(n+3)/7!. Then multiply by the factorial, and you get something like (n^2-9)(n^2-4)*(n^2-1)*n. When expanded all the terms have odd powers, and you can gradually improve it

@Deadcode No, that should be useful. Anyway, here's one for n^7 that I found manually (||||||)((||){2,5}(|)x*x+|(|)(||){1,4})x*x+x+x+|(|){1,6}x+x+|x

For n^7, I want to do 5040, and 1680, and ...

Have you got any method for figuring out how to multiply by n?

I haven't thought about it yet

The best way to analyze it is by looking at (|){2,3}x*x+x?x+|x?x+

@Deadcode Yes, I suppose you're right. The problem is, that you aren't really multiplying by n^2. That would be (?*(|){2,3}x*x+|)x?x+ (I think)

I think x*x+ shouldn't be (n+2)*(n+1)*n/6

> I saw that x?x*x+x+ gave me oeis.org/A002415

I tried to explain it above.

Odd powers can be nicer in some ways. For n^5 I've got (||){1,4}x*x+x+x+|(|){1,4}x+x+|x, but there should be a better way

The way I found this was by guessing random things... I saw that x?x*x+x+ gave me oeis.org/A002415, which looks pretty close to n^4. So I multiplied by 12, and added n^2

I'm not sure what the best way to multiply by 12 is

Which could be ((|){2,3}x*x+)?x?x+

((|||||||||||)x*x+)?x?x+ works for n^4

which I suppose is just (|||||)x+x+|x

I haven't thought very carefully about this problem... but while playing, I found x+((|||||)x+)|x for n³

I'm pretty certain my solution is correct... All of the ideas I've had to shorten it work much better in my imagination than in reality

I did... but I didn't wait for it to finish... how long should it take?

Yes, ask...

It fails for my cyclops regex on 3

> zsh: segmentation fault (core dumped) ./regex <<< '0000000000000000 + 000000000000000 = 0000000000000001'

nvm, I didn't recompile after pulling :)

git pull syas I'm up to date...

> Error: Unrecognized option "--test=binary-sum"

@Deadcode My first attempt gets me to 121... I need to think some more about this

When I was playing earlier this didn't work... I can't remember what the difference is

^(x(x*))(?<!^\3+(x+x))(?!(?=\1*(\1\2+$))\4*$)\1*$

So it beats .Net now!

I haven't checked what changed, but it seems that you don't have to worry about 1 anymore, and can start with (x(x*))

That's quite pleasing. I still feel uneasy with (?<!) for some reason. Even though it was introduced years ago

It's one of the trends on code.golf that I came to really dislike. A rather hilarious example of this strange thinking is here

It would be nice if you weren't allowed to invert the outputs... That way handling 1 becomes much easier

@Deadcode The way the question is worded makes the approach we both originally took seem very natural

I never learnt about the square regexes... nice work. shorter yet is: ^(x(x+))(?<!^\3+(x+x))(?!(?=\1*(\1\2+$))\4*$)\1*$

Actually, I can get 63: ^(x(x+))(?<!^\3+(x+x))(?!(?=x*(\1(?=(\1*)\2+$)\1+$\5))\4*$)\1*$ So it's 1char shorter than the one I gave you before... but I gets the answer wrong for 1

((x+)\5*(?=\5$))? seems like a really ugly construction. I want to do tail /= n where n is a (possibly 1) divisor of tail

And it thinks that 1 is Guiga

I was just trying a slightly different approach for Guiga... Right now it's 4 chars longer: ^(x(x+))(?<!^\3+(x+x))(?!((x+)\5*(?=\5$))?\1(?=(\1*)\2+$)\1+$\6)\1*$

I was just slightly annoyed that I couldn't test locally with ^(x(x+))(?<!^\3+(x+x))... I really like developing solutions by using ./regex

btw, are there lookbehinds in RegexMathEngine?

In general I don't have much interest in codegolf.stackexchange... I spend some time messing around on code.golf, and recently did a couple of regex-ish holes in Vim which tempted me to look here for a bit

I scrolled through a few, looking for some low-hanging fruit

Cool! I suppose it's not so common to divide by big numbers in regex.

After supposing B'>B?