标签: flatten

目标是消除所有内部括号.

(flatten'(a(bc)d))变为'(abcd)

这是我在Racket中的代码

; if slist is null, return empty
; otherwise, if it is a pair, recursively solve car and cdr and concat them
; if it is a symbol, return the symbol

(define flatten
  (lambda (slist)
    (cond
      [ (null? slist) '()]
      [ (pair? slist)  
        (cons ((flatten (car slist)) (flatten (cdr slist))))]
      [ (symbol? slist) slist])))

它在抱怨

procedure application: expected procedure, given: c; arguments were: ()

这意味着我正在尝试访问car和cdr列出一个空列表.

I did the trace:
> (flatten '(a (b …

我有一个包含此列表的 python 脚本：

blocks = [
  "item-1",
  "item-2",
  "item-3.0;item-3.1;item-3.2"
]

我试过这个：

for (i, block) in enumerate(blocks):
  if ";" in block:
    [blocks.insert(i, c) for c in block.split(";")]
  else:
    blocks.insert(i, block)

要得到这个：

blocks = [
  "item-1",
  "item-2",
  "item-3.0",
  "item-3.1",
  "item-3.2"
]

不幸的是，我的代码不断覆盖列表中的元素，我只剩下这个：

blocks = [
  "item-1",
  "item-2",
  "item-3.2"
]

如何修改脚本以允许我在列表中拆分字符串，然后将新的子字符串插入原始字符串的位置，而不会覆盖列表中的其他元素？

我有这一系列的元组

val data = Seq(((1,2),3), ((4,5),6), ((7,8),9))

我想把它压平得到

Seq((1,2,3), (4,5,6), (7,8,9))

在我的ruby项目中,我有一个数组数组,这是进行一些重图遍历的结果

例:

[[], [1, 2, 3, 4, 5], [[], [], [[], [], [34, 54, 23, 45]]]]

我想要最终的产品

[[1, 2, 3, 4, 5], [34, 54, 23, 45]]

flatten将离开我

[1, 2, 3, 4, 5, 34, 54, 23, 45]

所以我不想那样

我被困住了,可以在如何做到这一点上使用一些帮助

到目前为止,我有

class Array
  def flatten_blanks
    each{ |elem| elem.flatten_blanks if elem.is_a?(Array) }
    reject!{ |elem| elem.is_a?(Array) && elem.length < 1 }
    self
  end
end

这很接近,但让我有类似的东西

[[[[[[[1, 2, 3, 4, 5]]]]]]], [[[[[[[34, 54, 23, 45]]]]]]]

我有一个平面阵列。像这样：

const inputArray = [
  {
    path: '1',
    id: '1'
  },
  {
    path: '2',
    id: '2'
  },
  {
    path: '3',
    id: '3'
  },
  {
    path: '3.4',
    id: '4'
  },
  {
    path: '3.5',
    id: '5'
  },
  {
    path: '3.4.6',
    id: '6'
  },
  {
    path: '3.4.7',
    id: '7'
  },
  {
    path: '8',
    id: '8'
  },
]

pathid 元素的唯一路径在哪里。例如，path: '3.5'表示此对象是具有 的对象的子对象id: '3'。并且path: '3.4.6'是孩子的path: '3.4'。我想将它们收集到嵌套结构中。所以结果应该是这样的。

const result = [
  {
    path: '1',
    id: '1',
    children: …

在Scala中，对于包含要分解的数组的case类，是否可以更有效地使用平面地图？

这是一个有效的代码，但看起来不正确：

object stuff {
    def main(args: Array[String]): Unit = {
        case class Stuff(name: String, stuff: Seq[String])
        case class FlatStuff(name: String, stuff: String)

        val someStuff = Array(Stuff("a", Seq("1", "2", "3")), Stuff("b", Seq("4", "5")))

        val stuffs = someStuff.flatMap(item => {
            val flatten = new Array[FlatStuff](item.stuff.length)
            for (i <- 0 until item.stuff.length) {
                flatten(i) = FlatStuff(item.name, item.stuff(i))
            }
            flatten
        })

        stuffs.foreach(stuff => println(stuff))
    }
}

我有一个 Spark 作业，它有一个具有以下值的 DataFrame：

{
  "id": "abchchd",
  "test_id": "ndsbsb",
  "props": {
    "type": {
      "isMale": true,
      "id": "dd",
      "mcc": 1234,
      "name": "Adam"
    }
  }
}

{
  "id": "abc",
  "test_id": "asf",
  "props": {
    "type2": {
      "isMale": true,
      "id": "dd",
      "mcc": 12134,
      "name": "Perth"
    }
  }
}

我想优雅地将它展平（因为没有未知的键和类型等），这样道具仍然是一个，struct但里面的所有东西都被展平了（不管嵌套的级别如何）

所需的输出是：

{
  "id": "abchchd",
  "test_id": "ndsbsb",
  "props": {
    "type.isMale": true,
    "type.id": "dd",
    "type.mcc": 1234,
    "type.name": "Adam"
  }
}

{
  "id": "abc",
  "test_id": "asf",
  "props": {
      "type2.isMale": true,
      "type2.id": "dd",
      "type2.mcc": 12134,
      "type2.name": "Perth" …

我有灰度图像，但我需要将其转换为一维向量的数据集我该怎么做？我在转换中找不到合适的方法：

train_dataset = torchvision.datasets.ImageFolder(root='./data',train=True, transform=transforms.ToTensor())
test_dataset = torchvision.datasets.ImageFolder(root='./data',train=False, transform=transforms.ToTensor())

train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=4, shuffle=True)
test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=4, shuffle=False)

这个要点是我写的一个小型基准测试，用于比较JS中深度为 1 的扁平数组的 4 种替代方案的性能 （代码可以按原样复制到谷歌控制台）。如果我没有遗漏任何东西，那么本机 Array.prototype.flat 迄今为止的性能最差 - 比任何替代品慢 30-50 倍。

更新：我在jsperf上创建了一个基准。

应该注意的是，该基准测试中的第 4 次实现始终是性能最高的 - 通常实现 70 倍的性能。该代码在 node v12 和 Chrome 控制台中进行了多次测试。

这个结果在一个大的子集中最为突出 - 请参阅下面测试的最后 2 个数组。考虑到规范和似乎完全遵循规范的V8 实现，这个结果非常令人惊讶。我的 C++ 知识不存在，因为我对 V8 兔子洞很熟悉，但在我看来，鉴于递归定义，一旦我们到达最终深度子数组，就不会对该子数组调用进行进一步的递归调用（标志当递减的深度达到 0 时，shouldFlatten 为假，即最终的子级别）并且添加到扁平结果包括迭代循环每个子元素，以及对该方法的简单调用。因此，我看不出为什么 a.flat 应该在性能上受到如此大的影响。

我想也许在原生公寓中结果的大小没有预先分配的事实可能解释了这种差异。此基准测试中的第二个实现（未预先分配）表明，仅凭这一点无法解释差异 - 它的性能仍然是原生 flat 的 5-10 倍。这可能是什么原因？

已测试的实现（代码中的顺序相同，存储在 implementations 数组中 - 我写的两个在代码片段的末尾）：

1. 我自己的展平实现包括预先分配最终展平的长度（从而避免所有重新分配的大小）。原谅命令式风格的代码，我是为了最大的性能。
2. 最简单的实现，循环遍历每个子数组并推入最终数组。（因此冒着许多大小重新分配的风险）。
3. Array.prototype.flat（原生平面）
4. [ ].concat(...arr)（=展开数组，然后将结果连接在一起。这是一种实现深度=1 展平的流行方法）。

测试的数组（代码中的顺序相同，存储在 benchmarks 对象中）：

1. 1000 个子数组，每个子数组 10 个元素。（共10人）
2. 10 个子数组，每个子数组 …

你能展平这样的元组吗：

(42, (23, (22, (17, []))))

成为所有元素的一个元组：

(42,23,22,17)

?