标签: enumerator

我正在尝试追踪代码中的错误.我把它煮成下面的片段.在下面的示例中,我有一个int网格(行列表),但我想找到具有1的列的索引.这个的实现是为每一行创建一个枚举器并逐步遍历每一列转而将调查员保持在一步.

class Program
{
    static void Main(string[] args)
    {
        var ints = new List<List<int>> {
            new List<int> {0, 0, 1},    // This row has a 1 at index 2
            new List<int> {0, 1, 0},    // This row has a 1 at index 1
            new List<int> {0, 0, 1}     // This row also has a 1 at index 2
        };
        var result = IndexesWhereThereIsOneInTheColumn(ints);

        Console.WriteLine(string.Join(", ", result)); // Expected: "1, 2"
        Console.ReadKey();
    }


    private static IEnumerable<int> IndexesWhereThereIsOneInTheColumn(
        IEnumerable<List<int>> myIntsGrid)
    {
        var …

我不知道是否可以实现满足以下第二个思想要求的最佳字符串生成器类:

• 使用正则表达式生成标准
• 字典顺序列举.
• 伯爵计算
• 索引访问

还有哪些其他最佳选择？

• 订购:首先按长度(最短的第一个),然后按字典顺序排列.
• 生成中使用的字符范围的规范:[AZ],[az],数字,特殊符号和最终空间(正则表达式？)的所有可打印或任何可能的组合.
• 字符串长度以给定的最小值/最大值为界.
• 搜索空间受边界限制:开始字符串结束字符串可能过滤(正则表达式？)

最后编辑

首先,我使用正则表达式而不是正则表达式来改写标题.

我正在考虑修改第一项要求,因为它是一扇敞开的门,可能导致难以解决的问题.

我需要建议和帮助正确的措辞.

第二个想法要求编辑完成.仍然愿意提出改进建议.

有办法吗？

a = b.map{ |e| #return multiple elements to be added to a }

而不是为每个要添加的迭代返回单个对象,a可以返回多个对象.

我目前正在实现这一目标:

a = []
b.map{ |e| a.concat([x,y,z]) }

有没有办法在单行中进行此操作而无需事先声明a = []？

我在解析文本文件时构建了两个数组.第一个包含列名,第二个包含当前行的值.我需要一次迭代两个列表来构建一个地图.现在我有以下内容:

var currentValues = currentRow.Split(separatorChar);
var valueEnumerator = currentValues.GetEnumerator();

foreach (String column in columnList)
{
    valueEnumerator.MoveNext();
    valueMap.Add(column, (String)valueEnumerator.Current);
}

这很好用,但它并不能完全满足我的优雅感,如果阵列的数量大于2,它会变得非常毛茸茸(我偶尔也会这样做).有没有人有另一个更高级的成语？

我写了一个类似的函数,Data.Enumerator.List.map它Iteratee与Enumerator一个不同Stream类型的函数兼容.

import Data.Enumerator

test :: Monad m => (ao -> ai) -> Iteratee ai m b -> Iteratee ao m b
test f iter = go $$ iter
   where go (Continue k) = continue $
            \stream -> go $$ k (fmap f stream)
         go (Yield res _) = yield res EOF

如果我省略了类型签名go,这将工作得很好.但是,我想包括它,但我无法确定正确的签名应该是什么.这是我认为它应该是:

go :: Monad m => Step ai m b -> Iteratee ao m b

但这不起作用.
我需要一些关于找到正确类型签名的建议go.

所有string.Split方法似乎都返回一个字符串数组(string[]).

我想知道是否有一个惰性变体返回一个IEnumerable<string>大字符串(或无限长度IEnumerable<char>),当一个人只对第一个子序列感兴趣时,一个节省计算工作量和内存.如果字符串由设备/程序(网络,终端,管道)构成,并且因此不需要立即完全可用,则它也可能是有用的.这样人们就已经可以处理第一次出现了.

.NET框架中是否有这样的方法？

在C#中,从对象的枚举器创建对象数组的最优雅方法是什么？例如,在这种情况下,我有一个可以返回字节的枚举器,所以我想将其转换为byte [].

编辑:创建枚举器的代码:

IEnumerator<byte> enumerator = updDnsPacket.GetEnumerator();

将非泛型集合转换为泛型集合的最佳方法是什么？LINQ有办法吗？

我有以下代码.

public class NonGenericCollection:CollectionBase
{
    public void Add(TestClass a)
    {
        List.Add(a);
    }
}

public class ConvertTest
{
    public static List<TestClass> ConvertToGenericClass( NonGenericCollection    collection)
    {
        // Ask for help here.
    }
}

谢谢!

上下文:C#3.0,.Net 3.5
假设我有一个生成随机数的方法(永远):

private static IEnumerable<int> RandomNumberGenerator() {
    while (true) yield return GenerateRandomNumber(0, 100);
}

我需要将这些数字分组为10组,所以我想要像:

foreach (IEnumerable<int> group in RandomNumberGenerator().Slice(10)) {
    Assert.That(group.Count() == 10);
}

我已经定义了Slice方法,但我觉得应该已经定义了一个.这是我的Slice方法,仅供参考:

    private static IEnumerable<T[]> Slice<T>(IEnumerable<T> enumerable, int size) {
        var result = new List<T>(size);
        foreach (var item in enumerable) {
            result.Add(item);
            if (result.Count == size) {
                yield return result.ToArray();
                result.Clear();
            }
        }
    }

问题:有没有更简单的方法来完成我想要做的事情？也许是Linq？

注意:上面的例子是一个简化,在我的程序中我有一个Iterator,它以非线性的方式扫描给定的矩阵.

编辑:为什么Skip+ Take不好.

实际上我想要的是:

var group1 = RandomNumberGenerator().Skip(0).Take(10);
var group2 = RandomNumberGenerator().Skip(10).Take(10);
var group3 = …

我很好奇为什么ruby返回一个Enumerator而不是一个Array,看起来似乎是一个明显的选择.例如:

'foo'.class
# => String

大多数人认为String是一个字符数组.

'foo'.chars.class
# => Enumerator

那么为什么String #chars会返回一个Enumerable而不是一个Array呢？我假设有人对此进行了大量的思考,并认为Enumerator更合适,但我不明白为什么.