00:00 - 21:0021:00 - 00:00

12:01 AM
I wonder if I should put C++ on my resume, given I don't know it well now but have three months to actually figure it out before I'd be tested on it in an interview.
I'm applying for a summer internship that asks for JS, Python, Java, or C++ and I have 3.5 out of those 4 covered.
Oddly enough, it's a Microsoft internship, and they ask for Java and not C#.

I wouldn't put C++ then. It is an or, and you'll look like a real tit if you don't learn it for any reason

Happens

I panicked and didn't correct them

Good job

12:14 AM
is my cmc incomprehensible?

Maybe
I can't understand it

@LeakyNun Nope. Haskell 46 bytes: TIO

I had to read it a few times to understand it. It is well formed but maybe could be worded more clearly
By well formed I mean it is possible to understand what you mean

^^^ is slightly invalid

@H.PWiz lol, was about to point out
(to everyone) ping me if you don't understand the CMC

12:19 AM
@LeakyNun Can we output `1` as `0.99999` for example?

@H.PWiz yes
but you can't output `70.0303...` as `69.(10)2(10)2...` :P

@LeakyNun I think I understand it, but I don't understand outputs the n-th digit when given n, and given n,

so `f(0)=23, f(1) = 1, f(2) = 2, f(3) = 1, f(4) = 2, etc`

Is the second n the length of the digits?

`f` represents the real number `23.121212...`
so `p(f,0) = 69, p(f,1) = 3, p(f,2) = 6, etc`
`p(f,_)` represents `f*3`

12:21 AM
I get that, I'm just not sure what n we're given

p(f,n) is the n-th digit of "f*3"

Ah, I get it now

sorry, will reply less frequently from now

If `f` represented the number `1.997` would `p(f,1)` be `9`?

1.997 * 3 = 5.991
yes

Anonymous
12:29 AM
So this CMC requires laziness... Definitely a job for Haskell

Not necessarily

Anonymous
@H.PWiz Well, not exactly requires, but it's probably the least painful way to solve it :P Working with infinite lists is hard

hint: there's more to the cmc than the surface

wait who said "no onë sanë" i wasn't ready to talk yet
@NieDzejkob you called?
Why do you people only talk when I am not talking :|||

Anonymous
@Christopher Allow me to introduce you to a little topic called "time zones" :P

12:36 AM
@Mego Wait you guys have timezones? Imma have to talk to geobits about fixing them so they all are in EST
@DJMcMayhem i sandboxed Text to BrainFlak
I cannot decide on what to say to express my frustration so I am saying this instead

@H.PWiz are you fixing it :P

I'm looking at doing it APL. So don't hold your breath

0

Guidelines Task This is a tricky one. You need to take any positive integer up to four billion and turn it in to plain English. You do not need any capitalisation or punctuation, but you need to include and's where necessary. You can assume that you will always get a valid input. Examples 1...

@Christopher I saw that. It looks good, but you'll need to specify what texts it is being scored on

12:48 AM
Yeah

I'm not sure about the general utility of a complex-conjugate builtin

@LeakyNun I believe this is impossible for some inputs, like 0.3333333...

@ØrjanJohansen you can output either 1.000... or 0.999...

@Οurous Like APL's `+` ?

12:51 AM
@LeakyNun Hi Kenny.

@LeakyNun No you can't, because you will never know that it won't suddenly get a 2 or 4 in there.

@ØrjanJohansen bingo
19 mins ago, by Leaky Nun
hint: there's more to the cmc than the surface

@Adám I'm going to assume so, but I mean in the context of a 2d language where I can only have so many builtins.

you win my respect :P

Yay!

12:52 AM
this is equivalent to solving the halting problem

Oh ..., shame I didn't see that :(

@Adám Also is that just a plus sign?

@Οurous Yes. Monadic `-` negates both real and imaginary part. `+` negates just the imaginary part.

Anonymous
@LeakyNun In theory, yes. In practice, not necessarily. In a language with fixed-width (or otherwise limited) integers, the value represented by `f` is guaranteed to have a finite number of decimal places :P

Since Haskell doesn't have for loops, what's the best way to get a list of tuples like tio.run/##y0osS9TNL0jNy0rJ/v@/… ?

12:58 AM
@Pavel You linked to Hello world in java

@Mego not really
I can output 3 in a loop

@Potato44 oops
Basically, nested for loops

Anonymous
@LeakyNun Sure, but `f(INT_MAX+1)` isn't a valid function call, so it's impossible to output more digits than the maximum value of your data type.

Like, one for loop is just using an array range

@Pavel depends on what you are doing with the for loop, like a foreach loop?

1:00 AM
@Potato44 Just need a list of tuples (1, 1), (1, 2), (1, 3), (2, 1), (2, 2)...

Anonymous
@Pavel `[(i,j)|i<-[0..4],j<-[0..5]]`

Lovely

@Adám That irritated me at first, but it the longer I think about it the more I like it. I think I'll re-purpose `z` for conjugate and `Z` for "is a finite number". Thanks.

Jan 13 at 17:31, by Mego
When in doubt, steal glyphs from APL :P

Anonymous
Or `liftM2(,)[0..4][0..5]`

1:02 AM
Or `(,)<\$>[0..4]<*>[0..5]`.

Heh. APL is actually a lot like that for me: Cycles through "That's dumb" -> "I wonder why they would do that" -> "Oh I get it" -> "Hey that's actually cool"
4

@ØrjanJohansen I understood Mego's two, that one looks like black magic.

Anonymous
@Pavel It's identical to my second, but spelled differently

I've never seen triangle brackets in Haskell

Anonymous
`<\$>` is inline `fmap`, and `<*>` is inline `ap`

1:05 AM
@Mego you do have a point
but I work with Type 2 computability :P

Well, it's closer to `liftA2(,)[0..4][0..5]`

Anonymous
@H.PWiz Sure, but with lists, they're functionally identical

@Mego inline fmap, not mapM

Anonymous
@Potato44 Derp

The `...<\$>...<*>...` notation is equivalent to `liftA...` but (1) needs no import (2) works regardless of number of arguments.

1:07 AM
It works really nicely with Parsers

Anonymous
If you want even cleaner code: `sequence[a,b]`

I use Haskell so I can apply the functional patterns i learn to System.Linq and bring my C# programs closer and closer to being just one obscenely long statement.

Anonymous
@Pavel Psh, nothing obscene about long statements. Pointfree is the glorious standard which we all strive to achieve.

Also, the triangle brackets are just convention, `<\$>` and `<*>` are operator names.

btw for a more feasible CMC: multiply by 2 instead
(this is feasible)

1:09 AM
Or if you mean why Haskell doesn't use `<....>` as general bracketing, that's also because `<` and `>` are operator chars, not delimiters.

@Mego Not always pointfree, it's lambdas all the way down.

Anonymous
@Pavel Then make it pointfree :P

@Mego No operator functions. How do you make `n=>n+3` pointfree?

With currying

In Haskell, `(+)3`, in C#, idk.

Anonymous
1:10 AM
@H.PWiz Exactly

@H.PWiz I'm still left with named arguments

Anonymous
`var Plus = a=>a=>a+b`

Anonymous
Your constructs to write pointfree code don't have to themselves be pointfree

@Pavel I think most haskellers would prefer `(3+)`

Anonymous
That allowance is given for languages that are not designed with the light of pointfree in mind

1:12 AM
I'd prefer `(+3)`

Anonymous
@H.PWiz Yeah I always write `<op><arg>` and not `<arg><op>` unless `<op>` isn't commutative

F# should be my favorite language, because I love the capability of the .NET platform, and I love the functional aspect that System.Linq gives, but for some reason it isn't.

Never mind, that's wrong.

Easy CMC: Let's just multiply by 10 instead

1:17 AM
It's everything I like about C# with some extras thrown in, but I just can't get into it.

Anonymous
@Pavel To me, F# is almost there. The lack of an arbitrary-width integer type in .NET frustrates me

@Mego There's a `BigInteger`

Anonymous
...I need to use .NET more

Also, the decimal type goes up to `79,228,162,514,264,337,593,543,950,335`.

...octillion? is that the word? Indeed it is

1:24 AM
If you need more than that you might be doing it wrong

@MDXF What encoding does cubically output in?

@LeakyNun APL 24 bytes

one of your cops outputs characters in it but I can't tell if it's proper without knowing the encoding

@H.PWiz nice

Although, I think some of it is redundant

1:29 AM
@H.PWiz If the operand will always consist of scalar functions, then the `¨` is unnecessary.

Yes, but my examples were harder to write as scalar functions

CMC: what types of loops does your chosen language have?

@totallyhuman C#: for, foreach, while, label/goto, recursion

@totallyhuman For-In-EndFor, For-InEach-EndFor, While-EndWhile, While-Until, Repeat-EndRepeat, Repeat-Until, ApplyToEach, ApplyNTimes, ApplyUntil, GoToLine, Label, GoToLabel, Recursion.

.oO( Define "loops" )
(Also "have")

1:39 AM
F# is the same as C#, but will tail-call optimization

Recursion, `mapM`/`traverse`, `mapM_`, `sequence`, list comprehensions, `do` expressions (in the list monad).

@ØrjanJohansen I'd argue that most of those aren't loops but list transformations.

Ah yes, I forgot, mapping, reduction, cumulative reduction.

Well my argument is that in Haskell, lists are loops in many respects.
Especially after GHC gets done fusing them.

Naturally C/F# have a collection of standard mapping/reducing/whatnot builtins

1:44 AM
Which is one reason why there are so few "real" loop constructions.

Also `IEnumerable<T>.ForEach`

@totallyhuman Recursion, various comprehensions / state folding / iterative applications / (etc.). If you count inline intermediate language, you can add everything you find in your standard assembler language (goto / jmp / jmpz, etc.).

(Without import libraries.)

(yes that means you can `goto label` in a functional language)

