Example #1
1
        /// <summary>
        /// Locates the changes between the prior and post state of the modules..
        /// </summary>
        /// <param name="modules_prior">List of the available modules prior to the update.</param>
        /// <param name="modules_post">List of the available modules after the update.</param>
        private void PrintChanges(List<CkanModule> modules_prior, List<CkanModule> modules_post)
        {
            var prior = new HashSet<CkanModule>(modules_prior, new NameComparer());
            var post = new HashSet<CkanModule>(modules_post, new NameComparer());


            var added = new HashSet<CkanModule>(post.Except(prior, new NameComparer()));
            var removed = new HashSet<CkanModule>(prior.Except(post, new NameComparer()));


            var unchanged = post.Intersect(prior);//Default compare includes versions
            var updated = post.Except(unchanged).Except(added).Except(removed).ToList();

            // Print the changes.
            user.RaiseMessage("Found {0} new modules, {1} removed modules and {2} updated modules.", added.Count(), removed.Count(), updated.Count());

            if (added.Count > 0)
            {
                PrintModules("New modules [Name (CKAN identifier)]:", added);
            }

            if (removed.Count > 0)
            {
                PrintModules("Removed modules [Name (CKAN identifier)]:", removed);
            }

            if (updated.Count > 0)
            {
                PrintModules("Updated modules [Name (CKAN identifier)]:", updated);
            }
        }
Example #2
0
        static void Main(string[] args)
        {
            string input = Console.ReadLine();
            string pattern = @"(\D+)(\d+)";
            var regex = new Regex(pattern);

            MatchCollection matches = Regex.Matches(input,pattern);

            StringBuilder builder = new StringBuilder();

            foreach (Match match in matches)
            {
                StringBuilder sb = new StringBuilder();
                var message = match.Groups[1].Value.ToUpper();
                var numberOfRepetitions = int.Parse(match.Groups[2].Value);

                for (int i = 0; i < numberOfRepetitions; i++)
                {
                    sb.Append(message);
                }

                builder.Append(sb);
            }
            var set = new HashSet<char>();

            foreach (char ch in builder.ToString())
            {
                set.Add(ch);
            }
            Console.WriteLine("Unique symbols used: {0}", set.Count());
            Console.WriteLine(builder);
        }
Example #3
0
        public HashSet<String> extract()
        {
            HashSet<String> hashes = new HashSet<String>();
            int totalCount = 0;

            uint maxMemoryChunk = 10 * 1024 * 1024; // 10 megabytes
            byte[] buffer = new byte[maxMemoryChunk];
            while (true)
            {
                int bytesRead = reader.readNextMemoryRegion(buffer, maxMemoryChunk);
                if (0 == bytesRead)
                {
                    Console.WriteLine("Finished reading all regions");
                    break;
                }

                int n = bytesRead - 8;
                for (int i = 0; i < bytesRead; ++i)
                {
                    if ('s' == buffer[i] && isMagic(buffer, i, server.Magic))
                    {
                        totalCount++;
                        hashes.Add(BitConverter.ToString(buffer, i + 8, 32).ToLower().Replace("-", ""));
                    }
                }
            }

            Console.WriteLine("Number of unique s2gs hash strings found: " + hashes.Count());
            Console.WriteLine("Number of total s2gs hash strings found: " + totalCount);

            return hashes;
        }
