public int ModifLikeProduit(List<string> aData)
 {
     DataSet DsJson = new DataSet();
     MyCo NewCo = new MyCo();
     NewCo.UpdateLikeProduit(aData.IndexOf(aData.Last()).ToString(),aData.Last(),ref DsJson);
     return aData.IndexOf(aData.Last());
 }
Example #2
0
 public static long Jump(Dictionary<int, List<int>> cluspos, long currentpos, List<int> peaks, int[] peakclus, ref int nextvalue, ref int currentposs)
 {
     long startpos = currentpos / 2;
     int pos = (int)startpos / 512;
     if (nextvalue < peaks[currentposs])
         nextvalue = peaks[currentposs];
     if(nextvalue - pos > 0)
     {
         if(nextvalue - pos < 50)//pretty close
         {
             pos = nextvalue;
         }
     }
     else
     {
         currentposs++;
     }
     int index = peaks.IndexOf(pos);
     
     if (index != -1)
     {
         index = peakclus[index];
         Random r = new Random();
         if (r.Next(0, 100) > 25)//25% jump
         {
             int random = r.Next(0, cluspos[index].Count);
             int loc = cluspos[index][random];
             currentposs = peaks.IndexOf(loc);
             return (long)(loc * 512 * 2);
         }
     }
     return currentpos;
 }
        public static List<Scraper> GetScrapers(bool allowIgnored = false)
        {
            loadScrapers();

            List<string> scraperPriorities = new List<string>(EmulatorsCore.Options.ReadOption(o => o.ScraperPriorities).Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries));
            List<string> ignoredScraperIds = new List<string>();
            if (!allowIgnored)
            {
                ignoredScraperIds.AddRange(EmulatorsCore.Options.ReadOption(o => o.IgnoredScrapers).Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries));
            }

            List<Scraper> scrapers = new List<Scraper>();
            foreach (Scraper scraper in allScrapers)
            {
                if (allowIgnored || !ignoredScraperIds.Contains(scraper.IdString))
                {
                    if (!scraperPriorities.Contains(scraper.IdString))
                        scraperPriorities.Add(scraper.IdString);
                    scrapers.Add(scraper);
                }
            }

            scrapers.Sort((Scraper s, Scraper t) =>
            {
                return scraperPriorities.IndexOf(s.IdString).CompareTo(scraperPriorities.IndexOf(t.IdString));
            });
            return scrapers;
        }
Example #4
0
        public bool IsValid(string s)
        {
            List<char> lefts = new List<char>() { '(', '[', '{' };
            List<char> rights = new List<char>() { ')', ']', '}' };

            Stack<char> charStack = new Stack<char>();
            foreach (char c in s)
            {

                if (lefts.IndexOf(c) > -1)
                {
                    charStack.Push(c);
                }
                else
                {
                    if (charStack.Count == 0)
                    {
                        return false;
                    }
                    char pop = charStack.Pop();
                    if (lefts.IndexOf(pop) == rights.IndexOf(c))
                    {
                        continue;
                    }
                    return false;
                }
            }
            if (charStack.Count != 0) return false;

            return true;
        }
    public List<float> AssignWidthToPoints(List<Vertex> path, float minWidth)
    {
        List<float> sumOfPointNeighb = new List<float>();
        float totalSum = 0;
        float maxSum = 0;
        foreach (Vertex v in path)
        {
            sumOfPointNeighb.Add(ftm.GetSumFromNeighbourhood(v.x, v.z, 2 * (int)minWidth));
            totalSum += sumOfPointNeighb[path.IndexOf(v)];
            if(sumOfPointNeighb[path.IndexOf(v)] > maxSum){
                maxSum = sumOfPointNeighb[path.IndexOf(v)];
            }
        }
        float averageSum = totalSum / sumOfPointNeighb.Count;

        List<float> finalWidthValues = new List<float>();
        //Debug.Log("-------------");
        foreach (float f in sumOfPointNeighb)
        {
            float value = minWidth + minWidth/2 * (maxSum - f) / maxSum;
            finalWidthValues.Add(value);
            //Debug.Log(value);
            //finalWidthValues.Add(minWidth);
        }

        return finalWidthValues;
    }
