/// <summary> /// Serializes a data document instance into a Subarray<byte> delimited chunk of thread-local buffer. /// Because sub-arrays are used for thread-local optimizations, this method should be used in a synchronous-only /// thread-bound flows, such as serializing payload into Pile and the returned object must be consumed right away as subsequent calls /// to this method will overwrite the previous content as the same thread local physical buffer is re-used. /// </summary> public static Subarray <byte> SerializeToSubarray(TypedDoc doc) { var stream = ts_WriteStream; var writer = ts_Writer; var result = ts_Subarray; if (stream == null) { stream = new MemoryStream(INITIAL_BUFFER_CAPACITY); writer = SlimFormat.Instance.GetWritingStreamer(); writer.BindStream(stream); result = new Subarray <byte>(); ts_WriteStream = stream; ts_Writer = writer; ts_Subarray = result; } stream.Position = 0; Serialize(doc, writer, true); result.Set(stream.GetBuffer(), (int)stream.Position); //don't let large hunk dangling in the TLS if (stream.Capacity > BUFFER_TRIM_CAPACITY) { stream.SetLength(0); stream.Capacity = INITIAL_BUFFER_CAPACITY; } return(result); }
public void PutSubarray() { using (var pile = new DefaultPile(NOPApplication.Instance)) { pile.Start(); var src = new byte[] { 1, 6, 9, 250 }; var sub = new Subarray <byte>(); sub.Set(src, 2); var ptr1 = pile.Put(sub); sub.Set(src, 4); var ptr2 = pile.Put(sub); var got1 = pile.Get(ptr1) as byte[]; var got2 = pile.Get(ptr2) as byte[]; Aver.IsNotNull(got1); Aver.AreEqual(2, got1.Length); Aver.AreEqual(1, got1[0]); Aver.AreEqual(6, got1[1]); Aver.IsNotNull(got2); Aver.AreEqual(4, got2.Length); Aver.AreEqual(1, got2[0]); Aver.AreEqual(6, got2[1]); Aver.AreEqual(9, got2[2]); Aver.AreEqual(250, got2[3]); } }
public static Subarray FindSmallestSequentiallyCoveringSubset(List <string> paragraph, List <string> keywords) { // Maps each keyword to its index in the keywords array. var keywordToIdx = new Dictionary <string, int>(); // Since keywords are uniquely identified by their indices in keywords // array, we can use those indices as keys to lookup in a vector. var latestOccurrence = new List <int>(); // For each keyword (identified by its index in keywords array), stores the // length of the shortest subarray ending at the most recent occurrence of // that keyword that sequentially cover all keywords up to that keyword. var shortestSubarrayLength = new List <int>(); // Initializes latestOccurrence , shortestSubarrayLength , and keywordToIdx. for (var i = 0; i < keywords.Count; ++i) { latestOccurrence.Add(-1); shortestSubarrayLength.Add(int.MaxValue); keywordToIdx[keywords[i]] = i; } var shortestDistance = int.MaxValue; var result = new Subarray(-1, -1); for (var i = 0; i < paragraph.Count; ++i) { if (keywordToIdx.ContainsKey(paragraph[i])) { var keywordIdx = keywordToIdx[paragraph[i]]; if (keywordIdx == 0) // First keyword. { shortestSubarrayLength[0] = 1; } else if (shortestSubarrayLength[keywordIdx - 1] != int.MaxValue) { var distanceToPreviousKeyword = i - latestOccurrence[keywordIdx - 1]; shortestSubarrayLength[keywordIdx] = distanceToPreviousKeyword + shortestSubarrayLength[keywordIdx - 1]; } latestOccurrence[keywordIdx] = i; // Last keyword, look for improved subarray. if (keywordIdx == keywords.Count - 1 && shortestSubarrayLength[shortestSubarrayLength.Count - 1] < shortestDistance) { shortestDistance = shortestSubarrayLength[shortestSubarrayLength.Count - 1]; result.Start = i - shortestSubarrayLength[shortestSubarrayLength.Count - 1] + 1; result.End = i; } } } return(result); }
// Solution One public static Subarray FindSmallestSubarrayCoveringSet(List <string> paragraph, HashSet <string> keywords) { var keywordsToCover = new Dictionary <string, int>(); foreach (var keyword in keywords) { keywordsToCover[keyword] = keywordsToCover.ContainsKey(keyword) ? keywordsToCover[keyword] + 1 : 1; } var result = new Subarray(-1, -1); var remainingToCover = keywords.Count; var left = 0; for (var right = 0; right < paragraph.Count; ++right) { if (keywordsToCover.ContainsKey(paragraph[right])) { var keywordCount = keywordsToCover[paragraph[right]]; keywordsToCover[paragraph[right]] = --keywordCount; if (keywordCount >= 0) { --remainingToCover; } } // Keeps advancing left until it reaches end or keywordsToCover does not // have all keywords. while (remainingToCover == 0) { if ((result.Start == -1 && result.End == -1) || right - left < result.End - result.Start) { result.Start = left; result.End = right; } if (keywordsToCover.ContainsKey(paragraph[left])) { var keywordCount = keywordsToCover[paragraph[left]]; keywordsToCover[paragraph[left]] = ++keywordCount; if (keywordCount >= 0) { ++remainingToCover; } } ++left; } } return(result); }
// Solution Two public static Subarray FindSmallestSubarrayCoveringSubset(IEnumerator <string> iter, List <string> queryStrings) { var dict = new Dictionary <string, int>(); foreach (var s in queryStrings) { dict[s] = int.MinValue; } var numStringsFromQueryStringsSeenSoFar = 0; var result = new Subarray(-1, -1); var idx = 0; var loc = new List <string>(); while (iter.MoveNext()) { var s = iter.Current ?? string.Empty; if (dict.ContainsKey(s)) { // s is in queryStrings. var it = dict[s]; if (it == int.MinValue) { // First time seeing this string from queryStrings. numStringsFromQueryStringsSeenSoFar++; } loc.Remove(s); dict[s] = idx; loc.Add(s); } if (numStringsFromQueryStringsSeenSoFar == queryStrings.Count) { // We have seen all strings in queryStrings, let’s get to work. if ((result.Start == -1 && result.End == -1) || idx - dict[loc.First()] < result.End - result.Start) { result.Start = dict[loc.First()]; result.End = idx; } } ++idx; } return(result); }
public void Given_ArrayWithPositiveValues_Expect_NumberInArrayWithSmallestMagnitude(int[] i, int e) { int a = Subarray.FindLargestSumOfContiguousSubarray(i); Assert.True(a == e, "Actual: " + a); }
public void Given_InvalidArray_Expect_ThrowsArgumentException(int[] i) { Assert.Throws <ArgumentException>(() => Subarray.FindLargestSumOfContiguousSubarray(i)); }
public void Given_ValidArray_Expect_LargestSum(int[] i, int e) { int a = Subarray.FindLargestSumOfContiguousSubarray(i); Assert.True(a == e, "Actual: " + a); }
public void Given_ValidArray_Expect_ReturnsMaximumProduct(int[] d, int e) { int a = Subarray.MaximumProduct(d); Assert.True(a == e, "Expected: " + e + " Actual: " + a); }
public void Given_NullOrEmptyArray_Expect_ThrowsArguementException(int[] i) { Assert.Throws <ArgumentException>(() => Subarray.MaximumProduct(i)); }