Example #4
0
        private void textBox1_TextChanged(object sender, EventArgs e)
        {

            //Unsorted 
            HashSet<int> set = new HashSet<int>();
            List<int> list = new List<int>();
            SortedSet<int> sortset = new SortedSet<int>();
            StringBuilder s = new StringBuilder();
            Random rand = new Random();

            //Add random numbers to a list (not ordered)
            for (int i = 0; i < 10000; i++) { list.Add(rand.Next(1, 20000)); }

            //Place unique numbers from the list previously generated into a hashset
            for (int i = 0; i < 10000; i++) { set.Add(list[i]); }

            //Sorts the list of random numbers through the use of a Sortedset
            for (int i = 0; i < 10000; i++) { sortset.Add(list[i]); }

            //count distinct characters in the list 
            int unique = (from i in list select i).Distinct().Count();

            //String formatting
            s.Append("1. Hashset method: " + set.Count().ToString() + " unique numbers." +
            "The time complexity of this code is O(nlog(n) + 2n), because the intialization of variables " +
            "is O(1) and the add function for the hashset and list is O(1). Therefore the algorithm executes" +
            "10000 times twice and we'll mark this up to be (2n)." +
            "This gives us a time complexity for the aglorithm to be O(2n). Then the add time complexity for the sortedset is nlogn which consequatnly"+
            "gives us O(nlog(n) + 2n)");
            s.Append("\r\n2. " + unique.ToString() + " unique numbers.");
            s.Append("\r\n3. " + sortset.Count().ToString() + " unique numbers");
            textBox1.Text = s.ToString();                  
        }
Example #5
0
 public static void problem(int[] numbers, int raznica)
 {
     HashSet<int> lilu = new HashSet<int>(numbers);
     int counter = lilu
         .Count(p => lilu.Contains(p + raznica));
     Console.WriteLine(counter);
 }
		public override void UndoRedoPerformed(List<GameObject> modified)
		{
			modifiedMeshes = new HashSet<Mesh>(modifiedMeshes.Where(x => x != null));

			if(z_ReflectionUtil.ProBuilderExists())
			{
				// delete & undo causes cases where object is not null but the reference to it's pb_Object is
				HashSet<object> remove = new HashSet<object>();

				foreach(object pb in modifiedPbMeshes)
				{
					try
					{
						z_ReflectionUtil.Invoke(pb, "ToMesh");
						z_ReflectionUtil.Invoke(pb, "Refresh");
						z_ReflectionUtil.Invoke(null, z_Pref.PB_EDITOR_MESH_UTILITY_TYPE, "Optimize", BindingFlags.Public | BindingFlags.Static, z_Pref.PB_EDITOR_ASSEMBLY, pb);
					}
					catch
					{
						remove.Add(pb);
					}

				}

				if(remove.Count() > 0)
					modifiedPbMeshes.SymmetricExceptWith(remove);
			}

			foreach(Mesh m in modifiedMeshes)
				m.vertices = m.vertices;

			base.UndoRedoPerformed(modified);
		}
        public ICollection<AuthorModel> GetRandomAuthors(int rightAuthorId)
        {
            var authorIds = this.data.Authors
             .All()
             .Select(a => a.Id)
             .ToList();

            var randomAuthorIds = new HashSet<int>();
            randomAuthorIds.Add(rightAuthorId);

            while (randomAuthorIds.Count() < GlobalConstants.NumberOfAuthorsToChoose)
            {
                var randomAuthorId = this.GetRandomAuthorId(authorIds);
                randomAuthorIds.Add(randomAuthorId);
            }

            var randomAuthors = this.data.Authors
                .All()
                .Where(a => randomAuthorIds.Contains(a.Id))
                .OrderBy(a => a.FullName)
                .ProjectTo<AuthorModel>()
                .ToList();

            return randomAuthors;
        }
        public void TestEdbLogging()
        {
            Init();

            var queryArgs = new Dictionary<string, string>
            {
                { "@source.environment", TestName },
                { "@source.groupId", CurrentGroupId },
                { "@source.path", "EDB_expected_event_sources.log" }
            };

            var expectedLines = File.ReadAllText(@"Expected\EdbLoggingTest.txt").Split(new[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries);
            var expected = new HashSet<string>(expectedLines);

            GetAndValidateRecords(queryArgs, new [] { "@message" }, expected.Count(),
                records =>
                {
                    foreach (var record in records)
                    {
                        var message = (JContainer)JsonConvert.DeserializeObject(record.Fields["@message"]);
                        message.Children().First().Remove();
                        var lineText = JsonConvert.SerializeObject(message);
                        Assert.IsTrue(expected.Contains(lineText));
                    }
                }, 3);
        }
Example #9
0
        string Main()
        {
            int position = 1;
            int smallGap = 2;
            int bigGap = 4;
            int totalPrimeCount = 0;

            HashSet<int> diagonals = new HashSet<int>();
            diagonals.Add(1);

            while (true)
            {
                for (int i = 0; i < 4; i++)
                {
                    position += smallGap;
                    diagonals.Add(position);
                    if (UsefulFunctions.IsPrime(position))
                        totalPrimeCount++;
                }

                double average = (double)totalPrimeCount / diagonals.Count();

                if (average < .10)
                {
                    break;
                }

                smallGap += 2;
                bigGap += 2;
            }
            return (bigGap - 1).ToString();
        }
Example #10
0
        public long Solve()
        {
            var primes = new Prime((long)Math.Sqrt(Limit) + 1).PrimeList;

            var squerePrimes = new List<long>();
            var cubePrimes = new List<long>();
            var fourthPrimes = new List<long>();

            var cubeLimit = false;
            var fourthLimit = false;
            foreach (var prime in primes)
            {
                var squere = prime * prime;
                squerePrimes.Add(squere);

                if (!cubeLimit)
                {
                    var cube = squere * prime;

                    if (cube > Limit)
                    {
                        cubeLimit = true;
                        continue;
                    }
                    cubePrimes.Add(cube);
                }

                if (!fourthLimit)
                {
                    var fourth = squere * squere;
                    if (fourth > Limit)
                    {
                        fourthLimit = true;
                        continue;
                    }
                    fourthPrimes.Add(fourth);
                }
            }

            Console.WriteLine(squerePrimes.Count);
            Console.WriteLine(cubePrimes.Count);
            Console.WriteLine(fourthPrimes.Count);

            var numbers = new HashSet<long>();

            foreach (var cubePrime in cubePrimes)
            {
                foreach (var squerePrime in squerePrimes)
                {
                    foreach (var fourthPrime in fourthPrimes)
                    {
                        numbers.Add(cubePrime + squerePrime + fourthPrime);
                    }
                }
            }

            return numbers.Count(t => t < Limit);
        }
Example #11
0
 public RearsegmentBackups(IEnumerable<Segment> segments,
     HashSet<NodeEndpoint> endpoints,
     int numberOfBackCopiesToKeep)
 {
     this.segments = segments;
     this.endpoints = endpoints;
     this.numberOfBackCopiesToKeep = numberOfBackCopiesToKeep;
     fairDistribution = (segments.Count() * numberOfBackCopiesToKeep) / endpoints.Count() + 1;
     currentDistribution = PrepareDistributions();
 }
        private static string GetRequestedByFromChangeset(IEnumerable<IBuildInformationNode> changesets)
        {
            var users = new HashSet<String>();
            foreach (var changeset in changesets)
                users.Add(changeset.Fields["CheckedInBy"]);

            var count = users.Count();
            if (count > 1)
                return "(Multiple Users)";
            return users.First();
        }
Example #13
0
        public long Solve()
        {
            var primes = new List<int> { 2, 3, 5, 7 };
            var truncatePrimes = new HashSet<int>();
            var posibleLeftPrimes = new List<int>();
            var posibleRightPrimes = new List<int>();

            while (truncatePrimes.Count() < 11)
            {
            }

            return 0;
        }
Example #14
0
File: Deck.cs Project: Amichai/Set
 public void ShuffleDeck()
 {
     if (this.cards.Count() != 0) throw new Exception();
     HashSet<int> indicesTaken = new HashSet<int>();
     while (this.cards.Count() < allCards.Count) {
         int idxToTake = rng.Next(0, allCards.Count);
         if (!indicesTaken.Contains(idxToTake)) {
             this.cards.Push(allCards[idxToTake]);
             indicesTaken.Add(idxToTake);
         }
     }
     if (indicesTaken.Count() != allCards.Count) throw new Exception();
 }
Example #15
0
        public bool IsConnected()
        {
            HashSet<Point> allPathablePoints = new HashSet<Point>();
            foundPathablePoints = new HashSet<Point>();

            for (int i = 0; i < thisMap.Width; i++)
            {
                for (int j = 0; j < thisMap.Height; j++)
                {
                    if(CountsAsWalkable(thisMap.getCell(i, j)))
                        allPathablePoints.Add(new Point(i, j));
                }
            }

            if(allPathablePoints.Count() == 0)
                return true;

            Stack<Point> workNodes = new Stack<Point>();

            workNodes.Push(allPathablePoints.First());

            while (workNodes.Count() > 0)
            {
                var thisNode = workNodes.Pop();
                if (CountsAsWalkable(thisMap.getCell(thisNode.x, thisNode.y)))
                {
                    foundPathablePoints.Add(thisNode);
                    var neighbours = Get4WayNeighbours(thisNode);
                    foreach (var p in neighbours)
                        workNodes.Push(p);
                }
            }

            if (allPathablePoints.Intersect(foundPathablePoints).Count() == allPathablePoints.Count())
                return true;

            return false;
        }
Example #16
0
        double CalcAverage(HashSet<int> diagonals)
        {
            long totalCount = diagonals.Count();
            int primeCount = 0;

            foreach (int diagonal in diagonals)
            {
                if (primes[diagonal])
                    primeCount++;
            }

            double average = (double)primeCount / totalCount;
            return average;
        }
Example #17
0
        private static IEnumerable<long> GetAllPermutation(long posiblePrime)
        {
            var output = new HashSet<long> { posiblePrime };
            var count = 0;
            var posiblePrimeText = posiblePrime.ToString(CultureInfo.InvariantCulture);

            while (output.Count != count)
            {
                posiblePrimeText = GetNexPosible(posiblePrimeText);
                count = output.Count();
                output.Add(int.Parse(posiblePrimeText));
            }

            return output;
        }
        public void AddFeedWritesSourceIfItDoesNotExist()
        {
            // Arrange
            bool writeCalled = false;
            var sourceFile = GetPackagesSourceFile();
            sourceFile.Setup(c => c.WriteSources(It.IsAny<IEnumerable<WebPackageSource>>())).Callback(() => writeCalled = true);
            ISet<WebPackageSource> set = new HashSet<WebPackageSource>(GetSources());

            // Act
            bool returnValue = PackageManagerModule.AddPackageSource(sourceFile.Object, set, new WebPackageSource(source: "http://www.microsoft.com/feed3", name: "Feed3"));

            // Assert
            Assert.Equal(set.Count(), 3);
            Assert.True(writeCalled);
            Assert.True(returnValue);
        }
Example #19
0
        private static ICollection<Student> SeedStudents()
        {
            ICollection<Student> students = new HashSet<Student>();

            while (students.Count() <= 10)
            {
                students.Add(
                        new Student(
                            firstNames[rnd.Next(0, firstNames.Length)],
                            lastNames[rnd.Next(0, lastNames.Length)],
                            GenerateFacultyNumber(rnd)
                        ));
            }

            return students;
        }
        public void CardsAreRandomlyDistributed()
        {
            // Arrange
            var cardPositions = new HashSet<int>();

            // Act
            for(var i=0; i<400; i++)
            {
                Setup();
                var firstCard = board.First();
                var matchPosition = board.ToList().FindIndex(1, p => p.IsMatch(firstCard));
                cardPositions.Add(matchPosition);
            }

            // Assert
            cardPositions.Count().ShouldBeGreaterThanOrEqualTo(numberOfPairs-1);
        }
Example #21
0
        private bool IsPandigital(long number)
        {
            var digits = new HashSet<long>();

            while (number > 0)
            {
                var digit = number % 10;

                if (digit == 0)
                    return false;

                digits.Add(digit);

                number = number / 10;
            }

            return digits.Count() == 9;
        }
Example #22
0
        public static void CompareSequenceLists(HashSet<string> expected, HashSet<string> result)
        {
            Console.WriteLine();
            Console.Write("Expected (Possible): ");
            foreach (var value in expected)
                Console.Write(value + ",");
            Console.WriteLine();
            Console.Write("Actual:");
            foreach (var value in result)
                Console.Write(value + ",");

            Assert.AreEqual(expected.Count, result.Count(), "Different sequence counts.");

            foreach (var s in result)
            {
                Assert.IsTrue(expected.Contains(s), "Could not locate " + s);
            }
        }
Example #23
0
        public void Rete(HashSet<int> list, Stack<int> st, List<IList<int>> re)
        {
            if (list.Count() == 0)
            {
                re.Add(new List<int>(st));
                return;
            }

            HashSet<int> nhs = new HashSet<int>(list);

            foreach (var item in list)
            {
                nhs.Remove(item);
                st.Push(item);
                Rete(nhs, st, re);
                st.Pop();
                nhs.Add(item);
            }
        }
Example #24
0
        private bool IsPandigital(long number)
        {
            var lenght = (int)Math.Log10(number) + 1;
            var digits = new HashSet<long>();

            while (number > 0)
            {
                var digit = number % 10;

                if (digit == 0)
                    return false;

                digits.Add(digit);

                number = number / 10;
            }

            return (digits.Count() == lenght) && digits.Max() == lenght;
        }
        public ActionResult Index()
        {
            var model = new HomeViewModel();

            var randomQuestion = factory.GetRandomQuestion();

            var authorIds = this.Data.Authors
                .All()
                .Select(a => a.Id)
                .ToList();

            var randomAuthorIds = new HashSet<int>();

            if (GlobalVariables.BinaryMode)
            {
                var randomAuthorId = factory.GetRandomAuthorId(authorIds);
                randomAuthorIds.Add(randomAuthorId);
            }

            else
            {
                randomAuthorIds.Add(randomQuestion.AuthorId);

                while (randomAuthorIds.Count() < GlobalConstants.NumberOfAuthorsToChoose)
                {
                    var randomAuthorId = factory.GetRandomAuthorId(authorIds);
                    randomAuthorIds.Add(randomAuthorId);
                }
            }

            var authors = this.Data.Authors
                .All()
                .Where(a => randomAuthorIds.Contains(a.Id))
                .ProjectTo<AuthorViewModel>()
                .ToList()
                .OrderBy(a => a.FullName);

            model.Question = randomQuestion;
            model.Authors = authors;

            return View(model);
        }
        internal IEnumerable<RepositoryCommitModel> GetTags(string name, int page, int p, out string referenceName, out int totalCount)
        {
            var commit = GetCommitByName(name, out referenceName);
            if (commit == null)
            {
                totalCount = 0;
                return Enumerable.Empty<RepositoryCommitModel>();
            }
            var tags = _repository.Tags;
            var commits = new HashSet<RepositoryCommitModel>(AnonymousComparer.Create<RepositoryCommitModel>((x, y) => x.ID == y.ID, obj => obj.ID.GetHashCode()));
            foreach (var tag in tags)
            {
                var c = _repository.Lookup(tag.Target.Id) as Commit;
                commits.Add(ToModel(c));

            }
            totalCount = commits.Count();

            return commits.OrderByDescending(x => x, (x, y) => x.Date.CompareTo(y.Date));
        }
        public void TestAddAllAndForEach()
        {
            // Arrange
            var setA = new HashSet<int>();
            setA.Add(1);
            setA.Add(2);
            setA.Add(3);
            var setB = new HashSet<int>();
            setB.Add(2);
            setB.Add(4);
            setB.Add(6);

            var expectedValues = new int[] { 1, 2, 3, 4, 6 };

            // Act
            setA.AddAll(setB);

            // Assert
            Assert.AreEqual(expectedValues.Length, setA.Count());
            expectedValues.ForEach(expected => Assert.IsTrue(setA.Contains(expected)));
        }
Example #28
0
        private double GetMinimumCostRoute(int startVertex, HashSet<int> set, Node root)
        {
            if (!set.Any())
            {
                //source node is assumed to be the first
                root.ChildNodes = new Node[1] { new Node { Value = _vertices.First(), Selected = true } };
                return _adjacencyMatrix[startVertex, 0];
            }

            double totalCost = double.MaxValue;
            int i = 0;
            int selectedIdx = i;
            root.ChildNodes = new Node[set.Count()];

            foreach (var destination in set)
            {
                root.ChildNodes[i] = new Node { Value = destination };

                double costOfVistingCurrentNode = _adjacencyMatrix[startVertex, destination];

                var newSet = new HashSet<int>(set);
                newSet.Remove(destination);
                double costOfVisitingOtherNodes = GetMinimumCostRoute(destination, newSet, root.ChildNodes[i]);
                double currentCost = costOfVistingCurrentNode + costOfVisitingOtherNodes;

                if (totalCost > currentCost)
                {
                    totalCost = currentCost;
                    selectedIdx = i;
                }

                i++;
            }

            root.ChildNodes[selectedIdx].Selected = true;

            return totalCost;

        }
Example #29
0
		public List<SearchResult> Search(string query)
		{
			var results = new List<SearchResult>();

			if (string.IsNullOrEmpty(query))
			{
				return results;
			}

			var titlesReturned = new HashSet<string>();
			var descriptionsReturned = new HashSet<string>();
			int resultsTried = 0;

			while (titlesReturned.Count() < 10 && resultsTried < 300)
			{
				resultsTried++;

				var randomTitle = string.Join(" ", GetSentence(titleChain, 12));
				var randomDescription = string.Join(" ", Enumerable.Range(0, rng.Next(1, 4)).SelectMany(_ => GetSentence(descriptionChain, 25)));

				if ((randomTitle.Contains(query.ToLower()) || randomDescription.Contains(query.ToLower()))
					&& !titlesReturned.Contains(randomTitle) && !descriptionsReturned.Contains(randomDescription))
				{
					titlesReturned.Add(randomTitle);
					descriptionsReturned.Add(randomDescription);

					results.Add(new SearchResult()
					{
						Title = TitleCase(randomTitle),
						Description = SentenceCase(randomDescription),
						Relevance = rng.Next(1, 6),
						Url = "#"
					});
				}
			}

			return results;
		}
Example #30
0
        public Dwarf(dfproto.BasicUnitInfo unit)
        {
            m_unit = unit;
            m_labors = new HashSet<DwarfLabor>(unit.LaborsList.Select(id => GameData.GetLabor(id)));
            m_skills = unit.SkillsList.ToDictionary(s => GameData.GetSkill(s.Id));
            m_profession = new Lazy<DwarfProfession>(() => GameData.GetProfession(m_unit.Profession));

            m_unskilled_count = m_labors.Count(l => !l.HasSkill);

            // look for the migrant counter to identify new migrants
            var migrant_counter_trait = unit.MiscTraitsList.FirstOrDefault(t => t.Id == MISC_TRAIT_MIGRANT_COUNTER);
            if (migrant_counter_trait != null)
                m_migrant_counter = migrant_counter_trait.Value;

            m_labors_view = m_labors.Where(l => l.HasSkill).Select(l => new DwarfListItem(
                l.Skill.Profession.Image,
                this,
                l)).ToList();
            m_labors_potential_view = m_skills.Where(p => p.Key.HasLabor && !m_labors.Contains(p.Key.Labor)).Select(p => new DwarfListItem(
                p.Key.Profession.Image,
                this,
                p.Key.Labor)).ToList();
        }