Где допущена ошибка при проверки c Split('-')?

Question

[stuffed_pretzel]

При проверки индекса группы должно быть 3 или 4 буквы перед тире и 3 цифры после (Пример: зит-101)
Но при введении в терминале зит101 или 101зит пишет, что что правильно. Где же ошибка?

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _3
{
    class Program
    {

        static void Main(string[] args)
        {
            string index;
            Console.Write("Введите индекс группы: ");
            index = Console.ReadLine();

            bool valid = true; //полагаем, что индекс является группой
            var parts = index.Split('-'); //разделяем на части по тире
            if (parts.Length == 2) //если получили две части
            {
                //разбор первой части
                string p1 = parts[0];
                if (p1.Length == 3 || (p1.Length == 4 && Char.IsLetter(p1[3]))) //трехсимвольная часть, либо 4-символьная
                {
                    //должно быть 3 больших буквы
                    for (int i = 0; i < 3; i++)
                    {
                        if (!Char.IsLetter(p1[i]))
                        {
                            valid = false;
                            break;
                        }
                    }
                }
                else
                {
                    valid = false;
                }
                //если первая часть подходит, проверяем вторую
                if (valid)
                {
                    string p2 = parts[1];
                    if (p2.Length == 3) //трехсимвольная часть
                    {
                        //должно быть 3 цифры
                        for (int i = 0; i < 3; i++)
                        {
                            if (!Char.IsDigit(p2[i]))
                            {
                                valid = false;
                                break;
                            }
                        }
                        //проверка первой цифыр 1..5
                        if (valid)
                        {
                            int a = int.Parse(p2[0].ToString());
                            if (a < 1 || a > 5)
                            {
                                valid = false;
                            }
                        }

                    }
                }
            }

            if (valid)
            {
                Console.WriteLine("Введен корректный индекс группы");
            }
            else
            {
                Console.WriteLine("Строка не является индексом группы");
            }

            Console.ReadKey();
        }
    }
}

Comments

[Модератор]

stuffed_pretzel читаем п. 3.8 регламента работы сервиса и исправляем. Спасибо.

Answer 1

[freeExec]

if (parts.Length == 2)
{}
else valid = false;

Answer 2

[#]

уточните условия. а то даже приведенный код дает другой выхлоп

слегка модифицируем

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace parse_xxxx_000
{
    static class Program
    {

        static void Main(string[] args)
        {
            "zit-101".parse().print();
            "101-zit".parse().print();
            "zit101".parse().print();
            "101zit".parse().print();
        }

        static void print(this object o) => Console.WriteLine(o.ToString());

        static (string, bool) parse(this string s)
        {
            bool valid = true; //полагаем, что индекс является группой
            var parts = s.Split('-'); //разделяем на части по тире
            if (parts.Length == 2) //если получили две части
            {
                //разбор первой части
                string p1 = parts[0];
                if (p1.Length == 3 || (p1.Length == 4 && Char.IsLetter(p1[3]))) //трехсимвольная часть, либо 4-символьная
                {
                    //должно быть 3 больших буквы
                    for (int i = 0; i < 3; i++)
                    {
                        if (!Char.IsLetter(p1[i]))
                        {
                            valid = false;
                            break;
                        }
                    }
                }
                else
                {
                    valid = false;
                }
                //если первая часть подходит, проверяем вторую
                if (valid)
                {
                    string p2 = parts[1];
                    if (p2.Length == 3) //трехсимвольная часть
                    {
                        //должно быть 3 цифры
                        for (int i = 0; i < 3; i++)
                        {
                            if (!Char.IsDigit(p2[i]))
                            {
                                valid = false;
                                break;
                            }
                        }
                        //проверка первой цифыр 1..5
                        if (valid)
                        {
                            int a = int.Parse(p2[0].ToString());
                            if (a < 1 || a > 5)
                            {
                                valid = false;
                            }
                        }

                    }
                }
            }
            return (s, valid);
        }
    }
}

и получим

.. попробую свернуть.. с конца..

//проверка первой цифыр 1..5

if (valid)
        valid = (p2[0] >= '1') && (p2[0] <= '5');

//должно быть 3 цифры

valid = p2.All(c => Char.IsDigit(c));

//если первая часть подходит, проверяем вторую

//если первая часть подходит, проверяем вторую
                if (valid)
                {
                    //трехсимвольная часть
                    //должно быть 3 цифры
                    //проверка первой цифыр 1..5
                    string p2 = parts[1];
                    valid = p2.Length == 3 && p2.All(c => Char.IsDigit(c)) && ((p2[0] >= '1') && (p2[0] <= '5'));
                }

.. упростим логику. ту внимательно смотри как

было

static (string, bool) parse(this string s)
        {
            bool valid = true; //полагаем, что индекс является группой
            var parts = s.Split('-'); //разделяем на части по тире
            if (parts.Length == 2) //если получили две части
            {
                //разбор первой части
                string p1 = parts[0];
                if (p1.Length == 3 || (p1.Length == 4 && Char.IsLetter(p1[3]))) //трехсимвольная часть, либо 4-символьная
                {
                    //должно быть 3 больших буквы
                    for (int i = 0; i < 3; i++)
                    {
                        if (!Char.IsLetter(p1[i]))
                        {
                            valid = false;
                            break;
                        }
                    }
                }
                else
                {
                    valid = false;
                }
                //если первая часть подходит, проверяем вторую
                if (valid)
                {
                    //трехсимвольная часть
                    //должно быть 3 цифры
                    //проверка первой цифыр 1..5
                    string p2 = parts[1];
                    valid = p2.Length == 3 && p2.All(c => Char.IsDigit(c)) && ((p2[0] >= '1') && (p2[0] <= '5'));
                }
            }
            return (s, valid);
        }

и как лучше (упс, исправлена поспешность )))

static (string, bool) parse(this string s)
        {
            bool valid = true; //полагаем, что индекс является группой
            var parts = s.Split('-'); //разделяем на части по тире
            if (parts.Length == 2) //если получили две части
            {
                //разбор первой части
                string p1 = parts[0];
                if (p1.Length == 3 || (p1.Length == 4 && Char.IsLetter(p1[3]))) //трехсимвольная часть, либо 4-символьная
                {
                    //должно быть 3 больших буквы
                    for (int i = 0; i < 3; i++)
                    {
                        if (!Char.IsLetter(p1[i]))
                        {
                            valid = false;
                            break;
                        }
                    }
                }
                else
                    valid = false;
                //если первая часть подходит, проверяем вторую
                valid &=
                    //должно быть 3 цифры
                    parts[1].Length == 3 &&
                    parts[1].All(c => Char.IsDigit(c)) &&
                    //проверка первой цифыр 1..5
                    ((parts[1][0] >= '1') && (parts[1][0] <= '5'));
            }
            return (s, valid);
        }

...применяем туже логику и

static (string, bool) parse(this string s)
        {
            bool valid = true; //полагаем, что индекс является группой
            var parts = s.Split('-'); //разделяем на части по тире
            if (parts.Length == 2) //если получили две части
            {
                //разбор первой части
                valid &=
                    //должно быть 3 больших буквы .. на самом деле ты и не проверял большие
                    //трехсимвольная часть, либо 4-символьная
                    (parts[0].Length == 3 || parts[0].Length == 4) &&
                    parts[0].All(c => Char.IsLetter(c));
                //если первая часть подходит, проверяем вторую
                valid &=
                    //должно быть 3 цифры
                    parts[1].Length == 3 &&
                    parts[1].All(c => Char.IsDigit(c)) &&
                    //проверка первой цифыр 1..5
                    ((parts[1][0] >= '1') && (parts[1][0] <= '5'));
            }
            return (s, valid);
        }

...и еще разок

static (string, bool) parse(this string s)
        {
            bool valid = true; //полагаем, что индекс является группой
            var parts = s.Split('-'); //разделяем на части по тире
            if (parts.Length == 2) //если получили две части
            {
                valid &=
                    //разбор первой части
                    //должно быть 3 больших буквы .. на самом деле ты и не проверял большие
                    //трехсимвольная часть, либо 4-символьная
                    (parts[0].Length == 3 || parts[0].Length == 4) &&
                    parts[0].All(c => Char.IsLetter(c)) &&
                    //если первая часть подходит, проверяем вторую
                    //должно быть 3 цифры
                    parts[1].Length == 3 &&
                    parts[1].All(c => Char.IsDigit(c)) &&
                    //проверка первой цифыр 1..5
                    ((parts[1][0] >= '1') && (parts[1][0] <= '5'));
            }
            return (s, valid);
        }

ну вот где то теперь, можно заметить, что не стоит сразу предполагать успех..
продолжить?

убираем предположения

static (string, bool) parse(this string s)
        {
            var parts = s.Split('-'); //разделяем на части по тире
            return (s,
                //если получили две части
                parts.Length == 2 &&
                //разбор первой части
                //должно быть 3 больших буквы .. на самом деле ты и не проверял большие
                //трехсимвольная часть, либо 4-символьная
                (parts[0].Length == 3 || parts[0].Length == 4) &&
                parts[0].All(c => Char.IsLetter(c)) &&
                //если первая часть подходит, проверяем вторую
                //должно быть 3 цифры
                parts[1].Length == 3 &&
                parts[1].All(c => Char.IsDigit(c)) &&
                //проверка первой цифыр 1..5
                ((parts[1][0] >= '1') && (parts[1][0] <= '5')));
        }

и сразу поменялся результат

все. тут уже должно быть понятно

забавно, но мы умудрились исчерпать размер ответа. но можно и так https://dotnetfiddle.net/Bdge92
а без каментов и пустых строк выглядит компактно