Using mutables in a Set or as keys in a Dict is not necessarily bad; it's
changing them after they've been inserted that causes the chaos. Your 1785
"distinct" elements are all references to a single array object that is
being continually mutated by the santa function.
I'm not sure why there would be randomness in the number of elements, but
would guess that something is being hashed on its memory location instead
of its contents. I don't know what that would be though since hashes on
arrays are a function of their values only.
On Wednesday, December 16, 2015 at 12:22:06 AM UTC-5, Jan Strube wrote:
>
> So now we have Tomas saying that two arrays are not equal, even though
> their contents are equal.
> Kristoffer is saying that changing a mutable doesn't update the hash.
> It looks like these two effects are competing when inserting into a Set.
> In the game the input was 8192 directions.
> Of those 2592 were distinct - the result of the string solution.
> The version with arrays gave 1785 distinct elements in the Set.
>
> So sometimes, the hash definitely did get updated (most of the time in
> fact).
> I'm fine with the lesson that using mutables in a Set (or Dict) is a bad
> idea, but I'd still like to understand what's going on here. In fact, the
> array solution is not reproducible on my machine. Two runs give two
> different numbers.
> Where does this randomness come from?
>
>
>
> On Tuesday, December 15, 2015 at 1:09:54 PM UTC-8, Kristoffer Carlsson
> wrote:
>>
>> The set is built as a number of key-value pairs of the hash and the
>> object. When you modify the object the key that contains the hash does not
>> get updated. A good reason not to put mutables in sets.
>>
>> On Tuesday, December 15, 2015 at 5:17:00 PM UTC+1, Josh Langsfeld wrote:
>>>
>>> I played with it a bit more and am seeing some unexpected behavior. If
>>> you add a mutable element, change it, and then add another equal one, the
>>> set gets two elements. But if you don't mutate the element, it stays at
>>> one.
>>>
>>> julia> s = Set{Vector{Int}}()
>>> Set{Array{Int64,1}}()
>>>
>>> julia> el = [1,2,3]; push!(s, el)
>>> Set([[1,2,3]])
>>>
>>> julia> push!(s, [1,2,3]) #Pushing a new array object, but the length
>>> stays at 1.
>>> Set([[1,2,3]])
>>>
>>> julia> s = Set{Vector{Int}}()
>>> Set{Array{Int64,1}}()
>>>
>>> julia> el = [1,2,3]; push!(s, el)
>>> Set([[1,2,3]])
>>>
>>> julia> el[1] = 10; @show s; #Mutate the set element from the outside
>>> s = Set([[10,2,3]])
>>>
>>> julia> push!(s, [10,2,3])
>>> Set([[10,2,3],[10,2,3]])
>>>
>>> julia> length(s)
>>> 2
>>>
>>> julia> els = collect(s); els[1] == els[2]
>>> true
>>>
>>> Is something buggy going on here?
>>>
>>> On Tuesday, December 15, 2015 at 10:57:31 AM UTC-5, Josh Langsfeld wrote:
>>>>
>>>> It's not array equality that's the issue here. Arrays with the same
>>>> elements are '==' (but not '==='). If you manually test pushing the same
>>>> array to a Set you'll see it works fine.
>>>>
>>>> Jan, what happened is that your 'santa' function modifies and returns
>>>> the same array that was passed in instead of creating a new one. So the
>>>> only array that ever gets created is the first 'start = [0 0]' and it just
>>>> gets continually modified, both in the santa function and in the set.
>>>> Switching to a tuple works because you are forced to create a new tuple to
>>>> change one of the elements.
>>>>
>>>> On Tuesday, December 15, 2015 at 3:32:40 AM UTC-5, Tomas Lycken wrote:
>>>>>
>>>>> Probably because the arrays will not be equal even if their contents
>>>>> are equal (this is true of most mutable types in Julia).
>>>>>
>>>>> If you try representing a position as a tuple `(0,0)` instead of as an
>>>>> array `[0,0]`, you'll find that it works as expected.
>>>>>
>>>>> // T
>>>>>
>>>>> On Tuesday, December 15, 2015 at 8:28:36 AM UTC+1, Jan Strube wrote:
>>>>>>
>>>>>> That's not a problem at all. In fact that's the very reason why I'm
>>>>>> using a Set in the first place.
>>>>>>
>>>>>> My question is: Why is the number of entries in the set different
>>>>>> when I add Arrays vs. adding ASCIIStrings?
>>>>>>
>>>>>>
>>>>>> On Monday, December 14, 2015 at 10:57:57 PM UTC-8, [email protected]
>>>>>> wrote:
>>>>>>>
>>>>>>> I think your problem is that Sets cannot contain duplicate entries,
>>>>>>> so if Santa ever passes the same point twice it won't be added.
>>>>>>>
>>>>>>> Cheers
>>>>>>> Lex
>>>>>>>
>>>>>>> On Tuesday, December 15, 2015 at 4:23:19 PM UTC+10, Jan Strube wrote:
>>>>>>>>
>>>>>>>> I'm trying to learn a bit more Julia by solving the puzzles over on
>>>>>>>> http://adventofcode.com
>>>>>>>> On day 3, the problem is to follow a number of directions and
>>>>>>>> figure out how many new places you end up.
>>>>>>>> http://adventofcode.com/day/3
>>>>>>>>
>>>>>>>> I thought I can solve this simply by defining a set of [x y]
>>>>>>>> positions, each time adding a new grid position to the set, so I'd end
>>>>>>>> up
>>>>>>>> with a Set{ Array{Int64,2}} of the right length.
>>>>>>>> However, this doesn't work as expected. I get the wrong number
>>>>>>>> (it's too low).
>>>>>>>>
>>>>>>>> Wrapping each grid position into a string() call, however, gives me
>>>>>>>> the right answer.
>>>>>>>> The explanation is a bit convoluted. To avoid spoilers I've put the
>>>>>>>> code up at https://gist.github.com/jstrube/3d54e15f7d051b72032b
>>>>>>>>
>>>>>>>> I don't quite understand this. Is this expected?
>>>>>>>>
>>>>>>>>
