Question

我正在使用Regex.Split编写PascalCaseParser，我希望一次从一个集合中选择两个项目。

此示例代码演示。

void Main()
{
    string pascalCasedString = "JustLikeYouAndMe";
    var words = WordsFromPascalCasedString(pascalCasedString);
    words.Dump();
}

IEnumerable<string> WordsFromPascalCasedString(string pascalCasedString)
{
    var rx = new Regex("([A-Z])");
    return rx.Split(pascalCasedString)
             .Where(c => !string.IsNullOrEmpty(c))
             // how to select 2 elements at a time?
             ;
}

上述代码的结果是：

IEnumerable<String> (10 items)
J 
ust 
L 
ike 
Y 
ou 
A 
nd 
M 
e

集合中的每两个元素都会产生一个我想要函数WordsFromPascalCasedString产生的结果。

我的问题是：一般来说，您如何处理一次返回两件物品的要求。我很好奇是否有任何有趣的非暴力方法。

Answer 1

正则表达式应为([A-Z][a-z]*)。如果要包含数字，请调整最后一部分。如果您希望在大写分隔符后面至少有一个小写元素，请使用+而不是*。

编辑对于实际问题，您需要在for循环中实现并迭代以获得更好的性能（将列表传递一次）。在您的具体问题中，您只需使用Regex.Matches

即可

var result = Regex.Matches("([A-Z][a-z]*)([A-Z][a-z]*)?", "AbCdEfGhIj")
                  .OfType<Match>()
                  .Where(m => m.Success)
                  .Select(m => Tuple.Create(m.Groups[1].Value, m.Groups[2].Value));

Answer 2

就个人而言，在这个特殊情况下，我会选择 Simon Belanger 的答案。但一般来说，要从IEnumerable中选择连续的对，你可以使用它：

IEnumerable<Tuple<string, string>> WordsFromPascalCasedString(string pascalCasedString)
{
    var rx = new Regex("([A-Z])");
    var array = rx.Split(pascalCasedString)
                  .Where(c => !string.IsNullOrEmpty(c))
                  .ToArray();
    var items = Enumerable.Range(0, array.Length / 2)
                          .Select(i => Tuple.Create(array[i * 2], array[i * 2 + 1]);
}

或者这需要付出更多努力，但它可以重复使用并且效率更高：

IEnumerable<Tuple<T, T>> Pairs<T>(IEnumerable<T> input)
{
    var array = new T[2];
    int i = 0;
    foreach(var x in input)
    {
        array[i] = x;
        i = (i + 1) % 2;
        if (i == 0)
        {
            yield return Tuple.Create(array[0], array[1]);
        }
    }
}


IEnumerable<Tuple<string, string>> WordsFromPascalCasedString(string pascalCasedString)
{
    var rx = new Regex("([A-Z])");
    var output = rx.Split(pascalCasedString)
                   .Where(c => !string.IsNullOrEmpty(c));
    var items = Pairs(output);
}

可以轻松扩展到n：

组

IEnumerable<IEnumerable<T>> Batches<T>(IEnumerable<T> input, int n)
{
    var array = new T[n];
    int i = 0;
    foreach(var x in input)
    {
        array[i] = x;
        i = (i + 1) % n;
        if (i == 0)
        {
            yield return array.ToArray();
        }
    }

    if (i != 0)
    {
        yield return array.Take(i);
    }
}

MoreLINQ中存在类似的方法。

Answer 3

最简单的是编写简单返回对的函数。

类似的东西：

IEnumerable<Tuple<T,T>> Pairs<T>(IEnumerable<T> items)
{
    T first = default(T);
    bool hasFirst = false;
    foreach(T item in items)
    {
       if (hasFirst)
          yield return Tuple.Create(first, item);
       else
           first = item;
       hasFirst = !hasFirst;
    }
}

Aggregate可能只有一种单线方法。这纯粹是娱乐代码，因为在路上创建了大量垃圾，但没有使用可变对象。

IEnumerable<Tuple<T,T>> Pairs<T>(IEnumerable<T> collection)
{
  return collection
    .Aggregate(
      Tuple.Create(false, default(T), Enumerable.Empty<Tuple<T,T>>()),
         (accumulate, item)=> !accumulate.Item1 ? 
        Tuple.Create(true, item, accumulate.Item3) :
            Tuple.Create(false, default(T),
              accumulate.Item3.Concat(
                 Enumerable.Repeat(Tuple.Create(accumulate.Item2, item), 1))),
      accumulate => accumulate.Item3); 
}

奇数和偶数元素的{p> Zip（index %2 ==/!= 0）是2行方法。请注意，迭代源集合两次。

IEnumerable<Tuple<T,T>> Pairs<T>(IEnumerable<T> collection)
{
  return collection
   .Where((item, index)=>index %2 == 0)
   .Zip(collection.Where((item, index)=>index %2 != 0),
   (first,second)=> Tuple.Create(first,second));
}

Answer 4

这只是为了分享，我在得到其他答案的启发后，我想出了我想出的解决方案。它并不比其他人好......

void Main()
{
    string pascalCasedString = "JustLikeYouAndMe";
    var words = WordsFromPascalCasedString(pascalCasedString);
    words.Dump();
}

IEnumerable<string> WordsFromPascalCasedString(string pascalCasedString)
{
    var rx = new Regex("([A-Z])");
    return rx.Split(pascalCasedString)
             .Where(c => !string.IsNullOrEmpty(c))
             .InPieces(2)
             .Select(c => c.ElementAt(0) + c.ElementAt(1));
}

static class Ext
{
    public static IEnumerable<IEnumerable<T>> InPieces<T>(this IEnumerable<T> seq, int len)
    {
        if(!seq.Any()) 
            yield break;

        yield return seq.Take(len);

        foreach (var element in InPieces(seq.Skip(len), len))
            yield return element;
    }
}

如何一次选择2项？

4 个答案: