Pastable version of Algorithm for zig-zagging over potentially infinite sets

<pre class='prettyprint' language='cs'>using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using NUnit.Framework;

namespace MagicMvc.Tests
{
    [TestFixture]
    public class ZigZaggerTests
    {
        IEnumerable&lt;int&gt; NaturalNumbers()
        {
            int i = 0;
            while (true)
            {
                yield return i++;
            }
        }

public class Tuple&lt;T0, T1&gt;
        {
            public Tuple(T0 first, T1 second)
            {
                this.First = first;
                this.Second = second;
            }

public T0 First { get; private set; }
            public T1 Second { get; private set; }
        }

readonly Action&lt;Tuple&lt;int, int&gt;, int, int&gt; assert =
            (tuple, a, b) =&gt; Assert.That(tuple.First == a &amp;&amp; tuple.Second == b);

static IEnumerable&lt;Tuple&lt;TX, TY&gt;&gt; ZigZag&lt;TX, TY&gt;(IEnumerable&lt;TX&gt; xs, IEnumerable&lt;TY&gt; ys)
        {
            var xValues = new List&lt;TX&gt;();
            IEnumerator&lt;TX&gt; xEnumerator = xs.GetEnumerator();
            IEnumerator&lt;TY&gt; yEnumerator = ys.GetEnumerator();
            var yValues = new List&lt;TY&gt;();
            while (xEnumerator.MoveNext() &amp;&amp; yEnumerator.MoveNext())
            {
                xValues.Add(xEnumerator.Current);
                yValues.Add(yEnumerator.Current);
                for (int i = xValues.Count - 1; i &gt;= 0; i--)
                {
                    yield return new Tuple&lt;TX, TY&gt;(xValues[i], yValues[xValues.Count - i - 1]);
                }
            }
        }

[Test]
        public void CombineAFuncWithOneParameter()
        {
            Expression&lt;Func&lt;int, bool&gt;&gt; filterOne = i =&gt; i != 1;
            Expression&lt;Func&lt;int, bool&gt;&gt; filterTwo = i =&gt; i != 2;
            Expression&lt;Func&lt;int, bool&gt;&gt; combined = filterOne.And(filterTwo);
            IQueryable&lt;int&gt; filtered = this.NaturalNumbers().Take(3).AsQueryable().Where(combined);
            Assert.AreEqual(0, filtered.Single());
        }

[Test]
        public void CombineFuncsWithTwoParameters()
        {
            Expression&lt;Func&lt;int, int, bool&gt;&gt; filterOne = (x, y) =&gt; x != y;
            Expression&lt;Func&lt;int, int, bool&gt;&gt; filterTwo = (x, y) =&gt; x*2 == y;
        }

[Test]
        public void TestInfiniteSets()
        {
            List&lt;Tuple&lt;int, int&gt;&gt; tuples = ZigZag(this.NaturalNumbers(), this.NaturalNumbers()).Take(10).ToList();
            this.assert(tuples[0], 0, 0);
            this.assert(tuples[1], 1, 0);
            this.assert(tuples[2], 0, 1);
            this.assert(tuples[3], 2, 0);
            this.assert(tuples[4], 1, 1);
            this.assert(tuples[5], 0, 2);
            this.assert(tuples[6], 3, 0);
            this.assert(tuples[7], 2, 1);
            this.assert(tuples[8], 1, 2);
            this.assert(tuples[9], 0, 3);
        }
    }
}</pre>
<a href="http://www.refactormycode.com/codes/806-algorithm-for-zig-zagging-over-potentially-infinite-sets" style="color:#fff" title="As seen on RefactorMyCode.com"><img alt="Small_logo" src="http://www.refactormycode.com/images/small_logo.gif" style="border:0" /></a>

Refactor :my => 'code'

Recent

Popular

Pastable version of Algorithm for zig-zagging over potentially infinite sets