public static (IMutableBidirectionalGraph <CyclicCluster, CondensedEdge <DisplayNode, DisplayEdge, CyclicCluster> > Clustered, IBidirectionalGraph <DisplayNode, DisplayEdge> Simple) GetFullClusteredGraph(this NodeGraph nodeGraph)
{
var rootNodes = nodeGraph.Nodes.Values;
var fullDisplayGraph = GetDisplaySubgraph(nodeGraph, rootNodes, SetUtils.GetEmpty <NodeKey>());
return(fullDisplayGraph.GetClusteredGraph(), fullDisplayGraph);
}
public static IEnumerable <long> Get()
{
var pandigitals =
SetUtils.Permutations(Enumerable.Range(0, 10).Select(x => (long)x))
.Select(d => d.Reverse())
.Where(digits => digits.First() != 0);
return(pandigitals.Where(HasSubstringDivisibility).Select(x => x.DigitsToNumber()));
}
public void ConvertAllReturnCorrectValue()
{
ArraySet <int> arrSet = new ArraySet <int>();
arrSet.Add(10);
Assert.IsInstanceOfType(SetUtils.ConvertAll <int, MySet.HashSet <int> >(arrSet), typeof(MySet.HashSet <int>));
Assert.IsInstanceOfType(SetUtils.ConvertAll <int, ArraySet <int> >(arrSet), typeof(ArraySet <int>));
Assert.IsInstanceOfType(SetUtils.ConvertAll <int, LinkedSet <int> >(arrSet), typeof(LinkedSet <int>));
}
public void ExistMustReturnFalseIfItemsNonExist()
{
ArraySet <int> arrSet = new ArraySet <int>();
arrSet.Add(1);
arrSet.Add(3);
Assert.IsFalse(SetUtils.Exists(arrSet, (item) => {
return(item == 2);
}));
}
public void ExistMustReturnTrueIfItemsExist()
{
ArraySet <int> arrSet = new ArraySet <int>();
arrSet.Add(1);
arrSet.Add(3);
Assert.IsTrue(SetUtils.Exists(arrSet, (item) => {
return(item == 1);
}));
}
public void ConvertAllReturnCorrectNumberOfElements()
{
ArraySet <int> arrSet = new ArraySet <int>();
int numOfElements = 50;
for (int i = 0; i < numOfElements; i++)
{
arrSet.Add(i);
}
Assert.AreEqual(numOfElements, SetUtils.ConvertAll <int, MySet.HashSet <int> >(arrSet).Count);
Assert.AreEqual(numOfElements, SetUtils.ConvertAll <int, ArraySet <int> >(arrSet).Count);
Assert.AreEqual(numOfElements, SetUtils.ConvertAll <int, LinkedSet <int> >(arrSet).Count);
}
public void CheckForAllReturnTrue()
{
ArraySet <int> arrSet = new ArraySet <int>();
int numOfElements = 50;
for (int i = 0; i < numOfElements; i++)
{
arrSet.Add(i);
}
Assert.IsTrue(SetUtils.CheckForAll <int>(arrSet, (item) => {
return(item >= 0 && item <= numOfElements);
}));
}
public void EternityInterrupted()
{
var items = new List <Interval>
{
new Interval(DateTimeOffset.MinValue, DateTimeOffset.MaxValue),
new Interval(DateTime.Parse("2019/01/08"), DateTime.Parse("2019/01/10")),
};
var joines = SetUtils.Merge(items);
joines.Select(x => x.ToString()).Should().BeEquivalentTo(
"01/01/0001 => 08/01/2019",
"08/01/2019 => 10/01/2019",
"10/01/2019 => 31/12/9999");
}
public static long Get()
{
var pandigit = 9;
var prime = 0;
while (prime == 0)
{
var arr = SetUtils.LexicographicPermutations(Enumerable.Range(1, pandigit--))
.Select(x => x.Reverse().DigitsToNumber())
.Reverse()
.ToArray();
prime = arr.FirstOrDefault(x => PrimeUtils.IsPrime(x));
}
return(prime);
}
public void Breaking()
{
var input =
@"01/01/2017 +00:00 31/01/2017 +00:00
01/02/2017 +00:00 28/02/2017 +00:00
";
var intervals = from line in input.Lines()
let split = line.Split("\t")
let start = split[0]
let end = split[1]
select new Interval(DateTimeOffset.Parse(start), DateTimeOffset.Parse(end));
var joines = SetUtils.Merge(intervals);
joines.Select(x => x.ToString()).Should().BeEquivalentTo(
"01/01/2017 => 31/01/2017",
"01/02/2017 => 28/02/2017");
}
public void FindAllReturnCorrectValue()
{
ArraySet <int> arrSet = new ArraySet <int>();
for (int i = 0; i < 50; i++)
{
arrSet.Add(i);
}
ArraySet <int> newArrSet = SetUtils.FindAll <int, ArraySet <int> >(arrSet, (item) => {
return(item % 2 == 0);
});
foreach (int item in newArrSet)
{
Assert.IsTrue(item % 2 == 0);
}
Assert.AreEqual(25, newArrSet.Count);
}
public void ForEachRunFuncForEverItem()
{
ArraySet <int> arrSet = new ArraySet <int>();
int numOfElements = 50;
bool[] testArray = new bool[numOfElements];
for (int i = 0; i < numOfElements; i++)
{
arrSet.Add(i);
testArray[i] = false;
}
SetUtils.ForEach <int>(arrSet, (item) => {
testArray[item] = true;
});
for (int i = 0; i < numOfElements; i++)
{
Assert.IsTrue(testArray[i]);
}
}
public void Complex()
{
var items = new List <Interval>
{
new Interval(DateTime.Parse("2019/01/1"), DateTime.Parse("2019/01/15")),
new Interval(DateTime.Parse("2019/01/08"), DateTime.Parse("2019/01/10")),
new Interval(DateTime.Parse("2019/01/16"), DateTime.Parse("2019/01/31")),
new Interval(DateTime.Parse("2019/01/20"), DateTime.Parse("2019/01/20"))
};
var joines = SetUtils.Merge(items);
joines.Select(x => x.ToString()).Should().BeEquivalentTo(new[]
{
"01/01/2019 => 08/01/2019",
"08/01/2019 => 10/01/2019",
"10/01/2019 => 15/01/2019",
"16/01/2019 => 20/01/2019",
"20/01/2019 => 20/01/2019",
"20/01/2019 => 31/01/2019",
});
}
public static IEnumerable <string> Main()
{
var fourDigitPrimes = new HashSet <long>(PrimeUtils.Primes
.SkipWhile(x => x.ToString().Length < 4)
.TakeWhile(x => x.ToString().Length == 4));
while (fourDigitPrimes.Any())
{
var prime = fourDigitPrimes.First();
var permutations = SetUtils.Permutations(MiscUtils.GetDigits(prime)).Select(x => (long)x.DigitsToNumber()).Where(x => x > 1000);
var primePermutations = fourDigitPrimes.Intersect(permutations).ToArray();
if (primePermutations.Length >= 3)
{
var threes = primePermutations.Choose(3).ToArray();
foreach (var special in threes.Where(HaveEqualDifference))
{
yield return(string.Join("", special.OrderBy(x => x)));
}
}
fourDigitPrimes.ExceptWith(primePermutations);
}
}
public async Task When_MultiDependency_Edge()
{
using (var workspace = WorkspaceUtils.GetSubjectSolution())
{
var project = workspace.CurrentSolution.Projects.Single(p => p.Name == "SubjectSolution");
var graph = await NodeGraph.BuildGraph(CompilationCache.CacheWithSolution(workspace.CurrentSolution), ct : default);
var someClassNode = graph.Nodes[TypeNodeKey.GetFromFullName("SubjectSolution.SomeClass")];
var deepClassNode = graph.Nodes[TypeNodeKey.GetFromFullName("SubjectSolution.SomeClassDepth5")];
var roots = new HashSet <Node>();
roots.Add(someClassNode);
roots.Add(deepClassNode);
var paths = NodeGraphExtensions.GetMultiDependencyRootPaths(graph, roots).ToArray();
var path = paths.Single();
var displayGraph = graph.GetDisplaySubgraph(subgraphNodes: roots, pinnedNodes: SetUtils.GetEmpty <NodeKey>());
var multiEdges = displayGraph.Edges.OfType <MultiDependencyDisplayEdge>();
AssertEx.ContainsSingle(multiEdges, m => m.Source.DisplayString.EndsWith("SomeClass") && m.Target.DisplayString.EndsWith("SomeClassDepth5"));
}
}
public static IEnumerable <int[]> PandigitalNumbers(int pandigital)
{
return(SetUtils.Permutations(Enumerable.Range(1, pandigital)));
}
public static IBidirectionalGraph <DisplayNode, DisplayEdge> GetDisplaySubgraph(this NodeGraph nodeGraph, IList <ITypeSymbol> rootSymbols) => GetDisplaySubgraph(nodeGraph, rootSymbols.Select(tpl => nodeGraph.GetNodeForType(tpl)).Trim(), SetUtils.GetEmpty <NodeKey>());
public void Version1_Choose()
{
var res = SetUtils.Choose(new [] { 1, 2, 3, 4, 5 }, 3);
}
