标签: list

我想实现以下目标：如果用户选择输入X（这是一个数字，可以说1、2、3 ... 10），我也想渲染特定的其他vue组件x次。如果我用10中的v-for n来解决这个问题，它会起作用，但是如果我使用变量，它就不会起作用。

    <template>
<div>
    <select v-model="selected" >
    <option disabled value="">Please select one</option>
    <option>1</option>
    <option>2</option>
    <option>3</option>
    </select>

    <span v-for="n in selected" :key="n">{{"hey"}}</span>


</div>
</template>

<script>
export default {
  data: function () {
      return {
        selected: ''
      }
  },
}
</script>

有什么好主意吗？我刚刚返回了一些字符串rn，（但是它必须是一个组件，但是我可以将字符串替换为正确的组件），如果我将所选的字符串替换为例如5的数字（那么它将呈现5倍）

在简短的说明上也很明显：当我用n替换“ hey”时，它将呈现正确的数字。（数字而不是次数，它显示1 2 3 ...，但仅显示一次）

给定起始编号和增量后，我希望能够在Haskell中创建列表列表。

例如：

>listIncrease 5 3
[[5], [5,6], [5,6,7]]

我尝试使用递归函数，但无法正确获得该函数。

这是我目前拥有的：

>listIncrease 5 3
[[5], [5,6], [5,6,7]]

我知道由于基本情况和基本情况不正确，以及递归步骤（因为您不能将[[Int]]设为[Int]），因此无法使用。

我试图以相反的顺序遍历一个列表，从-0索引项（也是第0个项）开始，而不是-1索引项，以便现在有了新的列表供使用。我想出了两种方法来做到这一点，但似乎都不是简洁明了的。

a_list = [1, 2, 3, 4, 5]

print(a_list[:1] + a_list[:0:-1])    # take two slices of the list and add them
# [1, 5, 4, 3, 2]

list_range = range(-len(a_list)+1,1)[::-1]    # create an appropriate new index range mapping
print([a_list[i] for i in list_range])        # list comprehension on the new range mapping
# [1, 5, 4, 3, 2]

python 3中有没有一种方法可以使用切片或另一种方法来更简单地实现这一目的？

我试图找出在列表中解包迭代器的pythonic方法是什么。

例如：

my_iterator = zip([1, 2, 3, 4], [1, 2, 3, 4])

我提供了以下几种在列表中解压缩迭代器的方法：

1）

my_list = [*my_iterator]

2）

my_list = [e for e in my_iterator]

3）

my_list = list(my_iterator)

No 1）是我最喜欢的方法，因为它减少了代码，但是我想知道这是否也是pythonic方法。或者，也许除了Python 3之外，还有另一种方法可以实现这一目标？

我有一个树对象，它是不规则的树，每当我运行代码时，孩子的名字和键值就可以更改。例如：

