The Third Stack

Mr. Xcoder

20:04

@DJMcMayhem What was subtraction again?

(Brain-Flak)

DJMcMayhem

There isn't any subtraction, but [...] negates ..., so you can implement subtraction pretty easily

Mr. Xcoder

Ok, let me do subtraction first.

DJMcMayhem

Because everything inside of (...) is implicitly summed, so (a[b]) pushes a-b

Mr. Xcoder

... why:

3
8
5

@DJMcMayhem (()[])?

Erik the Outgolfer

huh

HyperNeutrino

20:06

I remember <> -> height, () -> one, {} -> pop what was [] again?

Erik the Outgolfer

that's for pushing length of stack including itself

DJMcMayhem

[] == stack height

HyperNeutrino

ohh

wait what is <> then, 0?

Erik the Outgolfer

<> == switch stack

HyperNeutrino

wait right facekeyboard

DJMcMayhem

20:07

@Mr.Xcoder That's three seperate atoms (...) == push (...), () == 1, [] == stack height

Mr. Xcoder

@DJMcMayhem Why does (()[]) subtract but return the values on the stack too?

DJMcMayhem

So that pushes stack-height + 1

@Mr.Xcoder Parentheses have different meanings depending on whether there is anything inside of them. [] by itself is a nilad

So you're pushing stack height + 1 (3). You got (un)lucky with your input choices lol

Mr. Xcoder

@Dj Please suggest me two inputs.

DJMcMayhem

@Mr.Xcoder 5, 8 is fine, it's just the wrong program accidentally gave the right result.

Do you want me to tell you how to subtract, or do you want to figure it out with hints?

Also, this might be a better conversation in the third stack...

← 26 messages moved from The Nineteenth Byte

Mr. Xcoder

Ok... o/

HyperNeutrino

20:11

o/

Thomas Ward

