How do I put multiple conditionals in a single dfn

do i just nest :s?

@Razetime {cond1: result1 ⋄ cond2: result2 ⋄ result3}

@Razetime What do you mean by multiple conditionals? {cond1∧cond2:'both'} maybe?

like an if else hierarchy

@Bubbler I think it's this one

Then what Bubbler said.

f←{{⍺=0∧⍵=0:0⋄⍺=0∧⍵=1:1⋄⍺=1∧⍵=10:0⋄⍺=1∧⍵=11:1⋄⍺}/⍵}

This is my (very clunky) implementation for the talk interpreter

@Razetime Don't forget that ∧ is a normal function.

oh yes, right to left

@Razetime ⍺=0∧⍵=0→⍺⍵≡0 0 etc.

@Razetime Hold on, it is simply a look-up table, no?

yes pretty much

Why not pick the result from a list?

I didn't think of it

also I could just remove the outer function and use ⎕

@Razetime What is the input format of this function?

I think it could be simplified a lot

a string or character list

I was planning on ⍎ with each chunk of 2 chars

then doing this

@Bubbler yeah, there's definitely a very short answer

@Razetime How can one become 10 or 11?

If you map '00' '01' '10' '11' to 0 1 2 3 instead of 0 1 10 11, it's equivalent to {0 1∊⍨v←¯2⊥⍺⍵:v⋄⍺}/

Change ¯2 to ¯10 if you want 0 1 10 11

{⍺v⊃⍨0 1∊⍨v←¯2⊥⍺⍵}/ works too I guess

or (⊣(,⊃⍨0 1∊⊢)¯2⊥,)/

or {(0 1∊⍨V)⊃⊣,V←¯2⊥,)/

or {0::⍺⋄~~¯2⊥⍺⍵}/

Domain error FTW.

We need an adverse operator.

@Bubbler so, convert from binary

Yeah, but ⍎ could be actually shorter

because if the original input is a string, you'll need ⍎ or ⎕D⍳ anyway

g←{((⍴⍵) ⍴ 1 0) ⊂ ⍵}

something like this

or is it fair to accept input as '01' '10' '00' '11'

that isn't a character vector is it

Right.

codegolf.stackexchange.com/questions/190819/… Here's the question btw

Chunking: ⋄ ⎕IO←1 ⋄ {⍵⊂⍨2|⍳≢⍵}'0011010010'

@Bubbler 00 11 01 00 10

How does this look: {{(0 1 ,(9/0), 0 1)[⍺+⍵]}/⍎¨((⍴⍵) ⍴ 1 0) ⊂ ('0',⍵)}

Did you try running the code?

not yet

I think ⎕IO←0 is required

There are two inputs (initial value and program), and you're taking only one.

it takes the initial value and program together

separated by a space?

that's why ('0',⍵) is used

no, no space

Oh.

input can be a single string, so it's allowed I guess

but something is still wrong

It's wrong because the reduction is done from the right.

So you need to reverse the entire array right before reduction

so it looks like <commands reversed> <initial>

oh makes sense

Thanks for saving me a lot of time

Btw, looking through the submissions, an array of pairs of digits is a valid format for a program

well, is it better to follow the question or the submissions?

> You can ... split your input into valid commands (e.g. taking them as a list; e.g. [00, 01, 00]) if you like.

^ in the challenge description, so I guess it's OK.

But then there's something like this

I guess that was more efficient there because it's a substitution

h←{{(0 1 ,(9/0), 0 1)[⍺+⍵]}/⌽⍵}

so this isn't working correctly

⋄{{(0 1 ,(9/0), 0 1)[⍺+⍵]}/⌽⍵} 0 00 01 11 11 01

⋄{{(0 1 ,(9/0), 0 1)[⍺+⍵]}/⌽⍵} 0 00 01 11 11 01

@Razetime INDEX ERROR

⋄⎕IO←0⋄{{(0 1 ,(9/0), 0 1)[⍺+⍵]}/⌽⍵} 0 00 01 11 11 01

@Bubbler 0

according to the test cases it's supposed to be 1

⋄⎕IO←0⋄{{(0 0 1 ,(9/0), 0 1)[⍺+⍵]}/⌽⍵} 0 00 01 11 11 01

@Bubbler 0

No, that's totally wrong

⋄{{(0 1 ,(9/0), 0 1)[⍺+⍵]}\⌽⍵} 0 00 01 11 11 01

@Razetime INDEX ERROR

⋄⎕IO←0⋄{{(0 1 ,(9/0), 0 1)[⍺+⍵]}\⌽⍵} 0 00 01 11 11 01

@Razetime INDEX ERROR

