Exemple #1
0
        /// <returns>
        /// Возвращает количество фраз, начинающихся с заданного префикса
        /// </returns>
        public static int GetCountByPrefix(IReadOnlyList <string> phrases, string prefix)
        {
            var count = RightBorderTask.GetRightBorderIndex(phrases, prefix, -1, phrases.Count) -
                        LeftBorderTask.GetLeftBorderIndex(phrases, prefix, -1, phrases.Count) - 1;

            return(Math.Max(0, count));
        }
Exemple #2
0
        public static int GetCountByPrefix(IReadOnlyList <string> phrases, string prefix)
        {
            var leftBoarder  = LeftBorderTask.GetLeftBorderIndex(phrases, prefix, -1, phrases.Count);
            var rightBoarder = RightBorderTask.GetRightBorderIndex(phrases, prefix, -1, phrases.Count);

            return(rightBoarder - leftBoarder - 1);
        }
Exemple #3
0
        public static int GetCountByPrefix(IReadOnlyList <string> phrases, string prefix)
        {
            var end   = RightBorderTask.GetRightBorderIndex(phrases, prefix, -1, phrases.Count);
            var start = LeftBorderTask.GetLeftBorderIndex(phrases, prefix, -1, phrases.Count);

            return(end - start - 1);
        }
Exemple #4
0
        public static string[] GetTopByPrefix(IReadOnlyList <string> phrases, string prefix, int count)
        {
            var phrasesCount = phrases.Count;
            var leftBorder   = LeftBorderTask.GetLeftBorderIndex(phrases, prefix, -1, phrasesCount) + 1;

            if (leftBorder == phrasesCount)
            {
                return(new string[0]);
            }

            var actualCount = Math.Min(count, phrasesCount - leftBorder);

            var result          = new List <string>();
            var nextPhraseIndex = 0;

            for (var i = 0; i < actualCount; i++)
            {
                nextPhraseIndex = leftBorder + i;

                if (!phrases[nextPhraseIndex].StartsWith(prefix, StringComparison.OrdinalIgnoreCase))
                {
                    break;
                }

                result.Add(phrases[nextPhraseIndex]);
            }

            return(result.ToArray());
        }
        public static int GetCountByPrefix(IReadOnlyList <string> phrases, string prefix)
        {
            int left  = LeftBorderTask.GetLeftBorderIndex(phrases, prefix, -1, phrases.Count);
            int right = RightBorderTask.GetRightBorderIndex(phrases, prefix, -1, phrases.Count);

            return(right - left - 1);
        }
Exemple #6
0
        /// <returns>
        /// Возвращает количество фраз, начинающихся с заданного префикса
        /// </returns>
        public static int GetCountByPrefix(IReadOnlyList <string> phrases, string prefix)
        {
            // тут стоит использовать написанные ранее классы LeftBorderTask и RightBorderTask
            var first = LeftBorderTask.GetLeftBorderIndex(phrases, prefix, -1, phrases.Count) + 1;
            var last  = RightBorderTask.GetRightBorderIndex(phrases, prefix, -1, phrases.Count) - 1;

            return(Math.Max(0, last - first + 1));
        }
