public void Test_PermutateV4_GenerateIndices() { var input = new List <List <Slot> > { new List <Slot> { new Slot() }, new List <Slot> { new Slot(), new Slot() }, new List <Slot> { new Slot(), new Slot(), new Slot() } }; var actual = Permutator.GenerateIndices(input); var expected = new List <BoundedInt> { new BoundedInt(0, 0), new BoundedInt(1, 0), new BoundedInt(2, 0) }; for (var i = 0; i < 3; i++) { if (!actual[i].Equals(expected[i])) { Assert.Fail(); } } Assert.Pass(); }
public void Test_PermutateV4_Increment_4() { var input = new List <BoundedInt> { new BoundedInt(1, 0), new BoundedInt(0, 0), new BoundedInt(0, 0) }; var expected = new List <BoundedInt> { new BoundedInt(1, 1), new BoundedInt(0, 0), new BoundedInt(0, 0) }; var actual = Permutator.Increment(input); for (var i = 0; i < 3; i++) { if (!actual[i].Equals(expected[i])) { Assert.Fail(); } } // TODO: Add your test code here Assert.Pass("Your first passing test"); }
public void GenerateTimetables(SlotList slotList) { var result = Permutator.Run_v2_WithConsideringWeekNumber(slotList.ToArray()); _timetableList = new TimetableList(result); NotifyObserver(); }
static void Main() { BigInteger answer = 0; int search = 10; BigInteger max = 0; EAsContFraction e; for (int a = 1; a < search; ++a) { e = new EAsContFraction(a); e.print(); Console.WriteLine(); Pair p; p = e.toRational(); Console.WriteLine(p.a + "/" + p.b); Console.WriteLine(Permutator.sumOfDigits(p.a)); } e = new EAsContFraction(99); Pair p2 = e.toRational(); answer = Permutator.sumOfDigits(p2.a); Console.WriteLine("Answer: " + answer); // Keep the console window open in debug mode. Console.WriteLine("Press any key to exit."); Console.ReadKey(); }
public void Test_StateTable_GetStateOfDefinitelyOccupied_2() { var input = Permutator.Run_v2_withoutConsideringWeekNumber(TestData .GetSlotsByName(TestData.Subjects.HighwayAndTransportation).ToArray()); var expected = StateTable.ParseString_AsStateOfDefinitelyOccupied( "00000000000000000000001100000000~" + "00000000000000000000000000000000~" + "00000011110000000000000000000000~" + "00000000000000000000000000000000~" + "00000000000000000000000000000000~" + "00000000000000000000000000000000~" + "00000000000000000000000000000000" ); var actual = StateTable.GetStateOfDefinitelyOccupied(input); for (int i = 0; i < 7; i++) { if (expected[i] != actual[i]) { string errorMessage = "Error at day = " + i + "\n"; errorMessage += "Expected = " + Convert.ToString(expected[i], 2) + "\n"; errorMessage += "Actual = " + Convert.ToString(actual[i], 2); Assert.Fail(errorMessage); } } Assert.Pass(); }
public void Permutator_CanPermutate() { Permutator idx = new Permutator(10); for (int i = 0; i < 10; i++) Console.WriteLine("{0}", idx[i]); }
public NetworkTrainer(BackPropagationNetwork BPN, DataSet DS) { Network = BPN; DataSet = DS; _idx = new Permutator(DataSet.Size); _iterations = 0; _errorHistory = new List <double>(); }
static void Main() { // We're going to create a permutation dictionary of all // cubic values up to a certain point. The purpose here is to // be able to attach a list of all discovered cubic permutations // to any particular cubic value that when sorted acts as a key // to this dictionary BigInteger answer = 0; Dictionary <BigInteger, List <BigInteger> > cubicDict = new Dictionary <BigInteger, List <BigInteger> >(); int search = 100000; for (int i = 0; i < search; ++i) { // get the cube of the index, convert it to a string, // sort it, and use the sorted permutation of it's digits BigInteger it = BigInteger.Pow(i, 3); List <BigInteger> digits = Permutator.getDigits(it); digits.Sort(); BigInteger sorted = 0; for (int j = 0; j < digits.Count; ++j) { sorted += BigInteger.Pow(10, j) * digits[j]; } List <BigInteger> knownPerms; // we want to enforce the rule that associated permutations // have the same number of digits List <BigInteger> sortedDigits = Permutator.getDigits(sorted); if (sortedDigits.Count == digits.Count) { if (cubicDict.TryGetValue(sorted, out knownPerms)) { knownPerms.Add(it); if (knownPerms.Count == 5) { foreach (BigInteger x in knownPerms) { Console.WriteLine(x); } answer = i; break; } } else { knownPerms = new List <BigInteger>(); knownPerms.Add(it); cubicDict.Add(sorted, knownPerms); } } } Console.WriteLine("Answer: " + answer); // Keep the console window open in debug mode. Console.WriteLine("Press any key to exit."); Console.ReadKey(); }
public void CheckingPermutation() { var list = new List <int>() { 1, 2, 3, 4, 5 }; var result = Permutator.Permute(list); Assert.True(result.Count == 120); }
public void Test_PermutateV4_Increment_5() { var input = new List <BoundedInt> { new BoundedInt(1, 1) }; var actual = Permutator.Increment(input); Assert.True(actual == null); }
private static IEnumerable <IEnumerable <int> > CreateIndices(int length) { return((from p in Enumerable.Range(0, length) select( from s in Permutator.CreateIndices(length - 1) .DefaultIfEmpty(Enumerable.Empty <int>()) select s.Take(p) .Concat(new[] { length - 1 }) .Concat(s.Skip(p)) )) .SelectMany(i => i)); }
public void Test_ClashFinder_GetTimetableState_1() { var chosenSubject = TestData.Subjects.HubunganEtnik; var input = Permutator.Run_v2_WithConsideringWeekNumber(TestData.GetSlotsByName(chosenSubject) .ToArray()); var result = ClashFinder.GetSubjectState(input); foreach (int dayState in result) { Assert.IsTrue(dayState == 0); } }
static int nextDigitFactorial(int x) { int ret = 0; List <int> digits = Permutator.getDigits(x); Func <int, int> factorial = null; factorial = y => y <= 1 ? 1 : y *factorial(y - 1); foreach (int a in digits) { ret += factorial(a); } return(ret); }
public void CanPermute() { string str = "ABC"; int n = str.Length; var result = Permutator.Permute(str); Assert.Equal(result, new[] { "ABC", "ACB", "BAC", "BCA", "CBA", "CAB" }); }
public void SandboxTest_3() { var input = TestData.GetSlotsByName(TestData.Subjects.Hydrology); var input2 = TestData.GetSlotsByName(TestData.Subjects.FluidMechanicsII); var input3 = TestData.GetSlotsByName(TestData.Subjects.StructuralAnalysisII); var input4 = TestData.GetSlotsByName(TestData.Subjects.HighwayAndTransportation); var input5 = TestData.GetSlotsByName(TestData.Subjects.IntroductionToBuildingServices); int result1 = Permutator.Run_v2_WithConsideringWeekNumber(input.ToArray()).Count; int result2 = Permutator.Run_v2_WithConsideringWeekNumber(input2.ToArray()).Count; int result3 = Permutator.Run_v2_WithConsideringWeekNumber(input3.ToArray()).Count; int result4 = Permutator.Run_v2_WithConsideringWeekNumber(input4.ToArray()).Count; int result5 = Permutator.Run_v2_WithConsideringWeekNumber(input5.ToArray()).Count; Console.WriteLine("Total combination is " + result1 * result2 * result3 * result4 * result5); }
public void Test_StateTable_GetStateOfDefinitelyOccupied_1() { var input = Permutator.Run_v2_withoutConsideringWeekNumber(TestData .GetSlotsByName(TestData.Subjects.AdvancedStructuralSteelDesign).ToArray()); var expected = StateTable.ParseString_AsStateOfDefinitelyOccupied( "00000000000000111100000000000000~" + "00110000000000000000000000000000~" + "00000000000000000000000000000000~" + "00000000000000000000000000000000~" + "00000000000000000000000000000000~" + "00000000000000000000000000000000~" + "00000000000000000000000000000000" ); var actual = StateTable.GetStateOfDefinitelyOccupied(input); Assert.IsTrue(actual.SequenceEqual(expected)); }
public void Test_PermutateV4_Runv2_WithoutConsideringWeekNumber() { int expectedCount = 285696; var input = new List <Slot>(); input.AddRange(TestData.GetSlotsByName(TestData.Subjects.Hydrology)); input.AddRange(TestData.GetSlotsByName(TestData.Subjects.StructuralAnalysisII)); input.AddRange(TestData.GetSlotsByName(TestData.Subjects.HighwayAndTransportation)); input.AddRange(TestData.GetSlotsByName(TestData.Subjects.FluidMechanicsII)); input.AddRange(TestData.GetSlotsByName(TestData.Subjects.IntroductionToBuildingServices)); var timer = Stopwatch.StartNew(); var result = Permutator.Run_v2_withoutConsideringWeekNumber(input.ToArray()); timer.Stop(); Console.WriteLine("Combination count : " + result.Count); Console.WriteLine("Elapsed time : " + timer.Elapsed.TotalSeconds + " s"); Assert.True(result.Count == expectedCount); }
public void Test_PermutateV4_Partitionize_6() { var input = new[] { new Slot { Code = "abc", Type = "L", Number = "1" }, new Slot { Code = "abc", Type = "L", Number = "2" }, new Slot { Code = "abc", Type = "L", Number = "3" }, new Slot { Code = "abc", Type = "L", Number = "1" }, new Slot { Code = "abc", Type = "L", Number = "2" }, new Slot { Code = "abc", Type = "L", Number = "3" } }; var actual = Permutator.Partitionize(input); var expected = new List <List <Slot> > { new List <Slot> { input[0], input[1], input[2] }, new List <Slot> { input[3], input[4], input[5] } }; if (actual.Count != expected.Count) { Assert.Fail(); } foreach (var e in expected) { actual.RemoveAll(x => x.ScrambledEquals(e)); } Assert.True(actual.Count == 0); }
/// <summary> /// Generates a random set of coefficients. The number of set coefficients is a number drawn from the Robust Soliton Distribution that was initialized in the constructor /// </summary> /// <param name="symbolId">For Luby Transform, the symbol ID has no bearing on the coefficients</param> /// <param name="complexity">The number of operations that had to be performed</param> /// <returns></returns> public bool[] GenerateCoefficients(long symbolId, ref int complexity) { // Set up the set of coefficients var coefficients = new bool[NumSymbols]; complexity += NumSymbols; var degree = _pmf.Generate(); // This is the number of bits that will be set in the coefficients array. O(log(n)) complexity += (int)Math.Ceiling(Math.Log(NumSymbols, 2.0)); for (var i = 0; i < degree; i++) // O(n) { complexity++; coefficients[i] = true; } // Mix up the coefficients array Permutator <bool> .Permutate(coefficients, _random); // O(n) complexity += NumSymbols; return(coefficients); }
public void Test_StateTable_1() { var stateTable = new StateTable_v1(); var data = new List <Slot>(); data.AddRange(GetSlotsByName(Subjects.Hydrology)); data.AddRange(GetSlotsByName(Subjects.IntroductionToBuildingServices)); data.AddRange(GetSlotsByName(Subjects.HighwayAndTransportation)); data.AddRange(GetSlotsByName(Subjects.StructuralAnalysisII)); var result = Permutator.Run_v2_WithConsideringWeekNumber(data.ToArray())[0]; for (int i = 0; i < result.Count; i++) { stateTable.Add(new IndexedSlot(result[i])); } Console.WriteLine(stateTable.ToString()); Assert.Pass(); }
public void Test_ClashFinder_GetTimetableState_2() { var chosenSubject = TestData.Subjects.ArtCraftAndDesign; var input = Permutator.Run_v2_WithConsideringWeekNumber(TestData.GetSlotsByName(chosenSubject) .ToArray()); var result = ClashFinder.GetSubjectState(input); for (int i = 0; i < Day.NumberOfDaysPerWeek; i++) { if (i == 0) //Monday { Assert.IsTrue(result[i] == Convert.ToInt32("00000000000000111100000000000000", 2)); } else { Assert.IsTrue(result[i] == 0); } } }
private List <IList <ulong> > GenWeightCombos(ulong targetWeight, ulong[] nums) { List <IList <ulong> > weightCombos = new List <IList <ulong> >(); for (int i = 2; i < input.Length; i++) { foreach (var wc in Permutator.Combinations(i, nums)) { if (Sum(wc) == targetWeight) { weightCombos.Add(wc); } } if (weightCombos.Count != 0) { break; } } return(weightCombos); }
public override object Task2() { thrusters = new IntCode.Emulator[5]; for (int i = 0; i < 5; i++) { thrusters[i] = new IntCode.Emulator(thrusterCode); } int[] phaseSettings = new int[] { 5, 6, 7, 8, 9 }; long maxSignal = 0; foreach (int[] arr in Permutator.Permutate(phaseSettings)) { long sig = RunFeedbackLoop(arr); if (sig > maxSignal) { maxSignal = sig; } } return(maxSignal); }
public int FindShortestDistance(bool includePathBack) { var pathFinder = new PathFinder(); var points = FindAllPoints(); var permutatios = Permutator.Permute(points.Keys.ToArray()); permutatios = permutatios.Where(p => p[0] == '0'); // Remembering all the distances speed things up a bit... var knownDistances = new Dictionary <string, int>(); var shortest = int.MaxValue; foreach (var permutation in permutatios) { var sum = 0; char[] currentPermutation = permutation; if (includePathBack) { currentPermutation = permutation.Concat(new[] { '0' }).ToArray(); } for (int i = 0; i < currentPermutation.Length - 1; i++) { var key = "" + currentPermutation[i] + currentPermutation[i + 1]; if (!knownDistances.ContainsKey(key)) { knownDistances.Add(key, pathFinder.FindShortestPath( points[currentPermutation[i]], points[currentPermutation[i + 1]], NodeTypeAtPos)); } sum += knownDistances[key]; } shortest = Math.Min(shortest, sum); } return(shortest); }
public override object Task1() { thrusterCode = IntCode.Tools.ParseCode(input[0]); IntCode.Emulator ICE = new IntCode.Emulator(thrusterCode); long maxSignal = 0; var response = IntCode.Emulator.ResultTemplate; foreach (int[] arr in Permutator.Permutate(new int[] { 0, 1, 2, 3, 4 })) { response.Item2 = 0; foreach (int s in arr) { ICE.Reboot(); ICE.QueueInput(s, response.Item2); response = ICE.Run(); } if (response.Item2 > maxSignal) { maxSignal = response.Item2; } } return(maxSignal); }
public void Test_ClashFinder_GetTimetableState_3() { var chosenSubject = TestData.Subjects.AdvancedStructuralSteelDesign; var input = Permutator.Run_v2_WithConsideringWeekNumber(TestData.GetSlotsByName(chosenSubject) .ToArray()); var result = ClashFinder.GetSubjectState(input); for (int i = 0; i < Day.NumberOfDaysPerWeek; i++) { if (i == 0) //Monday { Assert.IsTrue(result[i] == Convert.ToInt32("00000000000000111100000000000000", 2)); } else if (i == 1) //Tuesday { Assert.AreEqual(Convert.ToInt32("00110000000000000000000000000000".Reverse(), 2), result[i]); } else //others { Assert.IsTrue(result[i] == 0); } } }
/// <summary> /// Produces a hash for the paths of adjacent bnodes for a bnode, /// incorporating all information about its subgraph of bnodes. /// </summary> /// <remarks> /// Produces a hash for the paths of adjacent bnodes for a bnode, /// incorporating all information about its subgraph of bnodes. This method /// will recursively pick adjacent bnode permutations that produce the /// lexicographically-least 'path' serializations. /// </remarks> /// <param name="id">the ID of the bnode to hash paths for.</param> /// <param name="bnodes">the map of bnode quads.</param> /// <param name="namer">the canonical bnode namer.</param> /// <param name="pathNamer">the namer used to assign names to adjacent bnodes.</param> /// <param name="callback">(err, result) called once the operation completes.</param> private static HashResult HashPaths(string id, IDictionary <string, IDictionary <string, object> > bnodes, UniqueNamer namer, UniqueNamer pathNamer) { #if !PORTABLE MessageDigest md = null; try { // create SHA-1 digest md = MessageDigest.GetInstance("SHA-1"); var groups = new JObject(); IList <string> groupHashes; var quads = (IList <RdfDataset.Quad>)bnodes[id]["quads"]; for (var hpi = 0;; hpi++) { if (hpi == quads.Count) { // done , hash groups groupHashes = new List <string>(groups.GetKeys()); ((List <string>)groupHashes).Sort(StringComparer.CurrentCultureIgnoreCase); for (var hgi = 0;; hgi++) { if (hgi == groupHashes.Count) { var res = new HashResult(); res.hash = EncodeHex(md.Digest()); res.pathNamer = pathNamer; return(res); } // digest group hash var groupHash = groupHashes[hgi]; md.Update(JavaCompat.GetBytesForString(groupHash, "UTF-8")); // choose a path and namer from the permutations string chosenPath = null; UniqueNamer chosenNamer = null; var permutator = new Permutator((JArray)groups[groupHash]); while (true) { var contPermutation = false; var breakOut = false; var permutation = permutator.Next(); var pathNamerCopy = pathNamer.Clone(); // build adjacent path var path = string.Empty; var recurse = new JArray(); foreach (string bnode in permutation) { // use canonical name if available if (namer.IsNamed(bnode)) { path += namer.GetName(bnode); } else { // recurse if bnode isn't named in the path // yet if (!pathNamerCopy.IsNamed(bnode)) { recurse.Add(bnode); } path += pathNamerCopy.GetName(bnode); } // skip permutation if path is already >= chosen // path if (chosenPath != null && path.Length >= chosenPath.Length && string.CompareOrdinal(path, chosenPath) > 0) { // return nextPermutation(true); if (permutator.HasNext()) { contPermutation = true; } else { // digest chosen path and update namer md.Update(JavaCompat.GetBytesForString(chosenPath, "UTF-8")); pathNamer = chosenNamer; // hash the nextGroup breakOut = true; } break; } } // if we should do the next permutation if (contPermutation) { continue; } // if we should stop processing this group if (breakOut) { break; } // does the next recursion for (var nrn = 0;; nrn++) { if (nrn == recurse.Count) { // return nextPermutation(false); if (chosenPath == null || string.CompareOrdinal(path, chosenPath) < 0) { chosenPath = path; chosenNamer = pathNamerCopy; } if (!permutator.HasNext()) { // digest chosen path and update namer md.Update(JavaCompat.GetBytesForString(chosenPath, "UTF-8")); pathNamer = chosenNamer; // hash the nextGroup breakOut = true; } break; } // do recursion var bnode_1 = (string)recurse[nrn]; var result = HashPaths(bnode_1, bnodes, namer, pathNamerCopy); path += pathNamerCopy.GetName(bnode_1) + "<" + result.hash + ">"; pathNamerCopy = result.pathNamer; // skip permutation if path is already >= chosen // path if (chosenPath != null && path.Length >= chosenPath.Length && string.CompareOrdinal(path, chosenPath) > 0) { // return nextPermutation(true); if (!permutator.HasNext()) { // digest chosen path and update namer md.Update(JavaCompat.GetBytesForString(chosenPath, "UTF-8")); pathNamer = chosenNamer; // hash the nextGroup breakOut = true; } break; } } // do next recursion // if we should stop processing this group if (breakOut) { break; } } } } // get adjacent bnode var quad = (IDictionary <string, object>)quads[hpi]; var bnode_2 = GetAdjacentBlankNodeName((IDictionary <string, object>)quad["subject" ], id); string direction = null; if (bnode_2 != null) { // normal property direction = "p"; } else { bnode_2 = GetAdjacentBlankNodeName((IDictionary <string, object>)quad["object"], id ); if (bnode_2 != null) { direction = "r"; } } if (bnode_2 != null) { // get bnode name (try canonical, path, then hash) string name; if (namer.IsNamed(bnode_2)) { name = namer.GetName(bnode_2); } else { if (pathNamer.IsNamed(bnode_2)) { name = pathNamer.GetName(bnode_2); } else { name = HashQuads(bnode_2, bnodes, namer); } } // hash direction, property, end bnode name/hash using (var md1 = MessageDigest.GetInstance("SHA-1")) { // String toHash = direction + (String) ((Map<String, // Object>) quad.get("predicate")).get("value") + name; md1.Update(JavaCompat.GetBytesForString(direction, "UTF-8")); md1.Update(JavaCompat.GetBytesForString((string)((IDictionary <string, object>)quad["predicate"])["value"], "UTF-8")); md1.Update(JavaCompat.GetBytesForString(name, "UTF-8")); var groupHash = EncodeHex(md1.Digest()); if (groups.ContainsKey(groupHash)) { ((JArray)groups[groupHash]).Add(bnode_2); } else { var tmp = new JArray(); tmp.Add(bnode_2); groups[groupHash] = tmp; } } } } } catch { // TODO: i don't expect that SHA-1 is even NOT going to be // available? // look into this further throw; } finally { md?.Dispose(); } #else throw new PlatformNotSupportedException(); #endif }
/// <summary> /// Returns the Threat Level after assigning <see cref="Force"/> to /// <see cref="CityBlock"/>. No work is done here to remember state of any sort, /// only the allocated threat level is calculated and returned. It is not the most /// optimized thing that can be done, but given the timeframe and problem domain, /// this is pretty close to being good enough. /// </summary> /// <returns></returns> private int Allocate() { //var comparer = new ForceComparer(); var threatLevel = Blocks.Sum(x => x.ThreatLevel); /* Really, really (REALLY) avoid the R# help here: that could * be potentially very, very (VERY) expensive. */ var permutator = new Permutator<Force>(Forces); do { var localForces = (from x in permutator.Values select x.Clone()) .OfType<Force>().ToList(); // ReSharper disable once PossibleMultipleEnumeration var localBlocks = (from x in Blocks.ToArray() select (CityBlock) x.Clone()).ToArray(); // Assign all the possible forces we can to the best possible locations. foreach (var force in localForces .TakeWhile(x => x.TryPatrol(localBlocks)) .Where(x => localBlocks.All(y => y.IsPatrolled))) { break; } threatLevel = Math.Min(threatLevel, localBlocks.Sum(x => x.ThreatLevel)); // This is as low as we can go, no point in continuing through the (many) other permutations. if (threatLevel == 0) break; } while (permutator.Next()); //// Permute the forces themselves. //var forcePermutations = Forces.Permute().ToArray(); //// ReSharper disable once LoopCanBePartlyConvertedToQuery //foreach (var forces in forcePermutations) //{ // var localForces = (from x in forces // select x.Clone()).OfType<Force>().ToArray(); // // ReSharper disable once PossibleMultipleEnumeration // var localBlocks = (from x in Blocks.ToArray() // select (CityBlock) x.Clone()).ToArray(); // // Assign all the possible forces we can to the best possible locations. // foreach (var force in localForces // .TakeWhile(x => x.TryPatrol(localBlocks)) // .Where(x => localBlocks.All(y => y.IsPatrolled))) // { // break; // } // threatLevel = Math.Min(threatLevel, // localBlocks.Sum(x => x.ThreatLevel)); // // This is as low as we can go, no point in continuing through the (many) other permutations. // if (threatLevel == 0) break; //} return threatLevel; }
// to search for the solution we must // find the 126 possible selections for X // and determine the set difference set Y. We then must test // the various orders of X and Y. In total we // end up checking about 10^6 combinations. static void Main() { List <int> t = new List <int>() { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; for (int i = 1; i <= 9; ++i) { for (int j = i + 1; j <= 9; ++j) { for (int k = j + 1; k <= 9; ++k) { for (int m = k + 1; m <= 9; ++m) { for (int n = m + 1; n <= 9; ++n) { // for each set of i,j,k,l,m, and n // we want to check the linear solution // using all possible permutations of these numbers // as well as the possible permutations of the difference // set with [1,10] List <int> dSet = new List <int>(); List <int> X = new List <int>(); X.Add(i); X.Add(j); X.Add(k); X.Add(m); X.Add(n); foreach (int x in t) { if (x != i && x != j && x != k && x != m && x != n) { dSet.Add(x); } } // now that we have the difference set, we need // to operate on all the permutations of these numbers // and compute the constant we need for our computations int constant = 0; foreach (int item in dSet) { constant += item; } foreach (int item in X) { constant += 2 * item; } constant /= 5; List <List <int> > permsX = Permutator.getIntPermutations(X); List <List <int> > permsDSet = Permutator.getIntPermutations(dSet); foreach (List <int> u in permsDSet) { foreach (List <int> v in permsX) { if (u[0] + v[0] + v[1] == constant && u[1] + v[1] + v[2] == constant && u[2] + v[2] + v[3] == constant && u[3] + v[3] + v[4] == constant && u[4] + v[4] + v[0] == constant) { // print the solution sets, but print // the solution in the format as described in the problem description int min = 10, index = 0; for (int x1 = 0; x1 < u.Count; ++x1) { if (u[x1] <= min) { min = u[x1]; index = x1; } } for (int x1 = 0; x1 < u.Count; ++x1) { int x2 = (x1 + index) % u.Count; Console.Write(u[x2] + "," + v[x2 % 5] + "," + v[(x2 + 1) % 5] + "; "); } Console.WriteLine(); } } } } } } } } // Keep the console window open in debug mode. Console.WriteLine("Press any key to exit."); Console.ReadKey(); }