⍺  ⍵ ans
00 0 0
00 1 1
01 0 1
01 1 1
10 0 0
10 1 0
11 0 0
11 1 1

hmm

maybe instead of adding 9 0's in the middle, change it to something else

and then return ⍺ by itself

l←{{⍺⍵≡0 0:0⋄⍺⍵≡0 1:1⋄⍺⍵≡1 10:0⋄⍺⍵≡1 11:1⋄⍺}/⍵} this one works

but adding doesn't seem to work, probably get indices in a matrix

which is probably bigger

Sum should work because 0 1 2 10 11 12 → 0 1 1 0 0 1

I think I found the mistake

⋄⎕IO←0⋄{{(0 1 ,(9/⍺), 0 1)[⍺+⍵]}/⌽⍵} 0 00 01 11 11 01

@Razetime 1

silly me

we just need to replace the rest of the non conforming cases with ⍺ instead of 0

@Razetime 0 1 ,(9/⍺), 0 1 can be golfed (don't do this in production code) to ∊0 1(9/⍺)0 1

⋄⎕IO←0⋄{{(0 1 ,(9/⍺), 0 1)[⍺+⍵]}/⌽⍵}0 00 01 00

@Razetime 1

Actually, 13⍴0 1,9/⍺ is shorter and better (fine for production code too).

@Adám is it an extended thing?

No, just bad form to go nested in the process of generating flat data. And it is a bit obscure too.

@Adám nice, I'll add that in

@Razetime Btw, you can remove the outer {…⍵}

lol my computer science teacher just said we won't cover multi dimensional arrays until next year... maybe APL is a bit out of reach for now :(

Yes I was going to do that, just needed arguments

Now it can be replaced with ⎕

You don't even need ⎕, it's a valid 2-train

@Razetime The inner function can be tacit: (+⌷13⍴0 1,9/⊣)

How do tacit functions work with reduction?

@Razetime Reduction doesn't care what type its operand is.

⊣ is ⍺ and ⌷ is ⍵?

Wrap the tacit function in parens and apply / like (+⌷13⍴0 1,9/⊣)/.

@Razetime No, + is ⍺+⍵ and ⌷ does indexing into the list.

⍵ is ⊢.

But I think the arguments should be reversed, because ⍺ is the command and ⍵ is the accumulator there

what does the / in the tacit fn do?

That's replicate.

But that works as replicate only when its left side is a constant

coool

tio.run/##SyzI0U2pTMzJT///qKM97b@G9qOe7YbGj3q3GCgY6ljqP@parKn/…

what setup do i use for this?

(If you take input as something like 0(0 0)(0 1)(1 1)(1 1)(0 1), then you can do (0<-/⍤,⍨)/⌽)

@Razetime This

And you need to change ⊣ to ⊢, as I said earlier

oh, great

You'll need that footer line a lot if you golf in APL regularly

@Bubbler well, it's already a bit ambiguous whether we should use the current solution , so, maybe not? I'm not sure.

Yep I'll bookmark it

Yeah, just an idea. I think yours is valid enough

so how dos that work?

compare first with o and subract if true

⍵ ⍺  ans
0 00 0
1 00 1
0 01 1
1 01 1
0 10 0
1 10 0
0 11 0
1 11 1

Attach ⍵ and ⍺ in that order, and add the two ends and subtract the middle.

Then you magically get positive when ans is 1, and non-positive when ans is 0.

Very very elegant

0(0 0)(0 1)(1 1)(1 1)(0 1) type vector from a normalstring

maybe it'd be smaller

Announcement: We're about to launch a site that verifies solutions to the APL Programming Competitions' phase I problems for the last few years. Let me know if you want to test the site (you'll probably have to solve the problems) and/or write some APL code to implement lenient checking of user solutions.

@Adám How does "lenient checking" work?

We have a reference implementation f and then we do (f(≡⍥p)your_function) where p is a post-processing function.

So the p can be defined per task?

@Adám would love to test it!

@Bubbler Yes, of course.

@rak1507 Want to meet on Zoom?

Would it be possible at around 3-ish?

What time zone?

BST

I can do 14:45.

I won't be home in time unfortunately

What's your availability tomorrow?

Probably from 4 roughly

OK, lets say then then. Ping me when available. My Zoom ID is the result of -\758,435,8447 in APL.

Alright great

If anyone else wants to join too, they are welcome.

@Adám Sure, i'm in

⋄{⍺≠⍵}\1 1 1 2 2 2 2 3 3 3

@Razetime 1 0 1 1 1 0 0 0 0 0

≠⍀1 1 1 2 2 2 2 3 3 3

⋄≠⍀1 1 1 2 2 2 2 3 3 3

@Razetime 1 0 1 1 1 0 0 0 0 0

why doesn't it show the places where two numbers aren't equal?

aka 0 0 1 0 0 0 1 0 0 0

@Razetime \ is a weird operation (≠\1 2 3 4 is (1)(1≠2)(1≠2≠3)(1≠2≠3≠4), plus regular APL RTL evaluation, aka it's O(n^2)). you probably want 2≠/x

⋄2≠/1 1 1 2 2 2 2 3 3 3 4 4 4

@Razetime 0 0 1 0 0 0 1 0 0 1 0 0

yupppp

⋄2≠/1 1 1 2 2 2 2 3 3 3 2 2 2

@Razetime 0 0 1 0 0 0 1 0 0 1 0 0

@dzaima ≠\ is O(n) but {⍺≠⍵}` is O(n²):

      ]runtime -c ≠\v1 ≠\v2 ≠\v3 ≠\v4

  ≠\v1 → 4.5E¯7 |    0% ⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕
* ≠\v2 → 8.2E¯7 |  +83% ⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕
* ≠\v3 → 1.0E¯6 | +133% ⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕
* ≠\v4 → 1.5E¯6 | +230% ⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕

      v1←1=?1e2⍴2
      v2←1=?2e2⍴2
      ]runtime -c {⍺≠⍵}\v1 {⍺≠⍵}\v2

  {⍺≠⍵}\v1 → 1.2E¯3 |    0% ⎕⎕⎕⎕⎕⎕⎕⎕⎕
* {⍺≠⍵}\v2 → 5.1E¯3 | +321% ⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕

hmm

The drop function removes eveything before an index

how do i drop only one element

@Adám still O(n^2) for integers

(but you're right that most cases of \ would be O(n)ified by the implementation)

@Razetime by a specific index?

yep

@Razetime not very simple (concatenating before and after is probably your best bet)

(in dzaima/APL i have this (drop last item of the first 3 items) but that's a dzaima/APL-specific feature)

I'll find something

@Razetime ⋄ 3(↑,1↓↓)'abcde'

@Adám abce

{∩/(↑∘⍵)¨(⍺,-⍺)}

oh you wanted to drop it

another alternative - ≠∘⍳∘≢⊢⍤/⊢

and that's dumb anyway

@dzaima That's nice in being sensitive to ⎕IO and being modifiable to remove multiple.

how would it work if you wanted to remove multiple?

@Razetime you'd need to use something like (~∊⍨) instead of ≠

@Razetime Yeah, ↑ : ⋄ 1 3(~⍤∊⍨∘⍳∘≢⊢⍤/⊢)'abcdef'

@Adám bdef

@dzaima (obligatory performance comparison)

Simpler: ⋄ 1 3{⍵[⍺~⍨⍳⍴⍵]}'abcdef'

@Adám bdef

I should add that one to APLcart.

@Adám it's 2x slower in the single item case

Multi-item case performance comparison coming up?

@Adám i don't have anything to compare to

(oh right, i do)

⊂⍤~⍨∘⍳∘≢⌷⊢ works for any rank.

@Adám there you go

@dzaima Wow, I was about to suggest ⍸⍣¯1 but thought it'd be silly.

@Adám it's able to utilize sortedness

Nice example of why / should be extended to imply trailing 0s like ⊂. Unfortunately, backwards compatibility prevents that.

@Adám damn singletons

(though i would personally blame ⍸⍣¯1 on not being able to know information it should (i.e. the original length))

It (kind-of) did in Iverson Notation.

@Adám how?

@dzaima Special vectors.

Wow, thought I'd found a better way to do something, timed it, 12000% increase in time, oh well

Just noticed that Iverson originally regarded all non-zero values as truthy.

@rak1507 tends to happen here lol

wow never seen a 204900% increase before, well now I have

@dzaima I did actually write some O(n) code for integer comparison scans in Dyalog, but decided it wasn't worth the risk of introducing bugs. It works on basically the same principle as the boolean case: some left arguments give the same result regardless of the right argument, once the right argument is boolean.

@Marshall I doubt anyone ever uses comparison scans for integers other than Booleans.

@Adám Ah, that wasn't quite right: I implemented the reductions, not scans (the benefit being that reductions can shortcut and be sublinear). And these are used, but only on an axis of length 2.

@Marshall Wait, if they are only used on axes of length 2 (I agree on that), then there's nothing to shortcut, is there?

@Adám You can stop after one comparison. Which is what you would be doing anyway. I think the shortcutting version came out to be about the same speed as the one Dyalog has now, but a dedicated length-2 reduction method would be much better than either.

Announcement: Webinar on 18.0 extensions to X⊂Y and ↑[ax]Y in an hour on dyalog.tv.

@dzaima and anyone else interested: I've been thinking that characters should be treated as an affine space in BQN (like the points in a plane or line, which have relative position but no particular origin). That means you can add or subtract numbers from characters, but not add two characters or negate a character.

@Marshall what about subtracting two chars?

Following a little-known but good way of thinking about affine spaces, a character is a number plus one "characterness" (which comes from an origin character, probably null). Characterness is linear and an operation is allowed if it results in a value with zero or one characterness. Negating a character gives -1 and adding two gives 2, so they aren't allowed. Of course a character result also has to be a valid code point.

@ngn Yes, that works too. In theory you could also do (a+b)÷2 where a and b are characters, but since the intermediate result a+b isn't valid you have to work around with a+(b-a)÷2.

This means you can get the alphabet with 'a'+↕26, and •UCS can be replaced by adding or subtracting the null character. Since you probably don't want the null character in your source code, there should probably be a primitive or system value for it.

If you subtract the characterness do you get the codepoint? 'a' - ? = 97

oh, yes; cool

@TessellatingHeckler I guess you figured it out but characterness is a property and not an actual value: every character has one characterness so any one of them is equally valid as an origin point. If you've ever wondered about the distinction between points and vectors it is the same: a point has one pointness and a vector has none.

@Marshall following this logic: 'c'='c'*1 and 0='c'*0 :)

The theory would also imply 0×c and c÷∞ give 0 while 1×c and c÷1 give c. This kind of makes sense, and it's nice that 1 would be the identity element of × over all data values, but I'm not sure I'd require it of implementations.

@Marshall Shouldn't mix pad with null chars?

@Marshall can't say I have wondered about such a distinction; are you saying if you add pointness to a vector, you get ... a point?

@Adám Actually this gives a reason why the pad doesn't have to be a null character, because it doesn't give any direct correspondence between numbers and characters. We can say null is the smallest valid character (but we could do that with TAO anyway), but we can't say it is like 0 in any way.

Webinar in 2 mins.

@TessellatingHeckler If you add an origin point to a vector (which necessarily has one pointness), you get a point. You can't just add one pointness; there's no such thing.

@TessellatingHeckler a vector and a point require storing the same things - a single x and y position. The difference is that a point has a specific origin whereas a vector doesn't

and it turns a relative path into a fixed path, huh

this reminds of the two kinds of temporal types in k - cuando (when) vs cuanto (how long)

that would be a System.DateTime vs a System.TimeSpan in .Net?

@TessellatingHeckler no idea

@ngn Yep. Time is a 1d affine space!

in that you can add a datetime + timespan to get a new datetime, but you can't add two datetimes

@TessellatingHeckler yes, sounds right

it's also similar to the distinction between ordinal numbers (indices; affected by ⎕io) and cardinal numbers (lengths; immune to ⎕io)

@ngn So it is. I hadn't thought about it that way before. That explains why ⎕IO←1 breaks mainly when you scale indices.

@ngn beautiful

In that interpretation the ⎕IO question is whether to use the earliest position in an array as the origin (0) or a virtual position just before it (1).

@Marshall for me there's no ⎕io question - always use 0 :)

@ngn now the BQN question will be what's the ⎕IO of characters :p

(also i wonder how'd APL look if ordinals and cardinals were different types)

@dzaima There's no index operation, so no need to choose!

@dzaima This is exactly the pointer/index distinction from C, so a lot like that. I don't know how I missed that pointer/index is the same as point/vector. I've spent so much time with both. It's like finishing two entire halves of a jigsaw puzzle and I finally learned they go together.

@Marshall oh wow

"Oh, this brings me to another example of an affine space: The space of pointers in C"

In much greater depth

I guess I could just use ␀ as the literal null character. @ is also possible as ^@ sometimes represents null.

Javascript BQN now supports affine characters! + and - only, not × or ÷.

@Marshall could you give an example of how this behavior is different? (the "how can I use this change?")

ah so it seems like instead of a explicit list 0,1,2,3,4,5,6,7,8,9 its using a point & offset

does this effect anything outside of the compiler?

@cannadayr It should mean that you can do 'a' + 3 and get 'd' without having to do ⎕UCS 3+(⎕UCS 'a')

oh nice gotchya

hmm, presumably 'abc'+3 does scalar expansion(?) and becomes 'def'? and 'abc' + 1 2 3 becomes 'bdf'?

All sorts of possibilities. Get the Greek alphabet (with both initial and final sigma) with 'α'+↕25; quick lowercasing for the latin one by adding 32; find the value of a digit by subtracting '0'.

@TessellatingHeckler Yes. Try it out here.

inb4 my favourite nitpick; ২ is a perfectly valid digit according to regex \d

@TessellatingHeckler what regex engine? I tested grep on osx & linux and it didn't match

@Marshall Nice! mlochbaum.github.io/BQN/try.html#code=IjQ1NiItJzAn this has got to be one of the golfier ways to get the digits of a number.

@cannadayr my default regex engine, .Net (PowerShell / C#). It's also not PCRE compatible, so maybe that matters.

ahh yea i dont mess around w/ windows hah. there be dragons.

if I cant recompile my operating system, is it really mine?

PowerShell and .Net Core are MIT licensed, open source, and macOS / Linux compatible these days ;)

just ... beware of the telemetry, because there always has to be a Microsoft catch

dont trust microsoft

^ exactly

chromium is open source but that doesnt make it foss imo

@TessellatingHeckler dzaima/BQN regex (•_R_) doesn't recognize it, but of course if you want to then there are ways.

@Marshall not that I particularly want to, I merely nitpick when people use \d to validate Arabic numerals, not realising it (in .Net) also covers numerals from other number systems

@TessellatingHeckler Ah, yeah, I can see how that could cause some problems.

mlochbaum.github.io/BQN/try.html#code=J+CnqCctJ+Cnpic= translation compared to Bengali-0 to the rescue to find the value :D

Another cool property is that if you have a runtime that optimizes with 1-byte ints, but only signed ones (such as Dyalog), you can convert directly from one-byte characters (ÿ and earlier) to one-byte ints by subtracting 128+@ instead of @, where @ is the null character. In Dyalog you'd probably need ⎕DR to avoid going through 2-byte ints and wasting memory.

@TessellatingHeckler With PCRE you have to turn UCP on to get that behaviour.

Oh no I missed the webinar :(

@rak1507 It is was recorded, and the slides are also available for download.

Yeah, I'm watching it on youtube just now

Ooh that partitioned enclose thing is so cool

Yeah, I'm happy how that extension turned out.

There are so many cool features in the primitives, I really need to read more docs

Explaining -style=max is pretty handy too

Wow, just upgraded from 17.1 -> 18.0 and seeing around 25% speedup on average for my AoC answers

Planning to do a video on 2019 day 14 in the near future, 18.0 puts my part 2 solution at 140µs which is faster than anything I see on Reddit

@voidhawk looking forward.

@voidhawk including k?

Haven't checked yours :)

@voidhawk did you mean milliseconds (not micro-)?

Nope, micro

@voidhawk dyalog can't even start in that amount of time :)

Yeah, I'm just using cmpx in RIDE, I guess it's not really a fair comparison

@voidhawk it's fair, i just have to use \t to measure in k, not end-to-end

For the entirety of p14 (read from disk, parse, p1, p2) cmpx gives me 770µs

@voidhawk is this your solution?

I made some changes, hold on

no rush

gist.github.com/voidhawk42/398091adbf8339186712b5422edb7c63

@voidhawk thanks! i'll test in a moment

on my laptop cmpx says 8.8e¯4 for both parts. that's close to your measurement.

Nice, I tested on a desktop with a fairly recent processor

i7-8700 apparently

mine is an i5-7200U

my ngn/k solution takes ~64ms. my k9 solution takes ~6ms. (but my algorithm is probably bad)

i'll have to translate yours for a fair comparison

Thanks, that'd be cool to see - aside from parsing I'm not really using any fancy primitives, just matrix indexing/math

I was surprised that ⌈/r in line 3 is faster than directly indexing with n⌷⍤0 1⊢r but apparently it is (??)

@voidhawk on the second line, why do you have to enclose i⍳⊂'FUEL'? it's a simple scalar

Yeah, refresh

I mistyped it

i'm moving too slowly, only a line and a half so far :)

Lol

Made some changes that get me down to 7.4E¯4

Might just be noise at this point

i suspect that after i get past r×⍤1 0 it will get easier..

yay, i did part 1 (in k9)

Nice!

turned out the ×⍤1 0 is just * in k :) (in this particular case)

Oh neat, k has leading-axis agreement (think that's what it's called)?

@voidhawk i guess you could put it that way

k has only scalars and vectors. for matrices we use vectors of vectors.

@ngn If a vector of vectors can be jagged (non-rectangular), how does K deal with them when it is passed to a matrix function?

@Bubbler i think the only interesting case is "flip" (i.e. transpose, monadic +). there are different opinions about what it should do - pad, repeat, or error.

@Bubbler can you think of another primitive that relies on the argument being a matrix?