Example #6
0
    public static void Main()
    {
        List <int> ll = new List<int>();
        string t1;
        int idx1;
        int idx2;
        int ent1;
        int ent2;

        for(int i = 1; i <= 10; i++) {
            ll.Add(i);
        }
        foreach(int i in ll)
            Console.Write("{0} ", i);
        Console.WriteLine();
        while(true) {
            t1 = Console.ReadLine();
            if(t1 == "-999")
                break;
            string[] t2 = t1.Split(' ');
            ent1 = Convert.ToInt32(t2[0]);
            ent2 = Convert.ToInt32(t2[1]);
            idx1 = ll.IndexOf(ent1);
            idx2 = ll.IndexOf(ent2);
            ll.RemoveAt(idx1);
            ll.Insert(idx1, ent2);
            ll.RemoveAt(idx2);
            ll.Insert(idx2, ent1);
            foreach(int i in ll)
                Console.Write("{0} ", i);
            Console.WriteLine();
        }
    }
Example #7
0
        //Plays an animation from a given list of Texture2D's
        public void Animate(List<Texture2D> textures, float time, float animationRate)
        {
            //Keep track of the elapsed time
            if (animationTime == null)
            {
                animationTime = time;
            }
            else
            {
                animationTime += time;
            }

            //The given animation rate determines when we switch to the next texture in the list
            if (animationTime > animationRate / textures.Count)
            {
                //Switch to the next texture in the list, or the first texture if we're at the end.
                if (textures.IndexOf(texture) < textures.Count - 1)
                {
                    texture = textures[textures.IndexOf(texture) + 1];
                }
                else
                {
                    texture = textures[0];
                }

                //Reset the elapsed time
                animationTime = 0;
            }
        }
Example #8
0
        public static List<Notices> GetAllNotices(string link)
        {
            string htmlPage = "";
            List<string> NoticeTitles = new List<string>();
            List<string> NoticeDates = new List<string>();
            List<string> NoticeUrl = new List<string>();

            List<Notices> Notices = new List<Notices>();

            using(var client = new WebClient())
            {
                Uri weblink = new Uri(link, UriKind.Absolute);
                htmlPage = client.DownloadString(weblink);
            }

            NoticeTitles = PatternHelper.GetNoticeTitle(htmlPage);
            NoticeDates = PatternHelper.GetNoticeDate(htmlPage);
            NoticeUrl = PatternHelper.GetNoticeLink(htmlPage);

            foreach(var item in NoticeTitles)
            {
                Notices.Add(new Notices {
                    Title = item,
                    Date = NoticeDates[NoticeTitles.IndexOf(item)],
                    Url = NoticeUrl[NoticeTitles.IndexOf(item)]
                });
            }

            return Notices;
        }
Example #9
0
        internal static List<Block> CheckPostImport(List<Block> ret)
        {
            if (ret == null) return null;

            var lastImport = ret.LastOrDefault(r => r is Model.Import);
            var firstNonImport = ret.FirstOrDefault(r => !(r is Model.Import));

            if (lastImport == null || firstNonImport == null)
            {
                return ret;
            }

            var lix = ret.IndexOf(lastImport);
            var fnix = ret.IndexOf(firstNonImport);

            if (lix != -1 && fnix != -1)
            {
                if (fnix < lix)
                {
                    for (int i = fnix; i < ret.Count; i++)
                    {
                        if (ret[i] is Model.Import)
                        {
                            Current.RecordWarning(ErrorType.Parser, ret[i], "@import should appear before any other statements.  Statement will be moved.");
                        }
                    }
                }
            }

            return ret;
        }
Example #10
0
        static void Main()
        {
            Console.WriteLine("Enter some text to see how many times each word appears:");
            string text = Console.ReadLine();
            string[] textSplitted = text.Split(',', ' ');

            List<string> words = new List<string>();
            List<int> counter = new List<int>();

            for (int i = 0; i < textSplitted.Length; i++)
            {
                string currentWord = textSplitted[i];
                if (currentWord != "")
                {
                    if (words.IndexOf(currentWord) == -1)
                    {
                        words.Add(currentWord);
                        counter.Add(1);
                    }
                    else
                    {
                        int index = words.IndexOf(currentWord);
                        counter[index]++;
                    }
                }
            }

            Console.WriteLine("Letters : Appearances");
            for (int i = 0; i < words.Count; i++)
            {
                Console.WriteLine("{0} - {1}", words[i], counter[i]);
            }
        }
Example #11
0
        static void Main()
        {
            Console.WriteLine("Enter some text to see how many times each letter appears:");
            string text = Console.ReadLine();

            List<char> letters = new List<char>();
            List<int> counter = new List<int>();

            for (int i = 0; i < text.Length; i++)
            {
                char currentLetter = text[i];
                if (currentLetter != ' ')
                {
                    if (letters.IndexOf(currentLetter) == -1)
                    {
                        letters.Add(currentLetter);
                        counter.Add(1);
                    }
                    else
                    {
                        int index = letters.IndexOf(currentLetter);
                        counter[index]++;
                    }
                }
            }

            Console.WriteLine("Letters : Appearances");
            for (int i = 0; i < letters.Count; i++)
            {
                Console.WriteLine("{0} - {1}", letters[i], counter[i]);
            }
        }
    static void Main()
    {
        string number = Console.ReadLine();

        List<string> digits = new List<string>();

        for (char i = 'A'; i <= 'Z'; i++)
            digits.Add(i.ToString());

        for (char i = 'a'; i <= 'f'; i++)
            for (char j = 'A'; j <= 'Z'; j++)
                digits.Add(i.ToString() + j.ToString());

        if (number.Length == 1)
        {
            Console.WriteLine(digits.IndexOf(number[0].ToString()));
            return;
        }

        long result = 0, pow = 0;

        for (int i = number.Length - 1; i >= 0; i--)
        {
            // Example with number aFG...

            string left = number[i - 1].ToString(); // Found: F
            string right = number[i].ToString(); // Found: G

            if (i - 2 >= 0 && char.IsLower(number[i - 2])) // Check: aFG
            {
                left = number[i - 2] + "" + number[i - 1]; // Correct numbers: aF and G
                i--;
            }

            int index = digits.IndexOf(left + right); // Finds only numbers from type aF, bG, pL, etc...

            if (index != -1)
            {
                // Found one number
                result += index * (long)Math.Pow(168, pow++);
            }
            else
            {
                // There are two numbers, example: FG => calculates its values
                result += digits.IndexOf(right) * (long)Math.Pow(168, pow++) +
                          digits.IndexOf(left) * (long)Math.Pow(168, pow++);
            }

            i--;

            if (i - 1 == 0)
            {
                // Only one number left
                result += digits.IndexOf(number[0].ToString()) * (long)Math.Pow(168, pow);
                break;
            }
        }

        Console.WriteLine(result);
    }
Example #13
0
        public EditCustomerInformationModel(Customer customer, IEnumerable<Country> countries)
        {
            Firstname = customer.Firstname;
            Lastname = customer.Lastname;
            Email = customer.Email;
            //Birthday = customer.Birthday ?? DateTime.MinValue;
            SelectedGenderType = (int) customer.Gender;

            AvailableCountries = countries.Select(x => new SelectListItem { Selected = x.Name.Trim() == customer.Country.Trim(), Text = x.Name.Trim(), Value = x.Name.Trim() }).ToList();
            AvailableCountries.Insert(0, new SelectListItem { Selected = false, Text = "I'd rather not say", Value = string.Empty });

            Genders = new List<SelectListItem>();
            Genders.Add(new SelectListItem { Selected = false, Text = "I'd rather not say", Value = "0" });
            Genders.Add(new SelectListItem { Selected = false, Text = GenderTypeEnum.Male.ToString(), Value = ((int)GenderTypeEnum.Male).ToString() });
            Genders.Add(new SelectListItem { Selected = false, Text = GenderTypeEnum.Female.ToString(), Value = ((int)GenderTypeEnum.Female).ToString() });

            SelectedBirthDate = (customer.Birthday.HasValue) ? customer.Birthday.Value.Day : 0;
            SelectedBirthMonth = (customer.Birthday.HasValue) ? customer.Birthday.Value.Month : 0;
            SelectedBirthYear = (customer.Birthday.HasValue) ? customer.Birthday.Value.Year : 1970;

            BirthDate = new List<SelectListItem>{ new SelectListItem { Selected = false, Text = "Day", Value = "0" } };
            BirthDate.AddRange(Enumerable.Range(1, 31).Select(x => new SelectListItem { Selected = x == SelectedBirthDate, Text = x.ToString(), Value = x.ToString() }).ToList());

            var months = new List<string> { "Month", "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December" };
            BirthMonth = new List<SelectListItem>();
            months.ForEach(x => BirthMonth.Add(new SelectListItem { Selected = months.IndexOf(x) == SelectedBirthMonth, Text = x, Value = months.IndexOf(x).ToString() }));
        }
Example #14
0
        public void HandleInput(List<Keys> input)
        {
            if (input.IndexOf(Keys.Left) > -1)
            {
                MoveLeftIfPossible();
            }

            if (input.IndexOf(Keys.Right) > -1)
            {
                MoveRightIfPossible();
            }

            if (input.IndexOf(Keys.PageDown) > -1)
            {
                field.RotateBlockRight();
            }

            if (input.IndexOf(Keys.PageUp) > -1)
            {
                field.RotateBlockLeft();
            }

            if (input.IndexOf(Keys.Space) > -1)
            {
                field.FixBlock();
            }
        }
        void Start()
        {
            if (instance != null)
                throw new Exception("Error: multiple LocationGraphs present");
            instance = this;

            locations = new List<Location>();

            Component[] components = this.gameObject.GetComponents(typeof(Edge));
            Edge[] edges = new Edge[components.Length];
            for (int i = 0; i < components.Length; i++) {
                edges[i] = (Edge) components[i];

                if (!locations.Contains(edges[i].one))
                    locations.Add(edges[i].one);
                if (!locations.Contains(edges[i].two))
                    locations.Add(edges[i].two);
            }

            graph = new bool[locations.Count, locations.Count];
            for (int i = 0; i < graph.GetLength(0); i++) {
                for (int j = 0; j < graph.GetLength(1); j++) {
                    graph[i,j] = inverse;
                }
            }

            foreach (Edge edge in edges) {
                int indexOne = locations.IndexOf(edge.one);
                int indexTwo = locations.IndexOf(edge.two);

                graph[indexOne, indexTwo] = !inverse;
                graph[indexTwo, indexOne] = !inverse;
            }
        }
Example #16
0
 static void ComputeDistinctStrands(string[] strands, ref int cDistinctStrands, ref string concatenatedDistinctStrands, ref int[] permuation)
     {
     List<string> distinct = new List<string>();
     foreach (string strand in strands)
         {
         if (distinct.IndexOf(strand) < 0)
             distinct.Add(strand);
         } 
     //
     StringBuilder builder = new StringBuilder();
     foreach (string s in distinct)
         {
         if (builder.Length > 0)
             builder.Append('+');
         builder.Append(s);
         }
     concatenatedDistinctStrands = builder.ToString();
     cDistinctStrands = distinct.Count;
     //
     permuation = new int[strands.Length];
     for (int i = 0; i < strands.Length; i++)
         {
         permuation[i] = distinct.IndexOf(strands[i]) + 1;
         }
     }
Example #17
0
        public void HandleInput(List<Keys> input)
        {
            if (input.IndexOf(Keys.Left) > -1)
            {
                MoveLeftIfPossible();
            }

            if (input.IndexOf(Keys.Right) > -1)
            {
                MoveRightIfPossible();
            }

            if (input.IndexOf(Keys.Space) > -1)
            {
                field.FixBlock();
            }
            if (input.IndexOf(Keys.A) > -1)
            {
                currentBlock.RotateLeft();
            }

            if (input.IndexOf(Keys.D) > -1)
            {
                currentBlock.RotateRight();
            }
        }
Example #18
0
        static void Main()
        {
            Console.WriteLine("Enter a word:");
            string word = Console.ReadLine();

            List<string> words = new List<string> {
                             ".NET",
                             "CLR",
                             "namespace"
                             };

            List<string> explanations = new List<string> {
                                    "platform for applications from Microsoft",
                                    "managed execution environment for .NET",
                                    "hierarchical organization of classes"
                                    };

            if (words.IndexOf(word) != -1)
            {
                Console.WriteLine("{0} - {1}", word, explanations[words.IndexOf(word)]);
            }
            else
            {
                Console.WriteLine("Sorry, but there is no description of this word!");
            }
        }
		public void Update(List<Hearthstone.Card> cards, bool reset)
		{
			try
			{
				if(reset)
				{
					_animatedCards.Clear();
					ItemsControl.Items.Clear();
				}
				var newCards = new List<Hearthstone.Card>();
				foreach(var card in cards)
				{
					var existing = _animatedCards.FirstOrDefault(x => AreEqualForList(x.Card, card));
					if(existing == null)
						newCards.Add(card);
					else if(existing.Card.Count != card.Count || existing.Card.HighlightInHand != card.HighlightInHand)
					{
						var highlight = existing.Card.Count != card.Count;
						existing.Card.Count = card.Count;
						existing.Card.HighlightInHand = card.HighlightInHand;
						existing.Update(highlight).Forget();
					}
					else if(existing.Card.IsCreated != card.IsCreated)
						existing.Update(false).Forget();
				}
				var toUpdate = new List<AnimatedCard>();
				foreach(var aCard in _animatedCards)
				{
					if(!cards.Any(x => AreEqualForList(x, aCard.Card)))
						toUpdate.Add(aCard);
				}
				var toRemove = new List<Tuple<AnimatedCard, bool>>();
				foreach(var card in toUpdate)
				{
					var newCard = newCards.FirstOrDefault(x => x.Id == card.Card.Id);
					toRemove.Add(new Tuple<AnimatedCard, bool>(card, newCard == null));
					if(newCard != null)
					{
						var newAnimated = new AnimatedCard(newCard);
						_animatedCards.Insert(_animatedCards.IndexOf(card), newAnimated);
						ItemsControl.Items.Insert(_animatedCards.IndexOf(card), newAnimated);
						newAnimated.Update(true).Forget();
						newCards.Remove(newCard);
					}
				}
				foreach(var card in toRemove)
					RemoveCard(card.Item1, card.Item2);
				foreach(var card in newCards)
				{
					var newCard = new AnimatedCard(card);
					_animatedCards.Insert(cards.IndexOf(card), newCard);
					ItemsControl.Items.Insert(cards.IndexOf(card), newCard);
					newCard.FadeIn(!reset).Forget();
				}
			}
			catch(Exception e)
			{
				Log.Error(e);
			}
		}
Example #20
0
		//We currently don't clean White Text, Small Text, Hidden Columns, Rows
		private List<ContentType> RemoveUnsupportedElements(List<ContentType> elementsToClean)
		{
			int index = elementsToClean.IndexOf(ContentType.WhiteText);
			if (index != -1)
			{
				elementsToClean.Remove(elementsToClean[index]);
			}

			index = elementsToClean.IndexOf(ContentType.SmallText);
			if (index != -1)
			{
				elementsToClean.Remove(elementsToClean[index]);
			}

			index = elementsToClean.IndexOf(ContentType.HiddenColumn);
			if (index != -1)
			{
				elementsToClean.Remove(elementsToClean[index]);
			}

			index = elementsToClean.IndexOf(ContentType.HiddenRow);
			if (index != -1)
			{
				elementsToClean.Remove(elementsToClean[index]);
			}

			index = elementsToClean.IndexOf(ContentType.HiddenSheet);
			if (index != -1)
			{
					elementsToClean.Remove(elementsToClean[index]);
			}

			return elementsToClean;
		}
Example #21
0
		List<byte> CreateInputBytes(List<byte> messageBytes)
		{
			var bytes = new List<byte>();
			var previousByte = new byte();
			messageBytes.RemoveRange(0, messageBytes.IndexOf(0x7E) + 1);
			messageBytes.RemoveRange(messageBytes.IndexOf(0x3E), messageBytes.Count - messageBytes.IndexOf(0x3E));
			foreach (var b in messageBytes)
			{
				if ((b == 0x7D) || (b == 0x3D))
				{ previousByte = b; continue; }
				if (previousByte == 0x7D)
				{
					previousByte = new byte();
					if (b == 0x5E)
					{ bytes.Add(0x7E); continue; }
					if (b == 0x5D)
					{ bytes.Add(0x7D); continue; }
				}
				if (previousByte == 0x3D)
				{
					previousByte = new byte();
					if (b == 0x1E)
					{ bytes.Add(0x3E); continue; }
					if (b == 0x1D)
					{ bytes.Add(0x3D); continue; }
				}
				bytes.Add(b);
			}
			return bytes;
		}
Example #22
0
        /// <summary>
        /// Tries to implement the Get [] semantics, but it cuts corners like crazy.
        /// Specifically, it relies on the knowledge that the only Gets used are
        /// keyed on PrincipalID, Email, and FirstName+LastName.
        /// </summary>
        /// <param name="fields"></param>
        /// <param name="values"></param>
        /// <returns></returns>
        public UserAccountData[] Get(string[] fields, string[] values)
        {
            List<string> fieldsLst = new List<string>(fields);
            if (fieldsLst.Contains("PrincipalID"))
            {
                int i = fieldsLst.IndexOf("PrincipalID");
                UUID id = UUID.Zero;
                if (UUID.TryParse(values[i], out id))
                    if (m_DataByUUID.ContainsKey(id))
                        return new UserAccountData[] { m_DataByUUID[id] };
            }
            if (fieldsLst.Contains("FirstName") && fieldsLst.Contains("LastName"))
            {
                int findex = fieldsLst.IndexOf("FirstName");
                int lindex = fieldsLst.IndexOf("LastName");
                if (m_DataByName.ContainsKey(values[findex] + " " + values[lindex]))
                    return new UserAccountData[] { m_DataByName[values[findex] + " " + values[lindex]] };
            }
            if (fieldsLst.Contains("Email"))
            {
                int i = fieldsLst.IndexOf("Email");
                if (m_DataByEmail.ContainsKey(values[i]))
                    return new UserAccountData[] { m_DataByEmail[values[i]] };
            }

            // Fail
            return new UserAccountData[0];
        }
Example #23
0
        public void HandleInput(List<Keys> input)
        {
            if (input.IndexOf(Keys.Left) > -1)
            {
                field.Move(Movement.Left);
            }

            if (input.IndexOf(Keys.Right) > -1)
            {
                field.Move(Movement.Right);
            }

            if (input.IndexOf(Keys.Space) > -1)
            {
                //field.FixBlock();
            }

            if (input.IndexOf(Keys.PageDown) > -1)
            {
                field.Move(Movement.RotateClockwise);
            }

            if (input.IndexOf(Keys.Delete) > -1)
            {
                field.Move(Movement.RotateCounterClockwise);
            }
        }
        //public PlayerSprite testRemotePlayer = new PlayerSprite();

        public GameContentManager(string localPlayer, List<string> allPlayers, BomberGame game)
        {
            Game = game;
            isGameEnded = false;
            Sprites = new List<Sprite>();
            RemotePlayers = new List<PlayerSprite>();
            LocalPlayer = new PlayerSprite();
            LocalPlayer.GameContentManager = this;
            LocalPlayer.PlayerID = localPlayer;
            int localPlayerNumber = allPlayers.IndexOf(localPlayer);
            LocalPlayer.PlayerIndex = localPlayerNumber;
            LocalPlayer.Controller = new PlayerController();
            LocalPlayer.Controller.Player = LocalPlayer;
            Sprites.Add(LocalPlayer);
            foreach (string s in allPlayers)
            {
                if (s != localPlayer)
                {
                    PlayerSprite player = new PlayerSprite();
                    player.GameContentManager = this;
                    player.PlayerID = s;
                    int playerNumber = allPlayers.IndexOf(s);
                    player.PlayerIndex = playerNumber;
                    Sprites.Add(player);
                    RemotePlayers.Add(player);
                }
            }
        }
