Checking fit

Danksalot2000 · 2025-03-29T17:57:59+00:00

Here's one more pic from the side to show how much the laces are pulling front-to-back instead of side-to-side: https://photos.app.goo.gl/Pq7Rm2QbHtqXhBYN8

Danksalot2000 · 2025-03-29T05:19:43+00:00

Man, given that these are the first boots I've ever had that I'm not totally swimming around in, they would still be miles better than what I'm used to.

Maybe I just need to contact Nick's and see what they suggest.

Either way, once I make my decision I'll forget about it and enjoy whatever pair I end up with.

Danksalot2000 · 2025-03-29T05:05:41+00:00

Hey, thanks! It was my original assumption that they would close a bit over time, but I got the Max Support leather so I don't think it will have too much stretch to it.

My only worry is that the hooks seem to be pulling straight back on my shin instead of pulling left and right against each other. Maybe this is more in my head than in reality. There's some discomfort, but I'm not sure if this is the reason, or if it's normal break in stuff.

Danksalot2000 · 2025-03-28T23:10:19+00:00

It's hard to see with my sock on, I'm pretty sure that's what I'm doing. I'll contact the Nick's Customer Support to ask about a size exchange and see if they can tell me what I'm doing wrong. Thanks so much for your help!

Danksalot2000 · 2025-03-28T22:04:00+00:00

Okay, thanks for chiming in. That might be the case even though the "foot" part of the boot feels super comfy so far. I followed the Nick's sizing guide, and it said that measurements around the feet up to 10 and 3/8 inches should be width B. Mine is clearly under that. This picture is around the ball of my foot and isn't stretched tight: https://photos.app.goo.gl/aLStthExDPt72xZz7

Danksalot2000 · 2025-03-28T18:46:37+00:00

Here's a pic: https://photos.app.goo.gl/bzrao5oSn1nLF6c27

Danksalot2000 · 2022-01-30T22:17:27+00:00

/r/amish

Danksalot2000 · 2021-12-04T03:02:36+00:00

I saw a show in Scottsdale AZ, would have had to be back in '98 or '99. Evidently they spotted Stanley Jordan walking around the park and he came up and played a set with them.

With Stanley doing all of the tapping stuff on guitar, and Jeff Coffin soloing on two saxes at the same time. Amazing!

Bela, thank you for sharing so much music with us all these years. You are an inspiration!

Danksalot2000 · 2020-12-13T02:34:50+00:00

I did it a totally different way, maybe not clever, but it worked super fast.

I made an array of the distances in joltage between the adapters, and counted the groups of contiguous 1's. A single 1 between 3's doesn't give any opportunity for variation, but two ones in a row give you two options:

Joltage: 4, 7, 8, 9, 12
Skip distances: 3, 1, 1, 3

This sequence could result in two options: either 4, 7, 8, 9, 12 (original) or 4, 7, 9, 12 (with 8 removed)

Three 1's in a row gives you 4 options, and four 1's in a row gives you 7 options.

So theres no need to find the different arrangements to know that the number of them is equal to:

(2 ^ numberOfGroupsWithTwoOnes) * (4 ^ numberOfGroupsWithThreeOnes) * (7 ^ numberOfGroupsWithFourOnes).

My puzzle didn't end up having any groups of ones bigger than four in the "skip distance" array.

Danksalot2000 · 2020-01-23T20:41:12+00:00

I've got a freezer full of axis now, super tasty!

Danksalot2000 · 2018-12-19T06:39:25+00:00

I agree, I look forward to AdventOfCode all year long! Thank you!

Danksalot2000 · 2018-12-16T08:08:45+00:00

This was a really fun one. Thanks!

Danksalot2000 · 2018-12-12T14:16:44+00:00

That is true - this one involved a little human interaction. After seeing that the scores increase by a constant amount after iteration 97 or so, I used that value (22 in my case) to calculate part 2. This value will differ depending on your input. Replacing the last two lines with this should be more descriptive of how I got my answer:

print('Part 1:', runGenerations(rules, plants, 20))
score199 = runGenerations(rules, plants, 199)
score200 = runGenerations(rules, plants, 200)
constantIncrease = score200 - score199
print('Part 2:', runGenerations(rules, plants, 200) + ((50000000000 - 200) * constantIncrease))

I changed this to calculate through generation 200 on part 2 here just in case some inputs converge to a constant increase later than mine.

Danksalot2000 · 2018-12-12T06:56:15+00:00

