Question

假设我有两个数组：

a = np.array(
[[0, 1],
 [2, 3],
 [4, 5],
 [6, 7]])

b = np.array(
[[2, 3],
 [6, 7],
 [0, 1],
 [4, 5]])

如您所见，一个数组只是另一个数组的 shuffle 。我需要结合这两个数组以形成第三个数组c，例如：

数组c的第一部分（直到随机索引i）由数组a的第一部分（直到索引i）组成。因此，c[:i] == a[:i]必须返回True。
数组c的其余部分由数组b中的值填充，这些值尚未出现在数组c中，其顺序完全相同。

鉴于索引i已设置为2 ，代码中上述数组a和b的期望输出应为：

> c
[[0, 1],
 [2, 3],
 [6, 7],
 [4, 5]]

数组c的长度必须与数组b和数组a的长度相同，并且数组a或数组{中的两个元素都有可能存在{1}}相同。数组b还必须包含c和a中相同的元素（即，其行为有点像随机播放）。

我尝试了多种解决方案，但没有一个能提供理想的结果。最接近的是这样：

但是，有时这会导致数组a = np.arange(10).reshape(5, 2) np.random.shuffle(a) b = np.arange(10).reshape(5, 2) b_part = b[:4] temp = [] for part in a: if part in b_part: continue else: temp.append(part) temp = np.array(temp) c = copy.deepcopy(np.vstack((b_part, temp)))小于数组c和a，因为这两个列表中的元素有时都可以重复。

Answer 1

这是一种解决方案：

full_len = len(a)

b_not_in_a_part = ~np.all(np.isin(b,a[:i+1]),axis=1)         # Get boolean mask, to apply on b
b_part_len = full_len-i-1                                    # Length of b part of c

c = np.concatenate((a[:i+1], b[b_not_in_a_part,:]), axis=0)  # Contruct c, using the mask for the b part.

进行测试：

import numpy as np
a = np.array(
[[0, 1],
 [2, 3],
 [0, 0],
 [2, 3],
 [4, 5],
 [6, 7]])
b = np.array(
[[2, 3],
 [6, 7],
 [0, 1],
 [4, 5],
 [2, 3],
 [0, 0]])

i = 2

print ("a is:\n", a)
print ("b is:\n", b)

full_len = len(a)

b_not_in_a_part = ~np.all(np.isin(b,a[:i+1]),axis=1)         # Get boolean mask, to apply on b
b_part_len = full_len-i-1                                    # Length of b part of c

c = np.concatenate((a[:i+1], b[b_not_in_a_part,:]), axis=0)  # Contruct c, using the mask for the b part.
print ("c is:\n", c)

输出：

a is:
 [[0 1]
 [2 3]
 [0 0]
 [2 3]
 [4 5]
 [6 7]]
b is:
 [[2 3]
 [6 7]
 [0 1]
 [4 5]
 [2 3]
 [0 0]]
c is:
 [[0 1]
 [2 3]
 [0 0]
 [6 7]
 [4 5]]

注意：在此示例中，c的长度仅为5，即使a和b的长度为{ {1}}。这是因为，由于6中的重复性很高，b中剩余的值不足，无法用于b。

Answer 2

以下应正确处理重复项。

read -r -a users
for user in "${users[@]}"; do
  mkdir -- "$user"
done

它

间接对def mix(a, b, i): sa, sb = map(np.lexsort, (a.T, b.T)) mb = np.empty(len(a), '?') mb[sb] = np.arange(2, dtype='?').repeat((i, len(a)-i))[sa] return np.concatenate([a[:i], b[mb]], 0)和a进行排序
在未从b取得的位置上创建一个True的蒙版，即具有a个Falses，然后具有i个Trues。
使用排序顺序将该掩码映射到len(a)-i
使用掩码过滤b并追加到b

示例（为了节省空间）：

a[:i]

Answer 3

只需使用 numpy.concatenate（）并确保您的索引本身就是1（因为numpy索引达到但不包括所述索引值，请参见下文）：（编辑：似乎您修改了a，b和c数组，因此我将在下面更改我的代码以适应）

@import "../node_modules/bootstrap/scss/bootstrap";

html, body {
    height: 100% !important;
    width: 100% !important;
}

输出：

import numpy as np

a = np.array(
[[0, 1],
 [2, 3],
 [4, 5],
 [6, 7]])

b = np.array(
[[2, 3],
 [6, 7],
 [0, 1],
 [4, 5]])


i = 2
c = a[0:i]
for k in b:
    if k not in c:
        c = np.concatenate((c, [k]))

print(c)

Answer 4

对于core_st，获得结果的第一部分：
```
open_core()
```
获取i=2和c = a[i:]之间的“不常见”元素：
```
b
```
从c和diff = np.array([x for x in b if x not in c])中选择random个元素到原始数组：
```
diff
```

输出：

concatenate

numpy的二维数组组合

4 个答案: