12:18 AM
@Lynn Nice!

I still want to sub-divide them semantically a bit, but… this is a good start
Actually grouping them by meaning/subject (like “Primes”) is probably more useful than this, really

9 hours later…
9:15 AM
@Dennis I need some support for this answer. I don't think the `0Ȯ3¡1Ȯ3¡0Ȯ3¡1Ȯ3¡` is golfy enough, I want to merge the two halves into one.

7 hours later…
3:54 PM
@Dennis how come `I` doesn't work on string? Is there generally no arithmetic on characters?

@MartinEnder No, not yet.

4:34 PM
@EriktheGolfer I'd suggest taking a look at the accepted answer instead. Using a similar technique, you can get a 7 byte solution.

4:45 PM
@Dennis I specifically wanted support for that portion, to not repeat the same thing twice.

4:58 PM
I feel like generating such a bit table (transposed) should be a built-in; it’s come up before, to me, at least
A table of all z-bit numbers, in binary, left padded with zeroes, giving a 2^z × z binary matrix
Huh, it’s a bit surprising that `Ṡ` is conjugate for complex numbers, not sign

How would you define the sign of a complex number?

z / abs(z) if z else 0
So the sign of 5+5i is 0.7071+0.7071i, and stuff. Basically rescale it to the unit circle.
In mathematics, the sign function or signum function (from signum, Latin for "sign") is an odd mathematical function that extracts the sign of a real number. In mathematical expressions the sign function is often represented as sgn. == Definition == The signum function of a real number x is defined as follows: sgn ⁡ ( x ) := { − 1 if ...
Oops, the onebox doesn’t make it clear, but that specifically links to the “Complex signum” section

@EriktheGolfer The thing is, there is no golfy way to do what you're doing, no straightforward way to do `0Ȯ3¡1Ȯ3¡` twice. You won't be happy golfing in Jelly if you don't treat it like an array-manipulation language.
@Lynn Hm, yeah, that might have been useful.

@Dennis I tried lots of ways. @Dennis Also, I think this part of the Quick documentation is a bit misleading: (`¤`) Nilad followed by links as a nilad.

It’s true, though! `¤` is like a right parenthesis.
`2×5‘` prints 11, and `2×5‘¤` prints 12
`¤` wraps a nilad (`5`) followed by links (`‘`) into a new nilad (`5‘¤`)

5:11 PM
`2×5‘` is `(2 * 5) + 1`, while `2×5‘¤` is `2 * (5 + 1)`. "Followed" is an incorrect term, since it is preceded, not followed by.

@Lynn In general, an atom that left-pads rows of a matrix might be useful too. Currently, the shortest way is `Uz0ZU`, which isn't particularly golfy...
@EriktheGolfer It's only preceded if you read it right-to-left. I don't.

I guess the terms are ambiguous. If Jelly reads `5` first, and then `‘`—yeah.

@Lynn I think "preceded" means "before", while "followed" means "after", although they are ambiguous, so they can be easily confused. Also, there is no syntax sample there.

Oof, there should be one, yeah.
`<nilad><link><link>…¤` syntactically behaves as a single nilad”. How’s that?
Maybe `<nilad><non-niladic links>¤`
Maybe `<nilad><monads/dyads>¤`
Documentation is hard. Describing Jelly in the Tutorial has been a rewarding challenge. (◡‿◡✿)

2 hours later…
6:51 PM
@Dennis Well, I looked at that answer, but I can't seem to find the "transpose" atom.

1 hour later…
8:08 PM
Z

8:31 PM
@EriktheGolfer Transpose is called zip in Jelly. `Z` transposes without filler, `z` transposes with filler, and `ż` (sort of) works like Python's `zip`.

@Dennis No, not that, the one on the J answer. I looked for it, but I guess it's not zip.

Yes, it is. `Z` behaves like J's `|:` when the arrays have the same length.

The technique used on the other answer roughly translates to `⁴ḶB`. I think I'm supposed to do `F`, then form chunks of length 4.

That wouldn't work. You need to left-pad all binary representations to the same length, which can be achieved with `z`. `z` pads to the right though, so you have to reverse the rows first.

@Dennis Umm... so, the filler is the array itself?

8:48 PM
`z` is a dyad. You have to specify the filler or the chain will fork and use the left argument.

@Dennis That's what I assumed, so, transpose works by using the array itself as a filler right? (sorry I'm a newbie)
Till now, I have constructed 5/7 bytes.
`⁴ḶBṚz`
The outcome is not good though, as it seems to have `16`s in it:
`[[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0], [1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 16, 16], [1, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 0, 16, 16, 16, 16], [1, 0, 1, 0, 1, 0, 1, 0, 16, 16, 16, 16, 16, 16, 16, 16]]`
Using `⁴ḶBUz`, the outcome is better.
`[[0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1], [16, 16, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1], [16, 16, 16, 16, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1], [16, 16, 16, 16, 16, 16, 16, 16, 1, 1, 1, 1, 1, 1, 1, 1]]`
It seems like I need to move all `16`s to the right, then translate them to `0`s altogether.

@EriktheGolfer That's because `⁴` sets the left argument to 16, and you don't provide a right argument to `z`. Try this instead: `⁴ḶBUz0`

@Dennis Yeah, I thought of it.
7th byte can be `G`, but, as the comment section there says, it might just not be fit (although the answer is accepted, that means I can use it)

Better use `Y`, which avoids the spaces.

@Dennis Found it before looking!!
(yay, built my code myself! [will add credit to help])

9:15 PM
@EriktheGolfer Nice work. That answer cannot be accepted though since the challenge is from 2013; Jelly was created only 8 months ago. In fact, you should add non-competing to the header, as the CJam and MATL answers did.