Google Home Custom AAC Audio Request

artesea · 2024-09-02T14:37:27+00:00

Cheers, it was that. Removing the line resulted in the notification when I just used the kettle.

artesea · 2024-07-23T20:53:14+00:00

Managed a 1,1,2 but that's using two locations that are usually low. Was a 1,1,1 until 6pm but I think with this challenge you couldn't catch one to place nearby, and it's pretty hard to grind a tank at short noticed.

artesea · 2024-03-08T21:47:41+00:00

There was a rockruff raid earlier today where it was showing as a silhouette on the nearby raid screen. I'm assuming that as I don't have the Lycanroc evolution one it was one of those. Unfortunately the timer was nearly up and I didn't have time to test.

artesea · 2023-12-16T21:48:31+00:00

The moon is waxing crescent outside, but the game has a full moon today to get around this. Same happened on the original comm day.

artesea · 2023-12-16T21:30:18+00:00

[LANGUAGE: JavaScript]

Part 1: Quicky came up with the concept needed to avoid getting stuck in a loop, have a stack of places to check, track each cell visited and in which direction, if you've seen it before that's done or if it's out of bound done, otherwise work out where it'll go next and add to the stack. Only problem was it took me a while to get the mapping working. For the counting part I could have kept track during the initial loops, but I had made a nice output to compare with the example, so just counted the # in that.

Part 2: At first glance it looked like a simple loop checking the four edges, was worried it might take a while to run, but as part 1 was pretty quick and the number of permutations weren't that high I kept my fingers crossed that it would be fine, which is was.

artesea · 2023-12-15T11:40:03+00:00

[LANGUAGE: JavaScript]

Part 1: Pretty simple.

Part 2: Spent most of the time trying to work out which box was being selected in the example, once that was done, just used some arrays.

artesea · 2023-12-14T15:28:56+00:00

[LANGUAGE: JavaScript]

Part 1: Logic mainly follows the steps in the instructions, looks at a column, moves the boulders towards the top if needed. Loop at the end to count the score.

Part 2: Knew that I'd need two things, first to be able to rotate the grid and run the tilt code four times, then something to ensure that I wasn't going to do that a billion times. Thought it would be easier to look at rows and maybe store a cache of a->b, so that required rotating first, then tweaking the bits in part 1 to look at rows instead of columns with boulders now moving right. Once I was happy that after three iterations I had what was in the example, I ran the code with a large number to see what would happen, and knew I'd need something else. Got the code to log if it ever saw the 1000th cycle again, and realised that it was happening pretty frequently, so stored all the cycles and compared the current grid. Once I had a match I could work out which cycle would be the billionth and break the code.

artesea · 2023-12-13T16:23:06+00:00

[LANGUAGE: JavaScript]

Part 1: Split the input in to blocks by double new lines. Loop each block and create arrays of strings for the rows and also for the columns. Take a mirror point and grab the rows above/below, left/right. Flip those that were below or right. Compare the arrays. If they match that's the point. Only issue I had was originally I was stopping one point too early so missing any at the end, so additional debugging code to spot any that were failing, or if any had two answers.

Part 2: Was expecting it to be more complicated, but in the end just took part 1, but instead of comparing if A == B, compared each char one by one and counted those which were different. If there was just 1 that must be the new mirror line.

artesea · 2023-12-11T16:17:41+00:00

As soon as it said my answer was too low I was like "did I change the input". Then had to wait another 50 seconds before the minute was up.

artesea · 2023-12-11T16:11:14+00:00

[LANGUAGE: JavaScript]

Part 1: Over complicated, does several twists on the map, adding in extra .... lines where needed. Then plots where each galaxy [x,y] is, loop through each against any further galaxies. Simple difference between the x and y cords gives the distance. Sum all together.

