CSharp · Console
using System;
public class Program
{
private static bool allTestsPassed = true;
public static void Main()
{
TestCartisian();
Console.WriteLine($"allTestsPassed: {allTestsPassed}");
}
/// <summary>
/// This is used whenever you have two sources, and you definitely want some results from both sources, but need to still cap the results to one ultimate / final 'take' count
/// </summary>
/// <param name="take">The ultimate/final amount that should be taken from the total results count</param>
/// <param name="leftCount">The number of results that are currently in the first or 'left' data set</param>
/// <param name="rightCount">The number of results that are currently in the second or 'right' data set</param>
/// <returns><code>tuple (int leftTakeCount, int rightTakeCount)</code></returns>
public static (int leftTakeCount, int rightTakeCount) GetTakeCountsFromTwoSourcesToMeetOneTotalQuota(int take, int leftCount, int rightCount)
{
int halfTake = take / 2; // since it's an int here, the decimal will just truncate
int totalCount = leftCount + rightCount;
bool totalCountAboveTake = totalCount > take;
bool leftAboveHalfTake = leftCount > halfTake;
bool shouldReduceLeft = totalCountAboveTake && leftAboveHalfTake;
bool rightAboveHalfTake = rightCount > halfTake;
bool shouldReduceRight = totalCountAboveTake && rightAboveHalfTake;
// When both counts are above the requested take count and also above the halfTake, then we can just chop both down to the half count
bool canReduceBothToHalftake = totalCountAboveTake & leftAboveHalfTake & rightAboveHalfTake;
int leftReductionToHalfTake = canReduceBothToHalftake ? leftCount - halfTake : 0;
int rightReductionToHalfTake = canReduceBothToHalftake ? rightCount - halfTake : 0;
// When one of the counts is below halfTake, we need to calculate the difference so that we'll end up with some of both
int leftReductionToDifference = (shouldReduceLeft & !canReduceBothToHalftake) ? leftCount - (take - rightCount) : 0;
int rightReductionToDifference = (shouldReduceRight & !canReduceBothToHalftake) ? rightCount - (take - leftCount) : 0;
// Since we used booleans above, one of these will end up as 0. So get the other one
int maxLeftReduction = Math.Max(leftReductionToHalfTake, leftReductionToDifference);
int maxRightReduction = Math.Max(rightReductionToHalfTake, rightReductionToDifference);
int finalLeftReduction = shouldReduceLeft ? maxLeftReduction : 0;
int finalRightReduction = shouldReduceRight ? maxRightReduction : 0;
int leftTakeCount = leftCount - finalLeftReduction;
int rightTakeCount = rightCount - finalRightReduction;
return (leftTakeCount, rightTakeCount);
}
private static void TestCartisian()
{
var runUntil = 20;
var cartisianRunUntil = 20;
var ultimateTakeLimit = 10;
var expectedCount = 0;
// Only Left rows
for(int left = 0; left < runUntil; left++)
{
expectedCount = Math.Min(ultimateTakeLimit, left);
TestLine(ultimateTakeLimit, left, 0, expectedCount);
}
// Only Right rows
for(int right = 0; right < runUntil; right++)
{
expectedCount = Math.Min(ultimateTakeLimit, right);
TestLine(ultimateTakeLimit, 0, right, expectedCount);
}
// Cartisian Left side
for(int left = 0; left < cartisianRunUntil; left++)
{
for(int right = 0; right < cartisianRunUntil; right++)
{
expectedCount = Math.Min(ultimateTakeLimit, left+right);
TestLine(ultimateTakeLimit, left, right, expectedCount);
}
}
}
private static void TestLine(int finalTakeCount, int leftDataSetCount, int rightDataSetCount, int expectedCount)
{
var takeCounts = GetTakeCountsFromTwoSourcesToMeetOneTotalQuota(finalTakeCount, leftDataSetCount, rightDataSetCount);
int resultCount = takeCounts.leftTakeCount + takeCounts.rightTakeCount;
bool passes = resultCount == expectedCount;
allTestsPassed = allTestsPassed && passes;
Console.WriteLine($"leftDataSet: {leftDataSetCount}.Take({takeCounts.leftTakeCount}) rightDataSet: {rightDataSetCount}.Take({takeCounts.rightTakeCount}) resultCount: {resultCount} expectedCount: {expectedCount} passes: {passes}\r\n");
}
}