Как найти слово в массиве строк с

You can define your own string.ContainsAny() and string.ContainsAll() methods. As a bonus, I’ve even thrown in a string.Contains() method that allows for case-insensitive comparison, etc.

public static class Extensions
{
    public static bool Contains(this string source, string value, StringComparison comp)
    {
        return source.IndexOf(value, comp) > -1;
    }

    public static bool ContainsAny(this string source, IEnumerable<string> values, StringComparison comp = StringComparison.CurrentCulture)
    {
        return values.Any(value => source.Contains(value, comp));
    }

    public static bool ContainsAll(this string source, IEnumerable<string> values, StringComparison comp = StringComparison.CurrentCulture)
    {
        return values.All(value => source.Contains(value, comp));
    }
}

You can test these with the following code:

    public static void TestExtensions()
    {
        string[] searchTerms = { "FOO", "BAR" };
        string[] documents = {
            "Hello foo bar",
            "Hello foo",
            "Hello"
        };

        foreach (var document in documents)
        {
            Console.WriteLine("Testing: {0}", document);
            Console.WriteLine("ContainsAny: {0}", document.ContainsAny(searchTerms, StringComparison.OrdinalIgnoreCase));
            Console.WriteLine("ContainsAll: {0}", document.ContainsAll(searchTerms, StringComparison.OrdinalIgnoreCase));
            Console.WriteLine();
        }
    }

Поиск подстроки

Последнее обновление: 02.03.2023

Функция find() возвращает индекс первого вхождения подстроки или отдельного символа в строке в виде значние я типа size_t:

#include <iostream>
#include <string>

int main()
{
    std::string text {"A friend in need is a friend indeed."};
    std::cout << text.find("ed") << std::endl;      // 14
    std::cout << text.find("friend") << std::endl;  // 2
    std::cout << text.find('d') << std::endl;     // 7
    std::cout << text.find("apple") << std::endl;  // 18446744073709551615
}

Если строка или символ не найдены (как в примере выше в последнем случае), то возвращается специальная константа std::string::npos,
которая представляет очень большое число (как видно из примера, число 18446744073709551615). И при поиске мы можем проверять результат функции find() на равенство этой константе:

if (text.find("banana") == std::string::npos)
{
    std::cout << "Not found" << std::endl;
}

Функция find имеет ряд дополнительных версий. Так, с помощью второго параметра мы можем указать индекс, с которого надо вести поиск:

#include <iostream>
#include <string>

int main()
{
    std::string text {"A friend in need is a friend indeed."};
    // поиск с 10-го индекса
    std::cout << text.find("friend", 10) << std::endl;      // 22
}

Используя эту версию, мы можем написать программу для поиска количества вхождений строки в тексте, то есть выяснить, сколько раз строка встречается в тексте:

#include <iostream>
#include <string>

int main()
{
    std::string text {"A friend in need is a friend indeed."};
    std::string word {"friend"};
    unsigned count{};       // количество вхождений
    for (unsigned i {}; i <= text.length() - word.length(); )
    {
        // получаем индекс
        size_t position = text.find(word, i);
        // если не найдено ни одного вхождения с индекса i, выходим из цикла
        if (position == std::string::npos) break;
        // если же вхождение найдено, увеличиваем счетчик вхождений
        ++count;
        // переходим к следующему индексу после position
        i = position + 1;
    }
    std::cout << "The word is found " << count << " times." << std::endl; // The word is found 2 times.
}

Здесь в цикле пробегаемся по тексту, в котором надо найти строку, пока счетчик i не будет равен text.length() - word.length().
С помощью функции find() получаем индекс первого вхождения слова в тексте, начиная с индекса i. Если таких вхождений не найдено, то выходим из цикла.
Если же найден индекс, то счетчик i получает индекс, следующий за индексом найденного вхождения.

В итоге, поскольку искомое слово “friend” встречается в тексте два раза, то программа выведет

The word is found 2 times.

В качестве альтернативы мы могли бы использовать цикл while:

#include <iostream>
#include <string>

