标签: sub-array

我正在切割一个字符串数组并将其设置为[String]变量,但类型检查器正在抱怨.这是一个可能的编译器错误吗？

var tags = ["this", "is", "cool"]
tags[1..<3]
var someTags: [String] = tags[1..<3]

我一直在尝试搜索在Swift中获取子数组的正确方法,但我在这里遗漏了一些东西.此代码不起作用,因为rowArray.append(row)抛出了一个错误.

无法将'ArraySlice <Int>'类型的值转换为指定类型'[Int]'

我无法弄清楚如何从主数组中获取[Int]或将ArraySlice <Int>转换为[Int].我猜我错过了一些简单但似乎无法从文档中找到答案的东西.

var rowArray = [[Int]]()

var rangeStart = 0
let rangeLength = mapWidth

for var index = 0; index < mapHeight; ++index{
    rangeStart = tileIDs.count - ((index + 1) * mapWidth )

    let row : [Int] = tileIDs[rangeStart...rangeStart+rangeLength]
    rowArray.append(row)
}
rowArray.append(row)

很明显,它的论点是:

int MPI_Type_create_subarray(
  int ndims,
  int array_of_sizes[],
  int array_of_subsizes[],
  int array_of_starts[],
  int order,
  MPI_Datatype oldtype,
  MPI_Datatype *newtype
);

但是,我无法理解这个方法如何接收我们想要分割的原始数组以及它返回新子数组的位置(因为此方法应该返回一个整数).换句话说,我只是想在C++中看到这个方法的简单实现,我无法在Internet上找到它.

考虑下面这样的数组:

  {1, 5, 3, 5, 4, 1}

当我们选择一个子阵列时,我们将它减少到子阵列中的最小数字.例如,子阵列{5, 3, 5}变为{3, 3, 3}.现在,子阵列的总和被定义为所得子阵列的总和.例如,{5, 3, 5}总和是3 + 3 + 3 = 9.任务是找到可以从任何子阵列中获得的最大可能总和.对于上面的数组,最大的和是12,由子阵列给出{5, 3, 5, 4}.

是否有可能比O(n ²)更好地及时解决这个问题？

在python列表中可以像这样切片x[4:-1]以从第四个元素到最后一个元素.

在R中,对于带有x[4:length(x)]和用于多维数组的向量,可以实现类似的东西x[,,,,4:dim(x)[5],,,].对于从中间元素到最后一个元素的特定维度的数组切片,这是更优雅的语法吗？

谢谢

我有以下代码片段:

char board[3][3] = {
                     {'1','2','3'},
                     {'4','5','6'},
                     {'7','8','9'}
                   };

printf("address of board : %p\n", &board);
printf("address of board[0] : %p\n", &board[0]);

两个printf()语句都打印相同的值:0x0013ff67

1. 据我所知,board(ie)数组名称代表第一个子数组的地址(即)board[0]和

2. board[0] 表示第一个数组中第一个元素的地址(即) board[0][0]

为什么我在所有printf()陈述中都得到相同的地址？我希望这两个语句都有不同的地址.

我对这些东西很新,并且不理解这种行为.请赐教.

我有一个对象数组,例如

var arr = [
    {"a": "x"},
    {"b": "0"},
    {"c": "k"},
    {"a": "nm"},
    {"b": "765"},
    {"ab": "i"},
    {"bc": "x"},
    {"ab": "4"},
    {"abc": "L"}
];

假设我只对其键对应的对象感兴趣var input = ["ab", "bc"].这意味着我想以下列方式提取所有可能的子数组result[i].length == 2:

var result = [
    [{"ab": "i"}, {"bc": "x"}],
    [{"ab": "4"}, {"bc": "x"}] // or [{"bc": "x"}, {"ab": "4"}]
];

- 也就是说,子数组中对象的顺序绝对不重要:我只对每个子数组包含两个对象这一事实感兴趣 - {"ab": ...}和{"bc": ...}.

如果我感兴趣var input = ["a","a","ab"],结果应该是这样的:

var result = [
    [{"a": "x"}, {"a": "nm"}, {"ab": …

我有3D numpy数组,我只想要独特的2D子数组.

输入:

[[[ 1  2]
  [ 3  4]]

 [[ 5  6]
  [ 7  8]]

 [[ 9 10]
  [11 12]]

 [[ 5  6]
  [ 7  8]]]

输出:

[[[ 1  2]
  [ 3  4]]

 [[ 5  6]
  [ 7  8]]

 [[ 9 10]
  [11 12]]]

我尝试将子数组转换为字符串(tostring()方法),然后使用np.unique,但在转换为numpy数组后,它删除了\ x00的最后一个字节,所以我无法使用np.fromstring()将其转换回来.

例:

import numpy as np
a = np.array([[[1,2],[3,4]],[[5,6],[7,8]],[[9,10],[11,12]],[[5,6],[7,8]]])
b = [x.tostring() for x in a]
print(b)
c = np.array(b)
print(c)
print(np.array([np.fromstring(x) for x in c]))

输出:

[b'\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00', b'\x05\x00\x00\x00\x06\x00\x00\x00\x07\x00\x00\x00\x08\x00\x00\x00', b'\t\x00\x00\x00\n\x00\x00\x00\x0b\x00\x00\x00\x0c\x00\x00\x00', b'\x05\x00\x00\x00\x06\x00\x00\x00\x07\x00\x00\x00\x08\x00\x00\x00']
[b'\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04'
 b'\x05\x00\x00\x00\x06\x00\x00\x00\x07\x00\x00\x00\x08'
 b'\t\x00\x00\x00\n\x00\x00\x00\x0b\x00\x00\x00\x0c'
 b'\x05\x00\x00\x00\x06\x00\x00\x00\x07\x00\x00\x00\x08'] …

我想要一个 numpy 2D ndarray 的子数组（介于最小值和最大值之间）

    xy_dat = get_xydata()
    x_displayed = xy_dat[((xy_dat > min) & (xy_dat < max))]

min 和 max 是浮点数，以便与数组 xy_dat 的第一个值进行比较

xy_dat 是一个二维 numpy 数组：

[[ 735964.            1020.        ]
 [ 735964.04166667    1020.        ]
 [ 735964.08333333    1020.        ]
 ..., 
 [ 736613.39722222    1095.        ]
 [ 736613.40416667    1100.        ]
 [ 736613.41111111    1105.        ]]

x_displayed 被正确过滤，但我丢失了第二个值（它现在是一个一维数组）：

[ 735964.04166667  735964.08333333  735964.125      
 ...,  
736613.39027778  736613.39722222  736613.40416667]

如何对第一个值进行过滤并保留另一个值？

我注意到，采用非“快速线性索引”子数组分配的视图，而这在经典向量上是可能的。知道如何让这个分配免费吗？

以下是该行为的说明：

function temp!(lin::Vector{Int}, v::AbstractVector)
  w = view(v, lin)
  return nothing
end

lin = Int[1]; v = [0.0, 0.0, 0.0, 0.0];
temp!(lin, v)
@allocated temp!(lin, v) # allocates 0
vr = view(v, 1:3)
temp!(lin, vr)
@allocated temp!(lin, vr) # allocates 64