(lol I'm totally not stealing ideas for my golflang)

1:48 AM
@Οurous would that break everything though
Because of lazy evaluation, you don't know the order that stuff will execute in

so far I've thought of infinite, foreach, first n, while, until

@Pavel Actually, you do, by the time you're in the IL. You can only jump inside the same IL section, so it works. It's really bad, but it works.

I've tried all of his languages and almost every esolang on TIO
it has to be something obvious

@quartata Got it

@Pavel V, recursion.

1:56 AM
@H.PWiz how what is it

Cubically -6

I guess it also sorta has a for? Not really

It's not cubically

More like a do N times

Unless it's using a weird encoding

1:57 AM
`-6` flag

Anonymous
@H.PWiz Gah. People need to remember the "include any flags you're using" rule!

....
you're right

That was literally the first thing I tried

I didn't try any flags because it wasn't in the bytecount
@MDXF you have to include command line options in cops

43 minutes left ha

1:59 AM
@totallyhuman literally tried it twice because I thought maybe a cosmic ray hit it the first time
@totallyhuman doesn't matter, would have been ruled invalid

Anonymous
It's frustrating that a decent number of the cops that went uncracked for a while were because they didn't include the flags like they were supposed to

yeah plus I could've crossed the snippet's graph's limit again
:P

All right that leaves these two:
2

???, 8 bytes One last crack at a short one. gD[Lxe]O Outputs as raw

2

???, 11 bytes JuvlikaJoEs Outputs decimal with newline after every number.

I think I know the first one
one sec
second one could be almost anything...

2:15 AM
@quartata Except a non-obscure, general-purpose language.

2:26 AM
hrm OK the first wasn't what I thought

2:56 AM
hmm
somebody could totally do codesins
like cinemasins
or even golfsins

3:17 AM
The second one almost looks like Tomato.

4:00 AM
I don't think that has an esolangs page

4:24 AM
Or a working implementation

1 hour later…
5:25 AM
@mudkip201 I was doing this challenge and I immediately thought of the one byte answer, but it didn't seem to work correctly. Isn't input implicitly put on the stack, therefore summing should sum the input?

@tfbninja I don't know pyt, but I'm pretty sure it's just an input format issue: Try it online!

CMP: should iterating over a stack be destructive?

5:47 AM
Yes: by definition, a stack only lets you access the top item, so iterating over all items requires popping each one to get to the one beneath it. If you want non-destructive iteration, you've got a deque or a linked list or something else.
Or, you can push the popped values onto another stack and restore them later, in which case it's not "destructive" per se.

2 hours later…
7:43 AM
Just had a bit of fun implementing a brainfuck interpreter that supports arbitrary cell sizes

1 hour later…
8:55 AM
0

Guidelines Task Given a DNA strand, return its RNA complement (per RNA transcription). Both DNA and RNA strands are a sequence of nucleotides. The four nucleotides found in DNA are adenine (A), cytosine (C), guanine (G) and thymine (T). The four nucleotides found in RNA are adenine (A), cyto...

3 hours later…
11:55 AM
is the Bubblegum compression script public?

12:25 PM
LZ77 and LZMA 2?

12:40 PM
DEFLATE and LZMA 2, but you need to figure out all the right options, plus bijective base 96 decoding

1:13 PM
@tfbninja yes and no. Pyt only pulls input to the stack if a function call requires more items to be on the stack than there are

what’s the simplest (ie turing tarpit) language that can simulate programs the most easily?

if by "simplest" you mean the one with the fewest symbols, then Unary :P

2 hours later…
3:14 PM
Is there a way and is it a good practice to have a chat room associated with a particular challenge?

Create one, of course.
Good practice? ... There is nothing bad about creating a room, is it?
About associated, consider setting the feeds.

@user202729 Thanks. Later I'll try to figure out how creating a new room works. I guess I can associate it by simply putting a link to it in the challenge.

@ngn you can also put a link to the challenge in the room description; what challenge would it be about?
you can create a new room by clicking the "create new room" button at the bottom of chat.stackexchange.com, then enter its name, description and choose its host site and default access level, and then check if any possible duplicate rooms are suggested

3:39 PM
\o/ Physica can now take lists from STDIN
And \o/ some serial downvotes have been reversed

@totallyhuman At least Discord's bots support GH, compared to SE's feeds....

that happens for a reason, I don't think asking for messages is a good thing to do?

@EriktheOutgolfer my latest one, tetris strategy. There's an interesting discussion in the comments that's sliding off-topic. I'd like to respond to it without forcing potential solvers to read through all of the noise.

in that case a link should automatically appear after enough comments have been posted, and then the discussion will be copied over to a chat room; that's when you can flag the comments as obsolete (except the one which links to the chat room) :) note: the link may appear to somebody else too, not necessarily you!

@EriktheOutgolfer it's the same as an anti-freeze except I need other people :P

that's why I question it

4:14 PM
do you question anti-freezes too?

especially since using a sockpuppet to do that isn't allowed (doing something you can't do with only one account)
no I don't question anti-freezes

You're overthinking this.

thanks :D

@EriktheOutgolfer I've seen that before, it says "Room for X and Y" (only two users). Next time I'll click. If the room is public, that works for me.

yes, the room is public
actually the links asks you to move the discussion to a chat room, and if you click it then you'll post a comment that says "Let us continue this discussion in chat." (the bold part will be a link to the chat room instead)
yes, it will mention two users in the room's title, but I don't think that matters much, the point is to get the discussion off the comments

