here is a slightly modified version from colin’s. class Hash def diff(other) (self.keys + other.keys).uniq.inject({}) do |memo, key| unless self[key] == other[key] if self[key].kind_of?(Hash) && other[key].kind_of?(Hash) memo[key] = self[key].diff(other[key]) else memo[key] = [self[key], other[key]] end end memo end end end It recurses into the hashes for more efficient left and right {a: {c: 1, b: … Read more
I know this is old question, however this is my solution: SELECT md5(CAST((array_agg(f.* order by id))AS text)) /* id is a primary key of table (to avoid random sorting) */ FROM foo f;
You can do it in a single assignment: my %hash; @hash{@array1} = @array2; It’s a common idiom. From perldoc perldata on slices: If you’re confused about why you use an ‘@’ there on a hash slice instead of a ‘%’, think of it like this. The type of bracket (square or curly) governs whether it’s … Read more
Hash collisions are correctly handled by Dictionary<> – in that so long as an object implements GetHashCode() and Equals() correctly, the appropriate instance will be returned from the dictionary. First, you shouldn’t make any assumptions about how Dictionary<> works internally – that’s an implementation detail that is likely to change over time. Having said that…. … Read more
use constant actually makes constant subroutines. To do what you want, you need to explicitly call the sub: use constant X => 1; my %x = ( &X => ‘X’); or use constant X => 1; my %x = ( X() => ‘X’);
hash is a required property in the NSObject protocol, which groups methods that are fundamental to all Objective-C objects, so that predates Swift. The default implementation just returns the objects address, as one can see in NSObject.mm, but one can override the property in NSObject subclasses. hashValue is a required property of the Swift Hashable … Read more
Solution: You must pass image option to your command as follow : docker image pull [OPTIONS] NAME:[TAG@DIGEST] For Example: (ubuntu 18.04) docker image pull ubuntu:18.04@sha256:98706f0f213dbd440021993a82d2f70451a73698315370ae8615cc468ac06624
I’m surprised that you saw chained hashing to be faster than linear probing – in practice, linear probing is typically significantly faster than chaining. This is primarily due to locality of reference, since the accesses performed in linear probing tend to be closer in memory than the accesses performed in chained hashing. There are other … Read more
Using sys.maxsize: >>> import sys >>> sys.maxsize 9223372036854775807L >>> hash(‘asdf’) -618826466 >>> hash(‘asdf’) % ((sys.maxsize + 1) * 2) 18446744073090725150L Alternative using ctypes.c_size_t: >>> import ctypes >>> ctypes.c_size_t(hash(‘asdf’)).value 18446744073090725150L