在数组中重新编号元素的有效方法(Efficient way of re-numbering elements in an array)

 我是python的新手，我正在尝试实现遗传算法，但需要一些操作代码的帮助。 
 
 我用这种方式制定了问题： 
 
 
 
 每个个体I都用一串M整数表示 
 
 
 I每个元素e取0到N的值 
 
 
 0 - N每个数字必须至少出现在I中一次 
 
 
 e的值并不重要，只要每个唯一值元素具有相同的唯一值（将它们视为类标签） 
 
 
 e小于或等于N 
 
 
 每个I N可以不同 
 
 
 在应用交叉操作后，我可能会生成违反这些约束中的一个或多个的子项，因此我需要找到一种方法来重新对元素进行编号，以便它们保留其属性，但符合约束条件。 
 
 例如： 
 
parent_1 (N=5): [1 3 5 4 2 1|0 0 5 2]
parent_2 (N=3): [2 0 1 3 0 1|0 2 1 3]

*** crossover applied at "|" ***

child_1: [1 3 5 4 2 1 0 2 1 3]
child_2: [2 0 1 3 0 1 0 0 5 2]
 
 child_1显然仍然满足所有约束，因为N = 5并且所有值0-5在数组中至少出现一次。 
 
 问题在于子2 - 如果我们使用max(child_2)计算N的方法，我们得到值5，但如果我们计算唯一值的数量，那么N = 4，这是N的值应该是什么。 我所要求的（以非常漫长的方式，被授予）是一个好的，pythonic方式这样做： 
 
child_2: [2 0 1 3 0 1 0 0 5 2]
*** some python magic ***
child_2':  [2 0 1 3 0 1 0 0 4 2]
*or*
child_2'': [0 1 2 3 1 2 1 1 4 0]
 
 child_2''用于说明值本身并不重要，只要唯一值的每个元素映射到相同的值，就会满足约束。 
 
 这是我到目前为止所尝试的： 
 
value_map = []
for el in child:
    if el not in value_map:
        value_map.append(el)

for ii in range(0,len(child)):
    child[ii] = value_map.index(child[ii])
 
 这种方法可以工作并返回类似于child_2''的结果，但我无法想象它在字符串上迭代两次的方式非常有效，所以我想知道是否有人对如何使其更好有任何建议。 
 
 谢谢，对于这么简单的问题这么长的帖子感到抱歉！ 

I am reasonably new to python and am trying to implement a genetic algorithm, but need some assistance with the code for one of the operations.
 
I have formulated the problem this way:
 
 
 
each individual I is represented by a string of M integers
 
 
each element e in I takes a value from 0 to N
 
 
every number from 0 - N must appear in I at least once
 
 
the value of e is not important, so long as each uniquely valued element takes the same unique value (think of them as class labels)
 
 
e is less than or equal to N
 
 
N can be different for each I 
 
 
after applying the crossover operation i can potentially generate children which violate one or more of these constraints, so i need to find a way to re-number the elements so that they retain their properties, but fit with the constraints.
 
for example:
 
parent_1 (N=5): [1 3 5 4 2 1|0 0 5 2]
parent_2 (N=3): [2 0 1 3 0 1|0 2 1 3]

*** crossover applied at "|" ***

child_1: [1 3 5 4 2 1 0 2 1 3]
child_2: [2 0 1 3 0 1 0 0 5 2]
 
child_1 obviously still satisfies all of the constraints, as N = 5 and all values 0-5 appear at least once in the array.
 
The problem lies with child 2 - if we use the max(child_2) way of calculating N we get a value of 5, but if we count the number of unique values then N = 4, which is what the value for N should be. What I am asking (in a very long winded way, granted) is what is a good, pythonic way of doing this:
 
child_2: [2 0 1 3 0 1 0 0 5 2]
*** some python magic ***
child_2':  [2 0 1 3 0 1 0 0 4 2]
*or*
child_2'': [0 1 2 3 1 2 1 1 4 0]
 
child_2'' is there to illustrate that the values themselves dont matter, so long as each element of a unique value maps to the same value, the constraints are satisfied.
 
here is what i have tried so far:
 
value_map = []
for el in child:
    if el not in value_map:
        value_map.append(el)

for ii in range(0,len(child)):
    child[ii] = value_map.index(child[ii])
 
this approach works and returns a result similar to child_2'', but i can't imagine that it is very efficient in the way it iterates over the string twice, so i was wondering if anyone has any suggestions of how to make it better.
 
thanks, and sorry for such a long post for such a simple question!