(I'm curious, forgive me for lurking)

DJMcMayhem

That's fine

→ 1 message moved to The Nineteenth Byte

Mr. Xcoder

Ok teach me how to negate a number...

Nvm...

DJMcMayhem

So [...] evaluates to the negative of ... So [()()()] for example would evaluate to -3, but nothing is done with that value. ([()()()]) would push -3

Mr. Xcoder

@DJMcMayhem ([{}]) would negate the top of the stack, wouldn't it?

DJMcMayhem

20:15

Yep!

HyperNeutrino

yes

though it doesn't always make sense to pop, negate, the push if you want to do something with the negated value

(but we can golf it after you've made a solution first :P)

Mr. Xcoder

But then how to add that to the other input?

DJMcMayhem

@HyperNeutrino Yes, Push-Pop-Redundancy is hard to figure out (even for me still)

HyperNeutrino

yup

@Mr.Xcoder things next to each other are implicitly summed

DJMcMayhem

^

Which is why ()()() == 3

So {}{} evaluates to the sum of the top two elements, ({}{}) pushes that

HyperNeutrino

20:18

wait (({}){}) is the shortest way to double the top value right?

DJMcMayhem

Yeah

Mr. Xcoder

I thought (([{}]){}) would work, but it does not...

DJMcMayhem

@Mr.Xcoder That's really close, it just has a redundant push in it

HyperNeutrino

see the problem is you're popping, negating, then pushing, and then popping that element off and adding it

DJMcMayhem

You should pop two values and push one, that's popping two and pushing two

HyperNeutrino

20:20

so you're getting x => (x[-1] = -x[-1]) + x[-1]

Mr. Xcoder

([{}]){} doesn't do it either... Trying to comply to those advices

HyperNeutrino

that's the wrong push to remove lol ;)

you want to pop and negate and then add that to the next element without pushing the first value back

Mr. Xcoder

Hooray!

([{}]{})

DJMcMayhem

Yep!

HyperNeutrino

yay

now you have the problem that two values were popped

Mr. Xcoder

20:22

Actually that should be ({}[{}]), shouldn't it?

HyperNeutrino

@Mr.Xcoder no because then you're subtracting the second element from the first but it's the other way around

Mr. Xcoder

ik.

DJMcMayhem

@Mr.Xcoder One is a-b the other is b-a

Mr. Xcoder

@DJMcMayhem Ik.

> confusing-languages

lol

DJMcMayhem

room topic changed to The Third Stack: A chat room for discussing the Brain-Flak programming language. Try it online: tio.run/#brain-flak Github link: github.com/DJMcMayhem/Brain-Flak [brain-flak] [confusing-languages] [scary-pencils] [what-does-my-code-do?]

HyperNeutrino

20:23

what is a scary pencil

Mr. Xcoder

@DJMcMayhem What should I do next?

DJMcMayhem

So like HN said, you're losing the second value (b), so you won't be able to use it in the next loop

So you need a way to compute a-b while leaving b on the stack

Mr. Xcoder

So I should duplicate it?

DJMcMayhem

(or b-a, I don't remember)

That's one way

So you could move 'a' over to the other stack so you can duplicate 'b', then move 'a' back over

That's the easiest way to understand, but it's not the shortest

Mr. Xcoder

Woah woah woah, take it easy.

HyperNeutrino

20:25

I found that harder to understand :I lol

DJMcMayhem

Oh, haha

@Mr.Xcoder The other way is realizing that (...) evaluates to the same thing as ... So ((...)) pushes something twice

So how would you write a peek snippet? (evaluates to the top element without removing it)

Mr. Xcoder

Well I got it: ([{}]({}))

DJMcMayhem

Exactly

HyperNeutrino

yay

Mr. Xcoder

Gives me:

-3
5

HyperNeutrino

20:27

you now need to loop it

DJMcMayhem

Now you just need to wrap that in a loop

ninja'd

HyperNeutrino

lol

DJMcMayhem

But first, @Mr.Xcoder Do you understand stack switching?

Mr. Xcoder

@DJMcMayhem Not really, no. I guess it's <> that just reverses the stack?

DJMcMayhem

No, it switches

Mr. Xcoder

20:29

What does that mean?

DJMcMayhem

There are two stacks, and every operation does something to the active stack. <> toggles between the two

Mr. Xcoder

oh, I see. Can you give me an example?

DJMcMayhem

So all input is loaded to the active stack at first, and then the alternate is empty. So something like <>(()()) will print 2 no matter what the input is

Because you're pushing 2 onto the (empty) alternate, so the input is irrelevant

Mr. Xcoder

cool.

DJMcMayhem

And since (...) pushes to the active always, then ({}<>) will pull the top value off the active, and move it over to the alternate

Mr. Xcoder

20:31

Ok. How should I go about looping?

HyperNeutrino

It's also worth noting that <> evaluates to 0 so it doesn't affect chains of nilads.

DJMcMayhem

@Mr.Xcoder {...} will run the code inside it until the top of the active stack is 0 (or empty)

It also evaluates all the code inside it, but that's a little more advanced and not needed for this task. But it's a really cool second approach to things

Mr. Xcoder

SO {([{}]({}))} wouldn't work.

... but why?...

HyperNeutrino

well first of all, you need to move the deltas to the other stack because otherwise they interfere with your current calculations

Mr. Xcoder

@HyperNeutrino Ok, I switched to {<([{}]({}))>}. Next

HyperNeutrino

20:34

that doesn't work.

<...> evaluates ... and returns 0

DJMcMayhem

No, that's the monad. <...> != <>

HyperNeutrino

what you need to do is (...<>)<>, which evaluates stuff, switches, pushes, and switches back

Mr. Xcoder

oh

sweet. {(([{}]({}))<>)<>} still won't work though

HyperNeutrino

so is the shortest way of pushing 0 just (<><>)

@Mr.Xcoder that doesn't work because it will stop whenever there's a 0 in the input

DJMcMayhem

Or (<()>)

HyperNeutrino

20:35

ah cool

DJMcMayhem

@Mr.Xcoder Since you're a beginner, you could assume the input doesn't contain 0's

That makes it much harder

@HyperNeutrino Sometimes (<>) works

HyperNeutrino

(requires all sorts of stack-height weirdness lol)

@DJMcMayhem huh interesting. I guess that's only when you want to switch stacks right?

Mr. Xcoder

@DJMcMayhem Regardless of that, it still does not work.

DJMcMayhem

What do you have?

What's it doing?

Mr. Xcoder

{(([{}]({}))<>)<>}

HyperNeutrino

20:36

oh right. that's pushing twice

Mr. Xcoder

let's see. {...} Loops right?

HyperNeutrino

{([{}]({})<>)<>}

that was pushing to first stack, then swapping and pushing to second stack, then swapping back, so pushing to both stacks

Mr. Xcoder

Ok so now {([{}]({})<>)<>} gives me 0.

DJMcMayhem

Your deltas are on the alternate. Toggle again

Mr. Xcoder

I know. Wait

Haha, {([{}]({})<>)<>}<>

HyperNeutrino

20:38

does that work?

Mr. Xcoder

Yes.

DJMcMayhem

Well, technically you'll want a {} after that to get rid of the last difference

HyperNeutrino

I'm wondering if this causes troubles with it exhausting the end of the stack which would give an extra value

Mr. Xcoder

Oh no sorry

DJMcMayhem

And also, it reverses the deltas too

HyperNeutrino

20:38

(ninja'd :P)

@DJMcMayhem well my 36-byter does too :P

which I guess I could fix by just moving everything back to the other stack

DJMcMayhem

Which is fortunately pretty easy, other than handling '0'

HyperNeutrino

yup :P

Mr. Xcoder

@DJMcMayhem So I need to reverse the result of {([{}]({})<>)<>}<>{}?

DJMcMayhem

Yeah. So another loop that toggles elements over

Which is either trivial (if you don't handle deltas of 0) or slightly difficult (if you do)

Mr. Xcoder

i'll pick the easy way, gtg in 2'

HyperNeutrino

20:41

I have 62 bytes as my final answer @DJMcMayhem

Mr. Xcoder

@HyperNeutrino For handling 0s?

DJMcMayhem

Challenge accepted

HyperNeutrino

handling 0s, and in the correct order

^^ :P

anyway gtg o/

Mr. Xcoder

@DJMcMayhem I thought {{([{}]({})<>)<>}<>{}{}} would work for reversing. Apparently I was wrong

DJMcMayhem

So first off simplify

How do you move one item over?

Mr. Xcoder

20:44

<>.

DJMcMayhem

No, that toggles

Mr. Xcoder

I think I figured.

DJMcMayhem

But it doesn't move anything

Mr. Xcoder

What did I do this time: {({([{}]({})<>)<>}<>{}<>)<>}<>?

@DJMcMayhem (...<>)<>.

DJMcMayhem

@Mr.Xcoder Yes, and what you're trying to move is the top item on the stack {}

So ({}<>)<>

@HyperNeutrino I got it 58 (54 if we can assume there's always at least two inputs)

Mr. Xcoder

20:48

@DJMcMayhem Is ({([{}]({})<>)<>}<>{}<>)<> correct?

DJMcMayhem

For reversing or for the whole thing?

Mr. Xcoder

no it actually is identity with {([{}]({})<>)<>}<>{}

@DJMcMayhem reversing. but it ain't valid.

DJMcMayhem

You only want one loop

Mr. Xcoder

huh

DJMcMayhem

And the [{}] inside will mess it up because it removes multiple items

Mr. Xcoder

20:50

ahh, I'd like to continue learning but I gtg now. Bye o/

DJMcMayhem

np

Mr. Xcoder

See you

HyperNeutrino

nvm back now

DJMcMayhem

@HyperNeutrino Wanna see my solution?

I'm pretty sure it's optimal

HyperNeutrino

sure!

DJMcMayhem

20:52

Try it online!

The trick is pushing should I keep looping values over in the first loop, not in the middle of the second

HyperNeutrino

oh hm smart

Riley

21:09

@DJMcMayhem I've never seen that trick before. It's genius.

DJMcMayhem

:D

@Riley I'm glad to hear that, and that means a lot coming from you :)

Riley

I bet I have a bunch of answers that I could improve with that.

DJMcMayhem

Brain-flak just passed 50 stars on github for the first time! \o/ \o/

4

@Riley I think I've used it before, but I can't remember where

Riley

21:28

It only saved 2 bytes on one answer. I thought it would have been a lot more than that. It's too bad you can't search for brain-flak code.

DJMcMayhem

0

A: Tips for Golfing in Brain-Flak

Push extra loop counters Frequently, you'll want to do something like Perform X operation on every element in the stack or Perform X operation on every pair of adjacent elements in the stack When the input may contain '0's, or the result of operation X may give a 0, this is really in...

@Riley Could you maybe save 2 more by combining the (()) with an existing ()? (No idea if that'll work, I haven't seen the answer in question)

Riley

This one. No, and I reverse the stack 4 times, but there is too much other stuff going on to do this more than once.

Transcript for