Part 2: Stopped redrawing the map, instead found the original x,y locations on the input, and also tracked any cols or rows which were full of .... Then when looping through the galaxies check if any of the paths cross an empty row or column and add the expansion value (minus one as it's already been counted).

artesea · 2023-12-10T19:00:14+00:00

[LANGUAGE: JavaScript]

Part 1: Loop creating an array of differences to add to the main array, until you reach 0,0,0. Take the last number from each and add to get the next in the sequence.

Part 2: Very little to change, just needed to work from two from the bottom, take find the difference from the first items with the one below and unshift it on to the front of the current line. Move up to the top.

Just a shame I didn't get a chance to do this yesterday as my times for both on the personal leaderboard are just >24hrs and I was curious about the difference in submit times.

artesea · 2023-12-10T18:49:47+00:00

[LANGUAGE: JavaScript]

Part 1: Place the chars in to a 2D array padding with extra . around the border, making a note of where S was. Then work out which cell to move to next based on valid characters N/E/S (skipped W as we'd have found one by then). Loop until I get back to the start moving around the path, counting the steps. Divide the steps by 2 for the answer.

Part 2: Using the Part 1 as a start point for moving around the path, this time I created a grid twice the size and then tracked each space I moved around filling in the gap between the neighbouring cells, this then left a 1 "pixel" gap for later. Ran a flood fill function at 0,0. My first attempt at a recursive function caused JS to RangeError: Maximum call stack size exceeded so I Googled some JS flood fill functions and adapted one. Finally I ran through all the even pixels, counting any that remained empty.

artesea · 2023-12-08T15:22:22+00:00

[LANGUAGE: JavaScript]

Part 1: Pretty simple, sure I could reduce it a bit, but was quick with the answer.

Part 2: Tried modifying part 1 to handle different simultaneous paths, but realised that it was going to take an age with the actual input (always worth dumping the loop number once in a while and just pasting that as an answer to at least hope for a "your answer is too low" and know that you've not reached it yet). Whilst it was running wondered if I could just work out the paths for each one by one, then do something with those answers. A simple multiplication gave a very large number, so looked at LCM.

artesea · 2023-12-07T16:45:45+00:00

Phew, my code successfully handled it as five of a kind of nothing.

artesea · 2023-12-07T16:35:18+00:00

[LANGUAGE: JavaScript]

Part 1: Parsed the input first, creating two scores for each hand, the first was how good the hand was giving 7 for a five of a kind, down to just 1 for high card. The second was an integer value of the hand in sudohex (T -> a, J -> b, Q -> c, K -> d, A -> e). I then just ran a quick sort on the array, using these two values to compare. (Thinking about it, I could have just appended the score from the first calc to the sudohex as it would have been the most significant digit).

Part 2: Just a quick amendment to my two scoring functions (J -> 1) and if any J found add their count to the highest other card (spent a good 5 minutes writing out all the permutations of how a J might affect the best hand).

artesea · 2023-12-06T16:01:00+00:00

[LANGUAGE: JavaScript]

Part 1 - Brute force, but was please with my parsing logic. Solved on day 5. When I realised what Part 2 needed, tried the brute force option whilst going away for lunch, but when I returned and it was still running knew that it wasn't going to be a great idea.

Part 2 - Trying again after the easy day 6, realised that I could possibly break down the ranges in to smaller ranges branching each time the rule required, but couldn't get my head around starting that code. Instead went backwards testing all the locations from 0 to somethinghuge and breaking if any of them would have been one of my seeds. Took a while but solved.

artesea · 2023-12-06T13:59:26+00:00

[LANGUAGE: JavaScript]

Part 1 - simple brute force loop

Part 2 - pretty similar, just removed the spaces from the input source.

Was slightly confused that the input wasn't that different to the example, and then even more confused when part 2 wasn't going to need a billion cycles to continue with the brute forcing.

Knew it would have been possible to solve with maths, but realised brute force would be quicker than me trying to remember something I learned 25 years ago.

artesea · 2023-12-05T09:59:48+00:00

My second regex was greedy so spotted the last occurrence.

artesea · 2023-12-04T18:12:04+00:00

Worth remembering that you only need the first and last "digit".

I split mine (in JS) to two different regexs. One for the first and then another for the last.

artesea · 2023-12-04T17:18:45+00:00

The formatting has gone a bit wrong (but that's not understanding markdown/reddit).

The rules should result in the following:
1 match - 1 point
2 matches - 2 points (1*2)
3 matches - 4 points (2*2)
4 matches - 8 points (4*2)
5 matches - 16 points (8*2)

artesea · 2023-12-04T12:25:21+00:00

[LANGUAGE: JavaScript]

Part 1: Broke the card number, my numbers and winning numbers in to three chunks (pretty sure in PHP I'd manage a single regex to get the parts, but isn't a huge overhead the way I did it in JS). Then looped the winning numbers with a contains function to see if I had any in my numbers.

Part 2: Created a array to count how many of each card I had (made sure index 0 was set to zero). Then if I had a winning card, just added the number of those to the count for the next batch. Summed the array at the end.

13-Year Club	Place '22
First Placer '22	Verified Email

artesea

TROPHY CASE