private static List<int> GetMostCommonElementList(List<int> intsList)
        {
            intsList.Sort();
            List<int> listWithRemovedElements =new List<int>(intsList);
            int listCount = intsList.Count;
            int currentNumber = intsList[0];

            int occurance = 1;
            for (int i = 0; i <= listCount - 1; i++)
            {
                if (i == listCount - 1 && intsList[i] != intsList[i-1])
                {
                    currentNumber = intsList[i];
                    listWithRemovedElements.RemoveAll(x => x == currentNumber);
                }
                else if (intsList[i] == intsList[i + 1])
                {
                    occurance++;
                }
                else
                {
                    if (occurance % 2 != 0)
                    {
                        currentNumber = intsList[i];
                        listWithRemovedElements.RemoveAll(x => x == currentNumber);
                    }
                    occurance = 1;
                }
            }

            return listWithRemovedElements;
        }
        public override bool Parse(List<string> aAnswer)
        {
            if (!aAnswer.Contains(BASE_ERROR) && aAnswer.Contains("OK"))
            {
                aAnswer.RemoveAll(OKString);
                aAnswer.RemoveAll(this.ReadParamsClone);
                aAnswer.RemoveAll(String.IsNullOrEmpty);

                if (aAnswer.Count == 1)
                {
                    string[] zSplit = aAnswer[0].Split(new Char[] { ' ', ' ', ' ' });
                    if (zSplit.Count() == 3)
                    {
                        String zCleanSN = TrimValue(zSplit[2]);
                        SerialNumber = zCleanSN;
                        return true;
                    }
                    else
                    {
                        _logger.Debug("InCorrect Params Count: {0}", zSplit.Count());
                        return false;
                    }
                }
                else
                    return false;
            } else
                return false;
        }
Example #3
0
        private bool CorruptEntityAnimations_Func()
        {
            List<string> tocorrupt = new List<string>();

            if (!LoadXMLAndModify("./entities2.xml", delegate (XmlDocument XML)
            {
                tocorrupt.AddRange(from XmlNode n in XML.LastChild.ChildNodes select n.Attributes["anm2path"].Value);
            }))
            { return false; }

            tocorrupt.RemoveAll(x => x.Length == 0);
            tocorrupt.RemoveAll(x => x.Contains("Fireworks") == true);

            if (!tocorrupt.Select(corruptfile => "./gfx/" + corruptfile)
                .All(toopen => LoadXMLAndModify(toopen, delegate (XmlDocument XML)
                {
                    AnimCont A = new AnimCont();
                    foreach (XmlNode frame in XML.GetElementsByTagName("Frame"))
                    {
                        CorruptFrame(frame, A);
                    }
                })))
            { return false; }

            List<string> itemfiles = Safe.GetFiles("./gfx/characters");
            return itemfiles.All(file => LoadXMLAndModify(file, delegate (XmlDocument XML)
            {
                AnimCont A = new AnimCont();
                foreach (XmlNode frame in XML.GetElementsByTagName("Frame"))
                {
                    CorruptFrame(frame, A);
                }
            }));
        }
        private void PrepareProducts(List<Product> products)
        {
            products.RemoveAll(x => x.Name.Contains("*"));

            var coupon = products.FirstOrDefault(x => x.Name.Contains("$"));
            if (coupon != null)
            {
                for (var i = 0; i < coupon.Quantity; i++)
                {
                    var bread = products.First(x => x.Name.Contains("хляб") && !x.Name.Contains("$") && x.Quantity > 0 && x.SellingPrice > coupon.SellingPrice * -1);
                    bread.Quantity--;

                    var breadWithCouponName = bread.Name + " с купон";

                    var breadWithCoupon = products.FirstOrDefault(x => x.Name == breadWithCouponName);

                    if (breadWithCoupon != null)
                    {
                        breadWithCoupon.Quantity++;
                    }
                    else
                    {
                        breadWithCoupon = new Product { Name = breadWithCouponName, SellingPrice = bread.SellingPrice - coupon.SellingPrice * -1, Quantity = 1 };
                        products.Add(breadWithCoupon);
                    }
                }

                products.RemoveAll(x => x.Quantity == 0);
                products.RemoveAll(x => x.Name.Contains("$"));
            }
        }
