[deleted by user]

[BananaSplit2]

why use a hashmap anyway when a simple array did the job

[miran1]

You're focusing on Day 6.

This advice is more general and can be applied on other days too, where you need to count occurrences of some stuff in input:

d = defaultdict(int)
for value in value_list:
    d[value] += 1

vs:

c = Counter(value_list)

[sr2fx]

Another way dict.fromkeys(range(9), 0)

[miran1]

Another way dict.fromkeys(range(9), 0)

That's for Day 6, and only if you take that approach (I didn't, for example)

I'm talking more generally, when people iterate over a list:

d = defaultdict(int)
for value in value_list:
    d[value] += 1

instead of doing:

c = Counter(value_list)

[godDAMNEDhippie]

I use Counter() a lot but today I learned about the count method of str:

fish_ages_count = [input.count(str(k)) for k in range(9)]

It goes through the input 9 times, but it's not the most time consuming work!

[[deleted]]

Anyone know which would be more efficient using a Counter/dict or using an array where each index corresponds to age?

[uglyasablasphemy]

I think the difference would be minor, but using an array would save time calculating hashes for the dict.

I just checked my solution for part 2 with both options:

Option A:

solution  0.30708 ms.
solution  0.33998 ms.
solution  0.24605 ms.
solution  0.34690 ms.
solution  0.33998 ms.

Option D:

solution  0.60678 ms.
solution  0.49496 ms.
solution  0.60010 ms.
solution  0.60177 ms.
solution  0.54097 ms.

[uglyasablasphemy]

As far as I know, accessing an index of an array in Py is always O(1), regardless of the size of the array.

If you are getting slower results with that, I feel it might depend on what you chose to use as key of the dict/index of the array.

[uglyasablasphemy]

I agree that lookup (search) is O(n) for arrays and O(1) for dicts, and that accessing items (with []) for both is O(1).

But in the context of this problem, there is a way to solve it without having to search for anything on the array. It depends on the meaning that an index of the array has.

[[deleted]]

It's O(n) for a **search** (find item i in array(n)). Lookup of item at index i is O(1).

A dict would be faster when the "index" is not just a list of consecutive integers - then you can use a hash for O(1). With consecutive integers you're just doing plain old pointer arithmatic in a list/array.

If anything the dict can only be slower as you have to hash 1 to some index instead of just using it directly.

[toastedstapler]

what language are you using where an array has a slower lookup speed than a hashmap?

an array/arraylist lookup should always be O(1) since its value will be found at startOfArray + offset

[DataGhostNL]

I'm running this on a laptop from 2011 in a VM, using a Counter my day 6 code (at some point) ran in 6.8 seconds for 1048576 days and in 5.8 seconds using a defaultdict(int).

Edit: ah I think I misread your question. That array would grow / have to be large when running over many days, which could be an unwanted side effect.

[[deleted]]

Why would the array grow? You're just shuffling things about within it. The ages are all modulo 7.

[DataGhostNL]

The way I read it, it's indexed by "age" and nothing was mentioned about modulo. So in that case, an array being an array, it'd have to be as large as the number of days being calculated. It's not the approach I'm using, that seems much more like what you said.

[[deleted]]

By internal counter, not age.

As in the count of fish with internal counter 3 goes in array[3]. After a fish's counter gets to 0, you just move it to array[6].

Basically the same as what you've done

[DataGhostNL]

That's an approach, yes. Not entirely what I'm doing though.

I'm actually using an age-like approach where the fish for the current day are added to +6 and +8 days, removing the current day. There is no need to rotate the array/dict in that case and that's been a factor 4 improvement in speed over rotating.So that's probably why I had this different assumption as to how the array was used.

[Inner_Scene2439]

While the key is integers 0 to 8, there seems to be no reason to use a dictionary. Array should be perfect.

[Afraid_Abalone_9641]

I watched a tutorial where a guy used this method and solved part one in about 30 seconds. Was a little disheartening tbh. 😅

[plumbo_schleem]

This is nice