Exemple #7
0
        public static int GetCountByPrefix(IReadOnlyList <string> phrases, string prefix)
        {
            var left   = LeftBorderTask.GetLeftBorderIndex(phrases, prefix, -1, phrases.Count);
            var right  = RightBorderTask.GetRightBorderIndex(phrases, prefix, -1, phrases.Count);
            var result = right - left - 1;

            return((result <= 0) ? 0 : result);
        }
        /// <returns>
        /// Возвращает количество фраз, начинающихся с заданного префикса
        /// </returns>
        public static int GetCountByPrefix(IReadOnlyList <string> phrases, string prefix)
        {
            // тут стоит использовать написанные ранее классы LeftBorderTask и RightBorderTask
            var startIndex = LeftBorderTask.GetLeftBorderIndex(phrases, prefix, -1, phrases.Count) + 1;
            var endIndex   = RightBorderTask.GetRightBorderIndex(phrases, prefix, -1, phrases.Count);

            return(endIndex - startIndex);
        }
        /// <returns>
        /// Возвращает количество фраз, начинающихся с заданного префикса
        /// </returns>
        public static int GetCountByPrefix(IReadOnlyList <string> phrases, string prefix)
        {
            int leftIndex  = LeftBorderTask.GetLeftBorderIndex(phrases, prefix, -1, phrases.Count);
            int rightIndex = RightBorderTask.GetRightBorderIndex(phrases, prefix, -1, phrases.Count);

            // тут стоит использовать написанные ранее классы LeftBorderTask и RightBorderTask
            return(rightIndex - leftIndex - 1);
        }
        public static string[] GetTopByPrefix(IReadOnlyList <string> phrases, string prefix, int count)
        {
            int actualCount = Math.Min(GetCountByPrefix(phrases, prefix), count);
            int startIndex  = LeftBorderTask.GetLeftBorderIndex(phrases, prefix, -1, phrases.Count) + 1;

            string[] result = new string[actualCount];
            Array.Copy(phrases.ToArray(), startIndex, result, 0, actualCount);
            return(result);
        }
Exemple #11
0
 public static int GetCountByPrefix(IReadOnlyList <string> phrases, string prefix)
 {
     if (prefix == "")
     {
         return(phrases.Count);
     }
     return(RightBorderTask.GetRightBorderIndex(phrases, prefix, -1, phrases.Count)
            - LeftBorderTask.GetLeftBorderIndex(phrases, prefix, -1, phrases.Count) - 1);
 }
        /// <returns>
        /// Возвращает первую фразу словаря, начинающуюся с prefix.
        /// </returns>
        /// <remarks>
        /// Эта функция уже реализована, она заработает,
        /// как только вы выполните задачу в файле LeftBorderTask
        /// </remarks>
        public static string FindFirstByPrefix(IReadOnlyList <string> phrases, string prefix)
        {
            var index = LeftBorderTask.GetLeftBorderIndex(phrases, prefix, -1, phrases.Count) + 1;

            if (index < phrases.Count && phrases[index].StartsWith(prefix, StringComparison.OrdinalIgnoreCase))
            {
                return(phrases[index]);
            }
            return(null);
        }
Exemple #13
0
        public static string[] GetTopByPrefix(IReadOnlyList <string> phrases, string prefix, int count)
        {
            var           index = LeftBorderTask.GetLeftBorderIndex(phrases, prefix, -1, phrases.Count) + 1;
            List <string> words = new List <string>();

            for (int i = index; i < phrases.Count &&
                 phrases[i].StartsWith(prefix, StringComparison.OrdinalIgnoreCase) && words.Count < count; i++)
            {
                words.Add(phrases[i]);
            }
            return(words.ToArray());
        }
Exemple #14
0
        /// <returns>
        /// Возвращает первые в лексикографическом порядке count (или меньше, если их меньше count)
        /// элементов словаря, начинающихся с prefix.
        /// </returns>
        /// <remarks>Эта функция должна работать за O(log(n) + count)</remarks>
        public static string[] GetTopByPrefix(IReadOnlyList <string> phrases, string prefix, int count)
        {
            var left          = LeftBorderTask.GetLeftBorderIndex(phrases, prefix, -1, phrases.Count) + 1;
            var countByPrefix = Math.Min(count, GetCountByPrefix(phrases, prefix));
            var result        = new string[countByPrefix];

            for (int i = 0; i < countByPrefix; i++)
            {
                result[i] = phrases[i + left];
            }
            return(result);
        }