Example #5
0
    static void Main(string[] args)
    {
        Console.Write("Show all prime numbers from 1 to ");
        int n = int.Parse(Console.ReadLine());
        List<int> numbers = new List<int>();
        numbers.Add(2); //adding 2 in the list
        for (int i = 0; i < n - 2; i += 2) //so it can show numbers from 3 to N and excluding all even numbers
        {
            numbers.Add(i + 3);
        }

        int range = (int)(Math.Sqrt(n)); //check for divisors up to the square root of N

        //first removing numbers divisible by 3, 5, 7, 11
        numbers.RemoveAll(item => item % 3 == 0 && item != 3);
        numbers.RemoveAll(item => item % 5 == 0 && item != 5);
        numbers.RemoveAll(item => item % 7 == 0 && item != 7);
        numbers.RemoveAll(item => item % 11 == 0 && item != 11);

        //then checking the rest divisiors with the help of the range
        for (int i = 13; i < range; i += 2)
        {
            numbers.RemoveAll(item => item % i == 0);
        }

        //printing numbers
        Console.WriteLine("The prime numbers from 1 to N are: ");
        Console.WriteLine(String.Join(", ", numbers));
    }
		protected void BuildFolderList() {
			List<FileData> lstFolders = new List<FileData>();

			string sRoot = Server.MapPath("~/");

			string[] subdirs;
			try {
				subdirs = Directory.GetDirectories(sRoot);
			} catch {
				subdirs = null;
			}

			if (subdirs != null) {
				foreach (string theDir in subdirs) {
					string w = FileDataHelper.MakeWebFolderPath(theDir);
					lstFolders.Add(new FileData { FileName = w, FolderPath = w, FileDate = DateTime.Now });
				}
			}

			lstFolders.RemoveAll(f => f.FileName.ToLower().StartsWith(SiteData.AdminFolderPath));
			lstFolders.RemoveAll(f => f.FileName.ToLower().StartsWith("/bin/"));
			lstFolders.RemoveAll(f => f.FileName.ToLower().StartsWith("/obj/"));
			lstFolders.RemoveAll(f => f.FileName.ToLower().StartsWith("/app_data/"));

			ddlFolders.DataSource = lstFolders.OrderBy(f => f.FileName);
			ddlFolders.DataBind();
		}
Example #7
0
        static void Main(string[] args)
        {
            string[] input = Console.ReadLine().Split('\\');

            List<char> left = input[0].ToCharArray().ToList();
            List<char> right = input[1].ToCharArray().ToList();
            string command = input[2];

            List<char> result = new List<char>();

            switch (command)
            {
                case "join":

                    foreach (char element in right)
                    {
                        result.AddRange(left.FindAll(c => c == element));
                    }

                    result.Sort();

                    Console.WriteLine(String.Join("", result.Distinct()));

                    break;

                case "right exclude":

                    result = left;

                    foreach (char element in right)
                    {
                        result.RemoveAll(c => c == element);
                    }

                    result.Sort();

                    Console.WriteLine(String.Join("", result.Distinct()));

                    break;

                case "left exclude":

                    result = right;

                    foreach (char element in left)
                    {
                        result.RemoveAll(c => c == element);
                    }

                    result.Sort();

                    Console.WriteLine(String.Join("", result.Distinct()));

                    break;

                default:
                    break;
            }
        }
