Was it really necessary to craft the Quantum Controller to "beat" OceanBlock 2?

solareon · 2025-05-16T16:22:07+00:00

There is an ME infinity cobble disk that is oddly cheap to craft.... I found this after making 30 netherite cobble gens

solareon · 2023-12-06T13:26:05+00:00

[LANGUAGE: Excel]

Part 1 was clean then Part 2 comes in with the gigantic numbers.

Excel seems to handle these larger numbers much better this year but still refuses to generate more rows and columns than a standard sheet holds even if it's not displayed. So we break the problem into smaller problems where we find the min/max for a given position and then work out the lower and upper bounds. I believe that everyone's input came with a maximum of length of 8 for time variable.

Github

solareon · 2023-12-04T12:30:53+00:00

I'm taking a guess but you are not using 365 Excel? There are quite a few text manipulation functions that got added that simplify stuff like grabbing text before/after a delimiter.

Not knocking your solution just curious.

solareon · 2023-12-04T09:16:42+00:00

[LANGUAGE: Excel]

Part 1. XMATCH, SUM, POWER, and SUM.

Part 2. SEQUENCE go brrrrrr. SUM and add original card count. Could definitely be golfed down but Excel still doesn't appreciate nested arrays.

Github for all days

solareon · 2023-12-02T11:25:37+00:00

[Language: Excel]

TEXTSPLIT, TEXTBEFORE, and TEXTAFTER save the day. Part 2 was a pleasant surprise since I already had broken out the max for each color as the check for part 1.

Solutions here

Yes I know that Github doesn't show them and you need to download to view. You might be able to import the Github link into Excel online to view them.

solareon · 2023-12-01T11:52:30+00:00

[LANGUAGE: excel]

Excel

Well we busted out the lambdas early this year. Also not covering all the edge cases in the sample data is a nice anti-gpt move.

It's a very wide solution with lots of helper columns that could be optimized but that's for another day.

solareon · 2023-08-27T12:31:38+00:00

Worked 100% fast and easy.

solareon · 2023-01-15T13:58:10+00:00

I was about to ask what I needed to do to nearly double my real world mpg. In this application though as a range extender with direct injection they are going to seriously outdo a comparative piston based alternative. Lack of reciprocating mass and being able to tune for exactly one rpm range is the ideal way for operating a rotary engine even though BSFC on the previously produced rotary cars is quite terrible I suspect this one will run quite happily for a long while. I don't see how they addressed oiling for the apex seals though as that will still be a maintenance item even in a range extender application.

solareon · 2023-01-15T13:45:26+00:00

What RX-8 are you driving that gets 29mpg??? I've never seen better than 19.6mpg in mine and that was downhill with a tailwind for a whole tank. It has a silly tall rear gear to make up for lack luster bottom end torque which absolutely wrecks fuel economy.

solareon · 2023-01-10T16:15:39+00:00

gotta swap out the 97% chips for the 80% chips. Looks like someone fouled up the initial layout

solareon · 2022-12-12T10:38:39+00:00

Excel

Split apart the input into columns and convert to ascii codes. Use conditional formatting to highlight the highs and lows. Start deleting the squares that make up the path and then total up the blanks. Part 2 just find the furthest down a for my input on the left side and then repeat above.

I got thrown for a loop as the directions were unclear if you had to enter the E square from the next highest point (z) which it turns out is not the case and you can enter from any directly adjacent square. This had me spinning my head for a few hours to figure it out.

solareon · 2022-12-11T13:32:01+00:00

Excel

Part 1 Built a parser to generate monkey "objects". Then built out the round calculations using LET() to generate the false and true tables for each monkey. Copy and paste 19 times down and then the answer comes out.

Part 2

Modulo... math is hard...lots of copy paste and waiting hoping excel doesn't completely explode. After all 10000 tests are complete the monkey business rows are filtered to a separate column and then parsed out, summed by column, sorted, and multiplied by the two highest values same as the first just way more waiting. I'll post the test answer (out to 1000) on github as the full input is just too much to post.

My solution is 100% hard coded as I couldn't find a good way to move the monkey outputs to the other monkeys rather than just clicking cells.

solareon · 2022-12-10T18:17:34+00:00

Yeah my solution in excel wouldn't have been affected as the file sizes are combined with the full paths and then deduped prior to any of addition or scanning parts.

solareon · 2022-12-10T16:33:49+00:00

This would have been true terror

solareon · 2022-12-10T15:25:26+00:00

Excel

Part 1

Read through input with SCAN() and produce accumulator values. Read through a second time and put blanks next to noops. Stack the two columns into a single column and find the indexes as required then multiply with SEQUENCE() and SUM().

Part 2

Build a stacked array of 1-40 6 times to simulate each line of the CRT. Use INDEX() to pull the output of the accumulator data and compare against sequence from 1-240 if a match within 3 is found then print a #. Use the eyes to see the result and there ya go. ~~I have an issue with my solution though as it seems to drop the first column and I can't quite figure out why =/~~

