Python 向量（列表）到二维矩阵 hash

Question

I have a function that returns a vector. The length of the vectors is different for each result. For example, these are some vectors that my function returned:

res_1 = [67, 68, 69, 70, 25, 71]
res_2 = [49, 45, 50, 51, 52, 53, 54, 45, 55, 56, 25, 57, 58, 59, 60, 61, 62, 63, 64, 45, 65, 58, 66, 45, 50]
res_3 = [72, 4]

I want a function to make a 2D matrix hash from a vector. The matrix hash length must be constant. for example 50x50 or 100x100. This function must produce a unique value NxN matrix for each given vector.

How can I implement this function?

Answer 1

Using zero-padding is a good idea, but it may not work if your vector-generating function can output a list containing one or more zeroes. You might get unlucky and get a duplicate vector by chance.

It's hard to say, as there isn't much detail about the vector-generating function in the question.

In any case, here's a convoluted way to get a 16x16 matrix made up of binary bits from a SHA256 hash of a list:

#!/usr/bin/env python3

import hashlib
import numpy as np
import bitstring

res_1 = [67, 68, 69, 70, 25, 71]
res_2 = [49, 45, 50, 51, 52, 53, 54, 45, 55, 56, 25, 57, 58, 59, 60, 61, 62, 63, 64, 45, 65, 58, 66, 45, 50]
res_3 = [72, 4]

def hash(l):
    m = hashlib.sha256()
    m.update(bytearray(l))
    h = m.hexdigest()
    c = bitstring.BitArray(hex=h)
    b = c.bin
    a = np.frombuffer(b.encode('utf-8'), 'u1') - ord('0')
    r = np.reshape(a, (-1, 16))
    return r

print(hash(res_1))
print(hash(res_2))
print(hash(res_3))

So long as the lists contain different values, they should have different byte representations and so their SHA256 hashes should be practically guaranteed to be unique. Though it is possible for a collision to happen, the odds are so small as to be practically negligible.

If even very small odds of a hash collision are not acceptable, you might look into zero-padding or other ways to do a so-called "perfect hash", instead of using SHA256.

Sample output:

[[1 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0]
 [0 0 0 0 1 0 1 0 0 1 1 1 1 0 0 0]
 [1 0 0 1 1 0 0 1 0 1 0 1 1 0 1 0]
 [1 1 0 1 0 1 1 1 1 0 0 0 0 1 1 0]
 [0 1 1 0 0 1 1 0 1 0 1 1 1 0 1 0]
 [1 1 0 1 0 0 0 1 0 1 1 0 1 0 0 1]
 [1 0 0 0 0 0 0 1 1 0 0 0 1 0 0 0]
 [0 0 0 1 0 1 0 0 0 1 1 0 1 0 0 0]
 [1 1 1 1 0 1 0 1 0 0 1 1 1 1 0 1]
 [1 1 0 0 1 1 0 1 1 0 1 0 1 1 1 0]
 [1 1 1 1 0 0 0 1 0 0 1 0 1 0 0 0]
 [0 0 0 0 1 0 0 1 1 0 0 0 0 1 1 1]
 [0 0 1 1 0 0 0 1 1 0 1 1 0 1 0 1]
 [1 0 0 1 0 1 1 1 0 1 1 1 1 1 1 0]
 [1 1 1 0 0 0 0 1 1 0 0 1 0 0 1 1]
 [0 1 0 1 1 1 1 1 1 1 0 0 1 0 0 1]]
[[0 0 1 1 0 1 1 1 1 1 1 0 1 1 0 1]
 [0 0 0 1 1 1 1 0 1 1 0 0 1 1 1 1]
 [0 1 0 1 1 1 0 0 0 0 0 0 0 0 0 1]
 [0 1 0 0 0 0 1 0 1 1 0 1 0 0 1 1]
 [0 1 0 0 0 1 1 0 1 0 0 1 0 1 1 1]
 [0 1 1 1 0 1 1 1 1 1 0 1 1 1 0 1]
 [0 0 1 1 0 1 1 1 0 1 1 0 0 1 1 0]
 [0 1 0 0 0 1 1 0 0 1 0 0 1 0 0 1]
 [0 1 1 0 1 1 1 0 0 0 0 1 1 0 0 0]
 [0 1 0 1 1 1 1 1 0 1 1 1 1 1 0 0]
 [0 1 1 1 0 1 0 0 1 1 1 0 1 0 0 0]
 [1 1 1 1 0 0 1 0 0 1 0 1 0 1 1 1]
 [1 1 1 1 1 1 0 0 0 0 1 1 0 0 1 1]
 [0 1 0 1 1 1 0 0 0 1 1 1 1 0 0 1]
 [1 0 1 0 1 0 1 0 1 0 0 1 0 1 0 1]
 [0 1 0 1 1 1 1 0 0 0 0 0 1 0 0 0]]
[[1 0 1 0 1 0 0 1 1 0 1 1 0 1 0 0]
 [1 1 0 1 0 0 0 1 0 0 1 1 1 1 1 1]
 [1 0 0 0 1 0 1 0 0 1 0 1 0 0 0 1]
 [0 1 0 1 0 1 1 0 1 0 1 0 1 1 0 0]
 [0 0 0 1 0 1 1 1 0 0 1 0 0 1 0 0]
 [0 0 0 0 1 1 0 1 1 1 1 1 1 0 1 0]
 [1 1 0 1 1 0 0 1 1 1 1 0 0 0 1 0]
 [1 0 0 1 0 0 0 1 1 0 1 0 0 1 0 0]
 [1 0 1 1 1 0 1 1 0 1 1 0 0 1 0 1]
 [1 1 1 1 0 1 1 0 0 0 1 0 0 1 1 1]
 [1 1 0 1 1 0 0 0 0 1 1 1 1 1 0 0]
 [1 1 0 1 0 1 1 1 0 1 0 0 1 0 0 1]
 [1 1 1 1 0 1 1 1 0 0 1 0 0 1 0 1]
 [1 1 1 0 1 1 1 1 1 0 1 1 0 0 1 1]
 [1 1 0 0 0 1 0 1 1 0 1 0 0 0 0 0]
 [1 1 0 0 0 1 1 1 0 0 1 1 0 0 1 0]]

Answer 2

If you know the maximum possible length ( max_len ) of vector , it's logical to just fill the vector with zeros: vector += [0]*(max_len - len(vector))

than make it 2D: vector2D = [vector[i:i+N] for i in range(0, max_len, N)]