Example #8
0
    public static void Main (string[] args) {
        var l = new List<string> {
            "A", "A", "B", "C", "D"
        };

        PrintItems(l);
        Console.WriteLine(l.RemoveAll((s) => s == "A"));
        PrintItems(l);
        Console.WriteLine(l.RemoveAll((s) => s == "Q"));
        PrintItems(l);
    }
 public static List<TfmRidPair> FilterForApplicableTFMRIDPairs(List<TfmRidPair> tfmRidPairs,
     string framework, string runtimeIdentifier)
 {
     if (framework != null)
     {
         tfmRidPairs.RemoveAll(x => !framework.Equals(x.framework));
     }
     if (runtimeIdentifier != null)
     {
         tfmRidPairs.RemoveAll(x => !runtimeIdentifier.Equals(x.runtimeIdentifier));
     }
     
     return tfmRidPairs;
 }
        void OnHierarchyChange()
        {
            emitters = new List<StudioEventEmitter>(Resources.FindObjectsOfTypeAll<StudioEventEmitter>());

            if (!levelScope)
            {
                emitters.RemoveAll(x => PrefabUtility.GetPrefabType(x) != PrefabType.Prefab);
            }

            if (!prefabScope)
            {
                emitters.RemoveAll(x => PrefabUtility.GetPrefabType(x) == PrefabType.Prefab);
            }            
        }
Example #11
0
        // Event handlers
        private void generate_btn_Click(object sender, EventArgs e)
        {
            status_bar.Value = 0;

            string password = "";

            List<char> choices = new List<char>();

            if(lower_box.Checked) {
                choices.AddRange(lower);
            }
            if(upper_box.Checked) {
                choices.AddRange(upper);
            }
            if(num_box.Checked) {
                choices.AddRange(numbers);
            }
            if(sym_box.Checked) {
                choices.AddRange(symbols);
            }
            if(include_text.Text.Length > 0) {
                choices.AddRange(include_text.Text.ToCharArray());
            }

            if(exclude_text.Text.Length > 0) {
                for(int i = 0; i < exclude_text.Text.Length; i++) {
                    choices.RemoveAll(item => item == exclude_text.Text[i]);
                }
            }

            char next;
            for(int i = 0; i < (int)passlength_select.Value; i++) {
                if(choices.Count > 0) {
                    next = choices[rand.Next(choices.Count)];
                } else {
                    next = ' ';
                }

                if(repeat_box.Checked) {
                    choices.RemoveAll(item => item == next);
                }

                password += next;
            }

            status_bar.Value = 100;
            pass_text.Text = password;
        }
Example #12
0
        public static List<string> ReadFile(string filename)
        {
            List<string> listFileContent = new List<string>();

            StringBuilder stringBuilder = new StringBuilder();
            using (FileStream fileStream = new FileStream(filename, FileMode.Open, FileAccess.Read))
            {
                using (StreamReader streamReader = new StreamReader(fileStream))
                {
                    char[] fileContents = new char[_bufferSize];
                    int charsRead = streamReader.Read(fileContents, 0, _bufferSize);

                    // Can't do much with 0 bytes
                    //if (charsRead == 0)
                    //    throw new Exception("File is 0 bytes");

                    while (charsRead > 0)
                    {
                        stringBuilder.Append(fileContents);
                        charsRead = streamReader.Read(fileContents, 0, _bufferSize);
                    }

                    string[] contentArray = stringBuilder.ToString().Split(new char[] { '\r', '\n' });
                    foreach (string line in contentArray)
                    {
                        listFileContent.Add(line.Replace("#", ""));
                    }
                    listFileContent.RemoveAll(s => string.IsNullOrEmpty(s));
                }
            }
            return listFileContent;
        }
Example #13
0
        public NanoHttpResponse Handle(NanoHttpRequest request)
        {
            try
            {
                var places = new List<string>(File.ReadAllLines(Strings.Places));
                var place = request.Address.Substring(5);

                bool found = false;

                if (places.Contains(place))
                {
                    found = true;
                    places.RemoveAll(s => s == place);
                }

                File.WriteAllLines(Strings.Places, places.ToArray());
                return new NanoHttpResponse(StatusCode.Ok, (found?"Deleted ":"Not found ") + place);
            }

            catch (Exception e)
            {
                NotificationHandler.Instance.AddNotification("Не удалось обновить places.txt");
                return new ErrorHandler(StatusCode.InternalServerError, e.ToString()).Handle(request);
            }
        }