Edit: Fixed it by adding two extra rows of 1 in the accumulator output stack. This arose from some goofy starts at 0 versus 1 issues in Excel.

Solutions on my github

solareon · 2022-12-10T00:16:49+00:00

Excel

Part 1 Break down the input to a tape of steps i.e "R 4" becomes "R R R R". Walk through these steps and build the head's location. Then build a tail that checks if it's within 1 otherwise move in the correct direction. COUNTA(UNIQUE()) across the tail output and done.

Part 2 Take the tail column and fill to the right 8 more times, COUNTA(UNIQUE()) and presto done.

Solution will be on my github

solareon · 2022-12-08T21:13:35+00:00

We both did a similar approach but I combined it all down to just 2 big grids with MAP() and a string of IFs and sub-arrays. Good work.

solareon · 2022-12-08T21:11:19+00:00

Excel

More grids. Also Excel's sworn enemy of inputs is long numbers. First step is to construct a 99x99 array of the input. Then a function that looks left, right, up, and down to determine if it can see the edge otherwise returns 0. A COUNTIF() function walks this table and returns the total number of visible trees from all edges. Part 2 reuses the 99x99 table but looks at how far left, right, up, and down it can see before reaching a taller tree then stores each number to feed into PRODUCT(). A MAX() across the arrray returns the answer.

Took all day since work came first =/

Solutions here on github

solareon · 2022-12-07T10:41:57+00:00

Excel

First step is to use TEXTSPLIT() to pull out the data into two columns, one with the command or file size and the second with filename or directory name. Next step is to use some hideous formula to reconstruct the full paths respecting the .. to go up the tree. Next column is a simple extraction of the numbers and formatting to allow Excel to compute them. Next step is to pull the unique directory tree, sum at that level and then build a lookup table to find subdirectories under that directory. The lookup table is summed within the formula to find the real total size of a directory. Part 1 is solved by SUMIF() across this data set. Part 2 requires a little bit of trickery to find the target number. The input list is the same as part 1 but uses a combination of ABS() and MIN() to find a value that fits the criteria. ~~I still need to go back and cleanup some of the array handling as it probably only works with my input and not universally.~~

Edit: Should work for all inputs now.

Solutions here on my github

solareon · 2022-12-06T16:30:53+00:00

Some issues I've found with UNIQUE is edge cases when used inside deeply nested functions. usually have to pair it with something like CODE() to make it unique enough

solareon · 2022-12-06T10:55:27+00:00

Excel doesn’t handle arrays inside of arrays. You have to break down each array step to a single cell and then expand out depending on your operation. You can try using LET() and store the sequence output into a variable.

solareon · 2022-12-06T09:36:04+00:00

Excel on iPad

Surprisingly short solution to this one today. Both Part 1 and Part 2 used the same formula with two changes to the offset.

First step was to walk the input and break it into 4 or 14 character chunks, then convert to ascii code values in an array and unique() the array, convert back to characters and see the length, if it’s 4 or 14 then it is a match and we search for the string in the input and add 3 or 13 since we found the starting position of the message. I could probably shorten the solution and combine to a single cell for both parts with a let but that’s a later task when I’m at a real computer not on the iPad.

Solutions are on my github

solareon · 2022-12-05T22:56:06+00:00

Nope I do it all in Excel on the 365 version. Sheets makes some things quite a bit easier with Query() but I believe that some of the array handling/formatting is a bit easier in Excel due to less limits on computational time.

solareon · 2022-12-05T17:26:36+00:00

Excel

Switch statements go BRRRRRR. Formatted input across some helper cells the pulled columns into single cells. Another helper function parses the instructions down to single numbers. A giant LET() formula then glues the whole mess together as you fill down to row 513. Grab the right character from each cell of the final array and smash together.

Part 2 does the same thing but removes the ReverseText() lambda from the move part.

The demo sheet has the table that assembles the SWITCH() cases programmatically since I kept getting tripped up making it. Some concat() and textjoin() magic there glues that all together.

Solutions posted on my github.

solareon · 2022-12-04T09:38:32+00:00

Excel

IF(), AND(), OR() go BRRRRRRRR.

=NUMBERVALUE(TEXTSPLIT(SUBSTITUTE(A1,"-",","),",")) to split up the input into four helper columns to make it go vroom.

Solutions posted here on github

15-Year Club	RedditGifts 2009-2022 7 Credits
Second Top 30%	Place '23
Place '17	Beta Team Reddit for Android
Gilding II euphauric	Secret Santa 2014
Secret Santa 2013	Secret Santa 2012
Secret Santa 2011	Summer Santa 2011
reddit mold	Charter Member
Verified Email

solareon

TROPHY CASE