static IEnumerable <HashAnalysisResult> BenchmarkNastyNestedCases() { var manuals = ( from a in MoreEnumerable.Generate(-10000, a => a + 6).TakeWhile(a => a < 14100) from b0 in MoreEnumerable.Generate(int.MaxValue, c => (int)(c * 0.95)).TakeWhile(c => c > 0) from sign in new[] { -1, 1 } let b = sign * b0 select new NastyNestedManual { Nested = new NastyNestedManual { A = b, B = a, }, A = a, B = b, } ).ToArray(); var valueObjects = manuals.Select(m => m.ToValueObject()).ToArray(); var tuples = manuals.Select(m => m.ToTuple()).ToArray(); var cs7tuples = manuals.Select(m => m.ToCs7Tuple()).ToArray(); yield return(ProcessList(manuals)); yield return(ProcessList(valueObjects)); yield return(ProcessList(tuples)); yield return(ProcessList(cs7tuples)); }
static IEnumerable <HashAnalysisResult> BenchmarkSymmetricalCases() { var manuals = ( from a in MoreEnumerable.Generate(-5100, a => a + 5).TakeWhile(a => a < 5100) from b0 in MoreEnumerable.Generate(int.MaxValue, c => (int)(c * 0.95)).TakeWhile(c => c > 0) from sign in new[] { -1, 1 } let b = sign * b0 from swap in new[] { true, false } select new IntPairManual { A = swap ? a : b, B = swap ? b : a, } ).Distinct().ToArray(); var valueObjects = manuals.Select(m => m.ToValueObject()).ToArray(); var tuples = manuals.Select(m => m.ToTuple()).ToArray(); var structs = manuals.Select(m => m.ToStruct()).ToArray(); var anonymous = manuals.Select(m => new { m.A, m.B, }).ToArray(); yield return(ProcessList(manuals)); yield return(ProcessList(valueObjects)); yield return(ProcessList(tuples)); yield return(ProcessList(structs)); yield return(ProcessList(anonymous)); }
static IEnumerable <HashAnalysisResult> BenchmarkIntPairCases() { var manuals = ( from a in MoreEnumerable.Generate(-8000, a => a + 4).TakeWhile(a => a < 8000) from b0 in MoreEnumerable.Generate(int.MaxValue, c => (int)(c * 0.95)).TakeWhile(c => c > 0) from sign in new[] { -1, 1 } let b = sign * b0 select new IntPairManual { A = a, B = b, } ).ToArray(); var valueObjects = manuals.Select(m => m.ToValueObject()).ToArray(); var tuples = manuals.Select(m => m.ToTuple()).ToArray(); var cs7tuples = manuals.Select(m => m.ToCs7Tuple()).ToArray(); var structs = manuals.Select(m => m.ToStruct()).ToArray(); var anonymous = manuals.Select(m => new { m.A, m.B, }).ToArray(); yield return(ProcessList(manuals)); yield return(ProcessList(valueObjects)); yield return(ProcessList(tuples)); yield return(ProcessList(cs7tuples)); yield return(ProcessList(structs)); yield return(ProcessList(anonymous)); }
public void Solve() { var salt = ReadLine(); void InitArrays() { _mpValToIndexRepeating5 = Enumerable.Repeat(-1, 16).ToList(); _nextCheck = 0; _md5Cache = new List <byte[]>(23000); } InitArrays(); WriteLine(MoreEnumerable .Generate(0, i => i + 1) .Where(n => IsKey(salt, n, false)) .Take(64) .Last()); InitArrays(); Write(MoreEnumerable .Generate(0, i => i + 1) .Where(n => IsKey(salt, n, true)) .Take(64) .Last()); _md5Cache = null; // Free up this memory }
public void Refresh() { bool hasRows = _rowDefinitions.Count > 0; bool hasCols = _columnDefinitions.Count > 0; int rCount = Math.Max(_rowDefinitions.Count, 1); int cCount = Math.Max(_columnDefinitions.Count, 1); var g = new List <UIElement> [rCount, cCount]; var rc = MoreEnumerable.Generate(true, b => b).Take(rCount).ToArray(); var cc = MoreEnumerable.Generate(true, b => b).Take(cCount).ToArray(); for (int i = 0; i < rCount; i++) { for (int j = 0; j < cCount; j++) { g[i, j] = new List <UIElement>(); } } for (int k = 0; k < _grid.Children.Count; k++) { var c = _grid.Children[k]; int i = (int)(c.GetValue(Grid.RowProperty) ?? 0); int j = (int)(c.GetValue(Grid.ColumnProperty) ?? 0); g[i, j].Add(c); } for (int i = 0; i < rCount; i++) { for (int j = 0; j < cCount; j++) { var hasContent = g[i, j].Any(HasContent); rc[i] = rc[i] && hasContent; cc[j] = cc[j] && hasContent; } } if (hasRows) { for (int i = 0; i < rCount; i++) { _grid.RowDefinitions[i] = rc[i] ? CloneRow(i) : EmptyRow; } } if (hasCols) { for (int j = 0; j < cCount; j++) { _grid.ColumnDefinitions[j] = cc[j] ? CloneColumn(j) : EmptyColumn; } } }
public void UnfoldFiniteSequence() { var result = MoreEnumerable.Unfold(1, x => (Result: x, State: x + 1), e => e.Result <= 100, e => e.State, e => e.Result); var expectations = MoreEnumerable.Generate(1, x => x + 1).Take(100); Assert.That(result, Is.EqualTo(expectations)); }
public void UnfoldFiniteSequence() { var result = MoreEnumerable.Unfold(1, x => new { result = x, state = x + 1 }, e => e.result <= 100, e => e.state, e => e.result); var expectations = MoreEnumerable.Generate(1, x => x + 1).Take(100); Assert.That(result, Is.EqualTo(expectations)); }
private void ShowInerDirtectiryRec(DirectoryInfo directoryInfo, int index) { Console.WriteLine($"{string.Concat(MoreEnumerable.Generate("\t", (s) => s).Take(index))}{directoryInfo.Name}"); directoryInfo.GetDirectories().ForEach(d => ShowInerDirtectiryRec(d, index + 1)); foreach (var f in directoryInfo.GetFiles()) { if (FileSystemHelper.FileFormats.Where(format => f.Name.LastIndexOf(format) == f.Name.Length - format.Length).Any()) { Console.WriteLine($"{string.Concat(MoreEnumerable.Generate("\t", (s) => s).Take(index))}--f: {f}"); } } }
public (string, string) Solve(string[] input) { var earliestLeavingTime = long.Parse(input[0]); var busses = input[1].Split(',').Where(x => x != "x").Select(int.Parse).ToList(); var leaving = MoreEnumerable.Generate(earliestLeavingTime, n => n + 1) .Select(m => new { Min = m, Bus = busses.FirstOrDefault(b => m % b == 0) }) .First(x => x.Bus != 0); var part1 = (leaving.Min - earliestLeavingTime) * leaving.Bus; var part2 = Solve2Optimized(input[1]); return(part1.ToString(), part2.ToString()); }
public static IQuery <int> Sequence(int first, int last, int step) { if (step <= 0) { throw new ArgumentException(null, nameof(step)); } if (last < first) { step = -step; } return(MoreEnumerable.Generate(first, i => i + step) .TakeWhile(i => step < 0 ? i >= last : i <= last) .ToQuery()); }
public void ZipLongestDisposeSequencesEagerly() { var shorter = TestingSequence.Of(1, 2, 3); var longer = MoreEnumerable.Generate(1, x => x + 1); var zipped = shorter.ZipLongest(longer, Tuple.Create); var count = 0; foreach (var _ in zipped.Take(10)) { if (++count == 4) { ((IDisposable)shorter).Dispose(); } } }
static IEnumerable <HashAnalysisResult> BenchmarkComplicatedCases() { var manuals = ( from a in MoreEnumerable.Generate(-500, a => a + 4).TakeWhile(a => a < 500) from b0 in MoreEnumerable.Generate(int.MaxValue, b => (int)(b * 0.9)).TakeWhile(b => b > 0) from sign in new[] { -1, 1 } let b = sign * b0 from c in MoreEnumerable.Generate(1, c => c << 1).TakeWhile(c => c > 0) select new ComplicatedManual { AnEnum = (SeekOrigin)(c % 3), A = a, NullableInt = a < b && b < c ? default(int?) : a & b & c, B = b, Label = Math.Min(a, c).ToString(), Time = new DateTime(2014, 1, 1) + TimeSpan.FromSeconds(a + c + Math.Log(b0)), C = c, } ).ToArray(); var valueObjects = manuals.Select(m => m.ToValueObject()).ToArray(); var tuples = manuals.Select(m => m.ToTuple()).ToArray(); var cs7tuples = manuals.Select(m => m.ToCs7Tuple()).ToArray(); var structs = manuals.Select(m => m.ToStruct()).ToArray(); var anonymous = manuals.Select(m => new { m.AnEnum, m.A, m.NullableInt, m.B, m.Label, m.Time, m.C } ).ToArray(); yield return(ProcessList(manuals)); yield return(ProcessList(valueObjects)); yield return(ProcessList(tuples)); yield return(ProcessList(cs7tuples)); yield return(ProcessList(structs)); yield return(ProcessList(anonymous)); }
public void TransposeWithAllRowsAsInfiniteSequences() { var matrix = MoreEnumerable.Generate(1, x => x + 1) .Where(IsPrime) .Take(3) .Select(x => MoreEnumerable.Generate(x, n => n * x)); var result = matrix.Transpose().Take(5); var expectations = new[] { new[] { 2, 3, 5 }, new[] { 4, 9, 25 }, new[] { 8, 27, 125 }, new[] { 16, 81, 625 }, new[] { 32, 243, 3125 } }; AssertMatrix(expectations, result); }
protected override void ExecuteDay(byte[] input) { if (input == null) { return; } var regex = new Regex(@"^Generator (?<gen>\w) starts with (?<init>\d+)$", RegexOptions.Compiled); var generators = input.GetLines() .Select(l => regex.Match(l)) .ToDictionary( m => m.Groups["gen"].Value, m => (ulong)Convert.ToInt32(m.Groups["init"].Value)); Dump('A', Enumerable.Range(0, 40_000_000) .Scan( (a: generators["A"], b: generators["B"]), (state, _) => ((state.a * 16807) % 2147483647, (state.b * 48271) % 2147483647)) .Skip(1) .Where(s => (ushort)s.a == (ushort)s.b) .Count()); var aGenerator = MoreEnumerable .Generate(generators["A"], a => (a * 16807) % 2147483647) .Where(a => a % 4 == 0); var bGenerator = MoreEnumerable .Generate(generators["B"], b => (b * 48271) % 2147483647) .Where(b => b % 8 == 0); Dump('B', aGenerator.Zip(bGenerator, (a, b) => (a, b)) .Take(5_000_000) .Where(s => (ushort)s.a == (ushort)s.b) .Count()); }
static IEnumerable <int> fuelValues(int start) => MoreEnumerable.Generate(start, s => Math.Max(s / 3 - 2, 0)) .Skip(1) .TakeWhile(s => s != 0);
protected override void ExecuteDay(byte[] input) { var marbles = new LinkedList <int>(); LinkedListNode <int> prevNode(LinkedListNode <int> node) => node.Previous ?? marbles.Last; LinkedListNode <int> nextNode(LinkedListNode <int> node) => node.Next ?? marbles.First; LinkedListNode <int> nextNodeCount(LinkedListNode <int> node, int count) { for (int i = 0; i < count; i++) { node = nextNode(node); } return(node); } void AddNumber(int number) { foreach (var n in MoreEnumerable .Generate( number, n => n / 10) .TakeWhile(n => n != 0) .Reverse() .Select(n => n % 10) .DefaultIfEmpty(0)) { marbles.AddLast(n); } } AddNumber(37); var elf1 = marbles.First; var elf2 = nextNode(elf1); void DoTick() { AddNumber(elf1.Value + elf2.Value); elf1 = nextNodeCount(elf1, elf1.Value + 1); elf2 = nextNodeCount(elf2, elf2.Value + 1); } var numRecipes = Convert.ToInt32(input.GetString()); while (marbles.Count < numRecipes + 10) { DoTick(); } Dump('A', string.Join( "", MoreEnumerable .Generate( marbles.First, n => nextNode(n)) .Skip(numRecipes) .Take(10) .Select(n => n.Value))); marbles.Clear(); AddNumber(numRecipes); var matchList = marbles.Reverse().ToList(); marbles.Clear(); AddNumber(37); elf1 = marbles.First; elf2 = nextNode(elf1); while (true) { DoTick(); if (MoreEnumerable .Generate( marbles.Last, n => prevNode(n)) .Take(matchList.Count) .Select(n => n.Value) .SequenceEqual(matchList)) { Dump('B', marbles.Count - matchList.Count); return; } if (MoreEnumerable .Generate( marbles.Last, n => prevNode(n)) .Skip(1) .Take(matchList.Count) .Select(n => n.Value) .SequenceEqual(matchList)) { Dump('B', marbles.Count - matchList.Count - 1); return; } } }
public void GenerateWithNullGenerator() { MoreEnumerable.Generate(0, null); }
public void GenerateIsLazy() { MoreEnumerable.Generate(0, BreakingFunc.Of <int, int>()); }
public void GenerateProcessesNonNumerics() { var result = MoreEnumerable.Generate("", s => s + 'a').TakeWhile(s => s.Length < 5); result.AssertSequenceEqual("", "a", "aa", "aaa", "aaaa"); }
public void GenerateTerminatesWhenCheckReturnsFalse() { var result = MoreEnumerable.Generate(1, n => n + 2).TakeWhile(n => n < 10); result.AssertSequenceEqual(1, 3, 5, 7, 9); }
public void GenerateWithNullGenerator() { Assert.ThrowsArgumentNullException("generator", () => MoreEnumerable.Generate(0, null)); }
public void GenerateIsLazy() { var result = MoreEnumerable.Generate(0, BreakingFunc.Of <int, int>()).TakeWhile(n => false); result.Consume(); }
public void GenerateFuncIsNotInvokedUnnecessarily() { MoreEnumerable.Generate(0, BreakingFunc.Of <int, int>()) .Take(1) .Consume(); }