Example #14
0
 private static List<int> Simp(int i)
 {
     List<int> list;
     if (max_num >= i)
     {
         list = new List<int>(good_num);
         list.RemoveAll(EndS);
     }
     else
     {
         list = new List<int>(good_num);
         for (int j = 1; j < i - max_num + 1; j++)
         {
             if (IsSimp(max_num + j))
             {
                 list.Add(max_num + j);
             }
         }
     }
     /*list = new List<int>();
     for (int j = 1; j < i + 1; j++)
     {
         if (IsSimp(j))
         {
             Thread.Sleep(2);
             list.Add(j);
         }
     }*/
     return list;
 }
Example #15
0
        protected override void OnGetValue(PropertySpecEventArgs e)
        {
            base.OnGetValue(e);

            var attributeList = new List<Attribute>();
            attributeList.AddRange(e.Property.Attributes.ToList());

            //check all of the attributes: if we find a dynamic one, evaluate it and possibly add/overwrite a static attribute
            foreach (Attribute customAttribute in e.Property.Attributes)
            {
                if (customAttribute is DynamicReadOnlyAttribute)
                {
                    attributeList.RemoveAll(x => x is ReadOnlyAttribute);

                    if (DynamicReadOnlyAttribute.IsDynamicReadOnly(propertyObject, e.Property.Name))
                    {
                        //condition is true: the dynamic attribute should be applied (as static attribute)
                        attributeList.Add(new ReadOnlyAttribute(true)); //add static read only attribute
                    }
                }
            }
            
            e.Property.Attributes = attributeList.ToArray();

            var propertyInfo = propertyObject.GetType().GetProperty(e.Property.Name);
            var value = propertyInfo.GetValue(propertyObject, null);

            var isNestedPropertiesObject = IsNestedExpandablePropertiesObject(propertyInfo);

            // if nested properties object, wrap in DynamicPropertyBag to provide support for things like DynamicReadOnly
            e.Value = isNestedPropertiesObject ? new DynamicPropertyBag(value) : value;
        }
        public DataListTO(string dataList, bool ignoreColumnDirection = false)
        {
            var fixedDataList = dataList.Replace(GlobalConstants.SerializableResourceQuote, "\"").Replace(GlobalConstants.SerializableResourceSingleQuote, "\'");
            Inputs = new List<string>();
            Outputs = new List<string>();
            using (var stringReader = new StringReader(fixedDataList))
            {
                var xDoc = XDocument.Load(stringReader);

                var rootEl = xDoc.Element("DataList");

                if (rootEl != null)
                {
                    if (ignoreColumnDirection)
                    {
                        Map(rootEl);
                    }
                    else
                    {
                        MapForInputOutput(rootEl);
                    }
                }
            }
            Inputs.RemoveAll(string.IsNullOrEmpty);
            Outputs.RemoveAll(string.IsNullOrEmpty);
        }
        static void Main(string[] args)
        {
            List<int> someSequence = new List<int>() { 4, 2, 2, 5, 2, 3, 2, 3, 1, 5, 2 };
            HashSet<int> someHashSet = new HashSet<int>();

            for (int i = 0; i < someSequence.Count; i++)
            {
                someHashSet.Add(someSequence[i]);
            }

            foreach (var number in someHashSet)
            {
                int counterForMatches = 0;
                for (int i = 0; i < someSequence.Count; i++)
                {
                    if (someSequence[i] == number)
                    {
                        counterForMatches++;
                    }
                }

                if (counterForMatches % 2 == 1)
                {
                    someSequence.RemoveAll(item => item == number);
                }
            }

            foreach (var number in someSequence)
            {
                Console.WriteLine(number);
            }
        }
Example #18
0
        public MyDayViewModel(
            [Import] IEventAggregator aggregator,
            [Import] ITasksService tasksService,
            [Import] IProjectsService projectsService,
            [Import] ITeamService teamService,
            [Import] IBackgroundExecutor executor,
            [Import] IAuthorizationService authorizator)
            : base(aggregator, tasksService, projectsService, teamService, executor, authorizator)
        {
            aggregator.Subscribe<MemberProfile>(ScrumFactoryEvent.SignedMemberChanged, OnSignedMemberChanged);

            aggregator.Subscribe<Task>(ScrumFactoryEvent.TaskAdded, t => { UpdateTasks(); });
            aggregator.Subscribe<Task>(ScrumFactoryEvent.TaskAssigneeChanged, t => { UpdateTasks(); });
            aggregator.Subscribe<Task>(ScrumFactoryEvent.TaskChanged, t => { UpdateTasks(); });

            aggregator.Subscribe<ICollection<ProjectInfo>>(ScrumFactoryEvent.RecentProjectChanged, prjs => {
                List<ProjectInfo> prjs2 = new List<ProjectInfo>(prjs);
                if (MemberEngagedProjects != null)
                    prjs2.RemoveAll(p => MemberEngagedProjects.Any(ep => ep.ProjectUId == p.ProjectUId));
                RecentProjects = prjs2.Take(8).ToList();
                OnPropertyChanged("RecentProjects");
            });

            OnLoadCommand = new DelegateCommand(OnLoad);
            RefreshCommand = new DelegateCommand(Load);
            ShowMemberDetailCommand = new DelegateCommand<MemberProfile>(ShowMemberDetail);
            CreateNewProjectCommand = new DelegateCommand(CreateNewProject);

            eventsViewSource = new System.Windows.Data.CollectionViewSource();
        }
        public static void Main()
        {
            var inputIntList = new List<int>() { 4, 2, 2, 5, 2, 3, 2, 3, 1, 5, 2 };
            var dictionary = new Dictionary<int, int>();

            for (int i = 0; i < inputIntList.Count; i++)
            {
                if (dictionary.ContainsKey(inputIntList[i]))
                {
                    dictionary[inputIntList[i]]++;
                }
                else
                {
                    dictionary.Add(inputIntList[i], 1); 
                }
            }

            foreach (var item in dictionary)
            {
                if (item.Value % 2 != 0)
                {
                    inputIntList.RemoveAll(x => x == item.Key);
                }
            }

            Console.WriteLine(string.Join(", ", inputIntList));
        }
Example #20
0
        internal void Execute(IDbConnection connection, IDbTransaction transaction, MigrationDirection direction, IDbCommandExecutor commandExecutor)
        {
            Debug.Assert(connection.State == ConnectionState.Open);

            var context = new RuntimeContext(connection, transaction, commandExecutor, _providerMetadata);
            Database database = GetDatabaseContainingMigrationChanges(direction, context);
            var translator = new CommandsToSqlTranslator(_provider);
            foreach (string commandText in translator.TranslateToSql(database, context))
            {
                //MigSharp uses ADO, not SMO to run SQL. ADO does not support the 'GO' statement in SQL as it is not TSQL.
                //We split SQL on 'GO' and run as individual statements
                var separatedByGoStatements = new List<string>(goStatementRegex.Split(commandText));
                separatedByGoStatements.RemoveAll(r => String.IsNullOrEmpty(r.Trim()));

                foreach (var statement in separatedByGoStatements)
                {
                    IDbCommand command = connection.CreateCommand();
                    command.CommandTimeout = 0; // do not timeout; the client is responsible for not causing lock-outs
                    command.Transaction = transaction;
                    command.CommandText = statement;
                    try
                    {
                        commandExecutor.ExecuteNonQuery(command);
                    }
                    catch (DbException x)
                    {
                        Log.Error("An error occurred: {0}{1}while trying to execute:{1}{2}", x.Message, Environment.NewLine, command.CommandText);
                        throw;
                    }
                }
            }
        }
        public IList<PatternStart> RandomizeColoring()
        {
            //original color
            Dictionary<PatternStart, IList<Color>> startToColor = new Dictionary<PatternStart, IList<Color>>();
            //keep track of the active patterns. Will contain new color
            List<PatternStart> active = new List<PatternStart>();

            foreach (var start in _patternStarts)
            {
                IList<Color> colors = EffectsToColors(start.SampleEffect.ColorEffects);
                startToColor[start] = colors;
                OrderedSet<Color> distinct = new OrderedSet<Color>();
                distinct.AddAll(colors);
                IDictionary<Color, Color> oldToNew = OldToNew(startToColor, active);
                Color randBase = distinct.FirstOrDefault(oldToNew.ContainsKey);
                IList<Color> newColors = randBase == default(Color)
                                            ? ColorPicker.PickColors(distinct.Count)
                                            : ColorPicker.PickColors(randBase, distinct.Count);
                IEnumerator<Color> newEnum = newColors.GetEnumerator();
                IEnumerator<Color> oldEnum = distinct.GetEnumerator();
                while(oldEnum.MoveNext())
                {
                    newEnum.MoveNext();
                    if (!oldToNew.ContainsKey(oldEnum.Current))
                    {
                        oldToNew[oldEnum.Current] = newEnum.Current;
                    }
                }
                start.ApplyColors(colors.Select(c=>oldToNew[c]).ToList());
                active.RemoveAll(s => s.EndTime <= start.StartTime);
                active.Add(start);
            }
            return _patternStarts;
        }