{
    addressRouter: 192.168.0.1,   
    addresses: 
        {
            address1: 'A',   

        },
        {
            address2: 'B',   

        },
        {
            ports: [
                {
                    portA: 'C',   
                    portB: null
                },


        }
    route: 'D',

}

所以名称：“ addressRouter”，“ addresses”，“ address1”等及其键是不可预测的，但是我需要将树对象转换为以下格式的数组：

addressRouter
addresses/address1
addresses/address2
addresses/ports/portA
addresses/ports/portB
route

然后把钥匙放在旁边。

我有此功能来构造树，这是正确的：

const iterate = (obj, obj2) => {
  Object.keys(obj).forEach(key => {

    obj2[key] = obj[key];

    if (typeof obj[key] === 'object') {
        iterate(obj[key], obj2)
    }
  })
}

但是在调试之后，我意识到它并没有获得所有分支。

我目前正在学习Haskell，我必须说，我过得很糟糕。

我的任务是创建一个函数evens，该函数接受一个值x，并返回从0to到所有偶数的列表x。

例如：

>  evens 10

> [2,4,6,8,10]

Run Code Online (Sandbox Code Playgroud)

我一直在尝试使用列表理解来修改一些示例函数，以实现我的目标，但是我简直陷入了很多错误，更糟糕的是，即使我尝试了很多事情，所有的一切都变得令人困惑。

我最后的尝试如下：

evens :: int -> [int]
evens n = [x | x <- [0..n], filter even x]

它产生了错误：

ex1.hs：9：29：错误：

•无法将预期类型“布尔”与实际类型“ [整数]”匹配

•在表达式中： filter even x

在列表理解的步骤中： filter even x

在表达式中： [x | x <- [0 .. n], filter even x]

我确实看到它期望布尔值，但是坦率地说，我不知道在哪里或为什么。

任何帮助将不胜感激。我从没有使用过函数式编程语言的经验，并且很难弄清自己在思想上的错误。我觉得我已经超出了这个简单的问题，以至于难以置信。

我正在使用WPF应用程序，有一次，我必须从字符串列表中获取/显示所有重复项。（具有重复的字符串名称和列表中相同字符串的数量）例如：“该列表包含字符串'Hello'3次。” 到目前为止，我已经成功获取了字符串的名称，但是我无法设法获得正确的出现在列表中的次数。到目前为止，这是我的代码：

List<String> answerData = new List<String>();

using (MySqlCommand command = new MySqlCommand(query2, conn))
                {
                    using (MySqlDataReader reader = command.ExecuteReader())
                    {
                        while (reader.Read())
                        {
                            answerData.Add(reader.GetString(0));
                        }
                    }
                }

var duplicates = answerData
                .GroupBy(i => i)
                .Where(g => g.Count() > 1)
                .Select(g => g.Key);

foreach (var d in duplicates)
{           
    MessageBox.Show(""+ d + duplicates.Count().ToString()); //Here I tried to get the number
    //with Count() but it doesn't work as I thought it would. 

}

我应该添加/更改什么以获得我想要的结果？

编辑

按照建议将我的代码更改为以下内容：

var duplicates = answerData
                .GroupBy(i …

我的清单如下：

list(c(TRUE, FALSE), TRUE, FALSE)

该列表包含只有一个目标TRUE，其他都是的混合TRUE和FALSE。我想算出TRUE唯一对象的位置编号，在这种情况下，答案是2。

听起来很简单，但到目前为止我还是失败了。

有什么解决办法吗？

我正在开发一个函数，该函数将使用两个六个六边形的骰子，并在元组列表中返回配对的所有可能性。

因此，我希望我的程序返回如下内容：

[(1,1),(1,2),(1,3),(1,4),(1,5),(1,6),
 (2,1),(2,2),(2,3),(2,4),(2,5),(2,6),
 (3,1),(3,2),(3,3),(3,4),(3,5),(3,6),
 (4,1),(4,2),(4,3),(4,4),(4,5),(4,6),
 (5,1),(5,2),(5,3),(5,4),(5,5),(5,6),
 (6,1),(6,2),(6,3),(6,4),(6,5),(6,6)]

我认为我的头可能在正确的常规区域，但是执行起来有点麻烦，因为我是Haskell的新手。这是我所拥有的：

rolls :: [(Integer, Integer)]
fstDice = [1, 2, 3, 4, 5, 6]
sndDice = [1, 2, 3, 4, 5, 6]
rolls
    | zip fstDice sndDice
    | drop 1 sndDice
    | otherwise = rolls 

我知道最后一部分是非常错误的，相信我。我以前是zip将两个骰子放在一起，然后想到要放下head第二个骰子，然后重复该过程，直到sndDice没有空并找到所有的骰子对为止。

我不确定这个想法是否错误，或者只是我的业余执行不正确。

（根据记录，我知道它不会编译！我也不知道如何处理该错误。）

考虑以下：

var1 = 'test test'
var2 = 'test test'

list1=[10,12,12,"Test"]

list2=[10,12,12,"Test"]

print(id(var1) == id(var2)) # True
print(id(list1) == id(list2)) # False

该布尔表达式为False。这意味着list1和list2的存储位置不同。为什么具有相同值的变量指向相同的内存位置，而列表却指向不同的位置？