Exemple #15
0
        /// <returns>
        /// Возвращает первые в лексикографическом порядке count (или меньше, если их меньше count)
        /// элементов словаря, начинающихся с prefix.
        /// </returns>
        /// <remarks>Эта функция должна работать за O(log(n) + count)</remarks>
        public static string[] GetTopByPrefix(IReadOnlyList <string> phrases, string prefix, int count)
        {
            var           begin       = LeftBorderTask.GetLeftBorderIndex(phrases, prefix, -1, phrases.Count) + 1;
            var           end         = RightBorderTask.GetRightBorderIndex(phrases, prefix, -1, phrases.Count) - 1;
            List <string> goodPhrases = new List <string>();

            for (int i = begin; i <= end && i < begin + count; i++)
            {
                goodPhrases.Add(phrases[i]);
            }
            return(goodPhrases.ToArray());
        }
Exemple #16
0
        /// <returns>
        /// Возвращает первые в лексикографическом порядке count (или меньше, если их меньше count)
        /// элементов словаря, начинающихся с prefix.
        /// </returns>
        /// <remarks>Эта функция должна работать за O(log(n) + count)</remarks>
        public static string[] GetTopByPrefix(IReadOnlyList <string> phrases, string prefix, int count)
        {
            int left = LeftBorderTask.GetLeftBorderIndex(phrases, prefix, -1, phrases.Count);

            string[] words = new string[Math.Min(count, GetCountByPrefix(phrases, prefix))];

            for (int i = 0; i < words.Length; i++)
            {
                words[i] = phrases[i + left + 1];
            }

            return(words);
        }
Exemple #17
0
        /// <returns>
        /// Возвращает количество фраз, начинающихся с заданного префикса
        /// </returns>
        public static int GetCountByPrefix(IReadOnlyList <string> phrases, string prefix)
        {
            var right = RightBorderTask.GetRightBorderIndex(phrases, prefix, -1, phrases.Count);
            var left  = LeftBorderTask.GetLeftBorderIndex(phrases, prefix, -1, phrases.Count);

            if (right - left - 1 < 0)
            {
                return(0);
            }
            else
            {
                return(right - left - 1);
            }
        }
Exemple #18
0
        /// <returns>
        /// Возвращает первые в лексикографическом порядке count (или меньше, если их меньше count)
        /// элементов словаря, начинающихся с prefix.
        /// </returns>
        /// <remarks>Эта функция должна работать за O(log(n) + count)</remarks>
        public static string[] GetTopByPrefix(IReadOnlyList <string> phrases, string prefix, int count)
        {
            // паста из GetCountByPrefix(...) в целях уложиться в требования к O(...)
            var first = LeftBorderTask.GetLeftBorderIndex(phrases, prefix, -1, phrases.Count) + 1;
            var last  = RightBorderTask.GetRightBorderIndex(phrases, prefix, -1, phrases.Count) - 1;

            count = Math.Min(count, Math.Max(0, last - first + 1));
            var ret = new string[count];

            for (var i = 0; i < count; ++i)
            {
                ret[i] = phrases[first + i];
            }
            return(ret);
        }
