The Nineteenth Byte

ASCII-only

00:50

any haskell experts here?

Riker

02:47

@flawr yea I meant the website :p nubleh.github.io/i_painted

flawr

09:19

@Riker oh neat:)

H.PWiz

10:34

@Deadcode I think there is a fairly short regex solution to this since you only need to consider the largest prime factor. So with the appropriate multiplication and some fiddly work for when p < 14 it might be quite straight-forward. (I lack too much knowledge on multiplication to figure anything out)

Deadcode

11:52

@H.PWiz I've thought about that a little, but chose a different problem for my next post :)

ais523

13:53

@Deadcode: I've been interested in regex-with-backreferences recently for a quite different reason, and realised I don't know how backreferences work in complex situations; is there some concise/simple specification for explaining exactly what a particular backreference does in cases such as loops?

digEmAll

15:10

Does anyone know if it's possible to install a new R package on TIO ?

Mr. Xcoder

15:22

@digEmAll Ask Dennis to do so in the TIO chat room

talk.tryitonline.net

For general discussion and feature requests regarding tryitonl...

digEmAll

@Mr.Xcoder: oh thanks! sorry I didn't know of that chat...

El'endia Starman

15:53

@Riker This is quite cool.

Anush

16:32

here is a (slightly idealised) real life puzzle.I have a remote control car that takes 3 batteries. I can use it for one hour before the batteries go flat. I can recharge the batteries in a separate recharger and that takes 1 hour also. Unfortunately the recharger can only recharge either 2 or 4 batteries at a time and all the batteries must have an equal amount of charge to start with. What is the minimum number of batteries I have to buy so I can use my remote control car forever?

wizzwizz4

Probably 5 or, failing that, 7.

No, 5 doesn't work.

Use 3, swap'n'charge 2, swap'n'charge 4, repeat.

But it's probably best just to use the fourth battery charging point for something else.

Then you only need 6.

Anush

how do you do 6?

I use 3, then put a new set of 3 in and charge 2. Then what I do ? I only have 2 charged batteries

wizzwizz4

Stick a paperclip in the fourth charging slot, charge 3 batteries at once.

Anush

@wizzwizz4 I don't think that works

so do you think 7 batteries works ?

wizzwizz4

Electrocute self, burn down house.

@Anush Yes.

Anush

16:45

so I use 3, then put 3 new ones in and charge how many?

it can only be 2

so then I have 3 to use

so I use those and charge 4?

is that the strategy?

wizzwizz4

@Anush Yes.

Though, IRL I wouldn't recommend it.

Anush

ok so then I have 4 charged and three used

wizzwizz4

Keep your batteries grouped together.

Anush

and it seems I can keep going forever?

wizzwizz4

@Anush Yes.

Anush

16:47

why wouldn't you recommend it?

wizzwizz4

@Anush Devices don't use batteries evenly, so mixing and matching can cause problems.

Ahem. Reasons.

Anush

you mean one flat battery is not the same as another flat battery?

Erik the Outgolfer

@Anush um... are you actually facing such a problem?

Anush

@EriktheOutgolfer yes!

the only idealisation is that it takes about 30 minutes to run the batteries down and 4 hours to charge them

Erik the Outgolfer

the answer is, obviously, well, patience :P

Anush

16:49

@EriktheOutgolfer sure but you still need a plan! :)

wizzwizz4

@Anush In which case the numbers work better.

It's an 8:1 ratio, not a 1:1 ratio, so you should only need 27 batteries and 8 chargers.

Making an assumption about the charging circuit of the chargers that may or may not be reasonable.

Namely that it will provide a fixed potential difference across the battery regardless of whatever's happening to the other batteries.

Anush

27 batteries is really expensive!

wizzwizz4

Not that expensive!

Anush

well 8 chargers are

wizzwizz4

It's less than three houses.

Erik the Outgolfer

16:52

welcome to Greece...

Anush

@wizzwizz4 a very good point

wizzwizz4

Once I've got three houses, I'll buy you 8 chargers.

Anush