4:19 PM
@EriktheOutgolfer ah, understood. I've seen other users do that before. Thanks!

(you can also edit the comment during the 5 minutes you would normally be able to if you want to clarify anything about the move there)

5:03 PM
@mudkip201 ok that makes sense

@DJMcMayhem a bit late, but that challenge is about that specific input format :P

I have a conjecture
any solvable problem can be implemented in a single expression in python
does anybody know how to go about proving or disproving that?

Python is TC => Proven :P

well yes but can anything be a single expression

in Python 3, yes

5:08 PM
@7H3_H4CK3R Probably true for every language which trivially allows continuation of statements and expressions.

Because I managed to check the validity of a Sudoku in a single lambda

simply make a full program, convert it to a string and make it an argument of `exec` :P

`lambda grid: all(map(lambda x: len(x)==len(set(x)),grid + list(zip(*tuple(grid))) + [(lambda a: list(a[0]+a[1]+a[2]))(list(zip(*tuple(grid[3*y:3*y+3])))[3*x:3*x+3]) for x in range(3) for y in range(3)]))`
@Adám what exactly do you mean?

@7H3_H4CK3R I know APL best, so I'll use APL as example, but it surely applies to a multitude of languages:

@EriktheOutgolfer As long as the full program itself doesn’t contain `exec`, you proved it! :P

5:12 PM
why shouldn't it, of course properly escaping the string should be implied!!

@7H3_H4CK3R APL allows reshaping any data into an empty list with `0⍴data`. This then allows a "no-op concatenation" to any other data for further processing. E.g. The two statements `A←2,3` and `B←4,5` can be combined as `A←2,3,(0⍴B←4,5)`.

Oh TIL you can nest `exec`s o_O

There are language's that are tc without having an eval or similar, thus any solvable problem must be solvable without exec

@Mr.Xcoder How would you not be allowed to do so?

Well, carefully.

5:14 PM
@Mr.Xcoder yeah, why not

@Adám that's interesting, but does python allow that?

@EriktheOutgolfer I just did that too lol, char-to-char except for the `2`

I think so. Can't you chop lists to length-0 and append them to other lists?

I guess so....

@7H3_H4CK3R I question such languages...btw TC ≠ solvable in a single expression

5:16 PM
@Mr.Xcoder Same in APL.

I know tc != one expression

Oh that reminds me to either ban or implement exec-s in Physica

I was proving that you don't need an exec in a full program, so you also don't need nested execs in a single expression
But hang on any problem that requires a while loop can't necessarily be put down in one expression without some sort of hack

