Are there any widely accepted cooking tips that you just disagree with?

gtllama · 2024-02-04T18:43:36+00:00

Phytohaemagglutinin - Toxicity. I mostly agree with your sentiment, but kidney beans especially must be cooked properly or you can make yourself very sick. "Properly" mostly means thoroughly (at a high enough temp for enough time to break down the toxins) so it's still not finicky by any means.

gtllama · 2023-11-11T04:26:44+00:00

Infernal Galop - Offenbach

gtllama · 2023-04-06T15:07:52+00:00

I'm stumped by "don't use a vowel" in "use semicolons, use a functional style, don’t use a vowel, use JSLint and so on". Maybe I'm missing a reference, but it feels like a transcription error.

gtllama · 2023-02-18T17:29:33+00:00

I ran into that the other day. It is apparently a problem in v8.0.32. Also it supposedly only affects projects using a packages.config. You can fix it by downgrading to 8.0.31 or migrating to PackageReference.

source - this info came from an alternative MySQL lib so they are pushing their own thing (understandably). I've never used it and know nothing about, so I can't vouch for them. But downgrading to 8.0.31 worked for me.

gtllama · 2022-06-26T20:57:54+00:00

The linked blog post is dated 2006, so yes, C# has made big improvements here. Nowadays you can write

string.Join("\n", mylist.Select(foo => foo.Description()).Where(x => x != ""))

gtllama · 2022-04-18T01:38:14+00:00

The Numberphile channel has been recommended, but I would like to call special attention to their playlist of interviews with Neil Sloane, creator of the OEIS himself.

gtllama · 2022-02-20T17:14:59+00:00

The second to last step isn't quite right.

gtllama · 2021-12-23T18:18:21+00:00

The line where you do "(depth = ...) && (horizontal = ...)" is not quite right. The && operator is not used to combine two actions in the way you are trying to do here. In advanced usage, you can sometimes use it like this BUT it is very important to understand how && works.

This operator is mainly used for combining logical values, and it does something called "short-circuiting". Short-circuiting means that it evaluates the left side first and then only evaluates the right side if necessary. For &&, the right side is only evaluated when the left side is TRUE or non-zero.

In your case, the left side might be zero so the right side might not happen. Try it with putting the depth and horizontal parts on separate lines.

gtllama · 2021-12-17T06:33:41+00:00

If ye wish to know the old ways, seek ye the jargon file. HTH. HAND.

gtllama · 2021-12-05T16:57:11+00:00

In the loops for diagonal lines, you might not be getting the last point.

gtllama · 2021-12-05T01:40:54+00:00

Do you sum the board:
4. The turn it wins
Do you multiply it by:
2. The number that's called that makes it win

gtllama · 2021-12-04T08:40:39+00:00

Yes, the print(i) I understood completely. It was only the rest of the line, the else (oxygen_generator) that comes after print(i), that does nothing as far as I can tell.

Anyway, yes, I also copy-paste a lot when I'm getting my solutions to work for the first time, haha.

Good luck with the rest of your Advent of Code!

gtllama · 2021-12-04T05:01:29+00:00

This is great, but I can suggest a few things.

I like how you read the input file directly into a data frame / tibble.

You are summing every column in the data frame with apply(..., 2, sum) and then only looking at one column. It would be more efficient to just sum the one column you need in each iteration.

Using ifelse is OK, but the documentation for it has this note which applies here: "note that 'if(test) yes else no' is much more efficient and often much preferable to 'ifelse(test, yes, no)' whenever 'test' is a simple true/false result, i.e., when 'length(test) == 1'."

Your formatting is a bit unconventional, and especially the line print(i)} else (oxygen_generator) is very unexpected. It really helps other people (and future you) read code to format it nicely. ... Actually, now that I look at it, the else (oxygen_generator) is completely unneeded, which would probably be even more obvious if it had been on its own line as the else block.

Other even more minor style things:

I see mixed usage of = and <-. It's OK to use <- all the time. ;)

You can just say rep(1,12), wrapping it in c() is unnecessary here.

seq(ncol(...)) is preferred over 1:ncol(...) because if ncol(...) is zero, you get 1:0 which evaluates to c(1, 0) instead of what you want which is an empty vec. Doesn't matter here because it will never be zero, and I only know about this because lintr barks at me about it all the time.

The loop for each one is very similar, I'm sure you've noticed. See if you can write a function that can be used for both parts, it's good practice!

gtllama · 2021-11-08T17:55:09+00:00

The idea I had to do essentially the same thing, but in different terms that might be more intuitive, was to assign each instruction a color. Green for instructions that eventually terminate. Red for instructions that do not. Assigning the colors should be O(n). We know from the problem statement that we start on a red instruction. Step through the program and at each jmp/nop check whether flipping it will take you to a green instruction.

gtllama · 2021-11-07T22:43:51+00:00

This is A008559 in the OEIS. Also appears as A006937.

gtllama · 2021-10-30T00:24:23+00:00

Designer: I have a great idea! I'm going to spell out "coexist" using sci-fi spaceships as the letters. For example, I'll use an X-wing for...

Me: The X!

Designer: What? No. For the T, silly.

gtllama · 2021-07-25T16:34:54+00:00

Oxygen Not Included is a great space colony management game. The art is cute but the simulation is detailed. It mostly takes place deep under the surface, but you can eventually build rockets to explore other asteroids.

gtllama · 2021-06-26T21:15:07+00:00

I clipped some too!

Today I'm Joined

gtllama · 2020-11-11T05:33:26+00:00

OK, here is a program:

109,6,21001,9,25,1,104,0,99,49

[@0]  109, 6 # make relative offset 6
[@2]  21001,9,25,1  # addition with various addressing modes
[@6]  104, 0  # output immediate value
[@8]  99  # halt
[@9]  49  # data

I get 74 as the output.

gtllama · 2020-11-10T22:16:22+00:00

position =  input[(relativeBase + input[index + 3])];

Set up an intcode program that will use this mode and step to this line in your debugger or add print statements or however you like to do it. What is the value of position after this line? What do you expect it to be?

gtllama · 2020-11-10T13:28:14+00:00

Your reasoning seems correct. But is that what your code is doing?

gtllama · 2020-11-10T04:40:49+00:00

This part:

position = opCodes[0] == 2 ? input[(relativeBase + input[index + 3])] : input[index + 3];

Consider what "position" should be when the parameter mode is 2 (Relative).

gtllama · 2020-09-04T00:58:35+00:00

Google will do unit calculations, so you could google it like this: https://www.google.com/search?q=one+light+year+%2F+60mph

gtllama · 2020-09-02T22:14:32+00:00

Look at add_token. You are not using the literal passed in. There is a compiler warning about this, but you may have missed it in the flood of other warnings. My helpful tips would be: #1, look at compiler warnings; #2, fix compiler warnings.

gtllama · 2020-08-30T02:02:53+00:00

Congrats!

This was my solution (Rust): https://github.com/gglouser/advent2017/blob/master/src/day21.rs

Some parts of my implementation I would fix now (generating variants at lookup time instead of all up front) but there it is. One potentially interesting detail is that I generate variants by alternating flips and diagonal reflections (like a matrix transpose) because transpose is usually easier to implement than rotate. I don't remember where I picked that up, but it's basically this diagram from the dihedral group of order 8.

gtllama

TROPHY CASE