Exemple #19
0
        public static string[] GetTopByPrefix(IReadOnlyList <string> phrases, string prefix, int count)
        {
            var leftIndex  = LeftBorderTask.GetLeftBorderIndex(phrases, prefix, -1, phrases.Count);
            var rightIndex = RightBorderTask.GetRightBorderIndex(phrases, prefix, -1, phrases.Count);

            count = Math.Min(count, rightIndex - leftIndex - 1);
            var topByPrefix = new string[count];

            for (var i = 0; i < count; i++)
            {
                topByPrefix[i] = phrases[leftIndex + i + 1];
            }

            return(topByPrefix);
        }
        /// <returns>
        /// Возвращает первые в лексикографическом порядке count (или меньше, если их меньше count)
        /// элементов словаря, начинающихся с prefix.
        /// </returns>
        /// <remarks>Эта функция должна работать за O(log(n) + count)</remarks>
        public static string[] GetTopByPrefix(IReadOnlyList <string> phrases, string prefix, int count)
        {
            // тут стоит использовать написанный ранее класс LeftBorderTask
            var startIindex = LeftBorderTask.GetLeftBorderIndex(phrases, prefix, -1, phrases.Count) + 1;
            var resultArray = new List <string> {
            };

            while (count > 0 &&
                   startIindex < phrases.Count &&
                   phrases[startIindex].StartsWith(prefix, StringComparison.OrdinalIgnoreCase))
            {
                resultArray.Add(phrases[startIindex]);
                startIindex++; count--;
            }
            return(resultArray.ToArray());
        }
        /// <returns>
        /// Возвращает первые в лексикографическом порядке count (или меньше, если их меньше count)
        /// элементов словаря, начинающихся с prefix.
        /// </returns>
        /// <remarks>Эта функция должна работать за O(log(n) + count)</remarks>
        public static string[] GetTopByPrefix(IReadOnlyList <string> phrases, string prefix, int count)
        {
            var valueOfLeftBorder = LeftBorderTask.GetLeftBorderIndex(phrases, prefix, -1, phrases.Count) + 1;
            var countPhrases      = GetCountByPrefix(phrases, prefix);
            var result            = new string[count];

            if (count > countPhrases)
            {
                count = countPhrases;
            }

            for (var i = 0; i < count; i++)
            {
                result[i] = phrases[valueOfLeftBorder + i];
            }
            return(result);
        }
        /// <returns>
        /// Возвращает первые в лексикографическом порядке count (или меньше, если их меньше count)
        /// элементов словаря, начинающихся с prefix.
        /// </returns>
        /// <remarks>Эта функция должна работать за O(log(n) + count)</remarks>
        public static string[] GetTopByPrefix(IReadOnlyList <string> phrases, string prefix, int count)
        {
            List <string> tmpList = new List <string> {
            };
            var index             = LeftBorderTask.GetLeftBorderIndex(phrases, prefix, -1, phrases.Count);
            int i = 1;

            while (index + i < phrases.Count &&
                   phrases[index + i].StartsWith(prefix, StringComparison.OrdinalIgnoreCase) &&
                   i <= count)
            {
                tmpList.Add(phrases[index + i]);
                ++i;
            }
            // тут стоит использовать написанный ранее класс LeftBorderTask
            return(tmpList.ToArray());
            //return null;
        }
Exemple #23
0
        /// <returns>
        /// Возвращает первые в лексикографическом порядке count (или меньше, если их меньше count)
        /// элементов словаря, начинающихся с prefix.
        /// </returns>
        /// <remarks>Эта функция должна работать за O(log(n) + count)</remarks>
        public static string[] GetTopByPrefix(IReadOnlyList <string> phrases, string prefix, int count)
        {
            var start  = LeftBorderTask.GetLeftBorderIndex(phrases, prefix, -1, phrases.Count) + 1;
            var result = new List <string>();

            for (var i = start; i < start + count; ++i)
            {
                if (i == phrases.Count ||
                    !phrases[i].StartsWith(prefix, StringComparison.OrdinalIgnoreCase))
                {
                    break;
                }

                result.Add(phrases[i]);
            }

            return(result.ToArray());
        }
Exemple #24
0
        public static string[] GetTopByPrefix(IReadOnlyList <string> phrases, string prefix, int count)
        {
            var index = LeftBorderTask.GetLeftBorderIndex(phrases, prefix, -1, phrases.Count) + 1;
            var arr   = new List <string>();

            for (int i = 0; i < count; i++)
            {
                if (i + index < phrases.Count &&
                    phrases[index + i].StartsWith(prefix, StringComparison.OrdinalIgnoreCase))
                {
                    arr.Add(phrases[index + i]);
                }
                else
                {
                    break;
                }
            }
            return(arr.ToArray());
        }
Exemple #25
0
        /// <returns>
        /// Возвращает первые в лексикографическом порядке count (или меньше, если их меньше count)
        /// элементов словаря, начинающихся с prefix.
        /// </returns>
        /// <remarks>Эта функция должна работать за O(log(n) + count)</remarks>
        public static string[] GetTopByPrefix(IReadOnlyList <string> phrases, string prefix, int count)
        {
            var phrasesList    = new List <string>();
            var firstItemIndex = LeftBorderTask.GetLeftBorderIndex(phrases, prefix, -1, phrases.Count) + 1;
            var trueCount      = Math.Min(count, phrases.Count - firstItemIndex);

            if (firstItemIndex == phrases.Count)
            {
                return(new string[0]);
            }
            for (var i = 0; i < trueCount; i++)
            {
                if (!phrases[firstItemIndex + i].StartsWith(prefix, StringComparison.OrdinalIgnoreCase))
                {
                    break;
                }
                phrasesList.Add(phrases[firstItemIndex + i]);
            }
            return(phrasesList.ToArray());
        }
Exemple #26
0
        public static string[] GetTopByPrefix(IReadOnlyList <string> phrases, string prefix, int count)
        {
            var startIndex = LeftBorderTask.GetLeftBorderIndex(phrases, prefix, -1, phrases.Count) + 1;

            if (count > GetCountByPrefix(phrases, prefix))
            {
                count = GetCountByPrefix(phrases, prefix);
            }
            var result = new string[count];

            for (int i = 0; i < count; i++)
            {
                if (phrases[startIndex].StartsWith(prefix))
                {
                    result[i] = phrases[startIndex];
                }
                startIndex++;
            }
            return(result);
        }
Exemple #27
0
        /// <returns>
        /// Возвращает первые в лексикографическом порядке count (или меньше, если их меньше count)
        /// элементов словаря, начинающихся с prefix.
        /// </returns>
        /// <remarks>Эта функция должна работать за O(log(n) + count)</remarks>
        public static string[] GetTopByPrefix(IReadOnlyList <string> phrases, string prefix, int count)
        {
            var start   = LeftBorderTask.GetLeftBorderIndex(phrases, prefix, -1, phrases.Count) + 1;
            var words   = new List <string>();
            int numbers = GetCountByPrefix(phrases, prefix); //вызов этого метода == нарушение условия на сложность, переписать

            if (numbers == 0)
            {
                return(new string[0]);
            }
            if (count > numbers)
            {
                count = numbers;
            }
            for (int i = 0; i < count; i++)
            {
                words.Add(phrases[start + i]);
            }
            return(words.ToArray());
        }
Exemple #28
0
        /// <returns>
        /// Возвращает первые в лексикографическом порядке count (или меньше, если их меньше count)
        /// элементов словаря, начинающихся с prefix.
        /// </returns>
        /// <remarks>Эта функция должна работать за O(log(n) + count)</remarks>
        public static string[] GetTopByPrefix(IReadOnlyList <string> phrases, string prefix, int count)
        {
            var pCount = phrases.Count;
            var left   = LeftBorderTask.GetLeftBorderIndex(phrases, prefix, -1, pCount) + 1;

            if (left == pCount)
            {
                return(new string[0]);
            }
            var result = new List <string>();

            for (int i = 0; i < count; ++i)
            {
                var ind = left + i;
                if (ind >= pCount ||
                    !phrases[ind].StartsWith(prefix, StringComparison.OrdinalIgnoreCase))
                {
                    break;
                }
                result.Add(phrases[ind]);
            }
            return(result.ToArray());
        }
Exemple #29
0
        public static string[] GetTopByPrefix(IReadOnlyList <string> phrases, string prefix, int count)
        {
            var start   = LeftBorderTask.GetLeftBorderIndex(phrases, prefix, -1, phrases.Count) + 1;
            var numbers = GetCountByPrefix(phrases, prefix);

            if (numbers <= 0)
            {
                return(new string[0]);
            }

            if (count > numbers)
            {
                count = numbers;
            }

            var words = new string[count];

            for (var i = 0; i < count; i++)
            {
                words[i] = phrases[start + i];
            }

            return(words);
        }