public void Example3() { Assert.AreEqual(new List <string> { "aabb", "abab", "abba", "baab", "baba", "bbaa" }, Permutations.SinglePermutations("aabb").OrderBy(x => x).ToList()); }
private void TestInvalidTiles(int[] tiles, int invalidTileValue) { if ((tiles is null) || (tiles.Length != 6)) { Assert.Fail("test data invalid"); } Permutations <int> permutations = new Permutations <int>(tiles); foreach (IList <int> permutation in permutations) { SetTiles(permutation); Assert.IsTrue(nvm.HasErrors); for (int index = 0; index < permutation.Count; index++) { if (permutation[index] == invalidTileValue) { Assert.IsNotNull(nvm.GetErrors(propertyNames[index])); } else { Assert.IsNull(nvm.GetErrors(propertyNames[index])); } } } }
public static void DoTest() { var alphabets = "abcdefg"; var permutations = Permutations.ComputeDistinct(alphabets); Debug.Assert(permutations.Count == 720); var one = "abcdefg"; var two = "dabcgfe"; Debug.Assert(Permutations.IsAnargram(one, two) == true); one = "123456"; two = "789123"; Debug.Assert(Permutations.IsAnargram(one, two) == false); one = "abc"; two = "bbb"; Debug.Assert(Permutations.IsAnargram(one, two) == false); one = "acdf"; two = "bcde"; Debug.Assert(Permutations.IsAnargram(one, two) == false); one = "I am legion"; // L is small two = "Legion I am"; // L is capital Debug.Assert(Permutations.IsAnargram(one, two) == false); one = "I am legion"; // L is small two = "legion I am"; // L is small Debug.Assert(Permutations.IsAnargram(one, two) == true); }
/// <summary> /// Initialize the variations for constructors. /// </summary> /// <param name="values">List of values to select variations from.</param> /// <param name="lowerIndex">The size of each variation set to return.</param> /// <param name="type">The type of variations set to generate.</param> private void Initialize(IList <T> values, int lowerIndex, GenerateOption type) { myMetaCollectionType = type; myLowerIndex = lowerIndex; myValues = new List <T>(); myValues.AddRange(values); if (type == GenerateOption.WithoutRepetition) { List <int> myMap = new List <int>(); int index = 0; for (int i = 0; i < myValues.Count; ++i) { if (i >= myValues.Count - myLowerIndex) { myMap.Add(index++); } else { myMap.Add(Int32.MaxValue); } } myPermutations = new Permutations <int>(myMap); } else { ; // myPermutations isn't used. } }
override public void Evaluate(int SpreadMax) { if (FInput.IsChanged || FWithRepetition.IsChanged) { buffer.Clear(); for (int i = 0; i < FInput.SliceCount; i++) { buffer.Add(FInput[i]); } if (FWithRepetition[0]) { go = GenerateOption.WithRepetition; } else { go = GenerateOption.WithoutRepetition; } Permutations <T> permutations = new Permutations <T>(buffer, go); FOutput.SliceCount = 0; foreach (IList <T> p in permutations) { FOutput.AddRange(p); } FCount.SliceCount = 1; FCount[0] = (int)permutations.Count; } }
/// <summary> /// Initialize the combinations by settings a copy of the values from the /// </summary> /// <param name="values">List of values to select combinations from.</param> /// <param name="lowerIndex">The size of each combination set to return.</param> /// <param name="type">The type of Combinations set to generate.</param> /// <remarks> /// Copies the array and parameters and then creates a map of booleans that will /// be used by a permutations object to refence the subset. This map is slightly /// different based on whether the type is with or without repetition. /// /// When the type is WithoutRepetition, then a map of upper index elements is /// created with lower index false's. /// E.g. 8 choose 3 generates: /// Map: {1 1 1 1 1 0 0 0} /// Note: For sorting reasons, false denotes inclusion in output. /// /// When the type is WithRepetition, then a map of upper index - 1 + lower index /// elements is created with the falses indicating that the 'current' element should /// be included and the trues meaning to advance the 'current' element by one. /// E.g. 8 choose 3 generates: /// Map: {1 1 1 1 1 1 1 1 0 0 0} (7 trues, 3 falses). /// </remarks> private void Initialize(ICollection <T> values, Int32 lowerIndex, GenerateOption type) { Type = type; LowerIndex = lowerIndex; _values = new List <T>(); _values.AddRange(values); List <Boolean> map = new List <Boolean>(); if (type == GenerateOption.WithoutRepetition) { map.AddRange(_values.Select((t, i) => i < _values.Count - LowerIndex)); } else { for (Int32 i = 0; i < values.Count - 1; ++i) { map.Add(true); } for (Int32 i = 0; i < LowerIndex; ++i) { map.Add(false); } } _permutations = new Permutations <Boolean>(map); }
public override object Run(RunModes runMode, object input, bool Logging) { var currentSeed = 345; while (true) { var nextSeed = SeedCubes(currentSeed); var foundPermsMaster = CubesDictionary[currentSeed].ToList(); foreach (var cube in CubesDictionary[currentSeed]) { var count = 0; var foundPerms = new List <long>(); foreach (var cube2 in foundPermsMaster) { if (Permutations.IsPermutations(cube, cube2) && !foundPerms.Contains(cube)) { count++; foundPerms.Add(cube); } if (count == 5) { return(cube); } } foundPermsMaster.RemoveAll(foundPerms.Contains); } currentSeed = nextSeed; } }
public override object Run(RunModes runMode, object input, bool Logging) { int replacePrimeFamilyCount = (int)input; Primes.InitPrimes(); Primes.TrimPrimes(9, 1000000); var primeList = Primes.AllPrimes.OrderBy(p => p); int primeInitLength = 0; foreach (var start in primeList) { var stringStart = start.ToString(); var stringStartLength = stringStart.Length; if (stringStartLength > primeInitLength) { Primes.InitPrimes((long)Math.Pow(10, stringStartLength)); Primes.TrimPrimes((long)(Math.Pow(10, stringStartLength - 1) - 1), (long)Math.Pow(10, stringStartLength)); primeInitLength = stringStartLength; } for (int indecesToReplace = 1; indecesToReplace < stringStartLength; indecesToReplace++) { var indeces = Combinations.ChooseStringIndeces(indecesToReplace, stringStartLength); foreach (var index in indeces) { var permutations = Permutations.GenerateReplacements(stringStart, index); if (permutations.Count() >= replacePrimeFamilyCount && permutations.Count(Primes.IsPrime) >= replacePrimeFamilyCount) { return(permutations.Min()); } } } } return(0); }
private void GeneratePermutationsBtn_Click(object sender, EventArgs e) { if (!IsInputValid(InputField.Text)) { MessageBox.Show("Please populate input field by either typing or importing file"); return; } ClearAllFields(); Stopwatch watch = new Stopwatch(); watch.Start(); var permutable = InputField.Text.ToCharArray(); var permutations = Permutations.Generate(permutable); permutations.ToList().ForEach(x => PermutationsField.Text += new string(x) + "\r\n"); PermutationsCountField.Text = permutations.Count().ToString(); Permutations.GetMatches(permutable, permutations).ToList().ForEach(x => MatchingPermutationsField.Text += new string(x) + "\r\n"); watch.Stop(); TimeField.Text = watch.ElapsedMilliseconds.ToString(); }
static void Main(string[] args) { Console.WriteLine("Input a string: "); string s = Console.ReadLine(); var sC = (from entry in s select entry).ToList(); bool boolSol = false; var p = new Permutations <char>(sC, GenerateOption.WithoutRepetition); string temp = "", ts = ""; foreach (var v in p) { foreach (var k in v) { temp += k; } ts = new string(temp.ToCharArray().Reverse().ToArray()); if (temp == ts) { boolSol = true; break; } temp = ""; } Console.WriteLine($">< {boolSol} ><"); Console.ReadLine(); }
public void GeneratedPermutationsCountTest() { char[] permutable = new char[] { 'A', 'B', 'C', 'D' }; var permutations = Permutations.Generate(permutable); Assert.AreEqual(24, permutations.Count()); }
public void Basic() { var p = new Permutations(); var result = p.Permute(new[] { 1, 2, 3 }); var expected = new List <IList <int> >() { new List <int>() { 1, 2, 3 }, new List <int>() { 1, 3, 2 }, new List <int>() { 2, 1, 3 }, new List <int>() { 2, 3, 1 }, new List <int>() { 3, 2, 1 }, new List <int>() { 3, 1, 2 }, }; Assert.Equal(expected, result); }
public static List <List <int> > GetGenotypeCombinations(int numberOfStates, int currentState) { const int diploidState = 2; const int maxNumberOfStates = 4; if (numberOfStates > maxNumberOfStates) { Console.WriteLine($"CanvasPartition.exe: number of states/samples {numberOfStates} is too large for full combinatorial enumeration\n" + $"Settings to the default number {maxNumberOfStates}"); numberOfStates = maxNumberOfStates; } var upperSetBound = SpecialFunctions.Factorial(numberOfStates) * SpecialFunctions.Factorial(numberOfStates / 2); var allCombinations = new List <List <int> >(Convert.ToInt32(upperSetBound)); for (int numberOfDiploidStates = 1; numberOfDiploidStates < numberOfStates; numberOfDiploidStates++) { IEnumerable <int> states = Enumerable.Repeat(currentState, numberOfStates - numberOfDiploidStates) .Concat(Enumerable.Repeat(diploidState, numberOfDiploidStates)); var permutations = new Permutations <int>(states.ToList(), GenerateOption.WithoutRepetition); //List<List<int>> permutations = null; // %%% var list = permutations.Select(x => x.ToList()).ToList(); allCombinations.AddRange(list); } return(allCombinations); }
public void shouldreturnvalidresultfoBasicMethod() { var input = new int[] { 1, 3, 5 }; var expectedResult = new List <List <int> > { new List <int> { 1, 3, 5 }, new List <int> { 1, 5, 3 }, new List <int> { 3, 1, 5 }, new List <int> { 3, 5, 1 }, new List <int> { 5, 1, 3 }, new List <int> { 5, 3, 1 } }; var result = Permutations.findPermutations(input); var listResult = CollectionEquivalence.AreEqual <int>(result, expectedResult); Assert.True(listResult); }
public void shouldReturnFalseIfStringsAreNotTheSameLength() { var s1 = "abc"; var s2 = "abcd"; Assert.False(Permutations.IsPermutation(s1, s2)); }
/// <summary> /// Construct a enumerator with the parent object. /// </summary> /// <param name="source">The source Permutations object.</param> public Enumerator(Permutations <T> source) { myParent = source; myLexicographicalOrders = new int[source.myLexicographicOrders.Length]; source.myLexicographicOrders.CopyTo(myLexicographicalOrders, 0); Reset(); }
/// <summary> /// Initialize the combinations by settings a copy of the values from the /// </summary> /// <param name="values">List of values to select combinations from.</param> /// <param name="lowerIndex">The size of each combination set to return.</param> /// <param name="type">The type of Combinations set to generate.</param> /// <remarks> /// Copies the array and parameters and then creates a map of booleans that will /// be used by a permutations object to refence the subset. This map is slightly /// different based on whether the type is with or without repetition. /// /// When the type is WithoutRepetition, then a map of upper index elements is /// created with lower index false's. /// E.g. 8 choose 3 generates: /// Map: {1 1 1 1 1 0 0 0} /// Note: For sorting reasons, false denotes inclusion in output. /// /// When the type is WithRepetition, then a map of upper index - 1 + lower index /// elements is created with the falses indicating that the 'current' element should /// be included and the trues meaning to advance the 'current' element by one. /// E.g. 8 choose 3 generates: /// Map: {1 1 1 1 1 1 1 1 0 0 0} (7 trues, 3 falses). /// </remarks> private void Initialize(IList <T> values, int lowerIndex, GenerateOption type) { myMetaCollectionType = type; myLowerIndex = lowerIndex; myValues = new List <T>(); myValues.AddRange(values); List <bool> myMap = new List <bool>(); if (type == GenerateOption.WithoutRepetition) { for (int i = 0; i < myValues.Count; ++i) { if (i >= myValues.Count - myLowerIndex) { myMap.Add(false); } else { myMap.Add(true); } } } else { for (int i = 0; i < values.Count - 1; ++i) { myMap.Add(true); } for (int i = 0; i < myLowerIndex; ++i) { myMap.Add(false); } } myPermutations = new Permutations <bool>(myMap); }
public void PermutationsTest() { var expected = new HashSet <string> { "01", "12", "02", "10", "21", "20", }; // Should return all combinations of {0, 1, 2} foreach (var x in Permutations.Integers(3, 2)) { int first = x[0]; int second = x[1]; var str = $"{first}{second}"; if (expected.Contains(str)) { expected.Remove(str); } else { Assert.Fail($"{str} was not in the set when it should be"); } } Assert.AreEqual(0, expected.Count); }
static int ShortestCircuit() { int result = int.MaxValue; int curr; List <int> way; List <int> perm = new List <int>(); for (int i = 1; i <= Verticles; ++i) { perm.Add(i); } var p = new Permutations <int>(perm); foreach (var v in p) { curr = 0; way = new List <int>() { 0 }; way.AddRange(v); for (int i = 0; i <= Verticles; ++i) { curr += graph[way[i]][way[(i + 1) % Verticles]].Length; } result = Math.Min(result, curr); } return(result); }
public void Permutation_Test() { int[] nums = { 1, 2, 3 }; var result = Permutations.Permutations_(nums, 3); Assert.AreEqual(new List <string>(), result); }
public ActionResult Problem41(uint n) { if (n > 9) { n = 9; } // Set up prime calculator var cal = new PrimeCalculator(); // Keep trying until we run out of digits. while (n > 0) { List <int> digits = Enumerable.Range(1, (int)n).ToList(); var permutations = new Permutations <int>(digits); var allPrimes = permutations.Select(numList => numList.MakeNumber()) .Where(num => cal.IsPrimeAutoExpand(num)).ToList(); // If there is at least 1 prime with n-digit, find the maximum amongst these primes and // that's the answer if (allPrimes.Count > 0) { ulong max = allPrimes.Max(); return(ViewAnswer(41, "The maximum " + n + "-digit pandigital prime is", max)); } // Otherwise, reduce number of digits and try again. --n; } return(ViewAnswer(41, "No n-digit pandigital prime found.", 0)); }
public void PermutationEmpty() { var testArr = Array.Empty <int>(); var ex = Assert.Throws <ArgumentException>(() => Permutations.OfSampleSize(someList: testArr, 1).ToList(), "Its expected that an empty array is not a valid argument"); Assert.That(ex.Message, Is.EqualTo("someList cannot be empty.")); }
public static void C(string name, string type, int length, string output) { int count = (int)Math.Pow(10, length); List <string> list = new List <string>(10000); string format = "D" + length; for (int i = 0; i < count; i++) { var digits = i.ToString(format).ToArray(); Permutations <char> p = new Permutations <char>(digits, length); List <string> pn = p.Get(","); if (pn.Exists(x => list.Contains(x))) { continue; } list.Add(i.Format(format, ",")); } if (output.Equals("txt")) { SaveToText(name, type, list); return; } SaveToDB(name, type, list); }
public IEnumerable <Processo> ProcessarFila(IEnumerable <Processo> processos) { var indices = Enumerable.Range(0, processos.Count()).ToList(); var permutacoes = new Permutations <int>(indices); var filaMenorCusto = new List <Processo>(); float?filaMenorCustoTotal = null; foreach (var permutacao in permutacoes) { var sequenciaExecucao = new List <Processo>(); foreach (var indice in permutacao) { sequenciaExecucao.Add(processos.ElementAt(indice)); } var custo = CalcularCusto(sequenciaExecucao); if (filaMenorCustoTotal == null || filaMenorCustoTotal > custo) { filaMenorCustoTotal = custo; filaMenorCusto = sequenciaExecucao; } } return(filaMenorCusto); }
static void Main(string[] args) { Console.WriteLine("Input all digits in a line i.e. 123: "); var n = Console.ReadLine(); var sN = (from entry in n select entry).ToList(); Stopwatch stopwatch = new Stopwatch(); stopwatch.Start(); var p = new Permutations <char>(sN, GenerateOption.WithoutRepetition); stopwatch.Stop(); string temp = ""; Console.WriteLine(stopwatch.Elapsed); Console.WriteLine("\nHere are all the permutations:"); foreach (var v in p) { temp = string.Join("", v); Console.WriteLine(temp); temp = ""; } }
public string ShowPermutationDetails(string documentContent) { string cleanPermutation; string key; bool isContentOk = Descriptor.GetKey(documentContent, out cleanPermutation, out key); if (!isContentOk) { return("The document content you entered is not legal"); } // key doesn't exist string msg = String.Format("\nThe document {0} doesn't exist in the system", documentContent); if (!_documentsManagementSystem.ContainsKey(key)) { return(msg); } // key exist but permutation doesn't exist Permutations toSearch = new Permutations(cleanPermutation, null); Permutations foundItem; bool isPermutationExist = _documentsManagementSystem[key].Permutations.Search(toSearch, out foundItem); msg = String.Format("\nThe permutation {0} doesn't exist in the system", cleanPermutation); if (!isPermutationExist) { return(msg); } int numOfPermutationCopies = foundItem.Count; DateTime timeStamp = foundItem.Ref.Data.Timestamp; return(string.Format("\nFor the document permutation of {0}, there are {1} numbers of copies, and the last copy was updated in {2}", documentContent, numOfPermutationCopies, timeStamp)); }
/// <summary> /// 可重复组合 /// </summary> public static void Cr(string name, string type, int length, string output) { List <List <int> > lists = length == 2 ? GetPr2() : GetPr3(); List <string> clist = new List <string>(360); foreach (var list in lists) { Permutations <int> p = new Permutations <int>(list, length); List <string> pn = p.Get(","); if (pn.Exists(x => clist.Contains(x))) { continue; } clist.Add(list.Format(",")); } if (output.Equals("txt")) { SaveToText(name, type, clist); return; } SaveToDB(name, type, clist); }
public string FindClosestPermutation(string permutation) { string cleanPermutation; string key; string msg = string.Format("The permutation {0} was not found, and also wasn't found a following permutation", permutation); if (!Descriptor.GetKey(permutation, out cleanPermutation, out key)) { return("The document content you entered is not legal"); } if (!_documentsManagementSystem.ContainsKey(key)) { return(string.Format("The document for the permutation {0}, doesn't exist in the system", permutation)); } Permutations itemToFind = new Permutations(cleanPermutation, null); Permutations foundItem; bool foundNext = _documentsManagementSystem[key].Permutations.SearchNext(itemToFind, out foundItem); if (foundNext) { return(ShowPermutationDetails(foundItem.Permutation)); } return(msg); }
public string SolvePart1() { // Do for all combinations of Phase var permutations = new Permutations <int>(Enumerable.Range(0, 5).ToList()); var maxOutput = int.MinValue; foreach (var permutation in permutations) { // For Amp A -> E var signal = 0; foreach (int phase in permutation) { var amplifier = new IntCodeMachine.IntCodeMachine(Input, new[] { phase, signal }); amplifier.Execute(false); signal = int.Parse(amplifier.Outputs.First()); } // Record final output if higher than previous final if (signal > maxOutput) { maxOutput = signal; } } return($"Part 1: {maxOutput}"); }
internal IPropertyValue Actual(string label) { if (_collectionNames.IsNullOrEmpty()) { return(Label == label ? this : null); // this should shortcut nicely when there is no collection. } var values = Permutations.Where(each => ParentPropertySheet.ResolveMacros(Label, each) == label) .SelectMany(each => _values .Select(value => ParentPropertySheet.ResolveMacros(value, each))) .ToArray(); if (values.Length > 0) { return(new ActualPropertyValue { SourceLocation = SourceLocation, IsSingleValue = values.Length == 1, HasMultipleValues = values.Length > 1, SourceString = "", Value = values[0], Values = values, ParentRule = ParentPropertyRule.ParentRule }); } return(null); }
/// <summary> /// Конструктор с параметрами /// </summary> /// <param name="key1"> Ключ для первого прохода шифрования. </param> /// <param name="key2"> Ключ для второго прохода шифрования. </param> public BitMaps(byte[] key1, byte[] key2) { // Создаем ключ на базе двух ключей BitmapKey = CryforceUtilities.MergeArrays(key1, key2); Bitmaps = new Permutations<int>(new[] {0, 1, 2, 3, 4, 5, 6, 7}).MakePermutationsSet(); // 40320 перестановок 8 бит BitmapsIdx = BitmapKeyIdx = 0; // Производим самообновление ключа RefreshKey(); }
static void Main(string[] args) { List<string> input = File.ReadAllLines("Input.txt").ToList(); List<string> locations = new List<string>(); List<Journey> journeys = input.Select(s => s.Split(' ')) .Select( parts => new Journey {DepartFrom = parts[0], TravelTo = parts[2], Distance = Convert.ToInt32(parts[4])}) .ToList(); foreach (Journey journey in journeys) { //Console.WriteLine($"{journey.DepartFrom}, {journey.TravelTo}: {journey.Distance}"); locations.AddRange(new[] { journey.DepartFrom, journey.TravelTo } ); } locations = locations.Distinct().ToList(); Permutations<string> trips = new Permutations<string>(locations); List<int> totalDistances = new List<int>(); Console.WriteLine("Crunching numbers..."); foreach (IList<string> trip in trips) { //Console.WriteLine(string.Join(", ", trip)); int totalDistance = 0; for (int i = 0; i < trip.Count - 1; i++) { Journey nextJourney = journeys.FirstOrDefault( x => (x.DepartFrom.Equals(trip[i]) && x.TravelTo.Equals(trip[i + 1]) || x.TravelTo.Equals(trip[i]) && x.DepartFrom.Equals(trip[i + 1]))); if (nextJourney == null) { Console.WriteLine($"!?ERROR?! Could not find Journey from {trip[i]} to {trip[i + 1]}!"); continue; } totalDistance += nextJourney.Distance; } totalDistances.Add(totalDistance); //Console.WriteLine(totalDistance); } Console.WriteLine($"Shortest distance: {totalDistances.Min()}"); Console.WriteLine($"Longest distance: {totalDistances.Max()}"); Console.Write("Press any key..."); Console.ReadKey(); }
static void Main() { int n = Int32.Parse(Console.ReadLine()); int[] arr = new int[n]; for (int i = 0; i < n; i++) { arr[i] = i + 1; } Permutations p = new Permutations(); p.setper(arr); }
public void Generate_Permutations_Without_Repetition_On_3_Unique_Input_Items_Should_Create_12_Output_Permutations() { var integers = new List<int> { 1, 2, 3 }; var p = new Permutations<int>(integers, GenerateOption.WithoutRepetition); foreach (var v in p) { System.Diagnostics.Debug.WriteLine(string.Join(",", v)); } Assert.AreEqual(6, p.Count); }
public static void Main(string[] args) { bool isFirstRun = true; while (true) { if (isFirstRun) { System.Console.WriteLine("UWW CS215 Fano Plane Automorphism Finder" + Environment.NewLine + "Authored by Connor Grady, Grant Jones, and Collin Stolpa"); } else { System.Console.WriteLine(); } string input = CollectInput(); string[] items = new string[7] { "1", "2", "3", "4", "5", "6", "7" }; Permutations permutations = new Permutations(); List<List<string>> results = permutations.GeneratePermutations(items.ToList()); //WritePermutations(results); switch (input) { case "OutputPerms": WritePermutations(results); break; case "OutputAutos": // Now that we have the Permutations, let's check for the automorphisms List<List<string>> automorphisms = results.Where(IsAutomorphism).ToList(); // Convert to Cycle Notation List<string> automorphicCycles = automorphisms.Select(perm => permutations.ToCycleNotation(results.FirstOrDefault(), perm)).ToList(); // Write cycles to the Console WriteCycles(automorphicCycles, automorphisms.Select(auto => string.Join("", auto)).ToList()); break; default: System.Console.WriteLine("ERROR: No valid selection detected. Please try again..."); break; } isFirstRun = false; } }
static void Main() { int N = GetValidInput("Enter the upper margin for the permutations range( 1 to N ): ", 2); //build the array List<int> numbers = new List<int>(); for (int i = 1; i <= N; i++) { numbers.Add(i); } //generate a permutations collection Permutations<int> permutations = new Permutations<int>(numbers); //print the elements in the collection foreach (IList<int> p in permutations) { foreach (var item in p) { Console.Write(item); } Console.WriteLine(); } }
/// <summary> /// Specifies whether the provided permutation is an automorphism of the Fano Plane Permutations. /// </summary> /// <param name="permutation">The permutation derived to check.</param> /// <returns>Boolean specifying whether the permutation is an automorphism.</returns> private static bool IsAutomorphism(List<string> permutation) { Permutations permutations = new Permutations(); // Get the permutation as a set of 7 sets of 3 characters List<List<string>> permGroups = permutations.PermTo7SetsOf3(permutation); // Get the Fano Plane collection List<List<string>> fanoGroups = FanoPlane.GenerateCollection(); // This will contain the result of all the "true" method comparisons // If there are 7 "true" bools at the end, then it is an automorphism List<bool> groupBools = new List<bool>(7); // For each 3-member group of the permutation foreach (List<string> permGroup in permGroups) { // True if there's at least one 3-member group in the fano plane collection that matches // this 3-member group of the permutation bool atLeastOneGroupMatches = false; // For each 3-member group in the fano collection, for the first group that matches all 3 members (regardless of order), // set atLeastOneGroupMatches = true, remove that 3-member group from the fano collection, and break from the loop foreach (List<string> fanoGroup in from fanoGroup in fanoGroups let charsMatch = permGroup.All(fanoGroup.Contains) where charsMatch select fanoGroup) { atLeastOneGroupMatches = true; fanoGroups.Remove(fanoGroup); break; } // Add whatever the value of atLeastOneGroupMatches to the bool collection groupBools.Add(atLeastOneGroupMatches); } // Return a boolean whose value is true if the count of all "true" booleans in the bool collection is 7 return groupBools.Count(x => x) == 7; }
/// <summary> /// Returns all 10 digit pandigital numbers. Filters numbers that start with 0. /// </summary> public IEnumerable<long> GetPandigitalNumbers() { var numbers = Enumerable.Range(0, 10).ToList(); var perms = new Permutations<int>(numbers, GenerateOption.WithoutRepetition).AsParallel() .Where(list => list[0] != 0) .Select(DigitHelper.ConvertToNumber); return perms; }
void DoArrayBuilder() { Permutations<int> intPer = new Permutations<int>(new int[] { 0, 1, 2, 3, 4 }, GenerateOption.WithoutRepetition); //生成颜色数组 foreach (IList<int> item in intPer) { if (ConditionService.Verify14(item)) { int[] ts = new int[5]; item.CopyTo(ts, 0); _Colors.Add(ts); } } //生成国家数组 foreach (IList<int> item in intPer) { if (ConditionService.Verify08(item)) { int[] ts = new int[5]; item.CopyTo(ts, 0); _Nationals.Add(ts); } } //生成饮料数组 foreach (IList<int> item in intPer) { if (ConditionService.Verify09(item)) { int[] ts = new int[5]; item.CopyTo(ts, 0); _Drinks.Add(ts); } } //生成宠物数组 foreach (IList<int> item in intPer) { int[] ts = new int[5]; item.CopyTo(ts, 0); _Pets.Add(ts); } //生成香烟数组 foreach (IList<int> item in intPer) { int[] ts = new int[5]; item.CopyTo(ts, 0); _Cigarettes.Add(ts); } this.SetTotalLabel(_Colors.Count * _Nationals.Count * _Drinks.Count * _Pets.Count * _Cigarettes.Count); //_count = _Colors.Count + _Nationals.Count + _Drinks.Count + _Pets.Count + _Cigarettes.Count; }
private int GetResultsForSet(IList<int> set) { var setPermutations = new Permutations<int>(set, GenerateOption.WithoutRepetition); var results = new HashSet<int>(); bool shouldPrint = (set[0] == 1 && set[1] == 2 && set[2] == 5 && set[3] == 6); foreach (IList<int> nums in setPermutations) { foreach (IList<int> ops in operationVariations) { // Possible bracket combinations: int a = 0; try { // (1 2)(3 4) a = Add( O(O(nums[0], nums[1], ops[0]), O(nums[2], nums[3], ops[2]), ops[1]), results); //if (shouldPrint) // Console.WriteLine(string.Format("({0} {1} {2}) {3} ({4} {5} {6}) = {7}", // nums[0], Op(ops[0]), nums[1], Op(ops[1]), nums[2], Op(ops[2]), nums[3], a)); } catch { } try { // ((1 2)3) 4 a = Add( O(O(O(nums[0], nums[1], ops[0]), nums[2], ops[1]), nums[3], ops[2]), results); } catch { } try { // (1(2 3)) 4 a = Add( O(O(nums[0], O(nums[1], nums[2], ops[1]), ops[0]), nums[3], ops[2]), results); //if (shouldPrint) // Console.WriteLine(string.Format(" ({0} {1} ({2} {3} {4})) {5} {6} = {7}", // nums[0], Op(ops[0]), nums[1], Op(ops[1]), nums[2], Op(ops[2]), nums[3], a)); } catch { } try { // 1 ((2 3)4) a = Add( O(nums[0], O(O(nums[1], nums[2], ops[1]), nums[3], ops[2]), ops[0]), results); } catch { } try { // 1 (2(3 4)) a = Add( O(nums[0], O(nums[1], O(nums[2], nums[3], ops[2]), ops[1]), ops[0]), results); } catch { } } } var ordered = results.OrderBy(o => o).ToList(); int lastMax = 0; for (int counter = 1; counter < ordered.Count; counter++) { if (ordered[counter] != ordered[counter - 1] + 1) { lastMax = ordered[counter - 1]; break; } } //if (shouldPrint) //{ // Console.WriteLine(); // Console.WriteLine(); // foreach (int num in ordered) // Console.Write(num + " "); // Console.WriteLine(); // Console.WriteLine(lastMax); // Console.WriteLine(); //} return lastMax; }