are you looking to buy three houses?

wizzwizz4

Are you selling three houses?

Anush

:)

this has got surreal quickly

wizzwizz4

16:53

If so, I think we've got a deal.

You get your battery chargers, and I get my three houses!

Erik the Outgolfer

maybe a financial advisor would be cheaper... ;)

wizzwizz4

@EriktheOutgolfer Ssshhhh…

Quintec

@Anush Can I interest you in ω houses?

Erik the Outgolfer

@wizzwizz4 wait, what am I doing wrong? I'm just, eh, trying to prevent theft... :P

you won't silence me...

Anush

@Quintec of course!

Quintec

17:01

@Anush I suppose you won't mind if I do a small rotation and give you ε houses instead? :P

Anush

@Quintec It is a lot like a game of transfinite Monopoly here :)

wizzwizz4

@EriktheOutgolfer has been kicked from The Nineteenth Byte.

Quintec

OuO

"Diamonds are forever - unless you misuse them..." hem

wizzwizz4

@Quintec Where'd my diamond go?

Quintec

I stole it

wizzwizz4

17:08

@Quintec Come back here!

Quintec

flees

wizzwizz4

Thank you for returning it.

Bubbler

@Quintec Slightly more rotation gives you McDon..

wizzwizz4

@Bubbler That's not a number though.

That's what we started with.

Bubbler

I had to realize that sooner

wizzwizz4

17:12

Does C have uint_fast64_t?

Bubbler

@wizzwizz4 Apparently yes

wizzwizz4

Cool and good.

wizzwizz4

17:33

Did you know that malloc and free are completely useless if you have realloc?

Dennis

realloc won't free the old memory if it fails to allocate.

wizzwizz4

@Dennis You can still do:

char *buffer = realloc(NULL, 17);
char *newbuffer;
if (!(new_buffer = realloc(buffer, 22))) {
    realloc(buffer, 0);
    fprintf(stderr, "NOOOOOOOOO!\n");
}

Dennis

17:48

Or you could just use free and malloc. ;)

wizzwizz4

@Dennis Ssshhhh…

Deadcode

@Anush Better solution: Get a charger like the MH-C401FS that can charge any number of batteries (1, 2, 3, or 4) with independent circuits.

wizzwizz4

I have come up with a legitimate use case, though; a dynamically-growing static list defaulting to NULL.

@Deadcode You only save 1 battery, though.

So, in the end, it really comes down to which is worth more: a charger or a battery.

Deadcode

Or peace of mind!

wizzwizz4

18:09

> > Germans have a saying: Early is on time, on time is late, and late is unforgivable.

— Richard U

Does this mean that early is unforgivable?

Or is it a mapping?

In which case, wouldn't it be better to optimise it?

Deadcode

@ais523 In ECMAScript, a backref is only set when a capturing group is exited, and all backrefs created anywhere inside a loop are deleted when that loop repeats. In PCRE, a backref is set when a capturing group is either exited or it loops back to the beginning, and backrefs are never deleted (except by what I will subsequently explain).

In Perl, it's like PCRE, except that a backref that was set during a previous iteration of a loop will be deleted by directly experiencing 0 repetitions during a later iteration of the loop (for example, (something)? will be deleted if the ? directly results in evaluating it 0 times).

In all engines, backrefs are deleted when backtracking goes through the point at which they were set (or if they had a previous value, backtracking will restore the previous value), and all backrefs created inside a negative lookaround are deleted upon exiting the negative lookaround (except for some exceptions in Perl which I haven't 100% researched).

wizzwizz4

@Deadcode Why isn't PCRE the same as Perl?

Deadcode

18:51

@wizzwizz4 Well that's the question, isn't it? ;) "Perl compatible" is right there in the name.

There are plenty of other ways it's different, too.

Anush

19:06

@Deadcode thanks

Erik the Outgolfer

20:31

@wizzwizz4 has been requested to peacefully resign or the diamond will be taken away by force :P

wizzwizz4

You'll never take me alive! … again.

Erik the Outgolfer

.oO( silencer is dead... nice ) ;P

.oO( looks like he tried to silence our Dennis too... does he have no shame... )

flawr

21:25

Is anyone here familiar with Mathematica?

PhiNotPi

some

flawr

I'm trying to evaluate a sum of some complex numbers: Total[{1 , E^(2*I/3*Pi) , E^((4*I)/3*Pi)}] This sum should be zero, but I just get the same "symbolic" expression back.

Is there a way to tell mathematica to evaluate it?

wizzwizz4

@flawr Sum?

flawr

@wizzwizz4 that is what Total[] does.

PhiNotPi

Well you can wrap the whole thing in Simplify[]

Pavel

21:33

Or N

flawr

@PhiNotPi hm that seems to work, thanks!

@Pavel N?

Pavel

@flawr If Simplify didn't work you could try N

But it did work

PhiNotPi

N[] basically evaluates expressions (like "2/3" which is normally left as a fraction) into a float ("0.666667")

Pavel

In this case it actually gives about 4.4*^-16 though

flawr

Ah so N[] only evaluates the values numerically (using floating point numbers)?

lirtosiast

21:48

Yep

You can mitigate this using higher precision or use Chop[] to set small numbers to 0

flawr

Ah well in my case I need exact results so I have to rely on algebraic maniplations.

Thanks a lot for the help, everyone!

lirtosiast

If you just want whether it's zero, there is PossibleZeroQ

flawr

I've found other functions with this Q-suffix, do you know what it means?

lirtosiast

It returns a boolean

That's about it

PhiNotPi

I'm just guessing that it stands for "Query"

flawr

21:57

oh, that makes more sense. I thought it has something to do with rational numbers :D

lirtosiast

Can someone convince @wizzwizz4 that codegolf.stackexchange.com/a/179392/39328 is smaller than Loader's number (or prove me wrong?)

wizzwizz4

@lirtosiast I would also like that convincing.

My brain shuts down when numbers get that big.

flawr

I agree, numbers greater than three might be of theoretical interest but have no practical use whatsoever.

12

lirtosiast

My assessment that it's stronger is that Loader's number is basically that Loader's number is the largest number expressible in the calculus of constructions, which is fairly powerful

And thus manually composing functions together can't beat it, since you can probably do that in the calculus of constructions

But that's not rigorous

wizzwizz4

If H(ω², 3) = 24, and h(3, 3, 2, 5) = 3^(2^5) (Hardy, hyperoperation), then I can try to represent my number.

Actually, h will need to be defined slightly differently.

Ørjan Johansen

22:06

@ASCII-only Haskellers read this channel lazily if at all, so you cannot expect to reach us on the spot. Also don't ask to ask.

2

Also, there's a Haskell chat.

H.PWiz

Also, not many will admit to being an "expert"

Ørjan Johansen

(I admit nothing!)

wizzwizz4

h is like that, except if you wrote h(ω², 3, 2, 5) and "n" (the current parameter to H) was currently 3, it'd do h(ωω, 3, 2, 5) = h(ω*3, 3, 2, 5) = h(ω*2 + ω, 3, 2, 5) = h(ω*2 + 3, 3, 2, 5) = h(3, 3, 2, 5) (discarding everything except the last term).

lirtosiast

I don't need exact, just a very loose upper bound

flawr

@H.PWiz I admit that @H.PWiz is an expert.

H.PWiz

22:10

Damn!

wizzwizz4

Now, w is ω, and w_n is ω_n.

@flawr All those years of building up a secret identity, and you ruined it!

H.PWiz

(though to be fair, I know little further than code golf)

Erik the Outgolfer

so... now that we've admitted @H.PWiz is an expert, well, any expert tips for golfing in Jelly? :P

flawr

@H.PWiz that is what I'd expect an expert trying to hide his expertise to say.

wizzwizz4

a is a strange thing that can't really be represented with the Hardy hierarchy by me, because I'm not an expert, so I expect @H.PWiz to fix it for me.

wizzwizz4

22:22