@7H3_H4CK3R Today, Dyalog APL has an infix function `⊣` which discards everything evaluated until now (although it doesn't delete variables) and returns its left argument. This makes it even more trivial to write anything in a single statement.

you could perhaps simulate one with a lambda generator, does that exist? Can I put a generator in a lambda?

5:20 PM
You can probably write a brainfuck interpreter in one line

that is actually one of the things I have tried a number of times but not managed even in multiple expressions
I always fail at loops

In one line, definitely. In a single expression, it is a bit harder.

Yes that's the point @Mr.Xcoder
maybe to restrict yourself to a single expression try packing your solved problem into a lambda
if you can supply a lambda and only said lambda to solve a problem
python obviously has the advantage of list comprehensions and functional operations

@7H3_H4CK3R That's nothing, PPCG has a "check a Sudoku in a single regex" code-golf challenge

5:37 PM
@EriktheOutgolfer Oh yeah, I know. I was just answering why that format didn't work

5:48 PM
@Adám Technically TC doesn't imply anything resembling normal I/O format (on esolangs we call that "BF-complete"), which might matter for some languages and challenges.
Hm maybe that should have been to @Erik

@7H3_H4CK3R I'm pretty sure that's true with `exec`

42 mins ago, by Erik the Outgolfer
simply make a full program, convert it to a string and make it an argument of `exec` :P

@ØrjanJohansen ...unrelated?
my `print` example was just to demonstrate the ability to nest `exec`s, nothing to do with TC-ness

@EriktheOutgolfer I meant this one.

5:59 PM
I'll try it. What's the easiest way to prove TC? Brainfuck?
(I'm going to try it without exec BTW)

Bitwise cyclic tag is often easier.

@ØrjanJohansen you can have full control of the output in Python...
especially Python 3, where the `print` function has an `end` argument so that you can omit a trailing newline

@EriktheOutgolfer I'm really just quibbling on the logic itself, "Python is TC => Proven :P" doesn't follow.

and, of course, `time.sleep` (import `time` module)

@7H3_H4CK3R Are imports allowed?

6:04 PM
@DJMcMayhem Or perhaps SKI calculus, in this particular case.
Or, well, aren't you basically starting with lambda calculus, Q.E.D.
(Might depend on scoping rules.)

Anonymous
@DJMcMayhem `__import__('foo')` is a statement

Anonymous
You can do anything in a single statement by simply passing `exec` a code object containing the compiled bytecode

I'm going to try it without exec though
@Mego Ah, perfect

well, you could ask "Is a functional language TC without recursion"

6:20 PM
@Mego why even compile into bytecode? just put the string directly there :P
well, the only downside is that you can't use magic comments, but, well, `ord` and `chr` to the rescue!

Anonymous
@EriktheOutgolfer Because it's probably shorter

lol proving TC-ness doesn't include golfing

Anonymous
Well sure, but if we're doing it, might as well make it short :P

our coding styles differ then ;P
mine is "first implement, then golf"

hmm... I think a repeated application of a list of regexes is turing-complete. Would it help?

6:27 PM
@EriktheOutgolfer Lol our coding styles are extremely different... Mine is “first golf, then fix the bugs” :P

How could you say `def(x): while x[1][x[0]]: x = (lambda x: ...)(x)` as a lambda?

why would you want to do that

you'll see

why not just directly do `x = ...` instead?

well, I figured that the solution could make it possible to only use x once, and the lambda is a workaround. Besides, if the lambda and the while condition were arguments, this could be some obscure builtin function

Anonymous
6:35 PM
@NieDzejkob `f=lambda x:x[0][1][x[0]]and x.__setitem__(0,(lambda x: ...)(x))or None`

Anonymous
I think that will work

WTF? How does this work?

Anonymous
Oh wait I missed something

uh, and return x at the end of course. We're doing functional

Anonymous
`f=lambda x:x[0][1][x[0]]and(x.__setitem__(0,(lambda y: ...)(x))or f(x))or x`

Anonymous
6:39 PM
`or` is used for sequencing of `x.__setitem__` and `f(x)`, because `x.__setitem__` returns `None`

I'd like to repeat that lambda expressions already are Turing complete.

I believe the `f=` at the beginning might make this not work as a part of a larger lambda

yeah assignments are not expressions

Anonymous
@NieDzejkob You can construct the Y-combinator with Python lambdas, so you don't need it

the fuck is a Y-combinator...

Anonymous
6:41 PM

@MartinEnder Yes, signed 32 bit
@quartata Default codepage?

Anonymous
In a nutshell: the Y-combinator is used to do recursion without an explicit name for the function (like in lambda calculus)

that will indeed make it very hard to make a quine. (and it also means that it's not guaranteed that a quine exists, as the language isn't Turing-complete with only a finite amount of memory.)

your computer is only a finite-state automata...

Anonymous
6:45 PM
@NieDzejkob Sure, but it has access to nearly arbitrarily-large amounts of memory (and therefore states), so it's close enough to a true TM that TCness can be considered in practical contexts

Anonymous
If the language could theoretically use infinite memory if it was available, we can still call it TC

@Mego technically speaking, 16 bytes is almost exactly as far away from infinity as 16 gigabytes
@Mego does it mean that C is not turing complete but a subset of it is? (C requires a pointer to fit in a fixed-width integer, AFAIK)

Anonymous
I think you're misunderstanding a core concept of TMs

Anonymous
TMs have a finite, arbitrarily-large number of states

yeah, but they have an infinite tape

6:50 PM
@NieDzejkob sure, just because a quine exists doesn't mean any existing PC could run it, but a language's memory is finite due to its spec, it's possible that you couldn't even write a quine that would theoretically work on a machine with infinite memory.

All TC proofs for real programming languages need to ignore implementation limits, it's just a question of which ones.

Anonymous
@NieDzejkob Yes. Look at it this way: with N bits of memory, there are M TMs that you can encode. If N is allowed to be arbitrarily large, then M will also be arbitrarily large. Thus, the number of TMs that you cannot encode with N bits (¬M) approaches 0.

CMP: Write a cubically implementation that uses bigints

Anonymous
Look at it like an epsilon-delta proof

all I'm saying is that the proof for the existence of quines in programming languages rests on their TC-ness, and a language that essentially contains a single 32-bit register is so far from TC that there's no reason to assume (by default) that a quine exists.

Anonymous
6:53 PM
The problem with Cubically is that N is not allowed to be arbitrarily-large, so it cannot be considered TC by the practical definition, much less by the theoretical definition.

if the official spec imposes the limits, then if you reimplement the language with a larger integer type, you would be essentially not reimplementing the language at all, but instead implementing a new language

Anonymous
@EriktheOutgolfer I don't think anyone was arguing that that wasn't the case

6 mins ago, by Ørjan Johansen
All TC proofs for real programming languages need to ignore implementation limits, it's just a question of which ones.
I was mostly referring to this
unless it's an implementation limit and not a spec limit, then it cannot be ignored

@MartinEnder yeah that's why the bounties are so big

7:18 PM
@Mr.Xcoder I'm more of an "implement in a golfed format" person.

Whee!

The right language for the job! Lol — DJMcMayhem 7 secs ago

Just wanted it posted before I logged off. See ya!

\o
CMC: Given a square matrix, check whether all its diagonals are palindrome.

7:40 PM
@Mr.Xcoder How many diagonals does a 4×4 matrix have?

For example, `[[1, 2, 3, 4], [1, 2, 3, 4], [1, 2, 3, 4], [1, 2, 3, 4]]` has the following diagonals: `[[1, 2, 3, 4], [2, 3, 4], [3, 4], [4], [1], [1, 2], [1, 2, 3]]`

Are those going top to bottom or bottom to top?

Starts with the main diagonal, then goes to top-right, and then goes from bottom-left to the main diagonal

Shouldn't be too hard in Husk either, I'll attempt it.
Btw I'd like to see a Python and a Haskell solution
Husk, 7 bytes. Perhaps @H.PWiz can give some tips?

7:56 PM
@Mr.Xcoder You don't need map reverse, only reverse. Since palindromes are still palindromes when reversed

but then he would be taking the antidiagonals instead

8:20 PM
@Mr.Xcoder Husk, 4 bytes

Nice

Hmm no, that only works on square matrices.
Oh right, they are square

8:42 PM
CMC: Given a printable ASCII string, check whether the last digit occurs before the first letter. E.g. `"&\$#47*1d\$:YdB="` is truthy, `"/49--dEG?*4"` is falsy.

@Zgarb Will there always be a letter and digit?

@Pavel Sure.

@Zgarb `perl -pe s/[^a-zA-Z]+\D+//` outputs nothing for truthy and garbage for falsy.

@Zgarb V, 8 bytes: `ø^Á*áÄ*\$`
Compressed regex FTW
Oh wait, I guess it should actually be `ø^Á«áÄ«\$`

CMC: write the fastest program to output the shortest sequence of pancake flips to sort an array

8:57 PM
...

00:00 - 21:0021:00 - 00:00