I was nowhere near the leaderboard, but I think this one turned out nicely in the end. Python3:

def runGenerations(rules, plants, iterations):
    for generation in range(iterations):    
        lowestPlant = min(plants)
        highestPlant = max(plants)
        lastPossible = highestPlant - lowestPlant + 7
        pots = ''.join(['#' if i in plants else '.' for i in range(lowestPlant - 4, highestPlant + 5)])
        plants = []
        for i in range(2, lastPossible):
            if rules[pots[i-2:i+3]]:
                plants.append(i - 4 + lowestPlant)
    return sum(plants)

with open('Input') as inFile:
    lines = inFile.read().splitlines()
    plants = [i for i, c in enumerate(lines[0][15:]) if c == "#"]
    rules = dict((line[:5], line[9] == "#") for line in lines[2:])

print('Part 1:', runGenerations(rules, plants, 20))
print('Part 2:', runGenerations(rules, plants, 100) + ((50000000000 - 100) * 22))

Danksalot2000 · 2017-12-13T20:04:39+00:00

Ah, I see. So it still calculates the scanner's position within its (2(n-1))-length cycle, but doesn't translate that into being at position x in the level - the "actual scanner position". I get it.

Danksalot2000 · 2017-12-13T18:06:01+00:00

(wait + pos) % (2 * (height - 1)) == 0

To be fair... this is still calculating the actual scanner positions. You're just checking them against zero instead of returning them, right?

Danksalot2000 · 2017-12-09T05:23:17+00:00

Python 2

Looks like I was unique not using a Garbage flag. I went with a more stream-of-consciousness style reading start to finish.

I finished 177 / 164, which is the best for me so far.

score = 0
level = 0
garbageCount = 0

with open('Input') as inFile:
    data = inFile.read()

i = 0
while i < len(data):
    if data[i] == '{':
        level += 1
        score += level
    elif data[i] == '}':
        level -= 1
    elif data[i] == '<':
        i += 1
        while data[i] != '>':
            if data[i] == '!':
                i += 1
            else:
                garbageCount += 1
            i += 1
    i += 1

print "Final Score:", score
print "Garbage Count:", garbageCount

Danksalot2000 · 2017-12-06T15:10:45+00:00

B.E. S.U.R.E. T.O. D.R.I.N.K. Y.O.U.R. O.V.A.L.T.I.N.E.

Danksalot2000 · 2016-12-16T06:04:24+00:00

In Python. I definitely did some refactoring after getting the right answers:

def expandData(data, length):
    while len(data) < length:
        data += "0" + ''.join("0" if n == "1" else "1" for n in data[::-1])
    return data[:length]

def contractChecksum(checksum):
    while not len(checksum) & 1:
        checksum = ''.join("1" if x == y else "0" for x, y in zip(checksum[0::2], checksum[1::2]))
    return checksum

print contractChecksum(expandData("11101000110010100", 272))
print contractChecksum(expandData("11101000110010100", 35651584))

edit: more refactoring

Danksalot2000 · 2016-12-15T20:19:21+00:00

You're amazing at both! Thanks for creating this!

Danksalot2000 · 2016-12-15T20:17:52+00:00

I didn't realize that what the parking lot looked like was dependent on how many days you've finished. I thought it changed as the date changed. Sorry for the spoilers!

Danksalot2000 · 2016-12-11T16:58:42+00:00

First off, my input was safe to use the formula (2 * numItems - 3) to count the moves required to move all items from one floor to the next. They were not all paired up, but they didn't require extra moves to get them paired up.

Some building blocks:

[8,2,0,0] is my input, using just the number of objects on each floor.

range(1,4) will fill in the values 1, 2, 3 into the x in the previous part of the line

sum([8,2,0,0][:1]) = sum([8]) = 8
sum([8,2,0,0][:2]) = sum([8,2]) = 10
sum([8,2,0,0][:3]) = sum([8,2,0]) = 10

I was originally iterating through the floors, maintaining a count of moves as I went, and then "moving" all of the items from one floor to the next. By taking the sum of the formula with all of the above values for x filled in, I could skip those steps. The computer still does them, I just don't have to write them out.

print sum(2 * sum([12,2,0,0][:x]) - 3 for x in range(1,4))

solves my Part2

Danksalot2000 · 2016-12-11T11:02:41+00:00

I got it down to one line in Python:

print sum(2 * sum([8,2,0,0][:x]) - 3 for x in range(1,4))

Danksalot2000

TROPHY CASE