Basically, a(0) becomes h(h(ω_n, ω_n, ω_n), h(ω_n, ω_n, ω_n), h(ω_n, ω_n, ω_n), h(ω_n, ω_n, ω_n)), a(1) becomes…

h(h(h(ω_n, ω_n, ω_n, ω_n, ω_n, ω_n), h(ω_n, ω_n, ω_n, ω_n, ω_n, ω_n), h(ω_n, ω_n, ω_n, ω_n, ω_n, ω_n), h(ω_n, ω_n, ω_n, ω_n, ω_n, ω_n), h(ω_n, ω_n, ω_n, ω_n, ω_n, ω_n), h(ω_n, ω_n, ω_n, ω_n, ω_n, ω_n), h(ω_n, ω_n, ω_n, ω_n, ω_n, ω_n), h(ω_n, ω_n, ω_n, ω_n, ω_n, ω_n)), h(h(ω_n, ω_n, ω_n, ω_n, ω_n, ω_n), h(ω_n, ω_n, ω_n, ω_n, ω_n, ω_n), h(ω_n, ω_n, ω_n, ω_n, ω_n, ω_n), h(ω_n, ω_n, ω_n, ω_n, ω_n, ω_n), h(ω_n, ω_n, ω_n, ω_n, ω_n, ω_n), h(ω_n, ω_n, ω_n, ω_n, ω_n, ω_n), h(ω_n, ω_n, ω_n, ω_n, ω_n, ω_n), h(ω_n, ω_n, ω_n, ω_n, ω_n, ω_n)), h(h(ω_n, ω_n, ω_n, ω_n, ω_n, ω_n), h(ω_n, ω_n, ω_n, ω_n, ω_n,…

Ørjan Johansen

@H.PWiz The "don't ask to ask" link pretty much covers that too.

Pavel

@wizzwizz4 is this some new APL bullshit

Erik the Outgolfer

more like an overly long message... ω is the ordinal symbol

wizzwizz4

and a(2) becomes something bigger than fits in my computer's RAM.

Ørjan Johansen

@wizzwizz4 Tip: "bigger than fits in my computer's RAM" is completely insignificant for this particular question.

The same applies to "atoms in the universe" and the like.

wizzwizz4

22:25

By the way, ω_n is actually {ω_0, ω_1, ω_2,…} where ω_0 is {0, ω, ω*2, ω*3…} and ω_1 is {0, ω_0, ω_0*2, …}.

New Sandboxed Posts

0

A: Sandbox for Proposed Challenges

SLIPpery Packets The Serial Line Internet Protocol is an early internet protocol, used to essentially escape any "packet END" bytes that may appear in a packet. It has since been replaced by the more sophisticated Point-to-Point protocol, however it is still preferred on microcontrollers and low...

wizzwizz4

@ØrjanJohansen I am aware.

I don't comprehend that, though.

Anyway, a(9) isn't that big, but H(h(9, a, a), 9) is pretty big.

I don't know whether it's big enough, though.

I plan to make a new version, v2, where h(a, b, c) is identical to h(H(a, n), b, c) for non-integer values of a.

That'd be better-defined, but is not what we're discussing right now.

And I've got to go, so I can't discuss; if anyone can sketch a basic proof as to an upper bound on my number, and if that upper bound is less than loader.c, then I'll delete my answer.

Erik the Outgolfer

actually... the burden of proof is on the answerer

Ørjan Johansen

@wizzwizz4 I don't understand these fast-growing ordinal notations, but in some sense this amounts to the question of whether the CoC programming language can define the construction you use. If it can, then Loader's number immediately blows it out of the water.

Although I seem to recall that for fast growing functions, constructing them in CoC basically requires constructing something like the corresponding ordinal in order to have a termination proof, so the two ways of seeing it may be equivalent.

(I don't really understand CoC either, mind you :P)

Deadcode

22:59

@Neil Looks like I beat your Retina solution for Rocco numbers by 1 byte. Mine converted to Retina would be 67 bytes.

(5 bytes of overhead for converting decimal to unary)

talk.tryitonline.net

Transcript for