# Регулярные выражения
### [任务 ₍ᐢ. ̫ .ᐢ₎](https://github.com/kolei/OAP/blob/master/articles/lab5_regex.md)
## 任务-1
```
using System;
using System.Text.RegularExpressions;

class Program
{
    static void Main()
    {
        string input = "Найдите все натуральные числа: 123, а также число 456 и число 7890.";
        string pattern = @"\b\d+\b";
        Regex regex = new Regex(pattern);
        MatchCollection matches = regex.Matches(input);
        foreach (Match match in matches)
        {
            Console.WriteLine(match.Value);
        }
    }
}
```
```
123
456 
7890
```
## 任务-2
```
using System;
using System.Text.RegularExpressions;

class Program
{
    static void Main()
    {
        string input = "Найдите ВСЕ слова, написанные КАПСОМ внутри текста.";
        string pattern = @"\b(?:[А-ЯЁA-Z]+\b|\b[А-ЯЁA-Z]+(?=[а-яёa-z]))";
        Regex regex = new Regex(pattern);
        MatchCollection matches = regex.Matches(input);
        foreach (Match match in matches)
        {
            Console.WriteLine(match.Value);
        }
    }
}
```
```
Н
ВСЕ   
КАПСОМ
```
## 任务-3
```
using System;
using System.Text.RegularExpressions;

class Program
{
    static void Main()
    {
        string input = "Найдите слова, в которых есть русская буква, а когда-нибудь за ней цифра, например, бамбук27.";

        string pattern = @"\b\p{IsCyrillic}+\d+\p{IsCyrillic}*\b";
        Regex regex = new Regex(pattern);
        MatchCollection matches = regex.Matches(input);
        foreach (Match match in matches)
        {
            Console.WriteLine(match.Value);
        }
    }
}
```
```
бамбук27
```
## 任务-4
```
using System;
using System.Text.RegularExpressions;

class Program
{
    static void Main()
    {
        string input = "Найдите все слова, начинающиеся с Русской или Латинской Большой буквы.";
        string pattern = @"\b[\p{Lu}\p{Lu}]([\p{L}])*\b";
        Regex regex = new Regex(pattern);
        MatchCollection matches = regex.Matches(input);
        foreach (Match match in matches)
        {
            Console.WriteLine(match.Value);
        }
    }
}
```
```
Найдите
Русской  
Латинской
Большой  
```
## 任务-5
```
using System;
using System.Text.RegularExpressions;

class Program
{
    static void Main()
    {
        string input = "Найдите слова, которые начинаются на гласную букву, используя регулярные выражения.";
        string pattern = @"\b[aeiouаеёиоуыэюяAEIOUАЕЁИОУЫЭЮЯ]\w*\b";
        Regex regex = new Regex(pattern, RegexOptions.IgnoreCase);
        MatchCollection matches = regex.Matches(input);
        foreach (Match match in matches)
        {
            Console.WriteLine(match.Value);
        }
    }
}
```
```
используя
```
## 任务-6
```
using System;
using System.Text.RegularExpressions;

class Program
{
    static void Main()
    {
        string input = "Найти 321 числа 7255, которые 791 не находятся внутри или на границе слова 22.";
        // поиск натуральных чисел
        string pattern = @"(?<!\w)\d+(?!\w)";

        Regex regex = new Regex(pattern);
        MatchCollection matches = regex.Matches(input);
        foreach (Match match in matches)
        {
            Console.WriteLine(match.Value);
        }
    }
}
```
```
321
7255
791
22  
```
## 任务-7
```
using System;
using System.Text.RegularExpressions;

class Program
{
    static void Main()
    {
        string[] lines = {
            "Это строка содержит * символ",
            "А здесь нет звездочки",
            "Еще одна строка с *",
            "Строка без *"
        };
        string pattern = @".*\*.*";
        Regex regex = new Regex(pattern);
        foreach (string line in lines)
        {
            if (regex.IsMatch(line))
            {
                Console.WriteLine(line);
            }
        }
    }
}
```
```
Это строка содержит * символ
Еще одна строка с *
Строка без *       
```
## 任务-8
```
using System;
using System.Text.RegularExpressions;

class Program
{
    static void Main()
    {
        string[] lines = {
            "Строка с ( открывающей скобкой",
            "Эта строка (также) содержит закрывающую ) скобку",
            "Еще одна строка без скобок",
            "Текст с (несколькими (вложенными) скобками)"
        };
        string pattern = @".*\(.+\).*";
        Regex regex = new Regex(pattern);
        foreach (string line in lines)
        {
            if (regex.IsMatch(line))
            {
                Console.WriteLine(line);
            }
        }
    }
}
```
```
Эта строка (также) содержит закрывающую ) скобку
Текст с (несколькими (вложенными) скобками)
```
## 任务-9
```
using System;
using System.Text.RegularExpressions;

class Program
{
    static void Main()
    {
        string html = @"
            <html>
            <head>
                <title>Пример HTML-страницы</title>
            </head>
            <body>
                <h1>Оглавление</h1>
                <ul>
                    <li><a href=""#section1"">Раздел 1</a></li>
                    <li><a href=""#section2"">Раздел 2</a></li>
                    <li><a href=""#section3"">Раздел 3</a></li>
                </ul>
            </body>
            </html>";

        string pattern = @"<h1>Оглавление<\/h1>.*?<\/ul>";
        Regex regex = new Regex(pattern, RegexOptions.Singleline);

        // поиск оглавления в html-странице
        Match match = regex.Match(html);
        if (match.Success)
        {
            Console.WriteLine(match.Value);
        }
    }
}
```
```
<h1>Оглавление</h1>                                          
                <ul>                                         
                    <li><a href="#section1">Раздел 1</a></li>
                    <li><a href="#section2">Раздел 2</a></li>
                    <li><a href="#section3">Раздел 3</a></li>
                </ul>                          
```
## 任务-10
```
using System;
using System.Text.RegularExpressions;

class Program
{
    static void Main()
    {
        string html = @"
            <html>
            <head>
                <title>Пример HTML-страницы</title>
            </head>
            <body>
                <h1>Оглавление</h1>
                <ul>
                    <li><a href=""#section1"">Раздел 1</a></li>
                    <li><a href=""#section2"">Раздел 2</a></li>
                    <li><a href=""#section3"">Раздел 3</a></li>
                </ul>
            </body>
            </html>";

        string pattern = @"<h1>Оглавление<\/h1>\s*<ul>(.*?)<\/ul>";
        Regex regex = new Regex(pattern, RegexOptions.Singleline);

        // поиск текстовой части оглавления в html-странице
        Match match = regex.Match(html);
        if (match.Success)
        {
            string tocText = Regex.Replace(match.Groups[1].Value, "<.*?>", "");
            Console.WriteLine(tocText.Trim());
        }
    }
}
```
```
Раздел 1                    
                    Раздел 2
                    Раздел 3
```
## 任务-11
```
using System;
using System.Text.RegularExpressions;

class Program
{
    static void Main()
    {
        string text = @"
            Пример текста
            
            с пустыми строками
            
            
            и еще одной
            
            в середине.";

        string pattern = @"^\s*$";
        Regex regex = new Regex(pattern, RegexOptions.Multiline);
        MatchCollection matches = regex.Matches(text);

        Console.WriteLine("Найденные пустые строки:");
        foreach (Match match in matches)
        {
            Console.WriteLine(match.Value);
        }
    }
}
```
```
Найденные пустые строки:

            
            
            
            

Process finished with exit code 0.
```
## 任务-12
```
using System;
using System.Text.RegularExpressions;

class Program
{
    static void Main()
    {
        string text = "Завтрак в 09:00. Пары в 12:00. Некорректное время 37:98.";
        string pattern = @"\b([01]?[0-9]|2[0-3]):([0-5][0-9])\b";
        Regex regex = new Regex(pattern);
        MatchCollection matches = regex.Matches(text);

        Console.WriteLine("Найденные времена:");
        foreach (Match match in matches)
        {
            Console.WriteLine(match.Value);
        }
    }
}
```
```
Найденные времена:
09:00
12:00
```
## 任务-13
```
using System;
using System.Text.RegularExpressions;

class Program
{
    static void Main()
    {
        string text = "Цвета: #800080, #DCDCDC, #abcdef, #B22222, #0123456789.";
        string pattern = @"#[0-9A-Fa-f]{6}\b";
        Regex regex = new Regex(pattern);
        MatchCollection matches = regex.Matches(text);

        Console.WriteLine("Найденные HTML-цвета:");
        foreach (Match match in matches)
        {
            Console.WriteLine(match.Value);
        }
    }
}
```
```
Найденные HTML-цвета:
#800080
#DCDCDC
#abcdef
#B22222
```
## 任务-14
```
using System;
using System.Text.RegularExpressions;

class Program
{
    static void Main()
    {
        string[] expressions = { "1 + 2", "1.2 * 3.4", "-3 / -6", "-2 - 2" };
        string pattern = @"([-+]?\d*\.?\d+)\s*([-+*/])\s*([-+]?\d*\.?\d+)";
        Regex regex = new Regex(pattern);

        foreach (string expression in expressions)
        {
            Match match = regex.Match(expression);

            if (match.Success)
            {
                double operand1 = double.Parse(match.Groups[1].Value);
                char operation = char.Parse(match.Groups[2].Value);
                double operand2 = double.Parse(match.Groups[3].Value);

                Console.WriteLine($"Выражение: {expression}");
                Console.WriteLine($"Операнд1: {operand1}");
                Console.WriteLine($"Операция: {operation}");
                Console.WriteLine($"Операнд2: {operand2}");
                Console.WriteLine();
            }
            else
            {
                Console.WriteLine($"Не удалось разобрать выражение: {expression}");
            }
        }
    }
}
```
```
Выражение: 1 + 2
Операнд1: 1
Операция: +
Операнд2: 2
```