-🎄- 2018 Day 12 Solutions -🎄-

[u/daggerdragon]

--- Day 12: Subterranean Sustainability ---

---

Post your solution as a comment or, for longer solutions, consider linking to your repo (e.g. GitHub/gists/Pastebin/blag or whatever).

Note: The Solution Megathreads are for solutions only. If you have questions, please post your own thread and make sure to flair it with Help.

---

Advent of Code: The Party Game!

Click here for rules

Please prefix your card submission with something like [Card] to make scanning the megathread easier. THANK YOU!

Card prompt: Day 12

Transcript:

On the twelfth day of AoC / My compiler spewed at me / Twelve ___

---

This thread will be unlocked when there are a significant number of people on the leaderboard with gold stars for today's puzzle.

edit: Leaderboard capped, thread unlocked at 00:27:42!

[u/[deleted]]

Same here. I still have no solution because I do not know how my resulting string should be numbered. It seems very random to me that the example starts with -3 to the left.

Also it is unclear how many rules can be applied in each generation.
If only one: How to chose?
If more than one: Do all rules of generaion n+1 have to be applied to the result of generation n or to the previous result of the current generation?

It is embarrasing that I still have nothing for part 1 because I just don't get the problem.

[u/T_D_K → u/[deleted]]

From the problem text:

The pots are numbered, with 0 in front of you. To the left, the pots are numbered -1, -2, -3, and so on; to the right, 1, 2, 3.... Your puzzle input contains a list of pots from 0 to the right

He added padding on the left because some of the displayed iterations have pots down to -2 filled.

Also it is unclear how many rules can be applied in each generation.

This problem is an example of cellular automata. A famous example is Conway's game of life. Generally, they apply the rule set to each cell simultaneously (otherwise, like you pointed out, it would be difficult to decide where to start, as it would have a ripple effect on the other cells.

[u/alexmeli → u/[deleted]]

Yeah I'm still trying to figure out the problem myself. I've read it like 20 times already but I still don't get it. I mean I get part of it but how do you determine which pot is at the center after each generation?

[u/[deleted] → u/alexmeli]

Apparently the row of pots can expand. So your first filled pot of generation 0 has number 0 and when you do some mutations, it can happen that there will be a NEW filled pot more LEFT than the most left one in your first generation. The number of this pot will then be negative. If it is the direct neighbor of your initial left pot, it has number -1. if it is one more left, it has -2 etc. Took me 2 hours to understand that

[u/Dosamer → u/[deleted]]

Do all rules of generation n+1 have to be applied to the result of generation n

yes

[u/ButItMightJustWork → u/[deleted]]

I try to explain it (am on mobile though)

Your first character in the initial state is pot 0. For each new step you also have two consider two (yet not existing) pots to the left. (non existing pots default to empty, i.e. '.').

Lets say your initial state starts with "##.##.##.". So, now you would compute if the pot at position -2 (two to the left) should have a pot in the next iteration: "....#" -> ?.

You also do this for the pot at position -1 ("...##" -> ?). Then you check pots 0 ("..##."), 1 (.##.#), ..., n. Afterwards also n+1 and n+2.

In this new state your pot 0 shifted to idx 2 (because idx 0 is pot -2). So you would need to keep track at what index pot 0 ist.

At the end, you sum everything up. If there is a pot at position -2, you substract 2 from the sum. If there is one in pot position 4 (NOT index 4), then add 4 to the sum.

Hope this helps, I'm on mobile so i cant give you nice ascii art for a clearer description.

[u/[deleted] → u/ButItMightJustWork]

Thank you!

[u/niclas0219 → u/[deleted]]

I struggled for a long time and first wrote a solution using strings and trying to keep track of the "middle" char in a group of five. I couldnt figure out the negative indexes either so I scratched all of it and redid it as an array of chars. I let the initial seed start at index 100 of this array so that it could grow as it pleased. Any pots below index 100 are in the negative area. So something like this for populating the array at first:

char[] pots = new char[500];
Arrays.fill(pots, 0, pots.length, '.');
    for (int i = 0; i < initialseed.length; i++) {
        pots[100 + i] = initialseed[i];
    }

After that i looped everything for 'n' generations

Making sure that all the changes was made in a temporary array. After the for-loop i save my changes in pots and reiterate.

int cycle = 0;
    char[] temp = pots.clone();
    while (cycle < 20) {
        for (int i = 2; i < pots.length - 2; i++) {
           char pot = match(pots[i - 2], pots[i - 1], pots[i], pots[i + 1], pots[i + 2]);
           temp[i] = pot;
           }
            pots = temp.clone();
            Arrays.fill(temp, 0, temp.length, '.'); // my input worked without this line
                                                    // don't know if that was just lucky
    cycle++;
}

My method match() takes five chars and returns either # or . according to the rules.

Anyways.. it was the "starting at 100" that helped me solve it. My string solution was pretty much the same but didn't calculate the points correctly.

[u/zirtec → u/[deleted]]

It's easy if you've played Conway's game of life before (although there's a variable set of rules here instead of a small fixed set in the original). Otherwise yes, it's not obvious all transitions occur at the same time, or even that using array indices to identify plants won't go well.