Example #25
0
 public int ambiguous(string[] dictionary)
 {
     List<string> list = new List<string>();
     List<int> count = new List<int>();
     int res = 0;
     for (int a = 0; a < dictionary.Length; a++)
     {
         if (!list.Contains(dictionary[a]))
         {
             list.Add(dictionary[a]);
             count.Add(1);
         }
         else
             count[list.IndexOf(dictionary[a])]++;
         for (int b = 0; b < dictionary.Length; b++)
         {
             string temp = dictionary[a] + dictionary[b];
             if (a == b)
                 continue;
             if (!list.Contains(temp))
             {
                 list.Add(temp);
                 count.Add(1);
             }
             else
                 count[list.IndexOf(temp)]++;
         }
     }
     for (int c = 0; c < count.Count; c++)
     {
         if (count[c] > 1)
             res++;
     }
     return res;
 }
        static bool count(int currentSum, int targetSum, int amountNums, int currentNumber, int prevNumber, List<int> subSetSum0, List<int> set, bool isFristPass)
        {
            if (currentSum + currentNumber == targetSum)
            {
                set[set.IndexOf(currentNumber)] = 0;
                subSetSum0.Add(currentNumber);
                return true;
            }
            else
            {
                for (int i = amountNums; i > 0; i--)
                {
                    if (count(currentSum + currentNumber, targetSum, i - 1, set[i - 1], currentNumber, subSetSum0, set, false) == true)
                    {
                        try
                        {
                            set[set.IndexOf(currentNumber)] = 0;
                        }
                        catch (ArgumentOutOfRangeException)
                        {
                            return false;
                        }
                        subSetSum0.Add(currentNumber);
                        if (isFristPass == false)
                            return true;
                    }

                }
            }

            return false;
        }
Example #27
0
    public static void Main (string[] args) {
      var list = new List<Enum1> { Enum1.Value0, Enum1.Value1, Enum1.Value0, (Enum1)3 };

      Console.WriteLine(list.IndexOf(Enum1.Value0));
      Console.WriteLine(list.IndexOf(Enum1.Value1));
      Console.WriteLine(list.IndexOf((Enum1)2));

      // Other overloads not implemented yet
    }
        static void Main(string[] args)
        {
            string text = Console.ReadLine();
            List<string> letters = new List<string>();
            for (char i = 'A'; i <= 'Z'; i++)
            {
                letters.Add(i.ToString());
            }
            for (char j = 'a'; j <= 'f'; j++)
            {
                for (char i = 'A'; i <= 'Z'; i++)
                {
                    letters.Add(j.ToString() + i);
                }
            }

            int power = 0;
            BigInteger result = 0;
            string concatenation = "";
            int index = 0;
            for (int i = text.Length - 1; i >= 0; i--)
            {
                if (i > 0)
                {
                    if (char.IsUpper(text[i]) && char.IsLower(text[i - 1]))
                    {
                        concatenation = text[i - 1].ToString() + text[i];
                        index = letters.IndexOf(concatenation);
                        if (index >= 0)
                        {
                            result = Power(power) * index + result;
                            power++;
                            concatenation = "";
                            i--;
                        }

                    }
                    else
                    {

                        index = letters.IndexOf(text[i].ToString());
                        result = Power(power) * index + result;
                        power++;

                    }
                }

                else if (i == 0)
                {
                    index = letters.IndexOf(text[i].ToString());
                    result = Power(power) * index + result;
                    power++;
                }

            }
            Console.WriteLine(result);
        }
Example #29
0
 public int GetGameScore(List<Frame> frames)
 {
     AddTwoSinteticRolls(frames);
     var gameFrames = frames.Take(10).ToList();
     var simpeRollsSum = gameFrames.Where(frame => frame.IsSimple).Sum(frame => frame.FrameSum);
     var spareRollsSum = gameFrames.Where(frame => frame.IsSpare).Sum(frame => frame.FrameSum + frames[frames.IndexOf(frame) + 1].FirstRoll);
     var strikeRollsSum = gameFrames.Where(frame => frame.IsStrike).SelectMany(frame => frames.Skip(frames.IndexOf(frame)).Take(3)).Sum(frame => frame.FrameSum);
     return simpeRollsSum + spareRollsSum + strikeRollsSum;
 }
Example #30
0
 private static void AddResult(List<int> numbers, List<int> result, int i)
 {
     if (numbers.IndexOf(i) > -1)
     {
         result.Add(i);
         numbers.RemoveRange(0, numbers.IndexOf(i) + 1);
         AddResult(numbers, result, i);
     }
 }