Example #22
0
        static void Main()
        {
            int number = int.Parse(Console.ReadLine());
            var list = new List<int>();
            IEnumerable<int> list2 = Enumerable.Range(2, number-1);
            list = list2.ToList();

            int p=2;
            while (p<=number)
            {
                for (int i = 2*(p-1);i < list.Count;i=i+p )
                {
                        list[i] = -1;
                }
                p++;
            }

            list.RemoveAll(item => item == -1);

            for (int i = 0; i < list.Count - 1; i++)
            {
                Console.Write(list[i] + ", ");
            }
                Console.Write(list[list.Count - 1]);
        }
Example #23
0
        static void Main()
        {
            Console.WriteLine("Please, enter a sequence of integers, separated by space:");
            var input = Console.ReadLine();
            var inputSplited = input.Split(new string[] {" "}, StringSplitOptions.RemoveEmptyEntries);
            int[] inputInts = Array.ConvertAll(inputSplited, int.Parse);
            var sequence = new List<int>();
            sequence.AddRange(inputInts);
            var countOccurencies = 0;

            int currentInt;

            for (int i = 0; i < sequence.Count; i++)
            {
                currentInt = sequence[i];

                //-------------------- using simple algorythm -------------
                for (int j = 0; j < sequence.Count; j++)
                {
                    if (sequence[i] == sequence[j])
                    {
                        countOccurencies++;
                    }
                }

                if (countOccurencies % 2 != 0)
                {
                    sequence.RemoveAll(x => x == currentInt);
                    i = i - 1;
                }
                countOccurencies = 0;

                //-------------- OR using the 10 times faster (for large data) algorythm below:----------
                //countOccurencies = 1;
                //var countedInts = new List<int>();
                //
                //if (!countedInts.Exists(x => x == currentInt))
                //{
                //    for (int j = i + 1; j < sequence.Count; j++)
                //    {
                //        if (sequence[i] == sequence[j])
                //        {
                //            countOccurencies++;
                //        }
                //    }
                //
                //    if (countOccurencies%2 != 0)
                //    {
                //        sequence.RemoveAll(x => x == currentInt);
                //        i = i - 1;
                //    }
                //    else
                //    {
                //        countedInts.Add(currentInt);
                //    }
                //    countOccurencies = 1;
                //}
            }
            Console.WriteLine(string.Join(" ", sequence.ToArray()));
        }
        protected void RemoveStaffWithNoPendingApprovals(List<Staff> staffList)
        {
            if (!string.IsNullOrEmpty(GetPreselectedUsername(Page)))
            {
                chkHide.Visible = false;
                return;
            }

            if (chkHide.Checked)
            {
                staffList.RemoveAll(delegate(Staff staff)
                {
                    bool hasPending = false;
                    const int stage = 1; // submitted by staff but awaiting approval by supervisor
                    if (BookingMode == eBookingMode.Book)
                    {
                        List<BookedEvent> events = BookedEvent.GetAll(staff.Username, stage);
                        hasPending = events.Count > 0;
                    }
                    else
                    {
                        const string suggestedEventQueryKey = "SE";
                        bool isAdHoc = Page.Request.QueryString[suggestedEventQueryKey] == null;
                        List<PrebookedEvent> events = PrebookedEvent.GetAll(staff.Username, stage, isAdHoc);
                        hasPending = events.Count > 0;
                    }
                    return !hasPending;
                });
            }
        }
    static List<int> CheckingEquals(List<int> numbers)
    {
        List<int> temp = new List<int>();
        for (int i = 0; i < numbers.Count; i++)
        {
            temp.Add(numbers[i]);
        }

        List<int> longestSequ = new List<int>();
        while (temp.Count > 0)
        {
            List<int> currentSequ = new List<int>();
            for (int col = 0; col < temp.Count; col++)
            {
                if (temp[0] == temp[col])
                {
                    currentSequ.Add(temp[col]);
                }
            }
            temp.RemoveAll(i => i == currentSequ[0]);
            if (currentSequ.Count > longestSequ.Count)
            {
                longestSequ = currentSequ;
            }
        }
        return longestSequ;
    }