int main()
{
    std::string text {"A friend in need is a friend indeed."};
    std::string word {"friend"};
    unsigned count{};       // количество вхождений
    size_t index{}; // начальный индекс
    while ((index = text.find(word, index)) != std::string::npos)
    {
        ++count;
        index += word.length(); // перемещаем индекс на позицию после завершения слова в тексте
    }
    std::cout << "The word is found " << count << " times." << std::endl;
}

Еще одна версия позволяет искать в тексте не всю строку, а только ее часть. Для этого в качестве третьего параметра передается количество символов из искомой строки, которые программа будет искать в тексте:

#include <iostream>
#include <string>

int main()
{
    std::string text {"A friend in need is a friend indeed."};
    std::string word {"endless"};
    // поиск с 10-го индекса 3 первых символов слова "endless", то есть "end"
    std::cout << text.find("endless", 10, 3) << std::endl;      // 25
}

Стоит отметить, что в этом случае искомая строка должна представлять строковый литерал или строку в С-стиле (например, символьный массив с концевым нулевым байтом).

Функция rfind. Поиск в обратном порядке

Функция rfind() работает аналогично функции find(), принимает те же самые параметры, только ищет подстроку в обратном порядке – с конца строки:

#include <iostream>
#include <string>

int main()
{
    std::string text {"A friend in need is a friend indeed."};
    std::cout << text.rfind("ed") << std::endl;      // 33
    std::cout << text.rfind("friend") << std::endl; // 22
    std::cout << text.rfind('d') << std::endl;     // 34
    std::cout << text.rfind("apple") << std::endl;  // 18446744073709551615
}

Поиск любого из набора символов

Пара функций – find_first_of() и find_last_of() позволяют найти соответственно первый и последний индекс любого из набора символов:

#include <iostream>
#include <string>

int main()
{
    std::string text {"Phone number: +23415678901"};
    std::string letters{"0123456789"};  // искомые символы
    std::cout << text.find_first_of(letters) << std::endl;      // 15
    std::cout << text.find_last_of(letters) << std::endl;      // 25
}

В данном случае ищем в строке “Phone number: +23415678901” первую и последнюю позицию любого из символов из строки “0123456789”. То есть таким образом мы найдем начальный и конечный индекс
номера телефона.

Если нам, наоборот, надо найти позиции символов, которые НЕ представляют любой символ из набора, то мы можем использовать функции find_first_not_of() (первая позиция)
и find_last_not_of() (последняя позиция):

#include <iostream>
#include <string>

int main()
{
    std::string text {"Phone number: +23415678901"};
    std::string letters{"0123456789"};  // искомые символы
    std::cout << text.find_first_not_of(letters) << std::endl;      // 0
    std::cout << text.find_last_not_of(letters) << std::endl;      // 14
}

Мы можем комбинировать функции. Например, найдем количество слов в строке:

#include <iostream>
#include <string>