Example #26
0
    /* Task 6: 
     * Write a program that removes from given sequence all numbers that occur odd number of times. Example:
     * {4, 2, 2, 5, 2, 3, 2, 3, 1, 5, 2}  {5, 3, 3, 5}
     */

    static void Main(string[] args)
    {
        var numbers = new List<int> { 4, 2, 2, 5, 2, 3, 2, 3, 1, 5, 2 };
        var uniqueNumbers = new Dictionary<Int32, Int32>();

        for (int i = 0; i < numbers.Count; i++)
        {
            if (uniqueNumbers.ContainsKey(numbers[i]))
            {
                uniqueNumbers[numbers[i]]++;
            }
            else
            {
                uniqueNumbers.Add(numbers[i], 1);
            }
        }

        foreach (var uniqueNumber in uniqueNumbers)
        {
            if (uniqueNumber.Value % 2 != 0)
            {
                numbers.RemoveAll(x => x == uniqueNumber.Key);
            }
        }

        foreach (var number in numbers)
        {
            Console.Write("{0} ", number);
        }
    }
Example #27
0
        public List<ICheckStrategy> getSolutions()
        {
            List<ICheckStrategy> lijst = new List<ICheckStrategy>();            
            lijst.Add(vermenigvuldigen_door_halveren.ReturnStrat());
            lijst.Add(vermenigvuldigen_kolomsgewijs.ReturnStrat());
            lijst.Add(vermenigvuldigen_met_1x_meer.ReturnStrat());
            lijst.Add(vermenigvuldigen_met_1x_minder.ReturnStrat());
            lijst.Add(vermenigvuldigen_met_1x_minder_10.ReturnStrat());
            lijst.Add(vermenigvuldigen_met_de_helft_van_10x.ReturnStrat());
            lijst.Add(vermenigvuldigen_met_een_handig_getal.ReturnStrat());
            lijst.Add(vermenigvuldigen_met_omkeringsprincipe.ReturnStrat());
            lijst.Add(vermenigvuldigen_naar_analogie_met_nullen.ReturnStrat());
            lijst.Add(vermenigvuldigen_met_rond_getal.ReturnStrat());
            lijst.Add(vermenigvulidgen_door_te_verdubbelen.ReturnStrat());
            lijst.Add(vermenigvulidgen_met_sprongen_op_de_getallenlijn.ReturnStrat());
            lijst.Add(vermenigvulidgen_met_oppervlaktemodel.ReturnStrat());
            lijst.Add(cijferend.ReturnStrat());

            lijst.RemoveAll(item => item == null);

            for (int i = 0; i < lijst.Count; i++)
            {
                //Console.WriteLine(lijst[i].ReturnImportance());
            }

            return data.GetStratsToDisplay(lijst, 4);
        }