int main()
{
    std::string text {"When in Rome, do as the Romans do."};    // исходный текст
    const std::string separators{ " ,;:."!?'*n" }; // разделители слов
    unsigned count{};   // счетчик слов
    size_t start { text.find_first_not_of(separators) }; // начальный индекс первого слова
    while (start != std::string::npos) // если нашли слово
    {
        // увеличиваем счетчик слов
        count++;
        size_t end = text.find_first_of(separators, start + 1); // находим, где кончается слово
        if (end == std::string::npos) 
        {
            end = text.length();
        }
        start = text.find_first_not_of(separators, end + 1); // находим начальный индекс следующего слова и переустанавливаем start
    }
    // выводим количество слов
    std::cout << "Text contains " << count << " words" << std::endl;    // Text contains 8 words
}

Вкратце рассмотрим данный код. В качестве текста, где будем подсчитывать слова, определям переменную text. И также определяем строку разделителей, такие как знаки пунктуации, пробелы, символ перевода строки, которые не являются словами:

const std::string separators{ " ,;:."!?'*n" }; // разделители слов

Перед обработкой введенного текста фиксируем индекс первого символа первого слова в тексте. Для этого применяется функция find_first_not_of(), которая возвращает
первый индекс любого символа, который не входит в строку separators:

size_t start { text.find_first_not_of(separators) };

Далее в цикле while смотрим, является ли полученный индекс действительным индексом:

while (start != std::string::npos)

Например, если в строке одни только символы из набора separators, тогда функция find_first_not_of() возвратит значение std::string::npos,
что будет означать, что в тексте больше нет непунктационных знаков.

И если start указывает на действительный индекс начала слова, то увеличиваем счетчик слово. Далее находим индекс первого символа из separators, который идет сразу после слова. То есть фактически это индекс после
последнего символа слова, который помещаем в переменную end:

size_t end = text.find_first_of(separators, start + 1); // находим, где закончилось слово

Для нахождения позиции окончания слова используем функцию find_first_of(), которая возвращает первую позицию любого символа из separators, начиная с индекса start+1

Причем может быть, что функция find_first_of() не найдет ни одного символа из separators (например, слово является поседним в тексте, и после него нет никаких знаков пунктуации или пробелов),
в этом случае конечный индекс равен длине текста.

if (end == std::string::npos) // если НЕ найден ни один из символов-разделителей
    end = text.length();        // устанавливаем переменную end на конец текста

После того, как мы нашли начальный индексы слова и его конец, переустанавливаем start на начальный индекс следующего слова и повторяем действия цикла:

start = text.find_first_not_of(separators, end + 1); // находим начальный индекс следующего слова и переустанавливаем start

В конце выводим количество найденных слов.

Массивы строк. Примеры решения наиболее распространенных задач

Содержание

• 1. Массив строк. Тип string[]. Создание массива строк
• 2. Пример инициализации массива строк
• 3. Пример ввода строк с клавиатуры и создания массива строк
• 4. Пример сортировки массива строк методом вставки
• 5. Пример поиска заданной строки в массиве строк
• 6. Пример подсчета количества вхождений заданной строки в массиве строк
• Связанные темы

Поиск на других ресурсах:

1. Массив строк. Тип string[]. Создание массива строк

В языке C# строки могут быть объединены в массив. Каждая строка представляется типом string.

Для создания массива строк нужно выполнить следующие шаги.

1. Объявить ссылку на тип string, например

string[] arrString;

где arrString – название ссылки;

2. Выделить память для массива

arrString = new string[size];

здесь size – количество строк (экземпляров) типа string.

  ⇑

2. Пример инициализации массива строк

Массив строк может быть инициализирован при его объявлении. Ниже приводится пример инициализации и вывод на экран массива daysOfWeek, определяющего дни недели.

using System;

namespace ConsoleApp8
{
  class Program
  {
    static void Main(string[] args)
    {
      // Инициализация массива строк
      string[] daysOfWeek = { "Sunday", "Monday", "Tuersday",
      "Wednesday", "Thirsday", "Friday", "Saturday" };

      // Вывод массива строк AS в цикле
      for (int i = 0; i < daysOfWeek.Length; i++)
        Console.WriteLine("AS[{0}] = {1}", i, daysOfWeek[i]);
      Console.ReadKey();
    }
  }
}

Результат выполнения программы

AS[0] = Sunday
AS[1] = Monday
AS[2] = Tuersday
AS[3] = Wednesday
AS[4] = Thirsday
AS[5] = Friday
AS[6] = Saturday

  ⇑

3. Пример ввода строк с клавиатуры и создания массива строк

В примере вводятся строки с клавиатуры до тех пор, пока не будет введена пустая строка «». Одновременно формируется массив строк, который выводится на экран после завершения ввода.

using System;

namespace ConsoleApp8
{
  class Program
  {
    static void Main(string[] args)
    {
      // Ввод строк с клавиатуры
      // и образование нового массива

      // 1. Объявление переменных
      string[] AS; // ссылка на массив строк
      int count; // текущее количество строк в массиве
      string s;
      string[] AS2; // дополнительная переменная-ссылка - сохраняет старый массив строк

      // 2. Цикл ввода строк
      Console.WriteLine("Enter strings:");

      count = 0; // обнулить количество строк
      AS = new string[count]; // выделить память для 0 строк

      do
      {
        // Ввести строку
        s = Console.ReadLine();

        // Проверка, пустая ли строка
        if (s!="")
        {
          // если строка не пустая, то добавить строку в массив
          count++;

          // предварительно выделить память для нового массива
          // в котором на 1 элемент больше
          AS2 = new string[count];

          // скопировать старый массив в новый
          for (int i = 0; i < AS2.Length - 1; i++)
            AS2[i] = AS[i];

          // добавить последнюю введенную строку в массив AS2
          AS2[count - 1] = s;

          // Освобождать память, предварительно выделенную под AS не нужно,
          // этим занимается сборщик мусора

          // перенаправить ссылку AS на AS2
          AS = AS2;
        }
      } while (s != "");

      // 3. Вывод массива строк AS в цикле
      for (int i = 0; i < AS.Length; i++)
        Console.WriteLine("AS[{0}] = {1}", i, AS[i]);
      Console.ReadKey();
    }
  }
}

Как видно из вышеприведенного кода, не нужно делать освобождение предварительно выделенной памяти для массива AS как в языках C/C++. Этим занимается сборщик мусора.

Результат работы программы

Enter strings:
abc
bcdef
ghi
jkl mno

AS[0] = abc
AS[1] = bcdef
AS[2] = ghi
AS[3] = jkl mno

  ⇑

4. Пример сортировки массива строк методом вставки

В примере демонстрируется ввод массива из n строк (n>0) и его сортировка методом вставки. Строки сортируются по возрастанию.

using System;

namespace ConsoleApp8
{
  class Program
  {
    static void Main(string[] args)
    {
      // Сортировка массива строк методом вставки
      // 1. Объявление переменных
      string[] AS; // массив строк
      int count; // количество элементов в массиве
      string s; // дополнительная переменная-строка

      // 2. Ввести количество строк
      Console.Write("count = ");
      count = Int32.Parse(Console.ReadLine());

      // 3. Выделить память для массива из count строк
      AS = new string[count];

      // 4. Ввести данные массива с клавиатуры
      Console.WriteLine("Enter array:");

      for (int i=0; i<AS.Length; i++)
      {
        Console.Write("AS[{0}] = ", i);
        AS[i] = Console.ReadLine();
      }

      // 5. Сортировка методом вставки
      for (int i = 0; i < AS.Length - 1; i++)
        for (int j = i; j >= 0; j--)
          if (String.Compare(AS[j], AS[j + 1]) > 0) // функция Compare()
          {
            // поменять значения местами
            s = AS[j];
            AS[j] = AS[j + 1];
            AS[j + 1] = s;
          }

      // 6. Вывести массив AS
      Console.WriteLine("Sorted array:");
      for (int i = 0; i < AS.Length; i++)
        Console.WriteLine("AS[{0}] = {1}", i, AS[i]);

      Console.ReadKey();
    }
  }
}

Как видно из вышеприведенного примера, для сравнения двух массивов используется функция Compare(). Эта функция возвращает число больше 0, если первая строка находится в лексикографическом порядке после второй строки. Если строки равны, функция возвращает нулевое значение.

Результат работы программы

count = 5
Enter array:
AS[0] = lkd
AS[1] = kbd
AS[2] = abcd
AS[3] = jklm nop
AS[4] = ffed

Sorted array:
AS[0] = abcd
AS[1] = ffed
AS[2] = jklm nop
AS[3] = kbd
AS[4] = lkd

  ⇑

5. Пример поиска заданной строки в массиве строк

В примере вводится массив строк и вводится некоторая строка. Если строка есть в массиве, то определяется ее позиция. Результат поиска выводится на экран.

using System;

namespace ConsoleApp8
{
  class Program
  {
    static void Main(string[] args)
    {
      // Поиск заданной строки в массиве строк
      // 1. Объявление переменных
      string[] AS; // массив строк
      int count; // количество элементов в массиве
      string str; // искомая строка

      // 2. Ввести количество строк
      Console.Write("count = ");
      count = Int32.Parse(Console.ReadLine());

      // 3. Проверка, корректно ли значение count
      if (count<=0)
      {
        Console.WriteLine("Error. The value of count is incorrect.");
        Console.ReadKey();
        return;
      }

      // 4. Выделить память для массива из count строк
      AS = new string[count];

      // 5. Ввести данные массива с клавиатуры
      Console.WriteLine("Enter array:");

      for (int i=0; i<AS.Length; i++)
      {
        Console.Write("AS[{0}] = ", i);
        AS[i] = Console.ReadLine();
      }

      // 6. Ввести строку символов
      Console.Write("Enter string: ");
      str = Console.ReadLine();

      // 7. Поиск строки в массиве строк
      bool f_is = false; // флаг, сигнализирующий о наличии строки в массиве
      int index = -1; // позиция строки в массиве

      for (int i = 0; i < AS.Length - 1; i++)
        if (str == AS[i])
        {
          f_is = true;
          index = i;
        }

      // 8. Вывод результата
      if (f_is)
      {
        Console.WriteLine("String "{0}" is in the array.", str);
        Console.WriteLine("Position is {0}", index);
      }
      else
      {
        Console.WriteLine("String "{0}" is not in the array.", str);
      }
      Console.ReadKey();
    }
  }
}

Результат работы программы

count = 7
Enter array:
AS[0] = sd
AS[1] = lkjl
AS[2] = wewe
AS[3] = ooii
AS[4] = slkdlk
AS[5] = cxx
AS[6] = lkl

Enter string: wewe
String "wewe" is in the array.
Position is 2

  ⇑

6. Пример подсчета количества вхождений заданной строки в массиве строк

В примере вводится строка и массив строк. Затем осуществляется подсчет количества вхождений заданной строки в массиве строк.

using System;

namespace ConsoleApp8
{
  class Program
  {
    static void Main(string[] args)
    {
      // Вычисление количества вхождений заданной строки в массиве строк
      // 1. Объявление переменных
      string[] AS; // массив строк
      int count; // количество элементов в массиве
      string str; // строка, количество вхождений которой вычисляется
      int n_occurs; // количество вхождений - результат

      // 2. Ввод строки str
      Console.WriteLine("Enter string:");
      str = Console.ReadLine();

      // 3. Ввод количества элементов в массиве
      Console.Write("count = ");
      count = Convert.ToInt32(Console.ReadLine());

      // 4. Проверка, корректно ли значение count
      if (count<=0)
      {
        Console.WriteLine("Error. The value of count is incorrect.");
        Console.ReadLine();
        return;
      }

      // 5. Выделение памяти для массива строк
      AS = new string[count];

      // 6. Ввод массива с клавиатуры
      Console.WriteLine("Enter the array AS:");

      for (int i=0;i<AS.Length;i++)
      {
        Console.Write("AS[{0}] = ", i);
        AS[i] = Console.ReadLine();
      }

      // 7. Подсчет количества вхождений
      n_occurs = 0;
      for (int i = 0; i < AS.Length; i++)
        if (str == AS[i])
          n_occurs++;

      // 8. Вывод результата
      Console.WriteLine("n_occurs = {0}", n_occurs);

      Console.ReadKey();
    }
  }
}

Результат выполнения программы

Enter string:
abc
count = 9

Enter the array AS:
AS[0] = dd
AS[1] = abc
AS[2] = ghi
AS[3] = jklm
AS[4] = abc
AS[5] = def
AS[6] = bca
AS[7] = abc
AS[8] = fklsdj
n_occurs = 3

  ⇑

Связанные темы

• Одномерные массивы. Примеры решения задач на одномерные массивы. Массивы структур. Массивы классов. Инициализация массивов
• Многомерные массивы. Ступенчатые массивы. Инициализация многомерных массивов
• Ссылки на массивы. Свойство Length. Присваивание массивов
• Неявно типизированные массивы. Ключевое слово var

  ⇑