Example #28
0
        protected override void OnLoad(EventArgs e)
        {
            var app_list = new List<App>(from x in DataContainer.Instance().Applications
                                         where x.Preferences.Contains(CurrentCourse.BannerName)
                                         select x);

            // now sort according to preferences
            {
                var tmpList = new List<App>();
                foreach (var x in (CurrentCourse.HiringPreferences ?? "").Split(','))
                {
                    tmpList.AddRange(app_list.Where(a => a.User.Equals(x, StringComparison.OrdinalIgnoreCase)));
                    app_list.RemoveAll(a => a.User == x);
                }
                tmpList.AddRange(app_list);
                app_list = tmpList;
            }

            appgrid.DataSource = app_list;
            appgrid.DataBind();

            prefs_body.DataSource = (from x in app_list
                                     select x.User);
            prefs_body.DataBind();
        }
        public void ReplaceInFiles(string rootDir, string include,string exclude,IDictionary<string,string>replacements,StringBuilder logger = null)
        {
            if (string.IsNullOrEmpty(rootDir)) { throw new ArgumentNullException("rootDir"); }
            if (!Directory.Exists(rootDir)) { throw new ArgumentException(string.Format("rootDir doesn't exist at [{0}]", rootDir)); }

            string rootDirFullPath = Path.GetFullPath(rootDir);

            // search for all include files
            List<string> pathsToInclude = new List<string>();
            List<string> pathsToExclude = new List<string>();

            if (!string.IsNullOrEmpty(include)) {
                string[] includeParts = include.Split(';');
                foreach (string includeStr in includeParts) {
                    var results = RobustReplacer.Search(rootDirFullPath, includeStr);
                    foreach (var result in results) {
                        if (!pathsToInclude.Contains(result)) {
                            pathsToInclude.Add(result);
                        }
                    }
                }
            }

            if (!string.IsNullOrEmpty(exclude)) {
                string[] excludeParts = exclude.Split(';');
                foreach (string excludeStr in excludeParts) {
                    var results = RobustReplacer.Search(rootDirFullPath, excludeStr);
                    foreach (var result in results) {
                        if (!pathsToExclude.Contains(result)) {
                            pathsToExclude.Add(result);
                        }
                    }
                }
            }

            int numFilesExcluded = pathsToInclude.RemoveAll(p => pathsToExclude.Contains(p));
            LogMessageLine(logger,"Number of files excluded based on pattern: [{0}]", numFilesExcluded);

            foreach (string file in pathsToInclude) {
                string fileFullPath = Path.GetFullPath(file);
                bool modified = false;

                using (var fileStream = File.Open(fileFullPath, FileMode.Open, FileAccess.ReadWrite)) {
                    using (var replacer = new TokenReplacer(fileStream)) {
                        foreach (string key in replacements.Keys) {
                            modified |= replacer.Replace(key, replacements[key]);
                        }
                    }

                    fileStream.Flush();
                }

                if (modified) {
                    LogMessageLine(logger,"Updating text after replacements in file [{0}]", fileFullPath);
                }
                else {
                    LogMessageLine(logger,"Not writing out file because no replacments detected [{0}]", fileFullPath);
                }
            }
        }
 private List<IPlugin> GetLoadingSequence()
 {
     int num = 0;
     List<IPlugin> tmp;
     List<IPlugin> list = new List<IPlugin>(plugins);
     List<IPlugin> ret = new List<IPlugin>(list.FindAll(p => !p.Info.HasPreconditions));
     list.RemoveAll(p => ret.Contains(p));
     for (int precount = 1; list.Count > 0; precount = num)
     {
         tmp = list.FindAll(p => p.Info.Preconditions.Count == precount);
         ret.AddRange(tmp);
         list.RemoveAll(p => tmp.Contains(p));
         num = precount + 1;
     }
     return ret;
 }